【深度C++】之“构造函数”

Jinxk8

已于 2024-06-25 13:21:59 修改

阅读量672

点赞数

分类专栏：面向对象C++ 文章标签： c++ 编程语言

于 2020-05-26 23:28:53 首次发布

本文链接：https://blog.csdn.net/u014609638/article/details/103847199

版权

面向对象C++ 专栏收录该内容

31 篇文章 107 订阅

订阅专栏

0. C++中的构造函数

构造函数（constructor）是类的一种特殊的成员函数，它的定义是：

构造函数是类控制其对象的初始化过程的一个或几个特殊的成员函数。
（摘选自《C++ Primer》第5版本）

理解这个定义：

构造函数是成员函数；
是特殊的成员函数；
是一个或几个成员函数。

构造函数的任务是：

构造函数的任务是初始化类对象的数据成员，无论何时只要类的对象被创建，就会执行构造函数。
（摘选自《C++ Primer》第5版本）

举例来说，当我们使用类类型创建一个该类类型的变量的时候，就自动执行了某个构造函数，例如：

MyClass my_class;  // 后面会讲到，此处执行了“默认构造函数”
MyClass my_class(5, 9.0);  // 此处执行了“参数构造函数”
MyClass my_class = 6;  // 此处执行了“转换构造函数”
MyClass my_class(other_my_class);  // 此处执行了“拷贝构造函数”
MyClass my_class(std::move(rhs_my_class));  // 此处执行了“移动构造函数”

构造函数的特殊性在于：

自动执行
名字和类名相同
没有返回类型
不能声明为const（试想下，构造函数的任务就是初始化数据成员，也就是修改数据成员的数值，若声明为const，构造函数就失去了意义；但可以声明为constexpr）

构造函数的类别

C++中的构造函数有很多种：

默认构造函数
参数构造函数
转换构造函数
拷贝构造函数
移动构造函数
constexpr构造函数

1. 默认构造函数

1.1 合成的默认构造函数

我们定义一个类，叫做MyClass，它有一些数据成员：

class MyClass {
private:
    int num;
    float ratio;
    bool is_valid;
};

若我们定义的类仅仅写成上述模样，则当我们实例化一个类时：

#include "MyClass.h"

MyClass my_class;

该代码会调用一个合成的默认构造函数。

“合成”是指编译器为该类合成了一个默认构造函数，默认构造函数执行了所有数据成员的默认初始化（关于默认初始化的详细内容可以参考【深度C++】之“初始化”）。

若类定义仅仅如上述示例简单，则完全可以靠编译器的能力解决。

1.2 默认构造函数与初始值列表

1.2.1 默认构造函数

当然，我们可以为MyClass类定义一个默认构造函数，不使用编译器的能力。

class MyClass {
private:
    int num;
    float ratio;
    bool is_valid;
public:
    MyClass();
};

函数名与类同名，无返回值，无参数，这样就定义了一个默认构造函数。

在.cpp文件中可以定义构造函数的函数体：

#include "MyClass.h"

MyClass::MyClass()
    : num(0), ratio(0.0f), is_valid(false)  // 使用了初始值列表进行初始化
{}

如果我们只是如上定义这个函数，则该函数与合成默认构造函数具有一样的功能。

若想要自己的默认构造函数与合成构造函数的功能一样，可以使用default关键字：

class MyClass {
private:
    int num;
    float ratio;
    bool is_valid;
public:
    MyClass() = default;
};

在定义默认构造函数的时候，我们使用了一个特殊的方法，叫做构造函数初始值列表（constructor initialize list），即在冒号后面、左大括号前面的那些内容。

1.2.2 初始值列表

初始值列表负责为新创建的对象的一个或几个数据成员赋初值，它在构造函数的函数体执行前执行。

对每个变量赋值的顺序和.h中变量定义的顺序相关。

任何构造函数都可以使用初始值列表，且推荐使用初始值列表，一是效率，二是明确。

当然可以写成：

#include "MyClass.h"

MyClass::MyClass() {
    num = 0;
    ratio = 0.0f;
    is_valid = false;
}

两种写法得到的结果是一样的，但是过程不一样：

使用初始值列表，直接将数据成员的值赋值为初始值列表中的值；
未使用初始值列表，先对数据成员执行默认初始化，再进行赋值操作。

此处可以明显看出初始化和赋值的区别。使用初始值列表可以直接初始化类内成员。

1.2.3 必须使用初始值列表的数据成员

某些数据成员，必须使用初始值列表，如下：

const修饰的数据成员
引用类型成员

class MyClass {
private:
    int num;
    float ratio;
    bool is_valid;
    const int op;    // const修饰的数据成员
    // double &distance_;    // 引用类型数据成员示例见第2部分
public:
    MyClass();    // 默认构造函数
};

上述示例中的const int op只能使用初始值列表，因为无法对其执行默认初始化，二者在定义的时候就必须手动初始化。

#include "MyClass.h"

MyClass::MyClass(): op(5) {
    // 仅示例必须使用初始值列表，其他数据成员请读者自行想象
}

可以理解，因为我们在函数中定义一个const或者引用的时候都必须进行初始化。

2. 参数构造函数

2.1 带参数的构造函数

参数构造函数，即在默认构造函数基础上添加函数参数。

class MyClass {
private:
    int num;
    float ratio;
    bool is_valid;
    double &distance_;    // 引用类型数据成员
public:
    MyClass(double &dis);    // 参数构造函数
};

在实现中：

#include "MyClass.h"

MyClass::MyClass(double &dis): distance_(dis) {
    // 获取一个对象的引用通常以为这需要修改它，
    // 在逻辑上意味着该对象是MyClass的重要组成部分
}

若我们将参数构造函数中的每个参数都写成默认实参，则该参数构造函数为我们的类提供了默认构造函数的功能，括号里不需要传入任何参数依旧可以正确初始化。

例如：

class MyClass {
private:
    int num;
    float ratio;
    bool is_valid;
public:
    // 参数构造函数
    MyClass(int _num = 0, float _ratio = 0.0, _is_valid = false);
};

在实现中：

#include "MyClass.h"

MyClass::MyClass(int _num = 0, float _ratio = 0.0, _is_valid = false):
    num(_num), ratio(_ratio), is_valid(_is_valid) {
}

2.2 委托构造函数

可以在构造函数的初始值列表处，调用其他的构造函数，如：

class MyClass {
private:
    int num;
    float ratio;
    bool is_valid;
public:
    // 默认构造函数
    // 将构造工作委托给了下面的参数构造函数
    MyClass(): MyClass(0) {}
    // 参数构造函数
    MyClass(int _num, float _ratio = 0.0, _is_valid = false);
};

一个委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程，就称作委托构造函数。

在实际项目中，要根据类的性质而设计构造函数，将初始化的过程统一管理，委托给其他的构造函数，方便以后的代码维护。

3. 转换构造函数

如果构造函数只接受一个实参，则它实际上定义了转换为此类类型的隐式转换机制。有时我们把这种构造函数称作转换构造函数。

class MyClass {
private:
    int num;
public:
    // 转换构造函数
    MyClass(int _num): num(_num) {}
};

此时，我们在代码中书写:

#include "MyClass.h"

int main() {
    MyClass my_class = 1;
    return 0;
}

是完全可以编译通过正确的，表面上看，我们将数据类型int转换为MyClass了。

是否执行隐式转换，完全看类设计者的意图。

当然我们可以使用explicit关键字来抑制构造函数定义的隐式转换。

class MyClass {
private:
    int num;
public:
    // 显示转换构造函数
    explicit MyClass(int _num): num(_num) {}
};

使用explicit需要注意：

explicit只对有一个实参的构造函数有效，多个实参的无需使用；
只需要在.h类内声明构造函数时使用explicit，在.cpp类外定义时不重复使用。

标准库中，string接受一个const char *的构造函数，且没声明explicit，因此我们可以写成：

#include <string>

int main() {
    string s = "abc";
    return 0;
}

这样写又直观，又方便。

4. 拷贝构造函数

4.1 拷贝构造函数的定义

拷贝构造函数的定义如下：

class MyClass {
private:
    int num;
public:
    // 默认构造函数
    MyClass(): num(0) {}
    // 拷贝构造函数
    MyClass(const MyClass &orig);    // 拷贝构造函数
};

定义拷贝构造函数需注意：

第一个参数必须是自身类类型的左值引用；
该参数几乎总是const；
不应该将拷贝构造函数定义为explicit，因为拷贝构造函数几乎是隐式使用。

4.2 合成拷贝构造函数

当我们定义了其他类型的构造函数却没有定义拷贝构造函数时，编译器会自动帮我们定义一个合成拷贝构造函数。与合成默认构造函数不同，只要我们定义了构造函数，合成默认构造函数就不会被编译器定义。

合成拷贝构造函数等价于如下形式：

// 拷贝构造函数
MyClass(const MyClass &orig): num(orig.num) {}

即内置类型直接拷贝，类类型成员执行该类类型的拷贝构造函数。

4.3 何时调用拷贝构造函数

拷贝初始化时通常使用拷贝构造函数来完成，通常发生在以下几种情况：

使用“=”定义变量，=右边是相同类类型
将一个对象作为实参传递给一个非引用类型的形参
从一个返回类型为非引用类型的函数返回一个对象
用花括号列表初始化一个数组中的元素或一个聚合类中的成员

5 移动构造函数

5.1 对象移动

正如4.3概括的，在很多情况下会发生对象的拷贝。

若一个类管理了很多其他类类型的成员变量（string, vector等），还包括使用new关键字开辟的内存空间，拷贝一个对象的代价是相当大的。

在其中某些情况下，对象拷贝之后就立即被销毁了。此时使用移动而不是拷贝将大幅提升程序性能。

想要理解对象移动的工作原理，需要先明白C++中的左值与右值，请参考【深度C++】之“左值与右值”。

对象移动需要C++引入的新类型，右值引用。

5.2 右值引用

我们通过&&来定义一个右值引用。

int a = 2;
int &&rr_a = a * 4;

上述代码，将一个右值引用绑定到了a * 4的表达式结果上，因为a * 4的结果是一个右值，因此可以讲rr_a绑定到这个值上。

对于返回左值的表达式：

返回左值引用的函数，连同赋值、下标、解引用和前置递增/递减运算符，都是返回左值的表达式的例子。我们可以将一个左值引用绑定到这类表达式的结果上。

对于返回右值的表达式：

返回非引用类型的函数，连同算术、关系、位以及后置递增/递减运算符，都生成右值。我们不能将一个左值引用绑定到这类表达式上，但是我们可以将一个const的左值引用或者一个右值引用绑定到这类表达式上。

（以上两句话摘选自摘选自《C++ Primer》第5版本，抽象却精湛，建议背诵）

5.3 移动构造函数

声明一个移动构造函数如下：

class MyClass {
private:
    int *data;
public:
    // 移动构造函数
    MyClass(MyClass &&rhs) noexcept;
};

定义移动构造函数：

#include "MyClass.h"

// 移动构造函数
// 1. 移动构造函数不应该抛出任何异常
MyClass::MyClass(MyClass &&rhs) noexcept
    // 2. 调用成员初始化器接管rhs中的资源
    : data(rhs.data)
{
    // 3. 令rhs进入这样的状态，对其运行析构函数是安全的
    rhs.data = nullptr;
}

为了方便演示移动构造函数，我们在MyClass中定义了一个指针data。

在移动构造函数中，我们没有分配任何新的内存，它接管了rhs中的data，并让rhs中的data置为nullptr。

此时rhs中的对象处于一种可以析构的状态，它的析构函数判断data指针为空，便不再执行delete相关操作。因为我们的移动构造函数就是来处理对象拷贝之后就销毁的情况。

除了将源对象处于可析构的状态，移动操作还必须保证源对象仍然有效，有效指的是可以安全地为其赋值。但是我们不应该再使用或者依赖源对象的任何值，因为已经将源对象所管理的内容移动到了新的对象中去了。

定义移动构造函数需注意：

移动构造函数不应该抛出任何异常；
令移后源进入对其运行析构函数是安全的状态，且不再对移后源中的值作任何假设。

5.4 何时调用移动构造函数

编译器使用普通的函数匹配规则来确定使用的是拷贝构造函数还是移动构造函数，通常是：

移动右值，拷贝左值

#include "MyClass.h"

MyClass c1;
MyClass c2(c1);    // 调用 拷贝构造函数

MyClass get_my_class();    // 声明一个返回右值MyClass的函数
MyClass c3(std::move(get_my_class()));    // 调用 移动构造函数

若一个类没有定义移动构造函数，编译器会为类合成一个移动构造函数，称作合成移动构造函数。

有一些情况，编译器不会为类合成移动构造函数，尤其是在类的设计者自行定义了拷贝构造函数时，此时调用上述的最后一行代码，将调用拷贝构造函数。

6. constexpr构造函数

constexpr构造函数是字面值常量类中的一种特殊的构造函数。

关于字面值常量类，参考【深度C++】之“常量表达式constexpr”。

一个字面值常量类，必须至少定义一个constexpr构造函数。

constexpr构造函数的函数体是空的，只能使用初始值列表进行所有成员的初始化。提供的初始值必须是一条常量表达式，或者使用constexpr构造函数（因为字面值常量类可以嵌套字面值常量类）。

可以声明为=default或者=delete。

class MyConstexprClass {
private:
    int sz_;
    double ratio_;
public:
    constexpr MyConstexprClass(int sz = 0, double ratio = 0.0) :
            sz_(sz), ratio_(ratio) {}
};