C++构造函数

在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）。

我们通过成员函数 setname()、setage()、setscore() 分别为成员变量 name、age、score 赋值，这样做虽然有效，但显得有点麻烦。有了构造函数，我们就可以简化这项工作，在创建对象的同时为成员变量赋值。

class Student
{
public:
​    Student(char *name, int age, float score) {
​         _name = name;
​         _age = age;
​         _score = score;
​    }
​    void show()
​    {
​         cout << _name <<"的年龄是：" << _age << ", 成绩是：" << _score << endl;
​    }
private:
​    char *_name;
​    int _age;
​    float _score;
};

构造函数是干什么的

该类对象被创建的时候，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成成员的初始化工作，故：构造函数的作用：初始化对象的数据成员

class Counter
{
public:
  // 类Counter的构造函数
  // 特点：以类名作为函数名，无返回类型
  Counter()
  {
​    m_value = 0;
  }
private:   
  // 数据成员
 int m_value;
}

eg: Counter c1;

编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter()自动地初始化对象c1的m_value值设置为0

构造函数的种类

默认构造函数

如果用户自己没有定义构造函数，那么编译器会自动生成一个默认的构造函数，只是这个构造函数的函数体是空的，也没有形参，也不执行任何操作。比如上面的 Student 类，默认生成的构造函数如下：

Student(){}

一个类必须有构造函数，要么用户自己定义，要么编译器自动生成。一旦用户自己定义了构造函数，不管有几个，也不管形参如何，编译器都不再自动生成。

一般构造函数

一般构造函数（也称重载构造函数），一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）。

Student(char *name, int age, float score) {
​         _name = name;
​         _age = age;
​         _score = score;
​    }

创建对象时根据传入的参数不同调用不同的构造函数。

拷贝构造函数

复制构造函数（也称为拷贝构造函数）。复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中

若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询有关 “浅拷贝” 、“深拷贝”。

Student(const Student &stu){
  this->m_name = stu.m_name;
  this->m_age = stu.m_age;
  this->m_score = stu.m_score;
}

拷贝构造函数是一种特殊的构造函数，具有单个形参，该形参（常用const修饰）是对该类型的引用。当定义一个新对象并用同一类型的对象都它进行初始化时，将显示使用拷贝构造函数，当该类型的对象传递给函数返回该类型的对象时，将隐式调用拷贝构造函数

当类中有一个数据成员是指针时，或者有成员表示在构造函数中分配的其他资源，必须显示定义拷贝构造函数

构造函数的使用情况

一个对象以值传递的方式传入函数体

一个对象以值传递的方式从函数体返回

一个对象需要通过另一个对象进行初始化

转换构造函数

转换构造函数用于将其他类型的变量，隐式转换为本类对象。

Student(int r)
 ｛
​     int num=1004；
​     int age= r；
 ｝

转换构造函数可以用在哪里？

假如重载了+号运算符，使得两个Student类的对象可以相加，其结果为两个对象的成员变量age之和。

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

为我们定义了 转换构造函数，那么 s1+19，执行如果过程：

首选调用+号运算符，发现19不是Student类的对象，而是int类型

然后调用转换构造函数，将19变为Student（19）

现在便可以进行加法运算，其值是s1.age+ (TempStudentObject).age=18+19 = 37

移动构造函数

所谓移动语义，指的就是以移动而非深拷贝的方式初始化含有指针成员的类对象。简单的理解，移动语义指的就是将其他对象（通常是临时对象）拥有的内存资源“移为已用”。

#include <iostream>
using namespace std;
class demo{
public:
  demo():num(new int(0)){
   cout<<"construct!"<<endl;
  }
  //拷贝构造函数
  demo(const demo &d):num(new int(*d.num)){
   cout<<"copy construct!"<<endl;
  }
  ~demo(){
   cout<<"class destruct!"<<endl;
  }
private:
  int *num;
};
demo get_demo(){
  return demo();
}
int main(){
  demo a = get_demo();
  return 0;
}

如上所示，我们为 demo 类自定义了一个拷贝构造函数。该函数在拷贝 d.num 指针成员时，必须采用深拷贝的方式，即拷贝该指针成员本身的同时，还要拷贝指针指向的内存资源。否则一旦多个对象中的指针成员指向同一块堆空间，这些对象析构时就会对该空间释放多次，这是不允许的。

可以看到，程序中定义了一个可返回 demo 对象的 get_demo() 函数，用于在 main() 主函数中初始化 a 对象，其整个初始化的流程包含以下几个阶段：

执行 get_demo() 函数内部的 demo() 语句，即调用 demo 类的默认构造函数生成一个匿名对象；

执行 return demo() 语句，会调用拷贝构造函数复制一份之前生成的匿名对象，并将其作为 get_demo() 函数的返回值（函数体执行完毕之前，匿名对象会被析构销毁）；

执行 a = get_demo() 语句，再调用一次拷贝构造函数，将之前拷贝得到的临时对象复制给 a（此行代码执行完毕，get_demo() 函数返回的对象会被析构）；

程序执行结束前，会自行调用 demo 类的析构函数销毁 a。

construct! <-- 执行 demo()

copy construct! <-- 执行 return demo()

class destruct! <-- 销毁 demo() 产生的匿名对象

copy construct! <-- 执行 a = get_demo()

class destruct! <-- 销毁 get_demo() 返回的临时对象

class destruct! <-- 销毁 a

事实上，对于程序执行过程中产生的临时对象，往往只用于传递数据（没有其它的用处），并且会很快会被销毁。因此在使用临时对象初始化新对象时，我们可以将其包含的指针成员指向的内存资源直接移给新对象所有，无需再新拷贝一份，这大大提高了初始化的执行效率。

#include <iostream>
using namespace std;
class demo{
public:
  demo():num(new int(0)){
​    cout<<"construct!"<<endl;
  }
  demo(const demo &d):num(new int(*d.num)){
​    cout<<"copy construct!"<<endl;
  }
  //添加移动构造函数
  demo(demo &&d):num(d.num){
​    d.num = NULL;
​    cout<<"move construct!"<<endl;
  }
  ~demo(){
​    cout<<"class destruct!"<<endl;
  }
private:
  int *num;
};
demo get_demo(){
  return demo();
}
int main(){
  demo a = get_demo();
  return 0;
}

可以看到，在之前 demo 类的基础上，我们又手动为其添加了一个构造函数。和其它构造函数不同，此构造函数使用右值引用形式的参数，又称为移动构造函数。并且在此构造函数中，num 指针变量采用的是浅拷贝的复制方式，同时在函数内部重置了 d.num，有效避免了“同一块对空间被释放多次”情况的发生。

在 Linux 系统中使用g++ demo.cpp -o demo.exe -std=c++0x -fno-elide-constructors命令执行此程序，输出结果为：

construct!

move construct!

class destruct!

move construct!

class destruct!

class destruct!

通过执行结果我们不难得知，当为 demo 类添加移动构造函数之后，使用临时对象初始化 a 对象过程中产生的 2 次拷贝操作，都转由移动构造函数完成。

我们知道，非 const 右值引用只能操作右值，程序执行结果中产生的临时对象（例如函数返回值、lambda 表达式等）既无名称也无法获取其存储地址，所以属于右值。当类中同时包含拷贝构造函数和移动构造函数时，如果使用临时对象初始化当前类的对象，编译器会优先调用移动构造函数来完成此操作。只有当类中没有合适的移动构造函数时，编译器才会退而求其次，调用拷贝构造函数。

在实际开发中，通常在类中自定义移动构造函数的同时，会再为其自定义一个适当的拷贝构造函数，由此当用户利用右值初始化类对象时，会调用移动构造函数；使用左值（非右值）初始化类对象时，会调用拷贝构造函数。

浅拷贝与深拷贝

浅拷贝

所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。也就是增加了一个指针，指向原来已经存在的内存。 正常情况下，“浅拷贝”已经能很好的工作，但是一旦对象存在动态成员，浅拷贝就会出问题。让我们考虑下面一段代码：

​

   #include <iostream>
​   #include <assert.h>  

​    using namespace std;

​    class Test
​    {
​    public:
​         Test(){
​             p = new int(10);
​         }
​         ~Test(){
​             assert(p != NULL);   // assert()作用是如果他的条件返回错误，则终止程序执行 
​             delete p;
​         }
​    private:
​         int x;
​         int y;
​         int* p;
​    };
​    int main()
​    {
​         Test t1;
​         Test t2(t1);  // 调用默认拷贝构造函数
​         return 0;
​    }

上述程序崩溃。在使用t1复制t2时，进行的是浅拷贝，只是将成员的值进行赋值。此时，t1.p = t2.p, 即两个指针指向了堆里的同一个空间。这样，析构函数会被调用两次，这就是错误出现的原因。此问题的解决方法是“深拷贝”。

深拷贝

深拷贝就是对于对象中的动态成员，并不只是简单的赋值，而是重新分配空间，即资源重新分配。上述代码处理如下：

​

    #include <iostream>
​    #include <assert.h>  

​    using namespace std;

​    class Test
​    {
​    public:
​         Test(){
​             x = 0;
​             y = 0;
​             p = new int(10);
​         }

​         Test(const Test& t)
​         {
​             x = t.x;
​             y = t.y;
​             p = new int(10);
​             *p = *(t.p);
​         }

​         ~Test(){
​             assert(p != NULL);   // assert()作用是如果他的条件返回错误，则终止程序执行 
​             delete p;
​         }
​         int get_x(){return x;}
​         int get_y(){return y;}
​    private:
​         int x;
​         int y;
​         int* p;
​    };

​    int main()
​    {
​         Test t1;
​         Test t2(t1);  // 调用默认拷贝构造函数
​         cout<<"("<<t1.get_x()<<", "<<t1.get_y()<<")"<<endl
​             <<"("<<t2.get_x()<<", "<<t2.get_y()<<")"<<endl;
​         return 0;
​    }

此时t1与t2的p各自指向一段内存空间，但他们指向的内容相同，这就是“深拷贝”。

参考

浅谈C++中的几种构造函数_林多-CSDN博客_c++ 构造函数

c++ 构造函数详解_若尘的博客-CSDN博客_c++构造函数

C++11移动构造函数详解 (biancheng.net)