自定义简单链表类反馈

Question

我想实现一个可以与任何数据类型一起使用的简单链表类，所以我使用的是模板。我还需要实现一个Iterator类，它将与我的列表一起使用。事实证明，这是一个比我想象的更大的挑战。所以我开始工作：

template<typename Element>
class Node;
template<typename Element>
class SimpleLinkedList;
template<typename Element>
class Iterator;
template<typename Element>
class Node
{
private:
    Element data;
    Node<Element> *next;
public:
    // constructor
    Node();
    // destructor
    ~Node();
    // getters
    Element getData();
    Node<Element> *getNext();
    // setters
    void setData(Element newData);
    void setNext(Node<Element> *adr);
    // has next
    bool hasNext();
};
template<typename Element>
class SimpleLinkedList
{
    friend class Node<Element>;
private:
    Node<Element> *head;
public:
    // constructor
    SimpleLinkedList();
    // destructor
    ~SimpleLinkedList();
    // getters
    Node<Element> *getHead();
    Node<Element> *getNode();
    // add
    void append(Element newData);
    // is list
    bool valid();
};
template<typename Element>
class Iterator
{
    friend class SimpleLinkedList<Element>;
    friend class Node<Element>;
private:
    Node<Element> *it;
public:
    // constructor
    Iterator();
    // constructor with params
    Iterator(Node<Element> *head);
    // destructor
    ~Iterator();
    // has next
    bool valid();
    // step
    Node<Element> *step();
    // ++ operatpr
    Iterator<Element>* & operator++();
};
/*
 * Node implementation
 */
// constructor
template<typename Element>
Node<Element>::Node()
{
    this->data = Element(); // default constructor for Element
    this->next = 0;
}
// destructor
template<typename Element>
Node<Element>::~Node()
{
    // not sure
    // note to self: test this!
}
// getters
template<typename Element>
Element Node<Element>::getData()
{
    return this->data;
}
template<typename Element>
Node<Element> Node<Element>::*getNext()
{
    return this->next;
}
// setters
template<typename Element>
void Node<Element>::setData(Element newData)
{
    this->data = newData;
}
template<typename Element>
void Node<Element>::setNext(Node<Element> *adr)
{
    this->next = adr;
}
/*
 * return value:
 *      true - it's not the last node
 *      false - it's the last node
 */
template<typename Element>
bool Node<Element>::hasNext()
{
    if(this->next != 0)
        return true;
    return false;
}
/*
 * SimpleLinkedList implementation
 */
// constructor
template<typename Element>
SimpleLinkedList<Element>::SimpleLinkedList()
{
    this->head = Node<Element>();
}
// destructor
template<typename Element>
SimpleLinkedList<Element>::~SimpleLinkedList()
{
    //
}
// getters
template<typename Element>
Node<Element> *SimpleLinkedList<Element>::getHead()
{
    return this->head;
}
template<typename Element>
Node<Element> *SimpleLinkedList<Element>::getNode()
{
    return this; // not sure how to do this
}
// add new
template<typename Element>
void SimpleLinkedList<Element>::append(Element newData)
{
    Node<Element> *newNode = Node<Element>();
    newNode->setData(newData);
    Node<Element> *temp = Node<Element>();
    temp = this->head;
    while(temp->next != 0) // while not last element
    {
        temp = temp->next;
    }
    newNode->next = 0;
    temp->next = newNode;
}

template<typename Element>
bool SimpleLinkedList<Element>::valid()
{
    if(this->head != 0)
        return true;
    return false;
}
/*
 * Iterator implementation
 */
// constructor
template<typename Element>
Iterator<Element>::Iterator()
{
    this->it = 0;
}
/*
 * recieves the first element of a SimpleLinkedList
 */
template<typename Element>
Iterator<Element>::Iterator(Node<Element> *head)
{
    this->it = head;
}
// destructor
template<typename Element>
Iterator<Element>::~Iterator()
{
}
/*
 * return value:
 *      true - valid list entru
 *      false - outside of lists bounds
 */
template<typename Element>
bool Iterator<Element>::valid()
{
    if(this->it != 0)
        return true;
    return false;
}
// gets the next list entry
template<typename Element>
Node<Element> *Iterator<Element>::step()
{
    return this->it->next;
}
// it++ operatpr
//template<typename Element>
//Iterator<Element>::Iterator<Element> & operator++()
//{
    // research more about this
//}

我想我有一个主要问题：我可以声明一个新的节点，比方说：

Node<int> *newNode;

但我不能说

Node<int> *newNode = Node<int>();

这只在newNode不是指针时有效，但如果节点不是指针，我的链表将不起作用。重大缺陷。解决这个问题的正确方法是什么？

Answer 1

通常，您可以在三个不同的内存区域中分配变量：

堆栈：

void func()
{
    Node<int>  node();          // An instance of type 'Node<int>'
    Node<int>* nodePtr = &node; // A pointer to the instance above
    ...
}

数据部分：

Node<int>  node();          // An instance of type 'Node<int>'
Node<int>* nodePtr = &node; // A pointer to the instance above
...

堆：

Node<int>* nodePtr = new Node<int>();
// A pointer to an instance of type 'Node<int>'

您需要在堆中分配Node<int>实例，然后使用指向该实例的指针，如上面的示例所示。请注意，指针本身在堆中是而不是（如果用作局部变量，则在堆栈中；如果用作全局变量，则位于数据段中）。

Answer 2

您想要：

Node<int> *newNode = new Node<int>();
                     ^^^---- new!