第三次实验 构造函数和析构函数

一、实验目的和要求

1、熟悉类的定义格式和类中成员的访问权限。

2、构造函数与析构函数的调用时机与顺序。

3、掌握对象的定义以及对象的初始化的时机与方法。

二、实验内容

1、下面程序sy3_1.cpp中用ERROR表明的语句有错，在不删除和增加代码行的情况下，改正错误语句，使其正确运行。

[cpp] view plain copy

1. //sy3_1.cpp 
2. #include<iostream> 
3. using namespace std; 
4. class Aa 
5. { 
6.     public: 
7.     Aa(int i =0){a=i;cout<<"Constructor"<<a<<endl;} 
8.     ~Aa(){cout<<"Destructor"<<a<<endl;} 
9.     void print(){cout<<a<<endl;} 
10.     private: 
11.     int a; 
12. }; 
13. int main() 
14. { 
15. Aa a1(1),a2(2); 
16. a1.print(); 
17. cout<<a2.a<<endl;//ERROR 
18. return 0; 
19. } 

运行显示错误：

修改：

[cpp] view plain copy

1. #include<iostream> 
2. using namespace std; 
3. class Aa 
4. { 
5.     public: 
6.     Aa(int i =0){a=i;cout<<"Constructor"<<a<<endl;} 
7.     ~Aa(){cout<<"Destructor"<<a<<endl;} 
8.     void print(){cout<<a<<endl;} 
9.     private: 
10.     int a; 
11. }; 
12. int main() 
13. { 
14. Aa a1(1),a2(2); 
15. a1.print(); 
16. a2.print();//ERROR 
17. return 0; 
18. } 

能够正确运行：

2、调试下列程序。

[cpp] view plain copy

1. //sy3_2.cpp 
2. #include<iostream> 
3. using namespace std; 
4. class TPoint 
5. { 
6.     public: 
7.     TPoint(int x,int y){X=x;Y=y;} 
8.     TPoint(TPoint &p); 
9.     ~TPoint(){cout<<"Destructor is called\n";} 
10.     int getx(){return X;} 
11.     int gety(){return Y;} 
12.     private: 
13.     int X,Y; 
14. }; 
15. TPoint::TPoint(TPoint &p) 
16. { 
17. X=p.X; 
18. Y=p.Y; 
19. cout<<"Copy-initialization Constructor is called\n"; 
20. } 
21. int main() 
22. { 
23. TPoint p1(4,9); 
24. TPoint p2(p1); 
25. TPoint p3=p2; 
26. cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")\n"; 
27. return 0; 
28. } 

在该程序中，将TPoint类的带有两个参数的构造函数进行修改，在函数体内增添下述语句：

        cout<<"Constructor is called.\n";

（1）写出程序的输出结果，并解释输出结果。

（2）按下列要求进行调试：

        在主函数体内，添加下列说明语句：

        TPoint P4，P5(2)；

调试程序会出现什么现象？为什么？如何解决？（提示：对已有的构造函数进行适当修改）结合运行结果分析如何使用不同的构造函数创建不同的对象。

调试结果错误：

因为在类中没有定义不带参数和带一个参数的构造函数，将TPoint(int x=0,int y)改为TPoint(int x=0,int y=0)后继续调试：

在实验中TPoint p1(4,9);和TPoint P4,P5(2);调用了构造函数，TPoint p2(p1);和TPoint p3=p2;调用拷贝构造函数。

3、对教材中Li3_11.cpp的主函数做如下修改：

（1）将Heapclass *pa1,*pa3改为Heapclass *pa1,*pa2,*pa3；

（2）在语句pa2=new Heapclass；后增加语句pa3=new Heapclass(5)；

（3）在语句if(!pa1||!pa2)改为if(!pa1||!pa2||！pa3)；

（4）在语句delete pa2;后增加语句delete pa3；

写出程序的输出结果，并解释输出结果。

[cpp] view plain copy

1. #include<iostream> 
2. using namespace std; 
3. class Heapclass 
4. { 
5.     public: 
6.     Heapclass(int x); 
7.     Heapclass(); 
8.     ~Heapclass(); 
9.     private: 
10.     int i; 
11. }; 
12. Heapclass::Heapclass(int x) 
13. { 
14.     i=x; 
15.     cout<<"Contstructor is called."<<i<<endl; 
16. } 
17. Heapclass::Heapclass() 
18. { 
19. cout<<"Default Contstructor is called."<<endl; 
20. } 
21. Heapclass::~Heapclass() 
22. { 
23. cout<<"Default is called."<<endl; 
24. } 
25. int main() 
26. { 
27. Heapclass *pa1,*pa2,*pa3; 
28. pa1=new Heapclass(4); 
29. pa2=new Heapclass; 
30. pa3=new Heapclass(5); 
31. if(!pa1||!pa2||!pa3); 
32. { 
33.     cout<<"Out of Memory!"<<endl; 
34.     return 0; 
35. } 
36. cout<<"Exit main"<<endl; 
37. delete pa1; 
38. delete pa2; 
39. delete pa3; 
40. return 0; 
41. } 

输出结果：

用3个指针*p1，*p2，*p3指向三个新创建的对象，并调用了带一个和不带构造参数的构造函数对对象进行初始化，则输出了前三个语句。实验结束后，调用了析构函数，产生了后三个语句。

4、请定义一个矩形类（Rectangle），私有数据成员为矩形的长度（len）和宽带（wid），无参构造函数置len和wid为0，有参构造函数置len和wid为对应形参的值，另外还包括求矩形周长、求矩形面积、取矩形长度和宽度、修改矩形长度和宽度为对应形参的值、输出矩形尺寸等公有成员函数。要求输出矩形尺寸的格式为“length：长度，width：宽度”。（sy3_3.cpp）

[cpp] view plain copy

1. //sy3_3.cpp 
2. #include<iostream> 
3. using namespace std; 
4. class Rectangle 
5. { 
6.     public: 
7.     Rectangle(){len=0;wid=0;} 
8.     Rectangle(double Len,double Wid){len=Len;wid=Wid;} 
9.     double Circumference(){return 2*(len+wid);} 
10.     double Area(){return len*wid;} 
11.     double getl(){return len;} 
12.     double getw(){return wid;} 
13.     void charge(double a,double b){len=a;wid=b;} 
14.     print(){cout<<"length:"<<len<<"width:"<<wid;} 
15.     private: 
16.     int len,wid; 
17. }; 
18. int main() 
19. { 
20. Rectangle p1; 
21. Rectangle p2(4.0,5.0); 
22. cout<<"p1的矩形尺寸："; 
23. p1.print(); 
24. cout<<"p2的矩形尺寸："; 
25. p2.print(); 
26. cout<<"p2周长："<<p2.Circumference()<<endl; 
27. cout<<"p2面积："<<p2.Area()<<endl; 
28. cout<<"p2的长度："<<p2.getl()<<endl; 
29. cout<<"p2的宽度："<<p2.getw()<<endl; 
30. p2.charge(5.0,6.0); 
31.  
32. cout<<"修改后的矩形尺寸"; 
33. p2.print(); 
34. return 0; 
35. } 

输出结果：

三、分析与讨论

1、类中私有成员的访问权限。

    答：类中私有成员是被隐藏的数据，只有该类的成员函数或友元函数才可以引用它。

2、构造函数与析构函数的调用顺序。

    答：构造函数是一种特殊的成员函数，对象的创建和初始化工作可以由它来完成。析构函数的作用是在对象消失时执行一项清理任务，例如可以用来释放由构造函数分配的内存等。

3、何时进行对象初始化？如何进行？（提示：注意分一般对象与堆对象讨论）

    答：在声明对象的时候进行的数据成员设置，称为对象的初始化，初始化由构造函数来完成。

四、实验小结

         通过本次实验，我感觉自己收获还是很大的，通过实验熟悉了类的定义格式和类中成员的访问权限，还知道了构造函数和析构函数的调用时机与顺序以及知道了对象的定义和对象的初始化的时机与方法。