碎碎念

最近搬迁博客，就把这些文章都过了一遍，修改了许多东西。

为了写出来的 C 语言能和 Cpp（C++20 标准）兼容，我写的一般是 C99 标准，高于 C99 标准的我会说明。

这个只是速记，不能代替正常的学习过程。

好习惯

用 stdint.h 代替原本大小不明确的类型。

所有控制语句都加上大括号，即使只有一句话。

错误处理约定好，0 为成功，非 0 为错误码。对任何可能调用失败的函数都做好检查。不要随意 exit，尽可能把错误交给上层。

比起宏，多用静态内联函数代替，避免出错。

语言编写风格

Google C 风格（Google C Style）

Google 的公开风格指南主要是 C++，但在写 C 代码时通常沿用类似约定。核心特点：小写 + 下划线，为主；驼峰只在类型名等少数地方用。

典型约定（简略版）：

• 变量名（局部、全局、参数）：
  使用小写 + 下划线：total_count, file_size, index_i
• 函数名：
  同样小写 + 下划线：read_file(), compute_sum()
• 类型名（struct/enum/typedef）：
  一般首字母大写 + 下划线或驼峰：MyStruct, ErrorCode，或写成：my_struct_t
• 宏 / 常量宏：
  全大写 + 下划线：MAX_BUFFER_SIZE, DEFAULT_TIMEOUT_MS
• 枚举常量：
  全大写 + 下划线：COLOR_RED, COLOR_GREEN
• 全局变量：
  不鼓励大量使用；若用也写成普通的 g_size、g_config 或直接 global_config，不会特意用匈牙利前缀。

一个符合 Google 风味的 C 例子：

typedef struct {
    int width;
    int height;
} Rectangle;

int compute_area(const Rectangle *rect) {
    return rect->width * rect->height;
}

static int max_int(int a, int b) {
    return a > b ? a : b;
}

特点：整体偏“UNIX/C 社区”风格，不使用匈牙利命名，不用成员名前缀类型信息，简单直接。

微软风格（Microsoft C/C++ 命名习惯）

微软内部风格历史上深受 Windows API 和早期 MFC 影响，特点是：喜欢匈牙利命名 + 大小写混合（驼峰/帕斯卡）。
不过需要注意：现在官方也在弱化“匈牙利记号法”，但 Windows SDK/MFC 里仍然能广泛看到这种风格。

典型传统习惯：

• 变量名前缀（“匈牙利命名”）：
  • n/i/c：nCount（int），iIndex，cChar
  • sz：以 '\0' 结尾的字符串：szName
  • psz：指向字符串的指针：pszBuffer
  • dw：DWORD：dwFlags
  • lp/p：指针：lpBuffer, pNext
• 函数名：
  • 常用 帕斯卡命名法（首字母大写驼峰）：CreateWindowEx, GetModuleHandle
• 结构体 / 类型名：
  • typedef struct _FOO { ... } FOO, *PFOO;
    成员常驼峰：dwSize, lpBuffer
• 宏常量：
  • 全大写 + 下划线：MAX_PATH, ERROR_ACCESS_DENIED

一个典型带微软味道的片段：

typedef struct _RECT {
    LONG left;
    LONG top;
    LONG right;
    LONG bottom;
} RECT, *PRECT;

int nCount;
char szName[64];
DWORD dwFlags;

编译预处理

宏定义

define 的宏定义只是替换（一般来说, 宏定义用大写字母, 与普通变量区分）， 下例：

#include<stdio.h>
#define a 10
#define b 20+a
b*2=20+10*2 //要达到先加后乘的效果应该是把b定义为(20+a)

注意: 由于宏定义在预编译中，编译之前，没有检查语法。用#undef 可以终止宏定义的作用域.

宏定义只是机械的替换，所以会出现这样的情况：

#define s(x) x*x 
int main(){
	int x = 5;
	printf("s(x+1)");
}
// 输出x+1*x+1

所以最好每个值加上小括号避免这种情况。

#define STR(s) #s

STR(hello)      → "hello"
STR(123 + 456)  → "123 + 456"
  
#define CAT(x, y) x##y

CAT(hello, world)  → helloworld
CAT(var, 123)      → var123

还可以用 \ 换行。

常用指令

#include
#if / #ifdef / #ifndef / #elif / #else / #endif
#error
#warning
#pragma once
#pragma pack
_Static_assert(sizeof(int) == 4, "int must be 4 bytes"); // C11

数据类型

数据二进制底层形式

原码，反码和补码

负数补码： “取反 + 1”（对整个数取反再加一，符号位也一起参与）

浮点数

以 32 位浮点数为例子，其底层为：

[S][ EEEEEEEE ][ FFFFFFFFFFFFFFFFFFFFFFF ]
 ^    8 位指数          23 位尾数字段
符号位 exponent          fraction

$$ \text{值} = (-1)^S \times 1.\text{F} \times 2^{E_{\text{实际}}} $$

一些技巧

sizeof 可以获得相应类型或者变量的内存大小。

C 语言可以是用科学记数法，e 和 E 都可以用。

类型转化

分为隐式类型转化和显示类型转化，很好理解，不写了。

注意截断和溢出。

基础类型

布尔型

实际上 C 语言有布尔类型，内建为 _Bool，可以用 stdbool.h 引入（烂尾了）。

整形

因为 C 语言历史发展的缘故，它的整形数据结构大小不同平台不一致，下表：

在标准库 limits.h 中可以看到相应类型的最小值和最大值，是宏定义，我就不一一列出来了。

故而写 C 语言我更推荐引用 <stdint.h> 库，使用里面的数据类型，里面的格式都是 uintx_t、intx_t，非常简洁。

C99 起同样拥有 long long 与 LL/ULL 后缀

字符类型

本来字符类型属于整数类型是不用再写的，但是 C 语言存在转义字符和规定符。

转义字符

规定符

补充要点：

• printf 中所有浮点实参都会默认提升为 double，因此 %f / %lf 实际一样，都读 double。
• scanf 中 %f 和 %lf 有区别：分别是 float * 和 double *。

printf 中的宽度/精度：

• %nd： 在 printf 中表示：

  宽度至少为 n 的十进制整数，右对齐，不足时左侧补空格。 示例：printf("%5d", x); 表示宽度至少 5。

• %-ns： 在 printf 中表示：

  宽度至少为 n 的字符串，左对齐，不足时右侧补空格。 示例：printf("%-10s", s); 表示宽度至少 10。

• %m.nf： 在 printf 中表示：

  总宽度至少为 m，小数部分保留 n 位，右对齐； 若实际位数不足 m，则左侧补空格。 示例：printf("%5.2f", y); 即 m = 5, n = 2。

• %0nd： 在 printf 中表示：

  宽度至少为 n 的整数，右对齐，不足时左侧用 0 填充。 示例：printf("%05d", x); 即 n = 5。

• %#x： 在 printf 中表示：

  以十六进制输出无符号整数，并带有 0x 前缀（%#X 为 0X 前缀）。

• %*d： 在 printf 中表示：

  宽度由 额外的一个 int 实参 指定。 例如： printf("%*d “, w, x); // 等价于 printf("%nd “, x); 其中 n = w

scanf 中的宽度/抑制赋值：

• %nd： 在 scanf 中表示：

  最多读取 n 位数字 构成一个整数，存入对应变量，多余的字符留在输入缓冲区。 示例：scanf("%4d", &a); 即 n = 4。

• %*d： 在 scanf 中表示：

  读取一个整数，但 不赋值、不保存（抑制赋值），常用于跳过不需要的数据。

• %d%*c%d： 在 scanf 中表示：

  先读一个整数给第一个参数，然后读一个字符并丢弃（%*c），再读一个整数给第二个参数。 例如输入 1+2 时：a=1，+ 被丢弃，b=2。

单引号当成字符，双引号当成字符串。

宽字符

<wchar.h> 或 <stddef.h> 中引入

wchar_t 宽字符

L"" 宽字符字面量

浮点型

正常的浮点数字默认被当成 double 类型的，带上 f 或者 F，比如 2.3f，可以修改字面量为 foalt。同理 l 和 L 可以修改字面量为 long double

void

void 类型指定没有可用的值。它通常用于以下三种情况下：

函数返回为空：C 中有各种函数都不返回值，或者您可以说它们返回空。不返回值的函数的返回类型为空。例如 void exit (int status);

函数参数为空：C 中有各种函数不接受任何参数。不带参数的函数可以接受一个 void。例如 int rand(void);

指针指向 void：类型为 void * 的指针代表对象的地址，而不是类型。例如，内存分配函数 * void *malloc( size_t size );* 返回指向 void 的指针，可以转换为任何数据类型。

指针

指针，就是一个专门指向内存一个地方的东西，形式为 type*，这里的 type 同样可以是指针，因为指针的值也是存放在内存里的。

实际上在 C 语言中几乎所有东西都能是指针，甚至函数也是！

数组

一维数组

定义: type name[length]

存储在连续内存中, 根据个数和类型占空间, 内存字节数 = 元素个数*sizeof(类型)。

注意: 引用范围为 [0, 长度-1]

int a[4]={1,2,3,4};
int a[4]={1,2,3}; // 没给初始值的默认为0
int a[]={1,2,3,4} // 长度为初始化的长度
char fuck[] = "fjskljf" // 结尾默认加0,因为这是字符串
int a[12]; // 初始化:如果没有初始化,那么内存中是什么是不确定的

多维数组

那二维数组举例

顾名思义, 两个维度.形式:

int score[3][4](先行后列)

其实仍是一维排序, 在内存里就是

[0][0],[0][1],[0][2],[0][3],[1][0],[1][1],[1][2],[1][3](如此依序排列)

初始化:

int a[2][3]={1,2,3,4,5,6};
int a[2][3]={{1,2,3},{4,5,6}};
int a[2][3]={1,2,3,4}; // 未初始化的为0即{1,2,3,4,0,0}
int a[2][3]={{1,2},{3,4}}; // 为{1,2,0,3,4,0}

可省略行数, 但不可省略列数, 以上所有把行数去掉依旧等价.

多类型结构

结构体

定义

结构体就是把 若干字段打包成一个整体类型，格式如下：

struct Point { // 定义
    int x;
    int y;
};

struct Person { // 定义同时声明变量
    char name[20];
    int age;
} p1, p2;

struct Point p; // 定义变量
struct Point *pp = &p;
p.x = 10;
pp->y = 4;     // 等价于 (*pp).y

初始化

顺序初始化：

struct Person p = {"Alice", 20};  // 按成员声明顺序

指定初始化：

struct Person p = {
    .age = 20,
    .name = "Alice",
};

复合字面量：

可以直接在表达式里构造一个“临时结构体对象”：

func((struct Point){3, 4});  // 作为参数

内存布局

struct S {
    char c;   // 1 字节
    int  i;   // 通常 4 字节
};

常见 32/64 位 ABI 中，sizeof(struct S) 通常是 8，而不是 5，因为中间会插入填充字节，使 int 按 4 字节对齐。

在单片机这类非常缺空间的机子上这是不能容忍的，所以这里有许多优化手段。

位域让你用“位”为单位定义整数成员（常用于协议、寄存器等）：

struct Flags {
    unsigned int a : 1;   // 1 位
    unsigned int b : 3;   // 3 位
    unsigned int c : 4;   // 4 位
};

注意：

• 具体布局（高位/低位顺序、是否跨字节）是 实现相关 的。
• 跨平台时尽量不用位域刻画精确二进制协议，改用位运算 &、<< 等自己控制。

有些编译器还支持 #pragma pack 或属性来改变对齐方式：

#pragma pack(push, 1)
struct Packed {
    char c;
    int  i;
};
#pragma pack(pop)

• 可减少空间，但可能导致访问变慢，甚至在某些硬件上非法（未对齐访问）。
• 标准 C 不定义这些行为，属于编译器扩展；跨平台时要谨慎。

结构体与 typedef

下面的写法十分繁琐：

struct Point {
    int x, y;
};

struct Point p;

typedef struct Point {
    int x, y;
} Point;

Point p;   // 不用再写 struct

typedef struct { // 使用匿名函数
    int x, y;
} Point; 

嵌套结构体与自引用

struct Date { int y, m, d; };

struct Person {
    char name[20];
    int age;
    struct Date birthday;
};

struct Person p = {
    .name = "Bob",
    .age = 30,
    .birthday = {1990, 1, 1}
};

struct Node {
    int value;
    struct Node *next;  // OK，指针大小固定
    // struct Node next; // 错误，类型不完整
};

struct S {
    int tag;
    union {
        int i;
        float f;
    };  // 匿名 union C11标准
};

struct S s;
s.i = 10;   // 不需要 s.u.i

联合体

其实等于只有一个地址的结构体，以最后赋值的值为内容， 最大占其中最大成员的内存。语法与结构体一致。

union Data d = {10};    // 初始化 .i = 10
union Data d = {.f = 3.14f};

经典用法：

typedef enum {
    TYPE_INT,
    TYPE_FLOAT,
    TYPE_PTR
} ValueType;

typedef struct {
    ValueType type;
    union {
        int   i;
        float f;
        void *p;
    } data;
} Value;

Value v;
v.type = TYPE_INT;
v.data.i = 42;

// 也可匿名

枚举类型

enum Color {
    RED, // 默认为0,逐次+1
    GREEN,
    BLUE
};

enum ErrorCode {
    ERR_OK      = 0,
    ERR_IO      = 1,
    ERR_TIMEOUT = 2,
    ERR_FATAL   = 100
};

enum Weekday {
    MON = 1,
    TUE,        // 2
    WED,        // 3
    THU = 10,
    FRI,        // 11
    SAT,        // 12
    SUN         // 13
};

enum Color color;

color = RED;

if (color == GREEN) {
    /* ... */
}

enum Color color = BLUE; // C99

运算符与表达式

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。

算术运算符

下表显示了 C 语言支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

关系运算符

下表显示了 C 语言支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

逻辑运算符

下表显示了 C 语言支持的所有关系逻辑运算符。假设变量 A 的值为 1，变量 B 的值为 0，则：

位运算符

位运算符作用于位，并逐位执行操作。

赋值运算符

下表列出了 C 语言支持的赋值运算符：

杂项运算符 ↦ sizeof & 三元

下表列出了 C 语言支持的其他一些重要的运算符，包括 sizeof 和 ? :。

C 中的运算符优先级

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

变量和函数

命名规则

语法层面的规则（编译器强制）：

• 可以包含：字母（a–z / A–Z）、数字（0–9）、下划线 _
• 第一个字符：必须是字母或 _，不能是数字
• 区分大小写：myVar 和 myvar 是两个不同标识符
• 不能包含空格或特殊符号：& * $ @ - + 等都不允许
• 不能是关键字：if、else、int、static、return 等

作用域（scope）

作用域 = 这个标识符“在哪些地方可见”。

代码块作用域（块作用域）

• 出现于：花括号 { ... } 内，如函数体、if、while、for 块
• 典型：局部变量、形参

void f(int x) {        // x 也是块作用域
    int a = 10;        // a 只在 f 的花括号内可见
    if (x > 0) {
        int b = 20;    // b 只在 if 块内可见
    }                  // 这里 b 已经“不可见”
}

文件作用域（全局/静态作用域）

• 出现于：所有函数之外、全局区域
• 从定义点开始，到 该源文件末尾 都可见

int g = 0;         // 文件作用域

void foo(void) {
    g++;
}

函数作用域（只针对标签）

• goto 标签名的作用域是所在函数内部，这里一般不深究。

链接属性（linkage）

链接属性 = 跨源文件时，这个名字是否“指向同一个实体”。

C 里有三种链接属性：

• 外部链接（external linkage）
• 内部链接（internal linkage）
• 无链接（no linkage）

外部链接：多个文件共享同一个标识符

• 默认：文件作用域的非 static 变量 / 函数

// a.c
int g = 0;        // g 有外部链接

void foo(void) {} // foo 也有外部链接

// b.c
extern int g;     // 和 a.c 里的 g 是同一个
void foo(void);   // 声明 a.c 中的 foo

内部链接：仅在当前源文件内部可见

• 通过 static 修饰的、处在文件作用域的变量 / 函数

// a.c
static int counter = 0;     // 只能在 a.c 内使用

static void helper(void) {  // 只能在 a.c 内调用
    counter++;
}

• 其他源文件即使声明 extern int counter; 也无法访问到这里的 counter，因为链接属性不同。

无链接：每个定义独立，文件间不共享

• 块作用域的变量、形参、typedef 名等都属于“无链接”：
  • 它们在每个函数/块里都是各自独立的标识符，“名字相同”也不是同一个实体。

void f(void) {
    int x;       // 无链接
}

void g(void) {
    int x;       // 另一个完全无关的 x
}

生存期（lifetime / storage duration）

生存期 = 变量在内存中实际存在的时间段，和作用域（可见范围）不是一回事。

主要有两类：

• 静态存储期（static storage duration）
• 自动存储期（automatic storage duration）

静态存储期

• 在程序开始运行时分配，在程序结束时释放
• 包括：
  • 所有文件作用域的变量（不管有没有 static）
  • 用 static 修饰的局部变量
  • 所有字符串常量、常量区之类的实现细节对象（你可以先记住“全局 + static 局部”）

int g;                 // 静态存储期

void f(void) {
    static int s = 0;  // 也是静态存储期，只是作用域在块内
    s++;
}

自动存储期

• 典型：普通局部变量、函数形参
• 在进入块/函数时分配，在离开块/函数时销毁

void f(int x) {  // x 自动存储期
    int y = 10;  // y 自动存储期
}                // 运行到这里 x 和 y 就“消亡”

• 自动变量的初始内容 如果你没显式初始化，就是未定义的垃圾值。

（动态分配内存 malloc 那块，属于“动态存储期”，由你手动控制，这里不归类进关键字存储类型里。）

存储类关键字与常见关键字

这里把常见的相关关键字一块讲清楚：auto，register，static，extern，const，inline。

auto（自动存储，几乎不用显式写）

• 默认就是 auto，你写不写都一样：

void f(void) {
    int x;        // 等价于 auto int x;
    auto int y;   // 很少有人这样写
}

• 作用：

  • 块作用域
  • 自动存储期
  • 无链接

• 现代 C 基本不用显式写 auto，只要知道“普通局部变量就是 auto 存储期”即可。

register（建议放在寄存器）

• 语法：

void f(void) {
    register int x = 0;
}

• 本意：建议编译器把这个变量放在 CPU 寄存器里，加快访问（现在优化器通常更聪明，register 多数被忽略）。
• 限制：
  • 理论上不能对 register 变量取地址（&x 不一定允许）。
• 作用：
  • 块作用域
  • 自动存储期
  • 无链接

在现代 C 里，普遍建议：不用写 register，交给编译器自动优化就好。

static

分几种情况：

文件作用域的 static（改变链接属性 → 内部链接）

static int g = 0;   // 只在本源文件内可见（内部链接）

static void helper(void) {
    /* 只在本文件内可调用 */
}

• 作用域：文件作用域
• 存储期：静态存储期
• 链接属性：内部链接（仅本文件共享）

这是一种“隐藏实现细节”的手段，非常推荐用于库/模块内部的全局量和函数。

块作用域的 static（改变存储期 → 静态存储期）

void counter(void) {
    static int c = 0;   // 只初始化一次，整个程序期间都存在
    c++;
    printf("%d\n", c);
}

• 作用域：块作用域（只在函数内部可见）
• 存储期：静态存储期（整个程序运行期一直存在）
• 链接属性：无链接

典型用途：

• 在函数内做“静态局部变量”，用来记忆调用状态（如计数器、缓存等）。
• 注意：初始值默认是 0（全局/static 变量默认会清零）。

extern

用于 声明一个已经在别处定义的全局变量或函数，不改变其本身属性，只是告诉编译器“这个名在别的翻译单元有定义”。

// a.c
int g = 42;

// b.c
extern int g;     // 声明：g 在别处定义

适用场景：

• 在头文件中声明全局变量/函数接口，在某个 .c 中给出定义：

// mylib.h
extern int my_global;
void my_func(void);

// mylib.c
#include "mylib.h"
int my_global = 0;
void my_func(void) { ... }

特性：

• 只能用在文件作用域（不能在函数里面用 extern 定义一个新变量，还想有外部链接）。
• 不会改变变量本身的生存期/链接属性，只是一个声明。

const

const = 只读 语义限定符，和存储期/作用域无直接关系，但用在变量定义和声明时极其常用。

const int x = 10;         // x 不能被修改
int *p;
const int *pc;            // 指向 const int 的指针：*pc 不能改
int * const cp = &x;      // const 指针：cp 本身不能改，*cp 可以（这里示例不严谨，只看语法）

几点要注意：

• const 不等于“放在只读存储区”，只是 语义上的不可改，具体放哪是实现细节。
• 作用域、生存期、公/私有都由“位置和 static/extern”决定，const 只是增加“禁止修改”的约束。

常见模式：文件内只读全局常量

static const double PI = 3.141592653589793;

• 作用域：文件作用域
• 存储期：静态存储期
• 链接属性：内部链接
• 语义：不可修改

inline（内联函数）

• 关键字：inline，表示“建议内联”，是否真正内联由编译器决定。
• 一般配合 static 或 extern 一起用（否则可能出现多重定义问题），在 C99/C11 中需要注意用法：

常见安全写法（放在头文件）：

static inline int max_int(int a, int b) {
    return a > b ? a : b;
}

• static inline 函数：
  • 作用域：翻译单元内部（类似内部链接）
  • 通常会被内联，也可以生成本地函数体

或在 C11 里配合 extern inline 用于某些高级优化场景，这个比较复杂，入门阶段记住：

• 把小工具函数写成 static inline 放头文件里，即可。

inline 不改变存储期，它只影响函数的链接属性和是否生成独立函数体，与“变量的生命周期”不同类概念，这里放一起只是顺带说明。

“就近原则”的变量遮蔽（shadowing）

当你在内层作用域定义了与外层同名的变量时，内层会“遮蔽”外层：

int x = 1;          // 全局 x

void f(void) {
    int x = 2;      // 局部 x，遮蔽全局 x
    printf("%d\n", x); // 打印 2，而不是 1
}

建议：

• 尽量避免在函数内使用和全局变量相同的名字，免得混淆。
• 若必须使用全局变量，给全局量加统一前缀或放在结构体里，减少直接裸露的全局。

程序控制流

控制流关键字

if(){
  
}else if(){
  
}else{
  
}

switch:
case x:
	xxx;
	break;
default:
	xxx;

for (a;b;c){ // 除了b都可省略
  
}

while(){
  continue; // 跳过一次循环
  break; // 跳出循环
}

do{
  
}while()
  
  
goto xxx
xxx:
	xxx;

main

int main(int argc, char* argv[]){
} // 函数入口强制定义argc表示参数个数，包括自己。argv表示每个命令字符串

同时 main 不一定是第一个函数, 在一些调试检测需求下, 以下是有可能会出现的:

• 全局对象的构造函数会在 main 函数之前执行。（Cpp）

• 一些全局变量、对象和静态变量、对象的空间分配和赋初值就是在执行 main 函数之前，而 main 函数执行完后，还要去执行一些诸如释放空间、释放资源使用权等操作。

• 进程启动后，要执行一些初始化代码（CRT），然后跳转到 main 执行。全局对象的构造也在 main 之前。

• 通过关键字 __attribute__，让一个函数在主函数之前运行，进行一些数据初始化、模块加载验证等。

其余关键字

volatile：禁止编译器优化

auto：表示“自动存储期的局部变量”（和默认一样，所以不用管）

nullptr：C23 加的，没绷住。

常用库函数

math.h

ctype.h

stdio.h

标准输入输出

文件处理

错误检查

stdlib.h

动态内存

字符串到数字

随机数

程序控制 / 环境

排序与查找

string.h

字符串函数（以 '\0' 结尾）

内存函数（任意字节块）

断言

assert 在 assert.h 中, 检测参数是否为否, 如果问否, 则使用 abort 退出程序。是运行时断言，_Static_assert 是编译时。