Question

我想实现一个适用于任何数据类型的Simple Linked List类，所以我使用的是模板。我还需要实现一个可以使用我的列表的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

你想：

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

Answer 2

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

<强>堆栈：

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>实例，然后使用指向该实例的指针，如上例所示。请注意，指针本身在堆中是不（如果用作局部变量，则在堆栈中;如果用作全局变量，则在数据部分中）。

自定义简单链表类反馈

2 个答案: