C - 数组下标不是整数

Question

我正在开发一个程序，将值弹出并将值压入堆栈并检查(查看)堆栈顶部。如果你运行我的程序，你会看到我收到“数组下标不是整数”的错误，我想知道这不是什么意思，我应该如何继续修复这个错误。

stack.c程序:

#include <stdlib.h>
#include <stdbool.h>
#include "stack.h"

static int mockUp = 42;
static int *stackTop = &mockUp;
static int stack[10];


int isstackempty() {
   if(top == -1)
      return 1;
   else
      return 0;
}

int isstackfull() {
   if(top == DEFAULT_STACK_SIZE)
      return 1;
   else
      return 0;
}

int top()
{
   return *stackTop;
}

int pop( int *val)
{
    if(!isstackempty()) {
      val = stack[top];
      top = top - 1;   
      return val;
      printf("%d popped from stack\n", val);
   } else {
      printf("Error. Could not pop value as stack is empty.\n");
   }
}

int push( int val)
{
    if(!isstackfull()) {
      top = top + 1;   
      stack[top] = val;
      printf("%d pushed onto stack\n", val);
   } else {
      printf("%d could NOT be pushed as stack is full.\n", val);
   }
}

int main()
{
    push(1);
    push(2);
    push(3);
    push(4);
    push(5);
    push(6);
    push(7);
    push(8);
    push(9);

    printf("Value at top of stack is %d\n", top());

    while(!isstackempty()) {
      int val = pop();
      printf("Stack value popped %d\n", val);
   }

   return 0;

}

stack.h程序:

#define DEFAULT_STACK_SIZE 10

extern void setStackSize( int size); 
extern int getStackSize();
extern void deleteStack();
extern int top();
extern int pop(  int* val);
extern int push( int val);

Answer 1

在这个最小的例子中你真的有很多错误。

你试过编译你的代码吗？

int top()
{
    return 0;
}

int main(void)
{
    top = top + 1;
}

GCC 返回错误:

a.c:18:6: error: lvalue required as left operand of assignment
  top = 4;

你创建堆栈的方式很糟糕。

1. 不要使用全局变量
2. 你必须通过知道有多少元素来检查你的堆栈是否已满存储以及堆栈中剩余多少空间。你通过保存这个来做到这一点变量中的信息，而不是通过查看顶部元素是否是魔术数字 DEFAULT_STACK_SIZE。
3. 使用 struct 而不是声明没有意义的随机变量(比如模型。

对这样的数据结构使用 struct 的优点是您对象中有你需要的所有信息，你不需要声明单独的变量来跟踪内部状态，你不需要声明全局变量。

#include <stdio.h>

typedef struct stack
{
    int buffer[10];
    size_t len;
} Stack;

void stack_init(Stack *stack)
{
    if(stack == NULL)
        return;

    stack->len = 0;
}

int stack_is_full(Stack *stack)
{
    if(stack == NULL)
        return 0;

    size_t buffer_size = sizeof stack->buffer / sizeof *stack->buffer;

    if(stack->len >= buffer_size)
        return 1;

    return 0;
}

int stack_is_empty(Stack *stack)
{
    if(stack == NULL)
        return 0;

    if(stack->len == 0)
        return 1;

    return 0;
}

// if val is NULL, user wants to pop without
// getting the value
int stack_pop(Stack *stack, int *val)
{
    if(stack == NULL)
        return 0;

    if(stack_is_empty(stack))
    {
        fprintf(stderr, "stack_pop: stack is empty\n");
        return 0;
    }

    stack->len--;

    if(val)
        *val = stack->buffer[stack->len];

    return 1;
}

int stack_push(Stack *stack, int val)
{
    if(stack == NULL)
        return 0;

    if(stack_is_full(stack))
    {
        fprintf(stderr, "stack_pop: stack is full\n");
        return 0;
    }

    stack->buffer[stack->len++] = val;
    return 1;
}

void stack_print(Stack *stack)
{
    if(stack == NULL)
    {
        puts("(null)");
        return;
    }

    printf("[ ");

    int i;
    // printing array backwards, the top first, the
    // last at the bottom
    for(i = stack->len - 1; i >= 0; --i)
        printf("%d%c ", stack->buffer[i], i ? ',': '\0');

    printf("]\n");

}

int main(void)
{
    Stack stack;

    stack_init(&stack);

    int top_val;

    if(stack_pop(&stack, &top_val))
        printf("top val: %d\n", top_val);


    stack_push(&stack, 1);
    stack_push(&stack, 2);
    stack_push(&stack, 3);
    stack_push(&stack, 4);

    if(stack_pop(&stack, &top_val))
        printf("top val: %d\n", top_val);

    stack_print(&stack);

    stack_push(&stack, 5);
    stack_push(&stack, 6);
    stack_push(&stack, 7);
    stack_push(&stack, 8);

    stack_print(&stack);

    if(stack_pop(&stack, &top_val))
        printf("top val: %d\n", top_val);

    stack_print(&stack);

    stack_push(&stack, 99);
    stack_push(&stack, 100);
    stack_push(&stack, 101);
    stack_push(&stack, 102);
    stack_push(&stack, 103);
    stack_push(&stack, 104);

    stack_print(&stack);

    for(int i = 0; i < 15; ++i)
        stack_pop(&stack, NULL); // ignoring the actual value

    stack_print(&stack);

    return 0;
}

这是一个非常基础的栈，显然可以改进。我正在尝试的重点要显示的是，通过将有关堆栈的所有信息封装在一个结构，很容易编写操作整个堆栈的函数，并且它是内部状态。在 main 中很容易使用堆栈，你可以如果您愿意，可以使用多个堆栈。

---

这是我的示例的输出:

stack_pop: stack is empty
top val: 4
[ 3, 2, 1 ]
[ 8, 7, 6, 5, 3, 2, 1 ]
top val: 8
[ 7, 6, 5, 3, 2, 1 ]
stack_pop: stack is full
stack_pop: stack is full
[ 102, 101, 100, 99, 7, 6, 5, 3, 2, 1 ]
stack_pop: stack is empty
stack_pop: stack is empty
stack_pop: stack is empty
stack_pop: stack is empty
stack_pop: stack is empty
[ ]