成员函数重载(函数重载的要求是)
很多朋友对于成员函数重载和函数重载的要求是不太懂，今天就由小编来为大家分享，希望可以帮助到大家，下面一起来看看吧！
c++类成员函数的重载,覆盖和隐藏有什么区别
1.成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual
关键字可有可无。
2.覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual
关键字。
3.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
有关重载，应该是很好理解的（在同一个类中，函数名相同，函数的参数类型和个数不同），此处不予更多的说明，对于覆盖和隐藏（主要在基类和派生类中体现），借助下面这个例子来直观的说明：
#include<iostream>
using
namespace
std;
class
People
{
public:
//
隐藏:是指派生类的函数屏蔽基类函数
//
隐藏规则1：
//
1)
函数名相同
&&
参数不同
//
2)
virtual不影响
void
getId_different_params()
{cout
<<
"People::getId_different_params"
<<
endl;}
virtual
void
getName_different_params()
{cout
<<
"People::getName_different_params"
<<
endl;}
//
隐藏规则2:
//
1)
函数名相同
&&
参数相同
//
2)
无virtual
void
getPhone_same_params()
{cout
<<
"People::getPhone_same_params"
<<
endl;}
//
覆盖规则:
//
1)
函数名相同
&&
参数相同
//
2)
有virtual
virtual
void
getAddress_same_params()
{cout
<<
"People::getAddress_same_params"
<<
endl;}
};
class
Children
:
public
People
{
public:
//
隐藏:是指派生类的函数屏蔽基类函数
//
隐藏规则1：
//
1)
函数名相同
&&
参数不同
//
2)
virtual不影响
void
getId_different_params(int)
{cout
<<
"Children::getId_different_params(int)"
<<
endl;}
virtual
void
getName_different_params(int)
{cout
<<
"Children::getName_different_params(int)"
<<
endl;}
//
隐藏规则2:
//
1)
函数名相同
&&
参数相同
//
2)
无virtual
void
getPhone_same_params()
{cout
<<
"Children::getPhone_same_params"
<<
endl;}
//
覆盖规则:
//
1)
函数名相同
&&
参数相同
//
2)
有virtual
virtual
void
getAddress_same_params()
{cout
<<
"Children::getAddress_same_params"
<<
endl;}
};
void
main()
{
Children
*c
=
new
Children();
c->getId_different_params(1);
c->getName_different_params(1);
c->getPhone_same_params();
c->getAddress_same_params();
/*输出为：
Children::getId_different_params(int)
Children::getName_different_params(int)
Children::getPhone_same_params
Children::getAddress_same_params
*/
People
*p
=
new
Children();
p->getId_different_params();
p->getName_different_params();
p->getPhone_same_params();
p->getAddress_same_params();
/*输出为：
People::getId_different_params
//由于子类中的函数只是隐藏了基类中的函数而没有覆盖，因为指针为基类指针，故调用基类函数
People::getName_different_params
//由于子类中的函数只是隐藏了基类中的函数而没有覆盖，因为指针为基类指针，故调用基类函数
People::getPhone_same_params
//由于子类中的函数只是隐藏了基类中的函数而没有覆盖，因为指针为基类指针，故调用基类函数
Children::getAddress_same_params
//
由于子类中的函数覆盖了基类中的函数，虽然指针为基类指针，但是会调用子类函数
*/
}
关于C++重载运算符
所谓重载，就是重新赋予新的含义。函数重载就是对一个已有的函数赋予新的含义，使之实现新功能。
运算符也可以重载
运算符重载是对已有的运算符赋予多重含义
必要性
C++中预定义的运算符其运算对象只能是基本数据类型，而不适用于用户自定义类型（如类）
(一) C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。
（二） C++允许重载的运算符C++中绝大部分的运算符允许重载.
不能重载的运算符只有5个：
(1)成员访问运算符.
(2)作用域运算符∷
(3)条件运算符?:
(4)成员指针运算符*
(5)编译预处理命令的开始符号#
(三)重载不能改变运算符运算对象(即操作数)的个数。
(四)重载不能改变运算符的优先级别。
(五)重载运算符的函数不能有默认的参数，否则就改变了运算符参数的个数，与前面第(3)点矛盾。
(六)重载的运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个是类对象(或类对象的引用)。也就是说，参数不能全部是C++的标准类型，以防止用户修改用于标准类型数据的运算符的性质。
(七)用于类对象的运算符一般必须重载，但有两个例外，运算符“=”和“&”不必用户重载。
①赋值运算符(=)可以用于每一个类对象，可以利用它在同类对象之间相互赋值。
②地址运算符&也不必重载，它能返回类对象在内存中的起始地址。
总之，当C++语言原有的一个运算符被重载之后，它原先所具有的语义并没有消失，只相当于针对一个特定的类定义了一个新的运算符。
运算符重载可以使用成员函数和友元函数两种形式。可以参考以下的经验：
(1)只能使用成员函数重载的运算符有：=、()、[]、->、new、delete。
(2)单目运算符最好重载为成员函数。
(3)对于复合的赋值运算符如+=、-=、*=、/=、&=、!=、~=、%=、>>=、<<=建议重载为成员函数。
(4)对于其它运算符，建议重载为友元函数。
运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。也就是说，运算符重载是通过定义函数实现的。运算符重载实质上是函数的重载。重载运算符的函数一般格式如下：
函数类型 operator运算符名称(形参表列)
{
对运算符的重载处理
}
重载为类成员函数时参数个数=原操作数个数-1
（后置++、--除外）
重载为友元函数时参数个数=原操作数个数，且至少应该有一个自定义类型的形参。
将“+”、“-”运算重载为复数类的成员函数。
规则:
实部和虚部分别相加减。
操作数:
两个操作数都是复数类的对象。
#include<iostream>
using namespace std;
class complex//复数类声明
{
public://外部接口
complex(double r=0.0,double i=0.0)
{
real=r;
imag=i;
}//构造函数
complex operator+(complex c2);//+重载为成员函数
complex operator-(complex c2);//-重载为成员函数
void display();//输出显示复数
private://私有数据成员
double real;//复数实部
double imag;//复数虚部
};
complex complex::operator+(complex c2)//重载函数实现
{
complex c;
c.real=real+c2.real;
c.imag=imag+c2.imag;
return complex(c.real,c.imag);
}
complex complex::operator-(complex c2)//重载函数实现
{
complex c;
c.real=real-c2.real;
c.imag=imag-c2.imag;
return complex(c.real,c.imag);
}
void complex::display()
{ cout<<"("<<real<<","<<imag<<“i”<<")"<<endl;}
void main()//主函数
{ complex c1(5,4),c2(2,10),c3;//声明复数类的对象
cout<<"c1="; c1.display();
cout<<"c2="; c2.display();
c3=c1-c2;//使用重载运算符完成复数减法
cout<<"c3=c1-c2=";
c3.display();
c3=c1+c2;//使用重载运算符完成复数加法
cout<<"c3=c1+c2=";
c3.display();
}
程序输出的结果为：
c1=(5,4i)
c2=(2,10i)
c3=c1-c2=(3,-6i)
c3=c1+c2=(7,14i)
在本程序中对运算符“+”,”-”进行了重载，使之能用于两个复数的相加减。在该例中运算符重载函数operator+，operator－作为Complex类中的成员函数。
“+”，”-”是双目运算符，为什么在程序中的重载函数中只有一个参数呢？实际上，运算符重载函数有两个参数，由于重载函数是Complex类中的成员函数，有一个参数是隐含的，运算符函数是用this指针隐式地访问类对象的成员。
可以看到，重载函数operator+访问了两个对象中的成员，一个是this指针指向的对象中的成员，一个是形参对象中的成员。如this->real+c2.real，this->real就是c1.real。
在将运算符函数重载为成员函数后，如果出现含该运算符的表达式，如c1+c2,编译系统把它解释为c1.operator+(c2)
即通过对象c1调用运算符重载函数，并以表达式中第二个参数(运算符右侧的类对象c2)作为函数实参。运算符重载函数的返回值是Complex类型，返回值是复数c1和c2之和(Complex(c1.real+ c2.real,c1.imag+c2.imag))。
仔细看下吧你的问题都在里面这是我们的PPT
成员函数重载运算符和友元函数重载运算符
先上题：下列运算符都可以被友元函数重载的是：
A)=,+,-,
B) [],+,(),new
C)->,+,,>>
D)<<,>>,+,
正确答案为D
在运算符重载，友元函数运算符重载函数与成员运算符重载函数的区别是：友元函数没有this指针，而成员函数有，因此，在两个操作数的重载中友元函数有两个参数，而成员函数只有一个。
重载运算符的基本原则：
下面比较成员函数和非成员函数（友元函数）重载运算符
所以说，单目运算符建议选择成员函数。
下面是重点
=，（），[]，->
原因很简单，会和编译器默认分配的运算符重载成员函数冲突，引发歧义。
我们知道友元函数不是类的成员函数，它只是类的“朋友“，具有访问把它声明为“朋友”的类的数据成员的权限而已。
那么当把赋值运算符重载为类的友员函数，在程序中执行类对象的赋值语句时，程序就会出现两种矛盾的选择。
程序是不允许有矛盾不确定选择的，所以当赋值运算符重载为类的友元函数时，编译器就会提示错误。
对于剩下的3个运算符->, [],()为什么不能重载为友元函数，也是跟上面一样的道理。即编译器发现当类中没有定义这3个运算符的重载成员函数时，就会自己加入默认的运算符重载成员函数。
那么下面这个题的答案也就很明显了：
将x+y*z中的“+”用成员函数重载，“*”用友元函数重载应该写为：？
答案为：x.operator+(operator*(y,z))
成员函数重载的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于函数重载的要求是、成员函数重载的信息别忘了在本站进行查找哦。