C linkedList中的void*

我有一个简单的链表，看起来像这样

typedef struct Node { 
    void *data;
    struct Node *next
} Node;

typedef struct Node {
Node *head;
Node *tail;
int size;
} LinkedList

我的add_node函数如下所示：

void add_nth_node(LinkedList *list, int n, void *new_data) {
Node *prev, *curr;
Node *new_node;

if (list == NULL) {
    return;
}

/* n >= list->size inseamna adaugarea unui nou nod la finalul listei. */
if (n > list->size) {
    n = list->size;
} else if (n < 0) {
    return;
}

curr = list->head;
prev = NULL;
while (n > 0) {
    prev = curr;
    curr = curr->next;
    --n;
}

new_node = malloc(sizeof(Node));
if (new_node == NULL) {
    perror("Not enough memory to add element!");
    exit(-1);
}

new_node->data = new_data;
new_node->next = curr;
if (prev == NULL) {
    /* Adica n == 0. */
    list->head = new_node;
} else {
    prev->next = new_node;
}

if (new_node->next == NULL) {
    list->tail = new_node;
}

list->size++;

int i;    
for (i = 0; i < 10; i++) {
     add_nth_node(list, i, &i);
}

int i, v[10];
    for(i = 0; i < 10; i++) {
        v[i] = i;
        add_nth_node(list_1, i, &v[i]);
    }

void添加第n个节点（LinkedList*列表，int n，void*新数据）{
节点*prev，*curr；
节点*新节点；
if（list==NULL）{
回来
}
/*n>=列表->最终列表的大小*/
如果（n>列表->大小）{
n=列表->大小；
}else if（n<0）{
回来
}
curr=列表->标题；
prev=NULL；
而（n>0）{
上一次=当前；
当前=当前->下一步；
--n；
}
新节点=malloc（sizeof（node））；
if（新节点==NULL）{
perror（“内存不足，无法添加元素！”）；
出口（-1）；
}
新建_节点->数据=新建_数据；
新建节点->下一步=当前；
if（prev==NULL）{
/*adican==0*/
列表->头部=新节点；
}否则{
上一步->下一步=新建_节点；
}
if（新建节点->下一步==NULL）{
列表->尾部=新节点；
}
列表->大小++；

当我尝试向列表中添加节点时，出现了一些奇怪的情况。 当我这样添加它们时：

void add_nth_node(LinkedList *list, int n, void *new_data) {
Node *prev, *curr;
Node *new_node;

if (list == NULL) {
    return;
}

/* n >= list->size inseamna adaugarea unui nou nod la finalul listei. */
if (n > list->size) {
    n = list->size;
} else if (n < 0) {
    return;
}

curr = list->head;
prev = NULL;
while (n > 0) {
    prev = curr;
    curr = curr->next;
    --n;
}

new_node = malloc(sizeof(Node));
if (new_node == NULL) {
    perror("Not enough memory to add element!");
    exit(-1);
}

new_node->data = new_data;
new_node->next = curr;
if (prev == NULL) {
    /* Adica n == 0. */
    list->head = new_node;
} else {
    prev->next = new_node;
}

if (new_node->next == NULL) {
    list->tail = new_node;
}

list->size++;

int i;    
for (i = 0; i < 10; i++) {
     add_nth_node(list, i, &i);
}

int i, v[10];
    for(i = 0; i < 10; i++) {
        v[i] = i;
        add_nth_node(list_1, i, &v[i]);
    }

inti；
对于（i=0；i<10；i++）{
添加第n个节点（列表、i和i）；
}

但当我添加这样的元素时：

void add_nth_node(LinkedList *list, int n, void *new_data) {
Node *prev, *curr;
Node *new_node;

if (list == NULL) {
    return;
}

/* n >= list->size inseamna adaugarea unui nou nod la finalul listei. */
if (n > list->size) {
    n = list->size;
} else if (n < 0) {
    return;
}

curr = list->head;
prev = NULL;
while (n > 0) {
    prev = curr;
    curr = curr->next;
    --n;
}

new_node = malloc(sizeof(Node));
if (new_node == NULL) {
    perror("Not enough memory to add element!");
    exit(-1);
}

new_node->data = new_data;
new_node->next = curr;
if (prev == NULL) {
    /* Adica n == 0. */
    list->head = new_node;
} else {
    prev->next = new_node;
}

if (new_node->next == NULL) {
    list->tail = new_node;
}

list->size++;

int i;    
for (i = 0; i < 10; i++) {
     add_nth_node(list, i, &i);
}

int i, v[10];
    for(i = 0; i < 10; i++) {
        v[i] = i;
        add_nth_node(list_1, i, &v[i]);
    }

inti，v[10]；
对于（i=0；i<10；i++）{
v[i]=i；
添加第n个节点（列表1、i和v[i]）；
}

一切正常，为什么？ 为什么我必须把元素放在向量的前面，才能将它们添加到列表中

add_nth_node(list, i, &i) // (1)
// and
add_nth_node(list_1, i, &v[i]); // (2)

它们不相同，但为每个节点指定的数据值在两个选项中相同

（1） 您将指针指向

i

的地址

（2） 您将指针指向

v[i]

的地址

---

使用（1）是一个非常糟糕的主意，因为在这种情况下，所有节点的

数据都指向同一地址。因此，如果一个节点的
数据发生更改，所有节点的数据都会更改值。
传递指向临时循环变量（
&i
）的指针可能是一个糟糕的主意。建议更改结构标记（
typedef struct
Node）或typedef符号。否则它们可能会相互屏蔽。因为
i
将更改，
v[i]
不会更改您有重复的
struct节点
定义。将
typedef struct Node{…}LinkedList
更改为
typedef struct LinkedList{…}LinkedList
或只是
typedef struct{…}LinkedList
，因为除了typedef之外，您没有使用任何对结构的命名引用。