C++对象模型的演变及验证 (2)

最新推荐文章于 2017-10-31 22:45:13 发布

delphiwcdj

最新推荐文章于 2017-10-31 22:45:13 发布

阅读量906

点赞数

分类专栏： C++沉思录 C/C++

本文链接：https://blog.csdn.net/delphiwcdj/article/details/8171167

版权

C/C++ 同时被 2 个专栏收录

194 篇文章 1 订阅

订阅专栏

C++沉思录

8 篇文章 2 订阅

订阅专栏

2012-11-11 wcdj

玛雅人预测的2012年12月21日世界末日前的最后一个光棍节，果真是一个人的节日，祝小时爸爸手术顺利，早日康复！

本文在前文的基础上，考虑继承关系（单继承），继续验证继承关系下的C++对象模型。

先看下什么叫作覆盖（override）

覆盖override，是指派生类中存在重新定义的函数，其函数名、参数列、返回值类型必须同父类中的相对应被覆盖的函数严格一致，覆盖函数和被覆盖函数只有函数体（花括号中的部分）不同，当派生类对象调用子类中该同名函数时会自动调用子类中的覆盖版本，而不是父类中的被覆盖函数版本，这种机制就叫做覆盖，特征是：
        1、不同的范围（分别位于派生类与基类）；
        2、函数名字相同；
        3、参数相同；
       4、基类函数必须有virtual关键字。

以上说明摘自: 区分重载(overload)，覆盖(Override)和隐藏(hide)

验证例子

在前文的基础上，进行验证。

/* 2012-11-11 wcdj
 * C++虚函数表的实例解析
 */

#include <stdio.h>

// 指定按1字节对齐
#pragma pack(1)

// 定义普通函数指针
typedef void(*Fun)(void);

// 定义类成员函数指针
class Base;
typedef void(Base::*CFun)(void);
#define callMemFun(obj, pCFun) ( (obj).*(pCFun) )
#define pcallMemFun(pobj, pCFun) ( (pobj)->*(pCFun) )

 
class Base
{
public:
	// constructor
	Base() {}
	Base(int a, char b): m_iA(a), m_cB(b) {}
	virtual ~Base() {}

	// virtual functions
	virtual void f()
	{ 
		printf("invork f()\n"); 
	}
	virtual void g()
	{ 
		printf("invork g()\n"); 
	}
	virtual void h()
	{ 
		printf("invork h()\n"); 
	}

	// non-virtual functions
	void test()
	{ 
		printf("This is non-virtual  function named test\n"); 
	}
	void test2()
	{ 
		printf("This is non-virtual  function named test2\n"); 
	}

private:
	int m_iA;
	char m_cB;

};

class Derive1 : public Base
{
public:
	// constructor and destructor
	Derive1() {}
	Derive1(int a, char b, int c) : Base(a, b), m_iC(c) {}
	virtual ~Derive1() { printf("invork ~Derive1\n"); }

	virtual void x() { printf("invork Derive1::x()\n"); }
	virtual void y() { printf("invork Derive1::y()\n"); }
	virtual void z() { printf("invork Derive1::z()\n"); }

	void test() { printf("invork Derive1::test\n"); }

private:
	int m_iC;

};

class Derive2 : public Base
{
public:
	// constructor and destructor
	Derive2() {}
	Derive2(int a, char b, int c) : Base(a, b), m_iC(c) {}
	virtual ~Derive2() { printf("invork ~Derive2\n"); }

	void f() { printf("invork Derive2::f()\n"); }
	void g() { printf("invork Derive2::g()\n"); }


	void test() { printf("invork Derive2::test\n"); }

private:
	int m_iC;

};

int main()
{
	// [1]
	Derive1 d1(1, 'z', 2);

	// 计算类的大小
	// sizeof(Derive1) = sizeof(vfptr) + sizeof(m_iA) + sizeof(m_cB) + sizeof(m_iC) = 4 + 4 + 4 + 1 
	printf("the size of Derive1: %d\n", sizeof(d1));

	// 调用基类的
	d1.f();
	d1.x();

	Base *pd1 = new Derive1(3, 'z', 4);
	// 因为派生类没有覆盖, 即没有实现多态, 因此此处调用基类原有的
	pd1->f();
	// 只能访问基类的成员
	//pd1->x();
	delete pd1;


	// [2]
	Derive2 d2(5, 'z', 6);

	// 计算类的大小
	// sizeof(Derive2) = sizeof(vfptr) + sizeof(m_iA) + sizeof(m_cB) + sizeof(m_iC) = 4 + 4 + 4 + 1 
	printf("the size of Derive2: %d\n", sizeof(d2));

	Base *pd2 = new Derive2(7, 'z', 8);
	// 因为派生类覆盖了基类的虚函数, 即实现了多态, 因此此处调用派生类的实现
	pd2->f();
	delete pd2;

	// 默认调用派生类的
    d2.f();
	// 显式指定调用基类的
	d2.Base::f();


	return 0;
}

/*
output:

the size of Derive1: 13
invork f()
invork Derive1::x()
invork f()
invork ~Derive1
the size of Derive2: 13
invork Derive2::f()
invork ~Derive2
invork Derive2::f()
invork f()
invork ~Derive2
invork ~Derive1

*/

单继承无虚函数覆盖override

在这个继承关系中，子类没有覆盖任何父类的函数。对象模型参考Derive1类的验证。

注意：

(1) 虚函数按照其声明顺序放于表中，其中，派生类的析构函数会替换基类的虚构函数；

(2) 父类的虚函数在子类的虚函数前面，虚函数表中没有x(), y(), z()虚函数，pd1只能访问基类的成员；

(3) 注意隐藏的概念，例如：

d1.test();

d1.Base::test();

所谓的隐藏，指的是派生类类型的对象、指针、引用访问基类和派生类都有的同名函数时，访问的是派生类的函数，即隐藏了基类的同名函数。隐藏规则的底层原因其实是Ｃ++的名字解析过程。在继承机制下，派生类的类域被嵌套在基类的类域中。派生类的名字解析过程如下：
　　1、首先在派生类类域中查找该名字。
　　2、如果第一步中没有成功查找到该名字，即在派生类的类域中无法对该名字进行解析，则编译器在外围基类类域对查找该名字的定义。
      总结一下隐藏的特征：
      1、如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
      2、如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

单继承有虚函数覆盖overide

派生类覆盖父类的虚函数是很显然的事情，不然虚函数就变得毫无意义了。对象模型参考Derive2类的验证。

注意：

(1) 派生类覆盖的 f() 函数被放到了虚表中原来父类虚函数的位置；即，

Base *pd2 =newDerive2(7,'z', 8);

pd2->f();

由于基类指针pd2所指的内存中的虚函数表的 f() 的位置已经被派生类Derive2::f() 函数地址所取代，于是在实际调用发生时，是 Derive2::f() 被调用了，即，实现了多态。

(2) 基类中没有被派生类覆盖的虚函数，在虚函数表中保持不变；

(3) 使用基类指针可以访问派生类中的函数，前提是派生类覆盖了基类的虚函数；

任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。即，访问non-public的虚函数：如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。