C++构造函数和析构函数的总结

C++是面向对象的编程语言，在定义类的时候，离不开构造函数和析构函数。构造函数的形式很容易辨别，在类中与类同名的成员函数称为构造函数，在初始化一个对象时，如果有初始化数据，先传入到构造函数中，再通过构造函数赋值到类的成员变量中。所以构造函数相当于一个中介，是向封装好的类初始化数据。另外，需要注意的地方是，类有构造函数的情况下，且构造函数需要传参，则初始化对象时必须要传参。这样可以避免垃圾数据。

构造函数允许重载，所以在实例化对象的时候，可以根据传入参数的不同选择不同的构造函数，但是只会执行其中的一个，具体执行哪一个，按照传入的参数。具体如下：

#include<iostream>
using namespace std;
class ABC{
int data;
string name;
public:
ABC(int d,const char* ch):data(d),name(ch){}
ABC(ABC & a){
data=a.data;
name=a.name;
}
~ABC(){}
};
int main(){
ABC b(13,"bob");
ABC a(b);
return 0;
}

这样对象a，b中的数据都是13和“bob”。但是a是b 的副本，即在定义a的时候，调用了拷贝构造函数

<pre name="code" class="cpp"><span style="font-size:10px;">ABC(ABC & a){
data=a.data;
name=a.name;
}</span>

实质上，如果不在类中显式的定义拷贝构造函数，类也会定义一个默认的拷贝构造函数，完成所有成员的逐个复制。

说到这，介绍一个很重要的概念--默认构造函数。默认构造函数与默认拷贝构造函数不同，默认构造函数无参，若用户没有编写构造函数，编译器会产生一个默认构造函数，这个构造函数什么也不做，若定义了构造函数，则不会产生默认构造函数。注意默认构造函数与默认拷贝构造函数不同，两个虽然都是在没有定义构造函数的情况下产生，但是两个是完全不同的函数，默认构造函数是无参函数，并且什么都不做，只是一个空头衔。但是默认拷贝构造函数需要传参，形参是类对象，且需要完成所有成员的逐个复制。

析构函数：类名作为函数名，在前面加上~。析构函数不允许重载，并且析构函数无参

通常情况下对象在程序结束的时候会自动调用析构函数，但是需要注意的是动态分配内存的情况。

例：

ABC* p=new ABC(12,"Jone");
delete p;

new 的地方分配内存，会自动调用类的构造函数；delete的地方释放内存，会自动调用析构函数。
在类对象作为函数的传入参数和函数的返回对象时，注意没有引用的情况下，实质上会调用构造和析构函数，例如下：

#include<iostream>
using namespace std;
class ABC{
int data;
string name;
public:
ABC(int d,const char* ch):data(d),name(ch){cout<<"调用构造"<<endl;}
ABC(ABC & a){
data=a.data;
name=a.name;
cout<<"调用拷贝构造"<<endl;
}
~ABC(){cout<<"调用析构"<<endl;}
};
ABC func(ABC a){
return a;
}
int main(){
ABC a(123,"bob");
ABC b(12,"zhangsan");
b=func(a);

return 0;
}

调用func函数过程中，会两次调用拷贝构造函数，两次调用析构函数。结果如下：



原因是在调用函数func时，传入参数为ABC a的形式，其实这个时候编译器会创建一个对象a的拷贝对象。也就是调用了一次拷贝构造函数，再返回的时候，又创建了一个返回对象的拷贝对象，所以又调用了一次拷贝构造函数。所以在那个函数结束的时候会调用两次析构函数。另一种情况，如果带引用，会是什么样，改写成：

ABC& func(ABC& a)

传入的时候只是传入a的引用，返回的时候也只是a的引用，所以不需要创建新的对象。C++中引用的作用很重要，在函数中能用引用的尽量用引用，一些我们容易忽略的地方，往往会造成意想不到的结果。

最后补充一种特殊的容易出问题的情况：

实例：用拷贝构造函数的时候注意重复释放同一块内存的问题

#include<iostream>
using namespace std;
class F{
string* str;
public:
F(string* mem):str(mem){}
~F(){
delete str;
}
};
int main(){
F f1=new string;
F f2=f1;//初始化f2调用拷贝构造函数，将f1的一切复制到f2上，也即f2中的str和f1中的str指向同一块内存，两次析构时，会重复释放
return 0;
}

这是一个很简单的程序，编译的时候没有问题，但是运行的时候出问题，问题是重复释放同一块内存。

解决方法：

1、加上一个静态计数器，如下

#include<iostream>
using namespace std;
class F{
string* str;
static int cnt;
public:
F(string* mem):str(mem){cnt++;}
F(const F& a){
*this=a;
cnt++;
}
~F(){
if(--cnt==0)
delete str;
}
};
int F::cnt=0;//静态成员变量要在类外定义
int main(){
F f1=new string;
F f2=f1;
return 0;
}

2、拷贝构造函数时，再分配一块新的内存空间

同样的问题也会发生在赋值运算符。同样会造成重复释放一块内存，这个时候还需要重载赋值运算符。

总结起来就是：当成员变量是指针指向动态内存的时候，三个地方需要改动：1.拷贝构造函数；2.operator=；3.析构函数。