Dream Blog

C 语言发展史

Sat, 26 Sep 2026 00:00:00 GMT

C 语言发展史#

C 语言由丹尼斯·里奇（Dennis Ritchie）于 20 世纪 70 年代初在贝尔实验室主持设计。它最初服务于 UNIX 操作系统开发，核心目标是在运行效率、底层控制能力和源代码可移植性之间取得平衡。

【一】C 语言诞生的背景#

早期操作系统主要使用汇编语言编写。汇编语言执行效率高，也能直接控制硬件，但它与具体处理器紧密相关：更换硬件平台后，程序往往需要大幅重写。

高级语言虽然更容易编写和移植，当时却难以同时满足系统软件对运行效率和底层操作的要求。C 语言正是在这一矛盾中逐步形成的。

其演进关系可以概括为：

1
BCPL（1967）
2
    ↓
3
B 语言（1969）
4
    ↓
5
C 语言（约 1972）

【1】BCPL 语言#

1967 年，马丁·理查兹（Martin Richards）设计了 BCPL。它是一种结构简单、便于编写编译器的无类型语言，对后来的 B 语言产生了直接影响。

【2】B 语言#

1969 年前后，肯·汤普森（Ken Thompson）在贝尔实验室以 BCPL 为基础设计了 B 语言，并将其用于早期 UNIX 系统的开发。

B 语言采用“无类型”的设计，适合当时字长固定的计算机，但在 PDP-11 等新硬件上逐渐暴露出数据类型不足、运行效率不高等问题。

【3】C 语言诞生#

1971—1973 年间，丹尼斯·里奇对 B 语言进行改进，逐步加入字符、整数、指针、数组和结构体等机制。改进后的语言最初被称为“New B”，后来正式命名为 C。

1973 年，UNIX 内核的大部分代码被改用 C 语言编写。这一实践证明：操作系统并非只能使用汇编语言开发，也使 UNIX 更容易被移植到不同的计算机平台。

【二】重要发展时间线#

时间	事件	意义
1967 年	BCPL 语言诞生	为 B 语言提供设计基础
1969 年	肯·汤普森设计 B 语言	用于早期 UNIX 开发
1972 年前后	丹尼斯·里奇设计 C 语言	加入数据类型等重要机制
1973 年	UNIX 内核大部分改用 C 编写	验证了 C 语言的系统编程能力和可移植性
1978 年	《The C Programming Language》第一版出版	K&R C 成为事实上的语言规范
1983 年	ANSI 成立 X3J11 委员会	C 语言标准化工作正式展开
1989 年	ANSI 发布 C89	C 语言的第一个正式标准
1990 年	ISO 发布 C90	将 C89 纳入国际标准体系
1995 年	发布 C95 修订案	增强宽字符和多字节字符支持
1999 年	发布 C99	语言功能和标准库得到大幅扩展
2011 年	发布 C11	引入原子操作、线程和泛型选择等功能
2018 年	发布 C17	主要修正和澄清 C11
2024 年	ISO/IEC 9899<2024> 正式发布	通常称为 C23，是当前主要标准版本

【三】K&R C 与标准化#

1978 年，布莱恩·柯林汉（Brian Kernighan）和丹尼斯·里奇合著的《C 程序设计语言》（The C Programming Language）第一版出版。

《C 程序设计语言》封面

书中描述的 C 语言后来被称为 K&R C。它不是由标准化组织发布的正式标准，但在 C89 出现以前长期被视为事实上的规范。

随着 C 语言不断普及，不同编译器对语言的实现逐渐产生差异。为了提高程序的兼容性和可移植性，美国国家标准协会（ANSI）于 1983 年成立 X3J11 委员会，并在 1989 年发布第一个正式标准 C89。

【四】C 语言标准演进#

【1】C89 与 C90#

C89：ANSI X3.159-1989。
C90：ISO/IEC 9899<1990>。
两者在技术内容上基本相同，通常合称为 ANSI C 或 C89/C90。
引入函数原型，完善类型检查。
标准化 void、const、volatile 等类型和限定符。
系统定义标准头文件和标准库。
明确预处理、类型转换和程序行为规则。

【2】C95#

C95 并不是一次完整重写的语言标准，而是对 C90 的修订，正式形式为 C90 的 Amendment 1。

主要变化包括：

加强宽字符和多字节字符支持。
增加 <wchar.h> 和 <wctype.h>。
增加用于替代部分特殊字符的双字符组（digraph）。

【3】C99#

C99 是 C 语言历史上一次重要更新，代表性变化包括：

允许使用 // 单行注释。
允许在语句之间声明变量。
允许在 for 初始化部分声明变量。
增加 long long、_Bool 和复数类型。
引入 inline 和 restrict。
支持可变长度数组（VLA）。
支持指定初始化器、复合字面量和柔性数组成员。
增加 <stdint.h> 等标准头文件。

从 C11 开始，可变长度数组变为实现可选功能，并不是所有编译器都完整支持。

【4】C11#

C11 更关注并发编程、类型安全和现代硬件支持，代表性变化包括：

引入 _Atomic 和原子操作。
增加 <threads.h> 线程库。
引入 _Generic 泛型选择。
引入 _Static_assert 静态断言。
支持匿名结构体和匿名联合体。
增加对齐控制功能。
改进 Unicode 字符支持。

线程和原子操作在部分实现中属于可选功能，实际使用时需要检查编译器及标准库支持情况。

【5】C17（C18）#

C17 的正式标准编号为 ISO/IEC 9899<2018>，因此也经常被称为 C18。

它没有加入重要的新语言特性，主要用于修正 C11 中的缺陷、歧义和规范表述问题，是对 C11 的维护性更新。

【6】C23#

C23 在开发阶段曾被称为 C2X，最终标准文件为 ISO/IEC 9899<2024>。虽然正式文件于 2024 年发布，业界通常仍将这一版本称为 C23。

代表性变化包括：

增加 nullptr 和 nullptr_t。
增加 typeof 和 typeof_unqual。
支持 constexpr 对象。
支持二进制整数字面量和数字分隔符。
增加 _BitInt 位精确整数类型。
引入 #embed 预处理指令。
改进枚举、属性和类型推导能力。
将 bool、true、false 纳入语言本身。
删除部分过时的旧式语法。

C23 较新，不同编译器对各项特性的支持程度可能不同。使用前应查看具体编译器版本的说明。

【五】各版本对比#

版本	发布时间	定位	代表性变化
K&R C	1978 年	事实规范	描述标准化以前的经典 C 语言
C89/C90	1989/1990 年	首个正式标准	函数原型、类型限定符、标准库
C95	1995 年	C90 修订案	宽字符、多字节字符
C99	1999 年	大规模功能扩展	`//`、`inline`、VLA、`stdint.h`
C11	2011 年	现代化更新	原子操作、线程、泛型选择、静态断言
C17	2018 年	维护性版本	修正和澄清 C11
C23	2024 年正式发布	当前主要标准版本	`nullptr`、`typeof`、`constexpr`、`#embed`

【六】C 语言的主要特点#

【1】运行效率高#

C 语言提供较少的运行时抽象，程序通常可以被编译成高效的机器代码，因此适合对性能和资源占用要求较高的场景。

【2】具备底层控制能力#

指针、位运算和内存操作使 C 语言能够直接处理内存地址、寄存器及硬件资源。

【3】源代码可移植性较好#

符合标准且避免依赖平台特性的 C 程序，通常只需少量修改或重新编译，就能运行在不同平台上。

“可移植”并不意味着所有 C 程序在任何平台上都会得到完全相同的结果。数据类型长度、字节序及实现定义行为等仍可能存在差异。

【4】语言核心精简#

C 语言的语法和核心机制相对精简，许多功能通过标准库或第三方库提供。这种设计带来了灵活性，也要求程序员主动管理资源。

【5】需要关注内存安全#

C 语言允许直接操作内存，但不会自动进行边界检查或垃圾回收。数组越界、空指针、悬空指针和内存泄漏都是常见风险。

【七】主要应用领域#

操作系统与内核：UNIX、Linux 内核及部分 Windows 系统组件。
嵌入式系统：单片机、汽车电子、工业控制和物联网设备。
驱动程序与固件：需要直接操作硬件和寄存器的程序。
编译器与运行时：编译器、解释器及语言运行库。
数据库与基础软件：数据库、网络服务和高性能基础组件。
跨语言接口：C ABI 简单而稳定，许多语言通过 C 接口调用系统库。

【八】C 语言的影响#

C 语言对后来的编程语言产生了深远影响。C++ 和 Objective-C 直接建立在 C 的基础上；Java、C#、JavaScript 等语言也借鉴了大量 C 风格语法。

更重要的是，C 语言及其 ABI 已成为操作系统、硬件和高级编程语言之间的重要接口。即使应用程序并不直接使用 C 编写，其底层往往仍依赖 C 标准库、系统调用或由 C 实现的运行时组件。

【九】常见认识误区#

C 语言不是在 1972 年某一天突然完成的。
它是在 1971—1973 年间逐步设计和完善的。
K&R C 不是正式标准。
它是 C89 出现以前被广泛采用的事实规范。
C89 和 C90 不是两个差异明显的版本。
二者技术内容基本相同，只是发布组织和年份不同。
C17 和 C18 通常指同一代标准。
C17 是常用名称，正式标准文件发布于 2018 年。
C2X 已经不再是“计划中的标准”。
它最终发展为 C23，并以 ISO/IEC 9899<2024> 的形式正式发布。
可移植性不等于完全与平台无关。
编写可移植程序仍需避免未定义行为和平台相关假设。

【十】总结#

C 语言的发展可以概括为：

使用接近高级语言的结构化表达方式，获得接近底层硬件的控制能力。

它诞生于 UNIX 操作系统的开发需求，经过 K&R C、C89/C90、C99、C11、C17 和 C23 等阶段不断完善。虽然现代编程语言不断涌现，C 语言仍然是操作系统、嵌入式开发、编译器和高性能基础软件领域的重要工具。

学习 C 语言不仅是学习一种语法，更是在理解内存、数据表示、编译过程及计算机系统的基本工作方式。

【十一】延伸阅读#

C 语言开发环境的安装与配置

Sat, 26 Sep 2026 00:00:00 GMT

C 语言开发环境的安装与配置#

编写并运行一个 C 程序，至少需要以下两类工具：

代码编辑器或集成开发环境（IDE）：用于编写和管理源代码。
C 工具链：通常包含编译器、链接器、调试器和构建工具。

注意： Visual Studio Code 只是代码编辑器。安装 C/C++ 扩展后，还需要单独安装 GCC、Clang 或 MSVC 等编译器，才能编译和运行 C 程序。

【一】开发工具的组成#

工具	作用	常见选择
编辑器 / IDE	编写代码、管理文件、提供代码提示	Visual Studio Code、Visual Studio、CLion、Vim
编译器	将 C 源代码翻译为目标代码	GCC、Clang、MSVC
链接器	将目标文件和库组合成可执行程序	GNU `ld`、LLVM `lld`、MSVC LINK
调试器	单步执行、查看变量和调用栈	GDB、LLDB、Visual Studio Debugger
构建工具	自动执行多文件编译和链接	Make、CMake、Ninja

C 源文件通常使用 .c 扩展名，头文件通常使用 .h 扩展名。例如：

1
hello.c       C 源文件
2
student.h     头文件

【二】编辑器的选择#

【1】Visual Studio Code#

Visual Studio Code（简称 VS Code）体积较小、跨平台且扩展丰富，适合初学者使用。

下载地址：Visual Studio Code 官网
C/C++ 扩展：Microsoft C/C++

安装 VS Code 后，在扩展面板中搜索并安装 Microsoft 发布的 C/C++ 扩展。该扩展提供代码补全、语法检查和调试支持，但编译器仍需单独安装。

初学阶段建议先在终端中手动执行编译命令。这样可以清楚理解“源文件 → 编译 → 可执行文件 → 运行”的过程。

【2】其他选择#

Visual Studio：适合 Windows，内置 MSVC 工具链和图形化调试器。
CLion：跨平台商业 IDE，学生和符合条件的开源开发者可申请免费许可。
Vim / Neovim / Emacs：高度可定制，适合熟悉命令行的用户。
Sublime Text：轻量、启动快，但编译和调试通常需要自行配置。

Atom 已于 2022 年停止官方维护，不建议再作为新的 C 语言学习环境。

【三】Windows 环境安装（推荐）#

Windows 上可以选择 GCC、MSVC 或 WSL 等开发方案。本文采用以下组合搭建 C 语言开发环境：

1
VS Code + MinGW-w64 工具链（GCC + GDB）

【1】安装 MinGW-w64#

为了在 Windows 上使用 GCC，可以安装 MinGW-w64。
MinGW-w64 是一个开源项目，为 Windows 系统提供 GCC 工具链及相关运行库，支持生成 32 位和 64 位 Windows 应用程序。
访问 MinGW-w64 官网，进入其下载页面，选择合适的 MinGW-w64 发行包。
MinGW-w64 的下载页面列出了多个发行包及相关工具：

img

本文采用 MinGW-w64。单击图中红框标出的“SourceForge”超链接，即可进入 SourceForge 上的 MinGW-w64 下载页面。
SourceForge 下载地址：MinGW-w64 Files
GitHub 上也提供了编译完成的二进制包：MinGW-Builds

img

进入下载页面后，可以根据 Windows 系统架构选择对应的安装包：

img

使用在线安装程序时，可能会遇到网络连接错误，因此也可以直接下载 SJLJ 版本的压缩包（提供 32 位和 64 位版本）：

[下载 32 位 sjlj](https://sourceforge.net/projects/mingw-w64/files/Toolchains targetting Win32/Personal Builds/mingw-builds/8.1.0/threads-posix/sjlj/)
[下载 64 位 sjlj](https://sourceforge.net/projects/mingw-w64/files/Toolchains targetting Win64/Personal Builds/mingw-builds/8.1.0/threads-posix/sjlj/)

下载完成后，将压缩包解压到合适的位置。在其 bin 目录中可以找到 gcc.exe、g++.exe 等程序：

img

安装 MinGW-w64 时，需要确保所选工具包中包含 GCC、G++、Binutils 和运行库等基本组件。
将 MinGW-w64 安装目录下的 bin 子目录添加到 Path 环境变量中。完成配置后，即可在命令行中直接调用这些工具。

img

安装并配置完成后，可以在 Windows 命令行中运行 gcc、g++、ar、ranlib、dlltool 等 GNU 工具。

【2】安装 VS Code#

（1）下载安装包#

从 VS Code 官网下载安装程序。

image-20260921220124456

（2）安装#

双击下载的安装程序，开始安装。图中使用的安装包名称为 VSCodeUserSetup-x64-1.83.1.exe；实际文件名会随版本更新而变化。

image-20260921220218339

选择安装位置，然后单击“下一步”。

image-20260921220229486

选择开始菜单文件夹。这里采用默认选项，直接单击“下一步”。

image-20260921220241479

选择附加任务。为了方便后续使用，这里勾选图中所示的全部选项。

image-20260921220258127

确认安装设置后，单击“安装”。

image-20260921220308116

安装完成后，勾选“启动 Visual Studio Code”，然后单击“完成”。

image-20260921220320533

（3）选择颜色主题风格#

VS Code 首次启动时会打开欢迎页面，可以在其中选择颜色主题。默认主题为深色模式，本文选择浅色模式；后续也可以在设置中随时更换主题。

image-20260921220358709

（4）配置 VS Code#

[1] 安装中文语言包#

单击左侧活动栏中的“扩展”按钮，在搜索框中输入 Chinese，找到并安装 Chinese (Simplified) (简体中文) Language Pack for Visual Studio Code。

image-20260921220449049

语言包安装完成后需要重启 VS Code。正常情况下，界面会显示重启按钮；如果没有显示，也可以手动关闭并重新启动 VS Code。

image-20260921220501215

[2] 安装 C 语言扩展#

单击左侧活动栏中的“扩展”按钮，搜索 C/C++，选择并安装 C/C++ Extension Pack。该扩展包集成了 C/C++ 开发中常用的多个扩展。

image-20260921220543673

【3】验证安装#

完全关闭并重新打开 VS Code，然后新建一个 PowerShell 终端，依次执行：

Terminal window

1
gcc --version
2
gdb --version
3
Get-Command gcc
4
gcc -dumpmachine

如果安装正确：

gcc --version 会显示 GCC 版本信息；
gdb --version 会显示 GDB 版本信息；
Get-Command gcc 会显示 gcc.exe 的实际路径；
对于 64 位 MinGW-w64，gcc -dumpmachine 的结果通常包含 x86_64-w64-mingw32。

【四】编写并运行第一个 C 程序#

【1】创建项目目录#

建议为每个项目单独建立文件夹。例如：

1
C:\Code\c-study\hello

使用 VS Code 打开该文件夹，然后新建 hello.c：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    printf("Hello, C!\n");
6
    return 0;
7
}

【2】编译程序#

在 VS Code 中选择“终端 → 新建终端”，执行：

Terminal window

1
gcc -std=c17 -Wall -Wextra -Wpedantic -g hello.c -o hello.exe

各参数含义：

参数	作用
`-std=c17`	按 C17 标准编译
`-Wall -Wextra -Wpedantic`	开启常用警告，帮助发现潜在问题
`-g`	写入调试信息，供 GDB 使用
`hello.c`	输入的 C 源文件
`-o hello.exe`	指定生成的可执行文件名

编译成功时，GCC 通常不会输出任何信息。没有消息往往表示没有发现错误。

【3】运行程序#

在 PowerShell 中执行：

Terminal window

1
.\hello.exe

预期输出：

1
Hello, C!

PowerShell 默认不会直接从当前目录查找程序，因此需要使用 . 表示当前目录，即写成 .\hello.exe。

【五】Windows 上的其他方案#

【1】Visual Studio + MSVC#

如果希望使用完整 IDE，可以安装 Visual Studio Community。在安装器中选择：

1
使用 C++ 的桌面开发（Desktop development with C++）

虽然工作负载名称包含“C++”，其中的 MSVC 编译器同样可以编译 C 程序。在 “Developer PowerShell for VS” 中可以这样编译：

Terminal window

1
cl /W4 /Zi hello.c
2
.\hello.exe

MSVC 与 GCC 的命令行参数不同，不能直接照搬 GCC 的参数。

【2】WSL（适合学习 Linux 开发）#

WSL 可以在 Windows 中提供 Linux 环境。管理员 PowerShell 中执行：

Terminal window

1
wsl --install

进入 Ubuntu 后安装工具链：

Terminal window

1
sudo apt update
2
sudo apt install build-essential gdb

WSL 中生成的是 Linux 可执行文件，应在 WSL 内使用 ./hello 运行，而不是在 Windows 中运行。

【六】Linux 环境安装#

先检查编译器是否已经安装：

Terminal window

1
gcc --version

如果未安装，可以根据发行版执行相应命令。

【1】Debian / Ubuntu#

Terminal window

1
sudo apt update
2
sudo apt install build-essential gdb

【2】Fedora#

Terminal window

1
sudo dnf install gcc gdb make

【3】Arch Linux#

Terminal window

1
sudo pacman -S base-devel gdb

编译并运行：

Terminal window

1
gcc -std=c17 -Wall -Wextra -Wpedantic -g hello.c -o hello
2
./hello

【七】macOS 环境安装#

macOS 推荐安装 Apple Command Line Tools：

Terminal window

1
xcode-select --install

安装后验证：

Terminal window

1
cc --version
2
clang --version

macOS 默认提供的是 Apple Clang。系统中的 gcc 命令通常也会调用 Clang，并不代表安装了 GNU GCC。

编译并运行：

Terminal window

1
cc -std=c17 -Wall -Wextra -Wpedantic -g hello.c -o hello
2
./hello

【八】常见问题排查#

【1】提示“无法识别 gcc”或“gcc 不是内部或外部命令”#

可能原因：

工具链尚未安装；
MinGW-w64 安装目录下的 bin 文件夹没有加入 Path；
修改 Path 后没有重启终端或 VS Code；
Path 中存在其他旧版 GCC，导致工具冲突。

在 PowerShell 中检查：

Terminal window

1
Get-Command gcc -All

【2】安装了 VS Code 扩展却不能编译#

C/C++ 扩展只提供代码编辑、代码提示和调试集成，不包含编译器。按照本文的技术路线，还需要单独安装 MinGW-w64 工具链。

【3】出现 `No such file or directory`#

先确认终端所在目录和文件名：

Terminal window

1
Get-Location
2
Get-ChildItem

然后确认当前目录中确实存在 hello.c。文件扩展名也可能被 Windows 隐藏，应避免将文件误命名为 hello.c.txt。

【4】双击程序后窗口一闪而过#

不要通过双击运行控制台程序。应在 PowerShell、Windows Terminal 或 VS Code 终端中执行：

Terminal window

1
.\hello.exe

【5】中文输出乱码#

初学阶段可先使用英文路径、英文文件名和英文输出，减少编码问题。需要输出中文时，应确保源文件、终端和程序使用兼容的字符编码；在现代 Windows Terminal 中通常建议统一使用 UTF-8。

【6】`gcc` 和 `g++` 有什么区别#

gcc：用于编译 C 程序；
g++：用于编译 C++ 程序，并自动链接 C++ 标准库。

学习 C 语言时，源文件应使用 .c 扩展名，并使用 gcc 编译。

【九】推荐的学习配置#

对于 Windows 初学者，建议统一使用以下组合：

项目	推荐选择
编辑器	Visual Studio Code
编辑扩展	Microsoft C/C++
工具链	MinGW-w64 GCC
调试器	GDB
语言标准	C17（兼容性较好）
编译警告	`-Wall -Wextra -Wpedantic`

C23 已正式发布，但不同编译器对其特性的支持程度不一致。基础学习阶段使用 C17 更稳定；学习 C23 新特性时，再根据编译器版本选择 -std=c23 或旧版 GCC 使用的 -std=c2x。

【十】延伸阅读#

C 语言初识：程序运行机制与基本结构

Sat, 26 Sep 2026 00:00:00 GMT

【一】C 程序的运行机制#

从源代码到程序运行，通常会经历编写、预处理、编译、汇编、链接和运行等阶段。开发者平时执行一条编译命令时，这些阶段大多由编译器工具链自动完成，因此中间文件不一定会被保留下来。

img

图中展示的是 Windows 下的 MSVC 工具链：cl.exe 负责处理和编译源文件，link.exe 负责链接，目标文件扩展名为 .obj。本文安装的是 MinGW-w64 GCC 工具链，目标文件通常使用 .o 扩展名。二者生成的文件名称和使用的命令有所不同，但整体处理过程基本一致。

1
1. 编写代码：使用编辑器编写 C 源代码，并保存为 xx.c 文件。
2

3
2. 预处理：处理 #include、#define、条件编译等预处理指令，并处理源代码中的注释，通常得到 xx.i 文件。
4

5
3. 编译：对预处理后的代码进行词法分析、语法分析、语义分析和优化，再转换为汇编代码，通常得到 xx.s 文件。
6

7
4. 汇编：汇编器将汇编代码转换成机器指令，生成可重定位目标文件；GCC 通常生成 xx.o，MSVC 通常生成 xx.obj。
8

9
5. 链接：链接器把一个或多个目标文件、启动代码和所需的库组合起来，解析函数与变量的引用，最终生成可执行文件。Windows 下通常为 xx.exe。
10

11
6. 运行：操作系统加载可执行文件及其依赖的动态库，完成运行环境初始化后开始执行程序，并得到运行结果。

这里需要区分“编译”的两种常见含义：

广义的编译：泛指从源文件生成可执行文件的整个构建过程，包括预处理、狭义编译、汇编和链接。
狭义的编译：特指把预处理后的 C 代码转换为汇编代码的阶段。

目标文件虽然已经包含机器指令，但通常还存在尚未确定地址的符号引用，因此不能直接运行。例如，程序调用 printf 时，目标文件只记录了对该函数的引用；链接器还需要从相应的库中找到它，并建立正确的关联。

使用 MinGW-w64 GCC 时，可以通过下面的命令分别观察各个阶段：

Terminal window

1
# 1. 预处理：hello.c -> hello.i
2
gcc -E hello.c -o hello.i
3

4
# 2. 编译：hello.i -> hello.s
5
gcc -S hello.i -o hello.s
6

7
# 3. 汇编：hello.s -> hello.o
8
gcc -c hello.s -o hello.o
9

10
# 4. 链接：hello.o -> hello.exe
11
gcc hello.o -o hello.exe
12

13
# 5. 运行（PowerShell）
14
.\hello.exe

实际开发时通常不需要手动执行每个阶段。一条命令即可让 GCC 依次完成预处理、编译、汇编和链接：

Terminal window

1
gcc hello.c -o hello.exe
2
.\hello.exe

gcc 不只是狭义上的编译器命令，它还充当工具链的驱动程序，会根据参数自动调用预处理器、编译器、汇编器和链接器。

【二】C 基础语法#

C 语言是一种通用编程语言，广泛应用于系统编程、嵌入式开发和高性能计算等领域。

C 语言具有高效、灵活、可移植性强等特点，是许多其他编程语言（如 C++、Java、Go）的基础，至今仍是操作系统、驱动程序和底层库开发的主流选择。

在 C 语言中，令牌（Token）是程序的基本组成单位。编译器通过词法分析，将源代码识别为一个个具有特定含义的令牌。了解令牌的类别，有助于看懂程序的语法结构。

C 语言的令牌主要包括以下几种类型：

关键字（Keywords）：语言预留的具有特殊含义的单词，如 int、if、return。
标识符（Identifiers）：程序员自定义的名称，用于变量、函数、数组等。
常量（Constants）：程序中固定不变的值，如整数 42、浮点数 3.14。
字符串字面量（String Literals）：由双引号括起来的字符序列，如 "Hello"。
运算符（Operators）：用于执行运算的符号，如 +、==、&&。
分隔符（Separators）：用于分隔语句和代码块的符号，如 ;、{}。

阅读代码时，可以先找出标识符、字面量和运算符，再观察分号、括号与花括号如何组织语句。C 语言区分大小写，例如 count 和 Count 是两个不同的标识符。

【三】C 程序的基本结构#

【1】简单的 C 语言程序#

先从一个输出文字的 C 程序开始，观察头文件、main 函数与 return 语句的位置：

1
#include <stdio.h>
2

3
int main() {
4
  printf("Hello, World!\n");
5
  return 0;
6
}

上面的代码可以从以下几个组成部分理解；变量声明和其他函数定义则会出现在后续示例中：

预处理器指令：如 #include 和 #define，在编译前由预处理器处理。
主函数：每个 C 程序都有且只有一个 main() 函数，是程序的执行入口。
变量声明：声明程序中使用的变量，C89 要求声明必须在代码块最开头。
函数定义：定义程序中使用的函数，描述函数的具体实现逻辑。

【2】复杂一点的 C 程序结构#

再看一个稍完整的 C 程序：它从标准输入读取两个整数，调用 add 函数计算结果，并输出求和结果。下面先认识整体结构，各知识点会在后续章节展开说明。

1
#include <stdio.h>   // 头文件包含
2

3
#define PI 3.14159    // 宏定义
4

5
// 函数声明
6
int add(int a, int b);
7

8
int main() {         // 主函数
9
    // 变量声明
10
    int num1, num2, sum;
11

12
    // 用户输入
13
    printf("Enter two integers: ");
14
    if (scanf("%d %d", &num1, &num2) != 2) {
15
        printf("Invalid input.\n");
16
        return 1;
17
    }
18

19
    // 函数调用
20
    sum = add(num1, num2);
21

22
    // 输出结果
23
    printf("Sum: %d\n", sum);
24

25
    return 0;        // 返回 0 表示程序成功执行
26
}
27

28
// 函数定义
29
int add(int a, int b) {
30
    return a + b;
31
}

展开收起

scanf 会返回成功读取并转换的数据项数量。本例需要读取两个整数，因此返回值应为 2；如果返回值不等于 2，程序会提示输入无效并提前结束，从而避免继续使用未正确赋值的变量。

头文件包含

头文件通常在程序开头通过 #include 指令引入。例如，<stdio.h> 声明了标准输入输出函数，<stdlib.h> 提供了常用的通用工具声明。包含相应头文件后，编译器才能获得所用函数和宏的相关信息。
标准库头文件通常使用尖括号 < >，项目自定义头文件通常使用双引号 " "；两种写法的头文件搜索方式不同。
示例：#include <stdio.h>（标准库头文件）、#include "myheader.h"（自定义头文件）。

宏定义

宏通过 #define 指令定义，可表示符号常量或代码片段。预处理器会在编译前展开宏；宏常用于定义常量或简短的可复用表达式。
宏本身不进行类型检查，使用时需谨慎；需要类型约束时，可以考虑使用 const 变量。
示例：#define PI 3.14159、#define MAX(a, b) ((a) > (b) ? (a) : (b))

函数声明

函数声明（也称函数原型）提供返回类型、函数名和参数信息，使编译器能在调用处检查参数与返回类型。本例在调用 add 之前先写出声明，再在 main 之后给出定义。
多个源文件需要调用同一个函数时，可以将其声明放在头文件中共享。
示例：int add(int a, int b);

主函数

main() 函数是 C 程序的入口点，每个 C 程序都必须包含一个 main() 函数。程序从 main() 开始执行，返回值通常为 0 表示程序成功执行，非零值表示出现了错误。
main() 函数也可以接收命令行参数：int main(int argc, char *argv[])，其中 argc 是参数个数，argv 是参数字符串数组。
示例：int main() { ... }

变量声明

在 C 程序中，变量使用前需要声明其类型。变量既可以在函数内部声明为局部变量，也可以在函数外部声明为全局变量。
声明变量时可同时进行初始化，未初始化的局部变量包含不确定值（垃圾值），而全局变量和静态变量会被自动初始化为 0。
示例：int count = 0;、float price = 9.99;、char grade = 'A';

语句和表达式

语句用于组织程序中的操作，例如函数调用、赋值或控制流。表达式则可以由变量、运算符和常量等构成，并参与求值。
C 语言中，赋值本身也是一个表达式，具有值（即被赋的值），因此可以写出 a = b = c = 0; 这样的链式赋值。
示例：

1
printf("Enter two integers: ");
2
sum = add(num1, num2);

控制流语句

控制流语句决定程序的执行顺序，包括条件判断（if/else、switch）、循环（for、while、do-while），以及 break、continue、goto 和 return 等跳转语句。
合理使用控制流语句有助于让程序逻辑更清晰；为了保持代码可读性，应避免滥用 goto。
示例：

1
if (num1 > num2) {
2
    printf("num1 is greater than num2");
3
}

函数定义

函数定义包含完整的函数体，描述函数的具体实现。一个函数通常由返回类型、函数名、参数列表和函数体组成。设计函数时，可以尽量让每个函数专注于一项明确的任务。
C 语言的函数不支持重载，每个函数名在同一作用域中必须唯一。函数可以递归调用自身。
示例：

1
int add(int a, int b) {
2
    return a + b;
3
}

返回语句

return 语句用于终止函数的执行，并将控制权连同返回值一起交还给调用者。void 类型的函数可以使用不带值的 return; 提前退出，也可以省略 return 语句。
main() 函数的返回值会传递给操作系统，0 通常表示成功，可使用标准宏 EXIT_SUCCESS 和 EXIT_FAILURE（定义在 <stdlib.h>）。
示例：return 0;、return EXIT_SUCCESS;

C 语言基础：注释、关键字、变量与数据类型

Sat, 26 Sep 2026 00:00:00 GMT

【一】注释#

注释用于补充代码的设计意图、使用条件和注意事项，不参与程序运行。C 语言支持 // 单行注释和 /* ... */ 块注释，其中 // 从 C99 开始被正式纳入标准。

【1】单行注释#

1
// 单行注释

单行注释以 // 开始，到当前行末尾结束。它既可以单独占一行，也可以写在代码行末尾。

【2】多行注释#

1
/* 单行注释 */
2
/*
3
 多行注释
4
 多行注释
5
 多行注释
6
 */

块注释以 /* 开始、以 */ 结束，可以写成一行或跨越多行，适合补充较长的说明。

1
#include <stdio.h>
2

3
// 这是单行注释
4

5
/*
6
这是多行注释
7
它可以跨越多行
8
*/
9

10
int main(void) {
11
    // 打印一条消息
12
    printf("Hello, World!\n");
13
    return 0;
14
}

【3】文档注释（文本注释）#

文档注释本质上仍是块注释，C 语言标准并没有单独规定“文档注释”语法。Doxygen 等文档生成工具会识别 /** ... */ 中的特定标记，并据此生成接口文档。

1
/**
2
    本质是多行注释
3
    文档注释的功能 : 添加批注
4
*/

1
#include <stddef.h>
2

3
/**
4
* @brief 计算字符串的长度
5
*
6
* @param str 指向以空字符结尾的字符串
7
* @return 字符串的长度
8
*/
9
size_t string_length(const char *str);

上例只展示函数声明及其文档说明。@brief、@param 和 @return 是 Doxygen 常用标记，不是 C 语言关键字。

【4】注意#

块注释不能嵌套。例如，/* 外层 /* 内层 */ 外层 */ 会在遇到第一个 */ 时结束，后续内容可能引发编译错误。
字符串字面量和字符常量中的 //、/*、*/ 只是普通字符，不会被识别为注释。例如，"https://example.com" 中的 // 不会开始一段注释。
注释是写给人看的，应简洁明了，重点解释“为什么这样做”、约束条件和容易忽略的问题，而不是机械重复代码已经表达的内容。
良好的注释习惯是专业编程的重要组成部分，有助于代码维护和团队协作。

【二】关键字#

关键字是由 C 语言标准预先赋予特殊含义的单词，不能用作变量名、函数名或其他标识符。不同 C 标准引入的关键字有所不同，下表首先列出 C90 的 32 个经典关键字。

关键字	说明
auto	声明自动变量（局部变量默认存储类型，现代 C 中很少显式使用）
break	跳出当前循环或 switch 语句
case	switch 语句中的分支标签
char	声明字符类型；`sizeof(char)` 始终等于 1，但 1 字节不一定等于 8 位
const	添加只读限定，表示不能通过该左值修改对象
continue	结束本次循环迭代，直接开始下一轮循环
default	switch 语句中的默认分支（所有 case 均不匹配时执行）
do	do-while 循环的循环体，循环体至少执行一次
double	声明双精度浮点型变量或函数返回值类型（通常占 8 字节）
else	条件语句的否定分支（与 if 连用）
enum	声明枚举类型，用于定义一组命名的整型常量
extern	声明变量或函数在其它文件或本文件的其他位置定义
float	声明单精度浮点型变量或函数返回值类型（通常占 4 字节）
for	for 循环语句，适合已知循环次数的场景
goto	无条件跳转语句（应谨慎使用，可能降低代码可读性）
if	条件判断语句
int	声明整型变量或函数返回值类型（通常占 4 字节）
long	声明长整型变量或函数返回值类型
register	建议编译器将变量存入寄存器以提高访问速度（现代编译器通常自动优化）
return	函数返回语句，可带返回值，也可不带（void 函数）
short	声明短整型变量或函数返回值类型（通常占 2 字节）
signed	声明有符号类型变量（可表示负数，整型默认有符号）
sizeof	获取类型或表达式结果类型所占的字节数；涉及 VLA 时可能在运行期求值
static	使局部变量具有静态存储期，或使文件作用域名称具有内部链接
struct	声明结构体类型，将不同类型的数据组合成一个整体
switch	多分支选择语句，根据表达式的值跳转到对应 case
typedef	为已有数据类型定义新的别名，提高代码可读性
unsigned	声明无符号类型变量（只能表示非负数，范围更大）
union	声明共用体类型，所有成员共享同一块内存空间
void	表示无值类型；可声明无返回值函数、无参数函数或通用对象指针 `void *`
volatile	表示对象可能以编译器无法预知的方式变化，要求相关访问按抽象机规则发生
while	while 循环语句，适合循环次数未知但终止条件明确的场景

【1】C99 新增关键字#

`_Bool`	`_Complex`	`_Imaginary`	`inline`	`restrict`

C99 新增的关键字主要用于：布尔类型支持（_Bool）、复数支持（_Complex、_Imaginary）、内联函数优化（inline）、指针别名限制优化（restrict）。

_Imaginary 与虚数类型属于实现可选功能，并非所有编译器都提供支持。

【2】C11 新增关键字#

`_Alignas`	`_Alignof`	`_Atomic`	`_Generic`	`_Noreturn`
`_Static_assert`	`_Thread_local`

C11 新增的关键字主要用于：内存对齐控制（_Alignas、_Alignof）、原子操作与多线程支持（_Atomic、_Thread_local）、泛型选择（_Generic）、静态断言（_Static_assert）和标记无返回值函数（_Noreturn）。

【3】C23 新增的常用关键字#

`alignas`	`alignof`	`bool`	`constexpr`	`false`	`nullptr`
`static_assert`	`thread_local`	`true`	`typeof`	`typeof_unqual`	`_BitInt`

C23 为部分以下划线开头的旧写法提供了更自然的拼写，并加入 constexpr、nullptr、typeof、typeof_unqual 和 _BitInt 等功能。C23 较新，实际使用前应确认编译器版本及其支持情况。

【三】标识符#

标识符是变量、函数、数组、类型等程序实体的名称，通常由程序员定义。对于基础学习，可以将规则概括为：标识符由英文字母、数字和下划线组成，但不能以数字开头。

一个常见的标识符以字母 A-Z、a-z 或下划线 _ 开始，后面可以跟零个或多个字母、下划线或数字 0-9。

C 标识符中不能随意使用 @、$、%、空格和连字符等字符。C 语言区分大小写，因此 Manpower 和 manpower 是两个不同的标识符。下面列出几个有效的标识符：

1
mohd       zara    abc   move_name  a_123
2
myname50   _temp   j     a23b9      retVal

以下是一些无效的标识符示例及原因：

1
2abc        // 错误：以数字开头
2
my-name     // 错误：包含连字符 -
3
float       // 错误：与关键字重名
4
my name     // 错误：包含空格

命名建议：标识符应具有描述性，能清晰表达其用途。常见的命名风格有下划线命名法（my_variable）和小驼峰命名法（myVariable），在同一项目中保持一致即可。

以下划线开头的名称还涉及标准保留规则：

任何位置都不要自定义以双下划线 __ 开头的标识符。
任何位置都不要自定义以下划线加大写字母开头的标识符，如 _Value。
文件作用域中，应避免定义任何以下划线开头的标识符。

这些名称通常保留给编译器、标准库和具体实现使用。

【四】常量#

常量可以理解为程序中直接使用的固定值，或在程序中不允许通过某个名称修改的对象。学习时需要区分字面量、const 限定对象和宏常量，它们虽然都常被称作“常量”，但语言机制并不相同。

常量可以是整型常量、浮点型常量、字符常量、枚举常量等：

1
const int MAX = 100;            // const 限定的整型对象
2
const double PI = 3.1415926;    // const 限定的浮点型对象
3
const char NEWLINE = '\n';      // const 限定的字符型对象

其中，100、3.1415926 和 '\n' 是字面量；MAX、PI 和 NEWLINE 是具有类型的 const 限定对象。const 表示不能通过这些名称修改对应对象，但它并不等同于预处理宏。

字符常量中常用的转义字符包括：

\n：换行
\t：水平制表符
\\：反斜杠
\'：单引号
\0：空字符，数值为 0，常用作 C 字符串的结束标志

与 #define 宏相比，const 限定对象具有明确类型，编译器可以进行类型检查，也能在调试器中观察它。二者用途并不完全相同，应根据使用场景选择。

常见的字面量可以分为以下几类：

1
42                    // 整数字面量
2
3.14                  // 浮点数字面量，默认类型为 double
3
3.14f                 // float 类型的浮点数字面量
4
'A'                   // 字符常量
5
"Hello"               // 字符串字面量

C99 引入 _Bool 类型；包含 <stdbool.h> 后，在 C17 及更早标准中通常可以使用 bool、true 和 false 宏。C23 将 bool、true 和 false 纳入语言本身。

1
#include <stdbool.h>
2

3
bool is_ready = true;

C 语言不存在名为 null 的通用“空常量”。表示空指针时，传统写法使用 NULL 或整数常量 0；C23 还引入了 nullptr。空指针与表示字符串结尾的空字符 '\0' 是两个不同概念。

【1】字符串字面量#

字符串字面量是由双引号括起来的字符序列，用于表示文本数据。

字符串字面量在内存中以字符数组形式表示，末尾会自动添加空字符 \0（null character），用于标记字符串结束。

1
char greeting[] = "Hello, World!";  // 编译器自动计算长度（包含 \0）

以下是关于字符串字面量的几点重要说明：

“Hello” 在内存中实际占 6 个字节：'H'、'e'、'l'、'l'、'o'、'\0'。
修改字符串字面量会产生未定义行为，因此不应通过指针修改它；若需要可修改的字符串，应使用字符数组保存其副本。
两个相邻的字符串字面量会被编译器自动拼接："Hello, " "World!" 等同于 "Hello, World!"。
字符 'A'（字符常量）和字符串 "A"（字符串字面量）是不同的，后者包含 'A' 和 '\0' 两个字符。

1
1. 整数字面量：10、20、0xFF、077
2
2. 浮点数字面量：3.14、-0.5、1.0e3、2.5f
3
3. 字符常量：'a'、'A'、'0'、' '、'!'、'\0'、'\n'
4
4. 字符串字面量："任意内容"、""（空字符串）
5
5. 布尔值：false 和 true（具体用法取决于采用的 C 标准）
6

7
主要用途：
8
1. 参与表达式计算或通过 printf 输出，此时应使用与类型相匹配的格式说明符。
9
2. 为变量提供初始值，例如：int a = 10; char ch = 'a';

普通字符常量通常使用单引号，例如 'A'。源代码中的中文字符涉及源文件编码、执行字符集和实现支持，不能简单假设 '我' 能像普通单字节字符一样存入 char。处理中文文本时通常使用字符串及明确的字符编码方案，相关内容会在字符串章节中进一步说明。

【2】自定义常量#

自定义常量常见有三种方式：const 限定对象、对象式宏和枚举常量。

（1）使用 `const`#

1
const int MAX_STUDENTS = 50;
2
const double TAX_RATE = 0.13;

这种写法具有明确的数据类型，适合定义在运行过程中不应被修改的值。

（2）使用 `#define`#

1
#define BUFFER_SIZE 1024
2
#define PI 3.1415926

#define 由预处理器执行文本替换，没有变量类型，也不会为宏名称本身分配存储空间。为了便于识别，宏名称通常使用全大写字母和下划线。

宏定义末尾通常不写分号，否则分号也会成为替换内容的一部分：

1
#define MAX_COUNT 100    // 正确

（3）使用枚举常量#

1
enum Weekday {
2
    MONDAY = 1,
3
    TUESDAY,
4
    WEDNESDAY
5
};

枚举常量适合表示一组相互关联的命名整数值。在上例中，MONDAY 为 1，后续未显式赋值的成员依次递增，因此 TUESDAY 为 2、WEDNESDAY 为 3。

【五】变量#

变量是具有名称、类型和值的程序对象，其保存的值可以在允许的范围内发生变化。“可以变化”表示变量具备修改能力，并不意味着它在程序运行期间一定会被修改。

例如，鸡蛋的单价可能随时间改变，因此可以使用变量保存；某一时刻赋给该变量的 1.0 则是一个固定的字面量。

从入门角度看，可以把变量理解为一块用于存放数据的存储区域：

变量类型决定数据的表示方式、允许执行的操作及通常需要的存储空间。
变量名用于在源代码中标识这个对象。
变量值是当前保存在对象中的数据。
变量地址表示对象在存储空间中的位置，可以使用取地址运算符 & 获取可寻址对象的地址。

“变量一定真实占用一块独立内存”是便于入门的理解。经过优化后，编译器可能把变量保存在寄存器中，甚至完全消除不必要的变量；程序应依据 C 语言规则使用变量，而不应依赖编译器具体如何存储它。

【1】变量的声明、定义与初始化#

1
int age;              // 定义变量，但没有显式初始化
2
int score = 100;      // 定义变量并初始化
3
double price = 1.0;   // 定义并初始化 double 变量
4

5
score = 95;           // 赋值：修改变量已有的值

基本格式如下：

1
数据类型 变量名 = 初始值;

数据类型：规定数据的表示方式、取值范围和可执行的操作。
变量名：在程序中访问变量时使用的标识符。
=：在定义中表示初始化，在普通语句中表示赋值。
初始值：变量创建时获得的第一个值。

初始化与赋值看起来都使用 =，但发生时机不同：初始化发生在对象创建时，而赋值用于修改已经存在的对象。

声明用于向编译器说明名称及其类型，定义还会真正创建对应的对象。变量定义本身也是一种声明；使用 extern 且不带初始化器的写法通常只进行声明：

1
extern int shared_count;    // 声明：定义位于其他位置
2
int shared_count = 0;       // 定义：创建对象并初始化

同一个作用域中可以存在相互兼容的重复声明，但一个对象通常只能有一个定义。

【2】未初始化变量#

函数内部的普通局部变量如果没有显式初始化，其值通常是不确定的。读取这种不确定值通常会导致未定义行为，因此应遵循“先初始化，再使用”的原则。

1
int count;
2
printf("%d\n", count);    // 错误示例：count 尚未初始化

可以在定义时给出初始值：

1
int count = 0;
2
printf("%d\n", count);    // 正确：输出 0

文件作用域变量以及使用 static 声明的对象，如果没有显式初始化，会按规则进行零初始化：

1
static int total;    // 自动初始化为 0

“垃圾值”是日常教学中的形象说法，但不够严谨。标准术语是不确定值；问题也不只是输出不可预测，读取它还可能导致未定义行为。

【3】作用域与生命周期#

作用域决定变量名可以在源代码的哪些位置被访问。
**生命周期（存储期）**决定变量对应的对象从何时存在到何时结束。

函数内部定义的普通局部变量通常只能在所在代码块中访问，并在进入代码块时创建、离开代码块时结束。文件作用域变量和静态局部变量通常在整个程序运行期间存在。

1
int global_count = 0;      // 文件作用域变量
2

3
void increase(void)
4
{
5
    static int calls = 0;  // 仅在本函数中可见，但值会跨调用保留
6
    int step = 1;          // 普通局部变量
7

8
    calls += 1;
9
    global_count += step;
10
}

【六】数据类型#

数据类型规定一组数据的表示方式、取值范围以及可以对其执行的操作。C 语言是静态类型语言，变量和函数的类型在编译阶段就需要确定。

C 语言没有“引用数据类型”这一类别。引用是 C++ 等语言中的概念；C 语言通过指针间接访问对象。

从入门角度，可以将常见类型整理如下：

1
1. 基本类型
2
   a. 字符类型：char、signed char、unsigned char
3
   b. 整数类型：short、int、long、long long 及其 signed/unsigned 形式
4
   c. 布尔类型：_Bool（C99）；bool 是常用写法
5
   d. 浮点类型：float、double、long double
6

7
2. 枚举类型
8
   enum
9

10
3. void 类型
11
   表示“无值”，常用于无返回值函数和通用对象指针 void *
12

13
4. 派生类型
14
   指针、数组和函数类型
15

16
5. 结构与联合类型
17
   struct、union

展开收起

【1】整数类型#

整数类型用于表示没有小数部分的数值。signed 类型可表示负数、零和正数，unsigned 类型只表示非负数。

类型	常见含义	说明
`char`	字符或小整数	大小始终为 1 字节；是否有符号由实现决定
`short`	短整型	至少 16 位
`int`	基本整型	通常是平台上运算较自然的整数类型，至少 16 位
`long`	长整型	至少 32 位
`long long`	长长整型	至少 64 位

C 标准只规定各类型的最小表示范围和相对等级，并不保证 int 永远是 4 字节。实际大小取决于编译器和目标平台，可用 sizeof 运算符查看。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    printf("sizeof(char)      = %zu\n", sizeof(char));
6
    printf("sizeof(short)     = %zu\n", sizeof(short));
7
    printf("sizeof(int)       = %zu\n", sizeof(int));
8
    printf("sizeof(long)      = %zu\n", sizeof(long));
9
    printf("sizeof(long long) = %zu\n", sizeof(long long));
10
    return 0;
11
}

sizeof 的结果类型是 size_t，使用 printf 输出时应采用 %zu 格式说明符。

【2】浮点类型#

浮点类型用于表示带小数部分或范围很大的近似数值：

类型	常见精度	说明
`float`	约 6～9 位十进制有效数字	单精度浮点类型
`double`	约 15～17 位十进制有效数字	双精度浮点类型
`long double`	不低于 `double`	具体精度由实现决定

浮点数采用有限位数表示，很多十进制小数无法被精确存储，因此不应简单使用 == 判断两个计算所得的浮点数是否相等。

1
double result = 0.1 + 0.2;
2
printf("%.17f\n", result);  // 结果可能不是精确的 0.3

【3】布尔类型#

C99 引入 _Bool 类型，其值会归一化为 0 或 1。在 C17 及更早标准中，通常包含 <stdbool.h> 后使用更易读的 bool、true 和 false：

1
#include <stdbool.h>
2

3
bool is_valid = true;

在条件判断中，数值 0 表示假，任何非零值都表示真。C23 已将 bool、true 和 false 纳入语言本身。

【4】字符类型与字符编码#

char 本质上属于整数类型，也常用于保存字符编码单元。字符常量使用单引号，字符串字面量使用双引号：

1
char grade = 'A';
2
char message[] = "Hello";

sizeof(char) 永远等于 1，但 C 标准规定的“字节”不一定是 8 位。可以通过 <limits.h> 中的 CHAR_BIT 查看每字节的位数；在现代通用平台上通常为 8。

【5】固定宽度整数类型#

当程序确实需要宽度明确的整数时，可以使用 <stdint.h> 提供的类型，例如 int8_t、uint32_t 和 int64_t。这些类型只有在实现能够提供对应宽度时才会定义。

1
#include <stdint.h>
2

3
uint32_t color = 0xFF3366U;
4
int64_t distance = 9000000000LL;

普通业务代码优先使用 int 等基本类型；处理文件格式、网络协议、硬件寄存器等对位宽有明确要求的场景时，再考虑固定宽度类型。

C 语言数据类型

Sat, 26 Sep 2026 00:00:00 GMT

【一】数据类型#

在 C 语言中，数据类型用于描述数据的性质。一个对象或表达式的类型，会影响以下内容：

数据在内存中的表示方式和通常占用的空间；
数据能够表示的取值范围与精度；
可以对数据执行哪些运算；
编译器应当如何解释对应的位模式。

例如，同样一组二进制位，按整数、浮点数或字符解释时，含义可能完全不同。

C 语言的类型可以概括为以下几类：

基本类型：包括字符类型、整数类型、布尔类型和浮点类型。
枚举类型：使用 enum 定义一组具名的整数常量。
派生类型：包括数组类型、指针类型和函数类型。
结构体与共用体类型：分别使用 struct 和 union 组织多个成员。
void 类型：表示“没有值”，常用于无返回值函数和通用对象指针 void *。

C 语言没有“引用类型”这一类别。引用是 C++ 等语言中的概念；C 语言主要通过指针间接访问其他对象。

本章以初学阶段最常用的类型为主。除此之外，C99 还提供复数类型，C11 增加了原子类型相关机制，这些内容通常在数学计算和并发编程中进一步学习。

【二】基础数据类型#

C 语言的基本类型主要包括：

类别	常用类型	用途
字符类型	`char`、`signed char`、`unsigned char`	保存字符编码单元或小整数
整数类型	`short`、`int`、`long`、`long long` 及其无符号形式	保存整数
布尔类型	`_Bool`，以及常用写法 `bool`	表示逻辑真与假
浮点类型	`float`、`double`、`long double`	保存带小数部分或范围较大的近似数值

数据类型的实际大小与取值范围由 C 标准的最低要求、编译器、目标平台和数据模型共同决定，不能简单认为 int 永远为 4 字节、long 永远为 8 字节。

C 标准规定了整数类型的最低精度与相对关系，例如：

1
sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

相邻类型的大小允许相同。sizeof(char) 按定义始终为 1，但 C 语言中的 1 字节不一定等于 8 位；每字节的位数可通过 <limits.h> 中的 CHAR_BIT 查看。现代通用平台通常为 8 位。

可以使用 sizeof 查看当前编译环境中某个类型所占的字节数，并通过以下头文件查询类型范围：

<limits.h>：整数类型的范围和每字节位数；
<float.h>：浮点类型的范围与精度；
<stdint.h>：固定宽度整数类型及相关宏。

【1】浮点类型#

浮点类型用于表示带小数部分或数值范围较大的近似值：

类型	常见大小	常见有效数字	字面量示例
`float`	4 字节	约 6～9 位十进制有效数字	`3.14f`
`double`	8 字节	约 15～17 位十进制有效数字	`3.14`
`long double`	8、12 或 16 字节	不低于 `double`	`3.14L`

表中的大小与精度是现代平台上的常见情况，实际结果仍取决于具体实现。可以使用 sizeof 查看大小，并通过 <float.h> 中的 FLT_DIG、DBL_DIG、LDBL_DIG 等宏查看精度。

浮点数使用有限位数保存数值，很多十进制小数无法被二进制浮点格式精确表示：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    double result = 0.1 + 0.2;
6

7
    printf("%.17f\n", result);
8
    return 0;
9
}

常见输出为 0.30000000000000004。因此，判断浮点计算结果是否相等时，通常需要结合业务允许的误差范围，而不能一律直接使用 ==。

【2】`void` 类型#

void 表示“没有值”或“不指定具体对象类型”，主要有以下用途：

1
void print_message(void);  // 函数没有返回值，并且不接收参数
2
void *data;                // 可以保存任意对象的地址

不能定义 void 类型的普通变量，因为 void 没有可存储的值和确定的对象大小。
void * 是通用对象指针，可以与其他对象指针相互转换。
void * 不包含所指对象的具体类型信息，因此不能直接解引用；使用前需要转换或赋给正确类型的对象指针。

【三】逻辑类型#

C99 引入了 _Bool 类型。包含 <stdbool.h> 后，在 C17 及更早标准中通常可以使用更易读的 bool、true 和 false；C23 已将 bool、true 和 false 纳入语言本身。

1
#include <stdbool.h>
2

3
bool is_ready = true;
4
bool has_error = false;

在条件判断中：

数值 0 表示假；
任何非零值都表示真；
将任意标量值转换为 _Bool 时，0 会转换为 0，非零值会转换为 1。

因此，“非零为真”描述的是条件判断规则，并不表示所有非零值本身都等于整数 1。

例如：

1
int x;
2

3
if (0.5) {
4
    x = 12;
5
} else {
6
    x = 18;
7
}
8

9
// 0.5 是非零值，条件为真，因此 x 最终为 12。

浮点数也可以作为判断条件，但实际程序通常应写出含义更明确的比较表达式，例如 value != 0.0。

【四】整数类型#

C 的标准整数类型包括 char、short、int、long 和 long long，每种标准有符号整数类型（除 plain char 外）都有对应的无符号形式。

1
signed char / unsigned char
2
signed short / unsigned short
3
signed int / unsigned int
4
signed long / unsigned long
5
signed long long / unsigned long long

其中，signed 可以省略，因此 short 等价于 signed short，int 等价于 signed int。但是，char、signed char 和 unsigned char 是三个不同的类型，普通 char 是否带符号由具体实现决定。

下面表格中的字节数和范围是常见 8 位字节、二进制补码环境中的典型结果，并非 C 标准对所有平台的固定要求。编写程序时，可以使用 sizeof 和 <limits.h> 在当前环境中确认。

【1】字符类型（`char`）#

类型名称	常见长度	常见范围	说明
`char`	1 字节	由实现决定	与 `signed char`、`unsigned char` 都是不同类型
`signed char`	1 字节	-128 ～ 127	明确表示有符号小整数
`unsigned char`	1 字节	0 ～ 255	也常用于查看对象的原始字节

给整数类型赋值时，需要注意目标类型能否表示该值：

1
char c1 = 129;
2
unsigned char c2 = -1;

如果当前实现的普通 char 是有符号的，并且无法表示 129，转换结果由实现定义，编译器也可能发出警告；这不一定是编译错误。
转换到无符号整数类型时，数值会按该类型可表示值数量取模。在 8 位 unsigned char 环境中，-1 会转换为 255。

不应依赖超出范围后的隐式转换结果来表达正常业务逻辑。需要明确范围时，应先检查数值，再进行转换。

【2】`short` 类型#

类型名称	常见长度	常见范围
`short`（`signed short`）	2 字节	-32768 ～ 32767
`unsigned short`	2 字节	0 ～ 65535

【3】int 类型#

类型名称	常见长度	常见范围
`int`（`signed int`）	4 字节	-2147483648 ～ 2147483647
`unsigned int`	4 字节	0 ～ 4294967295

【4】long 类型#

long 的大小不能仅根据“32 位或 64 位系统”判断，它还取决于平台采用的数据模型：

常见环境	数据模型	`long` 的常见长度	`signed long` 的常见范围
32 位 Windows / Linux	ILP32	4 字节	-2³¹ ～ 2³¹ - 1
64 位 Windows（包括 MinGW-w64）	LLP64	4 字节	-2³¹ ～ 2³¹ - 1
64 位 Linux / macOS	LP64	8 字节	-2⁶³ ～ 2⁶³ - 1

相应的 unsigned long 范围通常为 0 ～ 2^N - 1，其中 N 是该类型的位数。

【5】`long int` 类型#

long int 不是另一种独立类型，它只是 long 的完整写法；同理，unsigned long int 与 unsigned long 完全等价。

1
long a = 10L;
2
long int b = 10L;                  // 与 long 相同
3
unsigned long c = 10UL;
4
unsigned long int d = 10UL;        // 与 unsigned long 相同

【6】`long long` 类型#

类型名称	常见长度	常见范围
`long long`（`signed long long`）	8 字节	-2⁶³ ～ 2⁶³ - 1
`unsigned long long`	8 字节	0 ～ 2⁶⁴ - 1

long long 从 C99 开始成为标准类型，标准保证它至少能够表示 -9223372036854775807 ～ 9223372036854775807。

【7】注意事项#

有符号整数发生超出可表示范围的算术溢出时，会产生未定义行为。
无符号整数运算按 2^N 取模，其中 N 是该类型的值位数，因此不会发生标准意义上的有符号溢出，但仍可能造成逻辑错误。
float、double 和 long double 没有对应的 unsigned 形式，下面的写法都是语法错误：
```
1
unsigned float value1;
2
unsigned double value2;
3
unsigned long double value3;
```
需要明确位宽时，可以使用 <stdint.h> 中的 int8_t、uint32_t、int64_t 等类型。只有实现能够提供相应宽度时，这些类型才会被定义。

【五】整数进制#

按照进位规则计数的数制称为进位计数制，简称进位制。
C 源代码中的整数字面量可以使用二进制、八进制、十进制和十六进制表示。
进制只影响源代码的书写方式，不会改变整数在程序中的类型和值。例如，10、012 和 0xA 表示的数值都等于十进制的 10。

【1】二进制#

基数为 2 的进位制称为二进制。
二进制只有 0、1 两种数字，计数时逢 2 进 1。
二进制整数字面量以 0b 或 0B 开头，例如 0b1010。

0b 前缀从 C23 开始成为标准语法；在更早的 C 标准模式中，它属于 GCC、Clang 等编译器提供的扩展。使用旧版编译器或严格的 C17 模式时，应先确认是否支持。

1
0b1010 = 1 × 2^3 + 0 × 2^2 + 1 × 2^1 + 0 × 2^0
2
       = 1 × 8   + 0 × 4   + 1 × 2   + 0 × 1
3
       = 10

【2】八进制#

基数为 8 的进位制称为八进制。
八进制包含 0～7 共八种数字，计数时逢 8 进 1。
八进制整数字面量以数字 0 开头。

1
01010 = 1 × 8^3 + 0 × 8^2 + 1 × 8^1 + 0 × 8^0
2
      = 1 × 512 + 0 × 64  + 1 × 8   + 0 × 1
3
      = 520

注意区分普通十进制数和以 0 开头的八进制数。例如，010 表示十进制的 8；08 和 09 不是合法的八进制整数字面量。

【3】十进制#

基数为 10 的进位制称为十进制。
十进制包含 0～9 共十种数字，计数时逢 10 进 1。
十进制整数字面量没有额外前缀。

1
1010 = 1 × 10^3 + 0 × 10^2 + 1 × 10^1 + 0 × 10^0
2
     = 1 × 1000 + 0 × 100  + 1 × 10   + 0 × 1
3
     = 1010

【4】十六进制#

基数为 16 的进位制称为十六进制。
十六进制包含 0～9 和 A～F（不区分大小写）共 16 种数字，计数时逢 16 进 1。
十六进制整数字面量以 0x 或 0X 开头。

1
0x1010 = 1 × 16^3 + 0 × 16^2 + 1 × 16^1 + 0 × 16^0
2
       = 1 × 4096 + 0 × 256  + 1 × 16   + 0 × 1
3
       = 4112

上述公式中的 ^ 仅用于表示数学上的乘方。在 C 表达式中，^ 是按位异或运算符，并不表示乘方。

整数的进制与输出格式可以不同。printf 常用的无符号整数格式说明符如下：

格式说明符	输出形式
`%u`	无符号十进制
`%o`	无符号八进制
`%x`	无符号十六进制（小写）
`%X`	无符号十六进制（大写）

printf 没有标准的二进制格式说明符。如果需要输出二进制，通常需要自行逐位处理。

【5】练习#

（1）进制表示#

要求：分别使用二进制、八进制、十进制和十六进制字面量表示整数，并统一使用十进制输出。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 0b1010;  // 二进制字面量（C23，旧版 GCC 也支持此扩展）
6
    int b = 01010;   // 八进制字面量
7
    int c = 1010;    // 十进制字面量
8
    int d = 0x1010;  // 十六进制字面量
9

10
    printf("a = %d\n", a);  // 以十进制输出
11
    printf("b = %d\n", b);  // 以十进制输出
12
    printf("c = %d\n", c);  // 以十进制输出
13
    printf("d = %d\n", d);  // 以十进制输出
14

15
    return 0;
16
}

展开收起

运行结果

（2）数据类型#

使用 sizeof 运算符查看当前编译环境中常用数据类型占用的字节数。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    printf("sizeof(char)               = %zu\n", sizeof(char));
6
    printf("sizeof(unsigned char)      = %zu\n", sizeof(unsigned char));
7
    printf("sizeof(short)              = %zu\n", sizeof(short));
8
    printf("sizeof(unsigned short)     = %zu\n", sizeof(unsigned short));
9
    printf("sizeof(int)                = %zu\n", sizeof(int));
10
    printf("sizeof(unsigned int)       = %zu\n", sizeof(unsigned int));
11
    printf("sizeof(long)               = %zu\n", sizeof(long));
12
    printf("sizeof(unsigned long)      = %zu\n", sizeof(unsigned long));
13
    printf("sizeof(long int)           = %zu\n", sizeof(long int));
14
    printf("sizeof(unsigned long int)  = %zu\n", sizeof(unsigned long int));
15
    printf("sizeof(long long)          = %zu\n", sizeof(long long));
16
    printf("sizeof(unsigned long long) = %zu\n", sizeof(unsigned long long));
17
    printf("sizeof(float)              = %zu\n", sizeof(float));
18
    printf("sizeof(double)             = %zu\n", sizeof(double));
19
    printf("sizeof(long double)        = %zu\n", sizeof(long double));
20

21
    return 0;
22
}

展开收起

sizeof 表达式的结果类型是 size_t，使用 printf 输出时应匹配 %zu，不能使用 %d。

运行结果

以下结果用于展示平台差异，不代表所有编译环境都完全相同。

1
# Windows 10/11，x86_64 MinGW-w64 GCC 13.2.0
2
sizeof(char)                  = 1
3
sizeof(unsigned char)         = 1
4
sizeof(short)                 = 2
5
sizeof(unsigned short)        = 2
6
sizeof(int)                   = 4
7
sizeof(unsigned int)          = 4
8
sizeof(long)                  = 4
9
sizeof(unsigned long)         = 4
10
sizeof(long int)              = 4
11
sizeof(unsigned long int)     = 4
12
sizeof(long long)             = 8
13
sizeof(unsigned long long)    = 8
14
sizeof(float)                 = 4
15
sizeof(double)                = 8
16
sizeof(long double)           = 16
17

18
# Ubuntu 18.04，x86_64 GCC 的一种典型结果
19
sizeof(char)                  = 1
20
sizeof(unsigned char)         = 1
21
sizeof(short)                 = 2
22
sizeof(unsigned short)        = 2
23
sizeof(int)                   = 4
24
sizeof(unsigned int)          = 4
25
sizeof(long)                  = 8
26
sizeof(unsigned long)         = 8
27
sizeof(long int)              = 8
28
sizeof(unsigned long int)     = 8
29
sizeof(long long)             = 8
30
sizeof(unsigned long long)    = 8
31
sizeof(float)                 = 4
32
sizeof(double)                = 8
33
sizeof(long double)           = 16

展开收起

【六】ASCII 码#

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是一种早期且广泛使用的字符编码标准。

ASCII 使用 7 位编码，共定义 128 个码位，范围为十进制 0～127（十六进制 0x00～0x7F）。其中包含英文字母、十进制数字、常用符号和控制字符。

ASCII 的核心作用是建立字符与整数编码值之间的映射。例如，在 ASCII 中，字符 'A' 对应十进制值 65，字符 '0' 对应十进制值 48。

在 C 语言中，char 属于整数类型，因此字符可以参与整数运算，也可以分别按字符形式或整数形式输出：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    char ch = 'A';
6

7
    printf("字符：%c\n", ch);
8
    printf("编码值：%d\n", (int)(unsigned char)ch);
9
    return 0;
10
}

在 ASCII 环境中，程序会输出字符 A 及其编码值 65。

C 语言标准并不强制执行字符集必须采用 ASCII，但 Windows、Linux 和 macOS 等现代通用环境通常兼容 ASCII 的前 128 个码位。ASCII 之外的中文等字符需要结合 UTF-8、GBK 等字符编码理解，不能简单当作单个 char 处理。

ASCII 可以划分为：

0x00～0x1F：32 个控制字符；
0x20～0x7E：95 个可打印字符；
0x7F：删除控制字符 DEL。

image-20260922215505519

【1】不可打印字符#

不可打印字符通常不直接显示图形，而是用于控制文本、终端或通信过程。常见示例如下：

ASCII 值	转义写法	名称	说明
0	`\0`	NUL（空字符）	C 字符串的结束标志
8	`\b`	BS（退格）	对应退格控制功能
9	`\t`	HT（水平制表）	移动到下一个水平制表位置
10	`\n`	LF（换行）	Unix/Linux 文本中的换行字符
13	`\r`	CR（回车）	将位置移至当前行开头；Windows 文本换行通常使用 `\r\n`
127	无常用转义写法	DEL（删除）	删除控制字符

键盘上的 Enter 键会由终端或操作系统转换成相应的输入序列，并不能在所有环境下简单等同于单个 ASCII 10。

【2】可打印字符#

ASCII 值	字符	描述
32	空格	空格字符 `' '`
39	`'`	单引号；在字符常量中写作 `'\''`
47	`/`	正斜杠
48	`0`	数字字符 `'0'`，不要与编码值为 0 的 `\0` 混淆
65	`A`	大写英文字母 A
92	`\`	反斜杠；在 C 字符常量中写作 `'\\'`
96	`	反引号
97	`a`	小写英文字母 a
124	`\|`	竖线

ASCII 中的数字字符和英文字母各自连续排列，因此可以进行一些简单换算：

1
int digit = '7' - '0';       // 得到整数 7
2
char lower = 'A' + 32;       // ASCII 中得到字符 'a'

其中，C 标准保证 '0'～'9' 连续，因此第一种数字转换写法具有可移植性；'A' + 32 依赖 ASCII 的字母排列方式。更通用的大小写转换应使用 <ctype.h> 中的 tolower 和 toupper：

1
#include <ctype.h>
2

3
char lower = (char)tolower((unsigned char)'A');
4
char upper = (char)toupper((unsigned char)'a');

为了在 Markdown 表格中显示竖线字符，表格中的 | 写作 \|。这只是 Markdown 转义，不属于字符本身。

C 语言语法符号

Sat, 26 Sep 2026 00:00:00 GMT

【一】语法符号的理解#

每种编程语言都有自己的词汇和语法规则。编译器不会把源代码直接当作一整段文字理解，而是先进行词法分析，将代码识别成一个个具有语法意义的最小单元，这些单元通常称为 Token（记号或词法单元）。

例如：

1
int sum = a + 10;

可以识别为：

1
int    sum    =    a    +    10    ;
2
关键字 标识符  运算符 标识符 运算符 常量  标点符号

按照本系列笔记便于理解的分类方式，可以将常见语法符号分为：

关键字：由语言标准赋予固定含义的单词；
标识符：由程序员命名的变量、函数、类型等名称；
运算符：表示计算、比较、赋值或其他操作的符号；
分隔符：用于分隔词法单元的空白字符和注释；
标点符号：用于组织声明、表达式、语句和代码块的符号。

此外，源代码中还有常量和字符串字面量。它们属于 C 语言 Token 的重要组成部分，将在“常量”章节单独讲解。

从 C 标准的词法分类来看，许多“运算符”和“标点符号”会统一归入 punctuator（标点符号/界符）。本章将它们分开说明，是为了便于初学者按用途理解。

【二】关键字#

关键字是由 C 语言标准预先规定并赋予特殊语法含义的单词，不能用作变量名、函数名或其他标识符。

【1】C90 的 32 个关键字#

C90 规定了 32 个经典关键字：

1
auto       break      case       char       const
2
continue   default    do         double     else
3
enum       extern     float      for        goto
4
if         int        long       register   return
5
short      signed     sizeof     static     struct
6
switch     typedef    union      unsigned   void
7
volatile   while

关键字区分大小写。例如，int 是关键字，而 Int 不是关键字；但不应通过改变大小写来创建含义相近的名称。

【2】后续标准新增的关键字#

C 语言会随标准更新而扩展，因此“C 语言只有 32 个关键字”只适用于 C90。常见新增关键字如下：

（1）C99 新增#

1
inline      restrict      _Bool      _Complex      _Imaginary

inline：建议以内联方式处理函数；
restrict：表达指针访问对象的别名约束；
_Bool：布尔类型；
_Complex、_Imaginary：复数和虚数类型相关关键字，其中虚数类型属于实现可选功能。

（2）C11 新增#

1
_Alignas        _Alignof        _Atomic         _Generic
2
_Noreturn       _Static_assert  _Thread_local

这些关键字主要用于对齐控制、原子操作、泛型选择、静态断言和线程存储期等功能。

（3）C23 常用新增关键字#

1
alignas          alignof          bool             constexpr
2
false            nullptr         static_assert    thread_local
3
true             typeof          typeof_unqual    _BitInt

C23 较新，不同编译器对这些关键字的支持程度可能不同。学习或使用 C23 功能时，应确认编译器版本和所选择的语言标准模式。

【3】容易误认为关键字的名称#

以下名称虽然经常出现在 C 程序中，但它们并不是 C 语言关键字：

名称	实际性质
`main`	程序入口函数的约定名称
`printf`、`scanf`	标准库函数名
`NULL`	标准头文件提供的宏
`size_t`	标准库定义的类型名
`include`、`define`	预处理指令中的名称

它们分别受到标准库或预处理规则约束，不能简单按普通关键字理解。

【三】标识符#

标识符是程序中名称的词法形式，可用于命名宏、变量、函数、形参、结构体成员、自定义类型等程序实体。

C 语言标识符的基本命名规则如下：

基础且可移植的标识符由英文字母 A-Z、a-z、数字 0-9 和下划线 _ 组成。
第一个字符必须是字母或下划线，不能是数字。
标识符不能与 C 语言关键字相同。
C 语言区分大小写，因此 sum、Sum 和 SUM 是三个不同的标识符。
标识符中不能包含空格、连字符 -、点号 .、@ 等字符。

新版 C 标准也支持一定范围的通用字符名称及扩展字符，但其可用性还受源文件编码和编译器支持影响。基础学习及追求可移植性时，优先使用英文字母、数字和下划线。

【1】合法与非法标识符#

下面是一些合法的标识符：

1
x    y    sum    a100    student_name    score2

以下标识符不合法：

名称	原因
`1a`	以数字开头
`3'a`	以数字开头，并且包含单引号
`x*y`	包含运算符 `*`
`@`	`@` 不能构成基础标识符
`b.8`	包含点号 `.`
`my-name`	包含连字符 `-`
`my name`	包含空格，会被识别为两个词法单元
`while`	与关键字相同

【2】命名建议#

名称应表达用途，例如用 student_count 表示学生数量，而不是随意使用 a1。
可以采用下划线命名法 student_count 或小驼峰命名法 studentCount，同一项目中应保持一致。
常量宏通常使用全大写字母和下划线，例如 MAX_SIZE。
不要只通过大小写区分含义相近的变量，例如同时定义 data、Data 和 DATA，这会降低可读性。
简短的局部循环变量可以使用 i、j 等惯用名称，但作用范围较大的名称应更具体。

【3】保留标识符#

某些形式的标识符保留给编译器、标准库或具体实现使用。编写用户代码时，应遵循以下安全规则：

不要定义以双下划线开头的名称，如 __value；
不要定义以下划线加大写字母开头的名称，如 _Value；
在文件作用域中，避免定义任何以下划线开头的名称；
不要重用标准库中已有的函数名、宏名和类型名来表达其他含义。

例如，_A7b_3x 从字符组成规则看是合法形式，但它以下划线和大写字母开头，属于实现保留标识符，不应在用户代码中使用。

【四】运算符#

运算符用于表示计算、比较、赋值、成员访问等操作。一个运算符需要几个操作数，就称为几元运算符。例如，-a 中的 - 是一元运算符，a - b 中的 - 是二元运算符，condition ? a : b 是三元条件运算符。

按照功能，常用运算符可以概括为：

类别	常见运算符	作用概述
算术运算符	`+`、`-`、`*`、`/`、`%`	执行基本算术运算
关系运算符	`<`、`<=`、`>`、`>=`、`==`、`!=`	比较两个值
逻辑运算符	`&&`、`
位运算符	`&`、`	`、`^`、`~`、`<<`、`>>`
赋值运算符	`=`、`+=`、`-=`、`*=`、`/=` 等	为对象赋值或执行复合赋值
自增、自减运算符	`++`、`--`	将操作数增加或减少 1
条件运算符	`?:`	根据条件从两个表达式中选择一个
指针相关运算符	`&`、`*`	获取对象地址或间接访问所指对象
成员访问运算符	`.`、`->`	访问结构体或共用体成员
其他运算符	`sizeof`、类型转换、下标 `[]`、函数调用 `()`、逗号 `,`	完成类型大小查询等操作

同一个符号在不同上下文中可能具有不同含义。例如，* 既可以表示乘法，也可以用于声明指针或解引用指针；& 既可以表示按位与，也可以表示取地址。

运算符还涉及优先级、结合性和求值规则。为了让表达式含义更清楚，不确定时应主动使用圆括号，而不是仅依赖记忆优先级。具体规则将在后续运算符章节中展开。

【五】分隔符#

分隔符用于划分相邻的词法单元。常见分隔内容包括：

空格（space）；
水平制表符（tab）；
换行符（newline）；
其他空白字符，例如垂直制表和换页；
注释 // ... 和 /* ... */。

在预处理阶段，注释会被替换为空白，因此注释也能起到分隔词法单元的作用。字符串或字符常量内部的 //、/* 并不会开始注释：

1
const char *url = "https://example.com";  // 字符串中的 // 是普通字符
2
char slash = '/';                         // 字符常量中的 / 是普通字符

空白字符有时可以省略，有时则必不可少：

1
int count;     // int 和 count 之间必须分隔
2
int intcount;  // intcount 是一个完整的标识符，不等同于 int count
3

4
total=a+b;     // 编译器能够识别，但不利于阅读
5
total = a + b; // 含义相同，格式更清晰

还应注意：

// 注释持续到当前行末尾；
/* ... */ 块注释可以跨行，但不能嵌套；
换行通常只是空白，但它会结束 // 注释和预处理指令；
不能用空白拆开一个完整的多字符运算符，例如 >=、==、++。

合理使用空格、缩进和换行不会改变大多数代码的含义，却能显著提升可读性并帮助排查语法错误。

【六】标点符号#

C 语言中常见的标点符号包括逗号、分号、冒号、圆括号、方括号、花括号、点号和箭头等。它们用于组织声明、表达式、语句、函数、数组和代码块。

符号	常见用途
`,`	分隔声明项、函数参数和初始化器；在特定上下文中也可作为逗号运算符
`;`	结束声明或表达式语句；单独的 `;` 表示空语句
`:`	用于 `case`、`default`、标签以及条件运算符 `?:`
`( )`	函数声明与调用、条件、表达式分组和类型转换
`[ ]`	数组声明、数组下标和属性语法等
`{ }`	构成复合语句、函数体或初始化器
`.`	通过对象访问结构体或共用体成员
`->`	通过指针访问结构体或共用体成员
`#`、`##`	预处理指令及宏中的字符串化、记号拼接
`...`	可变参数函数或其他标准规定的省略形式

标点符号与空白分隔符不同：它们具有严格的语法作用，不能随意省略。部分符号在特定上下文中也属于运算符，例如逗号、圆括号、方括号、点号和箭头。

下面的程序集中演示了常见标点符号的用法：

1
#include <stdio.h>
2

3
int add(int x, int y)
4
{
5
    return x + y;
6
}
7

8
int main(void)
9
{
10
    int values[2] = {3, 4};
11
    int result = add(values[0], values[1]);
12

13
    switch (result) {
14
        case 7:
15
            printf("result = %d\n", result);
16
            break;
17
        default:
18
            printf("unexpected result\n");
19
            break;
20
    }
21

22
    return 0;
23
}

展开收起

在这个示例中：

逗号分隔函数形参、实参和数组初始化元素；
分号结束声明、函数调用和 return、break 语句；
圆括号用于函数声明、函数调用和 switch 条件；
方括号用于数组声明及下标访问；
花括号构成初始化器、函数体和 switch 语句体；
冒号跟在 case 和 default 标签之后。

C 语言常量

Sat, 26 Sep 2026 00:00:00 GMT

【一】常量的理解#

常量是指在程序运行期间其数值不发生变化的数据。

常量包括以下几种：

整型常量
浮点常量
字符常量
字符串常量
标识常量

【二】整型常量#

整型常量通常简称为整数。

整数可以是十进制数、八进制数和十六进制数。

例如，十进制的数值3356可以有下列三种不同的表示形式：

二进制数 0b1101 0001 1100
十进制数 3356
八进制数 06434
十六进制数 0xd1c

【三】浮点常量#

浮点常量又称为实数，一般含有小数部分。

C语言中，实数只有十进制的实数，它又分为单精度实数和双精度实数，它们的表示方法基本相同。

实数有两种表示方法，即一般形式和指数形式。

一般形式的基本形式如下： [ + | - ] M.N

例如：3.5，-12.5，3.1415926

指数形式的实数一般是由尾数部分、字母e或E和指数部分组成。当一个实数的符号为正号时，可以省略不写。

表示形式如下：

1
[+|-]M.N<e|E>[+|-]T

例如：

1
1.176e+10      表示   1.176x10^10
2
-3.5789e-8     表示  -3.5789x10^-8

通常表示特别大或特别小的数。

【五】字符常量#

字符常量是指一个单一字符，其表示形式是由两个单引号包括的一个字符。

例如：

1
'A', 'a', 'Q', '0', '9', '+', ':', '?', ' ', '$'

都是字符常量。

在C语言中，字符常量具有数值。字符常量的值就是该字符的ASCII码值。

因此，可以这样说字符常量实际上是一字节的正整数。

练习-字符常量#

计算并输出下面字符的结果

1
char  a, b, u, v ;      // 说明a、b、u和v为字符变量
2
a = 'F' ;               // 将70送给a
3
b = 'A'+2;              // b存放的是 'c' 字符
4
u = ' ' + 'B';          // u存放的是 'b' 字符
5
v= 'b' - 32;            // v存放的是 'B' 字符

等价运算

1
#include <stdio.h>
2

3
int main() {
4
    char a, b, u, v; // 说明 : a b u v 是字符变量
5
    a = 'F'; // 将 70 赋值给 a
6
    b = 'A' + 2; // b 存放的是 'C' 的字符
7
    u = ' ' + 'B'; // u 存放是的是 'b' 的字符
8
    v = 'b' - 32; // v 存放的是 'B' 的字符
9

10
    printf("a=%d\n", a); // 70
11
    printf("b=%d\n", b); // 65 + 2 = 67
12
    printf("u=%d\n", u); // 66 + 32 = 98
13
    printf("v=%d\n", v); // 98 - 32 = 66
14
}

1
a= 70;
2
b= 65+2;
3
u= 32+66 ;
4
v= 97-32;

【六】字符串常量#

字符串常量是指用双引号括起来的一串字符来表示的数据。

下面给出几个字符串常量的例子：

1
"Helloworld!",   "Student",   "9",   "LINUX",  "李四"
2
"北京海淀成府路***号",   "姓名：",   "******@qq.com"
3
"what matters is what you do, not what you think"
4
"行动比空想更重要。"

【七】标识常量#

标识常量是指用标识符代替常量使用的一种常量，其名称通常是一个标识符，别名宏。

标识常量也叫符号常量，为了不与一般变量的名称相混淆，标识常量的名称一般使用大写英文字母的标识符。

标识常量在使用之前必须预先定义。

标识常量的一般说明形式为：

1
#define <标识常量名称> <常量>

例如：

1
#define MAX 50
2
#define PI 3.1415926
3
#define NULL 0
4
#define EOF -1
5
#define ERROR -1

其中，MAX、PI、NULL、EOF和ERROR都是标识常量，它们代替的常量分别是50、3.1415926、0、-1和-1。

这里，每个标识常量说明式子只能给出一个标识常量，并且占据一个书写行。

以下是图片内容的 Markdown 格式转换：

练习-水分子数#

一个水分子的质量约为3.0*10^-23g，1夸脱水大约有950g，编写程序，要求输入水的夸脱数，然后显示这么多水中包含多少水分子。

代码实现:

1
#include <stdio.h>
2
#include <windows.h>  // 引入 windows 头文件，用于设置控制台编码
3

4
// 定义一个水分子的质量（单位：克）
5
#define WATER_MOLECULES 3.0e-23
6

7
int main() {
8
    // 强制控制台输出使用 UTF-8 编码，确保中文显示正常
9
    SetConsoleOutputCP(65001);
10

11
    // 提示用户输入水的夸脱数
12
    printf("请输入水的夸脱数：");
13

14
    // 声明变量用于存储用户输入的夸脱数
15
    int num;
16

17
    // 读取用户输入的整数（夸脱数）
18
    scanf("%d", &num);
19

20
    // 显示用户输入的夸脱数
21
    printf("水的夸脱数为:%d\n", num);
22

23
    /* 计算水分子数量的公式说明：
24
     * 1. 首先计算总质量：夸脱数 × 950（每夸脱的质量）
25
     * 2. 然后除以一个水分子的质量（3.0e-23克）
26
     * 3. 得到的就是总的水分子数量
27
     */
28
    printf("%d 夸脱中 包含 %e 个水分子\n", num, num * 950 / WATER_MOLECULES);
29
}

展开收起

运行结果

1
请输入水的夸脱数 >:10
2
num=10
3
10 夸脱的水中有 3.166667e+026 个水分子

练习-求圆面积#

输入圆的半径计算圆的面积和周长

C 语言变量与存储类型

Sat, 26 Sep 2026 00:00:00 GMT

【一】变量的理解#

定义：变量是指在程序运行期间其数值可以发生变化的数据。
表示方式：变量在程序中用变量名表示，变量名由用户根据其用途任意命名。
命名规则：变量名命名遵从标识符的起名规则。
- 只能由字母、数字、下划线组成。
- 开头不能是数字。
- 不能和系统的关键字重名。
内存概念：在程序运行时，变量占据一定大小的存储空间，其大小由其数据类型来决定，作为某变量的内存空间的首地址，称为变量的地址。

【二】变量的定义#

使用前提：变量在程序中使用时，必须预先说明它们的存储类型和数据类型。
一般形式： <存储类型> <数据类型> <变量名>;
- <存储类型>：可以是关键词 auto、register、static 和 extern 之一。
- <数据类型>：可以是前面讲的基本数据类型，也可以是后面要讲的自定义的数据类型。
- <变量名>：是一个合法的标识符，其前面的32字符有效。
注意事项：在上述变量说明的式子中，<变量名> 之后有一个分号 ;，意味着它是一个语句，该语句通常称为变量的说明语句。
常见基本数据类型： char, short, int, long, long int, long long, float, double, long double。

这张图片是上一份笔记的延续，接着讲解了C语言中变量的另外三种存储类型：auto、register 和 extern。

为了方便你阅读和复习，我同样将图片内容整理成了结构化的笔记：

【三】auto存储类型#

作用域：用 auto 存储类型说明的变量都是局部于某个程序范围内的，只能在某个程序范围内使用，通常在函数体内或函数中的复合语句里。
语法特点：C语言中，在函数体的某程序段内说明 auto 存储类型的变量时可以省略关键字 auto。

代码示例：

1
auto int k ;   //说明一个auto整型的k变量
2
int j ;        //省略了auto，说明一个auto整型的j变量
3
double x;      //省略了auto，说明一个auto双精度型的变量

【四】register存储类型#

定义：register 称为寄存器型。
目的：使用 register 关键字说明的变量主要目的是想将所说明的变量放入CPU的寄存器存储空间中，这样可以加快程序的运行速度。
机制：如申请不到就使用一般内存，同 auto。
使用频率：register 在程序中使用较少（现代编译器优化已经很强大，通常不需要手动指定）。

代码示例：

1
register int count;     // 定义一个存储类型为register的整型变量;
2
register float number;  // 定义一个存储类型为register的浮点变量;

【五】extern存储类型#

定义：extern 称为外部参照引用型。
目的：使用 extern 说明的变量是想引用在其它文件中函数体外部定义的变量。
作用域：当变量在一个文件中的函数体外定义，所有其他文件中的函数或程序段都可引用这个变量。
用途：一般用于在文件之间传递数据。

这是关于变量基础知识的最后一部分内容，主要讲解了 static（静态）存储类型以及变量的初始化。

基于你上传的图片，我继续为你整理成结构化笔记，并补充了一些初学者容易混淆的关键知识点，希望能帮到你：

【六】static存储类型#

static 为静态存储类型，既可以在函数体内定义，也可以在函数体外定义 static 类型的变量。

在函数体内定义（静态局部变量）：
- 在内存中以固定地址存放。
- 程序运行时会保持其值。它下次再调用该函数，该变量不再重新定义，还保留上次存入的数值。
- 💡 补充提示：静态局部变量只初始化一次。即使函数结束，它的内存也不会被回收，下一次调用函数时，它会保留上一次运行结束时的值。
在函数体外定义（静态全局变量）：
- 主要作用是限定变量的作用域，限定文件的作用域在本文件内。
- 💡 补充提示：普通全局变量可以通过 extern 跨文件引用，但 static 全局变量只能在当前源文件内使用（内部链接），其他文件即使写了 extern 也无法访问，这有助于避免不同文件间的变量命名冲突。

【七】变量的初始化#

一般形式： <存储类型> <数据类型> <变量> = <表达式> ;

概念：变量的初始化是指变量在被定义的同时赋给一个初值。

1
int i=0;
2
static double w=100.56;
3
double result = 1;
4
double x = 5, y = x*2 ;  // 定义x并赋值为5，定义y并赋值为x*2 (10)
5
register int count = 0 ;
6
auto double s = 0 ;

这是关于变量基础知识的最后一小部分内容，主要讲解了 常变量（const） 以及它与 符号常量（#define） 的核心区别。这也是C语言中非常经典的考点。

按照惯例，我为你整理了结构化的笔记，并补充了详细的对比表格：

【八】常变量#

概念：C99标准允许使用常变量，方法是在定义变量时，前面加一个关键字 const。
特点：在程序运行期间其值不能改变。

代码示例：

1
const int a3 = 3;   // 定义一个整型变量，指定其值为3，在程序运行期间其值不能改变。

常变量与符号常量的区别（核心重点）#

图片中给出了 #define 和 const 的对比示例：

1
#define Pi 3.1415926           // 定义符号常量
2
const float Pi = 3.1415926     // 定义常变量

虽然两者在程序中都能代表 3.1415926，但在底层机制上有本质区别：

对比维度	符号常量 (`#define Pi 3.14...`)	常变量 (`const float Pi = 3.14...`)
本质	预编译指令（宏定义）	变量（带只读属性）
处理阶段	预编译阶段	编译和运行阶段
工作机制	简单的字符替换（全置换）	分配内存，存入数值
存储单元	不分配存储单元（预编译后名字就消失了）	要占用存储单元
类型检查	无类型，仅仅是文本替换	有明确数据类型，编译器会进行安全检查
生命周期	预编译后就不存在了	存在于程序的运行期间

💡 通俗理解：#define 就像是Word文档里的“查找替换”，在真正编译前，代码里所有的 Pi 都被换成了数字；而 const 是真正在内存里划了一小块地（存储单元），放进了数字，只不过这块地是“只读”的，不允许被修改。

C 语言强制类型转换

Sat, 26 Sep 2026 00:00:00 GMT

【一】强制类型转换理解#

目的：C语言的强制类型转换用于将一个数据类型转换为另一个数据类型，目的是为了让程序在编译和运行时能够正确地执行。
转换方式：分为两种：
- 显式的数据类型转换
- 隐式的数据类型转换

【二】显式的数据类型转换#

一般形式：(数据类型名称) <表达式>
代码示例解析：
```
1
int a=2, b=0 ;
2
float c = 4.8, d= 3.3;
3
b = (int) (a + c +d) ;   // b存入右边表达式的计算 结果为10
```
- 计算过程：a + c + d 的结果是 2 + 4.8 + 3.3 = 10.1（此时是浮点型 float）。
- 通过 (int) 强制转换，10.1 被转换为整型 10，最后赋值给整型变量 b。

【三】隐式的数据类型转换#

定义：类型转换可以是隐式的，由编译器自动执行。
代码示例解析：
```
1
int a=2, b=0 ;
2
float c = 4.8, d= 3.3;
3
b = a + c + d ;   // b存入右边表达式的计算 结果为10
```
- 计算过程：a + c + d 的结果依然是浮点型 10.1。
- 但在赋值给整型变量 b 时，编译器会自动将 10.1（float）隐式转换为 10（int），然后存入 b。

这是关于C语言数据类型转换的进阶内容，主要讲解了整数提升（Integer Promotion）和常用算术转换的底层规则。这也是理解C语言表达式求值顺序和类型的核心。

结合你之前的学习脉络，我为你整理成结构化笔记，并补全了图片中未展示完整的部分：

【四】整数提升#

概念：整数提升是指把小于 int 或 unsigned int 的整数类型（如 char、short、bool、位域等）转换为 int 或 unsigned int 的过程。
常用算术转换：是隐式地把值强制转换为相同的类型。编译器在处理算术运算时，遵循以下两步：
1. 首先执行整数提升（把小的整型提升为 int 或 unsigned int）。
2. 如果操作数类型不同，则它们会被转换为下列层次中出现的最高层次的类型。

C语言标准规定的算术转换层次（从低到高）依次为： int -> unsigned int -> long -> unsigned long -> long long -> unsigned long long -> float -> double -> long double

C 语言算术运算符

Sat, 26 Sep 2026 00:00:00 GMT

【一】表达式#

定义：所谓表达式是指由运算符、运算量和标点符号组成的有效序列，是用来说明一个计算过程。
表达式语句：表达式可以独立形成语句，该语句称为表达式语句。
一般形式： <表达式> ; （注意末尾必须有分号）

【二】算术运算符#

运算符	功能说明	举例
`+`	加，一目取正（一元正号）	`a+b`, `+a`
`-`	减，一目取负（一元负号）	`a-b`, `-a`
`*`	乘法	`a*b`
`/`	除法	`a/b`
`%`	取模或求余	`a%b`
`++`	增1（自增）	`a++`, `++b`
`--`	减1（自减） (被UI遮挡)	`a--`, `--b`

这张图片紧接着上一节的算术运算符，专门针对最容易出错的除法运算符 / 和取模运算符 % 进行了详细区分。这是C语言初学者最容易踩坑的地方，也是考试必考的核心点。

按照惯例，我为你整理了结构化笔记，并补充了极其重要的实战避坑指南：

【三】整数除法和实数除法#

C语言的除法运算符分为整数除法和实数除法。

【1】整数除法#

求整 /：得到两个整数相除的整数部分。
求余 %：得到两个整数相除的余数部分。
举例：
- 1/2 的结果为 0 （小数部分被直接丢弃）
- 1%2 的结果为 1 （1除以2，商0余1）

【2】实数除法#

除法 /：得到两个实数相除的结果为一个实数。
举例：
- 1.0/2 的结果为 0.5

这张图片是一个具体的实战练习题（练习9），通过实际代码运行来验证上一节关于整数除法和实数除法的理论知识。

按照惯例，我为你整理了结构化笔记，并针对代码中的细节和考点进行深度解析：

【四】练习#

【1】除法运算符#

题目：计算 1/2、1.0/2、1%2 的结果分别是多少？

源代码：

1
#include <stdio.h>
2

3
int main(int argc, char const *argv[])
4
{
5
    printf("1/2 =%d\n",1/2);
6
    printf("1.0/2=%f\n",1.0/2);
7
    printf("1%%2 =%d\n",1%2);
8
    return 0;
9
}

运行结果：
```
1
1/2=0
2
1%2=1
3
1.0/2=0.500000
```

这张图片详细讲解了C语言中极其重要且容易出错的自增（++）与自减（--）运算符。图片通过定义和七行代码示例，精准地展示了“前缀（先算后用）”和“后缀（先用后算）”的区别。

按照惯例，我为你整理了结构化笔记，并对代码示例进行了深度拆解，最后补充了考试必考的避坑指南：

【2】自增自减运算符#

（1）自增运算符#

i++：表示 i 的值先参与运算，最后再自增1（后缀）。
++i：表示 i 的值先自增1，之后再参与运算（前缀）。

（2）自减运算符#

i--：表示 i 的值先参与运算，最后再自减1（后缀）。
--i：表示 i 的值先自减1，之后再参与运算（前缀）。

假设每一行代码都从头执行，即初始值始终是 x=5, y=9。如果连续执行而不重置变量，结果会不同。

我们按照图片给出的初始值 x=5, y=9，逐行拆解：

z = ++x;
- 前缀：x先加1变成6，然后把6赋给z。
- 结果：z=6，x=6
z = x++;
- 后缀：先把x当前值5赋给z，然后x再加1变成6。
- 结果：z=5，x=6
z = --x;
- 前缀：x先减1变成4，然后把4赋给z。
- 结果：z=4，x=4
z = x--;
- 后缀：先把x当前值5赋给z，然后x再减1变成4。
- 结果：z=5，x=4
z = ++x+y++;
- 前缀+后缀混合：++x使x变成6（取6参与运算），y++取y当前值9参与运算（然后y变成10）。z = 6 + 9 = 15。
- 结果：z=15，x=6，y=10
z = --x+y++;
- --x使x变成4（取4参与运算），y++取y当前值9参与运算（然后y变成10）。z = 4 + 9 = 13。
- 结果：z=13，x=4，y=10
z = ++x+y--;
- ++x使x变成6（取6参与运算），y--取y当前值9参与运算（然后y变成8）。z = 6 + 9 = 15。
- 结果：z=15，x=6，y=8

【3】算术运算符#

源代码（基于输出结果还原，利用重置变量来独立验证每一行的逻辑）：

1
#include <stdio.h>
2

3
int main() {
4
    int x, y, z;
5

6
    // 第一行
7
    x = 5; y = 9; z = ++x;      // 前缀：x先加1变6，z=6
8
    printf("z=%d, x=%d\n", z, x);
9

10
    // 第二行
11
    x = 5; y = 9; z = x++;      // 后缀：z=5，x再加1变6
12
    printf("z=%d, x=%d\n", z, x);
13

14
    // 第三行
15
    x = 5; y = 9; z = --x;      // 前缀：x先减1变4，z=4
16
    printf("z=%d, x=%d\n", z, x);
17

18
    // 第四行
19
    x = 5; y = 9; z = x--;      // 后缀：z=5，x再减1变4
20
    printf("z=%d, x=%d\n", z, x);
21

22
    // 第五行
23
    x = 5; y = 9; z = ++x + y++; // ++x为6，y++取9，z=15；运算后x=6, y=10
24
    printf("z=%d, x=%d, y=%d\n", z, x, y);
25

26
    // 第六行
27
    x = 5; y = 9; z = --x + y++; // --x为4，y++取9，z=13；运算后x=4, y=10
28
    printf("z=%d, x=%d, y=%d\n", z, x, y);
29

30
    // 第七行
31
    x = 5; y = 9; z = ++x + y--; // ++x为6，y--取9，z=15；运算后x=6, y=8
32
    printf("z=%d, x=%d, y=%d\n", z, x, y);
33

34
    return 0;
35
}

展开收起

C 语言关系与逻辑运算符

Sat, 26 Sep 2026 00:00:00 GMT

【一】关系运算符#

运算符	功能说明	举例
`>`	大于	`a > b`
`>=`	大于等于	`a >= 5`
`<`	小于	`3 < x`
`<=`	小于等于	`x <= y + 1`
`==`	等于	`x + 1 == 0`
`!=`	不等于	`c != '\0'`

真为1，假为0，非零为真，0为假

1
int a=5, b=6;
2
a>(b-1)        // 结果值为0
3
(a +1)== b     // 结果值为1
4
a>=(b-2)       // 结果值为1
5
a<100          // 结果值为1
6
(a+3)<=b       // 结果值为0
7
a != (b-1)     // 结果值为0

【二】逻辑运算符#

运算符	功能说明	举例
`!`	逻辑反（非）	`!(x == 0)`
`&&`	逻辑与	`x > 0 && x < 100`
`		`

【三】逻辑非运算符#

逻辑非 ! 运算符的运算律如下（一元运算符）：

运算量	结果
1	0
0	1

结合我们上一节学的“非零为真，0为假”，可以推导出：!非0 = 0；!0 = 1。

1
int k=8;
2
! (k ==0)      // 结果值为1
3
! ((k-8) == 0) // 结果值为0
4
! (k<= 0)      // 结果值为1

【四】逻辑与运算符 (`&&`)#

逻辑与 && 运算符的运算规律如下（二元运算符）：

左运算量	右运算量	结果
1	1	1
1	0	0
0	1	0
0	0	0

提炼核心规则：全真才真，一假即假。只有当左右两边都为“真”（非0）时，整个表达式的结果才为“真”（1）。

【五】逻辑与的短路特性#

定义：如果第一个操作数是 false（假，即0），那么无论第二个操作数是什么值，结果也不可能等于 true（真，即1）。
形式：(表达式1) && (表达式2)
规则：如果表达式1为假，则表达式2不会进行运算，即表达式2“被短路”。

1
int x = 5, y = 6 ;
2
(x>5)&&(y++) ;   // 结果为假 ，运算后 x=5, y=6

【六】逻辑或运算符 (`||`)#

逻辑或 || 运算符的运算规律如下（二元运算符）：

左运算量	右运算量	结果
1	1	1
1	0	1
0	1	1
0	0	0

提炼核心规则：有真即真，全假才假。只要左右两边有一个为“真”（非0），整个表达式的结果就为“真”（1）。只有当两边都为“假”（0）时，结果才为“假”（0）。

【七】逻辑或的短路特性#

定义：如果第一个操作数是 true（真，非0），第二个操作符就不会再被求值了。
形式：(表达式1) || (表达式2)
规则：如果表达式1为真，则表达式2不会进行运算，即表达式2“被短路”。

1
int x = 5, y = 6 ;
2
(x<= 5)||(y++) ;   // 结果为真 ，运算后 x=5, y=6

初始状态：x = 5，y = 6。
计算左侧 (x <= 5)：5 <= 5 为真，返回 1。
触发短路：因为 || 的左侧为 1（真），整个 || 表达式的结果已确定为真（1）。
跳过右侧：编译器直接跳过右侧的 (y++)，根本不执行。
最终结果：整个表达式为真（1），x 依然是5，y 依然是6。

Dream Blog

C 语言发展史

C 语言发展史#

【一】C 语言诞生的背景#

【1】BCPL 语言#

【2】B 语言#

【3】C 语言诞生#

【二】重要发展时间线#

【三】K&R C 与标准化#

【四】C 语言标准演进#

【1】C89 与 C90#

【2】C95#

【3】C99#

【4】C11#

【5】C17（C18）#

【6】C23#

【五】各版本对比#

【六】C 语言的主要特点#

【1】运行效率高#

【2】具备底层控制能力#

【3】源代码可移植性较好#

【4】语言核心精简#

【5】需要关注内存安全#

【七】主要应用领域#

【八】C 语言的影响#

【九】常见认识误区#

【十】总结#

【十一】延伸阅读#

C 语言开发环境的安装与配置

C 语言开发环境的安装与配置#

【一】开发工具的组成#

【二】编辑器的选择#

【1】Visual Studio Code#

【2】其他选择#

【三】Windows 环境安装（推荐）#

【1】安装 MinGW-w64#

【2】安装 VS Code#

（1）下载安装包#

（2）安装#

（3）选择颜色主题风格#

（4）配置 VS Code#

[1] 安装中文语言包#

[2] 安装 C 语言扩展#

【3】验证安装#

【四】编写并运行第一个 C 程序#

【1】创建项目目录#

【2】编译程序#

【3】运行程序#

【五】Windows 上的其他方案#

【1】Visual Studio + MSVC#

【2】WSL（适合学习 Linux 开发）#

【六】Linux 环境安装#

【1】Debian / Ubuntu#

【2】Fedora#

【3】Arch Linux#

【七】macOS 环境安装#

【八】常见问题排查#

【1】提示“无法识别 gcc”或“gcc 不是内部或外部命令”#

【2】安装了 VS Code 扩展却不能编译#

【3】出现 No such file or directory#

【4】双击程序后窗口一闪而过#

【5】中文输出乱码#

【6】gcc 和 g++ 有什么区别#

【九】推荐的学习配置#

【十】延伸阅读#

C 语言初识：程序运行机制与基本结构

【一】C 程序的运行机制#

【二】C 基础语法#

【三】C 程序的基本结构#

【1】简单的 C 语言程序#

【2】复杂一点的 C 程序结构#

C 语言基础：注释、关键字、变量与数据类型

【一】注释#

【1】单行注释#

【2】多行注释#

【3】文档注释（文本注释）#

【4】注意#

【二】关键字#

【1】C99 新增关键字#

【2】C11 新增关键字#

【3】出现 `No such file or directory`#

【6】`gcc` 和 `g++` 有什么区别#

（1）使用 `const`#

（2）使用 `#define`#

【2】`void` 类型#

【1】字符类型（`char`）#

【2】`short` 类型#

【5】`long int` 类型#

【6】`long long` 类型#