C 语言奇幻之旅 - 第04篇：C 语言数据类型与变量-CSDN博客

本文链接：https://blog.csdn.net/2503_90093283/article/details/144921508

引言

亲爱的各位朋友，大家好！我是凌云，欢迎来到 C 语言奇幻之旅的第 5 篇！编程的世界就像一座巨大的图书馆，而数据类型和变量则是书架上的书籍。每一本书都有其独特的主题和内容，正如每种数据类型都有其特定的用途和存储方式。我们将一起探索C语言中的数据类型与变量，了解它们如何帮助我们组织和处理数据，学习如何声明和初始化变量，以及常量与字面量的概念，并通过一些代码示例来展示不同数据类型的使用。

1. 数据类型

在C语言中，数据类型决定了变量可以存储的数据种类以及占用的内存空间。C语言提供了几种基本的数据类型，让我们逐一了解它们。

数据类型	大小（字节）	取值范围（典型）	含义
基本类型
`char`	1	-128 到 127 或 0 到 255	字符类型，存储ASCII字符或小整数
`signed char`	1	-128 到 127	有符号字符类型
`unsigned char`	1	0 到 255	无符号字符类型
`int`	4	-2,147,483,648 到 2,147,483,647	整数类型，通常为32位
`signed int`	4	-2,147,483,648 到 2,147,483,647	有符号整数类型
`unsigned int`	4	0 到 4,294,967,295	无符号整数类型
`short`	2	-32,768 到 32,767	短整数类型，通常为16位
`signed short`	2	-32,768 到 32,767	有符号短整数类型
`unsigned short`	2	0 到 65,535	无符号短整数类型
`long`	4 或 8	-2,147,483,648 到 2,147,483,647（32位）或更大（64位）	长整数类型，大小取决于平台
`signed long`	4 或 8	同 `long`	有符号长整数类型
`unsigned long`	4 或 8	0 到 4,294,967,295（32位）或更大（64位）	无符号长整数类型
`long long`	8	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	长长整数类型，通常为64位
`signed long long`	8	同 `long long`	有符号长长整数类型
`unsigned long long`	8	0 到 18,446,744,073,709,551,615	无符号长长整数类型
`float`	4	约 ±3.4e-38 到 ±3.4e38，精度约6-7位小数	单精度浮点数类型
`double`	8	约 ±1.7e-308 到 ±1.7e308，精度约15位小数	双精度浮点数类型
`long double`	8 或 16	范围更大，精度更高（取决于平台）	扩展精度浮点数类型
派生类型
`数组`	取决于元素类型和数量	无固定范围	存储相同类型元素的集合
`指针`	4 或 8	取决于平台	存储内存地址的类型
`结构体`	取决于成员大小之和	无固定范围	用户自定义的复合数据类型
`联合体`	最大成员的大小	无固定范围	所有成员共享同一块内存
`枚举`	通常为 `int` 大小	用户定义的整数常量集合	用户定义的整数常量集合
void 类型
`void`	无大小	无值	表示“无类型”，通常用于函数返回值或指针类型

1.1 char：计算机中的单字节奇迹

在 C 语言中，char 是一种基本的数据类型，用来表示单个字符。它通常占用 1 个字节（8 位）的内存空间。这意味着它可以表示 256 种不同的值（从 0 到 255），或者当被用作有符号类型时，它可以表示从 -128 到 127 的值。在大多数情况下，char 是用来存储 ASCII 字符的。

1.1.2 char 在计算机中的存储

当我们在程序中定义一个 char 变量时，实际上是在告诉编译器为该变量分配 1 个字节的内存空间。这个字节中的每一位都可以是 0 或 1，组合成不同的二进制模式。例如：

char myChar = 'A';

在这个例子中，myChar 变量存储的是字符 A。但是，计算机并不直接存储字母 “A”，而是存储了代表 A 的 ASCII 数值，即 65（十进制）。在内存中，对应二进制数 01000001，想要搞懂 char 的原理那我们得先明白 ASCII 码。

1.1.3 ASCII字符集：字符的数字编码

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是一个基于拉丁字母的一字符集。它定义了 128 个字符的编码方案，其中包含 95 个可打印字符和 33 个控制字符。每个 ASCII 字符都对应一个唯一的数字，范围从 0 到 127。例如：

空格：32
数字 0 - 9：48 - 57
大写字母 A - Z：65 - 90
小写字母 a - z：97 - 122

当我们使用 char 类型时，我们实际上是在使用这些 ASCII 数值。例如，当我们写 char ch = 'A';，我们实际上是将数值 65 赋给了 ch，而这个数值就是字符 A 的 ASCII 码。

1.1.4 char 和 ASCII 的关系

char 类型和 ASCII 之间的关系非常紧密。每一个 char 类型的变量都能够容纳一个 ASCII 字符的数值。因此，在 C 语言编程中，当你需要处理文本数据时，char 类型就成为了你的得力助手。你不仅可以使用它来存储单个字符，还可以通过数组的形式创建字符串，或者利用指针操作大量文本数据。

此外，由于ASCII是一个广泛接受的标准，所有遵循此标准的系统都能正确地解释和显示这些字符。这也使得C语言编写的程序具有良好的跨平台兼容性。

标准 ASCII 码的对照表

二进制	八进制	十进制	十六进制	字符/缩写	说明	二进制	八进制	十进制	十六进制	字符/缩写	说明
00000000	000	0	00	NUL (NULL)	空字符	00000001	001	1	01	SOH (Start of Heading)	标题开始
00000010	002	2	02	STX (Start of Text)	文本开始	00000011	003	3	03	ETX (End of Text)	文本结束
00000100	004	4	04	EOT (End of Transmission)	传输结束	00000101	005	5	05	ENQ (Enquiry)	询问字符
00000110	006	6	06	ACK (Acknowledge)	确认字符	00000111	007	7	07	BEL (Bell)	响铃字符
00001000	010	8	08	BS (Backspace)	退格字符	00001001	011	9	09	HT (Horizontal Tab)	水平制表符
00001010	012	10	0A	LF (Line Feed)	换行符	00001011	013	11	0B	VT (Vertical Tab)	垂直制表符
00001100	014	12	0C	FF (Form Feed)	换页符	00001101	015	13	0D	CR (Carriage Return)	回车符
00001110	016	14	0E	SO (Shift Out)	移出字符	00001111	017	15	0F	SI (Shift In)	移入字符
00010000	020	16	10	DLE (Data Link Escape)	数据链路转义	00010001	021	17	11	DC1 (Device Control 1)	设备控制1
00010010	022	18	12	DC2 (Device Control 2)	设备控制2	00010011	023	19	13	DC3 (Device Control 3)	设备控制3
00010100	024	20	14	DC4 (Device Control 4)	设备控制4	00010101	025	21	15	NAK (Negative Acknowledge)	否定确认
00010110	026	22	16	SYN (Synchronous Idle)	同步空闲	00010111	027	23	17	ETB (End of Transmission Block)	传输块结束
00011000	030	24	18	CAN (Cancel)	取消字符	00011001	031	25	19	EM (End of Medium)	介质结束
00011010	032	26	1A	SUB (Substitute)	替换字符	00011011	033	27	1B	ESC (Escape)	转义字符
00011100	034	28	1C	FS (File Separator)	文件分隔符	00011101	035	29	1D	GS (Group Separator)	组分隔符
00011110	036	30	1E	RS (Record Separator)	记录分隔符	00011111	037	31	1F	US (Unit Separator)	单元分隔符
00100000	040	32	20	(Space)	空格	00100001	041	33	21	!	感叹号
00100010	042	34	22	"	双引号	00100011	043	35	23	#	井号
00100100	044	36	24	$	美元符号	00100101	045	37	25	%	百分号
00100110	046	38	26	&	与符号	00100111	047	39	27	’	单引号
00101000	050	40	28	(	左括号	00101001	051	41	29	)	右括号
00101010	052	42	2A	*	星号	00101011	053	43	2B	+	加号
00101100	054	44	2C	,	逗号	00101101	055	45	2D	-	减号
00101110	056	46	2E	.	句号	00101111	057	47	2F	/	斜杠
00110000	060	48	30	0	数字0	00110001	061	49	31	1	数字1
00110010	062	50	32	2	数字2	00110011	063	51	33	3	数字3
00110100	064	52	34	4	数字4	00110101	065	53	35	5	数字5
00110110	066	54	36	6	数字6	00110111	067	55	37	7	数字7
00111000	070	56	38	8	数字8	00111001	071	57	39	9	数字9
00111010	072	58	3A	:	冒号	00111011	073	59	3B	;	分号
00111100	074	60	3C	<	小于号	00111101	075	61	3D	=	等于号
00111110	076	62	3E	>	大于号	00111111	077	63	3F	?	问号
01000000	100	64	40	@	At符号	01000001	101	65	41	A	大写字母A
01000010	102	66	42	B	大写字母B	01000011	103	67	43	C	大写字母C
01000100	104	68	44	D	大写字母D	01000101	105	69	45	E	大写字母E
01000110	106	70	46	F	大写字母F	01000111	107	71	47	G	大写字母G
01001000	110	72	48	H	大写字母H	01001001	111	73	49	I	大写字母I
01001010	112	74	4A	J	大写字母J	01001011	113	75	4B	K	大写字母K
01001100	114	76	4C	L	大写字母L	01001101	115	77	4D	M	大写字母M
01001110	116	78	4E	N	大写字母N	01001111	117	79	4F	O	大写字母O
01010000	120	80	50	P	大写字母P	01010001	121	81	51	Q	大写字母Q
01010010	122	82	52	R	大写字母R	01010011	123	83	53	S	大写字母S
01010100	124	84	54	T	大写字母T	01010101	125	85	55	U	大写字母U
01010110	126	86	56	V	大写字母V	01010111	127	87	57	W	大写字母W
01011000	130	88	58	X	大写字母X	01011001	131	89	59	Y	大写字母Y
01011010	132	90	5A	Z	大写字母Z	01011011	133	91	5B	[	左方括号
01011100	134	92	5C	\	反斜杠	01011101	135	93	5D	]	右方括号
01011110	136	94	5E	^	插入符号	01011111	137	95	5F	_	下划线
01100000	140	96	60	`	反引号	01100001	141	97	61	a	小写字母a
01100010	142	98	62	b	小写字母b	01100011	143	99	63	c	小写字母c
01100100	144	100	64	d	小写字母d	01100101	145	101	65	e	小写字母e
01100110	146	102	66	f	小写字母f	01100111	147	103	67	g	小写字母g
01101000	150	104	68	h	小写字母h	01101001	151	105	69	i	小写字母i
01101010	152	106	6A	j	小写字母j	01101011	153	107	6B	k	小写字母k
01101100	154	108	6C	l	小写字母l	01101101	155	109	6D	m	小写字母m
01101110	156	110	6E	n	小写字母n	01101111	157	111	6F	o	小写字母o
01110000	160	112	70	p	小写字母p	01110001	161	113	71	q	小写字母q
01110010	162	114	72	r	小写字母r	01110011	163	115	73	s	小写字母s
01110100	164	116	74	t	小写字母t	01110101	165	117	75	u	小写字母u
01110110	166	118	76	v	小写字母v	01110111	167	119	77	w	小写字母w
01111000	170	120	78	x	小写字母x	01111001	171	121	79	y	小写字母y
01111010	172	122	7A	z	小写字母z	01111011	173	123	7B	{	左花括号
01111100	174	124	7C	\|	竖线	01111101	175	125	7D	}	右花括号
01111110	176	126	7E	~	波浪号	01111111	177	127	7F	DEL (Delete)	删除字符

1.1.5 实际应用

在实际编程中，char 类型不仅仅用于存储单个字符。我们可以使用它来构建更复杂的结构，如字符串、字符数组等。同时，结合 ASCII 值，我们能够执行字符间的比较、转换大小写、计算字符的偏移量等操作。例如：

char lowerCase = 'a' + ('B' - 'A'); // 将 'B' 转换为 'b'

这段代码利用了 ASCII 值之间的关系，将大写字母 B 转换为了小写字母 b。

1.2 int：整数的自然选择

int 是 C 语言中用来表示整数值的基本数据类型之一。它通常用于存储不带小数部分的数字，即整数。int 类型是程序员处理计数、索引、循环控制变量等最常用的数据类型。

1.2.1 int 的大小和范围

int 类型的大小（以字节为单位）和其能表示的值的范围取决于具体的编译器和平台架构。以下是常见的几种情况：

32位系统：int 通常是 4 字节（32 位），可以表示的有符号整数范围是从 -2,147,483,648 到 2,147,483,647。
16位系统：在一些较老或嵌入式系统上，int 可能只有 2 字节（16 位），这时它的范围会更小，从 -32,768 到 32,767。
64位系统：尽管 int 在大多数64位系统上仍然是 4 字节，但某些编译器可能会提供更大的整数类型，如 long int 或者特定的64位整数类型。

为了确保代码的可移植性，建议使用标准库提供的宏来定义整数类型的最大和最小值，例如 INT_MAX 和 INT_MIN，它们可以在 <limits.h> 头文件中找到。

1.2.2 int 在计算机中的存储

int 类型在内存中是以二进制补码的形式存储的，数据的存储，后续我会开一个章节继续讲解。这意味着正数直接用其二进制表示，而负数则用其绝对值减一后的反码加一表示。例如，在一个32位系统上：

数值	二进制表示	解释
5	`00000000 00000000 00000000 00000101`	最高位为 `0`，表示这是一个正数。其余位表示数值 `5` 的二进制形式。
-5	`11111111 11111111 11111111 11111011`	最高位为 `1`，表示这是一个负数。这是 `-5` 的二进制补码表示，通过对 `5` 的二进制形式取反码并加一得到。

补充说明：
在二进制表示中，最高位（最左边的一位） 被称为符号位：

0 表示正数
1 表示负数

1.2.3 实际应用

int 类型广泛应用于各种编程场景中，比如：

循环控制：for 循环和 while 循环中的计数器。
数组索引：访问数组元素时使用的下标。
数学运算：执行加法、减法、乘法等操作。
状态标志：表示程序运行状态或返回值。

1.3 short 类型：紧凑的整数解决方案

short 是 C 语言中的一种基本数据类型，用于表示较小范围内的整数值。它通常占用比 int 更少的内存空间，因此当确定数值不会超出 short 的范围时，使用 short 可以节省内存资源。这使得 short 在嵌入式系统或对性能和内存敏感的应用程序中特别有用。

1.3.1 short 类型的大小和范围

short 类型的大小（以字节为单位）和其能表示的值的范围同样取决于具体的编译器和平台架构。然而，根据ISO C标准，short 至少应为 16 位宽，并且不能比 int 类型更宽。以下是常见的几种情况：

16位系统：short 通常是 2 字节（16 位），可以表示的有符号整数范围是从 -32,768 到 32,767。
32位和64位系统：在大多数现代系统上，short 也是 2 字节（16 位）。尽管如此，在某些特定平台上，short 可能会是更大的尺寸，但这并不常见。

为了确保代码的可移植性，建议使用标准库提供的宏来定义 short 类型的最大和最小值，例如 SHRT_MAX 和 SHRT_MIN，它们可以在 <limits.h> 头文件中找到。

1.3.2 short 在计算机中的存储

与 int 类似，short 类型在内存中也以二进制补码的形式存储。这意味着正数直接用其二进制表示，而负数则用其绝对值减一后的反码加一表示。例如，在一个16位系统上：

数值	二进制表示	解释
128	`00000000 10000000`	最高位为 `0`，表示这是一个正数。其余位表示数值 `128` 的二进制形式。
-128	`10000000 11111111`	最高位为 `1`，表示这是一个负数。这是 `-128` 的二进制补码表示，通过对 `128` 的二进制形式取反码并加一得到。

补充说明：
在二进制表示中，最高位（最左边的一位） 被称为符号位：

0 表示正数
1 表示负数

1.3.3 实际应用

short 类型广泛应用于各种编程场景中，特别是在需要节省内存的情况下，比如：

数组索引：当数组大小有限时，使用 short 作为索引可以节省内存。
循环控制：对于小范围的计数器，short 可以是一个合适的选择。
数学运算：处理相对较小的数值时，short 提供了足够的精度。
状态标志：表示程序运行状态或返回值，特别是当这些值在较小范围内变化时。

当然，我会按照您的要求来介绍 long 类型，并确保以 # 开头的标题只保留左右空格。以下是根据您的需求调整后的文本：

1.4 long 类型：处理大整数的有效工具

long 是一种有符号整数类型，默认情况下可以存储正数、负数和零。它的大小（以字节为单位）和所能表示的值的范围取决于具体的编译器和平台架构。

1.4.1 long 类型的大小和范围

根据 ISO C 标准，long 至少应为 32 位宽，并且不能比 int 类型更窄。然而，在不同的平台上，long 的具体大小可能会有所不同：

32位系统：
- 大小：通常是 4 字节（32 位）
- 有符号范围：从 -2,147,483,648 到 2,147,483,647
- 无符号范围：从 0 到 4,294,967,295
64位系统：
- 大小：通常是 8 字节（64 位）
- 有符号范围：从 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
- 无符号范围：从 0 到 18,446,744,073,709,551,615

请注意，不同平台和编译器对 long 类型的定义可能有所不同，因此在编写跨平台代码时，建议使用标准库提供的宏来确定其大小和范围，例如 <limits.h> 中的 LONG_MAX 和 LONG_MIN。

1.4.2 long 在计算机中的存储

long 类型在计算机内存中以二进制补码的形式存储，这与 int 和其他有符号整数类型相同。这意味着正数直接用其二进制表示，而负数则用其绝对值减一后的反码加一表示。具体来说，在一个64位系统上：

数值	二进制表示	解释
9,223,372,036,854,775,807（最大值）	`01111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111`	最高位为 `0`，表示这是一个正数。其余位表示数值 `9,223,372,036,854,775,807` 的二进制形式。
-9,223,372,036,854,775,808（最小值）	`10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000`	最高位为 `1`，表示这是一个负数。这是 `-9,223,372,036,854,775,808` 的二进制补码表示，通过对其绝对值的二进制形式取反码并加一得到。

补充说明：
在二进制表示中，最高位（最左边的一位） 被称为符号位：

0 表示正数
1 表示负数

1.4.3 实际应用

long 类型广泛应用于各种编程场景中，特别是在需要处理较大数值的情况下：

大整数运算：当 int 类型不足以表示所需的数值范围时，long 提供了更大的范围。
时间戳：许多系统使用 long 类型来存储时间戳，因为它们可以表示从某个基准时间点到现在的秒数或毫秒数。
文件大小：在处理大文件时，long 类型可以准确地表示文件的大小。
数学计算：在进行复杂的数学运算时，long 可以提供更高的精度和更大的数值范围。

1.5 float 类型：浮点数的世界

在C语言中，float 是一种用于表示单精度浮点数的数据类型。它通常占用 4个字节（32位） 的内存空间，能够表示大约 6到7位十进制有效数字 的浮点数。

1.5.1 float 基本属性

属性	值	示例或说明
类型	单精度浮点数	`float a = 3.14f;`
占用内存	4 字节（32位）	`sizeof(float)` 返回 `4`。
有效数字	6到7位十进制	`float b = 1.123456f;`（可精确存储6到7位小数）。
标准	IEEE 754	所有现代计算机都遵循此标准。
适用场景	内存敏感的场景	嵌入式系统、图形处理等。

1.5.2 float 数值范围和精度

最大值：大约 3.4×10383.4×1038
最小正值：大约 1.4×10−451.4×10−45
精度：大约 6 到 7 位十进制数字

1.5.3 float 在计算机中的存储

部分	位数	描述	示例或说明
符号位	1 位	表示数的正负：`0` 为正数，`1` 为负数。	`+3.14f` 的符号位为 `0`，`-3.14f` 的符号位为 `1`。
指数位	8 位	表示数的规模（大小），采用偏移表示法（Excess-127）。	指数位的值为 `130`，则实际指数为 `130 - 127 = 3`。
尾数位	23 位	表示数的精度，存储规格化后的小数部分。	浮点数 `3.14f` 的尾数位存储的是 `10010001111010111000011`。

符号位

符号位值	含义	示例或说明
0	正数	`+3.14f` 的符号位为 `0`。
1	负数	`-3.14f` 的符号位为 `1`。

指数位

属性	值	示例或说明
位数	8 位	指数位的值为 `10000010`（二进制），表示实际指数为 `130 - 127 = 3`。
偏移量	127（Excess-127）	实际指数 = 指数位的值 - 127。
实际指数范围	-126 到 127	指数位的值为 `1` 时，实际指数为 `-126`；为 `254` 时，实际指数为 `127`。
特殊值	全 `0` 和全 `1` 有特殊含义	全 `0` 表示非规格化数，全 `1` 表示无穷大或 NaN。

尾数位

属性	值	示例或说明
位数	23 位	尾数位存储的是规格化后的小数部分。
存储内容	规格化后的小数部分	浮点数 `3.14f` 的尾数位存储的是 `10010001111010111000011`。
规格化形式	`1.xxxxx * 2^指数`	浮点数 `6.625f` 规格化为 `1.10101 * 2^2`。
省略位	规格化后的第一位 `1` 不存储	尾数位只存储小数点后的部分。

1.5.4 float 存储示例

以浮点数 -6.625f 为例：

步骤	值	示例或说明
符号位	`1`（负数）	`-6.625f` 的符号位为 `1`。
二进制表示	`110.101`	整数部分 `6` 的二进制为 `110`，小数部分 `0.625` 的二进制为 `0.101`。
规格化	`1.10101 * 2^2`	规格化后的形式为 `1.10101 * 2^2`。
指数位	实际指数 `2`，偏移后为 `129`，二进制为 `10000010`	指数位的值为 `10000010`。
尾数位	`10101`（补全到23位为 `10101000000000000000000`）	尾数位存储的是 `10101`（补全到23位）。
最终存储	`1 10000010 10101000000000000000000`	合并后的二进制表示。

1.5.5 float 特殊值

特殊值	描述	示例或说明
零值	符号位为 `0` 或 `1`，指数位和尾数位全为 `0`。例如：`+0.0f` 和 `-0.0f`。	`float zero = 0.0f;` 或 `float negative_zero = -0.0f;`
无穷大	指数位全为 `1`，尾数位全为 `0`。例如：`+∞` 和 `-∞`。	`float inf = 1.0f / 0.0f;`（正无穷大）。
NaN	指数位全为 `1`，尾数位不全为 `0`。用于表示无效的浮点数运算结果。	`float nan = 0.0f / 0.0f;`（NaN）。

1.6 double 类型：双精度浮点数的世界

在C语言中，double 是一种用于表示双精度浮点数的数据类型。它通常占用 8个字节（64位） 的内存空间，能够表示大约 15到16位十进制有效数字 的浮点数。与 float 相比，double 提供了更高的精度和更大的数值范围。本文将详细解析 double 类型在计算机中的存储方式及其特性。

属性	值	示例或说明
类型	双精度浮点数	`double a = 3.14;`
占用内存	8 字节（64位）	`sizeof(double)` 返回 `8`。
有效数字	15到16位十进制	`double b = 1.123456789012345;`（可精确存储15到16位小数）。
标准	IEEE 754	所有现代计算机都遵循此标准。
适用场景	需要高精度的计算	科学计算、金融计算、物理仿真等。

1.6.1 dobule 数值范围和精度

最大值：大约 1.8×103081.8×10308
最小正值：大约 4.9×10−3244.9×10−324
精度：大约 15 到 16 位十进制数字

1.6.2 double 在计算机中的存储

部分	位数	描述	示例或说明
符号位	1 位	表示数的正负：`0` 为正数，`1` 为负数。	`+3.14` 的符号位为 `0`，`-3.14` 的符号位为 `1`。
指数位	11 位	表示数的规模（大小），采用偏移表示法（Excess-1023）。	指数位的值为 `1026`，则实际指数为 `1026 - 1023 = 3`。
尾数位	52 位	表示数的精度，存储规格化后的小数部分。	浮点数 `3.14` 的尾数位存储的是 `10010001111010111000011`（补全到52位）。

符号位

符号位值	含义	示例或说明
0	正数	`+3.14` 的符号位为 `0`。
1	负数	`-3.14` 的符号位为 `1`。

指数位

属性	值	示例或说明
位数	11 位	指数位的值为 `10000000001`（二进制），表示实际指数为 `1025 - 1023 = 2`。
偏移量	1023（Excess-1023）	实际指数 = 指数位的值 - 1023。
实际指数范围	-1022 到 1023	指数位的值为 `1` 时，实际指数为 `-1022`；为 `2046` 时，实际指数为 `1023`。
特殊值	全 `0` 和全 `1` 有特殊含义	全 `0` 表示非规格化数，全 `1` 表示无穷大或 NaN。

尾数位

属性	值	示例或说明
位数	52 位	尾数位存储的是规格化后的小数部分。
存储内容	规格化后的小数部分	浮点数 `3.14` 的尾数位存储的是 `10010001111010111000011`（补全到52位）。
规格化形式	`1.xxxxx * 2^指数`	浮点数 `6.625` 规格化为 `1.10101 * 2^2`。
省略位	规格化后的第一位 `1` 不存储	尾数位只存储小数点后的部分。

1.6.3 double 存储示例

以浮点数 -6.625 为例：

步骤	值	示例或说明
符号位	`1`（负数）	`-6.625` 的符号位为 `1`。
二进制表示	`110.101`	整数部分 `6` 的二进制为 `110`，小数部分 `0.625` 的二进制为 `0.101`。
规格化	`1.10101 * 2^2`	规格化后的形式为 `1.10101 * 2^2`。
指数位	实际指数 `2`，偏移后为 `1025`，二进制为 `10000000001`	指数位的值为 `10000000001`。
尾数位	`10101`（补全到52位为 `1010100000000000000000000000000000000000000000000000`）	尾数位存储的是 `10101`（补全到52位）。
最终存储	`1 10000000001 1010100000000000000000000000000000000000000000000000`	合并后的二进制表示。

1.6.4 double 特殊值

特殊值	描述	示例或说明
零值	符号位为 `0` 或 `1`，指数位和尾数位全为 `0`。例如：`+0.0` 和 `-0.0`。	`double zero = 0.0;` 或 `double negative_zero = -0.0;`
无穷大	指数位全为 `1`，尾数位全为 `0`。例如：`+∞` 和 `-∞`。	`double inf = 1.0 / 0.0;`（正无穷大）。
NaN	指数位全为 `1`，尾数位不全为 `0`。用于表示无效的浮点数运算结果。	`double nan = 0.0 / 0.0;`（NaN）。

1.6.5 double 与 float 的对比

特性	`float`（单精度）	`double`（双精度）	示例或说明
占用内存	4 字节（32位）	8 字节（64位）	`sizeof(float)` 返回 `4`，`sizeof(double)` 返回 `8`。
有效数字	6到7位十进制	15到16位十进制	`float a = 1.123456;`（精确到6到7位），`double b = 1.123456789012345;`（精确到15到16位）。
指数范围	-126 到 127	-1022 到 1023	`float` 的指数范围较小，`double` 的指数范围更大。
精度	较低	较高	`float` 适用于内存敏感的场景，`double` 适用于需要高精度的场景。
适用场景	内存敏感的场景	需要高精度的场景	`float` 用于嵌入式系统，`double` 用于科学计算。

1.6.6 double 精度问题

问题描述	示例代码	示例或说明
十进制小数无法精确表示	`double a = 0.1; double b = 0.2; double c = a + b;`	`c` 的值可能为 `0.30000000000000004`，而不是 `0.3`。

1.7 Bool 类型：布尔逻辑的世界

1.7.1 Bool 在计算机中的存储

bool 类型通常实现为一个字节（8 位），但只使用两个值来表示真和假：

true：非零值（通常是 1）
false：0

尽管 bool 类型在内存中占用一个字节，但实际上它只需要一位来表示两种状态。这是因为大多数现代计算机系统更喜欢以字节为单位进行内存分配，而不是单独处理位。

1.7.2 内存布局

尽管 bool 类型只使用两个值，但它在内存中占用一整个字节。例如：

数值：true
二进制表示：00000001
数值：false
二进制表示：00000000

请注意，任何非零值在转换为 bool 类型时都会被视为 true，而只有 0 会被视为 false。

1.7.3 使用场景

bool 类型主要用于逻辑判断和条件控制。以下是一些常见的应用场景：

条件语句：如 if、while 和 for 循环中的条件表达式。
函数返回值：表示操作是否成功或失败。
标志变量：用来跟踪程序状态或事件的发生。

1.8 丢失的符号位：无符号整数

无符号整数是没有符号位的数据类型，这意味着它们只能表示非负数（即零和正数）。与有符号整数不同，无符号整数的所有位都用来表示数值，因此可以表示更大的数值范围。

1.8.1 无符号整数的最大和最小值

1.8.1.1 最小值

对于任何无符号整数类型，最小值总是 0。这是因为所有位都被设置为 0，表示数值 0。

1.8.1.2 最大值

最大值取决于类型的大小（以字节或位为单位）。以下是几种常见无符号整数类型及其最大值：

unsigned char（通常8位）
- 最大值： $28$ −1=25528−1=255
- 二进制表示：11111111
unsigned short（通常16位）
- 最大值： $2^{16}$ −1=65,535216−1=65,535
- 二进制表示：11111111 11111111
unsigned int（通常32位）
- 最大值： $2^{32}$ −1=4,294,967,295232−1=4,294,967,295
- 二进制表示：11111111 11111111 11111111 11111111
unsigned long（通常是32位或64位，具体取决于平台）
- 32位系统：
  - 最大值： $2^{32}$ −1=4,294,967,295232−1=4,294,967,295
  - 二进制表示：11111111 11111111 11111111 11111111
- 64位系统：
  - 最大值： $2^{64}$ −1=18,446,744,073,709,551,615264−1=18,446,744,073,709,551,615
  - 二进制表示：11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111
unsigned long long（通常是64位）
- 最大值： $2^{64}$ −1=18,446,744,073,709,551,615264−1=18,446,744,073,709,551,615
- 二进制表示：11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111

1.8.2 为什么最大值是 $2^n−1$ ？

无符号整数的最大值由其位宽决定，具体来说是由 $2^n−1$ 公式计算得出，其中 n 是该类型占用的位数。这个公式的背后原理如下：

二进制数的特性：一个 n 位的二进制数可以表示 $2^n$ 种不同的组合。例如，4 位的二进制数可以表示从 0000 到 1111，共 $2^4$ =16 种不同的组合。
最小值考虑：这些组合中，000...000 表示数值 0，所以剩下的 $2^n−1$ 个组合用来表示从 1 到最大值的数值。
最大值计算：因此，最大值就是 $2^n−1$ 。例如，对于 4 位的无符号整数，最大值是 $2^4$ −1=15。

1.8.3 实际应用中的注意事项

选择合适的数据类型：根据您需要表示的最大值选择适当的数据类型。如果数值永远不会超过某个较小的范围，使用较小的类型（如 unsigned short 或 unsigned char）可以节省内存。
防止溢出：在进行算术运算时，确保结果不会超出目标类型的范围。例如，两个 unsigned int 类型的数相加可能会导致溢出，产生意外的结果。
跨平台编程：不同的编译器和平台可能对 long 类型有不同的定义。为了确保代码的可移植性，建议使用标准库提供的宏来定义最大和最小值，例如 <limits.h> 中的 UINT_MAX、USHRT_MAX 等。

2. 变量声明与初始化

在C语言的世界里，变量是程序的基本构建块。无论是初学者还是资深开发者，理解变量的声明与初始化都是至关重要的。本文将带你深入探讨这一主题，从基础概念到高级技巧，层层递进，助你掌握C语言的核心技能。

2.1 变量的声明

2.1.1 什么是变量声明？

在C语言中，变量声明是告诉编译器变量的名称和类型。声明变量时，你需要指定变量的数据类型和变量名。例如：

int age;

这行代码声明了一个名为 age 的整数类型变量。编译器会为这个变量分配内存空间，以便在程序中使用。

2.1.2 变量命名的规则

变量名必须遵循以下规则：

只能包含字母、数字和下划线。
不能以数字开头。
不能使用C语言的关键字（如 int、return 等）。

例如，int 1age; 是非法的，而 int age1; 是合法的。

2.2 变量的初始化

2.2.1 什么是变量初始化？

变量初始化是指在声明变量的同时为其赋予一个初始值。例如：

int age = 25;

这行代码不仅声明了一个整数变量 age，还将其初始化为 25。

2.2.2 未初始化的变量

未初始化的变量包含的是垃圾值，即内存中之前存储的随机数据。使用未初始化的变量可能导致不可预测的行为。例如：

int age;
printf("%d", age); // 输出可能是任意值

为了避免这种情况，建议在声明变量时进行初始化。

2.3 变量声明与初始化的进阶技巧

2.3.1 多重声明与初始化

你可以在一条语句中声明和初始化多个同类型的变量。例如：

int x = 1, y = 2, z = 3;

这行代码声明并初始化了三个整数变量 x、y 和 z。

2.3.2 常量变量

使用 const 关键字可以声明常量变量，其值在程序运行期间不能被修改。例如：

const int MAX_AGE = 100;

尝试修改 MAX_AGE 的值会导致编译错误。

2.3.3 静态变量

在函数内部使用 static 关键字声明的变量称为静态变量。静态变量的生命周期贯穿整个程序运行期间，但其作用域仅限于声明它的函数。例如：

void counter() {
    static int count = 0;
    count++;
    printf("%d\n", count);
}

每次调用 counter() 函数时，count 的值都会递增。

2.4 趣味案例：变量的生命周期与作用域

2.4.1 局部变量 vs 全局变量

局部变量在函数内部声明，生命周期仅限于函数执行期间。全局变量在函数外部声明，生命周期贯穿整个程序运行期间。例如：

#include <stdio.h>

int globalVar = 10; // 全局变量

void func() {
    int localVar = 20; // 局部变量
    printf("Global: %d, Local: %d\n", globalVar, localVar); 
}

int main() {
    func();
    return 0;
}

在这个例子中，globalVar 可以在整个程序中使用，而 localVar 只能在 func() 函数内部使用。

2.4.2 变量的隐藏

当局部变量与全局变量同名时，局部变量会“隐藏”全局变量。例如：

#include <stdio.h>

int var = 10; // 全局变量

void func() {
    int var = 20; // 局部变量
    printf("%d\n", var); // 输出 20
}

int main() {
    func();
    printf("%d\n", var); // 输出 10
    return 0;
}

在 func() 函数内部，局部变量 var 隐藏了全局变量 var。

3. 常量与字面量

在C语言中，常量和字面量是编写程序时不可或缺的元素。它们不仅让代码更具可读性，还能提高程序的稳定性和效率。本文将带你深入探索常量与字面量的世界，从基础概念到实际应用，层层递进，助你掌握这一重要知识点。

3.1 常量：不可改变的“铁律”

3.1.1 什么是常量？

常量是程序运行期间其值不能被修改的变量。在C语言中，常量通常用 const 关键字定义。例如：

const int MAX_AGE = 100;

这里，MAX_AGE 被定义为一个常量，其值固定为 100，任何试图修改它的操作都会导致编译错误。

3.1.2 常量的优势

安全性：常量的值不可变，避免了意外修改。
可读性：常量名通常具有描述性，使代码更易理解。
维护性：如果需要修改常量的值，只需修改一处定义。

3.1.3 常量的定义方式

常量可以通过以下两种方式定义：

使用 const 关键字：
```
const double PI = 3.14159;
```
使用 #define 宏：
```
#define PI 3.14159
```

两者的区别在于：

const 定义的常量具有类型信息，而 #define 只是简单的文本替换。
const 常量在编译时分配内存，而 #define 不占用内存。

3.2 字面量：代码中的“硬编码”

3.2.1 什么是字面量？

字面量是直接在代码中写入的值。例如：

int age = 25;       // 25 是整数字面量
double pi = 3.14;   // 3.14 是浮点数字面量
char c = 'A';       // 'A' 是字符字面量

字面量是程序中最直接的数据表示方式。

3.2.2 字面量的类型

C语言中的字面量可以分为以下几类：

整数字面量：
- 十进制：42
- 八进制：052（以 0 开头）
- 十六进制：0x2A（以 0x 开头）
浮点数字面量：
- 标准形式：3.14
- 科学计数法：1.23e-4
字符字面量：
- 单字符：'A'
- 转义字符：'\n'（换行符）
字符串字面量：
- 双引号包裹："Hello, World!"

3.2.3 字面量的趣味案例

以下代码展示了不同类型字面量的使用：

#include <stdio.h>

int main() {
    int decimal = 42;          // 十进制
    int octal = 052;           // 八进制，等价于十进制的 42
    int hexadecimal = 0x2A;    // 十六进制，等价于十进制的 42

    printf("Decimal: %d, Octal: %d, Hexadecimal: %d\n", decimal, octal, hexadecimal);
    // 输出：Decimal: 42, Octal: 42, Hexadecimal: 42

    double pi = 3.14;
    double scientific = 1.23e-4;

    printf("Pi: %f, Scientific: %f\n", pi, scientific);
    // 输出：Pi: 3.140000, Scientific: 0.000123

    char letter = 'A';
    char newline = '\n';

    printf("Letter: %c, Newline: %c", letter, newline);
    // 输出：Letter: A, Newline: （换行）

    return 0;
}

3.3 常量与字面量的实战应用

3.3.1 常量与字面量的结合

常量和字面量常常结合使用，以提高代码的可读性和可维护性。例如：

#include <stdio.h>

#define MAX_USERS 100
const double TAX_RATE = 0.07;

int main() {
    int users = 50;
    double price = 99.99;
    double total = price * users * (1 + TAX_RATE);

    printf("Total cost for %d users: $%.2f\n", users, total);
    // 输出：Total cost for 50 users: $5349.93

    return 0;
}

在这个例子中，MAX_USERS 和 TAX_RATE 分别通过 #define 和 const 定义，使代码更清晰。

3.3.2 常量与枚举

枚举（enum）是一种特殊的常量，常用于定义一组相关的整数值。例如：

#include <stdio.h>

enum Weekday { MON, TUE, WED, THU, FRI, SAT, SUN };

int main() {
    enum Weekday today = WED;

    if (today == WED) {
        printf("Today is Wednesday!\n");
        // 输出：Today is Wednesday!
    }

    return 0;
}