解决C语言realloc报错：expression must have arithmetic type的内存重分配问题

问题描述 #

尝试为molecule->atoms数组和molecule->atom_ptrs指针数组重新分配内存，这两个数组已通过molmalloc函数完成初始malloc分配，但运行时触发报错：Can't use realloc because expression must have arithmetic type。

待排查函数 #

void molappend_atom(molecule *molecule, atom *atom)
{
   // 检查是否已达到原子最大容量
    if (molecule->atom_no == molecule->atom_max) {
        // 若atom_max不为0，则将其翻倍
        if (molecule->atom_max != 0) {
            molecule->atom_max *= 2;
        }
        // 若atom_max为0，则设置为1
        else {
            molecule->atom_max = 1;
        }
        // 重新分配atoms数组内存
        molecule->atoms = (atom *) realloc(molecule->atoms, sizeof(atom) * molecule->atom_max);
        // 重新分配atom_ptrs数组内存
        molecule->atom_ptrs = (atom **) realloc(molecule->atom_ptrs, sizeof(atom *) * molecule->atom_max);
    }
    // 将输入atom的数据复制到atoms数组的下一个空位
    molecule->atoms[molecule->atom_no] = *atom;
    // 设置atom_ptrs数组中对应的指针指向新增的atom
    molecule->atom_ptrs[molecule->atom_no] = &molecule->atoms[molecule->atom_no];
    // 递增atom_no计数器
    molecule->atom_no++;
}

结构体定义 #

typedef struct atom
{
char element[3];
double x, y, z;
} atom;

typedef struct bond
{
atom *a1, *a2;
unsigned char epairs;
} bond;

typedef struct molecule
{
unsigned short atom_max, atom_no;
atom *atoms, **atom_ptrs;
unsigned short bond_max, bond_no;
bond *bonds, **bond_ptrs;
} molecule;

数组初始化函数 #

molecule *molmalloc(unsigned short atom_max, unsigned short bond_max)
{
    molecule *mol = (molecule *)malloc(sizeof(molecule));       // 为molecule结构体分配内存
    if (mol == NULL) 
    {      // 检查内存分配是否失败
        return NULL;        // malloc失败
    }

    mol->atom_max = atom_max;       // 将结构体中的atom_max设为参数指定的值
    mol->atom_no = 0;       // 将结构体中的atom_no设为0
    
    mol->atoms = (atom *)malloc(sizeof(atom) * atom_max);       // 为atoms数组分配内存，容纳atom_max个atom
    if (mol->atoms == NULL) 
    {      // 检查内存分配是否失败
        free(mol);      // 释放mol结构体，避免内存泄漏
        return NULL;        // malloc失败
    }

    mol->atom_ptrs = (atom **)malloc(sizeof(atom *) * atom_max);        // 为atom_ptrs数组分配内存
    if (mol->atom_ptrs == NULL) 
    {      // 检查内存分配是否失败
        free(mol->atoms);       // 先释放结构体中的数组，再释放结构体，确保所有内存都被释放
        free(mol);      // 释放mol结构体
        return NULL;        // malloc失败
    }

    mol->bond_max = bond_max;       // 将结构体中的bond_max设为参数指定的值
    mol->bond_no = 0;       // 将结构体中的bond_no设为0

    mol->bonds = (bond *)malloc(sizeof(bond) * bond_max);       // 为bonds数组分配内存，容纳bond_max个bond
    if (mol->bonds == NULL) 
    {       // 检查内存分配是否失败
        free(mol->atoms);       // 释放结构体中所有已分配的内存，避免内存泄漏
        free(mol->atom_ptrs);   
        free(mol);              
        return NULL;        // malloc失败
    }
    mol->bond_ptrs = (bond **)malloc(sizeof(bond *) * bond_max);        // 为bond_ptrs数组分配内存（注意是**）
    if (mol->bond_ptrs == NULL) 
    {       // 检查内存分配是否失败
        free(mol->atoms);       // 释放结构体中所有已分配的内存，避免内存泄漏
        free(mol->atom_ptrs);
        free(mol->bonds);
        free(mol);
        return NULL;        // malloc失败
    }

    return mol;     // 返回molecule结构体的内存地址
}

错误原因分析 #

核心问题是函数参数名与结构体类型名重名：
在molappend_atom函数中，参数molecule *molecule的变量名molecule和typedef定义的结构体类型名molecule完全一致。编译器会将代码中的molecule->atoms误解为对类型molecule进行成员访问，而类型不是可操作的变量（算术类型），因此触发报错。

修复方案 #

修改函数参数的变量名，避免与结构体类型名冲突，比如将参数名改为mol：

void molappend_atom(molecule *mol, atom *atom)
{
   // 检查是否已达到原子最大容量
    if (mol->atom_no == mol->atom_max) {
        // 若atom_max不为0，则将其翻倍
        if (mol->atom_max != 0) {
            mol->atom_max *= 2;
        }
        // 若atom_max为0，则设置为1
        else {
            mol->atom_max = 1;
        }
        // 重新分配atoms数组内存
        mol->atoms = (atom *) realloc(mol->atoms, sizeof(atom) * mol->atom_max);
        // 重新分配atom_ptrs数组内存
        mol->atom_ptrs = (atom **) realloc(mol->atom_ptrs, sizeof(atom *) * mol->atom_max);
    }
    // 将输入atom的数据复制到atoms数组的下一个空位
    mol->atoms[mol->atom_no] = *atom;
    // 设置atom_ptrs数组中对应的指针指向新增的atom
    mol->atom_ptrs[mol->atom_no] = &mol->atoms[mol->atom_no];
    // 递增atom_no计数器
    mol->atom_no++;
}

额外优化建议 #

1. 检查realloc返回值：realloc可能分配失败返回NULL，直接赋值会丢失原内存地址，导致内存泄漏。建议先用临时变量接收返回值，检查成功后再赋值：

atom *new_atoms = (atom *)realloc(mol->atoms, sizeof(atom) * mol->atom_max);
if (new_atoms == NULL) {
    // 处理分配失败逻辑，比如返回错误或终止程序
    return;
}
mol->atoms = new_atoms;

atom **new_atom_ptrs = (atom **)realloc(mol->atom_ptrs, sizeof(atom *) * mol->atom_max);
if (new_atom_ptrs == NULL) {
    // 处理失败逻辑
    return;
}
mol->atom_ptrs = new_atom_ptrs;

2. 避免重复类型转换：在C语言中，malloc/realloc的返回值可以直接赋值给指针类型，不需要强制转换（强制转换可能隐藏潜在的类型不匹配问题）。

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