C++ 多态如何实现？

1、虚函数

使用关键字 virtual 可以声明一个虚函数。虚函数在派生类中仍然为虚函数，即使派生类中没有使用关键字 virtual 声明。

class Base {
public:
    Base() = default;
    virtual ~Base();
    virtual void virtualFunc();
    void nonOverride();
};

class Derive : public Base {
public:
    Derive() = default;
    ~Derive();
    void virtualFunc(); // virtual function
};

虚函数具有以下几点性质

1）一旦某个函数被声明为虚函数，则在所有派生类中它都是虚函数；

2）virtual 只能出现在类内部的声明语句之前而不能用于类外部的函数定义；

3）所有虚函数都必须有定义（纯虚函数例外）；

4）对虚函数的调用可能在运行时才被解析（运行时多态）；

5）派生类中的函数只有与基类虚函数的调用形式一样（有一个例外，返回对象本身的指针或引用）才构成覆盖（重写）；

比如基类 Base::VirtualFunc() 返回 char，而派生类 Derive::VirtualFunc() 返回 int，编译时报错，表示返回值不兼容。

class Base {
 public:
  virtual ~Base() = default;

  virtual char VirtualFunc() { reutrn 0; }
};

class Derive : public Base {
 public:
  int VirtualFunc() { return 0; }
};

int main() {
  Derive d;
  Base& b = d;

  b.VirtualFunc();
  return 0;
}

编译报错

virtual.cc:12:7: error: conflicting return type specified for ‘virtual int Derive::VirtualFunc()’
   12 |   int VirtualFunc() { return 0; }
      |       ^~~~~~~~~~~
virtual.cc:7:16: note: overridden function is ‘virtual char Base::VirtualFunc()’
    7 |   virtual char VirtualFunc();
      |                ^~~~~~~~~~~

如果返回值是对象本身的指针或者引用，是可以的。

class Base {
 public:
  virtual ~Base() = default;

  virtual Base* VirtualFunc() { return nullptr;}
};

class Derive : public Base {
 public:
  Derive* VirtualFunc() {
    static Derive s_derive;
    return &s_derive;
  }
};

int main() {
  Derive d;
  Base& b = d;

  b.VirtualFunc();
  return 0;
}

6）override 关键字显式说明派生类覆盖继承于基类的一个虚函数（编译器会帮助检查是否覆盖虚函数，没有的话会报错，不是也会报错）；

class Base {
 public:
  virtual ~Base() = default;

  virtual Base* VirtualFunc() { return nullptr; }
  void Func2() {}
};

class Derive : public Base {
 public:
  Derive* VirtualFunc() override {
    static Derive s_derive;
    return &s_derive;
  }

  void Func2() override {}
};

int main() {
  Derive d;
  Base& b = d;

  b.VirtualFunc();
  return 0;
}

编译报错

virtual.cc:17:8: error: ‘void Derive::Func2()’ marked ‘override’, but does not override
   17 |   void Func2() override {}
      |        ^~~~~

7）使用作用域运算符可以回避虚函数的机制;

#include <iostream>

class Base {
 public:
  virtual ~Base() = default;
  virtual void Out() { std::cout << "Base\n"; }
};

class Derive : public Base {
 public:
  void Out() {
    Base::Out();
    std::cout << "Derive\n";
  }
};

int main() {
  Derive d;
  Base& b = d;

  b.Out();
  return 0;
}

Derive::Out() 函数可以通过 Base::Out() 回避虚函数机制，调用基类实现。

wuyong@Thinkpad:~/debug$ ./a.out 
Base
Derive

8、在虚函数体的位置（声明语句的分号前）书写 =0 就可以将一个虚函数说明为纯虚函数（= 0 标志只能出现在类的虚函数声明处）；

也可以为纯虚函数提供定义，不过函数体必须在类外部。

2、抽象基类

含有纯虚函数的类时抽象基类，抽象基类不能被实例化，即使为纯虚函数提供了定义。

class Base {
 public:
  virtual ~Base() = default;
  virtual void Out() = 0;
};

void Base::Out() {}

int main() {
  Base b;

  b.Out();
  return 0;
}

编译报错，提示不是定义一个抽象基类的对象。

virtual.cc:12:8: error: cannot declare variable ‘b’ to be of abstract type ‘Base’
   12 |   Base b;
      |        ^
virtual.cc:3:7: note:   because the following virtual functions are pure within ‘Base’:
    3 | class Base {
      |       ^~~~
virtual.cc:9:6: note:     ‘virtual void Base::Out()’
    9 | void Base::Out() {}
      |      ^~~~

抽象基类正是为了接口和实现分离而存在的，只能定义抽象基类的指针或者引用，通过虚函数动态绑定特性，调用派生类真正的实现，而不需要知道派生类实现细节。

比如在 DB 声明数据库操作接口，其实现在 DBImpl 类中。main 函数中就不需要知道 DBImpl 的实现细节，通过抽象基类固定的接口操作数据库，而 DBImpl 的实现改变也不会对 main 函数整个操作有影响（只要接口保持不变）。

/// db.h
#include <string>

class DB {
 public:
  static int Open(const std::string& name, DB** dbptr);

  DB() = default;
  virtual ~DB() = default;

  DB(const DB&) = delete;
  DB& operator=(const DB&) = delete;

  virtual int Put(const std::string& key, const std::string& value) = 0;
  virtual int Delete(const std::string& key) = 0;
  virtual int Get(const std::string& key, std::string* value) = 0;
};

/// dbimp.h
class DBImpl : public DB {
 public:
  explicit DBImpl(const std::string& dbname) : dbname_(dbname) {}
  ~DBImpl() override = default;

  DBImpl(const DBImpl&) = delete;
  DBImpl& operator=(const DBImpl&) = delete;

  int Put(const std::string& key, const std::string& value) override;
  int Delete(const std::string& key) override;
  int Get(const std::string& key, std::string* value) override;

 private:
  std::string dbname_;
};

/// dbimpl.cc
#include <iostream>
int DB::Open(const std::string& name, DB** dbptr) {
  if (!dbptr) {
    return -1;
  }
  *dbptr = new DBImpl(name);
  if (*dbptr == nullptr) {
    return -1;
  }
  return 0;
}

int DBImpl::Put(const std::string& key, const std::string& value) {
  std::cout << "[Put] " << key << " " << value << std::endl;
  return 0;
}

int DBImpl::Delete(const std::string& key) {
  std::cout << "[Delete] " << key << std::endl;
  return 0;
}

int DBImpl::Get(const std::string& key, std::string* value) {
  std::cout << "[Get] " << key << std::endl;
  return 0;
}

/// main.cc
int main() {
  DB* dbptr;
  DB::Open("testdb", &dbptr);
  dbptr->Put("key", "value");
  dbptr->Delete("key");
  delete dbptr;
}

3、虚函数实现

虚函数是通过虚函数表 vtable 实现的，每个具有虚函数的 class 都具有虚函数表，通过 class 的大小我们可以看出一些端倪。

#include <iostream>
class Base {
 public:
  void* private_;
};

class Base2 {
 public:
  virtual void Out() { std::cout << "Cout" << std::endl; }
  virtual void Out2() { std::cout << "Cout2" << std::endl; }

 public:
  void* private_;
};

int main() {
  std::cout << "sizeof(Base) = " << sizeof(Base) << std::endl;
  std::cout << "sizeof(Base2) = " << sizeof(Base2) << std::endl;

  Base b;
  Base2 b2;
  std::cout << &b << ' ' << &(b.private_) << std::endl;
  std::cout << &b2 << ' ' << &(b2.private_) << std::endl;

  return 0;
}

执行后输出为（ADM64 平台，Debian系统）

sizeof(Base) = 8
sizeof(Base2) = 16
0x7ffdc4ef5298 0x7ffdc4ef5298
0x7ffdc4ef5280 0x7ffdc4ef5288

可以看到，具有虚函数的 Base2 比 Base 大 8 个字节（一个指针的大小），我们猜测 Base2 具有如下布局

+-----------+
|    vtable_   | ---------->+-------------+
+-----------+                  |    func out   |
|   private_   |                  +-------------+
+-----------+                  |    func out2 |
                                       +-------------+

为了验证我们的想法，做如下尝试，强制

#include <iostream>
class Base {
 public:
  void* private_;
};

class Base2 {
 public:
  virtual void Out() { std::cout << "Cout" << std::endl; }
  virtual void Out2() { std::cout << "Cout2" << std::endl; }

 public:
  void* private_;
};

int main() {
  Base2 b2;
  typedef void (*PFunc)();
  uint64_t** vtable = reinterpret_cast<uint64_t**>(&b2);
  PFunc out = (PFunc)((*vtable)[0]);
  PFunc out2 = (PFunc)((*vtable)[1]);
  out();
  out2();

  return 0;
}

输出为

Cout
Cout2

印证了我们的想法。为了进一步印证我们的想法，我们验证如下事情：对于派生类重写的虚函数，应该指向不同的地址，而没有重写的虚函数，基类和派生类应该指向同一地址。

#include <iostream>
class Base {
 public:
  virtual void Out() { std::cout << "Cout" << std::endl; }
  virtual void Out2() { std::cout << "Cout2" << std::endl; }
};

class Derive : public Base {
 public:
  virtual void Out() { std::cout << "Derive::Cout" << std::endl; }
};

int main() {
  typedef void (*PFunc)();
  {
    Base b;
    uint64_t** vtable = reinterpret_cast<uint64_t**>(&b);
    PFunc out = (PFunc)((*vtable)[0]);
    std::cout << (void*)(*vtable)[0] << std::endl;
    PFunc out2 = (PFunc)((*vtable)[1]);
    std::cout << (void*)(*vtable)[1] << std::endl;
    out();
    out2();
  }
  {
    Derive d;
    uint64_t** vtable = reinterpret_cast<uint64_t**>(&d);
    PFunc out = (PFunc)((*vtable)[0]);
    std::cout << (void*)(*vtable)[0] << std::endl;
    PFunc out2 = (PFunc)((*vtable)[1]);
    std::cout << (void*)(*vtable)[1] << std::endl;
    out();
    out2();
  }
  return 0;
}

输出为

0x561426d43320
0x561426d43358
Cout
Cout2
0x561426d43390
0x561426d43358
Derive::Cout
Cout2

进一步印证了我们的猜想。

4、多重继承虚函数实现

#include <iostream>
class Base {
 public:
  virtual void Out() { std::cout << "Cout" << std::endl; }

  uint64_t val;
};

class Base2 {
 public:
  virtual void Out2() { std::cout << "Cout2" << std::endl; }

  uint64_t val2;
};

class Derive : public Base, public Base2 {
 public:
  virtual void Out2() { std::cout << "Derive::Cout2" << std::endl; }
  virtual void Out3() { std::cout << "Derive::Cout3" << std::endl; }

  uint64_t val3;
};

int main() {
  Derive d;
  std::cout << "sizeof(Derive) = " << sizeof(Derive) << std::endl;
  std::cout << &d << std::endl;
  std::cout << &d.val << std::endl;
  std::cout << &d.val2 << std::endl;
  std::cout << &d.val3 << std::endl;
  return 0;
}

从 Derive 的布局来看，多重继承也有相似的虚函数实现：每一个基类都会有自己的虚函数表，派生类的虚函数表的数量根据继承的基类的数量来定。

sizeof(Derive) = 40
0x7fff72a07df0
0x7fff72a07df8
0x7fff72a07e08
0x7fff72a07e10

还是和之前一样，我们看看 vtable 如何布局，已经 Derive 新定义的虚函数在那个 vtable 中。

首先，如果有另外一个 Derive2 继承 Derive，并且没有添加虚函数，那么第一个 vtable 应该具有 Derive 定义的三个虚函数，因此猜测布局如下：


                        +---> +----------------------+
+----------+     |          |         Base1::Out         |
|  vtable     |---+         +-----------------------+
+----------+                |         Derive::Out2      |
|     val1     |                +-----------------------+
+----------+                |        Derive::Out3       |
|  vtable     |---+         +-----------------------+
+----------+    |     
|     val2     |    +---> +-----------------------+
+----------+              |         Base2::Out2()      |
|     val3     |             +-----------------------+
+----------+

我们通过代码

int main() {
  Derive d;
  typedef void (*PFunc)();
  uint64_t** vtable1 = reinterpret_cast<uint64_t**>(&d);
  std::cout << &(*vtable1)[0] << std::endl;
  std::cout << &(*vtable1)[1] << std::endl;
  std::cout << &(*vtable1)[2] << std::endl;

  for (int i = 0; i < 3; ++i) {
    std::cout << &(*vtable1)[i] << std::endl;
    PFunc func = (PFunc)((*vtable1)[i]);
    func();
  }

  std::cout << std::endl;

  uint64_t** vtable2 = reinterpret_cast<uint64_t**>((char*)&d + 16);
  for (int i = 0; i < 3; ++i) {
    std::cout << &(*vtable2)[i] << std::endl;
    PFunc func = (PFunc)((*vtable2)[i]);
    func();
  }
  return 0;
}

输出为

0x55ae7e38ed20
0x55ae7e38ed28
0x55ae7e38ed30
0x55ae7e38ed20
Cout
0x55ae7e38ed28
Derive::Cout2
0x55ae7e38ed30
Derive::Cout3

0x55ae7e38ed48
Derive::Cout2
0x55ae7e38ed50
Segmentation fault

和我们的猜想符合。

欢迎关注公众号“源知源为”，阅读更多技术干货
C/C++基础 文章被收录于专栏

C/C++ 语言基础

全部评论
这个直接看汇编会更好
点赞
送花 回复
分享
发布于 2023-06-18 15:31 湖南

相关推荐

头像 会员标识 头像
Hello_WordN
昨天 09:01
嵌入式软件开发
兄弟们谈谈心(薪)
找工作的终极目标：谈薪！谈高薪！兄弟们咱们别给多少钱都干，第一影响市场行情&nbsp;第二对于自己来说越高的薪资&nbsp;代表自己越好的生活水平第一点：重点(HR的定位）记住：你不是在和给你打电话的HR谈，只是让这个HR把你的诉求上报上去，所以别把HR当敌人，统一战线，为己所用。我们与HR之间并没有太大的利益关系，你多1k、2k不会太影响HR，所以我们并没有直接的交易关系，大多数的薪资一般HR没有决定权，只有申报权，可能有个界定，如果小于岗位预期可能HR就可以定，大于需要申报，这个区分各个公司，不过首先我们需要正视HR，摆正你和他的关系是你谈薪的一个好的开始。1.&nbsp;谈薪就是——讨价还价&nbsp;谈薪谈薪，重点是“谈”...
投递知乎等公司7个岗位 > 牛客在线求职答疑中心 牛客解忧铺
点赞 评论 收藏
转发
头像 头像
做人要有梦想dji
昨天 16:25
已编辑
理想汽车_底层软件工程师(准入职员工)
华为实习技术面+主管面(已入池)
投递岗位：终端BG软件部--&gt;通用软件开发整体面试流程：4.23笔试--&gt;4.25综合测评--&gt;5.11上午技术面--&gt;5.11下午主管面首先说一下我不知道二面就是下午，技术面刚过就发短信过来让我开始准备，我以为系统发错了，因为一面刚刚变绿，然后又发了一个前面同学在准备了啥的，我就意识到是一天两面。技术面1、自我介绍2、无八股，围绕简历比赛和两个项目问相关技术(因为我是华为校园大使，所以面试管问了我作为校园大使做了什么工作，然后主要是问的项目和竞赛内容，怎么做的，做了什么，负责了那些内容还有一些细节)（1）问挑战杯、互联网＋、数学建模比赛相关（2）嵌入式项目问主控选型、...
投递华为等公司10个岗位 > 嵌入式学习免费专栏 第一次面试 通信硬件人笔面经互助
点赞 评论 收藏
转发
头像
人狠话不多的椰子很友好
04-07 10:58
西安电子科技大学 电子信息类
点赞 评论 收藏
转发
头像
爱看剧的大西瓜一定要上岸
05-11 12:14
已编辑
门头沟学院 电子信息类
点赞 评论 收藏
转发
5 8 评论
分享

全站热榜

正在热议
# 牛客帮帮团来啦！有问必答 #
710717次浏览 11528人参与
# 许愿池 #
77224次浏览 1542人参与
# 通信硬件人笔面经互助 #
107804次浏览 2178人参与
# 你的秋招进展怎么样了 #
501061次浏览 13425人参与
# 找工作时遇到的神仙HR #
177695次浏览 1744人参与
# 如何写一份好简历 #
259405次浏览 3918人参与
# 铜五铁六真的存在吗？ #
27366次浏览 293人参与
# 找工作，你会甘心进小厂还是猛冲大厂 #
35074次浏览 352人参与
# 产品实习，你更倾向大公司or小公司 #
35959次浏览 548人参与
# 非技术岗是怎么找实习的 #
73883次浏览 1385人参与
# 市场营销面经 #
4559次浏览 125人参与
# 互联网公司评价 #
79604次浏览 1087人参与
# 通信硬件薪资爆料 #
196362次浏览 1759人参与
# 你的秋招进行到哪一步了 #
353108次浏览 6269人参与
# 硬件兄弟们 甩出你的华为奖状 #
27522次浏览 180人参与
# 无实习如何秋招上岸 #
224771次浏览 3518人参与
# 投了多少份简历才上岸 #
56713次浏览 947人参与
# 面试中的破防瞬间 #
82597次浏览 1015人参与
# 通信/硬件的薪资开多少，才值得去？ #
10746次浏览 140人参与
# 产品人求职现状 #
50606次浏览 747人参与
牛客网
牛客企业服务