栈的实现在代码块中显示为空数组，但在在线编译器中正常工作。

huangapple
go评论96阅读模式
英文:

Stack implementation shows blank array in codeblock but works fine in online compiler

问题

我有一个简单的堆栈实现。我想在推送之前显示堆栈。所以如果我的堆栈大小是3，根据我的实现，它应该打印0 0 0。但在Codeblocks（版本20.03）中显示为空白，在一些在线编译器中可以正常工作。

  1. #include <stdio.h>
  2. #include <stdbool.h>
  4. void init_stack(int);
  5. void push(int);
  6. int pop();
  7. int peek();
  8. void print();
  10. int top = -1;
  11. int stack_size;
  12. int stack[];
  14. int main()
  15. {
  16.     printf("您的堆栈大小：");
  17.     scanf("%d", &stack_size);
  18.     printf("此堆栈仅允许整数值！");
  19.     stack[stack_size];
  21.     init_stack(stack_size);
  23.     bool t = true;
  24.     while(t)
  25.     {
  26.         printf("\n\n1. 推送\n2. 弹出\n3. 窥视\n4. isEmpty\n5. isFull\n6. 打印堆栈\n7. 退出");
  27.         printf("\n\n选择：");
  29.         int c;
  30.         scanf("%d", &c);
  32.         int Element;
  33.         switch(c)
  34.         {
  35.         case 1 :
  36.             printf("\n\n元素：");
  37.             scanf("%d", &Element);
  39.             if(top < stack_size-1)
  40.             {
  41.                 push(Element);
  42.                 printf("\n成功...");
  43.             }
  44.             else printf("\n\t堆栈溢出！");
  45.             break;
  47.         case 2 :
  48.             if(top > -1)
  49.             {
  50.                 Element = pop();
  51.                 printf("\n弹出的元素是：%d", Element);
  52.             }
  53.             else printf("\n\t堆栈下溢！");
  54.             break;
  56.         case 3 :
  57.             if(top > -1)
  58.             {
  59.                 Element = peek();
  60.                 printf("\n顶部元素是：%d", Element);
  61.             }
  62.             else printf("\n\t");
  63.             break;
  65.         case 4 :
  66.             if(top > -1) printf("\n堆栈不为空。");
  67.             else printf("\n堆栈为空！");
  68.             break;
  70.         case 5 :
  71.             if(top < stack_size-1) printf("\n堆栈未满。");
  72.             else printf("\n堆栈已满！");
  73.             break;
  75.         case 6 :
  76.             printf("\n\n当前堆栈：");
  77.             print();
  78.             break;
  80.         default :
  81.             t = false;
  82.         }
  83.     }
  85.     return 0;
  86. }
  88. void push(int Element)
  89. {
  90.     top++;
  91.     stack[top] = Element;
  92. }
  94. int pop()
  95. {
  96.     int Element = stack[top];
  97.     stack[top] = 0;  //从堆栈中删除元素
  98.     top--;
  99.     return Element;
  100. }
  102. int peek()
  103. {
  104.     return stack[top];
  105. }
  107. void print()
  108. {
  109.     int i;
  110.     for(i=0; i<stack_size; i++)
  111.     {
  112.         printf("\t%d", stack[i]);
  113.     }
  114. }
  116. void init_stack(int n)
  117. {
  118.     int i;
  119.     for(i=0; i<n; i++)
  120.     {
  121.         stack[i] = 0;
  122.     }
  123. }
英文:

I have a simple stack implementation. I want to show the stack before pushing
So If my stack size is 3, according to my implementation, it should print
0 0 0
But it is showing blank in codeblocks (version 20.03) but works fine in some online compiler

  1. #include &lt;stdio.h&gt;
  2. #include &lt;stdbool.h&gt;
  3. void init_stack(int);
  4. void push(int);
  5. int pop();
  6. int peek();
  7. void print();
  8. int top = -1;
  9. int stack_size;
  10. int stack[];
  11. int main()
  12. {
  13. printf(&quot;Size of your stack : &quot;);
  14. scanf(&quot;%d&quot;, &amp;stack_size);
  15. printf(&quot;This Stack Allows Only Integer Value!&quot;);
  16. stack[stack_size];
  17. init_stack(stack_size);
  18. bool t = true;
  19. while(t)
  20. {
  21. printf(&quot;\n\n1. Push\n2. Pop\n3. Peek\n4. isEmpty\n5. isFull\n6. Print Stack\n7. Exit&quot;);
  22. printf(&quot;\n\nChoose : &quot;);
  23. int c;
  24. scanf(&quot;%d&quot;, &amp;c);
  25. int Element;
  26. switch(c)
  27. {
  28. case 1 :
  29. printf(&quot;\n\nElement : &quot;);
  30. scanf(&quot;%d&quot;, &amp;Element);
  31. if(top &lt; stack_size-1)
  32. {
  33. push(Element);
  34. printf(&quot;\nSuccessful...&quot;);
  35. }
  36. else printf(&quot;\n\tStack overflow!&quot;);
  37. break;
  38. case 2 :
  39. if(top &gt; -1)
  40. {
  41. Element = pop();
  42. printf(&quot;\nPopped element is : %d&quot;, Element);
  43. }
  44. else printf(&quot;\n\tStack underflow!&quot;);
  45. break;
  46. case 3 :
  47. if(top &gt; -1)
  48. {
  49. Element = peek();
  50. printf(&quot;\nTop element is : %d&quot;, Element);
  51. }
  52. else printf(&quot;\n\t&quot;);
  53. break;
  54. case 4 :
  55. if(top &gt; -1) printf(&quot;\nStack is not empty.&quot;);
  56. else printf(&quot;\nStack is empty!&quot;);
  57. break;
  58. case 5 :
  59. if(top &lt; stack_size-1) printf(&quot;\nStack is not full.&quot;);
  60. else printf(&quot;\nStack is full!&quot;);
  61. break;
  62. case 6 :
  63. printf(&quot;\n\nCurrent stack :&quot;);
  64. print();
  65. break;
  66. default :
  67. t = false;
  68. }
  69. }
  70. return 0;
  71. }
  72. void push(int Element)
  73. {
  74. top++;
  75. stack[top] = Element;
  76. }
  77. int pop()
  78. {
  79. int Element = stack[top];
  80. stack[top] = 0;  //deleting the element from the stack
  81. top--;
  82. return Element;
  83. }
  84. int peek()
  85. {
  86. return stack[top];
  87. }
  88. void print()
  89. {
  90. int i;
  91. for(i=0; i&lt;stack_size; i++)
  92. {
  93. printf(&quot;\t%d&quot;, stack[i]);
  94. }
  95. }
  96. void init_stack(int n)
  97. {
  98. int i;
  99. for(i=0; i&lt;n; i++)
  100. {
  101. stack[i] = 0;
  102. }
  103. }

Screenshots

Codeblocks

栈的实现在代码块中显示为空数组，但在在线编译器中正常工作。

Please point out my mistakes.

答案1

得分: 1

避免全局变量。通过函数参数将您的“堆栈”传递给对其进行操作的函数。

为了实现这一点，您需要将所有堆栈信息作为一个值传递。您可以使用一个结构体来实现这一点。

使用动态内存分配来实现这一点。

例如：

  1. typedef struct stack {
  2.     size_t capacity;
  3.     size_t top;
  4.     int *stack;
  5. } stack_t;
  7. stack_t *init_stack(size_t size) {
  8.     stack_t *new_stack = malloc(sizeof(stack_t));
  9.     if (!new_stack) return NULL;
  11.     new_stack->stack = calloc(size, sizeof(int));
  12.     if (!new_stack->stack) {
  13.         free(new_stack);
  14.         return NULL;
  15.     }
  17.     return new_stack;
  18. }
  20. bool push(stack_t *stack, int value) {
  21.     if (!stack || stack->top >= stack->capacity - 1) {
  22.         return false;
  23.     }
  24.         
  25.     stack->stack[stack->top++] = value;
  26.     return true;
  27. }
  29. // 堆栈的其他操作

然后在 main 中，您可以写：

  1. int main(void) {
  2.     size_t size;
  3.     if (scanf("%zu", &size) != 1) return 1;
  5.     stack_t *stack = init_stack(size);
  6.     if (!stack) return 1;
  7.     
  8.     // 对您的堆栈进行操作。
  10.     // 释放您的堆栈
  12.     return 0;
  13. }
英文:

  1. Avoid global variables. Pass your "stack" to functions which work on it via a function argument.

  2. To accomplish this you need all of your stack info as a value. You can use a struct to accomplish this.

  3. Use dynamic memory allocation to accomplish this.

E.g.

  1. typedef struct stack {
  2.     size_t capacity;
  3.     size_t top;
  4.     int *stack;
  5. } stack_t;
  7. stack_t *init_stack(size_t size) {
  8.     stack_t *new_stack = malloc(sizeof(stack_t));
  9.     if (!new_stack) return NULL;
  11.     new_stack-&gt;stack = calloc(size, sizeof(int));
  12.     if (!new_stack-&gt;stack) {
  13.         free(new_stack);
  14.         return NULL;
  15.     }
  17.     return new_stack;
  18. }
  20. bool push(stack_t *stack, int value) {
  21.     if (!stack || stack-&gt;top &gt;= stack-&gt;capacity - 1) {
  22.         return false;
  23.     }
  24.         
  25.     stack-&gt;stack[stack-&gt;top++] = value;
  26.     return true;
  27. }
  29. // the other operations on a stack

Then in main you can now write:

  1. int main(void) {
  2.     size_t size;
  3.     if (scanf(&quot;%zu&quot;, &amp;size) != 1) return 1;
  5.     stack_t *stack = init_stack(size);
  6.     if (!stack) return 1;
  7.     
  8.     // operations on your stack.
  10.     // free your stack
  12.     return 0;
  13. }
  16. </details>
  20. # 答案2
  21. **得分**: 0
  23. 感谢 @[WeatherVane][1] 提供的解决方案。
  25. ```c
  26.     #include &lt;stdio.h&gt;
  27.     #include &lt;stdbool.h&gt;
  28.     #include &lt;stdlib.h&gt;  // 添加了 malloc
  30.     void init_stack(int);
  31.     void push(int);
  32.     int pop();
  33.     int peek();
  34.     void print();
  36.     int top = -1;
  37.     int stack_size;
  38.     int* stack;  // 删除了 []
  40.     int main()
  41.     {
  42.         printf("栈的大小: ");
  43.         scanf("%d", &stack_size);
  44.         stack = (int*)malloc(sizeof(int) * stack_size);  // 修正了 malloc 的使用
  45.         printf("此栈只允许整数值!");
  47.         init_stack(stack_size);
  49.         bool t = true;
  50.         while (t)
  51.         {
  52.             printf("\n\n1. 入栈\n2. 出栈\n3. 查看栈顶元素\n4. 判断栈是否为空\n5. 判断栈是否已满\n6. 打印栈\n7. 退出");
  53.             printf("\n\n选择: ");
  55.             int c;
  56.             scanf("%d", &c);
  58.             int Element;
  59.             switch (c)
  60.             {
  61.                 case 1:
  62.                     printf("\n\n元素: ");
  63.                     scanf("%d", &Element);
  65.                     if (top < stack_size - 1)
  66.                     {
  67.                         push(Element);
  68.                         printf("\n入栈成功...");
  69.                     }
  70.                     else
  71.                     {
  72.                         printf("\n\t栈溢出!");
  73.                     }
  74.                     break;
  76.                 case 2:
  77.                     if (top > -1)
  78.                     {
  79.                         Element = pop();
  80.                         printf("\n弹出的元素为: %d", Element);
  81.                     }
  82.                     else
  83.                     {
  84.                         printf("\n\t栈下溢!");
  85.                     }
  86.                     break;
  88.                 case 3:
  89.                     if (top > -1)
  90.                     {
  91.                         Element = peek();
  92.                         printf("\n栈顶元素为: %d", Element);
  93.                     }
  94.                     else
  95.                     {
  96.                         printf("\n\t栈为空!");
  97.                     }
  98.                     break;
  100.                 case 4:
  101.                     if (top > -1)
  102.                     {
  103.                         printf("\n栈不为空。");
  104.                     }
  105.                     else
  106.                     {
  107.                         printf("\n栈为空!");
  108.                     }
  109.                     break;
  111.                 case 5:
  112.                     if (top < stack_size - 1)
  113.                     {
  114.                         printf("\n栈不满。");
  115.                     }
  116.                     else
  117.                     {
  118.                         printf("\n栈已满!");
  119.                     }
  120.                     break;
  122.                 case 6:
  123.                     printf("\n\n当前栈:");
  124.                     print();
  125.                     break;
  127.                 default:
  128.                     t = false;
  129.             }
  130.         }
  132.         free(stack);  // 释放分配的内存
  133.         return 0;
  134.     }
  136.     void push(int Element)
  137.     {
  138.         top++;
  139.         stack[top] = Element;
  140.     }
  142.     int pop()
  143.     {
  144.         int Element = stack[top];
  145.         stack[top] = 0;  // 从栈中删除元素
  146.         top--;
  147.         return Element;
  148.     }
  150.     int peek()
  151.     {
  152.         return stack[top];
  153.     }
  155.     void print()
  156.     {
  157.         int i;
  158.         for (i = 0; i <= top; i++)
  159.         {
  160.             printf("\t%d", stack[i]);
  161.         }
  162.     }
  164.     void init_stack(int n)
  165.     {
  166.         int i;
  167.         for (i = 0; i < n; i++)
  168.         {
  169.             stack[i] = 0;
  170.         }
  171.     }
英文:

Thanks @WeatherVane for the solution.

  1. #include &lt;stdio.h&gt;
  2. #include &lt;stdbool.h&gt;
  3. #include &lt;stdlib.h&gt;  // Added for malloc
  4. void init_stack(int);
  5. void push(int);
  6. int pop();
  7. int peek();
  8. void print();
  9. int top = -1;
  10. int stack_size;
  11. int* stack;  // Removed []
  12. int main()
  13. {
  14. printf(&quot;Size of your stack: &quot;);
  15. scanf(&quot;%d&quot;, &amp;stack_size);
  16. stack = (int*)malloc(sizeof(int) * stack_size);  // Corrected malloc usage
  17. printf(&quot;This Stack Allows Only Integer Value!&quot;);
  18. init_stack(stack_size);
  19. bool t = true;
  20. while (t)
  21. {
  22. printf(&quot;\n\n1. Push\n2. Pop\n3. Peek\n4. isEmpty\n5. isFull\n6. Print Stack\n7. Exit&quot;);
  23. printf(&quot;\n\nChoose: &quot;);
  24. int c;
  25. scanf(&quot;%d&quot;, &amp;c);
  26. int Element;
  27. switch (c)
  28. {
  29. case 1:
  30. printf(&quot;\n\nElement: &quot;);
  31. scanf(&quot;%d&quot;, &amp;Element);
  32. if (top &lt; stack_size - 1)
  33. {
  34. push(Element);
  35. printf(&quot;\nSuccessful...&quot;);
  36. }
  37. else
  38. {
  39. printf(&quot;\n\tStack overflow!&quot;);
  40. }
  41. break;
  42. case 2:
  43. if (top &gt; -1)
  44. {
  45. Element = pop();
  46. printf(&quot;\nPopped element is: %d&quot;, Element);
  47. }
  48. else
  49. {
  50. printf(&quot;\n\tStack underflow!&quot;);
  51. }
  52. break;
  53. case 3:
  54. if (top &gt; -1)
  55. {
  56. Element = peek();
  57. printf(&quot;\nTop element is: %d&quot;, Element);
  58. }
  59. else
  60. {
  61. printf(&quot;\n\tStack is empty!&quot;);
  62. }
  63. break;
  64. case 4:
  65. if (top &gt; -1)
  66. {
  67. printf(&quot;\nStack is not empty.&quot;);
  68. }
  69. else
  70. {
  71. printf(&quot;\nStack is empty!&quot;);
  72. }
  73. break;
  74. case 5:
  75. if (top &lt; stack_size - 1)
  76. {
  77. printf(&quot;\nStack is not full.&quot;);
  78. }
  79. else
  80. {
  81. printf(&quot;\nStack is full!&quot;);
  82. }
  83. break;
  84. case 6:
  85. printf(&quot;\n\nCurrent stack:&quot;);
  86. print();
  87. break;
  88. default:
  89. t = false;
  90. }
  91. }
  92. free(stack);  // Free the allocated memory
  93. return 0;
  94. }
  95. void push(int Element)
  96. {
  97. top++;
  98. stack[top] = Element;
  99. }
  100. int pop()
  101. {
  102. int Element = stack[top];
  103. stack[top] = 0;  // Deleting the element from the stack
  104. top--;
  105. return Element;
  106. }
  107. int peek()
  108. {
  109. return stack[top];
  110. }
  111. void print()
  112. {
  113. int i;
  114. for (i = 0; i &lt;= top; i++)
  115. {
  116. printf(&quot;\t%d&quot;, stack[i]);
  117. }
  118. }
  119. void init_stack(int n)
  120. {
  121. int i;
  122. for (i = 0; i &lt; n; i++)
  123. {
  124. stack[i] = 0;
  125. }
  126. }

答案3

得分: -1

这个在文件作用域中声明的数组：

  1. int stack[];

是一个数组的试探性定义，等同于以下定义：

  1. int stack[1];

它的单个元素被初始化为零。

所以这个声明没有意义。

在main函数内部的这个语句：

  1. stack[stack_size];

没有效果。它试图访问先前在文件作用域中声明的数组的不存在的元素，索引为stack_size，前提是stack_size不等于0。

而不是在文件作用域中声明数组，你可以在main函数中声明一个可变长度数组，如下所示：

  1. int main()
  2. {
  3. printf("你的栈的大小：");
  4. scanf("%d", &stack_size);
  5. printf("这个栈只允许整数值！");
  6. int stack[stack_size];
  7. //...

在这种情况下，你需要修改你的函数，为传递的数组添加一个额外的参数，例如：

  1. #include <string.h>;
  2. //...
  3. void init_stack(int stack[], int n)
  4. {
  5. memset(stack, 0, n * sizeof(int));
  6. }

请注意，print函数应该只输出栈中的实际值。所以它应该定义成如下方式：

  1. void print(void)
  2. {
  3. for(int i = 0; i < top + 1; i++)
  4. {
  5. printf("\t%d", stack[i]);
  6. }
  7. }

但无论如何，最好的做法是不要使用单独的变量，而是将数组、变量top和变量size声明为一个结构体的数据成员。例如：

  1. struct Stack
  2. {
  3. int size;
  4. int top;
  5. int *data;
  6. };
英文:

This declaration of an array in the file scope

  1. int stack[];

is a tentative definition of an array that is equivalent to the definition

  1. int stack[1];

and its single element is zero initialized.

So this declaration does not make sense.

This statement within main:

  1. stack[stack_size];

has no effect. It is an attempt to access a non-existent element of the previously declared file scope array with the index stack_size provided that stack_size is not equal to 0.

Instead of the file scope array you could declare a variable length array within the function main like:

  1. int main()
  2. {
  3. printf(&quot;Size of your stack : &quot;);
  4. scanf(&quot;%d&quot;, &amp;stack_size);
  5. printf(&quot;This Stack Allows Only Integer Value!&quot;);
  6. int stack[stack_size];
  7. //...

In this case you will need to change your functions adding one more parameter for the passed array to the functions as for example

  1. #include &lt;string.h&gt;
  2. //...
  3. void init_stack( int stack[], int n )
  4. {
  5. memset( stack, 0, n * sizeof( int ) );
  6. }

Pay attention to that the function print should output only actual values in the stack. So it should be defined something like the following way

  1. void print( void )
  2. {
  3. for( int i = 0; i &lt; top + 1; i++ )
  4. {
  5. printf(&quot;\t%d&quot;, stack[i]);
  6. }
  7. }

But in any case it would be much better instead of using separate variables as the array, the variable top and the variable size to declare a structure that will contain these entities as its data members. For example:

  1. struct Stack
  2. {
  3. int size;
  4. int top;
  5. int *data;
  6. };

huangapple
  • 本文由 发表于 2023年7月7日 02:56:27
  • 转载请务必保留本文链接：https://go.coder-hub.com/76631787.html
  • c
  • codeblocks
  • online-compilation
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定