【C++】学习笔记——多态_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 和 ﬁnal

如果我们想实现一个类，使其不能被继承，应该怎么做？方法一：将父类的构造函数私有化，由于子类的构造函数必须调用父类的构造函数，所以父类的构造函数私有化会导致子类无法实例出对象。方法二：使用关键字 final 。

// 父类增加关键词 final
class A final
{
  //
};
class B : public A
{
  //
};

ﬁnal 还可以修饰虚函数，表示该虚函数不能再被重写。

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由于不是虚函数，所以没有进入虚函数表。

运行时是通过本身的父类虚函数表或者切片的父类虚函数表（自己的）找到相应的虚函数，不同的对象虚函数表不同，因此实现多态。

【C++】学习笔记——多态_1

十二、继承

8. 继承和组合

十三、多态

1. 多态的概念

2. 多态的定义和实现

虚函数重写的两个特殊情况

override 和 ﬁnal

3. 多态的原理

1. 虚函数表

未完待续

热门文章

最新文章

相关课程

相关电子书

相关实验场景