文章目录
- 十二、继承
- 8. 继承和组合
- 十三、多态
- 1. 多态的概念
- 2. 多态的定义和实现
- 虚函数重写的两个特殊情况
- override 和 final
- 3. 多态的原理
- 1. 虚函数表
- 未完待续
十二、继承
8. 继承和组合
我们已经知道了什么是继承，那组合又是什么？下面这种情况就是 组合 。
class A
{
//
};
class B
{
private:
A _a;
};
组合和继承都是让代码复用，但是继承的复用是一种 白箱复用 ，父类的内部细节是对子类透明的，根透明箱子一样。而组合的复用是一种 黑箱复用 ，因为对象的内部细节是不可见的。
继承一定程度破坏了父类的封装，父类的改变，对子类有很大的影响。子类和父类间的依赖关系很强，耦合度高 。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于保持每个类被封装 。
优先使用对象组合，而不是继承。
public继承是一种 is-a 的关系。也就是说每个子类对象都是一个父类对象。
组合是一种 has-a 的关系。假设B组合了A，每个B对象中都有一个A对象。
十三、多态
1. 多态的概念
多态 通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成某个行为时会产生出不同的状态 。举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。
2. 多态的定义和实现
我们先实现一下多态，来尝尝鲜：
#include<iostream>
using namespace std;
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student : public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
// 多态
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(ps);
// 子类可以赋值给父类---切片
Func(st);
return 0;
}
在继承中想要构成多态是有条件的。
1. 必须通过父类的指针或者引用调用虚函数。
2. 被调用的函数必须是 虚函数 ，且子类必须对父类的虚函数进行重写。
虚函数的重写(覆盖/隐藏)：子类中有一个跟父类完全相同的虚函数(即子类虚函数与父类虚函数的 返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了父类的虚函数。（实际上父类的虚函数可以被子类继承，所以只要父类写上 virtual ，子类即使不写 virtual 也能构成重写）
关于重写：重写是重写的 实现 ，仅仅会改变实现方式，声明并不会改变 。
虚函数重写的两个特殊情况
协变
在虚函数重写时，父类和子类的虚函数返回类型可以不同，但要求返回类型必须是父子类关系的指针和引用，则称为 协变 。
#include<iostream>
using namespace std;
class A {};
class B : public A {};
class Person
{
public:
// 虚函数重写，返回类型是对应的指针或引用
virtual A* f()
{
cout << "A::f()" << endl;
return new A;
}
};
class Student : public Person
{
public:
// 虚函数重写，返回类型是对应的指针或引用
virtual B* f()
{
cout << "B::f()" << endl;
return new B;
}
};
int main()
{
Person* p = new Student;
p->f();
return 0;
}
当返回类型是对应的指针或引用时成功实现多态，当返回类型不是时：
#include<iostream>
using namespace std;
class A {};
class B : public A {};
class Person
{
public:
// 返回类型不同且不说相应的指针或引用
virtual A f()
{
cout << "A::f()" << endl;
return *new A;
}
};
class Student : public Person
{
public:
// 返回类型不同且不说相应的指针或引用
virtual B f()
{
cout << "B::f()" << endl;
return *new B;
}
};
int main()
{
Person* p = new Student;
p->f();
return 0;
}
析构函数的重写
如果父类的析构函数为虚函数，此时子类析构函数只要定义，无论是否加 virtual 关键字，都与父类的析构函数构成重写。原因是编译器对析构函数的名称做了特殊处理，编译后所以析构函数的名称统一处理成 destructor 。
当父类的析构函数不是虚函数时，如下情况则会：
#include<iostream>
using namespace std;
class Person
{
public:
~Person()
{
cout << "~Person()" << endl;
}
};
class Student : public Person
{
public:
~Student()
{
cout << "~Student()" << endl;
}
};
int main()
{
// 父类指针指向父类对象
Person* p1 = new Person;
// 父类指针指向子类对象
Person* p2 = new Student;
delete p1;
cout << endl;
delete p2;
return 0;
}
没能成功进行多态调用，访问的还是父类的析构函数。当父类的析构函数是虚函数时：
#include<iostream>
using namespace std;
class Person
{
public:
virtual ~Person()
{
cout << "~Person()" << endl;
}
};
class Student : public Person
{
public:
// 子类可以不写 virtual ，自动构成虚函数重写
~Student()
{
cout << "~Student()" << endl;
}
};
// 只有派生类Student的析构函数重写了Person的析构函数
//下面的delete对象调用析构函数，才能构成多态
//才能保证p1和p2指向的对象正确的调用析构函数
int main()
{
// 父类指针指向父类对象
Person* p1 = new Person;
// 父类指针指向子类对象
Person* p2 = new Student;
delete p1;
cout << endl;
delete p2;
return 0;
}
成功构成多态调用。我们怎么分辨 普通调用 和 多态调用 呢？
普通调用 看指针或引用或者对象的类型。
多态调用 看指针或引用指向的对象。
override 和 final
如果我们想实现一个类，使其不能被继承，应该怎么做？方法一：将父类的构造函数私有化，由于子类的构造函数必须调用父类的构造函数，所以父类的构造函数私有化会导致子类无法实例出对象。方法二：使用关键字 final 。
// 父类增加关键词 final
class A final
{
//
};
class B : public A
{
//
};
final 还可以修饰虚函数，表示该虚函数不能再被重写。
class Car
{
public:
virtual void Drive() final
{
//
}
};
class Benz :public Car
{
public:
virtual void Drive()
{
cout << "Benz-舒适" << endl;
}
};
override 可以检查子类虚函数是否重写了父类某个虚函数，如果没有重写则编译报错。
class Car
{
public:
void Drive()
{
//
}
};
class Benz :public Car
{
public:
// override 写在子类后面
virtual void Drive() override
{
cout << "Benz-舒适" << endl;
}
};
3. 多态的原理
1. 虚函数表
这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
private:
int _b = 1;
};
int main()
{
Base bb;
cout << sizeof(Base) << endl;
return 0;
}
答案是：8；原因是，int 占 4 个字节，而只要类里面有虚函数，类就会在内部 额外生成一个指针 ，指针指向函数指针数组，函数指针数组里存的都是虚函数的地址，称为 虚函数表 。指针占 4 个字节，故答案是 8 。
对于上面的代码，我们再进行改造一下：
#include<iostream>
using namespace std;
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;
}
我们发现，父类b对象和子类d对象虚函数表是不一样的，这里我们发现Func1完成了重写，所以d的虚函数表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚函数表中虚函数的覆盖。b对象的虚函数表先拷贝一份父类的虚函数表，然后子类重写的函数覆盖进b对象的虚函数表。重写是语法的叫法，覆盖是原理层的叫法。Func3由于不是虚函数，所以没有进入虚函数表。
运行时是通过本身的父类虚函数表或者切片的父类虚函数表（自己的）找到相应的虚函数，不同的对象虚函数表不同，因此实现多态。
