实验3 构造函数与析构函数（P279）

最新推荐文章于 2024-03-26 19:24:40 发布
最新推荐文章于 2024-03-26 19:24:40 发布
阅读量359 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luojun_1/article/details/80766510
版权

实验目的和要求

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

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

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

实验内容

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

[cpp] view plain copy
print ?
  1. <span style="font-size:18px;">//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. }</span>  
//sy3_1.cpp
#include<iostream>
using namespace std;
class Aa
{
  public:
      Aa(int i=0){a=i;cout<<"Constructor"<<a<<endl;}
      ~Aa(){cout<<"Destructor"<<a<<endl;}
      void print(){cout<<a<<endl;}
  private:
    int a;
};
int main()
{
    Aa a1(1),a2(2);
    a1.print();
   cout<<a2.a<<endl;//ERROR
    return 0;
}

运行结果如下:


修改程序如下：

[cpp] view plain copy
print ?
  1. <span style="font-size:18px;">//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.     a2.print();    
  18.     return 0;    
  19. }</span>  
//sy3_1.cpp
#include<iostream>  
using namespace std;  
class Aa  
{  
  public:  
      Aa(int i=0){a=i;cout<<"Constructor"<<a<<endl;}  
      ~Aa(){cout<<"Destructor"<<a<<endl;}  
      void print(){cout<<a<<endl;}  
  private:  
    int a;  
};  
int main()  
{  
    Aa a1(1),a2(2);  
    a1.print();  
    a2.print();  
    return 0;  
}

正确程序运行结果如下：



2、调试下列程序。

[cpp] view plain copy
print ?
  1. <span style="font-size:18px;">//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.     TPoint p4,p5(2);  
  27.     cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")\n";  
  28.     return 0;  
  29. }</span>  
//sy3_2.cpp
#include<iostream>
using namespace std;
class TPoint
{
public:
    TPoint(int x,int y){X=x,Y=y;}
    TPoint(TPoint &p);
    ~TPoint(){cout<<"Destructor is called\n";}
    int getx(){return X;}
    int gety(){return Y;}
private:
    int X,Y;
};
TPoint::TPoint(TPoint &p)
{
    X=p.X;
    Y=p.Y;
    cout<<"Copy-initialization Constructor is called\n";
}
int main()
{
    TPoint p1(4,9);
    TPoint p2(p1);
    TPoint p3=p2;
    TPoint p4,p5(2);
    cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")\n";
    return 0;
}

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

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

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

修改程序如下：

[cpp] view plain copy
print ?
  1. <span style="font-family:SimSun;font-size:18px;">//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.     cout<<"Constructor is called\n";  
  21. }  
  22. int main()  
  23. {  
  24.     TPoint p1(4,9);  
  25.     TPoint p2(p1);  
  26.     TPoint p3=p2;  
  27.     cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")\n";  
  28.     return 0;  
  29. }</span>  
//sy3_2.cpp
#include<iostream>
using namespace std;
class TPoint
{
public:
    TPoint(int x,int y){X=x,Y=y;}
    TPoint(TPoint &p);
    ~TPoint(){cout<<"Destructor is called\n";}
    int getx(){return X;}
    int gety(){return Y;}
private:
    int X,Y;
};
TPoint::TPoint(TPoint &p)
{
    X=p.X;
    Y=p.Y;
    cout<<"Copy-initialization Constructor is called\n";
    cout<<"Constructor is called\n";
}
int main()
{
    TPoint p1(4,9);
    TPoint p2(p1);
    TPoint p3=p2;
    cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")\n";
    return 0;
}


原程序运行结果如下：


修改后的程序运行结果如下：


输出结果解释：


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

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

TPoint  P4，P5(2);

[cpp] view plain copy
print ?
  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.     cout<<"Constructor is called\n";  
  21. }  
  22. int main()  
  23. {  
  24.     TPoint P4,P5(2);  
  25.     TPoint p1(4,9);  
  26.     TPoint p2(p1);  
  27.     TPoint p3=p2;  
  28.     cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")\n";  
  29.     return 0;  
  30. }  
//sy3_2.cpp
#include<iostream>
using namespace std;
class TPoint
{
public:
    TPoint(int x,int y){X=x,Y=y;}
    TPoint(TPoint &p);
    ~TPoint(){cout<<"Destructor is called\n";}
    int getx(){return X;}
    int gety(){return Y;}
private:
    int X,Y;
};
TPoint::TPoint(TPoint &p)
{
    X=p.X;
    Y=p.Y;
    cout<<"Copy-initialization Constructor is called\n";
    cout<<"Constructor is called\n";
}
int main()
{
    TPoint P4,P5(2);
    TPoint p1(4,9);
    TPoint p2(p1);
    TPoint p3=p2;
    cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")\n";
    return 0;
}
运行结果如下：


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

出现的现象：


为什么：因为在类中没有定义不带参数和带一个参数的构造函数；

如何解决：将带两个参数的构造函数改为缺省的构造函数，就是可以将TPoint(int x,int y)改为TPoint(int x=0,int y=0) ； 在运行过程中，TPoint p1(4,9)和TPoint p4,p5(2);调用了构造函数，而TPoint p2(p1)和TPoint p3=p2是使用了拷贝构造函数。如下所示：

[cpp] view plain copy
print ?
  1. //sy3_2.cpp  
  2. #include<iostream>  
  3. using namespace std;  
  4. class TPoint  
  5. {  
  6. public:  
  7.     TPoint(int x=0,int y=0){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.     cout<<"Constructor is called\n";  
  21. }  
  22. int main()  
  23. {  
  24.     TPoint P4,P5(2);  
  25.     TPoint p1(4,9);  
  26.     TPoint p2(p1);  
  27.     TPoint p3=p2;  
  28.     cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")\n";  
  29.     return 0;  
  30. }  
//sy3_2.cpp
#include<iostream>
using namespace std;
class TPoint
{
public:
    TPoint(int x=0,int y=0){X=x,Y=y;}
    TPoint(TPoint &p);
    ~TPoint(){cout<<"Destructor is called\n";}
    int getx(){return X;}
    int gety(){return Y;}
private:
    int X,Y;
};
TPoint::TPoint(TPoint &p)
{
    X=p.X;
    Y=p.Y;
    cout<<"Copy-initialization Constructor is called\n";
    cout<<"Constructor is called\n";
}
int main()
{
    TPoint P4,P5(2);
    TPoint p1(4,9);
    TPoint p2(p1);
    TPoint p3=p2;
    cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")\n";
    return 0;
}


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

（1）将Heapclass *pa1,*pa2 改为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
print ?
  1. <span style="font-family:SimSun;font-size:18px;">//程序Li3_11.cpp  
  2. //new和delete的用法  
  3. #include<iostream>    
  4. using namespace std;    
  5. class Heapclass    
  6. {    
  7.     public:    
  8.     Heapclass(int x);    
  9.     Heapclass();    
  10.     ~Heapclass();    
  11.     private:    
  12.     int i;    
  13. };    
  14. Heapclass::Heapclass(int x)    
  15. {    
  16.     i=x;    
  17.     cout<<"Contstructor is called."<<i<<endl;    
  18. }    
  19. Heapclass::Heapclass()    
  20. {    
  21. cout<<"Default Contstructor is called."<<endl;    
  22. }    
  23. Heapclass::~Heapclass()    
  24. {    
  25. cout<<"Default is called."<<endl;    
  26. }    
  27. int main()    
  28. {    
  29. Heapclass *pa1,*pa2,*pa3;    
  30. pa1=new Heapclass(4);    
  31. pa2=new Heapclass;    
  32. pa3=new Heapclass(5);    
  33. if(!pa1||!pa2||!pa3);    
  34. {    
  35.     cout<<"Out of Memory!"<<endl;    
  36.     return 0;    
  37. }    
  38. cout<<"Exit main"<<endl;    
  39. delete pa1;    
  40. delete pa2;    
  41. delete pa3;    
  42. return 0;    
  43. }</span>  
//程序Li3_11.cpp
//new和delete的用法
#include<iostream>  
using namespace std;  
class Heapclass  
{  
    public:  
    Heapclass(int x);  
    Heapclass();  
    ~Heapclass();  
    private:  
    int i;  
};  
Heapclass::Heapclass(int x)  
{  
    i=x;  
    cout<<"Contstructor is called."<<i<<endl;  
}  
Heapclass::Heapclass()  
{  
cout<<"Default Contstructor is called."<<endl;  
}  
Heapclass::~Heapclass()  
{  
cout<<"Default is called."<<endl;  
}  
int main()  
{  
Heapclass *pa1,*pa2,*pa3;  
pa1=new Heapclass(4);  
pa2=new Heapclass;  
pa3=new Heapclass(5);  
if(!pa1||!pa2||!pa3);  
{  
    cout<<"Out of Memory!"<<endl;  
    return 0;  
}  
cout<<"Exit main"<<endl;  
delete pa1;  
delete pa2;  
delete pa3;  
return 0;  
}
原程序输出结果如下：


解释：pa1、pa2、pa3中是2个指向类Heapclass的对象指针，在能够赋给它们足够内存的情况下，使用运算符new给它们赋值，同时对它们所指向的对象进行初始化。使用delete释放这三个指针所指向的对象，由于不能够赋给pa1、pa2或pa3足够内存，所以输出“Out of Memory”。

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

[cpp] view plain copy
print ?
  1. //sy3_4.cpp  
  2. #include<iostream>  
  3. using namespace std;  
  4. class Rectangle  
  5. {  
  6. public:  
  7.    Rectangle()  
  8.    {  
  9.        len=0;  
  10.        wid=0;  
  11.    }  
  12.    Rectangle(double Len,double Wid)  
  13.    {  
  14.        len=Len;  
  15.        wid=Wid;  
  16.     }  
  17.    double Circumference()  
  18.    {  
  19.        return 2*(len+wid);  
  20.     }  
  21.    double Area()  
  22.    {  
  23.        return len*wid;  
  24.     }  
  25.    double getl()  
  26.    {  
  27.        return len;  
  28.     }  
  29.    double getw()  
  30.    {  
  31.        return wid;  
  32.     }  
  33.    void charge(double a,double b)  
  34.    {  
  35.        len=a;  
  36.        wid=b;  
  37.     }  
  38.    void s()  
  39.    {  
  40.        cout<<"length:"<<len<<"  "<<"width:"<<wid<<endl;  
  41.     }  
  42. private:  
  43.     int len,wid;  
  44. };  
  45. int main()  
  46. {  
  47.   Rectangle q;  
  48.   Rectangle h(5.0,2.0);  
  49.   cout<<"q的矩形尺寸："<<endl;  
  50.   q.s();  
  51.   cout<<"h的矩形尺寸："<<endl;  
  52.   h.s();  
  53.   cout<<"h的周长:"<<h.Circumference()<<endl;  
  54.   cout<<"h的面积："<<h.Area()<<endl;  
  55.   cout<<"h的长度："<<h.getl()<<endl;  
  56.   cout<<"h的宽度："<<h.getw()<<endl;  
  57.   h.charge(8.0,6.0);  
  58.   cout<<"修改后的矩形的尺寸："<<endl;  
  59.    h.s();  
  60.    return 0;  
  61. }  
//sy3_4.cpp
#include<iostream>
using namespace std;
class Rectangle
{
public:
   Rectangle()
   {
       len=0;
       wid=0;
   }
   Rectangle(double Len,double Wid)
   {
       len=Len;
       wid=Wid;
    }
   double Circumference()
   {
       return 2*(len+wid);
    }
   double Area()
   {
       return len*wid;
    }
   double getl()
   {
       return len;
    }
   double getw()
   {
       return wid;
    }
   void charge(double a,double b)
   {
       len=a;
       wid=b;
    }
   void s()
   {
       cout<<"length:"<<len<<"  "<<"width:"<<wid<<endl;
    }
private:
    int len,wid;
};
int main()
{
  Rectangle q;
  Rectangle h(5.0,2.0);
  cout<<"q的矩形尺寸："<<endl;
  q.s();
  cout<<"h的矩形尺寸："<<endl;
  h.s();
  cout<<"h的周长:"<<h.Circumference()<<endl;
  cout<<"h的面积："<<h.Area()<<endl;
  cout<<"h的长度："<<h.getl()<<endl;
  cout<<"h的宽度："<<h.getw()<<endl;
  h.charge(8.0,6.0);
  cout<<"修改后的矩形的尺寸："<<endl;
   h.s();
   return 0;
}
运行结果如下：



分析与讨论

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

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

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

    答：构造函数在创建对象的时候被调用，析构函数在释放对象的时候被调用，释放由构造函数分配的内存，构造函数与析构函数的调用顺序正好相反。

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

    答：一般对象：在对象创建时进行初始化，可以用构造函数或拷贝函数进行初始化。

        堆对象：使用运算符new分配内存，调用构造函数来进行初始化。

实验总结

    在这次实验中我学会了构造函数与析构函数的使用，掌握了它们的调用方法与调用顺序，当然对类的定义格式和类中成员的访问权限也更加的熟悉，同时还掌握了拷贝函数的使用方法，虽然对知识点的掌握不是很牢固，在编写程序时因为对知识点不能熟练运用，会导致不知道该怎么去构造这个程序，头脑里没有清晰地思路，在写程序前先不要着急写，应该先弄清楚所写得程序要运用到哪些基本知识，自己如果对某个知识不熟悉就得巩固一下，再按照题目要求弄清这个程序的思路，我相信通过长期反复的训练最终也会熟能生巧。

    这次实验的过程不是非常的顺利，在编写程序是，由于疏忽大意将private的p写成大写的，并且把文件格式存错了，本该是.cpp为后缀的，存成了.c为后缀，导致一直运行都出现错误，在一次次的排查之后才找到了问题的出处，所以，在写程序是一定要细心，只有细心才能有所所获。




luojun_1
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++实验六 多态性和虚函数的应用 课程 实验报告
06-11
每个类都提供了构造函数、析构函数以及显示信息的方法。在程序中，通过动态创建不同类型的对象，并利用基类指针调用派生类的方法，展示了多态性在实际问题中的应用。 综上所述，该实验通过设计抽象类和派生类，使用...
c++---练习题---圆类的定义和使用
bless_my_head的博客
07-10 6657
6-14 圆类的定义与使用（拷贝构造函数） (40分) 本题要求完成一个圆类的定义，设计适当的函数：包括构造函数、拷贝构造函数以及析构函数，从而可以通过测试程序输出样例中的结果。（圆周率取值3.14） 函数接口定义： //定义一个圆类 class Circle 裁判测试程序样例： #include<iostream> using namespace std; /* 请在这里填写答案 */ int main() { float r; cin>>r; Circle
圆类的定义与使用（拷贝构造函数）
Mr123zhangchao的博客
04-21 2497
圆类的定义与使用（拷贝构造函数） (25 分) 本题要求完成一个圆类的定义， 设计适当的函数：包括构造函数、拷贝构造函数以及析构函数，从而可以通过测试程序输出样例中的结果。（圆周率取值3.14） 函数接口定义： //定义一个圆类 class Circle 输入样例： 在这里给出一组输入。例如： 5 输出样例： 在这里给出相应的输出。例如： Constructor called Copy constructor called 78.5 31.4 Destructor called Destructor cal
6-63.圆类的定义与使用（拷贝构造函数）
weixin_73121626的博客
12-03 612
【代码】6-63.圆类的定义与使用（拷贝构造函数）
实验3 构造函数与析构函数（P279）
Lijing_666的博客
04-12 1110
实验目的和要求  1、熟悉类的定义格式和类中成员的访问权限。  2、构造函数与析构函数的调用时机与顺序。  3、掌握对象的定义以及对象的初始化的时机与方法。实验内容  1、下面程序sy3_1.cpp中用ERROR标明的语句有错吧，在不删除和增加代码行的情况下，改正错误语句，使其正确运行。//sy3_1.cpp #include&lt;iostream&gt; using namespace std...
4.3.2 复制构造函数
m0_53359491的博客
04-28 151
目录 1、定义 2、语法形式 3、特性 4、复制构造函数调用的三种情况 5、实例展示（Point 类的复制构造函数） 6、运行结果 1、定义 对象创建时，用同类对象来初始化新对象，这种对象创建方式所调用的构造函数称为复制构造函数（Copy Constructor）。 2、语法形式 类名(const 类名 &对象名); //const 可以不写，其形参是本类对象的引用。 3、特性 复制构造函数是一种特殊的构造函数，其具有一般构造函数的所有特性。 当用户没..
吉林大学C++上机实验报告
07-15
C++编程实验报告 本实验报告的主要内容是基于C++语言实现...通过本实验，我们了解了C++语言的基本概念和编程技术，例如类、构造函数、析构函数、成员函数、运算符重载等，并掌握了如何使用C++语言来实现一个多项式类。
计算机理论导引实验研究报告CFG是P成员.doc
最新发布
07-18
该类包含了构造函数、析构函数、设置值的函数、检查值的函数以及打印表格内容的函数。 3. **动态规划实现**：通过循环遍历输入字符串，并利用动态规划填充表格的方式实现了对给定上下文无关文法的验证算法。 #### ...
c++实验1 类与简单对象
04-10
析构函数在对象生命周期结束时自动调用，用于清理资源。在类中，构造函数没有返回类型，名字与类名相同，可以有参数或无参数。析构函数以波浪线`~`开头。 4. **成员函数的定义与实现**：成员函数可以定义在类内或类...
P03：UNIX V6++存储管理部分实验1
08-04
2. 分析MemoryDescriptor.h和MemoryDescriptor.cpp，填充MemoryDescriptor类的相关信息，如USER_SPACE_SIZE、USER_SPACE_PAGE_TABLE_CNT和USER_SPACE_START_ADDRESS等静态数据成员，以及构造函数、析构函数、...
java mypoint_java题：设计point类用来定义平面上的一个点，用构造函数传递坐标位置编写测试类在该类中实现point类的对...
weixin_33067503的博客
02-16 1807
alisa回答于：2018-03-29第一题：/* MyPoint.java */// class MyPointpublic class MyPoint {public MyPoint(int x,int y) {this.x = x;this.y = y;}public int getX() {return x;}public int getY() {return y;}private int...
C++编写一个关于圆形的程序,要求定义一个圆形类Circle
热门推荐
qq_58619891的博客
10-04 1万+
1、编写一个关于圆形的C++程序。要求定义一个圆形类Circle，其中包含如下成员： 1）1个私有数据成员（半径）。 2）3个公有函数成员（设置半径、计算面积、计算周长）。 3）3个构造函数（不带参数的构造函数，带参数的构造函数和拷贝构造函数）。 //函数main使用圆形类Circle创建圆形对象，要求 1）定义一个圆对象c1，从键盘输入一个值x，并将其设定为c1的半径，计算并显示c1的面积和周长 2）再定义一个圆对象c2，并将半径初始化为2x，计算并显示c2的面积和周长 3）再定义一个圆对象c3，并用c1
3-1 Point类的构造函数(构造函数的重载)
Rocky0429
09-15 3850
3-1 Point类的构造函数 Time Limit: 1000MS Memory limit: 65536K 题目描述 通过本题目的练习可以掌握类的构造函数的定义； 设计一个点类Point，私有数据成员有x、y；公有成员函数有：无参数的构造函数Point()，带参数的构造函数Point(int,int);ShowPoint()输出点对象的信息 在主函数main()中
类与对象——实验二
alcohol_sun的博客
05-26 1427
【实验目的】 1、掌握类的构造函数和析构函数的概念和使用方法； 2、掌握对象数组、对象指针的定义和使用方法； 3、掌握new和delete的使用方法； 【实验内容】 1、 设计描述平面坐标上的点CPoint类，该类满足下述要求： •具有x，y坐标信息； •具有带默认形参值的构造函数，参数分别用于初始化x和y坐标信息； •具有获取x、y信息的GetX和GetY函数，具有设置x、y信息的SetX和SetY函数； 2、 设计一个矩形类CRectangle，该类满足下述要求： •具有矩形的左下角和右上角两个点的坐标
【第二天】C++类和对象解析：构造函数、析构函数和拷贝构造函数的完全指南
m0_75045191的博客
10-22 304
构造函数是类实例化对象时自动调用拷贝构造函数本质是构造函数旧对象 初始化新对象 时。如果用户不提供拷贝构造 编译器会自动提供一个默认的拷贝构造（完成赋值动作--浅拷贝）
C++中的类和对象(一)
weixin_30698527的博客
01-09 484
一，类的概念及封装 1.什么是封装 第一层含义：封装是面向对象程序设计最基本的特性。把数据（属性）和函数（方法）合成一个整体，这在计算机世界中是用类和对象实现的。（把属性和方法进行封装） 第二层含义：把客观事物封装成抽象的类，并且类可以把自己的属性和方法只让可信的类或者对象操作，对不可信的进行信息的隐藏。（对属性和方法进行访问控制） 2.类的访问控制 　　在C++中可以...
3.定义一个矩形类(Rectangle)，包含私有成员:长(length)、宽(width) ,3.定义一个矩形类(矩形)，包含私有成员:长(长度)、宽(宽度)，
m0_68642791的博客
03-26 553
【代码】3.定义一个矩形类(Rectangle)，包含私有成员:长(length)、宽(width) ,3.定义一个矩形类(矩形)，包含私有成员:长(长度)、宽(宽度)，
圆类
Lhw_666的博客
01-27 1223
题目 定义一个圆类 (Circle)，属性为半径 (radius)，要求能获取和修改圆的半径，并能计算圆的周长和面积，并编写 main 函数进行测试。 相关阅读 相关阅读 完整代码 #include<bits/stdc++.h> #define Pi 3.14; using namespace std; class Circle{ double radius; public: double getRadius(){ return radius; }
实验三
wm38381415108的博客
05-01 1258
1、下面程序sy3_1.cpp中用ERROR标明的语句有错，在不删除和增加代码行的情况下，改正错误语句，使其正确运行错误代码如下：错误代码运行如下：修改程序后运行如下2，调试下列程序（1）在该程序中，将TPoint类的带有两个参数的构造函数进行修改，在函数体内增加下述语句：cout&lt;&lt;"Constructor is called.\n";（1）写出程序的输出结果，并解释输出结果。修...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值