如何在C ++中的另一个类中调用一个类的构造函数？

Question

Here is my code:

template<class Datatype>
class Node
{
    public:
        Node()
        {
            next = NULL;
            prev = NULL;
        }
        Node* getNext()
        {
            return next;
        }
        Node* getPrev()
        {
            return prev;
        }
        Datatype* getData()
        {
            return &data;
        }
        void changeNext()
        {
            next = NULL;
        }
        void changeNext(Node& nextNode)
        {
            next = &nextNode;
        }
        void changePrev()
        {
            prev = NULL;
        }
        void changePrev(Node& prevNode)
        {
            prev = &prevNode;
        }
        Node* addNext(Node &);
        Node* addPrev(Node &);
        void nodeDel();
        void addData(Datatype &);
    private:
        Node* next;
        Node* prev;
        Datatype data;
};

template<class Datatype>
class Stack
{
    public:
        Stack()
        {
            node.Node();
        }
        int push(Datatype &);
        Datatype pop();
        Datatype* peek();
    private:
        Node<Datatype> node;
};

The compiling error is like this:

my_node.h: In constructor ‘Stack<Datatype>::Stack() [with Datatype = float]’:
test.cpp:8:15:   instantiated from here
my_node.h:58:4: error: invalid use of ‘Node<float>::Node’

At beginning, I didn't wrote the constructor for Stack. However, I felt that actually the constructor of node defined by me was not been called, because there are some values in next and prev pointers. So I tried to write a constructor of Stack which explicitly call the constructor of Node. Unfortunately, the compiling error shown above came. I want to know how to call the constructor of a class which is within the other class.

Thank, Kevin Zhou

Answer 1

This:

Stack()
{
    node.Node();
}

isn't the right way to call a member's constructor. Use an initialization list instead:

Stack(): node()
{
}

It should be noted that explicitly calling the default constructor is not necessary. Which means you only really need to use the initialization list if you're calling a custom constructor.

Answer 2

If you don't do anything, the default constructor for the node member will be called.

If you want to explicitly construct a member, you do it in the constructors initializer list :

Stack()
    : node()
{}

Since the default constructor will be called anyway, explicitly constructing members is only useful if you need to pass arguments to the constructors (ie call their non-default constructor).

Answer 3

Simply change the definition of the class Stack the following way, because your definition of the class is wrong

template<class Datatype>
class Stack
{
    public:
        Stack() : head( nullptr )
        {
        }
        int push(Datatype &);
        Datatype pop();
        Datatype* peek();
    private:
        Node<Datatype> *head;
};

Take into account that stack node should have only one reference to the next node. So the class Node should have the following data members

class Node
{
//...
    private:
        Node* next;
        Datatype data;
};

Data member Node *prev should be excluded.

ALso it would be much better if the class Node would be internal class of the class STack.