1. #include"iostream"
  2. using namespace std;//名称空间
  3. class Rectangle  //计算矩形的面积
  4. {
  5. public :
  6.     int w,l;//成员变量，和为对象占用的内存空间
  7.     void Init(int w_,int l_); //成员函数：函数与C与几乎一致
  8.     int  Sget(); //可以通过行为改变属性的值
  9. };
  11. void Rectangle::Init(int w_,int l_)  //归属::行为
  12. {
  13.   w=w_;
  14.   l=l_;
  16. }
  17. int Rectangle::Sget()
  18. {
  19.    return  w*l;
  20. }
  21. int main()
  22. {   int w,l;
  23.     Rectangle r;//r是一个对象，通过类定义的变量为对象
  24.     cin >>w >>l;
  25.     r.Init(w,l);
  26.     cout <<"面积为："<< r.Sget()<< endl;
  27.     return 0;
  28. }
  1. //构造函数存在的意义与必要性：避免声明
  2. #include"iostream"
  3. using namespace std;//名称空间
  4. class Rectangle  //计算矩形的面积
  5. {
  6. public :
  7.     int w,l;//成员变量，和为对象占用的内存空间
  8.     void Init(int w_,int l_); //成员函数：函数与C与几乎一致
  9.     int  Sget(); //可以通过行为改变属性的值
  10. };
  12. void Rectangle::Init(int w_,int l_)  //归属::行为
  13. {
  14.   w=w_;
  15.   l=l_;
  17. }
  18. int Rectangle::Sget()
  19. {
  20.    return  w*l;
  21. }
  22. int main()
  23. {   int w,l;
  24.     Rectangle r;//r是一个对象，通过类定义的变量为对象
  25.     Rectangle r1;
  26.     cin >>w >>l;
  27.     r.Init(w,l);
  28.     r1.w=3;
  29.     r1.l=4;
  30.     cout <<"面积为："<< r.Sget()<< endl;
  31.     cout <<"面积为："<< r1.Sget()<< endl;
  32.     return 0;
  33. }
  1. /*
  2.  *构造函数存在的意义与必要性,构造函数是一种特殊的成员函数，构造指初始化对象（可重载），析构函数是编译器自动调用
  3.  *可以认为是对内存空间的高效管理，在分配内存，回收内存上的很严谨，大大降低了bug概率
  4.  *名字与类名相同，却没有返回值
  5.  *无法像一般函数一样显式的调用，创建对象时自动执行
  6.  */
  7. #include"iostream"
  8. using namespace std;//名称空间
  9. class Rectangle  //计算矩形的面积
  10. {
  11. private:
  12.     int w,l;
  13. public :
  14.     Rectangle(int w_,int l_);//析构函数有~ ,析构函数不能进行重载
  15.     void Init(int w_,int l_); //成员函数：函数与C与几乎一致
  16.     int  Sget(); //可以通过行为改变属性的值
  18. };
  19. Rectangle::Rectangle(int w_,int l_)//构造函数
  20. {
  21.     w=w_;
  22.     l=l_;
  23. }
  24. void Rectangle::Init(int w_,int l_)  //归属::行为
  25. {
  26.   w=w_;
  27.   l=l_;
  29. }
  30. int Rectangle::Sget()
  31. {
  32.    return  w*l;
  33. }
  34. int main()
  35. {  
  37.     Rectangle * ptr;
  39.     ptr=new Rectangle(3,4);//通过堆来申请内存chuck
  40.                             //Rectangle r(3,4);//通过栈来传参
  41.     cout <<"面积为："<<ptr->Sget()<< endl;
  43.     return 0;
  44. }

C 类 - 图1```cpp //构造函数的简单分类：空参数，有参数，拷贝构造

include”iostream”

using namespace std;//名称空间 class Rectangle //计算矩形的面积 { public : int w,l;//成员变量，和为对象占用的内存空间 Rectangle(){}; //空参数，比如打印一句话，拷贝构造会是系统默认构造消失，故加上空构造 //Rectangle(int w,int l) 初始化一个对象更为简单 Rectangle(Rectangle p);//拷贝构造 void Init(int w,int l); //成员函数：函数与C与几乎一致 int Sget(); //可以通过行为改变属性的值 }; Rectangle::Rectangle(Rectangle p) { w=p->w; l=p->l; } void Rectangle::Init(int w,int l) //归属::行为 { w=w; l=l; } int Rectangle::Sget() { return w*l; } int main() { int w,l; Rectangle r;//r是一个对象，通过类定义的变量为对象 Rectangle r1; cin >>w >>l; r.Init(w,l); r1.w=3; r1.l=4; Rectangle r2(&r1); cout <<”面积为：”<< r.Sget()<< endl; cout <<”面积为：”<< r1.Sget()<< endl; cout <<”面积为” << r2.Sget()<<endl; return 0; }

  1. ```cpp
  2. //构造函数的简单分类：空参数，有参数，拷贝构造
  3. #include"iostream"
  4. using namespace std;//名称空间
  5. class Rectangle  //计算矩形的面积
  6. {
  7. public :
  8.     int w,l;//成员变量，和为对象占用的内存空间
  9.     Rectangle(){};    //空参数，比如打印一句话
  10.     //Rectangle(int w_,int l_)   初始化一个对象更为简单
  11.     Rectangle(Rectangle *p);//拷贝构造
  12.     void Init(int w_,int l_); //成员函数：函数与C与几乎一致
  13.     int  Sget(); //可以通过行为改变属性的值
  14. };
  15. Rectangle::Rectangle(Rectangle *p)
  16. {
  17. this->w=p->w;//this指向当前函数的对象
  18. this->l=p->l;
  19. }
  20. void Rectangle::Init(int w_,int l_)  //归属::行为
  21. {
  22.   this->w=w_;
  23.   this->l=l_;
  24. }
  25. int Rectangle::Sget()
  26. {
  27.    return this->w*this->l;
  28. }
  29. int main()
  30. {   int w,l;
  31.     Rectangle r;//r是一个对象，通过类定义的变量为对象
  32.     Rectangle r1;
  33.     cin >>w >>l;
  34.     r.Init(w,l);//this指向r
  35.     r1.w=3; //this指向r1
  36.     r1.l=4;
  37.     //Rectangle r2(&r1);
  38.     cout <<"面积为："<< r.Sget()<< endl;
  39.     cout <<"面积为："<< r1.Sget()<< endl;
  40.    // cout <<"面积为" << r2.Sget()<<endl;
  41.     return 0;
  42. }
  1. enum Rectangle_Kind
  2. {
  3.     com_R=0;
  4.     spe_R=1;
  5. };
  6. typedef struct R
  7. {
  8.     enum R_K;
  9.     R_K=com_R;
  10. };
  1. /*!构造函数的简单分类：空参数，有参数，拷贝构造*/
  3. #include"iostream"
  4. using namespace std;//!<名称空间
  5. /**
  6.  * 这是一个计算矩形面积的类
  7.  */
  8. typedef struct R_K
  9. {
  10.   int w,l; /*!two integer value in this struct*/
  11. }
  12. class Rectangle  
  13. {
  14. public :
  15.     int w,l; /*!< two integer value */
  16.     Rectangle(){};    //!< a member function which is Null,but Rectangle(int w_,int l_) 初始化一个对象更为简单
  17.     Rectangle(Rectangle *p);//!<析构函数
  18.     void Init(int w_,int l_); //！<成员函数,初始化长度
  19.     int  Sget(); //！<可以通过行为改变属性的值
  20. };
  21. Rectangle::Rectangle(Rectangle *p)
  22. {
  23. this->w=p->w;
  24. this->l=p->l;
  25. }
  26. void Rectangle::Init(int w_,int l_)  
  27. {
  28.   this->w=w_;
  29.   this->l=l_;
  30. }
  31. int Rectangle::Sget()
  32. {
  33.    return this->w*this->l;
  34. }
  35. int main()
  36. {   int w,l;
  37.     Rectangle r;/*!< this is an object */
  38.     Rectangle r1;
  39.     cin >>w >>l; /*!< input two integer value */
  40.     r.Init(w,l);/*!< this is an ptr point to obj r*/
  41.     r1.w=3; 
  42.     r1.l=4;
  43.     cout <<"r的面积为："<< r.Sget()<< endl;
  44.     cout <<"r1的面积为："<< r1.Sget()<< endl;
  45.     return 0;
  46. }