【C++】对象初始化和清理

对象的初始化和清理：

首先，我们创建完一个类后，当我们需要对类进行初始化；而当我们完成工作后，需要对类进行清理。这些工作，分别需要调用构造函数和析构函数。

构造函数和析构函数的定义与特点：

构造函数：

1.作用：主要作用于对创建的对象成员属性进行初始化；
2.语法：类名+()+{}
3.注意事项：
构造函数没有返回值，但不需要写void；
构造函数函数名与类名一样；
构造函数可以有形参，可以发生重载；
构造函数只会调用一次，且会自动调用；

析构函数：

1.作用：主要作用于在对象销毁前对其进行清理；
2.语法：~类名+()+{}
3.注意事项：
析构函数没有返回值，但不需要写void；
析构函数函数名与类名一样；
析构函数没有形参，不可以发生重载；
析构函数只会调用一次，且会在程序销毁前自动调用；

编译器强制要求对对象进行初始化和清理，如果我们没有手动进行这些工作，那么编译器会自动帮我们提供构造函数和析构函数，只不过编译器提供的是空实现。

class Info
{
public:
	//构造函数
	Info()
	{
		cout<<"Y"<<endl;
	}
	//析构函数
	~Info()
	{
		cout<<"N"<<endl;
	}
};

int main()
{
	Info A;//只是初始化，并未调用任何成员变量
	return 0;
}

上面代码我们在主函数中没有调用这两个函数，但会自动调用：

初始化列表：

我们可以调用构造函数来进行成员属性初始化，这里还有一种初始化方法，就是利用初始化列表来对成员变量进行初始化。其实际上还是需要调用构造函数。

它的语法是：构造函数名+括号+冒号+属性赋值+大括号

    class Info
{
public:
    //构造函数，这里构造函数接收数据传给变量成员
	Info(int a,int b,string c) :id(a),tel(b),name(c)
	{
		
	}
private:
	int id;
	int tel;
	string name;
};

类对象作为类的成员：

有时候，我们往往需要在一个类中调用另一个类，类似于在一个函数中调用另一个函数。这时候一个类就作为另一个类的成员，这就会带来一些问题，是先调用哪一个类的构造函数，最后释放时，先调用哪个类的析构函数？

1. 如果类A的成员属性包含类B，那么在使用类A时，首先调用类B的构造函数进行初始化，最后再调用类A的构造函数进行初始化；
2. 如果类A的成员属性包含类B，那么在释放内存时，首先调用类A的析构函数，最后再调用类B的析构函数；

构造函数的分类：

构造函数可以有两种分类方法：
1.根据构造函数有无参数可以分为有参构造和无参构造；

	//无参构造函数
	Info()
	{
		cout << "调用无参构造函数" << endl;
	}
	//有参构造函数
	Info(int a)
	{
		cout << "调用有参构造函数" << endl;
	}

2.根据构造函数是否发生拷贝可以分为普通构造函数和拷贝构造函数；

	//无参构造函数
	Info()
	{
		cout << "调用无参构造函数" << endl;
	}
	//拷贝构造函数
	Info(const Info& p)
	{
		cout << "调用拷贝构造函数" << endl;
	}

拷贝构造函数，顾名思义，就是将传进来的类的属性拷贝到新的一个类中，令其在初始化时可以完成一套完整的复制工作；

系统提供的构造函数注意事项：
当用户设定某些构造函数时，系统可能不提供某些构造函数

情况一：用户设置了默认构造函数：
系统还会提供的构造函数：

默认构造函数	×
有参构造函数	√
拷贝构造函数	√

情况二：用户设置了有参构造函数：
系统还会提供的构造函数：

默认构造函数	×
有参构造函数	×
拷贝构造函数	√

情况三：用户设置了拷贝构造函数：
系统还会提供的构造函数：

默认构造函数	×
有参构造函数	×
拷贝构造函数	×

构造函数的调用

构造函数有三种调用方法：小括号调用、显式调用、隐式转换调用；

1.小括号调用：

变量名后面不跟小括号视为调用默认构造函数（无参构造函数）、变量名后跟小括号视情况调用有参构造函数和拷贝构造函数；

	Info A;//调用默认构造函数
	Info B(2);//调用有参构造函数
	Info C(A);//调用拷贝构造函数

注意：若变量名后跟括号但没有参数，那么不会视为默认构造函数调用，将视为函数声明（数据类型为类Info，没有参数，函数名为A）；

Info A();//函数声明

2.显式调用：

显式调用对于三种类型的构造函数分别对应三种调用方法：
1.默认构造函数调用：
与小括号调用类似；

	Info A;

2.有参构造函数调用：
设置一个匿名对象，将其作为等号右边，那么下列语句即可视为调用有参构造函数：

	Info B = Info(2);
	Info(2)//匿名对象

3.拷贝构造函数调用：
与有参构造函数类似，只不过传递参数不同：

	Info C = Info(B);

注意：不可以利用拷贝构造函数来初始化匿名对象（匿名对象一旦创建但未给予名称，随后会被立即销毁），因为编译器会将Info B 与Info (B) 两个表达式等价：

	Info B(10);//有参构造函数调用
	Info(B);//拷贝构造函数初始化匿名对象

拷贝构造函数的调用情景：
1.当我们需要复制一个类的属性副本给另一个类；
2.接收实参类型为类的函数，会自动调用拷贝构造函数创造一份副本形参；
3.当函数返回类，接收的时候会调用拷贝构造函数；

class D
{
public:
	D()
	{
		cout<<"调用默认构造函数" << endl;
	}
	D(const D & p)
	{
		s = p.s;
		cout<<"调用拷贝构造函数" << endl;;
	}
	~D()
	{
		cout<<"调用析构函数" << endl;;
	}
private:
	int s;
};

D func(D var3)//形参，调用拷贝构造函数，类似于D var3=var
{
	D var4;//创建类，调用默认构造函数
	return var4;//返回参数
}

int main()
{
	D var;//创建类，调用默认构造函数
	D var2 = var;//复制一份副本，调用拷贝构造函数，类似于D var2=var
	D var5 = func(var);//接收参数副本，调用拷贝构造函数，类似于D var5=var4
	return 0;
}

3.隐式转换调用：

隐式转换与显式类似：

    Info A;//无参构造函数调用
	Info B = 10;//有参构造函数调用
	//类似于Info B = Info(10);
	Info C = B;//拷贝构造函数调用
	//类似于Info C = Info(B);

深拷贝和浅拷贝

浅拷贝和深拷贝都是对于拷贝构造函数而言的；如果我们的拷贝构造函数将接收的对象属性拷贝到栈区，那么就时浅拷贝；如果拷贝构造函数将接收到的对象属性拷贝到一个新开的堆区，那么就是深拷贝；

浅拷贝容易导致对之前堆区开辟的内存进行多次释放的问题：

这里我们要将Test中的指针属性拷贝到Test2中，结束后调用析构函数中的delete关键字对开辟的堆区进行释放；但这里就有一个问题，因为我们使用的拷贝构造函数进行的是浅拷贝，即直接将一个堆区的地址多次复制粘贴给下一个对象；而最后我们进行销毁时，就会多次访问并释放这同一个空间，造成多次释放。

问题代码如下：

class Info
{
public:
	Info()
	{
		cout << "默认构造函数" << endl;
	}
	Info(int a)
	{
		id = a;
		point = new int(a);
		cout << "有参构造函数" << endl;

	}
	
	//有问题！！！
	//**********************************//
	Info(Info& p)
	{
	    id=p.id;
		point = p.point;
		cout << "拷贝构造函数" << endl;
	}
	//**********************************//
	
	~Info()
	{
		delete point;
		point = NULL;
		cout << "析构函数" << endl;
	}
private:
	int id;
	int* point;
};

int main()
{
	Info Test1(10);
	Info Test2(Test1);
	return 0;
}

于是这里我们选择利用深拷贝，即对指针指向的空间内容在堆区另外开辟一个空间存放，这样就不会对同一块内存进行多次释放，它的拷贝构造函数如下；

Info(Info& p)
	{
		id = p.id;
		point = new int(p.id);
		cout << "拷贝构造函数" << endl;
	}

静态成员：

静态成员变量：
在类中，用static关键字修饰的成员变量就会变成静态成员，它的空间在静态区分配，并且在编程时就已经分配好。静态成员有几个特点：

1. 静态成员必须在类里面声明，在类外一定要初始化（在main函数初始化）
2. 静态成员共用一块内存空间，无论对于哪个对象访问静态成员都只是访问同一块空间；
3. 具体对象只能访问静态成员，所以我们不仅可以通过对象访问静态成员，还可以通过类访问静态成员：

class Info
{
public:
	static int id;
};
int Info::id = 312100;//初始化
int main()
{
	cout << Info::id << endl;
	return 0;
}

4. 静态成员也有权限，如果我们给静态成员设置权限，那么类外也不可以访问；

class Info
{
private:
	static int id;
};
int Info::id = 312100;//初始化
int main()
{
	cout << Info::id << endl;//不可访问
	return 0;
}

静态成员函数：
类似地，我们也有静态成员函数，静态成员函数与静态成员变量类似，都具有共有性，只不过静态成员函数多一个注意事项：静态成员函数只能访问静态成员变量，不能访问其他非静态成员变量。