-1

这次我没有问题，但我只是在寻找 List implementationetion，只是一个简单的 List，其中包含 Node(int,nextNode) 之类的节点。我过去做过很多次，但我的 c++ 有点生锈了。你能和我分享一下吗？我正在查看我的存档，在 github 上，但我没有找到 antyhing。

编辑：

*我决定做我的，但我不明白为什么在使用 delete 后我仍然可以得到 cout<getWrt()<*

#include <cstdio>
#include <cmath>
#include<iostream>

using namespace std;

class Node{

public:
    Node(Node* next, int wrt){
        this->next = next;
        this->wrt = wrt;

    }

    Node(const Node& obiekt){
        this->wrt = obiekt.wrt;
        this->next = obiekt.next;
    }
    ~Node(){}

    void show(){
        cout<<this->wrt<<endl;
    }

    int getWrt(){
        return this->wrt;
    }

    Node* getNext(){
        return this->next;
    }

 private:
    Node* next;
    int wrt;

};


int main()
{
Node* n  = new Node(NULL, 2);
n->show();
Node* n2 = new Node(*n);
n2->show();
delete n;
n->show();
n2->show();
return 0;
}
4

2 回答 2

4

基本列表实现通常称为单链表（或在函数式语言中称为 cons-list）。

函数定义直接切入列表的结构：

List := Empty | Cons T List

当然，这在 C 或 C++ 中并不真正起作用，因此我们需要将结构一分为二：

  • 该列表被实现为一个节点链
  • List 类隐藏了这个实现细节

这是一些简单的代码：

template <typename T>
struct Node {
    Node(T t): element(t) {}

    T element;
    std::unique_ptr<Node> next;
};

template <typename T>
class List {
    typedef Node<T> N;
public:
    List() {}

    bool empty() const { return head == nullptr; }

    T& front() { assert(!this->empty()); return head->elem; }
    T const& front() const { { assert(!this->empty()); return head->elem; }

    void pop() { assert(!this->empty()); swap(head, head->next); }

    void push(T t) {
        std::unique_ptr<N> n{ new Node {t} };

        n->next = std::move(head);

        head = std::move(n);
     }

private:
    std::unique_ptr<N> head;
};

如您所见，此列表只是作为堆栈实现，没有迭代等......不过，这是一个好的开始:)

于 2012-05-26T17:23:53.993 回答
2

正如 aix 所说，你最好的选择是选择...

  • std::list，它是一个双向链表，这意味着它以向后遍历速度换取内存使用量或
  • 不太广泛实现的 std::slist（在 C++11 中称为 forward_list），它是单链接的，只能以一种方式遍历。

当然，cplusplus.com 有这两者的参考信息。

作为 STL 的一部分，这两个列表实现都经过了广泛的测试、调整和调试。两者都支持标准的 STL 算法。几乎没有理由不使用它们。

于 2012-05-26T17:12:45.900 回答