C++练习题及答案（四）

第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 )                                                              //字符串连接函数定义

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

【解答】

以二元运算符为例。

可能会出现的问题：

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

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

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

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

程序略。

 

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

【解答】

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

 

二、程序设计

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×10³⁸～3.4×10³⁸，或自行设定）检查，数据溢出时显示错误信息并中断程序运行。

【解答】

#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₁, x₂,…, x_n)和Y = ( y₁, y₂,…, y_n)，它们之间的加、减和乘法分别定义为：

X + Y= ( x₁ + y₁, x₂+ y₂,…, x_n+ y_n)

X - Y = ( x₁ - y₁, x₂ - y₂,…, x_n - y_n )

X * Y = x₁ * y₁ + x₂ * y₂ +…+ x_n* y_n

编写程序定义向量类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;

}