首页 > 其他分享 >第七章 Part5 多态

第七章 Part5 多态

时间：2023-02-17 00:11:23浏览次数：35  
标签：函数 int void 绑定 多态 virtual Part5 第七章

多态

多态基本概念

  • 多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。
  • 多态性(polymorphism)提供接口与具体实现之间的另一层隔离，从而将”what”和”how”分离开来。多态性改善了代码的可读性和组织性，同时也使创建的程序具有可扩展性，项目不仅在最初创建时期可以扩展，而且当项目在需要有新的功能时也能扩展。
  • c++支持编译时多态(静态多态)和运行时多态(动态多态)，运算符重载和函数重载就是编译时多态，而派生类和虚函数实现运行时多态。
  • 静态多态和动态多态的区别就是函数地址是早绑定(静态联编)还是晚绑定(动态联编)。如果函数的调用，在编译阶段就可以确定函数的调用地址，并产生代码，就是静态多态(编译时多态)，就是说地址是早绑定的。而如果函数的调用地址不能编译不能在编译期间确定，而需要在运行时才能决定，这这就属于晚绑定(动态多态,运行时多态)。
点击查看代码 
//计算器
class Caculator{
public:
	void setA(int a){
		this->mA = a;
	}
	void setB(int b){
		this->mB = b;
	}
	void setOperator(string oper){
		this->mOperator = oper;
	}
	int getResult(){
		
		if (this->mOperator == "+"){
			return mA + mB;
		}
		else if (this->mOperator == "-"){
			return mA - mB;
		}
		else if (this->mOperator == "*"){
			return mA * mB;
		}
		else if (this->mOperator == "/"){
			return mA / mB;
		}
	}
private:
	int mA;
	int mB;
	string mOperator;
};

//这种程序不利于扩展，维护困难，如果修改功能或者扩展功能需要在源代码基础上修改
//面向对象程序设计一个基本原则:开闭原则(对修改关闭，对扩展开放)

//抽象基类
class AbstractCaculator{
public:
	void setA(int a){
		this->mA = a;
	}
	virtual void setB(int b){
		this->mB = b;
	}
	virtual int getResult() = 0;
protected:
	int mA;
	int mB;
};

//加法计算器
class PlusCaculator : public AbstractCaculator{
public:
	virtual int getResult(){
		return mA + mB;
	}
};

//减法计算器
class MinusCaculator : public AbstractCaculator{
public:
	virtual int getResult(){
		return mA - mB;
	}
};

//乘法计算器
class MultipliesCaculator : public AbstractCaculator{
public:
	virtual int getResult(){
		return mA * mB;
	}
};

void DoBussiness(AbstractCaculator* caculator){
	int a = 10;
	int b = 20;
	caculator->setA(a);
	caculator->setB(b);
	cout << "计算结果：" << caculator->getResult() << endl;
	delete caculator;
}

向上类型转换及问题

问题抛出

  • 对象可以作为自己的类或者作为它的基类的对象来使用。还能通过基类的地址来操作它。取一个对象的地址(指针或引用)，并将其作为基类的地址来处理，这种称为向上类型转换。
  • 也就是说：父类引用或指针可以指向子类对象，通过父类指针或引用来操作子类对象。
class Animal{
public:
	void speak(){
		cout << "动物在唱歌..." << endl;
	}
};

class Dog : public Animal{
public:
	void speak(){
		cout << "小狗在唱歌..." << endl;
	}
};

void DoBussiness(Animal& animal){
	animal.speak();
}

void test(){
	Dog dog;
	DoBussiness(dog);
}

运行结果:动物在唱歌
问题抛出: 我们给DoBussiness传入的对象是dog，而不是animal对象，输出的结果应该是Dog::speak。

问题解决思路

解决这个问题，我们需要了解下绑定(捆绑,binding)概念。
把函数体与函数调用相联系称为绑定(捆绑，binding)

  • 当绑定在程序运行之前(由编译器和连接器)完成时，称为早绑定(early binding).C语言中只有一种函数调用方式，就是早绑定。

  • 上面的问题就是由于早绑定引起的，因为编译器在只有Animal地址时并不知道要调用的正确函数。

  • 编译是根据指向对象的指针或引用的类型来选择函数调用。这个时候由于DoBussiness的参数类型是Animal&,

  • 编译器确定了应该调用的speak是Animal::speak的，而不是真正传入的对象Dog::speak。

  • 解决方法就是迟绑定(迟捆绑,动态绑定,运行时绑定，late binding),意味着绑定要根据对象的实际类型，发生在运行。

  • C++语言要实现这种动态绑定，必须有某种机制来确定运行时对象的类型并调用合适的成员函数。

问题解决方案(虚函数,vitual function)

C++动态多态性是通过虚函数来实现的，虚函数允许子类（派生类）重新定义父类（基类）成员函数，而子类（派生类）重新定义父类（基类）虚函数的做法称为覆盖(override)，或者称为重写。
对于特定的函数进行动态绑定，c++要求在基类中声明这个函数的时候使用virtual关键字,动态绑定也就对virtual函数起作用.

  • 为创建一个需要动态绑定的虚成员函数，可以简单在这个函数声明前面加上virtual关键字，定义时候不需要.
  • 如果一个函数在基类中被声明为virtual，那么在所有派生类中它都是virtual的.
  • 在派生类中virtual函数的重定义称为重写(override).
  • Virtual关键字只能修饰成员函数.
  • 构造函数不能为虚函数

注意: 仅需要在基类中声明一个函数为virtual.调用所有匹配基类声明行为的派生类函数都将使用虚机制。

点击查看代码 
class Animal{
public:
	virtual void speak(){
		cout << "动物在唱歌..." << endl;
	}
};
class Dog : public Animal{
public:
	virtual void speak(){
		cout << "小狗在唱歌..." << endl;
	}
};
void DoBussiness(Animal& animal){
	animal.speak();
}
void test(){
	Dog dog;
	DoBussiness(dog);
}

C++如何实现动态绑定

动态绑定什么时候发生？所有的工作都是由编译器在幕后完成。当我们告诉通过创建一个virtual函数来告诉编译器要进行动态绑定，那么编译器就会根据动态绑定机制来实现我们的要求， 不会再执行早绑定。

问题:C++的动态捆绑机制是怎么样的？
首先，我们看看编译器如何处理虚函数。当编译器发现我们的类中有虚函数的时候，编译器会创建一张虚函数表，把虚函数的函数入口地址放到虚函数表中，并且在类中秘密增加一个指针，这个指针就是vpointer(缩写vptr)，这个指针是指向对象的虚函数表。在多态调用的时候，根据vptr指针，找到虚函数表来实现动态绑定。

验证对象中的虚指针：

class A{
public:
	virtual void func1(){}
	virtual void func2(){}
};

//B类为空，那么大小应该是1字节，实际情况是这样吗？
class B : public A{};

void test(){
	cout << "A size:" << sizeof(A) << endl;
	cout << "B size:" << sizeof(B) << endl;
}

在编译阶段，编译器秘密增加了一个vptr指针，但是此时vptr指针并没有初始化指向虚函数表(vtable),什么时候vptr才会指向虚函数表？在对象构建的时候，也就是在对象初始化调用构造函数的时候。编译器首先默认会在我们所编写的每一个构造函数中，增加一些vptr指针初始化的代码。如果没有提供构造函数，编译器会提供默认的构造函数，那么就会在默认构造函数里做此项工作，初始化vptr指针，使之指向本对象的虚函数表。
起初，子类继承基类，子类继承了基类的vptr指针，这个vptr指针是指向基类虚函数表，当子类调用构造函数，使得子类的vptr指针指向了子类的虚函数表。

  • 当子类无重写基类虚函数时:

image
image

过程分析:
Animal* animal = new Dog;
animal->fun1();
当程序执行到这里，会去animal指向的空间中寻找vptr指针，通过vptr指针找到func1函数，此时由于子类并没有重写也就是覆盖基类的func1函数，所以调用func1时，仍然调用的是基类的func1.
**代码验证: **示例代码\71 验证子类无重写基类函数
**执行结果: **我是基类的func1
**测试结论: **无重写基类的虚函数，无意义

  • 当子类重写基类虚函数时:
    image

image

过程分析:
Animal* animal = new Dog;
animal->fun1();
当程序执行到这里，会去animal指向的空间中寻找vptr指针，通过vptr指针找到func1函数，由于子类重写基类的func1函数，所以调用func1时，调用的是子类的func1.
代码验证: 示例代码\72 验证子类重写基类函数
执行结果: 我是子类的func1
测试结论: 无重写基类的虚函数，无意义

多态的成立条件：

  • 有继承
  • 子类重写父类虚函数函数
    1. 返回值，函数名字，函数参数，必须和父类完全一致(析构函数除外)
    2. 子类中virtual关键字可写可不写，建议写
  • 类型兼容，父类指针，父类引用 指向 子类对象

静态编译和动态编译

1.1多态分类
1. 静态多态 函数重载
2. 动态多态 虚函数 继承关系

1.2静态联编
1.地址早绑定 在编译阶段就绑定好了的

1.3动态联编
地址晚绑定，运行时绑定好地址
1.4多态
1.父类的引用或指针，指向子类的对象

多态基本概念

  1. 多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。
  2. 多态性(polymorphism)提供接口与具体实现之间的另一层隔离，从而将”what”和”how”分离开来。多态性改善了代码的可读性和组织性，同时也使创建的程序具有可扩展性，项目不仅在最初创建时期可以扩展，而且当项目在需要有新的功能时也能扩展。
  3. c++支持编译时多态(静态多态)和运行时多态(动态多态)，运算符重载和函数重载就是编译时多态，而派生类和虚函数实现运行时多态。
  4. 静态多态和动态多态的区别就是函数地址是早绑定(静态联编)还是晚绑定(动态联编)。如果函数的调用，在编译阶段就可以确定函数的调用地址，并产生代码，就是静态多态(编译时多态)，就是说地址是早绑定的。而如果函数的调用地址不能编译不能在编译期间确定，而需要在运行时才能决定，这这就属于晚绑定(动态多态,运行时多态)。
点击查看代码 
#include<iostream>
using namespace std;

class Animal
{
public:

	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};

class Cat : public Animal
{
public:
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
};


//调doSpeak时，会提前在编译阶段找形参类型，speak函数的地址早就绑定好了，早绑定--静态联编，编译阶段就确定好了地址
//如果想要调用猫的speak，就不能提前绑定好函数的地址，所以需要在运行时候再去确定函数的地址
//动态联编：
//写法：将speak()改为虚函数；
//在父类上声明虚函数，发生了多态，已经变成了晚绑定地址了，现在只在运行阶段才能确定到底调用的是谁
//什么叫多态：父类的引用或者指针，指向子类对象
void doSpeak(Animal & animal)
{
	animal.speak();
}

//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);//动物在说话
}

int main()
{
	test01();

	system("pause");
	return 0;
}

多态原理解析

多态原理解析：

  1. 当父类中有了一个虚函数后，内部结构就发生了改变，内部多了一个 vfptr（virtual function pointer）虚函数表指针指向vftable 虚函数表
  2. 子类中 ，进行集成 ，会继承 vfptr 和vftable，vfptr也会指向父类中的 vftable，创建子类对象时，在构造函数中，就会把虚函数表的指针指向自己的虚函数表如果发生了重写，会替换掉虚函数表中原有的的speak()，改为&Cat::speak
  3. 深入剖析：如下图：
    image

Animal的虚函数表
image

Cat重写了speak()之后，Cat的虚函数表
image

Cat重写了speak()之后，Cat的虚函数表
image

点击查看代码 
#include<iostream>
using namespace std;

class Animal
{
public:

	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};

class Cat : public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};


//调doSpeak时，会提前在编译阶段找形参类型，speak函数的地址早就绑定好了，早绑定--静态联编，编译阶段就确定好了地址
//如果想要调用猫的speak，就不能提前绑定好函数的地址，所以需要在运行时候再去确定函数的地址
//动态联编：
//写法：将speak()改为虚函数，在父类上声明虚函数，发生了多态，已经变成了晚绑定地址了，现在只在运行阶段才能确定到底调用的是谁
//什么叫多态：父类的引用或者指针，指向子类对象
void doSpeak(Animal & animal)
{
	animal.speak();
}

//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);//当基类中的函数不是虚函数的时候，就会发生静态绑定，调用的还是父类的speak方法【动物在说话】，而添加了虚函数之后【小猫在说话】
}

void test02()
{
	//cout << sizeof(Animal) << endl;//1 函数不算对象身上
	//cout << sizeof(Animal) << endl;//4 写上virtual关键字之后
	Animal * animal = new Cat;//发生多态，父类的指针指向子类的对象

	animal->speak();//猫在说话
	//过程：（不需要记住，知道重写的原理就行了）
	//*(int *)animal,先强转成int类型的指针，再取 *，用来寻找虚函数表，
	//之后就找到了自己的虚函数表
	//虚函数表内部的结构也是一个数组，数组也是int类型的，也要进行强转，转成对象：
	//(int *)*(int *)animal
	//强转完之后，要再取到它:
	//*(int *)*(int *)animal : 这是函数的地址，函数指针指向函数地址，函数指针：
	//((void(*)())
	//指向 *(int *)*(int *)animal ：
	//(((void(*)()) (*(int *)*(int *)animal))
	//(((void(*)()) (*(int *)*(int *)animal))();//调用函数
}

int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

多态深入解析

猫吃鱼的函数调用：
编译器的调用方式：
((void()())(((int)(int *)animal + 1)))();

点击查看代码 
#include<iostream>
using namespace std;

class Animal
{
public:

	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
	virtual void eat()
	{
		cout << "动物在吃饭" << endl;
	}
};

class Cat : public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}

	virtual void eat()
	{
		cout << "小猫在吃鱼" << endl;
	}
};


//调doSpeak时，会提前在编译阶段找形参类型，speak函数的地址早就绑定好了，早绑定--静态联编，编译阶段就确定好了地址
//如果想要调用猫的speak，就不能提前绑定好函数的地址，所以需要在运行时候再去确定函数的地址
//动态联编：
//写法：将speak()改为虚函数，在父类上声明虚函数，发生了多态，已经变成了晚绑定地址了，现在只在运行阶段才能确定到底调用的是谁
//什么叫多态：父类的引用或者指针，指向子类对象
void doSpeak(Animal & animal)
{
	animal.speak();
}

//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);//动物在说话
}

void test02()
{
	//cout << sizeof(Animal) << endl;//1 函数不算对象身上
	//cout << sizeof(Animal) << endl;//4 写上virtual关键字之后
	Animal * animal = new Cat;//发生多态，父类的指针指向子类的对象

	animal->speak();//猫在说话
	//过程：（不需要记住，知道重写的原理就行了）
	//*(int *)animal,先强转，再取 *
	//之后就找到了自己的虚函数表
	//虚函数表内部的结构也是一个数组，数组也是int类型的，也要进行强转：
	//(int *)*(int *)animal
	//强转完之后，要再取到它:
	//*(int *)*(int *)animal : 这是函数的地址，函数指针指向函数地址，函数指针：
	//((void(*)())
	//指向 *(int *)*(int *)animal ：
	//(((void(*)()) (*(int *)*(int *)animal))
	//(((void(*)()) (*(int *)*(int *)animal))();//调用函数
	
	//*((int*)*(int *)animal+1) 猫吃鱼的的地址
	((void(*)())(*((int*)*(int *)animal + 1)))();
}

int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

image

多态案例

多态案例：
早期方法，不利于扩展

  • 真正的开发中，有个开发原则--开闭原则
  • 对扩展开放，对修改关闭
  • 利用多态实现，非常利于后期扩展，结构性非常好，可读性高，但是发生多态以后，内部变得复杂了，效率稍微降低，
  • C++比C语言效率稍微低。就低在了多态。
  • 多态的内部结构多了一个指针，空类里什么都没有，发生多态以后，内部多了一个vfptr指针，所以内部变得复杂了，效率稍微降低，
多态案例代码 
#include<iostream>
#include<string>
using namespace std;

//class Calculate
//{
//public:
//	void setvl(int v)
//	{
//		this->val1 = v;
//	}
//
//	void setv2(int v)
//	{
//		this->val2 = v;
//	}
//
//	int getResult(string oper)
//	{
//		if (oper == "+")
//		{
//			return val1 + val2;
//		}
//		else if (oper == "-")
//		{
//			return val1 - val2;
//		}
//	}
//private:
//	int val1;
//	int val2;
//
//};


//真正的开发中，有个开发原则--开闭原则
//对扩展开放，对修改关闭


//利用多态实现计算器
class abstractCalculator
{
public:
	virtual int getResult(){ return 0; };

	void setvl(int v)
	{
		this->val1 = v;
	}

	void setv2(int v)
	{
		this->val2 = v;
	}

	int val1;
	int val2;
};

//加法计算器
class PlusCalculator : public abstractCalculator
{
public:
	virtual int getResult()
	{ 
		return val1 + val2; 
	};
};


//减法法计算器
class SubCalculator : public abstractCalculator
{
public:
	virtual int getResult()
	{
		return val1 - val2;
	};
};
//乘法法计算器
class MulCalculator : public abstractCalculator
{
public:
	virtual int getResult()
	{
		return val1 * val2;
	};
};



void test01()
{
	abstractCalculator * abc = new PlusCalculator;
	//加法计算器
	abc = new PlusCalculator;
	abc->setvl(10);
	abc->setv2(20);

	cout << abc->getResult() << endl;
	delete abc;//没有赋为空

	//减法计算器
	abc = new SubCalculator;
	abc->setvl(10);
	abc->setv2(20);

	cout << abc->getResult() << endl;
	delete abc;//没有赋为空

	//乘法计算器
	abc = new MulCalculator;
	abc->setvl(10);
	abc->setv2(20);

	cout << abc->getResult() << endl;
	delete abc;//没有赋为空

}

int main()
{
	test01();
	
	system("pause");
	return 0;
}

抽象类和纯虚函数

虚析构和纯虚析构

指向成员的指针

标签：函数,int,void,绑定,多态,virtual,Part5,第七章
From： https://www.cnblogs.com/Epiephany/p/17128735.html

相关文章

  • 第七章 类 Part5 继承
    继承引出继承点击查看代码classIndexPage{public: //网页头部 voidHeader(){ cout<<"网页头部!"<<endl; } //网页左侧菜单 voidLeftNavigation(){......
  • 第七章 类 Part4 友元
    友元目的：访问类中的私有属性类的主要特点之一是数据隐藏，即类的私有成员无法在类的外部(作用域之外)访问。但是，有时候需要在类的外部访问类的私有成员，怎么办？解决方法是......
  • 第七章 类和对象 Part3 类的静态成员
    静态成员在类定义中，它的成员（包括成员变量和成员函数），这些成员可以用关键字static声明为静态的，称为静态成员。不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被......
  • 接口实现多态
    title:接口实现多态date:2023-02-0614:59:36tags:Golang接口使得程序更具有灵活性和拓展性的主要原因是它实现了多态性。多态性指的是不同的类型可以实现相同的接......
  • 重学Java-第七章 Java表达式、语句和块
    7.1表达式7.1.1定义 表达式是由数字、运算符、数字分组符号（括号)、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合，约束变量是在表达式中已被指定数值，......
  • 继承、多态 中那些你该知道的知识
    面向对象编程一、继承：二、多态：一、继承：有的时候客观事物之间就存在一些关联关系，那么在表示成类和对象的时候也会存在一定的关联。例如猫它是动物，就具有动物的基本属性......
  • go语言继承和多态
    packageatypeAnimalinterface{call()}typeDogstruct{}typeCatstruct{}func(dogDog)call(){println("我是狗，狗叫")}func(catCat)c......
  • 第七章 类Part2
    深拷贝和浅拷贝浅拷贝同一类型的对象之间可以赋值，使得两个对象的成员变量的值相同，两个对象仍然是独立的两个对象，这种情况被称为浅拷贝.一般情况下，浅拷贝没有任何副作用......
  • 第七章 类_Part1
    1.类和对象1.1类和对象的基本概念1.1.1C和C++中struct区别c语言struct只有变量c++语言struct既有变量，也有函数1.1.2类的封装​ 我们编写程序的目的是为了解决现......
  • 实战：第七章：微信H5支付时用户有微信分身停留5秒后未选择哪个微信分身，也未支付就被动回
    三种问题：微信H5支付时用户有微信分身停留5秒后未选择哪个微信分身，也未支付就被动回调到商户支付是否完成的页面安卓H5支付设置了redirect_url后调起微信收银台5秒后回退......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99