Getting "undeclared member" error with derived class

Basically I have a base class that has its members in a protected block and when I try to access those items in the base class I get the error

error: `child' undeclared (first use this function)

Code:

template <typename T>
class Node
{

protected:
    T** child;   //dynamically allocated T array.
    T data;
    size_t size;

public:
    Node(size_t capacity) : size(capacity)
    {
        child = new T*[capacity];

        for (size_t i = 0; i < capacity; ++i)
            child[i] = NULL;
    }

    Node(size_t capacity, T x) : data(x), size(capacity)
    {
        child = new T*[capacity];

        for (size_t i = 0; i < capacity; ++i)
            child[i] = NULL;
    }

    virtual ~Node()
    {
        for(size_t i = 0; i < size; ++i)
            delete child[i];
    }
};


template <typename T>
class BinaryTreeNode : public Node<T>
{
public:
    BinaryTreeNode() : Node<T>(2) { }

    BinaryTreeNode(T x) : Node<T>(2, x) { }

    ~BinaryTreeNode()
    {
        delete child[0];
        delete child[1];
    }

};

With extraneous code removed, your problem simplifies to

Code:

template <typename T>
class Node
{
protected:
    size_t size;
};

template <typename T>
class BinaryTreeNode : public Node<T>
{
public:
    BinaryTreeNode()
    {
        size = 0;
    }
};

When you remove the templates, the code compiles.

Code:

//template <typename T>
class Node
{
protected:
    size_t size;
};

//template <typename T>
class BinaryTreeNode : public Node//<T>
{
public:
    BinaryTreeNode()
    {
        size = 0;
    }
};

On a hunch, using

Code:

Node<T>::size = 0;

in the original version works. Don't ask me why, I'm a C programmer.

In short, for some reason, you want

Code:

template <typename T>
class BinaryTreeNode : public Node<T>
{
public:
    BinaryTreeNode() : Node<T>(2) { }

    BinaryTreeNode(T x) : Node<T>(2, x) { }

    ~BinaryTreeNode()
    {
        delete Node<T>::child[0];
        delete Node<T>::child[1];
    }

};

By the way, aren't you going to delete the same childs multiple times in BinaryTreeNode because both derived and base class destructor will do that?

The compiler is correct if it rejects the original code. The C++ standard (Section 14.6.2) requires that all names that are not dependent on template parameters are bound to their present definitions when parsing a template function or class. Only names that are dependent are looked up at the point of instantiation.

This means that the base class template is not expanded when compiling the derived class template so, in indigo's example code, "delete child[0];" in BinaryTreeNode's destructor looks for something named "child" at global scope (i.e. it looks for ::child[0]). No such thing exists, hence the error.

The more usual fix is to prefix the members with "this->", viz.

Code:

~BinaryTreeNode()
    {
        delete this->child[0];
        delete this->child[1];
    }

There is also the incidental issue, noted by anon, that (with the problem affecting compilation fixed) BinaryTreeBode's destructor will delete the children, and then Node's destructor will delete them again. That is formally undefined behaviour.

Ok, thanks for the help, like you said I totally got

Originally Posted by anon

By the way, aren't you going to delete the same childs multiple times in BinaryTreeNode because both derived and base class destructor will do that?

this is true, I have gotten rid of the derived class constructor since the base class does the same thing (only one being undefined)