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

Love The Way You Lie 2022-12-26 15:30 181阅读 0赞

**类所占内存的大小是由成员变量（静态变量除外）决定的，虚函数指针和虚基类指针也属于数据部分，成员函数是不计算在内的。因为在编译器处理后，成员变量和成员函数是分离的**。成员函数还是以一般的函数一样的存在。a.fun()是通过fun(a.this)来调用的。所谓成员函数只是在名义上是类里的。  
**其实成员函数的大小不在类的对象里面，同一个类的多个对象共享函数代码**。  
而我们访问类的成员函数是通过类里面的一个指针实现，而这个指针指向的是一个table，table里面记录的各个成员函数的地址（当然不同的编译可能略有不同的实现）。所以我们访问成员函数是间接获得地址的。所以这样也就增加了一定的时间开销，这也就是为什么我们提倡把一些简短的，调用频率高的函数声明为inline形式（内联函数）。

class CBase 
    {
         
    }; 
    // sizeof(CBase)=1；

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

class CBase 
    {
         
        int a; 
        char p; 
    }; 
    // sizeof(CBase)=8;

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

class CBase 
    {
         
    public: 
        CBase(void); 
        virtual ~CBase(void); 
    private: 
        int  a; 
        char *p; 
    }; 
    // sizeof(CBase)=12

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

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

可见子类的大小是本身成员变量的大小加上父类的大小。  
//其中有一部分是虚拟函数表的原因，一定要知道父类子类共享一个虚函数指针

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{
        };   // sizeof(D)=8

类D的大小更让人疑惑吧，类D是由类B，C派生过来的，它的大小应该为二者之和5，为什么却是8 呢？这是因为为了提高实例在内存中的存取效率。类的大小往往被调整到系统的整数倍。并采取就近的法则，距离哪个最近的倍数，就是该类的大小，所以类D的大小为8个字节。

// ====== 测试一 ======
    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++编译系统中，数据和函数是分开存放的(**函数放在代码区**；数据主要放在栈区和堆区，静态/全局区以及文字常量区也有)，实例化不同对象时，只给数据分配空间，各个对象调用函数时都都跳转到(内联函数例外)找到函数在代码区的入口执行，可以节省拷贝多份代码的空间
 *  类的静态成员变量编译时被分配到静态/全局区，因此静态成员变量是属于类的，所有对象共用一份，不计入类的内存空间。
 *  **内联函数(声明和定义都要加inline)也是存放在代码区**，内联函数在被**调用**时，编译器会用内联函数的代码替换掉函数，避免了函数跳转和保护现场的开销。不要将成员函数的这种存储方式和inline(内联)函数的概念混淆。不要误以为用inline声明(或默认为inline)的成员函数，其代码段占用对象的存储空间，而不用inline声明的成员函数，其代码段不占用对象的存储空间。不论是否用inline声明(或默认为inline)，成员函数的代码段都不占用对象的存储空间。用inline声明的作用**是在调用该函数时，将函数的代码段复制插人到函数调用点**，而若不用inline声明，在调用该函数时，流程转去函数代码段的入口地址，在执行完该函数代码段后，流程返回函数调用点。inline与成员函数是否占用对象的存储空间无关

**综上所述**

*  同一个类创建的多个对象，其数据成员是各用各的，互不相通（静态成员变量是共享的）。
 *  成员函数是共享共用的，多个对象共用一份代码，**所有类成员函数和非成员函数代码存放在代码区**。
 *  不论成员函数在类内定义还是在类外定义，成员函数的代码段都用同一种方式存储。
 *

![在这里插入图片描述][20201206162333512.png_pic_center]  
参考链接：  
[C++成员函数在内存中的存储方式][C]  
[C++ 类在内存中的存储方式][C_]

[20201206162333512.png_pic_center]: /images/20221120/cc1d572a8a5a48968d8721b5575831d9.png
[C]: https://blog.csdn.net/fuzhongmin05/article/details/59112081
[C_]: https://zhuanlan.zhihu.com/p/103384358