c++多态

4.7多态

4.7.1多态的基本概念

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

多态分两类：

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

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

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

动态多态满足条件：

1. 有继承关系
2. 子类重写父类虚函数

重写：函数返回值类型函数名称参数列表要完全相同才叫重写

虚函数在父类中定义，虚函数在父类中不需要实现，都是通过子类来实现的。这样就是实现函数的多态

​

动态多态的使用

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

#include<iostream>
using namespace std;
#include<string>
//动物类
class animal 
{
public:
	//虚函数，
	virtual void speak()//在前面加virtual就可以实现地址晚绑定
	{
		cout << "动物在说话" << endl;
	}

};


//猫类
class cat : public animal
{
public:
	void speak()//这个就叫重写父类虚函数前面的virtual可写可不写
	{
		cout << "小猫在说话" << endl;
	}
};

//地址早绑定，在编译阶段就确定了函数地址无论传什么动物都会走animalspeak路线
//如果想让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段绑定
void dospeak(animal & anm)//animal &anm = c;
//父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，父类引用是无法调用的；
//允许父子之间的引用 
//父类引用接受子类对象
{
	anm.speak();
}


void test01()
{
	cat c;
	dospeak(c);
}

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

多态的升入剖析

是子类对象的地址给了父类指针或引用，从而让父类指针或引用指向了子类对象，从而来访问子类对象的成员函数，或者成员属性

表的内部记录的是 Animal的speak函数地址

注意第三点：只能传入父类的指针/引用 才能实现多态！ 值传递是不可以滴

可以通俗的理解，子类可能含有一些父类没有的成员变量或者方法函数，但是子类肯定继承了父类所有的成员变量和方法函数。
所以用父类指针指向子类时，没有问题，因为父类有的，子类都有，不会出现非法访问问题。但是如果用子类指针指向父类的话，一旦访问子类特有的方法函数或者成员变量，就会出现非法。

虽然父类指针可以指向子类，但是其访问范围还是仅仅局限于父类本身有的数据，那些子类的数据，父类指针是无法访问的。
虚函数实现的过程是：**通过对象内存中的虚函数指针vptr找到虚函数表vtbl，再通过vtbl中的函数指针找到对应虚函数的实现区域并进行调用。**所以虚函数的调用时由指针所指向内存块的具体类型决定的。一定要知道父类子类都有各自的指针

基类的虚函数表和子类的虚函数表不是同一个表

子类可以通过重写来替换父类拷贝过来的虚函数表内容，

虚函数表存放各个虚函数地址{其实是数组}

父类指针或者引用指向子类对象时发生多态

animal & am = cat

am.speak();这里会运行cat的speak函数因为am内部存放的时cat虚函数表指针所以会从子类的虚函数表内部找speak函数入口地址。

4.7.2多态案例一.计算器类

#include<iostream>
#include<string>
using namespace std;
//普通写法
class calculate
{
public:
	int getresult(string p)//这里p前面不能用引用因为传入的是一个常量开辟在全局区
	{
		if (p == "+")
			return num1 + num2;
		else if (p == "-")
			return num1 - num2;
		else if (p == "*")
			return num1 * num2;
	}
	int num1;
	int num2;
};


void test01()
{
	calculate c;
	c.num1 = 10;
	c.num2 = 28;
	cout << c.num1 << "+" << c.num2 <<"="<< c.getresult("+") << endl;
	cout << c.num1 << "-" << c.num2 << "="<<c.getresult("-") << endl;
	cout << c.num1 << "*" << c.num2 <<"="<< c.getresult("*") << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

#include<iostream>
#include<string>
using namespace std;
//普通写法
class calculate
{
public:
	int getresult(string p)
	{
		if (p == "+")
			return num1 + num2;
		else if (p == "-")
			return num1 - num2;
		else if (p == "*")
			return num1 * num2;
	}
	int num1;
	int num2;
};
//如果想要扩展新的功能
//在正式的开发中体长开闭原则
//开闭原则：对扩展进行开发，对修改进行关闭
//利用多态实现计算器
//实现计算器抽象类
class abstractcalculate {
public:
	virtual int getresult()
	{
		return 0;
	}
	int n_num1;
	int n_num2;
};
class add:public abstractcalculate
{
public:
	int getresult()
	{
		return n_num1 + n_num2;
	}
};
class sub :public abstractcalculate
{
	int getresult()
	{
		return n_num1 - n_num2;
	}
};


class mul :public abstractcalculate
{
	int getresult()
	{
		return n_num1 * n_num2;
	}
};

void test01()
{
	//多态使用条件
	//父类指针或者引用指向子类对象
	abstractcalculate* p = new add;//直接用类名开辟一个子类对象
	//用完后记得把内存释放，内存释放后p这个对象还是存在的
	p->n_num1 = 87;
	p->n_num2 = 898;
	cout << p->getresult() << endl;
	delete p;//这里只是把p所指向内存地址(开辟的add对象和内部数据）释放掉了还是可以给他其他的地址的
	/// delete是删除指针指向的对象，让其释放内存。指针中的地址不变，所以一般在delete指针后，要将该指针的值赋值NULL（置空）防止其变成野指针。
	p = new sub;
	p->n_num1 = 87;
	p->n_num2 = 898;
	cout << p->getresult() << endl;
	//需要重新为他赋值
	//（1）delete 一次以后，p成了野指针，它作为地址的值还是有效地没还可以访问它以前指向的内存，不过那片内存被重新格式化了；
	//（2）p不等于NULL，用 if (p) 语句不能判断它指向的内存是否有效（此时它指向的内存无效，p本身有效）；
	//（3）delete 一次以后，不能再次delete，否则会报错；
	//（4）此时如果误用p指针，仍然可以修改内存的值和从该处取出数值，但此时数据不受保护，该内存空间可能被重新被分配给别的变量；
	//（5）如果p指向的空间再次被new函数分配，即使是分配给别的指针，即使分配大小与原来不一样，p又恢复了效力，可以改变内存的值，甚至可以重新被delete，p的作用与新分配的指针一样；


}

//使用多态嗷好处：
//组织结构清晰
//
int main()
{
	test01();
	system("pause");
	return 0;
}

4.7.3纯虚函数和抽象类

在多态中，通常父类中的实现是毫无意义的，通常都是调用子类重写的内容

因此可以将虚函数改成纯虚函数

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

当类中有了纯虚函数，整个类也称为抽象类。

抽象类：

• 无法实例化对象（因为是没有意义的）
• 子类必须重现抽象类中的纯虚函数，否则也属于抽象类

#include<iostream>
using namespace std;
class base
{
public:
	//找要有一个纯虚函数这个类就是抽象类
	virtual void func() = 0;
};
class son1:public base
{
public:
	void func(){}//哪怕里面什么内容都没有也算是重写过父类的纯虚函数
	
};

void test()
{
	son1 p;
	int a=10;
	//base* s = new p;不允许使用对象名来开辟内存空间
	base* s = new son1;//只能用类型名（类名）来开辟
	s->func();
	
}

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

#include<iostream>
using namespace std;
class make
{
public:
	virtual void boil() = 0;
	virtual void chongpao() = 0;
	virtual void daoshui() = 0;
	virtual void out() = 0;
	void makedrink()
	{
		boil();
		chongpao();
		daoshui();
		out();
	}
};
class caffe:public make
{
public:
	virtual void boil()
	{
		cout << "煮水" << endl;
	}
	virtual void chongpao() {
		cout << "冲泡咖啡" << endl;
	}
	virtual void daoshui()
	{
		cout << "倒入杯中" << endl;
	}
	virtual void out()
	{
		cout << "加入牛奶和糖" << endl;
	}
};


class tea :public make
{
public:
	virtual void boil()
	{
		cout << "煮山泉" << endl;
	}
	virtual void chongpao() {
		cout << "冲泡茶叶" << endl;
	}
	virtual void daoshui()
	{
		cout << "倒入杯中" << endl;
	}
	virtual void out()
	{
		cout << "加入枸杞" << endl;
	}
};

void dowork(make* p)
{
	p->makedrink();//一个接口有不同形态这就叫多态
	//要记得把堆区数据释放
	delete p;
}
void test()
{
	//caffe s;
	//dowork(s);
	dowork(new tea);

	
}

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

4.7.5虚析构和纯虚析构

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

因为父类中的函数是被子类包括的

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

虚析构和纯虚析构共性：

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

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

• 如果是纯虚析构该类属于抽象类无法实例化对象；

虚析构语法：

virtual ~类名（){}

纯虚析构：

virtual ~类名（） = 0；

析构函数 就是先进后出 后进先出

父类在析构时this指针指向的是父类的析构函数

父类中有数据到堆区，父类析构也要写释放代码！前面例子父类中没有堆区数据所以不用管

因此虚析构和纯虚析构都需要代码实现

因此纯虚析构可以在类内声明，类外实现。

#include<iostream>
using namespace std;
#include<string>
class animal
{
public:
	animal()
	{
		cout << "调用构造函数" << endl;
	}
	virtual void func() = 0;
	virtual ~animal() {
		cout << "调用析构函数" << endl;
	}
	virtual ~animal() = 0;
};
animal ::~animal() {
	//纯虚析构也需要代码实现。
}
class cat:public animal
{
public:
	cat(string name)
	{
		cout << "调用猫的构造函数" << endl;
		n_name = new string(name);
	}
	void func()
	{
		cout << *n_name<<"小猫在说话" << endl;
	}
	 ~cat()
	{
		if (n_name != NULL) {
			cout << "调用猫的析构函数" << endl;
			delete n_name;
			n_name = NULL;
		}
	}
	string* n_name;
};


void test()
{
	//这里要输参数原因：设置了有参构造函数好，默认构造函数会取消，如果需要得自己写入
	animal* p = new cat("tom");
	p->func();
	delete p;//这里才会调用析构函数
	
}

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

4.7.6多态案例三电脑组装

#include<iostream>
using namespace std;
#include<string>
//抽象不同零件的类

class cpu
{
public:
	//抽象计算函数
	virtual void calculate() = 0;
};
//显卡
class card
{
public:
	//抽象计算函数
	virtual void display() = 0;
};
//内存条
class memory
{
public:
	//抽象计算函数
	virtual void remmenber() = 0;
};
//电脑类
class computer
{
public://在构造函数中对传入的数据进行接收
	computer(cpu* p, card* d, memory* y)
	{
		c = p;
		a = d;
		m = y;
	}
	void work()
	{
		c->calculate();
		a->display();
		m->remmenber();
	}
	~computer()
	{
		if (c != NULL)
		{
			delete c;
			c = NULL;
		}
		if (a != NULL)
		{
			delete a;
			a = NULL;
		}
		if (m != NULL)
		{
			delete m;
			m = NULL;
		}
		return; 
	}

private:
	cpu* c;
	card* a;
	memory* m;
};
//具体厂商
class intercard:public card
{
public:
	void display()
	{
		cout << "inter的card正在工作" << endl;
	}
};
class intercpu :public cpu
{
public:
	void calculate()
	{
		cout << "inter的cpu正在工作" << endl;
	}
};
class intermemory :public memory
{
public:
	void remmenber()
	{
		cout << "inter的memory正在工作" << endl;
	}
};




class lenovocard :public card
{
public:
	void display()
	{
		cout << "lenovo的card正在工作" << endl;
	}
};
class lenovocpu :public cpu
{
public:
	void calculate()
	{
		cout << "lenovo的cpu正在工作" << endl;
	}
};
class lenovomemory :public memory
{
public:
	void remmenber()
	{
		cout << "lenovo的memory正在工作" << endl;
	}
};
void test()
{
	//组装不同的电脑
	cpu* c1 = new intercpu;
	card* a1 = new intercard;
	memory* m1 = new intermemory;
	computer* com1 = new computer(c1, a1, m1);
	com1->work();
	delete com1;
	//组装第二台电脑
	computer* com2 = new computer(new intercpu, new lenovocard, new intermemory);
	com2->work();
	delete com2;

}

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

用父类定义的指针是不可以访问子类的成员的，而且指针所指内存大小跟父类大小一致，也就是说指针可以指向子类，但获取不到超出父类内存大小的地址，除非你强定义指针