OOP

面向对象程序设计（object-oriented programming）的核心思想就是数据抽象，继承和动态绑定。
多态性分两类：
静态多态性：函数重载和运算符重载实现的多态性属于静态，又称为编译时的多态性
动态多态性：在程序运行过程中才动态确认操作所针对的对象，又称为运行时多态性，通过虚函数实现。
虚函数：对于某些函数，基类希望它的派生类各自定义适合自身的版本，此时基类就将这些函数声明成虚函数。虚函数允许通过基类指针或引用来访问基本和派生类中的同名函数，通过指针调用同名函数，而不是通过对象名。
虚函数的使用方法：
1.在基类中用virtual声明成员函数为虚函数
2.在派生类中重新定义此函数，要求函数名，函数类型，函数参数个数和类型都要一样，当基类的成员函数声明为虚函数时，派生类中的同名函数都自动成为虚函数。因此在派生类重新声明该虚函数时，可以加virtual也可以不加，一般要加，保证可读性。
3.定义一个指向基类对象的指针变量，通过指针调用虚函数。通过虚函数和指向基类对象的指针变量的配合使用，能方便调用同一类族不同类对象的同名函数。
虚函数

#include<iostream> 
using namespace std;
class A{
public: 
	virtual void f(){
		cout << "A.f()" << endl; 
	};//虚函数
	void g(){
		this->f();
	} 
	A(){
	}
};

class B:public A{
	public:
		void f(){
			cout << "B:f()"<< endl;
		}
};

int main(){
	A a;
	a.g();
	B b;
	b.g();
	return 0;	
}

运行结果：

纯虚函数

#include<iostream> 
using namespace std;
class A{//定义一个基类
public: 
	virtual void f()=0;//纯虚函数
	void g(){
		this->f();
	} 
	A(){
	}
};

class B:public A{//继承A
	public:
		void f(){
			cout << "B:f()"<< endl;
		}
};

int main(){
	A *a= new B();//抽象类的指针和引用 -> 由抽象类派生出来的类的对象
	//A a;//不允许这样做
	// A * a = new A()//抽象类不能实例化对象
	a->g();
	B b;
	b.g();
	return 0;	
}

运行结果：

析构函数
析构函数的作用是进行清理工作，对象在生成的时候首先调用的是父类的构造函数，之后调用自己的构造函数。派生类的对象撤销时先调用派生类的析构函数，再调用基类的析构函数。但是如果用new运算符建立了临时对象，用一个基类的指针删除一个派生类的对象，若基类中有析构函数，并定义一个指向该基类的指针变量，那么当用delete撤销对象时，系统只执行基类的析构函数，并不执行派生类的析构函数。因此一般而言，基类的析构函数为虚函数，来保证派生类的析构函数能够被调用。
注意构造函数不能声明为虚函数。因为在执行构造函数时类对象还未完成建立过程，当然谈不上函数与类对象的blinding，也就是绑定。具体原因如下：
1.构造一个对象的时候，必须知道对象的实际类型，而虚函数行为是在运行期间确定实际类型的。而在构造一个对象时，由于对象还未构造成功。编译器无法知道对象 的实际类型
2.虚函数的执行依赖于虚函数表。而虚函数表在构造函数中进行初始化工作，即初始化vptr，让他指向正确的虚函数表。而在构造对象期间，虚函数表还没有被初 始化，将无法进行。

#include<iostream>
using namespace std;

class Base  {
    public:
        Base()    { cout << "构造函数: Base" << endl; }
        virtual ~Base()   { cout << "析构函数 : Base" << endl; }
};

class Derived: public Base {
    public:
        Derived()   { cout << "构造函数: Derived" << endl; }
        ~Derived()   { cout << "析构函数 : Derived" << endl; }
};

int main()  {
    Base *Var = new Derived();
    delete Var;
    return 0;
}

执行结果：