C++ 多态

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

文章目录

1 多态的基本概念

同一个操作作用于不同的对象，可以有不同的解释，会产生不同的效果，这就是多态。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class People
{
public:
	//虚函数
	virtual void Mypro()
	{

	}
};
//1.有继承
class xishi :public People
{
public:
	//2.重写父类的虚函数
	virtual void Mypro()
	{
		cout << "约西施" << endl;
	}
};

class wangzhaojun :public People
{
public:
	
	//重写父类的虚函数
	virtual void Mypro()
	{
		cout << "约王昭君" << endl;
	}
	
};



class diaochan :public People
{
public:
	//重写父类的虚函数
	virtual void Mypro()
	{
		cout << "约貂蝉" << endl;
	}
};

class yangguifei :public People
{
public:
	//重写父类的虚函数
	virtual void Mypro()
	{
		cout << "约杨贵妃" << endl;
	}
};


//同一个操作
void doLogin(People *pro)
{
	pro->Mypro();//产生不同的效果
}

void test()
{
	People *pro = NULL;
	//3.父类指针指向子类对象
	pro = new xishi;
	doLogin(pro);//不同的对象
	delete pro;

	pro = new wangzhaojun;
	doLogin(pro);//不同的对象
	delete pro;

	pro = new diaochan;
	doLogin(pro);//不同的对象
	delete pro;

	pro = new yangguifei;
	doLogin(pro);//不同的对象
	delete pro;
	pro = NULL;

	
	
}

int main()
{
	test();

	system("pause");
	return EXIT_SUCCESS;
}

2.多态有什么用

1.可以解决项目中的紧耦合问题,提供程序的可扩展性

2.应用程序不必为每一个子类的功能调用编写代码，只需要对抽象的父类进行处理

3.多态发生的三个条件

1.有继承。2.重写父类的虚函数。3.父类指针指向子类对象

4.多态的实现原理（重点难点）

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak()
	{
		cout << "Anima speak()" << endl;
	}
	
};
class Dog :public Animal
{
public:
	virtual void speak()
	{
		cout << "Dog speak()" << endl;
	}
};

void test()
{
	cout << sizeof(Animal) << endl;

	Animal *animal = new Dog;
	animal->speak();
}

int main()
{
	test();
	system("pause");
	return EXIT_SUCCESS;
}

5.纯虚函数和抽象类(重点)

1.依赖倒转
业务层依赖抽象层，实现层依赖抽象层

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//抽象层
//有纯虚函数的类叫抽象类，不能实例化对象
class rule
{
public:
	//纯虚函数
	virtual int getnum(int a, int b) = 0;
};

//实现层
class plus_rule :public rule
{
public:
	virtual int getnum(int a, int b)//重写父类的虚函数，依赖抽象层
	{
		return a + b;
	}
};

class miux_rule :public rule
{
public:
	virtual int getnum(int a, int b)
	{
		return a - b;
	}
};


//业务层
int doLogin(rule* cal)
{

	int a = 10;
	int b = 20;


	int ret = cal->getnum(a, b);//依赖抽象层

	return ret;

}

void test()
{
	rule* r = NULL;
	r = new plus_rule;
	cout << doLogin(r) << endl;
	delete r;

	r = new miux_rule;
	cout << doLogin(r) << endl;
	delete r;
}
void test02()
{
	//抽象类不能实例化对象
	//rule r;
}

class Maker
{
public:
	virtual void func1() = 0;
	virtual void func2() = 0;
};

class Son :public Maker
{
public:
	virtual void func1()
	{

	}
	virtual void func2()
	{

	}
};

void test03()
{
	Son s;
}

int main()
{
	test();
	system("pause");
	return EXIT_SUCCESS;
}

2.开闭原则
对修改源代码关闭，对扩展新功能开发
3.纯虚函数

class rule
{
public:
	//纯虚函数
	virtual int getnum(int a, int b) = 0;
};

4.抽象类
1.有纯虚函数的类叫抽象类，不能实例化对象

//有纯虚函数的类叫抽象类，不能实例化对象
class rule
{
public:
	//纯虚函数
	virtual int getnum(int a, int b) = 0;
};

void test02()
{
	//抽象类不能实例化对象
	//rule r;
}

2.如果子类继承抽象类，子类必须实现抽象类的所有纯虚函数，不然子类也变为抽象类

class Maker
{
public:
	virtual void func1() = 0;
	virtual void func2() = 0;
};

class Son :public Maker
{
public:
	virtual void func1()
	{

	}
	virtual void func2()
	{

	}
};

void test03()
{
	Son s;
}

6 接口的定义（了解）

1.所谓的接口，即将内部实现细节封装起来，外部用户用过预留的接口可以使用接口的功能而不需要知晓内部具体细节。C++中，通过类实现面向对象的编程，而在基类中只给出纯虚函数的声明，然后在派生类中实现纯虚函数的具体定义的方式实现接口，不同派生类实现接口的方式也不尽相同

//抽象类
class Father
{
public:
	virtual void func1() = 0;//接口的声明
	virtual void func2(int a) = 0;
	virtual void func3(int a,int b) = 0;
};

class Son :public Father
{
public:
	virtual void func1()//接口的实现
	{

	}
	virtual void func2(int a)
	{

	}
	virtual void func3(int a, int b)
	{

	}
};

7 模板方法(重点)

在抽象类中确定好函数的调用顺序

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class Drink
{
public:
	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//导入杯中
	virtual void PourInCup() = 0;
	//加点辅料
	virtual void addSonm() = 0;

	//模版方法,把调用函数的顺序确定下来
	void func()
	{
		Boil();
		Brew();
		PourInCup();
		addSonm();
	}
};

class Coffee :public Drink
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮点露水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "拿铁" << endl;
	}
	//导入杯中
	virtual void PourInCup()
	{
		cout << "导入盆中" << endl;
	}
	//加点辅料
	virtual void addSonm()
	{
		cout << "加点大蒜" << endl;
	}
};

class Tea :public Drink
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮点自来水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "铁观音" << endl;
	}
	//导入杯中
	virtual void PourInCup()
	{
		cout << "倒入碗中" << endl;
	}
	//加点辅料
	virtual void addSonm()
	{
		cout << "加点酱油" << endl;
	}
};



void test()
{
	Drink* dr = NULL;
	dr = new Coffee;
	dr->func();
	delete dr;

	dr = new Tea;
	dr->func();
	delete dr;
	dr = NULL;
}

int main()
{
	test();
	system("pause");
	return EXIT_SUCCESS;
}

8 虚析构函数和纯虚析构函数（重点）

1.虚析构函数是为了解决基类指针指向派生类对象，并用基类指针释放派生类对象
2.纯虚析构函数，有纯虚析构函数的类是抽象类，不能实例化对象
注意：纯虚析构函数需要在类外实现

class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造" << endl;
	}

	//虚析构函数会调用子类的析构函数
	virtual ~Animal()
	{
		cout << "Animal的析构" << endl;
	}
};

class Son :public Animal
{
public:
	Son()
	{
		cout << "Son的构造" << endl;
		pName = new char[64];
		memset(pName, 0, 64);
		strcpy(pName, "如花");
	}

	~Son()
	{
		cout << "Son的析构" << endl;
		if (pName != NULL)
		{
			delete[] pName;
			pName = NULL;
		}
	}

public:
	char *pName;
};

void test()
{
	Animal *animal = new Son;
	delete animal;
}

9 父类引用子类对象（了解）

class Animal
{
public:
	virtual void speak()
	{
		cout << "Animal speak()" << endl;
	}
};

class Dog :public Animal
{
public:
	virtual void speak()
	{
		cout << "Dog speak()" << endl;
	}
};

void test()
{
	Animal &animal = Dog();
	animal.speak();

	Animal* dog = new Dog();
	Animal* &an = dog;
	an->speak();
	delete dog;
}

10 重写，重载，重定义（了解）

1.重载，同一作用域的同名函数

2.重写（覆盖）:

​ 1. 有继承

​ 2.子类（派生类）重写父类（基类）的virtual函数

​ 3.函数返回值，函数名字，函数参数，必须和基类中的虚函数一致

3.重定义（隐藏）

​ 1. 有继承

​ 2.子类（派生类）重新定义父类（基类）的同名成员（非virtual函数）

11 案例1：动物园案例

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
//1.创建动物的基类
class Animal
{
public:
	virtual void speak() = 0;
};

//2.创建动物
class Dog :public Animal
{
public:
	Dog(string name)
	{
		this->name = name;
	}
	virtual void speak()
	{
		cout << "小狗" << name << "汪汪汪" << endl;
	}
private:
	string name;
};

class Dark :public Animal
{
public:
	Dark(string name,string type)
	{
		this->name = name;
		this->type = type;
	}
	virtual void speak()
	{
		cout <<type<<"品牌的"<< "小鸭" << name << "嘎嘎嘎" << endl;
	}
private:
	string name;
	string type;
};

class Tiger :public Animal
{
public:
	Tiger(string name,int age)
	{
		this->name = name;
		this->age = age;
	}
	virtual void speak()
	{
		cout << age << "岁" << "老虎" << name << "嗷嗷嗷" << endl;
	}
private:
	string name;
	int age;

};

//3.创建动物园
class Zoo
{
public:
	Zoo()
	{
		mCapacity = 1024;
		mSize = 0;
		//申请空间，存储Animal*的空间，指针数组
		this->p = new Animal*[mCapacity];
	}

	//增加动物
	int AddAnimal(Animal* animal)
	{
		if (mCapacity == mSize)
		{
			return -1;
		}
		//把指针存储到指针数组
		this->p[mSize] = animal;
		mSize++;

		return 0;
	}

	void StartSpeak()
	{
		for (int i = 0; i < mSize; i++)
		{
			p[i]->speak();
		}
	}

	//析构函数
	~Zoo()
	{
		//先释放指针数组中指针指向的堆区空间
		for (int i = 0; i < mSize; i++)
		{
			if (p[i] != NULL)
			{
				delete p[i];
				p[i] = NULL;
			}
		}

		//释放指针数组
		delete[] p;
		p = NULL;
	}


private:
	Animal* *p;
	int mCapacity;//容量
	int mSize;

};

class Cat :public Animal
{
public:
	Cat(string name)
	{
		this->name = name;
	}
	virtual void speak()
	{
		cout << "小猫" << name << "喵喵" << endl;
	}
private:
	string name;
};

void test()
{
	//创建动物园
	Zoo *zoo = new Zoo;

	//添加动物
	zoo->AddAnimal(new Dog("晋三"));
	zoo->AddAnimal(new Dark("黑鸭", "周黑鸭"));
	zoo->AddAnimal(new Tiger("三胖", 35));

	zoo->AddAnimal(new Cat("小蓝"));
	zoo->StartSpeak();

	//烧了动物园
	delete zoo;
}
//把学员抽象
//建立学员,学员属性：姓名，年龄，性别，特长
//建立班级
//测试


int main()
{
	test();
	system("pause");
	return EXIT_SUCCESS;
}

12 案例2：班级案例

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class rule
{
public:
	virtual double getNum(double a, double b) = 0;
};
//加
class rule_add :public rule
{
public:
	virtual double getNum(double a, double b)
	{
		return a + b;
	}
};
//减
class rule_minux :public rule
{
public:
	virtual double getNum(double a, double b)
	{
		return a - b;
	}
};

//乘
class rule_take :public rule
{
public:
	virtual double getNum(double a, double b)
	{
		return a * b;
	}
};

//除
class rule_division :public rule
{
public:
	virtual double getNum(double a, double b)
	{
		if (b == 0)
		{
			cout << "除数不能为0" << endl;
			return -1.0;
		}
		return a / b;
	}
};

void test()
{
	rule *r = NULL;
	r = new rule_add;
	cout << r->getNum(30,10) << endl;

	r = new rule_minux;
	cout << r->getNum(30, 10) << endl;

	r = new rule_take;
	cout << r->getNum(30, 10) << endl;

	r = new rule_division;
	cout << r->getNum(30, 10) << endl;
}
int main()
{
	test();
	system("pause");
	return EXIT_SUCCESS;
}

13 案例3：技术器案例

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

class Manito
{
public:
	virtual void show() = 0;
};

class Maker :public Manito
{
public:
	Maker(string name, int age, string sex, string Skill)
	{
		this->name = name;
		this->age = age;
		this->sex = sex;
		this->Skill = Skill;
	}
	virtual void show()
	{
		cout << name << "展现" << Skill << endl;
	}

private:
	string name;
	int age;
	string sex;
	string Skill;

};

class Maker2 :public Manito
{
public:
	Maker2(string name, int age, string sex, string Skill)
	{
		this->name = name;
		this->age = age;
		this->sex = sex;
		this->Skill = Skill;
	}
	virtual void show()
	{
		cout << name << "展现" << Skill << endl;
	}

private:
	string name;
	int age;
	string sex;
	string Skill;

};

//班级
class MyClass
{
public:
	MyClass()
	{
		mCapacity = 50;
		mSize = 0;
	
		this->p = new Manito*[mCapacity];
	}

	//增加人员
	void AddManito(Manito* ma)
	{
		if (mSize == mCapacity)
		{
			return;
		}

		this->p[mSize] = ma;
		mSize++;
	}

	//秀技能
	void StartShow()
	{
		for (int i = 0; i < mSize; i++)
		{
			p[i]->show();
		}
	}


	~MyClass()
	{
		for (int i = 0; i < mSize; i++)
		{
			if (p[i] != NULL)
			{
				delete p[i];
				p[i] = NULL;
			}

		}
		
		delete[] p;
		p = NULL;
	}



private:
	Manito* *p;
	int mCapacity;
	int mSize;
};

void test()
{
	MyClass *my = new MyClass;

	my->AddManito(new Maker("Maker", 18, "男", "跳舞"));
	my->AddManito(new Maker2("Maker2", 16, "女", "唱歌"));
	my->StartShow();

	delete my;

	
}
int main()
{
	test();
	system("pause");
	return EXIT_SUCCESS;
}
鬼谷八荒伯特利
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++多态
weixin_50569901的博客
04-20 1万+
C++中的多态分为静态多态和动态多态两种，其中： 静态多态在编译阶段实现，其原理是由函数重载实现，通过不同的实参调用其相应的同名函数。 动态多态通过虚函数实现，以下着重介绍 动态多态的两个必要条件： 必须通过基类的指针或者引用调用 被调用的必须是虚函数，且在派生类中实现了该虚函数的重写 以下解释何为通过基类的指针或者引用调用 int main() { Person p; student s; Person &tmp1 = p; Person &tmp2 = s;//tm
c++多态总结
08-30
c++多态总结，vptr总结，多态原理探究
C++ 多态 超详细讲解
热门推荐
qq_53558968的博客
05-18 5万+
文章目录多态概念引入1、C++中多态的实现1.1 多态的构成条件1.2 虚函数1.3虚函数的重写1.4 C++11 override && final1.5 重载，覆盖(重写)，重定义（隐藏）2、抽象类2.1 抽象类的概念2.2 接口继承和实现继承3、 多态的原理3.1 虚函数表3.2多态的原理3.3动态绑定与静态绑定4 、继承中的虚函数表4.1 单继承中的虚函数表4.2 多继承中的虚函数表other 一些有意思的题目 多态概念引入 多态字面意思就是多种形态。 我们先来想一想在日常生活中
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
c++多态 详解
最新发布
qq_39117115的博客
03-09 988
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++多态详解
米莱虾
10-12 922
目录 多态的概念 多态的实现 虚函数的定义要遵循以下重要规则： 多态的概念 多态现在一般的用法，就是拿一个父类的指针去调用子类中被重写的方法。 那为什么要用多态呢，我们直接在子类中写一个同名的成员函数，从而隐藏父类的函数不是也可以吗? -------- 这是不可以的。下面我们用一个例子来解释为什么要用多态： 将父类比喻为电脑的外设接口，子类比喻为外设，现在我有移动硬盘、U盘以及MP3，它们3个都是可以作为存储但各不相同。在写驱动的时候，用个父类表示外设接口，然后在子类中重写父类那个读取设备..
c++ 多态详解
不倒翁.
05-02 5464
c++多态详解
c++ 多态
RSH的博客
07-24 371
1、多态 多态的基本概念 多态是C++面向对象三大特性之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 虚函数表存放的是虚函数的入口地址，当子类重写了虚函数后，子类会把继承于父类的虚函数表进行覆盖，所以当用父类指针或引用指向子类对象的时候，由于本身还是子类，所以当调用公共接口时，它会从子类去
C++多态（超级详细版）
kkbca的博客
10-28 1万+
在继承中要构成多态还有两个条件：1. 必须通过基类的指针或者引用调用虚函数2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写public:virtual void BuyTicket() { cout
C++多态的底层原理
分享学习的知识，记录我的技术成长道路
04-27 2788
要了解C++多态的底层原理需要我们对C指针有着深入的了解，这个在打印虚表的时候就可以见功底，理解了多态的本质我们才能记忆的更牢，使用起来更加得心应手。
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
C++ 多态的游戏例程
01-20
1）头文件 game.h #ifndef GAME_H #define GAME_H // base class class CCreature { protected: int m_nLifePower， m_nPower; public: virtual void Attack(CCreature *pCreature){} virtual void Hurted...
C++ 多态和虚函数 高清PDF
08-15
多态性（在C + +中用虚函数实现）是面向对象程序设计语言继数据抽象和继承之后的第三个基本特征。 它提供了与具体实现相隔离的另一类接口，即把“ w h a t”从“h o w”分离开来。多态性提高了代码的组织性和可读性...
详解C++ 多态的实现及原理
01-20
C++的多态性用一句话概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用...
C++多态的实现机制深入理解
12-26
在面试过程中C++的多态实现机制经常会被面试官问道。大家清楚多态到底该如何实现吗？下面小编抽空给大家介绍下多态的实现机制。 1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚...
C++ 多态 实例
03-02
在C++编程语言中，多态（Polymorphism）是一种核心特性，它允许不同类型的对象对同一消息作出不同的响应。这个实例将帮助初学者深入理解多态的概念，并通过实际代码来展示其工作原理。 多态分为编译时多态（静态...
c++多态解析1
08-08
C++的多态性是其面向对象特性的重要组成部分，它允许通过父类的指针或引用来调用子类重写后的成员函数，实现了“一个接口，多种实现”的...了解并掌握多态的原理和实现机制，对于编写高效、可维护的C++代码至关重要。
C++多态解释1
08-08
C++的多态性是面向对象编程中的一个核心概念，它允许不同的对象对同一消息做出不同的响应。在C++中，多态性主要通过虚函数（virtual function）来实现。...理解并熟练运用多态是成为专业C++程序员的关键技能之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值