C++内存大小计算：指针、空类、虚函数与继承深度解析

核心结论与环境说明

测试环境：Linux 32位系统（指针大小为4字节）。

C/C++标准规定，sizeof运算符用于计算数据类型或变量在内存中占用的字节数。需要注意的是，指针本身的大小取决于平台架构（32位为4字节，64位通常为8字节），而指针所指向的内存容量无法直接通过sizeof获取，除非是在特定语境下（如数组名退化为指针前的原始数组）。

第1步：理解数组名与指针的sizeof差异

目的：明确数组名在特定上下文中的行为与普通指针的区别。

入口：定义字符数组与字符指针。

当我们将字符串字面量赋值给数组时，编译器会分配足够的空间容纳字符串及结尾的空字符'\0'。一旦数组名赋值给指针，该指针便失去了数组长度信息，仅作为地址存在。

int main()
{
    char q[] = "hello"; // 包含 'h','e','l','l','o','\0'，共6个字节
    std::cout << "q: " << sizeof(q) << std::endl; // 输出: 6

    char *mq = q;     // mq 是指针，仅存储地址
    std::cout << "mq: " << sizeof(mq) << std::endl; // 输出: 4 (32位系统)

    const char *p = "hello"; // p 也是指针
    std::cout << "p: " << sizeof(p) << std::endl; // 输出: 4 (32位系统)
}

第2步：分析类的内存构成要素

目的：探究数据成员、成员函数及特殊修饰符对对象大小的影响。

1. 空类的最小单位

即使类中没有定义任何成员，编译器也会为其实例分配至少1个字节的空间。这是为了确保每个不同的对象实例在内存中具有独一无二的地址。如果空类占用0字节，两个不同类型的空类对象可能共享相同地址，违反C++对象模型的基本假设。

class A
{
};

int main() {
    A a;
    std::cout << sizeof(a) << std::endl; // 输出: 1
}

2. 纯数据成员的分配

类的对象大小通常等于其非静态数据成员大小的总和。普通成员函数、构造函数等属于代码段，不占用对象实例的内存空间。

class A
{
public:
    int val; // 4字节
};

int main() {
    A a;
    std::cout << sizeof(a) << std::endl; // 输出: 4
}

3. 引入构造函数的影响

即使添加了构造函数初始化列表，只要没有增加新的数据成员，对象大小依然保持不变。这是因为函数代码存储在只读的数据段/代码段中，而非栈上的对象实例里。

class A
{
public:
    int val;
    A(int value) : val(value) {} // 构造函数不占对象内存
};

int main() {
    A a(3);
    std::cout << sizeof(a) << std::endl; // 输出: 4
}

4. 静态成员变量的存储位置

静态成员变量不属于类的某个特定实例，而是存储在静态数据区，所有对象共享同一份副本。因此，静态成员变量不计入sizeof的计算结果中。

class A
{
public:
    int val;
    static int sta_val; // 存放在静态区，不计入对象大小
};
int A::sta_val = 3;

int main() {
    A a(3);
    std::cout << sizeof(a) << std::endl; // 输出: 4
}

5. 虚函数带来的开销

当一个类声明了虚函数（virtual function），编译器会在对象中隐含地添加一个虚函数表指针（vptr）。在32位系统中，该指针占用4字节。无论类中包含多少个虚函数，通常只会有一个vptr（除非涉及多重继承）。

class A
{
public:
    int val;       // 4字节
    virtual void func(); // 引入vptr，+4字节
};

int main() {
    A a;
    std::cout << sizeof(a) << std::endl; // 输出: 8
}

第3步：理解继承关系中的内存叠加

目的：观察父类成员如何贡献到子类的总内存占用中。

1. 无虚函数的普通继承

子类对象包含父类的所有非私有成员变量以及自身定义的成员变量。内存是简单累加的。

class Base {
public:
    int val; // 4字节
};

class Derived : public Base {
public:
    int valb; // 4字节
};

int main() {
    Derived d;
    std::cout << sizeof(d) << std::endl; // 输出: 8 (Base::val + Derived::valb)
}

2. 含有虚函数的继承叠加

若父类包含虚函数，子类对象将继承父类的vptr，并加上父类和子类各自的数据成员。这解释了为什么在某些情况下，简单的继承会导致对象大小显著增加。

class Base {
public:
    int val;           // 4字节
    virtual void func(); // vptr, 4字节
};

class Derived : public Base {
public:
    int valb; // 4字节
};

int main() {
    Derived d;
    // Base部分: val(4) + vptr(4) = 8字节
    // Derived部分: valb(4)
    // 总计: 12字节
    std::cout << sizeof(d) << std::endl; // 输出: 12
}

总结与注意事项

• 平台依赖：以上示例基于32位Linux环境。在64位系统中，指针和vptr通常变为8字节，需重新评估数值。
• 内存对齐：实际开发中，编译器可能会进行内存对齐（Padding），导致对象大小大于各成员之和。虽然上述简单示例未触发对齐填充，但在复杂结构体中需特别注意。
• 性能权衡：引入虚函数支持多态，代价是每个对象增加4~8字节的开销及间接调用指令，需在灵活性与资源消耗间取得平衡。

以上就是C/C++内存分配大小实例讲解的详细内容，更多关于C++内存布局与sizeof用法的资料请关注本站其它相关文章！