第十章 运算符重载 复习题

运算符重载复习题

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++中不能重载的运算符是( )

A. =

B. ()

C. ::

D. delete

10. 不能作为函数重载判断依据的是( )

A. const

B. 返回类型

C. 参数个数

D. 参数类型

11. 为满足运算符“+”的可交换性，必须将其重载为成员函数，重载的函

数名是关键字加上运算符“+”。operator

12. 具有相同函数名但具有不同参数表的函数称为。重载函数

13. 拷贝构造函数是在用一个对象初始化另一个对象时被调用，系统缺省的拷贝

构造函数的工作方法是。拷贝数据成员

14.下列程序定义了一实部为mal,虚部为imag的复数类complex,并在类中重载

了复数的+、-操作。请将下列程序补充完整。

Class Complex{

public:

Complex(double r=0.0,double i=0.O){real=r;imag=i；}

Complex operator +(Complex);

friend Complex operator -(Complex,Complex);

private:

double real,imag;

};

Complex Complex:: operator +(Complex c){

return *this;

};

operator -(Complex c1,Complex c2){

return Complex( _);

}

33．this->real+=c.real,this->imag+=c.imag;

Complex

c1.real+c2.real,c1.imag+c2.imag

15．设有类的定义：

class Matrix //定义Matrix 类

{public:

Matrix(); //默认构造函数

friend Matrix operator+(Matrix &,Matrix &); //重载运算符“+”

void input(); //输入数据函数

void display(); //输出数据函数

int mat[2][3]; };

实现两个矩阵A和B（均为2行3列）的和。试写出成员函数Matrix( )实现构造函数初始化0值，友员函数Matrix operator+(Matrix &a,Matrix &b)实现重载运算符+，使之能用于该矩阵相加，如：C=A+B。

Matrix::Matrix() (1分) //定义构造函数

{for(int i=0;i<2;i++) (1分)

for(int j=0;j<3;j++) (1分)

mat[i][j]=0; (1分)

}

Matrix operator+(Matrix &a,Matrix &b) (1分) //定义重载运算符“+”函数

{Matrix c; (1分)

for(int i=0;i<2;i++) (1分)

for(int j=0;j<3;j++) (1分)

{c.mat[i][j]=a.mat[i][j]+b.mat[i][j];} (1分)

return c; (1分)

}

16．仔细阅读程序，在题后写出其运行结果。

#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)

{Complex c;

c.real=real+c2.real;

c.imag=imag+c2.imag;

void Complex::display()

{cout<<"("<

int main()

{Complex c1(3,4),c2(1,-2),c3;

c3=c1+c2;

c1.display(); cout<<'+';c2.display(); cout<<'=';c3.display();

return 0;

}

运行结果：

39. (3,4i)+(1,-2i)=(4,2i)

17．仔细阅读程序，在题后写出其运行结果。

#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)

{Complex c;

c.real=real+c2.real;

c.imag=imag+c2.imag;

return c;}

void Complex::display()

{cout<<"("<

int main()

{Complex c1(2,3),c2(1,2),c3;

c3=c1+c2;

c1.display(); cout<<'+';c2.display(); cout<<'=';c3.display();

return 0;

}

运行结果：

39. (2,3i)+(1, 2i)=(4,5 i)

18．写出下列程序的运行结果。

#include

class Coord{

public:

Coord(int i=0,int j=0){x=i;y=j;}

void Print(){cout<<"x="<

friend Coord operator++(Coord op);

private:int x,int y;

};

Coord operator ++(Coord op){

++op.x; ++op.y;

return op;

}

void main(){

Coord obj(2,3); obj.Print();

++obj; obj.Print();

}

运行结果：

39. x=2,y=3 (2分)

x=2,y=3 (3分)

19. 下面程序是一个含有比较运算符和赋值运算符重载的程序，仔细阅读程序并

将其补充完整。

#include

class point{

private:float x,y;

public:

point(float xx=0,float yy=0) { x=xx,y=yy;}

point(point&);

~point();

bool operator==(point);

bool operator!=(point);

point& operator+=(point);

float getx(){return x;}

float gety(){return y;}

};

point::point(point& p){

}

bool point::operator==(point p){

if((x==p.getx())&&(y==p.gety()) )

Return 1;

else

Return 0;

}

bool point::operator!=(point p){

if( )

Return 1;

else

Return 0;

}

point& point::operator+=(point p){

this->x+=p.getx();

this->y+=p.gety();

return

}

void main(){

point p1(1,2),p2(3,4);p3(5,6);

cout<<”p1==p2? ”<<(p1==p2)<

cout<<”p1!=p2? ”<<(p1!=p2)<

p3+=p1;

cout<<”p3+=p1,p3: ”<

x=p.getx(),y=p.gety() ;

(x!=.getx())&&(y!=.gety())

*this

20．定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。

将运算符函数重载为非成员、非友元的普通函数。编写程序，求出两个复数之和。

41．

#include

using namespace std;

int main() (1分)

{void convert(int n);

int number; (1分)

cout<<"input an integer:";

cin>>number; (1分)

cout<<"output:"<

if (number<0)

{cout<<"-";

number=-number; (1分)

} (1分)

convert(number);

cout<

return 0; (1分)

}

void convert(int n)

{int i;

char c;

if ((i=n/10)!=0) (1分)

convert(i);

c=n%10+'0'; (1分)

cout<<" "<

}

21．仔细阅读程序，在题后写出其运行结果。

#include

#include

class String

{public:

String(){p=NULL;}

String(char *str);

friend bool operator>(String &string1,String &string2);

void display();

private:

char *p;

};

String::String(char *str)

{p=str;

}

void String::display()

{cout<

bool operator>(String &string1,String &string2)

{if(strcmp(string1.p,string2.p)>0)

return true;

else

return false;

}

void compare(String &string1,String &string2)

{if(operator>(string1,string2)==1)

{string1.display();cout<<">";string2.display();}

else

{string1.display();cout<<"<=";string2.display();}

}

int main()

{String string1("Aello"),string2("Book");

compare(string1,string2);

return 0;

}

运行结果：

39. Aello<=Book

22．仔细阅读程序，在题后写出其运行结果。

#include

using namespace std;

class Time

{public:

Time(){minute=0;sec=0;}

Time(int m,int s):minute(m),sec(s){}

Time operator++();

void display(){cout<

private:

int minute;

int sec;

};

Time Time::operator++()

{if(++sec>=60)

{sec-=60;

++minute;}

return *this;

}

int main()

{Time time1(34,58);

for (int i=1;i<3;i++)

{++time1;

time1.display();}

return 0;

}

运行结果：

38．34:59 (2分)

35:0 (3分)

23. 下列程序定义了一实部为real, 虚部为imag的复数类complex, 并在类中

重载了复数的+、-操作。请将下列程序补充完整。

Class Complex{

public:

Complex(double r=0.0,double i=0.O){real=r;imag=i；}

Complex operator +(Complex);

friend Complex operator -(Complex,Complex);

private:

double real,imag;

};

Complex Complex:: operator +(Complex c){

return *this;

};

operator -(Complex c1,Complex c2){

return Complex( _);

}

this->real+=c.real,this->imag+=c.imag;

Complex

c1.real+c2.real,c1.imag+c2.imag

24．仔细阅读程序，在题后写出其运行结果。

#include

using namespace std;

class Time

{public:

Time(){minute=0;sec=0;}

Time(int m,int s):minute(m),sec(s){}

Time operator++();

Time operator++(int);

void display(){cout<

private:

int minute;

int sec;

};

Time Time::operator++()

{if(++sec>=60)

{sec-=60;

++minute;}

return *this;

}

Time Time::operator++(int)

{Time temp(*this);

sec++;

if(sec>=60)

{sec-=60;

++minute;}

return temp;

}

int main()

{Time time1(34,59),time2;

cout<<" time1 : ";

time1.display();

++time1;

time2=time1++;

cout<<" time2 : ";

time2.display();

cout<<" time1 : ";

time1.display();return 0;

}

运行结果：

38．time1:34:59 (2分)

time2:35:0 (2分)

time1:35:1 (1分)

25．编程：定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。将运算符函数重载为非成员、非友元的普通函数。编写程序，求

出两个复数之和。

6．答：

#include

using namespace std;

class Complex

{public:

Complex(){real=0;imag=0;}

Complex(double r,double i){real=r;imag=i;} （2分）

double get_real();

double get_imag(); （2分）

void display();

private:

double real;

double imag; （2分）

};

double Complex::get_real()

{return real;} （2分）

double Complex::get_imag()

{return imag;} （2分）

void Complex::display()

{cout<<"("<

Complex operator + (Complex &c1,Complex &c2)

{

return Complex(c1.get_real()+c2.get_real(),c1.get_imag()+c2.get_imag()); （2分）

}

int main()

{Complex c1(3,4),c2(5,-10),c3; （2分）

c3=c1+c2; （2分）

cout<<"c3=";

c3.display(); （2分）

return 0;

}

运算符重载基础概念练习题

运算符重载基础概念练习题 1、下列运算符中, （）运算符在C++中不能重载。 A = B () C :: D delete 2、下列运算符中, （）运算符在C++中不能重载。 A ?: B [] C new D && 3、下列关于C++运算符函数的返回类型的描述中,错误的是（）。 A 可以是类类型 B 可以是int类型 C 可以是void类型 D 可以是float类型 4、下列运算符不能用友元函数重载的是（）。 A + B = C * D << 5、在重载运算符函数时,下面（）运算符必须重载为类成员函数形式。 A + B - C ++ D -> 6、下列关于运算符重载的描述中,正确的是（）。 A 运算符重载可以改变运算符的操作数的个数 B 运算符重载可以改变优先级 C 运算符重载可以改变结合性 D 运算符重载不可以改变语法结构 7、友元运算符obj>obj2被C++编译器解释为（）。 A operator>(obj1,obj2) B >(obj1,obj2) C obj2.operator>(obj1) D obj1.oprator>(obj2) 8、在表达式x+y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的是（）。 A operator+有两个参数，operator*有两个参数 B operator+有两个参数，operator*有一个参数 C operator+有一个参数，operator*有两个参数 D operator+有一个参数，operator*有一个参数 9、重载赋值操作符时,应声明为（）函数。 A 友元 B 虚 C 成员 D 多态 10、在一个类中可以对一个操作符进行（）重载。 A 1种 B 2种以下 C 3种以下 D 多种 11、在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。

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中用运算符重载实现矩阵运算

走进3D的世界 -- C++中用运算符重载实现矩阵运算 作者：周军 矩阵(Matrix)无处不在，我们的生活中到处都能找到矩阵的身影，然而此处我不想把这个定义放大，我们只讨论线性代数中的矩阵，我们要用它们来完成我们的3D变换。为什么矩阵可以完成3D变换呢？下面，我们就来介绍矩阵是如何变换坐标的： 设空间中有一坐标(x,y,z)，如果我们想把它变换成另一坐标(x,’y’,z’)，我们可以进行如下操作： = (x’,y’,z’,1) 这就是矩阵的妙用了。它在复杂处理变换的时候表现得尤为突出。假设我们想要把一个物体先沿z轴旋转角thetaZ，再沿x轴旋转角thetaX，我们可以进行如下操作(pseudo-code): obj*=rotX(thetaX)*rotZ(thetaZ); 注意：矩阵的乘法是不可逆的，而且我们要按变化顺序的逆序进行乘法，具体推导见计算几何相关书籍。 下面，我们进入正题：如何再C++中用重载运算符的方法来进行矩阵运算以完成线性变换呢？我们需要变换坐标，所以很自然地，我们需要一个向量(Vector)类；同时我们要进行

为直观、人性化，我选用了运算符重载这以技巧而不是简单地调用函数，下面请看我的具体实现：

以上便是CVector类的具体实现，我想对C++和线性代数有所了解的读者都能很清楚地理解这段代码，在次不累述。 上述代码的成员函数实在类外定义的，如果读者在实践中为了提高速度可以把这些成员函数定义在类内以起到内联函数的作用，可以省去参数压栈、出栈时的时间。 下面是CMatrix类的具体实现：

是不是也很好理解呢？哈哈，这就是用运算符重载的好处。不过这种方法也确实有它的不足，而且这个不足在游戏编程中是致命的，那就是效率不高，这也正是为什么Microsoft 在DirectX中也使用难看的一般函数调用来完成矩阵运算的原因。影响速度的主要原因是在使用运算符+、-、*、/等时，程序会在每次运算时创建临时对象再将临时对象返回，对于重复多次的矩阵运算来说，这无疑成为了一笔庞大的额外开销（好在现在的计算机的处理速度还算快）。但注意：在使用+=、-=、*=、/=时不会有上述问题，因为在使用这些运算符时程序只需要修改第一个对象不需要创建并返回临时对象。所以在能使用+=、-=、*=、/=时尽量不要使用单一的=、-、*、/运算符。 好了，这两个类我们已经封装好了，下面还有什么呢？是的，忘了向大家交代旋转矩阵了：

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<<"("<int) //这里编译器不会把2向上转换即(int->double) 这的强者类型转换 //呵呵恐怖吗你以为你在调用第二个函数结果调用的是第一个 system("pause"); }

C++运算符重载讲解与经典实例 (2)

C++中预定义的运算符的操作对象只能是基本数据类型，实际上，对于很多用户自定义类型，也需要有类似的运算操作。例如： class complex { public: complex(double r=0.0,double I=0.0){real=r;imag=I;} void display(); private: double real; double imag; }; complex a(10,20),b(5,8); “a+b”运算如何实现？这时候我们需要自己编写程序来说明“+”在作用于complex类对象时，该实现什么样的功能，这就是运算符重载。运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据导致不同类型的行为。 运算符重载的实质是函数重载。在实现过程中，首先把指定的运算表达式转化为对运算符函数的调用，运算对象转化为运算符函数的实参，然后根据实参的类型来确定需要调用达标函数，这个过程爱编译过程中完成。 一、运算符重载的规则 运算符重载规则如下： ①、C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。 ②、重载之后运算符的优先级和结合性都不会改变。 ③、运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。 不能重载的运算符只有五个，它们是：成员运算符“.”、指针运算符“*”、作用域运算符“：：”、“sizeof”、条件运算符“？：”。 运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。 运算符重载为类的成员函数的一般语法形式为： 函数类型 operator 运算符（形参表） { 函数体； } 运算符重载为类的友元函数的一般语法形式为： friend 函数类型 operator 运算符（形参表） { 函数体； } 其中，函数类型就是运算结果类型；operator是定义运算符重载函数的关键字；运算符是重载的运算符名称。 当运算符重载为类的成员函数时，函数的参数个数比原来的操作个数要少一个；当重载为类

第11章 运算符重载 习题解答

第11章运算符重载 一．单项选择题 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++实验21 运算符重载

实验21 运算符重载 一、实验目的和要求 1．理解运算符重载的作用。 2．掌握实现运算符重载的方法及几种特殊运算符的重载格式。 3．进一步锻炼针对类的编程能力。 二、实验准备 ?知识点 1．运算符重载定义的一般格式、基本概念。 2．运算符函数重载的两种形式。 3．通过成员函数实现运算符重载的一般格式。 4．通过友元函数实现运算符重载的一般格式。 5．”++”运算符的重载。 6．”=”赋值运算符的重载。 ?课前练习题 1．重载运算”+”，实现a+b运算，则。 A．a必须为对象，b可为整数或实数B．a和b必须为对象 C．b必须为对象，a可为整数或实数D．a和b均可为整数或实数 2．在C++中，运算符的重载有两种实现方法，一种是通过成员函数来实现，另一种则通过_________来实现。 3．不能重载的5个运算符是：______、______、______、______、_________。 4．重载赋值运算符必须通过________函数实现。 5．用成员函数实现前置”--”运算符重载的一般格式为：_______________________________。6．用友元函数实现后置”--”运算符重载的一般格式为：_______________________________。 ?分析 1．有以下程序： #include class C{ private: double x; public: C( ) { x=0.0; } C(double a) { x=a; } friend C operator--(C t) //行A { t.x--; return t; } void show(){cout<

C++程序设计运算符重载习题

选择题 1．在下列运算符中，能重载的是( )。 (a) ! (b) sizeof (c) new (d) delete 2．在下列运算符中，不能重载的是( )。 (a) <= (b) >> (c) ：：(d) &= 3．下列关于运算符重载的描述中，( )是正确的。 (a) 可以改变参与运算的操作数个数(b) 可以改变运算符原来的优先级 (c) 可以改变运算符原来的结合性(d) 不能改变原运算符的语义 4．下列函数中，能重载运算符的函数是( )。 (a) 成员函数(b) 构造函数(c) 析构函数(d) 友员函数 5．不能用友员函数重载的是( )。 (a) = (b) = = (c) += (d) != 6．下面描述中，错误的是( )。 (a) 只有系统预先定义的运算符才可能被重载 (b) 使用类型转换函数不能把一个类转换为另一个类 (c) 使用类型转换函数可以把类转换为基本类型 (d) 类型转换函数只能定义为一个类的成员函数，不能定义为类的友员函数 1、a,c,d 2、c 3、d 4、b,c 5、a 6、b 阅读下列程序，写出执行结果 1．#include〈iostream.h〉 class T { public : T( ) { a = 0; b = 0; c = 0; } T( int i , int j , int k ) { a = i; b =j ; c = k; } void get( int &i , int &j , int &k ) { i = a; j = b; k = c; } T operator * ( T obj ); private: int a , b , c; }; T T::operator * ( T obj ) { T tempobj; tempobj.a = a * obj.a; tempobj.b = b * obj.b; tempobj.c = c * obj.c; return tempobj; } void main( ) { T obj1( 1,2,3 ), obj2( 5,5,5 ), obj3; int a , b , c;

第13章习题

第13章 一、选择题 1、下面关于运算符重载的说法中，错误的是（）。 A、可以对C++所有运算符进行重载 B、运算符重载保持固有的结合性和优先级顺序 C、运算符重载不能改变操作数的个数 D、在运算符函数中，不能使用缺省的参数值 2、下列运算符能被重载的是（）。 A、:: B、?: C、. D、% 3、下列叙述正确的是（）。 A、运算符重载函数只能是一个成员函数 B、运算符重载函数既可以是一个成员函数，也可以是友元函数 C、运算符重载函数只能是一个非成员函数 D、运算符重载函数只能是友元函数 4、下列叙述不正确的是（）。 A、利用成员函数重载二元运算符时，参数表中的参数必须为两个 B、利用成员函数重载二元运算符时，成员函数的this指针所指向的对象作为运算符的左操作数 C、利用成员函数重载二元运算符时，参数表中的参数作为此运算符的右操作数 D、运算符重载时不能改变运算符的语法结构 5、为了区分一元运算符的前缀和后缀运算，在后缀运算符进行重载时，额外添加一个参数，其类型是（）。 A、void B、char C、int D、float 6、下列能正确重载运算符的友元函数原型是（）。 A、friend B operator?: ( ); B、friend B operator+(int x); C、friend B operator+(B b); D、friend B operator+(B b, B a); 7、下列叙述正确的是（）。 class B { int a,b; public: B(int aa=0, int bb=0) { a=aa; b=bb; } B operator+ ( int x ) //A { B r; r.a=a+x; r.b=b+x;

运算符重载

8.4 运算符重载 运算符重载是非常重要的功能，因为它使我们能够使用像+、–、*这样的标准C++运算符，来处理自定义数据类型的对象。该功能允许我们编写重新定义特定运算符的函数，从而使该运算符处理类对象时执行特定的动作。例如，我们可以重新定义>运算符，从而使该运算符用于前面看到的CBox类对象时，如果第一个实参的体积比第二个大，就返回true。 运算符重载功能不允许我们使用新的运算符，也不允许我们改变运算符的优先级，因此运算符的重载版本在计算表达式的值时优先级与原来的基本运算符相同。运算符的优先级表可以在本书第2章和MSDN库中找到。 虽然我们不能重载所有运算符，但限制不是特别严格。下面给出不能重载的运算符： 作用域解析运算符 :: 条件运算符 ?: 直接成员访问运算符 . sizeof运算符 sizeof 解除对指向类成员的指针的引用运算符 .* 任何其他运算符都是可以重载的，这给予我们相当大的灵活性。显然，确保标准运算符的重载版本与原来的正常用途一致，或者至少在操作上相当直观，是合适的想法。如果为某个类重载的+运算符却执行使类对象相乘的操作，这可能就不是明智的做法。理解运算符重载机制如何工作的最好方法是完成一个示例，因此下面为CBox类实现刚才提到的大于运算符>。 8.4.1 实现重载的运算符

为了给某个类实现重载的运算符，我们必须编写特殊的函数。假设在类定义内重载>运算符的函数是CBox类的成员，则该函数的声明如下所示： class CBox { public: bool operator>(CBox& aBox) const; // Overloaded 'greater than' // Rest of the class definition... }; 这里的单词operator是个关键字。该关键字结合运算符符号或名称，本例中是>，将定义一个运算符函数。本例中的函数名是operator>()。在运算符函数的声明中，关键字和运算符本身之间有无空格都行，前提是没有歧义。歧义出现在运算符是名称而非符号的时候，比如new或delete。如果写成不加空格的operatornew和operatordelete，则它们都是合法的普通函数名。因此，如果要编写这些运算符的运算符函数，则必须在关键字operator和运算符名称之间加个空格。注意，我们将函数声明为const，因为该函数不修改本类的数据成员。 在operator>()运算符函数中，运算符的右操作数由函数形参定义，左操作数由this指针隐式定义。因此，如果有下面这条if语句： if(box1 > box2) cout << endl << "box1 is greater than box2"; 则括弧中的表达式将调用重载的运算符函数，它与下面这个函数调用等价： box1.operator>(box2); 表达式中的CBox对象与运算符函数形参之间的对应关系如图8-3所示。

c 运算符重载总结

c++运算符重载总结 目录1.一般运算符重载2.关系运算符重载3.逻辑运算符重载4.单目运算符重载5.自增减运算符重载6.位运算符重载7.赋值运算符重载8.内存运算符重载9.特殊运算符重载10.总结c++的一大特性就是重载(overload)，通过重载可以把功能相似的几个函数合为一个，使得程序更加简洁、高效。在c++中不止函数可以重载，运算符也可以重载。由于一般数据类型间的运算符没有重载的必要，所以运算符重载主要是面向对象之间的。 1.一般运算符重载 在进行对象之间的运算时，程序会调用与运算符相对应的函数进行处理，所以运算符重载有两种方式：成员函数和友元函数。成员函数的形式比较简单，就是在类里面定义了一个与操作符相关的函数。友元函数因为没有this指针，所以形参会多一个。 class A{public: A(int d):data(d){} A operator+(A&);//成员函数A operator-(A&); A operator*(A&); A operator/(A&); A operator%(A&); friend A operator+(A&,A&);//友元函数friend A operator-(A&,A&); friend A operator*(A&,A&); friend A operator/(A&,A&); friend A operator%(A&,A&);private: int data;};//成员函数的形式A A::operator+(A &a){ return

A(data+a.data);}A A::operator-(A &a){ return A(data-a.data);}A A::operator*(A &a){ return A(data*a.data);}A A::operator/(A &a){ return A(data/a.data);}A A::operator%(A &a){ return A(data%a.data);}//友元函数的形式A operator+(A &a1,A &a2){ return A(a1.data+a2.data);}A operator-(A &a1,A &a2){ return A(a1.data-a2.data);}A operator*(A &a1,A &a2){ return A(a1.data*a2.data);}A operator/(A &a1,A &a2){ return A(a1.data/a2.data);}A operator%(A &a1,A &a2){ return A(a1.data%a2.data);}//然后我们就可以对类的对象进行+、-、*、/了。void main(void){ A a1(1),a2(2),a3(3); a1=a2+a3; //或者a1=a2.operator+(a3);} 注意：在进行a2+a3的时候会出错，因为我们在上面对+定义了两种方法，去掉一种即可。 2.关系运算符重载 因为函数体比较简单，后面我就只给出成员函数形式的函数声明了，关系运算符有==,!=,,=。 bool operator == (const A& ); bool operator != (const A& );bool operator bool operator bool operator > (const A& );bool operator >= (const A& ); 3.逻辑运算符重载 bool operator || (const A& );bool operator && (const A& );bool operator ! ();