波奇学C++:多态

组合和继承

继承是白箱复用(whiter-box-reuse),获得继承类的内部细节

组合是黑盒测试(black-box-reuse),无法得走类的内部实现

class C
{
	//
};
//组合
class E
{
private:
	C _cc;
};

is-a 关系用继承，人-学生；has-a 关系用组合 车-轮胎。

多态：不同的对象，做同一个行为结果是不一样的。

比如对象student , elder people,调用func，结果是不一样的。

class Person {
public:
	virtual void BuyTicket()const {
		cout << "买票-全价" << endl;
	}
};
class Student :public Person {
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void func(const Person& p)
{
	p.BuyTicket();
}
void func(const Person* p)
{
	p->BuyTicket();
}
int main()
{
	func(Person());
	func(Student());
    Student p;
	func(&p);
	return 0;
}

虚函数的意义：

为什么要有虚函数，通过在继承类中虚函数重定义/隐藏，不就能满足我们的要求吗？

个人理解是，进一步解决封装的问题，如果要想func一样封装类的行为，如果只有重载和隐藏的话，就要一个对象重载一个func，但是我们可以用向上转换接收基类和派生类的指针，并通过虚函数覆盖来实现调用派生类的对应的同名的函数。

构成多态的两个条件:

1.虚函数被调用的函数必须是虚函数，且派生类对基类的虚函数进行重写。BuyTicket是虚函数，并且在派生类中重写。

2.必须是父类的指针或者引用。如果不是，则只会调用基类的虚函数。（只有指针或者引用，才有能实现切片操作？）

虚函数的重写：

1.函数名，返回值，参数值三同。

2.返回值不同，但必须是父子关系指针和引用。

3.父类要加virtual,派生类重写可以不加virtual。

返回值不同 ，父子关系指针

class Person {
public:
	virtual Person* BuyTicket()const {
		cout << "买票-全价" << endl;
        return 0;
	}
};
class Student :public Person {
	virtual Student* BuyTicket()const { cout << "买票-半价" << endl; 
    return 0;
}
};

指针不一定是Person*和Student*这对父子指针，其他父子指针也可以。

析构函数加virtual是重写，因为父子类虚构函数都被重名为destructor,满足析构函数条件。

析构调用的运用场景

代码

class Person {
public:
	~Person()
	{

	}
};
class Student :public Person {
	~Student()
	{
		delete _a;
	}
	int* _a = new int[10];
};
int main()
{
    Person* p = new Person;
	delete p;
	p = new Student;
	delete p;
}

多态调用看的是指向的对象，普通对象看当前调用者类型。 p的类型是父类，如果是普通类型就会调用父类的析构函数，那么就会造成内存泄漏。

我的理解是使用虚函数可以选择性向上转换。不想向上转换，就可以用重写虚函数。

final 虚函数不能被重写

 Drive函数不能被重写。

class Car
{
public:
    virtual void Drive() finial{}
};

override帮助派生检查是否完成重写，如果没有被重写就会报错

Drive() 必须在派生类被重写。

class Car
{
public:
    virtual void Drive() override{}
};

设计一个不想被继承的类

方法：基类构造函数私有，派生类构造函数必须调用构造基类构造函数

class A
{
public:
	static A CreateObj()
	{
		return A();
	}
private:
	A();
};

A 不能被继承，但可以通过A:: CreateObj() 来创建A对象。

方法2：用final限定继承

class A final
{
public:
private:
};

重载，重写，重定义区别：

重载：函数在同一个作用域，函数名相同，参数不同。

重写（覆盖）：两个函数分别在基类和派生类的作用域，函数名，参数，返回值都必须相同，两个函数都是虚函数，即多态。

重定义：两个函数分别在基类和派生类的作用域，函数名相同，不构成重写就是重定义。

多态的底层原理

如图 A 的大小是16，原因就在于a里面保存了一个指针， 这个指针指向一个虚基表，虚基表保存虚函数的地址。内存对齐下1+8->8+8=16。

创建一个类B继承类A，b类同样存在一个_vfptr vfptr：保存的是含有重写的虚函数地址的虚基表地址。

多态的本质就是在类划分出一块空间，保存一个虚表地址，虚表保存一个重写虚函数的地址，

当子类调用时，访问父类空间的对应的虚表地址，找到对应虚函数的地址。多态就是改变这个虚函数的地址。

和重定义作比较，重定义会支持把子类函数的地址覆盖父类同名函数的地址，但是重写会生成虚表，虚表中覆盖虚函数的地址