C语言指针与内存分配问题

tamashii

闲来没事用C写了一个链表玩玩，可是……编译成功了，一运行就卡死 - -
求C大师指教
编译环境：Win7 x64 & GCC

1. #include <stdio.h>
   
2. #include <memory.h>
   
3. 
   
4. typedef struct _tagSTACK_ITEM {
   
5.         struct _tagSTACK_ITEM *next;
   
6.         int value;
   
7. } STACK_ITEM;
   
8. 
   
9. typedef struct _tagSTACK {
   
10.         int length;
    
11.         STACK_ITEM *top;
    
12. } STACK;
    
13. 
    
14. short CreateStack(STACK * ret_stack) {
    
15.         STACK stack;
    
16.         memset(&stack, 0, sizeof(STACK));
    
17.         stack.length = 0;
    
18.         stack.top = 0;
    
19.         ret_stack = &stack;
    
20.         return 1;
    
21. }
    
22. 
    
23. short CreateStackItem(int value, STACK_ITEM * ret_item) {
    
24.         STACK_ITEM item;
    
25.         memset(&item, 0, sizeof(STACK_ITEM));
    
26.         item.value = value;
    
27.         item.next = 0;
    
28.         ret_item = &item;
    
29.         return 1;
    
30. }
    
31. 
    
32. void StackPush(STACK *stack, int value) {
    
33.         if (stack->top == 0) { /* if stack is empty, let the top of stack goto value. */
    
34.                 STACK_ITEM *item;
    
35.                 memset(item, 0, sizeof(STACK_ITEM));
    
36.                 CreateStackItem(value, item);
    
37.                 stack->top = item;
    
38.         }
    
39.         else { /* if not, insert a new node. */
    
40.                 STACK_ITEM *item;
    
41.                 CreateStackItem(value, item);
    
42.                 item->next = stack->top;
    
43.                 stack->top = item;
    
44.         }
    
45.         stack->length++;
    
46. }
    
47. 
    
48. int StackPop(STACK *stack, int *value) {
    
49.         if (stack->length == 0) { /* if stack is null, then it will error. */
    
50.                 *value = 0;
    
51.                 return 0;
    
52.         }
    
53.         /* if not, pop a value. */
    
54.         *value = stack->top->value;
    
55.         /* move to next */
    
56.         stack->top = stack->top->next;
    
57.         stack->length--;
    
58.         return 1;
    
59. }
    
60. 
    
61. int main() {
    
62.         int i = 0;
    
63.         int a = 0;
    
64.         STACK * stack = 0;
    
65.         CreateStack(stack);
    
66.         StackPush(stack, 1);
    
67.         StackPush(stack, 2);
    
68.         StackPush(stack, 3);
    
69.         StackPush(stack, 4);
    
70.         StackPush(stack, 5);
    
71.         for (i = 0; i < 5; i++) {
    
72.                 if (StackPop(stack, &a)) {
    
73.                         printf("%d\n", a);
    
74.                 }
    
75.                 else {
    
76.                         printf("\aError! stack is empty! ");
    
77.                         return -1;
    
78.                 }
    
79.         }
    
80.         return 0;
    
81. }

复制代码

一瞬间的幻觉

在每句前面都加一个#不就不卡了嘛

神思

1. // TestC.cpp : 定义控制台应用程序的入口点。
   
2. //
   
3. 
   
4. #include "stdafx.h"
   
5. 
   
6. #include <iostream>
   
7. 
   
8. using namespace std;
   
9. #include <stdio.h>
   
10. #include <memory.h>
    
11. 
    
12. typedef struct _tagSTACK_ITEM {
    
13.         struct _tagSTACK_ITEM *next;
    
14.         int value;
    
15. } STACK_ITEM;
    
16. 
    
17. typedef struct _tagSTACK {
    
18.         int length;
    
19.         STACK_ITEM *top;
    
20. } STACK;
    
21. 
    
22. short CreateStack(STACK* &ret_stack) {
    
23.         STACK* stack = new STACK;
    
24.         memset(stack, 0, sizeof(STACK));
    
25.         stack->length = 0;
    
26.         stack->top = 0;
    
27.         ret_stack = stack;
    
28.         return 1;
    
29. }
    
30. 
    
31. short CreateStackItem(int value, STACK_ITEM* ret_item) {
    
32.         memset(ret_item, 0, sizeof(STACK_ITEM));
    
33.         ret_item->value = value;
    
34.         ret_item->next = 0;
    
35.         return 1;
    
36. }
    
37. 
    
38. void StackPush(STACK *stack, int value) {
    
39.         if (stack->top == 0) { /* if stack is empty, let the top of stack goto value. */
    
40.                 STACK_ITEM* item = new STACK_ITEM;
    
41.                 memset(item, 0, sizeof(STACK_ITEM));
    
42.                 CreateStackItem(value, item);
    
43.                 stack->top = item;
    
44.         }
    
45.         else { /* if not, insert a new node. */
    
46.                 STACK_ITEM *item = new STACK_ITEM;
    
47.                 CreateStackItem(value, item);
    
48.                 item->next = stack->top;
    
49.                 stack->top = item;
    
50.         }
    
51.         stack->length++;
    
52. }
    
53. 
    
54. int StackPop(STACK *stack, int *value) {
    
55.         if (stack->length == 0) { /* if stack is null, then it will error. */
    
56.                 *value = 0;
    
57.                 return 0;
    
58.         }
    
59.         /* if not, pop a value. */
    
60.         *value = stack->top->value;
    
61.         /* move to next */
    
62.          STACK_ITEM *stackItem = stack->top;
    
63.         stack->top = stack->top->next;
    
64.         stack->length--;
    
65.         delete stackItem;
    
66.         return 1;
    
67. }
    
68. 
    
69. int main() {
    
70. 
    
71. 
    
72.         int i = 0;
    
73.         int a = 0;
    
74.         STACK * stack = 0;
    
75.         CreateStack(stack);
    
76.         StackPush(stack, 1);
    
77.         StackPush(stack, 2);
    
78.         StackPush(stack, 3);
    
79.         StackPush(stack, 4);
    
80.         StackPush(stack, 5);
    
81.         for (i = 0; i < 5; i++) {
    
82.                 if (StackPop(stack, &a)) {
    
83.                         printf("%d\n", a);
    
84.                 }
    
85.                 else {
    
86.                         printf("\aError! stack is empty! ");
    
87.                         return -1;
    
88.                 }
    
89.         
    
90.                 }
    
91.                
    
92.     return 0;
    
93. }
    

复制代码

输出
5
4
3
2
1

tamashii

new STACK_ITEM……
大哥我这是C，不是C++……

神思

{:nm_7:}呃。。。那还不简单  改成malloc

1. 你敢告诉我你该什么了么

复制代码

听这话，我怎么感觉我干了不该干的呢？

首先，这种先进后出叫做栈，不叫链表，
然后，
第一个错误点

short CreateStack(STACK * ret_stack) {
        STACK stack;
        memset(&stack, 0, sizeof(STACK));
        stack.length = 0;
        stack.top = 0;
        ret_stack = &stack;
        return 1;
}
这你带进来ret_stack只是一个引用地址,

然后
STACK_ITEM *item;
memset(item, 0, sizeof(STACK_ITEM));
有2处这里,根本未申请空间,你就给他来个归零.

然后,就是pop的时候你没delete

tamashii

本来想说“写了个链栈”来着，怎么成链表了 - -bbbb
我还是好好学C语言吧
delete？那好像也是C++吧？

1. #include <stdio.h>
   
2. #include <memory.h>
   
3. #include <malloc.h>
   
4. 
   
5. typedef struct _tagSTACK_ITEM {
   
6.         struct _tagSTACK_ITEM *next;
   
7.         int value;
   
8. } STACK_ITEM;
   
9. 
   
10. typedef struct _tagSTACK {
    
11.         int length;
    
12.         STACK_ITEM *top;
    
13. } STACK;
    
14. 
    
15. short CreateStack(STACK *ret_stack) {
    
16.         STACK *stack = malloc(sizeof(STACK));
    
17.         memset(stack, 0, sizeof(STACK));
    
18.         stack->length = 0;
    
19.         stack->top = 0;
    
20.         ret_stack = stack;
    
21.         return 1;
    
22. }
    
23. 
    
24. short CreateStackItem(int value, STACK_ITEM *ret_item) {
    
25.         STACK_ITEM *item = malloc(sizeof(STACK_ITEM));
    
26.         memset(item, 0, sizeof(STACK_ITEM));
    
27.         item->value = value;
    
28.         item->next = 0;
    
29.         ret_item = item;
    
30.         return 1;
    
31. }
    
32. 
    
33. void StackPush(STACK *stack, int value) {
    
34.         if (stack->top == 0) { /* if stack is empty, let the top of stack goto value. */
    
35.                 STACK_ITEM *item = malloc(sizeof(STACK_ITEM));
    
36.                 memset(item, 0, sizeof(STACK_ITEM));
    
37.                 CreateStackItem(value, item);
    
38.                 stack->top = item;
    
39.         }
    
40.         else { /* if not, insert a new node. */
    
41.                 STACK_ITEM *item = malloc(sizeof(STACK_ITEM));
    
42.                 CreateStackItem(value, item);
    
43.                 item->next = stack->top;
    
44.                 stack->top = item;
    
45.         }
    
46.         stack->length++;
    
47. }
    
48. 
    
49. int StackPop(STACK *stack, int *value) {
    
50.         if (stack->length == 0) { /* if stack is null, then it will error. */
    
51.                 *value = 0;
    
52.                 return 0;
    
53.         }
    
54.         /* if not, pop a value. */
    
55.         *value = stack->top->value;
    
56.         /* move to next */
    
57.         STACK_ITEM * temp = stack->top;
    
58.         stack->top = stack->top->next;
    
59.         stack->length--;
    
60.         free(temp);
    
61.         return 1;
    
62. }
    
63. 
    
64. int main() {
    
65.         int i = 0;
    
66.         int a = 0;
    
67.         STACK * stack = 0;
    
68.         CreateStack(stack);
    
69.         StackPush(stack, 1);
    
70.         StackPush(stack, 2);
    
71.         StackPush(stack, 3);
    
72.         StackPush(stack, 4);
    
73.         StackPush(stack, 5);
    
74.         for (i = 0; i < 5; i++) {
    
75.                 if (StackPop(stack, &a)) {
    
76.                         printf("%d\n", a);
    
77.                 }
    
78.                 else {
    
79.                         printf("\aError! stack is empty! ");
    
80.                         return -1;
    
81.                 }
    
82.         }
    
83.         return 0;
    
84. }

复制代码

修正了一下，但是还是无法运行 - -

熊的选民

debug+watch应该就能找出错了吧。

现在的年轻人越来越强了。我身边那些靠编程拿工资的人写出来的东西都跟那啥一样，我认识的牛人都是把编程当成业余爱好的，这是什么道理呢？

苏小脉

tamashii 发表于 2011-7-18 20:20
本来想说“写了个链栈”来着，怎么成链表了 - -bbbb
我还是好好学C语言吧
delete？那好像也是C++吧？修正了 ...

神思说的第一个错误你没有改。

1. short CreateStack(STACK *ret_stack);

复制代码

这里的 ret_stack 是单间接引用，它仅仅是调用者传递的指针的一个拷贝，指向与调用者指针相同的地址。因此，你在 CreateStack 中修改 ret_stack，修改的仅仅是在 CreateStack 函数中的局部变量 `ret_stack'，而无法修改调用者非局部的指针。为了修改调用者的指针，调用者必须能够传递指针本身的地址，所以这里可以使用双间接引用，然后修改时通过 * 运算符反引用一下 ret_stack 即可。

1. short CreateStack(STACK **ret_stack) {
   
2.         ...
   
3.         *ret_stack = stack;
   
4.         ...
   
5. }

复制代码

调用的时候，就要传递指针的地址，而不是指针指向的地址，如下：

1.         STACK * stack = 0;
   
2.         CreateStack(&stack);

复制代码

CreateStackItem 也是一个道理。像这种分配一个结构实例的场合，我通常会直接返回实例的地址，但有时可能需要返回函数错误代码，所以需要双间接引用。

别的一些问题：

1、分配初始为 0 的内存不需要额外去调用一次 memset，直接用 calloc 即可。

2、57 行的 STACK_ITEM * temp = stack->top; 这一句与 C89 是不兼容的，只有 C99 才兼容。C89 要求所有的变量声明都处于代码块顶部而不能出现在非声明语句之后。

link006007

弄清变量作用域是什么就没问题了。。
还要注意 pop出的栈元素的回收
C遵循谁申请谁释放

做IT技术，编程不可能成为业余爱好  即使你是CTO，架构师，分析师
只是很多非核心代码你是交给别人去写，但是你要保证整个工程每个人代码的质量
把写程序当成业余爱好的CTO无法做到保证整体上的工程代码质量

神思

我是来吐槽的

// TestC.cpp : 定义控制台应用程序的入口点。

大哥我这是C，不是C++……