c++类和对象作业题挺重要

1、做你想做的，但你首先要知道你想做的是什么一、选择与填空1.下列有关类的说法不正确的是（ ）。A对象是类的一个实例B任何一个对象只能属于一个具体的类C一个类只能有一个对象D 类与对象的关系和数据类型与变量的关系相似答案：C分析：对象是类的一个实例，类与对象的关系和数据与变量的关系相似，所以一个类可以有多个对象。2.下面（ ）项是对构造函数和析构函数的正确定义。Avoid X:X(), void X:X()BX:X(参数),X:X()CX:X(参数),X:X(参数)Dvoid X:X(参数),void X:X(参数)答案：B分析构造函数无返回类型、可带参数、可重载；析构函数无返回类型、不可带参数、

2、不可重载。3.（ ）的功能是对象进行初始化。A析构函数B. 数据成员 C.构造函数 D.静态成员函数答案：C分析：当一个对象定义时，C+编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C+编译系统自动调用析构函数注销该对象并进行善后工作；4.下列表达方式正确的是（ ）。Aclass PBclass Ppublic： public：int x=15； int x；voidshow()coutx； void show()coutx； C class P D. class Pintf; public： ； int a；f=25； void Seta (int x) a=x

3、;答案：D分析：在类体不可对数据成员进行初始化；类定义结束时需用分号；只有类中的成员函数才能存取类中的私有数据。5.拷贝构造函数具有的下列特点中，（ ）是错误的。A如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的B拷贝构造函数只有一个参数，并且是该类对象的引用C拷贝构造函数是一种成员函数D 拷贝构造函数的名字不能用类名答案：D分析：如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的；拷贝构造函数只有一个参数，并且是该类对象的引用；拷贝构造函数的名字与类同名，并且不被指定返回类型；拷贝构造函数是一种成员函数。6.关于静态成员的描述中，（ ）是错误的。A静态成员可分为静态数据

4、成员和静态成员函数B静态数据成员定义后必须在类体进行初始化C静态数据成员初始化不使用其构造函数D静态数据成员函数中不能直接引用非静态成员答案：B静态成员的初始化位置在哪 怎么初始化的分析：静态成员可分为静态数据成员和静态成员函数；静态数据成员被定义后，必须对它进行初始化，初始化在类体外进行，一般放在该类的实现部分最合适，也可以放在其他位置，例如，放在主函数前面等；静态数据成员初始化与该类的构造函数和析构函数无关；在静态成员函数的实现中，可以直接引用静态成员，但不能直接引用非静态成员。7.关于友元的描述中，（ ）是错误的。A友元函数是成员函数，它被说明在类体B 友元函数可直接访问类中的私有成员C

5、 友元函数破坏封装性，使用时尽量少用D 友元类中的所有成员函数都是友元函数答案：A分析：友元函数是非成员函数，在类体说明了，在类体外定义，定义和调用等同于一般的普通函数；由于它可以直接访问类的私有成员，因此破坏了类的封装性和隐藏性，尽量少用。8.设有如下程序结构：class Box ;void main()Box A,B,C; 该程序运行时调用 (1) 次构造函数；调用 (2) 次析构函数。答案：(1)3(2)3分析：每创建一个对象自动调用一次构造函数，在这里创建了A、B、C三个对象，所以共调用了三次构造函数；每释放一个对象，系统自动调用一次析构函数，A、B、C对象释放时，分别调用析构函数，所

6、以析构函数共调用了三次。9.设A为test类的对象且赋有初值,则语句test B(A); 表示 。答案：将对象A复制给对象B。分析：执行test B(A);语句相当于调用了默认复制构造函数，将A对象的属性复制给B对象。10.利用“对象名.成员变量”形式访问的对象成员仅限于被声明为 (1)的成员；若要访问其他成员变量，需要通过 (2) 函数或 (3) 函数。答案：(1) public (2) 成员函数 (3)友元函数分析：类体的数据成员可声明为公有的、私有的和保护的，公有的数据成员可利用“对象名.成员变量”形式来进行访问；私有的数据成员能被类中的其他成员函数或友元函数所调用；保护的数据成员可以在

7、类体中使用，也可以在派生类中使用，但不能在其他类外通过对象使用。11对类的构造函数和析构函数描述正确的是（）。A. 构造函数可以重载，析构函数不能重载B. 构造函数不能重载，析构函数可以重载C. 构造函数可以重载，析构函数也可以重载D. 构造函数不能重载，析构函数也不能重载答案：A12.类的析构函数的作用是（D）。A.一般成员函数B.类的初始化C.对象初始化 D.删除对象答案：D13.假设OneClass为一个类，则该类的拷贝初始化构造函数的声明语句为（ ）。A.OneClass(OneClass p); B. OneClass& (OneClass p);C. OneClass(OneCla

8、ss & p);D. OneClass (OneClass *p);答案：C14.下面对于友元函数描述正确的是（ ）。A.友元函数的实现必须在类的部定义B.友元函数是类的成员C.友元函数破坏了类的封装性和隐藏性D.友元函数不能访问类的私有成员答案：C15.对于结构中定义的成员，其默认的访问权限为（ ）。A.public B. protected C.privateD. static答案：C16.为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（）。A.public B. protected C.privateD. static答案：A17.下面对静态数据成员

9、的描述中，正确的是（ ）。A.静态数据成员可以在类体进行初始化B.静态数据成员不可以在类体进行初始化C.静态数据成员不能受private控制符的作用D.静态数据成员可以直接用类名调用答案：B18.下面对静态数据成员的描述中，正确的是（ ）。A.静态数据成员是类的所有对象共享的数据B.类的每一个对象都有自己的静态数据成员C.类的不同对象有不同的静态数据成员值D.静态数据成员不能通过类的对象调用答案：A二、分析程序执行结果，如果出错则分析其出错结果1.分析以下程序执行的结果 #include #include class Sample public: int x,y; Sample()x=y=0;

10、 Sample(int a,int b)x=a;y=b; void disp() coutx=x,y=yendl; ; void main() Sample s1(2,3); s1.disp(); 解：本题说明了重载构造函数的定义方法。首先定义了一个类Sample,在main()中定义了它的一个对象，定义s1对象时调用其重载构造函数(x=2,y=3)，然后，调用其成员函数输出数据成员。所以输出为：x=2,y=3。 注意：构造函数是唯一不能被显式调用的成员函数，它在定义类的对象时自动调用，也称为隐式调用。 - 2.分析以下程序的执行结果 #include class Sample int x,y

11、; public: Sample()x=y=0; Sample(int a,int b)x=a;y=b; Sample() if(x=y) coutx=yendl; else coutx!=yendl; void disp() coutx=x,y=yendl; ; void main() Sample s1(2,3); s1.disp(); 解：本题说明了析构函数的定义方法。首先定义了一个类Sample,在main()中定义了它的一个对象，定义s1对象时调用其重载构造函数(x=2,y=3)，然后，调用其成员函数输出数据成员，最后在退出程序时自动调用析构函数。所以输出为： x=2,y=3 x!=

12、y 注意：析构函数在对象的作用域结束时被自动隐式调用。 3.分析以下程序的输出结果 #include class Sample int x; public: Sample(int a) x=a; coutconstructing object:x=xendl; ; void func(int n) static Sample obj(n); void main() func(1); func(10); 解：本题说明静态对象构造函数的调用情况，由于在func()函数中定义的对象obj是静态对象，故只被构造一次，所以输出为： counstructing object:x=1 注意：静态对象和静态变

13、量一样，只被构造一次。块作用域的静态变量，在首次进入到定义该静态对象的函数时，构造该静态对象，以后进入该函数时不再构造静态对象。 - 4. 分析以下程序的执行结果 #include class Sample int x,y; public: Sample()x=y=0; Sample(int a,int b)x=a;y=b; void disp() coutx=x,y=ydisp(); 解：本题说明了对象指针的使用方法。这里通过指向对象的指针来调用对象的成员函数。对象指针p指向对象s，p-disp()等价于s.disp()。所以输出为： x=2,y=3.5.分析以下程序的执行结果 #inclu

14、de class Sample public: int x; int y; void disp() coutx=x,y=yendl; ; void main() int Sample:*pc; Sample s; pc=&Sample:x; s.*pc=10; pc=&Sample:y; s.*pc=20; s.disp(); 解：本题说明了类数据成员指针的使用方法。在main()中定义的pc是一个指向Sample类数据成员的指针。执行pc=&Sample:x时，pc指向数据成员x，语句s.*pc=10等价于s.x=10(为了保证该语句正确执行，Sample类中的x必须是公共成员)；执行pc=

15、&Sample:y时，pc指向数据成员y，语句s.*pc=20等价于s.y=20(同样，Sample类中的y必须是公共成员)。所以输出为： x=10,y=20。 - 6. 分析以下程序的执行结果 #include class Sample int x,y; public: Sample()x=y=0; Sample(int a,int b)x=a;y=b; void disp() coutx=x,y=yendl; ; void main() Sample s1,s2(2,3); s1.disp(); s2.disp(); 解： 本题说明了构造函数的调用顺序。首先定义了一个类Sample,在ma

16、in()中定义了它的两个对象，定义s1对象时调用其默认构造函数(x=0,y=0)，定义s2对象时调用其重载构造函数(x=2,y=3)，然后，调用各自的成员函数输出各自的数据成员。所以输出为： x=0,y=0 x=2,y=3 - 7. 分析以下程序执行的结果 #include class Sample int x,y; public: Sample() x=y=0; Sample(int a,int b) x=a;y=b; Sample() if(x=y) coutx=yendl; else coutx!=yendl; void disp() coutx=x,y=yendl; ; void ma

17、in() Sample s1(2,3); s1.disp(); s1.Sample(); 解： 本题说明了可以显式调用析构函数。首先定义了一个类Sample,在main()中定义了它的一个对象，定义s1对象时调用其重载构造函数(x=2,y=3),然后，调用其成员函数输出数据成员，然后调用一次析构函数，最后在退出程序时又自动调用析构函数，所以输出为： x=2,y=3 x!=y x!=y 注意：析构函数不同于构造函数，析构函数既能被显式调用，也能被隐式调用。 - 8. 分析以下程序的执行结果 #include class Sample int x,y; public: Sample() x=y=0

18、; Sample(int a,int b) x=a;y=b; Sample() if(x=y) coutx=yendl; else coutx!=yendl; void disp() coutx=x,y=yendl; ; void main() Sample s1,s2(2,3); s1.disp(); s2.disp(); 解： 本题说明了析构函数的调用顺序，这里定义了两个对象，先顺序调用s1和s2对象的构造函数，再调用各自的成员函数disp()，最后顺序调用s2和s1的析构函数。所以输出为： x=0,y=0 x=2,y=3 x!=y x=y 9.分析以下程序的执行结果 #include #

19、include class Sample public: int x,y; Sample()x=y=0; Sample(int a,int b)x=a;y=b; void disp() coutx=x,y=yendl; Sample() if(x=y) coutx=yendl; else coutx!=yendl; ; void main() Sample s1(2,3); s1.disp(); if(s1.x=2) exit(0); 解： 本题说明了非正常退出程序时析构函数调用的情况。定义了一个类Sample,在main()中定义了它的一个对象，定义s1对象时调用其重载构造函数(x=2,y=

20、3),然后，调用其成员函数输出数据成员，由于if条件成立，执行exit非正常退出，不会隐式调用析构函数，所以输出为： x=2,y=3 注意：如果程序使用exit、abort非正常退出，不会隐式调用析构函数，这样造成对象申请资源无法回收，从而导致操作系统的资源紧而使应用程序无法运行。因此在通常情况下，应使用return语句正常退出。 - 10.分析以下程序的执行结果 (不用看了！)#include class Sample int x,y; public: Sample()x=y=0; Sample(int a,int b)x=a,y=b; Sample() if(x=y) coutx=yend

21、l; else coutx!=yendl; void disp() coutx=x,y=yendl; ; void main() Sample(2,3); 解： 本题说明了常量对象的构造函数和析构函数的调用情况。在main()中定义了一个常量对象，常量对象在构造之后立即析构。所以输出为： x!=y 注意：常量对象的作用域不是整个main()函数，而是仅限于包含该常量的值表达式，表达式一旦计算完成，其中的对象就按构造的逆序析构。 - 11.分析以下程序的执行结果 #include class Sample public: Sample(); Sample(int); Sample(); void

22、 display(); protected: int x; ; Sample:Sample() x=0; coutconstructing normallyn; Sample:Sample(int m) x=m; coutconstructing with a number:xendl; void Sample:display() coutdisplay a number:xendl; Sample:Sample() coutdestructingn; void main() Sample obj1; Sample obj2(20); obj1.display(); obj2.display(

23、); 解： 本题构造函数与析构函数的调用顺序。这里定义了两个对象，先顺序调用obj1和obj2对象的构造函数，再调用各自的成员函数disp()，最后顺序调用obj2和obj1的析构函数。所以输出为： constructing nomally constructing with a number:20 display a number:0 display a number:20 destructing destructing - #include class Sample int n; static int sum; public: Sample(int x)n=x; void add()sum

24、+=n; void disp() coutn=n,sum=sumendl; ; int Sample:sum=0; / 静态数据成员赋初值 void main() Sample a(2),b(3),c(5); a.add(); a.disp(); b.add(); b.disp(); c.add(); c.disp(); 解： 本题说明静态数据成员的使用方法。在类中定义了一个静态数据成员sum，在main()之前给它赋初值0，然后在main()中定义了三个对象，并执行各自的add()和disp()方法。所以输出为： n=2,sum=2 n=3,sum=5 n=5,sum=10 注意：静态数据成

25、员脱离具体的对象独立存在，其存储单元不是任何对象存储空间的一部分，但逻辑上所有对象都共享这一存储单元，对静态数据成员的任何操作都会访问这一存储单元，从而影响这一存储单元的所有对象。所以说静态数据成员不是对象成员，在引用时不需要用对象名。 13.分析以下程序执行的结果 #include class Sample int A; static int B; public: Sample(int a)A=a,B+=a; static void func(Sample s); ; void Sample:func(Sample s) coutA=s.A,B=Bendl; int Sample:B=0;

26、void main() Sample s1(2),s2(5); Sample:func(s1); Sample:func(s2); 解： 本题说明了静态成员函数的使用方法。其中的数据成员B是静态数据成员，求B之值是在构造函数中进行的。所以输出为： A=2,B=7 A=5,B=7 注意：静态成员函数与静态数据成员一样，也不是对象成员。静态成员函数的调用不同于普通的成员函数。在静态成员函数的实现中，引用类的非静态数据成员是通过对象进行的，如本题中s.A，引用类的静态数据成员是直接进行的，如本题中的B。 - 14.分析以下程序的执行结果 #include class Sample char c1,c

27、2; public: Sample(char a)c2=(c1=a)-32; void disp() coutc1转换为c2endl; ; void main() Sample a(a),b(b); a.disp(); b.disp(); 解： 本题说明了构造函数的调用方法。对于对象定义(c)，构造函数执行c1=c,c2=c-32(小写转大写)。所以输出为： a转换为A b转换为B - 15.分析以下程序执行的结果 #include class Sample int x,y; public: Sample()x=y=0; Sample(int a,int b)x=a;y=b; void dis

28、p() coutx=x,y=yendl; ; void main() Sample s1,s2(1,2),s3(10,20); Sample *pa3=&s1,&s2,&s3; for(int i=0;idisp(); 解： 本题说明对象指针数组赋初值方法。定义三个对象和一个对象指针数组，通过赋初值使后者的元素分别指向前面三个对象，然后使用for语句循环调用各个对象的disp()成员函数。所以输出为： x=0,y=0 x=1,y=2 x=10,y=20 - 16. 分析以下程序的执行结果 #include class Sample int x,y; public: Sample()x=y=0;

29、 Sample(int a,int b)x=a,y=b; void disp() coutx=x,y=yendl; ; void main() Sample s1,s2(1,2),s3(10,20); Sample *Pa3; Pa0=&s1; Pa1=&s2; Pa2=&s3; for(int i=0;idisp(); 解： 本题说明对象指针数组的赋值方法。定义三个对象和一个对象指针数组，通过赋值语句使后者的元素分别指向前面的三个对象(而不是采用上题的赋初值方法)，然后使用for语句循环调用各个对象的disp()成员函数。所以输出为： x=0,y=0 x=1,y=2 x=10,y=20 17

30、. 分析以下程序的执行结果 #include class Sample public: int x; int y; void disp() coutx=x,y=y*pc=10; pc=&Sample:y; p-*pc=20; p-disp(); 解： 本题说明了类数据成员指针的使用方法。这里通过指向对象的指针来给类数据成员赋值，其原理与上题相似。输出为： x=10,y=20 - 18.分析以下程序的执行结果 #include class Sample int x; int y; public: Sample(int a,int b) x=a;y=b; int getx()return x; i

31、nt gety()return y; ; void main() int (Sample:*fp)(); fp=&Sample:getx; Sample s(2,7); int v=(s.*fp)(); fp=&Sample:gety; int t=(s.*fp)(); coutv=v,t=tendl; 解： 本题说明了类成员函数指针的使用方法。在main()中定义的fp是一个指向Sample类成员函数的指针。执行fp=Sample:getx后。fp指向成员函数getx(),int v=(s.*fp)()语句等价于int v.getx(),v=x=2;执行fp=Sample:gety之后，fp

32、指向成员函数gety(),int t=(s.*fp)()语句等价于int t=s.gety(),t=x=7。所以输出为： v=2,t=7 - 19.分析以下程序的执行结果 #include class Sample int x; int y; public: Sample(int a,int b) x=a;y=b; int getx()return x; int gety()return y; ; void main() int (Sample:*fp)(); fp=&Sample:getx; Sample s(2,7),*p=&s; int v=(p-*fp)(); fp=&Sample:g

33、ety; int t=(p-*fp)(); coutv=v,t=tendl; 解： 本题说明了类成员函数指针的使用方法。这里通过指向对象的指针来调用指向类成员函数的指针，其原理与上题相似。输出仍为： v=2,t=7 20.分析找出以下程序中的错误，说明错误原因，给出修改方案使之能正确运行。#includeclass one int a1,a2;public:one(int x1=0, x2=0);void main()one data(2,3);coutdata.a1endl;coutdata.a2endl;分析：出错原因：构造函数参数表语法错；构造函数没有函数体；类的对象不能直接访问类的私有

34、成员变量。改正后的程序如下：#includeclass one int a1, a2;public:one(int x1=0, int x2=0) a1=x1;a2=x2;int geta1() return a1; int geta2() return a2; ;void main()one data(2,3);coutdata.geta1()endl;coutdata.geta2()endl;21.分析以下程序的错误原因，给出修改方案使之能正确运行。#include class Amplifierfloat invol,outvol;public:Amplifier(float vin,f

35、loat vout)invol=vin;outvol=vout;float gain();Amplifier:float gain() return outvol/invol; void main()Amplifier amp(5.0,10.0);coutgain()endl;分析：成员函数在类体外定义格式是：函数返回类型类名：成员函数名（参数表）；成员函数调用格式是：对象名.成员函数名（参数表）。改正后的程序如下：#include class Amplifier float invol,outvol;public:Amplifier(float vin,float vout) invol=v

36、in;outvol=vout;float gain();float Amplifier:gain() return outvol/invol;void main() Amplifier amp(5.0,10.0);coutamp.gain()endl;22.下列程序的运行结果是 。#include class pointint x,y;public:point(int a,int b)x=a;y=b;coutcalling the constructor function.endl;point(point &p);friend point move(point q);point()coutca

37、lling the destructor function.n;int getx()return x;int gety() return y;point:point(point &p)x=p.x;y=p.y;coutcalling the copy_initialization constructor function.n;point move(point q)coutOK!n;int i,j; i=q.x+10;j=q.y+20;point r(i,j);return r;void main() point m(15,40),p(0,0);point n(m);p=move(n);coutp

38、=p.getx(),p.gety()endl;分析：根据构造函数、拷贝构造函数和友元函数的特点，执行该程序后，输出结果是：calling the constructor function.calling the constructor function.calling the copy_initialization constructor function.calling the copy_initialization constructor function.OK！calling the constructor function.calling the copy_initialization

39、 constructor function.calling the destructor function.calling the destructor function.calling the destructor function.P=25,60calling the destructor function.calling the destructor function.calling the destructor function.说明：（1）构造函数执行三次，分别初始化主函数中的对象m，p和move函数中的对象r。（2）拷贝构造函数共执行了三次。第一次，初始化对象n；第二次在调用函数m

40、ove()时，实参n给形参q进行初始化；第三次是执行函数move的return r；语句时，系统用r初始化一个匿名对象时使用了拷贝构造函数。（3）析构函数执行了六次。在退出函数move时释放对象r和q共调用二次；返回主函数后，匿名对象赋值给对象p后，释放匿名对象又调用一次析构函数；最后退出整个程序时释放对象m，n和p调用三次。23.#include class Pointint x,y;public:Point()x=1;y=1;Point()coutPoint x,y is deleted.endl; ;void main()Pointa;运行结果为：Point 1,1 is deleted

41、.24. #include #include int count=0;class Pointint x,y;public:Point() x=1;y=1;count+;Point()count-;friend void display();；void display() cout There are count points,endl;void main() Point a;display();Point b5;display();display();运行结果为：There are 1 points,There are 6 points,There are 1 points,25.#inclu

42、declass Csampleint i;public:Csample( );void Display( );Csample();Csample:Csample( ) cout”Constructor”,”;i=0;void Csample:Display() cout”i=”i”,”;Csample:Csample( ) cout”Destructor”endl;void main( ) Csample a;a.Display( );运行结果为：Constructor,i=0,Destructor26. #include #include class Csample int i;public

43、:Csample()cout constructor1 endl; Csample(int val)cout Constructor2endl;i=val;void Display()couti=iendl;Csample()coutDestructorendl;getch(); ;void main()Csample a,b(10);a.Display();b.Display();运行结果为：Constructor1Constructor2i=-858993460i=10DestructorDestructor27.#includeclass Csampleprivate:int i;sta

44、tic int k;public:Csample( );void Display( );int Csample:k=0;Csample:Csample( ) i=0;k+;void Csample:Display( ) cout”i=”i”,k=”kendl;void main( ) Csample a,b;a.Display( );b.Display( );运行结果为:i=0,k=2i=0,k=2三、编程题1、定义盒子Box类，要求具有以下成员：可设置盒子形状；可计算盒子体积；可计算盒子的表面积，要求有默认构造函数、复制构造函数和析构函数。#includeclass Box int x,y,

45、z;int v,s;public:void init(int x1=0,int y1=0,int z1=0)x=x1;y=y1;z=z1;void volue()v=x*y*z;void area() s=2*(x*y+x*z+y*z);void show()coutx= xy= y z=zendl;couts= sv= vendl;void main() Box a;a.init(2,3,4);a.volue();a.area();a.show();2、在书中318页13.8基础上再增加如下要求；要现默认构造函数、复制构造函数、析构函数/ 13.8.cpp : 定义控制台应用程序的入口点。/

46、#include stdafx.h#include iostreamusing namespace std;class Arraypublic:Array(int n=5);Array(Array & n);Array();int & operator (int n);Array & operator =(Array &obj);int operator =(Array &obj);int get_size()return size;private:int size;int * ptr;Array:Array(int n)if(n0)exit(0);size=n;ptr=new intsize

47、;Array:Array(Array & n)size=n.size;ptr=new int size;for(int i=0;i=size)|(n0)cout数组越界!endl;exit(0);return ptrn;Array & Array:operator =(Array &obj)size=obj.size;ptr=obj.ptr;return *this;int Array:operator =(Array &obj)int i=0;if(size!=obj.size)return 0;else while (isize)&(ptri=obj.ptri)i+;if(i=size)r

48、eturn 1;else if(isize)return 0;int _tmain(int argc, _TCHAR* argv)int num1,num2,x;int i,j;cout请输入第一个数组的大小num1;Array Test(num1);for (i=0;inum1;i+)cout请输入第一个数组中的第i+1个元素x;Testi=x;cout第一个数组为:endl;for(i=0;inum1;i+)coutai=Testiendl;coutendl;cout请输入第二个数组的大小num2;Array Test2(num2);for (j=0;jnum2;j+)cout请输入第一个

49、数组中的第j+1个元素x;Test2j=x;cout第二个数组为:endl;for(j=0;jnum2;j+)coutbj=Test2jendl;coutendl;Array test3(Test2);for(j=0;jnum2;j+)coutbj=test3jendl;coutendl;if(Test=Test2)cout这两个数组是相等的endl;if(!(Test=Test2)cout这两个数组不相等！endl;coutendl;return 0;3、定义一个复数类，实现复数的运算符+,-, 前+，后+，前-，后-，=，重载，/complex.h#if!defined _COMPLEX_

50、H_#define _COMPLEX_H_#include using namespace std;class Complex/友元函数，重载输入输出friend ostream & operator(istream & is,Complex &co);public:/构造函数与析构函数Complex();Complex(const double a,const double b);Complex(const Complex &);Complex();/其他公有方法void setReal(const double a);void setImaginary(const double a);do

51、uble getReal();double getImaginary();void show();/打印Complex add(const Complex &co);/相加Complex sub(const Complex &co);/相减Complex & operator=(const Complex &m);/赋值运算符重载/加减运算符重载Complex operator+(const Complex &co);Complex operator-(const Complex &co);Complex operator+();/前+Complex operator+(int);/后+Com

52、plex operator-();/前-Complex operator-(int);/后-private:double real;/实部double imaginary;/虚部;#endif/complex.cppinclude Complex.h#include using namespace std;Complex:Complex() real=0;imaginary=0;Complex:Complex(const double a,const double b) real=a;imaginary=b;Complex:Complex(const Complex & co) real=co

53、.real ;imaginary=co.imaginary ;Complex:Complex() Complex & Complex:operator =(const Complex &m)if(this=&m)return *this;real=m.real ;imaginary=m.imaginary ;return *this;void Complex:setReal(const double a)real=a;void Complex:setImaginary(const double a) imaginary=a;double Complex:getReal()return real;double Complex:getImaginary()return imaginary;void Complex:show()if(real!=0)cout0)cout+imagin