第7章 运算符重载-习题

《面向对象程序设计》习题

班级：学号：姓名：名单序号：成绩：

第7章运算符重载和多态性

一、选择题（共30分，每题1分）

1．下列运算符中，（）运算符在C++中不能重载。

A.?:

B.[]

C. new

D.++

2．友元重载运算符obj1>obj2被C++编译器解释为（）。

A．operator >(obj1,obj2) B．>(obj1,obj2)

C．obj2.operator >(obj1) D．obj1.operator >(obj2)

3．重载赋值操作符时，应声明为（）函数。

A．友元B．虚C．成员D．多态

4．在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。

A. 作为友元函数重载的1元运算符

B. 作为成员函数重载的1元运算符

C. 作为友元函数重载的2元运算符

D. 作为成员函数重载的2元运算符5．在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（）。

A. 该运算符是一个单目运算符。

B. 该运算符函数有一个隐含的参数this。

C. 该运算符函数是类的成员函数。

D. 该运算符函数是类的友元函数。

6. 关于运输符重载，下列表述中正确的是（）。

A．C++已有的任何运算符都可以重载

B．运算符函数的返回类型不能声明为基本数据类型

C．在类型转换符函数的定义中不需要声明返回类型

D．可以通过运算符重载来创建C++中原来没有的运算符

7. C ++流中重载的运算符>>是一个（）。

A. 用于输出操作的非成员函数

B. 用于输出操作的成员函数

C. 用于输入操作的非成员函数

D. 用于输入操作的成员函数

8. 若要对Data类中重载的加法运算符成员函数进行声明，下列选项中正确的是（）。

A. Data +(Data);

B. Data operator+(Data);

C. Data +operator(Data);

D. operator +(Data, Data);

9. 下列运算符中哪些是不能够被重载的（）。

A. .，.*，sizeof，：：，?:

B. ++，--，new，= =

C. new，delete，>=，[ ]

D. +，-，=，delete

10. 在名为BigNumber类的类体中对运算符函数double进行如下声明：

operator double(BigNumbe);

函数声明中有一个明显的错误，这个错误就是（）。

A．参数表中不应该有任何参数

B．缺少对函数返回类型的说明

C．参数声明中缺少参数变量

D．函数声明中缺少函数体

11. 下列关于运算符重载的描述中，正确的是（）。

A. 运算符重载成为成员函数时，若参数表中无参数，重载是一元运算符

B. 一元运算符只能作为成员函数重载

C. 二元运算符重载成为非成员函数时，参数表中有一个参数

D. C++中可以重载所有的运算符

12. 在语句“cout<<’A’”中，cout是（）。

A. 类名

B. 函数名

C. 对象名

D. C++的关键字

13．下面是重载为非成员函数的运算符的函数原型，其中错误的是（）。

A．Fraction operator +（Fraction, Fraction）

B．Fraction& operator =（Fraction&, Fraction）

C．Fraction operator -（Fraction，Fraction）

D．Fraction& operator *（Fraction, Fraction）

14. 下列关于运算符重载的描述中，错误的是（）。

A. 运算符重载不能改变操作数的个数、优先级、结合性和运算符的语法结构

B. 所有的运算符都可以重载

C. 运算符函数的调用必须使用关键字operator

D. 在C++语言中不可以通过运算符重载创造出新的运算符

15. 如果表达式a>=b，中的“>=”是作为非成员函数重载的运算符，则可以等效地表示为（）。

A. a.operator>=(b)

B. a.operator>=(a)

C. operator>=(a, b)

D. a.operator>=(b, a)

16. 下列有关运算符函数的描述中，错误的是（）。

A. 运算符函数的名称总是以operator为前缀的

B. 运算符函数的参数可以是对象

C. 运算符函数只能定义为类的成员函数

D. 在表达式中使用重载的运算符相当于调用运算符重载函数

17. 将前缀运算符“--”重载为非成员函数，下列原型中，正确的是（）。

A. Decr &operator- - (int);

B. Decr operator- - (Decr &, int);

C. friend Decr &operator- - (Decr &, int);

D. friend Decr &operator- - (Decr &); 18．下列关于C++预定义流对象的叙述中，正确的是（）。

A．cin是C++预定义的标准输入流对象

B．cin是C++预定义的标准输入流类

C．cout是C++预定义的标准输入流对象

D．cout是C++预定义的标准输入流类

19．有如下类定义

class MyClass

{ public:

________________________

private:

int data;

};

若要为MyClass类重载流输入运算符“>>”，使得程序中可以用“cin>>obj;”的形式改变MyClass 类的对象obj中数据成员data的值，则在下划线处的声明语句应为（）。

A．friend istream& operator>>(istream& is, MyClass &a);

B．friend istream& operator>>(istream& is, MyClass a);

C．istream& operator>>(istream& is, MyClass &a);

D．istream& operator>>(istream& is, MyClass a);

20．若要在Viz类中将*重载为一元运算符，下列重载函数声明中肯定有错的是（）。

A．Viz operator *();

B．Viz operator *(Viz);

C．int operator *(Viz);

D．Viz operator *(Viz, Viz);

21．已知一运算符函数没有参数，下列关于该运算符函数的表述中错误的是（）。

A．该运算符函数是成员函数

B．该运算符是一元运算符

C．由于无参数，使用该运算符时不需要操作数

D．该运算符不是后缀++或后缀--

22．现需要将Matrix类对象使用的关系运算符“==”重载为成员函数，用于判断两个对象是否相等，以下正确且合理的函数声明是（）。

A．Matrix& operator==(const Matrix &a);

B．Matrix operator==(const Matrix &a);

C．bool& operator==(const Matrix &a);

D．bool operator==(const Matrix &a);

23. 关于赋值运算符=的重载，下列表述中错误的是（）。

A．=的重载函数必须且只能有一个参数

B．一个类即使没有重载=，也可以用=为该类的对象赋值

C．为了实现像“x=y=z;”这样的连续赋值，=的重载函数的返回值必须声明为引用D．=可以重载为一个类的友元函数

24．下列运算符中，可以重载为类的友元函数的运算符是（）。

A．= B．( ) C．. D．<<

25．有如下类的定义：

class MyClass{

public:

MyClass(double d=0.0):val(d){ }

//类型转换运算符double的定义

private:

double val;

};

若要使下列语句序列能够正常运行，下划线处的语句应为（）。

MyClass x(2.1);

cout<

A．operator double() const {return val;}

B．friend operator double() const {return val;}

C．double operator () const {return val;}

D．friend double operator () const {return val;}

26．若为类MyClass重载运算符“+”，下列声明中，错误的是（）。

A．friend MyClass operator+(double, double);

B．friend MyClass operator+(double, MyClass);

C．friend MyClass operator+(MyClass, double);

D．friend MyClass operator+(MyClass, MyClass);

27．下列关于运算符重载的叙述中，正确的是（）。

A．运算符重载的作用是使已有的运算符作用于类的对象

B．通过运算符重载机制可以为C++语言扩充新的运算符

C．重载运算符的操作类型可以全部为基本类型

D．C++中已有的任何运算符都可以重载

28. 运算符重载时以下性质一定会保持的是（）。

A．返回值类型、操作数类型B．操作数类型、优先级

C．优先级、操作数个数D．返回值类型、结合性

29．下列关于运算符重载的描述中错误的是（）。

A．不能通过运算符重载在C++中创建新的运算符

B．赋值运算符=只能重载为成员函数

C．运算符函数重载为类的成员函数时，第一操作数是该类对象

D．重载类型转换运算符时，应声明返回值为void

30．重载流插入运算符<<时，下列做法不合理的是（）。

A．将运算符函数的返回值类型设为ostream &

B．将运算符函数的第一个参数设为ostream &

C．为运算符函数设置两个参数

D．将运算符定义为类的成员函数

二、填空题（共28分，每空1分）

1．利用成员函数对二元运算符重载，其左操作数为，右操作数为。2．对双目运算符而言，成员运算符函数带有参数，而友元运算符函数带有参数；对单目运算符而言，成员运算符函数参数，而友元运算符函数带参数。3．重载运算符的函数不能有参数，否则就改变了运算符参数的个数。

4．对于用户自定义的类类型与其他数据类型之间的转换，通常有两种方法：通过进行类型转换；通过进行类型转换。

5．运算符重载函数一般采用两种形式：一是；二是。

6．列出5个不能重载的运算符：、、、和。

7. 下列程序定义了一分子为nume，虚部为deno的分数类Rational，并在类中重载了分数的+、-操作。请将下列程序补充完整。

class Rational

{public:

Rational(int x = 0, int y = 1)

①

void Print( );

②operator+(Rational a);

③operator-(Rational a, Rational b );

private:

int nume, deno;

};

④operator+(Rational a)

{ Rational r;

r.deno = a.deno*deno;

r.nume = a.nume*deno + a.deno*nume;

return r;

}

⑤operator-(Rational a, Rational b)

{ Rational r;

r.deno = a.deno*b.deno;

r.nume = ⑥;

return r;

}

三、看程序写结果（共24分，每题4分）

1．#include

#include

class Sales

{public:

void Init(char n[]) { strcpy(name,n); }

int & operator[](int sub);

char* GetName() { return name; }

private:

char name[25];

int divisionTotals[5];

};

int& Sales::operator [](int sub) //下标运算符重载

{ if(sub<0||sub>4)

{ cerr<<"Bad subscript! "<

abort();

}

return divisionTotals[sub];

}

int main()

{ int totalSales=0,avgSales;

Sales company;

company.Init("Swiss Cheese");

for(int i=0;i<5;i++)

company[i]=i;

cout<<"Here are the sales for "<

for(int i=0;i<5;i++)

cout<

for(i=0;i<5;i++)

totalSales+=company[i];

cout<

avgSales=totalSales/5;

cout<<"The average sales are "<

return 0;

}

2．#include

#include

class Words

{public:

Words(char *s)

{ str=new char[strlen(s)+1];

strcpy(str,s);

}

void Print() { cout<

char& operator [](int i) { return *(str+i); }

private:

char *str;

};

void main()

{ char *s="hello";

Words word(s);

word.Print();

int n=strlen(s);

while(n>=0)

{ word[n-1]=word[n-1]-32;

n--;

}

word.Print();

}

3．#include

#include

class Rect

{public:

Rect(int l,int w) { length=l; width=w; }

void Print() { cout<<"Area:"<

void* operator new(size_t size) { return malloc(size); }

void operator delete(void *p) { free(p); }

private:

int length,width;

};

void main()

{ Rect *p;

p=new Rect(5,4);

p->Print();

delete p;

}

4．#include

class BB

{ int a,b;

public:

BB(int i=0,int j=1) { a=i; b=j;}

BB operator +(BB c)

{ BB d;

d.a=a + c.a*10; d.b=b+c.b*10;

return d;

}

BB operator -(BB c)

{ BB d;

d.a=a * c.a; d.b=b*c.b;

return d;

}

void show()

{ cout<<'('<

int main()

{ BB x(2,6) , y(5, 5),z;

z=x+y; z.show();

z=x-y; z.show();

return 0;

}

5. #include

class EX

{ int x, y;

public:

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

EX operator * (EX z)

{ EX d;

d.x=x *z.x; d.y=y*z.y;

return d;}

EX operator /(EX c)

{ EX d;

d.x=x-c.x; d.y=y-c.y;

return d;}

void show()

{ cout<<'('<

int main()

{ EX a(30,10) , b(2,5),c;

c=a*b;

c.show();

c=a/b;

c.show();

return 0;

}

6. #include

class DD

{ int a,b;

public:

DD(int i=0,int j=1) { a=i; b=j;}

DD operator +(DD c)

{ DD d; d.a=a + c.a; d.b=b+c.b; return d;}

DD operator -(DD c)

{ DD d; d.a=a - c.a; d.b=b-c.b; return d;}

void show()

{ cout<<'('<

};

int main()

{ DD x(10,15) , y(5,7),z;

z=x+y;

z.show();

z=x-y;

z.show();

return 0;

}

五、编程题（共24分）

1．利用成员函数重载运算符+ 、-、*、/，适用于整型分数的运算要求，输出简分数的形式。

2．有两个矩阵a和b，均为两行三列，求两个矩阵之和。

（1）重载运算符“+”，使之能用于矩阵相加。如：c=a+b。

（2）重载流插入运算符“<<”和流提取运算符“>>”，使之能用于矩阵的输出和输入。

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

运算符重载基础概念练习题 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++期末复习--1.练习题_选择

面向对象程序设计综合练习（单选题） 单选题 1.C++源程序文件的缺省扩展名为( )。 A. cpp B. exe C. obj D. lik 2.程序运行中需要从键盘上输入多于一个数据时，各数据之间应使用( )符号作为分 隔符。 A. 空格或逗号 B. 逗号或回车 C. 逗号或分号 D. 空格或回车 3.关于封装，下列说法中不正确的是（）。 A. 通过封装，对象的全部属性和操作结合在一起，形成一个整体 B. 通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见） C. 通过封装，每个对象都成为相对独立的实体 D. 通过封装，对象的属性都是不可见的 4.面向对象软件开发中使用的OOA表示（）。 A. 面向对象分析 B. 面向对象设计 C. 面向对象语言 D. 面向对象方法 5.面向对象软件开发中使用的OOD表示（）。 A. 面向对象分析 B. 面向对象设计 C. 面向对象语言 D. 面向对象方法 6.在一个类的定义中，包含有（）成员的定义。 A. 数据 B. 函数 C. 数据和函数 D. 数据或函数 7.在类作用域中能够通过直接使用该类的（）成员名进行访问。 A. 私有 B. 公用 C. 保护 D. 任何 8.在关键字public后面定义的成员为类的（）成员。 A. 私有 B. 公用 C. 保护 D. 任何 9.在关键字private后面定义的成员为类的（）成员。 A. 私有 B. 公用 C. 保护 D. 任何 10.假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象 中数据成员a的格式为（）。 A. x(a) B. x[a] C. x->a D. x.a 11.假定AA为一个类，a()为该类公有的成员函数，x为该类的一个对象，则访问x对象 中成员函数a()的格式为（）。 A. x.a B. x.a() C. x->a D. x->a() 12.假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访 问px所指对象中数据成员a的格式为（）。 A. px(a) B. px[a] C. px->a D. px.a 13.假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有成员函数，它 返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（）。 A. x.a B. x.a() C. x->GetValue() D. x.GetValue() 14.假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定 义，则函数头为（）。 A. int AA::a() B. int AA:a() C. AA::a() D. AA::int a() 15.假定AA为一个类，a为该类公有的数据成员，若要在该类的一个成员函数中访问它，

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中也使用难看的一般函数调用来完成矩阵运算的原因。影响速度的主要原因是在使用运算符+、-、*、/等时，程序会在每次运算时创建临时对象再将临时对象返回，对于重复多次的矩阵运算来说，这无疑成为了一笔庞大的额外开销（好在现在的计算机的处理速度还算快）。但注意：在使用+=、-=、*=、/=时不会有上述问题，因为在使用这些运算符时程序只需要修改第一个对象不需要创建并返回临时对象。所以在能使用+=、-=、*=、/=时尽量不要使用单一的=、-、*、/运算符。 好了，这两个类我们已经封装好了，下面还有什么呢？是的，忘了向大家交代旋转矩阵了：

运算符重载练习题.

运算符重载 一．单项选择题 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. 设有以下类定义，其中说明了“+”运算符重载函数的原型。这是一个友元函数，当类

第十章 运算符重载 复习题

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

运算符重载题目

二、运算符重载（运算符重载的基本概念、运算符重载方法、运算符重载规则、特殊运算符重载和类型转换） 单选题10道： 1、假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句为（ B ）。 A. AB operator+(AB& a,AB& b) B. AB operator+(AB& a) C. operator+(AB a) D. AB &operator+( ) 2、关于运算符重载，下面的叙述错误的是（）。 A．运算符预定义的操作数个数不能改变 B．重载不能改变运算符的优先级顺序 C．参数的类型没有限制 D．尽量使其与原意保持一致 3、在一个类中可以对一个操作符进行（D ）重载。 A. 1种 B. 2种以下 C. 3种以下 D. 多种 4、重载赋值操作符时，应声明为（C ）函数。 A. 友元 B. 虚 C. 成员 D. 多态 5、要在类对象使用运算符，以下不必被重载的运算符是（ A ）。 A. [] B. = C. ++ D. -- 6、下列运算符中，不能重载的是（C ） A．new B．() C．::D．&& 7、在表达式x+y*z中，+ 是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的是（ A ）。 A）operator+有两个参数，operator*有两个参数 B）operator+有两个参数，operator*有一个参数 C）operator+有一个参数，operator*有两个参数 D）operator+有一个参数，operator*有一个参数 8、友元运算符obj1>obj2被C++编译器解释为（）。 A) operator>(obj1,obj2) B) >(obj1,obj2) C) obj1.operator>(obj2) D) obj2.operator>(obj1) 9、已知某个类的友元函数重载了+=和-，a，b，c是该类的对象，则“a+=b-c”被C++编译器解释为（）。 A) operator+=(a,operator-(b,c)) B) a.operator+=(b.operator-(c)) C) operator+=(a,b.operator-(c)) D) a.operator+=(operator-(b,c)) 10、下列运算符中，必须使用成员函数进行重载的是（）。 A) == B) = C) >> D) ++ 填空题10道： 1、多数运算符既能作为类的成员函数重载，也能作为类的非成员函数重载，但运算符“[]”只能作为类的函数重载。 2、加法运算符“+”和赋值运算符“=”都重载之后，“+=”也被重载了。 3、单目运算符作为类的成员函数重载时形参。 4、利用成员函数对二元运算符重载时，其右操作数为。 5、重载运算符函数的函数名由关键字引出。 6、运算符的重载归根结底是的重载。 7、后缀自增自减运算符定义时带有一个。

第7章 运算符重载-习题

《面向对象程序设计》习题 班级：学号：姓名：名单序号：成绩： 第7章运算符重载和多态性 一、选择题（共30分，每题1分） 1．下列运算符中，（）运算符在C++中不能重载。 A.?: B.[] C. new D.++ 2．友元重载运算符obj1>obj2被C++编译器解释为（）。 A．operator >(obj1,obj2) B．>(obj1,obj2) C．obj2.operator >(obj1) D．obj1.operator >(obj2) 3．重载赋值操作符时，应声明为（）函数。 A．友元B．虚C．成员D．多态 4．在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。 A. 作为友元函数重载的1元运算符 B. 作为成员函数重载的1元运算符 C. 作为友元函数重载的2元运算符 D. 作为成员函数重载的2元运算符5．在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（）。 A. 该运算符是一个单目运算符。 B. 该运算符函数有一个隐含的参数this。 C. 该运算符函数是类的成员函数。 D. 该运算符函数是类的友元函数。 6. 关于运输符重载，下列表述中正确的是（）。 A．C++已有的任何运算符都可以重载 B．运算符函数的返回类型不能声明为基本数据类型 C．在类型转换符函数的定义中不需要声明返回类型 D．可以通过运算符重载来创建C++中原来没有的运算符 7. C ++流中重载的运算符>>是一个（）。 A. 用于输出操作的非成员函数 B. 用于输出操作的成员函数 C. 用于输入操作的非成员函数 D. 用于输入操作的成员函数 8. 若要对Data类中重载的加法运算符成员函数进行声明，下列选项中正确的是（）。 A. Data +(Data); B. Data operator+(Data); C. Data +operator(Data); D. operator +(Data, Data); 9. 下列运算符中哪些是不能够被重载的（）。 A. .，.*，sizeof，：：，?: B. ++，--，new，= = C. new，delete，>=，[ ] D. +，-，=，delete 10. 在名为BigNumber类的类体中对运算符函数double进行如下声明： operator double(BigNumbe); 函数声明中有一个明显的错误，这个错误就是（）。 A．参数表中不应该有任何参数 B．缺少对函数返回类型的说明 C．参数声明中缺少参数变量 D．函数声明中缺少函数体 11. 下列关于运算符重载的描述中，正确的是（）。

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

运算符重载

第4章运算符重载 4.1 什么是运算符重载 所谓重载，就是重新赋予新的含义。函数重载就是对一个已有的函数赋予新的含义，使之实现新功能。 运算符也可以重载。实际上，我们已经在不知不觉之中使用了运算符重载。如：+可以对int、float、double的数据进行加法运算。 现在要讨论的问题是：用户能否根据自己的需要对C++已提供的运算符进行重载，赋予它们新的含义，使之一名多用。譬如，能否用“+”号进行两个复数、两个点的相加。在C++中不能在程序中直接用运算符“+”对复数进行相加运算。用户必须自己设法实现复数相加。 例如用户可以通过定义一个专门的函数来实现复数相加。见下例。 //例4.1 通过函数来实现复数相加。 #include using namespace std; class 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, imag; }; Complex Complex::complex_add(Complex &c2) { Complex c; c.real=real+c2.real; c.imag=imag+c2.imag; return c; //以上可简写为：return Complex(real+c2.real,imag+c2.imag); } void Complex::display() { cout<<"("<