0. 什么是构造函数

1. 默认构造函数

2. 一般构造函数

3. 拷贝构造函数

4. 转换构造函数

5. 移动构造函数

0. 什么是构造函数

在定义类的成员函数的时候，一般的成员函数与普通的全局函数没有太大的区别，在定义函数的时候都需要说明要返回的类型，比如：

int fun() {};  //返回int类型
void fun() {};  //什么都不返回

但是，类中有一种函数比较特殊，函数名与类名相同，且没有返回值类型，这中函数称为构造函数，它承担着类初始化的工作，非常重要。

常用的构造函数有默认构造函数、一般构造函数、拷贝构造函数、转换构造函数、移动构造函数。

1. 默认构造函数

首先要有一个概念，一个类时必有构造函数的，即便程序员没有手动定义构造函数，编译器也会创建一个默认构造函数，具体形式如下：

ClassName(){};

这是一个空的函数，即什么都不做。当然，实际上，默认构造函数也不是空的，这里只是简化一下，不作深究。

还值得注意的是，默认构造函数不止有一个，编译器还会创建其他类型的构造函数，比如，拷贝构造函数，这些后边再说。

所以，现在有一个认识就行，那就是如果程序员不手动定义构造函数，编译器会自动定义默认构造函数，即便这个构造函数可能什么都不做。

2. 一般构造函数

当程序员手动定义构造函数之后，编译器便不再生成默认构造函数。构造函数一般承担初始化工作，比如对成员变量初始化，看个栗子：

#include <iostream>
using namespace std;class Person {
public:int age;char* name;Person(int age, char* name) {this->age = age;this->name = name;}
};int main(){Person p(12,"kang");cout<<p.age<<endl;cout<<p.name<<endl;
}

运行结果：

构造函数支持重载，也就是说，可以有多个同名构造函数，不过他们的形参需要有区别。看栗子：

#include <iostream>
using namespace std;class Person {
public:int age;char* name;Person();Person(int age, char* name);Person(char* name);};Person::Person() {this->age = -1;this->name = "-1";
}Person::Person(int age, char* name) {this->age = age;this->name = name;
}Person::Person(char* name) {this->age = -1;this->name = name;
}int main(){Person p1(12,"kang");cout<<p1.age<<"  "<<p1.name<<endl;Person p2;cout<<p2.age<<"  "<<p2.name<<endl;Person p3("kang");cout<<p3.age<<"  "<<p3.name<<endl;
}

运行结果：

3. 拷贝构造函数

类在实例化的时候，有两步操作：

给对象分配内存，此时内存没有经过初始化，成员变量大多都是垃圾值；
对内存进行初始化，也就是调用构造函数对成员变量进行初始化。

对于一般构造函数，初始化的值来自于构造函数的输入参数，如果某个构造函数的输入参数是同类的对象，则称该构造函数为拷贝构造函数。

说白了，拷贝构造函数就是用别的对象来初始化新对象的内存。看一个栗子：

#include <iostream>
using namespace std;class Person {
public:int age;char* name;Person(int age, char* name);  //一般构造函数Person(const Person &p);  //拷贝构造函数  };Person::Person(int age, char* name) {this->age = age;this->name = name;
}Person::Person(const Person &p) {this->age = p.age;this->name = p.name;
}int main(){Person p1(12,"kang");   //调用一般构造函数Person p3(14,"wang");Person p2 = p1;      //调用拷贝构造函数,等效于 Person p2(p1);cout<<p1.age<<"  "<<p1.name<<endl;cout<<p2.age<<"  "<<p2.name<<endl;p2 = p3;
}

运行结果：

注意！27行的 Person p2 = p1 语句不是赋值，是在创建对象，因此要调用拷贝构造函数，而31行是对象的赋值，调用的是运算符“=”的重载函数。所以要注意，这俩东西调用是不一样的，类似与变量创建和赋值的区别。

如果程序员没有手动创建拷贝构造函数，编译器会自动创建一个默认拷贝构造函数，如果手动创建了，编译器就不会再创建了。默认拷贝构造函数很简单，就是用老对象”的成员变量对“新对象”的成员变量进行一一赋值，和上面 Person 类的拷贝构造函数非常类似。所以，上边那个例子，不定义拷贝构造函数，程序也是没问题的，因为编译器帮我们创建了一个默认构造函数。

可能会有疑问，既然编译器自己会创建拷贝构造函数，那为什么还需要用户手动创建呢？答案是，默认构造函数里边只是简单的浅拷贝，碰到指针就G了。对于指针指向的数据，如果用默认构造函数，那么“新对象”的指针跟“老对象”的指针指的是同一块内存，”老对象“的修改会影响到“新对象”，所以这时候就需要用户手动创建拷贝构造函数，使用深拷贝创建对象。

4. 转换构造函数

对于类型转换，大家可能并不陌生，C++自带很多类型转换规则，比如int转double，(int*)转(float*)，以及向上型转等等，除了这些自带的转换规则之外，用户还可以自定义转换规则，转换构造函数就是将其他类型转化为当前类。

借助前边的例子，如果我的对象创建语句是这么写的：

Person p = "Kang";

这个代码是编译不过的，因为Person类没有对应的构造函数，但是如果定义一个转换构造函数，自定义一下转换规则，那么这条语句就是可行的，看一个详细的例子：

#include <iostream>
#include <string.h>
using namespace std;class Person {
public:int age;char* name;Person(int age, char* name);  //一般构造函数Person(char* name);  //转换构造函数};Person::Person(int age, char* name) {this->age = age;this->name = name;
}Person::Person(char* name) {  //转换构造函数this->name = name;this->age = 0;
}int main(){Person p1(12,"kang");   //调用一般构造函数Person p2 = "Tom";      //调用转换构造函数,等效于 Person p2(“Tom”);cout<<p1.age<<"  "<<p1.name<<endl;cout<<p2.age<<"  "<<p2.name<<endl;p2 = "Jack";  //调用转换构造函数，因为=右边不是Person类型，所以不会调用运算符=的重载函数cout<<p2.age<<"  "<<p2.name<<endl;
}

运行结果：

可以看到，Person p2 = "Tom" 是没有问题的，正常来说，"Tom"是一个字符串，无法用他对 p2 进行初始化的，但是编译器会判断类型转换规则能不能用，再查看类中是否有转换构造函数，然后将“Tom”通过转换构造函数转化为Person类的对象，然后再调用拷贝构造函数对p2进行初始化。相当于中间用转换构造函数创建了一次匿名类，然后再使用拷贝构造函数。不得不说，编译器真的很努力了～

对于 p2 = "Jack" ，则先调用转换构造函数，再调用了赋值运算符重载函数。

需要强调的是，转换构造函数用于标准类型向自定义类转换，因此转换构造函数的形参只能有一个，或者有多个形参但最多只有一个不是默认参数。

Person::Person(char* name) {  //转换构造函数this->name = name;this->age = 0;
}Person::Person(char* name, int age = 0) {  //转换构造函数this->name = name;this->age = age;
}Person::Person(int age, char* name) {  //不是转换构造函数this->age = age;this->name = name;
}

5. 移动构造函数

拷贝构造函数可以用其他对象初始化新对象，但是，如果成员指针变量指向的数据量很大，再进行深拷贝，那么拷贝函数的时间开销是巨大的。而移动构造函数的诞生，就是为了解决拷贝构造函数时间开销大的问题。

借助一个例子来说明移动构造函数是如何工作的：

Person p = Person();

这条语句会先调用一般构造函数或者默认构造函数（取决于有没有手动定义一般构造函数），创建一个匿名对象；再调用拷贝构造函数。如果Person成员指针变量指向的数据量很大，那么时间开销是很大的。

移动构造函数的优化思路是：既然一般构造函数创建出来的是一个匿名对象，我们不妨把新对象的指针直接指向匿名对象指向的空间，说简单一些就是，指针简单拷贝，然后将匿名对象的指针置空，因为匿名对象是无法被用户调用的，如此一来，匿名对象成员指针指向的数据都归新对象的指针变量了。有点鸠占鹊巢的意思==>

移动构造函数的声明形式如下：

ClassName(CalssNmae &&obj);

可以看到，为了能够引用匿名对象，移动构造函数的输入是右值引用。

光说不直观，看一个例子：

#include <iostream>
#include <string.h>
#include <chrono>
using namespace std;class demo{
public:demo(){               //一般构造函数num = new int[100000000];cout<<"constructor"<<endl;}demo(const demo& de) {   //拷贝构造函数num = new int[100000000];memcpy(this->num, de.num, 100000000);cout<<"copy constructor"<<endl;}
//    demo(demo &&de) {     //移动构造函数
//        num = de.num;
//        de.num = NULL;
//        cout<<"move constructor"<<endl;
//    }
private:int *num;
};demo get_demo(){return demo();
}int main(){auto start = std::chrono::system_clock::now();demo a = demo();auto finish = std::chrono::system_clock::now();auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(finish-start);std::cout<<double(duration.count())<< "ms" <<std::endl;return 0;
}

这个代码不能用IDE去编译运行，因为IDE会进行优化，我们就无法观察程序原本的运行轨迹了。

在Linux系统下，找到cpp所在文件夹，打开终端，输入：