Day 14 C++面向对象之多态

LXS_357

916人浏览 · 2025-12-02 17:34:48

LXS_357 · 2025-12-02 17:34:48 发布

Day 14 C++面向对象之多态

一、多态的基本概念

多态是C++面向对象三大特性之一。多态分为两类：

静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态

二者区别：

静态多态的函数地址早绑定 - 编译阶段确定函数地址
动态多态的函数地址晚绑定 - 运行阶段确定函数地址

若写执行函数时，函数内调用的是父类的同名函数，这个时候不管传的参数是那个子类的对象，最终调用输出的函数始终是父类的函数，若在父类的同名函数之前加关键字 virtual 则将此函数虚化，再调用时，传的是哪个对象就是调用哪个子类对象的函数

//动物类
class Animal
{
public:
	//加上virtual虚函数的字样，表示这个函数是虚函数，子类和父类有同名函数时，就会传什么参数就给什么参数的函数了
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};

//猫类
class Cat :public Animal//继承
{
public:
	void speak()//当子类和父类有相同的函数名时，若不特意指定，最终实现的就是父类的函数
	{
		cout << "小猫喵喵喵" << endl;
	}

};

//狗类
class Dog :public Animal
{
public:
	void speak()
	{
		cout << "小狗汪汪汪" << endl;
	}
};
//执行说话的函数
//地址早绑定，在编译阶段就确定了函数的地址
void doSpeak(Animal &animal)//Animal 的一个引用&animal = cat
{
	//这里调用的animal的函数，所以不管传什么样的动物，都是调用的动物的speak函数
	animal.speak();//父类的引用可以直接指向子类的引用
	//若想要执行的是指定动物说话，函数地址就不能早绑定，要晚绑定,父类函数＋virtual
}
void test01()
{
	Cat cat;//创建的对象是猫
	Dog dog;
	//本意是传什么就是什么在说话
	doSpeak(cat);
	doSpeak(dog);
}

动态多态满足条件：

得有一个继承关系；
子类要重写父类的虚函数（virtual），父类必须加这个 virtual 关键字；子类可加可不加

动态多态的使用：

父类的指针或引用，指向子类的对象

//执行函数的参数是父类的对象
void doSpeak(Animal &animal)//Animal &animal = cat
{
    ...
}

剖析：

void test02()
{
	cout << "size of Animal:" << sizeof(Animal) << endl;//不加virtual是1，加virtual是4
	//4个字节为指针
}

添加virtual时候，相当于在Animal内写了一个指针 vfptr （virtual function pointer虚函数指针），这虚函数指针对指向一个虚函数表（vftable），表内部记录虚函数的入口地址（&Animal：：speak）

若猫类 Cat 的函数没有发生重写，只是继承 Animal ，则Animal中的内容都会被继承一份（&Aniaml：：speak）。当子类重写了父类的虚函数，子类中的虚函数表内部会被替换成子类的虚函数地址（&Cat：：speak），父类没有发生改变，还是原来的

当父类的指针或者引用来指向子类对象的时候，发生多态，会从子类的虚函数表中去走子类的函数

//执行函数的参数是父类的对象
void doSpeak(Animal &animal)//Animal &animal = cat,当传的对象是猫时，就会走子类的表中的地址
{
    animal.speak();
}

二、多态案例1—计算器类

分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

多态的优点：代码组织结构清晰；可读性强；利用前期和后期的扩展及维护

//普通写法
class Calculator
{
public:
	int getResult(string oper)
	{
		if (oper == "+") {
			return m_Num1 + m_Num2;
		}
		else if (oper == "-") {
			return m_Num1 - m_Num2;
		}
		else if (oper == "*") {
			return m_Num1 * m_Num2;
		}
		//若想要扩展新的功能，需要修改源代码
	    //在真实开发中，提倡开闭原则
		//开放原则：对扩展进行开放，对修改进行关闭
	}
	int m_Num1;
	int m_Num2;
};

//多态写法：
//实现一个计算器的基类/抽象类，这个抽象类中什么功能都不写
class AbstractCalculator
{
public:
	virtual int getResult()//添加virtual实现多态
	{
		return 0;
	}
	int m_Num1;
	int m_Num2;
};
//加法计算器类
class AddCalculator:public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 + m_Num2;
	}
};
//减法
class SubCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};
//乘法
class MulCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};
//除法
class BubCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 / m_Num2;
	}
};
void test01()
{
	//创建一个计算器的对象
	Calculator c;
	c.m_Num1 = 8;
	c.m_Num2 = 4;
	cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;
}
void test02()
{
    //加法
	AbstractCalculator * a = new AddCalculator;//new创建的对象存放在堆区，用完之后记得销毁delete a；
	a->m_Num1 = 8;
	a->m_Num2 = 4;
	cout << a->m_Num1 << "+" << a->m_Num2 << "=" << a->getResult() << endl;//8+4=12
	delete a;
    //乘法
	a = new MulCalculator;
	a->m_Num1 = 8;
	a->m_Num2 = 4;
	cout << a->m_Num1 << "*" << a->m_Num2 << "=" << a->getResult() << endl;//8*4=32
	
}

多态时，需要添加算法，只需要继承父类进行扩展就可，不用修改源码

三、纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改写为纯虚函数，纯虚函数的语法：

virtual 返回值类型 函数名 （参数列表）=0;

当类中有了纯虚函数，这个类也称为抽象类，抽象类特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也属于抽象类

class Base//抽象类
{
public:
	virtual void func() = 0;//一定是在虚函数的基础上写=0，现在就是纯虚函数
	//只要有一个纯虚函数，这个类就是抽象类
};
class Son :public Base
{
public:
	void func()
	{
		cout << "这是儿子" << endl;
	}
};
void test01()
{
	//Base b;//报错，因为抽象类无法实例化对象
    //new Base;//报错，因为也不允许使用抽象类实例化对象
    Son s;//必须要重写父类的虚函数，否则报错
    Base *base=new Son;
    base->func();//调用的是子类的函数
}

四、多态案例2–制作饮品

制作饮品的流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态实现，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

//1.父类基类
class AbstractDrink
{
public://写4个步骤的纯虚函数
	virtual void Boil() = 0;
	virtual void Brew() = 0;
	virtual void PourInCut() = 0;
	virtual void AddSomting() = 0;
	void makeDrink()
	{
		Boil();
		Brew();
		PourInCut();
		AddSomting();
	}
};
//2.子类：咖啡
class Coffee:public AbstractDrink
{
public:
	void Boil()
	{
		cout << "煮水" << endl;
	}
	void Brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	void PourInCut()
	{
		cout << "倒入杯中" << endl;
	}
	void AddSomting()
	{
		cout << "添加奶泡" << endl;
	}
};
//3.子类：茶
class Tea :public AbstractDrink
{
public:
	void Boil()
	{
		cout << "煮矿泉水" << endl;
	}
	void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	void PourInCut()
	{
		cout << "倒入茶杯中" << endl;
	}
	void AddSomting()
	{
		cout << "添加枸杞" << endl;
	}
};
void doWork(AbstractDrink *a)//父类指针指向子类对象，
{
	a->makeDrink();//一个接口有多个形态，根据传入的对象去调用对应的函数
	//a为指针，存放在堆区，用完要释放
	delete a;
}
void test01()
{
	//制作咖啡
	doWork(new Coffee);//形参是父类，实参是子类
	doWork(new Tea);
}

五、虚析构和纯虚析构

多态使用时，父类的指针或引用去指向子类的对象，但如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。解决方法就是将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象；
都需要有具体的函数实现；

区别：如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：virtual ~类名（）{}

纯虚析构语法：virtual ~类名（）=0；或者类名::~类名()()

虚析构可以解决父类指针释放子类对象时不干净的问题

class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}
	/*
	virtual ~Animal()//虚析构
	{
		cout << "Animal的析构函数调用" << endl;
	}
	*/
	//纯虚析构，需要声明也需要实现，这里是声明
	virtual ~Animal() = 0;
	virtual void speak() = 0;//纯虚函数
};
Animal:: ~Animal()//在类外重写函数，前面Animal：：表示告知是Animal内部的函数
{
	cout << "Animal纯虚析构的调用" << endl;
}
class Cat :public Animal
{
public:
	Cat(string name)
	{
		cout << "Cat的构造函数调用" << endl;
		m_Name = new string(name);//new返回的是一个string的指针
		//堆区创建的属性，需要释放，提供对应的析构函数
	}
	void speak()
	{
		cout << *m_Name<<"小猫喵喵喵" << endl;
	}
	~Cat()
	{
		if (m_Name != NULL)
		{
			cout << "Cat的析构函数的调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	string *m_Name;//指针
};
void test01()
{
	Animal * animal = new Cat("Tom");//创建一个猫对象时，会先调用父类构造，先有父类再有子类，
	animal->speak();
	delete animal;//父类的指针在析构的时候，不会调用子类的析构函数，如果子类有堆区的数据，会造成子类的内存的泄露情况
	//解决，把父类的析构改回虚函数，这样就会走子类的析构，再去走父类的析构
}

有一些属性开设在子类的堆区了，所以需要释放，但防止释放不干净，所以需要写虚析构或纯虚析构去走子类的析构函数，使之释干净，若不写，就是只走父类的析构函数。纯虚析构需要声明也需要实现

总结：

虚析构和纯虚析构都是用来解决通过父类指针释放子类对象；
如果子类中没有堆区数据，可以不写虚析构或者纯虚析构；
拥有纯虚析构函数的类也属于抽象类，不可以用来实例化对象

六、多态案例三-电脑组装

电脑主要组成部件为CPU（用于计算）、显卡（用于显示）、内存条（用于存储）

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口；测试时组装三台不同的电脑进行工作

//抽象出每个零件的类，抽象类就是接口，只写，但不实现，在子类中进行重写进行实现
class CPU
{
public:
	//CPU的计算函数
	virtual void calculate() = 0;
};
class VideoCard
{
public:
	//显卡的显示函数
	virtual void display() = 0;
};
class Memory
{
public:
	//内存的存储函数
	virtual void storage() = 0;
};

class Computer
{
	//构造函数中传入三个零件的指针
public:
	Computer(CPU * cpu, VideoCard * vc, Memory * mem)
	{
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}
	~Computer()
	{
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}
		if (m_vc != NULL)
		{
			delete m_vc;
			m_vc = NULL;
		}
		if (m_mem != NULL)
		{
			delete m_mem;
			m_mem = NULL;
		}
	}
	//提供工作函数
	void work()
	{
		//让零件工作起来，调用零件的接口，就是抽象类的虚函数
		m_cpu->calculate();
		m_vc->display();
		m_mem->storage();
	}
private:
	CPU * m_cpu;
	VideoCard * m_vc;
	Memory * m_mem;
};
//具体零件厂商
class IntelCPU: public CPU
{
public:
	void calculate()
	{
		cout << "Intel的CPU开始计算了" << endl;
	}
};
class IntelVideoCard :public VideoCard
{
public:
	void display()
	{
		cout << "Intel的显卡开始显示了" << endl;
	}
};
class IntelMemory :public Memory
{
public:
	void storage()
	{
		cout << "Intel的内存开始存储了" << endl;
	}
};
class LenovoCPU : public CPU
{
public:
	void calculate()
	{
		cout << "Lenovo的CPU开始计算了" << endl;
	}
};
class LenovoVideoCard :public VideoCard
{
public:
	void display()
	{
		cout << "Lenovo的显卡开始显示了" << endl;
	}
};
class LenovoMemory :public Memory
{
public:
	void storage()
	{
		cout << "Lenovo的内存开始存储了" << endl;
	}
};
//若有不同的厂商，直接在后面追加即可
void test01()
{
	//第一台电脑的零件
	CPU* intelCPU = new IntelCPU;
	VideoCard* intelCard = new IntelVideoCard;
	Memory* intelMem = new IntelMemory;
	//创建第一台电脑
	Computer* computer = new Computer(intelCPU, intelCard, intelMem);
	computer->work();
	delete computer;
	//创建后续2台电脑
	/*
	CPU* lenovoCPU = new LenovoCPU;
	VideoCard* lenovoCard = new LenovoVideoCard;
	Memory* lenovoMem = new LenovoMemory;
	Computer* computer2 = new Computer(lenovoCPU, lenovoCard, lenovoMem);
	*/
	Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
	computer2->work();
	delete computer2;

	CPU* intel1CPU = new IntelCPU;
	VideoCard* lenovo1Card = new LenovoVideoCard;
	Memory* intel1Mem = new IntelMemory;
	Computer* computer3 = new Computer(intel1CPU, lenovo1Card, intel1Mem);
	computer3->work();
	delete computer3;
}

tips:

重写：函数名相同，参数列表相同，返回值类型相同（完全相同）

重载：函数名相同，但参数不同

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

自建 MCP 浏览器自动化服务：给 AI Agent 装上“能登录的手“

AI Agent技术社区

AI Agent 前端自学路线（四）

本文阐述了AI Agent四大核心模块与前端的映射关系：1）规划器（Planner）类比Promise链/Redux Saga，负责任务拆解和状态管理；2）工具调用（Tool Use）相当于Service层，通过标准化接口实现功能调用；3）记忆模块（Memory）对应状态管理与存储，包含短期对话记忆和长期向量化存储；4）任务拆解（Task Decomposition）采用组件化思维，通过递归执行处