• C++ 语言学习 day10 复习（1）

    1.
    /********* 探讨权限 ************
     * 权限|位置    类外  类内  派生
     * 公有：       √     √    √
     * 保护：       ×     √    √
     * 私有：       ×     √    ×

     * 总结:
     *      类外：只能访问公有成员
     *      类内：可访问所有成员
     *      派生：无法访问祖先类的私有成员
     *
     * 注意:
     *      C++中权限关键字开始位置就是权限
     *      直到下一个权限关键字或者类结束
     * ****************************/

    ******************************************************
     * 什么时候使用相关权限?
     * 公有:一般想让外界直接访问的之后使用公有权限,类似接口函数
     * 保护:既不想要外部访问,但是又想让派生类继承使用则使用保护权限
     * 私有:只允许内部自己访问,派生无法访问
     * ******************************************************/
     

    2.


    /********* 构造函数 和 析构函数 ***************
     *构造函数:
     *  作用:用于申请空间时初始化处理
     *  定义:
     *      1.函数名与类名相同
     *      2.无返回值
     *      --->通过从上定义规则可以发现,构造函数可以拥有参数,则可实现重载
     *析构函数:
     *  作用:用于销毁时做释放处理
     *  定义:
     *      1.函数名与类名相同,但多了一个~号
     *      2.无参，无返回值
     *      --->然通过以上定义规则发现,析构函数无法重载
     * 注意:
     *  如果用户没有提供构造和析构以及拷贝等函数则编译器默认提供
     *  1.无参构造
     *  2.拷贝构造(浅)
     *  3.析构函数
     *  4.=运算符函数
     * ******************************************/

    代码：

    1. #include <iostream>
    2. #include <string>
    3. using namespace std;
    4.  
    5. /********* 构造函数 和 析构函数 ***************
    6.  *构造函数:
    7.  *  作用:用于申请空间时初始化处理
    8.  *  定义:
    9.  *      1.函数名与类名相同
    10.  *      2.无返回值
    11.  *      --->通过从上定义规则可以发现,构造函数可以拥有参数,则可实现重载
    12.  *析构函数:
    13.  *  作用:用于销毁时做释放处理
    14.  *  定义:
    15.  *      1.函数名与类名相同,但多了一个~号
    16.  *      2.无参，无返回值
    17.  *      --->然通过以上定义规则发现,析构函数无法重载
    18.  * 注意:
    19.  *  如果用户没有提供构造和析构以及拷贝等函数则编译器默认提供
    20.  *  1.无参构造
    21.  *  2.拷贝构造(浅)
    22.  *  3.析构函数
    23.  *  4.=运算符函数
    24.  * ******************************************/
    26. class People
    27. {
    28. public:
    29.     People();   /*无参构造*/
    30.     People(string name,int age,string sex = "女");   /*带参构造*/
    31.     People(const People &people);                    /*拷贝构造*/
    32.  
    33.     ~People();  /*析构函数*/
    34. public:
    35.     void Print() const;/*接口函数*/
    36.     void operator =(const People &people) /*=号赋值运算符*/
    37.     {
    38.         this->m_name = people.m_name;
    39.         this->m_age = people.m_age;
    40.         this->m_sex = people.m_sex;
    41.         cout << "=号赋值运算符" << endl;
    42.     }
    43. protected:
    44.     string m_name;  /*姓名*/
    45.     int m_age;      /*年龄*/
    46.     string m_sex;   /*性别*/
    47. };
    48. /***** 类外实现 *****/
    49. People::People()    /*无参构造*/
    50. {
    51.     this->m_name = "";
    52.     this->m_age = 0;
    53.     this->m_sex = "女";
    54.     cout << "无参构造" << endl;
    55. }
    56.  
    57. People::People(string name,int age,string sex)/*带参构造*/
    58. {
    59.     this->m_name = name;
    60.     this->m_age = age;
    61.     this->m_sex = sex;
    62.     cout << "带参构造" << endl;
    63. }
    64.  
    65. People::People(const People &people) /*拷贝构造*/
    66. {
    67.     this->m_name = people.m_name;
    68.     this->m_age = people.m_age;
    69.     this->m_sex = people.m_sex;
    70.     cout << "拷贝构造" << endl;
    71. }
    72.  
    73. People::~People()  /*析构函数*/
    74. {
    75.     cout << "析构函数" << endl;
    76. }
    77.  
    78. void People::Print() const
    79. {
    80.     cout << "\t姓名:" << this->m_name
    81.          << "\t年龄:" << this->m_age
    82.          << "\t性别:" << this->m_sex
    83.          << endl;
    84. }
    85.  
    86. int main()
    87. {
    88.     /*1.实例化对象*/
    89.     People people1;                   /* 默认调用无参 */
    90.  
    91.     People people2("张三",18,"男");    /*带参构造*/
    92.     People people3("李四",17);        /*带参构造*/
    93.  
    94.     People people4(people2);    /*拷贝构造*/
    95.  
    96.     People people5 = people2;   /*拷贝构造*/
    97.     people5 = people3;          /*=号赋值运算符*/
    98.     /********* 输出结果内容 **********/
    99.     cout << "\npeople1:" << endl;
    100.     people1.Print();
    101.  
    102.     cout << "\npeople2:" << endl;
    103.     people2.Print();
    104.  
    105.     cout << "\npeople3:" << endl;
    106.     people3.Print();
    107.  
    108.     cout << "\npeople4:" << endl;
    109.     people4.Print();
    110.  
    111.     cout << "\npeople5:" << endl;
    112.     people5.Print();
    113.     return 0;
    114. }

    3.
    /*********** 浅拷贝 Vs 深拷贝 *************************
     *浅拷贝: 是值拷贝,针对指针变量,则都是指向到同一片内存空间地址
     *      会造成:①一个操作多个对象 ②多次析构照成程序崩溃
     *深拷贝: 在堆区申请空间的操作都要实现
     *      注意：一般牵扯指针操作,都会自己实现深拷贝
     ****************************************************/

    代码：

    1. #include <iostream>
    2. #include <string>
    3. using namespace std;
    4.  
    5. /*********** 浅拷贝 Vs 深拷贝 *************************
    6.  *浅拷贝: 是值拷贝,针对指针变量,则都是指向到同一片内存空间地址
    7.  *      会造成:①一个操作多个对象 ②多次析构照成程序崩溃
    8.  *深拷贝: 在堆区申请空间的操作都要实现
    9.  *      注意：一般牵扯指针操作,都会自己实现深拷贝
    10.  ****************************************************/
    11. class A{
    12. public:
    13.     A(){cout << "A的构造函数" <<endl;}
    14.     ~A(){cout << "A的析构函数" <<endl;}
    15.     string name[1000];
    16. };
    17.  
    18. class People
    19. {
    20. public:
    21.     People()
    22.     {
    23.         a = new A;  /*申请*/
    24.     }
    25.     /******** 深拷贝 ********/
    26.     People(const People &people)
    27.     {
    28.         /*** 重新申请空间,并修改指向 ***/
    29.         this->a = new A;  /*申请空间,修改指向*/
    30.         *this->a = *people.a;/*拷贝内容到新的空间*/
    31.         cout << "深拷贝构造函数" << endl;
    32.     }
    33.  
    34.     ~People()
    35.     {
    36.         delete a;   /*释放*/
    37.     }
    38. public:
    39.     A *a;    /* 类成员指针 */
    40. };
    41.  
    42.  
    43. int main()
    44. {
    45.     /***** 打印大小 *****/
    46.     cout << "sizeof(string) = " << sizeof(string) << endl;
    47.     cout << "sizeof(A) = " << sizeof(A) << endl;
    48.     cout << "sizeof(People) = " << sizeof(People) << endl;
    49.     /***** 1.实例化对象 ****/
    50.     People *people = new People;
    51.  
    52.     people->a->name[0] = "张三";
    53.  
    54.  
    55.     People people1(*people); /* 拷贝构造 */
    56.     people1.a->name[0] = "李四";
    57.  
    58.     cout << "people->a->name[0]" << people->a->name[0] << endl;
    59.     cout << "people1.a->name[0]" << people1.a->name[0] << endl;
    60.  
    61.     delete people;
    62.     return 0;
    63. }

    4.

    /****** 程序的执行顺序(初始化顺序) **************
     * 1.自上而下
     * 2.从左往右
     * 总结:初始化列表不会影响正常初始化顺序
     * 总结:析构顺序与初始化顺序相反
     * *****************************************/

    代码：

    other.h

    1. #ifndef OTHER_H
    2. #define OTHER_H
    3. #include <iostream>
    4. using namespace std;
    5.  
    6. class A{
    7. public:
    8.     A(){cout << __func__<< endl;}
    9.     A(int xx){cout << __func__<< endl;}
    10.     ~A(){cout << __func__<< endl;}
    11. };
    12.  
    13. class B{
    14. public:
    15.     B(){cout << __func__<< endl;}
    16.     B(int xx){cout << __func__<< endl;}
    17.     ~B(){cout << __func__<< endl;}
    18. };
    19.  
    20. class C{
    21. public:
    22.     C(){cout << __func__<< endl;}
    23.     ~C(){cout << __func__<< endl;}
    24. };
    25.  
    26. class D{
    27. public:
    28.     D(){cout << __func__<< endl;}
    29.     ~D(){cout << __func__<< endl;}
    30. };
    31.  
    32. /**** 人类中包含A和B *****/
    33. class People : public C,public D{
    34. public:
    35.     People()
    36.     :b(20),a(10)/*初始化列表 父类构造 -> 成员*/
    37.     {cout << __func__<< endl;}
    38.     ~People(){cout << __func__<< endl;}
    39. public:
    40.     A a;
    41.     B b;
    42. };
    43.  
    44. class Student
    45. {
    46. public:
    47.     Student(string name,int age)
    48.         :m_name(name),m_age(age)
    49.     {
    50.  
    51.     }
    52. public:
    53.     string m_name;
    54.     int m_age;
    55. };
    56.  
    57. #endif // OTHER_H

    main.c

    1. #include <iostream>
    2. #include "Other.h"
    3. using namespace std;
    4. /****** 程序的执行顺序(初始化顺序) **************
    5.  * 1.自上而下
    6.  * 2.从左往右
    7.  * 总结:初始化列表不会影响正常初始化顺序
    8.  * 总结:析构顺序与初始化顺序相反
    9.  * *****************************************/
    10. int main()
    11. {
    12.     /*1.实例化People */
    13.     People people; // C -> D -> A -> B -> People
    14.  
    15.     Student stu("张三",18);
    16.     cout << stu.m_name << "\t" << stu.m_age << endl;
    17.  
    18.     return 0;
    19. }/* 调用析构: ~People -> ~B -> ~A -> ~D -> ~C */

    5.

    /******** 常量成员 ***************************************
     * 通过前面的铺垫,我们初始化列表专门给常量成员做初始化操作
     * 分类:
     *      常量成员属性：
     *          定义:在变量名之前加 const
     *          作用:只初始化赋值一次,以后无法更改,必须由 "初始化列表" 操作
     *      常量成员函数:
     *          定义:在函数参数后加 const
     *          作用:该函数不可修改类成员属性值,只可访问
     *              自己在函数中定义的变量可以修改
     *          注意:一般读取函数都会写成const常函数
     *
     *      常对象只能访问常函数,后面set容器存放的都会变成常对象
     * *****************************************************/

    代码：

    1. #include <iostream>
    2.  
    3. using namespace std;
    4. /******** 常量成员 ***************************************
    5.  * 通过前面的铺垫,我们初始化列表专门给常量成员做初始化操作
    6.  * 分类:
    7.  *      常量成员属性：
    8.  *          定义:在变量名之前加 const
    9.  *          作用:只初始化赋值一次,以后无法更改,必须由 "初始化列表" 操作
    10.  *      常量成员函数:
    11.  *          定义:在函数参数后加 const
    12.  *          作用:该函数不可修改类成员属性值,只可访问
    13.  *              自己在函数中定义的变量可以修改
    14.  *          注意:一般读取函数都会写成const常函数
    15.  *
    16.  *      常对象只能访问常函数,后面set容器存放的都会变成常对象
    17.  * *****************************************************/
    18. class People
    19. {
    20. public:
    21.     People():value(10)
    22.     {
    23.  
    24.     }
    25. public:
    26.     /**** 成员属性 ****/
    27.     const int value;
    28.     int m_temp;
    29. public:
    30.     /**** 成员函数 ****/
    31.     void Print() const
    32.     {
    33.         /* 访问 */
    34.         cout << "value = " << value << endl;
    35.         cout << "m_temp = " << m_temp << endl;
    36.         /* 修改 */
    37.         //m_temp = 500;
    38.         /* 自定义函数变量可修改 */
    39.         int xxx = 10;
    40.         xxx = 50;
    41.     }
    42.  
    43.     void SetTemp(int temp)
    44.     {
    45.         m_temp = temp;
    46.     }
    47.     int temp() const;
    48. };
    49.  
    50.  
    51. int main()
    52. {
    53.     People people;
    54.     people.Print(); /* 调用 const 成员函数 */
    55.     people.SetTemp(50);/* 调用 非const 成员函数 */
    56.  
    57.     const People peo;
    58.     peo.Print();/* 调用 const 成员函数 */
    59.     //peo.SetTemp(50);/* 调用 非const 成员函数 */ 报错: 常对象只能调用常函数
    60.  
    61.     return 0;
    62. }
    63.  
    64.  
    65. int People::temp() const
    66. {
    67.     return m_temp;
    68. }

    6.

    /********** this 指针和空指针 *********
     * 都是指向到自己的指针
     * *********************************/

    代码：

    1. #include <iostream>
    2.  
    3. using namespace std;
    4. class People
    5. {
    6. public:
    7.     People(string name = "wu",int age = 0) : m_name(name),m_age(age){}    /* 构造函数 */
    8.     void Print();
    9.     void SetValue(int value);
    10. public:
    11.     string m_name;
    12.     int m_age;
    13.     int value;  /*注意这个成员*/
    14. };
    15.  
    16. /********** this 指针和空指针 *********
    17.  * 都是指向到自己的指针
    18.  * *********************************/
    20. void People::Print()
    21. {
    22.     /**** this指针案例 ****/
    23.     cout << "name = " << this->m_name << endl;
    24.     printf("this = %p\n",this);
    25.  
    26.     /**** 空指针案例 : 会造成同名问题,所以使用this指针解决*****/
    27.     cout << "name = " << m_name << endl;
    28.     cout << "value = " << value << endl;
    29. }
    30.  
    31. /** 发现类成员属性名与函数参数名重名 **/
    32. /** 根据调用优先级规则,谁定义得近调用谁**/
    33. void People::SetValue(int value)
    34. {
    35.     /** 在这里设置会不产生任何效果:因为 value是栈自己定义的会随着销毁 **/
    36.     value = value;
    37.     /** 可以 使用this指针解决该问题 **/
    38.     this->value = value;
    39. }
    40.  
    41. int main()
    42. {
    43.     People people;
    44.     people.SetValue(500);
    45.     people.Print();
    46.  
    47.     People *ptr = &people;
    48.     printf("ptr = %p\n",ptr);
    49.  
    50.     return 0;
    51. }

    7.

    /********  静态成员特征 *********
     * 公有特征:
     *      1.可以通过对象 或 类名访问
     *      2.所有对象公用同一静态变量空间
     *
     * 静态成员属性:
     *      注意:类内声明,类外初始化
     *      常用:用作数据记录
     *      须知:
     *          1.所有对象共享同一份数据
     *          2.空间在编译阶段就已经分配
     *          3.静态成员不占用对象空间
     * 静态成员函数:类内声明类外实现也可以,类内实现也可以
     *      注意:静态成员函数不能使用非静态成员,所以也不能访问this指针
     *      常用:接口处理(数据集,固定参数"串口参数,摄像头参数,音频参数,网络参数等")
     *
     * ***************************/

    代码：

    1. #include <iostream>
    2. #include <string>
    3. using namespace std;
    4.  
    5. class People
    6. {
    7. public:
    8.     People(){
    9.         s_value++;
    10.     }
    11. public: /* 成员函数 */
    12.     static void GetValue()  /* 静态成员函数 */
    13.     {
    14.         cout << "我是静态成员函数" << endl;
    15.         cout << "s_value = " << s_value << endl;
    16.         //cout << "m_value = " << m_value << endl; 报错:静态成员函数不能使用非静态成员
    17.     }
    18.  
    19.     static string GetIP()
    20.     {
    21.         return "IPV4 192.168.1.100";
    22.     }
    23.  
    24.     static int GetMax(int value1,int value2)
    25.     {
    26.         return value1 > value2 ? value1 : value2;
    27.     }
    28.  
    29. public: /* 成员属性 */
    30.     static int s_value;    /*静态成员属性:类内声明,类外初始化*/
    31.     int m_value;
    32. };
    33. /********  静态成员特征 *********
    34.  * 公有特征:
    35.  *      1.可以通过对象 或 类名访问
    36.  *      2.所有对象公用同一静态变量空间
    37.  *
    38.  * 静态成员属性:
    39.  *      注意:类内声明,类外初始化
    40.  *      常用:用作数据记录
    41.  *      须知:
    42.  *          1.所有对象共享同一份数据
    43.  *          2.空间在编译阶段就已经分配
    44.  *          3.静态成员不占用对象空间
    45.  * 静态成员函数:类内声明类外实现也可以,类内实现也可以
    46.  *      注意:静态成员函数不能使用非静态成员,所以也不能访问this指针
    47.  *      常用:接口处理(数据集,固定参数"串口参数,摄像头参数,音频参数,网络参数等")
    48.  *
    49.  * ***************************/
    51. /** 静态成员属性类外初始化 **/
    52. int People::s_value = 0;
    53.  
    54.  
    55. int main()
    56. {
    57.     /* 1.实例化对象 */
    58.     //People people;
    59.  
    60.     /* 2.调用对象 */
    61.     /* 2.1 实例对象调用静态成员 */
    62.     //cout << people.s_value << endl;
    63.  
    64.     /* 2.2 通过类名调用静态成员 */
    65.     //cout << People::s_value << endl;
    66.     //People::GetValue();
    67.  
    68.     /* 2.3 通常静态成员属性做记录数据 */
    69.     //cout << "当前女娲造人:" << People::s_value << endl;
    70.     //{People people;}
    71.     //cout << "当前女娲造人:" << People::s_value << endl;
    72.     //{People people;}
    73.     //cout << "当前女娲造人:" << People::s_value << endl;
    74.     //{People people;}
    75.     //cout << "当前女娲造人:" << People::s_value << endl;
    76.     //{People people;}
    77.     //cout << "当前女娲造人:" << People::s_value << endl;
    78.  
    79.     /* 2.4 通常静态函数做接口使用 */
    80.     cout << People::GetIP() << endl;
    81.  
    82.     cout << People::GetMax(10,20) << endl;
    83.  
    84.     /* 2.5 静态成员不占用类空间 */
    85.     cout << "sizeof(People) = " << sizeof(People) << endl;
    86.  
    87.     /* 3.销毁对象 */
    88.  
    89.     return 0;
    90. }

  • 相关阅读:
    英文ppt怎么翻译成中文？教你几种ppt翻译方法
    李峋同款爱心代码！跳动的心，给你爱的人一个惊喜！
    MySQL基本操作之数据库设计理论
    Vue 显示关键词附近内容并高亮显示关键词
    羧甲基壳聚糖-丙硫菌唑水凝胶微球/壳聚糖/磷酸甘油盐温敏性水凝胶/石墨烯壳聚糖复合水凝胶
    APIAuto——敏捷开发最强大易用的 HTTP 接口工具 （二）
    LeetCode537
    前端工程化：保姆级教学 Jenkins 部署前端项目
    kafka本地安装报错
    人声分离网站，帮你快速提取视频中的人声和背景音乐
  • 原文地址：https://blog.csdn.net/she666666/article/details/127988702