构造函数

  构造函数和析构函数是两个非常特殊的函数：它们没有返回值。这与返回值为void的函数显然不同，后者虽然也不返回任何值，但还可以让它做点别的事情，而构造函数和析构函数则不允许。在程序中创建和消除一个对象的行为非常特殊，就像出生和死亡，而且总是由编译器来调用这些函数以确保它们被执行。如果它们有返回值，要么编译器必须知道如何处理返回值，要么就只能由客户程序员自己来显式的调用构造函数与析构函数，这样一来，安全性就被人破坏了。另外，析构函数不带任何参数，因为析构不需任何选项。

一 析构函数：

语法 ：~classname()

特点：

1）无任何类型的返回值

2）无参数

调用机制：在对象被销毁时自动调用

~Struct_func(void)

	{
		cout << "我是析构函数" << endl;
	}

   二 构造函数

特点 ：1）方法名与类名相同

2 可以有参数，但不可以有返回值

1 ）无参构造函数

默认构造函数是没有参数的构造函数

class Struct_func{
public:
	Struct_func()
	{

		cout << "无参构造函数" << endl;
	}
	~Struct_func(void)

	{
		cout << "我是析构函数" << endl;
	}
};
void displayStructFunc(void)
{
	Struct_func t1;
}
int main()
{
	/*这里并未显示的调用构造函数，但只是构建一个其对象，会输出：无参构造函数  我是析构函数 */
	displayStructFunc();
	system("pause");
	return 0;
}

2 有参构造函数的二种初始化方式

初始化方式案例：

a1 ：用括号法初始化

a2 ：显示的调用成员函数初始化

class Struct_func{
public:
	Struct_func(int ma,int mb)
	{
		a = ma;
		b = mb;
		cout << "有参构造函数" << endl;
	}
	~Struct_func(void)

	{
		cout << "我是析构函数" << endl;
	}
	Struct_func(int ma)
	{
	
	}
public:
	void print(void)
	{
		cout << "a=:" << a << "  b=:" << b;
	}

private:
	int a;
	int b;
};

int main()
{
#if 0
	/*方法 1*/
	Struct_func t1(1, 2);
	t1.print();
#endif
	/*方法2显示的调用构造函数*/
	Struct_func t2 = Struct_func(9, 0);
	t2.print();
	system("pause");
	return 0;
}

方式2可以衍生为

Struct_func t1 (9, 0);

Struct_func t2 =t1;/*在默认情况下将同一个对象赋值给里一个同类型的对象时，c++将每一个原对象的数据成员内容复制到目标对象对应的数据成员中*/

2 拷贝构造函数的初始化（4中初始化方式）

1）用对对象初始化对象

class Struct_func{
public:
	Struct_func(Struct_func &obj)
	{
		a = obj.a+100;
		b = obj.b+1000;
		cout << "有参构造函数" << endl;
	}
	Struct_func(int _a,int _b)
	{
		a = _a;
		b = _b;
		cout << "有参构造函数" << endl;
	}
	~Struct_func(void)

	{
		cout << "我是析构函数" << endl;
	}	
public:
	void print(void)
	{
		cout << "a=:" << a << "  b=:" << b;
	}
private:
	int a;
	int b;
};
int main()
{
	Struct_func t2(9, 0);
	Struct_func t3(9, 10);
	
	
	/*初始化方式1*/
	Struct_func t1 = t2;//用t2初始化t1，只是将t1的值传递给t2，在执行t2对象时t2对象会根据自己的代码对数据加工
	t1.print();

#if 0
	
	 t1 = t3（5，6）;/*注意：在这个过程中，有的C++编译器会产生一个临时变量用于接收t3传过来的值，然后将该临时变量的值赋值给t1,但是在该临时变量

被销毁时也会调用一次析构函数*/

	t1 = t2;/*注意这种情况是将t2中的数据复制一份给t1，输出结果t1与t2的值完全相同的*/
#endif
	t1.print();

	system("pause");
	return 0;
}

Struct_func t1 = t2;直接用t2初始化t1；

2）用一个已经初始化的对象作为参数传递到另一个对象

class Struct_func{
public:
	Struct_func(Struct_func &obj)
	{
		a = obj.a+100;
		b = obj.b+1000;
		cout << "有参构造函数" << endl;
	}
	Struct_func(int _a,int _b)
	{
		a = _a;
		b = _b;
		cout << "有参构造函数" << endl;
	}
	~Struct_func(void)

	{
		cout << "我是析构函数" << endl;
	}	
public:
	void print(void)
	{
		cout << "a=:" << a << "  b=:" << b;
	}
private:
	int a;
	int b;
};
int main()
{
	Struct_func t2(9, 0);
	Struct_func t3(9, 10);
	
	/*初始化方式2*/
	Struct_func t1(t2);
#if 0
	
	Struct_func t1 = t2;
	t1 = t2;/*注意这种情况是将t2中的数据复制一份给t1，输出结果t1与t2的值完全相同的*/
#endif
	t1.print();

	system("pause");
	return 0;
}

Struct_func t1(t2);将t2以参数的形式传入到t1；

注意  t1 = t2;这种复制操作是不会调用拷贝构造函数的

3）在做参数传递的时候调用拷贝构造函数

4）在返回一个对象是调用拷贝构造函数并创建匿名对象

class Struct_func{
public:
	Struct_func(Struct_func &obj)
	{
		a = obj.a+100;
		b = obj.b+1000;
		
		cout << "拷贝构造函数" << endl;
	}
	Struct_func(int _a,int _b)
	{
		a = _a;
		b = _b;
		cout << "有参构造函数" << endl;
	}
	~Struct_func(void)

	{
		cout << "我是析构函数" << endl;
	}	
	int Get_A(void)
	{
		return a;
	}
public:
	void print(void)
	{
		cout << "a=:" << a << "  b=:" << b;
	}
private:
	int a;
	int b;
};
Struct_func constructor()
{
	Struct_func oppa(10, 9);//初始化有参构造函数并调用有参构造函数
	return oppa;//创建一个匿名对象并且执行拷贝构造函数，在本程序退出时自动销毁，所以在本程序中会
	//一次调用有参构造函数一次调用拷贝构造函数，在函数推出时会调用一次析构函数析构oppa对象，调用一次析构函数
	//析构匿名对象
}
void disp()
{
	constructor();
}
int main()
{	
	disp();
	system("pause");
	return 0;
}

可以参考博客地址：http://blog.chinaunix.net/uid-28977986-id-3977861.html