C语言字面量和常量

目录

引言

1. 字面量

1.1 字符字面量

1.2 整型字面量

1.3 浮点字面量

2. 常量

2.1 使用预处理器指令 #define 定义常量

2.1.1 语法格式

2.1.2 使用举例

2.2 使用 const 关键字定义常量

2.3 使用 #define 和 const 定义常量的区别

---

引言

        看了一些博文，有的文章对字面量和常量区别的不是很明显，个人观点以下对字面量和常量的定义是比较准确的。

        字面量是直接在代码中使用的程序运行期间不会改变的没有名字的固定值。所以我们只能用字面量来称呼它，故叫字面量。

        常量是用预处理器指令 #define 或 const 关键字定义的在程序运行期间不会改变的在代码中有名字的固定值。

1. 字面量

int i = 100;

像上面语句中的数字 100，这种在程序中不能修改的无法用名字称呼它的字面值常量，叫做字面量。比如 printf("Hello World\n"); 中的 "Hello World\n" 也是字面量。

1.1 字符字面量

        在 ASCII 码表中，编码 [0, 31] 和 127 是控制字符，共 33 个字符是不可以打印的，其中编码 [0, 31] 这 32 个字符主要用于控制打印机等外围设备。

        编码 [32, 126] 是可显示字符，也就是可以打印在屏幕上。记得以下几个编码规则，在 C语言对字符进行操作的时候，或许挺管用。

• 大写字母 A ~ Z 的 ASCII码 65 ~ 90
• 小写字母 a ~ z 的 ASCII码 97 ~ 122
• 大写字母比小写字母的 ASCII码小 32 (0b00100000，0x20) ，比如: char c = 'a'，小写字母变大写字母，c = c - 32 得到，也可以做位与操作，c = c & 0b11011111 得到
• 数字字符 0 ~ 9 的 ASCII码 48 ~ 57，所以一个数字要转换成数字字符，只要将数字 加上 48 (0x30) 即可
• 字符串的终止符为 '\0'，ASCII 码为 0
• 换行符 '\n' 的 ASCII码为 10 (0x0A)

        对于这些字符字面量，有4种书写格式

1) 用一对单引号把字符括起来（推荐使用）

#include <stdio.h>int main() {char c1 = 'A';printf("%c\n", c1);    // Areturn 0;
}

 对于不可打印字符和特殊字符，用转义字符书写。

\n	换行符	\t	水平制表符
\v	纵向制表符	\b	退格符
\r	回车符	\f	换页符
\a	报警响铃符	\\	反斜杠
\"	双引号	\'	单引号

#include <stdio.h>int main() {char c1 = '\\';printf("%c\n", c1);return 0;
}

2) 用编码数值书写

#include <stdio.h>int main() {char c1 = 65;     // 十进制，大写字母 A 的ASCII码：65char c2 = 0101;   // 八进制char c3 = 0x41;   // 十六进制printf("%c,%c,%c\n", c1, c2, c3);    // A,A,Areturn 0;
}

3) 对于任何字符，还可以用通用的转义字符书写

• \ooo，其中 ooo 表示三个八进制数字，注意是三个八进制数字，比如即使是编码为 1 的字符，也不能省掉前面那两个0。
• \xhh，其中 x 表示十六进制，hh 是二个十六进制数字

#include <stdio.h>int main() {char c1 = '\x41';   // 十六进制char c2 = '\101';   // 是3位八进制数字，即使编码为 1 的字符，也要写成 '\001'，不能写成 '\1'printf("%c,%c", c1, c2);    // A,Areturn 0;
}

1.2 整型字面量

        整型字面量可以用十进制、八进制、十六进制或二进制来表示。

• 以 0x 或 0X 开头表示十六进制
• 以数字 0 开头表示八进制
• 以 0b 开头表示二进制
• 不带前缀默认是十进制

以下表示同一个整型字面量

15                        // 十进制

017                      // 八进制

0xf                       // 十六进制

0b00001111        // 二进制

#include <stdio.h>int main() {int i1 = 15;int i2 = 017;int i3 = 0xf;int i4 = 0b00001111;printf("%d, %d, %d, %d\n", i1, i2, i3, i4);return 0;
}

整型字面量还可以带一个由 U 和 L 组合的后缀，U 和 L 不分先后顺序，U 可以大写也可以小写 u，是 unsigned 的意思，L 可以大写也可以小写 l，是 long 的意思。

15u         // 无符号整型字面量

15L         //  长整形字面量，推荐用大写 L，因为小写字面 l 和数字 1 很容易混淆

15ul        // 无符号长整形字面量

0xfu        // 无符号整型字面量

0xfL        // 长整形字面量

0xful       // 无符号长整型字面量

017u      // 无符号整型字面量 

017L      // 长整形字面量

017ul     // 无符号长整型字面量

// limits.h 文件中，int, unsigned int, long, unsigned int 取值范围定义
#define INT_MIN     (-2147483647 - 1)
#define INT_MAX       2147483647
#define UINT_MAX      0xffffffff
#define LONG_MIN    (-2147483647L - 1)
#define LONG_MAX      2147483647L
#define ULONG_MAX     0xffffffffUL

#include <stdio.h>
#include <limits.h>int main() {unsigned int uiVar = 15u;long longVar = 15L;unsigned long ulVar = 15ul;printf("%u\n", uiVar);      // %u 无符号整型格式化输出printf("%d\n", longVar);    // %d 以十进制格式化输出有符号整数（在 limits.h 中有定义: long 和 int 的取值范围是一样的）printf("%lu\n", ulVar);     // %lu 以无符号长整型格式化输出uiVar = 0xfu;longVar = 0xfL;ulVar = 0xful;printf("%u\n", uiVar);      // %u 无符号整型格式化输出printf("%d\n", longVar);    // %d 以十进制格式化输出有符号整数（在 limits.h 中有定义: long 和 int 的取值范围是一样的）printf("%lu\n", ulVar);     // %lu 以无符号长整型格式化输出uiVar = 017u;longVar = 017L;ulVar = 017ul;printf("%u\n", uiVar);      // %u 无符号整型格式化输出printf("%d\n", longVar);    // %d 以十进制格式化输出有符号整数（在 limits.h 中有定义: long 和 int 的取值范围是一样的）printf("%lu\n", ulVar);     // %lu 以无符号长整型格式化输出return 0;
}

注意：

018        是不对的整型字面量，因为八进制没有数码 8

15uu      是不对的整型字面量，后缀 u 不能重复

15Lu      是正确的整型字面量，跟 15uL表达的是同一个字面量，u和l组合时，不分先后顺序

1.3 浮点字面量

        通常用十进制或科学计数法来表示浮点字面量。

• 默认浮点字面量为 double 类型，比如：3.14
• 在数值后面加上后缀 f 或 F 表示 float 类型，比如：3.14f 或 3.14F
• 0 的 double 类型表示为 0. ；0 的 float 类型表示为  0.f 或 0.F
• 对于只有小数部分的浮点字面量，整数部分的 0 可以省略掉不写，比如：.01 等价于 0.01；.01f 等价于 0.01f
• 使用科学计数法时，指数用 e 或 E 表示。比如：3.14e0 或 3.14E0 表示的是 double 类型 3.14；而 3.14e0f 或 3.14E0F 表示的是 float 类型 3.14f
• double 类型 0 用科学计数法表示为 0e0，float 类型 0 用科学计数法表示为 0e0f

#include <stdio.h>int main() {printf("%d, %d\n", sizeof(.01), sizeof(0.01));          // 8, 8printf("%d, %d\n", sizeof(.01f), sizeof(0.01f));        // 4, 4printf("%.2f, %.2f\n", .01, 0.01);                      // 0.01, 0.01printf("%d, %d\n", sizeof(0.), sizeof(0.f));            // 8, 4printf("%d\n", sizeof(3.14));                           // 8printf("%d, %d\n", sizeof(3.14f), sizeof(3.14F));       // 4, 4printf("%d, %d\n", sizeof(3.14e0), sizeof(3.14E0));     // 8, 8printf("%d, %d\n", sizeof(3.14e0f), sizeof(3.14E0F));   // 4, 4printf("%d, %d\n", sizeof(0e0), sizeof(0e0f));          // 8, 4return 0;
}

1.4 字符串字面量

        字符串字面量用一对双引号把所有的字符括在里面，比如："Hello World\n"

• 字符串字面量在内存中编译器会自动在末尾加上一个字符串终止符('\0')，所以字符串在内存中占用的字节数会比字符串的长度多1字节。
• 两个相邻的仅由空格、制表符('\t') 或 换行符('\n') 分开的字符串字面量，可以连接成一个新的字符串字面量。
• 一个字符串过长，在一行放不下时，可以使用反斜杠 ('\') 进行换行。
• 空字符串 "" 在内存在占一个字节，这个字节存的是字符串终止符('\0')。

#include <stdio.h>int main() {printf("Hello World\n");      printf("Hello"  " world\n");  // 两个字符串字面量连接成一个新的字符串 "Hello World\n"printf("Hello \
World\n");                        // 用 '\' 换行printf("%d\n", sizeof(""));   // 1return 0;
}

2. 常量

        常量是用预处理器指令 #define 或 const 关键字定义的在程序运行期间不会改变的在代码中有名字的固定值。

2.1 使用预处理器指令 #define 定义常量

2.1.1 语法格式

#define 常量名 常量值
// 以下代码定义了一个名为 PI 的常量
#define PI 3.14

2.1.2 使用举例

#include <stdio.h>#define PI 3.14// 圆周长
double circumference(const double r) {return 2 * PI * r;	// 使用了预处理器指令 #define 定义的常量 PI
}int main() {printf("半径为 %.2f 的圆周长 = %.2f\n", 2.0, circumference(2.0));return 0;
}

2.2 使用 const 关键字定义常量

2.2.1 语法格式

const 常量类型 常量名 = 常量值;
// 以下代码定义了一个名为 PI 的常量
const double PI = 3.14;

2.2.2 使用举例

#include <stdio.h>const double PI = 3.14;// 圆周长
double circumference(const double r) {return 2 * PI * r;	// 使用了用 const 关键字定义的常量 PI
}int main() {printf("半径为 %.2f 的圆周长 = %.2f\n", 2.0, circumference(2.0));return 0;
}

注意：用 const 关键字定义的常量，必须同时它进行初始化

/*
// 以下对定义常量 MAX 是错误的，因为常量必须在定义的时同时对它进行初始化，初始化后的常量是不能改变的
const int MAX;
MAX = 100;
*/
// 正确用 const 定义 MAX 常量的方法
const int MAX = 100;

2.3 使用 #define 和 const 定义常量的区别

• 1. 编译器处理方式不同
• 使用 #define 定义的常量会在预处理阶段用它对应的字面量替换掉代码中的常量字符标识，在程序运行期间内存中并不存在该常量。
• 使用 const 定义的常量是具有数据类型和作用域的常量，在程序运行期间内存中是存在该常量的符号标识的

• 2. 类型和安全检查不同

• 使用 #define 定义的常量不存在数据类型，从而在编译阶段，编译器不会对它进行类型检查

• 使用 const 定义的常量是具有数据类型的，在编译阶段，编译器会对它进行类型检查

• 3. 作用域检查不同

• 使用 #define 定义的常量没有作用域，它在定义之后的整个代码中都有效

• 使用 const 定义的常量具有作用域，只有在它所在的作用域内有效

• 4. 存储方式不同

• 使用 #define 定义的常量在符号表中不会有相应的条目。

• 使用 const 定义的常量会在符号表中有相应的条目，有助于调试和可读性。

        使用 #define 与 const 这两种方式都可以用来定义常量，通常情况下，建议使用 const 关键字来定义常量，因为通过 const 关键字定义的常量，具有数据类型和作用域，编译器可以对它进行类型检测和作用域检查，而用 #define 定义的常量，仅在预编译阶段进行简单的文本替换，可能会导致一些没有预料到的问题。