【Cpp】类和对象#构造函数 析构函数

标题：【Cpp】类和对象#构造函数 析构函数

@水墨不写bug

（图片来源于网络）

---

目录

（一）构造函数

（二）析构函数

---

 正文开始：

（一）构造函数

        构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：
1. 函数名与类名相同。
2. 无返回值。（不需写为void）

class A {
public:
	A()//函数名和类名相同，且不需要写返回值类型
	{
		_a = 1;
		_c = 't';
	}
	
private:
	int _a;
	char _c;
	stack st1;
};

3. 对象实例化时编译器自动调用对应的构造函数。（自动初始化，省去了Init（）函数）

class A {
public:
	A()//函数名和类名相同
	{
		_a = 1;
		_c = 't';
	}	
private:
	int _a;
	char _c;

};
int main()
{
	A a1;	
	return 0;
}

（上述程序中，在创建a1后自动调用A（），将_a,_c初始化）
4. 构造函数可以重载。（构造函数可以有多个，也就是对象的初始化方式可以有多个）

        简单举一个例子：

class B {
public:
	B()
	{
		_a = 1;
		_c = 't';
		_arr = (int*)malloc(sizeof(int));
	}
	B(int n)
	{
		_arr = (int*)malloc(sizeof(int) * n);
		_a = 1;
		_c = 't';
	}

private:
	int _a;
	char _c;
	int* _arr;
};

int main()
{
	B b1;
	B b2(100);
	
	return 0;
}

 （        b1对象没有传参，调用没有参数的构造函数；b2传了一个参数n，调用有一个参数的默认构造，可以指定开辟空间的大小）

        但是对于下面的重载，情况就有所不同了：

class B {
public:
	B()
	{
		_a = 1;
		_c = 't';
		_arr = (int*)malloc(sizeof(int));
	}
	B(int n = 8)
	{
		_arr = (int*)malloc(sizeof(int) * n);
		_a = 1;
		_c = 't';
	}

private:
	int _a;
	char _c;
	int* _arr;
};

（这两个函数显然构成函数重载，因为他们的参数个数不同。但是在不传参调用的时候，会导致编译器报错，因为编译器无法区分无参调用调用的具体是哪一个函数）

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

6.对于自动生成的默认构造函数，有如下性质：

        i，自定义类型（int，float，int*等）不做处理，仍然是随机值；

        ii，对于自定义类型（struct，class声明中的类），转跳到这个自定义类型的对应的构造函数中去，自动调用自定义类型的构造函数。

7.什么是默认构造，总结下来有如下几种情况：

        i，自己没有写，编译器自动生成的的构造函数是无参数的构造函数，也就是默认构造；

        ii，自己写了一个函数，但是没有参数，也可以被编译器识别为默认的构造函数，这时编译器就不会再自动生成一个构造函数了；

        iii，自己写了一个函数，有参数，但是是全缺省的参数，这也可被编译器识别为默认的构造函数，这时编译器就不会再自动生成一个构造函数了；

（注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。但是要注意编译器生成的构造函数不会处理内置类型）

（二）析构函数

        析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

析构函数是特殊的成员函数，其特征如下：
1. 析构函数名是在类名前加上字符 ~。（~表示取反，暗示了清理资源的工作）
2. 无参数无返回值类型。（无需写void）

class stack{
public:
	stack(int n = 4)//函数名和类名相同
	{
		_arr = (int*)malloc(sizeof(int) * n);
		_top = 0;
		_capacity = 0;
	}
	~stack()//函数名和类名相同，不需要写返回值类型
	{
		free(_arr);
		_top = 0;
		_capacity = 0;
	}
private:
	int* _arr;
	int _top;
	int _capacity;
};

3.对象生命周期结束时，C++编译系统系统自动调用析构函数。

4.一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载，也就是说析构只有一种方式。

5.对于自动生成的析构函数，有如下性质：

        i，对于自定义类型（int，float，int*等）不做处理，自定义类型本身不需要资源的释放；

        ii，对于自定义类型（struct，class声明中的类），转跳到这个自定义类型的对应的析构函数中去，自动调用自定义类型的析构函数。

6.从上述特性可以得出：如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写析构函数，否则会造成资源泄漏，比如Stack类。

总结：

        默认生成虽然好，但是如果默认生成的构造/析构函数在调用时由于只处理自定义类型，如果自定义类型的构造/析构没有写，那么即使是默认生成的函数，本质上也是没有做任何工作。

class stack{
public:
	stack(int n = 4)//函数名和类名相同
	{
		_arr = (int*)malloc(sizeof(int) * n);
		_top = 0;
		_capacity = 0;
	}
	/*
	~stack()
	{
		free(_arr);
		_top = 0;
		_capacity = 0;
	}
	*/
private:
	int* _arr;
	int _top;
	int _capacity;
};

class A {
public:
	A()//函数名和类名相同
	{
		_a = 1;
		_c = 't';
	}
	
private:
	int _a;
	char _c;
	stack st1;
};

（虽然A类没有写析构，但是编译器会默认生成，处理A中需要释放的资源st1；但是st1的类没有写析构函数，也只是调用默认生成的析构，这时，st1中的动态申请的堆空间就无法释放了，造成内存泄漏）

        所以，我们能自己写的构造/析构，就最好自己写，不要过分依靠编译器默认生成。 

---

完·~ 

未经作者同意禁止转载