构造函数是类的一种特殊成员函数。当创建一个类类型的对象时，系统会默认调用构造函数。在C++中，在类中定义的函数，都是可以抽象成一种方法。于是构造函数也是为类的对象服务的一种方法。主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中 。特别的一个类可以有多个构造函数，可根据其参数个数的不同或参数类型的不同来区分它们，即构造函数的重载。
构造函数的要点：
1.构造函数的命名必须和类名完全相同。在java中普通函数可以和构造函数同名，但是必须带有返回值；
2.构造函数的功能主要用于在类的对象创建时定义初始化的状态。它没有返回值，也不能用void来修饰。这就保证了它不仅什么也不用自动返回，而且根本不能有任何选择。而其他方法都有返回值，即使是void返回值。尽管方法体本身不会自动返回什么，但仍然可以让它返回一些东西，而这些东西可能是不安全的；
3.构造函数不能被直接调用，必须通过new运算符在创建对象时才会自动调用；而一般的方法是在程序执行到它的时候被调用的；
4.当定义一个类的时候，通常情况下都会显示该类的构造函数，并在函数中指定初始化的工作也可省略，不过Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的。而一般的方法不存在这一特点；
5.当一个类只定义了私有的构造函数，将无法通过new关键字来创建其对象，当一个类没有定义任何构造函数，C#编译器会为其自动生成一个默认的无参的构造函数。
6.构造函数有回滚的效果，构造函数抛出异常时，构造的是一个不完整对象，会回滚，将此不完整对象的成员释放(c++)
构造函数和析构函数的内容很丰富，暗藏很多内部细节，下面就对这些情况讨论：
//****对象创建时即自动调用构造函数****
#include<iostream>
using namespace std;
class Test
{
public:
Test() //不带参数的构造函数是默认的构造函数,构造函数通常声明为公有的。
{
num=1;
cout<<"Default function!"<<endl;//将这里的赋值和打印语句去掉，
cout<<"num = "<<num<<endl; //就等同于系统默认的构造函数，
//即函数体为空，什么也不做
}
private:
int num;
};
int main()
{
Test a;
return 0;
}程序运行结果：
/***如果不声定义构造函数，系统则默认生成一个不带参数和返回值，
且为空的默认构造函数。
但一旦定义了带参数的构造函数，那么系统则不生成默认的构造函数
演示带参数的构造函数不是系统默认的构造函数***************/
#include<iostream>
using namespace std;
class Test
{
public:
Test(int nu);//带参数的构造函数
{
num=nu;
cout<<"num = "<<num<<endl;
}
private:
int num;
};
int main()
{
Test a;//尝试调用系统默认的构造函数，不成功
return 0;
}此时会报错：找不到默认的构造函数
/****带参数的构造函数,系统不再提供默认的构造函数****/
#include<iostream>
using namespace std;
class Test
{
public:
Test()
{
cout<<"Call default function"<<endl;
}
Test(int nu) //带参数的构造函数,系统不再提供默认的构造函数
{
num=nu;
cout<<"Initialing function!"<<endl;
cout<<"num = "<<num<<endl;
}
private:
int num;
};
int main()
{
Test a(10);//传递参数，调用带参数的构造函数
return 0;
}程序运行结果：
可以看到，默认的构造函数并没有执行。
//******new运算符创建对象时调用构造函数*****
#include<iostream>
using namespace std;
class Test
{
public:
Test(int nu)//带参数的构造函数
{
num=nu;
cout<<"Call Test(**) success!"<<endl;
cout<<"num = "<<num<<endl;
}
private:
int num;
};
int main()
{
Test* t3 = new Test(12);//调用new分配空间的同时，调用构造函数
delete t3;
return 0;
}程序运行结果：
析构函数(destructor) 与构造函数相反，当对象脱离其作用域时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。析构函数不带参数，于是不能被重载。
下面讨论析构函数与构造函数的内容：
/******delete运算符撤销对象时调用析构函数******/
#include<iostream>
using namespace std;
class Test
{
public:
Test(int nu)//带参数的构造函数
{
num=nu;
cout<<"Call Test(**) success!"<<endl;
cout<<"num = "<<num<<endl;
}
~Test()
{
cout<<"num has been distroyed !"<<endl;
}
private:
int num;
};
int main()
{
Test* t3=new Test(12);//调用new分配空间的同时，调用构造函数
delete t3;//使用delete释放t3时，调用析构函数
return 0;<span style="font-family: Arial, Helvetica, sans-serif;">}</span>
/****** delete运算符撤销对象时调用析构函数******/
#include<iostream>
using namespace std;
class Test
{
public:
Test();
Test(int nu);
~Test();
private:
int num;
};
Test::Test()
{
num=0;
cout<<"num = "<<num<<endl;
}
Test::Test(int nu)
{
num=nu;
cout<<"num = "<<num<<endl;
}
Test::~Test()
{
cout<<num<<" has been distroyed !"<<endl;
}
int main()
{
Test t1;
Test t2(10);
Test* t3=new Test(12);//调用new分配空间的同时，调用构造函数
delete t3;//由程序员释放堆上的内存
return 0;
}//花括号运行后，t1,t2被撤销，此时调用析构函数，
//且顺序和调用构造函数相反
/*****全局对象的构造函数先于main函数，析构函数后于main函数**/
#include<iostream>
using namespace std;
class Test
{
public:
Test();
Test(int nu);
~Test();
private:
int num;
};
Test::Test()
{
num=0;
cout<<"num = "<<num<<endl;
}
Test::Test(int nu)
{
num=nu;
cout<<"num = "<<num<<endl;
}
Test::~Test()
{
cout<<num<<" has been distroyed !"<<endl;
}
Test t1(12);//这里先于main函数，调用了构造函数
int main()
{
cout<<"Entering main...."<<endl;
return 0;
}//全局对象的析构后于Main函数
</pre><pre name="code" class="cpp">/****演示对象数组与构造函数和析构函数的关系****/
#include<iostream> using namespace std;
class Test
{
public:
Test();
Test(int nu);
~Test();
private:
int num;
};
Test::Test()
{
num=0;
cout<<"num = "<<num<<endl;
}
Test::Test(int nu)
{
num=nu;
cout<<"Initialing num"<<endl;
cout<<"num = "<<num<<endl;
}
Test::~Test()
{
cout<<num<<" has been distroyed !"<<endl;
}
int main()
{
Test t[2]={10,20};
Test* t2=new Test(2);
delete t2;//最先调用析构函数
Test* t3=new Test[2];//对象创建数组
delete[] t3;//撤销对象数组，调用两次析构函数
return 0;
}//撤销t[1],t[2]，调用两次析构函数
/*******演示显式调用析构函数，尽量不要这样做***/
#include<iostream>
using namespace std;
class Test
{
public:
Test();
Test(int nu);
~Test();
private:
int num;
};
Test::Test()
{
num=0;
cout<<"num = "<<num<<endl;
}
Test::Test(int nu)
{
num=nu;
cout<<"Initialing num"<<endl;
cout<<"num = "<<num<<endl;
}
Test::~Test()
{
cout<<num<<" has been distroyed !"<<endl;
}
int main()
{
Test t2(2);
t2.~Test();//显式调用析构函数
return 0;
}//对象生命周期结束，销毁对象，再次调用析构函数
有关这部分的内容真的很丰富，写了将近3个多小时，好累，就先说到这里。未完待续。。。。
