Programming on TouchingFish.top

Rust 的"解法"

Sun, 19 Oct 2025 00:00:00 +0000

翻出 2020 年写的 C 语言博客。

数组与指针，内存布局与调试。那时候写得挺认真的，后来还画内存图，标注高地址低地址，解释为什么 arr[3] = 20 能把旁边变量 i 的值也改了。文章结尾写的是：“为避免这种错误，始终要确保在使用数组时不越界访问。”

现在回头看，那句话翻译成人话大概是：你最好别写错。

因为写错了编译器不会告诉你。

学 Rust 的时候，很多东西越看越像是对 C 里那些经典问题的系统性回应。不是"Rust 比 C 好"——是 Rust 把二十年来系统编程中最常见的错误模式，逐个编码进了编译器和类型系统里。一个 Rust 新手在编译期被挡下的问题，可能比一个 C 老手十年遇到的运行时 bug 还全面。

指针三兄弟

NULL、野的、悬空——C 程序员的日常恐惧来源。

int *p = NULL; *p = 1; 编译通过。运行到这一行，操作系统发来 SIGSEGV。不是编译期能发现的事——NULL 是一个合法的指针值，只是指向的地址不可访问。编译器没有语义层面的"这个指针可能为空"的概念。

int* f() { int x = 5; return &x; } 也编译通过。x 在 f 的栈帧里，函数返回后栈帧被回收，返回的地址指向一块随时可能被覆盖的内存。这个地址仍然"合法"——它在一个可访问的内存段内，只是内容不受你控制。有时候打印出 5，有时候打印出随机数，有时候什么都没发生，取决于后续函数调用有没有踩到同一块栈空间。

free(p); *p = 1; 还是编译通过。free 之后那块堆内存被标记为可用，但 p 的值没变，仍然指向原地址。继续通过 p 读写，运气好时数据还没被覆盖，程序照常运行——这比直接崩溃更危险，因为你不知道错误已经埋下了。

Rust 的做法很简单：没有 NULL。没有悬垂引用。没有 use-after-free。

编程语言中的函数

Fri, 29 May 2020 00:00:00 +0000

数学上的函数是指一种映射关系，通常用来将一个输入（或多个输入）映射到一个输出。对于每一个特定的输入，总是有一个确定的输出。例如，函数 f(x) = x² 将输入 x 映射为其平方。

编程语言中的函数与之类似，具有输入和输出的概念，但其本质上更广泛和灵活。

在编程中，函数不仅可以执行计算，还可以执行一系列操作，如修改数据、输出信息、读取文件等。函数在编程中是用来封装一段代码，使得该代码可以复用，并且能够通过调用函数来执行特定的任务。

编程语言中的函数通常具有以下的特点：

定义与调用：
- 定义函数时，需要给出函数名、参数（如果有）和函数体。
- 调用函数时，通过函数名和传递的参数来执行函数。
参数与返回值：
- 函数通常接受参数（inputs），并可能返回一个值（output）。
- 某些函数可能不接受参数或不返回值（如在 C 语言中使用 void 关键字）。
封装与抽象：
- 函数将代码封装起来，使得复杂操作可以通过简单的函数调用来实现。
- 通过函数的使用，可以更容易地理解和管理代码结构。
作用域：
- 函数的内部变量通常具有局部作用域，即它们只能在函数内部访问。
- 这种作用域规则有助于避免变量命名冲突和意外的值修改。

Windows C 的函数编程

函数声明与定义

在使用函数前需要进行声明（或称为函数原型声明）。例如，int add(int a, int b);。

函数的定义包括函数的返回类型、函数名、参数列表和函数体。

返回类型

每个函数必须有一个返回类型，表明该函数返回的数据类型。

如果函数不返回任何值，使用 void 作为返回类型。

参数传递

C 语言中的函数参数通常是按值传递的，即传递的是参数的副本，函数内部的修改不会影响原参数。

如果需要函数内部修改外部变量的值，可以使用指针进行参数传递。

变量的作用域

局部变量只在离自己最近的大括号内有效。形式参数也是局部变量。

全局变量在源文件中定义，占用的内存不会因为程序结束而释放，二是在整个进程的执行过程中一直有效。

变量的存储方式分为：

静态存储方式：程序运行期间，由系统分配固定的存储空间，
动态存储方式：程序运行时根据需要进行动态的分配存储空间。

外部变量

全局变量在源程序文件（一个编译单位）中，从定义位置到文件末尾一直有效。可以使用 extern 扩展变量的作用域。

#include <stdio.h>

extern int k;
//扩展全局变量k的作用域
void print()
{
 printf("k = %d\n", k);
}

int k = 10;//全局变量k的定义与生效，向下↓
int main()
{
 print();
}

头文件是扩展名为 .h 的文件，包含了 C 函数声明和宏定义，被多个源文件中引用共享。全局变量不能定义在头文件中

结构体与对齐原则

Tue, 12 May 2020 00:00:00 +0000

结构体

结构体（struct）是一种用户自定义的数据类型，它允许我们将不同类型的数据组合在一起形成一个整体，从而更好地表示复杂的数据。

结构体是 C 语言中非常重要的一种数据类型，广泛应用于各种编程场景。

声明和定义结构体时，需要在语句末尾添加分号（";"）

#include <stdio.h>

struct student{
 int num;
 char name[20];
 char gender;
 int age;
 float socre;
 char addr[40];
};//语句末尾的分号（;）必不可少

int main()
{
 struct student s = {9001,"Alice",'M',24,98.9,"LA"};
 struct student sarr[3];
 int i;
 for(i=0; i<3; i++)
 {
 scanf("%d%s %c%d%f%s",&sarr[i].num,&sarr[i].name,&sarr[i].gender,&sarr[i].age,&sarr[i].socre,&sarr[i].addr);
 }
 printf("%d %s %c %d %.2f %s\n",s.num,s.name,s.gender,s.age,s.socre,s.addr);
 for(i=0;i<3;i++)
 {
 printf("%d %s %c %d %.2f %s\n",sarr[i].num,sarr[i].name,sarr[i].gender,sarr[i].age,sarr[i].socre,sarr[i].addr);
 }
}

结构体嵌套： 结构体中可以嵌套其他结构体。

struct Student
{
 int num;
 char name[10];
 struct Date
 {
 int year;
 int month;
 int day;
 }birthday;
 char gender;
};

C 语言允许定义无类型名的结构类型 ，常用于内嵌的结构类型：

struct
{
 int year;
 int month;
 int day;
}birthday;

当类型名 “Date” 省略时，必须后随结构变量 “birthday” 的定义。

字符串与字符数组

Sat, 09 May 2020 00:00:00 +0000

字符串是由一系列字符组成的字符数组，并以空字符 '\0' 结尾。

字符数组与字符串的概念在 C 语言中密不可分，是计算机处理文本时的基础。

字符数组与字符串数组

字符数组

字符数组：一个存储字符的数组 char str[6] = "hello";，通常用于表示字符串。

字符数组 str 包含5个字符 'h', 'e', 'l', 'l', 'o' 和一个隐含的结尾字符 '\0'，表示字符串的结束。

因此，字符数组初始化时，大小应比存储的字符串长读至少多一个字节。

char c[10]="1234567890";
printf("%s\n", c);
//输出结果为：123456789烫烫烫
//表示此时赋值没有结束符，使用%s输出会在'\0'处停止

字符串数组

包含多个字符串的数组。例如：

char names[3][10] = {"Alice", "Bob", "Charlie"};

这个 names 数组包含三个字符串，每个字符串最多可以容纳 9 个字符（最后一个字符是 '\0'）。

字符串的打印

printf 函数用于格式化输出字符串和字符。此时，使用 %s 和 %c 来打印字符串和字符有明显区别：

%s：用于打印字符串，即一系列字符直到遇到 '\0' 结束。例如：
```
char str[] = "hello";
printf("%s", str); // 输出: hello
```

%c：用于打印单个字符。例如：

char ch = 'A';
printf("%c", ch); // 输出: A

如果使用 %s 打印一个字符数组，程序会输出从该地址开始的所有字符，直到遇到 '\0'。而使用 %c 只会打印单个字符。

void print(char c[])
{
 int i=0;
 while(c[i]!=0)
 {
 printf("%c", c[i]);
 //%c是单字符逐一打印
 i++;
 }
}
int main()
{
 char c[10]="123456789";
	printf("%s\n", c);
 //%s从起始地址开始打印字符串，在'\0'处结束
 //此处"c"是字符数组名，表示字符数组的起始地址
 print(c);
}

字符串的初始化

`scanf` 函数

在使用 scanf 函数读取字符串时，有一些重要的注意事项：

数组与指针

Mon, 04 May 2020 00:00:00 +0000

数组和指针的关系：在 C 语言中，数组名其实是一个指针，指向数组的第一个元素。例如，如果你有一个数组 int arr[10];，那么 arr 实际上是指向 arr[0] 的指针。这意味着你可以用指针来遍历数组，也可以通过指针操作数组元素。
通过指针访问数组：当你理解了数组名是一个指针后，你就能明白为什么 *(arr + 1) 等价于 arr[1]。这个表达式的意思是“通过指针 arr，向后移动一个位置，然后取该位置的值”。
指针的灵活性：数组在定义时大小是固定的，而指针则更为灵活，可以指向任何内存位置。这使得你在处理数据时，能够更灵活地进行操作，例如动态分配内存或处理不同类型的数据结构。
内存理解：通过理解指针如何操作数组，你会对内存管理有更深入的认识。这在 C 语言中尤为重要，因为你需要手动管理内存，避免错误操作。

把数组和指针放在一起学习，有助于更深入地理解两者的工作原理，可以更好地理解内存和数据访问的底层机制，让编程更加高效和可靠。

数组

具有相同的数据类型
使用过程中需要保留原始数据

一维数组

数组初始化中的常量表达式：数组名 [常量表达式]（通常为常量，或宏定义的符号常量）表示数组的大小，这是因为一个函数的函数栈空间大小是固定的。

数组元素的引用方式是 数组名 [下标]（从 0 开始）访问数组中的数据

数组在内存中的存放

数组存放在一块连续的内存中，元素间的地址根据其数据类型所占字节数决定。

访问越界 (Out-of-Bounds Access)

C 语言的内存管理：先定义的变量在高地址，后定义的变量在低地址。

#include <stdio.h>

int main() {
 int i = 10; // 定义一个整数变量 i，并赋值为 10
 int arr[3] = {1, 2, 3}; // 定义一个大小为 3 的整数数组

 printf("Before out-of-bounds access:\n");
 printf("i = %d\n", i);
 printf("arr[0] = %d, arr[1] = %d, arr[2] = %d\n", arr[0], arr[1], arr[2]);

 // 访问数组的第 4 个元素（越界访问）
 arr[3] = 20;

 printf("\nAfter out-of-bounds access:\n");
 printf("i = %d\n", i); // 查看 i 的值是否被改变
 printf("arr[0] = %d, arr[1] = %d, arr[2] = %d\n", arr[0], arr[1], arr[2]);

 return 0;
}

当访问越界发生时，新定义的数组元素可能覆盖了先定义的变量i的地址（高地址），i的值（该地址中的值）发生改变。

C语言程序设计基础

Fri, 01 May 2020 00:00:00 +0000

在程序设计中，基本数据类型决定了变量可以存储的值和可执行的操作。

运算符与表达式用于执行各种计算和逻辑操作，如加减乘除、比较和逻辑运算，是编写有效程序的核心。

选择和循环结构控制程序流程，通过条件判断和重复执行代码块，实现复杂的逻辑和功能。

基本数据类型

C 语言的数据类型包括：基本类型（整型、浮点型、字符型等）、构造类型（数组、结构体）、指针类型、空类型。

整型

int 4 字节

short 2 字节

long 4 字节（Windows 32位/64位）、8 字节（Linux 64位）

- ILP32 LP64 LLP64 ILP64

char 8 8 8 8

short 16 16 16 16

int 32 32 32 64

long 32 64 32 64

long long 64 64 64 64

void * 32 64 64 64

-	ILP32	LP64	LLP64	ILP64
char	8	8	8	8
short	16	16	16	16
int	32	32	32	64
long	32	64	32	64
long long	64	64	64	64
void *	32	64	64	64

数据模型命名规则：I=int，L=long，P=pointer，数字表示位数。ILP32 表示 int/long/pointer 均为 32 位；LP64 表示 long/pointer 为 64 位；LLP64 表示 long long/pointer 为 64 位；ILP64 表示 int/long/pointer 均为 64 位。

从源代码到可执行程序

Fri, 01 May 2020 00:00:00 +0000

编程是和计算机对话的过程。我们按照计算机能理解的方式，用抽象的编程语言来描述算法和逻辑，给计算机下达指令，让它完成工作。

在 C 语言的程序开发过程中，预处理、编译和汇编是将源代码转化为可执行程序的几个关键阶段。理解它们之间的关系有助于更好地理解C语言的编译过程。下面将详细介绍这几个阶段的作用及其相互关系。

预处理

预处理（Preprocessing）是 C 语言编译过程中的第一个阶段。在这个阶段，C 编译器的预处理器（Preprocessor）处理代码中的预处理指令，如 #include、#define、#ifdef 等。这些指令通常用来管理宏定义、文件包含、条件编译等。

宏替换：将所有定义的宏替换为相应的代码。例如：
```
#define PI 3.14
```
在程序中所有出现 PI 的地方，都会被替换为 3.14。
文件包含：将 #include 指定的头文件内容插入到当前文件中。例如：
```
#include <stdio.h>
```
会将 stdio.h 文件的内容包含到当前源文件中。在一段代码中，通常会在首行引用头文件，指令告诉 CPP 从系统库中获取 stdio.h，并拷贝其中的文本到当前的源文件里。（乱用头文件会影响编译的效率）
条件编译：根据条件判断是否编译某些代码段。例如：
```
#ifdef DEBUG
printf("Debug mode\n");
#endif
```
只有在定义了 DEBUG 宏的情况下，printf 语句才会被编译。

预处理后的输出是一个扩展的源文件，其中所有的预处理指令都已经被处理和替换。这个文件将传递给编译器的下一阶段。

编译

编译（Compilation）是将预处理后的 C 代码转换为汇编代码的过程。编译器会检查代码的语法和结构，优化代码，并生成汇编代码。

在这个阶段，编译器会执行以下操作：

语法分析：检查代码的语法是否正确，确保符合C语言的语法规则。
语义分析：检查代码的语义是否合理，例如变量类型的正确性、函数调用的合法性等。
优化：编译器可能会对代码进行优化，以提高生成代码的运行效率。
生成汇编代码：将C语言的代码转换为特定硬件架构的汇编语言。例如，gcc 编译器将生成 .s 文件（包含汇编代码）。

汇编代码是一种低级语言，更接近机器代码，但仍然是人类可读的（如 MOV, ADD 等指令）。

汇编

汇编（Assembly）是将汇编代码转换为机器代码的过程。在这个阶段，汇编器（Assembler）会将汇编代码翻译成目标机器的二进制指令，这些指令可以直接在处理器上执行。

生成目标文件：汇编器将生成一个目标文件（通常是 .o 或 .obj 文件），它包含了机器代码以及一些调试和链接信息。

目标文件最终会被打包成可执行文件（例如 .exe 文件），可以直接在计算机上运行。

关系与流程

预处理是编译的第一步，处理宏、头文件等预处理指令，生成一个纯C语言的源代码文件。
编译阶段将预处理后的源代码翻译为汇编代码，这个过程中包括了语法检查、优化等重要步骤。
汇编阶段将汇编代码转换为机器代码，生成目标文件。

Programming on TouchingFish.top

Rust 的"解法"

指针三兄弟

编程语言中的函数

Windows C 的函数编程

函数声明与定义

返回类型

参数传递

变量的作用域

外部变量

结构体与对齐原则

结构体

字符串与字符数组

字符数组与字符串数组

字符数组

字符串数组

字符串的打印

字符串的初始化

scanf 函数

数组与指针

数组

一维数组

数组在内存中的存放

访问越界 (Out-of-Bounds Access)

C语言程序设计基础

基本数据类型

整型

从源代码到可执行程序

预处理

编译

汇编

关系与流程

`scanf` 函数