版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
1.继承对象模型
- 在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
-
{
-
int mi;
-
int mj;
-
int mk;
-
};
-
-
int main()
-
{
-
cout <<
"sizeof(Demo) = " <<
sizeof(Demo) <<
endl;
-
cout <<
"sizeof(Derived) = " <<
sizeof(Derived) <<
endl;
-
cout <<
"sizeof(Tset) = " <<
sizeof(Test) <<
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();
-
-
system(
"pause");
-
-
-
return
0;
-
}
- 运行结果
- 很巧妙的一个实验，通过比较所占字节大小得出结论。另外，强制类型转换后，更改数据，打印结果显示数据改变，说明类的内存结构和结构体的内存结构是相同的，强化这一思想。
2.多态对象模型
- C++多态的实现原理
- 当类中声明虚函数时，编译器会在类中生成一个虚函数表
- 虚函数表是一个存储成员函数地址的数据结构
- 虚函数表是由编译器自动生成与维护的
virtual成员函数会被编译器放入虚函数表中- 存在虚函数时，每个对象中都有一个指向虚函数表的指针
- 编译两个类，编译器生成了两张虚函数表，并将虚函数放入虚函数表
- 当类中有虚函数，创建对象时，在该对象中"塞"入一个指针成员变量，指向虚函数表
- 通过p指针找到具体对象，通过具体对象的虚函数表指针找到虚函数表，在虚函数表找到函数地址，三次寻址，C++的多态通过牺牲效率实现
3.编程实验
- 虚函数表指针的存在，继承中的对象模型
-
#include<iostream>
-
using
namespace
std;
-
-
class Demo
-
{
-
protected:
-
int mi;
-
int mj;
-
-
public:
-
virtual 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;
// 12, 不是8，因为插入了一个虚函数表指针（指针长度4字节）
-
cout <<
"sizeof(Derived) = " <<
sizeof(Derived) <<
endl;
// /16，不是12，因为继承了父类，原因同上。
-
cout <<
"sizeof(Tset) = " <<
sizeof(Test) <<
endl;
-
-
Derived d(1, 2, 3);
-
Test *p =
reinterpret_cast<Test *>(&d);
// 将类指针强制类型转换为结构体指针
-
-
// 以下实验证明带有虚函数的Derived的内存模型与Test结构体是一致的！
-
//1.大小相同，2.第1个成员变量vptr（虚函数）指针；3.往后依次为mi，mj，mk
-
cout <<
"Before changing ..." <<
endl;
-
d.print();
-
-
p->mi =
10;
-
p->mj =
20;
-
p->mk =
30;
-
-
cout <<
"After changing ..." <<
endl;
-
d.print();
-
-
system(
"pause");
-
-
-
return
0;
-
}
- 运行结果：
4.多态本质分析
- 下面用C实现C++的封装，继承，多态特性，深入理解C++对象模型
- test.h
-
#ifndef _TEST_H_
-
#define _TEST_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 value);
-
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 value);
-
-
#endif
- test.c
-
#include "test.h"
-
#include <malloc.h>
-
#include <stdio.h>
-
-
// static修饰函数，说明函数只能被本文件所使用，和修饰全局变量一样，限定在本文件作用域，隐藏的虚函数表。
-
static int Demo_Virtual_Add(Demo *pThis, int value);
-
static int Derived_Virtual_Add(Derived *pThis, int value);
-
-
struct VTable
// 2.定义虚函数表数据结构
-
{
// 这是一张表
-
int(*pAdd)(
void *,
int);
// 3.虚函数表里面存储的内容是（函数指针），主要这个pAdd具体指向谁，是地址层面的具体数值。
-
};
-
-
struct ClassDemo
// 父类结构体
-
{
-
struct VTable *vptr;
// 1.数定义虚函表指针 ==》虚函数表指针的类型
-
int mi;
-
int mj;
-
};
-
-
struct ClassDerived
// 子类结构体，拥有父类结构体里面的成员。也包括那个虚函数表指针
-
{
-
struct ClassDemo d;
// 模拟继承，实质就是父类成员叠加到子类成员中去。
-
int mk;
-
};
-
-
// 父类的虚函数表，static隐藏到当前文件中。// 给虚函数表初始化
-
static
struct VTable g_Demo_vtbl =
// g_Demo_vtbl的类型为static struct VTable
-
{
-
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)
-
{
-
// 4.只要有父类的对象产生，那么调用构造函数，关联虚函数表。
-
ret->vptr = &g_Demo_vtbl;
// 4.（g_Demo_vtbl）结构体类型，关联对象和虚函数表
-
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 value)
-
{
-
struct ClassDemo *obj = (
struct ClassDemo *)pThis;
-
-
return obj->mi + obj->mj +
value;
-
}
-
-
// 5.分析具体的虚函数
-
int Demo_Add(Demo *pThis, int value) // 是个虚函数
-
{
-
struct ClassDemo *obj = (
struct ClassDemo*)pThis;
-
-
// 从虚函数表中找到真正的实现函数
-
return obj->vptr->pAdd(pThis,
value);
// 虚函数表具体的指向，这个vptr在对象的构造函数中初始化。
-
}
-
-
void Demo_Free(Demo *pThis)
-
{
-
free(pThis);
-
}
-
-
/****************** Derived类 ，子类 ***********************/
-
Derived* Derived_Create(
int i,
int j,
int k)
// 构造函数
-
{
-
struct ClassDerived *ret = (
struct ClassDerived *)malloc(
sizeof(
struct ClassDerived));
-
if (ret != NULL)
-
{
-
// 只要有子类的对象产生，那么调用构造函数，关联虚函数
-
//（g_Derived_vtbl）结构体类型，关联对象和虚函数表
-
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 value)
-
{
-
struct ClassDerived *obj = (
struct ClassDerived *)pThis;
-
-
return obj->mk +
value;
-
}
-
-
// 分析虚函数
-
int Derived_Add(Derived* pThis, int value)
-
{
-
struct ClassDerived *obj = (
struct ClassDerived*)pThis;
-
-
// 从虚函数表中找到真正的实现函数
-
return obj->d.vptr->pAdd(pThis,
value);
-
}
- main.c
-
#include <stdio.h>
-
#include "test.h"
-
-
void run(Demo *p, int v)
-
{
-
int r = Demo_Add(p, v);
//多态
-
printf(
"r = %d\n", r);
-
}
-
int main()
-
{
//这两个指针类型都是void的。
-
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);
-
-
system(
"pause");
-
-
return
0;
-
}
- 运行结果：
5.小结
- 继承的本质是父子间成员变量的叠加
- C++中的多态是通过虚函数表实现的
- 虚函数表是由编译器自动生成与维护的
- 虚函数的调用效率低于普通成员函数。（虚函数要经过几次寻址）
6.补充说明
-
面向对象程序最关键的地方在于必须能够表现三大特性：封装，继承，多态！
<ul><li>封装指的是类中的敏感数据在外界是不能访问的；</li> <li>继承指的是可以对已经存在的类进行代码复用，并使得类之间存在父子关系；</li> <li>多态指的是相同的调用语句可以产生不同的调用结果。</li> </ul></li> <li>因此，如果希望用 C 语言完成面向对象的程序，那么肯定的，必须实现这三个特性；否则，最多只算得上基于对象的程序</li>
6.1封装
- 上文中通过 void* 指针保证具体的结构体成员是不能在外界被访问的，以此模拟 C++ 中 private 和 protected。因此，在头文件中定义了如下的语句：
-
typedef
void Demo;
-
typedef
void Derived;
- Demo 和 Derived 的本质依旧是 void， 所以，用 Demo* 指针和 Derived* 指针指向具体的对象时，无法访问对象中的成员变量，这样就达到了“外界无法访问类中私有成员”的封装效果！
6.2 继承
- 继承的本质是父类成员与子类成员的叠加，所以在用 C 语言写面向对象程序的时候，可以直接考虑结构体成员的叠加即可。文中的实现直接将 struct ClassDemo d 作为 struct ClassDerived 的第一个成员，以此表现两个自定义数据类型间的继承关系。因为 struct Class Derived 变量的实际内存分布就是由struct Class Demo 的成员以及 struct Class Derived 中新定义的成员组成的，这样就直接实现了继承的本质，所以说 struct Class Derived 继承自 struct ClassDemo。
6.3 多态
- 多态在 C++ 中的实现本质是通过虚函数表完成的，而虚函数表是编译器自主产生和维护的数据结构。因此，接下来要解决的问题就是如何在 C 语言中自定义虚函数表？文中认为通过结构体变量模拟 C++中的虚函数表是比较理想的一种选择，所以有了下面的代码：
-
struct VTable
-
{
-
void (*pAdd)(
void*,
int);
-
};
- 必须要注意的是，若误将 pAdd 指针的类型定义成了int (*)(Derived*, int) ，这从 C 语言的角度算不上错误， 所以编译运行都没有问题。但是，从面向对象的角度，这里可以说是一种语义上的错误！因为 pAdd 必须可以指向父类中定义的Add函数版本，也可以指向子类中定义的 Add 函数版本，所以说用 Derived* 作为第一个参数表示实际对象并不合适，应该直接使用 void* 。有了类型后就可以定义实际的虚函数表了，在 C 语言中用具有文件作用域的全局变量表示实际的虚函数表是最合适的，因此有了下面的代码：
-
// 父类对象使用的虚函数表
-
static
struct VTable g_Demo_vtbl =
-
{
-
Demo_Virtual_Add
-
};
-
// 子类对象使用的虚函数表
-
static
struct VTable g_Derived_vtbl =
-
{
-
Derived_Virtual_Add
-
};
- 每个对象中都拥有一个指向虚函数表的指针，而所有父类对象都指向g_Demo_vtbl，所以所有子类对象都指向 g_Derived_vtbl。当一切就绪后，实际调用虚函数的过程就是通过虚函数表中的对应指针来完成的。
197
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
