C++ 类和对象（二）构造和析构

约定不等于承诺〃 2022-12-20 12:36 146阅读 0赞

# C++ 类和对象（二） 构造和析构 #

### 文章目录 ###

*  C++ 类和对象（二） 构造和析构
 *   *  1. 构造函数和析构函数
     *   *  1.1 构造和析构的作用：
         *  1.2 构造函数语法：
         *  1.3 析构函数语法：
     *  2. 函数的分类和调用
     *   *  2.1 两种分类方式
         *  2.2 三种调用方式
     *  3. 拷贝构造函
     *   *  构造函数的调用时机
     *  4. 构造函数调用规则
     *  5. 深拷贝和浅拷贝

• 生活中买电子产品都会有出厂设置，在某一天我们不用的时候会删除自己的信息保证安全  
• C++中的面向对象来源于生活，类似的每个对象也会有初始设置以及对象销毁前的清理数据设置

## 1. 构造函数和析构函数 ##

构造： 初始化  
析构： 清理

> 一个变量或者对象没有初始化，对其使用后果是未知的  
> 同样，使用完一个对象或者变量，没有及时清理，也会有一定的安全问题

C++中使用构造函数和析构函数来解决上面的问题。

这两个函数会被编译器自动调用，完成初始化对象和清理的工作。  
对象的初始化和清理工作是编译器强制要求我们做的事情，因此，就算我们没有写构造析构，编译器会提供他们自己的构造和析构函数，只不过这两个函数的函数体是空的。

### 1.1 构造和析构的作用： ###

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

### 1.2 构造函数语法： ###

类名(可以有参数)
    { 
    }

1.  没有返回值，没有返回类型，也不写void
2.  函数名称和类名一样
3.  构造函数可以有参数，因此可以发生重载
4.  程序在调用对象时候会自动调用构造，无需手动调用，而且只调用一次(每次手机开机不需要进行初始化设置）

### 1.3 析构函数语法： ###

~类名(不能有参数)
    { 
    }

1.  没有返回值，不写void
2.  函数名和类名一样，在名称前要加上符号 ~
3.  析构函数不能有参数，不能发生重载
4.  程序在对象销毁前会自动调用析构函数，无需手动调用，只调用一次

**示例：**

#include <iostream>
    using namespace std;
    class Person { 
    public:
        //构造函数
        Person() { 
            cout << "调用构造函数" << endl;
        }
        //析构函数
        ~Person() { 
            cout << "调用析构函数" << endl;
        }
    };
    void func()
    { 
        Person p; //函数在栈区，调用完自动释放
    }
    int main()
    { 
        func();
        system("pause");
        return 0;
    }

## 2. 函数的分类和调用 ##

### 2.1 两种分类方式 ###

**构造函数发生重载后的分类**：

*  按参数分类： 有参构造和无参(默认构造)构造
 *  按类型分类： 普通构造和拷贝构造（除拷贝构造之外的其他的都叫普通构造）

**拷贝构造函数：**

> 复制一个一摸一样的Person对象出来，  
> 就要把传进来的对象的属性都复制给当前对象  
> 传进来的对象不能更改 , 所以加了const

**固定格式：**  
`Person(const Person &p)`

*  相同类型的对象是通过拷贝构造函数来实现复制的
 *  函数名称必须跟本类相同，且是参数是本类的引用常量

### 2.2 三种调用方式 ###

1.  括号法
2.  显示法
3.  隐式转换法

**注意：**

1.  调用默认构造函数时候，不要加()  
    因为会把它当作函数声明的，而不会创建对象了  
    int func(); //这是一个函数声明 返回类型 + 函数名 + 参数  
    Person p(); // 类似的 Person 是返回类型， p 是函数名
2.  不要用拷贝构造函数来初始化一个匿名对象  
    编译器认为 Person(p3) 等价于 Person p3; 而前面p3 已经声明过了

示例：

#include <iostream>
    using namespace std;
    class Person { 
    public:
        //构造函数
        Person() { 
            cout << "---1---调用无参构造函数" << endl;
        }
        Person(int a) { 
            m_age = a;
            cout << "---2---调用有参构造函数" << endl;
        }
        Person(const Person& p)
        { 
            m_age = p.m_age;
            cout << "---3---调用拷贝构造函数" << endl;
        }
        //析构函数
        ~Person() { 
            cout << "调用析构函数" << endl;
        }
        int m_age;
    };
    void func()
    { 
        //括号调用
        //Person p; //默认构造
        //Person p1(10);//有参构造
        //Person p2(p1); //拷贝构造
        //显示调用
        Person p3 = Person(10);
        //Person p4 = Person(p3);
        //Person(10);//匿名对象，执行完当前行就自动销毁
        //cout << "aaaaaaaaaaaaa" << endl;
        //不要用拷贝函数初始化一个匿名对象,编译器和i认为是对象的声明
        //Person(p3);
        //隐式调用
        //Person p5 = 10; // Person p5 = Person(10)
        //Person p6 = p5;
    }
    int main()
    { 
        func();
        system("pause");
        return 0;
    }

## 3. 拷贝构造函 ##

### 构造函数的调用时机 ###

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

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

//1. 使用一个已经创建完毕的对象来初始化一个新对象
    void func()
    { 
        Person p1(10);
        Person p2(p1); 
    }
    // 2. 值传递
    void func0(Person p) 
    { 
    }
    void func1()
    { 
        Person p3(10);
        func0(p3);
    }
    //3. 值方式返回对象
    Person func2()
    { 
        Person p(10);
        cout << (int*)&p << endl;
        return p;
    }
    int main()
    { 
        cout << "-----使用已经创建完毕的对象来初始化对象" << endl;
        func();
        cout << "-----使用值传递的方式来初始化对象" << endl;
        func1();
        cout << "-----使用值方式返回对象" << endl;
        Person p = func2();
        cout << (int*)&p << endl;
        system("pause");
        return 0;
    }

## 4. 构造函数调用规则 ##

默认情况下，C++编译器至少给一个类添加3个函数

1.  默认构造函数（无参， 函数体为空）
2.  默认析构函数（无参，函数体为空）
3.  默认拷贝构造函数， 对属性进行值拷贝

**构造函数调用规则：**  
• 如果用户定义有参构造函数， C++不再提供默认无参构造，但是会提供默认拷贝构造  
• 如果用户定义了拷贝构造函数， C++不会再提供其他构造函数  
提供下面的就不提供上面的了  
**示例：**

#include <iostream>
    using namespace std;
    class Person { 
    public:
        //Person() { 
        // cout << "调用默认构造函数" << endl;
        //}
        //Person(int a) { 
        // m_age = a;
        // cout << "调用有参构造函数" << endl;
        //}
        Person(const Person& p)
        { 
            m_age = p.m_age;
            cout << "调用拷贝构造函数" << endl;
        }
        //析构函数
        ~Person() { 
            cout << "调用析构函数" << endl;
        }
        int m_age;
    };
    void func()
    { 
        Person p1(20);
        //p1.m_age = 20;
        Person p2(p1); 
        cout << "p2的年龄是： " << p2.m_age << endl;
    }
    int main()
    { 
        func();
        system("pause");
        return 0;
    }

## 5. 深拷贝和浅拷贝 ##

**浅拷贝**： 简单的赋值拷贝操作（编译器提供的）

> 问题是： 堆区的内存重复释放

**深拷贝**： 在堆区重新申请空间，进行拷贝操作  
**堆区的内存已经释放干净了，再释放就是非法操作**

> **解决办法**： 堆区的存放数据是一样的，但是指向堆区的位置不一样

**注意点： 如果有属性是在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题**

**示例：**

class Person { 
    public:
        Person() { 
            cout << "调用默认构造函数" << endl;
        }
        Person(int a, int height) { 
            m_age = a;
            m_height = new int(height);//在堆区开辟了一段内存存放数据
            
            cout << "调用有参构造函数" << endl;
        }
        Person(const Person& p)
        { 
            m_age = p.m_age;
            //m_height = p.m_height;//编译器的默认拷贝函数， 简单的值拷贝
            m_height = new int(*p.m_height);//深拷贝
            cout << "调用拷贝构造函数" << endl;
        }
        //析构函数
        ~Person() { 
            //将堆区开辟的数据做释放操作
            //删除内存，安全
            if (m_height != NULL)
            { 
                delete m_height;
                m_height = NULL;//防止野指针出现，置空
            }
            cout << "调用析构函数" << endl;
        }
        int m_age;
        int* m_height;
    };
    void func()
    { 
        Person p1(10, 180);
        cout << "---p1的年龄是： " << p1.m_age << "身高是： " << *p1.m_height << endl;
        Person p2(p1); 
        cout << "---p2的年龄是： " << p2.m_age << "身高是: " << *p2.m_height << endl;
    }
    int main()
    { 
        func();
        system("pause");
        return 0;
    }

**规则1** ： 用户定义了有参构造函数，C++编译器就不会提供默认构造函数了  
![在这里插入图片描述][20201115124745467.png_pic_center]  
但是会提供默认拷贝构造函数，用于值拷贝  
![20201115124902235.png_pic_center][]  
**规则2**： 用户定义了拷贝构造函数，C++编译器就不再提供默认构造函数和有参构造函数  
![在这里插入图片描述][20201115124926912.png_pic_center]

[20201115124745467.png_pic_center]: /images/20221120/eb2e7dd2f35a4472bed3a29ae972219a.png
[20201115124902235.png_pic_center]: /images/20221120/79c937b84d274b258596b1eb808519b0.png
[20201115124926912.png_pic_center]: /images/20221120/aef32ac610e34c3c871f21212e09f231.png