lesson2 - 多态

已于 2023-07-12 19:41:19 修改
阅读量301 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-10-25 17:51:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LYC_462857656/article/details/127380594
版权

1. 多态的概念

多态就是函数调用的多种形态，使用多态能够使得不同的对象去完成同一件事时，产生不同的动作和结果。 

  • 比如买车票这件事
    • 普通人买票->正常买票
    • 学生买票->半价买票
    • 军人买票->优先买票

2. 多态定义及实现 

多态: 指向谁调用谁 

2.1 多态构成的两个条件:

  1. 虚函数重写  
  2. 父类指针或者引用去调用虚函数

2.2 虚函数的理解

class Person
{
public:
	//被virtual修饰的类成员函数
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};

  •  只有类的非静态成员函数前可以加virtual，普通函数前不能加virtual。

  • 虚函数这里的virtual和虚继承中的virtual是同一个关键字，但是它们之间没有任何关系。虚函数这里的virtual是为了实现多态，而虚继承的virtual是为了解决菱形继承的数据冗余和二义性。

2.2 虚函数重写的两个条件:

//父类
class Person
{
public:
	//父类的虚函数
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//子类的虚函数重写了父类的虚函数
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//子类的虚函数重写了父类的虚函数
	virtual void BuyTicket()
	{
		cout << "优先-买票" << endl;
	}
};
  1. 这个函数是虚函数,
  2. 三同:函数名,参数,返回值都要相同

 2.3 满足虚函数重写的两大特例

#include <iostream>
using namespace std;
class Person
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

class Student : public Person {
public:
	// 虚函数重写/覆盖条件 : 虚函数 + 三同（函数名、参数、返回值）
	
	// 特例1：子类虚函数不加virtual，依旧构成重写 （实际最好加上）
	//void BuyTicket() { cout << "买票-半价" << endl; }
	virtual void BuyTicket() { cout << "买票-半价" << endl; }

    //重写的协变:返回值可以不同, 但是要求返回值必须是父子关系的指针或者引用
	//.....
};

class Soldier : public Person {
public:
	virtual void BuyTicket() { cout << "优先买票" << endl; }
};

// 多态两个条件：
// 1、虚函数重写
// 2、父类指针或者引用去调用虚函数

// void Func(Person* p) // 父类指针或者引用去调用虚函数
void Func(Person& p)// 父类指针或者引用去调用虚函数
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	Soldier sd;

	Func(ps);
	Func(st);
	Func(sd);

	return 0;
}

  1. 子类虚函数不加virtual,依旧构成重写(实际中最好加上)
  2. 重写的协变:返回值可以不同,但是要求返回值必须是父子关系的指针或者引用

3. 经典面试题: 下面程序的输出结果是?

#include <iostream>
using namespace std;

class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};

class B : public A
{
public:
	void func(int val = 0){ std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}
  • 首先test不构成多态,func构成多态
  • p的类型是B*,指向的是B,p->test(A*this),这里会发生切片:子类指针传给父类指针
  • 父类里的test中的this->func,会去调用子类B的func,程序的结果是B->0吗
  • 这里有两点需要注意:
    • 虚函数func重写的是接口继承,重写实现
    • 普通函数继承是实现继承
  •  虚函数func重写,这里的子类B中func会去调用自己的func实现,会继承父类的接口
    virtual void func(int val = 1)接口继承
    { std::cout << "B->" << val << std::endl; };重写实现
  • 这段程序的运行结果是B->1

4. 经典面试题: 下面程序的输出结果是?

#include <iostream>
using namespace std;

class A
{
public:
	virtual void func(int val) { std::cout << "A->" << val << std::endl; }
	void test() { func(1); }
};

class B : public A
{
public:
	void func(int val) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	A*p = new B;

	p->test();
	return 0;
}

 

  • 这段代码中的p虽然是A*的指针,但是这里发生了切片操作,p指向的是B的那一大段空间 
  • 发生了多态,与指针类型无关

5. 多态的原理

#include <iostream>
using namespace std;

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }

	virtual void Func() { cout << "Func" << endl; }

	int _a = 0;
};

class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }

	int _b = 0;
};

void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person Mike;
	Func(Mike);

	Student Johnson;
	Func(Johnson);

	return 0;
}

  •  vfptr是一张虚函数的表,本质就是一个函数指针数组
  • 多态调用:运行时是去指向对象的虚表中找到函数地址,并进行调用(在符合多态的两个条件时,)
  • 普通调用:编译链接时就确认了函数地址,运行时直接调用

5.1 动态绑定和静态绑定

静态绑定： 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也成为静态多态，比如：函数重载。

动态绑定： 动态绑定又称为后期绑定(晚绑定)，在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

//父类
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};

 6. 在继承中把析构函数定义成虚函数

#include <iostream>
using namespace std;

 //建议在继承中析构函数定义成虚函数
class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }

	//int* _ptr;
};

class Student : public Person {
public:
	// 析构函数名会被处理成destructor，所以这里析构函数完成虚函数重写
	virtual ~Student() { cout << "~Student()" << endl; }
};

int main()
{
	Person* ptr1 = new Person;
	delete ptr1;

	Person* ptr2 = new Student;
	delete ptr2;

	return 0;
}

 

  • 这段代码在不同的编译器中,结果可能不一样,
  • 析构函数名会被处理成destructor，所以这里析构函数完成虚函数重写
  • 发生了多态,与指针类型无关

7. 关于重载.覆盖(重写),隐藏(重定义)的对比

  • 重载 : a. 两个函数在同一作用域,b.函数名相同,参数不同(类型,顺序,个数)
  • 重写(覆盖):
    两个函数分别在基类和派生类的作用域
    函数名/参数/返回值都必须相同(协变除外) -> 简称三同
    特殊点1: 两个函数都必须是虚函数(其实子类可以不用加virtual)
    特殊点2: 如果返回值不同,则必须是父类的指针或引用
  •  重定义(隐藏)
    两个函数分别在基类和派生类的作用域
    函数名相同
    两个基类和派生类的同名函数不构成重写,那么就是重定义(隐藏)

8.  C++11 override 和 final(使该类不可被子类继承)

8.1  final(使该类不可被子类继承) -> 加在父类上

  •  在一个父类的成员函数的后面+final使其变成不可被子类继承

8.2 override(判读子类是否发生了虚函数的重写) ->加在子类上

#include <iostream>
using namespace std;

class Car{
public:
	virtual void Drive1() {}
	void Drive2(){}
};

class Benz :public Car {
public:
	// 检查子类虚函数是否完成重写
	virtual void Drive1() override { cout << "Benz-舒适" << endl; }
	virtual void Drive2() override { cout << "Benz-舒适" << endl; }
};

int main()
{
	Benz A;
	return 0;
}

  •  在子类后面+override,判断这个子类的虚函数是否发生了虚函数的重写

9. 抽象类 && 纯虚函数

  •  在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口
    类），抽象类 不能实例化出对象 。

10. 多继承中的多态

#include <iostream>
using namespace std;

class Car
{
public:
	virtual void Drive() = 0;
};

class BMW : public Car
{
public:
	virtual void Drive()
	{
		cout << "操控-好开" << endl;
	}
};

class Benz :public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz-豪华舒适" << endl;
	}
};

int main()
{
	//Car c;
	//BMW b;
	Car* ptr = new BMW;
	ptr->Drive();

	ptr = new Benz;
	ptr->Drive();

	return 0;
}

 

  •  其中如果不需要用到父类的虚函数,仅仅是为了实现多态,
  • 将父类的虚函数写成纯虚函数,将父类定义成抽象类

11. 理解虚表

#include <iostream>
using namespace std;

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "Person::买票-全价" << endl;
	}

	virtual void Func1()
	{
		cout << "Person::Func1()" << endl;
	}
};

class Student : public Person {
public:
	// 这里只用BuyTicket()完成了虚函数的重写
	virtual void BuyTicket()
	{
		cout << "Student::买票-半价" << endl;
	}

	virtual void Func2()
	{
		cout << "Student::Func2()" << endl;
	}
};

int main()
{
	// 同一个类型的对象共用一个虚表
	Person p1;
	Person p2;

	// vs下 不管是否完成重写，子类虚表跟父类虚表都不是同一个
	Student s1;
	Student s2;
	return 0;
}

  •  同一个类型的对象共用一个虚表
  •  vs下 不管是否完成重写，子类虚表跟父类虚表都不是同一个

11. 1父类的虚表

#include <iostream>
using namespace std;

typedef void(*VFPTR)();

// 打印虚函数表中的虚函数地址,并且调用虚函数
void PrintVFTable(VFPTR* table)
{
	for (size_t i = 0; table[i] != nullptr; ++i)
	{
		printf("vft[%d]:%p->", i, table[i]);
		VFPTR pf = table[i];
		pf();
	}
	cout << endl;
}

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1 = 1;
};

class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2 = 2;
};

class Derive : public Base1, public Base2 {
public:
	//这里只重写了 func1
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d = 3;
};

int main()
{
	Derive d;

	PrintVFTable((VFPTR*)(*(int*)&d));
	PrintVFTable((VFPTR*)(*(int*)((char*)&d + sizeof(Base1))));

	return 0;
}

 

  • 这里子类的虚函数func3是没有发生重写的,也没有发生隐藏,就是一个普通的虚函数,
  • 虽然在监视窗口中没有看到func3,但是在打印出父类的虚表Base1和Base2中,发现这个普通的虚函数存在第一个父类的虚表中

12. 问答题

12.1 什么是多态? 

  • 就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会
    产生出不同的状态

12.2 什么是重载、重写(覆盖)、重定义(隐藏)? 

  • 重载 : a. 两个函数在同一作用域,b.函数名相同,参数不同(类型,顺序,个数)
  • 重写(覆盖):
    两个函数分别在基类和派生类的作用域
    函数名/参数/返回值都必须相同(协变除外) -> 简称三同
    特殊点1: 两个函数都必须是虚函数(其实子类可以不用加virtual)
    特殊点2: 如果返回值不同,则必须是父类的指针或引用
  •  重定义(隐藏)
    两个函数分别在基类和派生类的作用域
    函数名相同
    两个基类和派生类的同名函数不构成重写,那么就是重定义(隐藏)

 12.3 多态的实现原理？ 

  •  每一个类中都有一个vfptr,它是一张虚函数的表,本质就是一个函数指针数组
  • 多态调用:运行时去指向对象的虚表中找到函数地址,并进行调用(在符合多态的两个条件时,)

12.4 inline函数可以是虚函数吗？

  • 不可以,但是inline只是一个建议,当一个函数是虚函数以后,多态调用中,inline会直接失效

12.5 静态成员可以是虚函数吗? 

  • 不可以 ，因为 静态成员函数没有this指针 ，使用类型::成员函数
    的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

12.6 构造函数可以是虚函数吗

  • 不可以,virtual函数是为了实现多态,运行时去虚表中找对应虚函数进行调用
  • 对象中虚表指针都是构造函数初始化列表阶段才初始化的
  • 构造函数的虚函数是没有意义的

 12.7 析构函数可以是虚函数吗

  • 可以,建议基类的析构函数定义成虚函数
  • 析构函数名都会被处理成destructor，所以这里析构函数完成了虚函数重写
  • 构成多态与指针类型就无关了

12.8 拷贝构造 和 operator=可以是虚函数?

  •  拷贝构造不可以,拷贝构造也是构造函数,同上

  • operator=可以但是没有什么实际价值

12.9  对象访问普通函数快还是虚函数更快？

  • 不构成多态, 是一样快的。
  • 构成多态，则调用的普通函数快，
    因为构成多态，运行时调用虚函数需要到虚函数表中去查找

12.10 虚函数是在什么阶段生成的,存在哪的?

  • 编译阶段就生成好的,存在代码段(常量区)

12. 11什么是抽象类？抽象类的作用？ 

  • 在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类
  • 抽象类强制重写了虚函数，另外抽象类体现出了 接口继承关系 。
旧链爱学习
关注
专栏目录
多态与虚继承
夜黯竹亭风的博客
04-06 1097
多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数调用不同内容的函数。多态主要通过联编实现。 静态联编：在编译时一定确定要调用哪个函数。 动态联编：一个类如果有虚函数，它的对象有个指针，指向虚函数表，通过指针调用里面的虚函数。 虚函数表8个字节。 在类的继承的不同层次中，在不同的层次中可以出现名字、参数个数和类型相同而功能不同的函数。编译器按照向自己后父类的顺序进行覆盖查找
Lesson06--OOP多态.pdf
08-20
### Lesson06--OOP多态.pdf 知识点总结 #### 多态概念与基础知识 **多态**是面向对象编程（OOP）中的一个核心概念，它允许子类对象替代父类对象，从而使同一接口能表现出多种行为。本章节主要介绍了多态的基本原理...
嵌入式养成计划-40----C++菱形继承--虚继承--多态--模板--异常
This code no bug！
10-12 305
C++菱形继承--虚继承--多态--模板--异常
Lesson 13 -- 多态
m0_63667883的博客
08-09 41
必须通过基类的指针或者引用调用虚函数被调用的函数必须时虚函数，且派生类必须对基类的虚函数进行重写如此，调用哪一个函数，就和指针或者引用指向的对象有关在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
类和对象-----多态
Ycx_lq的博客
05-08 310
// lesson_4.cpp : 定义控制台应用程序的入口点。 // 动态的多态：一个接口，多个实现，不同的对象有相同的基类，接收同一消息时，产生不同的反应 #include "stdafx.h" #include using namespace std; class Biology { public: void grow(){ cout };
Lesson4上机练习-----多态
hypertelorism的博客
10-18 288
public abstract class Animal { public abstract void cry(); public abstract String getAnimalName(); } public class Cat extends Animal{ @Override public void cry() { // TODO Auto-generated meth
Lesson_9 上课笔记 -- 多态
HouRui2000的博客
01-21 122
2013-01-19 Lesson_9 多态 1 /*********************************************************** 2 * Lesson_9 3 * 4 * 多态 5 * ...
Java基础教程28-多态
Anthony_tester的博客
06-18 1923
本文介绍Java中三大特性之多态。实际上封装和继承都是为了多态服务的。什么是多态呢？多态指同一个实体同时具有多种形式。或者这样描述，同一个事件发生在不同对象上面，就有不同效果，这样的例子叫多态。下面，我们用多个子类调用同一个方法（子类重写了该方法），会得到不同结果。 1.Supper class，Student.java package lesson01; public class Stud
Lesson12_多态
weixin_44120423的博客
09-02 320
Lesson12_多态 回顾 静态代码块 static{} 在类加载时执行一次 Class.forName(“xxx”); 普通代码块 每创建一个对象，都会执行一次，在构造方法之前执行。可以写所有构造方法共有的代码 构造方法 调用了哪一个，执行哪一个 单例模式 SingleTon private构造方法，内部new对象，提供公开的访问方法，static该方法，static该属性 ​ 饿、懒 方法重载 同一个类中，相同的方法名，不同的参数列表。这种现象叫方法重载 package
Lesson07-封装、继承及多态
AyinMars的博客
07-23 104
面向对象 什么是面向对象 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。 但是，具体到微观事物的操作，我们仍然会使用面向过程的思路去处理。 面向对象的本质是：以类的方式组织代码，以对象的方式（组织）封装数据。 三大特性： 封装 继承 多态 从认识的角度考虑是先有对象后有类。对象，是具体的事物，类，是抽象的，是对对象的抽象。 值传递 public static void main(String[] args) { int a = 1; /
MFC学习lesson 2-C++经典语法.rar
02-19
本教程“MFC学习lesson 2 - C++经典语法”将深入探讨C++的基础语法在MFC框架中的应用。 1. **C++基础语法** C++是MFC的基础，因此理解和掌握C++的经典语法至关重要。这包括： - 变量声明与类型：了解不同数据类型...
50001-2020-lesson2studentsolution-FolkLoreee：50001-2020-lesson2studentsolution-FolkLoreee由GitHub Classroom创建
02-25
标题中的"50001-2020-lesson2studentsolution-FolkLoreee"似乎是一个课程项目，可能是某大学或在线课程中的第二课编程作业，专注于Java语言。这个项目的解决方案被存储在一个名为"FolkLoreee"的文件夹内，并且是通过...
Lesson_面向对象继承，多态，接口_实训
07-10
在这个"Lesson_面向对象继承，多态，接口_实训"中，我们将深入探讨这三个关键概念：继承、多态和接口，并通过实践来加深理解。 首先，让我们来看看**继承**。继承是面向对象编程的一个重要特性，它允许一个类（子类...
Lesson-14
03-13
在本课程"Lesson-14"中，我们将深入探讨Java编程语言的核心概念和技术。这个课程主要针对已经对基础编程有所了解的学习者，旨在提升他们在Java领域的技能和理解。标签"Java"表明我们的讨论将集中在这个广泛使用的...
C++——C++11新语法（中）
Wangx_wang的博客
11-06 1035
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
C++_用 using 语句继承基类的构造函数
最新发布
学海无涯
11-09 221
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
C 学习（4）
search7的博客
11-05 855
C语言学习，每个模块来自工作中的？？？
常用的c++特性--＞day02
m0_69093426的博客
11-06 614
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 292
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值