C++学习日记之构造函数和析构函数

构造函数和析构函数

为了对象的初始化和清理，若没有初始化，对象的状态是未知的，若使用完一个对象或变量没有清理，会有一定的安全问题。
C++中 如果我们不写这两个函数，编译淇会自动的提供，提供的这俩函数是空实现。
而且也不用我们手动调用，编译器会帮我们调用

语法

构造函数

类名（）{}
不写返回值也不写void，可以有参数，在使用这个类时会自动调用构造函数，且只调用一次。

析构函数

~类名（）{}
没有返回值不写void，前面有个波浪号，不可以有参数因此不能有重载，在对象销毁前自动调用析构函数，且只调用一次。

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

class Person
{
private:
	int age;
	string name;
public:
	Person()
	{
		cout << "Person构造函数的调用" << endl;
	}
	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}
};

void test()
{
	Person p1;//在栈区创建的临时变量，在执行会清理
}
int main()
{
	//test();//在调用函数之后就会被析构
	Person p1;//在main函数中需要等main函数大括号中走完后才会析构
	system("pause");
}

构造函数的分类及调用

按参数分为：有参构造和无参构造

根据小括号里有无参数
有参构造

	Person(int a)//有参构造函数
	{
		age = a;
		cout << "Person构造函数的调用" << endl;
	}

按类型分为：普通构造和拷贝构造

拷贝构造函数：将已经存在的一个类（和当前类名一样）复制拷贝，然后进行构造一样的类
要求不能更改原来的那个类，所以要用const，而且要用引用的方式

	//拷贝构造函数
	Person(const Person &a)
	{
		age = a.age;
	

有三种调用方式：括号法，显示法，隐式转换法

括号法

void test1()//括号法调用
{
	Person p1;
	Person p2(10);
	Person p3(p2);
}

int main()
{
	test1();
	system("pause");
}

显示法

void test2()//显式法
{
	Person p4;
	Person p5 = Person(10);//有参
	Person p6 = Person(p5);
}
int main()
{
	test2();
	system("pause");
}

显示法等号右侧的是匿名对象，特点：当前行执行完后，系统会立即回收掉匿名对象

对比下面的代码

void test2()//显式法
{

	Person p5 = Person(10);//有参
	cout << "111" << endl;
}
int main()
{
	test2();
	system("pause");
}

如上，非匿名，创建了一个类p5，系统会分配内存，在test2()函数大括号全部执行完后，这部分内存会被释放

void test2()//显式法
{

	Person(10);
	cout << "111" << endl;
}
int main()
{
	test2();
	system("pause");
}

如上匿名对象构造完立即回收

隐式转换法

void test3()//隐式转换法
{
	Person p5 = 10;//有参
	Person p6 = p5;
}
int main()
{
	test3();
	system("pause");
}

注意事项：

1、调用默认（无参）构造函数时不要加小括号（）
像这样：

Person p1();

函数不会调用无参构造，上面的语句编译器会认为是一个函数声明
类似 void func();
2、不要利用拷贝构造函数初始化匿名对象，如Person(p5)
编译器会认为Person(p5)和Person p5等价，对象的声明，实例化p5，并且无参构造

拷贝构造函数的调用时机

1、使用一个已经创建完毕的对象来初始化一个新对象

略

2、值传递的方式给函数参数传值

void work(Person a)
{
//a是形参，临时数据
}
void test4()
{
	Person p1;
	work(p1);  //这个函数值传递：Person a = p1这是拷贝构造的隐式转换法
}

int main()
{
	test4();
	system("pause");
}

3、以值方式返回局部对象

Person work_1()
{
	Person p1;
	return p1;
}
void test5()
{
	Person p = work_1();//拷贝构造函数的隐式转换法
}
int main()
{
	test5();
	system("pause");
}

但我输出结果仅有无参构造，网友说是由于版本问题，编译器优化了。

构造函数调用规则

1、默认情况下，编译器至少给一个类添加三个构造函数：无参（空实现）、有参（空实现）、拷贝（值实现）。
2、如果用户定义了有参，则编译器不提供无参，仍提供拷贝。
这时调用Person p1；就会报错，因为用户没定义，系统也不提供
3、如果用户定义了拷贝，则编译器不提供其他构造函数。

深拷贝与浅拷贝

浅拷贝

简单的赋值拷贝操作

void test6()
{
	Person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;
	Person p2(p1);
	cout << "p2的年龄为：" << p2.age << endl;
}
int main()
{
	test6();
	system("pause");
}

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

class Person
{
public:
	Person()//无参构造函数
	{
		cout << "Person无参构造函数的调用" << endl;
	}
	Person(int a,int b)//有参构造函数
	{
		age = a;
		height = new int(b);
		cout << "Person有参构造函数的调用" << endl;
	}
	//拷贝构造函数用户不提供，编译器会自己提供	~Person()
	{
		//析构代码，堆区的数据需要手动释放，将堆区开辟的数据做释放操作
		if (height != NULL)
		{
			delete height;
			height = NULL;//防止野指针的出现
		 }
		cout << "Person析构函数的调用" << endl;
	}
	int age;
	int *height;//身高数据开辟在堆区
};

void test6()
{
	Person p1(18,160);
	cout << "p1的年龄为：" << p1.age <<"p2身高为："<<*p1.height << endl;
	Person p2(p1);
	cout << "p2的年龄为：" << p2.age<<"p2身高为：" <<*p2.height<< endl;
}
int main()
{
	test6();
	system("pause");
}

会错，错误原因：
分析下程序进行过程：
出问题的是身高这个数据，首先是p1，在创建身高时申请了一块内存来放身高数据160，height指针是那块内存的地址，假如是0x0001，
然后进行拷贝构造，如果用系统提供的拷贝构造，会进行浅拷贝的操作，p2的身高指针也指向的0x0001，构造完成后进行析构，堆区是先进后出，所以p2先出，p2的身高指向的0x0001非空，进行释放内存，然后析构p1，p1的身高0x0001也不为空，进行释放，但已经释放过再释放是非法操作。

浅拷贝带来的问题：堆区的重复释放。

深拷贝

在堆区重新申请空间进行拷贝操作，堆区存放的数据是一样的，但指向的地址不一样。

Person(const Person &a)
{
	age = a.age;
	//height = a.height;//编译器默认实现就是这行代码
	//深拷贝
	height = new int(*a.height);//加*是指的指针指向的地址所对应的内容
	//重新在堆区开辟一个新的空间，new一个新的空间
	cout << "Person深拷贝构造函数的调用" << endl;
}

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