现代C++教程之新特性static_assert和delegating&Inheriting constructors 04

        静态断言（static_assert）允许在编译时对表达式进行静态检查，并在不满足条件时发出编译错误 ，委托构造函数（delegating constructors）允许一个构造函数调用同一个类的其他构造函数，以简化代码和避免重复。

1 静态断言（static_assert）

   static_assert是C++11引入的一个静态断言机制。它允许在编译时检查特定的表达式或条件，如果表达式为false，则会导致编译错误。

   static_assert的语法如下：

static_assert(expression, optional_message);

        其中，expression是要进行断言的表达式，可以是一个编译时常量或编译时可计算的表达式。optional_message是可选的字符串参数，用于提供断言失败时的自定义错误信息。

1.1 static_assert常见使用场景

• 检查类型大小

static_assert(sizeof(int) == 4, "int类型必须是4个字节大小");

        如果sizeof(int)不等于4，编译器将引发一个断言错误，并显示给定的错误消息。

• 检查模板类型

template <typename T>
void processValue(T value) {
    static_assert(std::is_integral<T>::value, "T必须是整数类型");
    // 继续处理逻辑
}

processValue(10);  // 正常调用
processValue("hello");  // 静态断言错误

   static_assert用于检查模板类型T是否是整数类型。如果T不是整数类型，将导致编译错误。

1.2 static_assert和assert的区别

        可以从以下几个方面来进行区别：

• 断言位置

   static_assert是在编译时进行断言，所以可以放置在任何地方，包括在函数内部、类内部、命名空间中等；assert是在运行时进行断言，通常放置在函数内部或主函数的开头，用于在程序运行期间检查条件。

• 断言条件

   static_assert的条件必须是一个编译时常量或编译时可计算的表达式；assert的条件可以是运行时的表达式，通常用于检查程序逻辑中的不变量、条件和预期。

• 错误处理

   static_assert会导致编译错误，如果条件为false，编译将失败，错误消息将在编译期间显示；assert会导致程序运行时的断言失败，程序将终止，并打印出错信息，通常在开发和调试期间使用。

• 功能范围

   static_assert可以用于复杂的编译时条件检查，例如类型和模板参数验证；assert通常用于程序运行过程中的基本条件检查和调试。

• 编译选项

   static_assert不依赖于编译选项，它总是被编译器执行；assert依赖于编译时定义的NDEBUG宏，默认情况下，只在未定义NDEBUG时起作用，以便在开发和调试期间执行断言检查。

2 委托构造函数（delegating constructors）

        在C++11中，引入了构造函数委托的概念，允许一个构造函数调用另一个构造函数来初始化对象。它可以减少代码重复，并使代码更清晰易读。

2.1 基本语法

        构造函数委托通过在初始化列表中使用类似于构造函数的语法来实现。在委托构造函数中，你可以调用相同类的其他构造函数，然后根据需要进行进一步的初始化。一个简单的例子：

class Point {
private:
    int x, y;
public:
    Point() : Point(0, 0) {} // 委托给带有两个参数的构造函数

    Point(int x, int y) {
        this->x = x;
        this->y = y;
    }

    int getX() { return x; }
    int getY() { return y; }
};

        第一个构造函数使用了构造函数委托，它调用了带有两个参数的构造函数并将其委托给它。这意味着调用无参构造函数时，会自动调用带有两个参数的构造函数，并将x和y初始化为0。

2.2 delegating constructors使用陷阱

        在使用构造函数委托时，有一些需要注意的事项：

• 委托构造函数必须出现在初始化列表中，而不能在函数体内部调用

        委托构造函数的主要目的是在构造函数的开始阶段调用其他构造函数完成初始化，而不是在函数体内部进行某些初始化操作。

class Person {
private:
    std::string name;
    int age;
public:
    // 错误
    Person()   { 
         // 错误！委托构造函数不能出现在函数体内部
         Person("", 0)
    }
     
    // 正确
    Person() : Person("", 0) {
        // 这里可以进行其他初始化操作
    }
    
   
    // 带参数的构造函数
    Person(std::string name, int age) {
        this->name = name;
        this->age = age;
    }
};

• 委托构造函数的调用必须在构造函数的初始化列表中完成，且只能调用该类中的其他构造函数
• 委托构造函数的调用顺序按照初始化列表中的顺序进行

        调用委托构造函数时，它们的调用顺序与它们在构造函数的初始化列表中出现的顺序相同。这意味着被委托的构造函数会在委托构造函数之前完成初始化。

• 每个构造函数只能委托给一个其他构造函数
• 构造函数的委托关系不能形成循环调用，即不能出现A委托给B，B委托给A的情况
• 在使用委托构造函数时，需要确保被委托的构造函数能够正确地初始化对象，以避免不必要的错误

3 继承构造函数（Inheriting Constructors）

3.1 什么是Inheriting Constructors？

        Inheriting Constructors是C++11引入的一项特性，它允许派生类继承其基类的构造函数。通过使用using关键字以及基类的构造函数名称，在派生类中声明继承构造函数。这样一来，派生类就能够直接使用基类的构造函数，无需再次定义相同的构造函数，并且可以保留基类构造函数的所有参数和默认参数。

        继承构造函数的语法如下所示：

class Base {
public:
    Base(int num) {
        std::cout << "Base(int num) called" << std::endl;
    }
    Base(int num1,int num2) {
        std::cout << "Base(int num1,int num2) called" << std::endl;
    }
};

class Derived : public Base {
public:
    using Base::Base; // 继承基类的构造函数
};

        继承构造函数只能继承基类的构造函数，不能继承其他成员函数或静态函数。此外，继承构造函数只能继承直接基类的构造函数，不能继承间接基类的构造函数。

3.2 为什么要引入Inheriting Constructors？

        C++11引入继承构造函数（Inheriting Constructors）的特性是为了解决以下几个问题：

• 代码重复

        当派生类需要定义与基类相同的构造函数时，如果没有继承构造函数的特性，就需要在派生类中重新定义相同的构造函数。这会导致代码冗余和维护困难。通过继承构造函数，派生类可以直接继承基类的构造函数，避免了代码的重复，并提高了代码的可读性和可维护性。

• 一致性

        继承构造函数可以确保派生类的构造函数与基类的构造函数具有相同的行为和语义。这项特性通过继承基类的构造函数，使得派生类的构造函数也能够初始化相同的成员变量和执行相同的初始化操作，从而保持了一致性。

• 隐式构造函数

        在某些情况下，派生类可能需要隐式地继承基类的构造函数。例如，当基类的构造函数为私有或受保护时，派生类不能直接调用基类的构造函数。通过继承构造函数，则可以间接地调用基类的构造函数，从而实现隐式的构造。

3.3  Inheriting Constructors高级用法

• 修改参数和默认参数

        通过继承构造函数，派生类可以对继承的构造函数的参数进行修改，或者为参数添加默认值。这样可以使派生类的构造函数更加灵活。

class Base {
public:
    Base(int num) {
        // 基类构造函数的实现
    }
};

class Derived : public Base {
public:
    using Base::Base; // 继承基类的构造函数

    Derived(int num, double val = 0.0) : Base(num) {
        // 派生类构造函数的实现
        // 对基类构造函数的参数进行修改，并添加了一个默认参数
    }
};

        Derived派生类继承了Base基类的构造函数。然后，Derived类定义了一个新的构造函数Derived(int num, double val = 0.0)，在其中修改了继承的构造函数的参数，并添加了一个默认参数。

• 委派构造函数

派生类可以通过继承构造函数来实现委派构造函数的效果。委派构造函数指的是一个构造函数调用另一个构造函数来完成实际的初始化工作。

class Base {
public:
    Base(int num) {
        // 基类构造函数的实现
    }
};

class Derived : public Base {
public:
    using Base::Base; // 继承基类的构造函数

    Derived() : Derived(0) {
        // 委派构造函数的实现
        // 调用派生类的其他构造函数来完成实际的初始化工作
    }
};

   Derived派生类继承了Base基类的构造函数。然后，Derived类定义了一个新的构造函数Derived()，它通过使用Derived(0)来调用另一个构造函数，从而委托其他构造函数来完成实际的初始化工作。

• 删除和重载继承的构造函数

        派生类可以通过使用delete关键字来删除继承的构造函数，或者通过定义自己的构造函数来重载继承的构造函数。

class Derived : public Base {
public:
    using Base::Base; // 继承基类的构造函数

    Derived() = delete; // 删除继承的构造函数

    Derived(float num) : Base(static_cast<int>(num)) {
        // 派生类构造函数的实现
        // 重载继承的构造函数
    }
};

   Derived派生类继承了Base基类的构造函数。然后，通过使用= delete来删除继承的构造函数Derived()，并定义了一个新的构造函数Derived(float num)来重载继承的构造函数。