在C弹性缓冲区程序中添加printf触发GCC数组越界编译错误

我编写了一个基于弹性缓冲区思路的小型C程序，启用编译标志-Wall -Werror -Wpedantic测试。程序在Clang下编译运行无错误，但GCC出现异常行为。

#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>

typedef unsigned char uc;
typedef unsigned long ul;

typedef struct {
    ul len;
    ul capacity;
    uc* data;
} dyn_arr_hdr;

#define _dyn_arr_get_hdr_(buf) (dyn_arr_hdr*)((uc*)(buf) - 2 * sizeof(ul))

void* _dyn_array_expand_if_needed_(void* buf, ul elem_size) {
    dyn_arr_hdr* head = _dyn_arr_get_hdr_(buf);
    if(head->len * 2 <= head->capacity)
        return buf;
    // 取消此printf注释会触发GCC编译错误
    // printf("expanding...\n");
    ul new_cap = head->capacity * 2;
    ul new_size = elem_size * new_cap;
    head->data = realloc(head->data, new_size);
    head->capacity = new_cap;
    return head->data;
}

void* dyn_arr_init(void*buf, ul elem_size) {
    dyn_arr_hdr* head = malloc(sizeof(dyn_arr_hdr));
    head->len = 0;
    head->capacity = 4;
    head->data = malloc(head->capacity * elem_size);
    return head->data;
}

#define dyn_arr_size(buf) ((_dyn_arr_get_hdr_(buf))->len)

#define dyn_arr_push_back(buf, n) buf = _dyn_array_expand_if_needed_(buf, sizeof(*buf)); \
                                  buf[dyn_arr_size(buf)++] = (n)
int main(void) {
    int* v = NULL;
    printf("ptr=%p\n", (void*)v);
    v = dyn_arr_init(v, sizeof(int));
    printf("ptr=%p\n", (void*)v);
    
    dyn_arr_push_back(v, 42);
    dyn_arr_push_back(v, 43);
    dyn_arr_push_back(v, 44);
    dyn_arr_push_back(v, 45);
    dyn_arr_push_back(v, 46);
    dyn_arr_push_back(v, 47);
    dyn_arr_push_back(v, 48);
    dyn_arr_push_back(v, 49);

    for(ul i = 0; i < dyn_arr_size(v); ++i)
        printf("val=%d\n", v[i]);
    return dyn_arr_size(v);
}

原本该程序在GCC中可正常编译运行，但取消_dyn_array_expand_if_needed_函数中printf("expanding...\n");的注释后，GCC会在该printf上方的if语句处报数组越界错误。我确信代码存在问题但找不到原因。

注：该错误出现在GCC 13.2及GCC trunk版本中，取消上述printf注释即可复现。

GCC错误信息如下：

在函数'dyn_array_expand_if_needed'中，从main的第47行第5列内联展开：
第18行第12列：错误：数组下标0超出了'void[16]'的数组边界 [-Werror=array-bounds=]
18 | if(head->len * 2 <= head->capacity)
| ^
在函数'dyn_arr_init'中，从main的第44行第9列内联展开：
第33行第18列：注：在由malloc分配的大小为16的对象的偏移量-16处
33 | head->data = malloc(head->capacity * elem_size);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

问题本质：代码存在严重未定义行为 #

这个报错看起来诡异，但核心是你的弹性缓冲区设计完全错误：

• dyn_arr_init里分别用malloc分配了两个独立的内存块：一个存dyn_arr_hdr结构体，另一个存数据。但_dyn_arr_get_hdr_宏却假设数据指针往前偏移2个ul的位置就是头部结构体——这完全不成立，两个独立malloc的内存块在地址上没有任何关联，你通过偏移得到的指针指向的是随机内存区域，属于非法访问。
• 为什么没注释printf时GCC没报错？因为没有printf时，函数被完全内联，GCC的静态分析没触发；加上printf后，函数内联逻辑变化，分析器察觉到了非法指针访问，于是抛出了数组越界错误——这个错误其实是在提示你代码的根本性问题，只是报错信息的表述有点误导。

修复方案：把头部和数据区放在同一块内存 #

正确的弹性缓冲区应该将头部和数据存储在同一块连续内存中，这样通过数据指针偏移就能合法拿到头部。修复后的代码如下：

#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h> // 用于abort()

typedef unsigned char uc;
typedef unsigned long ul;

// 使用柔性数组成员，让头部和数据区连续存储
typedef struct {
    ul len;
    ul capacity;
    uc data[];
} dyn_arr_hdr;

// 用offsetof计算头部到数据区的偏移，替代硬编码，更健壮
#define _dyn_arr_get_hdr_(buf) (dyn_arr_hdr*)((uc*)(buf) - offsetof(dyn_arr_hdr, data))

void* _dyn_array_expand_if_needed_(void* buf, ul elem_size) {
    dyn_arr_hdr* head = _dyn_arr_get_hdr_(buf);
    if(head->len * 2 <= head->capacity)
        return buf;
    
    printf("expanding...\n");
    ul new_cap = head->capacity * 2;
    // 重新分配时要包含头部和新的数据区
    ul new_total_size = sizeof(dyn_arr_hdr) + new_cap * elem_size;
    head = realloc(head, new_total_size);
    if(!head) return NULL; // 处理内存分配失败
    
    head->capacity = new_cap;
    return head->data; // 返回更新后的数据区指针
}

void* dyn_arr_init(void*buf, ul elem_size) {
    ul initial_cap = 4;
    ul total_size = sizeof(dyn_arr_hdr) + initial_cap * elem_size;
    dyn_arr_hdr* head = malloc(total_size);
    if(!head) return NULL;
    
    head->len = 0;
    head->capacity = initial_cap;
    return head->data; // 返回数据区指针给用户
}

#define dyn_arr_size(buf) ((_dyn_arr_get_hdr_(buf))->len)

// 用do-while包裹宏，避免在分支语句中出现语法错误
#define dyn_arr_push_back(buf, n) do { \
    buf = _dyn_array_expand_if_needed_(buf, sizeof(*buf)); \
    if(!buf) abort(); /* 简单处理分配失败 */ \
    buf[(_dyn_arr_get_hdr_(buf))->len++] = (n); \
} while(0)

int main(void) {
    int* v = NULL;
    printf("ptr=%p\n", (void*)v);
    v = dyn_arr_init(v, sizeof(int));
    printf("ptr=%p\n", (void*)v);
    
    dyn_arr_push_back(v, 42);
    dyn_arr_push_back(v, 43);
    dyn_arr_push_back(v, 44);
    dyn_arr_push_back(v, 45);
    dyn_arr_push_back(v, 46);
    dyn_arr_push_back(v, 47);
    dyn_arr_push_back(v, 48);
    dyn_arr_push_back(v, 49);

    for(ul i = 0; i < dyn_arr_size(v); ++i)
        printf("val=%d\n", v[i]);
    
    // 释放时要释放整个缓冲区（头部指针），不能只free(v)
    free(_dyn_arr_get_hdr_(v));
    return dyn_arr_size(v);
}

关键修复点说明 #

1. 柔性数组成员：uc data[]让结构体的末尾直接跟着数据区，确保头部和数据在同一块内存中。
2. 合法指针偏移：用offsetof(dyn_arr_hdr, data)计算头部到数据区的偏移，避免硬编码，适配结构体的潜在变化。
3. 整体内存分配/重分配：分配和扩容时操作的是包含头部和数据区的整块内存，确保指针合法性。
4. 宏的健壮性：dyn_arr_push_back用do-while包裹，避免在if等分支中出现语法错误。
5. 内存释放：必须释放头部指针，不能只释放用户拿到的数据指针，否则会造成内存泄漏。

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