讲义：C 语言的类型系统与内存模型 ¶

前置：数、进制与数据 ¶

• 十进制：20231029
• 二进制：[0b] 1001101001011001101110101
• 八进制：[0o] 115131565
• 十六进制：[0x] 134b375

你可以通过 %x 格式化字符串来打印十六进制数。

printf("%x\n", 20231029);
printf("%d\n", 0x20231029);

如何阅读它们？¶

这些都是“十”：0b1010，0o12，0xa，10。

• 0x18
  • ❌ 零埃克斯十八，零叉十八，零乘十八
  • ✅ 零埃克斯一八，零叉一八
• 0o23
  • ❌ 零欧二十三
  • ✅ 零欧二三
• 0b1010
  • ❌ 零币一千零一十
  • ✅ 零币一零一零
• 0x10000
  • ❌ 零埃克斯一万，零叉一万，零乘一万
  • ✅ 零埃克斯一零零零零，零叉一零零零零

ASCII¶

每个字符对应一个数字，即其 ASCII 码。如 A 的 ASCII 码为 65，a 的 ASCII 码为 97。

类型系统 ¶

类型是与数据相关的属性，它决定了数据的存储方式和可进行的操作。

变量是数据的载体，它是存储在内存中的一块空间，有类型和值。

计算机如何存储数据？¶

在一台 s390x 架构的计算机上：

MAGIC_R(0x20231029);
// =====
// 0x20231029: 4 (0x4) byte(s)
// 0000  20 23 10 29

大端序与小端序 ¶

主流架构（如 x86、AMD64、ARM）使用小端序。一些不常见的架构（如 SPARC）使用大端序。网络协议使用大端序。

先来练练手 ¶

你应当已经知道，不同类型的变量一般占据不同的字节数。

int i = 0x12345678;
MAGIC(i);

long long ll = 0xfedcba9876543210LL;
MAGIC(ll);

double d = 3.14159265358979323;
MAGIC(d);

float f = d;
MAGIC(f);

char c = 'A';
MAGIC(c);

MAGIC_R('A');

MAGIC_R((short)ll);

MAGIC("Hello world! I am a l" "ong string.");

=====
i: 4 (0x4) byte
0000  78 56 34 12
=====
ll: 8 (0x8) byte
0000  10 32 54 76 98 ba dc fe
=====
d: 8 (0x8) byte
0000  18 2d 44 54 fb 21 09 40
=====
f: 4 (0x4) byte
0000  db 0f 49 40
=====
c: 1 (0x1) bytes
0000  41
=====
'A': 4 (0x4) byte <!--(1)!-->
0000  41 00 00 00
=====
(short)ll: 2 (0x2) byte
0000  10 32
=====
"Hello world! I am a l" "ong string.": 33 (0x21) byte
0000  48 65 6c 6c 6f 20 77 6f 72 6c 64 21 20 49 20 61
0010  6d 20 61 20 6c 6f 6e 67 20 73 74 72 69 6e 67 2e
0020  00

基本类型 ¶

类型 - cppreference.com

整数类型：char short int long long long

其中，除了 char 以外的类型默认为 signed，即有符号数。也就是说，int 就是 signed int。将 signed 换为 unsigned，就得到了无符号数。

浮点类型：float double long double

定长整数类型与其他整数类型 ¶

在 stdint.h 中定义，如 int8_t uint8_t int16_t uint16_t int32_t uint32_t int64_t uint64_t。

sizeof 运算符与 offsetof 宏的结果：size_t，足够表示任何对象的大小。常被定义为 unsigned long。

在 stddef.h 中定义，ptrdiff_t 表示两个指针相减的结果。常被定义为 long。

uint64_t i = 0xdeadbeefcafebabe;
printf("%" PRIu64 "\n", i); // 应当包含 inttypes.h

结构体、联合体、枚举类型 ¶

枚举类型实质上是整数类型。它的值是由编译器自动分配的（一般从 0 开始），也可手动指定。

结构体的大小是其成员大小的总和，加上对齐所需的填充字节。

struct point {
  int x;
  long y;
};
struct point p = {1234, -5678};
MAGIC(p);

union un_t {
  long l;
  double d;
};
union un_t un;
un.d = 3.14159265358979323;
MAGIC(un);

enum en_t { ENA, ENB, ENC = 114514 };
MAGIC_R(ENA);
MAGIC_R(ENC);

MAGIC_PTR(&p.x);
MAGIC_PTR(&p.y);
MAGIC_PTR(&un.l);
MAGIC_PTR(&un.d);

=====
p: 16 (0x10) byte
0000  d2 04 00 00 00 00 00 00 d2 e9 ff ff ff ff ff ff
=====
un: 8 (0x8) byte
0000  18 2d 44 54 fb 21 09 40
=====
ENA: 4 (0x4) bytes
0000  00 00 00 00
=====
ENC: 4 (0x4) bytes
0000  52 bf 01 00
&p.x: 0x16d3cee18
&p.y: 0x16d3cee20
&un.l: 0x16d3cee10
&un.d: 0x16d3cee10

字符串，数组，函数，指针类型 ¶

数组是一系列相同类型的对象的集合。数组的大小是其元素大小的总和。

int arr[] = { 0xbeef, 0xcafe, 0xdead, 0xface, 0xfeed };
MAGIC(arr);

char str1[] = "Hello world!";
const char *str2 = "Hello world!";
MAGIC(str1);
MAGIC(str2);

以 main 函数为例，其有两种（标准规定的）形式：

int main(void);                   // 类型为 int(void)
int main(int argc, char *argv[]); // 类型为 int(int, char *[])

C 标准不允许对函数类型应用 sizeof 运算符。

所有的指针类型都拥有相同的大小。我们将在后面的章节中讨论指针类型。

void 类型 ¶

void 是一个不完整类型，即不存在 void 类型的变量。它作为函数的返回类型，表示函数没有返回值。它作为函数的参数类型，表示函数不接受参数。

void f(void) { /* 实现略去 */ }
void g(void) {
  return f(); // 仅当 f 的返回类型为 void 时才能这样写
}

int i = 0x12345678;
void *p = &i;
printf("%p\n", p);
printf("%d\n", *(int *)p);

struct incomp;

使用 typedef 为现有的类型定义别名 ¶

int a;

你已经很熟悉这样的声明了，对吧？a 是一个 int 类型的变量。

typedef int a;

这就是说，a 现在就是 int 的别名。你可以这样使用它：

a b; // 等价于 int b;

我们之前提到过的 size_t、ptrdiff_t、int8_t 等类型，就是通过 typedef 定义的。

考试中还会要求你阅读代码片段，为形参等位置填写类型声明。请参考历年卷总结中的例题。

struct point {
  int x;
  int y;
}

typedef struct point point;

内存模型 ¶

在 C 语言的内存模型中，字节（byte）是最小的可寻址的内存单元，其被定义为一系列连续的位（bit）。可寻址意味着每个字节都拥有其编号，即地址。

MAGIC_PTR(&i);
MAGIC_PTR(&ll);
MAGIC_PTR(&d);
MAGIC_PTR(&f);

MAGIC_SIZED(f, 0x20);

地址和指针 ¶

地址是一个无符号整数，它表示内存中的一个字节。指针是一个变量，其存储了一个地址。由于这个原因，所有指针类型的大小都是相同的。

MAGIC_R(&i);
MAGIC_PTR(&i);

对象和标识符 ¶

每个被存储的值都占用一定的物理内存，这样的一块内存称为对象。对象可以储存一个或多个值。声明变量时，创建了一个标识符（identifier），其与对象相关联。

所以，定义一个变量时实际上做了两件事：

• 为对象分配内存
• 将标识符与对象关联

思维训练：

int *psi = &i;

MAGIC(i);
MAGIC_R(*psi);
MAGIC(psi);
MAGIC_PTR(&i);
MAGIC_PTR(&psi);

=====
i: 4 (0x4) bytes
0000  78 56 34 12
=====
*psi: 4 (0x4) bytes
0000  78 56 34 12
=====
psi: 8 (0x8) bytes
0000  4c ae db 6f 01 00 00 00
&i: 0x16fdbae4c
&psi: 0x16fdbae08

我们可以观察到什么？

• psi 变量的值就是 i 关联的对象的地址（0x16fdbae4c）
• 通过 psi 可以访问 i 关联的对象（*psi）
• psi 本身作为一个变量，也有自己的地址（0x16fdbae08）

const char *pc = "Good morning my neighbors";

内存管理 ¶

C 的内存管理是一大痛点，因为它本身并不提供检查机制，一切都依赖于程序员自己。因此，好好掌握内存管理对于写出安全、稳定的程序是非常必要的。

int *dangling() {
  int i = 0xdeadbeef;
  int *p = &i;
  return p;
}

int main() {
  int *pfi = dangling();
  MAGIC(pfi);
  MAGIC(*pfi);
}

在这里 pfi 称为悬垂指针（dangling pointer），它指向了一个已经被销毁的对象。使用悬垂指针是未定义行为，可能会导致程序崩溃。

char *get_a_string() {
  char str[] = "Hello world!";
  return str;
}
int main() {
  char *str = get_a_string();
  printf("%s\n", str);
}

char *get_a_string() {
  char *str = "Hello world!";
  return str;
}
int main() {
  char *str = get_a_string();
  printf("%s\n", str);
}

存储期、作用域和链接 ¶

存储期描述对象，表明在内存中存储的时间。

作用域和链接性描述标识符，表明程序的哪些部分可以使用它。

存储期 ¶

• 静态存储期（static） 在程序开始时创建，在程序结束时销毁。如全局变量和静态变量。
• 自动存储期（automatic） 在程序进入作用域时创建，在程序离开作用域时销毁。如局部变量。
• 动态分配存储期（allocated） 在程序显式地分配内存时创建，在程序显式地释放内存时销毁。如 malloc() 分配的内存。

#include <stdlib.h>
int global;
int main() {
  int automatic;
  int *allocated = malloc(sizeof(int));

  MAGIC_PTR(&global);
  MAGIC_PTR(&automatic);
  MAGIC_PTR(allocated);
}

作用域 ¶

作用域 - cppreference.com

块作用域 ¶

for(int i = 0;;)
  function();

{
  for(int i;;) {
    int i;
  }
}

函数作用域 ¶

goto 语句的标签。这意味着，即使标签在内层的块中，它的作用域也延伸至整个函数。

函数原型作用域 ¶

函数原型中的变量名。从定义处到函数原型结束。

只在你使用 VLA 时需要注意这一顺序：

void use_VLA(int n, int m, ar[n][m]);

文件作用域 ¶

在任何函数外定义的变量。从定义处到文件末尾。

这样的变量称为全局变量。

由于讲义中涉及到的内容较多，无法在一节课内全部讲解。后续的讲义将会随回放链接更新而更新。

链接 ¶

阅读和撰写类型声明 ¶