C++深度解析(40)—C++对象模型分析（上）

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/qq_22847457/article/details/96997344

1.回归本质

• class是一种特殊的结构体
  • 在内存中class依旧可以看作变量的集合
  • class与struct遵循相同的内存对齐规则
  • class中的成员函数与成员变量是分开存放的。即每个对象有独立的成员变量，但所有对象共享类中的成员函数。
• 编程实验——对象内存布局初探

 
 

   
   

    
    

   
   
   
   

    
    

     
     #include<iostream>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     using 
     
     namespace 
     
     std;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     class A 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int i;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int j;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     char c;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     double d;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     void print() 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     cout << 
     
     "i = " << i << 
     
     ", "
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     			<< 
     
     "j = " << j << 
     
     ", "
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     			<< 
     
     "c = " << c << 
     
     ", "
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     			<< 
     
     "d = " << d << 
     
     ", " << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     struct B 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int i;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int j;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     char c;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     double d;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int main() 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	A a;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "sizeof(A) = " << 
     
     sizeof(A) << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "sizeof(a) = " << 
     
     sizeof(a) << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "sizeof(B) = " << 
     
     sizeof(B) << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	a.print();
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	B *p = 
     
     reinterpret_cast<B *>(&a);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	p->i = 
     
     1;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	p->j = 
     
     2;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	p->c = 
     
     'c';
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	p->d = 
     
     3;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	a.print();
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	p->i = 
     
     100;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	p->j = 
     
     200;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	p->c = 
     
     'C';
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	p->d = 
     
     3.14;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	a.print();
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	system(
     
     "pause");
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

• 运行结果

2.C++对象模型分析

• 运行时的对象退化为结构体的形式
  • 所有成员变量在内存中依次排布
  • 成员变量间可能存在内存空隙
  • 可以通过内存地址直接访问成员变量
  •  访问权限关键字在运行时失效
• C++对象模型
  • 类中的成员函数位于代码段中
  • 调用成员函数时对象地址作为参数隐式传递（this关键字，对象的地址）
  • 成员函数通过对象地址访问成员变量
  • C++语法规则隐藏了对象地址的传递过程
• 编程实验——对象本质分析

 
 

   
   

    
    

   
   
   
   

    
    

     
     #include<iostream>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     using 
     
     namespace 
     
     std;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     class Demo 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int mi;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int mj;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Demo(
     
     int i, 
     
     int j) 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		mi = i;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		mj = j;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int getI() 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     return mi;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int getJ() 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     return mj;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int add(int value) 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     return mi + mj + value;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int main()
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     Demo d(1, 2);
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "sizeof(d) = " << 
     
     sizeof(d) << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "d.getI() = " << d.getI() << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "d.getJ() = " << d.getJ() << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "d.add() = " << d.add(
     
     3) << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	system(
     
     "pause");
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

• 运行结果：

• 打印结果和预料相同，但C++代码语法规则隐藏了成员函数的调用规则，因此采用C语言对本段代码重新进行编写

3.下面用C实现上面的面向对象程序

• test.h

 
 

   
   

    
    

   
   
   
   

    
    

     
     #ifndef _TEST_H_
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     #define _TEST_H_
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     typedef 
     
     void Demo;  
     
     // 进行了隐藏，和private的联系 仔细体会，模拟private,防止外界通过指针访问结构体里面的变量。 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     Demo *Demo_Create(int i, int j);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int Demo_GetI(Demo *pThis);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int Demo_GetJ(Demo *pThis);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int Demo_Add(Demo *pThis, int value);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     void Demo_free(Demo *pThis);
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     #endif
    
    
   
   
 
 

• test.c

 
 

   
   

    
    

   
   
   
   

    
    

     
     #include "test.h"
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     #include "malloc.h"
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     struct ClassDemo 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int mi;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int mj;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     Demo *Demo_Create(int i, int j) 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     struct ClassDemo *ret = (struct ClassDemo *)malloc(sizeof(struct ClassDemo));
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     if (ret != 
     
     NULL) 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		ret->mi = i;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		ret->mj = j;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return ret;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int Demo_GetI(Demo *pThis) 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     struct ClassDemo *obj = (struct ClassDemo *) pThis;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return obj->mi;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int Demo_GetJ(Demo *pThis) 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     struct ClassDemo *obj = (struct ClassDemo *) pThis;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return obj->mj;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int Demo_Add(Demo *pThis, int value) 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     struct ClassDemo *obj = (struct ClassDemo *)pThis;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return obj->mi + obj->mj + value;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     void Demo_free(Demo *pThis) 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     free(pThis);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

• main.c

 
 

   
   

    
    

   
   
   
   

    
    

     
     #include <stdio.h>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     #include "test.h"
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int main() 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Demo *d = Demo_Create(
     
     1, 
     
     2);
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     printf(
     
     "d.mi = %d\n", Demo_GetI(d));
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     printf(
     
     "d.mj = %d\n", Demo_GetJ(d));
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     printf(
     
     "Add(3) = %d\n", Demo_Add(d, 
     
     3));
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Demo_free(d);
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     //d->mi = 100;    //这个d只是void类型，mi相当于私有变量，不能直接通过this指针d来访问。
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	system(
     
     "pause");
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

• 运行结果：

4.小结

• C++中的类对象在内存布局上与结构体相同
• 成员变量和成员函数在内存中分开存放
• 访问权限关键字在运行时失效
• 调用成员函数时对象地址作为参数隐式传递

总结：注意因为要模拟数据私有性private，所以函数的参数应该用void，在函数内再具体操作数据。防止外界直接访问。