C++常量如何声明 const和constexpr区别

C++中const用于声明运行时或编译时常量，保证值不可变；constexpr则要求编译时确定值，支持编译时计算，适用于数组大小、模板参数等场景，且constexpr变量必为const，反之不成立。

在C++中声明常量，我们主要依赖

const

和

constexpr

这两个关键字。简单来说，

const

确保变量一旦初始化就不能被修改，它既可以用于编译时常量，也可以用于运行时常量。而

constexpr

则更进一步，它强制要求变量在编译时就能确定其值，主要用于创建真正的编译时常量。

C++常量声明与选择

声明常量，最直观的方式就是使用

const

关键字。它放在类型前或类型后都可以，例如

const int max_size = 100;

或者

int const max_size = 100;

。这表示

max_size

的值在初始化后就不能再改变了。这种不变性可以在编译时被检查，从而避免很多潜在的错误。

而当我们需要一个在编译阶段就能确定其值的常量时，

constexpr

就显得尤为重要。比如

constexpr double PI = 3.1415926535;

。这意味着

PI

的值在程序编译完成时就已经固定下来，不会有任何运行时的计算开销。这对于数组大小、模板参数或者任何需要在编译时就确定的数值来说，是不可或缺的。

从另一个角度看，

const

更多地是关于“不变性”的承诺，而

constexpr

则是关于“编译时求值”的能力。一个

constexpr

变量必然是

const

的，因为它在编译时就确定了值，自然不能再改变。但一个

const

变量却不一定是

constexpr

的，它的值可能在运行时才确定，比如一个函数参数或者从文件读取的配置值。

立即学习“C++免费学习笔记（深入）”；

#include 

// const 可以在运行时初始化
void print_value(const int value) {
    // value = 10; // 错误：不能修改 const 参数
    std::cout << "Runtime const value: " << value << std::endl;
}

int main() {
    // const 变量，编译时确定
    const int compile_time_const = 100;
    std::cout << "Compile-time const: " << compile_time_const << std::endl;

    // const 变量，运行时确定
    int input_val;
    std::cout << "Enter a value: ";
    std::cin >> input_val;
    const int runtime_const = input_val; // runtime_const 在运行时初始化
    std::cout << "Runtime initialized const: " << runtime_const << std::endl;
    print_value(runtime_const);

    // constexpr 变量，必须在编译时确定
    constexpr double PI = 3.1415926535;
    std::cout << "Compile-time constexpr PI: " << PI << std::endl;

    // constexpr 函数示例
    constexpr int get_square(int n) {
        return n * n;
    }
    constexpr int square_of_5 = get_square(5); // 编译时计算
    std::cout << "Compile-time constexpr function result: " << square_of_5 << std::endl;

    // int arr[runtime_const]; // 错误：数组大小必须是编译时常量
    int arr_constexpr[compile_time_const]; // 正确：compile_time_const 是编译时常量
    int arr_constexpr_2[square_of_5]; // 正确：square_of_5 是编译时常量

    return 0;
}

C++中const关键字的深层理解与使用场景

const

关键字在C++里，与其说是一个简单的“常量”声明，不如说是一种强大的“不变性”契约。它渗透在语言的各个角落，从基本数据类型到复杂的类结构，无处不在。我个人觉得，掌握

const

的精髓，是写出健壮、可维护C++代码的关键一步。

它最直接的用法是修饰变量，声明一个常量，比如

const int max_iterations = 1000;

。这很明确，

max_iterations

的值不能变。但事情没那么简单，当涉及到指针时，

const

的位置就变得微妙起来。

考虑

const int* ptr;

和

int* const ptr;

。前者表示

ptr

指向的内容是常量，你不能通过

ptr

去修改它指向的值，但

ptr

本身可以指向别的地方。而后者则表示

ptr

这个指针本身是常量，它一旦指向某个地址就不能再指向别处了，但它指向的内容（如果不是

const

的）是可以修改的。如果两者兼顾，那就是

const int* const ptr;

，内容和指针本身都不能变。这种细微的差别，初学者常常混淆，但却是避免很多运行时错误的关键。

int a = 10;
int b = 20;

const int* ptr_to_const = &a; // ptr_to_const 指向的内容是常量
// *ptr_to_const = 15; // 错误：不能修改 ptr_to_const 指向的内容
ptr_to_const = &b; // 正确：ptr_to_const 本身可以改变指向

int* const const_ptr = &a; // const_ptr 这个指针是常量
*const_ptr = 15; // 正确：可以通过 const_ptr 修改它指向的内容
// const_ptr = &b; // 错误：const_ptr 本身不能改变指向

const int* const const_ptr_to_const = &a; // 指针和它指向的内容都是常量
// *const_ptr_to_const = 15; // 错误
// const_ptr_to_const = &b; // 错误

在函数参数中，

const

引用（

const T&

）非常常见，它既避免了对象拷贝的开销，又保证了函数不会修改传入的原始对象，这是一种非常好的实践。

此外，在类成员函数中，

const

修饰符（

void my_func() const;

）表示这个成员函数不会修改类的任何成员变量。这对于提供只读操作的函数至关重要，它让编译器帮你检查，确保你的设计意图得到遵守。这不仅提升了代码的安全性，也让使用者能清晰地知道哪些函数是安全的“只读”操作，哪些可能会改变对象状态。

使用

const

的好处是多方面的：它提高了代码的可读性，明确了变量的意图；它增加了安全性，让编译器在编译阶段就能捕获到对常量的不当修改；它还能帮助编译器进行优化，因为编译器知道某些值不会改变。在我看来，写C++，如果能坚持合理地使用

const

，代码质量会有一个质的飞跃。

C++ constexpr：编译时常量表达式的强大之处

constexpr

，这个C++11引入的关键字，我觉得它真正体现了现代C++追求“零开销抽象”和“尽可能在编译时完成工作”的哲学。它不仅仅是声明一个常量，更重要的是，它承诺这个值（或这个函数的结果）能够在编译阶段被完全确定。

constexpr

的核心在于“编译时求值”。这意味着，任何被

constexpr

修饰的变量，它的初始化表达式必须是一个常量表达式，即编译器在编译时就能完全计算出结果的表达式。比如，

constexpr int size = 10 * 20;

，这里的

10 * 20

在编译时就能算出是200。而

constexpr int size = get_runtime_input();

则是不允许的，因为

get_runtime_input()

的结果只能在运行时才能确定。

constexpr

的强大之处远不止于此，它还可以修饰函数、构造函数，甚至是C++20中的虚函数。一个

constexpr

函数意味着它在满足特定条件时（所有参数都是常量表达式），可以在编译时被调用并计算出结果。这带来的好处是显而易见的：

1. 性能优化：编译时计算意味着运行时没有任何开销。对于一些固定不变的数学计算或数据转换，直接在编译时完成，程序启动或执行时就省去了这部分计算时间。这对于嵌入式系统或者对性能极致追求的场景非常有利。
2. 类型安全与模板元编程：

   constexpr

   值可以作为非类型模板参数，或者用于数组的大小声明，这在以前通常需要依赖宏或者枚举。这使得模板元编程更加强大和类型安全。比如

   std::array

   中的

   N

   就可以是一个

   constexpr

   变量。
3. 更强的编译器检查：如果一个值被声明为

   constexpr

   但实际上不能在编译时确定，编译器会立即报错，这比运行时错误更容易发现和修复。

#include 
#include  // For std::array

// constexpr 函数：如果参数是常量表达式，则可以在编译时求值
constexpr int factorial(int n) {
    return (n <= 1) ? 1 : (n * factorial(n - 1));
}

// C++17 constexpr lambda
constexpr auto sum_two_numbers = [](int a, int b) {
    return a + b;
};

class Point {
public:
    constexpr Point(double x, double y) : x_(x), y_(y) {}
    constexpr double get_x() const { return x_; }
    constexpr double get_y() const { return y_; }
private:
    double x_, y_;
};

int main() {
    // constexpr 变量，由 constexpr 函数初始化
    constexpr int fact_5 = factorial(5); // 编译时计算 factorial(5)
    std::cout << "Factorial of 5 (constexpr): " << fact_5 << std::endl; // 120

    // 使用 constexpr 结果作为数组大小
    std::array my_array; // 数组大小在编译时确定为 24
    std::cout << "Size of my_array: " << my_array.size() << std::endl;

    // constexpr lambda 的使用
    constexpr int total = sum_two_numbers(10, 20); // 编译时计算
    std::cout << "Sum (constexpr lambda): " << total << std::endl;

    // constexpr 构造函数
    constexpr Point p1(1.0, 2.0); // 编译时构造 Point 对象
    std::cout << "Point coordinates (constexpr): (" << p1.get_x() << ", " << p1.get_y() << ")" << std::endl;

    // 注意：constexpr 函数如果运行时调用，行为和普通函数一样
    int runtime_val = 3;
    int fact_runtime = factorial(runtime_val); // 运行时计算 factorial(3)
    std::cout << "Factorial of 3 (runtime): " << fact_runtime << std::endl;

    return 0;
}

constexpr

函数有一些限制，比如它们通常不能包含虚函数调用、

goto

语句、非字面量类型的变量（除非它们也是

constexpr

的）等。这些限制确保了函数在编译时求值的可能性。但随着C++标准的演进，

constexpr

的能力也在不断增强，例如C++14放宽了

constexpr

函数的限制，允许包含局部变量和循环等。

const与constexpr：何时选择，如何抉择？

在实际编程中，面对

const

和

constexpr

，我们常常需要做出选择。这两种关键字虽然都与“不变性”有关，但它们的侧重点和适用场景却有着本质的区别。理解这些差异，才能做出最合适的抉择。

最核心的区别在于：

const

保证的是“运行时不变性”，而

constexpr

则要求“编译时不变性”。换句话说，所有

constexpr

的变量都是

const

的，因为它们在编译时就确定了值，自然不能再改变。但反过来就不成立了，一个

const

变量可能在运行时才被初始化，所以它不一定是

constexpr

的。

何时选择

const

？

当你只是想表达某个变量在初始化后不应被修改，无论其值是在编译时确定还是运行时确定，

const

都是你的首选。

• 函数参数：当你不希望函数修改传入的参数时，使用

  const

  引用或

  const

  指针，比如

  void process_data(const std::vector& data);

  。这是一种安全且高效的做法。
• 类成员函数：当一个成员函数不修改类的任何成员变量时，将其声明为

  const

  成员函数，例如

  double get_area() const;

  。这有助于维护对象的状态完整性，并允许

  const

  对象调用这些函数。
• 局部变量：对于那些在函数内部初始化后就不再改变的变量，使用

  const

  可以提高代码可读性，并帮助编译器进行优化。
• 全局或静态常量：如果这些常量的值可能依赖于运行时环境（比如从配置文件读取），或者你只是想表达它们不可变，但不需要在编译时使用它们进行计算，那么

  const

  是合适的。

何时选择

constexpr

？

当你需要一个值在编译时就必须确定，并且可能用于编译时计算（如数组大小、模板参数），或者你追求极致的性能优化，希望将计算提前到编译阶段时，

constexpr

是不可替代的。

• 数组大小：C++要求数组的大小必须是编译时常量，所以

  constexpr

  变量是理想的选择。

  int my_array[constexpr_size];

  。
• 模板参数：非类型模板参数必须是编译时常量，

  constexpr

  变量能够满足这一要求。
• 性能关键的计算：如果某个计算的结果在程序运行前就能确定，并且这个计算是重复的或者开销较大，将其封装为

  constexpr

  函数，可以避免运行时开销。
• 字面量类型：对于像整数、浮点数、枚举等字面量类型，如果它们的值是固定的，并且你想强调其编译时性质，

  constexpr

  是比

  const

  更强的声明。

总结一下核心差异：

特性	@@######@@	@@######@@
求值时机	编译时或运行时	必须在编译时
保证	变量值不可变	变量值不可变，且在编译时确定
适用范围	变量、指针、引用、函数参数、成员函数	变量、函数、构造函数、lambda表达式
隐含关系	@@######@@变量隐含@@######@@，反之不然
主要目的	表达不变性，防止意外修改	启用编译时计算，优化性能，提供更强的类型安全

在实践中，如果一个变量的值可以在编译时确定，并且你希望它具有编译时常量属性，那么优先使用

const

。如果只是简单地希望变量不可变，且其值可能在运行时确定，那么使用

constexpr

就足够了。过度使用

constexpr

可能会对代码的灵活性造成一些限制，因为它要求更严格的编译时求值条件。但另一方面，如果忽略

const

，你可能会错过一些重要的性能优化机会，并且无法利用其在模板元编程等领域的强大能力。所以，这确实是一个需要权衡的选择。

constexpr

const

constexpr

constexpr