C++学习（十六）—多态（二）

多态的好处

多态的好处
扩展性提高 组织性强 可读性强
如果父类中有了虚函数，子类并没有重写父类的虚函数，那麽这样的代码是毫无意义的
如果子类不重写父类虚函数，那麽没有用到多态带来的好处，而且内部结构还变得更为复杂

#include<iostream>

using namespace std;



class calculator
{
public:
	int getResult(string oper)
	{
		if (oper == "+")
		{
			return m_a + m_b;
		}
	}

	int m_a;
	int m_b;
protected:
private:
};



//  开闭原则  ——对扩展进行开放  对修改进行关闭

//	利用多态实现计算器

class AbstractCalcylator
{
public:
	virtual int getResult()
	{
		return 0;
	}
	int m_a;
	int m_b;
};

class Addcalculator :public AbstractCalcylator
{
public:
	int getResult()
	{
		return m_a + m_b;
	}
};

class Subcalculator :public AbstractCalcylator
{
public:
	int getResult()
	{
		return m_a - m_b;
	}
};

class Multicalculator :public AbstractCalcylator
{
public:
	int getResult()
	{
		return m_a * m_b;
	}
};

void test01()
{
	AbstractCalcylator  *calculator = new Addcalculator;
	calculator->m_a = 20;
	calculator->m_b = 10;

	cout << calculator->getResult() << endl;

	delete calculator;
}

//  多态的好处
//  扩展性提高  组织性强  可读性强
//  如果父类中有了虚函数，子类并没有重写父类的虚函数，那麽这样的代码是毫无意义的
//	如果子类不重写父类虚函数，那麽没有用到多态带来的好处，而且内部结构还变得更为复杂


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

抽象类和纯虚函数

纯虚函数 vir tual void f() = 0;
如果一个类中有纯虚函数出现，那么这个类就无法实例化对象了，有纯虚函数的类，也称为抽象类
如果子类继承了抽象类，那么子类必须要重写父类中的纯虚函数，否则子类也属于抽象类

虚析构和纯虚析构

如果子类中有属性创建在堆区，那么多态情况不会调用子类的析构代码，导致内存泄露
解决方案：利用虚析构或者纯虚析构
纯虚析构 类内表明，类外必须实现
如果一个类中有了纯虚析构函数，那么这个类也属于抽象类

#include<iostream>

using namespace std;

class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
	/*	virtual ~Animal()  //	虚析构解决的问题是当子类中有堆区内容，释放的时候导致释放不干净，内存泄漏
	{
		cout << "Animal的析构函数调用" << endl;
	}*/
	//  纯虚析构    有声明  也必须有实现  如果一个类中  有了纯虚析构函数  那么这个类也属于抽象类	  

	virtual ~Animal() = 0;
	
};


Animal::~Animal()
{
	cout << "Animal的纯虚析构函数调用" << endl;
}


class Cat :public Animal
{
public:
	Cat(const char * name)
	{
		this->m_Name = new char[strlen(name) + 1];
		strcpy_s(this->m_Name, strlen(name) + 1, name);

		cout << "Cat的有参构造函数调用" << endl;
	}


	void speak()
	{
		cout <<m_Name<< "小猫在说话" << endl;
	}

	~Cat()
	{
		if (this->m_Name != NULL)
		{
			delete this->m_Name;
			this->m_Name = NULL;
			cout << "Cat的析构函数调用" << endl;
		}
	}


	char * m_Name;  // 猫的姓名
};


void test01()
{
	Animal *animal = new Cat("Tom");

	animal->speak();

	delete animal;


}



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

向上向下类型转换

父类转子类 向下类型转换 不安全
子类转父类 向上类型转换 安全
如果发生多态，总是安全的