我们学习了 C++ 这么长时间了，我们来看看 C++ 中对象的本质。它里面是用 class 定义的对象，class 是一种特殊的 struct。在内存中 class 依旧可以看做变量的集合，class 与 struct 遵循相同的内存对齐规则。class 中的成员函数与成员变量是分开存放的，及每个对象有独立的成员变量，所有对象共享类中的成员函数。那么我们如果在 class 和 struct 中同时定义相同的成员变量的话，它们所占的内存大小会一样嘛？我们来做个实验，代码如下
#include <iostream>
using namespace std;
class A
{
int i;
int j;
char c;
double d;
};
struct B
{
int i;
int j;
char c;
double d;
};
int main()
{
cout << "sizeof(A) = " << sizeof(A) << endl;
cout << "sizeof(B) = " << sizeof(B) << endl;
return 0;
}
我们根据之前学的知识可知，sizeof(B) 应该是等于 20 的，我们来看看 sizeof(A) 等于多少呢？
我们看到 A 和 B 所占的内存大小是一样的，那便说明它们的内存分布是相同的。我们下来在 class A 中定义一个 print 函数用来打印几个成员变量的值，再定义 B 类型的指针用来强制转换指向对象 A。再用指针来改变 A 中成员变量的值，具体程序如下
#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();
return 0;
}
那么我们进行强制类型转换后是否可以访问 class 的私有成员变量呢？我们来看看编译结果
我们看到在进行类型转换后，我们可以直接在外部对 class 的成员变量进行直接的改变。在运行时对象会退化位结构体的形式，此时所有的成员变量在内存中一次排布，成员变量间可能存在内存空隙。我们便可以通过内存地址来直接访问成员变量，访问权限的关键字在运行时失效。
类中的成员函数是位于代码段中，调用成员函数时对象地址作为参数隐式传递。成员函数通过对象地址访问成员变量，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 v)
{
return mi + mj + v;
}
};
int main()
{
Demo d(1, 2);
cout << "d.i = " << d.getI() << endl;
cout << "d.j = " << d.getJ() << endl;
cout << "d.add(3) = " << d.add(3) << endl;
return 0;
}
我们定义了一个很平常的类，在里面定义了几个返回成员变量的函数，并定义了 一个 add 函数。我们来编译看看
我们看到已经正确实现。那么我们来想想，为什么我们在 getI 函数中能直接返回成员变量 mi 的值呢？是因为在 C++ 中的每个类对象都有一个隐藏的 this 指针，它时刻的指向整个对象，所以才能访问到它中的成员变量。下来我们就用 C 语言来实现上面的 C++ 程序，看看用 C 语言怎么写出面向对象的代码。
class.h 源码
#ifndef _CLASS_H_ #define _CLASS_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 v); void Demo_Free(Demo* pThis); #endif
class.c 源码
#include "class.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 v)
{
struct ClassDemo* obj = (struct ClassDemo*)pThis;
return obj->mi + obj->mj + v;
}
void Demo_Free(Demo* pThis)
{
free(pThis);
}
test.c 源码
#include <stdio.h>
#include "class.h"
int main()
{
Demo* d = Demo_Create(1, 2); // Demo d(1, 2);
printf("d.i = %d\n", Demo_getI(d)); // cout << "d.i = " << d.i << endl;
printf("d.j = %d\n", Demo_getJ(d)); // cout << "d.j = " << d.j << endl;
printf("add(3) = %d\n", Demo_add(d, 3)); // cout << "d.add(3) = " << d.add(3) << endl;
Demo_Free(d);
return 0;
}
我们编译结果如下
我们看到跟它后面的 C++ 代码的效果是一样的，感觉是不是很炫酷呢？下来我们来说说 C++ 中的继承对象模型。在 C++ 编译器的内部类可以理解为结构体，子类是由父类成员叠加子类新成员得到的。如下
下来我们还是以代码为例来进行分析
#include <iostream>
using namespace std;
class Demo
{
protected:
int mi;
int mj;
public:
void print()
{
cout << "mi = " << mi << ", "
<< "mj = " << mj << endl;
}
};
class Derived : public Demo
{
int mk;
public:
Derived(int i, int j, int k)
{
mi = i;
mj = j;
mk = k;
}
void print()
{
cout << "mi = " << mi << ", "
<< "mj = " << mj << ", "
<< "mk = " << mk << endl;
}
};
struct Test
{
void* p;
int mi;
int mj;
int mk;
};
int main()
{
cout << "sizeof(Demo) = " << sizeof(Demo) << endl;
cout << "sizeof(Derived) = " << sizeof(Derived) << endl;
/*
Derived d(1, 2, 3);
Test* p = reinterpret_cast<Test*>(&d);
cout << "Before changing ..." << endl;
d.print();
p->mi = 10;
p->mj = 20;
p->mk = 30;
cout << "After changing ..." << endl;
d.print();
*/
return 0;
}
我们先通过打印两个类的大小来看看它们所占的内存大小
分别是 8 和 12，也和我们之前所分析的是一致的。由于我们重写了 print 函数，所以我们应该将其声明为虚函数，再加上 virtual 关键字之后再来看看他们的内存大小是多少
变成 12 和 16 了，加了 4 个字节的空间。我们再将注释掉的内容展开，看看结果
我们通过强制类型转换来改变了他们的成员变量的值。在 struct 结构体中第一个为 void* 的指针，也就是说，在 class 类对象中还有一个指针存在。这个指针便是我们指向虚函数表的指针。那么 C++ 中多态究竟是怎么实现的呢？当类中声明虚函数时，编译器会在类中生成一个虚函数表，虚函数表是一个存储成员函数地址的数据结构。虚函数表是由编译器自动生成与维护的，virtual 成员函数会被编译器放入虚函数表中。当存在虚函数时，每个对象都有一个指向虚函数表的指针。多态对象模型如下所示
那么在编译器确认 add 函数是否为虚函数时，如果是，编译器则在对象 VPTR 所指的虚函数表中查找 add 函数的地址；如果不是，编译器则直接可以确定被调成员函数的地址。那么我们来看看具体它是怎么调用的，如下
由此看来，就调用的效率来说，虚函数肯定是小于普通成员函数的。我们再次完善之前用 C 语言实现继承的代码，用 C 代码实现多态的用法。
class.h 源码
#ifndef _CLASS_H_ #define _CLASS_H_ typedef void Demo; typedef void Derived; Demo* Demo_Create(int i, int j); int Demo_getI(Demo* pThis); int Demo_getJ(Demo* pThis); int Demo_add(Demo* pThis, int v); void Demo_Free(Demo* pThis); Derived* Derived_Create(int i, int j, int k); int Derived_getK(Derived* pThis); int Derived_add(Derived* pThis, int v); #endif
class.c 源码
#include "class.h"
#include <malloc.h>
static int Demo_Virtual_Add(Demo* pThis, int v);
static int Derived_Virtual_Add(Derived* pThis, int v);
struct VTable // 2. 定义虚函数表数据结构
{
int (*pAdd)(void*, int); // 3. 虚函数表里存储的东西
};
struct ClassDemo
{
// 1. 定义虚函数表指针 ==> 虚函数表指针类型
struct VTable* vptr;
int mi;
int mj;
};
struct ClassDerived
{
struct ClassDemo d;
int mk;
};
static struct VTable g_Demo_vtbl =
{
Demo_Virtual_Add
};
static struct VTable g_Derived_vtbl =
{
Derived_Virtual_Add
};
Demo* Demo_Create(int i, int j)
{
struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo));
if( ret != NULL )
{
ret->vptr = &g_Demo_vtbl; // 4. 关联对象和虚函数表
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;
}
// 6. 定义虚函数表中指针所指向的具体函数
static int Demo_Virtual_Add(Demo* pThis, int v)
{
struct ClassDemo* obj = (struct ClassDemo*)pThis;
return obj->mi + obj->mj + v;
}
// 5. 分析具体虚函数
int Demo_add(Demo* pThis, int v)
{
struct ClassDemo* obj = (struct ClassDemo*)pThis;
return obj->vptr->pAdd(pThis, v);
}
void Demo_Free(Demo* pThis)
{
free(pThis);
}
Derived* Derived_Create(int i, int j, int k)
{
struct ClassDerived* ret = (struct ClassDerived*)malloc(sizeof(struct ClassDerived));
if( ret != NULL )
{
ret->d.vptr = &g_Derived_vtbl;
ret->d.mi = i;
ret->d.mj = j;
ret->mk = k;
}
return ret;
}
int Derived_getK(Derived* pThis)
{
struct ClassDerived* obj = (struct ClassDerived*)pThis;
return obj->mk;
}
static int Derived_Virtual_Add(Derived* pThis, int v)
{
struct ClassDerived* obj = (struct ClassDerived*)pThis;
return obj->mk + v;
}
int Derived_add(Derived* pThis, int v)
{
struct ClassDerived* obj = (struct ClassDerived*)pThis;
return obj->d.vptr->pAdd(pThis, v);
}
test.c 源码
#include <stdio.h>
#include "class.h"
void run(Demo* p, int v)
{
int r = Demo_add(p, v);
printf("r = %d\n", r);
}
int main()
{
Demo* pb = Demo_Create(1, 2);
Derived* pd = Derived_Create(1, 22, 333);
printf("pb.add(3) = %d\n", Demo_add(pb, 3));
printf("pd.add(3) = %d\n", Derived_add(pd, 3));
run(pb, 3);
run(pd, 3);
Demo_Free(pb);
Demo_Free(pd);
return 0;
}
我们来编译看下是不是和我们在 C++ 中实现的多态的效果是否一致呢？
我们看到它的效果和 C++ 中的多态的效果是一样的，也就是说，我们用 C 语言实现了多态。屌爆了！！通过今天对 C++ 对象模型的分析，总结如下：1、C++ 中的类对象在内存布局上与结构体相同；2、成员变量和成员函数在内存中分开存放；3、访问权限关键字在运行时失效；4、调用成员函数时对象地址作为参数隐式传递；5、继承的本质就是父子间成员变量的叠加；6、C++ 中的多态是通过虚函数表实现的7、虚函数表是由编译器自动生成与维护的，虚函数的调用效率低于普通成员函数。
欢迎大家一起来学习 C++ 语言，可以加我QQ：243343083。