C++ 笔记（07）— 常量（字面常量、const定义常量、constexpr 定义常量、enum 定义常量、define 定义常量）

在 C++ 中，常量类似于变量，只是不能修改。与变量一样，常量也占用内存空间，并使用名称标识为其预留的空间的地址，但不能覆盖该空间的内容。

常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。

在 C++ 中，常量可以是：

• 字面常量；
• 使用关键字 const 声明的常量；
• 使用关键字 constexpr 声明的常量表达式（ C++11 新增的）；
• 使用关键字 enum 声明的枚举常量；
• 使用 #define 定义的常量（已摒弃，不推荐）；

1. 字面常量

字面常量可以是任何类型：布尔型、整型、浮点型、字符、字符串等。

1.1 整型常量

整型常量可以是十进制、八进制或十六进制的常量。前缀指定基数：

• 0x 或 0X 表示十六进制；
• 0 表示八进制；
• 不带前缀则默认表示十进制；

整数常量也可以带一个后缀，后缀是 U 和 L 的组合：

• U 表示无符号整数（ unsigned ）；
• L 表示长整数（ long ）；

后缀可以是大写，也可以是小写， U 和 L 的顺序任意。下面列举几个整数常量的实例：

212         // 合法的
215u        // 合法的
0xFeeL      // 合法的
078         // 非法的：8 不是八进制的数字
032UU       // 非法的：不能重复后缀

以下是各种类型的整数常量的实例：

85         // 十进制
0213       // 八进制 
0x4b       // 十六进制 
30         // 整数 
30u        // 无符号整数 
30l        // 长整数 
30ul       // 无符号长整数

1.2 浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

• 当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。
• 当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。

下面列举几个浮点常量的实例：

3.14159       // 合法的 
314159E-5L    // 合法的 
510E          // 非法的：不完整的指数
210f          // 非法的：没有小数或指数
.e55          // 非法的：缺少整数或分数

1.3 布尔常量

布尔常量共有两个，它们都是标准的 C++ 关键字：

• true 值代表真；
• false 值代表假；

1.4 字符常量

字符常量是括在单引号中。

• 如果常量以 L （仅当大写时）开头，则表示它是一个宽字符常量（例如 L’x’），此时它必须存储在 wchar_t 类型的变量中；
• 否则，它就是一个窄字符常量（例如 x ），此时它可以存储在 char 类型的简单变量中；

字符常量可以是一个普通的字符（例如 ‘x’）、一个转义序列（例如 ‘\t’），或一个通用的字符（例如 ‘\u02C0’）。

在 C++ 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（ \n ）或制表符（ \t ）等。下表列出了一些这样的转义序列码：

转义序列	含义
\\	\ 字符
\’	’ 字符
\"	" 字符
\?	? 字符
\a	警报铃声
\b	退格键
\f	换页符
\n	换行符
\r	回车
\t	水平制表符
\v	垂直制表符
\ooo	一到三位的八进制数
\xhh . . .	一个或多个数字的十六进制数

1.5 字符串常量

字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符、普通的字符、转义序列和通用的字符。

可以使用空格做分隔符，把一个很长的字符串常量进行分行。

下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

2. 使用 const 将变量声明为常量

从实用和编程的角度看，最重要的 C++ 常量类型是在变量类型前使用关键字 const 声明的。通用的声明方式类似于下面这样：

const type variable = value;

代码示例：

#include 
using namespace std;
 
int main()
{
   const int  LENGTH = 10;
   const int  WIDTH  = 5;
   const char NEWLINE = '\n';
   int area;  
   
   area = LENGTH * WIDTH;
   cout << "area is " << area << endl;
   cout << "newline " << NEWLINE;
   return 0;
}

3. 使用 constexpr 定义常量表达式

通过关键字 constexpr ，可让常量声明像函数：

constexpr double GetPi() {return 22.0 / 7;}

在一个常量表达式中，可使用另一个常量表达式：

constexpr double TwicePi() {return 2 * GetPi();}

使用示例：

#include 
using namespace std;
 
constexpr double GetPI() { return 22.0/7; }
constexpr double TwicePI() { return 2 * GetPI(); }

int main()
{
    const double PI = 22.0/7;
    cout << "PI is " << PI << endl;
    cout << "constexpr GetPI is " << GetPI() << endl;
    cout << "constexpr TwicePI is " << TwicePI() << endl;

    return 0;
}

GetPI() 和 TwicePI() 看起来像函数，但其实不是函数。函数在程序执行期间被调用，但 GetPI() 和 TwicePI() 是函数表达式，编译器将每个 GetPI() 都替换成了3.14286，并将每个 TwicePI() 都替换成了6.28571。通过在编译阶段对 TwicePI() 进行解析，程序的执行速度比将这些计算放在函数中时更快。

4. 使用关键字 enum 声明的枚举常量

枚举类型( enumeration )是 C++ 中的一种派生数据类型，它是由用户定义的若干枚举常量的集合。

如果一个变量只有几种可能的值，可以定义为枚举( enumeration )类型。所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。

创建枚举，需要使用关键字 enum 。枚举类型的一般形式为：

enum 枚举名{ 
     标识符[=整型常数], 
     标识符[=整型常数], 
... 
    标识符[=整型常数]
} 枚举变量;

如果枚举没有初始化, 即省掉"=整型常数"时，则从第一个标识符开始。
例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 “blue”。

enum color { 
    red, 
    green, 
    blue 
} c;
c = blue;

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5。

enum color { 
    red, 
    green=5, 
    blue 
};

在这里，blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，但 red 的值依然为 0。

#include 

using namespace std;

enum days 
{
    Mon,
    Tue,
    Wed,
    Thu,
    Fri,
    Sat,
    Sun,
} day;

int main()	
{
    day = Sun;
    if (day == Sun)
    {
        cout << "a is sunday" << endl;
    }
    return 0;
}

或者

#include 

using namespace std;

enum days 
{
    Mon,
    Tue,
    Wed,
    Thu,
    Fri,
    Sat,
    Sun,
} day;

int main()	
{
    enum days today = Mon; // 声明新的枚举变量
    if (today == Mon)
    {
        cout << "a is Monday" << endl;
    }
    return 0;
}

5. 使用 #define 定义常量

首先，也是最重要的是，编写新程序时，不要使用这种常量。这里介绍使用 #define 定义常量，只是为了帮助您理解一些旧程序，它们使用下面的语法定义常量：

#define pi 3.14286

#define 是一个预处理器宏，让预处理器将随后出现的所有 pi 都替换为3.14286。预处理器将进行文本替换，而不是智能替换。编译器既不知道也不关心常量的类型。

注意：使用 #define 定义常量的做法已被废弃，因此不应采用这种做法。