C++函数重载的方法

C++函数重载的方法

大家知道C++函数重载吗?在C++语言中，函数扮演着很重要的角色，不管面向过程设计，还是基于对象设计；不管是面向对象编程，还是基于泛型编程，函数都可以随处而见。

?在谈论C++中的函数重载、覆盖和隐藏之前，先回顾下函数的基础知识。?函数的声明包括函数的返回值类型，函数名称，参数列表（参数的类型、参数的个数、参数的顺序）。例如，声明一个两个整数之和的函数，int

iAdd(int

?iNum1,int iNum2);而函数的定义可以理解为对函数功能的详尽而准确的解说，通俗点，就是实现函数“how to

?do？”的效能。两个整数之和函数的定义如下：

?int iAdd(int iNum1,int iNum2){ return (iNum1+iNum2);}

?仔细观察函数的声明和定义，我们不难发现，函数的定义就是除掉函数声明后面的分号，换之成大括号，在大括号里面实现函数的功能。虽然在某些情况下，可以容许不对函数进行声明，只需要对函数定义，就能调用函数了。但是，强烈建议养成先声明函数，然后再定义函数，最后在调用函数的良好习惯。关于函数的基础知识，暂时论述到这。

?现在，进入本文的主题。函数重载（function

?overload），它是在同一可访问区域内部声明具有几个不同参数列（参数的类型、参数的个数，参数的顺序）的相同函数名称的一种机制，函数的调用是根据不同的参数类型和最佳匹配原则确定最终使用那个函数。函数覆盖（function

?override）是在派生类中完全一致性地声明了父类中的函数，区别在于函数

函数重载习题与解析

++习题与解析-重载 时间:2010-05-19 12:13:47 来源:第二电脑网作者:第二电脑网 第二电脑网导读：t< int add(int x,int y) { return x+y; } double add(double x,double y) { return x+y; } void main() { int a=4,b=6; double c=2.6,d=7.4; cout< class Sample { int i; double d; public: void setdata(int n){i=n;} void setdata(double x){d=x;} void disp() {

运算符重载练习题.

运算符重载 一．单项选择题 1．下列运算符中，运算符在C++中不能重载。 A．?： B．+ C． D．<= 解：C++中不能被重载的运算符有：·，一，：：，?：。本题答案为A。 2．下列运算符中，运算符在C++中不能重载。 A．&& B．[] C．：： D．new 解：c++中不能被重载的运算符有：·，·+，：：，?：。本题答案为c。 3．下列关于运算符重载的描述中，是正确的。 A．运算符重载可以改变操作数的个数 B．运算符重载可以改变优先级 C．运算符重载可以改变结合性 D．运算符重载不可以改变语法结构 解：运算符重载不能改变操作数的个数、运算符的优先级、运算符的结合性和运算程的语法结构。本题答案为D。 4．友元运算符objl>obj2被C++编译器解释为。 A．operator>(objl，obj2) B．>(obj1，obj2) C．obj2．operator：>(obj1) D．objl．operator>(obj2) 解：重载为友元函数的运算符的调用形式如下： operator<运算符>(<参数1>，<参数2>) 等价于：<参数1><运算符><参数2> 本题答案为A。 5．现需要对list类对象使用的逻辑运算符“==”重载，以下函数声明是正确的。 A、list & list：：operator==(const list &a)； B、list list：：operator==(const list &a)； C、bool & list：：operator==(const list &a)； D、bool list：：operator==(const list &a)； 6. 以下类中分别说明了“+=”和“++”运算符重载函数的原型。如果主函数中有定义： fun m,c,d;，那么，执行语句c=m++; 时，编译器把m++解释为： (33) A) c.operator++(m); B) m=operator++(m); C) m.operator++(m); D) operator++(m); class fun { public: .. .. .. fun operator +=(fun ); friend fun operator ++(fun &,int); }; 答案：D 7. 在第33题中，当执行语句d+=m; 时，C++编译器对语句作如下解释： (34) A. d=operator+=(m); B. m=operator+=(d); C. d.operator+=(m); D. m.operator+=(d); 答案：C 8. 设有以下类定义，其中说明了“+”运算符重载函数的原型。这是一个友元函数，当类

c 运算符的重载习题答案

1.概念填空题 1.1运算符重载是对已有的运算符赋予多重含义，使同一个运算符在作用于不同类型对象时导致不同的行为。运算符重载的实质是函数重载，是类的多态性特征。 1.2可以定义一种特殊的类型转换函数，将类的对象转换成基本数据类型的数据。但是这种类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。类类型转换函数既没有参数，也不显式给出返回类型。类类型函数中必须有return 表达式的语句返回函数值。一个类可以定义多个类类型转换函数。 1.3运算符重载时其函数名由operator运算符构成。成员函数重载双目运算符时,左操作数是对象,右操作数是函数参数。 2.简答题 2.2简述运算符重载的规则。 2.2简述重载单目运算符++、--，前置和后置时的差别。 2.3 C++中重运算符是否都可以重载?是否都可以重载成类的成员函数?是否都可以重载成类的友元函数? 2.4 构造函数作为类型转换函数的条件是什么。 3．选择题 3.1在下列运算符中,不能重载的是(B) A.！ B. sizeof C. new D. delete 3.2 不能用友员函数重载的是(A)。 A.= B.== C.<= D.++ 3.3下列函数中,不能重载运算符的函数是(B)。 A.成员函数 B.构造函数 C.普通函数 D.友员函数 3.4如果表达式++i*k时中的”++”和”*”都是重载的友元运算符，则采用运算符函数调用格式，该表达式还可表示为（B）。 A．operator*(i.operator++(),k) B．operator*(operator++(i),k) C．i.operator++().operator*(k) D．k.operator*(operator++(i)) 3.5已知在一个类体中包含如下函数原型：VOLUME operator-(VOLUME)const；下列关于这个函数的叙述中，错误的是（B ）。 A．这是运算符-的重载运算符函数 B．这个函数所重载的运算符是一个一元运算符 C．这是一个成员函数 D．这个函数不改变数据成员的值 3.6在表达式x＋y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的是（C ）。 A．operator+有两个参数，operator*有两个参数 B．operator+有两个参数，operator*有一个参数 C．operator+有一个参数，operator*有两个参数 D．operator+有一个参数，operator*有一个参数 4.写出下列程序运行结果 4.1#include #using namesoace std;

C++运算符重载例程详解

运算符重载就是对一个已有的运算符赋予新的含义，使之实现新功能。下面将通过简单的几个例程阐叙其用法。 例10.1 通过函数来实现复数相加。 #include using namespace std; class Complex //定义Complex类 {public: Complex( ){real=0;imag=0;} //定义构造函数 Complex(double r,double i){real=r;imag=i;} //构造函数重载Complex complex_add(Complex &c2); //声明复数相加函数void display( ); //声明输出函数private: double real; //实部 double imag; //虚部 }; Complex Complex::complex_add(Complex &c2) {Complex c; c.real=real+c2.real; c.imag=imag+c2.imag; return c;} void Complex::display( ) //定义输出函数{cout<<″(″<

int main( ) {Complex c1(3,4),c2(5,-10),c3; //定义3个复数对象c3=https://www.doczj.com/doc/d916448323.html,plex_add(c2); //调用复数相加函数cout<<″c1=″; c1.display( ); //输出c1的值cout<<″c2=″; c2.display( ); //输出c2的值 cout<<″c1+c2=″; c3.display( ); //输出c3的值 return 0; } 例10.2 改写例10.1，重载运算符“+”，使之能用于两个复数相加。#include using namespace std; class Complex {public: Complex( ){real=0;imag=0;} Complex(double r,double i){real=r;imag=i;} Complex operator+(Complex &c2); //声明重载运算符的函数void display( ); private: double real; double imag; }; Complex Complex::operator+(Complex &c2) //定义重载运算符的函数

第十章 运算符重载 复习题

运算符重载复习题 1. 重载赋值操作符时,应声明为( ) A. 友元函数 B. 虚函数 C. 成员函数 D. 多态函数 2.关于重载的描述，正确的是( ) A.函数重载只能在成员函数之间进行 B.函数重载只能在全局函数之间进行 C.函数重载可以在基类和派生类之间进行 D.函数重载必须要求同名的函数的形参类型和个数都完全一致，返回值类型无所谓 3．下列运算符中不能重载的是( )。 A．∷(域运算符) B.+ （正） C.++ （自增） D.*（指针） 4. 派生类的对象对它的基类成员中（） A. 公有继承的公有成员是可以访问的 B. 公有继承的私有成员是可以访问的 C. 公有继承的保护成员是可以访问的 D. 私有继承的公有成员是可以访问的 5 不能重载的运算符是（） A. ?: B. [ ] C. new D. && 6. C++中不能重载的运算符是( ) A. new B. += C. sizeof D. && 7.重载函数是( ) A.以函数参数来区分，而不用函数的返回值来区分不同的函数 B.以函数的返回值来区分，而不用函数参数来区分不同的函数 C.参数表完全相同而返回值类型不同的两个或多个同名函数 D.参数表和返回值类型中至少有一个不同的两个或多个同名函数 8.对于运算符重载，说法正确的是( ) A.运算符如果被重载为非成员函数，那么对象就不能利用这个运算符重载函数进行操作 B.运算符重载函数可能既不是成员函数，也不是友元函数 C.用户每定义一个类，系统会自动提供一个赋值运算符重载函数，所以完全不 必考虑重载赋值运算符函数 D.一个类的虚函数不能调用运算符重载函数 9. C++中不能重载的运算符是( )

c++运算符重载习题

Task8-1 /* 1. 定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。将运算符函数重载为非成员、非友元的普通函数。编写程序，求两个复数之和*/ #include using namespace std; class Complex { public: Complex(){real=0;imag=0;} Complex(double r,double i){real=r;imag=i;} void display(); double real; double imag; }; void Complex::display() { cout<<"("< using namespace std; class Counter { public: Counter(double Val=0.0) { itsVal=Val; }

double getValue()const { return itsVal; } Counter operator+ (const Counter &v) { return Counter(itsVal + v.getValue()); } private: double itsVal; }; int main() { Counter varOne(2), varTwo(4), varThree; varThree = varOne + varTwo; cout << "varOne: " << varOne.getValue()<< endl; cout << "varTwo: " << varTwo.getV alue() << endl; cout << "varThree: " << varThree.getValue() << endl; return 0; }

C++实验1重载函数和引用(附答案)

C++实验内容 实验一：重载函数和引用 一、实验目的 1、理解重载函数的意义。 2、掌握重载函数的使用方法。 3、引用的概念和使用。 二、实验内容 1、以下程序从键盘输入三角形的三边a、b、c，求能否构成三角形和三角形面积。 源程序代码： #include #include bool Validate(double a,double b,double c); void CalAndOutputArea(double a,double b,double c); void main() { double a,b,c; cout<<”请输入三角形的三边长度：”; cin>>a>>b>>c; if(Validate(a,b,c)) CalAndOutputArea(a,b,c); else cout<<”错误：不能构成三角形！”<0)&&(b>0)&&(c>0)) { if((a+b)<=c) return 0; if((a+c)<=b) return 0; if((c+b)<=a) return 0; return 1; //true } else return 0; //flase } void CalAndOutputArea(double a,double b,double c) { double s=(a+b+c)/2.0; double area=sqrt(s*(s-a)*(s-b)*(s-c)); cout<<”三角形(“<

c++ 基于时间类的运算符重载实验

实验：定义一个时间类Time(时，分，秒)，通过操作符重载实现： 时间的比较（==、!=、>、>=、<、<=）、时间增加/减少若干秒（+=、-=） 由题意，我定义了一个时间类Time，并且定义时(shi),分(fen),秒(miao)这些私有数据成员。 然后在main函数那里就可以通过构造函数定义一个时间了。如下图所示： 由上图可知，我还对（==、!=、>、>=、<、<=）这些运算符进行了重载，返回bool类型的值。而且，对于时间增加/减少若干秒，我用友元函数方式让一个时间类Time和int类型的数值（秒）相加。下面我将对各种运算符重载做详细说明。 1：首先，我们来看“==”这个运算符重载。 它在Cpp文件里的定义如下：

由上可知，只有两个时间类的时，分，秒分别相等，才能返回一个true值，否则返回一个false值。具体程序是通过条件语句构造而成，一目了然。而我们在main函数里先定义两个时间类time0，time1。分别让它们相等和不相等运行一次，实验结果如下： 2：我们来看“！=”这个运算符重载。 它在Cpp文件里定义如下： 由上可知，它就是把“==”运算符重载函数里的true和false互换而已，却起到了相反的效

果。实验结果如下： 3：我们来看“>”这个运算符重载。 它在Cpp文件里定义如下： 由上可知，程序有点复杂了，不过思路还是很清晰的。首先，通过比较两个时间类的时，看它们是否符合大于等于关系，如果没有则返回false值。然后比较时是否相等，如果不相等则说明第一个类的时一定大于第二个类的时，则返回true值。比较完时，如果在时相等的情况下，再来比较分，与比较时的程序相同，能轻松得出两个类的分的大小。在分也相等的情况下，再来比较秒，如果大于则返回true值，否则返回false值。至此，两类的时间大小可比较出来是否存在大于关系。鉴于有多种情况，我就其中3种进行截图。实验结果如下：

复数类,运算符重载(赋值运算符等)

/*定义复数类Complex， （1）定义私有数据成员，实部和虚部； （2）定义带默认值的构造函数，给数据成员赋值，默认值为0； （3）定义输出函数void display()，输出格式如“3+4i”或“-3-4i”； （4）定义复数与复数的加、减运算符重载；复数加实数运算符重载；赋值运算符重载；（5）定义主函数，对上述成员函数进行测试。 */ #include class Complex { private : double real; double imag; public: Complex(double r=0,double i=0) { real=r; imag=i; } void display() { cout<

{ real=c.real ; imag=c.imag ; return *this; } Complex operator -(Complex & c) { Complex temp; temp.real =c.real -real; temp.imag =c.imag -imag; return temp; } }; void main() { Complex a(2,3),b(4,5),c,d,f,g; cout<<"a="; a.display(); cout<<"b="; b.display(); c=a; cout<<"c=a="; c.display (); f=a+b; cout<<"f=a+b="; f.display(); d=a+4; cout<<"d=a+4="; d.display (); g=a-b; cout<<"g=a-b="; g.display(); } 结果： a=2+3i b=4+5i c=a=2+3i f=a+b=6+8i d=a+4=6+3i g=a-b=2+2i Press any key to continue

对n个数据进行从小到大排序,用重载函数实现

#include using namespace std; void s(int a,int b,int c,int t=0) { int i; for(i=0;i<2;i++) { if(a>b) { t=a; a=b; b=t; } if(b>c) { t=b; b=c; c=t; } }

cout<<"the sorted numbers: "<b) { t=a; a=b; b=t; } if(b>c) { t=b; b=c; c=t;

} } cout<<"the sorted numbers: "<b) { t=a; a=b; b=t; } if(b>c) { t=b; b=c;

c=t; } } cout<<"the sorted numbers: "<>a>>b>>c; cout<<"input 3 float:"<>d>>e>>f; cout<<"input 3 double:"<>g>>h>>i; s(a,b,c); s(d,e,f);

重载函数

实验九 1、重载函数允许不同的函数使用相同的名字，这使得完成类似的任务时可以使用相同的函数名。 #include #include using namespace std; const double PI=3.14159; double area(double r=0){ return PI*r*r; } double area(double a,double b){ return a*b; } double area(double a,double b,double h){ return (0.5*(a+b)*h); } double area(double a,double b,double c,int){ double s=0.5*(a+b+c); return sqrt(s*(s-a)*(s-b)*(s-c)); } void main(){ cout<

编译错误，area()调用时同时匹配的有double area(double a=0, double b=0)和double area(double r=0) （3）若将计算三角形面积的函数原型改为double area(double a, double b，double c);程序还能正确运行吗？为什么？不能，与梯形面积函数没有区分 （4）若将计算三角形面积的函数原型改为double area(double a, double b，double c=0，int); 程序还能正确运行吗？为什么。不能，边长应该为变量，否则错误 3、范例：全局变量、局部变量和静态局部变量的应用示例。 【要求】 (1) 分析并写出下列程序的执行结果，然后输入计算机执行，比较分析结果与执行结果。如果两结果不相同请分析原因。 分析结果：305 300 400 705 400 300 400 0 300 400 500 执行结果： 305 300 400 706 400 301 400 0 300 400 400 源程序：#include using namespace std; int a=300,b=400,c=500; void funa(int c){ static int a=5;

C++运算符重载

一、运算符重载的规则 运算符重载规则如下： ①、C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。 ②、重载之后运算符的优先级和结合性都不会改变。 ③、运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。 不能重载的运算符只有五个，它们是：成员运算符“.”、指针运算符“*”、作用域运算符“：：”、“sizeof”、条件运算符“？：”。 运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。 运算符重载为类的成员函数的一般语法形式为： 函数类型 operator 运算符（形参表） { 函数体； } 运算符重载为类的友元函数的一般语法形式为： friend 函数类型 operator 运算符（形参表） { 函数体； } 其中，函数类型就是运算结果类型；operator是定义运算符重载函数的关键字；运算符是重载的运算符名称。 当运算符重载为类的成员函数时，函数的参数个数比原来的操作个数要少一个；当重载为类的友元函数时，参数个数与原操作数个数相同。原因是重载为类的成员函数时，如果某个对象使用重载了的成员函数，自身的数据可以直接访问，就不需要再放在参数表中进行传递，少了的操作数就是该对象本身。而重载为友元函数时，友元函数对某个对象的数据进行操作，就必须通过该对象的名称来进行，因此使用到的参数都要进行传递，操作数的个数就不会有变化。 运算符重载的主要优点就是允许改变使用于系统内部的运算符的操作方式，以适应用户自定义类型的类似运算。 一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便此，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。 二、运算符重载为成员函数 对于双目运算符B，如果要重载B为类的成员函数，使之能够实现表达式oprd1 B oprd2,其中oprd1为类A的对象，则应当把B重载为A类的成员函数，该函数只有一个形参，形参的类型是oprd2所属的类型。经过重载后，表达式oprd1 B oprd2 就相当于函数调用 oprd1.operator B(oprd2).