50-C++对象模型分析（上）

注：博客中内容主要来自《狄泰软件学院》，博客仅当私人笔记使用。

测试环境：Ubuntu 10.10

GCC版本：9.2.0

 

一、回归本质

1）class是一种特殊的struct

    -    在内存中class依旧可以看作变量的集合

    -    class与struct遵循相同的内存对齐规则

    -    class中的成员函数与成员变量是分开存放的

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

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

 

2）值得思考的问题

 

编程实验
对象内存布局初探
50-1.cpp
#include <iostream>
#include <string>

using namespace std;

class A       //大小
{
    int i;    //4
    int j;    //4
    char c;   //1 + 3(补3)
    double d; //8
public:
    void print()
    {
        cout << "i = " << i << ", "
             << "j = " << j << ", "
             << "c = " << c << ", "
             << "d = " << d << endl;
    }
};

struct B       //大小
{
    int i;     //4
    int j;     //4
    char c;    //1 + 3(补3)
    double d;  //8
};

int main()
{
    A a;
    
    cout << "sizeof(A) = " << sizeof(A) << endl;    // 20 bytes
    cout << "sizeof(a) = " << sizeof(a) << endl;
    cout << "sizeof(B) = " << sizeof(B) << endl;    // 20 bytes
    
    a.print();
    //p指向了a的地址
    B* p = reinterpret_cast<B*>(&a);    //a不是整数。&a变成地址后进行类型转换
    /*
    reinterpret_cast强制类型转换 
    用于指针类型间的强制转换
       用于整数和指针类型间的强制转换(类指针也是指针)
    */
    
    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;
}

操作：

1) g++ 50-1.cpp -o 50-1.out编译正确，打印结果：

sizeof(A) = 20
sizeof(B) = 20
sizeof(B) = 20
i = -1220045651, j = -1218501692, c = , d = -5.58277e-42(未初始化打印随机值)
i = 1, j = 2, c = c, d = 3
i = 100, j = 200, c = C, d = 3.14

分析：

        用struct B类型指针p指向类A强制转换成B。通过指针p给变量i,j,c,d等赋初始值。然后访问a对象的print打印成员数值。通过打印变量可以知道，修改内存成功。证明：class退化成了struct，他们内存布局一样。

 

二、C++对象模型分析

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

        -    所有成员变量在内存中依次排布

        -    成员变量间可能存在内存空隙（内存对齐造成）

        -    可以通过内存地址直接访问成员变量

        -    访问权限关键字在运行时失效（编译阶段才对语法进行校验）

 

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

3）调用成员函数时对象地址作为参数隐式传递(成员函数有this指针，静态成员函数没有)  

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

5）C++语法规则隐藏了对象地址的传递过程  (this指针，只能在普通成员函数内部使用，表示当前对象；静态成员函数没有这个指针)

 

编程实验
对象本质分析
50-2.cpp
#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;
}

操作：

1) g++ 50-2.cpp -o 50-2.out编译正确，打印结果：

sizeof(d) = 8
d.getI() = 1
d.getJ() = 2
d.add(3) = 6

分析：

        sizeof(d) = 8 ——>Demo成员变量有2个int，32位机占8字节。

#ifndef _50_2_H_
#define _50_2_H_

typedef void Demo;  //模拟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

#include "50-2.h"
#include "malloc.h"

struct ClassDemo
{
    int mi;
    int mj;
};

Demo* Demo_Create(int i, int j)  //Demo*==> void* 万能类型，可以随意转换
{
    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);
}

#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是void类型，void类型指针不能访问其他内容
    
    Demo_Free(d);
    
    return 0;
}

操作：

1) g++ 50-2.c main.c -o 50-2.out编译正确，打印结果：

d.mi = 1
d.mj = 2    
Add(3) = 6    

分析：

        通过void*指针实现数据封装(没办法通过void*指针访问其它内容，使用前必须强制转换)。

 

小结

1）C++中的类对象在内存布局上与结构体相同

2）成员变量和成员函数在内存中分开存放

3）访问权限关键字在运行时失效  （编译阶段才会检查错误）

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