构造函数和析构函数

构造函数和析构函数的概述

类的数据成员不能在类的声明时候初始化,为了解决这个问题? 使用构造函数处理对对象的初始化。
构造函数是一种特殊的成员函数,与其他函数不同,不需要用户调用它,而是创建对象的时候自动调用。
析构函数是对象不再使用的时候,需要清理资源的时候调用。

构造函数
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

构造函数语法：

类名( ) {  }
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次

析构函数
析构函数语法：

~类名( ) {  }
1.析构函数，没有返回值，也不写void
2.函数名称与类名相同，在名称前加上符号~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对像销毁前会自动调用析构，无需手动调用，而且只会调用一次。

#include<iostream>
using namespace std;
class Person
{
public:
   //1.构造函数
   Person()
   {
   	cout << "构造函数的调用" << endl;
   }
   //2.析构函数
   ~Person()
   {
   	cout << "析构函数的调用" << endl;
   }
};
int main()
{
   Person p;
   return 0;
}

执行结果：
在类创建时调用构造函数
在类销毁时调用析构函数

构造函数详解

两种分类方式：

按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造

#include<iostream>
using namespace std;
class Person
{
public:
	//1.构造函数
	//无参构造（默认构造）
	Person()
	{
		cout << "构造函数的调用" << endl;
	}
	//有参构造
	Person(int a)
	{
		age = a;
	}
	//拷贝构造函数
	Person(const Person &p)
	{
		age =p.age;
	}
	int age;
};

构造函数的调用方法

三种调用方法：

括号法
显示法
隐示转换法

1.括号法

#include<iostream>
using namespace std;
class Person
{
public:
	//1.构造函数
	//无参构造（默认构造）
	Person()
	{
		cout << "构造函数的调用" << endl;
	}
	//有参构造
	Person(int a)
	{
		age = a;
	}
	//拷贝构造函数
	Person(const Person &p)
	{
		age =p.age;
	}
	int age;
};
int main()
{
	//默认构造函数调用
	Person p1;
	//括号法
	Person p2(10);//调用有参构造函数
	Person p3(p2);//调用拷贝构造函数
	//注意事项
	//在调用默认构造函数时，不要加小括号()
	//比如： Person p();
	//因为编译器会认为这是一个函数声明，不会认为在创建对象。
		
	return 0;
}

2.显示法

#include<iostream>
using namespace std;
class Person
{
public:
	//1.构造函数
	//无参构造（默认构造）
	Person()
	{
		cout << "构造函数的调用" << endl;
	}
	//有参构造
	Person(int a)
	{
		age = a;
	}
	//拷贝构造函数
	Person(const Person &p)
	{
		age =p.age;
	}
	int age;
};
int main()
{
	Person p1;
	//显示法
	Person p2 = Person(10);//有参构造
	Person p3 = Person(p2);//拷贝构造
	Person(10);  //称为匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象
	//注意事项
	//不要利用拷贝构造函数初始化匿名对象
	// 比如：Person(p3);
	//原因：编译器会认为Person(p3);等价于Person p3;会报重定义的错误
	return 0;
}

3.隐式转换法

#include<iostream>
using namespace std;
class Person
{
public:
	//有参构造
	Person(int a)
	{
		age = a;
	}
	//拷贝构造函数
	Person(const Person &p)
	{
		age =p.age;
	}
	int age;
};
int main()
{
	//隐式转换法
	Person p1 = 10;//有参构造
	Person p2 = p1;//拷贝构造
	system("pause");
	return 0;
}

拷贝构造函数的调用时机

C++中拷贝构造函数调用时机通常有三种情况

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

#include<iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "person默认构造函数调用" << endl;
	}
	Person(int a)
	{
		age = a;
		cout << "person有参构造函数调用" << endl;
	}
	Person(const Person&p)
	{
		age = p.age;
		cout << "person拷贝构造函数调用" << endl;
	}
	~Person()
	{
		cout << "person析构函数调用" << endl;
	}
	int age;
};

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

void test01()
{
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄为" << p2.age << endl;
}

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

void dowork(Person p)//此处传的是形参，会将实参拷贝一份，也就会出现拷贝构造函数
{

}
void test02()
{
	Person p;
	dowork(p);
}
int main()
{
	test02();
	return 0;
}

输出结果：

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

Person dowork2()
{
	Person p1;
	return p1; //返回是以拷贝构造函数返回的
}
void test03()
{
	Person p = dowork2();
}
int main()
{
	test03();
	return 0;
}

输出：

构造函数的调用规则

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

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

构造函数调用规则如下：

1. 如果用户定义有参函数，c++不再提供默认无参构造，但是会提供默认拷贝构造(切记)
2. 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

#include<iostream>
using namespace std;
class Person
{
public:
	int age;
};
int main()
{
	Person a1;
	a1.age = 18;
	Person a2(a1);  //编译器自己提供拷贝构造函数，会对属性进行值拷贝
	cout << a2.age << endl;
	system("pause");
	return 0;
}

深拷贝与浅拷贝

深拷贝：简单的赋值操作
浅拷贝：在堆区重新申请空间，进行拷贝操作

#include<iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person的默认构造函数" << endl;
	}
	Person(int a,int height)
	{
		age = a;
		Height=new int(height);
		cout << "Person的有参构造函数" << endl;
	}
	~Person()
	{
		//将堆区开辟的数据进行释放
		if (Height != NULL)
		{
			delete Height;
			Height == NULL;
		}
		cout << "Person的析构函数" << endl;
	}
	int age;
	int* Height;
};
int main()
{
	Person a1(18,160);
	cout << a1.age << " " << *a1.Height << endl;
	Person a2(a1);
	cout << a2.age << " " << *a2.Height << endl;
	system("pause");
	return 0;
}

这段代码会报错，原因是空间被重复释放
这就是浅拷贝的局限
图解：

所以我们可以自己实现拷贝构造函数，实现深拷贝
代码如下：

#include<iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person的默认构造函数的调用" << endl;
	}
	Person(const Person&p)
	{
		age = p.age;
		Height = new int(*p.Height);
		cout << "Person的拷贝构造函数的调用" << endl;
	}
	Person(int a,int height)
	{
		age = a;
		Height=new int(height);
		cout << "Person的有参构造函数的调用" << endl;
	}
	~Person()
	{
		//将堆区开辟的数据进行释放
		if (Height != NULL)
		{
			delete Height;
			Height==NULL;
		}
		cout << "Person的析构函数的调用" << endl;
	}
	int age;
	int* Height;
};
int main()
{
	Person a1(18,160);
	cout << a1.age << " " << *a1.Height << endl;
	Person a2(a1);
	cout << a2.age << " " << *a2.Height << endl;
	system("pause");
	return 0;
}