c++类和对象之多态

1.多态的概念

1.1概念

多态即多种形态，具体就是不同对象完成某个某个行为时会产生不同的状态。
比如说在买票时，不同人群的票价可能不一样，军人可以优先买票。

2.多态的定义和实现

2.1构成条件

1. 多态是在不同继承关系的类对象，去调用同一函数产生了不同的行为。
2. 必须通过基类的指针或者引用去调用虚函数
3. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写！

class Person
{
public:
	Person(const char* name)
		:_name(name)
	{}
	virtual void BuyTicket()
	{
		cout << _name << "Person ： 买票-全价 100￥" << endl;
	}
protected:
	string _name;


};

class Student : public Person
{
public:
	Student(const char*name)
		:Person(name)
	{}

	virtual void BuyTicket()
	{
		cout << _name << "Student: 买票-半价 50￥" << endl;
	}

};

class Soldier :public Person
{
public:
	Soldier(const char* name)
		:Person(name)
	{}

	virtual void BuyTicket() 
	{ 
		cout << _name << " Soldier：优先买预留票-88折 88 ￥" << endl; 
	}


};





void Pay(Person* ptr)
{
	ptr->BuyTicket();
}

int main()
{
	int option = 0;
	do
	{
		cout << "请选择身份: ";
		cout << "1.普通人 2.学生 3.军人" << endl;
		cin >> option;
		cout << "请输入名字 ：";
		string name;
		cin >> name;
		switch (option)
		{
		case 1:
		{
			Person p(name.c_str());
			Pay(&p);
			break;
		}
		case 2:
		{
			Student s(name.c_str());
			Pay(&s);
			break;
		}
		case 3:
		{
			Soldier sld(name.c_str());
			Pay(&sld);
			break;
		}
		default:
			cout << "输入错误！" << endl;
			break;

		}


	} while (option != -1);

	return 0;
}

2.3虚函数的重写（覆盖）

派生类中有一个跟基类完全相同的虚函数（返回值类型、 函数名、参数列表完全相同！），称子类的虚函数重写了基类的虚函数！

class Car 
{
public:
	virtual void Drive()
	{
		cout << "Car - " << endl;
	};
	

};

class Benz : public Car 
{
public:
	virtual void Drive() override
	{
		cout << "Benz - " << endl;
	}
};

---

注意：在重写基类的虚函数时，派生类不加virtual也可以构成重写（因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数的属性），但是该写法不规范，不建议使用！

虚函数重写的两个例外：

1. 协变（基类与派生类虚函数返回值类型不同)
   派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用，称为协变。

class A
{
public:
	virtual A* fun() { return new A; }
};

class B:public  A
{
public:
	virtual B* fun() { return new B; }
};

2. 析构函数的重写（基类与派生类析构函数的名字不同）
   如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同，看似违背重写的规则，但是其实是编译器对析构函数名称做了特殊处理，编译后的函数名称统一处理成 destructor

class Person
{
public:
	virtual  ~Person() { cout << "~Person()" << endl; }

};

class Student :public Person
{
public:
	 ~Student() { cout << "~Student" << endl; }
};

/* 只有派生类student的析构函数重写了Person的析构函数，
下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确调用析构函数
*/
int main()
{
	
	Person* p2 = new Student;
	
	delete p2;
	
	return 0;
}

2.4 c++11 override 和 final

1. final：修饰虚函数，表示该虚函数不能再被重写！（也可以修饰类，表示类不能被继承）
2. override ：检查派生类虚函数是否重写了某类某个虚函数，如果没有重写编译时会报错。

2.5 重载、覆盖（重写）、隐藏（重定义）的对比

3.抽象类

3.1 概念

在虚函数的后面加上 =0 将该函数变为纯虚函数。包含纯虚函数的类叫作抽象类（也叫做接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，需要重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class Car 
{
public:
	virtual void Drive() = 0; //纯虚函数
	
	

};

class Benz : public Car 
{
public:
	virtual void Drive() override
	{
		cout << "Benz - " << endl;
	}
};

4. 多态的原理

4.1虚函数表

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _base = 1;
};


int main()
{	
	Base b;

	cout << sizeof(b) << endl;
	
	return 0;
}

程序在64位下的运行结果？
– 16

通过调试，我们发现b对象是16 bytes 除了_base成员，还有一个_vfptr放在对象的前面（注意有些平台可能会放在对象的最后，和平台有关),对象中的这个指针我们叫做虚函数表指针(v代表virtual f代表function) 一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要放到虚函数表中，虚函数表也简称虚表。

class Base
{
public:
	virtual void Func1()
	{
		cout << "Base:: Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base:: Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base:: Func3()" << endl;
	}
private:
	int _b = 1;
};

class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive:: Func1()" << endl;
	}
private:
	int _d = 2;
};


int main()
{	
	Base b;
	Derive d;
	
	
	return 0;
}

发现的问题：

1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。

2. 基类b对象和派生类d对象的虚表是不一样的，这里func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫做覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。

3. 另外func2继承下来后是虚函数，放进了虚表，虽然func3也继承了下来，但是不是虚函数，不会放进虚表。

4. 虚函数表本质是一个存虚函数指针的指针数组 一般情况这个数组最后面放了一个nullptr。

5. 派生类虚表的生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中
   b. 如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c. 派生类自己新增的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

6. 虚函数和普通函数一样存在代码段中，（虚表存的是虚函数指针，不是虚函数） vs下虚表存在代码段中。

4.2多态的原理

4.3 动态绑定与静态绑定

1. 静态绑定又称为前期绑定（早绑定），在程序编译期间确定了程序的行为，也成为静态多态，比如：函数重载。
2. 动态绑定又称为后期绑定（晚绑定），是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体函数，也称为动态多态。

5.1多继承中的虚函数表

class Base1
{
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1 = 1;
};

class Base2
{
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2 = 1;
};

class Derive :public Base1, public Base2
{
public:
	virtual void func1(){ cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }

};

int main()
{	
	Base1 b1;
	Base2 b2;
	Derive d;

	
	
	return 0;
}