C++基础知识（多态）

最新推荐文章于 2024-09-11 22:33:26 发布
最新推荐文章于 2024-09-11 22:33:26 发布
阅读量752 收藏 22
点赞数 12
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81389826/article/details/135735766
版权

目录

1、静态联编和动态联编

2、多态原理解析

3、多态案例——计算器案例

4、抽象类和纯虚函数

5、纯虚函数和多继承

 6、向上类型转换和向下类型转换

 7、多态案例二——PK游戏需求

1、静态联编和动态联编
  • 多态分类

       静态多态：函数重载

       动态多态：虚函数  继承关系

  • 静态联编：地址早绑定 编译阶段绑定好地址
  • 动态联编：地址晚绑定 运行时候绑定好地址
  • 多态：父类的引用或者指针指向子类对象
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
 
class Cat :public Animal
{
	virtual void speak()  //virtual可写也可不写
	{
		cout << "小猫在说话" << endl;
	}
};
 
//调用doSpeak，speak函数的地址早就绑定好了，早绑定，静态联编  编译阶段就确定好了地址
//如果想调用猫的speak，不能提前绑定好函数的地址了，所以需要在运行时再去确定函数地址
//动态联编，写法doSpeak改为虚函数，在父类上声明虚函数，发生了多态
//父类的引用或者指针  指向  子类对象
void doSpeak(Animal & animal)  //Animal & animal = cat
{
	animal.speak();
}
//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);
}
 
int main()
{
	test01();
	system("pause");
	return 0;
}
2、多态原理解析
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
 
class Cat :public Animal
{
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
};
 
//调用doSpeak，speak函数的地址早就绑定好了，早绑定，静态联编  编译阶段就确定好了地址
//如果想调用猫的speak，不能提前绑定好函数的地址了，所以需要在运行时再去确定函数地址
//动态联编，写法doSpeak改为虚函数，在父类上声明虚函数，发生了多态
//父类的引用或者指针  指向  子类对象
void doSpeak(Animal & animal)  //Animal & animal = cat
{
	animal.speak();
}
//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);
}
 
void test02()
{
	//cout << sizeof(Animal) << endl;
	//父类指针指向子类对象 多态
	Animal *animal = new Cat;
	//animal->speak();
	//*(int*)*(int*)animal 函数地址   *(int*)animal虚函数表
	((void(*)()) (*(int*)*(int*)animal))();
}
 
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

父类：Animal

子类：Cat

可以看出，子类将speak()重写为自己的，所以输出才会是“小猫在说话”。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
	virtual void eat()
	{
		cout << "动物在吃饭" << endl;
	}
};
 
class Cat :public Animal
{
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
	virtual void eat()
	{
		cout << "小猫在吃鱼" << endl;
	}
};
 
//调用doSpeak，speak函数的地址早就绑定好了，早绑定，静态联编  编译阶段就确定好了地址
//如果想调用猫的speak，不能提前绑定好函数的地址了，所以需要在运行时再去确定函数地址
//动态联编，写法doSpeak改为虚函数，在父类上声明虚函数，发生了多态
//父类的引用或者指针  指向  子类对象
void doSpeak(Animal & animal)  //Animal & animal = cat
{
	animal.speak();
}
//如果发生了继承的关系，编译器允许进行类型转换
void test01()
{
	Cat cat;
	doSpeak(cat);
}
 
void test02()
{
	//cout << sizeof(Animal) << endl;
	//父类指针指向子类对象 多态
	Animal *animal = new Cat;
	//animal->speak();
	//*(int*)*(int*)animal 函数地址   *(int*)animal虚函数表
	((void(*)()) (*(int*)*(int*)animal))();
	//猫吃鱼的地址 *((int*)*(int*)animal+1)
	((void(*)())(*((int*)*(int*)animal + 1)))();
}
 
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}
3、多态案例——计算器案例
  • 早期方法 是不利于扩展
  • 开发有原则  开闭原则  --  对扩展开放  对修改关闭
  • 利用多态实现 – 利于后期扩展，结构性非常好，可读性高， 效率稍微低，发生多态内部结构复杂
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
//class Calculator
//{
//public:
//	void setv1(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;
//};
//
//void test01()
//{
//	Calculator cal;
//	cal.setv1(10);
//	cal.setv2(10);
//	cout << cal.getResult("+") << endl;
//	cout << cal.getResult("-") << endl;
//}
 
//真正的开发中，有个开发原则，开闭原则
//对扩展开放，对修改关闭
 
//利用多态实现计算器
class abstractCalculator
{
public:
	virtual int getResult()
	{
		return 0;
	};
 
	void setv1(int v)
	{
		this->val1 = v;
	}
	
	void setv2(int v)
	{
		this->val2 = v;
	}
 
public:
	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 MultiCalculator:public abstractCalculator
{
public:
	virtual int getResult()
	{
		return val1 * val2;
	}
};
 
void test02()
{
	abstractCalculator *abc;//加法计算器
	abc = new PlusCalculator;
 
	abc->setv1(10);
	abc->setv2(20);
	cout << abc->getResult() << endl;
	delete abc;
 
	abc = new SubCalculator;
	abc->setv1(10);
	abc->setv2(20);
	cout << abc->getResult() << endl;
	delete abc;
 
	abc = new MultiCalculator;
	abc->setv1(10);
	abc->setv2(20);
	cout << abc->getResult() << endl;
}
 
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}
4、抽象类和纯虚函数

       在设计时，常常希望基类仅仅作为其派生类的一个接口。这就是说，仅想对基类进行向上类型转换，使用它的接口，而不希望用户实际的创建一个基类的对象。同时创建一个纯虚函数允许接口中放置成员原函数，而不一定要提供一段可能对这个函数毫无意义的代码。

  • 纯虚函数写法  virtual void func() = 0;
  • 抽象类型
  • 抽象类 不可以实例化对象
  • 如果类 继承了抽象类， 必须重写抽象类中的纯虚函数
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
//真正的开发中，有个开发原则，开闭原则
//对扩展开放，对修改关闭
 
//利用多态实现计算器
class abstractCalculator
{
public:
	//虚函数
	/*virtual int getResult()
	{
		return 0;
	};*/
	//纯虚函数
	//如果父类中有了纯虚函数，那么子类继承父类则必须实现纯虚函数
	//如果父类中 有了纯虚函数，这个父类 就无法实例化对象了
	//这个类有了纯虚函数，通常又称为 抽象类
	virtual int getResult() = 0;
	
	void setv1(int v)
	{
		this->val1 = v;
	}
 
	void setv2(int v)
	{
		this->val2 = v;
	}
 
public:
	int val1;
	int val2;
};
 
class A :public abstractCalculator
{
 
 
};
 
 
 
//加法计算器
class PlusCalculator :public abstractCalculator
{
public:
	virtual int getResult()
	{
		return val1 + val2;
	}
};
 
//减法计算器
class SubCalculator :public abstractCalculator
{
public:
	virtual int getResult()
	{
		return val1 - val2;
	}
};
 
class MultiCalculator :public abstractCalculator
{
public:
	virtual int getResult()
	{
		return val1 * val2;
	}
};
 
void test02()
{
	abstractCalculator *abc;//加法计算器
	abc = new PlusCalculator;
 
	abc->setv1(10);
	abc->setv2(20);
	cout << abc->getResult() << endl;
	delete abc;
 
	abc = new SubCalculator;
	abc->setv1(10);
	abc->setv2(20);
	cout << abc->getResult() << endl;
	delete abc;
 
	abc = new MultiCalculator;
	abc->setv1(10);
	abc->setv2(20);
	cout << abc->getResult() << endl;
 
	//A a;  不允许使用抽象类的对象，因为在A中没有实现父类的纯虚函数
	//如果父类有了纯虚函数，这个父类就无法实例化对象
	//abstractCalculator *ab = new abstractCalculator; 
	//abstractCalculator aaa;
}
 
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}
5、纯虚函数和多继承

虚析构：用于解决   在释放基类指针（指向的是子类对象）时，不能调用子类的析构函数的问题。

  • virtual ~类名() {}
  • 解决问题： 通过父类指针指向子类对象释放时候不干净导致的问题
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
 
	//普通析构 是不会调用子类的析构的，所以可能会导致释放不干净
	//利用虚析构来解决
	virtual ~Animal()
	{
		cout << "Animal的析构调用" << endl;
	}
};
 
class Cat:public Animal
{
public:
	Cat(const char * name)
	{
		this->m_Name = new char[strlen(name) + 1];
		strcpy(this->m_Name, name);
	}
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
 
	~Cat()
	{
		cout << "Cat的析构调用" << endl;
		if (this->m_Name != NULL)
		{
			delete[] this->m_Name;
			this->m_Name = NULL;
		}
	}
	char * m_Name;
};
 
 
void test01()
{
	Animal *animal = new Cat("TOM");
	animal->speak();
	delete animal;
}
 
int main()
{
	test01();
	system("pause");
	return 0;
}

纯虚析构：写法  virtual ~类名() = 0

                  类内声明  类外实现

                 如果出现了纯虚析构函数，这个类也算抽象类，不可以实例化对象

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
 
	//普通析构 是不会调用子类的析构的，所以可能会导致释放不干净
	//利用虚析构来解决
	/*virtual ~Animal()
	{
		cout << "Animal的析构调用" << endl;
	}*/
 
	//纯虚析构  需要声明 还需要实现  类内声明，类外实现
	virtual ~Animal() = 0;//纯虚析构写法
	//如果函数中出现了 纯虚析构函数，那么这个类也算抽象类
	//抽象类  不可实例化对象
	
};
 
Animal::~Animal()
{
	//纯虚析构函数的实现
	cout << "Animal的纯虚析构调用" << endl;
}
 
// 如果出现了纯虚析构函数，这个类也算抽象类，不可以实例化对象
void func()
{
	//Animal an;  栈       栈和堆都不可以实例化对象
	//Animal *animal = new Animal; 堆
}
 
class Cat:public Animal
{
public:
	Cat(const char * name)
	{
		this->m_Name = new char[strlen(name) + 1];
		strcpy(this->m_Name, name);
	}
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
 
	~Cat()
	{
		cout << "Cat的析构调用" << endl;
		if (this->m_Name != NULL)
		{
			delete[] this->m_Name;
			this->m_Name = NULL;
		}
	}
	char * m_Name;
};
 
 
void test01()
{
	Animal *animal = new Cat("TOM");
	animal->speak();
	delete animal;
}
 
int main()
{
	test01();
	system("pause");
	return 0;
}
 6、向上类型转换和向下类型转换
  • 基类转派生类

            向下类型转换  不安全的

  • 派生类转 基类

            向上类型转换  安全

  • 如果发生多态

           总是安全的

  • 父类中如果写了虚函数，而子类没有任何重写，有意义吗？

          没有意义

 7、多态案例二——PK游戏需求

鄠邑原野
关注
专栏目录
C++多态基础知识
log_Li的博客
07-18 169
多态 C++中所谓的多态(polymorphism)是指,由继承而产生的相关的不同的类,其对象 对同一消息会作出不同的响应。 多态性是面向对象程序设计的一个重要特征,能增加程序的灵活性。可以减轻 系统 升级,维护,调试的工作量和复杂度. C++中通过virtual关键字对多态进行支持 使用virtual声明的函数被重写后即可展现多态特性  多态成立的条件 多态是设计模式的基础，多态是框架的基础 静态联编和动态联编 1、联编是指一个程序模块、代码之间互相关联的过程。  2、静态联编（static b
[C++]---多态及相关知识
夜微雨的博客
03-06 249
一.多态定义及实现 1.1概念 具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。 举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。 多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。 1.2实现多态 多态条件： 前提：继承条件下； 父类存在虚函数，且子类完成该虚函数的重写。 函数重写：子类父类存...
C++基础知识（封装继承多态）
壹的博客
03-26 1250
面试要点：C++的封装继承多态
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
c++_多态基础知识
zg915355901的博客
12-22 173
1，多态：一个接口，多种方法，程序运行时才决定调用的函数。 2，多态性是接口与实现进行分离。 3，虚函数：virtual修饰的函数，虚函数的限制 （1，静态成员函数不能定义虚函数 （2，构造函数不能定义虚函数，析构函数可以。 （3，声明需要virtual修饰，定义不用 （4，基类某一函数为虚函数，子类同名函数（函数名，参数，返回值），自动成为虚函数 4，纯虚函数：虚函数=0；-> virtu...
C++基础知识 - 为什么要使用多态特性
骆驼胡杨的博客
02-23 763
为什么要使用多态特性 项目需求： 因为各种不确定原因，包括认为原因，ODU设备会自动的切换到其它类型的设备，而切换后的设备，和原设备有很多不同的地方。如何完美的实现这个切换呢？ 解决方案： 使用多态。 只需要在基类函数前添加 virtual virtual void func() { std::cout << “调用Father类函数” << std::endl; } Father类 #pragma once #include <iostream> class Fa
c++基础知识.zip
05-13
C++是一种广泛使用的面向对象的编程语言，由Bjarne Stroustrup于1983年在C语言的基础上发展而来。C++不仅保留了C语言的效率和灵活性，还引入了面向对象编程的概念，如类、对象、继承、封装和多态等。这些概念是理解...
C++基础课件，讲述C++基础知识
06-20
本基础课件旨在全面介绍C++的基础知识，帮助初学者理解和掌握C++编程的基本概念和技术。 课件内容可能涵盖以下几个关键知识点： 1. **C++简介**：介绍C++的历史、特点和适用领域，以及与C语言的区别。 2. **基本...
C++基础知识大全
热门推荐
weixin_49199646的博客
10-31 1万+
秋招基本尘埃落定了，打算总结一下C++学习路线的相关知识，今天是第一篇：C++基础知识总结。 面向对象的三大特性： 1、封装：把客观事物抽象为类，包含自己的属性和方法。 2、继承：使用现有类的所有功能，在无需重新编写原有类的情况下对类的功能进行拓展。被继承的类成为父类或基类，继承的类成为子类或派生类。 3、多态：一种形式，多种状态，分为静态多态和动态多态。静态多态指编译时多态，如函数重载、模板；动态多态指运行时多态，特指virtual虚函数机制形成的多态。 类的访问权限：private、protected
c++基础知识总结
m0_72582315的博客
10-09 1709
1.浅谈一下c和c++的理解？c语言是一个面向过程的一种语言、c++是一种面向对象的一种语言面向过程：就是按部就班一步一步来，想到每一个步骤需要调用什么函数，按照顺序调用函数。面向对象：就是把问题分解成一个个对象，而对象不是为了解决某一个步骤，而是为了描述事物在解决过程中的行为。2.指针和引用的区别？3.值传递、地址传递、引用传递的区别？值传递：实参把值传递给形参、与原来的实参就没有关系、相当于产生了一个新变量、一个新的地址。地址传递：形参的改变会影响实参，会创建一个指针变量开辟一个新空间，指针保存着实参的
C++与QML的数据交互
qq_50679120的博客
09-11 473
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 247
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 443
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 883
set、map仿STL模拟实现
C++位图的实现与详解
2301_80468112的博客
09-09 669
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
【C++ && Qt day11】
wzj46的博客
09-11 258
2、头文件窗口文件。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1035
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
C++ lambda闭包消除类成员变量
最新发布
随手写下笔记和感悟
09-11 440
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
C++（二）----类和对象
weixin_73579966的博客
09-11 774
众所周知，C++与C语言不同的地方就是，C++引入了类和对象，可以在兼容C语言的同时面向对象编程，同时具备了封装、继承、多态三种特点（划重点）。面向对象可以说是C++最重要的部分了，而类和对象就是面向对象的基础，所以这一节我们学习类和对象。
C++基础知识解析：关系表达式与程序结构
"C++基础知识讲解，关系表达式及其在编程中的应用" 在C++编程语言中，关系表达式是程序设计中的重要组成部分，它们由关系运算符连接两个或多个算术表达式，用于进行比较并产生布尔结果。关系表达式主要用于逻辑判断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值