笼统的讲 constexpr 主要用于编译时期，const用于运行时，但实际上两者都可以同时用于编译时期和运行时。

const

const可以修饰全局变量，局部变量，函数参数，指针，引用，也可以修饰类成员函数，类成员变量，不可用于构造函数和析构函数。

被修饰的局部变量不可以修改，如果是类对象，则只可以调用 const 函数。

修饰类变量时，变量可以是static也可以是非static，static const int成员变量可以只声明不用定义，其他类型必须定义。

全局变量

const全局变量一般放在头文件中，对于基础类型（int、float）来说，如果没有取址操作，编译器会当作编译时变量。

const全局变量默认是static，只在当前cpp内可以用，其cpp内会报错。

// a.cpp
const int cn = 10; // cn 为static，其他cpp中不可用// b.cpp
extern const int cn; 
// 链接时会找不到 cn
// MSVC b.cpp.obj : error LNK2001: 无法解析的外部符号 "int const cn" (?cn@@3HB)

在const int cn 前面加上 extern const int cn可以让变量变成非static，此时其他cpp内可以使用。

// a.cpp
extern const int cn; // 加上后 cn 为非 static
const int cn = 10;// b.cpp
extern const int cn; 
// 可以正常使用 a.cpp 内的 cn

指针

指针可以两个地方添加const，const T* const p。第一个const代表p指向的内容不可修改，此时p指向的对象只可以调用const成员函数，第二个const代表p自身不可修改。

引用

引用前面可以添加const，const T& ref此时ref的对象只可以调用const成员函数。const T&可以指向右值，如果指向函数返回的临时对象，可以延长临时对象的生命周期，如下：

std::cout << "--- Right value life --------------" << std::endl;
class Base
{
public:explicit Base(int n) : n(n) { std::cout << "Base Construct, " << n << std::endl; }~Base() { std::cout << "Base Destruct, " << n << std::endl; }int n = 0;static Base fun(int n){ return Base(n); }
};{std::cout << "--- life begin -----" << std::endl;Base::fun(1);const Base& cbf = Base::fun(2); // 生命周期会被延长Base&& rbf = Base::fun(3); // 生命周期会被延长// const Base* bp = &Base::fun(4); // compile error, 不能对右值取地址std::cout << "--- life end -----" << std::endl;
}

输出结果

--- Right value life --------------
--- life begin -----
Base Construct, 1
Base Destruct, 1
Base Construct, 2
Base Construct, 3
--- life end -----
Base Destruct, 3
Base Destruct, 2

函数参数

const修饰函数参数时不要修饰变量自身，此时修饰是无效的，容易出现重定义。一般用于修饰指针或引用。

void fun(int n) {}
void fun(const int n) {} // 编译错误，与 上一个fun重定义void fun(int& n) {}
void fun(const int& n) {} // 没有问题，const int 变量会调用此函数

类成员函数

被const修饰的类成员函数其内部的this指针为const，函数内部不可修改变量，只能调用其他const修饰的成员函数。如果想要修改成员变量，可以把变量声明为mutable，或者使用const_cast把this指针变为非const。

class BC
{
public:void foo() { std::cout << "foo" << std::endl; }void bar() const { std::cout << "bar" << std::endl; }void fun(int n) const{this->bar(); // const 成员函数 std::cout << "fun: " << n << std::endl; // 可以读取变量this->m = 10; // 使用的mutable修饰，可以修改，this->foo(); // 非const成员函数 编译错误this->n = 3; // 编译错误const_cast<BC*>(this)->foo();const_cast<BC*>(this)->n = 4;}int n{};mutable int m{};
};

编译时

const int n = 10;
int array[n]; // n为编译时确定

constexpr

constexpr可修饰全局变量、局部变量、类static静态变量，指针，引用，函数，构造函数，类成员函数，if表达式，不可修饰类成员变量。

变量

constexpr修饰的变量具有const属性，不可修改，只能调用const成员函数。如果是修饰类对象必须要，类必须提供对应的 constexpr 构造函数。constexp变量通常是编译是的，如果有对变量进行取地址或调用成员函数，变量会变为运行时。

只能修饰类static静态变量变量，不可以修饰成员变量，修饰的static静态变量无需定义。

全局变量

constexpr全局变量默认是static的，通常放在头文件中，不可用extern引入到其他cpp中使用，如果想要设置为非static，需要加上inline。

constexpr int cn = 10; // static 变量，不同cpp内取地址值不一致inline constexpr int cn = 10; // 非 static 变量，不同cpp内取地址值一致

指针和引用

constexpr修饰的指针只表示当前指针变量是const，其指向的对象依然可以修改。对于引用和指针依然需要添加const来修饰用于指向const对象。

char str[] = "Hello World";
constexpr char* cec = str;cec[0] = 'h';
std::cout << cec << '\n'; // 输出：hello Worldint value = 10;
constexpr int* ptr = &value;
constexpr int& ref = value;const int cv = 20;
constexpr const int* cptr = &cv; // 需要加上const,否则会编译错误
constexpr const int& cref = cv; // 需要加上const,否则会编译错误

函数

constexpr可以在编译时运行，例如编译时计算数组长度，因为是编译时运行，所以实现必须在同一个cpp中，一般实现放在头文件中，类似于inline函数。constexpr函数如果传入的运行时参数，则会到运行时再执行。

constexpr int foo(int n)
{return 10*n;
}
int array[foo(10)];

类成员函数

constexpr修饰的构造函数表示当前类可以构造constexpr对象。

constexpr修饰的成员函数并不是const程序函数，只代表是可以编译时运行，如果想要是const属性依然要添加const。

constexpr成员函数也可以是set函数，用于编译时修改成员变量

class Vec2
{
public:constexpr Vec2()=default;constexpr Vec2(float x, float y) : x(x), y(y) {};constexpr float getX() const  { return x; }constexpr float getY() const { return y; }constexpr void setX(float x) { this->x = x; }constexpr void setY(float y) { this->y = y; }
private:float x{};float y{};
};constexpr Vec2 Add(const Vec2& lhs, const Vec2& rhs)
{Vec2 p; // 不能使用p.setX(lhs.getX() + rhs.getX());p.setY(lhs.getY() + rhs.getY());return p;
}// 使用示例
constexpr Vec2 p1 = {1, 2};
constexpr Vec2 p2 = {3, 4};
constexpr Vec2 p3 = Add(p1, p2);

if 表达式

编译时条件变量，内部的条件也必须是编译时能确定的，否则会报错。

if constexpr (sizeof(int) == 4)
{std::cout << sizeof(int) << std::endl;
}