关于结构指针与动态内存分配问题。

duleell

1. 
   
2. #include <stdio.h>;
   
3. #include <string.h>;
   
4. 
   
5. typedef struct node {
   
6.         char        info;
   
7.         struct node        *link;
   
8. } NODE;
   
9. 
   
10. void str2nodestr(char *string, NODE *node_string);
    
11. 
    
12. void main()
    
13. {
    
14.    NODE        node_string, *head;
    
15. 
    
16.    memset(&node_string,0x0,sizeof(NODE));
    
17. 
    
18.    str2nodestr("abcdEND", &node_string);
    
19. 
    
20.    head=&node_string;
    
21.    while( head->;info!=NULL ) {
    
22.         putc(head->;info,stdout);
    
23.         head=head->;link;
    
24.    }
    
25.    putc('\n',stdout);
    
26. }
    
27. 
    
28. void str2nodestr(char *string, NODE *node_string)
    
29. {
    
30.    NODE *node_char, *p=NULL;
    
31.    char        ch;
    
32. 
    
33.    while ( (ch=*string)!= '\0' ) {
    
34.         node_char=(NODE *)malloc(sizeof(NODE));
    
35.         node_char->;info=ch;
    
36.         node_char->;link=NULL;
    
37.         if (node_string->;info==NULL) {
    
38.                 node_string=node_char;
    
39.                 p=node_string;
    
40.         } else {
    
41.                 p->;link=node_char;
    
42.                 p=p->;link;
    
43.         }
    
44.         ++string;
    
45.    }
    
46. }
    

复制代码

调用子函数返回后，主函数中的node_string还是没改变，请指教。THX。

kj501

典型的造成内存泄漏的做法。C 语言中子函数对参数的修改在函数返回后就无效了。如果不想从子函数中返回node_string，可以在主函数中声明一个二级指针。传递参数时用NODE **node_string而不是NODE *node_string。

duleell

是不是主程序里先要给node_string分配空间，然后再把node_string的指针传给str2nodestr后，在str2nodestr中的操作才能影响主程序里的node_string。下面是我改完的，运行正确，内存也应该不会泄漏了吧。

1. 
   
2. #include <stdio.h>;
   
3. #include <string.h>;
   
4. 
   
5. typedef struct node {
   
6.         char        info;
   
7.         struct node        *link;
   
8. } NODE;
   
9. 
   
10. void str2nodestr(char *string, NODE *node_string);
    
11. 
    
12. void main()
    
13. {
    
14.    static char        aString[]="abcEND";
    
15.    NODE        *node_string, *head;
    
16.    long        sizeof_node_string;
    
17. 
    
18.    sizeof_node_string=sizeof(NODE)*strlen(aString);
    
19.    node_string=(NODE *)malloc(sizeof_node_string);
    
20.    memset(node_string,0x0,sizeof(sizeof_node_string));
    
21. 
    
22.    str2nodestr(aString, node_string);
    
23. 
    
24.    head=node_string;
    
25.    while( head!=NULL ) {
    
26.         putc(head->;info,stdout);
    
27.         head=head->;link;
    
28.    }
    
29.    putc('\n',stdout);
    
30.    
    
31.    free(node_string);
    
32. }
    
33. 
    
34. void str2nodestr(char *string, NODE *node_string)
    
35. {
    
36.    NODE *head;
    
37. 
    
38.    head=node_string;
    
39.    while ( (*string)!= '\0' ) {
    
40.         head->;info=*string;
    
41.         head->;link=head+sizeof(NODE);
    
42.         head=head->;link;
    
43.         ++string;
    
44.    }
    
45.    head->;link=NULL;
    
46. }
    

复制代码

yuxh

很简单啊!
把第一个程序中str2nodestr函数的
node_string=node_char;
改成
node_string->;info = node_char->;info;
即可
但在main中
while( head->;info!=NULL ) {
...
}
是错误的，要改成
head->;link!=NULL

duleell

这样做内存是否会产生泄漏？

1. 
   
2. #include <stdio.h>;
   
3. #include <string.h>;
   
4. 
   
5. typedef struct node {
   
6.         char        info;
   
7.         struct node        *link;
   
8. } NODE;
   
9. 
   
10. NODE *str2nodestr(char *string);
    
11. void print_node_string(NODE *node_string);
    
12. 
    
13. void main()
    
14. {
    
15.    static char        aString[]="abcEND";
    
16.    NODE        *head;
    
17. 
    
18.    head=str2nodestr(aString);
    
19.    print_node_string(head);
    
20.    
    
21.    free(head);
    
22. }
    
23. 
    
24. NODE *str2nodestr(char *string)
    
25. {
    
26.    NODE *node_string, *head;
    
27.    long        sizeof_node_string;
    
28. 
    
29.    sizeof_node_string=sizeof(NODE)*strlen(string);
    
30.    node_string=(NODE *)malloc(sizeof_node_string);
    
31.    memset(node_string,0x0,sizeof(sizeof_node_string));
    
32.    head=node_string;
    
33.    while ( (*string)!= '\0' ) {
    
34.         node_string->;info=*string;
    
35.         node_string->;link=node_string+sizeof(NODE);
    
36.         node_string=node_string->;link;
    
37.         ++string;
    
38.    }
    
39.    node_string->;link=NULL;
    
40. 
    
41.    return head;
    
42. }
    
43. 
    
44. void print_node_string(NODE *node_string)
    
45. {
    
46.    NODE *head=node_string;
    
47. 
    
48.    while( head!=NULL ) {
    
49.         putc(head->;info,stdout);
    
50.         head=head->;link;
    
51.    }
    
52.    putc('\n',stdout);
    
53. }
    

复制代码

yuxh

你这样做还能叫链表？

duleell

我看着也不像

我是想做一个能把任意长度的字符串转成链表并用子函数的形式实现的程序。

这样应该可以了吧?

1. 
   
2. #include <stdio.h>;
   
3. #include <string.h>;
   
4. 
   
5. typedef struct node {
   
6.         char        info;
   
7.         struct node        *link;
   
8. } NODE;
   
9. 
   
10. NODE *str2nodestr(char *string);
    
11. void print_node_string(NODE *node_string);
    
12. 
    
13. void main()
    
14. {
    
15.    static char        aString[]="abcEND";
    
16.    NODE        *ns1,*ns2;
    
17. 
    
18.    ns1=str2nodestr(aString);
    
19.    ns2=str2nodestr("1234");
    
20.    
    
21.    print_node_string(ns1);
    
22.    print_node_string(ns2);
    
23.    
    
24.    free(ns1);
    
25.    free(ns2);
    
26. }
    
27. 
    
28. NODE *str2nodestr(char *string)
    
29. {
    
30.    NODE *p,*node_char, *head=NULL;
    
31. 
    
32.    while ( (*string)!= '\0' ) {
    
33.         node_char=(NODE *)malloc(sizeof(NODE));
    
34.         node_char->;info=*string;
    
35.         node_char->;link=NULL;
    
36.         if (head==NULL) {
    
37.                 head=node_char;
    
38.                 p=head;
    
39.         } else {
    
40.                 p->;link=node_char;
    
41.                 p=p->;link;
    
42.         }
    
43.         ++string;
    
44.    }
    
45. 
    
46.    return head;
    
47. }
    
48. 
    
49. void print_node_string(NODE *node_string)
    
50. {
    
51.    NODE *head=node_string;
    
52. 
    
53.    while( head!=NULL ) {
    
54.         putc(head->;info,stdout);
    
55.         head=head->;link;
    
56.    }
    
57.    putc('\n',stdout);
    
58. }
    

复制代码

duleell

释放链表所用的内存空间是否要自己写函数？

sfeng

感觉上是需要自己写函数释放的。
因为分配的时候每个字符都是malloc了一个NODE大小的空间的。直接用free释放，感觉上是只释放了第一个字符的存放空间。

代码：

1. 
   
2. void free_node_string(NODE *node_string)
   
3. {
   
4. NODE *free_node = NULL;
   
5. NODE *head=node_string;
   
6. 
   
7.   while( head!=NULL ) {
   
8.     free_node = head;
   
9.     head=head->;link;
   
10.     free( free_node );
    
11.   }
    
12. }
    

复制代码

duleell

谢谢，我也是这么做的。