结构体成员void指针数组的访问、转换问题及代码错误排查

你的代码出现错误的核心原因是直接对void*类型指针进行数组下标运算和类型转换，这不符合C语言的语法规则，具体问题和修正方案如下：

错误原因拆解 #

1. void*无法直接做数组下标运算
   C语言中void是无类型，void*指向的内存没有明确的元素大小，编译器无法确定stack->st_base[i]需要跳过多少字节，因此会报「表达式必须是可修改的左值」错误。即便你在stack_init里把calloc的结果强转为int32_t*赋值给st_base，但st_base的类型仍是void*，编译器不会自动识别它实际指向的是int32_t数组。

2. 非法的类型转换
   在stack_pop中，你试图将void*下标访问的结果直接转为int32_t，但void*下标访问本身不合法，且得到的结果是void类型，无法直接转换为数值类型，因此触发「无效类型转换」错误。

3. 栈满/空判断逻辑错误
   原代码中stack->top >= (stack->size - 1)的判断有误：top从0开始计数，当top等于size时栈才真正存满，size-1会导致栈提前无法存入元素。

修正方案 #

根据你的需求，有两种修正方向：

方向1：仅支持int32_t类型的栈 #

如果你的栈只需要存储int32_t，直接把结构体中的st_base改为int32_t*即可，避免void*带来的类型问题：

typedef struct
{
    size_t size;
    size_t top;
    int32_t *st_base; // 替换void*为int32_t*
} stack_t;

dsa_err_t stack_init(stack_t *stack, uint32_t size)
{
    DSA_CHECK_ARG(stack);

    // calloc返回void*，可直接赋值给int32_t*，无需强制转换
    stack->st_base = calloc((size_t)size, sizeof(int32_t));
    if (!(stack->st_base))
    {
        return DSA_NO_MEM;
    }
    stack->top = 0;
    stack->size = size;
    return DSA_OK;
}

dsa_err_t stack_push(stack_t *stack, int32_t item)
{
    DSA_CHECK_ARG(stack && stack->st_base);

    // 栈满判断：top等于size时无法再存入
    if (stack->top >= stack->size)
    {
        return DSA_FAIL;
    }

    stack->st_base[(stack->top)++] = item;
    return DSA_OK;
}

dsa_err_t stack_pop(stack_t *stack, int32_t *item)
{
    // 新增对item非空的检查
    DSA_CHECK_ARG(stack && stack->st_base && item);

    // 栈空判断：top为0时无元素可弹出
    if (stack_is_empty(stack))
    {
        return DSA_FAIL;
    }
    stack->top--;
    *item = stack->st_base[stack->top];
    // 可选：清空弹出的元素
    stack->st_base[stack->top] = 0;
    return DSA_OK;
}

方向2：实现支持任意类型的通用栈 #

如果需要栈支持任意数据类型，需在结构体中记录每个元素的字节大小，通过指针偏移和memcpy来操作内存：

typedef struct
{
    size_t size;
    size_t top;
    size_t elem_size; // 新增：存储每个元素的字节数
    void *st_base;
} stack_t;

dsa_err_t stack_init(stack_t *stack, uint32_t size, size_t elem_size)
{
    DSA_CHECK_ARG(stack && elem_size > 0);

    stack->st_base = calloc((size_t)size, elem_size);
    if (!(stack->st_base))
    {
        return DSA_NO_MEM;
    }
    stack->top = 0;
    stack->size = size;
    stack->elem_size = elem_size;
    return DSA_OK;
}

dsa_err_t stack_push(stack_t *stack, const void *item)
{
    DSA_CHECK_ARG(stack && stack->st_base && item);

    if (stack->top >= stack->size)
    {
        return DSA_FAIL;
    }

    // 计算当前top位置的内存地址，用char*做偏移保证字节级准确
    void *dest = (char*)stack->st_base + stack->top * stack->elem_size;
    memcpy(dest, item, stack->elem_size);
    stack->top++;
    return DSA_OK;
}

dsa_err_t stack_pop(stack_t *stack, void *item)
{
    DSA_CHECK_ARG(stack && stack->st_base && item);

    if (stack_is_empty(stack))
    {
        return DSA_FAIL;
    }

    stack->top--;
    void *src = (char*)stack->st_base + stack->top * stack->elem_size;
    memcpy(item, src, stack->elem_size);
    // 可选：清空弹出位置的内存
    memset(src, 0, stack->elem_size);
    return DSA_OK;
}

通用栈的调用示例（存储int32_t）：

stack_t s;
stack_init(&s, 10, sizeof(int32_t));
int32_t val = 123;
stack_push(&s, &val);
int32_t out;
stack_pop(&s, &out);

内容的提问来源于stack exchange，提问作者horsemann07