c++编程学习：多态性&重载

最新推荐文章于 2023-10-30 19:00:00 发布
最新推荐文章于 2023-10-30 19:00:00 发布
阅读量701 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： c++ 文章标签： 多态&重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_22613757/article/details/84820839
本文详细介绍了C++中的多态性和重载，包括函数重载和运算符重载。通过成员函数和友元函数实现复数对象的加法运算，并探讨了重载的规则和限制，以及不同类型的运算符重载实现方式，如双目和单目运算符的成员函数和友元函数重载。

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

多态性与重载

  • 多态性是面向对象程序设计的重要特性之一。多态是会一个名字有很多种语义，或一个相同界面有很多多种实现；或是指发出同样的消息被不同类型的对象接收而导致完全不同的行为，即对象根据所接收到的消息做出相应的操作。

  • 消息主要是指对象成员函数的调用，不同的行为指不同的实现。

多态的实现：
  1. 函数重载
  2. 运算符重载
  3. 虚函数
函数重载
  • 多态性的一种形式，它是指允许在相同的作用域内，相同的函数名对应着不同得实现。
  • 函数重载的条件是要求函数参数的类型或个数有所不同。

在这里插入图片描述

  • 成员函数重载有三种方式：

  1. 在一个类中重载：参数的特征区分；例如：
    show（int, char）; show(char*, float);

  2. 在不同类中重载：实用类作用域符：：加以区分（不同类中重载，静态成员函数），例如：
    Circle::show(); Point::show();

  3. 根据类对象加以区分（不同类中重载，不同成员函数），例如：
    acircle.show() 调用 Circle::show()
    apoint.show() 调用 Point::show()

  4. 基类的成员函数在派生类中重载：继承时再介绍。

通过成员函数实现2个复数对象的加法运算
#include <iostream>
using namespace std;
class complex//复数类声明
{
public:	
	complex(double r=0.0,double i=0.0) //构造函数
    {	real=r;	imag=i;}void Show( );	//显示复数的值
       complex add(complex &c);//复数与复数相加的函数
private:	
	double real;
	double imag;
};	
complex  complex::add(complex &c2) //通过成员函数实现
{
	complex t;
	t.real=real+c2.real;
	t.imag=imag+c2.imag;
	return t;
}
void complex::Show()
{
	cout<<"("<<real<<","<<imag<<")"<<endl; 
}	

int main()     //主函数
{
	complex z1(1.5,2.8),z2(-2.3,3.4),z3;  //声明复数类的对象
	z3=z1.add(z2);//成员函数调用
	cout<<"z3=";
	z3.Show();
	return 0;
}
通过友元函数实现2个复数对象的加减运算
#include <iostream>
using namespace std;
class complex	//复数类声明
{
public:	//外部接口
	complex(double r=0.0,double i=0.0)
        {real=r;imag=i;}//构造函数
	friend complex add(complex &c1,complex &c2); //add2个复数友元函数	
	void Show();	//输出复数
private:	//私有数据成员
	double real;	//复数实部
	double imag;	//复数虚部
};	
complex  add(complex &c1,complex &c2) //通过友元函数实现
{	complex t;
	t.real=c1.real+c2.real;
	t.imag=c1.imag+c2.imag;
	return t;
}
void complex::Show()
{	cout<<"("<<real<<","<<imag<<")"<<endl; 
}

int main()     //主函数
{
complex z1(1.5,2.8),z2(-2.3,3.4),z3;  //声明复数类的对象
z3=add(z1,z2);//友元函数调用
cout<<"z3=";
z3.Show();
return 0;
}
通过成员函数重载实现2个复数对象的加减运算，以及1个复数对象和1个实数对象加法运算
#include <iostream>
using namespace std;
class complex	//复数类声明
{
public:	//外部接口
	complex(double r=0.0,double i=0.0){real=r;imag=i;}//构造函数
	complex add(complex &c2); //2个复数对象加的成员函数
	complex add(double e); //1个复数对象与1个实数加的成员函数	
	void Show();	//输出复数
private:	//私有数据成员
	double real;	//复数实部
	double imag;	//复数虚部
};	
void complex::Show()
{	cout<<"("<<real<<","<<imag<<")"<<endl; 
}
complex  complex::add(complex &c2) //通过成员函数实现
{	complex t;
	t.real=real+c2.real;
	t.imag=imag+c2.imag;
	return t;
}
complex  complex::add(double e) //通过成员函数实现
{	complex t;
	t.real=real+e;
	t.imag=imag;
	return t;
}
int main()     //主函数
{complex z1(1.5,2.8),z2(-2.3,3.4),z3,z4; 
z3=z1.add(z2);//成员函数调用
z4=z3.add(5.6);
cout<<"z3=";
z3.Show();
cout<<"z4=";
z4.Show();
return 0;
}
通过友元函数重载实现2个复数对象的加法运算，以及一个复数和一个实数的加法运算。
#include <iostream>
using namespace std;
class complex	//复数类声明
{
public:	//外部接口
complex(double r=0.0,double i=0.0)//构造函数
{real=r;imag=i;}
friend complex add(complex &c1,complex &c2); //2个复数对象加友元函数
friend complex add(complex &c1,double e); //1个复数对象与1个实数加友元函数
void Show();	//输出复数
private:	//私有数据成员
	double real;	//复数实部
	double imag;	//复数虚部
};
void complex::Show()
{	cout<<"("<<real<<","<<imag<<")"<<endl; 
}
complex  add(complex &c1,complex &c2) //通过友元函数实现
{	complex t;
	t.real=c1.real+c2.real;
	t.imag=c1.imag+c2.imag;
	return t;
}
complex add(complex &c1,double e) //通过友元函数实现
{complex t;
t.real=c1.real+e;
t.imag=c1.imag;
return t;
}
int main()     //主函数
{complex z1(1.5,2.8),z2(-2.3,3.4),z3,z4; z3=add(z1,z2);
z4=add(z3,5.6);
cout<<"z3=";
z3.Show();
cout<<"z4=";
z4.Show();
return 0;
}
小结
  • 定义一种新的数据类型，就同时需要定义对这种类型数据的操作，最基本的方法就是定义一系列能够完成各种运算的函数。
  1. 利用成员函数实现运算，函数中可方便的访问复数对象中的私有函数。
  2. 利用友元函数实现运算，提供了一种非成员函数访问复数对象中的私有成员的手段。
  3. 利用函数重载这一种多态性形式，提供在相同的作用域内，相同的函数名对应着不同的实现。
运算符重载

运算符重载是对已有的运算符富余多重含义。有两种方式：

  1. 重载为成员函数
  2. 重载为友元函数
实质
  • 必要性
    • c++中预定义的运算符其运算对象只能是基本数据类型，而不适用于用户自定义类型（如类）。
  • 实现机制
    • 将指定的运算表达式转化为对运算符函数的调用，运算对象转化为运算符函数的实参。
    • 编译系统对运算符的选择，遵循函数重载的选择原则。
规则和限制
  1. 可以重载c++中除下列运算符外的所有运算符：
    . * :: ?: sizeof
  2. 只能重载c++语言中已有的运算符，不可臆造新的。
  3. 不改变原运算符的优先级和结核性。
  4. 不能改变操作数个数。
  5. 经重载的运算符，其操作数中至少应该有一个是自定义类型（类）。
声明形式
函数类型   operator 运算符 （形参）
{
	body;
}
//作为成员函数重载时，第一个操作数就是当前对象本身，因此她并不需要出现在参数表中。
  1. 重载为类成员函数时：
    参数个数 = 原操作数个数 - 1（后置++ 、 --除外）
  2. 重载为友元函数时：
    参数个 = 原操作数个数，且至少应该有一个自定义类型的形参。
    由于友元函数不是任何类的成员函数，因此重载是必须在参数表中显示的给出所有的操作数。
双目运算符重载为成员函数

双目运算符 B

  • 如果要重载B为类成员函数，使之能够实现：
    表达式 oprd1 B oprd2， 其中oprd1为A类对象，则B应被重载为A类的成员函数，形参类型应该是oprd2所属的类型。
  • 经重载后，表达式oprd1 B oprd2 相当于oprd1.operator B(oprd2).
    即对象名oprd1.函数名B(参数)的调用形式。
将“+”运算重载为复数类的成员函数
  • 实现2个复数对象的加法运算，add 成员函数与 “+”运算符重载为成员函数。
#include <iostream>
using namespace std;
class complex	//复数类声明
{
public:	//外部接口
	complex(double r=0.0,double i=0.0){real=r;imag=i;}//构造函数
	complex add(complex &c2); //add成员函数
	complex operator +(complex &c2); //+重载为成员函数
	void Show();	//输出复数
private:	//私有数据成员
	double real;	//复数实部
	double imag;	//复数虚部
};	
complex  complex::add(complex &c2) //通过成员函数实现
{	complex t;
	t.real=real+c2.real;
	t.imag=imag+c2.imag;
	return t;
}
complex complex::operator +(complex &c2)  //重载+运算符为成员函数
{	complex t;
	t.real=real+c2.real;
	t.imag=imag+c2.imag;
	return t;//相当于return complex(t.real,t.imag);
}
void complex::Show()
{	cout<<"("<<real<<","<<imag<<")"<<endl; 
}
int main()     //主函数
{	complex z1(1.5,2.8),z2(-2.3,3.4),z3,z4	z3=z1.add(z2);//成员函数调用
	cout<<"z3=";
	z3.Show();
	z4=z1+z2;//+运算符重载 
	cout<<"z4=";
	z4.Show();	
	return 0;
}

双目运算符重载为友元函数

将“+”运算符重载为复数类的成员函数
  • 实现2个复数对象的加法运算，add 成员函数与“+”运算符重载为友元函数。
#include <iostream>
using namespace std;
class complex	//复数类声明
{public:	//外部接口
	complex(double r=0.0,double i=0.0)//构造函数
	{real=r;imag=i;}
	friend complex add(complex &c1,complex &c2); //add2个复数友元函数	
	friend complex operator +(complex &c1,complex &c2); //+重载为友元函数
	void Show();	//输出复数
private:	//私有数据成员
	double real;	//复数实部
	double imag;	//复数虚部
};	
complex  add(complex &c1,complex &c2) //通过友元函数实现
{	complex t;
	t.real=c1.real+c2.real;
	t.imag=c1.imag+c2.imag;
	return t;
}
complex  operator +(complex &c1,complex &c2) //通过友元函数重载+运算符 
{	complex t;
	t.real=c1.real+c2.real;
	t.imag=c1.imag+c2.imag;
	return t;
}
void complex::Show()
{	cout<<"("<<real<<","<<imag<<")"<<endl; 
}
int main()     //主函数
{	complex z1(1.5,2.8),z2(-2.3,3.4),z3,z4	z3=add(z1,z2);//友元函数调用	cout<<"z3=";
	z3.Show();
	z4=z1+z2;//+运算符重载 
	cout<<"z4=";
	z4.Show();	
	return 0;
}

单目运算符重载为成员函数

  • 前置单目运算符 U

    • 如果要重载前置 U 为类成员函数，使之能够实现表达式U oprd，其中oprd 为A类对象，则U应被重载为A类的成员函数，无形参。
    • 经重载后，表达式U oprd相当于oprd.operator U ()

  • 后置单目运算符 U

    • 如果要重载后置U为类成员函数，使之能够实现表达式oprd U,其中 oprd 为A 类对象，U应被重载为A类的成员函数，且具有一个int 类型的参数。
    • 经重载后，表达式oprd U 相当于oprd.opreator U(0) // 参数0 为后置运算标志。
#include <iostream>
using namespace std;
class complex	//复数类声明
{
public:	//外部接口
	complex(double r=0.0,double i=0.0){real=r;imag=i;}//构造函数
    complex operator ++(); //重载前置++运算符为成员函数
    complex operator ++(int); //重载后置++运算符为成员函数
	void Show();	//输出复数
private:	//私有数据成员
	double real;	//复数实部
	double imag;	//复数虚部
};	
complex complex::operator ++() //重载成员函数实现
{	complex t;
	t.real=real+1;
	t.imag=imag+1;
	real=real+1;
	imag=imag+1;
	return t;//相当于return complex(t.real,t.imag);
}
complex complex::operator ++(int) //重载成员函数实现
{	complex t;
	t.real=real;
	t.imag=imag;
	real=real+1;
	imag=imag+1;
	return t;//相当于return complex(t.real,t.imag);
}
void complex::Show()
{
	cout<<"("<<real<<","<<imag<<")"<<endl; 
}
int main()     //主函数
{complex z1(1.5,2.8),z2(1.5,2.8),z3,z4;
z3=++z1;//++前置运算符重载 
cout<<"z3=";
z3.Show();	
z4=z2++;//++后置运算符重载 
cout<<"z4=";
z4.Show();	
return 0;
}

单目运算符重载为友元函数

  • 前置单目运算符 U

    • 如果要重载 前置U 为类友元函数，使之能够实现表达式 U oprd，其中 U 应被重载为 A 类的成员函数，形参为oprd 所属类型。
    • 经重载后，表达式 U oprd 相当于 operator U(oprd)

  • 后置单目运算符U

    • 如果要重载后置U为类友元函数，使之能够实现表达式 oprd U ，其中U应被重载为 A 类的成员函数，有2个形参，其中一个是oprd所属类型，另一个是int 类型形参，但不必写形参名。
    • 经重载后，表达式 oprd U 相当于 operator U(oprd,0)。
    • //参数0只是后置运算标志
#include <iostream>
using namespace std;
class complex	//复数类声明
{
public:	//外部接口
	complex(double r=0.0,double i=0.0){real=r;imag=i;}//构造函数
    friend complex operator ++(complex &c); //重载前置++运算符为友元函数
    friend complex operator ++(complex &c,int); //重载后置++运算符为友元函数
	void Show();	//输出复数
private:	//私有数据成员
	double real;	//复数实部
	double imag;	//复数虚部
};	
complex operator ++(complex &c) //重载友元函数实现
{	complex t;
	t.real=c.real+1;
	t.imag=c.imag+1;
	c.real=c.real+1;
	c.imag=c.imag+1;
	return t;//相当于return complex(t.real,t.imag);
}
complex operator ++(complex &c,int) //重载友元函数实现
{	complex t;
	t.real=c.real;
	t.imag=c.imag;
	c.real=c.real+1;
	c.imag=c.imag+1;
	return t;//相当于return complex(t.real,t.imag);
}
void complex::Show()
{
cout<<"("<<real<<","<<imag<<")"<<endl; 
}
int main()     //主函数
{complex z1(1.5,2.8),z2(1.5,2.8),z3,z4;
z3=++z1;//++前置运算符重载 
cout<<"z3=";
z3.Show();	
z4=z2++;//++后置运算符重载 
cout<<"z4=";
z4.Show();	
return 0;
}

参考：https://blog.youkuaiyun.com/PattyAndSmith/article/details/84341952

C++多态实现——函数重载
PixelLogic的博客
08-23 229
C++中的多态性是指在使用相同的名称调用不同的函数。一种方式实现多态性是通过函数重载。函数重载是指可以有多个同名函数，但其参数类型或数量必须不同。C++编译器可以根据参数的类型和数量来区分不同的同名函数，并自动调用合适的函数，即实现函数重载。它简单易用，只需要定义同名函数并通过参数类型和数量的区分实现不同的功能即可。对于初学者来说，掌握函数重载是非常重要的，也是进一步理解C++多态性的关键所在。在上面的例子中，我们定义了一个名为Test的类，并在该类中定义了三个同名函数print，它们参数类型或数量不同。
斗破C++编程入门系列之三十七：多态性：运算符重载的概念和规则（四星斗师）
最新发布
南北粉面馆
10-06 893
但是由于实力悬殊，墨承仍然不是萧炎与海老的对手，为了进一步提升实力，墨承决定去密室将青鳞吞噬，当萧炎与海老追至密室门口，却被一个紫色的保护罩阻挡，正当萧炎与海老不知如何之时，一个神秘女子却带着青鳞似箭簇穿出，萧炎与海老追了过去，同时还有气急败坏的墨承，后续故事如何发展，请听下回分解。墨家的宴席正在进行中，但是苦苦寻找青鳞不得的萧炎，没有办法只能在家宴中质问墨承，并揭露墨承人面兽心的一面。斗气有十一个阶别，斗之气，斗者，斗师，大斗师，斗灵，斗王，斗皇，斗宗，斗尊，斗圣，斗帝。斗气大陆上很久没有出现过斗帝了。
C++中多态性和重载
一步一步往上爬~~~
03-10 2332
面向对象的三大特征： 1.封装：保证对象自身数据的完整性、安全性 2.继承：建立类之间的关系，实现代码复用、方便系统的扩展 3.多态：相同的方法调用可实现不同的实现方式。多态是指两个或多个属于不同类的对象，对于同一个消息（方法调用）作出不同响应的方式。 、、、、、、、、、 实现多态的方式： 函数重载；运算符重载；虚函数 、、、、、、、、、 C++有两
c++多态之重载
Robert_Gordon的博客
06-06 442
重载
c++ 多态、覆盖、重载的综述
wei_god的专栏
04-15 3645
在基类中定义了一个虚拟函数，然后在派生类中又定义一个同名，同参数表的函数，这就是多态。多态是这3种情况中唯一采用动态绑定技术的一种情况。也就是说，通过一个基类指针来操作对象，如果对象是基类对象，就会调用基类中的那个函数，如果对象实际是派生类对象，就会调用派声类中的那个函数，调用哪个函数并不由函数的参数表决定，而是由函数的实际类型决定。
C++：多态之重载
我们的征途是星辰大海
03-02 2405
在C++中，有两种重载，一种是函数的重载，另一种是运算符的重载。     C++的重载最早出现在基本运算符上。例如，加法操作只有一个运算符+，但是它却可以实现整数，浮点数，指针的加法运算。函数的重载与运算符的重载实现的效果一样，都是一种东西，实现相似的功能，只是在调用时，使用的参数的个数或类型上有不同。     函数的重载   如下，定义了4个函数，它们的名字都是：myMax(),但是，其中
C++中的多态性：深入理解与实践指南
09-14
C++作为一门支持多态性的编程语言，提供了多种机制来实现这一特性。本文将详细探讨C++中的多态性，包括它的基本概念、实现方式以及如何在实际编程中应用。 多态性是C++中一个强大的特性，它提供了编写灵活、可扩展...
C++实验三：多态性与运算符重载实践报告
该压缩包包含的内容涉及面向对象程序设计中的多态性实现以及C++语言中的运算符重载。以下是对文件标题、描述和文件列表中所涉及的知识点进行的详细阐述。 1. 面向对象程序设计中多态性的实现 多态性是面向对象程序...
C++实验报告多态性.doc
08-04
总结，本实验旨在通过具体实例帮助学生掌握C++中的多态性，包括静态多态性和动态多态性，以及它们在实际编程中的应用。这不仅加深了对面向对象编程的理解，也为后续的复杂项目开发打下了坚实的基础。
详解C++编程的多态性概念
01-20
C++支持多态性，在C++程序设计中能够实现多态性。利用多态性可以设计和实现一个易于扩展的系统。 顾名思义，多态的意思是一个事物有多种形态。多态性的英文单词polymorphism来源于希腊词根poly(意为&ldquo;很多&rdquo;)和morph...
C++---多态之重载多态
f斗牛士的博客
04-23 343
多态指有多重形式。函数多态即函数有多种形式；函数重载指有多个同名函数，对名称进行了重载。 函数的参数列表，也称为函数特征标。两函数的参数的数目、类型、参数的排列顺序相同，则函数的特征标相同。C++中可以定义名称相同的函数，但它们的特征标不能相同。 实例1 float Add(int m); float Add(int m,int n); float Add(int m,float n); ...
c++——函数重载（多态）
afootball的博客
08-10 1325
一、什么是函数重载 函数重载是c++在C语言基础上新增的功能。函数重载又称函数多态，就是能够使用多个同名的函数，同时可以实现函数的多种形式。函数重载的关键是函数的参数列表（函数特征标），如果俩个函数的参数数目和类型相同，同时参数的排列顺序也相同，则它们的特征标相同。c++允许定义相同名称的函数，前提条件是它们的特征标不同。 //函数重载例子，下面三个函数的特征标不同 void printf(int a,char b）;//1 void printf(int a,float b);//2 void print
c++函数重载(多态特性)
XiaoMingCL的博客
01-29 280
在同一个作用域内，可以声明几个功能类似的同名函数， 但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。不能仅通过返回类型的不同来重载函数。 当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。 void print(int a ) void print(int a, int b = 15) {
c++多态性，多态，和重载
u010029439的博客
03-18 492
多态性分两个部分： 1.静态多态性：通过重载实现，同名不同参。 2.动态多态性：多态，子类覆盖父类方法，运行时根据指针的类型来决定最终执行的方法。即：虚函数。 重载是同名不同参，参数完全一样顺序不同也叫同名不同参。 参考：http://www.runoob.com/cplusplus/cpp-overloading.html 在同一个作用域内，可以声明几个功能类似的同名函数，但是...
【C++】多态 ⑤ ( 重载 | 重写 | 重定义 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
10-30 1467
一、重载、重写、重定义概念 1、重载 Overloading 2、重写 Overriding 3、重定义 Redefinition
C++重载，重定义和多态
mxy568767179的博客
05-15 402
重载 重载函数通常用来在同一个作用域内 用同一个函数名 命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。 函数重载要求： 1.在同一个作用域内（同一个类中） 2.函数名字相同 3.参数列表不同：个数，类型，顺序 4.返回值不同不做为重载条件 重定义 重定义实际上是同名隐藏：在派生类中定义基类中存在的函数，派生类对象就只能访问自己的函数，而不能访问基类的同名函数（除非进行作用域扩展声明）重定义同样可以增强程序的可读性，减少函数名的数量，更重要的是它可以让相
C++多态，重载
wangleiwavesharp的专栏
11-17 467
多态(polymorphisn)可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。 封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。 而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。 静态多样性就是在编译时期确定函数的调用关
2022.01.30 C++ 基础（六）（重载、多态）
chenyfan_blog
01-30 1277
C++ 重载、多态、virtual
多态与重载
m0_47597369的博客
06-19 2607
多态和重载前言一、多态1. 定义格式2. 多态的特点3. 多态的示例二、重载1. 重载的作用2. 重载的原则3. 重载的示例2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、多态 多态是指某对象的某一行为在不同情况下的不同表现形式。 1. 定义格式 定义格式：父类类型 变量名=new 子类类型(); // D.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值