C++深度解析 C++对象模型分析（上） --- 成员变量和成员函数在内存中分开存放（49）

本文链接：https://blog.csdn.net/xiaodingqq/article/details/86063248

C++深度解析 C++对象模型分析（上） --- 成员变量和成员函数在内存中分开存放（49）

对象模型

问题：类对象的成员变量和成员函数，在内存是如何分布的？？

class和struct区别

class是一种特殊的struct。
在内存中class依旧可以看作变量的集合。
class与struct遵循相同的内存对齐规则。
class中的成员函数与成员变量是分开存放的。

每个对象有独立的成员变量。

所有对象共享类中的成员函数。

class默认访问权限为private

struct默认访问权限为public

示例程序一：（对象内存布局初探）

#include <iostream>
#include <string>

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;      //4
    int j;      //4
    char c;     //因为内存对齐，4
    double d;   //8
};

int main()
{
    A a;
    
    cout << "sizeof(A) = " << sizeof(A) << endl;    //20bytes
    cout << "sizeof(a) = " << sizeof(a) << endl;    
    cout << "sizeof(B) = " << sizeof(B) << endl;    //20bytes
    
    a.print();

    //指针类型间的强制转换reinterpret_cast
    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();

    return 0;
}

结果如下：

C++对象模型分析

运行时的对象退化为结构体的形式

所有成员变量在内存中依次排布
成员变量间可能存在内存空隙
可以通过内存地址直接访问成员变量
访问权限关键字在运行时失效

类中的成员函数位于代码段中

调用成员函数时对象地址作为参数隐式传递

成员函数通过对象地址访问成员变量

C++语法规则隐藏了对象地址的传递过程

示例程序二：（对象本质分析）

#include <iostream>
#include <string>

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;    //8 bytes
    cout << "d.getI() = " << d.getI() << endl;      //1
    cout << "d.getJ() = " << d.getJ() << endl;      //2
    cout << "d.add(3) = " << d.add(3) << endl;      //6
    
    return 0;
}

结果如下：

类的成员变量和成员函数，在内存是分开存放的

示例程序三：（使用C语言完成上面的程序）

50-2.h

#ifndef _50_2_H_
#define _50_2_H_

//类类型
typedef void Demo;

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

50-2.c

#include "50-2.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 "50-2.h"

int main()
{
    Demo* d = Demo_Create(1, 2);    //Demo *d = new Demo(1, 2);
    
    printf("d.mi = %d\n", Demo_GetI(d)); //d->getI()
    printf("d.mj = %d\n", Demo_GetJ(d)); //d->getJ()
    printf("Add(3) = %d\n", Demo_Add(d, 3)); //d->add(3)

    //d->mi = 100;  //私有成员
    
    Demo_Free(d);
    
    return 0;
}

结果如下：