C++课本的练习题及答案（第七章）

水深无声 2023-10-07 12:19 8阅读 0赞

### 第7章练习题 ###

**同步练习7.1**

#### **一、选择题** ####

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

（A）! （B）sizeof （C）new （D）delete

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

（A）可以改变参与运算的操作数个数 （B）可以改变运算符原来的优先级

（C）可以改变运算符原来的结合性 （D）不能改变原运算符的语义

3．运算符函数是一种特殊的（ ）或友元函数。

（A）构造函数 （B）析构函数 （C）成员函数 （D）重载函数

4．设op表示要重载的运算符，那么重载运算符的函数名是（ ）。

（A）operator op （B）op （C）函数标识符 （D）函数标识符op

5．用于类运算的运算符通常都要重载。但有两个运算符系统提供默认重载版本，它们是（ ）。

（A）->和. （B）++和-- （C）=和& （D）new和delete

【解答】 B D C A C

#### **二、程序练习** ####

阅读程序，其中s::connect函数实现字符串连接。把这个成员函数改写为重载+运算符函数，并修改main函数的对应代码，使其正确运行。

\#include<iostream>

\#include<cstring>

usingnamespace std;

classs

\{ public:

s() \{ \*str = '\\0'; len = 0; \}

s( char \*pstr )

\{ strcpy\_s( str,pstr ); len =strlen(pstr); \}

char \*gets() \{ return str; \}

int getLen() \{ return len; \}

s connect( s obj ); //字符串连接函数声明

private:

char str\[100\];

int len;

\};

ss::connect( s obj ) &n bsp; //字符串连接函数定义

\{ strcat\_s( str,obj.str );

return str;

intmain()

\{ s obj1( "Visual" ), obj2( "C++" ), obj3(" language");

obj3 = (obj1.connect(obj2)).connect(obj3); //调用字符串连接函数

cout<< "obj3.str = "<<obj3.gets() << endl;

cout<<"obj3.len= "<<obj3.getLen()<<endl;

【解答】

\#include <iostream>

\#include<cstring>

using namespace std;

class s

\{ public:

s()

\{\*str = '\\0'; len = 0; \}

s(char \*pstr )

\{ strcpy\_s( str,pstr );

len = strlen(pstr);

char \*gets()

\{ return str; \}

intgetLen()

\{ return len; \}

soperator+( s obj );

private:

char str\[100\];

int len;

\};

s s::operator+( s obj )

strcat\_s( str,obj.str );

return str;

int main()

sobj1( "Visual" ), obj2( " C++" ), obj3("language");

obj3= obj1 + obj2 + obj3;

cout<< "obj3.str = "<<obj3.gets() << endl;

cout<<"obj3.len= "<<obj3.getLen()<<endl;

**同步练习7.2**

#### **一、选择题** ####

1．在下列函数中，不能重载运算符的函数是（ ）。

（A）成员函数 （B）构造函数 （C）普通函数 （D）友元函数

2．在下列运算符中，要求用成员函数重载的运算符是（ ）。

（A）= （B）== （C）<= （D）++

3．在下列运算符中，要求用友元函数重载的运算符是（ ）。

（A）= （B）\[\] （C）<< （D）( )

4．如果希望运算符的操作数（尤其是第一个操作数）有隐式转换，则重载运算符时必须用（ ）。

（A）构造函数 （B）析构函数 （C）成员函数 （D）友元函数

5．当一元运算符的操作数，或者二元运算符的左操作数是该类的一个对象时，重载运算符函数一般定义为（ ）。

（A）构造函数 （B）析构函数 （C）成员函数 （D）友元函数

【解答】 B A C D C

#### **二、程序练习** ####

1．阅读程序，写出运行结果。

\#include<iostream>

usingnamespace std;

classT

\{ public :

T() \{ a =0; b = 0; c = 0; \}

T( inti, int j, int k ) \{ a = i; b =j; c = k; \}

voidget( int &i, int &j, int &k ) \{ i =a; j = b; k = c; \}

Toperator\* ( T obj );

private:

int a,b, c;

\};

TT::operator\* ( T obj )

\{ T tempobj;

tempobj.a= a \* obj.a;

tempobj.b= b \* obj.b;

tempobj.c= c \* obj.c;

returntempobj;

intmain()

\{ T obj1( 1,2,3 ), obj2( 5,5,5 ), obj3;

int a,b, c;

obj3 =obj1 \* obj2;

obj3.get(a, b, c );

cout<<"(obj1\*obj2 ): " <<"a ="<<a<<'\\t'<<"b ="<<b<<'\\t'<<"c = "<<c<<'\\n';

(obj2\*obj3).get(a, b, c );

cout<<"(obj2\*obj3 ): " <<"a ="<<a<<'\\t'<<"b ="<<b<<'\\t'<<"c = "<<c<<'\\n';

【解答】

2．阅读程序，写出运行结果。

\#include<iostream>

usingnamespace std;

classVector

\{ public:

Vector()\{ \}

Vector(inti,int j) \{ x = i; y = j; \}

friendVector operator+ ( Vector v1, Vector v2 )

\{ Vector tempVector;

tempVector.x= v1.x + v2.x;

tempVector.y= v1.y + v2.y;

return tempVector;

voiddisplay()

\{ cout << "( " << x<< ", " << y << ") "<< endl; \}

private:

int x,y;

\};

intmain()

\{ Vector v1( 1, 2 ), v2( 3, 4 ), v3;

cout<< "v1 = ";

v1.display();

cout<< "v2 = ";

v2.display();

v3 =v1 + v2;

cout<< "v3 = v1 + v2 = ";

v3.display();

【解答】

3．在同步练习7.1的程序练习中，用于连接字符串的重载“+”运算符函数被重载为class s的成员函数。请用友元函数定义改写之。

【解答】

\#include<iostream>

\#include<cstring>

using namespacestd;

class s

public:

s()

\{\*str = '\\0'; len = 0; \}

s( char \*pstr )

strcpy\_s( str,pstr );

len=strlen(pstr);

char \*gets()

\{ return str; \}

intgetLen()

\{ return len; \}

friend s operator+( s obj1, s obj2 ); //声明友元函数

private:

char str\[100\];

int len;

\};

s operator+( sobj1, s obj2 )

strcat\_s( obj1.str,obj2.str );

return obj1.str;

int main()

s obj1( "Visual" ),obj2( "C++" ),obj3(" language");

obj3 = obj1 + obj2 + obj3;

cout << "obj3.str ="<<obj3.gets() << endl;

**同步练习7.3**

#### **一、选择题** ####

1．设有类A的对象Aobject，若用成员函数重载前置自增表达式，那么++Aobject被编译器解释为（ ）。

（A）Aobject.operator++() （B）operator++(Aobject)

（C）++(Aobject) （D）Aobject ::operator++()

2．运算符++，=，+和\[\]中，只能用成员函数重载的运算符是（ ）。

（A）+和= （B）\[\]和后置++

（C）=和\[\] （D）前置++和\[\]

3．在C++中，如果在类中重载了函数调用运算符()，那么重载函数调用的一般形式为（ ）。

（A）（表达式）对象 （B）（表达式表）对象

（C）对象（表达式） （D）对象（表达式表）

4．设有类A的对象Aobject，若用友元函数重载后置自减表达式，那么Aobject--被编译器解释为（ ）。

（A）Aobject.operator-- () （B）operator-- (Aobject,0)

（C）-- (Aobject,0) （D）-- (Aobject,0)

5．如果表达式++j\*k中的++和\*都是重载的友元运算符，则采用运算符函数调用格式，该表达式还可以表示为（ ）。

（A）operator\*(j.operator++(),k) （B）operator\*(operator++(j),k)

（C）operator++(j).operator\*(k) （D）operator\*(operator++(j),)

6．如果类A要重载插入运算符<<，那么重载函数参数表的形式一般定义为（ ）。

（A）(constA&) （B）(ostream&)

（C）(constA&, ostream&) （D）(ostream&, constA&)

【解答】 A C D B B D

#### **二、程序练习** ####

改写下述程序中的student类，用重载运算符>>函数代替input函数；用重载运算符<<函数代替output函数；并修改main函数，使其得到正确的运行结果。

\#include<iostream>

usingnamespace std;

classstudent

\{ char name\[20\];

unsignedid;

double score;

public:

student(chars\[20\]="\\0", unsigned k=0, double t=0)

\{ strcpy\_s(name,s);

id=k;

score=t;

voidinput()

\{ cout<<"name? ";

cin>>name;

cout<<"id?";

cin>>id;

cout<<"score?";

cin>>score;

voidoutput()

\{ cout<<"name:"<<name<<"\\tid: "<<id<<"\\tscore:"<<score<<endl; \}

\};

intmain()

\{ student s;

s.input();

s.output();

【解答】

\#include <iostream>

using namespace std;

class student

char name\[20\];

unsigned id;

double score;

public:

student(chars\[20\]="\\0", unsigned k=0, double t=0)

strcpy\_s(name,s);

id=k;

score=t;

friend ostream& operator<<(ostream &, const student &);

friend istream& operator>>(istream &, student &);

\};

ostream & operator<<(ostream &out, conststudent &s)

out<<"name:"<<s.name<<"\\tid:"<<s.id<<"\\tscore: "<<s.score<<endl;

return out;

istream & operator>>(istream &in, student&s)

cout<<"name? ";

in>>s.name;

cout<<"id? ";

in>>s.id;

cout<<"score? ";

in>>s.score;

return in;

int main()

student s;

cin>>s;

cout<<s;

**同步练习7.4**

#### **一、选择题** ####

1．类型转换函数只能定义为一个类的（ ）。

（A）构造函数 （B）析构函数 （C）成员函数 （D）友元函数

2．具有一个非默认参数的构造函数一般用于实现从（ ）的转换。

（A）该类类型到参数类型 （B）参数类型到该类类型

（C）参数类型到基本类型 （D）类类型到基本类型

3．假设ClassX是类类型标识符，Type为类型标识符，可以是基本类型或类类型，Type\_Value为Type类型的表达式，那么，类型转换函数的形式为（ ）。

（A）ClassX :: operatorType(Type t) \{ … returnType\_Value; \}

（B）friendClassX ::operator Type() \{ … return Type\_Value; \}

（C）Type ClassX ::operator Type() \{ … return Type\_Value; \}

（D）ClassX :: operatorType() \{ … return Type\_Value; \}

4．在下列关于类型转换的描述中，错误的是（ ）。

（A）任何形式的构造函数都可以实现数据类型转换。

（B）带非默认参数的构造函数可以把基本类型数据转换成类类型对象。

（C）类型转换函数可以把类类型对象转换为其他指定类型对象。

（D）类型转换函数只能定义为一个类的成员函数，不能定义为类的友元函数。

5．C++中利用构造函数进行类类型转换时的构造函数形式为（ ）。

（A）类名::类名(arg); （B）类名::类名(arg,arg1=E1,…,agrn=En);

（C）~类名(arg); （D）~类名(arg,arg1=E1,…,agrn=En);

【解答】 C B D A B

#### **二、程序练习** ####

1．阅读下面程序，按注释位置指出语句的性质。

\#include<string.h>

\#include<iostream>

using namespace std;

//定义String类

class String

\{ friendostream &operator<<(ostream & output,String &s); //（1）什么语句

friend istream &operator>>(istream& input,String &s); //（2）什么语句

public:

String(const char \*m=""); //（3）什么语句

~String(); //（4）什么语句

operator int() const; //（5）什么语句

operator char\* ()const; //（6）什么语句

private:

char \*str;

int size;

\};

//（7）什么定义

String::String(const char \*m)

\{ size=strlen(m);

str=new char\[size+1\];

strcpy\_s(str,size+1,m);

//（8）什么定义

String::~String()

\{ delete \[\] str;

size=0;

//（9）什么定义

ostream &operator<<(ostream&output,String &s)

\{ output<<s.str;

return output;

//（10）什么定义

istream &operator>>(istream &input,String&s)

\{ chartemp\[1000\];

input>>temp;

delete \[\] s.str;

s.size=strlen(temp);

s.str=new char\[s.size+1\];

strcpy\_s(s.str,s.size+1,temp);

return input;

//（11）什么定义

String::operator int()const

\{ return size; \}

//（12）什么定义

String::operator char\* () const

\{ static chartemp\[1000\];

strcpy\_s(temp,"\\"");

strcat\_s(temp,str);

strcat\_s(temp,"\\"");

return temp;

int main()

\{ char s\[100\];

String s1,s2; //（13）调用什么函数

cout<<"Please input twostrings:"<<endl;

cin>>s1>>s2; //（14）调用什么函数

cout<<"outputis:"<<endl;

cout<<"s1 as String--"<<s1<<endl; //（15）调用什么函数

cout<<"sizeof(s1) -sizeof(s2)="<<((int)s1- (int)s2)<<endl; //（16）调用什么函数

cout<<"s1 as char \* --"<<(char\*)s1<<endl; //（17）调用什么函数

cout<<"s2 as char \* --"<<(char\*)s2<<endl; //（18）调用什么函数

strcpy(s,s2); //（19）调用什么函数

cout<<"After strcpy(s,s2);s="<<s<<endl; //（20）调用什么函数

return 0; //（21）调用什么函数

【解答】

\#include<string.h>

\#include<iostream>

using namespace std;

//定义String类

class String

\{ friend ostream&operator<<(ostream & output,String &s); //（1）运算符<<重载函数声明

friend istream&operator>>(istream & input,String &s); //（2）运算符>>重载函数声明

public:

String(const char\*m=""); //（3）构造函数声明

~String(); //（4）析构函数声明

operator int()const; //（5）类型转换函数声明

operator char\*()const; //（6）类型转换函数声明

private:

char \*str;

int size;

\};

//（7）定义构造函数

String::String(const char \*m)

\{ size=strlen(m);

str=newchar\[size+1\];

strcpy\_s(str,size+1,m);

//（8）定义析构函数

String::~String()

\{ delete \[\] str;

size=0;

//（9）定义运算符<<重载函数

ostream &operator<<(ostream &output,String&s)

\{ output<<s.str;

return output;

//（10）定义运算符>>重载函数

istream &operator>>(istream &input,String&s)

\{ char temp\[1000\];

input>>temp;

delete \[\] s.str;

s.size=strlen(temp);

s.str=newchar\[s.size+1\];

strcpy\_s(s.str,s.size+1,temp);

return input;

//（11）定义int类型转换函数

String::operator int()const

return size;

//（12）定义char\*类型转换函数

String::operator char\* () const

static chartemp\[1000\];

strcpy\_s(temp,"\\"");

strcat\_s(temp,str);

strcat\_s(temp,"\\"");

return temp;

int main()

char s\[100\];

String s1,s2; //（13）调用构造函数

cout<<"Pleaseinput two strings:"<<endl;

cin>>s1>>s2; /（14）/调用operator>>函数

cout<<"outputis:"<<endl;

cout<<"s1as String--"<<s1<<endl; //（15）调用operator<<函数

cout<<"sizeof(s1)-sizeof(s2)="<<((int)s1-(int)s2)<<endl; //（16）调用operatorint类型转换函数

cout<<"s1as char \* --"<<(char\*)s1<<endl; //（17）调用operator char\*类型转换函数

cout<<"s2as char \* --"<<(char\*)s2<<endl; //（18）调用operator char\*类型转换函数

strcpy(s,s2); //（19）对参数s2调用类型转换函数operator char\*，然后调用库函数

cout<<"Afterstrcpy(s,s2); s="<<s<<endl; //（20）调用库函数输出串

return 0; //（21）调用析构函数

2．定义人民币类RMB，包含：

私有数据成员 int yuan（元）、int jiao（角）、int fen（分）、bool mark（标志，表示正、负数）

成员函数 用（元，角，分，标志）构造RMB对象

用double数据构造RMB对象

类型转换，把RMB对象转换为double值

友元函数 重载<<，以“元角分”形式输出RMB对象值

重载>>，以“元角分”形式输入RMB对象值

以下是main函数的测试和运行显示。请补充RMB类的定义。

\#include<iostream>

using namespace std;

//此处定义class RMB

int main()

\{ RMB a, b;

double c;

cout<<"a :\\n"; cin>>a;

cout<<"b :\\n"; cin>>b;

cout<<"c :\\n"; cin>>c;

cout<<"a ="<<a<<"\\tb = "<<b<<"\\tc ="<<RMB(c)<<endl;

cout<<"a + c ="<<RMB(a+c)<<endl;

cout<<"a - b = "<<RMB(a-b)<<endl;

cout<<"b \* 2 ="<<RMB(b\*2)<<endl;

cout<<"a \* 0.5 ="<<RMB(a\*0.5)<<endl;

【解答】

\#include<iostream>

using namespacestd;

class RMB

int yuan, jiao, fen ;

bool mark;

public:

RMB(int y, int j, int f, boolmark=false);

RMB(double x=0);

operator double()const;

friend istream&operator>>(istream&, RMB&);

friend ostream&operator<<(ostream&, RMB);

\};

RMB::RMB(int y,int j, int f, bool m )

yuan=y;jiao=j; fen=f; mark=m;

RMB::RMB(doublex)

if(x<0)

mark=true; x=-x;

else

mark=0;

int n=int((x+0.005)\*100);

yuan=n/100;

jiao=(n-yuan\*100)/10;

fen=n%10;

RMB::operatordouble()const

double x=yuan+jiao/10.0+fen/100.0;

if(mark) x=-x;

return x;

istream&operator>>(istream&input, RMB &r)

cout<<"元？";input>>r.yuan;

cout<<"角？";input>>r.jiao;

cout<<"分？"; input>>r.fen;

return input;

ostream& operator<<(ostream&output, RMB r)

if(r.mark) output<<" - ";

output<<r.yuan<<"元"<<r.jiao<<"角"<<r.fen<<"分";

return output;

int main()

RMB a, b;

double c;

cout<<"a :\\n"; cin>>a;

cout<<"b :\\n"; cin>>b;

cout<<"c :\\n"; cin>>c;

cout<<"a = "<<a<<"\\tb= "<<b<<"\\tc = "<<RMB(c)<<endl;

cout<<"a + c ="<<RMB(a+c)<<endl;

cout<<"a - b ="<<RMB(a-b)<<endl;

cout<<"b \* 2 ="<<RMB(b\*2)<<endl;

cout<<"a \* 0.5 ="<<RMB(a\*0.5)<<endl;

**综合练习**

#### **一、思考题** ####

1．一个运算符重载函数被定义为成员函数或友元函数后，在定义方式、解释方式和调用方式上有何区别？可能会出现什么问题？请用一个实例说明之。

【解答】

以二元运算符为例。

<table> 
 <tbody> 
 <tr> 
 <td>运算符重载</td> 
 <td>定义</td> 
 <td>解释</td> 
 <td>调用</td> 
 </tr> 
 <tr> 
 <td>成员函数</td> 
 <td>Obj&amp; operator op(); Obj operator op(object);</td> 
 <td>Obj.operator op() ObjL.operator op(ObjR)</td> 
 <td>Obj op 或 op Obj ObjL op ObjR 左操作数通过this指针指定，右操作数由参数传递</td> 
 </tr> 
 <tr> 
 <td>友员函数</td> 
 <td>friend Obj &amp; operator op(Obj &amp;); friend Obj operator op(Obj,Obj);</td> 
 <td>operator op(Obj) operator op(ObjL,ObjR)</td> 
 <td>Obj op&nbsp; 或 &nbsp;op Obj ObjL op ObjR 操作数均由参数传递</td> 
 </tr> 
 </tbody> 
</table>

可能会出现的问题：

（1）运算符的左右操作数不同，须用友员函数重载；

（2）当运算符的操作需要修改类对象状态时，应用成员函数重载。

（3）友员函数不能重载运算符 = () \[\] ->

必须要用友员函数重载的运算符 >><<

程序略。

2．类类型对象之间、类类型和基本类型对象之间用什么函数进行类型转换？归纳进行类型转换的构造函数和类型转换函数的定义形式、调用形式和调用时机。

【解答】

构造函数可以把基本类型、类类型数据转换成类类型数据；类类型转换函数可以在类类型和基本数据类型之间做数据转换。

<table> 
 <tbody> 
 <tr> 
 <td>&nbsp;</td> 
 <td>定义形式</td> 
 <td>调用形式</td> 
 <td>调用时机</td> 
 </tr> 
 <tr> 
 <td>构造函数</td> 
 <td>ClassX::ClassX(arg,arg1=E1,...,argn=En);</td> 
 <td>隐式调用</td> 
 <td>建立对象、参数传递时</td> 
 </tr> 
 <tr> 
 <td>类类型转换函数</td> 
 <td>ClassX::operator Type();</td> 
 <td>用类型符显式调用； 自动类型转换时隐式调用</td> 
 <td>需要做数据类型转换时</td> 
 </tr> 
 </tbody> 
</table>

#### **二、程序设计** ####

1．定义一个整数计算类Integer，实现短整数+、-、\*、/基本算术运算。要求：可以进行数据范围检查（-32 768～32 767，或自行设定），数据溢出时显示错误信息并中断程序运行。

【解答】

\#include<iostream>

usingnamespace std;

classInteger

private:

short a;

public:

Integer(short n=0)\{ a=n;\}

Integeroperator +(Integer);

Integeroperator -(Integer);

Integeroperator \*(Integer);

Integer operator /(Integer);

Integeroperator =(Integer);

voiddisplay() \{ cout<<a<<endl; \}

\};

IntegerInteger::operator+(Integer x)

Integer temp;

if(a+x.a<-32768||a+x.a>32767)

\{cout<<"Data overflow!"<<endl; abort(); \}

temp.a=a+x.a;

return temp;

IntegerInteger::operator-(Integer x)

Integer temp;

if(a-x.a<-32768||a-x.a>32767)

\{cout<<"Data overflow!"<<endl; abort(); \}

temp.a=a-x.a;

returntemp;

Integer Integer::operator\*(Integerx)

Integer temp;

if(a\*x.a<-32768||a\*x.a>32767)

\{cout<<"Dataoverflow!"<<endl; abort();\}

temp.a=a\*x.a;

returntemp;

Integer Integer::operator/(Integer x)

Integer temp;

if(a/x.a<-32768||a/x.a>32767)

\{cout<<"Data overflow!"<<endl; abort(); \}

temp.a=a/x.a;

return temp;

Integer Integer::operator=(Integer x)

a=x.a;

return\*this;

intmain()

Integer A(90),B(30),C;

cout<<"A=";A.display();

cout<<"B=";B.display();

C=A+B;

cout<<"C=A+B=";C.display();

C=A-B;

cout<<"C=A-B=";C.display();

C=A\*B;

cout<<"C=A\*B=";C.display();

C=A/B;

cout<<"C=A/B=";C.display();

2．定义一个实数计算类Real，实现单精度浮点数+、-、\*、/基本算术运算。要求：可以进行数据范围（-3.4×1038～3.4×1038，或自行设定）检查，数据溢出时显示错误信息并中断程序运行。

【解答】

\#include<iostream>

usingnamespace std;

classReal

private:

double a;

public:

Real(double r=0)\{a=r;\}

Real operator +(Real);

Real operator -(Real);

Real operator \*(Real);

Real operator /(Real);

Real operator =(Real);

voiddisplay()

\{cout<<a<<endl; \}

\};

Real Real::operator+(Realx)

Real temp;

if(a+x.a<-1.7e308||a+x.a>1.7e308)

\{cout<<"Data overflow!"<<endl; abort(); \}

temp.a=a+x.a;

return temp;

RealReal::operator-(Real x)

Real temp;

if(a-x.a<-1.7e308||a-x.a>1.7e308)

\{cout<<"Data overflow!"<<endl; abort(); \}

temp.a=a-x.a;

returntemp;

RealReal::operator\*(Real x)

Real temp;

if(a\*x.a<-1.7e308||a\*x.a>1.7e308)

\{cout<<"Data overflow!"<<endl; abort(); \}

temp.a=a\*x.a;

returntemp;

RealReal::operator/(Real x)

Real temp;

if(a/x.a<-1.7e308||a/x.a>1.7e308)

\{cout<<"Data overflow!"<<endl; abort(); \}

temp.a=a/x.a;

return temp;

Real Real::operator=(Real x)

a=x.a;

return \*this;

intmain()

Real A(1.1),B(1.2),C;

cout<<"A=";A.display();

cout<<"B=";B.display();

C=A+B;

cout<<"C=A+B="; C.display();

C=A-B;

cout<<"C=A-B="; C.display();

C=A\*B;

cout<<"C=A\*B="; C.display();

C=A/B;

cout<<"C=A/B="; C.display();

3．假设有向量***X*** = ( *x*1, *x*2,…, *xn*)和***Y*** = ( *y*1, *y*2,…, *yn*)，它们之间的加、减和乘法分别定义为：

***X*** \+ ***Y***= ( *x*1 \+ *y*1, *x*2\+ *y*2,…, *xn*\+ *yn*)

***X*** \- ***Y*** = ( *x*1 \- *y*1, *x*2 \- *y*2,…, *xn* \- *yn* )

***X*** \* ***Y*** = *x*1 \* *y*1 \+ *x*2 \* *y*2 \+…+ *xn*\* *yn*

编写程序定义向量类Vector，重载运算符+、-、\*和=，实现向量之间的加、减、乘、赋值运算；重载运算符>>、<<实现向量的输入、输出功能。注意检测运算的合法性。

提示：向量类的声明可以是：

class Vector

\{ private:

double \*v;

intlen;

public:

Vector(intsize);

Vector(double \*,int);

~Vector();

double&operator\[\](int i);

Vector& operator =(Vector &);

friendVector operator +(Vector &,Vector &);

friendVector operator - (Vector&,Vector &);

frienddouble operator \*(Vector &,Vector &);

friendostream & operator <<(ostream &output,Vector &);

friendistream & operator >>(istream &input,Vector &);

\};

【解答】

\#include<iostream>

usingnamespace std;

class Vector

private:

double \*v;

int len;

public:

Vector(intsize);

Vector(double\*,int);

~Vector();

double&operator\[\](int i);

Vector &operator =(Vector &);

friendVector operator +(Vector &,Vector &);

friendVector operator -(Vector &,Vector &);

frienddouble operator \*(Vector &,Vector &);

friendostream & operator <<(ostream &output,Vector &);

friendistream & operator >>(istream &input,Vector &);

\};

Vector::Vector(int size)

if(size<=0||size>=2147483647)

\{cout<<"The size of "<<size<<"isoverflow!\\n";

abort();

v=new double\[size\];

for(inti=0;i<size;i++) v\[i\]=0;

len=size;

Vector::Vector(double\*C,int size)

if(size<=0||size>=2147483647)

\{cout<<"The size of"<<size<<"isoverflow!\\n"<<endl;

abort();

v=newdouble\[size\];

len=size;

for(inti=0;i<len;i++) v\[i\]=C\[i\];

Vector::~Vector()

delete \[\]v;

v=NULL; len=0;

double&Vector::operator\[\](int i)

if(i>=0 && i<len)

return v\[i\];

else

\{ cout<<"The sizeof"<<i<<"is overflow!\\n";

abort();\}

Vector&Vector::operator =(Vector &C)

if(len==C.len)

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

v\[i\]=C\[i\];

return \*this;

else

cout<<"Operator = fail!\\n";

abort();

Vectoroperator +(Vector &A,Vector &B) // 向量相加

int size=A.len ;

double \*T=new double\[size\];

if(size==B.len)

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

T\[i\]=A\[i\]+B\[i\];

return Vector (T,size);

else

cout<<"Operator + fail!\\n";

abort();

Vectoroperator -(Vector &A,Vector &B) //向量相减

int size=A.len ;

double \*T=new double\[size\];

if(size==B.len)

\{ for(inti=0;i<size;i++)

T\[i\]=A\[i\]-B\[i\];

return Vector (T,size);

else

cout<<"Operator - fail!\\n";

abort();

doubleoperator \*(Vector &A,Vector &B) //向量相乘

int size=A.len ;

double s=0;

if( size==B.len )

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

s+=A\[i\]\*B\[i\];

return s;

else

cout<<"Operator \* fail!\\n";

abort();

ostream& operator <<(ostream &output,Vector &A) //输出

int i;

output<<'(';

for( i=0;i<A.len-1;i++)

output<<A\[i\]<<',';

output<<A\[i\]<<')';

return output;

istream& operator >>(istream &input,Vector &A) //输入

for(int i=0;i<A.len;i++)

input>>A\[i\];

returninput;

int main()

intk1,k2,k3;double t;

cout<<"Inputthe length of Vector A:\\n";

cin>>k1;

VectorA(k1);

cout<<"Inputthe elements of Vector A:\\n";

cin>>A;

cout<<"Inputthe length of Vector B:\\n";

cin>>k2;

VectorB(k2);

cout<<"Inputthe elements of Vector B:\\n";

cin>>B;

cout<<"Inputthe length of Vector C:\\n";

cin>>k3;

VectorC(k3);

cout<<"A="<<A<<endl;

cout<<"B="<<B<<endl;

C=A+B;

cout<<"A+B="<<A<<"+"<<B<<"="<<C<<endl;

C=A-B;

cout<<"A-B="<<A<<"-"<<B<<"="<<C<<endl;

t=A\*B;

cout<<"A\*B="<<A<<"\*"<<B<<"="<<t<<endl;

4．定义一个类nauticalmile\_kilometer，它包含两个数据成员kilometer（千米）和meter（米）；还包含一个构造函数对数据成员进行初始化；成员函数print，用于输出数据成员kilometer和meter的值；类型转换函数operator double，实现把千米和米转换为海里（1海里=1.852千米）的功能。编写main函数，测试类nauticalmile\_kilometer。

【解答】

\#include <iostream>

using namespace std;

const double n = 1.852; // 定义海里与千米和米的转换系数(1海里=1.852千米)

class nauticalmile\_kilometer

public:

nauticalmile\_kilometer( intkm,double m )

kilometer = km; meter = m;

void print()

cout<<"kilometer="<<kilometer<<'\\t'<<"meter="<<meter<<endl;

operator double();

private:

int kilometer;

double meter;

\};

nauticalmile\_kilometer::operatordouble()

return ( meter / 1000 + double( kilometer )) / n;

int main()

nauticalmile\_kilometer obj( 100,50 );

obj.print();

cout << "nauticalmile=" << double( obj ) <<endl;

5．定义一个集合类setColour，要求元素为枚举类型值。例如，

enum colour \{ red, yellow, blue, white, black \};

集合类实现交、并、差、属于、蕴含、输入、输出等各种基本运算。设计main函数测试setColour类的功能。

【解答】

枚举类型数据用序值参与运算。定义枚举集合关键是对输入/输出操作进行显示转换。

程序略。

6．为例7-9的String类增加定义两个类型转换函数：

String::operator int()const;

String::operator double()const;

把数值形式的字符串转换成int或double类型数据，并在main函数进行测试。

【解答】

\#include<iostream>

\#include<cstring>

using namespacestd;

class String

char\*data;

intsize;

public:

String( char\* s);

operator char\* () const; //把类对象转换成字符串

operator int()const; //把类对象转换成int类型数值

operator double()const; //把类对象转换成double类型数值

\};

String::String(char\* s)

size=strlen(s);

data = new char(size+1);

strcpy\_s(data,size+1,s);

String::operatorchar\* () const

returndata;

String::operatorint()const

int i, n=0;

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

if(data\[i\]<'0'||data\[i\]>'9')

cout<<"\#No int\#\\n";

exit(0) ;

else

n\*=10;

n+=int(data\[i\]-'0');

return n;

String::operator double()const

double x=0, p=1;

int i, point=size;

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

if((data\[i\]<'0'||data\[i\]>'9')&&data\[i\]!='.')

cout<<"\#No double\#\\n";

exit(0) ;

if(data\[i\]=='.') point=i; //记录小数点位置

if(i<point) //处理整数部分

x\*=10;

x+=int(data\[i\]-'0');

if(i>point) //处理小数部分

p/=10;

x+=int(data\[i\]-'0')\*p;

return x;

void main()

String sobj = "hell";

char \* svar = sobj;

cout<<svar<<endl;

String iobj="2345";

int k;

k=int(String("456"))+100; //把字符串转换成int数据

cout<<"k="<<k<<endl;

double w;

w=double(String("3.14"))\*2; //把字符串转换成double数据

cout<<"w="<<w<<endl;

###### 推荐阅读 ######

> **全部习题章节：**  
> [C++课本的练习题及答案（第四章）][C]  
> [C++课本的练习题及答案（第五章）][C 1]  
> [C++课本的练习题及答案（第六章）][C 2]  
> [C++课本的练习题及答案（第七章）][C 3]  
> [C++课本的练习题及答案（第八章）][C 4]  
>

[C]: https://blog.csdn.net/qq_15719613/article/details/105368882
[C 1]: https://blog.csdn.net/qq_15719613/article/details/105369291
[C 2]: https://blog.csdn.net/qq_15719613/article/details/105369270
[C 3]: https://blog.csdn.net/qq_15719613/article/details/105369227
[C 4]: https://blog.csdn.net/qq_15719613/article/details/105369165