C++中类所占的内存大小以及成员函数的存储位置

SOC罗三炮

已于 2023-08-07 21:58:12 修改

阅读量1.6w

点赞数 72

CC 4.0 BY-SA版权

分类专栏： CPP 文章标签： c++

于 2020-12-06 16:36:10 首次发布

本文链接：https://blog.youkuaiyun.com/luolaihua2018/article/details/110736211

CPP 专栏收录该内容

67 篇文章

订阅专栏

类所占内存的大小是由成员变量（静态变量除外）决定的，虚函数指针和虚基类指针也属于数据部分，成员函数是不计算在内的。因为在编译器处理后，成员变量和成员函数是分离的。成员函数还是以一般的函数一样的存在。a.fun()是通过fun(a.this)来调用的。所谓成员函数只是在名义上是类里的。
其实成员函数的大小不在类的对象里面，同一个类的多个对象共享函数代码。
普通函数：属于全局函数，不受具体类和对象的限制，可以直接调用。
C++ 普通成员函数本质上是一个包含隐式形参（this指针）的普通函数，成员函数的地址，在编译期就已确定。对象调用成员函数时，编译器可以确定这些函数的地址，并通过传入this指针和其他参数，完成函数的调用，所以类中就没有必要存储成员函数的信息。
比如：A.test() ，A对象调用其成员函数test()。事实上可以理解成 test(&A)。
实际上，编译器把普通成员函数当成全局函数来调用，只不过增加了一个叫this的形参，指向的其实就是生成的对象，用来建立对象和成员函数之间的联系。

class CBase 
{ 
}; 
// 32-bit: sizeof(CBase)=1；
// 64-bit: sizeof(CBase)=1；

为什么空的什么都没有是1呢？
c++要求每个实例在内存中都有独一无二的地址。空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1。

class CBase 
{ 
    int a; 
    char p; 
}; 
// 32-bit: sizeof(CBase)=8；
// 64-bit: sizeof(CBase)=8；

字节对齐的问题。int 占4字节
char占一字节，补齐3字节

class CBase 
{ 
public: 
    CBase(void); 
    virtual ~CBase(void); 
private: 
    int  a; 
    char *p; 
}; 
// 32-bit: sizeof(CBase)=12；
// 64-bit: sizeof(CBase)=24；

C++ 类中有虚函数的时候有一个指向虚函数表的指针（vptr），在32位系统分配指针大小为4字节,在64位系统分配指针大小为8字节。无论多少个虚函数，只有这一个指针，大小为4字节或者8字节。
//注意一般的函数是没有这个指针的，而且也不占类的内存。

class CChild : public CBase 
{ 
public: 
    CChild(void); 
    ~CChild(void); 
    virtual void test();
private: 
    int b; 
}; 
// 32-bit: sizeof(CChild)=16；
// 64-bit: sizeof(CChild)=32；

可见子类的大小是本身成员变量的大小加上父类的大小。

class A {};    // sizeof(A)=1
 
class B{};     // sizeof(B)=1 
 
class C:public A{
    virtual void fun()=0;
};             // sizeof(C)=4     
  
class D:public B,public C{};  
// 32-bit: sizeof(C)=sizeof(D)=4；
// 64-bit: sizeof(C)=sizeof(D)=8；

C和D中只有一个指向虚函数表的指针，其大小为4字节（32-bit)或者8字节（64-bit）。

// ====== 测试一 ======
class Test {
private:
    int n;
    char c;
    short s;
};

Test t21;
cout << sizeof(t21) << endl;
// 运行结果：8

// ====== 测试二 ======
class Test {
public:
	//构造函数
    Test() {

    }
	//普通成员
    int func0() {
        return n;
    }
	//友元函数
    friend int func1();
	//常成员函数
    int func2() const {
        return s;
    }
	//内联函数
    inline void func3() {
        cout << "inline function" << endl;
    }
	//静态成员函数
    static void func4() {
        cout << "static function" << endl;
    }
	//析构函数
    ~Test() {

    }

private:
    int n;
    char c;
    short s;
};

int func1() {
    Test t;
    return t.c;
}

Test t22;
cout << sizeof(t22) << endl;
// 运行结果：8

// ====== 测试三 ======
class Test {
public:
    Test() {

    }

    int func0() {
        return n;
    }

    friend int func1();

    int func2() const {
        return s;
    }

    inline void func3() {
        cout << "inline function" << endl;
    }

    static void func4() {
        cout << "static function" << endl;
    }
	//虚函数，需要一个虚函数指针的开销
    virtual void func5() {
        cout << "virtual function" << endl;
    }

    ~Test() {

    }

private:
    int n;
    char c;
    short s;
};

int func1() {
    Test t;
    return t.c;
}

Test t23;
cout << sizeof(t23) << endl;
// x86目标平台运行结果：12；x64目标平台下运行结果：16

因 C++中成员函数和非成员函数都是存放在代码区的，故类中一般成员函数、友元函数，内联函数还是静态成员函数都不计入类的内存空间，测试一和测试二对比可证明这一点
测试三中，因出现了虚函数，故类要维护一个指向虚函数表的指针，分别在 x86目标平台和x64目标平台下编译运行的结果可证明这一点

总结

空的类是会占用内存空间的，而且大小是1，原因是C++要求每个实例在内存中都有独一无二的地址。
类内部的成员变量：
普通的变量：是要占用内存的，但是要注意对齐原则（这点和struct类型很相似）。
static修饰的静态变量：不占用内容，原因是编译器将其放在全局变量区。
类内部的成员函数：
普通函数：不占用内存。
虚函数：要占用4个字节（32位系统）或8个字节（64位系统），用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的，和虚函数的个数是没有关系的。
C++编译系统中，数据和函数是分开存放的(函数放在代码区；数据主要放在栈区或堆区，静态/全局区以及文字常量区也有)，实例化不同对象时，只给数据分配空间，各个对象调用函数时都都跳转到(内联函数例外)找到函数在代码区的入口执行，可以节省拷贝多份代码的空间
数据主要放在栈区或堆区，有可能是堆，也有可能是栈。这取决于实例化对象的方式：
- A a1 = new A(); //堆
- A a2; //栈
类的静态成员变量编译时被分配到静态/全局区，因此静态成员变量是属于类的，所有对象共用一份，不计入类的内存空间。
内联函数(声明和定义都要加inline)也是存放在代码区，在编译阶段，编译器会用内联函数的代码替换掉函数，避免了函数跳转和保护现场的开销。不要将成员函数的这种存储方式和inline(内联)函数的概念混淆。不要误以为用inline声明(或默认为inline)的成员函数，其代码段占用对象的存储空间，而不用inline声明的成员函数，其代码段不占用对象的存储空间。不论是否用inline声明(或默认为inline)，成员函数的代码段都不占用对象的存储空间。用inline声明的作用是在编译时期，将函数的代码段复制插人到函数调用点，而若不用inline声明，在调用该函数时，流程转去函数代码段的入口地址，在执行完该函数代码段后，流程返回函数调用点。inline与成员函数是否占用对象的存储空间无关