概述

在程序运行过程中，始终不发生改变的量，称之为常量。在 C++ 语言中常量是个固定值，也就是说常量值在定义后不能进行修改。

#define

①．宏常量
#define 是 C 语言中定义常量的方式，在 C++ 中也可以使用。
②．#define 的使用

#define MAX = 200

③．宏常量的特点
define 在预处理阶段起作用；宏常量没有数据类型，只是进行文本替换替换；宏常量在内存中会产生多份相同的备份。
若仅用于定义常量，在 C++ 中不推荐使用。

const

①．const 限定符
const 是 C++ 中的变量修饰符，表示该变量是只读的，不可改变的，const 是变量类型的一部分。
②．const 的使用

const int max = 20;

③．const 变量的特点
const 在编译、运行阶段起作用；const 常量有数据类型，编译器可以进行类型安全检查；const 常量在程序运行过程中只有一份备份。

enum

①．enum 枚举类
enum 是 C++ 中一种派生数据类型，它是由用户定义的若干枚举常量的集合。
②．enum 的使用

enum class color{ red,green,blue };

③．enum 类型的特点
enum 在编译时被全部求值；enum 常量隐含数据类型是整数，其最大值有限，且不能表示浮点类型 ；枚举常量不会占用对象的存储空间。

constexpr

①．constexpr 常量表达式
C++ 中使用 constexpr 表示常量表达式，是指值不会改变并且在编译过程就能得到计算结果的表达式，constexpr 是声明的一部分，而不是变量类型的一部分。
②．constexpr 的使用

constexpr int max = 35;

③．constexpr 的特点
constexpr 的变量的值必须是编译器在编译的时候就可以确定的。

对于C++23标准，如果我们想要某个类的成员变量能被此类的所有对象访问，且该变量不可修改，那么我们一般会选择将该变量声明为静态常量。例如此代码：

class Decrypter{
    static const int mask = 0x8a;
public:
    void decrypt(){
        ...
    }
};

其中，我们把Decrypter::mask声明为了一个静态常量。对于Decrypter类的所有对象而言，都能访问到同一个mask，节约了内存空间。

然而，如果我们把mask改为一个mask数组，如下列代码所示：

class Decrypter{
    static const int mask[] = {0x8a, 0x2b, 0x3c};
public:
    void decrypt(){
        ...
    }
};

此时编译器就会报错：

 error: in-class initialization of static data member 'const int Decrypter::mask []' of incomplete type

翻译过来就是：“错误：不完整类型的静态成员'const int Decrypter::mask []'的类内初始化”。

这句话连谓语都没有，简直晦涩难懂。

猜测其大致意思为：mask数组在初始化时遇到了错误，原因是其类型不完整。

解决办法有两种：

第一种方法是将定义搬到类外面去：

class Decrypter{
    static const int mask[];
public:
   void decrypt(){
        ...
   }
};
const int Decrypter::mask[] = {0x8a, 0x2b, 0x3c};

个人并不是很喜欢这种做法，因为破坏了直观性。万一这个静态常量下面的代码非常多，为了看他这一个静态常量的定义内容，我们还得用鼠标滚下去，再滚上来，很破坏阅读程序时的思维连贯性。也可能是博主最近学习了Python，不太喜欢这种形式。

所以为了依然在类内定义此静态常量，一般会采用第二种方法。

第二种方法是在前面加一个“constexpr”：

class Decrypter{
    constexpr static const int mask[] = {0x8a, 0x2b, 0x3c};
public:
   void decrypt(){
        ...
    }
};

这样编译器就不会报错了，程序完美运行，同时也达到了在类内直接定义此静态常量的目的。 

第一次看到这个关键字就很萌，这尼玛什么神仙关键字啊

然后一查资料：“常量表达式(constexpr)在编译期就可以计算出结果。”

然而这里的constexpr显然不是在编译期计算出来的，比如我写这串代码，也能正常运行：

#include <iostream>
using namespace std;

class Decripter{
    constexpr static const int mask[] = {10, 20, 30};
    int x;
public:
    Decripter(): x(0){}
    int next(){
        return mask[x++];
    }
};

int main() {
    Decripter dd;
    cout << dd.next() << endl;    //10
    cout << dd.next() << endl;    //20
    cout << dd.next() << endl;    //30
    return 0;
}

由于x是一直在变化的，所以显然不可能在编译期间得出

我反正是很懵的。。。

常量的作用：

        用于记录程序中不可更改的数据

C++定义常量的方式有两种：

        1、#define 宏常量

                通常在文件上方定义

        2、const 修饰的变量

                通常在变量定义前加关键字 const

#include <iostream>
using namespace std;

//1、宏常量
#define Day 7

int main()
{
        //Day = 8; //错误，Day是常量，一旦修改就会报错
        cout << "day =" << Day << endl;

        //2、const修饰的变量
        const int month = 12;
        //month = 24;    //错误，const修饰的变量也称为常量
        cout << "month=" << month << endl;

        return 0;
}