动态分配内存到我的堆栈（仅在需要时）

Question

我需要为我的结构内的一个数组分配内存，这个数组在我定义结构时没有定义的大小：

typedef struct stacks {
    int size; // Stores the size of my -values- array
    int sp; //points to the top of the stack, my stackpointer
    int *values;
} STACKS;

所以，为了初始化我的结构，我编写了这个函数，它为我的数组分配（使用 calloc？）内存，然后我将数组的新大小放入 SIZE 变量中。

#define MAXIMUM 10

int initStacks(STACKS *s){
    s->values = calloc(MAXIMUM,sizeof(int));
    s->size = MAXIMUM;
    s->sp = 0;
    return 0;
}

现在，如果我想将某些东西推到堆栈顶部（LIFO），我会使用这个：

int pushs(STACKS *s, int x){
    if (s->sp==s->size) {
        realloc(s->values, MAXIMUM * sizeof(int));
        s->size*=2;
    }

    s->values[s->sp]=x;
    s->sp++;
}

这是正确的做法吗？

realloc 在我的函数中是否正常工作？

非常感谢您的帮助！

编辑：

这会更有意义吗？这样，我真的不需要声明数组的值，即用#define maximum 10 定义的值

typedef struct stacks {
    int size; // guarda o tamanho do array valores
    int sp;
    int *values;
} STACKS;


int initStacks(STACKS *s){
    s->values = calloc(1,sizeof(int));
    s->size = 1;
    s->sp = 0;
    return 0;
}

int isEmptys(STACKS *s){
    return((s->sp)==0);
}

int pushs(STACKS *s, int x){
    s->size++;
    realloc(s->values, s->size * sizeof(int));
    s->values[s->sp]=x;
    s->sp++;
}

Answer 1

假设您有一个原始尺寸因子（名称 capacity 将是适当的，如果不是更多的话），您的原始代码缺少几件事：

• 将大小与常数进行比较，而不是将当前 sp 与堆栈当前大小进行比较。
• 不保存也不测试realloc的返回结果
• 实际上并没有将分配加倍（您在 realloc 表达式中缺少 2x。
• 声明int返回结果，但不存在这样的返回。
• 无法将推送结果（成功与否）反馈给调用者。顺便说一句，缺少的返回结果将是理想的选择。

解决所有这些问题：

int pushs(STACKS *s, int x)
{
    if (s->sp == s->size) 
    {
        void *pv = realloc(s->values, 2 * s->size * sizeof *(s->values));
        if (pv != NULL)
        {
            s->values = pv;
            s->size *= 2;
        }
        else
        {
            fprintf(stderr, "Failed to resize stack\n");
            return -1;
        }
    }

    s->values[s->sp++] = x;
    return 0;
}

未经测试，但希望足够接近。

祝你好运

Answer 2

虽然不是对实际问题的直接回答，而是对一般问题的更多回答，但我将其发布，因为它不适合评论。

如果您预计会有过多的 push/pop 操作和内存使用，以下可能是替代方案：

typedef struct SubStack_s {
    struct SubStack_s *prev;
    int data[ENTRIES_PER_SEGMENT];
} SubStack;

typedef struct {
    SubStack *tos;    // init to NULL
    size_t sp;        // init to 0
} Stack;

基本思想是将元素推入每个子堆栈直到填满（就像您已经做的那样）。如果当前已满，则分配一个新的，链接它们（new->prev = old）并继续使用新的（将new 存储到Stack.tos）

Pop 的工作方式类似，一旦不再使用，就会释放每个子堆栈。

这个概念被称为“碎片堆栈”。它比 realloc 方法更有效（它避免了复制），并且不会将 RAM 碎片化，因为所有块的大小都相同。哦，它允许有指向堆栈的指针，而 realloc-variint 不允许，因为堆栈的地址可以改变。