syxdevcode博客

C常量

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

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

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

整数常量

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

前缀指定基数：

不带前缀则默认表示十进制
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          /* 非法的：缺少整数或分数 */

字符常量

字符常量使用单引号表示，例如，'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
#include <stdio.h>
  
int main(){
    printf("%c,%c,%c,%c", 0101, '\101', '\x41', 'A');
    return 0;
}

字符串常量

字符串字面值或常量是括在双引号 "" 中的。

一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。

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

下面这三种形式所显示的字符串是相同的。

1
2
3
4
5
6
7
"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

在 C 语言中没有专门的字符串类型，因此双引号内的字符串会被存储到一个数组中，这个字符串代表指向这个数组起始字符的指针；

而单引号中的内容是一个 char 类型，是一个字符，这个字符对应的是 ASCII 表中的序列值。

定义常量

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

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

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

#define 预处理器

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

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

1
#define identifier value

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
 
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{ 
   int area;  
  
   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", 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;

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) 宏替换只作替换，不做计算，不做表达式求解;

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

C 常量