syxdevcode博客

CPP-常量

发表于 更新于 分类于
本文字数： 5k 阅读时长 ≈ 5 分钟

常量，又叫做字面量，是固定值，在程序执行期间不会改变。

常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。

前缀指定基数：

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

整数常量可以带一个后缀 U 或 L，U 表示无符号整数（unsigned），L 表示长整数（long）。
后缀可以是大写，也可以是小写，U 和 L 的顺序任意，可以两个同时存在。

整数常量的实例:

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

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

1
2
3
4
5
6
7
85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* 整数 */
30u        /* 无符号整数 */
30l        /* 长整数 */
30ul       /* 无符号长整数 */

浮点常量

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

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

由十进制数，加阶码标志 e 或 E 以及阶码（只能为整数，可以带符号）组成。

其一般形式为：
a E n（a为十进制数，n为十进制整数）其值为 a*10^n。

1
2
3
4
5
6
2.1E5 (等于2.1*10^5)
3.7E-2 (等于3.7*10^-2)
0.5E7 (等于0.5*10^7)
-2.8E-2 (等于-2.8*10^-2)
3.14159 
314159E-5L  (等于314159*10^-5)

以下不是合法的浮点数：

1
2
3
4
5
6
7
8
345 (无小数点)
E7 (阶码标志E之前无数字)
-5 (无阶码标志)
53.-E3 (负号位置不对)
2.7E  (无阶码)
510E          /* 非法的：不完整的指数 */
210f          /* 非法的：没有小数或指数 */
.e55          /* 非法的：缺少整数或分数 */

布尔常量

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

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

注意：不应把 true 的值看成 1，把 false 的值看成 0。

字符常量

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

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

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

反斜杠(\) 开头是叫转义序列(Escape Sequence)。

\ooo 是对用三位八进制数转义表示任意字符的形象化描述。
如 char ch = '\101'，等价于 char ch = 0101; (以0开头的表示八进制）。

\xhh 里面是 x 是固定的，表示十六进制(hexadecimal)，h 也表示十六进制。
如 char ch = '\x41'，就是用十六进制来表示，它与前面的 \101 是等价的。

实例

1
2
3
4
5
6
7
8
#include <iostream>
using namespace std;
 
int main()
{
   cout << "Hello\tWorld\n\n";
   return 0;
}

结果：Hello World

字符串常量

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

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

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
#include <string>
using namespace std;

int main() {
    string greeting = "hello, cpp";
    cout << greeting;
    cout << "\n";     // 换行符
    string greeting2 = "hello, \
                       cpp";
    cout << greeting;
    return 0;
}

定义常量

在 C 中，有两种简单的定义常量的方式：

  • 使用 #define 预处理器。
  • 使用 const 关键字。

通常，把常量定义为大写字母形式。

#define 预处理器

注意：#define 是宏定义，它不能定义常量，但宏定义可以实现在字面意义上和其它定义常量相同的功能，本质的区别就在于 #define 不为宏名分配内存。

宏定义是可以取消的

1
2
定义： #define    N    21
取消： #undef    N    12

下面是使用 #define 预处理器定义常量的形式：

1
#define identifier value

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;
 
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{
   int area;  
   
   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

结果：

1
value of area : 50

define 注意 边缘效应，例：#define N 2+3, N 的值是 5。

1
2
double a;
a = (float)N/(float)2;

在编译时，预想是 a=2.5，实际打印结果是 3.5。原因是在预处理阶段，编译器将 a=N/2 处理成 a=2+3/2，这就是 define 宏的边缘效应，所以应该写成 #define N (2+3)。

const 关键字

使用 const 前缀声明指定类型的常量，如下所示：

1
const type variable = value;

const 限定符定以后是不可以改变的，所以在定义时必须赋初始值，要不然是错误的，除非这个变量是用 extern 修饰的外部变量。

例如：

1
2
3
const int A=10;       //正确。
const int A;          //错误，没有赋初始值。
extern const int A;   //正确，使用extern的外部变量。

c-const-2021-01-15-2.png

注意：const 定义的是变量不是常量，而是去改变一个变量的存储类，把该变量所占的内存变为只读，带有类型。编译运行的时候起作用存在类型检查。

define和const区别联系

const 定义的是变量不是常量，只是这个变量的值不允许改变是常变量。

define 定义的是不带类型的常数，只进行简单的字符替换。在预编译的时候起作用，不存在类型检查。

1、两者的区别

(1) 编译器处理方式不同

#define 宏是在预处理阶段展开。
const 常量是编译运行阶段使用。

(2) 类型和安全检查不同

#define 宏没有类型，不做任何类型检查，仅仅是展开。
const 常量有具体的类型，在编译阶段会执行类型检查。

(3) 存储方式不同

#define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。（宏定义不分配内存，变量定义分配内存。）
const 常量会在内存中分配(可以是堆中也可以是栈中)。

(4) const 可以节省空间，避免不必要的内存分配。 例如：

1
2
3
4
5
6
#define NUM 3.14159 //常量宏
const doulbe Num = 3.14159; //此时并未将Pi放入RAM中
double i = Num; //此时为Pi分配内存，以后不再分配！
double I= NUM; //编译期间进行宏替换，分配内存
double j = Num; //没有内存分配
double J = NUM; //再进行宏替换，又一次分配内存！

const 定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象 #define 一样给出的是立即数，所以，const 定义的常量在程序运行过程中只有一份拷贝（因为是全局的只读变量，存在静态区），而 #define 定义的常量在内存中有若干个拷贝。

(5) 提高了效率。 编译器通常不为普通 const 常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

(6) 宏替换只作替换，不做计算，不做表达式求解;

宏预编译时就替换了，程序运行时，并不分配内存。

const修饰指针

1、const 关键字出现在 * 的左边：指针指向的内容不能被修改。
2、const 关键字出现在 * 的右边：指针本身不能被修改。
3、const 关键字出现在 * 的两边：指针指向的内容和指针本身都不能被修改。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
using namespace std;
int main()
{
    int a=1;
    int b;
    
    /**指向const的指针，指针指向的内容不能被修改**/
    const int *p1;
    int const *p2;
   
    /**const指针，指针本身不能被修改，必须初始化**/
    int *const p3=&a;
    
     /*指针本身和它指向的内容都是不能被改变的所以也得初始化*/
    const int* const p4=&a;
    int const* const p5=&b; 
    
     p1=p2=&a; //true  (指针本身的值可以改变)
    *p1=*p2=8; //false（指针指向的内容不能被修改）
    
    *p3=5; //true (指针指向的内容可以改变)
     p3=p1; //false（指针本身的值不能改变） 
    
     p4=p5;//false（指针本身和它指向的内容都是不能被改变） 
    *p4=*p5=4; //false（指针本身和它指向的内容都是不能被改变） 
  
    return 0;
}

1、const 修饰 *p，指向的对象只读，指针的指向可变：

1
2
3
4
5
int a = 9;
int b = 10;
const int *p = &a;//p是一个指向int类型的const值,与int const *p等价
*p = 11;    //编译错误，指向的对象是只读的，不可通过p进行改变
p = &b;     //合法，改变了p的指向

2、const 修饰 p，指向的对象可变，指针的指向不可变：

1
2
3
4
5
int a = 9;
int b = 10;
int * const p = &a;//p是一个const指针
*p = 11;    //合法，
p = &b;     //编译错误，p是一个const指针，只读，不可变

3、指针不可改变指向，指向的内容也不可变

1
2
3
4
5
int a = 9;
int b = 10;
const int * const p = &a;//p既是一个const指针，同时也指向了int类型的const值
*p = 11;    //编译错误，指向的对象是只读的，不可通过p进行改变
p = &b;     //编译错误，p是一个const指针，只读，不可变

总结：

const 放在 * 的左侧任意位置，限定了该指针指向的对象是只读的；const放在 * 的右侧，限定了指针本身是只读的，即不可变的。

如果还不是很好理解，我们可以这样来看，去掉类型说明符，查看 const 修饰的内容，上面三种情况去掉类型说明符 int 之后，如下：

1
2
3
const *p; //修饰*p，指针指向的对象不可变
* const p; //修饰p，指针不可变
const * const p; //第一个修饰了*p，第二个修饰了p，两者都不可变

const 右边修饰谁，就说明谁是不可变的。借助上面这种理解，就会发现以下几种等价情况：

1
2
3
4
const int NUM = 10; //与int const NUM等价
int a = 9;
const int *p  = &a;//与int const *p等价
const int arr[] = {0,0,2,3,4}; //与int const arr[]等价

C++ 常量