• C++核心编程之类和对象---对象特性--- 构造函数和析构函数(对象的初始化和清理)

    目录

    一、构造函数和析构函数(对象的初始化和清理)

    作用

    功能实现

    二、构造函数

    语法：类名 () {}

    三、析构函数

    语法  ~类名(){}

    四、构造函数的分类及调用

    五、拷贝构造函数的调用时机

    六、构造函数调用规则

    七、深拷贝与浅拷贝的问题        

    八、初始化列表

    九、类对象作为类成员

    十、静态成员

    1.静态成员分类

    2.静态成员变量

    3.静态成员函数

    一、构造函数和析构函数(对象的初始化和清理)

    对象的初始化和清理

            生活中我们买的电子产品都基本会有出厂设罩，在某一天我们不用时候也会删除一些自己信息数据保证安全

            C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。

    作用

            一个对象或者变量没有初始状态，对其使用后果是未知的，

            同样的使用完一个对象或变量没有及时清理，也会造成一定的安全问题

    功能实现

            C++利用构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作对象的初始化和清理工作是编译器强制我们要做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。

            

    • 构造函数：主要作用于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用
    • 析构函数：主要作用于对象销毁前系统自动调用，执行一些清理工作

     

    二、构造函数

    语法：类名 () {}

    • 构造函数，没有返回值也不写void
    • 函数名称与类名相同
    • 构造函数可以有参数，因此可以发生重载
    • 程序调用对象的时候会自动调用构造函数，无须手动调用，而且只会调用一次

    示例：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. class person{
    6.  
    7. public:// 在公共作用域下在主函数才能访问到
    8.  
    9.     // 构造函数
    10.  
    11. person()
    12.  
    13.     {
    14.  
    15.         // 在创建一个对象的时候会自动调用一次
    16.  
    17.         cout<<"person 构造函数的调用"<
    18.  
    19.     }
    20.  
    21. };
    22.  
    23. int main ()
    24.  
    25. {
    26.  
    27.     person p;
    28.  
    29.     return 0;
    30.  
    31. }

    运行结果：

     

    三、析构函数

    语法  ~类名(){}

    • 析构函数，没有返回值也不写void
    • 函数名称与类名相同称
    • 析构函数不可以有参数，因此不可以发生重载
    • 程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

    示例：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. class person{
    6.  
    7. public:// 在公共作用域下在主函数才能访问到
    8.  
    9.     // 析构函数
    10.  
    11.     ~person ()
    12.  
    13.     {
    14.  
    15.         cout<<"析构函数的调用"<
    16.  
    17.     }
    18.  
    19. };
    20.  
    21. void test()
    22.  
    23. {
    24.  
    25.     person p; // 在栈上的数据，在test执行完毕后就会释放这个对象
    26.  
    27. }
    28.  
    29. int main ()
    30.  
    31. {
    32.  
    33.     person p1;  // 在main函数中也会在整个程序中执行完的时候执行
    34.  
    35.     return 0;
    36.  
    37. }

    运行结果：

    四、构造函数的分类及调用

    两种分类方式：

    •         按参数分为：有参构造和无参构造
    •         按类型分为：普通构造和拷贝构造

    三种调用方式：

    •         括号法
      •         显示法
        •         隐式转换法

    示例：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. class person {
    6.  
    7. public:
    8.  
    9.     // 构造函数
    10.  
    11.     person() // 无参
    12.  
    13.     {
    14.  
    15.         cout << "person 的无参数的构造函数调用。" << endl;
    16.  
    17.     }
    18.  
    19.     person(int a) // 有参
    20.  
    21.     {
    22.  
    23.         age = a;
    24.  
    25.         cout << "person 的有参数的构造函数调用。" << endl;
    26.  
    27.     }
    28.  
    29.  
    30.  
    31.     // 拷贝构造函数
    32.  
    33.     person(const person& p)
    34.  
    35.     {
    36.  
    37.         // 把另一个person的属性传入进来 +const 防止改变原来的属性
    38.  
    39.         // 将传入的人身上的所有的属性全部拷贝到自己的身上
    40.  
    41.         age = p.age;
    42.  
    43.         cout << "person 的拷贝构造函数调用。" << endl;
    44.  
    45.     }
    46.  
    47.  
    48.  
    49.     // 析构函数
    50.  
    51.     ~person()
    52.  
    53.     {
    54.  
    55.         cout << "person 的析构函数的调用。" << endl;
    56.  
    57.     }
    58.  
    59.     int age;
    60.  
    61. };
    62.  
    63. void test()
    64.  
    65. {
    66.  
    67.     // 调用
    68.  
    69.     // 1. 括号法
    70.  
    71.     cout << "括号法调用" << endl;
    72.  
    73.     person p1; // 默认构造函数调用
    74.  
    75.     // 注意事项1：默认构造函数的调用不要加（）  因为会被认为是一个函数的声明,不会认为在创建对象
    76.  
    77.     person p2(10); // 调用有参构造函数
    78.  
    79.     // 拷贝构造函数的调用
    80.  
    81.     person p3(p2); // 拷贝构造函数的调用
    82.  
    83.  
    84.  
    85.     cout << "p2的年龄：" << p2.age << endl;
    86.  
    87.     cout << "p3的年龄：" << p3.age << endl;
    88.  
    89.     cout << endl;
    90.  
    91.  
    92.  
    93.     // 2. 显示法
    94.  
    95.     cout << "显示法调用" << endl;
    96.  
    97.     person p4; // 默认构造函数
    98.  
    99.     person p5 = person(10); // 有参构造
    100.  
    101.     person p6 = person(p3);  // 拷贝构造
    102.  
    103.     // 右侧相当于匿名对象，当执行结束后系统会立即回收掉匿名对象
    104.     // 注意事项2：不要利用拷贝构造函数 初始化 匿名对象
    105.     // 编译器会认为  person(p3)  === person p3，相当于时对象的声明
    106.  
    107.     cout << endl;
    108.  
    109.  
    110.  
    111.     cout << "测试匿名对象" << endl;
    112.  
    113.     person(10);
    114.  
    115.     cout << "aaa" << endl << endl;
    116.  
    117.  
    118.  
    119.     // 3. 隐式转换法
    120.  
    121.     cout << "隐式转换法调用" << endl;
    122.  
    123.     person p7 = 10; // 相当于person p3 = person(10);是一种有参构造
    124.  
    125.     person p8 = p7;
    126.  
    127.     cout << endl;
    128.  
    129.    }
    130.  
    131. int main()
    132.  
    133. {
    134.  
    135.     test();
    136.  
    137.     return 0;
    138.  
    139.     system("pause");
    140.  
    141. }

    运行结果：

    五、拷贝构造函数的调用时机

    C++中拷贝构造函数调用的时机通常有三种情况：

    • 使用一个已经创建完毕的对象来初始化一个新对象
    • 值传递的方式给函数参数传值
    • 以值方式返回局部对象

    示例：

    1. #include
    2. using namespace std;
    3. // 拷贝函数的三种调用时机
    4. class person {
    5. public:
    6.     person()
    7.     {
    8.         cout << "person 的默认函数构造" << endl;
    9.     }
    10.     // 有参
    11.     person(int in_age)
    12.     {
    13.         age = in_age;
    14.         cout << "有参构造函数" << endl;
    15.     }
    16.     // 拷贝
    17.     person(const person& p)
    18.     {
    19.         age = p.age;
    20.         cout << "拷贝构造函数" << endl;
    21.     }
    22.     // 析构
    23.     ~person()
    24.     {
    25.         cout << "person 的析构函数的调用" << endl;
    26.     }
    27. //private:
    28.     int age;
    29. };
    30.  
    31. // 1. 使用一个已经创建完毕的对象来初始化一个新的对象
    32. void test01()
    33. {
    34.     person p1(20); // 有参构造
    35.     person p2(p1); // 拷贝构造
    36.     cout << "p2的年龄为：" << p2.age << endl;
    37. }
    38.  
    39. // 2.值传递的方式给函数参数传值
    40. void do_work(person p)
    41. {
    42.  
    43. }
    44.  
    45. void test02()
    46. {
    47.     person p;
    48.     do_work(p);
    49. }
    50.  
    51. // 3. 以值的方式返回局部对象
    52. person do_work2()
    53. {
    54.     person p1;
    55.     cout << (int*)&p1 << endl;
    56.     return p1;  // 拷贝一个新的对象用于返回
    57. }
    58.  
    59. void test03()
    60. {
    61.     person p = do_work2(); // 得到的是拷贝的返回值
    62.     cout << (int*)&p << endl;
    63. }
    64.  
    65. int main()
    66. {
    67.     test01();
    68.     cout << endl;
    69.     test02();
    70.     cout << endl;
    71.     test03();
    72.     return 0;
    73. }

    运行结果：

    六、构造函数调用规则

    • 默认情况下，C++编译器至少给一个类添加3个函数
    •         1. 默认构造函数（无参，函数体为空）
    •         2. 默认析构函数（无参，函数体为空）
    •         3. 默认拷贝构造函数，对属性进行值拷贝
    • 构造函数调用规则：
    •         如果写了有参构造函数，编译器就不再提供默认构造函数，但是依然提供拷贝构造函数
    •         如果写了拷贝构造函数，编译器就不再提供默认构造函数和有参构造函数

    示例：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. class person
    6.  
    7. {
    8.  
    9. public:
    10.  
    11.     // 默认
    12.  
    13.     person()
    14.  
    15.     {
    16.  
    17.         cout<<"person 的默认函数构造"<
    18.  
    19.     }
    20.  
    21.  
    22.  
    23.     // 有参
    24.  
    25.     //  如果自己提供了有参构造，编译器就不再提供默认构造
    26.  
    27.     person(int in_age)
    28.  
    29.     {
    30.  
    31.         age = in_age;
    32.  
    33.         cout<<"person 的有参构造函数"<
    34.  
    35.     }
    36.  
    37.  
    38.  
    39.     // 拷贝
    40.  
    41.     // 如果自己不提供，编译器也会提供拷贝函数，值拷贝(两个析构，一个有参)
    42.  
    43.     /*person(const person& p)
    45.     {
    47.         this->age = p.age;
    49.         cout<<"person 的拷贝构造函数"<
    51.     }*/
    52.  
    53.  
    54.  
    55.     // 析构
    56.  
    57.     ~person()
    58.  
    59.     {
    60.  
    61.         cout<<"person 的析构函数的调用"<
    62.  
    63.     }
    64.  
    65.  
    66.  
    67.     int age;
    68.  
    69. };
    70.  
    71. void test01()
    72.  
    73. {
    74.  
    75.     person p;
    76.  
    77.     p.age = 18;
    78.  
    79.  
    80.  
    81.     person p1(p);
    82.  
    83.     cout<<"p1的年龄："<
    84.  
    85. }
    86.  
    87. int main()
    88.  
    89. {
    90.  
    91.     test01();
    92.  
    93.     return 0;
    94.  
    95. }

    运行结果：

     

    七、深拷贝与浅拷贝的问题        

    • 浅拷贝：简单的赋值拷贝操作
    • 深拷贝：在堆区重新申请空间，进行拷贝操作

    浅拷贝带来的问题是堆区的内存重复释放，利用深拷贝来解决。

    示例：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. class person
    6.  
    7. {
    8.  
    9. public:
    10.  
    11.     // 默认
    12.  
    13.     person()
    14.  
    15.     {
    16.  
    17.         cout<<"person 的默认函数构造"<
    18.  
    19.     }
    20.  
    21.  
    22.  
    23.     // 有参
    24.  
    25.     person(int age, double height)
    26.  
    27.     {
    28.  
    29.         this->age = age;
    30.  
    31.         cout<<"person 的有参构造函数"<
    32.  
    33.         this->height = new double(height); // new 一个新的指针变量，创建在堆区
    34.  
    35.     }
    36.  
    37.  
    38.  
    39.     // 拷贝
    40.  
    41.     person(const person & p)
    42.  
    43.     {
    44.  
    45.         this->age = p.age;  // 编译器默认实现
    46.  
    47.         cout<<"person 的拷贝构造函数"<
    48.  
    49.         // this->age = p.height; // 编译器的 拷贝构造默认实现方式
    50.  
    51.  
    52.  
    53.         // 解决浅拷贝带来的问题
    54.  
    55.  
    56.  
    57.         // 两个对象的指针分别设立在不同的存储地址
    58.  
    59.         this->height = new double(*p.height); // 利用深拷贝来解决浅拷贝的问题
    60.  
    61.     }
    62.  
    63.  
    64.  
    65.     // 析构
    66.  
    67.     ~person()
    68.  
    69.     {
    70.  
    71.         // 将我们在堆区开辟的数据做释放操作
    72.  
    73.         if(height !=NULL){
    74.  
    75.             delete height;
    76.  
    77.             height = NULL;
    78.  
    79.         }
    80.  
    81.         cout<<"person 的析构函数的调用"<
    82.  
    83.     }
    84.  
    85.    
    86.  
    87.     int age;
    88.  
    89.     double * height; // 身高数据的地址
    90.  
    91.  
    92.  
    93.     // 编译器提供的拷贝构造函数 会做浅拷贝处理  会重复释放
    94.  
    95.     // 身高是定义在堆区的，指针类型的存储的是地址，不能重复释放
    96.  
    97. };
    98.  
    99. void test01()
    100.  
    101. {
    102.  
    103.     person p1(18,1.80);
    104.  
    105.     cout<<"p1的年龄为： "<
    106.  
    107.     cout<<"p1的身高为："<<*p1.height<
    108.  
    109.  
    110.  
    111.     person p2(p1);
    112.  
    113.     cout<<"p2的年龄为："<
    114.  
    115.     cout<<"p2的身高为："<<*p2.height<
    116.  
    117. }
    118.  
    119. int main()
    120.  
    121. {
    122.  
    123.     test01();
    124.  
    125.     return 0;
    126.  
    127. }

    运行结果：

     

    八、初始化列表

    作用：C++提供了初始化列表语法，用来初始化属性。

    语法 ： 构造函数（）：属性1（值1），属性2（值2）... {}

    示例：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. class person
    6.  
    7. {
    8.  
    9. public:
    10.  
    11.     // 传统初始化操作
    12.  
    13.     /*person(int a ,int b,int c)
    15.     {
    17.         A = a;
    19.         B = b;
    21.         C = c;
    23.     }*/
    24.  
    25.  
    26.  
    27.     // 初始化列表属性,赋值默认值
    28.  
    29.     /*person():A(10),B(20),C(30)
    31.     {
    33.  
    35.     }*/
    36.  
    37.  
    38.  
    39.     // 设置成变量
    40.  
    41.     person(int a,int b,int c):A(a),B(b),C(c)
    42.  
    43.     {
    44.  
    45.  
    46.  
    47.     }
    48.  
    49.  
    50.  
    51.     int A;
    52.  
    53.     int B;
    54.  
    55.     int C;
    56.  
    57. };
    58.  
    59. void test01()
    60.  
    61. {
    62.  
    63.     // 每次调用一种
    64.  
    65.     person p(10,20,30);
    66.  
    67.     cout<<"A = "<
    68.  
    69.     cout<<"B = "<
    70.  
    71.     cout<<"C = "<
    72.  
    73.  
    74.  
    75. }
    76.  
    77. int main()
    78.  
    79. {
    80.  
    81.     test01();
    82.  
    83.     return 0;
    84.  
    85. }

    运行结果： 

    九、类对象作为类成员

    c++类中的成员是另一个类的对象，称该成员为对象成员

    例如：

    class A{};

    class B

    {

    A a;

    };

    B类中有对象A作为成员，A为对象成员

    那么，当创建B对象时，A与B的构造和析构顺序ABBA

    示例：

    1. #include
    2.  
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. // 设计一个手机类
    8.  
    9. class phone{
    10.  
    11. public:
    12.  
    13.     // 给手机命名
    14.  
    15.     // 构造函数
    16.  
    17.     phone(string in_name)
    18.  
    19.     {
    20.  
    21.         p_name = in_name;
    22.  
    23.         cout<<"这是phone的构造函数调用"<
    24.  
    25.     }
    26.  
    27.     ~phone()
    28.  
    29.     {
    30.  
    31.             cout<<"phone 析构函数的调用"<
    32.  
    33.     }
    34.  
    35.  
    36.  
    37.     // 手机类型的设计
    38.  
    39.     string p_name;
    40.  
    41. };
    42.  
    43. // 设计一个人的类
    44.  
    45. class person
    46.  
    47. {
    48.  
    49. public:
    50.  
    51.     // 获取内容
    52.  
    53.     person(string name,string p_name):my_name(name),my_phone(p_name)
    54.  
    55.     {
    56.  
    57.         // 相当于下边这样，隐式转换法
    58.  
    59.         // phone my_phone = p_name;
    60.  
    61.         cout<<"这是person 的构造函数调用"<
    62.  
    63.     }
    64.  
    65.     ~person()
    66.  
    67.     {
    68.  
    69.             cout<<"person 析构函数的调用"<
    70.  
    71.     }
    72.  
    73.  
    74.  
    75. // 姓名
    76.  
    77.      string my_name;
    78.  
    79.     // 手机
    80.  
    81.     phone my_phone;
    82.  
    83. };
    84.  
    85. // 当其他类作为本类的成员，构造时先构造其他类的对象，再构造自身
    86.  
    87. //  析构时先析构自身，再析构其他的对象
    88.  
    89. void test01()
    90.  
    91. {
    92.  
    93.     person p("张三","苹果MAX");
    94.  
    95.     cout<"有一个"<"手机"<
    96.  
    97. }
    98.  
    99. int main()
    100.  
    101. {
    102.  
    103.     test01();
    104.  
    105.     return 0;
    106.  
    107. }

    运行结果：

    十、静态成员

            静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

    1.静态成员分类

    静态成员变量：    

    • 所有对象共享同一份数据
    • 在编译阶段分配内存
    • 类内声明，类外初始化

    静态成员函数：

    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量

    2.静态成员变量

    示例：

    1. #include
    2.  
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. class person {
    8.  
    9. public:
    10.  
    11.     static int m_A; // 静态成员变量
    12.  
    13.     // 类内声明，类外初始化
    14.  
    15.  
    16.  
    17. private:
    18.  
    19.     static int m_B;// 静态成员变量
    20.  
    21.     // 在类外访问不到
    22.  
    23. };
    24.  
    25. int person::m_A = 0;
    26.  
    27. int person::m_B = 200;
    28.  
    29.  
    30.  
    31. // 两种访问方式
    32.  
    33. void test01()
    34.  
    35. {
    36.  
    37.     // 1. 通过对象访问
    38.  
    39.     cout << "通过对象访问" << endl;
    40.  
    41.     person p1;
    42.  
    43.     cout << "p1_a = " << p1.m_A << endl;
    44.  
    45.  
    46.  
    47.     person p2;
    48.     
    49.     p2.m_A = 200;
    50.  
    51.     cout << "共享数据，p2修改了数据，p1访问就变为p2修改后内容" << endl;
    52.  
    53.     cout << "p1_a = " << p1.m_A << endl;
    54.  
    55.     cout << "p2_a = " << p2.m_A << endl;
    56.  
    57.  
    58.  
    59.     // 2. 通过类名访问
    60.  
    61.     cout << "通过类名访问：" << person::m_A << endl;
    62.  
    63.  
    64.  
    65.     //并且私有权限类外访问不到
    66.  
    67. }
    68.  
    69. int main()
    70.  
    71. {
    72.  
    73.     test01();
    74.  
    75.  
    76.  
    77.     return 0;
    78.  
    79. }

    运行结果：

      

    3.静态成员函数

    示例：

    1. #include
    2.  
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. class person{
    8.  
    9. public:
    10.  
    11.     // 静态的成员函数
    12.  
    13.     static void func()
    14.  
    15.     {
    16.  
    17.         m_A = 100;
    18.  
    19.         // m_B = 200;  // 静态成员函数不能访问非静态成员变量
    20.  
    21.         // 静态成员函数是每个对象都共享的，调用非静态成员变量时不知道修改的是哪个对象的变量
    22.  
    23.         cout<<"静态函数的调用"<
    24.  
    25.     }
    26.  
    27.     static int m_A; // 静态成员变量
    28.  
    29.     // 类内声明，类外初始化
    30.  
    31.     int m_B;
    32.  
    33. private:
    34.  
    35.     static  void  func2()
    36.  
    37.     {
    38.  
    39.         cout<<"这是private下的调用"<
    40.     }
    41.  
    42. };
    43.  
    44. int person::m_A = 0;
    45.  
    46.  
    47.  
    48. // 两种访问方式
    49.  
    50. void test01()
    51.  
    52. {
    53.  
    54.     // 1. 通过对象访问
    55.  
    56.     cout << "通过对象访问" << endl;
    57.  
    58.     person p1;
    59.  
    60.     p1.func();
    61.  
    62.  
    63.  
    64.     // 2. 通过类名访问
    65.  
    66.     cout<<"通过类名访问：";
    67.  
    68.     person::func();
    69.  
    70.  
    71.  
    72.     person::func2();// 类外访问不到私有静态成员函数
    73.  
    74. }
    75.  
    76. int main()
    77.  
    78. {
    79.  
    80.     test01();
    81.     return 0;
    82.  
    83. }

    运行结果： 

     

  • 相关阅读:
    Dynamic Kafka Configurations
    免杀对抗-Python-混淆算法+反序列化-打包生成器-Pyinstall
    UE 智能指针的介绍
    Boost.Beast和C++编写程序
    米桃安全漏洞讲堂系列第4期：WebShell木马专题
    OpenHarmony、HarmonyOS、HarmonyNext互相兼容吗？
    Authing 被世界经济论坛评选为 2022 技术先锋企业
    C++ Reference: Standard C++ Library reference: C Library: clocale: setlocale
    c++day7
    【React】Lodash---groupBy() 分组
  • 原文地址：https://blog.csdn.net/hjl011006/article/details/133550565