C++ override a member variable (std::vector)

Question

here are the classes which my question is about

class Graph {}
class SceneGraph : public Graph {}

class Node {
public:
    virtual Node* getNode(int index) { return mNodeList[index]; }

protected:
    vector<Node*> mNodeList;
    Graph* mGraph;
}

class TransformationNode : public Node {
public:
    TransformationNode* getNode(int index) { return static_cast<TransformationNode*> (mNodelist[index]); }

    void _update() {
        auto beg = mNodeList.begin();
        auto end = mNodeList.end();
        while (begin != end) {
            TransformationNode* node = static_cast<TransformationNode*> (*beg);
            node->_update();
        }
    }

private:
    bool mUpdated;
    SceneGraph* mGraph;    
}

First of all, I want to talk about the problems I solved. They may helps others. And you can confirm me if I am right ^^

1. Can I override a function with a different return type ?
   Node* getNode(int index) became TransformationNode* getNode(int index)

   Yes as long as return types are covariant : http://www.tolchz.net/?p=33

2. Can I override a member ?

   I don't know about overriding but a variable with the same name in the derived class will hide the one in the base class

And there is the problem I really want to get around some how

In the TransformationNode class I did many (IMHO) avoidable type casting from base class to derived one. I definitely know that all the elements in the mNodeList vector are TransformationNodes but to process mNodeList I have to type cast them.

The inheritance is correct I mean TransformationNode is a Node

mNodeList holds child nodes of the node and it can not have a copy in the derived class which holds typecasted version of Nodes

And finaly I can even use reinterpered_cast if static_cast is more costly. Can you inform me about cost of these operations ? are they really big performance issues ?
assert (dynamic_cast)... kind of precaution has already been taken.

briefly I want my compiler to know that mGraph is actually a SceneGraph* and mNodeList holds TransformationNode* this helps me to avoid lost of type casting.

Thank you for taking your time

Answer 1

1) is correct, you can indeed override (virtual!) base functions if the return type is more derived.

Ad 2): indeed, you cannot "override" members. Redesign the base class if you need more flexible overridable behaviour.

static_cast is a static operation that is resolved at compile time, so much like reinterpret_cast it doesn't have any "cost".

---

As @Seth suggests in the comment, it might be an option to move the container. Ask yourself, can there ever be an abstract Node , or is every node actually of some derived concrete type? Perhaps you could make Node abstract:

struct Node { Node * getNode(size_t index) const = 0; };

struct TransformNode : Node
{
    TransformNode * getNode(size_t index) const { return m_nodes[index]; }
private:
    std::vector<TransformNode *> m_nodes;
};

Put the entire interface into the base class, but only implement it in each concrete class.