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

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

回归本质

• class是一种特殊的struct

  • 在内存中class依旧可以看作变量的集合
  • class与struct遵循相同的内存对齐规则
  • class中的成员函数与成员变量是分开存放的
    • 每个对象有独立的成员变量
    • 所有对象共享类中的成员函数

• 值得思考的问题

class A
{
    int i;
    int j;
    char c;
    double d;
}
sizeof(A) = ?

struct B
{
    int i;
    int j;
    char c;
    double d;
}
sizeof(B) = ?

//50-1.cpp
#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;     //1+3
    double d;   //8
};

int main()
{
    A a;

    cout << "sizeof(int) = " << sizeof(int) << endl;
    cout << "sizeof(char) = " << sizeof(char) << endl;
    cout << "sizeof(double) = " << sizeof(double) << endl;
    
    a.print();

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

    p->i = 1;
    p->j = 2;
    p->c = 'c';
    p->d = 4;

    a.print();

    p->i = 100;
    p->j = 101;
    p->c = 'f';
    p->d = 1000.11;

    a.print();
    cout << "sizeof(class A) = " << sizeof(class A) << endl;    //思考=24,why?
    cout << "sizeof(struct B) = " << sizeof(struct B) << endl;  //思考=24,why?
    return 0;
}

C++对象模型分析

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

//用C写面向对象的方法
//demo.h
#ifndef _DEMO_H_
#define  _DEMO_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_Del(Demo* pThis);

#endif

//demo.c
#include <malloc.h>
#include "demo.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 )
    {
        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_Del(Demo* pThis)
{
    free(pThis);
}

//main.c
#include <stdio.h>
#include "demo.h"

int main(void)
{
    Demo* d = Demo_Create(1, 2);
    printf("Demo_GetI(d) = %d\n",Demo_GetI(d));
    printf("Demo_GetJ(d) = %d\n",Demo_GetJ(d));
    printf("Demo_Add(d, 3) = %d\n",Demo_Add(d, 3));
    Demo_Del(d);
    return 0;
}

小结

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