当前位置：首页 > 编程日记 > 正文

【C++】对象实例化/成员函数/成员变量的内存管理

编程日记 2024-10-12 03:50:00

文章目录

- 1. 对象实例化的内存管理
- 总结
- 2.C++成员函数在内存中的存储方式
- 3.C++类的实例化对象的大小之sizeof()
- - 实例一：
  - 实例二：
  - 实例三：
  - 实例四：
  - 实例五：
  - 实例六：
  - 实例七：
  - 实例八：
  - 实例九：

1. 对象实例化的内存管理

解释：

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

总结

C++编译系统中，数据和函数是分开存放的(函数放在代码区；数据主要放在栈区和堆区，静态/全局区以及文字常量区也有)，实例化不同对象时，只给数据分配空间，各个对象调用函数时都都跳转到(内联函数例外)找到函数在代码区的入口执行，可以节省拷贝多份代码的空间
类的静态成员变量编译时被分配到静态/全局区，因此静态成员变量是属于类的，所有对象共用一份，不计入类的内存空间
**静态成员函数和非静态成员函数都是存放在代码区的，是属于类的，类可以直接调用静态成员函数，不可以直接调用非静态成员函数，两者主要的区别是有无this指针，**更加详细的解释后面专门写一篇文章
内联函数(声明和定义都要加inline)也是存放在代码区，内联函数在被调用时，编译器会用内联函数的代码替换掉函数，避免了函数跳转和保护现场的开销(实际上到底替不替换还要由编译器决定，即使声明为内联函数也有可能不替换，未声明成内联函数也有可能被编译器替换到调用位置，主要由编译器决定)，更详细的介绍后面也会专门写一篇文章

2.C++成员函数在内存中的存储方式

用类去定义对象时，系统会为每一个对象分配存储空间。如果一个类包括了数据和函数，要分别为数据和函数的代码分配存储空间。按理说，如果用同一个类定义了10个对象，那么就需要分别为10个对象的数据和函数代码分配存储单元，如下图所示。

能否只用一段空间来存放这个共同的函数代码段，在调用各对象的函数时，都去调用这个公用的函数代码。如下图所示。

显然，这样做会大大节约存储空间。C++编译系统正是这样做的，因此每个对象所占用的存储空间只是该对象的数据部分（虚函数指针和虚基类指针也属于数据部分）所占用的存储空间，而不包括函数代码所占用的存储空间。

看如下测试代码

class D  
{  
public:  void printA()  {  cout<<"printA"<<endl;  }  virtual void printB()  {  cout<<"printB"<<endl;  }  
};  int main(void)
{D *d=NULL;d->printA();d->printB();
}

问题：以上代码的输出结果是什么？

C++程序的内存格局通常分为四个区：全局数据区(data area)，代码区(code area)，栈区(stack area)，堆区(heap area)(即自由存储区)。全局数据区存放全局变量，静态数据和常量；所有类成员函数和非成员函数代码存放在代码区；为运行函数而分配的局部变量、函数参数、返回数据、返回地址等存放在栈区；余下的空间都被称为堆区。根据这个解释，我们可以得知在类的定义时，类成员函数是被放在代码区，而类的静态成员变量在类定义时就已经在全局数据区分配了内存，因而它是属于类的。对于非静态成员变量，我们是在类的实例化过程中(构造对象)才在栈区或者堆区为其分配内存，是为每个对象生成一个拷贝，所以它是属于对象的。

应当说明，常说的“某某对象的成员函数”，是从逻辑的角度而言的，而成员函数的存储方式，是从物理的角度而言的，二者是不矛盾的。

下面我们再来讨论下类的静态成员函数和非静态成员函数的区别：静态成员函数和非静态成员函数都是在类的定义时放在内存的代码区的，因而可以说它们都是属于类的，但是类为什么只能直接调用静态类成员函数，而非静态类成员函数(即使函数没有参数)只有类对象才能调用呢？

原因是类的非静态类成员函数其实都内含了一个指向类对象的指针型参数(即this指针)，因而只有类对象才能调用(此时this指针有实值)。

回答开头的问题，答案是输出“printA”后，程序崩溃。类中包括成员变量和成员函数。new出来的只是成员变量，成员函数始终存在，所以如果成员函数未使用任何成员变量的话，不管是不是static的，都能正常工作。需要注意的是，虽然调用不同对象的成员函数时都是执行同一段函数代码，但是执行结果一般是不相同的。不同的对象使用的是同一个函数代码段，它怎么能够分别对不同对象中的数据进行操作呢？原来C++为此专门设立了一个名为this的指针，用来指向不同的对象。

需要说明，不论成员函数在类内定义还是在类外定义，成员函数的代码段都用同一种方式存储。不要将成员函数的这种存储方式和inline(内联)函数的概念混淆。不要误以为用inline声明(或默认为inline)的成员函数，其代码段占用对象的存储空间，而不用inline声明的成员函数，其代码段不占用对象的存储空间。不论是否用inline声明(或默认为inline)，成员函数的代码段都不占用对象的存储空间。用inline声明的作用是在调用该函数时，将函数的代码段复制插人到函数调用点，而若不用inline声明，在调用该函数时，流程转去函数代码段的入口地址，在执行完该函数代码段后，流程返回函数调用点。inline与成员函数是否占用对象的存储空间无关，它们不属于同一个问題，不应搞混。

3.C++类的实例化对象的大小之sizeof()

总结一下，C++类的实例化对象的大小之sizeof()。

class D
{
public:D(){} virtual ~D(){}
private:int a ;char *p;
};

实例一：

class A
{
};A a;
cout << sizeof(a) << endl;

运行结果：1

解释：空类，没有任何成员变量或函数，即没有任何存储内容；但是由A a可知，空类仍然可以实例化。一个类能够实例化，编译器就需给它分配内存空间，来指示类实例的地址。**这里编译器默认分配了一个字节，以便标记可能初始化的类实例，同时使空类占用的空间最少（即1字节）。

实例二：

class B
{
private:int a;
};
B b;
cout << sizeof(b) << endl;

运行结果：4

解释：当类中有其它成员占据空间时，那一个字节就不算在内了，如本题：结果是4，而不是1+4=5。

实例三：

class BB
{
private:int a ;char b;
};
BB bb;
cout << sizeof(bb) << endl;

运行结果：8

解释：什么？怎么会是8？不应该是4 + 1 = 5吗？这里考察了对齐，涉及到编译器的优化。对于大多数CPU来说，CPU字长的整数倍操作起来更快，因此对于这些成员加起来不够这个整数倍，有可能编译器会插入多余的内容凑足这个整数倍；此外，有时候相邻的成员之间也有可能因为这个目的被插入空白，这个叫做“补齐”（padding）。所以，C++标准紧紧规定成员的排列按照类定义的顺序，但是不要求在存储器中是紧密排列的。因此，如上的一个字节的char在存储时被补全了，成为了4个字节。

实例四：

class C
{
private:int a ;char *p;
};
C c;
cout << sizeof(c) << endl;

运行结果：8

解释：一般情况下，如果是指针，则无论指针指向的是什么数据类型，都占4个字节的存储空间。

实例五：

class D
{
public:D(){}virtual ~D(){}private:int a ;char *p;
};
D d;
cout << sizeof(d) << endl;

运行结果：12

解释：考察虚函数。当类含有虚函数时，（不论是自己的虚函数，还是继承来的），那么类中就有一个成员变量信息：虚函数指针（4个字节），这个指针指向一个虚函数表，虚函数表的第一项是类的typeinfo信息，之后的项为此类的所有虚函数的地址。

更进一步的解释：当类中有虚函数的时候，编译器会为类建立一个表。这个表就是虚函数表，通过指向虚函数表的指针访问虚函数表。虚函数表就是为了保存类中的虚函数的地址。我们可以把虚函数表理解成一个数组，数组中的每个元素存放的就是类中虚函数的地址。当调用虚函数的时候，程序不是像普通函数那样直接跳到函数的代码处，而是先取出虚表指针即得到虚函数表的地址，根据这个来到虚函数表里，从这个表理取出该函数的指针，最后调用该函数。

实例六：

class E
{
public:E(){}virtual ~E(){}private:int a ;char *p;static int b;
};
E e;
cout << sizeof(e) << endl;

运行结果：12（4+4+4）

解释：考察静态成员变量的内存分配。由于静态成员变量是在静态存储区分配空间的，它不属于实例的一部分，因此类中的static成员变量不占据空间。

实例七：

class F:public E
{
public:F(){}~F(){}private:int c;
};
E e;
cout << sizeof(e) << endl;

运行结果：16（12+4）

解释：派生类对象的存储空间 = 基类存储空间 + 派生类特有的非static数据成员的空间

实例八：

class G: public virtual E
{
public:G(){}~G(){}private:int c;
};
G g;
cout << sizeof(g) << endl;

运行结果：20

解释：如果是虚继承的话，类对象的存储空间大小 = 基类的存储空间 + 派生类特有的非static数据成员的存储空间 + 每一个类的虚函数存储空间（这个是额外加的，即按照这个公式，sizeof(g) = 12(E基类的存储空间) + 4(G特有的非static数据成员的存储空间) + 4（E类的虚函数的存储空间，如果E类中有多个虚函数，只算一次））。

实例九：

class H: public virtual E
{
public:H(){}~H(){}virtual void GetValue(){}private:int c;
};
H h;
cout << sizeof(h) << endl;

运行结果：24

解释：对比实例八，按照上面的解释：类对象的存储空间大小 = 基类的存储空间 + 派生类特有的非static数据成员的存储空间 + 每一个类的虚函数存储空间（sizeof(h) = 12(E基类的存储空间) + 4(G特有的非static数据成员的存储空间) + 4（E类的虚函数的存储空间，如果E类中有多个虚函数，只算一次）+ 4（H类的虚函数的存储空间，如果H类中有多个虚函数，只算一次））。

如上，就是我对于这种类型的总结，这种问题只能出现一次！！！

https://www.dkcj.cn/info/22664.html