构造函数与析构函数详解
构造函数
构造函数的特点：以类名作为函数名，无返回类型。
如果创建一个类程序员没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做。构造函数就是构造一个类对象会运行的函数。
eg：
Counter(){}
只要程序员写了某种构造函数，系统就不会再自动生成这样一个默认的构造函数。
构造函数是一类特殊的函数，与其他的成员函数不同的是构造函数构造函数不需要用户来调用它，而是建立对象的时候自动的执行。
该类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数->由构造函数完成成员的初始化工作。
构造函数的作用：初始化对象的数据成员
构造函数种类：
1． 一般构造函数（也称重载构造函数）一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）创建对象时根据传入的参数不同调用不同的构造函数。
Eg: Complex(void)
{
m_real = 0.0;
m_imag = 0.0;
}
Complex(double real, double imag)
{
m_real = real;
m_imag = imag;
}
2． 复制构造函数（也称为拷贝构造函数）
复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中。
若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询 有关 “浅拷贝” 、“深拷贝”的文章论述。
Eg: Complex(const Complex & c)
{
// 将对象 c中的数据成员值复制过来
m_real = c.m_real;
m_imag = c.m_imag;
}
//当用一个对象a去初始化另外一个对象b时，会触发复制构造函数，当b被第二次被赋值时，不会执行构造函数。b的生命周期被销毁时，会去执行析构函数，销毁b当中最新的数据。
3． 等号运算符重载（也叫赋值构造函数）
它不属于构造函数，等号左右两边的对象必须已经被创建
注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，
若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作。
Eg: Complex &operator=( const Complex &rhs )
{
// 首先检测等号右边的是否就是左边的对象本身，若是本对象本身,则直接返回
if ( this == &rhs )
{
return *this;
}
// 复制等号右边的成员到左边的对象中
this->m_real = rhs.m_real;
this->m_imag = rhs.m_imag;
// 把等号左边的对象再次传出
// 目的是为了支持连等 eg: a=b=c 系统首先运行 b=c
// 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)
return *this;
}
实例：
Eg:
int main()
{
// 自动调用了无参构造函数，数据成员初值被赋为0.0
Complex c1，c2;// 如果定义一个对象时没有提供初始化式，就使用默认构造函数。
//自动调用有两个函数的构造函数，数据成员初值被赋为指定值
Complex c3(1.0,2.5);
// 也可以使用下面的形式
Complex c3 = Complex(1.0,2.5);
// 把c3的数据成员的值赋值给c1
// 由于c1已经事先被创建，故此处不会调用任何构造函数
// 只会调用 = 号运算符重载函数，应为c1和c3已被定义。
c1 = c3;
// 调用类型转换构造函数
// 系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1
c2 = 5.2;
// 调用拷贝构造函数( 有下面两种调用方式) //此时只执行显示定义复制构造函数。
Complex c5(c2);
Complex c4 = c2; // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2
//这一点特别重要，这儿是初始化，不是赋值。其实这儿就涉及了C++中的两种初始化的方式：复制初始化和赋值初始化。其中c5采用的是复制初始化，而c4采用的是赋值初始化，这两种方式都是要调用拷贝构造函数的。
}
二．析构函数
在设计一个类的时候，如果我们一个构造函数都没有写，那么 C++ 会帮我们写一个构造函数。只要我们写了一个构造函数，那么 C++ 就不会再帮我们写构造函数了。
析构函数特点：析构函数是这样写的： 函数名前面都加了一个 ~ 符号。 析构函数都是没有参数，也就是说：析构函数永远只能写一个。
析构函数作用：析构函数是用来撤销对象，释放资源，它与构造函数对应。释放了之后，这些资源就会被回收，可以被重新利用。析构函数, 在类的声明周期结束的时候运行的函数。
比如说，我们在构造函数里打开文件，在析构函数里关闭打开的文件。这是一个比较好的做法。
在构造函数里，我们去连接数据库的连接，在析构函数里关闭数据库的连接。
在构造函数里动态的分配内存，那么在析构函数里把动态分配的内存回收。
如果我们写的类是一个没有那么复杂的类，我们可以不需要写析构函数。如果一个类只要有这些情况：打开文件、动态分配内存、连接数据库。简单的说：就是只要构造函数里面有了 new这个关键词，我们就需要自己手动编写析构函数。
那么如果我们写了析构函数，就必须要注意三法则：同时编写：析构函数、赋值构造函数、赋值运算符。
#include <iostream>
#include <string>
using namespace std;
class NoName{
public:
NoName():pstring(new std::string)
, i(0), d(0){
cout << "构造函数被调用了！" << endl;
}
NoName(const NoName & other);
~NoName();
NoName& operator =(const NoName &rhs);
private:
std::string * pstring;
int i;
double d;
};
NoName::~NoName(){
cout << "析构函数被调用了！" << endl;
}
NoName::NoName(const NoName & other){
pstring = new std::string;//
*pstring = *(other.pstring);//将内容进复制
i = other.i;
d = other.d;
}
NoName& NoName::operator=(const NoName &rhs){
pstring = new std::string;
*pstring = *(rhs.pstring);
i = rhs.i;
d = rhs.d;
return *this;
}
int main(){
NoName a;
NoName *p = new NoName;
delete p;
return 0;
}
注：创建一个对象的数组时，分别为每一个调用了构造函数，删除一个动态数组对象的时候系统帮你自动为每一个调用了析构函数。
#include <string>
#include <iostream>
using namespace std;
class Fruit //定义一个类，名字叫Fruit
{
string name; //定义一个name成员
string colour; //定义一个colour成员
public:
void print() //定义一个输出名字的成员print()
{
cout<<colour<<" "<<name<<endl;
}
Fruit(const string &nst = "apple",const string &cst = "green"):name(nst),colour(cst)
{
cout <<"Aha,I'm "<<name<<". I have created!"<<endl;
} //构造函数
Fruit(Fruit &aF) //还记得我吗?我是复制构造函数
{
name = "another " +aF.name;
}
~Fruit()
{
cout <<"Dame it!"<<"I'm "<<name<<". And who killed me?"<<endl;
}
};
int main()
{
cout<<"main begin"<<endl;
cout<<"created *P"<<endl;
{
Fruit *p = new Fruit[10];
cout<<"created another apple"<<endl;
Fruit apple(*p);
cout<<"delete p"<<endl;
delete []p;//new []和delete []对应，new 和delete 对应，
}
cout<<"main end"<<endl;
return 0;
}