Thread: Scenegraph derived class vector c++ custom behaviour

I am trying to create a scenegraph with a vector of Base class pointer with different type of derived classes and their own behaviours. Now here is my question:

Code:

class Base
{
public:
    virtual void setParent(Base* pParent);
    virtual void addChild(Base* pChild);
    // for simplicity I wont implement all functions
private:
    Base* m_pParent;
    std::vector<Base*> m_pChildren;
};

classDerivedOne:publicBase
{
public:
    // virtual function override
    int custom(){return1337;}
}
classDerivedTwo:publicBase
{
public:
    int customtwo(){return1337+1;}
}
main(xyz)
{
    DerivedOne* d1 =newDerivedOne();
    DerivedTwo d2 =newDerivedTwo();
    d1->addChild(d2);
    for(auto e : d1->getChildren())
    {
        std::cout <<static_cast<DerivedOne*>(e)->custom(); std::endl;// returns 1337 twice instead of once
    }
}

Now my question is how do I realize the above? How can I call a specific function if the node is of a specific type? I want to create a scenegraph that can hold a variety of different node-types and some must not be rendered, so I am really curious to see if there is some way to realize this idea? The problem is that at the moment, if I cast a base to a derived class and call the function, the function is executed even when originally the class wasnt of that derived class.

Originally Posted by KevinExtremo

Now my question is how do I realize the above? How can I call a specific function if the node is of a specific type?

Perhaps the custom function (with customtwo replaced by custom in DerivedTwo) should be declared virtual in Base, either pure virtual, or with some default implementation (or even both, but that tends to be rare).

Originally Posted by KevinExtremo

The problem is that at the moment, if I cast a base to a derived class and call the function, the function is executed even when originally the class wasnt of that derived class.

Technically, you have undefined behaviour when you do that. If for some good reason you really need to cast the base class pointer to a derived class pointer type, use dynamic_cast. This way, you will get a null pointer if the object is not of the destination derived class type.

Originally Posted by KevinExtremo

So, let me get this straight. You mean I should declare it a pure virtual and call it no matter if the class actually has such a method or not and simply blast the call off to a virtual on those that dont?

No, what I mean is that you should design the base class such that you can call a virtual function, hence making use of the polymorphism associated with such a class hierarchy formed by inheritance. For example, this should just work:

Code:

for (auto e : d1->getChildren())
{
    std::cout << e->custom() << std::endl;
}

e would be a pointer to Base, but because both DerivedOne and DerivedTwo override custom (or use the default implementation from Base), you get the right behaviour for the subclass that is the type of the object that e points to, whatever it is.

Originally Posted by KevinExtremo

So, does that mean technically I could simply dynamic_cast every single element against a certain class and if the pointer exists it is of that type? Couldn't I use this method to call the functions? e.g:

Yes, but that is typically a poor approach. It may indicate that your base class interface is badly designed, or that you should not be trying to iterate over the derived class objects via a pointer to the base class, or that you really need double dispatch and hence should consider the visitor pattern.