【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 更容易被移植到不同的计算机平台。

【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 较新，不同编译器对各项特性的支持程度可能不同。使用前应查看具体编译器版本的说明。

【1】运行效率高#

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

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

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

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

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

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

【4】语言核心精简#

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

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

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

【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 语言学习环境。

【1】安装 MinGW-w64#

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

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

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

使用在线安装程序时，可能会遇到网络连接错误，因此也可以直接下载 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 等程序：

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

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

【2】安装 VS Code#

（1）下载安装包#

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

（2）安装#

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

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

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

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

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

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

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

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

（4）配置 VS Code#

[1] 安装中文语言包#

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

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

[2] 安装 C 语言扩展#

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

【3】验证安装#

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

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。

【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 中选择“终端 → 新建终端”，执行：

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

各参数含义：

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

【3】运行程序#

在 PowerShell 中执行：

1
.\hello.exe

预期输出：

1
Hello, C!

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

【1】Visual Studio + MSVC#

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

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

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

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

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

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

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

1
wsl --install

进入 Ubuntu 后安装工具链：

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

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

【1】Debian / Ubuntu#

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

【2】Fedora#

1
sudo dnf install gcc gdb make

【3】Arch Linux#

1
sudo pacman -S base-devel gdb

编译并运行：

1
gcc -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 中检查：

1
Get-Command gcc -All

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

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

【3】出现 No such file or directory#

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

1
Get-Location
2
Get-ChildItem

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

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

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

1
.\hello.exe

【5】中文输出乱码#

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

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

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

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

【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;

【1】C99 新增关键字#

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

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

【2】C11 新增关键字#

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

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

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

【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 int MAX_STUDENTS = 50;
2
const double TAX_RATE = 0.13;

1
#define BUFFER_SIZE 1024
2
#define PI 3.1415926

1
#define MAX_COUNT 100    // 正确

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

【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
}

【1】整数类型#

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

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】浮点类型#

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

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

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 等基本类型；处理文件格式、网络协议、硬件寄存器等对位宽有明确要求的场景时，再考虑固定宽度类型。

【1】浮点类型#

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

表中的大小与精度是现代平台上的常见情况，实际结果仍取决于具体实现。可以使用 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 * 不包含所指对象的具体类型信息，因此不能直接解引用；使用前需要转换或赋给正确类型的对象指针。

【1】字符类型（char）#

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

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

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

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

【2】short 类型#

【3】int 类型#

【4】long 类型#

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

相应的 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 从 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 等类型。只有实现能够提供相应宽度时，这些类型才会被定义。

【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 常用的无符号整数格式说明符如下：

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

【5】练习#

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
}

1
a = 10
2
b = 520
3
c = 1010
4
d = 4112

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
}

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

【1】不可打印字符#

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

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

【2】可打印字符#

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 转义，不属于字符本身。

【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
inline      restrict      _Bool      _Complex      _Imaginary

1
_Alignas        _Alignof        _Atomic         _Generic
2
_Noreturn       _Static_assert  _Thread_local

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

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

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

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

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

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

1
x    y    sum    a100    student_name    score2

以下标识符不合法：

【2】命名建议#

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

【3】保留标识符#

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

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

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

练习-字符常量#

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

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;

练习-水分子数#

一个水分子的质量约为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 个水分子

练习-求圆面积#

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