C++———多态

定义：方法的行为取决于调用该方法的对象，就是随着上下文，同一种方法具有不同的形态。称为多态。

调用同一个函数，编译器会根据上下文，匹配不同的形态。

#include <iostream>

using namespace std;

class Shape{
public:
	virtual double getL(void){
		
	}	
	
};
class Cir:public Shape{
public:
	Cir(int ri):r(ri){ };
	double getL(void){
		return 3.14*r*2;
	}
private:
		int r;	
};
class Tir:public Shape{
public:
	Tir(int a,int b, int c ):e1(a),e2(b),e3(c){
	}
	double getL(void){
		return e1+e2+e3;
	}
private:
		int e1;	
		int e2;
		int e3;
};
class Ret:public Shape{
public:
	Ret(int a,int b):h(a),w(b){
	}
	double getL(void){
		return 2*(h+w);
	}
private:
		int h;
		int w;	
};

double totalL(Shape *arr[],int n){
	
	double sum = 0;
	for(int i =0;i<n;++i){
		sum += arr[i]->getL();
	}
	return sum;
}
int main (){
	Cir C(4);
	Tir T(3,4,5);
	Ret R(5,8);
	Shape *arr[] = {&C,&T,&R};
	cout << totalL(arr,3) << endl;	
	
}

虚函数： 关键字 virtual .
虚函数的作用：在基类中使用虚函数，这样如果派生类中有和这个函数同名的函数，就会覆盖虚函数。
这样就可以避免。

在C++中，基类的指针可以指向派生类的地址。

当你用一个基类指针指向派生类的对象时，你想对派生类的对象调用派生类的方法的时候，会调用基类的方法。
EG:

当：virtual double getL(void) = 0；
时称为纯虚函数。
但它为一个纯虚函数的时候，你如果条用了它就会报错。
比如：我的
class Shape{
public:
virtual double getL(void){

}	

但是我图形就是，模糊的东西，我的代码，中就可以出现调用，Shape.getL这种操作。
但是，重编译器的角度来讲，Shape.getL，这是没有问题的，但是你把它声明成纯虚函数。
你再调用Shape.getL，编译器就会报错。

虚函数，避免内存泄漏的问题。

#include <iostream>
using namespace std;
class A {
public:
	A(){
			cout << "++++++++++A" << endl;
	}
	~A(){
			cout << "~~~~~~~~A" << endl;
	}
	void show(){
		cout << "-----------A" << endl; 
	}
};

class Ax:public A{

public:
	Ax(){
			cout << "++++++++++A" << endl;
	}
	~Ax(){
			cout << "~~~~~~~~AX" << endl;
	}
	void show(){
		cout << "************AX" << endl; 
	}	
	
};

int main (){
	A *p =new Ax;
	delete p;
	
	
}

我们再调用了，构造派生类的时候，它会调用基类的构造函数。
再析构的时候，它会调用基类和派生类的析构函数。
但是，像上面的情况，由于我的指针是基类的，然后在delete的时候就会值调用基类的析构，就少析构了派生类。
这样就会造成内存泄漏。

为避免这种情况，以及上面的情况，建议在构建基类的时候，使用虚函数。virtual