首先，我们创建完一个类后，当我们需要对类进行初始化；而当我们完成工作后，需要对类进行清理。这些工作，分别需要调用构造函数和析构函数。
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.根据构造函数有无参数可以分为有参构造和无参构造；
//无参构造函数
Info()
{
cout << "调用无参构造函数" << endl;
}
//有参构造函数
Info(int a)
{
cout << "调用有参构造函数" << endl;
}
2.根据构造函数是否发生拷贝可以分为普通构造函数和拷贝构造函数；
//无参构造函数
Info()
{
cout << "调用无参构造函数" << endl;
}
//拷贝构造函数
Info(const Info& p)
{
cout << "调用拷贝构造函数" << endl;
}
拷贝构造函数，顾名思义，就是将传进来的类的属性拷贝到新的一个类中，令其在初始化时可以完成一套完整的复制工作；
系统提供的构造函数注意事项：
当用户设定某些构造函数时，系统可能不提供某些构造函数
情况一：用户设置了默认构造函数：
系统还会提供的构造函数：
| 默认构造函数 | × |
|---|---|
| 有参构造函数 | √ |
| 拷贝构造函数 | √ |
情况二：用户设置了有参构造函数：
系统还会提供的构造函数：
| 默认构造函数 | × |
|---|---|
| 有参构造函数 | × |
| 拷贝构造函数 | √ |
情况三：用户设置了拷贝构造函数：
系统还会提供的构造函数：
| 默认构造函数 | × |
|---|---|
| 有参构造函数 | × |
| 拷贝构造函数 | × |
构造函数有三种调用方法：小括号调用、显式调用、隐式转换调用；
变量名后面不跟小括号视为调用默认构造函数（无参构造函数）、变量名后跟小括号视情况调用有参构造函数和拷贝构造函数；
Info A;//调用默认构造函数
Info B(2);//调用有参构造函数
Info C(A);//调用拷贝构造函数
注意：若变量名后跟括号但没有参数，那么不会视为默认构造函数调用，将视为函数声明（数据类型为类Info，没有参数，函数名为A）；
Info A();//函数声明
显式调用对于三种类型的构造函数分别对应三种调用方法：
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;
}
隐式转换与显式类似：
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关键字修饰的成员变量就会变成静态成员，它的空间在静态区分配，并且在编程时就已经分配好。静态成员有几个特点：
class Info
{
public:
static int id;
};
int Info::id = 312100;//初始化
int main()
{
cout << Info::id << endl;
return 0;
}
class Info
{
private:
static int id;
};
int Info::id = 312100;//初始化
int main()
{
cout << Info::id << endl;//不可访问
return 0;
}
静态成员函数：
类似地，我们也有静态成员函数，静态成员函数与静态成员变量类似，都具有共有性，只不过静态成员函数多一个注意事项：静态成员函数只能访问静态成员变量，不能访问其他非静态成员变量。