• C++学习day4

    作业：

    1> 思维导图

     2> 整理代码

    1. 拷贝赋值函数课上代码

    1. //拷贝赋值函数课上代码
    2. #include
    3. using namespace std;
    4.  
    5. //创建类
    6. class Stu
    7. {
    8. private://私有的
    9.     string name;
    10.     int socer;
    11.     int *age;//此处注意用到指针类型
    12. public://共有的
    13.     //无参构造函数（系统默认设置）
    14.     Stu()
    15.     {
    16.         cout << "Stu:: 无参构造函数 " << endl;
    17.  
    18.     }
    19.     //有参构造函数（自定义，自定义后需要将无参构造函数显性）
    20.     Stu(string n,int s,int a):name(n),socer(s),age(new int (a))//初始化列表
    21.     {
    22.         cout << "Stu:: 有参构造函数" << endl;
    23.  
    24.     }
    25.     //拷贝构造函数
    26.     Stu(const Stu &other):name(other.name),socer(other.socer),age(new int(*other.age))//此处注意*other.age：因为定义是指针类型所以要去指针指向的内容进行赋值
    27.     {
    28.         cout << "Stu:: 拷贝构造函数" << endl;
    29.     }
    30.     //拷贝赋值函数
    31.     Stu &operator=(const Stu &other) //此处不能用初始化列表因为是赋值操作
    32.     {
    33.         if(this != &other)//给自己赋值多此一举
    34.         {
    35.             name=other.name;
    36.             socer=other.socer;
    37.             age = new int (*other.age);//深拷贝赋值因为有指针防止段错误。。。
    38.         }
    39.         cout << "Stu:: 拷贝赋值函数" << endl;
    40.         //注意返回值是自身引用
    41.         return *this;
    42.     }
    43.     //析构函数
    44.     ~Stu()//会自动调用
    45.     {
    46.         cout << "Stu:: 析构函数" << endl;
    47.     }
    48.  
    49. };
    50. int main()
    51. {
    52.     Stu s1;//无参构造函数
    53.     Stu s2("王一博",100,23);//有参构造函数
    54.     Stu s3(s2); //拷贝构造函数====》将s2拷贝给s3==》Stu s3=s2
    55.  
    56.  
    57.     s1=s3;//拷贝赋值
    58.     return 0;
    59. }

     2.匿名对象（用来初始化有名对象）课上代码

    1. void fun(Stu g)//形参接收实参的值==》Stu g=Stu("lisa",120,25)
    2. {
    3.  
    4. }
    5. int main()
    6. {
    7.     Stu s1;//无参构造函数
    8.     Stu s2("王一博",100,23);//有参构造函数
    9.     Stu s3(s2); //拷贝构造函数====》将s2拷贝给s3==》Stu s3=s2
    10.  
    11.     //用到匿名对象给有名对象初始化
    12.     Stu s4=Stu("赵云",88,40);
    13.     //给数组初始化
    14.     Stu s[2]={Stu("哪吒",200,40),Stu("张飞",300,30)};//和c中初始化相似
    15.     //匿名对象作为函数实参使用
    16.     fun(Stu("lisa",120,25));
    17.  
    18.  
    19.     s1=s3;//拷贝赋值
    20.     return 0;
    21. }

     3.全局函数作友元,课上代码

    1. //友元上课代码（全局函数作友元）
    2. #include 
    3. using namespace std;
    4. //封装 房间类
    5. class Room
    6. {
    7.     friend void goodfriend(Room &r);//关键字：friend
    8. private://私有的
    9.     string bedroom;//卧室
    10. public://共有的
    11.     string sittingroom;//客厅
    12. public:
    13.     Room()
    14.     {
    15.         //在类内赋值
    16.         bedroom="卧室";
    17.         sittingroom="客厅";
    18.     }
    19. };
    20. //全局函数作友元
    21. void goodfriend(Room &r)
    22. {
    23.     cout << "好朋友正在参观" << r.sittingroom << endl;//共有权限访问成功毋庸置疑
    24.     cout << "好朋友正在参观" << r.bedroom << endl;//报错原因：私有权限类外不可访问，需要用友元
    25. }
    26.  
    27. int main()
    28. {
    29.    Room r;
    30.    goodfriend(r);
    31.    return 0;
    32. }

    4.成员函数作友元，课上代码

    1. //成员函数作友元
    2. #include 
    3. using namespace std;
    4. class Room;//需要声明一下，以免下面用到系统不知道报错
    5. //封装好朋友类
    6. class goodfriend
    7. {
    8. private:
    9.     Room *r;//用到指针是因为指针的大小是固定的，而变量的大小不明，系统无法分配空间
    10. public:
    11.     goodfriend();//在类内声明
    12.     void vist();//在类内声明
    13. };
    14.  
    15. //封装 房间类
    16. class Room
    17. {/*
    18.     friend void goodfriend(Room &r);//关键字：friend*/
    19.     friend void goodfriend::vist();
    20. private://私有的
    21.     string bedroom;//卧室
    22. public://共有的
    23.     string sittingroom;//客厅
    24. public:
    25.     Room()
    26.     {
    27.         //在类内赋值
    28.         bedroom="卧室";
    29.         sittingroom="客厅";
    30.     }
    31. };
    32. //类外实现
    33. goodfriend::goodfriend()
    34. {
    35.     r=new Room;//申请空间
    36. }
    37. void goodfriend::vist()
    38. {
    39.     cout  << "好朋友正在参观" << r->sittingroom << endl;//共有权限访问成功毋庸置疑
    40.     cout << "好朋友正在参观" << r->bedroom << endl;//报错原因：私有权限类外不可访问，需要用友元
    41.     //指针需要用->
    42. }
    43.  
    44.  
    45.  
    46.  
    47.  
    48. 全局函数作友元
    49. //void goodfriend(Room &r)
    50. //{
    51. //    cout << "好朋友正在参观" << r.sittingroom << endl;//共有权限访问成功毋庸置疑
    52. //    cout << "好朋友正在参观" << r.bedroom << endl;//报错原因：私有权限类外不可访问，需要用友元
    53. //}
    54.  
    55. int main()
    56. {
    57.    Room r;
    58.    //goodfriend(r);
    59.    goodfriend g;
    60.    g.vist();
    61.    return 0;
    62. }

     5.课前热身

    1. int const a; //......
    2. int const *p; //......
    3. int * const p; //
    4. int const * const p; //
    5. const int fun() {}  //该函数是返回一个常整型变量

     6.常成员函数&&非常成员函数

    1.非常对象可以调用常成员函数，也可以调用非常成员函数，优先调用非常成员函数

    2.常对象只能调用常成员函数，如果没有常成员函数，则报错

    1. #include 
    2. using namespace std;
    3. class Stu
    4. {
    5. private:
    6.     string name;//只对该成员变量在常成员函数中可以被修改mutable
    7.     int id;
    8. public:
    9.     Stu(){}
    10.     Stu(string name,int id):name(name),id(id)
    11.     {}
    12.     //常成员函数
    13.     void display()const //==》Stu const * const this;表示指针的值和指向都不可改
    14.     {
    15.         //this ->name ="li si";报错原因：因为被const修饰不可以更改
    16.         cout << name << " " << id <
    17.     }
    18.     //非常成员函数
    19.     void display()//==>Stu * const this;和常成员重载
    20.     {
    21.         this -> name ="lisi";
    22.         cout << name << " " << id << endl;
    23.     }
    24.  
    25. };
    26.  
    27. int main()
    28. {
    29.     cout << "Hello World!" << endl;
    30.     const Stu s1("zhangsan",1001);//常对象
    31.     s1.display();//常对象只能调用常成员函数
    32.     return 0;
    33. }

     7.成员函数来实现运算符重载

    1. //运算符重载
    2. #include
    3. using namespace std;
    4.  
    5. //构造类
    6. class Club
    7. {
    8. private://私有的
    9.     int age;
    10.     int hight;
    11. public:
    12.     //无参
    13.     Club(){}
    14.     Club(int a,int h):age(a),hight(h)
    15.     {
    16.  
    17.     }
    18.     //成员函数实现算数运算符重载 加法
    19.     const Club operator+(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    20.     {
    21.         //内部运算
    22.         Club temp;
    23.         temp.age=age+R.age;
    24.         temp.hight=hight+R.hight;
    25.  
    26.         return temp;
    27.     }
    28.     //成员函数实现算数运算符重载 减法
    29.     const Club operator-(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    30.     {
    31.         //内部运算
    32.         Club temp;
    33.         temp.age=age-R.age;
    34.         temp.hight=hight-R.hight;
    35.  
    36.         return temp;
    37.     }
    38.     //成员函数实现算数运算符重载 乘法
    39.     const Club operator*(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    40.     {
    41.         //内部运算
    42.         Club temp;
    43.         temp.age=age*R.age;
    44.         temp.hight=hight*R.hight;
    45.  
    46.         return temp;
    47.     }
    48.     //成员函数实现算数运算符重载 除法
    49.     const Club operator/(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    50.     {
    51.         //内部运算
    52.         Club temp;
    53.         temp.age=age/R.age;
    54.         temp.hight=hight/R.hight;
    55.  
    56.         return temp;
    57.     }
    58.     //成员函数实现算数运算符重载 取余
    59.     const Club operator%(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    60.     {
    61.         //内部运算
    62.         Club temp;
    63.         temp.age=age%R.age;
    64.         temp.hight=hight%R.hight;
    65.  
    66.         return temp;
    67.     }
    68. 关系运算符//
    69.     //成员函数实现关系运算符重载 >
    70.     bool operator>(const Club &R)const
    71.     {
    72.         if(age>R.age && hight>R.hight)
    73.         {
    74.             return true;
    75.         }
    76.         else
    77.             return false;
    78.     }
    79.     //成员函数实现关系运算符重载 <
    80.     bool operator<(const Club &R)const
    81.     {
    82.         if(age
    83.         {
    84.             return true;
    85.         }
    86.         else
    87.             return false;
    88.     }
    89.     //成员函数实现关系运算符重载 >=
    90.     bool operator>=(const Club &R)const
    91.     {
    92.         if(age>=R.age && hight>=R.hight)
    93.         {
    94.             return true;
    95.         }
    96.         else
    97.             return false;
    98.     }
    99.     //成员函数实现关系运算符重载 <=
    100.     bool operator<=(const Club &R)const
    101.     {
    102.         if(age<=R.age && hight<=R.hight)
    103.         {
    104.             return true;
    105.         }
    106.         else
    107.             return false;
    108.     }
    109.     //成员函数实现关系运算符重载 ==
    110.     bool operator==(const Club &R)const
    111.     {
    112.         if(age==R.age && hight==R.hight)
    113.         {
    114.             return true;
    115.         }
    116.         else
    117.             return false;
    118.     }
    119.  
    120.     //成员函数实现关系运算符重载 >
    121.     bool operator!=(const Club &R)const
    122.     {
    123.         if(age!=R.age && hight!=R.hight)
    124.         {
    125.             return true;
    126.         }
    127.         else
    128.             return false;
    129.     }
    130.     //赋值运算符
    131.     //成员函数实现赋值运算符重载 +=
    132.    Club &operator+=(const Club &R)
    133.     {
    134.         age += R.age;
    135.         hight += R.hight;
    136.         return *this;//返回自身
    137.     }
    138.    //成员函数实现赋值运算符重载 -=
    139.    Club &operator-=(const Club &R)
    140.     {
    141.         age -= R.age;
    142.         hight -= R.hight;
    143.         return *this;//返回自身
    144.     }
    145.    //成员函数实现赋值运算符重载 =
    146.    Club &operator=(const Club &R)
    147.     {
    148.         age = R.age;
    149.         hight = R.hight;
    150.         return *this;//返回自身
    151.     }
    152.    //成员函数实现赋值运算符重载 *=
    153.    Club &operator*=(const Club &R)
    154.     {
    155.         age *= R.age;
    156.         hight *= R.hight;
    157.         return *this;//返回自身
    158.     }
    159.    //成员函数实现赋值运算符重载 /=
    160.    Club &operator/=(const Club &R)
    161.     {
    162.         age /= R.age;
    163.         hight /= R.hight;
    164.         return *this;//返回自身
    165.     }
    166.    //成员函数实现赋值运算符重载 %=
    167.    Club &operator%=(const Club &R)
    168.     {
    169.         age %= R.age;
    170.         hight %= R.hight;
    171.         return *this;//返回自身
    172.     }
    173.  
    174.  
    175.  
    176.     void show()
    177.     {
    178.         cout << "age= " << age << " " << "hight= " << hight << endl;
    179.     }
    180. };
    181. int main()
    182. {
    183.     Club c1(10,10);
    184.     Club c2(10,10);
    185.  
    186.  
    187.     Club c3=c1+c2;
    188.     Club c4=c1-c2;
    189.     Club c5=c1*c1;
    190.     Club c6=c1/c2;
    191.     Club c7=c1%c2;
    192.  
    193.     cout << "算数运算符" << endl;
    194.     c3.show();
    195.     c4.show();
    196.     c5.show();
    197.     c6.show();
    198.     c7.show();
    199.  
    200.     cout << "关系运算符" << endl;
    201.  
    202.     if(c3!=c1)
    203.     {
    204.         if(c3>c1)
    205.         {
    206.             cout << "c3>c1 " << endl;
    207.         }
    208.         else if(c3
    209.         {
    210.             cout << "c3 << endl;
    211.         }
    212.         cout << "c3!=c1" << endl;
    213.  
    214.     }
    215.     else if(c3 == c1)
    216.     {
    217.  
    218.          if(c3>=c1)
    219.         {
    220.             cout << "c3>=c1" << endl;
    221.         }
    222.         else if(c3<=c1)
    223.         {
    224.             cout << "c3<=c1" << endl;
    225.         }
    226.  
    227.         {
    228.             cout << "c3==c1" << endl;
    229.  
    230.         }
    231.  
    232.     }
    233.  
    234.     cout << "赋值运算符" << endl;//赋值函数不要加类型否则属于初始化会报错
    235.     c3+=c2;
    236.     c4-=c2;
    237.     c5*=c1;
    238.     c6/=c2;
    239.     c7%=c2;
    240.  
    241.     c3.show();
    242.     c4.show();
    243.     c5.show();
    244.     c6.show();
    245.     c7.show();
    246.  
    247.  
    248.     return  0;
    249. }

    效果图:

     8.全局函数实现运算符重载

    1. //运算符重载
    2. #include
    3. using namespace std;
    4.  
    5. //构造类
    6. class Club
    7. {
    8.     friend const Club operator+(const Club &L,const Club &R);
    9.     friend const Club operator-(const Club &L,const Club &R);
    10.     friend const Club operator*(const Club &L,const Club &R);
    11.     friend const Club operator/(const Club &L,const Club &R);
    12.     friend const Club operator%(const Club &L,const Club &R);
    13.     friend bool operator>(const Club &L,const Club &R);
    14.     friend bool operator<(const Club &L,const Club &R);
    15.     friend bool operator<=(const Club &L,const Club &R);
    16.     friend bool operator>=(const Club &L,const Club &R);
    17.     friend bool operator==(const Club &L,const Club &R);
    18.     friend bool operator!=(const Club &L,const Club &R);
    19.     friend Club &operator+=( Club &L,const Club &R);
    20.     friend Club &operator-=( Club &L,const Club &R);
    21.    
    22.     friend Club &operator*=( Club &L,const Club &R);
    23.     friend Club &operator/=(Club &L,const Club &R);
    24.     friend Club &operator%=( Club &L,const Club &R);
    25.     
    26. private://私有的
    27.     int age;
    28.     int hight;
    29. public:
    30.     //无参
    31.     Club(){}
    32.     Club(int a,int h):age(a),hight(h)
    33.     {
    34.         
    35.     }
    36.     
    37.     void show()
    38.     {
    39.         cout << "age= " << age << " " << "hight= " << hight << endl;
    40.     }
    41. };
    42. //成员函数实现算数运算符重载 加法
    43. const Club operator+(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
    44. {
    45.     //内部运算
    46.     Club temp;
    47.     temp.age=L.age-R.age;
    48.     temp.hight=L.hight-R.hight;
    49.  
    50.     return temp;
    51. }
    52.    
    53. //成员函数实现算数运算符重载 减法
    54. const Club operator-(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
    55. {
    56.     //内部运算
    57.     Club temp;
    58.     temp.age=L.age-R.age;
    59.     temp.hight=L.hight-R.hight;
    60.  
    61.     return temp;
    62. }
    63.  
    64. //成员函数实现算数运算符重载 乘法
    65. const Club operator*(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
    66. {
    67.     //内部运算
    68.     Club temp;
    69.     temp.age=L.age*R.age;
    70.     temp.hight=L.hight*R.hight;
    71.  
    72.     return temp;
    73. }
    74. //成员函数实现算数运算符重载 除法
    75. const Club operator/(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
    76. {
    77.     //内部运算
    78.     Club temp;
    79.     temp.age=L.age/R.age;
    80.     temp.hight=L.hight/R.hight;
    81.  
    82.     return temp;
    83. }
    84. //成员函数实现算数运算符重载 取余
    85. const Club operator%(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
    86. {
    87.     //内部运算
    88.     Club temp;
    89.     temp.age=L.age%R.age;
    90.     temp.hight=L.hight%R.hight;
    91.  
    92.     return temp;
    93. }
    94. 关系运算符//
    95. //成员函数实现关系运算符重载 >
    96. bool operator>(const Club &L,const Club &R)
    97. {
    98.     if(L.age>R.age && L.hight>R.hight)
    99.     {
    100.         return true;
    101.     }
    102.     else
    103.         return false;
    104. }
    105. //成员函数实现关系运算符重载 <
    106. bool operator<(const Club &L,const Club &R)
    107. {
    108.     if(L.age>R.age && L.hight
    109.     {
    110.         return true;
    111.     }
    112.     else
    113.         return false;
    114. }
    115. //成员函数实现关系运算符重载 >=
    116. bool operator>=(const Club &L,const Club &R)
    117. {
    118.     if(L.age>=R.age && L.hight>R.hight)
    119.     {
    120.         return true;
    121.     }
    122.     else
    123.         return false;
    124. }
    125. //成员函数实现关系运算符重载 <=
    126. bool operator<=(const Club &L,const Club &R)
    127. {
    128.     if(L.age<=R.age && L.hight>R.hight)
    129.     {
    130.         return true;
    131.     }
    132.     else
    133.         return false;
    134. }
    135. //成员函数实现关系运算符重载 ==
    136. bool operator==(const Club &L,const Club &R)
    137. {
    138.     if(L.age==R.age && L.hight==R.hight)
    139.     {
    140.         return true;
    141.     }
    142.     else
    143.         return false;
    144. }
    145.  
    146. //成员函数实现关系运算符重载 !=
    147. bool operator!=(const Club &L,const Club &R)
    148. {
    149.     if(L.age!=R.age && L.hight>R.hight)
    150.     {
    151.         return true;
    152.     }
    153.     else
    154.         return false;
    155. }
    156. //赋值运算符
    157. //成员函数实现赋值运算符重载 +=
    158. Club &operator+=( Club &L,const Club &R)
    159. {
    160.     L.age += R.age;
    161.     L.hight += R.hight;
    162.     return L;//返回自身
    163. }
    164. //成员函数实现赋值运算符重载 -=
    165. Club &operator-=( Club &L,const Club &R)
    166. {
    167.     L.age -= R.age;
    168.     L.hight -= R.hight;
    169.     return L;//返回自身
    170. }
    171.  
    172. //成员函数实现赋值运算符重载 *=
    173. Club &operator*=( Club &L,const Club &R)
    174. {
    175.     L.age *= R.age;
    176.     L.hight *= R.hight;
    177.     return L;//返回自身
    178. }
    179. //成员函数实现赋值运算符重载 /=
    180. Club &operator/=( Club &L,const Club &R)
    181. {
    182.     L.age /= R.age;
    183.     L.hight /= R.hight;
    184.     return L;//返回自身
    185. }
    186. //成员函数实现赋值运算符重载 %=
    187. Club &operator%=(Club &L,const Club &R)
    188. {
    189.     L.age /= R.age;
    190.     L.hight /= R.hight;
    191.     return L;//返回自身
    192. }
    193.  
    194.  
    195. int main()
    196. {
    197.     Club c1(10,10);
    198.     Club c2(10,10);
    199.  
    200.  
    201.     Club c3=c1+c2;
    202.     Club c4=c1-c2;
    203.     Club c5=c1*c1;
    204.     Club c6=c1/c2;
    205.     Club c7=c1%c2;
    206.  
    207.     cout << "算数运算符" << endl;
    208.     c3.show();
    209.     c4.show();
    210.     c5.show();
    211.     c6.show();
    212.     c7.show();
    213.  
    214.     cout << "关系运算符" << endl;
    215.  
    216.     if(c3!=c1)
    217.     {
    218.         if(c3>c1)
    219.         {
    220.             cout << "c3>c1 " << endl;
    221.         }
    222.         else if(c3
    223.         {
    224.             cout << "c3 << endl;
    225.         }
    226.         cout << "c3!=c1" << endl;
    227.  
    228.     }
    229.     else if(c3 == c1)
    230.     {
    231.  
    232.          if(c3>=c1)
    233.         {
    234.             cout << "c3>=c1" << endl;
    235.         }
    236.         else if(c3<=c1)
    237.         {
    238.             cout << "c3<=c1" << endl;
    239.         }
    240.  
    241.         {
    242.             cout << "c3==c1" << endl;
    243.  
    244.         }
    245.  
    246.     }
    247.  
    248.     cout << "赋值运算符" << endl;//赋值函数不要加类型否则属于初始化会报错
    249.     c3+=c2;
    250.     c4-=c2;
    251.     c5*=c1;
    252.     c6/=c2;
    253.     c7%=c2;
    254.  
    255.     c3.show();
    256.     c4.show();
    257.     c5.show();
    258.     c6.show();
    259.     c7.show();
    260.  
    261.  
    262.     return  0;
    263. }

  • 相关阅读:
    【高等数学基础进阶】导数与微分
    Java代码审计-SQL注入
    麦子-linux字符设备驱动初探
    go语言编译过程概述
    科研-聚苯乙烯-b-聚丙烯酸胶束血红蛋白组装/牛血清白蛋白聚苯乙烯纳米微球PS/BSA
    ​LeetCode解法汇总337. 打家劫舍 III
    【STM32】读写内部Flash初步使用
    使用Shiro实现权限验证
    会stm32有机会进大公司吗？
    linux操作系统有什么好处？
  • 原文地址：https://blog.csdn.net/m0_69894626/article/details/133753028