1、constexpr

1.1 顶层const和底层const

C++为了区分，把本身被const修饰叫做顶层const，把指向的对象被const修饰叫做底层const。

大多数对象被const修饰都叫做顶层const。

指针被const修饰时，* 左边的const叫做底层const，* 右边的const叫做顶层const。

const修饰引用时，这个const是底层const。

int main() { int i = 0; int* const p1 = &i; // 顶层const const int ci = 42; // 顶层const const int* p2 = &ci; // 底层const const int& r = ci; // 底层const return 0; }

1.2 constexpr和常量表达式

常量表达式是指值不会改变并且在编译过程中就能得到计算结果的表达式。字面值、常量表达式初始化的const对象都是常量表达式，但是变量初始化的const对象不是常量表达式。

int size() { int n = 10; return n; } int main() { const int a = 1; // 是 const int b = a + 1; // 是 int c = 1; // 不是 const int d = c; // 不是 const int e = size(); // 不是 return 0; }

constexpr（constant expression）是C++11引入的一个关键字，用于指定常量表达式。它允许编译器在编译时计算表达式的值，从而提高运行时性能并增强类型安全性。

constexpr可以修饰变量，constexpr修饰的变量一定是常量表达式，且必须用常量表达式初始化，否则会报错。

int main() { constexpr int aa = 1; constexpr int bb = aa + 1; //constexpr int cc = c; // 报错 //constexpr int cc = size(); // 报错 return 0; }

constexpr可以修饰指针，constexpr修饰的指针是顶层const，也就是指针本身。

1.3 constexpr函数

constexpr普通函数，要求函数声明的参数和返回值都是字⾯值类型(整形、浮点型、指针、引⽤
等)，函数返回值类型不能是空。要求函数体中，只包含⼀条 return 返回语句，不能定义局部变
量，循环条件判断等控制流，并且返回值必须是常量表达式。

#include <iostream> using namespace std; constexpr int size() { return 10; } constexpr int func(int x) { return 10 + x; } constexpr int factorial(int n) { return n <= 1 ? 1 : n * factorial(n - 1); } int main() { constexpr int x = size(); constexpr int y = func(2); constexpr int z = factorial(5); cout << x << " " << y << " " << z << endl; return 0; }

constexpr构造函数，constexpr不能修饰⾃定义类型，但是⽤constexpr修饰类的构造函数后可以
就可以。该类的所有成员变量必须是字⾯类型(literal type)，constexpr构造函数必须在初始化列表
初始化所有成员变量，构造对象实参必须使⽤常量表达式，函数体必须为空，析构函数必须是平凡
的不做任何实际清理工作。

#include<iostream> using namespace std; class Date { public: constexpr Date(int year, int month, int day) :_year(year) , _month(month) , _day(day) { } private: int _year; int _month; int _day; }; int main() { int x = 2025; //constexpr Date d0(x, 9, 8); // 报错 constexpr Date d1(2025, 9, 8); return 0; }

constexpr成员函数，constexpr成员函数自动成为 const 成员函数，这意味着它们不能修改对象的
成员变量，其他要求跟普通函数⼀样。另外constexpr成员函数不能是虚函数。

C++11 标准规定，如果 constexpr 修饰的模板函数实例化结果不满足常量表达式函数的要求，则 constexpr 会被自动忽略，即该函数就等同于⼀个普通函数。

C++11中对constexpr函数要求较多，C++14/C++17/C++20中会逐步放开，后面会讲解。

1.4 constexpr 在C++14中的演进

C++14最显著的改进是大幅放宽了对constexpr函数的限制，使其语法和功能更接近普通函数。
函数限制的全面放宽
• 局部变量：允许声明和初始化局部变量（只要在constexpr上下⽂中使⽤）
• 控制流语句：⽀持if条件分⽀、for/while循环、switch语句等
• 多return语句：函数体不再限于单⼀return语句

constexpr int factorial(int n) { int res = 1; // 允许局部变量 for (int i = 2; i <= n; ++i) // 允许循环 { res *= i; } return res; } constexpr size_t stringLength(const char* str) { size_t len = 0; while (str[len] != '\0') ++len; return len; } constexpr size_t len = stringLength("Hello"); // 编译期计算：5

支持更复杂的返回类型
•C++14允许constexpr函数返回非基本类型，包括：void返回，自定义类、STL容器(std::array)、其他符合constexpr要求的复合类型

1.5 constexpr在C++17中的演进

if constexpr - 编译期条件分支
if constexpr 是 C++17 引⼊的⼀种条件编译语句，它允许在编译时根据常量表达式的结果决定编译哪部分代码，未选择的分支代码不会编译成指令，直接丢弃。

constexpr lambda 表达式
• lambda表达式可标记为constexpr
• 捕获必须是编译期常量
• 函数体需满足constexpr函数要求

int main() { // constexpr lambda⽰例 constexpr int n = 10; int y = 0; constexpr auto square = [n](int x) constexpr ->int{ return x * x * n; }; constexpr int result = square(5); // 编译期计算：250 return 0; }

1.6 constexpr在C++20中的演进

动态内存分配的编译期支持
支持 new / delete ：允许在 constexpr 上下文中使用动态内存分配

constexpr int dynamic_memory_example() { int* p = new int{ 42 }; // 编译期分配 int value = *p; delete p; // 必须显式释放 return value; } int main() { constexpr int v = dynamic_memory_example(); // 42 return 0; }

标准库的逐步constexpr化

try-catch 的全面支持

constexpr 联合体(union)

constexpr 可变(mutable)成员：constexpr成员函数中，成员变量是不能修改的，但是我们定义成员变量时，加上mutable修饰，这个成员变量在constexpr成员函数中就可以修改了。

constexpr 虚函数支持

C++20标准对constexpr关键字进⾏了⾰命性的增强，将编译期计算能⼒提升到了前所未有的⾼度。这些改进不仅⼤幅扩展了constexpr的应⽤范围，还使其成为现代C++元编程和性能优化的核⼼⼯具。

1.7 C++20的consteval

constexpr (常量表达式)的核⼼思想是 “允许” 在编译期进⾏计算。被它修饰的函数，编译器会验证其是否可以在编译时求值。如果可以，它很可能在编译期就被计算好；但如果上下⽂要求它在运⾏时计算，它也可以像⼀个普通函数⼀样运⾏。也就是说 constexpr 函数可以在编译期运⾏，也可以在运⾏期运⾏，它是否在编译期求值，取决于调⽤它的上下⽂。

constexpr int square(int x) { return x * x; } int main() { // 场景1：编译时求值 constexpr int const_val = square(10); // 必须在编译时计算 // 场景2：运⾏时求值 int runtime_input = 5; int runtime_val = square(runtime_input); // 在运⾏时像普通函数⼀样调⽤ return 0; }

consteval 是为了解决 constexpr 的“不确定性”⽽引⼊的。 consteval 的核⼼思想是创建⼀个必须在编译期求值的函数，它被称为⽴即函数。它⽐ constexpr 更严格，它修饰的函数必须在编译时被调⽤和求值。如果⼀个 consteval 函数不能在编译时被求值，那么程序将⽆法通过编译。将上⾯代码square函数改成 consteval 修饰会编译报错。

2、类型处理

2.1 auto

编译器推导auto类型时，有时候也会和初始值的类型不⼀样，编译器会适当的改变结果类型，使其
更符合初始化规则。⾸先使⽤引⽤其实是使⽤引⽤的对象，特别是当引⽤被⽤作初始值时，真正参
与初始化的其实是引⽤对象的值，所以编译器推导auto为引⽤对象的类型，⽽不是引⽤。其次⼀个带有const属性的值初始化auto对象推导时忽略掉顶层const，保留底层const。
• auto不能⾃动推导出引⽤类型，所以我们如果想将auto推导为引⽤类型，需要明确的指出：auto&x = i;
• auto不能推导出顶层const，如果想使⽤auto推导出顶层const，需要明确的指出：const auto x = ci;

• auto& 声明⼀个左值引用，它只能绑定到左值，如果初始化对象有const属性，推导时会保持const 限定符，否则涉及权限放⼤。
• const auto& 声明⼀个const 左值引⽤，既可以绑定到左值⼜可以绑定到右值，不会修改绑定对象。
• auto&& 是万能引⽤，遵循引⽤折叠的规则，既可以绑定到左值⼜可以绑定到右值，初始化表达式⾃动推导为左值引⽤或右值引⽤，如果初始化对象有const属性，推导时会保持 const 限定符。

2.2 decltype

如果我们希望⽤表达式推出变量的类型，但是不想⽤表达式的值初始化变量，那么这时可以使⽤decltype。需要注意的是编译器并不会实际调⽤f函数，⽽是⽤f的返回类型作为x的类型。

#include <iostream> using namespace std; int main() { int i = 0; const int ci = 0; const int& rci = ci; decltype(i) m = 1; // m的类型是int decltype(ci) x = 1; // x的类型是const int m++; //x++; // 报错 decltype(rci) y = x; // y的类型是const int& //y++;// 报错 return 0; }

2.3 尾置返回类型

尾置返回类型是C++11引⼊的⼀种函数声明语法，它允许将函数的返回类型放在参数列表之后⽽不是函数名前。

尾置返回类型的语法这⾥我们简单的做个了解即可，因为C++14引⽤了auto做返回类型时，返回类型⾃动推导，很多地⽅就不太需要尾置返回类型了。

为什么需要尾置返回类型：
1. 提⾼代码可读性：特别是当返回类型很⻓或复杂时
2. ⽀持Lambda表达式：Lambda表达式的返回类型必须使⽤尾置语法
3. 模板编程：在模板函数中，返回类型可能依赖于参数类型

// 1. 复杂返回类型 auto getComplexType() -> std::map<std::string, std::vector<int>> { // ... } // 2. 依赖参数类型的返回类型 template <typename T, typename U> auto add(T t, U u) -> decltype(t + u) { return t + u; } // 3. lambda表达式 auto lambda = [](int x) -> double { return x * 1.5; };

2.4 typedef和using

C++98中我们⼀般使⽤typedef重定义类型名，也很⽅便，但是typedef不⽀持带模板参数的类型重
定义。C++11中新增了using可以替代typedef，using 的别名语法覆盖了 typedef 的全部功能，不
少场景还更清晰⼀些，⽐如函数指针的重定义，其次最⼤的变化是⽀持带模板参数重定义的语法。

#include <map> #include <string> using namespace std; //typedef map<string, int> CountMap; //typedef int DateType; //typedef void (*Callback)(int); // using 兼容typedef的⽤法 using CountMap = map<string, int>; using STDateType = int; using Callback = void (*)(int); // using⽀持带模板参数的类型重定义 template<class Val> using Map = map<string, Val>; template<class Val> using MapIter = typename map<string, Val>::iterator; int main() { Map<int> countMap; MapIter<string> dit = dictMap.begin(); return 0; }