C++如何确定：该调用基类的虚函数，还是派生类的？

云中飞鸿--张*峰

已于 2023-02-14 11:22:07 修改

阅读量647

点赞数

分类专栏： c/c++ 文章标签： c++ java 开发语言

于 2023-02-13 18:13:04 首次发布

本文链接：https://blog.csdn.net/zxf347085420/article/details/129014003

版权

c/c++ 专栏收录该内容

68 篇文章 1 订阅

订阅专栏

1.直接通过对象来调用：看该对象是谁(基类/派生类)的对象，是谁的对象，就调用谁的函数；

2.通过指针/引用来调用：根据指针/引用“指向的对象”的类型，决定调用谁的函数；

Base *p = new Base();//指针指向“基类对象”，所以会调用 “基类的函数”

Base *p = new Son();//指针指向“派生类对象”，所以会调用 “派生类的函数”

举例说明：

#include "stdafx.h"
#include <iostream>

using namespace std;

class myclass
{
public:
   int i;
   virtual void go()
   {
       i = 0;
       show();
   }
   void show()
   {
       std::cout << "myclass->show()" << std::endl;
   }
   virtual ~myclass()
   {
       // 不加virtual 会造成内存泄漏
   }
};
class newmyclass: public myclass
{
public:
   void go() //子类重写/覆盖父类的虚函数（带不带virtual，都一样，都是虚函数！）
   {
       std::cout << "newmyclass->go()" << std::endl;
   }
   void show()
   {
       std::cout << "newmyclass->show()" << std::endl;
   }
   void put()
   {
       std::cout << "newmyclass->put()" << std::endl;
   }
};

// 1: 指针
void test1(myclass *p)//参数：父类类型指针
{
p->go();
}

// 2: 引用
void test2(myclass &p)//参数：父类类型引用
{
p.go();
}

// 3: 对象
void test3(myclass my)//参数：父类对象
{
my.go();
}

int main()
{
   //1.使用对象调用
   //my是类myclass的一个实例对象，而不是指向类myclass的对象的指针或引用，
   //所以函数调用my.go()是实调用，函数的入口地址是在编译阶段静态决定的
   myclass my;
   my.go();   // 正常调用父类的go函数

newmyclass newmy;
newmy.go(); // 正常调用子类的go函数

   //2.使用指针调用
   //myclass *pmy(nullptr);//父类指针
   myclass *pmy(NULL);
   pmy->show(); // 空指针可以调用show操作
   //pmy->go(); // 空指针无法调用go函数，因为myclass类，没有实例化为对象，go函数内部操作了对象的内部变量，此时该内部变量并没有构造出来

   myclass *p = new newmyclass;//创建的是“子类对象”
   p->go();          //调用子类的go函数
   p->myclass::go(); // 指定调用父类的go函数
   std::cout << typeid(p).name() << std::endl; //p的类型为父类类型指针 class myclass *
   std::cout << typeid(*p).name() << std::endl; //*p的类型为子类类型 class newmyclass

   //1.使用指针调用：根据指针对象指向的对象的类型决定
   test1(p); // 调用子类的go函数（形参指针指向：p指针指向子类对象）
   test1(&my); // 调用父类的go函数（形参指针指向：my是父类对象）
   test1(&newmy); // 调用子类的go函数（形参指针指向：newmy是子类对象）

   //2.使用引用调用：根据引用对象引用的对象的类型决定
   // 引用在语言内部用指针实现，引用是操作受限了的指针（仅容许取内容操作）
   test2(*p); // 调用子类的go函数（形参引用：*p是子类对象）
   test2(my); // 调用父类的go函数（形参引用：my是父类对象）
   test2(newmy); // 调用子类的go函数（形参引用：newmy是子类对象）

   //3.使用对象调用：谁的对象，就调用谁的函数
   // 对象作为参数，会使用拷贝构造函数，形成对象的副本
   test3(*p);          // 调用父类的go函数（形参对象：是父类对象）
   test3(my);        // 调用父类的go函数（形参对象：是父类对象）
   test3(newmy); // 调用父类的go函数（形参对象：是父类对象）

   //std::cout << "mytest" << std::endl;
   system("pause");
   return 0;
}

/*
myclass->show()
newmyclass->go()

myclass->show()
newmyclass->go()
myclass->show()

class myclass *
class newmyclass

newmyclass->go()
myclass->show()
newmyclass->go()

myclass->show()
myclass->show()
myclass->show()
*/

//==================================================

二、如果不是虚函数调用，而是基类和派生类中2个一样函数的调用

1.直接通过对象来调用：看该对象是谁(基类/派生类)的对象，是谁的对象，就调用谁的函数；

2.通过指针/引用来调用：根据指针/引用的类型，决定调用谁的函数；

Base *p = new Base();//指针类型是Base，所以会调用 “基类的函数”

Base *p = new Son();//指针类型是Base，所以会调用 “基类的函数”