Ytukyg

I have two class, each of them has several children:

class ContainerGeneral {...};

class ContainerTypeA : ContainerGeneral {

public:

    void doSomethingA();

};

class ContainerTypeB : ContainerGeneral {

    void doSomethingB();

};

class InterpreterGeneral {

protected:

    ContainerGeneral* container;

};



class InterpreterTypeA : InterpreterGeneral {

public:

    void saveContainer(ContainerTypeA* cont) {

        container = cont;

    }

};



class InterpreterTypeB : InterpreterGeneral {

public:

    void saveContainer(ContainerTypeB* cont) {

        container = cont;

    }

};

The Interpreter classes use to a container of a corresponding type (A to A, B to B, General to General). To do this I added a to InterpreterGeneral a member pointer to a ContainerGeneral object. I want InterpreterGeneral to address this object as a ContainerGeneral, but I want that the inherited classes would be able to address the same container as a container of the appropriate type. I can do it by casting the pointer to the inherited class when addressing it (examples only for A to save on space):

(ContainerTypeA*)container->doSomethingA();

Or by adding a new member pointer of the inherited type that would point to the same place as container:

class InterpreterTypeA : InterpreterGeneral {

public:

    void saveContainer(ContainerTypeA* cont) {

        containerA = cont;

        container = cont;

    }

    void doSomething() {

        containerA->doSomethingA();

    }

private:

    ContainerTypeA* containerA;

};

What is the best practice in this case, and is there a way to do this as clean as possible, without casting every time, and without adding new members that don't hold any "new" information?

If you need concrete type information about the container instance within InterpreterTypeA and InterpreterTypeB, express this in your code by not storing a GeneralContainer* data member in GeneralInterpreter (protected data member are quite debatable in any case), but instead concrete ContainerTypeA* and ContainerTypeB* data members in the subclasses InterpreterTypeA and InterpreterTypeB. Storing a base class pointer and then circumventing its limitation by casting hides the fact that concrete type information is required.

Besides, there is not much wrong with either providing empty default implementations of doSomethingA() and doSomethingB() in the container base class, or turn them into virtual pure member functions and shift the empty implementation into ContainerTypeA and ContainerTypeB. Then, it's safe to just call them - when it's the undesired concrete type, they won't do anything.

A last, pedantic side note: I don't see any reason to call derived classes in a hierarchy "son" classes. The common term is "child" class.

The problem you are dealing with has a solution in the form of virtual functions. Try this:

class ContainerGeneral {

public:

    virtual void doSomething() = 0;

};



class ContainerTypeA : public ContainerGeneral {

public:

    void doSomething() {

        std::cout << "Hello A!" << std::endl;

    };

};



class ContainerTypeB : public ContainerGeneral {

public:

    void doSomething() {

        std::cout << "Hello B!" << std::endl;

    };

};

With that you don't need to bother with inheriting from InterpreterGeneral at all:

class InterpreterGeneral {

public:

    void doSomething()

    {

        container->doSomething();

    }

private:

    ContainerGeneral* container;

};

Side note: This of course generates some runtime overhead. You can avoid it if you don't need polymorphism at runtime. Have a look at the static polymorphism. Only if you're a ninja.