C++中的构造函数
C++中的构造函数可以分为4类：

（1）默认构造函数。以Student类为例，默认构造函数的原型为

Student(）；//没有参数

（2）初始化构造函数

Student(int num，int age）；//有参数

（3）复制（拷贝）构造函数

Student(Student&）；//形参是本类对象的引用

（4）转换构造函数

Student(int r)   ；//形参时其他类型变量，且只有一个形参
默认和初始化构造函数
默认构造函数和初始化构造函数在定义类的对象的时候，完成对象的初始化工作。
class Student
{
public:
	//默认构造函数
	Student()
	{
	   num=1001;
       age=18;	   
	}
	//初始化构造函数
	Student(int n,int a):num(n),age(a){}
private:
	int num;
	int age;
};
int main()
{
	//用默认构造函数初始化对象S1
	Student s1;
	//用初始化构造函数初始化对象S2
	Student s2(1002,18);
	return 0;
}
复制（拷贝）构造函数##

复制构造函数用于复制本类的对象

 Student  s2（1002,1008）；
 Student  s3（s2）;//将对象s2复制给s3。注意复制和赋值的概念不同。
1
2

下面这种情况叫做赋值，不调用复制构造函数。

 Student s4;
 s4=s2;//这种情况叫做赋值，自己体会吧
1
2

大多数时候，在类中我们没有声明复制构造函数，而是C++自动为我们生成了一个复制构造函数，如下：

 Student(Student &b)
	{
		this.x=b.x;
		this.y=b.y;
	}
1
2
3
4
5

如代码所示，它的作用是将一个已存在的对象b，复制给调用该复制构造函数的对象。
具体来说，在一下情况发生时，会调用复制构造函数：


用复制的方法，建立一个新对象。
函数的形参为类的对象时。（这点和普通类型的形参类似，要复制一份实参给函数）
函数的返回值是类的对象，在函数中定义的对象，在函数结束后消息，需要调用复制构造函数，建立一个临时的对象，将该临时对象返回给调用该函数的对象。
默认的复制构造函数，在某些情况下会出现问题，想深入学习可以自行百度。

转换构造函数

转换构造函数用于将其他类型的变量，隐式转换为本类对象。
下面的转换构造函数，将int类型的r转换为Student类型的对象，对象的age为r，num为1004.

 Student(int r)
 ｛
	 int num=1004；
	 int age= r；
 ｝
1
2
3
4
5

转换构造函数可以用在哪里？
假如重载了+号运算符，使得两个Student类的对象可以相加，其结果为两个对象的成员变量age之和。

Student s1(01,18);
Student s2(02,20);
s1+s2;  //其值就是s1.age + s2.age = 18+20=36。
1
2
3

**那么  s1+19 呢(类对象与int直接相加）？ **
因为我们定义了 转换构造函数，那么  s1+19，执行如果过程：


首选调用+号运算符，发现19不是Student类的对象，而是int类型
然后调用转换构造函数，将19变为Student（19）
现在便可以进行加法运算，其值是s1.age+ (TempStudentObject).age=18+19 = 37


这里只是很浅的讲了这几类构造函数的基本概念，如果希望深入学习，网上有很多参考资料.

编译环境（vc6.0）

c++支持两种初始化形式：直接初始化和复制初始化。
直接初始化直接调用与实参匹配的构造函数，复制初始化总是调用复制构造函数。
直接初始化的例子：
string dots(10,'a');
复制初始化的例子：
(1)用类的一个对象去初始化另一个对象
cat cat1；
cat cat2(cat1);
(2)用类的一个对象去初始化另一个对象的另一个例子
cat cat2 = cat1;
(3)对象作为参数传递
f(cat a){}(如果作为引用，则不调用)
(4)对象作为函数的返回值
cat f()
{
cat a;
return  a;
}
(如果参数是引用，且返回的是参数的引用，则不调用)
由此可见：
直接初始化是利用基本数据类型等作为构造函数的参数。
复制初始化是利用一个对象作为拷贝构造函数的对象。
 
赋值运算符的几种情况：
(1)在定义变量同时初始化
String demo3 = demo1+demo2；
此时还要看加法运算符的重载的返回值，才能确定是调用拷贝构造函数还是构造函数
(2)先定义变量再初始化
String demo3；
demo3 = demo1+demo2；
此时还要看加法运算符的重载的返回值，才能确定是调用拷贝构造函数、构造函数还是复制运算符重载
 
下边的讨论我们主要针对构造函数，拷贝构造函数，赋值运算符重载的调用！
#include <iostream>
#include <string>
using namespace std;

class String
{
	char name[256];
public:
	String(char* str)
	{
		cout<< str <<"构造" << endl;
		strcpy(name,str);
	}
	String(String &s)
	{
		cout<< "拷贝构造"<< endl;
		strcpy(name,s.name);
	}
	String()
	{
		cout<<"默认构造"<<endl;
	}
	~String(){}
	String operator+(const String&);
	void operator=(const String&s)
	{
		strcpy(name,s.name);
		cout<<"赋值运算"<<endl;
	}
	void display()
	{
		cout << "The String is:" << name << endl;
	}
};

static char* str;

String String::operator +(const String&a)
{
	String s;
	cout<<"加法运算"<<endl;
	strcpy(s.name,name);
	strcat(s.name,a.name);
	return s;
	/*strcpy(str,name);
	strcat(str,a.name);
	return String(str);*/
}

void main()
{
	str = new char[256];
	String demo1("Virsual c++");
	String demo2("6.0");
	//demo1.display();
	//demo2.display();
	//String demo3;
	//demo3 = demo1 + demo2;
	String demo3 = demo1 + demo2;
	demo3.display();
	/*String demo4 = demo3 + "Programming";
	demo4.display();
	delete str;
	cout<<"-----------"<<endl;
	String demo5;
	demo5 = demo4;
	demo5.display();*/
}


这个例子通过修改可以得到不同的结果：（大家最好实验，不然很难理解）
我们主要讨论String demo3 = demo1 + demo2;的运行结果
（1）运算符的位置在定义的同时初始化。只可能调用构造函数和拷贝构造函数！
String demo3 = demo1 + demo2;
因为重载的加法运算符的返回值是对象，则调用拷贝构造函数。
（2）如果加法运算符改变 
String String::operator +(const String&a)
{
	cout<<"加法运算"<<endl;
	/*String s;	
	strcpy(s.name,name);
	strcat(s.name,a.name);
	return s;*/
	strcpy(str,name);
	strcat(str,a.name);
	return String(str);
}
因为函数返回的形式是构造函数，则调用构造函数而不是拷贝构造函数
可见不一定函数要求返回类的对象，就一定调用拷贝构造函数。
（3）先定义变量后初始化。
String demo3; demo3 = demo1 + demo2;
加法运算符的形式
String String::operator +(const String&a)
{
	cout<<"加法运算"<<endl;
	String s;	
	strcpy(s.name,name);
	strcat(s.name,a.name);
	return s;
	/*strcpy(str,name);
	strcat(str,a.name);
	return String(str);*/
}
因为复制运算符位置的改变，并且加法运算符重载返回的是局部对象。
则会调用复制构造函数后再调用赋值运算符重载。
加法运算符的形式
String String::operator +(const String&a)
{
	cout<<"加法运算"<<endl;
	/*String s;	
	strcpy(s.name,name);
	strcat(s.name,a.name);
	return s;*/
	strcpy(str,name);
	strcat(str,a.name);
	return String(str);
}
由于返回形式的变化，则只调用构造函数。
（4）如果复制运算符没有重载

加法运算符的形式
String String::operator +(const String&a)
{
	cout<<"加法运算"<<endl;
	String s;	
	strcpy(s.name,name);
	strcat(s.name,a.name);
	return s;
	/*strcpy(str,name);
	strcat(str,a.name);
	return String(str);*/
}
则只调用拷贝构造函数。
加法运算符的形式
String String::operator +(const String&a)
{
	cout<<"加法运算"<<endl;
	/*String s;	
	strcpy(s.name,name);
	strcat(s.name,a.name);
	return s;*/
	strcpy(str,name);
	strcat(str,a.name);
	return String(str);
}
则调用构造函数。

上面我是针对课本上的一个程序，总结的这几种函数的调用问题
因为上边的内容我只是想测试各种函数的调用问题，可能某种情况的出现实不允许的，例如如果该类中有指针，则必须有赋值运算符的重载。
 
有两种情况一般要编写拷贝构造函数和赋值运算符重载（拷贝构造，赋值运算符重载一般一起出现）
1.类中含有指针的成员变量。
2.在创建对象时要进行初始化。
 
拷贝构造与赋值运算符重载区别
复制运算符比拷贝构造做更多的东西，因为他要涉及到原有内容的丢弃和新内容的复制
这部分内容请参考：http://www.vckbase.com/document/viewdoc/?id=788
 
可能由于我的认识有限，请大家多提意见！
 

在学习C++的类时，碰到了构造函数，而关于构造函数又引申出了复杂情况下构造函数的调用顺序。看视频讲解、敲示例代码，算是大概清楚了调用次序，为了今后查询，特意在此记录一下。

 

构造函数：创建类对象时，初始化对象
	
复制构造函数：用已经存在的类对象，初始化一个新创建的同类型的类对象
复制构造函数调用的情况有三种：

1、用已存在的类对象，去初始化一个新创建的类对象

2、类对象作为函数的实参

3、类对象作为函数的返回值

组合类的构造函数：类的成员是另一个类的对象
当上述三个在一起出现时，各自的调用顺序是如何。也就是什么时候调用构造函数，什么时候调用复制构造函数，什么时候调用组合类的构造函数，而什么时候又调用组合类的复制构造函数？？

以下的程序可以解释在上述都存在的情况下，调用次序。

#include <iostream>
using namespace std;

//点类
class Point {
public:
	Point(int newX, int newY);//自定义构造函数
	Point();//默认构造函数
	Point(const Point& p);//复制构造函数
	int getX() {
		return x;
	}
	int getY() {
		return y;
	}
private:
	int x;
	int y;
};

//自定义构造函数实现
Point::Point(int newX, int newY) :x(newX), y(newY) {
	cout << "Calling constructor of Point." << endl;
}
//默认构造函数实现
Point::Point() :x(0), y(0) {}

//复制构造函数实现
Point::Point(const Point& p) {
	x = p.x;
	y = p.y;
	cout << "Calling copy constructor of Point." << endl;
}


//线类
class Line {
public:
	Line(Point xp1, Point xp2);//组合类构造函数
	Line(Line& l);//组合类的复制构造函数
	double getLen() { return len; }
private:
	Point p1, p2;
	double len;
};

//组合类构造函数的具体实现
Line::Line(Point xp1, Point xp2) :p1(xp1), p2(xp2) {
	cout << "Calling constructor of Line." << endl;
	double x = static_cast<double>(p1.getX() - p2.getX());
	double y = static_cast<double>(p1.getY() - p2.getY());
	len = sqrt(x * x + y * y);
}

//组合类的复制构造函数具体实现
Line::Line(Line& l) :p1(l.p1), p2(l.p2) {
	cout << "Calling the copy constructot of Line." << endl;
	len = l.len;
}


int main() {

	Point myp1(1, 1), myp2(5, 5);//建立point类的对象
	Line myL1(myp1, myp2);//利用已存在的point对象，去建立line类的对象
	Line myL2(myL1);//利用line的复制构造函数建立一个新的对象
	cout << "The length of myL1 is:" << myL1.getLen() << endl;
	cout << "The length of myL2 is:" << myL2.getLen() << endl;

	return 0;
}

1、创建Point类对象myp1和myp2时，调用Point类的构造函数

2、利用已经存在的Point类对象构建并初始化Line类对象，而这其中：

根据vs情况下的调试跟踪，向myL1传参时的顺序是先传入myp2，再传入myp1。

创建对象myL1时，需要调用Line类的构造函数，由构造函数的形参是对象，首先需要形实结合，才能进入函数主体。

在形实结合时，结合复制构造函数的调用情况，可知会调用两次Point类的复制构造函数。

然后进行初始化，又结合复制构造函数的调用情况，可知会调用两次Point类的复制构造函数。

之后，进入Line构造函数主体。

3、创建Line类对象myL2时，考虑到是类初始化类，因此需要调用Line类的复制构造函数。而在此之前，涉及到形参初始化，需要先调用两次Point类的复制构造函数。

至此，整个调用顺序大致流程如上。

附上vs调试的结果图



 

1.构造函数和复制构造函数相关的初始化
最近由于项目比较闲，自己自学了一些C++的知识，也在博客上总结一下。
首先理解“初始化”和“赋值”，一个新对象创建时，才会有初始化操作，初始化操作出现在构造函数中；而赋值是用来修改一个已经存在的对象的值，出现在operator=操作函数中。
1.1复制构造函数
用同一个类产生的另外一个对象的值来为将要被创建的对象进行初始化，执行这样的初始化操作的构造函数也被称为复制构造函数，它的格式如下：

　　class Complex 
　　{
　　public:
　　	Complex(double, double);//普通构造函数
　　	Complex(const Complex&);//复制构造函数
　　};
如果我们没有在类中声明一个复制构造函数，编译器也会为我们合成一个，这个缺省的复制构造函数会将新对象中的每个数据成员初始化为源对象中相应成员的值。


1.1.1缺省的复制构造函数的行为是否符合我们的会符合我们的要求


　　普通的：）
　　class Complex
　　{
　　private:
　　	double real_d;
　　	double imag_d;
　　public:
　　	Complex(double r, double i):real_d(r), imag_d(i){}
　　//....
　　};

如上这种没有明确声明的复制构造函数，它的行为就是复制两个数据成员，这符合我们预期的操作，是ok的
　　（特别的：）
　　class String 
　　{
　　private:
　　	char* data;
　　public:
　　	String(const char* cp = "");
　　	~String() {delete [] data;}	
　　};
　　String::String(const char* cp):data(new char[strlen(cp)+1])
　　{
　　	strcpy(data, cp);
　　}
如上这种缺省的复制构造函数就不符合我们的预期了，应为如果有多个String对象，它会指向同一块内存，如果释放一个String对象，其它的也会被释放所以我们必须明确的声明复制构造函数：
　　class String 
　　{
　　private:
　　	char* data;
　　public:
　　	String(const char* cp = "");
　　	String(const String&);
　　	~String() {delete [] data;}	
　　};
　　String::String(const String& s):data(new char[strlen(s.data)+1])
　　{
　　	strcpy(data, s.data);
　　}
这样就能确保每个String都会拥有一份数据的私有拷贝
对于缺省的复制构造函数是否能够正常工作，并没有一个通用的规则。从经验中得到的方法就是：对于包含指针的类要特别注意，如果被指向的对象是“属于”该类产生的对象，那么缺省的复制构造函数就有可能是错误的，因为它只是简单的复制了指针，而不是指针所指向的对象。复制构造函数在编码过程中是不可被忽略的！
1.2类成员的初始化
当类中的某个数据成员本身也是一个类对象时，我们应该避免用赋值操作来为该成员进行初始化，如下：
　　class Employee 
　　{
　　private:
　　	String name;
　　public:
　　	Employee(const String&);
　　};
　　
　　Employee::Employee(const String& n)
　　{
　　	name = n;//效率不高
　　}
这样做虽能得到正确结果，但效率并不高，因为一个新Employee对象被创建时，成员name先将会被String的缺省构造函数所初始化，而在Employee的构造函数中又会被初始化一次，所以这样做效率不高。我们可以把它合并成一步如下：

　　class String 
　　{
　　public:
　　String();
　　	String(const String&);
　　};
　　class Employee 
　　{
　　private:
　　	String name;
　　public:
　　	Employee(const String&);
　　};
　　Employee::Employee(const String& n):name(n){}

    我们用String::String(n)，这样编译器就只会用一次函数调用来初始化namne这个成员，在效率上会有30%的提升。同样，那些内建类型的成员也可以用这种初始化列表的方式来进行初始化，这样做会使代码的可读性更高。

1.3成员初始化的顺序

    C++中规定：一个类中的成员的初始化顺序和它在类中被声明的顺序(而不是构造函数定义的顺序)必须是一致的。忽略这种顺序在一些情况下不会有影响，但在某些场合下，就会导致问题，比如：某个成员的初始化过程中使用了另外成员的值，那么“另外成员”的初始化就必须在“某个成员”的前面了。一般我们最好在头文件把这种顺序记录下来，这样会给我们带来便利。
1.4类成员的引用
    如果在类中某个非静态数据成员是一个引用的话，因为所有的引用都必须被明确的初始化，所以我们必须在该类的每个构造函数中都使用初始化语法：

　　Class Payroll_entry
　　{
　　Private:
　　Employee& emp;
　　Public:
　　Payroll_entry(Employee&);
　　};
　　Payroll_entry::Payroll_entry(Employee& e){}//编译错误：“emp”必须被初始化

    所以我们在设计类的时候，为什么要将emp声明为Employee&，而不是Employee*呢？因为声明为引用会有下面两方面的限制：
1.我们必须在创建emp的时候就必须初始化
2.一旦绑定初始化后，emp就能不改变