it编程 > 编程语言 > C/C++

c++虚函数及常见问题汇总

17人参与 • 2025-12-01 • C/C++

封装，抽象，继承，多态是面向对象编程语言的特点。个人认为抽象和继承都是手段，多态才是目的，继承是多态的基础。

封装：

（1）将属性和函数封装到一个类里边，属性和函数组成一个完整的对象

（2）权限管理，增强安全性

（3）暴露有限的接口，增强了易用性，增强了安全性

抽象：

（1）抽象这个概念存在于很多场景，我们使用函数，本身就是通过函数隐藏具体的实现细节，这也算抽象

（2）c++ 中的抽象，可以使用抽象类来认识，抽象类是包含纯虚函数的类，抽象类不能创建对象

继承：

（1）技术来源于生活，生活中的对象，比如植物，动物，都存在继承

（2）继承带来的好处是子类可以复用父类的属性和函数

（3）c++ 中继承是实现多态的基础

多态：

同一个父类，可以派生出多个子类，每个子类都有自己专有的属性和方法，多姿多态，丰富多彩

1 多态

提到多态我们一般会想到这样一种使用场景：有一个基类，基类里边有虚函数；不同的类继承基类，然后分别在虚函数中实现自己的逻辑，覆盖基类的虚函数；派生类的指针也可以赋值给基类指针，通过基类指针调用虚函数的时候调用的是派生类实现的函数。

上边说的是典型的多态的场景，在有些文章或者书中，也把重载说成是一种多态。本节分别举一个虚函数多态的例子，一个重载多态的例子。

1.1 虚函数

如下代码， phone 是一个基类，类中有一个虚函数 virtual boid callup()。phone 派生出 3 个类，applephone，miphone，oppophone。在 main 函数中针对 3 个派生类，分别创建了一个对象。定义了 3 个函数 callup1()，callup2()，callup3()，3 个函数的形参分别是 phone 引用，phone 指针，phone 对象，在 main() 函数中分别调用这 3 个函数。

#include <iostream>
#include <string>
class phone {
public:
    virtual ~phone() {
      std::cout << "~phone()" << std::endl;
    }
    virtual void callup() {
      std::cout << "phone call up" << std::endl;
    }
};
class applephone : public phone {
public:
    void callup() {
        std::cout << "applephone call up" << std::endl;
    }
};
class miphone : public phone {
public:
    void callup() {
        std::cout << "miphone call up" << std::endl;
    }
};
class oppophone : public phone {
public:
    void callup() {
        std::cout << "oppophone call up" << std::endl;
    }
};
void callup1(phone &phone) {
  std::cout << "callup(phone &phone)" << std::endl;
  phone.callup();
}
void callup2(phone *phone) {
  std::cout << "callup2(phone *phone)" << std::endl;
  phone->callup();
}
// 派生类可以赋值给基类
// 因为基类中的数据成员，在派生类中都有
// 派生类赋值给基类的过程，就是成员赋值的过程
void callup3(phone phone) {
  std::cout << "callup3(phone phone)" << std::endl;
  phone.callup();
}
int main() {
    applephone apple;
    miphone mi;
    oppophone oppo;
    callup1(apple);
    callup1(mi);
    callup1(oppo);
    std::cout << std::endl;
    callup2(&apple);
    callup2(&mi);
    callup2(&oppo);
    std::cout << std::endl;
    callup3(apple);
    callup3(mi);
    callup3(oppo);
    std::cout << std::endl;
    return 0;
}

代码运行结果如下，可以看到，调用 callup1() 和 callup2() 能体现出多态的特点，分别调用的是类自己的 callup()；callup3() 没有体现多态，调用的都是基类的虚函数。引用传递和指针传递都能体现多态的特点；值传递不能体现多态的特点，还是调用的基类中的函数。

2 虚函数和虚函数表

2.1 函数名即地址

在 c 和 c++ 中函数和全局变量类似，都是有地址的，函数名就表示函数的入口地址。

如下代码，声明了一个函数指针 pf，形参和返回值与 hello 是一致的，这样就可以直接通过 pf 来对 hello 做函数调用了。

#include <iostream>
#include <string>
void hello(std::string name) {
  std::cout<< "hello " << name << std::endl;
}
typedef void (*pf)(std::string name);
int main() {
  std::cout<< (void *)hello << std::endl;
  hello("marry");
  pf pf = hello;
  std::cout << "pf = " << (void *)pf << std::endl;
  pf("tom");
  return 0;
}

2.2 虚表

虚函数表是虚函数工作的基础，也是实现多态的核心。对于有虚函数的类来说，都会有一个虚函数表。如下图所示，有虚函数的类，这个类的每个对象的第一个 8 字节(64 位系统是 8 字节，32 位系统是 4 字节) 中保存的是虚函数表的地址。

如果一个有虚函数的类，没有其它成员变量，那么 sizeof() 计算这个类的大小是 8(64 位系统上)，8 字节也就是存放虚函数表的空间。

#include <iostream>
#include <string>
class base {
public:
  virtual void sayhello1() {
    std::cout << "hello1" << std::endl;
  }
};
int main() {
  std::cout << "sizeof(base) = " << sizeof(base) << std::endl;
  return 0;
}

一个类的所有对象共用一张虚函数表，所以每个对象的第一个 8 字节里边存储的数据内容是相等的，都是虚函数表的地址。虚表中保存的是函数的地址，而函数又属于代码段，代码段是共享的，所以一个类的对象共享虚表。

如下代码，有一个包含虚函数的类 base，b1 和 b2 都是 base 的对象，我们获取对象第一个 8 字节中的内容，发现 b1 和 b2 是相等的，这也验证了一个类的对象指向同一个虚表。

#include <iostream>
#include <string>
class base {
public:
  virtual void sayhello1() {
    std::cout << "hello1" << std::endl;
  }
  virtual void sayhello2() {
    std::cout << "hello2" << std::endl;
  }
  virtual void sayhello3() {
    std::cout << "hello3" << std::endl;
  }
};
int main() {
  base b1;
  base b2;
  printf("&b1 = %p, *(long *)(&b1) = 0x%llx\n", &b1, *(long *)(&b1));
  printf("&b1 = %p, *(long *)(&b2) = 0x%llx\n", &b2, *(long *)(&b2));
  return 0;
}

运行结果如下，从打印信息来看，虚函数表的地址是 0x55f2dd2dbd58。

虚函数表中每一个表项都是一个函数的地址，在 64 位机器上，一个函数地址的长度是 8 字节，所以一个表项占  8 字节。如下代码，在类 base 中有 3 个虚函数，另外定义了一个函数指针类型。在 main 函数中首先找到了虚函数表，然后依次取出了虚函数的地址，通过函数地址可以直接进行调用。

#include <iostream>
#include <string>
class base {
public:
  virtual void sayhello1() {
    std::cout << "hello1" << std::endl;
  }
  virtual void sayhello2() {
    std::cout << "hello2" << std::endl;
  }
  virtual void sayhello3() {
    std::cout << "hello3" << std::endl;
  }
};
// 定义一个函数指针类型
typedef void (*pf)(void);
int main() {
  std::cout << "sizeof(base) = " << sizeof(base) << std::endl;
  base b;
  // vfptr 是指向虚函数表的地址
  long *vfptr = (long *)*(long *)(&b);
  // 虚函数表的第一个 8 字节就是函数 sayhello1 的地址
  long f1_function = *(vfptr + 0);
  // 虚函数表的第二个 8 字节是函数 sayhello2 的地址
  long f2_function = *(vfptr + 1);
  // 虚函数表的第三个 8 字节是函数 sayhello3 的地址
  long f3_function = *(vfptr + 2);
  printf("function1 = %p\n", f1_function);
  printf("function2 = %p\n", f2_function);
  printf("function3 = %p\n", f3_function);
  pf pf;
  pf = (pf)(f1_function);
  pf();
  pf = (pf)(f2_function);
  pf();
  pf = (pf)(f3_function);
  pf();
  return 0;
}

运行结果如下：

2.3 单继承，没有虚函数覆盖

如下代码， base 中有 3 个虚函数，derived 继承了 base 类， derived 中有 2 个虚函数。derived  中没有覆盖 base 中的函数，所以 derived 的虚表有 5 个表项，base 中的虚表有 3 个表项。

#include <iostream>
#include <string>
class base {
public:
  virtual void faa1() {
    std::cout << "faa1" << std::endl;
  }
  virtual void faa2() {
    std::cout << "faa2" << std::endl;
  }
  virtual void faa3() {
    std::cout << "faa3" << std::endl;
  }
};
class derived : public base{
public:
  virtual void fbb1() {
    std::cout << "fbb1" << std::endl;
  }
  virtual void fbb2() {
    std::cout << "fbb2" << std::endl;
  }
};
typedef void (*pf)(void);
void callpf1() {
  // base b; // base 中的虚表只有 3 个函数
  // 直接对象赋值，b 中的虚表也是只用 3 个表项
  // derived d;
  // base b = d;
  base b;
  long *vfptr = (long *)*(long *)(&b);
  long f1_function = *(vfptr + 0);
  long f2_function = *(vfptr + 1);
  long f3_function = *(vfptr + 2);
  long f4_function = *(vfptr + 3);
  long f5_function = *(vfptr + 4);
  pf pf;
  pf = (pf)(f1_function);
  pf();
  pf = (pf)(f2_function);
  pf();
  pf = (pf)(f3_function);
  pf();
  pf = (pf)(f4_function);
  pf();
  pf = (pf)(f5_function);
  pf();
}
void callpf2() {
  derived b;
  long *vfptr = (long *)*(long *)(&b);
  long f1_function = *(vfptr + 0);
  long f2_function = *(vfptr + 1);
  long f3_function = *(vfptr + 2);
  long f4_function = *(vfptr + 3);
  long f5_function = *(vfptr + 4);
  pf pf;
  pf = (pf)(f1_function);
  pf();
  pf = (pf)(f2_function);
  pf();
  pf = (pf)(f3_function);
  pf();
  pf = (pf)(f4_function);
  pf();
  pf = (pf)(f5_function);
  pf();
}
void callpf3() {
  base *b = new derived();
  long *vfptr = (long *)*(long *)(b);
  long f1_function = *(vfptr + 0);
  long f2_function = *(vfptr + 1);
  long f3_function = *(vfptr + 2);
  long f4_function = *(vfptr + 3);
  long f5_function = *(vfptr + 4);
  pf pf;
  pf = (pf)(f1_function);
  pf();
  pf = (pf)(f2_function);
  pf();
  pf = (pf)(f3_function);
  pf();
  pf = (pf)(f4_function);
  pf();
  pf = (pf)(f5_function);
  pf();
}
int main() {
  std::cout << "sizeof(base) = " << sizeof(base) << std::endl;
  std::cout << "sizeof(derived) = " << sizeof(derived) << std::endl;
  callpf2();
  std::cout << std::endl;
  callpf3();
  std::cout << std::endl;
  callpf1();
  std::cout << std::endl;
  return 0;
}

运行结果如下，因为 base 中的虚函数表的表项还是 3 个，所以调用 f4_function 和 f5_function 的时候会出现段错误。

2.4 单继承，有虚函数覆盖 --> 表项替换

在子类中，可以覆盖父类的虚函数，覆盖虚函数就是将虚函数表中的表项覆盖，改成子类中的虚函数的地址。当调用成员函数的时候，如果是虚函数，那么会查虚函数表，找到表之后再调用对应的函数。不同的子类，使用自己的虚函数地址覆盖了虚函数表的表项，那么函数调用的时候当然是调用子类中的函数。

如下代码，base 类中有 3 个虚函数；derived 继承了 base，覆盖了 base 中的 faa1 和 faa2；derived1 继承了 derived，覆盖了 faa1 和 faa2。

#include <iostream>
#include <string>
class base {
public:
  virtual void faa1() {
    std::cout << "faa1" << std::endl;
  }
  virtual void faa2() {
    std::cout << "faa2" << std::endl;
  }
  virtual void faa3() {
    std::cout << "faa3" << std::endl;
  }
};
class derived : public base{
public:
  virtual void faa1() {
    std::cout << "derived faa1" << std::endl;
  }
  void faa2() {
    std::cout << "derived faa2" << std::endl;
  }
  virtual void fbb1() {
    std::cout << "fbb1" << std::endl;
  }
  virtual void fbb2() {
    std::cout << "fbb2" << std::endl;
  }
};
class derived1 : public derived {
public:
  void faa1() {
    std::cout << "derived1 faa1" << std::endl;
  }
  void fbb1() {
    std::cout << "derived1 fbb1" << std::endl;
  }
};
typedef void (*pf)(void);
void callpf1() {
  // base b; // base 中的虚表只有 3 个函数
  // 直接对象赋值，b 中的虚表也是只用 3 个表项
  // derived d;
  // base b = d;
  base b;
  long *vfptr = (long *)*(long *)(&b);
  long f1_function = *(vfptr + 0);
  long f2_function = *(vfptr + 1);
  long f3_function = *(vfptr + 2);
  long f4_function = *(vfptr + 3);
  long f5_function = *(vfptr + 4);
  pf pf;
  pf = (pf)(f1_function);
  pf();
  pf = (pf)(f2_function);
  pf();
  pf = (pf)(f3_function);
  pf();
  pf = (pf)(f4_function);
  pf();
  pf = (pf)(f5_function);
  pf();
}
void callpf2() {
  derived b;
  long *vfptr = (long *)*(long *)(&b);
  long f1_function = *(vfptr + 0);
  long f2_function = *(vfptr + 1);
  long f3_function = *(vfptr + 2);
  long f4_function = *(vfptr + 3);
  long f5_function = *(vfptr + 4);
  pf pf;
  pf = (pf)(f1_function);
  pf();
  pf = (pf)(f2_function);
  pf();
  pf = (pf)(f3_function);
  pf();
  pf = (pf)(f4_function);
  pf();
  pf = (pf)(f5_function);
  pf();
}
void callpf3() {
  derived1 b;
  long *vfptr = (long *)*(long *)(&b);
  long f1_function = *(vfptr + 0);
  long f2_function = *(vfptr + 1);
  long f3_function = *(vfptr + 2);
  long f4_function = *(vfptr + 3);
  long f5_function = *(vfptr + 4);
  pf pf;
  pf = (pf)(f1_function);
  pf();
  pf = (pf)(f2_function);
  pf();
  pf = (pf)(f3_function);
  pf();
  pf = (pf)(f4_function);
  pf();
  pf = (pf)(f5_function);
  pf();
}
int main() {
  std::cout << "sizeof(base) = " << sizeof(base) << std::endl;
  std::cout << "sizeof(derived) = " << sizeof(derived) << std::endl;
  callpf2();
  std::cout << std::endl;
  callpf3();
  std::cout << std::endl;
  callpf1();
  std::cout << std::endl;
  return 0;
}

运行结果如下：

2.5 多继承

如下代码，有 3 个基类，base1，base2 和 base3。3 个基类中都有虚函数，也都有一个虚函数表。derived 类继承 3 个基类，那么 derived 中就有 3 个虚函数表。从打印的  derived 的大小也能看出来，base1、base2、base3 的大小是 8，derived 的大小是 24。

#include <iostream>
#include <string>
class base1 {
public:
  virtual void foo1() {
    std::cout << "base1::foo1" << std::endl;
  }
  virtual void faa2() {
    std::cout << "base1::faa2" << std::endl;
  }
  virtual void faa3() {
    std::cout << "base1::faa3" << std::endl;
  }
};
class base2 {
public:
  virtual void foo1() {
    std::cout << "base2::foo1" << std::endl;
  }
  virtual void fbb2() {
    std::cout << "base2::fbb2" << std::endl;
  }
  virtual void fbb3() {
    std::cout << "base2::fbb3" << std::endl;
  }
};
class base3 {
public:
  virtual void foo1() {
    std::cout << "base3::foo1" << std::endl;
  }
  virtual void fcc2() {
    std::cout << "base3::fcc2" << std::endl;
  }
  virtual void fcc3() {
    std::cout << "base3::fcc3" << std::endl;
  }
};
class derived : public base1, public base2, public base3 {
public:
  virtual void fbb1() {
    std::cout << "derived::fbb1" << std::endl;
  }
  void foo1() {
    std::cout << "derived::foo1" << std::endl;
  }
  void fbb2() {
    std::cout << "derived::fbb2" << std::endl;
  }
};
int main() {
  std::cout << "sizeof(base1) = " << sizeof(base1) << std::endl; // 8
  std::cout << "sizeof(base2) = " << sizeof(base2) << std::endl; // 8
  std::cout << "sizeof(base3) = " << sizeof(base3) << std::endl; // 8
  std::cout << "sizeof(derived) = " << sizeof(derived) << std::endl; // 24
  derived d;
  d.foo1();
  d.fbb2();
  d.fcc2();
  return 0;
}

运行结果如下：

2.6 一个类的多个对象是不是共享一个虚函数表 ?

是，一个包含虚函数的类的多个对象共享一个虚函数表。

如下代码，base 是基类，derived 是派生类。两个类分别有自己的虚函数表，对于一个类的多个对象来说，多个对象共享这个类的虚函数表。

对于一个对象来说，第一个 8 字节保存的就是虚函数表的地址，代码中打印出了每个对象的虚函数表。

#include <iostream>
#include <string>
class base {
public:
  base() {
    std::cout << "base()" << std::endl;
  }
  ~base() {
    std::cout << "~base()" << std::endl;
  }
  virtual void do() {
    std::cout << "base() do()" << std::endl;
  }
};
class derived : public base {
public:
  derived() {
    std::cout << "derived()" << std::endl;
  }
  ~derived() {
    std::cout << "~derived()" << std::endl;
  }
  void do() {
    std::cout << "derived() do()" << std::endl;
  }
};
typedef void (*pf)(void);
void testbase() {
  base b1;
  base b2;
  base b3;
  long *vfptr1 = (long *)*(long *)(&b1);
  long *vfptr2 = (long *)*(long *)(&b2);
  long *vfptr3 = (long *)*(long *)(&b3);
  std::cout << "1, virtual function table addr " << vfptr1 << std::endl;
  std::cout << "2, virtual function table addr " << vfptr2 << std::endl;
  std::cout << "3, virtual function table addr " << vfptr3 << std::endl;
  long f1 = *(vfptr1 + 0);
  long f2 = *(vfptr2 + 0);
  long f3 = *(vfptr3 + 0);
  pf pf1 = (pf)(f1);
  pf pf2 = (pf)(f2);
  pf pf3 = (pf)(f3);
  pf1();
  pf2();
  pf3();
}
void testderived() {
  derived d1;
  derived d2;
  derived d3;
  long *vfptr1 = (long *)*(long *)(&d1);
  long *vfptr2 = (long *)*(long *)(&d2);
  long *vfptr3 = (long *)*(long *)(&d3);
  std::cout << "1, virtual function table addr " << vfptr1 << std::endl;
  std::cout << "2, virtual function table addr " << vfptr2 << std::endl;
  std::cout << "3, virtual function table addr " << vfptr3 << std::endl;
  long f1 = *(vfptr1 + 0);
  long f2 = *(vfptr2 + 0);
  long f3 = *(vfptr3 + 0);
  pf pf1 = (pf)(f1);
  pf pf2 = (pf)(f2);
  pf pf3 = (pf)(f3);
  pf1();
  pf2();
  pf3();
}
void testderivedbase() {
  base *d1 = new derived;
  base *d2 = new derived;
  base *d3 = new derived;
  long *vfptr1 = (long *)*(long *)(d1);
  long *vfptr2 = (long *)*(long *)(d2);
  long *vfptr3 = (long *)*(long *)(d3);
  std::cout << "1, virtual function table addr " << vfptr1 << std::endl;
  std::cout << "2, virtual function table addr " << vfptr2 << std::endl;
  std::cout << "3, virtual function table addr " << vfptr3 << std::endl;
  long f1 = *(vfptr1 + 0);
  long f2 = *(vfptr2 + 0);
  long f3 = *(vfptr3 + 0);
  pf pf1 = (pf)(f1);
  pf pf2 = (pf)(f2);
  pf pf3 = (pf)(f3);
  pf1();
  pf2();
  pf3();
}
int main() {
  std::cout << "base ------------------------" << std::endl;
  testbase();
  std::cout << "derived ---------------------" << std::endl;
  testderived();
  std::cout << "derivedbase -----------------" << std::endl;
  testderivedbase();
  return 0;
}

打印结果如下：

（1）对于同一个类的多个对象来说，虚函数表是相同的

（2）基类和派生类的虚函数表是不同的，各自有各自的虚函数表，但是把派生类指针或者引用赋值给基类指针或者基类引用，那么基类中的虚函数表是派生类中的虚函数表

2.7 一个基类的多个派生类之间是共享一个虚表吗 ?

不是，虚函数表是以类为单位而存在的，一个基类的多个派生类分别有各自的虚函数表。

如下代码，base 是基类，有 3 个派生类 derived1，derived2 和 derived3。分别打印了 3 个派生类的虚函数表，虚函数表是不一样的。

#include <iostream>
#include <string>
class base {
public:
  base() {
    std::cout << "base()" << std::endl;
  }
  ~base() {
    std::cout << "~base()" << std::endl;
  }
  virtual void do() {
    std::cout << "base() do()" << std::endl;
  }
};
class derived1 : public base {
public:
  derived1() {
    std::cout << "derived1()" << std::endl;
  }
  ~derived1() {
    std::cout << "~derived1()" << std::endl;
  }
  void do() {
    std::cout << "derived1() do()" << std::endl;
  }
};
class derived2 : public base {
public:
  derived2() {
    std::cout << "derived2()" << std::endl;
  }
  ~derived2() {
    std::cout << "~derived2()" << std::endl;
  }
  void do() {
    std::cout << "derived2() do()" << std::endl;
  }
};
class derived3 : public base {
public:
  derived3() {
    std::cout << "derived3()" << std::endl;
  }
  ~derived3() {
    std::cout << "~derived3()" << std::endl;
  }
  void do() {
    std::cout << "derived3() do()" << std::endl;
  }
};
typedef void (*pf)(void);
void testbase() {
  base b1;
  base b2;
  base b3;
  long *vfptr1 = (long *)*(long *)(&b1);
  long *vfptr2 = (long *)*(long *)(&b2);
  long *vfptr3 = (long *)*(long *)(&b3);
  std::cout << "1, virtual function table addr " << vfptr1 << std::endl;
  std::cout << "2, virtual function table addr " << vfptr2 << std::endl;
  std::cout << "3, virtual function table addr " << vfptr3 << std::endl;
  long f1 = *(vfptr1 + 0);
  long f2 = *(vfptr2 + 0);
  long f3 = *(vfptr3 + 0);
  pf pf1 = (pf)(f1);
  pf pf2 = (pf)(f2);
  pf pf3 = (pf)(f3);
  pf1();
  pf2();
  pf3();
}
void testderived1() {
  derived1 d1;
  derived1 d2;
  derived1 d3;
  long *vfptr1 = (long *)*(long *)(&d1);
  long *vfptr2 = (long *)*(long *)(&d2);
  long *vfptr3 = (long *)*(long *)(&d3);
  std::cout << "1, virtual function table addr " << vfptr1 << std::endl;
  std::cout << "2, virtual function table addr " << vfptr2 << std::endl;
  std::cout << "3, virtual function table addr " << vfptr3 << std::endl;
  long f1 = *(vfptr1 + 0);
  long f2 = *(vfptr2 + 0);
  long f3 = *(vfptr3 + 0);
  pf pf1 = (pf)(f1);
  pf pf2 = (pf)(f2);
  pf pf3 = (pf)(f3);
  pf1();
  pf2();
  pf3();
}
void testderived2() {
  derived2 d1;
  derived2 d2;
  derived2 d3;
  long *vfptr1 = (long *)*(long *)(&d1);
  long *vfptr2 = (long *)*(long *)(&d2);
  long *vfptr3 = (long *)*(long *)(&d3);
  std::cout << "1, virtual function table addr " << vfptr1 << std::endl;
  std::cout << "2, virtual function table addr " << vfptr2 << std::endl;
  std::cout << "3, virtual function table addr " << vfptr3 << std::endl;
  long f1 = *(vfptr1 + 0);
  long f2 = *(vfptr2 + 0);
  long f3 = *(vfptr3 + 0);
  pf pf1 = (pf)(f1);
  pf pf2 = (pf)(f2);
  pf pf3 = (pf)(f3);
  pf1();
  pf2();
  pf3();
}
void testderived3() {
  derived3 d1;
  derived3 d2;
  derived3 d3;
  long *vfptr1 = (long *)*(long *)(&d1);
  long *vfptr2 = (long *)*(long *)(&d2);
  long *vfptr3 = (long *)*(long *)(&d3);
  std::cout << "1, virtual function table addr " << vfptr1 << std::endl;
  std::cout << "2, virtual function table addr " << vfptr2 << std::endl;
  std::cout << "3, virtual function table addr " << vfptr3 << std::endl;
  long f1 = *(vfptr1 + 0);
  long f2 = *(vfptr2 + 0);
  long f3 = *(vfptr3 + 0);
  pf pf1 = (pf)(f1);
  pf pf2 = (pf)(f2);
  pf pf3 = (pf)(f3);
  pf1();
  pf2();
  pf3();
}
int main() {
  std::cout << "base ------------------------" << std::endl;
  testbase();
  std::cout << "derived1 ---------------------" << std::endl;
  testderived1();
  std::cout << "derived2 ---------------------" << std::endl;
  testderived2();
  std::cout << "derived3 ---------------------" << std::endl;
  testderived3();
  return 0;
}

运行结果如下：

base ------------------------
base()
base()
base()
1, virtual function table addr 0x5565ee1b8d08
2, virtual function table addr 0x5565ee1b8d08
3, virtual function table addr 0x5565ee1b8d08
base() do()
base() do()
base() do()
~base()
~base()
~base()
derived1 ---------------------
base()
derived1()
base()
derived1()
base()
derived1()
1, virtual function table addr 0x5565ee1b8cf0
2, virtual function table addr 0x5565ee1b8cf0
3, virtual function table addr 0x5565ee1b8cf0
derived1() do()
derived1() do()
derived1() do()
~derived1()
~base()
~derived1()
~base()
~derived1()
~base()
derived2 ---------------------
base()
derived2()
base()
derived2()
base()
derived2()
1, virtual function table addr 0x5565ee1b8cd8
2, virtual function table addr 0x5565ee1b8cd8
3, virtual function table addr 0x5565ee1b8cd8
derived2() do()
derived2() do()
derived2() do()
~derived2()
~base()
~derived2()
~base()
~derived2()
~base()
derived3 ---------------------
base()
derived3()
base()
derived3()
base()
derived3()
1, virtual function table addr 0x5565ee1b8cc0
2, virtual function table addr 0x5565ee1b8cc0
3, virtual function table addr 0x5565ee1b8cc0
derived3() do()
derived3() do()
derived3() do()
~derived3()
~base()
~derived3()
~base()
~derived3()
~base()

2.8 虚函数重载

如下代码 base 是基类，derived 是派生类。base 中有两个虚函数 func1() 和 func2()，derived 中也有两个虚函数 func1() 和 func2()。derived 中的 func1() 和 base 中的 func1() 的形参列表是不一样的，所以 derived 中的 func1 不会覆盖 base 中的 func1。

#include <iostream>
#include <string>
class base {
public:
  base() {
    std::cout << "base()" << std::endl;
  }
  ~base() {
    std::cout << "~base()" << std::endl;
  }
  virtual void func1(int a) {
    std::cout << "base()::func1(int a), a = " << a << std::endl;
  }
  virtual void func2(int a = 100) {
    std::cout << "base()::func2(int a = 100), a = " << a << std::endl;
  }
};
class derived : public base {
public:
  derived() {
    std::cout << "derived()" << std::endl;
  }
  ~derived() {
    std::cout << "~derived()" << std::endl;
  }
  virtual void func1(double a) {
    std::cout << "derived()::func1(double a), a = " << a << std::endl;
  }
  virtual void func2(int a = 200) {
    std::cout << "derived()::func2(int a = 200), a = " << a << std::endl;
  }
};
typedef void (*pf)(int);
typedef void (*pf1)(double);
int main() {
  base *b = new derived;
  derived *d = new derived;
  std::cout << "----------------" << std::endl;
  b->func1(10);
  b->func1(1.123);
  b->func2();
  std::cout << "----------------" << std::endl;
  d->func1(10);
  d->func1(1.123);
  d->func2();
  return 0;
}

运行结果如下：

（1）派生类中的虚函数表如下

第一个表项是 base 中的 func1。

第二个表项在基类中是 base 中的 func2，在派生类中，derived 中的 func2 对 base 中的 func2 进行了覆盖。

第三个表象是派生类中的 func1，因为派生类中的 func1 和 base 中的 func1 形参不一样，所以不会对 base 中的 func1 进行覆盖。

（2）运行结果分析

① 使用 base 类型的指针或者 base 类型的引用，当指针指向 derived 对象的时候，调用 func1()，不管传参是 int 类型还是 double 类型，都是调用的 base 中的 func1()。当传参是 double 类型的时候也不是调用的 derived 中的 func1，也就是派生类和基类形不成重载。

② 使用 base 类型的指针或者引用，当指针指向 derived 对象的时候，调用 func2，调用的函数是 derived 中的 func2，但是默认参数还是 base 中初始化的。这个现象让人看起来有点奇怪，函数和默认参数不是配套的。

③ 使用 derived 指针或者引用，调用的 func1() 都是 derived 中的函数，不管入参是 int 还是 double。

④ 使用 derived 指针或者引用，调用 func2() 调用的是 derived 中的 func2()，并且形参默认是 200。

#include <iostream>
#include <string>
class base {
public:
  base() {
    std::cout << "base()" << std::endl;
    pb = new int[8];
  };
  virtual ~base() {
    std::cout << "~base()" << std::endl;
    if (pb) {
      std::cout << "delete pb" << std::endl;
      delete[] pb;
    }
  };
  virtual void do() {
    std::cout << "base() do()" << std::endl;
  }
  virtual void f() = 0;
  int *pb = nullptr;
};
class derived : public base {
public:
  derived() {
    std::cout << "derived()" << std::endl;
    pd = new int[16];
  };
  ~derived() {
    std::cout << "~derived()" << std::endl;
    if (pd) {
      std::cout << "delete pd" << std::endl;
      delete[] pd;
    }
  };
  void do() {
    std::cout << "derived() do()" << std::endl;
  }
  virtual void f() {
    std::cout << "derived() f()" << std::endl;
  }
  int *pd = nullptr;
};
int main() {
  derived *d1 = new derived();
  d1->do();
  delete d1;
  base *b1 = new derived;
  b1->do();
  delete b1;
  return 0;
}

3虚函数和纯虚函数

虚函数，之所以说是虚的，说的是在派生类中，可以覆盖基类中的虚函数；相对于虚函数来说，没有 virtual 修饰的函数可以叫做实函数，实函数的实现逻辑是不会变化的，不像虚函数，被继承之后就可以被覆盖，实现逻辑发生了变化。虚函数是实现多态的核心。虚函数和纯虚函数比较的话，虚函数可以在派生类中被覆盖，但是虚函数也是有自己的实现的，可以被直接调用；纯虚函数没有自己的实现，在派生类中可以被覆盖，并且必须实现。包含纯虚函数的类是抽象类，不能创建对象，如果抽象类的派生类中没有实现纯虚函数 ，那么派生类也是抽象类，不能创建对象。

虚函数和纯虚函数并没有严格的优劣之分。

从实际使用中，纯虚函数有一个优点，假如一个基类中的函数，派生类中必须实现自己的逻辑，而不能使用基类中的逻辑，那么就可以使用纯虚函数，这样在派生类中如果忘记实现了，那么编译器就会提示错误，起到了一个约束的作用；如果用虚函数实现，那么派生类中忘记实现的话，编译器也不会报错，起不到约束提醒的作用。

纯虚函数有以下两点：

（1）纯虚函数的声明方式

函数声明之后加 = 0，而不是花括号

（2）抽象类不能创建对象，抽象类的派生类如果没有实现所有的纯虚函数，派生类也是抽象类

（3）抽象类可以定义指针，并且可以使用派生类的指针给它赋值，也就是说抽象类虽然不能创建对象，但是抽象类的指针却可以指向一个对象

如下是使用抽象类的一个例子：

#include <iostream>
#include <string>
class phone {
public:
  phone() {
    std::cout << "phone()" << std::endl;
  }
  ~phone() {
    std::cout << "~phone()" << std::endl;
  }
  virtual void call() = 0;
  virtual void sendmessage(std::string msg) = 0;
};
class apple : public phone {
public:
  apple() {
    std::cout << "apple()" << std::endl;
  }
  ~apple() {
    std::cout << "~apple()" << std::endl;
  }
  virtual void call() {
    std::cout << "apple call()" << std::endl;
  }
  virtual void sendmessage(std::string msg) {
    std::cout << "apple send msg: " << msg << std::endl;
  }
};
class oppo : public phone {
public:
  oppo() {
    std::cout << "oppo()" << std::endl;
  }
  ~oppo() {
    std::cout << "~oppo()" << std::endl;
  }
  virtual void call() {
    std::cout << "oppo call()" << std::endl;
  }
};
class vivo : public phone {
public:
  vivo() {
    std::cout << "vivo()" << std::endl;
  }
  ~vivo() {
    std::cout << "~vivo()" << std::endl;
  }
  virtual void call() {
    std::cout << "vivo call()" << std::endl;
  }
  virtual void sendmessage(std::string msg) {
    std::cout << "vivo send msg: " << msg << std::endl;
  }
};
int main() {
  // 不能创建 phone 对象，因为 phone 是抽象类
  // phone phone;
  // 不能创建 oppo 对象，因为 oppo 没有实现 phone 中的 sendmessage 函数
  // 所以 oppo 也是抽象类
  // oppo oppo;
  std::cout << "sizeof(phone) = " << sizeof(phone) << std::endl;
  std::cout << "sizeof(apple) = " << sizeof(apple) << std::endl;
  std::cout << "sizeof(oppo) = " << sizeof(oppo) << std::endl;
  std::cout << "sizeof(vivo) = " << sizeof(vivo) << std::endl;
  phone *phone;
  apple apple;
  vivo vivo;
  phone = &apple;
  phone->call();
  phone->sendmessage("this is apple");
  phone = &vivo;
  phone->call();
  phone->sendmessage("this is vivo");
  return 0;
}

运行结果如下：

抽象类中也有虚表，从上边的打印来看，sizeof(phone) 计算出来的结果是 8。

3.1 为什么引入纯虚函数

一般在定义抽象类的时候，使用纯虚函数，抽象类也可以叫做接口类，起到接口约束的作用，但是这个类有没有创建对象的必要。

（1）包含纯虚函数的类是抽象类，抽象类不能创建对象

这是符合现实意义的，因为在现实中，有一个抽象类是植物，植物可以派生出玫瑰花，梧桐树等，但是植物本身创建对象是没有意义的。显示世界中没有任何一种生物，它就叫植物，而没有属于自己的名字。

（2）抽象类起到接口约束的作用

抽象类的派生类，如果不实现抽象类中所有的纯虚函数，那么派生类也是不能创建对象的，如果创建了对象，那么在编译的时候会报错误，在编译的时候就可以提醒开发者不能这么使用。如果使用虚函数，而不使用纯虚函数，那么起不到这样的规范作用。

3.2 纯虚函数和虚函数的相同点和不同点

相同点：

（1）在函数声明时都用 virtual 来修饰

（2）都有虚函数表，都可以用于实现多态

声明虚函数的类和声明纯虚函数的类中都有虚函数表，抽象类虽然不能创建对象，但是也有虚函数表。

不同点：

（1）声明方式不同

纯虚函数的声明方式为  virtual returntype functionname(parameter) = 0，纯虚函数不需要实现；虚函数在基类中的声明方式为 virtual returntype functionname(parameter)  {}，虚函数在基类中必须实现，如果虚函数没有实现会报编译错误。

#include <iostream>
#include <string>
class shape {
public:
  shape() {
    std::cout << "shape()" << std::endl;
  }
  /*
  ~shape() {
    std::cout << "~shape()" << std::endl;
  }
*/
  virtual double area(); /*{
    std::cout << "shape() area()" << std::endl;
    return 0;
  }; */
};
class square : public shape {
public:
  square(int length) : length_(length) {
    std::cout << "square(), length_ " << length_ << std::endl;
  }
  virtual double area() {
    std::cout << "sauqre() area " << length_ * length_ << std::endl;
    return length_ * length_;
  }
private:
  int length_;
};
int main() {
  square s1(10);
  square s2(20);
  s1.area();
  s2.area();
  return 0;
}

（2）纯虚函数，在派生类中必须要实现，否则派生类也是抽象类，不能创建对象；虚函数没有这个要求。

3.3 abstract class 官方文档 —— 纯虚函数可以有实现

abstract class - cppreference.com

我们上边说的虚函数必须有实现，那么纯虚函数是不是就不能有实现 ？其实不是的，纯虚函数也可以有实现。

（1）纯虚函数可以有实现

（2）纯虚函数的实现不能在类内声明的时候实现，而是可以在类外实现

（3）纯虚函数有实现，那么包含纯虚函数的类仍然是抽象类，不能实例化；继承抽象类的派生类，如果不实现基类中的纯虚函数，那么派生类也是抽象类，不能实例化

（4）纯虚函数如果没有实现，那么这个函数是不能直接调用的

（5）纯虚函数如果有实现，那么这个函数可以通过  类::函数 这样的方式调用，仍然不能直接调用函数，必须通过类来调用才可以

#include <iostream>
#include <string>
class abstract
{
public:
    // 纯虚函数，不能在声明的时候定义
    virtual void f() = 0; /* {
      std::cout << "a::f()\n";
    } */
    virtual void g() {
      // 纯虚函数不能这么调用, 会抛异常，pure virtual method called
      // f();
      // 如果纯虚函数没有实现，那么不能这么调用
      abstract::f();
      std::cout << "abstract() g()" << std::endl;
    }   // non-pure virtual
    ~abstract() {
        std::cout << "~abstract() ----------------" << std::endl;
        g();           // ok: calls abstract::g()
        // 纯虚函数，即使有实现，也不能这么调用
        // f();        // undefined behavior
        // 如果纯虚函数没有实现，则不能这么调用
        abstract::f(); // ok: non-virtual call
    }
};
// 纯虚函数不能在声明的时候定义，但是可以在类的外部定义
// definition of the pure virtual function
void abstract::f() {
    std::cout << "a::f()\n";
}
struct concrete : public abstract
{
    void f() override {
        // 如果纯虚函数没有实现，那么不能这么调用
        abstract::f(); // ok: calls pure virtual function
    }
    void g() override {
      std::cout << "concrete() g()" << std::endl;
    }
    ~concrete() {
        std::cout << "~concrete() ----------------" << std::endl;
        g(); // ok: calls concrete::g()
        f(); // ok: calls concrete::f()
    }
};
int main() {
  // 虽然纯虚函数有实现，但是 abstract 仍然会抽象类，不能创建对象
  // abstract a;
  concrete c;
  return 0;
}

到此这篇关于c++虚函数及常见问题的文章就介绍到这了,更多相关c++虚函数内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

赞 (0)

您想发表意见！！点此发布评论

推荐阅读

C++ ODB ORM 从入门到实战应用(ODB使用)

12-01

C++实现将文件保存到指定磁盘路径的完整指南

12-01

PyQt5实现多界面自由切换的完整项目实践指南

12-02

C++打印 vector的几种方法小结

11-30

C语言逗号运算符和逗号表达式的使用小结

11-30

C++ STL string迭代器的使用

12-02

猜你喜欢

版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。

发表评论