C++学习（一）-虚函数（1）

最新推荐文章于 2024-10-31 15:27:37 发布
原创 最新推荐文章于 2024-10-31 15:27:37 发布 · 571 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了C++中的多态性概念，包括编译时和运行时的多态，以及虚函数如何实现动态绑定。通过具体示例，解释了基类与派生类之间函数调用的不同情况。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1，多态性：是指不同对象收到相同的信息，产生不同的动作；简单地说，用一个名字定义不同的函数，这些函数执行不同但又类似的动作。也就是“一个接口，多钟方法”。

2，多态分为：编译时的多态和运行时的多态两种。

3，连编：是把函数名和函数体的程序代码连接在一起的过程。静态连编是在编译时完成的，动态连编是在运行时完成的，也就是在发生调用时，才去寻找和连接程序代码。

4，C++是编译性的，仍采用静态编译，但可以通过虚函数机制实现动态连编。编译时的多态性通过函数重载和运算符重载来实现。

5，(1)当基类指针指向子类对象时，基类指针调用基类和子类相同的函数时，调用的是基类的函数。

#include "stdafx.h"
#include "iostream"
using namespace std;

class Base
{
  public:
	  Base(int x,int y)
	  {
		  a=x;
		  b=y;
	  }
	   void show()
	  {
		  cout<<"调用的是基类函数"<<endl;
		  cout<<a<<" "<<b<<" "<<endl;
	  }
  private:
	  int a;
	  int b;
};

class Derived:public Base
{
public:
	Derived(int x,int y,int z):Base(x,y)
	{
		c=z;
	}
	 void show()//和基类相同的函数
	{
      cout<<"调用的是子类函数"<<endl;
	  cout<<"c="<<c<<endl;
	}
private:
	int c;
};
int main()
{
	Derived *pc=new Derived(30,50,40);  
	Base mc (30,20),*pb;
	pb=pc;            //基类指针指向子类对象
	//pc->show();       
	pb->show();     //基类指针调用基类和子类相同的函数时，调用的是基类的函数
	return 0;      
}

     实验结果如下：

  

   (2) 当基类的函数被设置为虚函数时，调用的子类中的函数。

    

#include "stdafx.h"
#include "iostream"
using namespace std;

class Base
{
  public:
	  Base(int x,int y)
	  {
		  a=x;
		  b=y;
	  }
	  virtual void show()//设置为虚函数
	  {
		  cout<<"调用的是基类函数"<<endl;
		  cout<<a<<" "<<b<<" "<<endl;
	  }
  private:
	  int a;
	  int b;
};

class Derived:public Base
{
public:
	Derived(int x,int y,int z):Base(x,y)
	{
		c=z;
	}
	 void show()
	{
      cout<<"调用的是子类函数"<<endl;
	  cout<<"c="<<c<<endl;
	}
private:
	int c;
};
int main()
{
	Derived *pc=new Derived(30,50,40);  
	Base mc (30,20),*pb;
	pb=pc;            //基类指针指向子类对象
	//pc->show();       
	pb->show();     //基类指针调用基类和子类相同的函数时，调用的是子类的函数
	return 0;      
}

 实验结果如下：


     (3) 当基类的虚函数带有缺省参数时时，调用的是基类中函数，即缺省参数的虚函数是静态绑定的。

#include "stdafx.h"
#include "iostream"
using namespace std;

class Base
{
  public:
	  Base(int x,int y)
	  {
		  a=x;
		  b=y;
	  }
	  virtual void show(char* value="我是缺省参数")//基类虚函数为缺省参数
	  {
		  cout<<"调用的是基类函数"<<endl;
		  cout<<a<<" "<<b<<" "<<value<<"\n"<<endl;
	  }
  private:
	  int a;
	  int b;
};

class Derived:public Base
{
public:
	Derived(int x,int y,int z):Base(x,y)
	{
		c=z;
	}
	 void show()
	{
      cout<<"调用的是子类函数"<<endl;
	  cout<<"c="<<c<<endl;
	}
private:
	int c;
};
int main()
{
	Derived *pc=new Derived(30,50,40);  
	Base mc (30,20),*pb;
	pb=pc;            //基类指针指向子类对象
	//pc->show();       
	pb->show();     //基类指针调用基类和子类相同的函数时，调用的是基类的函数
	return 0;      
}

实验结果如下：


     以上（1），（2），（3），全都是基类对象指针指向子类对象。

     (4)，当子类对象指针调用基类和子类相同的函数时，调用的是子类中的函数。

        

#include "stdafx.h"
#include "iostream"
using namespace std;

class Base
{
  public:
	  Base(int x,int y)
	  {
		  a=x;
		  b=y;
	  }
	  void show()//和子类相同的函数
	  {
		  cout<<"调用的是基类函数"<<endl;
		  cout<<a<<" "<<b<<"\n"<<endl;
	  }
  private:
	  int a;
	  int b;
};

class Derived:public Base
{
public:
	Derived(int x,int y,int z):Base(x,y)
	{
		c=z;
	}
	 void show()//和基类相同的函数
	{
      cout<<"调用的是子类函数"<<endl;
	  cout<<"c="<<c<<endl;
	}
private:
	int c;
};
int main()
{
	Derived *pc=new Derived(30,50,40);  
	Base mc (30,20),*pb;
	//pb=pc;            //基类指针指向子类对象
	pc->show();         //子类对象指针调用基类和子类相同的函数时，调用的时子类的函数。
	//pb->show();     
	return 0;      
}

实验结果如下：

 

     (5)  子类可以继承基类的函数，并且在一定继承方式下，可以访问它，也就是说，子类没有基类同名的函数，在一定方式下，可以访问基类函数

  

#include "stdafx.h"
#include "iostream"
using namespace std;

class Base
{
  public:
	  Base(int x,int y)
	  {
		  a=x;
		  b=y;
	  }
	  void show()
	  {
		  cout<<"调用的是基类函数"<<endl;
		  cout<<a<<" "<<b<<"\n"<<endl;
	  }
  private:
	  int a;
	  int b;
};

class Derived:public Base
{
public:
	Derived(int x,int y,int z):Base(x,y)
	{
		c=z;
	}

private:
	int c;
};
int main()
{
	Derived *pc=new Derived(30,50,40);  //子类对象指针
	Base mc (30,20),*pb;
	//pb=pc;            //基类指针指向子类对象
	pc->show();         //子类对象指针调用基类函数
	//pb->show();     
	return 0;      
}


     实验结果如下：

  

 

     (6)，子类对象指针可以指向基类对象，但是必须强制类型转换。此时即使子类对象指针指向基类对象，在调用基类和子类相同函数时，调用的是子类函数。

  

#include "stdafx.h"
#include "iostream"
using namespace std;

class Base
{
  public:
	  Base(int x,int y)
	  {
		  a=x;
		  b=y;
	  }
	  void show()
	  {
		  cout<<"调用的是基类函数"<<endl;
		  cout<<a<<" "<<b<<"\n"<<endl;
	  }
  private:
	  int a;
	  int b;
};

class Derived:public Base
{
public:
	Derived(int x,int y,int z):Base(x,y)
	{
		c=z;
	}
	void show()
	{
		cout<<"调用的是子类函数"<<endl;
		//cout<<c<<"\n"<<endl;
	}
private:
	int c;
};
int main()
{
	Derived *pc=new Derived(30,50,40);  //子类对象指针
	Base mc (30,20),*pb;
	pc=(Derived*)&mc;            //子类对象指针指向基类对象
	pc->show();         //子类对象指针调用子类函数
	//pb->show();     
	return 0;      
}


       实验结果：

  

    (7)，当子类指针指向基类对象时，必须强制类型转换，若基类和子类中有相同的函数，并且该函数为虚函数，用子类对象指针访问该函数时，访问的是基类中的函数。

   

#include "stdafx.h"
#include "iostream"
using namespace std;

class Base
{
  public:
	  Base(int x,int y)
	  {
		  a=x;
		  b=y;
	  }
	  virtual void show()//设置为虚函数
	  {
		  cout<<"调用的是基类函数"<<endl;
		  cout<<a<<" "<<b<<"\n"<<endl;
	  }
  private:
	  int a;
	  int b;
};

class Derived:public Base
{
public:
	Derived(int x,int y,int z):Base(x,y)
	{
		c=z;
	}
	void show()
	{
		cout<<"调用的是子类函数"<<endl;
		//cout<<c<<"\n"<<endl;
	}
private:
	int c;
};
int main()
{
	Derived *pc=new Derived(30,50,40);  //子类对象指针
	Base mc (30,20),*pb;
	pc=(Derived*)&mc;            //子类对象指针指向基类对象
	pc->show();         //子类对象指针调用基类函数
	//pb->show();     
	return 0;      
}

   　　实验结果如下：

　

       总结：对于基类和子类中具有的相同函数，对象指针访问函数的选择，依据于其所属的类型，当该函数为虚函数；对象指针访问函数选择，依据于其指向的对象。

     

７，使用对象指针的目的是为了表达一种动态的性质，即当指针指向不同对象时，执行不同的操作。

８，虚函数的定义是在基类中进行的，当某个函数被定义为虚函数，其在一个或多个派生类中可以被重新定义，但是，其函数原型，包括返回值类型，函数名，形参个数，形参类型及顺序，必须与基类中原型完全相同。这也是与重载函数一个不同的地方。

９，通过定义虚函数机制来实现多态时，派生类必须从它的基类中公有继承。

１０，只有通过基类指针访问虚函数，才能获得运行时的多态性。

１１，一个虚函数无论被公有继承多少次，都保有虚函数的特性。


１２，虚函数必须是其所在类的成员函数，不能是友元函数，也不能是静态成员函数，因为虚函数调用必须依靠指定的对象来决定该激活哪一个函数。

１３，内联函数不能是虚函数，因为内联函数不能再运行时确定其位置。

１４，构造函数不能是虚函数，但是析构函数可以是虚函数，并且通常是虚函数。




C++小作业-虚函数--交通工具
编程小鹏的博客
05-13 1330
一、问题描述 定义一个交通工具vehicle，将他作为基类派生校车类car,卡车类truck和轮船类boat，定义类并定义虚函数来显示各类信息。 二、代码实现 #include<iostream> using namespace std; class vehicle { protected: double speed; //速度,公里/小时 int wheels; //轮子数 double weight; //重量 p
C++-继承-单继承-虚函数-内存结构分析-汇编分析-逆向分析（一）
插件开发
11-11 621
C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型级别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态“。对于使用者而言，意思就是将复杂的子类，按照父类统一的函数接口来进行访问。
虚函数1
徐海兴的专栏
06-20 429
虚函数联系到多态，多态联系到继承。所以本文中都是在继承层次上做文章。没了继承，什么都没得谈。 下面是对C++的虚函数这玩意儿的理解。 一， 什么是虚函数（如果不知道虚函数为何物，但有急切的想知道，那你就应该从这里开始） 简单地说，那些被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形
虚函数 1 之虚函数的引入（C++ 学习笔记 38）
aaqian1的博客
01-20 257
①虚函数是重载的另一种表现形式。 ②是一种动态的重载方式，它提供了一种更为灵活的运行时的多态性机制。 ③虚函数允许函数调用与函数体之间的联系在运行时才建立，即在运行时才决定如何动作，即所谓的动态联编。 一、虚函数的引入 例 1：虚函数的引例。 ...
纯虚函数
zxf347085420的博客
03-25 722
纯虚函数是一种特殊的虚函数，在许多情况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。这就是纯虚函数的作用。 定义 编辑 纯虚函数是一种特殊的虚函数，它的一般格式如下： class <类名> { virtual <类型><函数名>(<参数表>)=0; … }; 在许多情况下，在基类...
虚函数，纯虚函数，多态
Xueqian E的博客
09-04 515
虚函数：前面有virtual，在父类里面有定义，有实现。如： virtual void xuhanshu(){ cout<<"Im xuhanshu"<<endl } 纯虚函数：前面有virtual，在父类里面有定义，但是不实现。后面必须跟“=0”，如： virtual void chunxu（）=0； 二者格式： 虚函数-- virtual xuhanshu(){ method body }; 纯虚函数--virtual chunxu()=0;...
C++——虚函数/纯虚函数
m0_70214752的博客
03-02 1826
在学习C++的过程中，对于虚函数的概念有一定的疑惑，因此写一篇文章帮助自己记忆和理解。提示：以下是本篇文章正文内容，下面案例可供参考实际写代码的过程中经常会出现类继承的现象。而类继承中往往又容易出现函数重写或者重定义的情况（可以理解为函数重名）。如下，此时若我们定义了一个输入类型为Entity的指针(即基类指针）的函数，而给他入的是继承类的实例，则可能无法达到我们所需要的要求。y=0;
深入理解C++多态-虚函数
LeoLei8060的博客
05-23 1325
C++多态的实现方式可以分为静态多态和动态多态，其中静态多态主要有函数重装和模板两种方式，动态多态就是虚函数。
面向对象程序设计语言C++第07章-虚函数和多态性.ppt
最新发布
06-18
面向对象程序设计语言C++中的多态性是C++语言的核心特征之一，通过虚函数实现。多态性让不同的对象能够对同一消息作出不同的响应。C++支持两种类型的多态性：静态多态性和动态多态性。静态多态性通常通过函数重载和...
【C++】深入理解C++虚函数与纯虚函数
Colorful___的博客
03-02 2万+
虚函数是在基类中使用关键字virtual声明的成员函数，它允许派生类对其进行重写（Override），实现运行时多态。当通过基类指针或引用调用虚函数时，实际调用的是对象类型对应的派生类中的函数，这个过程称为动态绑定（Dynamic Binding）或晚绑定（Late Binding）。虚函数重写指的是派生类中提供一个函数版本，该版本与基类中具有相同名称、相同返回类型和相同参数列表的虚函数相匹配。通过这种方式，派生类可以提供自己特定的实现，替换或扩展基类的行为。
C++虚函数（详解）
qq_51753728的博客
10-31 5048
在基类中使用virtual关键字修饰的成员函数称为虚函数。虚函数是 C++ 中实现多态性的重要机制，它允许在派生类中重写基类中的函数。虚函数的核心特性在于，它使得通过基类指针或引用调用函数时，可以根据实际对象的类型选择相应的函数实现。
c++虚函数详解
weixin_45138932的博客
07-07 3万+
某基类中声明为virtual并在一个或多个派生类中重新定义的成员函数叫做虚函数。用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”。实现动态联编，在函数运行阶段动态的选择合适的成员函数。 在定义了虚函数后，可实现在派生类中对虚函数进行重写，从而实现统一的接口和不同的执行过程。...
C++ 虚函数详解
竹剑单
05-27 9394
文章目录虚函数的作用虚函数的原理：虚函数表指针和虚函数表虚函数表存储虚函数的顺序析构函数和虚函数纯虚函数 虚函数的作用 虚函数是为了实现动态多态。多态是指为不同的数据类型提供统一的接口，分为静态多态和动态多态。静态多态包括函数重载和模板函数，动态多态是：指针或引用类型可以根据运行中实际指向的派生类型的不同，来执行不同派生类的方法。 举个例子，有一个基类 Character 表示职业统称，玩家会选择职业战士 Warrior 或者魔法师 Magician，然后所有的逻辑例如攻击，防守都会根据玩家选择的不同职业有
C++虚函数（1）
Dextrad_ihacker的博客
08-09 539
多态：1.绑定：*Connecting a function call to a function body is called binding.（将函数体和函数调用关联起来，就叫绑定*） 2.然后，那么什么是早绑定？（Early binding） When binding is performed before the program is run (by the compiler and l
C++ 虚函数
yes1cpp的专栏
02-08 724
1、基类中虚函数定义：  （1） c++中成员函数默认为非虚函数，为了指明函数为虚函数，需在其前面加上保留字virtual。  （2） 除了构造函数之外，任意非static成员函数可以是虚函数。  （3） 基类通常应将派生类需要重定义的任意函数定义为虚函数    class Base { public: Base():isbn(""),price(10){}; Base(str
C++虚函数(1) - 虚函数介绍
05-26 648
C++虚函数(1) - 虚函数介绍
C++虚函数的一点分析与思考
字节跳动 内推找我
05-13 1521
简介： 以下是自己看过的书籍以及自己思考的流程和总结，主要是对C++虚函数分析了，分析并不算足够深入，但相信对理解c++的虚函数会有些帮助。现在仅仅写到了单继承下的一些皮毛，后面还要继续挖掘一下，希望自己能以淡定一点的心做好一块，不负自己。 以下内容适合了解一些C++虚函数以及对指针操作相对来说有点基础的朋友，因为里面为了验证自己的思考进行了很多指针的强转，下面的测试需要有实际的代码操作，不希
C++虚函数详解
热门推荐
qq_42048450的博客
05-26 13万+
1.虚函数的使用？ 1.1虚函数的定义 在实现c++多态时会用到虚函数。虚函数使用的其核心目的是通过基类访问派生类定义的函数。所谓虚函数就是在基类定义一个未实现的函数名，为了提高程序的可读性，建议后代中虚函数都加上virtual关键字。一般格式： class base { public: base(); virtual void test(); //定义的一个虚函数 private: char *basePStr; }; 上述代码在基类中定义了一个test的虚函数，所有可以在其子类重新定义父
虚函数
zhuoya_的博客
05-13 4918
本篇目录*************************************     什么是虚函数                           **     虚函数指针以及虚函数表          **     成为虚函数的条件                    **     虚函数的生存周期                    **     为什么要使用虚析构函数     ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值