c++基础学习笔记——构造函数与析构函数概念及执行顺序

构造函数

先来看看构造函数与析构函数的一些相关概念。

构造函数的作用：为类的对象分配资源空间、初始化。
析构函数的作用：回收类的资源空间、清理对象。

构造函数名与类名相同，这是由类的唯一性和对象的多样性决定的。c++规定每个类都有构造函数，称为默认构造函数。

构造函数负责对象初始化工作，将数据成员初始化；
创建对象时，其类的构造函数确保用户在操作之前，系统保证初始化的进行。建立对象，必须有一个有意义的初始值；c++建立和初始化对象的过程专门由该类的构造函数完成；构造函数给对象分配空间和初始化；如果一个类没有专门定义的构造函数，那么c++就仅仅创建对象而不做初始化。

构造方法需满足以下语法规则：
①构造函数名与类名相同；
②没有返回类型；
③方法实现主要为字段赋初值；

注意：放在类外部定义的构造函数，其函数名前要加上“类名::”；
构造函数另一特殊之处在于其无返回值，函数体中也不允许有返回值，但可以有无返回值语句“return”；因为构造函数专门用于创建对象和为其初始化，所以它是在定义对象时自动调用的。如果建立一个对象数组，数组多大，构造函数就会被调用几次。

构造函数的初始化列表：表中数据的初始化顺序和声明顺序相同。

class Student
{
public:
	Student(int ssID = 0):id(ssID),score(100)		//冒号表示后面要对类的数据成员进行初始化
	{
		cout<<"Constructing student:"<<ssID<<endl;
	}
private:
	int id;
	int score;
}

注：构造函数可以有多个；构造函数可以重载；构造函数可用于隐式类型转换（在构造函数前加上explicit可禁止隐形转换）。

析构函数

析构函数：类生命周期一结束，系统立马调用析构函数回收内存空间。一个类可能在构造函数里分配资源，这些资源在对象不复存在以前被释放。
①析构函数也是特殊类型的成员，它没有返回值，没有参数，不能随意调用，也没有重载。只是在类对象生命周期结束的时候，由系统自动调用；
②析构函数名，就是在构造函数前加上一个逻辑非运算符“~”，表示逆构造函数；
③如果类没有定义析构函数，编辑器会提供一个默认的析构函数；
④析构函数只有一个，不能重载。

构造函数与析构函数执行顺序

代码借鉴 （执行顺序这一块都借鉴这篇博客，此处不另外举例） 　　　　https://blog.csdn.net/zq123lcx/article/details/78741373?ops_request_misc=%7B%22request%5Fid%22%3A%22158218451019725211933837%22%2C%22scm%22%3A%2220140713.130056874…%22%7D&request_id=158218451019725211933837&biz_id=0&utm_source=distribute.pc_search_result.none-task

#include <iostream>
using namespace std;
 
class ABCD
{
public:
    ABCD(int a,int b,int c)
    {
        this->a = a;
        this->b = b;
        this->c = c;
        cout<<"ABCD的有参构造函数："<<"a:"<<a<<" b:"<<b<<" c:"<<c<<endl;
    }
    
    ABCD(const ABCD& obj)
    {
        this->a = obj.a;
        this->b = obj.b;
        this->c = obj.c;
        cout<<"ABCD的拷贝构造函数："<<"a:"<<a<<" b:"<<b<<" c:"<<c<<endl;
    }
 
    ~ABCD()
    {
        cout<< "ABCD的析构函数。。。" <<endl;
    }
 
    int getA() 
    {
        return this->a;
    }
private:
    int a;
    int b;
    int c;
};
 
class mye
{
public:
    mye():a1(1,1,1),a2(2,2,2),m(100)
    {
        cout<<"mye的无参构造函数："<<endl;
    }
 
    mye(const mye& obj):a1(1,1,1),a2(2,2,2),m(100)
    {
        cout<<"mye的拷贝构造函数："<<endl;
    }
    ~mye()
    {
        cout<< "mye的析构函数。。。" <<endl;
    }
public:
    ABCD& getA1()
    {
        return a1;
    }
 
private:
    ABCD a1;
    ABCD a2;
    const int m;
};
 
int dothing(mye my1)
{
    cout << "doThing() my1.a1.a:" << my1.getA1().getA() <<endl;
    return 0;
}
 
int run2()
{
    mye mye1;
    dothing(mye1);
    return 0;
}
 
void main()
{
   run2();
   system("pause");
}

执行结果：

**执行流程：

main 函数调用 run2函数，在run2函数里，执行 mye mye1;
即执行 mye(const mye& obj):a1(1,1,1),a2(2,2,2),m(100)这句话，
先对 ABCD a1 和 ABCD a2 初始化，分别执行ABCD类的有参构造函数，
打印出ABCD的有参构造函数：a:1 b:1 c:1
ABCD的有参构造函数：a:2 b:2 c:2
再去执行mye 类的无参构造函数，
打印出mye的无参构造函数：
执行 dothing(mye1)这句话，（mye1是个元素，进入 mye 类，调用 mye 类的拷贝构造函数），先对 ABCD a1 和 ABCD a2 初始化，分别执行ABCD类的有参构造函数，
打印出ABCD的有参构造函数：a:1 b:1 c:1
ABCD的有参构造函数：a:2 b:2 c:2
再去执行mye 类的拷贝构造函数，
打印出mye的拷贝构造函数：
最后执行 dothing 函数输出的那句话，
打印出doThing() my1.a1.a:1
析构函数与构造函数执行的顺序相反
打印出
mye的析构函数。。。
ABCD的析构函数。。。
ABCD的析构函数。。。
mye的析构函数。。。
ABCD的析构函数。。。
ABCD的析构函数。。。**