c++中的构造函数与析构函数

构造函数和析构函数，这两个函数将会被编译器自动调用，构造函数完成对象的初始化动作，析构函数在对象结束的时候完成清理工作。
注意：对象的初始化和清理工作是编译器强制我们要做的事情，即使你不提供初始化操作和清理操作，编译器也会给你增加默认的操作，只是这个默认初始化操作不会做任何事。
构造函数：实例化对象的时候系统自动调用
析构函数：对象释放的时候系统自动调用
构造函数语法：
构造函数函数名和类名相同，没有返回类型，连void都不可以，但可以有参数，可以重载
析构函数语法：
析构函数函数名是在类名前面加”~”组成,没有返回类型，连void都不可以,不能有参数，不能重载

class Data
 2 {
 3 public:
 4     int num;
 5 public:
 6     //构造函数(无参的构造)
 7     Data()
 8     {
 9         num = 0;
10         cout<<"无参的构造函数"<<endl;
11     }
12     //构造函数（有参的构造）
13     Data(int n)
14     {
15         num = n;
16         cout<<"有参的构造函数"<<endl;
17     }
18 
19     //析构函数
20     ~Data()
21     {
22         cout<<"析构函数"<<endl;
23     }
24 
25 };
26 void test01()
27 {
28     //类实例化对象 系统自定调用构造函数
29     Data ob;
30     
31     //函数结束的时候 局部对象ob 被释放 系统自动调用析构函数
32 }
33 int main(int argc, char *argv[])
34 {
35     cout<<"-----001-----"<<endl;
36     test01();
37     cout<<"------002-------"<<endl;
38     return 0;
39 }

复制代码

1、构造函数分类：
按参数类型：分为无参构造函数和有参构造函数
按类型分类：普通构造函数和拷贝构造函数(复制构造函数)
2、构造函数的调用

class Data
{
public:
    int num;
public:
    //构造函数(无参的构造)
    Data()
    {
        num = 0;
        cout<<"无参的构造函数 num = "<<num<<endl;
    }
    //构造函数（有参的构造）
    Data(int n)
    {
        num = n;
        cout<<"有参的构造函数 num = "<<num<<endl;
    }

    //析构函数（没有返回值类型 没有参数 不能重载）
    ~Data()
    {
        cout<<"析构函数 num = "<<num<<endl;
    }

};
void test02()
{
    //调用无参 或 默认构造 (隐式调用)
    Data ob1;
    //调用无参构造 （显示调用）
    Data ob2 = Data();

    //调用有参构造（隐式调用）
    Data ob3(10);
    //调用有参构造（显示调用）
    Data ob4 = Data(20);

    //隐式转换的方式 调用有参构造（针对于 只有一个数据成员）（尽量别用)
    Data ob5 = 30;//转化成Data ob5(30)

    //匿名对象(当前语句结束 匿名对象立即释放)
    Data(40);
    cout<<"------"<<endl;
    
    //千万不要 用一下方式调用 无参构造
    
}

注意：在同一作用域 构造和析构的顺序相反

3构造函数和析构函数的执行顺序
对象在创建时构造函数的调用顺序

调用父类的构造函数；

调用成员变量的构造函数；

调用类自身的构造函数

如果通过“父类::函数名”来在子类中访问父类的函数，此时不论该函数是否为虚函数，都会直接调用父类对应的函数

子类对象析构时的顺序

析构函数的调用函数与构造函数相反
1.执行自身的析构函数；
2.执行成员变量的析构函数；
3.执行父类的析构函数

#include<iostream>
#include<string>
using namespace std;

class A {
	string a;
public:
	A() {
		cout << "A()" << endl;
	}
	A(string aa) {
		cout << "A(string aa) :" << aa << endl;
		a = aa;
	}
	~A() {
		cout << "~A() :" << a << endl;
	}
	virtual void  vt() {
		cout << "vt A()" << endl;
	}
};
class B : public A{
	A a1;
	string b;
public:
	B() : a1("default") {
		cout << "B()" << endl;
		b = "default";
	}
	B(string bb) : A(bb),a1(bb + "1") {
		cout << "B(string bb):" << bb << endl;
		b = bb;
	}
	void vt() {
		cout << "vt B()" << endl;  
		A::vt();
	}
	~B() {
		cout << "~B():" << b << endl;
	}
};

int main(void) {
	B b("bb");
	cout << endl;
	A *a1 = new B;
	a1 -> vt();
	delete a1;
	cout << endl;
	return 0;
}

执行结果

```cpp

```cpp
A(string aa) :bb
A(string aa) :bb1
B(string bb):bb

A()
A(string aa) :default
B()
vt B()
vt A()
~A() :

~B():bb
~A() :bb1
~A() :bb

————————————————
版权声明：本文为CSDN博主「梧桐樹下」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_37624402/article/details/95605130