我正在尝试教自己使用节点结构的链表，并希望有人可以对此提供帮助。我将从命令行获取输入，这将使我成为一个嵌套列表，并且可以将其输出。

例子:

输入:“1 2 3 4 5”
输出:“1 2 3 4 5”

我遇到两件事:
1)运行程序时，我不断收到警告:此声明中忽略了“typedef” [默认启用]
我该如何摆脱呢？

编辑:我已将其更改为typedef struct Node* NodePtr;
2)我的代码无法正常工作。我怎样才能解决这个问题？我正在尝试自学C++链表。

typedef struct Node;
typedef Node* NodePtr;
struct Node{
    int x;
    NodePtr next;
};

int main ()
{
    int n;
    NodePtr head, ptr = NULL;
    head = ptr;
    while (cin >> n){
        ptr = new Node;
        ptr->x = n;
        ptr->next = NULL;
        ptr = ptr->next;
    }

    NodePtr bling = head;
    while(bling != NULL){
        cout << bling->x << endl;
        bling = bling->next;
    }
    return 0;
}

1 -> 2 -> 3 -> NULL.

最佳答案

首先，关于结构的声明和您似乎想要的指针typedef，有许多方法可以做到这一点。以下将在C或C++中工作。

// declare NodePtr as a pointer to Node, currently an incomplete type
//  C and C++ both allow you to declare a pointer to damn-near anything
//  so long as there is an understanding of what it *will* be, in this
//  case, a structure called Node.
typedef struct Node *NodePtr;

// Now declare the structure type itself
struct Node
{
    int x;
    NodePtr next;
};

struct Node
{
    int x;
    struct Node *next; // omit the 'struct' for C++-only usage
};

Node* a, b;     // declares one Node* (a), and one Node (b)

NodePtr a, b;   // declares two Node*; both (a) and (b)

NodePtr head = NULL;     // always the head of the list.
NodePtr* ptr = &head;    // will always point to the next pointer to assign.
int n;
while (cin >> n)
{
    *ptr = new Node;
    (*ptr)->x = n;
    ptr = &(*ptr)->next;
}

// note this always terminates the load with a NULL tail.
(*ptr)->next = NULL;

      head ===> NULL;
ptr --^

head ===> node(1)
          next
ptr ------^

head ===> node(1)
          next ===> node(2)
                    next
ptr ----------------^

head ===> node(1)
          next ===> node(2)
                    next ===> node(3)
                              next
ptr --------------------------^

head ===> node(1)
          next ===> node(2)
                    next ===> node(3)
                              next ===> NULL;
ptr --------------------------^

#include <iostream>
using namespace std;

// declare NodePtr as a pointer to Node, currently an incomplete type
//  C and C++ both allow you to declare a pointer to damn-near anything
//  so long as there is an understanding of what it *will* be, in this
//  case, a structure called Node.
typedef struct Node *NodePtr;

// Now declare the structure type itself
struct Node
{
    int x;
    NodePtr next;
};

int main()
{
    // load our list with 20 elements
    NodePtr head = NULL;
    NodePtr* ptr = &head;
    for (int n=1;n<=20;++n)
    {
        *ptr = new Node;
        (*ptr)->x = n;
        ptr = &(*ptr)->next;
    }

    // terminate the list.
    *ptr = NULL;

    // walk the list, printing each element
    NodePtr p = head;
    while (p)
    {
        cout << p->x << ' ';
        p = p->next;
    }
    cout << endl;

    // free the list
    while (head)
    {
        NodePtr victim = head;
        head = head->next;
        delete victim;
    }

    return 0;
}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 

关于c++ - C++中的链接列表，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14544539/