C++的多态

多态是C++面向对象三大特性之一

分为两类：

静态多态：函数重载和运算符重载属于静态多态，复用函数名

动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态区别：

静态多态的函数地址早绑定——编译阶段确定函数地址

动态多态的函数地址晚绑定——运行阶段确定函数地址

class animal
{
public:
	//虚函数，使其变成动态多态
	virtual void speak()
	{
		cout << "说话" << endl;
	}
};


class cat :public animal
{
public:
	void speak()
	{
		cout << "猫说话" << endl;
	}
};

class dog :public animal
{
public:
	//重写 函数返回值类型 函数名 参数列表完全相同
	void speak()
	{
		cout << "狗说话" << endl;
	}
};

//地址早绑定，在编译阶段确定函数地址
//如果想执行让猫说话，那函数地址不能提前绑定，要在运行阶段绑定
//动态多态满足条件：
//1、有继承关系
//2、子类重写父类的虚函数

//动态多态的使用
//父类指针或引用执行子类对象
void test1(animal &A)
{
	A.speak();

}

void test2()//C++中允许父子类型的转换，因此此处直接将cat放入animal的位置就可以了
{
	cat cat;
	test1(cat);

	dog dog;
	test1(dog);
}



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

案例：用普通写法和多态写法实现计算器

普通写法

//分别利用普通写法和多态技术实现计算器

//普通写法
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;

};

void test1()
{
	calculator c;
	c.m_num1 = 2;
	c.m_num2 = 4;
	cout << c.m_num1 << "+" << c.m_num2 << "=" << c.getresult("+") << endl;
	cout << c.m_num1 << "-" << c.m_num2 << "=" << c.getresult("-") << endl;
	cout << c.m_num1 << "*" << c.m_num2 << "=" << c.getresult("*") << endl;
}

int main() {
	test1();

	system("pause");
	return 0;
}

多态写法

//利用多态实现计算器
//多态的好处：
// 1、组织结构清洗
// 2、可读性强
// 3、对于后期扩展和维护性高
//实现计算器抽象类
class abstractcalculator
{
public:
	virtual int getresult()
	{
		return 0;
	}
		int num1;
	int num2;
};

//加法计算器类
class add:public abstractcalculator
{
public:
	virtual int getresult()
	{
		return num1+num2;
	}
};

class sub :public abstractcalculator
{
public:
	virtual int getresult()
	{
		return num1 - num2;
	}
};

class mul :public abstractcalculator
{
public:
	virtual int getresult()
	{
		return num1 * num2;
	}
};

void test2()
{
	//加法运算
	abstractcalculator* abc = new add;
	abc->num1 = 10;
	abc->num2 = 20;
	cout << abc->num1 << "+" << abc->num2 << "=" << abc->getresult() << endl;
	//用完后进行销毁
	delete abc;

	//减法运算
	//虽然进行销毁，但abc的指针类型还是父类的指针，因此不需要再新建，直接赋值即可
	abc = new sub;
	abc->num1 = 10;
	abc->num2 = 20;
	cout << abc->num1 << "-" << abc->num2 << "=" << abc->getresult() << endl;
	delete abc;

	//乘法运算
	abc = new mul;
	abc->num1 = 10;
	abc->num2 = 20;
	cout << abc->num1 << "*" << abc->num2 << "=" << abc->getresult() << endl;
	delete abc;
}

纯虚函数和抽象类

在C++中，通常父类中的虚函数实现是无意义的，主要是调用子类重写的内容，因此可以将虚函数改为纯虚函数，此时这个类叫做抽象类

纯虚函数语法：virtual 返回值类型 函数名 （参数列表） = 0；

抽象类特点：

1、无法实例化对象

2、子类中必须重写抽象类中的纯虚函数，否则也属于抽象类

class base
{
public:
	virtual int getresult() = 0;//创建一个纯虚函数
	//不允许抽象类实例化对象：不能定义base b;

	
		int num1;
	int num2;
};

//加法计算器类
class son:public base
{
public:
	//抽象类的子类，需重写父类中的纯虚函数，否则属于抽象类
	virtual int getresult()
	{
		cout << "func的调用" << endl;
	};
};

void test1()
{
	base* base = new son;
	base->getresult();
	delete base;

}

案例：制作饮品：咖啡或茶

//多态案例：制作音频
class program
{
public:
	virtual void boil() = 0;

	virtual void brew() = 0;

	virtual void pour() = 0;

	virtual void put() = 0;

	void makedrink()
	{
		boil();
		brew();
		pour();
		put();
	};
};

class coffee :public program
{
public:
	virtual void boil()
	{
		cout << "煮" << endl;
	}

	virtual void brew()
	{
		cout << "冲泡" << endl;
	}

	virtual void pour()
	{
		cout << "倒入" << endl;
	}

	virtual void put()
	{
		cout << "加入" << endl;
	}
};

class tea :public program
{
public:
	virtual void boil()
	{
		cout << "煮2" << endl;
	}

	virtual void brew()
	{
		cout << "冲泡2" << endl;
	}

	virtual void pour()
	{
		cout << "倒入2" << endl;
	}

	virtual void put()
	{
		cout << "加入2" << endl;
	}
};

void dowork(program* abs)
{
	abs->makedrink();
	delete abs;
}

void test1()
{
	dowork(new coffee);
}

void test2()
{
	dowork(new tea);
}
int main() {
	test1();
	test2();
	system("pause");
	return 0;
}

虚析构和纯虚析构

多态使用时，如果子类中的属性开辟到堆区，那父类指针在释放时无法调用到子类的析构代码

解决方法：将父类中的析构函数改为虚析构或纯虚析构

虚析构和纯虚析构的共同点：

1、可以解决父类指针释放子类对象

2、都需要由具体的函数实现

虚析构和纯虚析构的区别：

纯虚析构属于抽象类，无法实例化对象

虚析构语法： virtual ~类名( ) { };

纯虚析构语法： virtual ~类名( ) { };

class animal
{
public:
	//纯虚函数
	virtual void speak() = 0;
	animal()
	{
		cout <<  "animal构造" << endl;
	}

	//利用虚析构可以解决父类指针释放子类对象时不干净的问题
	/*virtual ~animal()
	{
		cout << "animal析构" << endl;
	}*/

	//纯虚析构函数
	virtual ~animal() = 0;//需要在类外进行调用才可实现
};
animal::~animal()
{
	cout << "animal 纯虚析构函数" << endl;
}
class cat :public animal
{
public:
	cat(string name)
	{
		cout <<"cat构造" << endl;
		m_name=new string(name);
	}
	virtual void speak()
	{
		cout << *m_name<<"小猫说话" << endl;
	}
	~cat()
	{
		if (m_name != NULL)
		{
			cout << "cat析构" << endl;
			delete m_name;
			m_name = 0;
		}
	}
	string *m_name;
};

void test1()
{
	animal* animal = new cat("tom");
	//父类指针在析构时不会调用子类中的析构函数，导致子类中如果有堆区属性，出现内存泄漏
	animal->speak();
	delete animal;
}

int main() {
	test1();

	system("pause");
	return 0;
}

案例3：组装电脑

//电脑组装案例
//抽象出不同零件的抽象类
class cpu
{public:
	virtual void calculator() = 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_men = mem;
	}

	void work() 
	{
		m_cpu->calculator();
		m_vc->display();
		m_men->storage();
	}

	~computer() {
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}
		if (m_vc != NULL)
		{
			delete m_vc;
			m_vc = NULL;
		}
		if (m_men != NULL)
		{
			delete m_men;
			m_men = NULL;
		}
	}
private:
	cpu* m_cpu;
	videocard* m_vc;
	memory* m_men;
};

class Intelcpu :public cpu
{
public:
	virtual void calculator()
	{
		cout << "intelcpu实现" << endl;
	}
};

class Intelvideocard :public videocard
{
public:
	virtual void display()
	{
		cout << "intelvideocard实现" << endl;
	}
};

class Intelmemory :public memory
{
public:
	virtual void storage()
	{
		cout << "intelmemory实现" << endl;
	}
};

class lenovocpu :public cpu
{
public:
	virtual void calculator()
	{
		cout << "lenovocpu实现" << endl;
	}
};

class lenovovideocard :public videocard
{
public:
	virtual void display()
	{
		cout << "lenovovideocard实现" << endl;
	}
};

class lenovomemory :public memory
{
public:
	virtual void storage()
	{
		cout << "lenovomemory实现" << endl;
	}
};

void test1()
{
	cpu * intelcpu = new Intelcpu;
	videocard * intelvideocard = new Intelvideocard;
	memory * intelmemory = new Intelmemory;

	computer* computer1 = new computer(intelcpu, intelvideocard, intelmemory);
	computer1->work();
	delete computer1;
}

int main() {
	test1();


	system("pause");
	return 0;
}