C++11 constexpr关键字

╰+攻爆jí腚メ 2023-01-17 03:27 144阅读 0赞

**constexpr** 是 C++ 11 标准新引入的关键字，不过在讲解其具体用法和功能之前，读者需要先搞清楚 C++ 常量表达式的含义。  
  
**所谓常量表达式：**指的就是由多个（≥1）常量组成的表达式。换句话说，如果表达式中的成员都是常量，那么该表达式就是一个常量表达式。这也意味着，常量表达式一旦确定，其值将无法修改。  
  
实际开发中，我们经常会用到常量表达式。以定义数组为例，数组的长度就必须是一个常量表达式：

int url[10];//正确
    
    int url[6 + 4];//正确
    
    int length = 6;
    int url[length];//错误，length是变量

上述代码演示了 3 种定义 url 数组的方式，其中第 1、2 种定义 url 数组时，长度分别为 10 和 6+4，显然它们都是常量表达式，可以用于表示数组的长度；第 3 种 url 数组的长度为 length，**它是变量而非常量，**因此不是一个常量表达式，无法用于表示数组的长度。

我们知道，C++ 程序的执行过程大致要经历编译、链接、运行这 3 个阶段。

值得一提的是，常量表达式和非常量表达式的计算时机不同，非常量表达式只能在程序运行阶段计算出结果；而常量表达式的计算往往发生在程序的编译阶段，这可以极大提高程序的执行效率，因为表达式只需要在编译阶段计算一次，节省了每次程序运行时都需要计算一次的时间。  
  
对于用 C++ 编写的程序，性能往往是永恒的追求。那么在实际开发中，如何才能判定一个表达式是否为常量表达式，进而获得在编译阶段即可执行的“特权”呢？除了人为判定外，C++11 标准还提供有 constexpr 关键字。  
  
constexpr 关键字的功能是使指定的常量表达式获得在程序编译阶段计算出结果的能力，而不必等到程序运行阶段。C++ 11 标准中，constexpr 可用于修饰普通变量、函数（包括模板函数）以及类的构造函数。

**注意，获得在编译阶段计算出结果的能力，并不代表 constexpr 修饰的表达式一定会在程序编译阶段被执行，具体的计算时机还是编译器说了算。**

## constexpr修饰普通变量 ##

C++11 标准中，定义变量时可以用 constexpr 修饰，从而使该变量获得在编译阶段即可计算出结果的能力。  
  
值得一提的是，使用 constexpr 修改普通变量时，变量必须经过初始化且初始值必须是一个常量表达式。举个例子：

#include <iostream>
    using namespace std;
    
    int main()
    {
        constexpr int num = 1 + 2 + 3;
        int url[num] = {1,2,3,4,5,6};
        couts<< url[1] << endl;
        return 0;
    }
    
    //程序执行结果为：
    
    //2

**尝试将 constexpr 删除，此时编译器会提示“url\[num\] 定义中 num 不可用作常量”。**

可以看到，程序使用 constexpr 修饰 num 变量，同时将 "1+2+3" 这个常量表达式赋值给 num。由此，编译器就可以在编译时期对 num 这个表达式进行计算，因为 num 可以作为定义数组时的长度。  
  
有读者可能发现，将此示例程序中的 constexpr 用 const 关键字替换也可以正常执行，这是因为 num 的定义同时满足“num 是 const 常量且使用常量表达式为其初始化”这 2 个条件，由此编译器会认定 num 是一个常量表达式。

**注意：当常量表达式中包含浮点数时，考虑到程序编译和运行所在的系统环境可能不同，常量表达式在编译阶段和运行阶段计算出的结果精度很可能会受到影响，因此 C++11 标准规定，浮点常量表达式在编译阶段计算的精度要至少等于（或者高于）运行阶段计算出的精度。**

## constexpr修饰函数 ##

constexpr 还可以用于修饰函数的返回值，这样的函数又称为“常量表达式函数”。  
  
**注意，constexpr 并非可以修改任意函数的返回值。换句话说，一个函数要想成为常量表达式函数，必须满足如下 4 个条件：**  
  
1) 整个函数的函数体中，除了可以包含 using 指令、typedef 语句以及 static\_assert 断言外，只能包含一条 return 返回语句。  
  
举个例子：

constexpr int display(int x) 
    {
        int ret = 1 + 2 + x;
        return ret;
    }

注意，这个函数是无法通过编译的，因为该函数的返回值用 constexpr 修饰，但函数内部包含多条语句。  
  
如下是正确的定义 display() 常量表达式函数的写法：

constexpr int display(int x)
    {
        //可以添加 using 执行、typedef 语句以及 static_assert 断言
        return 1 + 2 + x;
    }

可以看到，display() 函数的返回值是用 constexpr 修饰的 int 类型值，且该函数的函数体中只包含一个 return 语句。  
  
2) 该函数必须有返回值，即函数的返回值类型不能是 void。  
  
举个例子：

constexpr void display()
    {
        //函数体
    }

像上面这样定义的返回值类型为 void 的函数，不属于常量表达式函数。原因很简单，因为通过类似的函数根本无法获得一个常量。  
  
3) 函数在使用之前，必须有对应的定义语句。我们知道，函数的使用分为“声明”和“定义”两部分，普通的函数调用只需要提前写好该函数的声明部分即可（函数的定义部分可以放在调用位置之后甚至其它文件中），但常量表达式函数在使用前，必须要有该函数的定义。  
  
举个例子：

#include <iostream>
    using namespace std;
    
    //普通函数的声明
    int noconst_dis(int x);
    //常量表达式函数的声明
    constexpr int display(int x);
    
    //常量表达式函数的定义
    constexpr int display(int x)
    {
        return 1 + 2 + x;
    }
    int main()
    {
        //调用常量表达式函数
        int a[display(3)] = { 1,2,3,4 };
        cout << a[2] << endl;
        //调用普通函数
        cout << noconst_dis(3) << endl;
        return 0;
    }
    //普通函数的定义
    int noconst_dis(int x)
    {
        return 1 + 2 + x;
    }
    
    //程序执行结果为：
    
    //3
    //6

**大家可自行将 display() 常量表达式函数的定义调整到 main() 函数之后，查看编译器的报错信息。**

可以看到，普通函数在调用时，只需要保证调用位置之前有相应的声明即可；而常量表达式函数则不同，调用位置之前必须要有该函数的定义，否则会导致程序编译失败。  
  
4) return 返回的表达式必须是常量表达式，举个例子：

#include <iostream>
    using namespace std;
    
    int num = 3;
    constexpr int display(int x)
    {
        return num + x;
    }
    int main()
    {
        //调用常量表达式函数
        int a[display(3)] = { 1,2,3,4 };
        return 0;
    }

该程序无法通过编译，编译器报“display(3) 的结果不是常量”的异常。  
  
常量表达式函数的返回值必须是常量表达式的原因很简单，如果想在程序编译阶段获得某个函数返回的常量，则该函数的 return 语句中就不能包含程序运行阶段才能确定值的变量。

**注意，在常量表达式函数的 return 语句中，不能包含赋值的操作（例如 return x=1 在常量表达式函数中不允许的）。另外，用 constexpr 修改函数时，函数本身也是支持递归的，感兴趣的读者可自行尝试编码测试。**

## constexpr修饰类的构造函数 ##

对于 C++ 内置类型的数据，可以直接用 constexpr 修饰，但如果是自定义的数据类型（用 struct 或者 class 实现），直接用 constexpr 修饰是不行的。  
  
举个例子：

#include <iostream>
    using namespace std;
    
    //自定义类型的定义
    constexpr struct myType 
    {
        const char* name;
        int age;
        //其它结构体成员
    };
    
    int main()
    {
        constexpr struct myType mt { "zhangsan", 10 };
        cout << mt.name << " " << mt.age << endl;
        return 0;
    }

此程序是无法通过编译的，编译器会抛出“constexpr不能修饰自定义类型”的异常。  
  
当我们想自定义一个可产生常量的类型时，正确的做法是在该类型的内部添加一个常量构造函数。例如，修改上面的错误示例如下：

#include <iostream>
    using namespace std;
    
    //自定义类型的定义
    struct myType 
    {
        constexpr myType(char *name,int age):name(name),age(age){};
        const char* name;
        int age;
        //其它结构体成员
    };
    
    int main()
    {
        constexpr struct myType mt { "zhangsan", 10 };
        cout << mt.name << " " << mt.age << endl;
        return 0;
    }
    
    //程序执行结果为：
    
    //zhangsan 10

可以看到，在 myType 结构体中自定义有一个构造函数，借助此函数，用 constexpr 修饰的 myType 类型的 my 常量即可通过编译。  
  
**注意，constexpr 修饰类的构造函数时，要求该构造函数的函数体必须为空，且采用初始化列表的方式为各个成员赋值时，必须使用常量表达式。**  
  
前面提到，constexpr 可用于修饰函数，而类中的成员方法完全可以看做是“位于类这个命名空间中的函数”，所以 constexpr 也可以修饰类中的成员函数，只不过此函数必须满足前面提到的 4 个条件。  
  
举个例子：

#include <iostream>
    using namespace std;
    
    //自定义类型的定义
    class myType 
    {
    public:
        constexpr myType(const char *name,int age):name(name),age(age){};
        constexpr const char * getname()
        {
            return name;
        }
        constexpr int getage()
        {
            return age;
        }
    private:
        const char* name;
        int age;
        //其它结构体成员
    };
    
    int main()
    {
        constexpr struct myType mt { "zhangsan", 10 };
        constexpr const char * name = mt.getname();
        constexpr int age = mt.getage();
        cout << name << " " << age << endl;
        return 0;
    }
    
    //程序执行结果为：
    
    //zhangsan 10

**注意，C++11 标准中，不支持用 constexpr 修饰带有 virtual 的成员方法。**

## constexpr修饰模板函数 ##

C++11 语法中，constexpr 可以修饰模板函数，但由于模板中类型的不确定性，因此模板函数实例化后的函数是否符合常量表达式函数的要求也是不确定的。  
  
针对这种情况下，C++11 标准规定，如果 constexpr 修饰的模板函数实例化结果不满足常量表达式函数的要求，则 constexpr 会被自动忽略，即该函数就等同于一个普通函数。  
  
举个例子：

#include <iostream>
    using namespace std;
    
    //自定义类型的定义
    struct myType 
    {
        const char* name;
        int age;
        //其它结构体成员
    };
    //模板函数
    template<typename T>
    constexpr T dispaly(T t)
    {
        return t;
    }
    
    int main()
    {
        struct myType stu{"zhangsan",10};
        //普通函数
        struct myType ret = dispaly(stu);
        cout << ret.name << " " << ret.age << endl;
        //常量表达式函数
        constexpr int ret1 = dispaly(10);
        cout << ret1 << endl;
        return 0;
    }
    
    //程序执行结果为：
    
    //zhangsan 10
    //10

可以看到，示例程序中定义了一个模板函数 display()，但由于其返回值类型未定，因此在实例化之前无法判断其是否符合常量表达式函数的要求：

*  当模板函数中以自定义结构体 myType 类型进行实例化时，由于该结构体中没有定义常量表达式构造函数，所以实例化后的函数不是常量表达式函数，此时 constexpr 是无效的；
 *  模板函数的类型 T 为 int 类型，实例化后的函数符合常量表达式函数的要求，所以该函数的返回值就是一个常量表达式。