C/C++编程：构造函数

系统管理员 2022-10-23 00:49 194阅读 0赞

# 构造函数 #

## 目的 ##

>  *  在构造函数中可以进行各种初始化操作

构造函数的任务就是初始化该类的一个对象。一般而言，初始化操作必须建立一个**类不变式**，所谓不变式就是从成员函数(从类外)被调用时必须保持的某些东西。比如：

class Vector{
        
    public:
    	Vector(int s);
    private:
    	double *elem;  // elem执行一个数组，保存sz个double
    	int sz;  //sz为负
    };

上面，我们用注释陈述不变式：“elem执行一个数组，保存sz个double"以及"sz为负”。构造函数必须保证这两点为真：

Vector::Vector(int s){
        
    	if(s < 0) throw Bad_size{
        s};
    	sz = s;
    	elem = new double(s);
    }

此构造函数尝试建立不变式，如果失败就抛出一个异常。如果构造函数无法建立不变式，则不应该创建对象而且必须保证没有资源泄漏。需要获取并在用完后显式或者隐式的归还的任何东西都是资源，比如内存、锁、文件句柄、线程句柄。

为什么应该定义一个不变式呢？

*  聚焦于类的设计工作上
 *  理清类的行为（比如错误状态下的行为）
 *  简化成员函数的定义
 *  理清类的资源管理
 *  简化类的文档

> 构造函数可以建立不变式并获取资源。一般而言，构造函数是通过初始化类成员和基类来完成这些工作的

### 优点 ###

*  无序考虑类是否被初始化
 *  经过构造函数完全初始化后的对象可以为`const`类型，也能更方便的被标准容器或算法使用

### 缺点 ###

## 定义 ##

*  构造函数是类的一种特殊的**非静态成员函数**，其特殊之处有三点：
    
     *  **构造函数的函数名必须与类名相同**
     *  **构造函数无返回值**
     *  **当我们创建类对象时构造函数会被自动调用，而不需要我们主动调用**
     *  类名不可以用于此类内的普通成员函数，数据成员等等：

struct S{
        
    	S();  //OK
    	void S(int);  //error:不能为构造函数指定返回类型
    	int S;        //error：类名只能表示构造函数
    	enum S{
        foo, bar}; //error:类名只能表示构造函数
    };

*  构造函数用于初始化该类类型的对象
 *  在类的构造函数定义中，**成员初始化器列表**指定各个直接和虚基类和各个非静态数据成员的**初始化器**。 （请勿与 `std::initializer_list`混淆）
    
     *  **成员初始化器列表**，其语法是冒号字符 : 后随一或多个 成员初始化器 的逗号分隔列表
     *  [成员初始化器列表][Link 1]
 *  构造函数必须不是`协程`(C++20 起)

> **非静态成员函数**：非静态成员函数是声明于类的成员说明中，不带 static 或 friend 说明符的函数。

显式初始化成员是一个好主意，注意，一个”隐式初始化“的内置成员其实是未初始化的

> 基类初始化器

*  一个构造函数可以初始化自己的成员和基类，但不能初始化基类的基类：

struct B{
        B(int);};
    struct BB: B{
        };
    struct BBB : BB{
        
    	BBB(int i) : B(i){
        }; //错误，尝试初始化基类的基类
    	
    };

*  派生类的基类的初始化方式和非数据成员相同。即，如果基类要求一个初始化器，我们就必须再构造函数中提供相应的基类初始化器。如果我们希望进行默认构造，可以显式指出：

class B1{
        B1();};  //具有默认构造函数
    class B2{
        B2(int);}; //无默认构造函数
    
    struct D1 : B1, B2{
        
    	D1(int i) : B1{
        }, B2{
        i}{
        }
    };
    
    struct D2: B1, B2{
        
    	D1(int i) :  B2{
        i}{
        }  // 隐式使用B1{}
    };
    
    struct D3: B1, B2{
        
    	D1(int i){
        };  //error：B2要求一个int初始化器
    }

与成员初始化类似，基类按照声明顺序进行初始化，建议按此顺序指定基类的初始化器。基类的初始化在成员之前，销毁在成员之后。

## 语法 ##

类名 ( 形参列表(可选) ) 异常说明(可选) attr(可选)

`类名`必须指明当前类(或者类模板的当前实例化) ，或当在命名空间作用域或在友元声明中声明时，它必须是有限定的类名。

**成员初始化器列表**，其语法是冒号字符 : 后随一或多个 成员初始化器 的逗号分隔列表，每项均具有下列语法

*  用**直接初始化**，或者当表达式列表为空时用**值初始化**，初始化类或者标识符所指的基类或成员

类或标识符 ( 表达式列表(可选) )

*  用**列表初始化**（如果列表为空则为**值初始化**，而在初始化聚合体时为**聚合初始化**），初始化类或者标识符所指的基类或成员

类或标识符 花括号初始化器列表

*  用**包展开**初始化多个基类
    
     *  类或标识符 - 任何指明非静态数据成员的标识符，或任何指明该类自身 （对于委托构造函数）或直接或虚基类的类型名。
     *  表达式列表 - 可为空的，传递给基类或成员的参数的逗号分隔列表
     *  花括号初始化器列表 - 花括号包围的初始化器和嵌套的花括号初始化器列表的列表
     *  形参包 - 变参模板**形参包**的名字

形参包 ...

## 解释 ##

*  构造函数没有名字且无法被直接调用。
 *  构造函数在发生**初始化**时调用，而且它们按照初始化的规则进行选择
    
     *  无`explicit` 说明符的构造函数是[转换构造函数][Link 2]
     *  有`constexpr`说明符的构造函数令其类型成为[字面类型][Link 3]，具体请参见[constexpr构造函数][constexpr](https://blog.csdn.net/zhizhengguan/article/details/114990126)
     *  可以接收同类型的另一对象为实参的构造函数是[复制构造函数][Link 4]和[移动构造函数][Link 5]
 *  在开始执行组成构造函数体的复合语句之前，所有直接基类，虚基类，及非静态数据成员的初始化均已结束。成员初始化器列表是能指定这些对象的非默认初始化之处。
 *  对于不能默认初始化的基类和非静态数据成员，例如引用和const限定的类型的成员，必须指定成员初始化器
 *  对没有成员初始化器的[匿名联合体][Link 6]或者[变体成员][Link 7]不进行初始化
 *  `类或标识符`指明[虚基类][Link 8]的初始化器，在并非所构造对象的最终派生类的构造期间被忽略
 *  出现于`表达式列表`或`花括号初始化器列表`中的名字在构造函数的作用域中求值：

class X {
        
        int a, b, i, j;
    public:
        const int& r;
        X(int i)
          : r(a) // 初始化 X::r 为指代 X::a
          , b{
        i} // 初始化 X::b 为形参 i 的值
          , i(i) // 初始化 X::i 为形参 i 的值
          , j(this->i) // 初始化 X::j 为 X::i 的值
        {
         }
    };

*  **成员初始化器**所抛出的异常可被`函数try块`处理
 *  成员函数(包括虚成员函数)可从**成员初始化器**调用，但如果在该点所有基类尚未被全部初始化，则行为未定义
 *  对于虚调用(如果在该点时已初始化直接基类)，适用与从构造函数与析构函数中进行虚函数调用相同的规则：虚成员函数表现如同 \*this 的动态类型是正在构造的类的静态类型（动态派发不在继承层级下传），而对纯虚成员函数的虚调用（但非静态调用）是未定义行为。
 *  若**非静态数据成员**具有[默认成员初始化器][Link 9]且同时出现在**成员初始化器列表**中，则使用成员初始化器而非默认成员初始化器

struct S {
        
        int n = 42;   // 默认成员初始化器
        S() : n(7) {
        } // 将设置 n 为 7，而非 42
    };

*  引用成员不能绑定到成员初始化器列表中的临时量

struct A {
        
        A() : v(42) {
         }  // 错误
        const int& v;
    };

> 变量的**初始化**在构造时提供其初值

## 复合类的构造函数 ##

**包含类类型成员的类称为复合类**。 创建复合类的类类型成员时，调用类自己的构造函数之前，先调用构造函数。 当包含的类没有默认构造函数是，必须使用复合类构造函数中的初始化列表。

#include <iostream>
    using namespace std;
    
    class Label{
        
    public:
        Label(string label, string address) :m_label(label),m_address(address) {
        };
        string m_label;
        string m_address;
    };
    
    class Box {
        
    public:
        Box(int width, int length, int height){
        
           m_width = width;
           m_length = length;
           m_height = height;
        }
    
    private:
        int m_width;
        int m_length;
        int m_height;
    };
    class StorageBox : public Box{
        
    public:
        StorageBox(int width, int length, int height, Label label)
            :Box(width, length, height) , m_label(label){
        }
    private:
        Label m_label;
    };
    
    
    
    int main() {
        
        //通过命名对象
         Label label1{
         "some_name", "some_address" };
         StorageBox sb1(1, 2, 3, label1);
    
         // 通过临时对象
         StorageBox sb2(3, 4, 5, Label{
         "another name", "another address" });
    
         //  通过临时对象作为初始化列表
         StorageBox sb3(1, 2, 3, {
        "myname", "myaddress"}); 
    }

[C/C++编程：继承构造函数][C_C]  
[C/C++编程：委托构造函数][C_C 1]

## 例子 ##

struct S {
        
        int n;
        S(int); // 构造函数声明
        S() : n(7) {
        } // 构造函数定义。
                      // ": n(7)" 为初始化器列表
                      // ": n(7) {}" 为函数体
    };
    S::S(int x) : n{
        x} {
        } // 构造函数定义。": n{x}" 为初始化器列表
    int main()
    {
        
        S s; // 调用 S::S()
        S s2(10); // 调用 S::S(int)
    }

[Link 1]: https://blog.csdn.net/zhizhengguan/article/details/114951794
[Link 2]: https://blog.csdn.net/zhizhengguan/article/details/114991155
[Link 3]: https://zh.cppreference.com/w/cpp/named_req/LiteralType
[constexpr]: https://blog.csdn.net/zhizhengguan/article/details/115054237
[Link 4]: https://blog.csdn.net/zhizhengguan/article/details/109555790
[Link 5]: https://blog.csdn.net/zhizhengguan/article/details/115014024
[Link 6]: https://zh.cppreference.com/w/cpp/language/union#.E5.8C.BF.E5.90.8D.E8.81.94.E5.90.88.E4.BD.93
[Link 7]: https://zh.cppreference.com/w/cpp/language/union#.E8.81.94.E5.90.88.E4.BD.93.E5.BC.8F.E7.9A.84.E7.B1.BB
[Link 8]: https://zh.cppreference.com/w/cpp/language/derived_class
[Link 9]: https://zh.cppreference.com/w/cpp/language/data_members#.E6.88.90.E5.91.98.E5.88.9D.E5.A7.8B.E5.8C.96
[C_C]: https://blog.csdn.net/zhizhengguan/article/details/116265538
[C_C 1]: https://blog.csdn.net/zhizhengguan/article/details/114990402