构造函数C ++的Super vs Subclass继承

Question

So this is the base class for a binary search tree with left, right, parent and data.

template<class Data>
class BSTNode
{
public:

    /** Constructor.  Initialize a BSTNode with the given Data item,
     *  no parent, and no children.
     */
    BSTNode(const Data & d) : data(d)
    {
        left = right = parent = 0;
    }


    BSTNode<Data>* left;
    BSTNode<Data>* right;
    BSTNode<Data>* parent;
    Data const data;   // the const Data in this node.

    /** Return the successor of this BSTNode in a BST, or 0 if none.
     ** PRECONDITION: this BSTNode is a node in a BST.
     ** POSTCONDITION:  the BST is unchanged.
     ** RETURNS: the BSTNode that is the successor of this BSTNode,
     ** or 0 if there is none.
     */
    BSTNode<Data>* successor()
    {
        BSTNode<Data>* cursor;
        BSTNode<Data>* par;
        cursor = this->right;
        par = this->parent;

        if (this->right != NULL)
        {
            while (cursor->left != NULL) {
                cursor = cursor->left;
            }
            return cursor;
        }
        if ((this->right == NULL) &&  (this == par->left))
            return this->parent;

        if ((this->right == NULL) && (this == par->right))
        {
            do
            {
                cursor = par;
                par = par->parent;
                if (par ==  NULL)
                {return cursor;}
            } while(cursor != par->left);
            return par;
        }
        if (this->right == NULL && this->parent == NULL)
            return NULL;

        return NULL;
    }
};

The subclass is RSTNode that is supposed to use all the members of BSTNode and add a priority on top of that:

template<class Data>
class RSTNode: public BSTNode<Data>
{
public:
    int priority;

    RSTNode(Data const & d)
        : BSTNode<Data>(d)
    {
        //call a random number generator to generate a random priority
        priority = rand();
    }
};

Now the problem is i'm not sure how to implement the constructor for the RSTNode as it does not recognize the members of BSTNode for some reason. I know that it should recognize them as it is supposed to inherit this information. Any help is appriciated.

Answer 1

That's because the default scope for data members is private . You need to declare them as protected if you want to access them in a subclass.

Better still, add a constructor to BSTNode that allows you to pass in initialisation values, and call this from the RSTNode constructor, since it should be the base class that is managing the lifetime of its members.

Answer 2

If I've read this correctly your attempting to inherit from a templated class:

class RSTNode: public BSTNode<Data>

Where your class definition of BSTNode isn't a templated class?

class BSTNode {

Is this part of the problem or have you pasted the wrong code?

You could fix it by either templating BSTNode

template <typename T> class BSTNode {

or deriving RSTNode from non-templated BSTNode:

class RSTNode: public BSTNode

However the fact that you've tried to to what you've written implies you aren't really understanding class definitions at a much deeper level, and the fact you are trying to set base class parameters directly in a derived class constructor and that you've made them public would lead me to believe you need to learn more about object oriented design - so although this might solve your problem technically, it's only tip of the iceberg when it comes to the issues you are having.

Also saying "it does not recognize the members of BSTNode for some reason" isn't very helpful as I suspect that isn't the exact output of your compiler when you try to do it.

Answer 3

Ok, I compiled this in Visual Studio...

template<class Data>
class BSTNode
{
public:

    /** Constructor.  Initialize a BSTNode with the given Data item,
     *  no parent, and no children.
     */
    BSTNode(const Data & d) : data(d)
    {
        left = right = parent = 0;
    }


    BSTNode<Data>* left;
    BSTNode<Data>* right;
    BSTNode<Data>* parent;
    Data const data;   // the const Data in this node.
};

template<class Data>
class RSTNode : public BSTNode<Data>
{
public:
   int priority;

   RSTNode(Data const & d)
      : priority(rand()),
        BSTNode<Data>(d)
   {
      left = 0; //Accessible because public
      right = 0;
      parent = 0;
   }
};

int _tmain(int argc, _TCHAR* argv[])
{
   RSTNode<std::string> node(std::string("test"));
    return 0;
}

It compiled so no access issues. Like other posters above it seems to me that you are either not posting the detail of your problem, or you are not understanding something fundemental.

>Now the problem is i'm not sure how to implement the constructor for the RSTNode as it >does not recognize the members of BSTNode for some reason. I know that it should recognize >them as it is supposed to inherit this information. Any help is appriciated.

The code above implements a constructor, or if you wanted to specifically have left, right and parent set then you would need :

BSTNode(const Data & d, BSTNode* l, BSTNode* r, BSTNode* p) 
       : data(d),
       left(l),
       right(r),
       parent(p)
    {
    }

and then use it in the RSTNode, or have a similar one for RSTNode that passed through to that one....

RSTNode(Data const & d, BSTNode* l, BSTNode* r, BSTNode* p)
   : priority(rand()),
     BSTNode<Data>(d,l,r,p)
{
}

Hope that helps a little, note that you should prefer initialiser lists to direct access to members in the ctor. But if you cannot change the base class then you would need to...

---

Corrected typo - data -> Data