C语言中不带malloc的链表 #包括 类型定义结构节点 { int i； 结构节点*下一步； }节点； 节点getnode（int a） { 结构节点n； n、 i=a； n、 next=NULL； 返回n； } main（） { int i； 节点newtemp、root、temp； scanf（“%d”、&i）； root=getnode（i）； 温度=根； 而(我--) { newtemp=getnode（i）； 下一个温度=&newtemp； if（root.next==NULL） { 根=温度； } 温度=*（下一个温度）； } 温度=根； while（temp.next！=NULL） { printf（“%d”，温度i）； 温度=*（下一个温度）； } }

我正在尝试不使用malloc创建一个链表。编程只打印根，不打印根之后的节点。我找不到那只虫子。如果出现任何内存问题，gcc编译器将抛出分段错误。（？）请忽略糟糕的编程风格

链表是长度不确定的东西，任何长度不确定的东西都不能在没有malloc的情况下创建

---

我建议您只需使用malloc来分配链中的下一个链接。

当您初始化

temp.next

时，分配给它的指针值是多少

#include <stdio.h>

typedef struct node
{
      int i;
      struct node *next;
}node;

node getnode(int a)
{
      struct node n;
      n.i=a;
      n.next=NULL;
      return n;
}

main()
{
     int i;
     node newtemp,root,temp;

     scanf("%d",&i);
     root=getnode(i);
     temp=root;

     while(i--)
     {
         newtemp=getnode(i);

         temp.next=&newtemp;
         if(root.next==NULL)
         {
            root=temp;
         }
        temp=*(temp.next);
     }


     temp=root;

     while( temp.next != NULL )
     {
         printf(" %d ",temp.i);
         temp=*(temp.next);
     }
}

哎呀，每次都是一样的！（如果你不相信，就画一幅画。）

---

放弃吧。如果您需要不确定的内存量（如果节点数量不确定，您需要），那么您需要分配内存。

您只有两个可用于存储节点的内存空间，它们是

root

和

newtemp

。将新节点分配给

newtemp

时，旧节点不再存在

假设在循环的第一次迭代之前，您在scanf中输入了编号

5

，则：

temp.next=&newtemp;

在循环的第一次迭代之后，您有

5 -> NULL

5 -> 4 -> NULL

在循环的第二次迭代之后，您有

5 -> NULL

5 -> 4 -> NULL

（包含

4

的节点已被包含

3

的节点完全替换）

---

唯一的解决方案是使用

malloc

，并使

getnode

返回一个

node*

您可以避免malloc，但不是免费的：

• 在Linux/UNIX上，您可以调用brk（）并编写自己的内存分配器
• 在每个系统上，您都可以使用固定大小的数组作为内存源来编写自己的分配器
• 我看不出有什么替代品可以直接购买malloc/free。他们在那里是有原因的
• 返回要在外部使用的局部变量很简单，但这是一个错误，不起作用

---

您可以静态声明节点结构数组，并从该数组中拾取新节点。但是，您可能已经实现了一个蹩脚的、非常专业化的自定义分配器。可用的最大节点数将是该阵列的大小

或者，您可以使用递归作为分配机制，并对递归堆栈底部的列表执行操作

---

这两种方法都有同样的麻烦。

因为还没有人根据现代C语言（也称C99）的精神回答这个关于

malloc

部分的问题。如果您的编译器符合以下要求，则您具有可变长度数组：

---

其中，

n

具有一些仅在运行时确定的值。您可能不应该过度使用这种方法，因为这受到堆栈大小的限制，否则您可能会遇到堆栈溢出。

当然，您可以构建链表或任何其他数据结构，而无需动态内存分配。 然而，不管你怎么努力，你都不能完全不分配内存来构建它

备选方案：

创建一个全局或静态内存池，您可以在其中放置对象，模拟heap/malloc/free。弗里特斯做了一些类似的事情。 在这种情况下，您将从程序开始就静态分配一个大内存块，并负责管理它，在需要新节点时返回正确的指针，并将该内存标记为已使用

附言：我不会质疑你为什么要避开马洛克。我相信你有很好的理由

在您的程序中，当您这样做时，在第20行：

node myNodes[n];

您正在分配这些节点，其中一个是“newtemp”。 然后在第28行：

     node newtemp,root,temp; 

它只是在旧的“newnode”上复制返回节点的内容（有争议，不是吗？）

你也这么做了，只是大声说：

     newtemp=getnode(i); 

这将设置一个最初来自“root.next”的指针到“newnode”

将在第一次传递时为“NULL”，但随后仅替换相同的内容

     if(root.next==NULL) 

也是将数据从单个分配对象“*（temp.next）”复制到另一个“temp”。 它不会创建任何新节点

如果您这样做，它将起作用：

    temp=*(temp.next); 
     { 
        root=temp; 
     } 

---

使用malloc时，指向该位置的“指针”将传递给变量（即指针）

每次使用此代码时，都会指向一个“新”位置。相反，您使用的是具有“静态”分配内存的普通变量。这意味着，每当你提到“temp”或“newtemp”时，你每次都是指同一个位置

现在，您告诉我如何仅使用3个（root、temp、newtemp）内存位置来存储10个元素的长列表。您可能想要抽出内存位置来想象发生了什么。但请记住，每次调用“temp”都是在同一个内存位置。为此，我们必须使用malloc（或calloc）来动态分配内存

---

在这种情况下，我们只需要很少的指针（远远小于列表使用的内存）

不使用

malloc

的链表？这可能吗？为什么？？我不确定，但当我们有堆栈分配和定义良好的复制构造函数时，为什么不可能呢？？？欢迎使用SO:）您可以而且应该使用“010101”按钮或4-空格缩进将代码段标记为代码。我刚才是为你做的。@gablin:当然。您可以静态地声明一个节点数组，并使用

#include <stdio.h>

typedef struct node 
{ 
    int i; 
    struct node *next; 
}
    node; 

#define MAX_NODES   10

node    *create_node( int a )
{ 
    // Memory space to put your nodes. Note that is is just a MAX_NODES * sizeof( node ) memory array.
    static node node_pool[ MAX_NODES ];
    static int  next_node = 0;

    printf( "[node  *create_node( int a )]\r\tnext_node = %d; i = %d\n", next_node, a );
    if ( next_node >= MAX_NODES )
    {
        printf( "Out of memory!\n" );
        return ( node * )NULL;
    }

    node    *n = &( node_pool[ next_node++ ] );

    n->i = a;
    n->next = NULL;

    return n; 
} 

int main( )
{ 
    int i; 
    node    *newtemp, *root, *temp; 

    root = create_node( 0 ); 
    temp = root; 

    for ( i = 1; ( newtemp = create_node( i ) ) && i < MAX_NODES; ++i )
    { 
        temp->next = newtemp; 

        if ( newtemp )
        {
            printf( "temp->i = %d\n", temp->i );
            printf( "temp->next->i = %d\n", temp->next->i );
            temp = temp->next;
        }
    }


    for ( temp = root; temp != NULL; temp = temp->next )
        printf( " %d ", temp->i );

    return  0;
}

    $ gcc -Wall -o list_no_malloc list_no_malloc.c 

$ ./list_no_malloc
[node   next_node = 0; i = 0)]
[node   next_node = 1; i = 1)]
temp->i = 0
temp->next->i = 1
[node   next_node = 2; i = 2)]
temp->i = 1
temp->next->i = 2
[node   next_node = 3; i = 3)]
temp->i = 2
temp->next->i = 3
[node   next_node = 4; i = 4)]
temp->i = 3
temp->next->i = 4
[node   next_node = 5; i = 5)]
temp->i = 4
temp->next->i = 5
[node   next_node = 6; i = 6)]
temp->i = 5
temp->next->i = 6
[node   next_node = 7; i = 7)]
temp->i = 6
temp->next->i = 7
[node   next_node = 8; i = 8)]
temp->i = 7
temp->next->i = 8
[node   next_node = 9; i = 9)]
temp->i = 8
temp->next->i = 9
[node   next_node = 10; i = 10
Out of memory!
 0  1  2  3  4  5  6  7  8  9 

node* new = (node*)malloc(sizeof(node));