day7-C++学习

1.静态联编和动态联编

多态分为静态多态和动态多态，运算符重载和函数重载就是静态多态，而派生类和虚函数实现动态多态。
静态多态和动态多态的区别就是函数地址是早绑定(静态联编)还是晚绑定(动态联编)。

**设置父类为动物类，子类为猫类**
class Animal
{
public:

	void speak()
	{
		cout << "动物在说话" << endl;
	}

	void eat()
	{
		cout << "动物在吃饭" << endl;
	}
};

class Cat :public Animal
{
public:

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

	void eat()
	{
		cout << "小猫在吃鱼" << endl;
	}
};

**此时调用doSpeak函数，结果是动物在说话**
void doSpeak(Animal & animal)
{
	animal.speak();
}
void test()
{
	Cat cat;
	doSpeak(cat);
}

//调用doSpeak时，speak函数的地址早就绑定好了，早绑定(静态联编)，编译阶段就确定好了地址
//如果想调用猫的speak，不能提前绑定好函数的地址，所以需要在运行时候再去确定函数地址，晚绑定(动态联编)
//写法将doSpeak方法改为虚函数,在父类上声明虚函数，发生了多态
//父类的引用或者指针指向子类对象

class Animal
{
public:

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

	virtual void eat()
	{
		cout << "动物在吃饭" << endl;
	}
};

class Cat :public Animal
{
public:

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

	virtual void eat()
	{
		cout << "小猫在吃鱼" << endl;
	}
};

void doSpeak(Animal & animal)//Animal & animal = cat
{
	animal.speak();
}
//如果发生了继承的关系，编译器允许进行类型转换
void test()
{
	Cat cat;
	doSpeak(cat);
}

2.多态原理解析

当父类中有了虚函数后，内部结构就发生了改变，内部多了一个 vfprt
vfprt：virtual function pointer 虚函数表指针，指向 vftable 虚函数表
父类中结构 的vfptr会指向&Animal::speak虚函数表
子类中进行继承，会继承父类的vfptr和vftable
子类的构造函数中会将虚函数表指针指向自己的虚函数表&Cat::speak
如果发生了重写，会替换掉虚函数表中的原有的speak，改为&Cat::speak

3.多态案例 – 计算器案例

在真正的开发中，有一个开发原则：开闭原则
对扩展开放，对修改关闭

//利用多态实现计算器
class abstractCalculator
{
public:
	//虚函数
	/*virtual int getResult()
	{
		return 0;
	}*/
	//纯虚函数 写法：virtual void func() = 0;
	//如果父类中有纯虚函数，子类继承父类就必须实现纯虚函数
	//如果父类中有纯虚函数，这个父类就无法实例化对象了
	//这个类有了纯虚函数，通常又称为抽象类

	virtual int getResult() = 0;
	void setv1(int v)
	{
		this->val1 = v;
	}
	void setv2(int v)
	{
		this->val2 = v;
	}
	int val1 = 0;
	int val2 = 0;
};

//如果父类中有纯虚函数，子类继承父类就必须实现纯虚函数
class A :public abstractCalculator
{
public:
	int getResult()
	{
		return 0;
	}
};

//加法计算器
class PlusCalculator :public abstractCalculator
{
public:
	int getResult()
	{
		return val1 + val2;
	}
};
//减法计算器
class SubCalculator :public abstractCalculator
{
public:
	int getResult()
	{
		return val1 - val2;
	}
};
//乘法计算器
class ChenCalculator :public abstractCalculator
{
public:
	int getResult()
	{
		return val1 * val2;
	}
};

void test()
{
	abstractCalculator* ab = new PlusCalculator;//加法计算器
	ab->setv1(19);
	ab->setv2(18);
	cout << ab->getResult() << endl;
	delete ab;

	ab = new SubCalculator;//减法计算器
	ab->setv1(19);
	ab->setv2(18);
	cout << ab->getResult() << endl;
	delete ab;

	ab = new ChenCalculator;//乘法计算器
	ab->setv1(19);
	ab->setv2(18);
	cout << ab->getResult() << endl;
	
	//如果父类中有纯虚函数，不能实例化对象了
	//抽象类无法实例化对象
	//如果子类继承了抽象类，必须重写抽象类中的纯虚函数
	//abstractCalculator a;
	//abstractCalculator * a = new abstractCalculator;
}

4.虚析构和纯虚析构

class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
	~Animal()
	{
		cout << "Animal的析构调用" << endl;
	}

};

class Cat :public Animal
{
public:
	Cat(const char* name)
	{
		this->m_name = new char[strlen(name) + 1];
		strcpy(this->m_name, name);
	}
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
	~Cat()
	{
		cout << "Cat的析构调用" << endl;
	}

	char* m_name;
};


void test()
{
	Animal* animal = new Cat("Tom");
	animal->speak();
	delete animal;
	//此时析构时只调用了父类的析构，释放不干净，所以需要引入虚析构
}

class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
	//普通析构是不会调用子类的析构的，所有可以会导致释放不干净
	//利用虚析构来解决这个问题
	virtual ~Animal()
	{
		cout << "Animal的析构调用" << endl;
	}

**扩展：**
	//纯虚析构写法 virtual ~类名() = 0
	//纯虚析构需要类内声明，类外实现
	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(this->m_name, name);
	}
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
	~Cat()
	{
		cout << "Cat的析构调用" << endl;
		if (this->m_name != NULL)
		{
			delete[] this->m_name;
			this->m_name = NULL;
		}
	}

	char* m_name;
};
void test()
{
	Animal* animal = new Cat("Tom");
	animal->speak();

	delete animal;
}

5.向上类型转换和向下类型转换

基类转变为派生类是向下类型转换 ，不安全
派生类转变为基类是向上类型转换 ，安全
如果发生多态，总是安全的