C++面向对象-6

Shan San

2018-10-14

CPP

C++多态

C++的多态意味着调用成员函数时，会根据调用的对象的类型来执行不同的函数

编译时的多态，编译时就确定了具体的操作过程。
运行时的多态，程序运行过程中才确定的操作过程。
操作的过程即称为联编，也称为绑定。

静态联编（早绑定），在编译和连接时确认的。比如函数重载，函数模板。效率高
动态联编（后期绑定），运行的时候才能确定是哪块代码段。灵活

静态联编

函数调用在程序执行前就准备好了

#include<iostream>
#define PI 3.1415926
using namespace std;

class Point
{
	private:
		int x;
		int y;
	public:
		Point(int x=0,int y=0)
		{
			this->x=x;
			this->y=y;
		}
		double area()
		{
			return 0.0;
		}
};

class Circle: public Point
{
	private:
		int r;
    public:
    	Circle(int x,int y,int R):Point(x,y)//基基类中有带参数的构造函数，派生类中的构造函数需要自定义 
    	{
    		this->r=R;
		}
		double area()
		{
			return r*r*PI;
		}
};

int main()
{
    Point A(3,3);//一个点 
	Circle B(3,3,3);   	//一个圆
	
	cout<<A.area()<<endl;
	cout<<B.area()<<endl;
	
	Point *ptr;  //Point类型的指针 
	ptr = &B;    //指向了Circle类型 
	cout<<ptr->area()<<endl;//输出结果不理想 
	
	return 0;
}

第三个cout输出0的原因:编译器在编译时就依据ptr的类型来执行那个are，指针ptr虽然指向了Circle类型的B，但是指针ptr为Point类型，所以执行Point类里的are方法。这里实行的即为静态编译。此时编译器看的是指针的类型而非内容。

动态编译

使用虚函数进行动态联编。程序在任意点可以根据所调用的对象类型来选择调用的函数，这种操作即为动态联编，也成为后期绑定。

虚函数

在基类中使用virtual关键字进行声明的函数。

virtual 函数返回值 函数名(形参)
{
    函数体
}

#include<iostream>
#define PI 3.1415926
using namespace std;

class Point
{
	private:
		int x;
		int y;
	public:
		Point(int x=0,int y=0)
		{
			this->x=x;
			this->y=y;
		}
		virtual double area()
		{
			return 0.0;
		}
};

class Circle: public Point
{
	private:
		int r;
    public:
    	Circle(int x,int y,int R):Point(x,y)//基基类中有带参数的构造函数，派生类中的构造函数需要自定义 
    	{
    		this->r=R;
		}
		double area()
		{
			return r*r*PI;
		}
};

int main()
{
    Point A(3,3);//一个点 
	Circle B(3,3,3);   	//一个圆
	
	cout<<A.area()<<endl;
	cout<<B.area()<<endl;
	
	Point *ptr;  //Point类型的指针 
	ptr = &B;    
	cout<<ptr->area()<<endl;
	cout<<(*ptr).area()<<endl; 
	return 0;
}

纯虚函数

在基类中不能对虚函数给出有意义的实现，这时侯就使用到了纯虚函数。包含纯虚函数的类是抽象类。抽象类至少包含一个纯虚函数。

定义方式:

virtual 返回值 函数名(形参)  = 0;

虚析构函数

在C++中，不能把构造函数定义为虚构造函数，因为在实例化一个对象时才会调用构造函数，而且虚函数的实现，其实际本质是通过一个虚函数表指针来调用的，还没有对象更没有没内存空间当然无法调用，故没有实例化一个对象之前的构造函数没有意义也不能实现。
析构函数可以为虚函数，而且大多数时候都声明为虚析构函数。这样就可以在基类的指针指向派生类的对象在释放时，可以根据所指向的对象类型动态联编调用子类的析构函数，实现真正的对象内存释放。

#include<iostream>
using namespace std;

class Point
{
	private:
	    int x;
	    int y;
	    int *str;
	public:
		Point(int x=0,int y=0)
		{
			this->x=x;
			this->y=y;
			str = new int[100];
		}
		~Point()
		{
			delete []str;
			cout<<"Called Point's Destructor and Delete str !"<<endl;
		}
};

class Circle:public Point
{
	private:
		int r;
		int *str;
	public:
		Circle(int x,int y,int r):Point(x,y)
		{
			this->r=r;
			str = new int[100];
		}
		~Circle()
		{
			delete []str;
			cout<<"Called Circle's Destructor and Delete str !"<<endl;
		}
};
int main() 
{
	Point *p;
	p = new Circle(10,10,20);
	delete p;
	
	return 0;
}