编写规范

语言风格

Google 风格：

• 函数名和变量名：小写 + 下划线
• 全局变量：不鼓励大量使用；若采用则类似 g_var
• 类型名：首字母大写 + 下划线或驼峰，或者类似 my_struct_t
• 宏和枚举常量：全大写 + 下划线

微软风格：

• 变量名前缀（“匈牙利命名”）：

  • 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
• 宏常量：全大写 + 下划线

注意事项

C 语言由于其特性，不建议作为日常使用语言，如果有底层开发需求，去使用 C++ or Rust。

除非你是嵌入式开发或者性能紧张场景，如果这样建议你看看下面文章，恐怕这类场景对于安全性要求也是很高的：

• Rust C
• MISRA C

还有一些好习惯推荐：

• 自定义类型代替原本大小不明确的类型。
• 所有控制语句都加上大括号，即使只有一句话。
• 比起宏，多用静态内联函数代替，避免出错。
• 错误处理约定好，0 为成功，非 0 为错误码。对任何可能调用失败的函数都做好检查。不要随意 exit，尽可能把错误交给上层。

语言要求

main

任何 C 程序必须从 main 函数开始

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

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

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

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

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

编译预处理

宏定义

// 替换
#define a 10
#define b 20+a
b * 2 = 20 + 10 * 2 // 要达到先加后乘的效果应该是把b定义为(20+a)
  
// 字符串定义
#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 <> #include "" // 一个先找库，一个先找当前目录
#if / #ifdef / #ifndef / #elif / #else / #endif // 根据条件来选择是否编译该段代码
#error       // 编译时直接报错并终止
#warning     // 编译时输出警告但不终止
#pragma once // 只允许引用一次，用来避免重复引用
#pragma pack // 控制结构体内存对齐
_Static_assert(sizeof(int) == 4, "int must be 4 bytes"); // C11 引入，编译期断言

类型

基础类型

整型

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

在标准库 limits.h 中可以看到相应类型的最小值和最大值，是宏定义。

long long 是 C99 才开始有的。

由于各个平台规定不一，故而写 C 语言更推荐引用 <stdint.h> 库，使用 uintx_t、intx_t。

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

浮点型

字符和宽字符

char 类型，默认为 8 bit，带符号。

unsigned char 类型，默认为 8 bit，不带符号。

wchar_t 类型，默认为 16 bit，通过 <wchar.h> 或 <stddef.h> 引入，主要用于宽字符支持。

指针

指针，就是一个存放内存地址的变量。形式为 type*，这里的 type 同样可以是指针，因为指针的值也是存放在内存里的。

type 的区别取决于你想如何解释这个地址上的变量。

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

void

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

• 函数返回为空：函数没有返回值，此时返回值类型要设置为 void，例如 void exit (int status);
• 函数参数为空：函数不需要参数，此时参数类型需要设置为 void，例如 int rand(void);
• 指针指向 void：类型为 void* 的指针代表对象的地址，而不是类型。例如，内存分配函数 void* malloc( size_t size );。返回指向 void 的指针，可以转换为任何指针类型。

字面量

字符字面量中，单引号当成字符，双引号当成字符串，L"" 为宽字符字面量。

整数字面量中，从 C99 起拥有 LL/ULL 的整数后缀。而且可以使用科学计数法。

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

转义字符和规定符

转义字符：

规定符：

printf 精度:

scanf 精度:

复合类型结构

数组

数组分为一维数组和多维数组，一维数组的定义为 type name[length]，其含义为存储在内存中连续存放的 length 个大小等同于 type 的变量们, 总空间大小为内存字节数 = 元素个数 * sizeof(类型)。

多维数组格式为 type name[length1][length2]...[lengthN]，在内存中仍是一维排序。

数组的第一个元素下标为 0，所有的方括号范围为 [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 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;
    struct Point; // 可嵌套
    struct { // 可匿名
      int a;
      int b;
    };
    struct Person* p; // 可自引用
    // struct Person p; // 错误，因为 Person 中又定义一个 Person，那么没法确认其大小
} p1, p2;

// 定义变量
struct Person p; 
struct Person *pp = &p;

// 使用变量
p.age = 10;
pp->age = 4; // 等价于 (*pp).y
p.a = 1; // 可自由使用任何匿名复合体

内存布局同数组类似，但是大小计算方式则不同，拿下例说明：

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)

初始化方式：

// 顺序初始化，即按成员声明顺序
struct Person p = {"Alice", 20};

// 指定初始化
struct Person p = {
    .age = 20,
    .name = "Alice",
};

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

联合体

空间大小为所有变量中空间最大的变量，以最后赋值的值来作为其内容的结构体。语法与结构体一致，下面只展示基本写法。

// 定义
union Data {
    int   i;
    float f;
    void *p;
};

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

// 使用变量
d.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

复合变量体与 typedef

定义复合变量体变量由于要反复写明其复合变量类型，十分麻烦，我们可以用 typedef 给它取别名

// 取别名
typedef struct Point {
    int x, y;
} Point;

// 使用匿名函数进一步简化
typedef struct {
    int x, y;
} Point; 

Point p;   // 不用再写 struct

类型转化

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

注意截断和溢出，C 编译器默认不检查这些东西，有一些安全选项开启后可以检查a。

运算符与表达式

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

运算符优先级：

算术运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

杂项运算符：sizeof 与三元

控制流

// 条件判断
if(){
  
}else if(){
  
}else{
  
}

// 多重条件判断
switch:
case x:
  xxx;
  break; // 如果不带 break，则会继续朝向下一个 case 作比较
default:
  xxx;

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

// 先判断再执行的循环 
while(){
  continue; // 跳过一次循环
  break;    // 跳出循环
}

// 先执行再判断的循环
do{
  
}while()
  
// 直接跳转
goto label
label:
  xxx;

函数

类型为 返回值类型 函数名(函数参数类型 函数参数名, ...){...}

变量函数特殊属性

作用域（scope）

作用域指的是变量或者函数的可见范围。

• 文件作用域（全局/静态作用域）：所有函数之外的全局区域，从其定义点开始，到该源文件末尾都可见
• 代码块作用域（块作用域）：花括号 { ... } 内是单独的一个作用域，如函数体、if、while、for 块，或者主动写的花括号。内层作用域可以看到外层作用域已定义变量，外层看不到内层。最里面的作用域定义变量可以覆盖外面作用域的同名变量。
• 函数作用域（只针对标签）：goto 标签名的作用域是所在函数内部，这里一般不深究。

链接属性（linkage）

链接属性指的是跨源文件时，不同文件中同个名字是否指向同一个实体。C 里有三种链接属性：

• 外部链接（external linkage）：多个文件共享同一个标识符，是文件作用域的非 static 变量 / 函数
• 内部链接（internal linkage）：仅在当前源文件内部可见，是通过 static 修饰的、处在文件作用域的变量 / 函数
• 无链接（no linkage）：每个定义独立，文件间不共享，是块作用域的变量、形参、typedef 名等，它们在每个函数/块里都是各自独立的标识符，“名字相同”也不是同一个实体。

生存期（lifetime / storage duration）

生存期 = 变量在内存中实际存在的时间段。主要有三类：

• 静态存储期：在程序开始运行时分配，在程序结束时释放，包括：

  • 所有文件作用域的变量（不管有没有 static）
  • 用 static 修饰的局部变量
  • 所有字符串常量、常量区之类的实现细节对象（你可以先记住“全局 + static 局部”）
• 自动存储期：在进入块/函数时分配，在离开块/函数时销毁，比如普通局部变量、函数形参。自动变量的初始内容在没显式初始化的情况下，就是未定义的垃圾值。
• 动态存储期：由程序员手动控制，比如动态分配内存

相应对应二进制文件中的常量段，栈，堆

关键字

常见关键字：

• auto：所有变量默认就是 auto 存储期，实际上不需要写。
• register：建议编译器把变量放在寄存器，但是由于现代编译器的优化方式，实际上不需要写。
• static：文件作用域的 static 会改变链接属性 → 内部链接，用来避免外界使用；块作用域的 static会改变存储期 → 静态存储期，用来作为代码块内部静态局部变量。
• extern：用于声明一个已经在别处定义的全局变量或函数，不改变其本身属性，只是告诉编译器“这个名在别的翻译单元有定义”。常用于在头文件中声明全局变量/函数接口，在某个 .c 中给出定义
• const：代表不变变量，不可修改，永远等于初始值
• inline：表示“建议内联”，是否真正内联由编译器决定。现在主要解决多重定义问题，inline 函数可以允许函数出现在多个文件不出现多重定义问题，inline static可以允许变量出现在多个文件不出现多重定义问题。
• volatile：禁止编译器优化
• nullptr：C23 加的，同 Cpp 中一样。

常用库函数

math.h

ctype.h

stdio.h

标准输入输出

文件处理

错误检查

stdlib.h

动态内存

字符串到数字

随机数

程序控制 / 环境

排序与查找

string.h

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

内存函数（任意字节块）

assert.h

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