通过指向base，static_cast，crtp，删除模板的指针派生的成员

Question

Looking for: accessing member of a derived class from a pointer to base.

Reductio ad absurdum:

class Base
{
public:
    int member_of_base;
};

class Derived : public Base
{
public:
    int member_of_derived;
};

I'm currently using templates:

template <class T>
class Client
{
    T* data; // T is Base or Derived
};

There are few levels of composition in the class hierarchy, so I have to carry the template type parameter through all of the hierarchy. What is the best approach to overcome this? Obviously I cannot access the member of Derived via a pointer to Base, ie:

Base* foo = new Derived();
foo->member_of_derived; // no go

Thus, I'm using:

Client<Base>
Client<Derived>

I'm trying to come up with a solution that works without the templates. Options that I know would work:

• void* //plain old C and casting as necessary, they're all pointers (as in memory addresses) in the machine
• static_cast<Derived*>(pointer_to_base); //type safe at compile time.
• wrapping the cast in a Client's template method (not to be confused with a design pattern here)

The last option seems to be the most "elegant", ie:

template <class T>
T* get_data() const { return static_cast<T*>(data); }

However, looking here and there tells me there might exist a way unknown to me. I saw CRTP, but that brings me back to templates, which is the original thing I want to go without. What are the ways, or popular approaches, to achieve such a goal?

The real code uses shared_ptr, weak_ptr and enable_shared_from_this with weak_from_this. I'm looking for a type safe "polymorphic member" access.

EDIT: they're not just "ints". They can be totally different types, as in protobuf in base and Json::Value in derived. And I'm trying to use the pointers to Base/Derived, which in turn would give me access to their respective members.

Answer 1

A virtual getter can solve the issue for you; as data types differ, you might pack them into a std::variant .

class Base
{
    // having private members probably is more appropriate
    int member_of_base;

public:
    using Data = std::variant<int, double>;

    virtual ~Base() { } // virtual functions -> have a virtual destructor!

    virtual Data getMember() // or just "member", if you prefer without prefix
    {
        return member_of_base;
    }
};

class Derived : public Base
{
    double member_of_derived;

public:   
    Data getMember() override
    {
        return member_of_derived;
    }
};

std::unique_ptr<Base> foo = new Base();
foo->getMember(); // member_of_base;
std::unique_ptr<Base> bar = new Derived();
bar->getMember(); // member_of_derived;

Admitted, not yet totally without templates, std::variant is one, but I suppose in that form it is acceptable...

There are some issues with, though:

1. Accessing the value is not the simplest, you might consider visit function for.
2. More severe: Base class (or wherever else you define the variant to be used) needs to be aware of all types that might be in use, adding a new type will force to recompile all other classes.
3. It has the smell of bad design. Why should it be necessary for a derived class to return something different than the base that shall serve the same purpose, though???

If you can delegate the work to be done to the classes themselves, you get around all these problems:

class Base
{
    int member_of_base;

public:
    virtual ~Base() { }

    virtual void doSomething()
    {
        /* use member_of_base */
    }
};

class Derived : public Base
{
    double member_of_derived;

public:
    void doSomething() override
    {
        /* use member_of_derived */   
    }
};

The latter would be the true polymorphic approach and normally the way to go; whereas the sample above returns void, you might just do all the calculations necessary in base and derived classes until you finally get to some common data type and return this one. Example:

class Base
{
    int64_t m_balance; // in 100th of currency in use

public:
    virtual ~Base() { }

    virtual int64_t balance()
    {
        return m_balance;
    }
};

class Derived : public Base
{
    long double m_balance; // arbitrary values in whole currency entities

public:
    int64_t balance() override
    {
        // calculate 100th of currency, correctly rounded:
        return std::llround(m_balance * 100);
    }
};

Admitted, I doubt pretty much representing a balance in double (even if long) is a good idea (issues with rounding, precision, etc)...