c++学习 2.26

1、菱形继承（钻石继承）

多继承引发的二义性，用作用域区分。

但菱形继承导致数据有两份，资源浪费。

利用虚继承，要解决菱形继承的问题，在继承之前加上virtual关键字

class Animal
{
public:
	int m_Age;
};
class sheep :virtual public Animal{};
class Tuo :virtual public Animal{};
class SheepTuo :public sheep, public Tuo {};

2、多态的基本概念

静态多态：函数重载和运算符重载     ——编译阶段确定函数地址

动态多态：派生类和虚函数实现运行时多态    ——运行阶段确定函数地址

静态多态

输出：动物在说话

class Animal
{
public:
	void speak()
	{
		cout << "动物在说话" << endl;
	}
};
class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};
void test01()
{
	Cat cat;
	doSpeak(cat);//父类的引用指向子类对象 c++允许父子类对象转换
}
int main()
{
	test01();
	return 0;
}

 将函数加上virtual关键字，输出：小猫在说话

class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};

动态多态的满足条件

1）有继承关系

2）子类重写父类的虚函数

动态多态的使用条件

父类的指针或者引用 执行子类对象

3、多态的底层原理

加入关键字virtual后

创建了一个vfptr 虚函数（表）指针，指向vftable 虚函数表  ——表内记录虚函数的地址

4、多态案例-计算器类

传统写法：需要在原码中修改。

不遵守开闭原则，开闭原则：对扩展进行开放，对修改进行关闭

#include<iostream>
using namespace std;
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;//操作数1
	int m_Num2;//操作数2
};
void test01()
{
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	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()
{
	test01();
	return 0;
}

使用多态实现：

#include<iostream>
using namespace std;
class AbstractCalculator
{
public:
	virtual int getResult()
	{
		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;
	}
};
void test01()
{
	//多态使用条件
	//父类指针或者引用指向子类对象

	//加法运算
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
	delete abc;//堆区创建，用完后需要销毁

	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;


}
int main()
{
	test01();
	return 0;
}

5、多态的好处

1）组织结构清晰

2）可读性强，每个功能独立

3）对于前期和后期扩展以及维护性较高

6、纯虚函数和抽象类

目的：当父类的虚函数无实际作用，一般继承只是调用子类重写函数，则可将父类的虚函数改为纯虚函数。

语法：virtual 返回值类型 函数名 (参数列表)=0;

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

#include<iostream>
using namespace std;
class Base
{
public:
	//纯虚函数
	//只要有一个纯虚函数，这个类成为抽象类
	//抽象类特点：
	//1、无法实例化对象    Base b; 报错  new Base;堆区创建，报错
	//2、抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类
	virtual void func() = 0;
};
class Son :public Base
{
public:
	virtual void func() {
		cout << "Son::func()被调用了" << endl;
	}
};
void test01()
{
    Base* son = new Son;
	son->func();
}
int main()
{
    test01();
	return 0;
}

7、多态案例2-制作饮品

将类中所有的过程函数包装在一个类的成员函数中，再用全局函数来调用该类包含全部过程的那个成员函数。

#include<iostream>
using namespace std;
class AbstractDrinking
{
public:
	//煮水
	virtual void Boil() = 0;

	//冲泡
	virtual void Brew() = 0;

	//倒入杯中
	virtual void PourInCup() = 0;

	//加入辅料
	virtual void PutSomething() = 0;

	//制作饮品
	void makeDrink()
	{
		Boil();
		Brew();
		PourInCup();
		PutSomething();
	}
};
class Coffee :public AbstractDrinking
{

public:
	virtual void Boil()
	{
		cout << "煮农夫山泉" << endl;
	}
	virtual void Brew()
	{
		cout << "冲咖啡" << endl;
	}
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}
	virtual void PutSomething()
	{
		cout << "加入糖和牛奶" << endl;
	}
};
class Tea :public AbstractDrinking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮农夫山泉" << endl;
	}
	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}
	virtual void PutSomething()
	{
		cout << "加入枸杞" << endl;
	}
};
void doWork(AbstractDrinking* abs)
{
	abs->makeDrink();
}
void test01()
{
	doWork(new Coffee);
}
int main()
{
	test01();
	return 0;
}