dpkg

也可以用 dpkg -L 来查看这个库包含哪里文件.
dpkg -L build-essential
dpkg

warning

前增量与后增量 运算符++variable 和variable++ 都是有效的，但它们的计算方式略有不同：

• ++x：先递增x，然后使用它的值。
• x++：先使用x的值，然后递增它。

在许多情况下，使用哪一个并不重要，因为递增或递减变量的值并未在语句中使用。例如，这两个语句是等效的（尽管第一个是该语句最常用的语法）： x++; y++;

在某些情况下，上下文会影响结果（当在语句中使用递增或递减变量的值时）。例如： x = 6; y = ++x + 2; // y is assigned 9: increment x first, then evaluate x + 2 (9) x = 6; y = x++ + 2; // y is assigned 8: evaluate x + 2 first (8), then increment x 像前面的示例一样，使用带有增量运算符的算术表达式的代码通常难以阅读，而且很容易出错。因此，通常最好避免编写这样的代码；相反，请按照您想要的顺序编写单独的语句。例如，如果您想先递增 x，然后将 x + 1 赋给 y，只需将其写为两个单独的语句即可。 替换下面的写法： y = ++x + 1; 将其换成2行: x++; y = x + 1

waring

前面的示例安全地使用了 strcpy 函数。但一般来说，strcpy 会带来安全风险，因为它假设其目标足够大以存储整个字符串，但情况可能并非总是如此（例如，如果字符串来自用户输入）。 我们选择现在显示 strcpy 是为了简化对字符串的介绍，但我们在第 2.6 节中说明了更安全的替代方案

左值

左值是可以出现在赋值语句左侧的表达式。它是一个表示内存存储位置的表达式。当我们介绍 C 指针类型以及创建组合 C 数组、结构体和指针的更复杂结构的示例时，仔细考虑类型并记住哪些 C 表达式是有效的左值（可以在左侧使用）非常重要的赋值语句）

从目前我们对 C 的了解来看，基本类型、数组元素和结构体的单个变量都是左值。静态声明的数组的名称不是左值（您无法更改内存中静态声明的数组的基地址）。以下示例代码片段根据不同类型的左值状态说明了有效和无效的 C 赋值语句：

struct studentT { 
	char name[32];
	 int  age;
	 float  gpa;
	 int   grad_yr;
};

int main(void) {
	struct studentT student1, student2;
	int x;
	char arr[10], ch;
	
	x = 10;               // Valid C: x is an lvalue;
	ch = 'm';            // Valid C: ch is an lvalue;
	student1.age = 18;   // Valid C: age field is an lvalue;
	student2 = student1;  // Valid C: student2 is an lvalue 
	arr[3] = ch;        // Valid C: arr[3] is an lvalue
	
	x + 1 = 8; // Invalid C: x+1 is not an lvalue
	arr = "hello"; // Invalid C: arr is not an lvalue
			// cannot change base addr of statically declared array
			// (use strcpy to copy the string value "hello" to arr)
	
	student1.name = student2.name; 
	 // Invalid C: name field is not an lvalue
	// (the base address of a statically
	// declared array cannot be changed)
}

</div>


^8704c9

### 1.6.4.   将结构传递给函数

在 C 中，所有类型的参数都按值传递给函数。因此，如果函数具有结构类型参数，那么当使用结构参数调用时，参数的值将传递给其形参，这意味着形参获得其形参值的副本。结构体变量的值是其内存的内容，这就是为什么我们可以在单个赋值语句中将一个结构体的字段分配为与另一个结构体相同的字段，如下所示：

```c
student2 = student1;

由于结构体变量的值代表其内存的全部内容，因此将结构体作为参数传递给函数会为参数提供所有参数结构体字段值的副本。如果函数更改结构体参数的字段值，则参数字段值的更改不会影响参数的相应字段值。也就是说，对参数字段的更改只会修改这些字段的参数内存位置中的值，而不是这些字段的参数内存位置中的值。

这是一个使用带有结构参数的 checkID 函数的完整示例程序：

#include <stdio.h>
#include <string.h>

/* struct type definition: */
struct studentT {
    char name[64];
    int  age;
    float gpa;
    int  grad_yr;
};

/* function prototype (prototype: a declaration of the
 *    checkID function so that main can call it, its full
 *    definition is listed after main function in the file):
 */
int checkID(struct studentT s1, int min_age);

int main(void) {
    int can_vote;
    struct studentT student;

    strcpy(student.name, "Ruth");
    student.age = 17;
    student.gpa = 3.5;
    student.grad_yr = 2021;

    can_vote = checkID(student, 18);
    if (can_vote) {
        printf("%s is %d years old and can vote.\n",
                student.name, student.age);
    } else {
        printf("%s is only %d years old and cannot vote.\n",
                student.name, student.age);
    }

    return 0;
}

/*  check if a student is at least the min age
 *    s: a student
 *    min_age: a minimum age value to test
 *    returns: 1 if the student is min_age or older, 0 otherwise
 */
int checkID(struct studentT s, int min_age) {
    int ret = 1;  // initialize the return value to 1 (true)

    if (s.age < min_age) {
        ret = 0;  // update the return value to 0 (false)

        // let's try changing the student's age
        s.age = min_age + 1;
    }

    printf("%s is %d years old\n", s.name, s.age);

    return ret;
}

当 main 调用 checkID 时，student 结构体的值（其所有字段的内存内容的副本）将传递给 s 参数。当函数更改其参数的年龄字段的值时，它不会影响其参数（学生）的年龄字段。通过运行该程序可以看到此行为，该程序输出以下内容：

Ruth is 19 years old
Ruth is only 17 years old and cannot vote.

输出显示，当 checkID 打印年龄字段时，它反映了函数对参数 s 的年龄字段的更改。但是，在函数调用返回后，main 会打印学生的年龄字段，其值与 checkID 调用之前的值相同。图 3 显示了 checkID 函数返回之前调用堆栈的内容。

Figure 3. The contents of the call stack before returning from the checkID function

当结构体包含静态声明的数组字段（如结构体 StudentT 中的 name 字段）时，理解结构体参数的按值传递语义尤其重要。当这样的结构体传递给函数时，结构体参数的整个内存内容（包括数组字段中的每个数组元素）都会复制到其参数中。如果函数更改了参数结构体的数组内容，则这些更改在函数返回后将不会保留。考虑到我们对数组如何传递给函数的了解，这种行为可能看起来很奇怪，但它与前面描述的结构复制行为是一致的。

1.7. Summary

在本章中，我们通过将 C 编程语言的许多部分与许多读者可能都知道的 Python 中类似的语言结构进行比较，介绍了 C 编程语言的许多部分。 C 与许多其他高级命令式和面向对象编程语言具有类似的语言功能，包括变量、循环、条件、函数和 I/O。我们讨论的 C 和 Python 功能之间的一些关键区别包括 C 要求所有变量在使用之前都必须声明为特定类型，并且 C 数组和字符串是比 Python 列表和字符串更低级别的抽象。较低级别的抽象允许 C 程序员更好地控制他们的程序如何访问其内存，从而更好地控制他们的程序的效率。

在下一章中，我们将详细介绍 C 编程语言。我们更深入地回顾了本章中介绍的许多语言特性，并介绍了一些新的 C 语言特性，最值得注意的是 C 指针变量和对动态内存分配的支持。

在前一章节已经介绍了很多c语言编程的基本概念, 现在让我们深入c语言的细节. 在这一章中我们将重新审视之前章节中的概念, 会对数组, 字符串和结构体进行更加详细的讨论. 我们也会阐述c语言的指针变量和动态内存分配. 指针提供了一种间接获得程序状态的方法, 并且动态内存分配允许一个程序去动态改变它运行所需要空间的大小, 当程序需要更大的空间时可以申请分配更多的空间, 同时当程序不需要这些空间时可以释放这些空间. 通过理解在何时以何种方式使用指针和动态内存分配, 可以让c程序设计更加强大和高效. 我们将以程序内存部分作为起始的讨论, 它将会帮助我们更好的理解后面章节主题的呈现.在后续章节, 我们将会覆盖c语言文件IO以及c语言程序库链接和源码编译汇编代码之类的进阶主题.

下面的c语言程序示例展示了函数, 参数, 本地变量和局部变量(函数简短注释)

/* An example C program with local and global variables */ 
#include <stdio.h> 

int max(int n1, int n2); /* function prototypes */ 
int change(int amt); 

int g_x; /* global variable: declared outside function bodies */ 

int main(void) { 
	int x, result; /* local variables: declared inside function bodies */ 
	
	printf("Enter a value: "); 
	scanf("%d", &x); 
	g_x = 10; /* global variables can be accessed in any function */ 
	
	result = max(g_x, x); 
	printf("%d is the largest of %d and %d\n", result, g_x, x); 
	
	result = change(10); 
	printf("g_x's value was %d and now is %d\n", result, g_x); 
	
	return 0; 

} 

int max(int n1, int n2) { /* function with two parameters */ 
	int val; /* local variable */ 
	
	val = n1; 
	if ( n2 > n1 ) { 
		val = n2; 
	} 
	return val; 
} 

int change(int amt) { 
	int val; 
	
	val = g_x; /* global variables can be accessed in any function */ 
	g_x += amt; 
	return val; 
}

这个例子展示了程序变量的不同作用范围. 变量的作用范围由它们的定义决定.换句话说, 作用范围是由代码块中的变量及其关联使用的程序内存决定.

在函数外面定义的变量是全局变量. 全局变量永久有效, 在程序的任何地方都可以被访问, 因为它们被放在特别的内存区域. 每一个全局变量必须拥有唯一的名字 ---- 在整个程序运行期间这个唯一的名字代表对一个指定存储的标识符.

局部变量和参数的作用域在函数定义的范围内. 举个例子, amt 参数的作用域在 change 函数内. 这意味着只有 change 函数内的语句才能使用 amt 参数, 并且 amt 参数也会在随着每一个 change 函数实例执行时(当函数被被调用时, 会在栈上分配空间)分配一块内存. 当函数被调用执行时, 在栈上分配参数值的空间, 当函数返回后, 参数值的空间被释放. 函数的每一次调用都会给自己参数和局部变量分配空间. 因此, 对于递归函数的运行, 每一次递归调用都会在栈上申请包含参数和局部变量的函数空间.

因为参数和局部变量的作用域在函数定义的内部, 不同的函数可以使用相同名字来代表局部变量和函数参数. 举个例子, change 和 max 函数有一样名字的局部变量 val. max 函数中的 val 变量不会改变 change 函数内部的局部变量 val, 它们的作用域都在函数内.

虽然有时可能会使用c语言的全局变量, 我们强烈建议尽可能避免使用全局变量. 使用局部变量和参数可以让代码更加模块化, 更通用, 更易于调试. 同时, 因为在函数调用时分配函数参数和局部变量空间, 这种按需分配可以让程序空间利用更加高效.

当启动一个新的程序, 操作系统会分配新的程序地址空间. 一个程序的地址空间(内存空间)代表着执行过程中所有内容存储位置, 包括存储所有的指令和数据. 程序空间可以由一系列的可寻址的字节数组组成; 程序空间中的每个使用的地址存储全部和部分的指令和数据(一些程序执行时需要的附加状态).

程序内存空间会分成几个部分, 每个部分用于在进程的地址空间中存储不同类型的代码状态实体. Figure 1对程序内存空间的各个组成部分做了说明.

Figure 1. 程序内存地址空间布局

程序内存布局的顶部(内存地址从上到下增长)保留给操作系统使用, 剩下的部分给程序使用. 程序的  code (代码段)用来存储指令. 举个例子, 上面示例程序代码段存储 main, max, change 这些函数指令.

局部变量和参数驻留在 stack(栈: 先进后出的数据存储容器)中. 随着函数的调用和返回, 堆栈空间的大小随着程序的执行而增长和收缩. 内存的堆栈的新增部分通常分配在内存底部附近(从高内存地址往低内存地址增长), 这可以为栈的改变留出空间. 当函数被调用(函数被调用时会在栈上分配对应的栈帧(stack frame))时, 局部变量和参数才会在栈上分配空间.

全局变量存储在_data_(数据段). 不像栈那样, 数据段不会增长会缩小 — 全局变量的存储空间在程序的整个运行过程中持续存在.

最后, heap (堆空间)是程序地址空间中与动态内存分配相关的部分. 堆空间一般远离栈空间, 并且堆空间随着程序的运行会进行更多的动态内存分配, 增长方向是从低内存地址往高内存地址方向增长. 这和栈空间增长方向相反.

C 的指针变量提供了间接方式访问程序内存。通过了解如何使用指针变量，程序员可以编写功能强大且高效的 C 程序。例如，通过指针变量，C 程序员可以：

1. 在调用函数栈帧中修改参数值
2. 在运行时根据需要动态分配(和释放)程序内存
3. 有效地将大型数据结构传递给函数
4. 创建链接的动态数据结构
5. 以不同的方式解释程序存储器的字节

在本节中，我们介绍 C 指针变量的语法和语义，并介绍如何在 C 程序中使用它们的常见示例。

2.2.1. Pointer Variables

指针变量可以存储特定类型值的内存位置的地址。例如，指针变量可以存储int类型的地址, 该地址上存储数值 12。指针变量 指向(引用)值。指针提供了 间接方式 来访问内存中的值。图 1 展示了指针变量在内存中的样子：

图 1. 指针变量存储内存中某个位置的地址。这里，指针存储保存数字 12 的整型变量的地址。

通过指针变量 ，可以间接访问它所指向的内存位置中存储的ptr值 (12)。 C 程序最常将指针变量用于：

1. "Pass by pointer(传指针)" 参数，用于编写可以通过指针参数修改其参数值的函数
2. 动态内存分配，用于编写在程序运行时分配(和释放)空间的程序。动态内存通常用于动态分配数组。当程序员在编译时不知道数据结构的大小（例如，数组大小取决于运行时的用户输入）时，它非常有用。它还允许在程序运行时调整数据结构的大小。

指针变量使用规则

使用指针变量的规则与常规变量类似，只不过需要考虑两种类型：指针变量的类型以及指针变量指向的内存地址中存储的类型。

1. 首先，使用以下方法声明一个指针变量type_name *var_name：

   int *ptr;   // stores the memory address of an int (ptr "points to" an int)
   char *cptr; // stores the memory address of a char (cptr "points to" a char)
   

2. 接下来，初始化指针变量(使其指向某个东西)。指针变量 存储地址值。应初始化指针来存储其类型与指针变量指向的类型相匹配的内存位置的地址。初始化指针的一种方法是对变量使用地址运算符( &) 来获取变量的地址值：

   int x;
   char ch;
   
   ptr = &x;    // ptr gets the address of x, pointer "points to" x
   cptr = &ch;  // cptr gets the address of ch, pointer "points to" ch
   

   
   图 2. 程序可以通过将合适的类型的现存变量地址分配给指针来初始化该指针。

   以下是由于类型不匹配导致的无效指针初始化的示例：

   cptr = &x;   // ERROR: cptr can hold a char memory location
                // (&x is the address of an int)
   

   尽管 C 编译器可能允许这种类型的赋值(带有有关不兼容类型的警告)，但访问和修改 xthrough的行为cptr可能不会按照程序员的预期运行。相反，程序员应该使用int *变量来指向int 存储位置。

   所有指针变量还可以分配一个特殊值NULL，它表示无效地址。虽然空指针（其值为 NULL）不应用于访问内存，但该值NULL对于测试指针变量以查看它是否指向有效的内存地址很有用。也就是说，C 程序员通常会 NULL在尝试访问指针所指向的内存位置之前检查指针，以确保其值不存在。将指针设置为NULL：

   ptr = NULL;
   cptr = NULL;
   

   图 3. 任何指针都可以被赋予特殊值 NULL，这表明它不引用任何特定地址。空指针永远不应该被取消引用。

3. 最后，使用指针变量：解引用运算符( *) 跟随指针变量到它指向的内存位置并访问该位置的值：

   /* Assuming an integer named x has already been declared, this code sets the
      value of x to 8. */
   
   ptr = &x;   /* initialize ptr to the address of x (ptr points to variable x) */
   *ptr = 8;   /* the memory location ptr points to is assigned 8 */
   

   图 4. 取消引用指针可访问指针所引用的值。

指针示例

下面是使用两个指针变量的 C 代码示例：

int *ptr1, *ptr2, x, y;

x = 8;
ptr2 = &x;     // ptr2 is assigned the address of x
ptr1 = NULL;

*ptr2 = 10;     // the memory location ptr2 points to is assigned 10
y = *ptr2 + 3;  // y is assigned what ptr2 points to plus 3

ptr1 = ptr2;   // ptr1 gets the address value stored in ptr2 (both point to x)

*ptr1 = 100;

ptr1 = &y;     // change ptr1's value (change what it points to)
*ptr1 = 80;

使用指针变量时，请仔细考虑相关变量的类型。绘制内存图片(如上所示)可以帮助理解指针代码正在做什么。一些常见错误涉及误用取消引用运算符 (*) 或地址运算符 (&)。例如：

ptr = 20;       // ERROR?:  this assigns ptr to point to address 20
ptr = &x;
*ptr = 20;      // CORRECT: this assigns 20 to the memory pointed to by ptr

如果您的程序取消引用不包含有效地址的指针变量，程序将崩溃：

ptr = NULL;
*ptr = 6;    // CRASH! program crashes with a segfault (a memory fault)

ptr = 20;
*ptr = 6;    // CRASH! segfault (20 is not a valid address)

ptr = x;
*ptr = 6;   // likely CRASH or may set some memory location with 6
            // (depends on the value of x which is used as an address value)

ptr = &x;   // This is probably what the programmer intended
*ptr = 6;

这些类型的错误说明了将指针变量初始化为 的原因之一 NULL；然后，程序可以在NULL取消引用指针之前测试指针的值：

if (ptr != NULL) {
    *ptr = 6;
}

指针参数提供了一种机制，函数可以通过该机制修改参数值。常用的指针传递(pass by pointer)模式使用指针函数参数，该参数获取调用者传递给它的 某个存储位置的地址值。例如，调用者可以传递其局部变量之一的地址。通过在函数内部取消引用(解引用)指针参数，函数可以修改其指向的存储位置处的值。

我们已经看到了与数组参数类似的功能，其中数组函数参数获取传递数组的基地址的值（该参数引用与其参数相同的数组元素集），并且该函数可以修改存储的值在数组中。一般来说，可以通过将指针参数传递给指向调用者作用域中的内存位置的函数来应用相同的想法。

以下是实现和调用带有传递指针参数的函数的步骤，每一步的代码示例如下：

1. 将函数参数声明为指向变量类型的指针：

   /* input: an int pointer that stores the address of a memory
    *        location that can store an int value (it points to an int)
    */
   int change_value(int *input) {
   

2. 进行函数调用时，传入变量的地址作为参数：

   int x;
   change_value(&x);
   

   在前面的示例中，由于参数的类型是int *，因此必须传递int类型变量的地址。

3. 在函数体内，取消引用指针参数以更改参数的值：

   *input = 100;  // the location input points to (x's memory) is assigned 100
   

接下来，让我们检查一个更大的示例程序：

#include <stdio.h>

int change_value(int *input);

int main(void) {
    int x;
    int y;

    x = 30;
    y = change_value(&x);
    printf("x: %d y: %d\n", x, y);  // prints x: 100 y: 30

    return 0;
}

/*
 * changes the value of the argument
 *     input: a pointer to the value to change
 *     returns: the original value of the argument
 */
int change_value(int *input) {
    int val;

    val = *input; /* val gets the value input points to */

    if (val < 100) {
        *input = 100;  /* the value input points to gets 100 */
    } else {
        *input =  val * 2;
    }

    return val;
}

运行时，输出为：

x: 100 y: 30

图 1显示了在 中执行 return 之前的调用堆栈change_value。

图 1. 从 change_value 返回之前的调用栈快照。

输入参数获取其参数值的副本(x的地址)。在main函数调用时x的值为30。在 change_value函数内部，参数被解引用(取消引用，取地址对应的值)，将值 100 分配给参数指向的内存位置(*input = 100; 意思是“input指向的位置设置为值 100”)。由于参数存储main函数堆栈帧中局部变量的地址，因此通过取消引用参数，可以更改调用者局部变量中存储的值。当函数返回时，参数的值反映了通过指针参数对其所做的更改(main函数中的x的值被change_value函数通过input参数修改为 100)。

除了通过指针传递参数之外, 程序通常使用指针变量来动态分配内存. 这种动态内存分配可以让c语言程序在运行时请求更多内存, 指针变量存储了动态分配内存空间的地址. 程序通常动态分配内存以调整特定运行的数组大小.

动态内存分配为程序提供了灵活性:

• 在运行时之前不需要知道数组或者其他数据结构的大小.(比如依赖用户输入的大小)
• 需要允许各种输入大小(非固定大小)
• 可以准确分配在运行时所需要的数据结构大小(避免浪费存储容量)
• 在程序运行时增长或者缩小内存分配的大小, 可以在需要时分配更多的空间, 在不需要时去释放空间.

2.4.1. Heap Memory

程序内存空间的每一个字节都有一个与之对应的地址. 程序运行所需的一切都在其内存空间中，不同类型的实体驻留在程序内存空间的不同部分. 举个例子, code(代码段)包换程序的指令, 全局变量存储在 data (数据段)中, 局部变量和参数占据 stack (栈)的空间, 动态内存来自 heap (堆)中. 因为栈和堆在运行时增长(随着函数的调用和返回以及动态内存的分配和释放), 它们通常在程序的地址空间内相距很远, 从而为程序运行留下大量的可用空间.

动态分配内存来自于程序地址空间的堆内存. 当程序在运行时动态的申请内存, 堆提供了一块内存，其地址必须分配给指针变量。

Figure 1 以栈上的指针变量(ptr)为例说明了正在运行的程序的内存部分, 该变量存储动态分配的堆内存的地址(它指向堆内存).

Figure 1. 栈上的指针指向从堆中分配的内存块.

值得注意的重点是堆空间是匿名内存, 其中"匿名"意味着堆中的地址没有与之绑定的变量名. 声明一个命名的变量会被分配在栈上(局部变量)或者出现在程序内存布局中的数据段(全局变量). 一个局部指针变量或全局指针变量可以存储匿名堆内存位置的地址(例如, 栈上的局部指针变量可以指向堆内存), 并且解引用此指针可以对堆中的数据进行操作.

2.4.2. malloc and free

malloc 和 free 都是C标准库(stdlib)中的函数, 程序可以调用它们用来分配和释放在堆中的内存. 堆内存必须由C程序显式分配(malloc)和释放(free).

为了分配堆中的内存, 调用 malloc, 传入要分配堆中的连续内存的字节总数. 使用 sizeof 操作符 计算要请求的字节数. 举个例子, 为了在堆上分配空间去存储一个整型, 程序可以进行如下调用:

// Determine the size of an integer and allocate that much heap space.
malloc(sizeof(int));

malloc 函数向调用函数返回分配的堆中内存的基地址(首地址, 或者在出错的情况下返回 NULL). 这是一个完整的示例程序，其中调用 malloc 去分配堆内存空间存储一个 int 值:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p;

    p = malloc(sizeof(int));  // allocate heap memory for storing an int

    if (p != NULL) {
        *p = 6;   // the heap memory p points to gets the value 6
    }
}

malloc 函数返回 void * 类型(万能指针), 这表示指向非指定类型(或任何类型)的通用指针. 当程序调用 malloc 并且将结果分配给指针变量时, 程序会将分配的内存与指针变量类型相关联.

有时候你可以看到调用 malloc 并将返回的类型显式地从 void * 转化为对应的指针类型. 例如:

p = (int *) malloc(sizeof(int));

在 malloc 前的 (int *) 告诉编译器把 malloc 返回的 void * 当作  int * 类型(它将 malloc 返回的类型转换为 int *). 我们将会 type recasting and the void * type章节进行更详细的讨论.

如果没有足够的堆内存满足请求分配的字节数, malloc 调用会失败. 通常来说, malloc 失败表示程序出现错误比如向 malloc 传递非常大的请求,传递负数字节, 或者在无限循环中调用 malloc 并耗尽堆内存. 因为调用 malloc 可能失败, 在指针值进行解引用前, 你应该总是对它的返回值进行空值测试(表明 malloc 失败). 对空指针进行解引用会导致程序崩溃!举个例子:

int *p;

p = malloc(sizeof(int));
if (p == NULL) {
    printf("Bad malloc error\n");
    exit(1);   // exit the program and indicate error
}
*p = 6;

当程序不再需要它在堆上通过 malloc 动态分配的内存时, 它可以通过调用 free 函数显式释放内存. 在调用 free 之后把指针的值设置为NULL也是一个好主意, 这样如果程序中的错误导致在调用free之后意外取消引用, 程序将崩溃而不是释放堆内存后供后续的调用 malloc 来重新分配(todo:考虑这句是否重新翻译). 这种意外的内存引用可能会导致未定义的程序行为, 这通常很难调试, 而空指针解引用将立即失败, 使其成为相对容易查找和修复的错误.

free(p);
p = NULL;

2.4.3. Dynamically Allocated Arrays and Strings

C程序员经常使用动态分配的内存来存储数组. 成功调用 malloc 会分配请求大小的一块连续的的堆内存. 它将这块内存的起始地址返回给调用者, 使返回的地址值适合堆内存中动态分配数组的基地址。

要为元素数组动态分配空间, 给 malloc 传递所需数组中的总字节数. 也就是说, 程序应该从 malloc 请求每个数组元素中的字节总数乘以数组中的元素数. 用  sizeof(<type>) * <number of elements> 这种表达式给 malloc 传递总字节数参数. 举个例子:

int *arr;
char *c_arr;

// allocate an array of 20 ints on the heap:
arr = malloc(sizeof(int) * 20);

// allocate an array of 10 chars on the heap:
c_arr = malloc(sizeof(char) * 10);

在本例中调用malloc之后, int指针变量arr存储堆内存中 20 个连续整数存储位置的数组的基地址, 而c_arr指针变量存储堆内存中 10 个连续字符存储位置的数组。图 2 描绘了这可能的样子。

图 2. 20元素的整型数组和10元素的字符数组在堆上分配的空间

请注意, 虽然malloc返回指向堆内存中动态分配空间的指针, 但 C 程序将该指向堆的指针存储在栈上. 指针变量仅包含堆中数组存储空间的基地址(起始地址) .就像静态声明的数组一样,动态分配的数组的内存位置位于连续的内存位置. 虽然对malloc的单次调用会导致分配所请求字节数的一块内存, 但对malloc的多次调用 不会 导致连续的堆地址(在大多数系统上). 在上面的示例中, char数组元素和int数组元素可能位于堆中相距较远的地址.

在堆空间中给数组动态分配内存中，程序可以通过指针变量来访问数组。由于指针变量的值表示堆中数组的基地址，因此我们可以使用与访问静态声明数组中的元素相同的语法来访问动态分配的数组中的元素。这里是例子:

int i;
int s_array[20];
int *d_array;

d_array = malloc(sizeof(int) * 20);
if (d_array == NULL) {
    printf("Error: malloc failed\n");
    exit(1);
}

for (i=0; i < 20; i++) {
    s_array[i] = i;
    d_array[i] = i;
}

printf("%d %d \n", s_array[3], d_array[3]);  // prints 3 3

为什么可以使用与访问静态声明数组中的元素相同的语法来访问动态分配的数组中的元素，这可能并不明显。然而, 尽管他们的类型(静态声明与动态内存分配)不同，s_array 和 d_array 的值都表示内存中的数组基址(首地址)。

表1. 静态分配 s_array 与动态分配 d_array 比较

因为两个变量的名称都表示内存中数组的基地址(数组元素首地址)，在变量后面的 [i] 的语法对于二者语义相同：[i] 对于内存中数组的相对基地址偏移 i 处的 int 类型存储位置解引用——访问第i个元素(i从0开始).

对于大多数用途，我们建议使用[i]语法来访问动态分配数组的元素。然而，程序也使用指针解引用语法(*操作符)来访问数组元素。举个例子，在引用动态分配数组的指针前面放*可以对指针解引用以访问数组下标为0的元素(数组首元素)：

/* these two statements are identical: both put 8 in index 0 */
d_array[0] = 8; // put 8 in index 0 of the d_array
*d_array = 8;   // in the location pointed to by d_array store 8

数组 描述了数组中的更多细节， 2.9.4. 指针运算 部分讨论了通过指针变量访问数组元素。

当程序使用完动态分配的数组后，它应该调用free来释放堆空间。如前所述，我们建议在释放指针后将其设置为NULL：

free(arr);
arr = NULL;

free(c_arr);
c_arr = NULL;

free(d_array);
d_array = NULL;

2.4.4. 指向堆内存的指针和函数

当给函数传递动态分配的数组时，指针变量参数的值被传递给函数(也就是把数组的首地址传递给函数)。因此，无论是传递静态声明或动态分配的数组给函数，函数参数都获得了相同的值——内存中数组的首地址。因此，同一个函数可用于相同类型的静态声明和动态分配的数组，并且可以在函数内部使用相同的语法来访问数组元素。参数声明int *arr 和 int arr[] 是等价的。但是，按照惯例，指针语法往往用于使用动态分配的数组调用的函数：

int main(void) {
    int *arr1;

    arr1 = malloc(sizeof(int) * 10);
    if (arr1 == NULL) {
        printf("malloc error\n");
        exit(1);
    }

    /* pass the value of arr1 (base address of array in heap) */
    init_array(arr1, 10);
    ...
}

void init_array(int *arr, int size) {
    int i;
    for (i = 0; i < size; i++) {
        arr[i] = i;
    }
}

在从init_array函数返回之前，内存中的内容如图三所示。注意，当main将arr1传递给init_array时，它仅传递数组的首地址(基址)。数组的大块连续内存仍然在堆上，函数可以通过解引用(dereferencing)指针参数来访问它。它还传递了数组的大小以便让init_array函数知道有多少个元素可以访问。

图3. 从 init_array 返回之前的内存内容。 main 的 arr1(实参) 和 init_array 的 arr(形参) 变量都指向同一块堆内存。

在之前的 1.5.1. 数组简介 中，我们介绍了静态声明的一维数组，并讨论了将数组传递给函数的语义。在 2.4. 动态内存分配 的章节中，我们介绍了动态分配的一维数组并讨论了将它们传递给函数的语义。

在这一章节中, 我们会更深入地了解 C 中的数组，更详细地描述静态和动态分配的数组，并讨论二维数组。

2.5.1. 一维数组

静态分配

在进入新内容之前，我们通过一个示例简要总结静态数组。有关静态声明的一维数组的更多详细信息，请参阅1.5.1. 数组简介。

静态声明的数组分配在栈上(对于局部变量)或内存的数据段(对于全局变量, 堆上)。程序员可以通过指定数组变量的类型(存储在每个索引处的类型)及其总容量(元素数量)来声明数组变量。

当将数组传递给函数时，C 会将首地址(基址)的值复制到函数参数。 也就是说，形参和实参都引用相同的内存位置 ——形参指针指向内存中实参的数组元素。因此，通过数组形参修改存储在数组中的值会修改存储在实参数组中的值。

以下是静态数组声明和使用的一些示例：

// declare arrays specifying their type and total capacity
float averages[30];   // array of float, 30 elements
char  name[20];       // array of char, 20 elements
int i;

// access array elements
for (i = 0; i < 10; i++) {
    averages[i] = 0.0 + i;
    name[i] = 'a' + i;
}
name[10] = '\0';    // name is being used for storing a C-style string

// prints: 3 d abcdefghij
printf("%g %c %s\n", averages[3], name[3], name);

strcpy(name, "Hello");
printf("%s\n", name);  // prints: Hello

动态分配

在本章的 动态内存分配部分，我们介绍了动态分配的一维数组，包括它们的访问语法以及将动态分配的数组传递给函数的语法和语义。在这里，我们通过一个示例对该信息进行简短回顾。

调用该malloc函数会在运行时在堆上动态分配一个数组。分配的堆空间的地址可以分配给全局或局部指针变量，然后该指针变量指向数组的第一个元素(首地址)。要动态分配空间，给malloc传递为数组分配的总字节数(使用sizeof运算符获取特定类型的大小)。一次malloc调用即可在堆上分配所请求大小的连续空间块。例如：

// declare a pointer variable to point to allocated heap space
int    *p_array;
double *d_array;

// call malloc to allocate the appropriate number of bytes for the array

p_array = malloc(sizeof(int) * 50);      // allocate 50 ints
d_array = malloc(sizeof(double) * 100);  // allocate 100 doubles

// always CHECK RETURN VALUE of functions and HANDLE ERROR return values
if ( (p_array == NULL) || (d_array == NULL) ) {
    printf("ERROR: malloc failed!\n");
    exit(1);
}

// use [] notation to access array elements
for (i = 0; i < 50; i++) {
    p_array[i] = 0;
    d_array[i] = 0.0;
}

// free heap space when done using it
free(p_array);
p_array = NULL;

free(d_array);
d_array = NULL;

数组内存布局

无论数组是静态声明的还是通过单次调用动态分配的malloc，数组元素都表示连续的内存位置(地址)：

 array [0]:  base address
 array [1]:  next address
 array [2]:  next address
   ...            ...
 array [99]: last address

元素的位置i位于距i数组基地址的偏移处。第 i 个元素的确切地址取决于数组中存储的类型的字节数。例如，考虑以下数组声明：

int  iarray[6];  // an array of six ints, each of which is four bytes
char carray[4];  // an array of four chars, each of which is one byte

它们各个数组元素的地址可能如下所示：

 addr   element
 ----   -------
 1230:  iarray[0]
 1234:  iarray[1]
 1238:  iarray[2]
 1242:  iarray[3]
 1246:  iarray[4]
 1250:  iarray[5]
     ...
 1280:  carray[0]
 1281:  carray[1]
 1282:  carray[2]
 1283:  carray[3]

在此示例中，1230是iarray的基地址和1280是carray的基地址。请注意，每个数组的各个元素都分配到连续的内存地址： 的每个元素iarray存储一个 4 字节int值，因此其元素地址相差 4，而 的每个元素carray存储一个 1 字节char值，因此其地址相差 1。无法保证局部变量集被分配到栈上的连续内存位置(因此，iarray的结尾和carray的开头之间的地址可能存在间隙，如此例所示。)

2.5.2. 二维数组

C 支持多维数组，但我们将多维数组的讨论限制为二维 (2D) 数组，因为一维和二维数组是 C 程序员最常用的。

静态分配的二维数组

要静态声明多维数组变量，请指定每个维度的大小。例如：

int   matrix[50][100];
short little[10][10];

这里，matrix是一个50 行100 列int 类型的二维数组，little是一个10 行 10 列short类型的二维数组。

要访问单个元素，请指定行索引和列索引：

int   val;
short num;

val = matrix[3][7];  // get int value in row 3, column 7 of matrix
num = little[8][4];  // get short value in row 8, column 4 of little

图 1将 2D 数组展示为整数值矩阵，其中 2D 数组中的特定元素通过行和列索引值进行索引。

图 1. 用矩阵表示的二维数组。访问矩阵 [2][3] 就像在第 2 行和第 3 列处对网格进行索引。

程序通常通过嵌套循环迭代来访问二维数组的元素。例如，以下嵌套循环将matrix所有元素初始化为 0：

int i, j;

for (i = 0; i < 50; i++) {  // for each row i
    for (j = 0; j < 100; j++) { // iterate over each column element in row i
        matrix[i][j] = 0;
    }
}

二维数组参数

将一维数组参数传递给函数的相同规则也适用于传递二维数组参数：形参(parameter)获取二维数组基地址的值 (&arr[0][0])。换句话说，形参(parameter)指向实参(argument)的数组元素，因此函数可以更改存储在传递的数组中的值。

对于多维数组参数，您必须指示该参数(parameter)是多维数组，但您可以不指定第一个维度的大小(为了良好的通用设计)。必须完全指定其他维度的大小，以便编译器可以生成数组中的正确偏移量。这是一个 2D 示例：

// a C constant definition: COLS is defined to be the value 100
#define COLS  (100)

/*
 * init_matrix: initializes the passed matrix elements to the
 *              product of their index values
 *   m: a 2D array (the column dimension must be 100)
 *   rows: the number of rows in the matrix
 *   return: does not return a value
 */
void init_matrix(int m[][COLS], int rows) {
    int i, j;
    for (i = 0; i < rows; i++) {
        for (j = 0; j < COLS; j++) {
            m[i][j] = i*j;
        }
    }
}

int main(void) {
    int matrix[50][COLS];
    int bigger[90][COLS];

    init_matrix(matrix, 50);
    init_matrix(bigger, 90);
    ...

matrix和bigger数组都可以作为参数传递给 init_matrix函数，因为它们具有与参数定义相同的列维度。

[!NOTE] 必须在 2D 数组的参数定义中指定列维度，以便编译器可以计算从 2D 数组基地址到特定行元素开头的偏移量。偏移计算根据内存中二维数组的布局进行。

二维数组内存布局

静态分配的二维数组在内存中按行优先顺序排列，这意味着第 0 行的所有元素排在前面，然后是第 1 行的所有元素，依此类推。例如，给出以下二维整数数组的声明：

int arr[3][4];  // int array with 3 rows and 4 columns

它在内存中的布局可能如图2所示。

图 2. 按行优先顺序排列的二维数组的布局。

请注意，所有数组元素都分配到连续的内存地址。也就是说，二维数组的基地址是[0][0] 元素 (&arr[0][0] )的内存地址，后续元素按行优先顺序连续存储(例如，整个第 1 行紧接着整个第 2 行，以此类推)。

动态分配的二维数组

动态分配的二维数组可以通过两种方式分配。对于 N x M 2D 阵列，可以：

1. 每次malloc调用，会分配一大块堆空间来存储所有 N x M 数组元素。

2. 多次调用malloc，分配数组的数组。首先，分配一个由 N 个 指向元素类型的指针组成的 1D 数组，并为 2D 数组中的每一行分配一个 1D 指针数组。然后，分配 N 个 大小为 M 的一维数组来存储二维数组中每行的列值集。将这 N 个数组(长度为M)中的第一个元素的地址(首地址)分配给第一个长度为N的数组。

变量声明、分配代码和数组元素访问语法根据程序员选择使用这两种方法中的哪一种而有所不同。

方法1:内存高效分配

在此方法中，一次调用allocate 即可分配存储_N_ x M_值数组malloc所需的字节总数。此方法的优点是内存效率更高，因为所有_N x M 元素的整个空间将立即分配在连续的内存位置中。

调用malloc返回分配空间的起始地址(数组的基地址)，该地址(如一维数组)应存储在指针变量中。事实上，使用此方法分配一维或二维数组之间没有语义差异：调用malloc在内存中返回堆上连续块分配的请求字节数的起始地址。因为使用此方法分配 2D 数组看起来就像分配 1D 数组一样，所以程序员必须在该单个堆内存空间块的顶部显式映射 2D 行和列索引(编译器没有行或列的隐式概念，因此无法将双索引语法解释到这个 malloc 分配的空间中）。

下面是使用方法 1 动态分配 2D 数组的 C 代码片段示例：

#define N 3
#define M 4

int main(void) {
    int *two_d_array;    // the type is a pointer to an int (the element type)

    // allocate in a single malloc of N x M int-sized elements:
    two_d_array = malloc(sizeof(int) * N * M);

    if (two_d_array == NULL) {
        printf("ERROR: malloc failed!\n");
        exit(1);
    }

    ...

图 3显示了使用此方法分配 2D 数组的示例，并说明了调用malloc.

图 3. 通过一次调用 malloc 分配 2D 数组的结果。

与一维动态分配数组一样，二维数组的指针变量也是在堆上分配的。然后为该指针分配调用malloc返回的值，该值表示堆内存中 N  x M 个 int类型的连续块的基地址。

由于此方法为 2D 数组使用单个 malloc 空间，因此内存分配尽可能高效(malloc整个 2D 数组只需要一次调用)。这是访问内存的更有效方法，因为所有元素都位于连续内存中，每次访问仅需要来自指针变量的单级间接访问。

但是，C 编译器不知道使用此方法进行 2D 或 1D 数组分配之间的区别。因此，使用此方法分配 2D 数组时，不能 使用静态声明的 2D 数组的双索引语法([i][j]) 。相反，程序员必须使用行和列索引值的函数([i*M + j] M其中是列维度)显式计算到堆内存的连续块中的偏移量。

下面是程序员如何构造代码来初始化 2D 数组的所有元素的示例：

// access using [] notation:
//   cannot use [i][j] syntax because the compiler has no idea where the
//   next row starts within this chunk of heap space, so the programmer
//   must explicitly add a function of row and column index values
//   (i*M+j) to map their 2D view of the space into the 1D chunk of memory
for (i = 0; i < N; i++) {
    for (j = 0; j < M; j++) {
        two_d_array[i*M + j] = 0;
    }
}

单个malloc和函数参数

通过单个malloc分配的int类型数组的基址是一个指向int的指针，因此可以将其传递给带有(int *)参数的函数。此外，该函数必须传递行和列维度，以便它可以正确计算二维数组的偏移量。例如：

/*
 * initialize all elements in a 2D array to 0
 *  arr: the array
 *  rows: number of rows
 *  cols: number of columns
 */
void init2D(int *arr, int rows, int cols) {
    int i, j;
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            arr[i*cols + j] = 0;
        }
    }
}

int main(void) {
    int *array;
    array = malloc(sizeof(int) * N * M);
    if (array != NULL) {
        init2D(array, N, M);
    }
    ...

方法 2:程序员友好的方法

动态分配 2D 数组的第二种方法将数组存储为 N 个 1D 数组的数组(每行一个 1D 数组)。它需要 N+1 次 调用 malloc：一次malloc用于行数组的数组，一次malloc用于 N 行列数组中的每一个。因此，行内的 元素位置是连续的，但元素在 2D 数组的行之间不连续。分配和元素访问不如方法 1 高效，并且变量的类型定义可能有点混乱。但是，使用此方法，程序员可以使用双索引语法来访问 2D 数组的各个元素(第一个索引是行数组的索引，第二个索引是该行内列元素数组的索引) 。

以下是使用方法 2 分配 2D 数组的示例(为了便于阅读，删除了错误检测和处理代码)：

// the 2D array variable is declared to be `int **` (a pointer to an int *)
// a dynamically allocated array of dynamically allocated int arrays
// (a pointer to pointers to ints)
int **two_d_array;
int i;

// allocate an array of N pointers to ints
// malloc returns the address of this array (a pointer to (int *)'s)
two_d_array = malloc(sizeof(int *) * N);

// for each row, malloc space for its column elements and add it to
// the array of arrays
for (i = 0; i < N; i++) {
// malloc space for row i's M column elements
    two_d_array[i] = malloc(sizeof(int) * M);
}

在此示例中，请注意传递给malloc的调用的变量类型和大小。为了引用动态分配的二维数组，程序员声明一个int **类型的变量(two_d_array)，该变量将存储动态分配的元素值int *数组的地址。two_d_array中的每个元素存储动态分配 int类型的数组的地址(two_d_array[i]的类型是int *)。

图 4显示了上述示例对 进行 N+1 次 调用malloc后内存的情况。

图 4. 使用 N+1 malloc 调用分配 2D 数组后的内存排列。

请注意，使用此方法时，只有作为单个调用的一部分分配的元素malloc在内存中是连续的。也就是说，每行内的元素是连续的，但不同行(甚至相邻行)的元素不是连续的。

分配后，可以使用双索引表示法访问二维数组的各个元素。第一个索引指定外部指针数组中的元素int *（哪一行），第二个索引指定内部数组中的元素int(行中的哪一列)。

int i, j;

for (i = 0; i < N; i++) {
    for (j = 0; j < M; j++) {
        two_d_array[i][j] = 0;
    }
}

要了解双索引的计算方式，请考虑表达式以下部分的类型和值：

   two_d_array: an array of int pointers, it stores the base address of an
             array of (int *) values. Its type is int** (a pointer to int *).

two_d_array[i]: the ith index into the array of arrays, it stores an (int *)
             value that represents the base address of an array of (int)
             values.  Its type is int*.

 two_d_array[i][j]: the jth element pointed to by the ith element of the array of
                 arrays, it stores an int value (the value in row i, column j
                 of the 2D array).  Its type is int.

数组的数组和函数参数

数组实参的类型是int **（指向 int 类型指针的指针)，并且函数形参与其参数(数组实参)的类型匹配。此外，行和列的大小应传递给函数。因为这是与方法 1 不同的类型，所以两种数组类型不能使用公共函数(它们不是相同的 C 类型)。

下面是一个示例函数，它采用方法 2(数组的数组)二维数组作为参数：

/*
 * initialize a 2D array
 * arr: the array
 * rows: number of rows
 * cols: number of columns
 */
void init2D_Method2(int **arr, int rows, int cols) {
    int i,j;

    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            arr[i][j] = 0;
        }
    }
}

/*
 * main: example of calling init2D_Method2
 */
int main(void) {
    int **two_d_array;

    // some code to allocate the row array and multiple col arrays
    // ...

    init2D_Method2(two_d_array, N, M);
    ...

这里，函数实现可以使用双索引语法。与静态声明的二维数组不同，行和列的维度都需要作为参数传递：参数rows指定最外层数组(行数组的数组)的边界，参数cols指定内部数组(数组列中每一行的值)。

在上一章中我们介绍了C 中的数组和字符串。在本章中，我们讨论动态分配的 C 字符串及其与 C 字符串库的使用。我们首先简要概述静态声明的字符串。

2.6.1. C 对静态分配字符串(字符数组)的支持

C 不支持单独的字符串类型，但在 C 程序中可以用'\0' 这个特别的空字符(零字节，null character)作为char数组的终止符来实现字符串。终止空字符表示字符串序列的结尾。并非每个字符数组都是 C 字符串，但每个 C 字符串都是char数组 。

由于字符串频繁出现在程序中，C 提供了一些库来操作字符串。使用 C 字符串库的程序需要包含string.h. 大多数字符串库函数要求程序员为函数操作的字符数组分配空间。打印字符串的值时，请使用%s占位符。

下面是一个使用字符串和一些字符串库函数的示例程序：

#include <stdio.h>
#include <string.h>   // include the C string library

int main(void) {
    char str1[10];
    char str2[10];

    str1[0] = 'h';
    str1[1] = 'i';
    str1[2] = '\0';   // explicitly add null terminating character to end

    // strcpy copies the bytes from the source parameter (str1) to the
    // destination parameter (str2) and null terminates the copy.
    strcpy(str2, str1);
    str2[1] = 'o';
    printf("%s %s\n", str1, str2);  // prints: hi ho

    return 0;
}

2.6.2.动态分配字符串

字符数组可以动态分配(如 指针 和 数组 部分中所述)。当动态分配空间来存储字符串时，请务必记住在数组中为'\0'字符串末尾的终止字符分配空间。

以下示例程序演示了静态和动态分配的字符串(注意传递给malloc的值)：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
    int size;
    char str[64];         // statically allocated
    char *new_str = NULL; // for dynamically allocated

    strcpy(str, "Hello");
    size = strlen(str);   // returns 5

    new_str = malloc(sizeof(char) * (size+1)); // need space for '\0'
    if(new_str == NULL) {
        printf("Error: malloc failed!  exiting.\n");
        exit(1);
    }
    strcpy(new_str, str);
    printf("%s %s\n", str, new_str);    // prints "Hello Hello"

    strcat(str, " There");  // concatenate " There" to the end of str
    printf("%s\n", str);    // prints "Hello There"

    free(new_str);  // free malloc'ed space when done
    new_str = NULL;

    return 0;
}

// Attempt to write a 12-byte string into a 5-character array. 
char mystr[5]; 
strcpy(mystr, "hello world"); 
// Attempt to write to a string with a NULL destination. 
char *mystr = NULL; 
strcpy(mystr, "try again"); 
// Attempt to modify a read-only string literal. 
char *mystr = "string literal value"; 
strcat(mystr, "string literals aren't writable");

2.6.3.用于操作 C 字符串和字符的库

C 提供了多个带有操作字符串和字符的函数的库。在编写使用 C 字符串的程序时，字符串库 (string.h) 特别有用。stdlib.h 和 stdio.h 库还包含用于字符串操作的函数，并且ctype.h 库包含用于操作单个字符值的函数。

使用 C 字符串库函数时，请务必记住，大多数函数不会为其操作的字符串分配空间，也不会检查您传入的字符串是否有效；您的程序必须为 C 字符串库将使用的字符串分配空间。此外，如果库函数修改了传递的字符串，调用者需要确保该字符串的格式正确(即末尾有一个终止字符\0)。使用错误的数组参数值调用字符串库函数通常会导致程序崩溃。不同库函数的文档(例如手册页)指定库函数是否分配空间，或者调用者是否负责将分配的空间传递给库函数。

strlen, strcpy, strncpy

字符串库提供了复制字符串和查找字符串长度的函数：

// returns the number of characters in the string (not including the null character)
int strlen(char *s);

// copies string src to string dst up until the first '\0' character in src
// (the caller needs to make sure src is initialized correctly and
// dst has enough space to store a copy of the src string)
// returns the address of the dst string
char *strcpy(char *dst, char *src);

// like strcpy but copies up to the first '\0' or size characters
// (this provides some safety to not copy beyond the bounds of the dst
// array if the src string is not well formed or is longer than the
// space available in the dst array); size_t is an unsigned integer type
char *strncpy(char *dst, char *src, size_t size);

当源字符串可能长于目标字符串的总容量时，使用strcpy函数是不安全的。在这种情况下，应该使用strncpy. 该size参数在 strncpy 中停止将多于size个数的字符从src字符串复制到dst 字符串中。当 src 字符串的长度大于或等于 size 时，strncpy 将 src 字符串中前 size 个字符复制到 dst 字符串中，并且不在 dst 中添加添加终止符。因此，程序员应该在调用 strncpy 后显式添加一个终止字符到 dst 字符串的末尾。

以下是在程序中使用这些函数的一些示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>   // include the string library

int main(void) {
    // variable declarations that will be used in examples
    int len, i, ret;
    char str[32];
    char *d_str, *ptr;

    strcpy(str, "Hello There");
    len = strlen(str);  // len is 11

    d_str = malloc(sizeof(char) * (len+1));
    if (d_str == NULL) {
        printf("Error: malloc failed\n");
        exit(1);
    }

    strncpy(d_str, str, 5);
    d_str[5] = '\0';   // explicitly add null terminating character to end

    printf("%d:%s\n", strlen(str), str);      // prints 11:Hello There
    printf("%d:%s\n", strlen(d_str), d_str);  // prints 5:Hello

    free(d_str);

    return 0;
}

// like strncpy but copies up to the first '\0' or size-1 characters
// and null terminates the dest string (if size > 0).
char *strlcpy(char *dest, char *src, size_t size);

// 将最多 5 个字符从 str 复制到 d_str strncpy(d_str, str, 5); 
d_str[5] = '\0'; // 显式添加空终止符到末尾

// 将最多 5 个字符从 str 复制到 d_str 
strlcpy(d_str, str, 6); // strlcpy 总是在末尾添加 '\0'

strcmp, strncmp

字符串库还提供了比较两个字符串的函数。使用==运算符比较字符串变量_不会_比较字符串中的字符 - 它仅比较两个字符串的基地址。例如，表达式：

if (d_str == str) { ...

将 d_str 指向的堆中数组的基地址与  str 指向栈上分配的数组的基地址进行比较。

要比较字符串的值，程序员需要手动编写代码来比较相应的元素值，或者使用字符串库中的strcmp或 strncmp 函数：

int strcmp(char *s1, char *s2);
// returns 0 if s1 and s2 are the same strings
// a value < 0 if s1 is less than s2
// a value > 0 if s1 is greater than s2

int strncmp(char *s1, char *s2, size_t n);
// compare s1 and s2 up to at most n characters

strcmp函数根据字符串的 ASCII 表示形式逐个字符地比较字符串。换句话说，它比较两个参数数组相应位置的char类型的值以产生字符串比较的结果，这有时会产生不直观的结果。例如，在 ASCII 编码中字符 'a' 的值大于字符 'Z' 的值。因此,  strcmp("aaa", "Zoo") 返回一个正数表示 "aaa" 比 "Zoo" 大，strcmp("aaa", "zoo") 调用返回一个负数表示 "aaa" 比 "zoo" 小。

以下是一些字符串比较示例：

strcpy(str, "alligator");
strcpy(d_str, "Zebra");

ret =  strcmp(str,d_str);
if (ret == 0) {
    printf("%s is equal to %s\n", str, d_str);
} else if (ret < 0) {
    printf("%s is less than %s\n", str, d_str);
} else {
    printf("%s is greater than %s\n", str, d_str);  // true for these strings
}

ret = strncmp(str, "all", 3);  // returns 0: they are equal up to first 3 chars

strcat, strstr, strchr

字符串库函数可以连接字符串(请注意，调用者需要确保目标字符串有足够的空间来存储结果)：

// append chars from src to end of dst
// returns ptr to dst and adds '\0' to end
char *strcat(char *dst, char *src)

// append the first chars from src to end of dst, up to a maximum of size
// returns ptr to dst and adds '\0' to end
char *strncat(char *dst, char *src, size_t size);

它还提供了在字符串中查找子字符串或字符值的函数：

// locate a substring inside a string
// (const means that the function doesn't modify string)
// returns a pointer to the beginning of substr in string
// returns NULL if substr not in string
char *strstr(const char *string, char *substr);

// locate a character (c) in the passed string (s)
// (const means that the function doesn't modify s)
// returns a pointer to the first occurrence of the char c in string
// or NULL if c is not in the string
char *strchr(const char *s, int c);

以下是使用这些函数的一些示例(为了可读性，我们省略了一些错误处理)：

char str[32];
char *ptr;

strcpy(str, "Zebra fish");
strcat(str, " stripes");  // str gets "Zebra fish stripes"
printf("%s\n", str);     // prints: Zebra fish stripes

strncat(str, " are black.", 8);
printf("%s\n", str);     // prints: Zebra fish stripes are bla  (spaces count)

ptr = strstr(str, "trip");
if (ptr != NULL) {
    printf("%s\n", ptr);   // prints: tripes are bla
}

ptr = strchr(str, 'e');
if (ptr != NULL) {
    printf("%s\n", ptr);   // prints: ebra fish stripes are bla
}

分别调用 strchr 和 strstr 返回参数数组中具有匹配字符或匹配子字符串的第一个元素的地址。该元素地址是在以 \0 结尾的 char 字符数组的开始处。换句话说，ptr指向另一个字符串内的子字符串的开头。当使用 printf 把 ptr 的值作为字符串打印时，会把 ptr 指针指向的字符数组开始之后的下标对应的字符都打印出来, 从而产生上面列出的结果。

strtok, strtok_r

字符串库还提供将字符串划分为token的函数。token(分词)是指字符串中由程序员选择的任意数量的分隔符分隔的字符子序列。

char *strtok(char *str, const char *delim);

// a reentrant version of strtok (reentrant is defined in later chapters):
char *strtok_r(char *str, const char *delim, char **saveptr);

strtok(或 strtok_r )函数在较大的字符串中查找单个标记。例如，将 strtok 的分隔符设置为空白字符集会在最初包含英语句子的字符串中生成单词。也就是说，句子中的每个单词都是字符串中的一个标记。

下面是一个示例程序，用于strtok查找单个单词作为输入字符串中的标记。(也可以从此处复制： strtokexample.c)。

/*
 * Extract whitespace-delimited tokens from a line of input
 * and print them one per line.
 *
 * to compile:
 *   gcc -g -Wall strtokexample.c
 *
 * example run:
 *   Enter a line of text:        aaaaa             bbbbbbbbb          cccccc
 *
 *   The input line is:
 *         aaaaa             bbbbbbbbb          cccccc
 *   Next token is aaaaa
 *   Next token is bbbbbbbbb
 *   Next token is cccccc
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(void) {
     /* whitespace stores the delim string passed to strtok.  The delim
      * string  is initialized to the set of characters that delimit tokens
      * We initialize the delim string to the following set of chars:
      *   ' ': space  '\t': tab  '\f': form feed  '\r': carriage return
      *   '\v': vertical tab  '\n': new line
      * (run "man ascii" to list all ASCII characters)
      *
      * This line shows one way to statically initialize a string variable
      * (using this method the string contents are constant, meaning that they
      *  cannot be modified, which is fine for the way we are using the
      *  whitespace string in this program).
      */
    char *whitespace = " \t\f\r\v\n";  /* Note the space char at beginning */

    char *token;  /* The next token in the line. */
    char *line;   /* The line of text read in that we will tokenize. */

    /* Allocate some space for the user's string on the heap. */
    line = malloc(200 * sizeof(char));
    if (line == NULL) {
        printf("Error: malloc failed\n");
        exit(1);
    }

    /* Read in a line entered by the user from "standard in". */
    printf("Enter a line of text:\n");
    line = fgets(line, 200 * sizeof(char), stdin);
    if (line == NULL) {
        printf("Error: reading input failed, exiting...\n");
        exit(1);
    }
    printf("The input line is:\n%s\n", line);

    /* Divide the string into tokens. */
    token = strtok(line, whitespace);       /* get the first token */
    while (token != NULL) {
        printf("Next token is %s\n", token);
        token = strtok(NULL, whitespace);     /* get the next token */
    }

    free(line);

    return 0;
}

sprintf

C语言 stdio 库还提供了操作 C 字符串的函数。也许最有用的是该sprintf函数，它“打印”到字符串中，而不是将输出打印到终端：

// like printf(), the format string allows for placeholders like %d, %f, etc.
// pass parameters after the format string to fill them in
int sprintf(char *s, const char *format, ...);

sprintf从各种类型的值初始化字符串的内容。它的参数format类似于printf和 的参数scanf。这里有些例子：

char str[64];
float ave = 76.8;
int num = 2;

// initialize str to format string, filling in each placeholder with
// a char representation of its arguments' values
sprintf(str, "%s is %d years old and in grade %d", "Henry", 12, 7);
printf("%s\n", str);  // prints: Henry is 12 years old and in grade 7

sprintf(str, "The average grade on exam %d is %g", num, ave);
printf("%s\n", str);  // prints: The average grade on exam 2 is 76.8

单个字符值的函数

标准 C 库(stdlib.h) 包含一组用于操作和测试各个 char 值的函数，包括：

#include <stdlib.h>   // include stdlib and ctypes to use these
#include <ctype.h>

int islower(ch);
int isupper(ch);       // these functions return a non-zero value if the
int isalpha(ch);       // test is TRUE, otherwise they return 0 (FALSE)
int isdigit(ch);
int isalnum(ch);
int ispunct(ch);
int isspace(ch);
char tolower(ch);     // returns ASCII value of lower-case of argument
char toupper(ch);

以下是它们的一些使用示例：

char str[64];
int len, i;

strcpy(str, "I see 20 ZEBRAS, GOATS, and COWS");

if ( islower(str[2]) ){
    printf("%c is lower case\n", str[2]);   // prints: s is lower case
}

len = strlen(str);
for (i = 0; i < len; i++) {
    if ( isupper(str[i]) ) {
        str[i] = tolower(str[i]);
    } else if( isdigit(str[i]) ) {
        str[i] = 'X';
    }
}
printf("%s\n", str);  // prints: i see XX zebras, goats, and cows

将字符串转换为其他类型的函数

stdlib.h 还包含在字符串和其他 C 类型之间进行转换的函数。例如：

#include <stdlib.h>

int atoi(const char *nptr);     // convert a string to an integer
double atof(const char *nptr);  // convert a string to a float

这是一个例子：

printf("%d %g\n", atoi("1234"), atof("4.56"));

有关这些和其他 C 库函数的更多信息(包括它们的用途、参数格式、返回内容以及需要包含哪些标头才能使用它们)，请参阅它们的 手册页。例如，要查看strcpy手册页，请运行：

$ man strcpy

在上一章中我们介绍了 C 结构类型。在本章中，我们将深入研究 C 结构体，检查静态和动态分配的结构体，并结合结构体和指针来创建更复杂的数据类型和数据结构。

我们首先快速概述静态声明的结构体。请参阅上一章了解更多详细信息。

2.7.1. C 结构类型回顾

结构体类型表示异构数据集合；它是一种将一组不同类型视为单个连贯单元的机制。

struct在 C 程序中定义和使用类型分为三个步骤：

1. 定义一个struct定义字段值及其类型的类型。
2. 声明struct类型的变量。
3. 使用 点表示 法访问变量中的各个字段值。

在 C 中，结构体是 1.6. 结构体-左值 (它们可以出现在赋值语句的左侧)。struct变量的值是其内存的内容(构成其字段值的所有字节)。当调用带struct参数的函数时，struct参数的值(其所有字段的所有字节的副本)被复制到 struct函数参数(形参)。

使用结构体进行编程时，特别是组合结构体和数组时，仔细考虑每个表达式的类型至关重要。struct 中的每个字段代表一种特定类型，访问字段值的语法以及将各个字段值传递给函数的语义遵循其特定类型。

以下完整的示例程序 演示了定义struct类型、声明该类型的变量、访问字段值以及将结构和单个字段值传递给函数。(为了可读性，我们省略了一些错误处理和注释)。

#include <stdio.h>
#include <string.h>

/* define a new struct type (outside function bodies) */
struct studentT {
    char  name[64];
    int   age;
    float gpa;
    int   grad_yr;
};

/* function prototypes */
int checkID(struct studentT s1, int min_age);
void changeName(char *old, char *new);

int main(void) {
    int can_vote;
    // declare variables of struct type:
    struct studentT student1, student2;

    // access field values using .
    strcpy(student1.name, "Ruth");
    student1.age = 17;
    student1.gpa = 3.5;
    student1.grad_yr = 2021;

    // structs are lvalues
    student2 = student1;
    strcpy(student2.name, "Frances");
    student2.age = student1.age + 4;

    // passing a struct
    can_vote = checkID(student1, 18);
    printf("%s %d\n", student1.name, can_vote);

    can_vote = checkID(student2, 18);
    printf("%s %d\n", student2.name, can_vote);

    // passing a struct field value
    changeName(student2.name, "Kwame");
    printf("student 2's name is now %s\n", student2.name);

    return 0;
}

int checkID(struct studentT s, int min_age) {
    int ret = 1;

    if (s.age < min_age) {
        ret = 0;
        // changes age field IN PARAMETER COPY ONLY
        s.age = min_age + 1;
    }
    return ret;
}

void changeName(char *old, char *new) {
    if ((old == NULL) || (new == NULL)) {
        return;
    }
    strcpy(old,new);
}

运行时，程序会产生：

Ruth 0
Frances 1
student 2's name is now Kwame

使用结构体时，考虑 struct 的类型及其字段尤为重要。例如，当将一个 struct 传递给函数时，参数将获取结构体值的副本(参数中所有字节的副本)。因此，对参数字段值的更改 不会 更改参数的值。前面程序中对 checkID 的调用中说明了此行为，该调用修改了参数的年龄字段。checkID 的更改对相应参数的年龄字段值没有影响。

将 struct 的字段传递给函数时，语义与字段的类型(函数参数的类型)匹配。例如，在对 changeName 的调用中，name 字段的值(结构体 student2 内部数组name的基地址)被复制到参数 old 中，这意味着形参(parameter: old)与内存中数组参数(argument:student2.name)引用相同的数组元素集。因此，更改函数中数组的元素也会更改参数中该元素的值；传递 name 字段的语义与 name 字段的类型相匹配。

2.7.2. 指针和结构体

就像其他 C 类型一样，程序员可以将变量声明为指向用户定义struct类型的指针。使用指针变量的语义struct类似于其他指针类型的语义，例如int *.

考虑struct studentT前面程序示例中引入的类型：

struct studentT {
    char  name[64];
    int   age;
    float gpa;
    int   grad_yr;
};

程序员可以声明类型 struct studentT或struct studentT *(指向 a 的指针struct studentT)的变量：

struct studentT s;
struct studentT *sptr;

// think very carefully about the type of each field when
// accessing it (name is an array of char, age is an int ...)
strcpy(s.name, "Freya");
s.age = 18;
s.gpa = 4.0;
s.grad_yr = 2020;

// malloc space for a struct studentT for sptr to point to:
sptr = malloc(sizeof(struct studentT));
if (sptr == NULL) {
    printf("Error: malloc failed\n");
    exit(1);
}

请注意调用 malloc 去初始化 sptr 指向堆内存中动态分配的结构。使用 sizeof 运算符来计算 malloc’s size request (e.g., `sizeof(struct studentT)) 确保 malloc  为结构中的 所有 字段值分配空间。

要访问指向一个 struct 的指针中的各个字段，首先需要取消引用(dereferenced)该指针变量。根据 指针取消引用 的规则 ，您可能会想访问struct如下字段：

// the grad_yr field of what sptr points to gets 2021:
(*sptr).grad_yr = 2021;

// the age field of what sptr points to gets s.age plus 1:
(*sptr).age = s.age + 1;

然而，由于指向结构体的指针非常常用，C 提供了一种特殊的运算符 ( →)，它可以取消引用一个 struct，同时访问其字段值。例如，sptr→year相当于(*sptr).year.以下是使用此表示法访问字段值的一些示例：

// the gpa field of what sptr points to gets 3.5:
sptr->gpa = 3.5;

// the name field of what sptr points to is a char *
// (can use strcpy to init its value):
strcpy(sptr->name, "Lars");

图 1概述了上述代码执行后变量s和 sptr 在内存中的样子。回想一下，malloc从堆中分配内存，而局部变量在堆栈上分配。

图 1. 静态分配的结构(栈上的数据)和动态分配的结构(堆上的数据)之间内存布局的差异。

2.7.3. 结构体中的指针字段

结构体也可以定义为将指针类型作为字段值。例如：

struct personT {
    char *name;     // for a dynamically allocated string field
    int  age;
};

int main(void) {
    struct personT p1, *p2;

    // need to malloc space for the name field:
    p1.name = malloc(sizeof(char) * 8);
    strcpy(p1.name, "Zhichen");
    p1.age = 22;


    // first malloc space for the struct:
    p2 = malloc(sizeof(struct personT));

    // then malloc space for the name field:
    p2->name = malloc(sizeof(char) * 4);
    strcpy(p2->name, "Vic");
    p2->age = 19;
    ...

    // Note: for strings, we must allocate one extra byte to hold the
    // terminating null character that marks the end of the string.
}

在内存中，这些变量将如图2所示(注意哪些部分分配在堆栈上，哪些部分分配在堆上)。

图 2. 具有指针字段的结构在内存中的布局。

随着结构及其字段类型的复杂性增加，请注意它们的语法。要正确访问字段值，请从最外层的变量类型开始，并使用其类型语法来访问各个部分。例如，表 1struct中所示的变量类型 决定了程序员应如何访问其字段。

表 1. 结构体字段访问示例

此外，了解字段值的类型允许程序使用正确的语法来访问它们，如表 2中的示例所示。

表 2. 访问不同的结构体字段类型

在检查最后一个示例时，首先考虑最外层变量的类型(p2是指向 struct personT 的指针)。因此，要访问结构体中的字段值，程序员需要使用→语法 ( p2→name)。接下来，考虑 name字段的类型 char *，在该程序中用于指向char值数组。要通过name字段访问特定char 存储位置，请使用数组索引表示法：p2→name[2] = 'a'。

2.7.4.结构体数组

数组、指针和结构体可以组合起来创建更复杂的数据结构。以下是声明不同类型的结构数组变量的一些示例：

struct studentT classroom1[40];   // an array of 40 struct studentT

struct studentT *classroom2;      // a pointer to a struct studentT
                                  // (for a dynamically allocated array)

struct studentT *classroom3[40];  // an array of 40 struct studentT *
                                  // (each element stores a (struct studentT *)

同样，为了理解在程序中使用这些变量的语法和语义，必须仔细考虑变量和字段类型。以下是访问这些变量的正确语法的一些示例：

// classroom1 is an array:
//    use indexing to access a particular element
//    each element in classroom1 stores a struct studentT:
//    use dot notation to access fields
classroom1[3].age = 21;

// classroom2 is a pointer to a struct studentT
//    call malloc to dynamically allocate an array
//    of 15 studentT structs for it to point to:
classroom2 = malloc(sizeof(struct studentT) * 15);

// each element in array pointed to by classroom2 is a studentT struct
//    use [] notation to access an element of the array, and dot notation
//    to access a particular field value of the struct at that index:
classroom2[3].year = 2013;

// classroom3 is an array of struct studentT *
//    use [] notation to access a particular element
//    call malloc to dynamically allocate a struct for it to point to
classroom3[5] = malloc(sizeof(struct studentT));

// access fields of the struct using -> notation
// set the age field pointed to in element 5 of the classroom3 array to 21
classroom3[5]->age = 21;

采用类型数组struct studentT作为参数的函数可能如下所示：

void updateAges(struct studentT *classroom, int size) {
    int i;

    for (i = 0; i < size; i++) {
        classroom[i].age += 1;
    }
}

程序可以向此函数传递静态或动态分配的数组struct studentT：

updateAges(classroom1, 40);
updateAges(classroom2, 15);

classroom1传递( 或classroom2) 给 updateAges 的语义与将静态声明(或动态分配)数组传递给函数的语义相匹配：形参(parameter)与实参(argument)引用相同的元素集，因此函数内数组值的更改会影响实参数组的元素。

图 3显示了第二次调用该函数时堆栈的样子updateAges(显示了传递的classroom2数组，其中每个元素中都有结构体的示例字段值)。

图 3. 传递给函数的 struct StudentT 数组的内存布局。

与往常一样，参数获取其参数值的副本(堆内存中数组的内存地址)。因此，修改函数中数组的元素将保留其参数的值(形参(parameter)和实参(argument)都引用内存中的同一数组)。

该updateAges函数无法传递classroom3数组，因为它的类型与参数的类型不同：classroom3是 struct studentT * 的数组，而不是 struct studentT 的数组。

2.7.5. 自指结构(数据结构)

一个结构体可以定义一个指向与自己类型相同的 struct 字段。这些自引用(self-referential)的 struct 类型可用于构建数据结构的链接实现，例如链表、树和图。

这些数据类型及其链接实现的详细信息超出了本书的范围。然而，我们简要展示了一个如何在 C 中定义和使用自引用struct类型来创建链表的示例。有关链表的更多信息，请参阅数据结构和算法教科书。

链表是实现列表抽象数据类型的一种方法。列表表示按元素在列表中的位置排序的元素序列。在 C 语言中，列表数据结构可以实现为数组或链表，使用自引用 struct 类型来存储列表中的各个节点。

为了构建后者，程序员将定义一个 node 结构体来包含一个列表元素和到列表中下一个节点的链接。下面是一个可以存储整数值链接列表的示例：

struct node {
    int data;           // used to store a list element's data value
    struct node *next;  // used to point to the next node in the list
};

这种类型的实例struct可以通过 next字段链接在一起以创建链表。

head 此示例代码片段创建一个包含三个元素的链表(该列表本身由指向列表中第一个节点的变量引用)：

struct node *head, *temp;
int i;

head = NULL;  // an empty linked list

head = malloc(sizeof(struct node));  // allocate a node
if (head == NULL) {
    printf("Error malloc\n");
    exit(1);
}
head->data = 10;    // set the data field
head->next = NULL;  // set next to NULL (there is no next element)

// add 2 more nodes to the head of the list:
for (i = 0; i < 2; i++) {
    temp = malloc(sizeof(struct node));  // allocate a node
    if (temp == NULL) {
        printf("Error malloc\n");
        exit(1);
    }
    temp->data = i;     // set data field
    temp->next = head;  // set next to point to current first node
    head = temp;        // change head to point to newly added node
}

请注意，该temp变量临时指向一个被初始化的 malloc 的 node 节点 ，然后通过将其 next 字段设置为指向当前 head 指向的节点(头结点)，然后将 head 更改为指向这个新节点(temp指向的节点)，将其添加到列表的开头。

执行此代码的结果在内存中类似于图 4。

图 4. 三个示例链表节点在内存中的布局。

C 支持许多执行标准 I/O 和文件 I/O 的函数。在本节中，我们将讨论一些最常用的 C 语言 I/O 接口。

2.8.1.标准输入/输出

每个正在运行的程序都以三个默认 I/O 流开始：标准输出 (stdout)、标准输入 (stdin) 和标准错误 (stderr)。程序可以将输出写入(打印)到 和stdout，stderr并且可以从 stdin 读取输入值。stdin 通常定义为从键盘读取输入，而 stdout 和 stderr 输出到终端。

C标准库stdio.h提供了printf用于打印到标准输出的函数以及scanf可用于从标准输入读入值的函数。C 还具有一次读写一个字符的函数 (getchar和putchar)，以及其他用于向标准 I/O 流读取和写入字符的函数和库。 一个 C 程序必须显式包含stdio.h调用这些函数。

您可以更改正在运行的程序的读取或写入的stdin stdout 或 stderr 的位置。实现此目的的一种方法是重定向其中一个或全部以读取或写入文件。以下是一些示例 shell 命令，用于将程序的stdin、stdout 或 stderr 重定向到文件($是 shell 提示符)：

#  redirect a.out's stdin to read from file infile.txt:
$ ./a.out < infile.txt

#  redirect a.out's stdout to print to file outfile.txt:
$ ./a.out > outfile.txt

# redirect a.out's stdout and stderr to a file out.txt
$ ./a.out &> outfile.txt

# redirect all three to different files:
#   (< redirects stdin, 1> stdout, and 2> stderr):
$ ./a.out < infile.txt 1> outfile.txt 2> errorfile.txt

printf

C 程序的printf函数类似于 Python 中的print格式化调用，其中调用者指定要打印的格式字符串。格式字符串通常包含特殊格式说明符，包括将打印制表符 (\t) 或换行符 (\n) 的特殊字符，或者为输出中的值指定占位符(% 后跟类型说明符)。在传递给 printf 的格式字符串中添加占位符时，请将其相应的值作为格式字符串后面的附加参数传递。以下是一些printf 调用示例：

printf.c

int x = 5, y = 10;
float pi = 3.14;

printf("x is %d and y is %d\n", x, y);

printf("%g \t %s \t %d\n", pi, "hello", y);

运行时，这些printf语句输出：

x is 5 and y is 10
3.14 	 hello 	 10

请注意制表符 (\t) 在第二次调用中如何打印，以及不同类型值的不同格式占位符（%g、%s和%d）。

下面是一组常见 C 类型的格式化占位符。请注意，long和值的占位符long long包含lorll前缀。

%f, %g: placeholders for a float or double value
%d:     placeholder for a decimal value (char, short, int)
%u:     placeholder for an unsigned decimal
%c:     placeholder for a single character
%s:     placeholder for a string value
%p:     placeholder to print an address value

%ld:    placeholder for a long value
%lu:    placeholder for an unsigned long value
%lld:   placeholder for a long long value
%llu:   placeholder for an unsigned long long  value

以下是它们的一些使用示例：

float labs;
int midterm;

labs = 93.8;
midterm = 87;

printf("Hello %s, here are your grades so far:\n", "Tanya");
printf("\t midterm: %d (out of %d)\n", midterm, 100);
printf("\t lab ave: %f\n", labs);
printf("\t final report: %c\n", 'A');

运行时，输出将如下所示：

Hello Tanya, here are your grades so far:
	 midterm: 87 (out of 100)
	 lab ave: 93.800003
	 final report: A

C 还允许您使用格式占位符指定字段宽度。这里有些例子：

%5.3f: print float value in space 5 chars wide, with 3 places beyond decimal
%20s:  print the string value in a field of 20 chars wide, right justified
%-20s: print the string value in a field of 20 chars wide, left justified
%8d:   print the int value in a field of 8 chars wide, right justified
%-8d:  print the int value in a field of 8 chars wide, left justified

这是一个更大的示例，在格式字符串中使用带有占位符的字段宽度说明符：

printf_format.c

#include <stdio.h> // library needed for printf

int main(void) {
    float x, y;
    char ch;

    x = 4.50001;
    y = 5.199999;
    ch = 'a';      // ch stores ASCII value of 'a' (the value 97)

    // .1: print x and y with single precision
    printf("%.1f %.1f\n", x, y);

    printf("%6.1f \t %6.1f \t %c\n", x, y, ch);

    // ch+1 is 98, the ASCII value of 'b'
    printf("%6.1f \t %6.1f \t %c\n", x+1, y+1, ch+1);

    printf("%6.1f \t %6.1f \t %c\n", x*20, y*20, ch+2);
    return 0;
}

运行时，程序输出如下所示：

4.5 5.2
   4.5 	    5.2 	 a
   5.5 	    6.2 	 b
  90.0 	  104.0 	 c

请注意最后三个语句中制表符和字段宽度的使用如何printf 产生表格输出。

最后，C 定义了用于以不同表示形式显示值的占位符：

%x:     print value in hexadecimal (base 16)
%o:     print value in octal (base 8)
%d:     print value in signed decimal  (base 10)
%u:     print value in unsigned decimal (unsigned base 10)
%e:     print float or double in scientific notation
(there is no formatting option to display a value in binary)

以下是使用占位符以不同表示形式打印值的示例：

int x;
char ch;

x = 26;
ch = 'A';

printf("x is %d in decimal, %x in hexadecimal and %o in octal\n", x, x, x);
printf("ch value is %d which is the ASCII value of  %c\n", ch, ch);

运行时，程序输出如下所示：

x is 26 in decimal, 1a in hexadecimal and 32 in octal
ch value is 65 which is the ASCII value of  A

scanf

该scanf函数提供了一种从stdin (通常是用户通过键盘输入的值)读取值并将其存储在程序变量中的方法。该scanf函数对用户输入数据的确切格式有点挑剔，这可能使其对用户输入的格式错误敏感。

该函数的参数scanf与 printf 的参数类似： scanf采用格式字符串，指定要读入的输入值的数量和类型，后跟应存储这些值的程序变量的 位置 。程序通常将 取地址 运算符(&) 与变量名称组合起来，以生成变量在程序内存中的位置 — 变量的内存地址。以下是scanf读取两个值(一个int和一个float)的调用示例：

scanf_ex.c

int x;
float pi;

// read in an int value followed by a float value ("%d%g")
// store the int value at the memory location of x (&x)
// store the float value at the memory location of pi (&pi)
scanf("%d%g", &x, &pi);

各个输入值必须由至少一个空白字符(例如空格、制表符、换行符)分隔。但是，scanf在查找每个数字文字值的开头和结尾时，会跳过前导和尾随空白字符。因此，用户可以输入值 8 和 3.14，并在这两个值之前或之后输入任意数量的空格(并且之间至少有一个或多个空格字符)，并且scanf将始终读取 8 并将其分配给 x ，3.14 并读取并将其分配给 pi 。例如，两个值之间有大量空格的输入将导致读取 8 并将其存储在x、 和 3.14 中并存储在pi：

       8                   3.14

程序员经常编写scanf仅由占位符说明符组成的格式字符串，中间不包含任何其他字符。为了读取上面的两个数字，格式字符串可能如下所示：

// read in an int and a float separated by at least one white space character
scanf("%d%g",&x, &pi);

getchar and putchar

C 函数 getchar 和 putchar 分别从 stdin 和 stdout 读取或写入单个字符值。 getchar 在需要支持仔细的错误检测和处理格式错误的用户输入的 C 程序中特别有用(scanf 这种方式并不健壮)。

ch = getchar();  // read in the next char value from stdin
putchar(ch);     // write the value of ch to stdout

2.8.2.文件输入/输出

C 标准 I/O 库 ( stdio.h) 包括用于文件 I/O 的流接口。文件存储持久数据：在创建它的程序执行之后仍然存在的数据。文本文件代表字符流，每个打开的文件都会跟踪其在字符流中的当前位置。打开文件时，当前位置从文件中的第一个字符开始，并且读(或写)随着文件中的每个字符而移动。要读取文件中的第 10 个字符，需要首先读取前 9 个字符(或者必须使用该fseek函数将当前位置显式移动到第 10 个字符)。

C 的文件接口将文件视为输入或输出流，库函数读取或写入文件流中的下一个位置。fprintf 和 fscanf 函数充当 printf 和 scanf 文件 I/O 的对应项。它们使用格式字符串来指定要写入或读取的内容，并且它们包含为写入或读取的数据提供值或存储的参数。类似地，该库提供了fputc、fgetc、fputs和fgets 函数，用于读取或者写入单个字符或字符串到其文件流。虽然C语言中有很多支持文件I/O的库，但我们仅详细介绍 stdio.h 库中文本文件的流接口。

文本文件可能包含特殊字符，如stdin和stdout流：换行符 ( '\n')、水平制表符 ( '\t') 等。此外，到达文件数据末尾时，C 的 I/O 库会生成一个特殊的文件结束符 ( EOF)，表示文件末尾。从文件读取的函数可以进行EOF测试确定它们何时到达文件流的末尾。

2.8.3.在 C 中使用文本文件

要在 C 中读取或写入文件，请按照下列步骤操作：

1. 声明 一个FILE *变量：

   FILE *infile;
   FILE *outfile;
   

   这些声明创建指向库定义FILE * 类型的指针变量。这些指针不能在应用程序中取消引用。相反，它们在传递给 I/O 库函数时引用特定的文件流。

2. 打开 文件：通过调用 fopen 将变量与实际文件流关联起来。打开文件时，模式 参数决定程序是否以读取 ( "r")、写入 ( "w") 或追加 ( "a") 方式打开文件：

   infile = fopen("input.txt", "r");  // relative path name of file, read mode
   if (infile == NULL) {
       printf("Error: unable to open file %s\n", "input.txt");
       exit(1);
   }
   
   // fopen with absolute path name of file, write mode
   outfile = fopen("/home/me/output.txt", "w");
   if (outfile == NULL) {
       printf("Error: unable to open outfile\n");
       exit(1);
   }
   

   fopen函数返回 NULL 来报告错误，如果给定的文件名无效或用户没有打开指定文件的权限(例如，没有对该output.txt 文件的写入权限)，则可能会发生这种情况。

3. 使用 I/O 操作来读取、写入或移动文件中的当前位置：

   int ch;  // EOF is not a char value, but is an int.
            // since all char values can be stored in int, use int for ch
   
   ch = getc(infile);      // read next char from the infile stream
   if (ch != EOF) {
       putc(ch, outfile);  // write char value to the outfile stream
   }
   

4. 关闭 文件：当程序不再需要该文件时用 fclose 关闭该文件：

   fclose(infile);
   fclose(outfile);
   

该stdio库还提供了更改文件中当前位置的函数：

// to reset current position to beginning of file
void rewind(FILE *f);

rewind(infile);

// to move to a specific location in the file:
fseek(FILE *f, long offset, int whence);

fseek(f, 0, SEEK_SET);    // seek to the beginning of the file
fseek(f, 3, SEEK_CUR);    // seek 3 chars forward from the current position
fseek(f, -3, SEEK_END);   // seek 3 chars back from the end of the file

2.8.4.stdio.h文件中的标准和文件 I/O 函数

C程序 stdio.h 库具有许多用于读取和写入文件以及标准类文件流(stdin、stdout和stderr)的函数。这些函数可以分为基于字符、基于字符串和格式化 I/O 函数。简而言之，以下是有关这些函数子集的一些其他详细信息：

// ---------------
// Character Based
// ---------------

// returns the next character in the file stream (EOF is an int value)
int fgetc(FILE *f);

// writes the char value c to the file stream f
// returns the char value written
int fputc(int c, FILE *f);

// pushes the character c back onto the file stream
// at most one char (and not EOF) can be pushed back
int ungetc(int c, FILE *f);

// like fgetc and fputc but for stdin and stdout
int getchar();
int putchar(int c);

// -------------
// String  Based
// -------------

// reads at most n-1 characters into the array s stopping if a newline is
// encountered, newline is included in the array which is '\0' terminated
char *fgets(char *s, int n, FILE *f);

// writes the string s (make sure '\0' terminated) to the file stream f
int fputs(char *s, FILE *f);

// ---------
// Formatted
// ---------

// writes the contents of the format string to file stream f
//   (with placeholders filled in with subsequent argument values)
// returns the number of characters printed
int fprintf(FILE *f, char *format, ...);

// like fprintf but to stdout
int printf(char *format, ...);

// use fprintf to print stderr:
fprintf(stderr, "Error return value: %d\n", ret);

// read values specified in the format string from file stream f
//   store the read-in values to program storage locations of types
//   matching the format string
// returns number of input items converted and assigned
//   or EOF on error or if EOF was reached
int fscanf(FILE *f, char *format, ...);

// like fscanf but reads from stdin
int scanf(char *format, ...);

一般来说，scanf和fscanf对格式错误的输入很敏感。然而，对于文件 I/O，程序员通常可以假设输入文件格式良好，因此 fscanf 在这种情况下可能足够健壮。使用 scanf 时，格式错误的用户输入通常会导致程序崩溃。一次读入一个字符并在将值转换为不同类型之前包含测试值的代码更加可靠，但它要求程序员实现更复杂的 I/O 功能。

fscanf 的格式字符串可以包含以下语法，指定不同类型的值以及从文件流读取的方式：

%d integer
%f float
%lf double
%c character
%s string, up to first white space

%[...] string, up to first character not in brackets
%[0123456789] would read in digits
%[^...] string, up to first character in brackets
%[^\n] would read everything up to a newline

获得fscanf正确的格式字符串可能很棘手，特别是在从文件中读取混合数字和字符串或字符类型时。

下面是一些使用不同格式字符串调用fscanf(和 fprintf ) 的示例(假设 fopen 上面的调用已成功执行)：

int x;
double d;
char c, array[MAX];

// write int & char values to file separated by colon with newline at the end
fprintf(outfile, "%d:%c\n", x, c);

// read an int & char from file where int and char are separated by a comma
fscanf(infile, "%d,%c", &x, &c);

// read a string from a file into array (stops reading at whitespace char)
fscanf(infile,"%s", array);

// read a double and a string up to 24 chars from infile
fscanf(infile, "%lf %24s", &d, array);

// read in a string consisting of only char values in the specified set (0-5)
// stops reading when...
//   20 chars have been read OR
//   a character not in the set is reached OR
//   the file stream reaches end-of-file (EOF)
fscanf(infile, "%20[012345]", array);

// read in a string; stop when reaching a punctuation mark from the set
fscanf(infile, "%[^.,:!;]", array);

// read in two integer values: store first in long, second in int
// then read in a char value following the int value
fscanf(infile, "%ld %d%c", &x, &b, &c);

在上面的最后一个示例中，格式字符串显式读取数字后面的字符值，以确保文件流的当前位置对于任何后续调用 fscanf 都正确前进。例如，此模式通常用于显式读入(并丢弃)空白字符(如“\n”)，以确保下一次调用fscanf从文件中的下一行开始。如果 下一次 调用fscanf尝试读入字符值，则需要读取附加的字符 。否则，在没有消耗换行符的情况下，下一次调用fscanf将读取换行符而不是预期的字符。如果下一次调用读取数字类型值，则前导空白字符将被 fscanf 自动丢弃，并且程序员不需要显式地从文件流中读取\n该字符。

几乎所有的 C 编程语言都已在前面的章节中介绍过。在本节中，我们将介绍一些剩余的高级 C 语言功能以及一些高级 C 编程和编译主题：

• C 常量、switch语句、枚举类型和 typedef
• 命令行参数
• 类型void *和类型重铸
• 指针算术
• C 库：使用、编译和链接
• 编写和使用您自己的 C 库 （并将您的程序划分为多个模块（.c和.h文件））
• 将 C 源代码编译为汇编代码。

lvalue 左值的概念(todo)

2.9.1. 常量,switch和typedef

常量、switch 语句、枚举类型和 typedef 是 C 语言的功能，可用于创建更具可读性和可维护性的代码。常量、枚举类型和 typedef 用于定义程序中文字值和类型的别名。 switch 语句可以用来代替一些链接if-else if语句。

C Constants(常量)

常量是 C 字面值的别名。使用常量代替文字值以使代码更具可读性且更易于修改。在 C 中，常量是使用以下语法在函数体外部定义的：

#define const_name (literal_value)

以下是定义和使用三个常量(N 、PI和NAME)的部分程序示例：

#include <stdio.h>
#include <stdlib.h>

#define N    (20)        // N:  alias for the literal value 20
#define PI   (3.14)      // PI: alias for the literal value 3.14
#define NAME ("Sarita")  // NAME: alias for the string literal "Sarita"

int main(void) {
  int array[N];   // an array of 20 ints
  int *d_arr, i;
  double area, circ, radius;

  radius = 12.3;
  area = PI*radius*radius;
  circ = 2*PI*radius;

  d_arr = malloc(sizeof(int)*N);
  if(d_arr == NULL) {
    printf("Sorry, %s, malloc failed!\n", NAME);
    exit(1);
  }
  for(i=0; i < N; i++) {
    array[i] = i;
    d_arr[i] = i*2;
  }
  ...

使用常量使代码更具可读性(在表达式中，PI比 更有意义3.14)。使用常量还可以使代码更容易修改。例如，要改变上面程序中数组的界限和pi值的精度，程序员只需要改变它们的常量定义并重新编译即可；所有使用该常量的代码都将使用它们的新值。例如：

#define N    (50)        // redefine N from 20 to 50
#define PI   (3.14159)   // redefine PI to higher precision

int main(void) {
  int array[N];  // now allocates an array of size 50
  ...
  area = PI*radius*radius;        // now uses 3.14159 for PI
  d_arr = malloc(sizeof(int)*N);  // now mallocs array of 50 ints
  ...
  for(i=0; i < N; i++) {    // now iterates over 50 elements
  ...

重要的是要记住，常量不是左值——它们是 C 类型字面量(文字值)的别名。因此，它们的值不能像变量那样在运行时更改。例如，以下代码会导致编译错误：

#define N  20

int main(void) {
  ...
  N = 50;  // compilation error: `20 = 50` is not valid C

Switch 语句

C switch语句可用于代替部分(但不是全部)链接 if代码和 else if 序列。虽然switch不为 C 编程语言提供任何额外的表达能力，但它通常会产生更简洁的代码分支序列。它还可以允许编译器生成比等效链接代码更有效执行的分支if 和 else if 代码。

语句的 C 语法switch如下所示：

switch (<expression>) {

   case <literal value 1>:
        <statements>;
        break;         // breaks out of switch statement body
   case <literal value 2>:
        <statements>;
        break;         // breaks out of switch statement body
   ...
   default:            // default label is optional
        <statements>;
}

switch语句的执行过程如下：

1. 首先对expression求值。
2. 接下来，switch搜索与case表达式的值匹配的字面量值(文字值)。
3. 找到匹配的case文字后，它开始执行紧随其后的语句。
4. 如果没有case找到匹配，它将开始执行标签中的语句 default(如果存在)。
5. 否则，语句主体中的任何语句switch都不会被执行。

关于switch语句的一些规则：

• 与每个关联的值case必须是字面量值(文字值) - 它 不能 是表达式。原始表达式 仅与与每个关联的文字值进行 相等 case匹配。
• 到达break语句将停止该语句体内所有剩余语句的执行switch。也就是说，break跳出语句主体switch并继续执行整个块之后的下一条语句switch。
• 具有匹配值的语句标记case将要执行的 C 语句序列的起点 - 执行跳转到主体内的某个位置switch以开始执行代码。因此，如果特定 case 的末尾没有 break 语句，则后续语句下的case语句将按顺序执行，直到执行一条 break 语句或到达 switch 语句体的末尾。
• 标签default是可选的。如果存在，则必须位于末尾。

这是一个带有语句的示例程序switch：

#include <stdio.h>

int main(void) {
    int num, new_num = 0;

    printf("enter a number between 6 and 9: ");
    scanf("%d", &num);

    switch(num) {
        case 6:
            new_num = num + 1;
            break;
        case 7:
            new_num = num;
            break;
        case 8:
            new_num = num - 1;
            break;
        case 9:
            new_num = num + 2;
            break;
        default:
            printf("Hey, %d is not between 6 and 9\n", num);
    }
    printf("num %d  new_num %d\n", num, new_num);
    return 0;
}

以下是此代码的一些运行示例：

./a.out
enter a number between 6 and 9: 9
num 9  new_num 11

./a.out
enter a number between 6 and 9: 6
num 6  new_num 7

./a.out
enter a number between 6 and 9: 12
Hey, 12 is not between 6 and 9
num 12  new_num 0

枚举类型

枚举类型(enum)是一种定义一组相关整型常量的方法。 switch 语句和枚举类型经常一起使用。

枚举类型应在函数体外部定义，使用以下语法(enum是 C 中的关键字)：

enum type_name {
   CONST_1_NAME,
   CONST_2_NAME,
   ...
   CONST_N_NAME
};

请注意，常量字段由逗号分隔的名称列表指定，并且不是显式给出的值。默认情况下，列表中的第一个常量被分配值 0，第二个常量被分配值 1，依此类推。

下面是为一周中的几天定义枚举类型的示例：

enum days_of_week {
   MON,
   TUES,
   WED,
   THURS,
   FRI
};

枚举类型值的变量使用类型名称来声明 enum type_name，并且它定义的常量值可以在表达式中使用。例如：

enum days_of_week day;

day = THURS;

if (day > WED) {
  printf("The weekend is arriving soon!\n");
}

枚举类型类似于定义一组常量，#define 如下所示：

#define MON    0
#define TUES   1
#define WED    2
#define THURS  3
#define FRI    4

枚举类型中的常量值的使用方式与常量的使用方式类似，可以使程序更易于阅读，代码更易于更新。然而，枚举类型的优点是可以将一组相关的整数常量组合在一起。它也是一个类型定义，因此变量和参数可以声明为枚举类型，而常量是文字值的别名。此外，在枚举类型中，每个常量的具体值都是从 开始按顺序隐式分配的0，因此程序员不必指定每个常量的值。

枚举类型的另一个很好的功能是可以轻松地在集合中添加或删除常量，而无需更改它们的所有值。例如，如果用户想要将星期六和星期日添加到日期集中并维护日期的相对顺序，他们可以将它们添加到枚举类型定义中，而不必像需要时那样显式地重新定义其他值使用#define常量定义：

enum days_of_week {
   SUN,        // SUN will now be 0
   MON,        // MON will now be 1, and so on
   TUES,
   WED,
   THURS,
   FRI,
   SAT
};

尽管值被隐式分配给枚举类型的常量，但程序员也可以使用= val语法为它们分配特定的值。例如，如果程序员希望星期几的值从 1 而不是 0 开始，他们可以执行以下操作：

enum days_of_week {
   SUN = 1,  // start the sequence at 1
   MON,      // this is 2 (next value after 1)
   TUES,     // this is 3, and so on
   WED,
   THURS,
   FRI,
   SAT
};

由于枚举类型为一组int文字值定义了别名，因此枚举类型的值将作为其int值而不是别名的名称打印出来。例如，给定上述 enum days_of_week 的定义，以下打印内容3不打印字符串"TUES"：

enum days_of_week day;

day = TUES;
printf("Today is %d\n", day);

枚举类型通常与 switch 语句结合使用，如下面的示例代码所示。该示例还显示了一个 switch 语句，其中多个 case 语句关联同一组语句, 某个 case 语句在下一个 case 语句前没有 break 语句(当 val 是 FRI, 两个 printf 语句会在遇到break语句之前执行, 因为在 break 之前 MON 和 WED 中的只有一个 printf语句)：

// an int because we are using scanf to assign its value
int val;

printf("enter a value between %d and %d: ", SUN, SAT);
scanf("%d", &val);

switch (val) {
  case FRI:
     printf("Orchestra practice today\n");
  case MON:
  case WED:
     printf("PSYCH 101 and CS 231 today\n");
     break;
  case TUES:
  case THURS:
     printf("Math 311 and HIST 140 today\n");
     break;
  case SAT:
     printf("Day off!\n");
     break;
  case SUN:
     printf("Do weekly pre-readings\n");
     break;
  default:
     printf("Error: %d is not a valid day\n", val);
};

类型定义( typedef)

C 提供了一种使用关键字定义新类型的方法，该新类型是现有类型的别名typedef。定义后，可以使用该类型的新别名来声明变量。此功能通常用于使程序更具可读性并使用较短的类型名称(通常用于结构和枚举类型)。以下是定义新类型的格式typedef：

typedef existing_type_name new_type_alias_name;

下面是一个使用 typedef 的部分程序示例：

#define MAXNAME  (30)
#define MAXCLASS (40)

enum class_year {
  FIRST = 1,
  SECOND,
  JUNIOR,
  SENIOR,
  POSTGRAD
};

// classYr is an alias for enum class_year
typedef enum class_year classYr;

struct studentT {
  char name[MAXNAME];
  classYr year;     // use classYr type alias for field type
  float gpa;
};

// studentT is an alias for struct studentT
typedef struct studentT  studentT;

// ull is an alias for unsigned long long
typedef unsigned long long ull;

int main(void) {

  // declare variables using typedef type names
  studentT class[MAXCLASS];
  classYr yr;
  ull num;

  num = 123456789;
  yr = JUNIOR;
  strcpy(class[0].name, "Sarita");
  class[0].year = SENIOR;
  class[0].gpa = 3.75;

  ...

由于 typedef 通常与结构一起使用，因此 C 提供了将 typedef 和结构定义组合在一起的语法，方法是在结构定义中添加前缀 typedef 并在结构定义的结束后 } 列出类型别名的名称。例如，以下定义了struct studentT名为 的类型的结构类型和别名studentT：

typedef struct studentT {
  char name[MAXNAME];
  classYr year;     // use classYr type alias for field type
  float gpa;
} studentT;

此定义相当于在结构体定义之后单独进行 typedef，如上例所示。

2.9.2. 命令行参数(Command Line Arguments)

通过读取命令行参数可以使程序变得更加通用，这些参数作为用户输入的运行二进制可执行程序的命令的一部分包含在内。它们指定更改程序运行时行为的输入值或选项。换句话说，使用不同的命令行参数值运行程序会导致程序的行为在不同的运行中发生变化，而无需修改程序代码并重新编译它。例如，如果程序将输入文件名的名称作为命令行参数，则用户可以使用任何输入文件名运行它，而不是在代码中引用特定输入文件名的程序。

用户提供的任何命令行参数都会作为参数值传递给main函数。要编写接受命令行参数的程序，main函数的定义必须包含两个参数：argc和argv：

int main(int argc, char *argv[]) { ...

请注意，第二个参数的类型也可以表示为char **argv。

第一个参数 argc 存储参数计数。它的值表示传递给主函数的命令行参数的数量(包括程序的名称)。例如，如果用户输入

./a.out 10 11 200

那么argc将保存值 4(a.out算作第一个命令行参数，10、11和200算作其他三个参数)。

第二个参数 argv 存储参数向量。它包含每个命令行参数的值。每个命令行参数都作为字符串值传入，因此argv的类型是一个字符串数组(或一个char数组)。 argv 数组包含 argc + 1 个元素。第一个argc元素存储命令行参数字符串，最后一个元素存储NULL，表示命令行参数列表的结尾。例如，在上面输入的命令行中，argv数组将类似于图 1：

图 1. 传递给 main 的 argv 参数是一个字符串数组。每个命令行参数都作为数组中的单独字符串元素传递。最后一个元素的值为 NULL，表示命令行参数列表的末尾。

数组中的字符串argv是不可变的，这意味着它们存储在只读内存中。因此，如果程序想要修改其命令行参数之一的值，则需要制作命令行参数的本地副本并修改该副本。

通常，程序希望将传递给main的命令行参数解释为字符串以外的类型。在上面的示例中，程序可能想要从其第一个命令行参数的字符串值"10"中提取整数值10。 C 的标准库提供了将字符串转换为其他类型的函数。例如，atoi(“a to i”，表示“ASCII 到整数”)函数将数字字符串转换为其相应的整数值：

int x;
x = atoi(argv[1]);  // x gets the int value 10

有关这些函数的更多信息，请参阅 2.6. 字符串和字符串库。 CommandLineargs.c程序 是 C 命令行参数的另一个示例。

2.9.3. The void * Type and Type Recasting

C 类型void *表示通用指针——指向任何类型的指针，或指向未指定类型的指针。 C 允许通用指针类型，因为系统上的内存地址始终存储在相同数量的字节中(例如，地址在 32 位系统上为 4 个字节，在 64 位系统上为 8 个字节)。因此，每个指针变量都需要相同数量的存储字节，并且由于它们的大小相同，因此编译器可以在 void *不知道变量指向的类型的情况下为变量分配空间。这是一个例子：

void *gen_ptr;
int x;
char ch;

gen_ptr = &x;  // gen_ptr can be assigned the address of an int
gen_ptr = &ch; // or the address of a char (or the address of any type)

通常，程序员不会void *像前面的示例那样声明类型变量。相反，它通常用于指定函数的通用返回类型或函数的通用参数。该void *类型通常被函数用作返回类型，这些函数返回新分配的内存，该内存可用于存储任何类型（例如，malloc）。它还用作可以采用任何类型值的函数的函数参数。在这种情况下，对函数的单独调用会传入指向某种特定类型的指针，该指针可以传递给函数的void *参数，因为它可以存储任何类型的地址。

因为void *是通用指针类型，所以不能直接取消引用——编译器不知道地址指向的内存大小。例如，地址可以指代int四个字节的存储位置，或者可以指char代存储器中的一个字节的存储位置。因此，程序员必须在取消引用之前显式地 将指针重新转换void *为特定类型的指针。重铸告诉编译器指针变量的具体类型，允许编译器为指针解引用生成正确的内存访问代码。

下面是两个void *使用示例：

1. 调用将malloc其void *返回类型重新转换为用于存储返回的堆内存地址的变量的特定指针类型：

   int *array;
   char *str;
   
   array = (int *)malloc(sizeof(int) * 10); // recast void * return value
   str = (char *)malloc(sizeof(char) * 20);
   
   *array = 10;
   str[0] = 'a';
   

2. 创建线程的时候经常会遇到 void *。在线程函数中使用 void * 参数类型允许线程采用任何类型的应用程序特定指针。 pthread_create 函数有一个用于线程主函数的参数和一个用于传递给新创建的线程将执行的线程主函数的参数值的 void * 参数。 void *参数的使用使得 pthread_create 成为一个通用的线程创建函数；它可用于指向任何类型的内存位置。对于调用 pthread_create 的特定程序，程序员知道传递给 void * 参数的实参类型，因此程序员必须在取消引用它之前将其重新转换为其已知类型。在此示例中，假设传递给 args 参数的地址包含整型变量的地址：

   /*
    * an application-specific pthread main function
    * must have this function prototype: int func_name(void *args)
    *
    * any given implementation knows what type is really passed in
    *  args: pointer to an int value
    */
   int my_thr_main(void *args) {
   	int num;
   
   	// first recast args to an int *, then dereference to get int value
   	num = *((int *)args);  // num gets 6
   	...
   }
   
   int main(void) {
   	int ret, x;
   	pthread_t tid;
   
   	x = 6;
   	// pass the address of int variable (x) to pthread_create's void * param
   	// (we recast &x as a (void *) to match the type of pthread_create's param)
   	ret = pthread_create(&tid, NULL,
   						 my_thr_main,    // a thread main function
   						 (void *)(&x));  // &x will be passed to my_thr_main
   	// ...
   

如果指针变量指向数组，则程序可以对指针执行算术以访问数组的任何元素。在大多数情况下，我们建议不要使用指针算术来访问数组元素：这样做很容易出错，而且更难以调试。然而，有时连续递增指针来迭代元素数组可能会很方便。

当递增时，指针指向_它所指向的类型的_下一个存储位置。例如，递增整数指针 ( int *) 使其指向下一个int存储地址(超出当前值 4 个字节的地址)，递增字符指针使其指向下一个 char存储地址(超出当前值 1 个字节的地址)。

在下面的示例程序中，我们演示了如何使用指针算术来操作数组。首先声明类型与数组元素类型匹配的指针变量：

#define N 10
#define M 20

int main(void) {
    // array declarations:
    char letters[N];
    int numbers[N], i, j;
    int matrix[N][M];

    // declare pointer variables that will access int or char array elements
    // using pointer arithmetic (the pointer type must match array element type)
    char *cptr = NULL;
    int *iptr = NULL;
    ...

接下来，将指针变量初始化为它们将迭代的数组的基地址：

// make the pointer point to the first element in the array
cptr = &(letters[0]); //  &(letters[0])  is the address of element 0
iptr = numbers;       // the address of element 0 (numbers is &(numbers[0]))

然后，使用指针取消引用，我们的程序可以访问数组的元素。在这里，我们取消引用以将值分配给数组元素，然后将指针变量递增 1 以将其前进以指向下一个元素：

// initialized letters and numbers arrays through pointer variables
for (i = 0; i < N; i++) {
    // dereference each pointer and update the element it currently points to
    *cptr = 'a' + i;
    *iptr = i * 3;

    // use pointer arithmetic to set each pointer to point to the next element
    cptr++;  // cptr points to the next char address (next element of letters)
    iptr++;  // iptr points to the next int address  (next element of numbers)
}

请注意，在此示例中，指针值在循环内递增。因此，增加它们的值使它们指向数组中的下一个元素。此模式有效地遍历数组的每个元素，其方式与每次迭代访问cptr[i] 或 iptr[i]的方式相同。

您可以看到上面的代码如何通过打印出数组元素的值来修改数组元素(我们首先使用数组索引进行展示，然后使用指针算术来访问每个数组元素的值)：

printf("\n array values using indexing to access: \n");
// see what the code above did:
for (i = 0; i < N; i++) {
    printf("letters[%d] = %c, numbers[%d] = %d\n",
           i, letters[i], i, numbers[i]);
}

// we could also use pointer arith to print these out:
printf("\n array values using pointer arith to access: \n");
// first: initialize pointers to base address of arrays:
cptr = letters;  // letters == &letters[0]
iptr = numbers;
for (i = 0; i < N; i++) {
    // dereference pointers to access array element values
    printf("letters[%d] = %c, numbers[%d] = %d\n",
            i, *cptr, i, *iptr);

    // increment pointers to point to the next element
    cptr++;
    iptr++;
}

输出如下所示：

 array values using indexing to access:
letters[0] = a, numbers[0] = 0
letters[1] = b, numbers[1] = 3
letters[2] = c, numbers[2] = 6
letters[3] = d, numbers[3] = 9
letters[4] = e, numbers[4] = 12
letters[5] = f, numbers[5] = 15
letters[6] = g, numbers[6] = 18
letters[7] = h, numbers[7] = 21
letters[8] = i, numbers[8] = 24
letters[9] = j, numbers[9] = 27

 array values using pointer arith to access:
letters[0] = a, numbers[0] = 0
letters[1] = b, numbers[1] = 3
letters[2] = c, numbers[2] = 6
letters[3] = d, numbers[3] = 9
letters[4] = e, numbers[4] = 12
letters[5] = f, numbers[5] = 15
letters[6] = g, numbers[6] = 18
letters[7] = h, numbers[7] = 21
letters[8] = i, numbers[8] = 24
letters[9] = j, numbers[9] = 27

指针算术可用于迭代任何连续的内存块。下面是一个使用指针算术来初始化静态声明的二维数组的示例：

// sets matrix to:
// row 0:   0,   1,   2, ...,  99
// row 1: 100, 110, 120, ..., 199
//        ...
iptr = &(matrix[0][0]);
for (i = 0; i < N*M; i++) {
    *iptr = i;
    iptr++;
}

// see what the code above did:
printf("\n 2D array values inited using pointer arith: \n");
for (i = 0; i < N; i++) {
    for (j = 0; j < M; j++) {
        printf("%3d ", matrix[i][j]);
    }
    printf("\n");
}

return 0;
}

输出将如下所示：

 2D array values initialized using pointer arith:
  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19
 20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39
 40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58  59
 60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79
 80  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98  99
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199

指针算术可以以任何模式访问连续的内存位置，在连续的内存块中的任何位置开始和结束。例如，在初始化指向数组元素地址的指针后，其值可以更改多个。例如：

iptr = &numbers[2];
*iptr = -13;
iptr += 4;
*iptr = 9999;

执行上述代码后，打印numbers数组的值将如下所示(请注意，索引 2 和索引 6 处的值已更改)：

numbers[0] = 0
numbers[1] = 3
numbers[2] = -13
numbers[3] = 9
numbers[4] = 12
numbers[5] = 15
numbers[6] = 9999
numbers[7] = 21
numbers[8] = 24
numbers[9] = 27

指针算术也适用于动态分配的数组。但是，程序员必须小心使用动态分配的多维数组。例如，如果程序使用多个malloc调用来动态分配 2D 数组的各个行(方法 2，数组的数组)，则必须重置指针以指向每行的起始元素的地址。重置指针是必要的，因为只有行内的元素位于连续的内存地址中。另一方面，如果 2D 数组被分配为 malloc 总行数乘以列空(方法 1)，则所有行都位于连续内存中(就像上面示例中静态声明的 2D 数组一样)。在后一种情况下，只需将指针初始化为指向基地址，然后指针运算将正确访问二维数组中的任何元素。

2.9.5. C库: 使用, 编译和链接

库实现了可供其他程序使用的函数和定义的集合。一个C库由两部分组成：

1. 库的 应用程序编程接口 ( API)，在一个或多个头文件(.h文件)中定义，这些头文件必须包含在计划使用该库的 C 源代码文件中。头文件定义了库向用户导出的内容。这些定义通常包括库函数原型，也可能包括类型、常量或全局变量声明。
2. 库功能的 实现 通常以预编译的二进制格式提供给程序，该格式链接(或添加)到由 gcc 创建的二进制可执行文件中。预编译的库代码可能位于包含多个 .o 文件的归档文件(libsomelib.a)中，这些文件可以在编译时静态链接到可执行文件中。或者，它可能由一个共享对象文件 (libsomelib.so) 组成，该文件可以在运行时动态链接到正在运行的程序中。

例如，C 字符串库实现了一组函数来操作 C 字符串。头文件 string.h 定义了它的接口，因此任何想要使用字符串库函数的程序都必须 #include <string.h> . C 字符串库的实现是更大的标准 C 库 ( libc) 的一部分，gcc编译器自动链接到它创建的每个可执行文件中。

库的实现由一个或多个模块(.c文件)组成，并且可能还包括库实现内部的头文件；内部头文件不是库 API 的一部分，而是精心设计的模块化库代码的一部分。通常，库的 C 源代码实现不会导出给库的用户。相反，该库以预编译的二进制形式提供。这些二进制格式不是可执行程序（它们不能单独运行），但它们提供可执行代码，可以在编译时通过gcc 链接 到(添加到)可执行文件中。

有许多库可供 C 程序员使用。例如，POSIX 线程库(在第 10 章中讨论)支持多线程 C 程序。 C 程序员还可以实现和使用自己的库(在下一节中讨论)。大型 C 程序往往会使用许多 C 库，其中一些 gcc 隐式链接，而另一些则需要使用 -l 命令行选项显式链接到 gcc 。

标准 C 库通常不需要与该 -l选项显式链接，但其他库则需要。库函数的文档通常会指定编译时是否需要显式链接该库。例如，POSIX 线程库 ( pthread) 和该 readline库需要在gcc命令行上显式链接：

$ gcc -o myprog myprog.c -pthread -lreadline

请注意，链接 POSIX 线程库是一种特殊情况，不包含 -l 前缀。但是，大多数库都使用gcc命令行上的-l语法显式链接到可执行文件。另请注意，库文件的全名不应包含在gcc的-l参数中；库文件的名称类似于libreadline.so或libreadline.a，但不包括文件名的lib前缀和.so或.a后缀。实际的库文件名还可能包含版本号(例如libreadline.so.8.0)，这些版本号也不包含在-l命令行选项(-lreadline)中。通过不强迫用户指定(甚至知道)要链接的库文件的确切名称和位置，gcc可以自由地在用户的库路径中查找库的最新版本。当库的共享对象(.so)和静态库(存档)(.a)版本都可用时，它还允许编译器选择动态链接。如果用户想要静态链接库，那么他们可以在gcc命令行中显式指定静态链接。 --static 选项提供了一种请求静态链接的方法：

$ gcc -o myprog myprog.c --static -pthread -lreadline

编译步骤

描述 C 程序编译步骤将有助于说明库代码如何链接到可执行二进制文件。我们首先介绍编译步骤，然后讨论(通过示例)编译使用库的程序时可能发生的不同类型的错误。

C 编译器通过四个不同的步骤(加上运行时发生的第五步)将 C 源文件(例如myprog.c)转换为可执行二进制文件(例如a.out).

1. 预编译器步骤首先运行并扩展预处理器指令：出现在 C 程序中的 # 指令，例如#define和#include。此步骤中的编译错误包括预处理器指令中的语法错误或gcc未找到与#include指令关联的头文件。要查看预编译器步骤的中间结果，请将-E标志传递给gcc(输出可以重定向到可以通过文本编辑器查看的文件)：

   $ gcc -E  myprog.c
   $ gcc -E  myprog.c  > out
   $ vim out
   

2. 接下来运行编译步骤并执行大部分编译任务。它将 C 程序源代码 (myprog.c) 转换为机器特定的汇编代码 (myprog.s)。汇编代码是计算机可以执行的二进制机器代码指令的人类可读形式。此步骤的编译错误包括C语言语法错误、未定义符号警告以及缺少定义和函数原型的错误。要查看编​​译步骤的中间结果，请将-S标志传递给gcc(此选项创建一个名为myprog.s的文本文件，其中包含myprog.c的汇编翻译，可以在文本编辑器查看)：

   $ gcc -S  myprog.c
   $ vim myprog.s
   

3. 汇编步骤将汇编代码转换为可重定位的二进制目标代码(myprog.o)。生成的目标文件包含机器代码指令，但它不是可以独立运行的完整可执行程序。 Unix 和 Linux 系统上的 gcc 编译器会生成名为 ELF(可执行和可链接格式)的特定格式的二进制文件。要在此步骤之后停止编译，请将-c标志传递给gcc(这会生成一个名为myprog.o的文件)。可以使用objdump或用于显示二进制文件的类似工具来查看二进制文件(例如a.out和.o文件)：

    $ gcc -c  myprog.c
    
    # disassemble functions in myprog.o with objdump:
    $ objdump -d myprog.o

4. 链接编辑步骤最后运行，并从可重定位二进制文​​件(.o)和库(.a或.so)创建单个可执行文件(a.out)。在此步骤中，链接器验证.o文件中对名称(符号)的任何引用是否存在于其他.o、.a或.so文件中。例如，链接器将在标准 C 库 (libc.so) 中找到printf函数。如果链接器找不到符号的定义，则此步骤将失败并显示错误，指出符号未定义。运行不带部分编译标志的gcc会执行将 C 源代码文件(myprog.c)编译为可以运行的可执行二进制文件(a.out)的所有四个步骤：

   $ gcc myprog.c
   $ ./a.out
   
   # disassemble functions in a.out with objdump:
   $ objdump -d a.out
   

   如果二进制可执行文件(a.out)静态链接到库代码(来自.a库文件)，则gcc会将.a文件中的库函数副本嵌入到生成的a.out文件中。应用程序对库函数的所有调用都绑定到库函数复制到的a.out文件中的位置。绑定将名称与程序存储器中的位置相关联。例如，绑定对名为gofish的库函数的调用意味着将函数名称的使用替换为函数内存中的地址(在后面的章节中我们将讨论内存地址)。

   但是，如果a.out是通过动态链接库(从库共享对象.so文件)创建的，则a.out不包含这些库中的库函数代码的副本。相反，它包含有关a.out文件运行它所需的动态链接库的信息。此类可执行文件需要在运行时执行额外的链接步骤。

5. 如果在链接编辑期间a.out与共享对象文件链接(步骤 4)，则需要运行时链接步骤。在这种情况下，动态库代码(在.so文件中)必须在运行时加载并与正在运行的程序链接。这种共享对象库的运行时加载和链接称为动态链接。当用户运行具有共享对象依赖项的a.out可执行文件时，系统会在程序开始执行其main函数之前执行动态链接。

   编译器在链接编辑编译步骤(步骤 4)期间将有关共享对象依赖项的信息添加到a.out文件中。当程序开始执行时，动态链接器检查共享对象依赖项列表，找到共享对象文件并将其加载到正在运行的程序中。然后，它更新a.out文件中的重定位表(relocation table)条目，将程序对共享对象中符号的使用(例如对库函数的调用)绑定到运行时加载的.so文件中的位置。如果动态链接器找不到可执行文件所需的共享对象(.so)文件，则运行时链接会报告错误。

   ldd 程序列出可执行文件的共享对象依赖项：

   $ ldd a.out
   

   GNU 调试器 (GDB) 可以检查正在运行的程序并显示在运行时加载和链接的共享对象代码。我们在第 3 章 中介绍了 GDB。然而，检查过程查找表 (PLT)(用于动态链接库函数调用的运行时链接)的详细信息超出了本教科书的范围。

有关编译阶段以及用于检查不同阶段的工具的更多详细信息，请参阅：编译阶段。

与编译和链接库相关的常见编译错误

由于程序员忘记包含库头文件或忘记显式链接库代码，可能会出现一些编译和链接错误。识别gcc与每个错误相关的编译器错误或警告将有助于调试与使用 C 库相关的错误。

考虑以下 C 程序，该程序从examplelib库调用libraryfunc函数，该库可作为共享对象文件libexamplelib.so使用：

#include <stdio.h>
#include <examplelib.h>

int main(int argc, char *argv[]) {
    int result;
    result = libraryfunc(6, MAX);
    printf("result is %d\n", result);
    return 0;
}

假设头文件examplelib.h包含以下示例中的定义：

#define MAX 10   // a constant exported by the library

// a function exported by the library
extern int libraryfunc(int x, int y);

函数原型的 extern 前缀意味着该函数的定义来自另一个文件——它不在 examplelib.h 文件中，而是由库实现之一的.c文件(一个头文件对应多个实现文件.c文件)提供。

忘记包含头文件(没有包含声明符号的位置)

如果程序员忘记在程序中包含examplelib.h，则编译器会生成有关程序使用它不知道的库函数和常量的警告和错误。例如，如果用户在没有#include <examplelib.h>的情况下编译程序，gcc将产生以下输出：

# '-g': add debug information, '-c': compile to .o
gcc -g -c myprog.c

myprog.c: In function main:
myprog.c:8:12: warning: implicit declaration of function libraryfunc
   result = libraryfunc(6, MAX);
            ^~~~~~~~~~~

myprog.c:8:27: error: MAX undeclared (first use in this function)
   result = libraryfunc(6, MAX);
                           ^~~

第一个编译器警告(函数libraryfunc的隐式声明)告诉程序员编译器无法找到libraryfunc函数的函数原型。这只是一个编译器警告，因为gcc会猜测函数的返回类型是整数，并将继续编译程序。然而，程序员不应该忽略诸如此类的警告！它们表明程序在使用myprog.c文件之前未包含函数原型，这通常是由于未包含包含函数原型的头文件所致。

第二个编译器错误(MAX undeclared (first use in this function))是由于缺少常量定义而产生的。编译器无法猜测缺少的常量的值，因此缺少的定义失败并出现错误。这种类型的“未声明”消息通常表明定义常量或全局变量的头文件丢失或尚未正确包含。

忘记链接库

如果程序员包含库头文件(如前面的清单所示)，但忘记在编译的链接编辑步骤(步骤 4)期间显式链接到库中，则 gcc 会显示未定义的引用错误(undefined reference)：

$ gcc -g myprog.c

In function main:
myprog.c:9: undefined reference to libraryfunc
collect2: error: ld returned 1 exit status

此错误源自编译器的链接器组件 ld。它表明链接器找不到在 myprog.c 中第 9 行调用的库函数 libraryfunc 的实现。未定义的引用(undefined reference)错误表示需要将库显式链接到可执行文件中。在此示例中，在 gcc 命令行上指定 -lexamplelib 将修复错误：

$ gcc -g myprog.c  -lexamplelib

gcc找不到头文件或库文件

如果gcc默认搜索的目录中不存在库的头文件或实现文件，编译也会失败并出现错误。例如，如果gcc找不到examplelib.h文件，它将产生如下错误消息：

$ gcc -c myprog.c -lexamplelib
myprog.c:1:10: fatal error: examplelib.h: No such file or directory
 #include <examplelib.h>
          ^~~~~~~
compilation terminated.

如果链接器在编译的链接编辑步骤中找不到要链接的 .a 或 .so 版本的库，gcc 将退出并出现如下错误：

$ gcc -c myprog.c -lexamplelib
/usr/bin/ld: cannot find -lexamplelib
collect2: error: ld returned 1 exit status

同样，如果动态链接的可执行文件无法找到共享对象文件(例如libexamplelib.so)，它将无法在运行时执行，并出现如下错误：

$ ./a.out
./a.out: error while loading shared libraries:
        libexamplelib.so: cannot open shared object file: No such file or directory

要解决这些类型的错误，程序员必须为 gcc 指定其他选项，以指示可以找到库文件的位置。他们可能还需要修改运行时链接器的 LD_LIBRARY_PATH 环境变量以查找库的 .so 文件。

库和包含路径(Library and Include Paths)

编译器自动在标准目录位置搜索头文件和库文件。例如，系统通常将标准头文件存储在/usr/include中，将库文件存储在/usr/lib中，而gcc会自动在这些目录中查找头文件和库； gcc 还会自动搜索当前工作目录中的头文件。

如果gcc找不到头文件或库文件，则用户必须使用-I和-L在命令行上显式提供路径。例如，假设名为libexamplelib.so的库存在于/home/me/lib中，其头文件examplelib.h位于/home/me/include中。因为默认情况下gcc对这些路径一无所知，所以必须明确告知它包含其中的文件才能成功编译使用该库的程序：

$ gcc  -I/home/me/include -o myprog myprog.c -L/home/me/lib -lexamplelib

要在启动动态链接的可执行文件时指定动态库(例如libexamplelib.so)的位置，请设置LD_LIBRARY_PATH环境变量以包含该库的路径。下面是一个 bash 命令示例，可以在 shell 提示符下运行或添加到.bashrc文件中：

export LD_LIBRARY_PATH=/home/me/lib:$LD_LIBRARY_PATH

当gcc命令行变长，或者可执行文件需要许多源文件和头文件时，使用make和Makefile有助于简化编译。这里是有关 make 和 Makefiles 的更多信息。

rpath && runpath

nixos, manylinux 以及其他一些分发linux二进制程序的方案. 这些方案的内涵就是设置特别的库搜索路径, 保持相对路径层级进行加载, 确保程序可以在不同的机器上运行, 而且单独的库搜素路径可以和系统本身的依赖保持隔离, 便于设置沙箱环境.

2.9.6. 编写和使用自己的C库

程序员通常将大型 C 程序划分为相关功能的单独模块(即单独的.c文件)。多个模块共享的定义被放入头文件(.h文件)中，这些文件由需要它们的模块包含。同样，C 库代码也在一个或多个模块(.c文件)和一个或多个头文件(.h文件)中实现。 C 程序员经常实现自己的常用功能 C 库。通过编写库，程序员可以在库中实现该功能一次，然后可以在他们编写的任何后续 C 程序中使用该功能。

在编译, 链接和C库使用部分中，我们介绍了如何使用、编译 C 库代码并将其链接到 C 程序中。在本节中，我们讨论如何用 C 语言编写和使用您自己的库。我们在这里介绍的内容也适用于构造和编译由多个 C 源文件和头文件组成的大型 C 程序。

要在 C 中创建库：

1. 在头文件 (.h) 中定义库的接口。任何想要使用该库的程序都必须包含该头文件。
2. 在一个或多个.c文件中创建该库的实现。这组函数定义实现了库的功能。有些函数可能是库的用户将调用的接口函数，而其他函数可能是库的用户无法调用的内部函数(内部函数是库实现的良好模块化设计的一部分)。
3. 编译该库的二进制形式，该库可以链接到使用该库的程序中。

库的二进制形式可以直接从其源文件构建，作为编译使用该库的应用程序代码的一部分。此方法将库文件编译为.o文件并将它们静态链接到二进制可执行文件中。以这种方式包含库通常适用于您为自己使用而编写的库代码(因为您可以访问其.c源文件)，并且它也是从多个.c模块构建可执行文件的方法。

或者，可以将库编译为二进制存档 (.a) 或共享对象 (.so) 文件，以供想要使用该库的程序使用。在这些情况下，库的用户通常无法访问库的 C 源代码文件，因此他们无法直接使用使用库源码来编译应用代码。当程序使用此类预编译库(例如.a或.so)时，必须使用gcc的-l命令行选项将库的代码显式链接到可执行文件中。

我们将详细讨论编写、编译和链接库代码的情况，其中程序员可以访问各个库模块(.c或.o文件)。这一重点也适用于设计和编译分为多个.c和.h文件的大型 C 程序。我们简要展示了用于构建归档库(静态库)和共享对象(动态共享库)的命令。有关构建这些类型的库文件的更多信息，请参阅gcc文档，包括gcc和ar的手册页。

库详细信息示例(Library Details by Example)

下面，我们将展示一些创建和使用您自己的库的示例。

定义库接口：

头文件(.h 文件)是包含 C 函数原型和其他定义的文本文件——它们代表库的接口。任何想要使用该库的应用程序中都必须包含头文件。例如，C标准库头文件通常存储在/usr/include/中，可以使用编辑器查看：

$ vi /usr/include/stdio.h

下面是来自库的示例头文件 (mylib.h)，其中包含库用户的一些定义。

#ifndef _MYLIB_H_
#define _MYLIB_H_

// a constant definition exported by library:
#define MAX_FOO  20

// a type definition exported by library:
struct foo_struct {
    int x;
    float y;
};

// a global variable exported by library
// "extern" means that this is not a variable declaration,
// but it defines that a variable named total_times of type
// int exists in the library implementation and is available
// for use by programs using the library.
// It is unusual for a library to export global variables
// to its users, but if it does, it is important that
// extern appears in the definition in the .h file
extern int total_times;

// a function prototype for a function exported by library:
// extern means that this function definition exists
// somewhere else.
/*
 * This function returns the larger of two float values
 *  y, z: the two values
 *  returns the value of the larger one
 */
extern float bigger(float y, float z);

#endif

头文件通常在其内容周围有特殊的“样板”代码：

#ifndef

// header file contents

#endif

此样板代码可确保编译器的预处理器仅在包含mylib.h的任何 C 文件中包含该内容一次。仅包含一次.h文件内容很重要，可以避免编译时出现重复定义错误(duplicate definition errors)。同样，如果您忘记在使用该库的 C 程序中包含.h文件，编译器将生成未定义符号(undefined symbol)警告。

.h 文件中的注释是库接口的一部分，是为库用户编写的。这些注释应该很详细，解释定义并描述每个库函数的作用、它采用的参数值以及它返回的内容。有时.h文件还会包含描述如何使用该库的顶级注释。

全局变量定义和函数原型之前的关键字extern意味着这些名称是在其他地方定义的。在库导出的任何全局变量之前包含extern尤其重要，因为它将名称和类型定义(在.h文件中)与库实现中的变量声明区分开来。在前面的示例中，全局变量在库内仅声明一次，但它通过库的.h文件中的extern定义导出给库用户。

实现库功能：

程序员在一个或多个.c文件(有时是内部.h文件)中实现库。该实现包括.h文件中所有函数原型的定义以及其实现内部的其他函数。这些内部函数通常使用关键字static定义，这将它们的可见性限制在定义它们的模块(.c文件)内。库实现还应包括.h文件中任何extern全局变量声明的变量定义。这是示例库实现 (mylib.c)：

#include <stdlib.h>

// Include the library header file if the implementation needs
// any of its definitions (types or constants, for example.)
// Use " " instead of < > if the mylib.h file is not in a
// default  library path with other standard library header
// files (the usual case for library code you write and use.)
#include "mylib.h"

// declare the global variable exported by the library
int total_times = 0;

// include function definitions for each library function:
float bigger(float y, float z) {
    total_times++;
    if (y > z) {
        return y;
    }
    return z;
}

创建库的二进制形式：

要创建库的二进制形式(.o文件)，请使用以下 -c选项进行编译：

$ gcc -o mylib.o -c mylib.c

一个或多个.o文件可以构建库的归档 ( .a) 或共享对象 ( .so) 版本。

• 要构建静态库，请使用归档器 (ar)：

  ar -rcs libmylib.a mylib.o
  

• 要构建动态链接库，mylib.o目标文件必须使用位置无关代码(使用-fPIC)构建。 通过将gcc的标志指定为-shared，可以从mylib.o创建libmylib.so共享对象文件：

  gcc -fPIC -o mylib.o -c mylib.c
  gcc -shared -o libmylib.so mylib.o
  

• 例如，共享对象和归档库通常是从多个.o文件构建的(请记住，动态链接库的.o需要使用-fPIC标志构建)：

  gcc -shared -o libbiglib.so file1.o file2.o file3.o file4.o
  ar -rcs libbiglib.a file1.o file2.o file3.o file4.o
  

使用并链接库：

.c在使用该库的其他文件中：

1. #include它的头文件
2. 在编译期间显式链接到实现(.o文件)中。

包含库头文件后，您的代码就可以调用库的函数(例如，在 中myprog.c)：

#include <stdio.h>
#include "mylib.h"   // include library header file

int main(void) {
    float val1, val2, ret;
    printf("Enter two float values: ");
    scanf("%f%f", &val1, &val2);
    ret = bigger(val1, val2);   // use a library function
    printf("%f is the biggest\n", ret);

    return 0;
}

$ gcc -I/home/me/myincludes -c myprog.c

常见编译命令(从源码, 目标文件或库文件中构建执行程序)

• 要将使用库 (mylib.o) 的程序 (myprog.c) 编译为二进制可执行文件：

  $ gcc -o myprog myprog.c mylib.o
  

• 或者，如果库的实现文件在编译时可用，则可以直接从程序和库 .c 文件构建程序：

  $ gcc -o myprog myprog.c mylib.c
  

• 或者，如果该库可作为归档或共享对象文件使用，则可以使用-l链接它，(-lmylib：请注意，库名称是libmylib.[a,so]，但是仅mylib部分包含在gcc命令行中)：

  $ gcc -o myprog myprog.c -L. -lmylib
  

  -L.选项指定libmylib.[so,a]文件的路径(-L后面的.表示应该搜索当前目录)。默认情况下，如果可以找到.so版本，gcc将动态链接库。有关链接和链接路径的详细信息，请参阅 2.9.5. 编译, 链接和C库使用。

然后可以运行该程序：

$ ./myprog

如果您运行 的动态链接版本myprog，您可能会遇到如下错误：

/usr/bin/ld: cannot find -lmylib
collect2: error: ld returned 1 exit status

此错误表明运行时链接器在运行时找不到libmylib.so。要解决此问题，请设置LD_LIBRARY_PATH环境变量以包含libmylib.so文件的路径。 myprog的后续运行使用您添加到LD_LIBRARY_PATH的路径来查找libmylib.so文件并在运行时加载它。例如，如果libmylib.so位于/home/me/mylibs/子目录中，请在 bash shell 提示符下运行此命令(仅一次)以设置LD_LIBRARY_PATH环境变量：

$ export LD_LIBRARY_PATH=/home/me/mylibs:$LD_LIBRARY_PATH

2.9.7. 将 C 编译为汇编，以及编译和链接汇编和 C 代码

编译器可以将 C 代码编译为汇编代码，并且可以将汇编代码编译为链接到二进制可执行程序的二进制形式。我们使用 IA32 汇编和“gcc”作为示例汇编语言和编译器，但任何 C 编译器都支持此功能，并且大多数编译器支持编译为多种不同的汇编语言。有关汇编代码和汇编编程的详细信息，请参阅[第 8 章](https://diveintosystems.org/book/C8-IA32/index.html#_ assembly_chapter)。

考虑这个非常简单的 C 程序：

simpleops.c

int main(void) {
    int x, y;
    x = 1;
    x = x + 2;
    x = x - 14;
    y = x*100;
    x = x + y * 6;

    return 0;
}

gcc 编译器将使用 -S 命令行选项将其编译为 IA32 程序集文本文件 (.s) 来指定编译为程序集，并使用 -m32 命令行选项来指定生成 IA32 程序集：

$ gcc -m32 -S simpleops.c   # runs the assembler to create a .s text file

此命令使用编译器对 C 代码的 IA32 汇编翻译创建一个名为simpleops.s的文件。由于.s文件是文本文件，因此用户可以使用任何文本编辑器查看(并编辑)它。例如：

$ vim simpleops.s

传递额外的编译器标志为gcc提供了指示，即它应该在将 C 转换为 IA32 汇编代码时使用某些功能或优化。

汇编代码文件，无论是从gcc生成的还是由程序员手工编写的，都可以使用-c选项由gcc编译为二进制机器代码形式：

$ gcc -m32 -c simpleops.s   # compiles to a relocatable object binary file (.o)

然后可以将生成的simpleops.o文件链接到二进制可执行文件(注意：这需要在您的系统上安装 32 位版本的系统库)：

$ gcc -m32 -o simpleops simpleops.o  # creates a 32-bit executable file

此命令为 IA32(和 x86-64)架构创建一个二进制可执行文件simpleops。

用于构建可执行文件的gcc命令行可以包含.o和.c文件，这些文件将被编译并链接在一起以创建单个二进制可执行文件。

系统提供允许用户查看二进制文件的实用程序。例如，objdump显示.o文件中的机器代码和汇编代码映射关系：

$ objdump -d simpleops.o

可以将此输出与汇编文件进行比较：

$ cat simpleops.s

您应该看到类似这样的内容(我们用 C 程序中的相应代码注释了一些汇编代码)：

        .file   "simpleops.c"
        .text
        .globl main
        .type   main, @function
main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $16, %esp
        movl    $1, -8(%ebp)      # x = 1
        addl    $2, -8(%ebp)      # x = x + 2
        subl    $14, -8(%ebp)     # x = x - 14
        movl    -8(%ebp), %eax    # load x into R[%eax]
        imull   $100, %eax, %eax  # into R[%eax] store result of x*100
        movl    %eax, -4(%ebp)    # y = x*100
        movl    -4(%ebp), %edx
        movl    %edx, %eax
        addl    %eax, %eax
        addl    %edx, %eax
        addl    %eax, %eax
        addl    %eax, -8(%ebp)
        movl    $0, %eax
        leave
        ret
        .size   main, .-main
        .ident	"GCC: (Ubuntu 7.4.0-1ubuntu1~18.04.1) 7.4.0"
        .section	.note.GNU-stack,"",@progbits

编写和编译汇编代码(Writing and Compiling Assembly Code)

程序员可以手动编写自己的汇编代码，并使用gcc将其编译成二进制可执行程序。例如，要在汇编中实现函数，请将代码添加到.s文件中并使用gcc对其进行编译。以下示例显示了 IA32 汇编中函数的基本结构。此类代码将写入具有原型int myfunc(int param);的函数的文件(例如myfunc.s)中。具有更多参数或需要更多空间用于局部变量的函数的前导码可能略有不同。

        .text                   # this file contains instruction code
.globl myfunc                   # myfunc is the name of a function
        .type   myfunc, @function
myfunc:                         # the start of the function
        pushl   %ebp            # function preamble:
        movl    %esp, %ebp      #  the 1st three instrs set up the stack
        subl    $16, %esp

        # A programmer adds specific IA32 instructions
        # here that allocate stack space for any local variables
        # and then implements code using parameters and locals to
        # perform the functionality of the myfunc function
        #
        # the return value should be stored in %eax before returning

        leave    # function return code
        ret

想要调用此函数的 C 程序需要包含其函数原型：

#include <stdio.h>

int myfunc(int param);

int main(void) {
    int ret;

    ret = myfunc(32);
    printf("myfunc(32) is %d\n", ret);

    return 0;
}

以下gcc命令从myfunc.s和main.c源文件构建可执行文件(myprog)：

$ gcc -m32 -c myfunc.s
$ gcc -m32 -o myprog myfunc.o main.c

2.10. Summary

在本章中，我们深入介绍了 C 编程语言，并讨论了一些高级 C 编程主题。在下一章中，我们将介绍两个非常有用的 C 调试工具：用于通用 C 程序调试的 GNU GDB 调试器，以及用于查找 C 程序中内存访问错误的 Valgrind 内存调试器。利用本章介绍的这些编程工具和核心 C 编程语言知识，C 程序员可以设计出功能强大、高效且健壮的软件。

3. C调试工具

在本节中，我们将介绍两种调试工具：GNU 调试器 (GDB)，它对于检查程序的运行时状态很有用，以及 Valgrind(发音为Val-grinned)，一种流行的代码分析套件。具体来说，我们介绍 Valgrind 的 Memcheck 工具，该工具可以分析程序的内存访问，以检测无效的内存使用、未初始化的内存使用和内存泄漏。

GDB 部分包括两个示例 GDB 会话，说明用于查找程序中的错误的常用 GDB 命令。我们还讨论了一些高级 GDB 功能，包括将 GDB 附加到正在运行的进程、GDB 和 Makefile、GDB 中的信号控制、汇编代码级别的调试以及调试多线程 Pthreads 程序。

Valgrind 部分讨论了内存访问错误以及它们为何如此难以检测。它还包括在存在一些严重内存访问错误的程序上运行 Memcheck 的示例。 Valgrind 套件包括其他程序分析和调试工具，我们将在后面的章节中介绍。例如，我们在第 11 章 中介绍了缓存分析工具 Cachegrind，以及第 12 章 中的函数调用分析工具Callgrind。

3.1. 使用 GDB 进行调试

GDB 可以帮助程序员查找并修复程序中的错误。 GDB 可以处理用多种语言编译的程序，但我们这里主要关注 C。调试器是一个控制另一个程序(正在被调试的程序)执行的程序——它允许程序员看到他们的程序在运行时正在做什么。使用调试器可以帮助程序员发现错误并确定他们发现的错误的原因。以下是 GDB 可以执行的一些有用操作：

1. 启动一个程序并逐行执行它
2. 当程序到达代码中的某些点时暂停程序的执行
3. 根据用户指定的条件暂停程序的执行
4. 显示程序暂停执行点处的变量值
5. 暂停后继续执行程序
6. 检查程序崩溃时的执行状态
7. 检查调用堆栈上任何堆栈帧的内容

GDB 用户通常会在其程序中设置断点(breakpoints)。断点指定程序中 GDB 将暂停程序执行的点。当正在执行的程序遇到断点时，GDB 暂停执行，并允许用户输入 GDB 命令来检查程序变量和堆栈内容，一次一行地执行程序，添加新断点，然后继续程序的执行直到遇到下一个断点。

许多 Unix 系统还提供数据显示调试器 (Data Display Debugger, DDD)，这是一个围绕命令行调试程序（GDB，用于例子）。 DDD 程序接受与 GDB 相同的参数和命令，但它提供了带有调试菜单选项的 GUI 界面以及 GDB 的命令行界面。

在讨论了一些关于如何开始使用 GDB 的预备知识后，我们提供了两个示例 GDB 调试会话，介绍了常用的 GDB 命令查找不同类型错误的上下文。第一个会话(GDB on badprog.c)展示了如何使用 GDB 命令查找 C 程序中的逻辑错误。第二个会话(GDB on segfaulter.c)展示了使用 GDB 命令检查此时的程序执行状态的示例程序崩溃时要找出崩溃的原因。

在常用 GDB 命令 部分中，我们更详细地描述了常用的 GDB 命令，并显示了一些命令的更多示例。在后面的部分中，我们将讨论一些高级 GDB 功能。

3.1.1. GDB 入门

调试程序时，使用-g选项对其进行编译很有帮助，该选项会向二进制可执行文件添加额外的调试信息。这些额外信息有助于调试器在二进制可执行文件中查找程序变量和函数，并使其能够将机器代码指令映射到 C 源代码行(C 程序员理解的程序形式)。此外，在编译调试时，请避免编译器优化(例如，不要使用-O2进行构建)。编译器优化的代码通常很难调试，因为优化的机器代码序列通常不能清楚地映射回 C 源代码。尽管我们在以下部分中介绍了-g标志的使用，但某些用户可能会使用-g3标志获得更好的结果，该标志可以显示额外的调试信息。

下面是一个示例gcc命令，它将构建一个合适的可执行文件以使用 GDB 进行调试：

$ gcc -g myprog.c

要启动 GDB，请在可执行文件上调用它。例如：

$ gdb a.out
(gdb)          # the gdb command prompt

当 GDB 启动时，它会打印(gdb)提示符，该提示符允许用户在开始运行a.out程序之前输入 GDB 命令(例如设置断点)。

类似地，要对可执行文件调用 DDD：

$ ddd a.out

有时，当程序因错误而终止时，操作系统会转储一个核心文件，其中包含有关程序崩溃时的状态信息。通过使用核心文件和生成它的可执行文件运行 GDB，可以在 GDB 中检查此核心文件的内容：

$ gdb core a.out
(gdb) where       # the where command shows point of crash

3.1.2. GDB 会话示例

我们通过两个使用 GDB 调试程序的示例会话来演示 GDB 的常见功能。第一个是使用 GDB 查找并修复程序中的两个错误的示例，第二个是使用 GDB 调试崩溃的程序的示例。我们在这两个示例会话中演示的 GDB 命令集包括：

使用 GDB 调试程序的示例 (badprog.c)

第一个示例 GDB 会话调试 badprog.c 程序。该程序应该找到int值数组中的最大值。但是，运行时，它错误地发现 17 是数组中的最大值，而不是正确的最大值 60。此示例显示 GDB 如何检查程序的运行时状态以确定程序未计算预期结果的原因。特别是，此示例调试会话揭示了两个错误：

1. 循环边界错误导致程序访问超出数组边界的元素。
2. 函数中的错误未向其调用者返回正确的值。

要使用 GDB 检查程序，首先使用“-g”编译程序以将调试信息添加到可执行文件：

$ gcc -g badprog.c

接下来，在二进制可执行程序（a.out）上运行 GDB。 GDB 初始化并打印(gdb)提示，用户可以在其中输入 GDB 命令：

$ gdb ./a.out

GNU gdb (Ubuntu 8.1-0ubuntu3) 8.1.0.20180409-git
Copyright (C) 2018 Free Software Foundation, Inc.
  ...
(gdb)

此时GDB还没有开始运行程序。常见的第一个调试步骤是在main()函数中设置断点，以在执行main()中的第一条指令之前暂停程序的执行。 break 命令在指定位置(在本例中是在 main() 函数的开头)设置一个断点(暂停程序)：

(gdb) break main

Breakpoint 1 at 0x8048436: file badprog.c, line 36.

run 命令告诉 GDB 启动程序：

(gdb) run
Starting program: ./a.out

如果程序需要命令行参数，请在run命令之后提供它们(例如，run 100 200将使用命令行参数100和200运行a.out)。

输入run后，GDB 从头开始​​执行程序，一直运行到遇到断点为止。到达断点时，GDB 在执行断点处的代码行之前暂停程序，并打印出断点编号和与断点相关的源代码行。在此示例中，GDB 在执行程序的第 36 行之前暂停程序。然后它会打印出(gdb)提示并等待进一步的指示：

Breakpoint 1, main (argc=1, argv=0x7fffffffe398) at badprog.c:36
36     int main(int argc, char *argv[]) {

(gdb)

通常，当程序在断点处暂停时，用户希望查看断点周围的 C 源代码。 GDB的list命令显示断点周围的代码：

(gdb) list
29	    }
30	    return 0;
31	}
32
33	/***************************************/
34	int main(int argc, char *argv[]) {
35
36	    int arr[5] = { 17, 21, 44, 2, 60 };
37
38	    int max = arr[0];

对 list 的后续调用将显示这些代码之后的下一行源代码。 list 还可以与特定行号(例如，list 11)或函数名称一起使用，以列出程序指定部分的源代码。例如：

(gdb) list findAndReturnMax
12	 * 	array: array of integer values
13	 * 	len: size of the array
14	 * 	max: set to the largest value in the array
15	 *  	returns: 0 on success and non-zero on an error
16	 */
17	int findAndReturnMax(int *array1, int len, int max) {
18
19	    int i;
20
21	    if (!array1 || (len <=0) ) {

用户可能希望在命中断点后一次执行一行代码，并在执行每一行后检查程序状态。 GDB的next命令仅执行下一行 C 代码。程序执行完这行代码后，GDB再次暂停程序。 print 命令打印程序变量的值。以下是对next和print的一些调用，以显示它们对接下来两行执行的影响。请注意，next后面列出的源代码行尚未执行——它显示了程序暂停的行，它代表接下来将执行的行：

(gdb) next
36	  int arr[5] = { 17, 21, 44, 2, 60 };
(gdb) next
38	  int max = arr[0];
(gdb) print max
$3 = 0
(gdb) print arr[3]
$4 = 2
(gdb) next
40	  if ( findAndReturnMax(arr, 5, max) != 0 ) {
(gdb) print max
$5 = 17
(gdb)

此时，在程序执行过程中，主函数已初始化其局部变量arr和max，并即将调用findAndReturnMax()函数。 GDB的next命令执行下一个完整的 C 源代码行。如果该行包含函数调用，则该函数调用的完整执行及其返回将作为单个next命令的一部分执行。想要观察函数执行情况的用户应该发出 GDB 的step命令，而不是next命令：step进入函数调用，在执行函数的第一行之前暂停程序。

因为我们怀疑该程序中的错误与findAndReturnMax()函数有关，所以我们希望单步执行该函数而不是跳过它。因此，当在第 40 行暂停时，step命令接下来将在findAndReturnMax()开始处暂停程序(或者，用户可以在findAndReturnMax()处设置一个断点，以在该处暂停程序的执行观点)：

(gdb) next
40	  if ( findAndReturnMax(arr, 5, max) != 0 ) {
(gdb) step
findAndReturnMax (array1=0x7fffffffe290, len=5, max=17) at badprog.c:21
21	  if (!array1 || (len <=0) ) {
(gdb)

程序现在暂停在findAndReturnMax函数内，其局部变量和参数现在在范围内。 print命令显示它们的值，list显示暂停点周围的 C 源代码：

(gdb) print array1[0]
$6 = 17
(gdb) print max
$7 = 17
(gdb) list
16	 */
17	int findAndReturnMax(int *array1, int len, int max) {
18
19	    int i;
20
21	    if (!array1 || (len <=0) ) {
22	        return -1;
23	    }
24	    max = array1[0];
25	    for (i=1; i <= len; i++) {
(gdb) list
26	        if(max < array1[i]) {
27	            max = array1[i];
28	        }
29	    }
30	    return 0;
31	}
32
33	/***************************************/
34	int main(int argc, char *argv[]) {
35

因为我们认为存在与该函数相关的错误，所以我们可能需要在该函数内部设置一个断点，以便我们可以在其执行过程中检查运行时状态。特别是，当max更改时在行上设置断点可以帮助我们了解该函数正在做什么。

我们可以在程序中的特定行号(第 27 行)设置断点，并使用cont命令告诉 GDB 让应用程序从暂停点继续执行。只有当程序遇到断点时，GDB才会暂停程序并再次获取控制权，允许用户输入其他GDB命令。

(gdb) break 27
Breakpoint 2 at 0x555555554789: file badprog.c, line 27.

(gdb) cont
Continuing.

Breakpoint 2, findAndReturnMax (array1=0x...e290,len=5,max=17) at badprog.c:27
27	      max = array1[i];
(gdb) print max
$10 = 17
(gdb) print i
$11 = 1

display命令要求 GDB 在每次遇到断点时自动打印出同一组程序变量。例如，每次程序遇到断点时(在findAndReturnMax()循环的每次迭代中)，我们都会显示i、max和array1[i]的值：

(gdb) display i
1: i = 1
(gdb) display max
2: max = 17
(gdb) display array1[i]
3: array1[i] = 21

(gdb) cont
Continuing.

Breakpoint 2, findAndReturnMax (array1=0x7fffffffe290, len=5, max=21)
    at badprog.c:27
27	      max = array1[i];
1: i = 2
2: max = 21
3: array1[i] = 44

(gdb) cont
Continuing.

Breakpoint 2, findAndReturnMax (array1=0x7fffffffe290, len=5, max=21)
    at badprog.c:27
27	      max = array1[i];
1: i = 3
2: max = 44
3: array1[i] = 2

(gdb) cont

Breakpoint 2, findAndReturnMax (array1=0x7fffffffe290, len=5, max=44)
    at badprog.c:27
27	      max = array1[i];
1: i = 4
2: max = 44
3: array1[i] = 60

(gdb) cont
Breakpoint 2, findAndReturnMax (array1=0x7fffffffe290, len=5, max=60)
    at badprog.c:27
27	      max = array1[i];
1: i = 5
2: max = 60
3: array1[i] = 32767

(gdb)

我们发现了第一个错误！ array1[i] 的值为 32767，该值不在传递的数组中，而 i 的值为 5，但 5 不是该数组的有效索引。通过 GDB，我们发现for循环边界需要固定为i < len。

此时，我们可以退出 GDB 会话并修复代码中的此错误。要退出 GDB 会话，请输入quit：

(gdb) quit
The program is running.  Exit anyway? (y or n) y
$

修复此错误后，重新编译并运行程序，它仍然找不到正确的最大值(它仍然发现 17 是最大值，而不是 60)。根据我们之前的 GDB 运行，我们可能怀疑调用findAndReturnMax()函数或返回时出现错误。我们在 GDB 中重新运行新版本的程序，这次在findAndReturnMax()函数的入口处设置一个断点：

$ gdb ./a.out
...
(gdb) break main
Breakpoint 1 at 0x7c4: file badprog.c, line 36.

(gdb) break findAndReturnMax
Breakpoint 2 at 0x748: file badprog.c, line 21.

(gdb) run
Starting program: ./a.out

Breakpoint 1, main (argc=1, argv=0x7fffffffe398) at badprog.c:36
36	int main(int argc, char *argv[]) {
(gdb) cont
Continuing.

Breakpoint 2, findAndReturnMax (array1=0x7fffffffe290, len=5, max=17)
    at badprog.c:21
21	  if (!array1 || (len <=0) ) {
(gdb)

如果我们怀疑函数的参数或返回值存在错误，检查堆栈的内容可能会有所帮助。 where(或bt，表示"backtrace")GDB 命令打印堆栈的当前状态。在此示例中，main()函数位于栈底部(在第 1 帧中)，并在第 40 行执行对findAndReturnMax()的调用。findAndReturnMax()函数位于栈的顶部堆栈(在第 0 帧中)，当前暂停在第 21 行：

(gdb) where
#0  findAndReturnMax (array1=0x7fffffffe290, len=5, max=17) at badprog.c:21
#1  0x0000555555554810 in main (argc=1, argv=0x7fffffffe398) at badprog.c:40

GDB 的frame命令移动到栈上任何帧的上下文中。在每个栈帧上下文中，用户可以检查该帧中的局部变量和参数。在此示例中，我们进入堆栈帧 1(调用者的上下文)并打印出main()函数传递给findAndReturnMax()的参数值(例如arr和max) :

(gdb) frame 1
#1  0x0000555555554810 in main (argc=1, argv=0x7fffffffe398) at badprog.c:40
40	  if ( findAndReturnMax(arr, 5, max) != 0 ) {
(gdb) print arr
$1 = {17, 21, 44, 2, 60}
(gdb) print max
$2 = 17
(gdb)

参数值看起来不错，所以让我们检查一下findAndReturnMax()函数的返回值。为此，我们在findAndReturnMax()返回之前添加一个断点，以查看它计算出的max值：

(gdb) break 30
Breakpoint 3 at 0x5555555547ae: file badprog.c, line 30.
(gdb) cont
Continuing.

Breakpoint 3, findAndReturnMax (array1=0x7fffffffe290, len=5, max=60)
    at badprog.c:30
30	  return 0;

(gdb) print max
$3 = 60

这表明该函数已找到正确的最大值 (60)。让我们执行接下来的几行代码，看看main()函数接收到什么值：

(gdb) next
31	}
(gdb) next
main (argc=1, argv=0x7fffffffe398) at badprog.c:44
44	  printf("max value in the array is %d\n", max);

(gdb) where
#0  main (argc=1, argv=0x7fffffffe398) at badprog.c:44

(gdb) print max
$4 = 17

我们发现了第二个错误！ findAndReturnMax() 函数识别传递的数组 (60) 中正确的最大值，但它不会将该值返回给 main() 函数。要修复此错误，我们需要更改findAndReturnMax()以返回其值max，或者添加一个“传递指针”(pass-by-pointer)参数，该函数将使用该参数来修改main()的值函数的max局部变量。

使用 GDB 调试崩溃的程序的示例 (segfaulter.c)

第二个示例 GDB 会话(在 segfaulter.c 程序上运行)演示了程序崩溃时 GDB 的行为以及我们如何使用GDB 帮助发现崩溃发生的原因。

在这个例子中，我们只是在 GDB 中运行segfaulter程序并让它崩溃：

$ gcc -g -o segfaulter segfaulter.c
$ gdb ./segfaulter

(gdb) run
Starting program: ./segfaulter

Program received signal SIGSEGV, Segmentation fault.
0x00005555555546f5 in initfunc (array=0x0, len=100) at segfaulter.c:14
14	    array[i] = i;

一旦程序崩溃，GDB 就会在程序崩溃时暂停程序的执行并夺取控制权。 GDB 允许用户在程序崩溃时发出命令来检查程序的运行时状态，通常可以发现程序崩溃的原因以及如何修复崩溃的原因。 GDB的where和list命令对于确定程序崩溃的位置特别有用：

(gdb) where
#0 0x00005555555546f5 in initfunc (array=0x0, len=100) at segfaulter.c:14
#1 0x00005555555547a0 in main (argc=1, argv=0x7fffffffe378) at segfaulter.c:37

(gdb) list
9	int initfunc(int *array, int len) {
10
11	    int i;
12
13	    for(i=1; i <= len; i++) {
14	        array[i] = i;
15	    }
16	    return 0;
17	}
18

此输出告诉我们程序在第 14 行initfunc()函数中崩溃。检查第 14 行的参数和局部变量的值可能会告诉我们崩溃的原因：

(gdb) print i
$2 = 1
(gdb) print array[i]
Cannot access memory at address 0x4

i 的值看起来不错，但是当我们尝试访问 array 的索引 i 时，我们看到一个错误。让我们打印出array的值(数组基地址的值)，看看这是否告诉我们什么：

(gdb) print array
$3 = (int *) 0x0

我们已经找到事故原因了！数组的基地址为零(或NULL)，我们知道取消引用空指针(通过array[i])会导致程序崩溃。

让我们看看是否可以通过查看调用者的堆栈帧来找出为什么array参数为NULL：

(gdb) frame 1
#1 0x00005555555547a0 in main (argc=1, argv=0x7fffffffe378) at segfaulter.c:37
37	  if(initfunc(arr, 100) != 0 ) {
(gdb) list
32	int main(int argc, char *argv[]) {
33
34	    int *arr = NULL;
35	    int max = 6;
36
37	    if(initfunc(arr, 100) != 0 ) {
38	        printf("init error\n");
39	        exit(1);
40	    }
41
(gdb) print arr
$4 = (int *) 0x0
(gdb)

进入调用者的堆栈帧并打印出main()传递给initfunc()参数的值，表明main()函数向initfunc()函数传递了一个空指针。换句话说，用户忘记在调用initfunc()之前分配arr数组。解决方法是使用malloc()函数为第 34 行的arr分配一些空间。

这两个示例 GDB 会话说明了查找程序中错误的常用命令。在下一节中，我们将更详细地讨论这些命令和其他 GDB 命令。

3.2. GDB 命令详细信息

在本节中，我们列出了常见的 GDB 命令并通过示例展示了它们的一些功能。我们首先讨论一些使 GDB 更易于使用的常见键盘快捷键。

3.2.1. GDB键盘快捷键

GDB 支持命令行补全。用户可以输入命令的唯一前缀并按TAB键，GDB 将尝试完成命令行。此外，独特的缩写可用于发出许多常见的 GDB 命令。例如，用户无需输入命令print x，只需输入p x即可打印出x的值，或者l可用于list命令，或者n可用于打印next的值。

向上和向下箭头键 滚动浏览之前的 GDB 命令行，无需每次都重新输入。

在 GDB 提示符下按RETURN键将执行 最近的上一个命令 。当使用一系列next或step命令逐步执行时，这特别有用；只需按RETURN，GDB 就会执行下一条指令。

3.2.2. 常用GDB命令

我们在这里总结了 GDB 最常用的命令，按照相似的功能对它们进行分组：用于控制程序执行的命令；用于评估程序执行点的命令；设置和控制断点的命令；以及用于打印程序状态和计算表达式的命令。 GDB ‘help’ 命令提供有关所有 GDB 命令的信息：

• help: GDB 命令的帮助文档。

help <topic or command> 显示可用的帮助主题或命令

help breakpoints 显示有关断点的帮助信息
help print 显示有关打印命令的帮助信息

执行控制流命令

• break: 设置一个断点。

break <func-name> Set breakpoint at start of function <func-name>
break <line> Set breakpoint at line number <line>
break <filename:><line> Set breakpoint at <line> in file <filename>
break main Set breakpoint at beginning of main
break 13 Set breakpoint at line 13
break gofish.c:34 Set breakpoint at line 34 in gofish.c
break main.c:34 Set breakpoint at line 34 in main.c

在特定文件中指定一行(如break gofish.c:34)允许用户在跨越多个 C 源代码文件(.c 文件)的 C 程序中设置断点。当设置的断点与程序暂停点的代码不在同一文件中时，此功能特别有用。

• run: 从头开始运行被调试的程序。

run <command line arguments>

run Run with no command line arguments
run 2 40 100 Run with 3 command line arguments: 2, 40, 100

• continue (cont): 从断点处继续执行

continue

• step (s): 执行程序 C 源代码的下一行，如果在该行上执行了函数调用，则单步执行函数。

step Execute next line (stepping into a function)
step <count> Executes next <count> lines of program code

step 10 Executes the next 10 lines (stepping into functions)

对于step <count>命令，如果一行包含函数调用，则被调用函数的行将计入count要单步执行的行总数中。因此，step <count>可能会导致程序在从发出step <count>命令的暂停点调用的函数内暂停。

• next (n): 与step命令类似，但它将函数调用视为单行。换句话说，当下一条指令包含函数调用时，next不会单步执行该函数，而是在函数调用返回后暂停程序(在函数调用后面的代码中的下一行暂停程序)。

next Execute the next line
next <count> Executes next <count> instructions

• until: 执行程序，直到到达指定的源代码行号。

until <line> Executes until hit line number <line>

• quit: 退出GDB

quit

用于检查执行点和列出程序代码的命令

• list: 列出程序源代码。

list Lists next few lines of program source code
list <line> Lists lines around line number <line> of program
list <start> <end> Lists line numbers <start> through <end>
list <func-name> Lists lines around beginning of function <func-name>

list 30 100 List source code lines 30 to 100

• where (backtrace, bt): 显示堆栈的内容(程序执行中当前点的函数调用顺序)。where命令有助于查明程序崩溃的位置以及检查函数调用和返回之间接口的状态，例如传递给函数的参数值。

where

• frame <frame-num>: 进入堆栈帧号<frame-num>的上下文。默认情况下，程序在帧 0(栈顶部的帧)的上下文中暂停。 frame命令可用于移动到另一个堆栈帧的上下文中。通常，GDB 用户移动到另一个堆栈帧来打印另一个函数的参数和局部变量的值。

frame <frame-num> Sets current stack frame to <frame-num>
info frame Show state about current stack frame

frame 3 Move into stack frame 3's context (0 is top frame)

设置和操作断点的命令

• break: 设置断点(在上面的执行控制流命令部分中有关于此命令的更多说明。)

break <func-name> Set a breakpoint at start of a function
break <line> Set a breakpoint at a line number
break main Set a breakpoint at start of main
break 12 Set a breakpoint at line 12
break file.c:34 Set a breakpoint at line 34 of file.c

• enable, disable, ignore, delete, clear: 启用、禁用、忽略一定次数或删除一个或多个断点。 delete命令按断点编号删除断点。相反，使用clear命令会删除源代码中特定位置的断点。

disable <bnums ...> Disable one or more breakpoints
enable <bnums ...> Enable one or more breakpoints
ignore <bpnum> <num> Don't pause at breakpoint <bpnum> the next <num> times it's hit

delete <bpnum> Delete breakpoint number <bpnum>
delete Deletes all breakpoints
clear <line> Delete breakpoint at line <line>
clear <func-name> Delete breakpoint at function <func-name>

info break List breakpoint info (including breakpoint bnums)
disable 3 Disable breakpoint number 3
ignore 2 5 Ignore the next 5 times breakpoint 2 is hit
enable 3 Enable breakpoint number 3
delete 1 Delete breakpoint number 1
clear 124 Delete breakpoint at source code line 124

• condition: 在断点上设置条件。条件断点是仅当某个条件成立时才将控制权转移给 GDB 的断点。它可用于仅在一定次数的迭代之后在循环内的断点处暂停(通过在循环计数器变量上添加条件)，或者仅当变量的值具有有趣的值时在断点处暂停程序调试目的(避免在其他时间暂停程序)。

condition <bpnum> <exp> Sets breakpoint number <bpnum> to break only when expression <exp> is true

break 28 Set breakpoint at line 28 (in function play)
info break Lists information about all breakpoints
Num Type Disp Enb Address What
1 breakpoint keep y 0x080483a3 in play at gofish.c:28

condition 1 (i > 1000) Set condition on breakpoint 1

用于检查和评估程序状态和表达式的命令

• print (p): 显示表达式的值。尽管 GDB 用户通常会打印程序变量的值，但 GDB 将打印任何 C 表达式的值(甚至是不在程序代码中的表达式)。 print命令支持不同格式的打印，并支持不同数值表示的操作数。

print <exp> Display the value of expression <exp>
p i print the value of i
p i+3 print the value of (i+3)

以不同格式打印：

print <exp> Print value of the expression as unsigned int
print/x <exp> Print value of the expression in hexadecimal
print/t <exp> Print value of the expression in binary
print/d <exp> Print value of the expression as signed int
print/c <exp> Print ASCII value of the expression
print (int)<exp> Print value of the expression as unsigned int

print/x 123 Prints 0x7b
print/t 123 Print 1111011
print/d 0x1c Prints 28
print/c 99 Prints 'c'
print (int)'c' Prints 99

要在表达式中指定不同的数字表示形式(数字默认为十进制表示形式)：

0x prefix for hex: 0x1c
0b prefix for binary: 0b101

print 0b101 Prints 5 (default format is decimal)
print 0b101 + 3 Prints 8
print 0x12 + 2 Prints 20 (hex 12 is 18 in decimal)
print/x 0x12 + 2 Prints 0x14 (decimal 20 in hexadecimal format)

有时，表达式可能需要显式类型转换来告知print如何解释它们。例如，在这里，在取消引用该地址之前，必须将地址值重新转换为特定类型(int *)(否则，GDB不知道如何取消引用该地址)：

print *(int *)0x8ff4bc10 Print int value at address 0x8ff4bc10

当使用print显示取消引用的指针变量的值时，不需要进行类型转换，因为 GDB 知道指针变量的类型并知道如何取消引用其值。例如，如果ptr被声明为int *，它指向的int值可以像这样显示：

print *ptr Print the int value pointed to by ptr

要打印出存储在硬件寄存器中的值：

print $eax Print the value stored in the eax register

• display: 到达断点时自动显示表达式的值。表达式语法与print命令相同。

display <exp> Display value of <exp> at every breakpoint

display i
display array[i]

• x (检查内存)：显示内存位置的内容。此命令类似于print，但它将其参数解释为地址值，并取消引用该地址值以打印存储在该地址处的值。

x <memory address expression>

x 0x5678 Examine the contents of memory location 0x5678
x ptr Examine the contents of memory that ptr points to
x &temp Can specify the address of a variable
(this command is equivalent to: print temp)

与print一样，x可以以不同格式显示值(例如，int、char或字符串)。

一般来说，x最多需要三个格式化参数(x/nfu <内存地址>)；它们列出的顺序并不重要：

  1. n: the repeat count (a positive integer value)

  2. f: the display format (s: string, i: instruction, x: hex, d: decimal, t: binary, a: address, …​)

  3. u: the units format (number of bytes) (b: byte, h: 2 bytes, w: 4 bytes, g: 8 bytes)

以下是一些示例(假设 s1 ="Hello There"位于内存地址0x40062d)：

x/d   ptr       Print value stored at what ptr points to, in decimal
x/a   &ptr      Print value stored at address of ptr, as an address
x/wx  &temp     Print 4-byte value at address of temp, in hexadecimal
x/10dh  0x1234  Print 10 short values starting at address 0x1234, in decimal

x/4c s1         Examine the first 4 chars in s1
    0x40062d   72 'H'  101 'e'  108 'l'  108 'l'

x/s s1         Examine memory location associated with var s1 as a string
    0x40062d   "Hello There"

x/wd s1        Examine the memory location assoc with var s1 as an int
                (because formatting is sticky, need to explicitly set
                units to word (w) after x/s command sets units to byte)
    0x40062d   72

x/8d s1        Examine ASCII values of the first 8 chars of s1
    0x40062d:  72  101 108 108 111 32  84  104

• whatis: 显示表达式的类型。

whatis <exp> Display the data type of an expression

whatis (x + 3.4) Displays: type = double

• set: 分配/更改程序变量的值，或分配要存储在特定内存地址或特定机器寄存器中的值。

set <variable> = <exp> Sets variable <variable> to expression <exp>

set x = 123 * y Set var x's value to (123 * y)

• info: 列出有关程序状态和调试器状态的信息。有大量的info选项用于获取有关程序当前执行状态和调试器的信息。一些例子包括：

help info Shows all the info options
help status Lists more info and show commands

info locals Shows local variables in current stack frame
info args Shows the argument variable of current stack frame
info break Shows breakpoints
info frame Shows information about the current stack frame
info registers Shows register values
info breakpoints Shows the status of all breakpoints

有关这些和其他 GDB 命令的更多信息，请参阅 GDB 手册页 (man gdb) 和 GNU 调试器主页。

3.3. 使用Valgrind调试内存

Valgrind 的 Memcheck 调试工具会突出显示程序中的堆内存错误。堆内存是正在运行的程序内存的一部分，在 C 程序中通过调用 malloc() 动态分配，并通过调用 free() 释放。 Valgrind 发现的内存错误类型包括：

• 从未初始化的内存中读取一个值。例如：

  int *ptr, x;
  ptr = malloc(sizeof(int) * 10);
  x = ptr[3];    // reading from uninitialized memory
  

• 在未分配的内存位置读取或写入值，这通常表示数组越界错误。例如：

  ptr[11] = 100;  // writing to unallocated memory (no 11th element)
  x = ptr[11];    // reading from unallocated memory
  

• 释放之前已经释放的内存。

  free(ptr);
  free(ptr); // freeing the same pointer a second time
  

• 内存泄漏。 内存泄漏是一块已分配的堆内存空间，但是程序中没有任何指针变量引用它，因此无法释放它。也就是说，当程序丢失(没有任何指向)已分配的堆空间块的地址时，就会发生内存泄漏。例如：

  ptr = malloc(sizeof(int) * 10);
  ptr = malloc(sizeof(int) * 5);  // memory leak of first malloc of 10 ints
  

内存泄漏最终会导致程序耗尽堆内存空间，从而导致后续调用 malloc() 失败。其他类型的内存访问错误，例如无效的读取和写入，可能会导致程序崩溃，或者可能导致某些程序内存内容以看似神秘的方式被修改。

内存访问错误是程序中最难发现的错误之一。通常，内存访问错误不会立即导致程序执行中出现明显的错误。相反，它可能会触发稍后在执行过程中发生的错误，通常发生在程序中看似与错误来源无关的部分。有时，出现内存访问错误的程序可能在某些输入上正确运行，但在其他输入上崩溃，从而导致难以查找和修复错误原因。

使用 Valgrind 可以帮助程序员识别这些难以查找的堆内存访问错误并修复这些错误，从而节省大量的调试时间和精力。 Valgrind 还帮助程序员识别在代码测试和调试中未发现的任何潜在堆内存错误。

3.3.1. 堆内存访问错误的示例程序

作为发现和修复具有内存访问错误的程序有多么困难的示例，请考虑以下小程序 (bigfish.c)。当该程序分配超出 bigfish 数组范围的值时，该程序在第二个 for 循环中出现 写入未分配的堆内存 错误（注意：列表中包含源代码行号，并且 print_array() 函数定义未显示，但其行为如所描述的那样）：

 1  #include <stdio.h>
 2  #include <stdlib.h>
 3
 4  /* print size elms of array p with name name */
 5  void print_array(int *p, int size, char *name) ;
 6
 7  int main(int argc, char *argv[]) {
 8      int *bigfish, *littlefish, i;
 9
10      // allocate space for two int arrays
11      bigfish = (int *)malloc(sizeof(int) * 10);
12      littlefish = (int *)malloc(sizeof(int) * 10);
13      if (!bigfish || !littlefish) {
14          printf("Error: malloc failed\n");
15          exit(1);
16      }
17      for (i=0; i < 10; i++) {
18          bigfish[i] = 10 + i;
19          littlefish[i] = i;
20      }
21      print_array(bigfish,10, "bigfish");
22      print_array(littlefish,10, "littlefish");
23
24      // here is a heap memory access error
25      // (write beyond bounds of allocated memory):
26      for (i=0; i < 13; i++) {
27          bigfish[i] = 66 + i;
28      }
29      printf("\nafter loop:\n");
30      print_array(bigfish,10, "bigfish");
31      print_array(littlefish,10, "littlefish");
32
33      free(bigfish);
34      free(littlefish);  // program will crash here
35      return 0;
36  }

在 main() 函数中，第二个 for 循环在写入超出 bigfish 数组范围的三个索引（索引 10、11 和 12）时会导致堆内存访问错误。程序不会在错误发生时崩溃（在执行第二个 for 循环时）；相反，它会在稍后调用 free(littlefish) 时崩溃：

bigfish:
 10  11  12  13  14  15  16  17  18  19
littlefish:
  0   1   2   3   4   5   6   7   8   9

after loop:
bigfish:
 66  67  68  69  70  71  72  73  74  75
littlefish:
 78   1   2   3   4   5   6   7   8   9
Segmentation fault (core dumped)

在 GDB 中运行此程序表明该程序在调用 free(littlefish) 时因段错误而崩溃。此时崩溃可能会让程序员怀疑访问 littlefish 数组时存在错误。然而，错误的原因是写入bigfish 数组，与程序访问 littlefish 数组的错误无关。

程序崩溃的最可能原因是 for 循环超出了 bigfish 数组的范围，并覆盖了 bigfish 最后一个分配元素和 littlefish 第一个分配元素之间的堆内存位置。 malloc() 使用两者之间的堆内存位置（以及 littlefish 的第一个元素之前）来存储有关为 littlefish 数组分配的堆内存的元数据。在内部，free() 函数使用此元数据来确定要释放多少堆内存。对 bigfish 索引 10 和 11 的修改会覆盖这些元数据值，导致程序在调用free(littlefish)时崩溃。但我们注意到，并非所有 malloc() 函数的实现都使用此策略。

由于该程序包含在 bigfish 内存访问错误后打印出 littlefish 的代码，因此错误的原因对于程序员来说可能更明显：第二个 for 循环以某种方式修改了 littlefish 数组的内容（其下标为0的元素值在循环后 神秘地 从 0 更改为 78 ）。然而，即使在这个非常小的程序中，也可能很难找到真正的错误：如果程序在第二个出现内存访问错误的 for 循环之后没有打印出 littlefish ，或者 for 循环上限是 12 而不是 13 ，则程序变量值不会出现明显的神秘变化，无法帮助程序员发现程序访问 bigfish 数组的方式存在错误。

在较大的程序中，这种类型的内存访问错误可能位于程序代码中与崩溃部分截然不同的部分。用于访问已损坏的堆内存的变量与用于错误地覆盖同一内存的变量之间也可能没有逻辑关联；相反，它们唯一的关联是它们碰巧引用了在堆中紧密分配的内存地址。请注意，这种情况在程序的不同运行过程中可能会有所不同，并且这种行为通常对程序员是隐藏的。同样，有时错误的内存访问不会对程序的运行产生明显影响，从而使这些错误难以发现。每当一个程序对于某些输入似乎运行良好，但在其他输入上崩溃时，这就是程序中内存访问错误的迹象。

像 Valgrind 这样的工具可以通过快速向程序员指出代码中堆内存访问错误的来源和类型来节省数天的调试时间。在前面的程序中，Valgrind 描绘了错误发生的点（当程序访问超出 bigfish 数组范围的元素时）。 Valgrind 错误消息包括错误类型、程序中发生错误的位置以及程序中错误内存访问附近的堆内存的分配位置。例如，以下是程序执行第 27 行时 Valgrind 将显示的信息（省略了实际 Valgrind 错误消息中的一些详细信息）：

Invalid write
 at main (bigfish.c:27)
 Address is 0 bytes after a block of size 40 alloc'd
   by main (bigfish.c:11)

此 Valgrind 错误消息表明程序正在第 27 行写入无效（未分配）堆内存，并且该无效内存紧接在第 11 行分配的内存块之后，表明循环正在访问 bigfish 指向的堆空间中已分配内存范围之外的某些元素。解决此错误的一个潜在方法是增加传递给 malloc() 的字节数或更改第二个 for 循环边界，以避免写入超出分配的堆内存空间的边界。

除了查找堆内存中的内存访问错误之外，Valgrind 还可以查找栈内存访问的一些错误，例如使用未初始化的局部变量或尝试访问超出当前栈边界的栈内存位置。但是，Valgrind 不会以与堆内存相同的粒度检测栈内存访问错误，并且不会检测全局数据内存的内存访问错误。

程序可能存在 Valgrind 无法找到的栈和全局内存的内存访问错误。但是，这些错误会导致错误的程序行为或程序崩溃，这与堆内存访问错误可能发生的行为类似。例如，覆盖超出栈上静态声明数组范围的内存位置可能会导致 神秘 地更改其他局部变量的值，或者可能会覆盖保存在栈上的用于从函数调用返回的状态，从而导致函数返回时崩溃。使用 Valgrind 处理堆内存错误的经验可以帮助程序员识别并修复访问栈和全局内存时的类似错误。

3.3.2. 怎样使用Memcheck

我们在示例程序 valgrindbadprog.c 上说明了 Valgrind Memcheck 内存分析工具的一些主要功能，该程序包含几个不良内存访问错误（代码中的注释描述了错误类型）。 Valgrind 默认运行 Memcheck 工具；我们在后面的代码片段中依赖于这种默认行为。您可以使用 --tool=memcheck 选项显式指定 Memcheck 工具。在后面的部分中，我们将通过调用 --tool 选项来调用其他 Valgrind 分析工具。

要运行 Memcheck，请首先使用 -g 标志编译 valgrindbadprog.c 程序，以将调试信息添加到可执行文件（例如 a.out ）。然后，使用 valgrind 运行可执行文件。请注意，对于非交互式程序，将 Valgrind 的输出重定向到文件以便在程序退出后查看可能会有所帮助：

$ gcc -g valgrindbadprog.c
$ valgrind -v ./a.out

# re-direct valgrind (and a.out) output to file 'output.txt'
$ valgrind -v ./a.out >& output.txt

# view program and valgrind output saved to out file
$ vim output.txt

Valgrind 的 Memcheck 工具会打印出程序执行期间发生的内存访问错误和警告。在程序执行结束时，Memcheck 还会打印出有关程序中任何内存泄漏的摘要。尽管修复内存泄漏很重要，但其他类型的内存访问错误对于程序的正确性更为重要。因此，除非内存泄漏导致程序耗尽堆内存空间并崩溃，否则程序员在考虑内存泄漏之前应首先关注修复这些其他类型的内存访问错误。要查看各个内存泄漏的详细信息，请使用 --leak-check=yes 选项。

第一次使用 Valgrind 时，它的输出可能看起来有点难以解析。但是，输出都遵循相同的基本格式，一旦您了解了这种格式，就可以更轻松地理解 Valgrind 显示的有关堆内存访问错误和警告的信息。以下是运行 valgrindbadprog.c 程序时出现的 Valgrind 错误示例：

==31059== Invalid write of size 1
==31059==    at 0x4006C5: foo (valgrindbadprog.c:29)
==31059==    by 0x40079A: main (valgrindbadprog.c:56)
==31059==  Address 0x52045c5 is 0 bytes after a block of size 5 alloc'd
==31059==    at 0x4C2DB8F: malloc (in /usr/lib/valgrind/...)
==31059==    by 0x400660: foo (valgrindbadprog.c:18)
==31059==    by 0x40079A: main (valgrindbadprog.c:56)

Valgrind 输出的每一行都以进程的 ID (PID) 号为前缀（本例中为 31059）：

==31059==

大多数 Valgrind 错误和警告具有以下格式：

1. 错误或警告的类型
2. 错误发生的位置（错误发生时程序执行栈跟踪。）
3. 错误周围的堆内存被分配的位置（通常是与错误相关的内存分配。）

在前面的示例错误中，第一行显示对内存的无效写入（写入堆中未分配的内存 — 一个非常严重的错误！）：

==31059== Invalid write of size 1

接下来的几行显示发生错误的堆栈跟踪。这些表明函数 foo() 的第 29 行发生了无效写入，该函数是从第 56 行的函数 main() 调用的：

==31059== Invalid write of size 1
==31059==    at 0x4006C5: foo (valgrindbadprog.c:29)
==31059==    by 0x40079A: main (valgrindbadprog.c:56)

其余行指示无效写入附近的堆空间在程序中的分配位置。 Valgrind 输出的这一部分表明，无效写入紧接在 5 字节堆内存空间块之后（ 0 个字节之后 ），该块是通过在函数 foo() 第 18 行调用 malloc() 分配的，由第 56 行 main() 调用：

==31059==  Address 0x52045c5 is 0 bytes after a block of size 5 alloc'd
==31059==    at 0x4C2DB8F: malloc (in /usr/lib/valgrind/...)
==31059==    by 0x400660: foo (valgrindbadprog.c:18)
==31059==    by 0x40079A: main (valgrindbadprog.c:56)

此错误中的信息表明程序中存在未分配的堆内存写入错误，并将用户引导至程序中发生错误的特定部分（第 29 行）以及分配错误周围的内存的位置（第 18 行）。通过查看程序中的这些点，程序员可以了解错误的原因和修复方法：

 18   c = (char *)malloc(sizeof(char) * 5);
 ...
 22   strcpy(c, "cccc");
 ...
 28   for (i = 0; i <= 5; i++) {
 29       c[i] = str[i];
 30   }

原因是 for 循环执行了太多次，访问了 c[5] ，超出了数组 c 的末尾。解决方法是更改​​第 29 行的循环边界或在第 18 行分配更大的数组。

如果检查 Valgrind 错误周围的代码不足以让程序员理解或修复错误，那么使用 GDB 可能会有所帮助。在代码中与 Valgrind 错误相关的点周围设置断点可以帮助程序员评估程序的运行时状态并了解 Valgrind 错误的原因。例如，通过在第 29 行放置断点并打印 i 和 str 的值，当 i 为 5 时，程序员可以看到数组越界错误。在这种情况下，使用 Valgrind 和 GDB 的组合可以帮助程序员确定如何修复 Valgrind 发现的内存访问错误。

虽然本章重点介绍了 Valgrind 的默认 Memcheck 工具，但我们将在本书后面介绍 Valgrind 的一些其他功能，包括 Cachegrind 缓存分析工具（第 11 章）、Callgrind 代码分析工具（第 11 章） 12)，以及Massif 内存分析工具（第 12 章）。有关使用 Valgrind 的更多信息，请参阅 Valgrind 主页 及其在线手册。

3.4. 高级GDB特性

本节介绍高级 GDB 功能，其中一些功能只有在阅读了操作系统 章节后才有意义。

3.4.1. GDB和make

GDB 接受 make 命令以在调试会话期间重建可执行文件，如果构建成功，它将运行新构建的程序（当发出 run 命令时）。

(gdb) make
(gdb) run

对于设置了许多断点并修复了一个错误但想要继续调试会话的用户来说，从 GDB 中进行构建非常方便。在这种情况下，GDB 用户可以运行 make 并在仍然设置所有断点的情况下开始调试程序的新版本，而不是退出 GDB、重新编译、使用新的可执行文件重新启动 GDB 以及重置所有断点。但请记住，如果添加或删除了源代码行，则通过在 GDB 中运行 make 来修改 C 源代码并重新编译可能会导致新版本程序中的断点与旧版本中的断点不在同一逻辑位置。出现此问题时，请退出 GDB 并在新的可执行文件上重新启动 GDB 会话，或者使用 disable 或 delete 禁用或删除旧断点，然后使用 break 在新编译的程序版本中的正确位置设置新断点。

3.4.2. 将 GDB 附加到正在运行的进程

GDB 支持通过将 GDB 连接到正在运行的进程来调试已在运行的程序（而不是在 GDB 会话中启动程序运行）。为此，用户需要获取进程 ID (PID) 值：

1. 使用 ps shell 命令获取进程的 PID：

    # ps to get process's PID (lists all processes started in current shell):
    $ ps
    
    # list all processes and pipe through grep for just those named a.out:
    $ ps -A | grep a.out
       PID TTY          TIME CMD
       12345 pts/3     00:00:00 a.out
    

2. 启动GDB并将其附加到特定的运行进程（PID为12345）：

    # gdb <executable> <pid>
    $ gdb a.out 12345
    (gdb)
    
    # OR alternative syntax: gdb attach <pid>  <executable>
    $ gdb attach 12345 a.out
    (gdb)

将 GDB 附加到进程会暂停该进程，用户可以在继续执行之前发出 GDB 命令。

或者，程序可以通过调用 kill(getpid(), SIGSTOP) 显式暂停自身以等待调试（如 attach_example.c 示例中所示）。当程序此时暂停时，程序员可以将 GDB 附加到进程中以对其进行调试。

无论程序如何暂停，在 GDB 连接进程并且用户输入一些 GDB 命令后，程序都会使用 cont 从其连接点继续执行。如果 cont 不起作用，GDB 可能需要显式向进程发送 SIGCONT 信号才能继续执行：

 (gdb) signal SIGCONT

3.4.3. 跟踪fork系统调用之后的进程

当GDB调试一个调用fork()函数创建新子进程的程序时，可以将GDB设置为跟随（调试）父进程或子进程，使另一个进程的执行不受GDB影响。默认情况下，GDB 在调用 fork() 后跟随父级。要将 GDB 设置为跟随子进程，请使用 set follow-fork-mode 命令：

(gdb) set follow-fork-mode child    # Set gdb to follow child on fork

(gdb) set follow-fork-mode parent   # Set gdb to follow parent on fork
(gdb) show follow-fork-mode         # Display gdb's follow mode

当用户想要在 GDB 会话期间更改此行为时，在程序中的 fork() 调用处设置断点非常有用。

attach_example.c 示例展示了一种在 fork 上"跟随"两个进程的方法：GDB 在 fork 后跟随父进程，子进程向自己发送一个 SIGSTOP 信号以在 fork 后显式暂停，从而允许程序员在继续之前将第二个 GDB 进程附加到子进程。

3.4.4. 信号控制

GDB进程可以向正在调试的目标进程发送信号，并且可以处理目标进程接收到的信号。 GDB 可以使用 signal 命令向其调试的进程发送信号：

(gdb) signal SIGCONT
(gdb) signal SIGALARM
...

有时，用户希望 GDB 在被调试进程收到信号时执行某些操作。例如，如果程序尝试访问其所访问类型的内存地址未对齐的内存，它会收到 SIGBUS 信号，并且通常会退出。 GDB 在 SIGBUS 上的默认行为也是让进程退出。但是，如果您希望 GDB 在收到 SIGBUS 时检查程序状态，则可以使用 handle 命令指定 GDB 以不同的方式处理 SIGBUS 信号（ info 命令显示有关 GDB 在调试期间如何处理进程接收到的信号的附加信息）：

(gdb) handle SIGBUS stop    # if program gets a SIGBUS, gdb gets control

(gdb) info signal           # list info on all signals
(gdb) info SIGALRM          # list info just for the SIGALRM signal

3.4.5. DDD设置和错误修复

运行 DDD 会在您的主目录中创建一个 .ddd 目录，用于存储其设置，以便用户无需在每次调用时从头开始重置所有首选项。保存设置的一些示例包括子窗口的大小、菜单显示选项以及启用窗口以查看寄存器值和汇编代码。

有时 DDD 在启动时挂起，并显示“等待 GDB 就绪”消息。这通常表明其保存的设置文件中有错误。解决此问题的最简单方法是删除“.ddd”目录（您将丢失所有保存的设置，并且需要在再次启动时重置它们）：

$ rm -rf ~/.ddd  # Be careful when entering this command!
$ ddd ./a.out

3.5. 调试汇编代码

除了高级 C 和 C++ 调试之外，GDB 还可以在汇编代码级别调试程序。这样做使 GDB 能够列出函数中的反汇编代码序列，在汇编指令级别设置断点，一次逐步执行一条汇编指令，并在运行时检查存储在机器寄存器以及栈和堆内存地址中的值。我们在本节中使用 IA32 作为示例汇编语言，但此处介绍的 GDB 命令适用于 GCC 支持的任何汇编语言。我们注意到，在阅读了后面章节中有关汇编代码的更多信息后，读者可能会发现本小节最有用。

我们使用以下简短的 C 程序作为示例：

int main(void) {
    int x, y;

    x = 1;
    x = x + 2;
    x = x - 14;
    y = x * 100;
    x = x + y * 6;

    return 0;
}

要编译为 IA32 可执行文件，请使用 -m32 标志：

$ gcc -m32 -o simpleops simpleops.c

或者，使用 gcc 的 -fno-asynchronous-unwind-tables 命令行选项进行编译会生成 IA32 代码，程序员更容易阅读和理解：

$ gcc -m32 -fno-asynchronous-unwind-tables -o simpleops simpleops.c

3.5.1. 使用 GDB 检查二进制代码

在本节中，我们将展示一些在汇编代码级别调试短 C 程序的示例 GDB 命令。下表总结了本节演示的许多命令：

首先，编译为 IA32 汇编指令集集并在 IA32 架构的可执行程序 simpleops 上运行 GDB：

$ gcc -m32 -fno-asynchronous-unwind-tables -o simpleops simpleops.c
$ gdb ./simpleops

然后，在 main 中设置断点，然后使用 run 命令开始运行程序：

(gdb) break main
(gdb) run

disass 命令反汇编（列出与之关联的汇编代码）程序的各个部分。例如查看main函数的汇编指令：

(gdb) disass main         # Disassemble the main function

GDB 允许程序员通过取消引用指令的内存地址来在各个汇编指令处设置断点：

(gdb) break *0x080483c1   # Set breakpoint at instruction at 0x080483c1

程序的执行可以一次执行一条汇编指令，使用 si 或 ni 进入或执行下一条指令：

(gdb) ni     # Execute the next instruction

(gdb) si     # Execute next instruction; if it is a call instruction,
             # then step into the function

si 命令进入函数调用，这意味着 GDB 将在被调用函数的第一条指令处暂停程序。 ni 命令会跳过它们，这意味着 GDB 将在调用指令之后的下一条指令处暂停程序（在函数执行并返回到调用者之后）。

程序员可以使用 print 命令和前缀为 $ 的寄存器名称来打印存储在机器寄存器中的值：

(gdb) print $eax    # print the value stored in register eax

display 命令在到达断点时自动显示值：

(gdb) display $eax
(gdb) display $edx

info registers 命令显示存储在机器寄存器中的所有值：

(gdb) info registers

3.5.2. 使用 DDD 在程序集级别进行调试

DDD 调试器在另一个调试器（本例中为 GDB）之上提供了一个图形界面。它提供了一个很好的界面，用于显示汇编代码、查看寄存器和单步执行 IA32 指令。由于 DDD 有单独的窗口来显示反汇编代码、寄存器值和 GDB 命令提示符，因此在汇编代码级别进行调试时，它通常比 GDB 更容易使用。

要使用 DDD 进行调试，请将 ddd 替换为 gdb ：

$ ddd ./simpleops

GDB 提示符出现在底部窗口中，它在提示符处接受 GDB 命令。虽然它为一些 GDB 命令提供了菜单选项和按钮，但通常底部的 GDB 提示符更容易使用。

DDD 通过选择 View → Machine Code Window 菜单选项来显示程序的汇编代码视图。该选项创建一个新的子窗口，其中包含程序的汇编代码列表（您可能需要调整此窗口的大小以使其更大）。

要在单独的窗口中查看程序的所有寄存器值，请启用 Status → Registers 菜单选项。

3.5.3. GDB汇编代码调试命令和示例

以下是一些有助于在汇编代码级别进行调试的 GDB 命令的详细信息和示例（请参阅常用 GDB 命令 部分，了解有关其中一些命令的更多详细信息，特别是 print 和 x 格式选项）：

• disass: 反汇编一个函数或某些地址范围的代码。

    disass <func_name>   # Lists assembly code for function
    disass <start> <end> # Lists assembly instructions between start & end address
    
    disass main          # Disassemble main function
    disass 0x1234 0x1248 # Disassemble instructions between addr 0x1234 & 0x1248

• break: 在指令地址处设置断点。

    break *0x80dbef10  # Sets breakpoint at the instruction at address 0x80dbef10

• stepi (si), nexti (ni) :

    stepi, si          # Execute next machine code instruction,
                       # stepping into function call if it is a call instr
    nexti,  ni         # Execute next machine code instruction,
                       # treating function call as a single instruction

• info registers: 列出所有寄存器值。

• print: 显示表达式的值。

    print $eax                # Print the value stored in the eax register
    print *(int *)0x8ff4bc10  # Print int value stored at memory addr 0x8ff4bc10

• x 显示给定地址的内存位置的内容。请记住， x 的格式是粘性的(sticky)，因此需要显式更改。

    (gdb) x $ebp-4      # Examine memory at address: (contents of register ebp)-4
                        # if the location stores an address x/a, an int x/wd, ...
    
    (gdb) x/s 0x40062d  # Examine the memory location 0x40062d as a string
    0x40062d   "Hello There"
    
    (gdb) x/4c 0x40062d # Examine the first 4 char memory locations
                        # starting at address 0x40062d
    0x40062d   72 'H'  101 'e' 108 'l' 108 'l'
    
    (gdb) x/d 0x40062d  # Examine the memory location 0x40062d in decimal
    0x40062d   72       # NOTE: units is 1 byte, set by previous x/4c command
    
    (gdb) x/wd 0x400000 # Examine memory location 0x400000 as 4 bytes in decimal
    0x400000   100      # NOTE: units was 1 byte set, need to reset to w

• set: 设置内存位置和寄存器的内容。

    set $eax = 10                 Set the value of register eax to 10
    set $esp = $esp + 4           Pop a 4-byte value off the stack
    set *(int *)0x8ff4bc10 = 44   Store 44 at address 0x8ff4bc10

• display: 每次命中断点时打印一个表达式。

    display $eax         Display value of register eax

3.5.4. 汇编调试常用命令快速汇总

$ ddd ./a.out
(gdb) break main
(gdb) run

(gdb) disass main         # Disassemble the main function
(gdb) break sum           # Set a breakpoint at the beginning of a function
(gdb) cont                # Continue execution of the program
(gdb) break *0x0804851a   # Set a breakpoint at memory address 0x0804851a
(gdb) ni                  # Execute the next instruction
(gdb) si                  # Step into a function call (step instruction)
(gdb) info registers      # List the register contents
(gdb) p $eax              # Print the value stored in register %eax
(gdb) p  *(int *)($ebp+8) # Print out value of an int at addr (%ebp+8)
(gdb) x/d $ebp+8          # Examine the contents of memory at the given
                          #  address (/d: prints the value as an int)
(gdb) x/s 0x0800004       # Examine contents of memory at address as a string
(gdb) x/wd 0xff5634       # After x/s, the unit size is 1 byte, so if want
                          # to examine as an int specify both the width w & d

3.6. 使用 GDB 调试多线程程序

由于多个执行流以及并发执行线程之间的交互，调试多线程程序可能会很棘手。一般来说，以下一些事情可以使调试多线程程序变得更容易：

• 如果可能，请尝试使用尽可能少的线程来调试程序的版本。
• 在代码中添加调试 printf 语句时，打印出执行线程的 ID 以识别哪个线程正在打印，并以 \n 结束该行。
• 通过仅让一个线程打印其信息和公共信息来限制调试输出量。例如，如果每个线程将其逻辑 ID 存储在名为 my_tid 的局部变量中，则可以使用 my_tid 值的条件语句将打印调试输出限制为一个线程，如以下示例所示：

if (my_tid == 1) {
    printf("Tid:%d: value of count is %d and my i is %d\n", my_tid, count, i);
    fflush(stdout);
}

3.6.1. GDB 和 Pthread

GDB 调试器特别支持调试线程程序，包括为各个线程设置断点和检查各个线程的堆栈。在GDB中调试Pthreads程序时需要注意的一点是，每个线程至少有三个标识符：

• Pthreads 库的线程 ID（其 pthread_t 值）。
• 操作系统的线程的轻量级进程 (LWP) ID 值。该 ID 部分用于操作系统跟踪该线程以进行调度。
• 线程的 GDB ID。这是在 GDB 命令中指定特定线程时使用的 ID。

线程 ID 之间的具体关系可能因操作系统和 Pthreads 库实现而异，但在大多数系统上，Pthreads ID、LWP ID 和 GDB 线程 ID 之间存在一一对应的关系。

我们介绍了一些用于在 GDB 中调试线程程序的 GDB 基础知识。有关在 GDB 中调试线程程序 的详细信息，请参阅以下内容。

3.6.2. GDB 线程特定命令：

• 启用打印线程启动和退出事件：

    set print thread-events

• 列出程序中所有现有的线程（GDB 线程号是列出的第一个值，命中断点的线程用 * 表示）：

    info threads

• 切换到特定线程的执行上下文（例如，在执行 where 时检查其堆栈），通过线程 ID 指定线程：

    thread <threadno>
    
    thread 12        # Switch to thread 12's execution context
    where            # Thread 12's stack trace

• 仅为特定线程设置断点。在代码中设置断点的地方执行的其他线程不会触发断点来暂停程序并打印GDB提示符：

    break <where> thread <threadno>
    
    break foo thread 12    # Break when thread 12 executes function foo

• 要将特定的 GDB 命令应用于所有线程或线程子集，请添加前缀thread apply <threadno | all> 为 GDB 命令，其中 threadno 指的是 GDB 线程 ID：

    thread apply <threadno|all> command

这并不适用于每个 GDB 命令，特别是设置断点，因此请使用此语法来设置特定于线程的断点：

    break <where> thread <threadno>

默认情况下，到达断点后，GDB 会暂停所有线程，直到用户输入 cont 。用户可以更改行为以请求 GDB 仅暂停遇到断点的线程，从而允许其他线程继续执行。

3.6.3. 示例:

我们展示了一些 GDB 命令以及在从文件 racecond.c 编译的多线程可执行文件上运行的 GDB 的输出。

这个错误的程序缺乏对共享变量 count 的访问同步。因此，程序的不同运行会产生不同的 count 最终值，这表明存在竞争条件。例如，以下是具有五个线程的程序的两次运行，产生不同的结果：

./a.out 5
hello I'm thread 0 with pthread_id 139673141077760
hello I'm thread 3 with pthread_id 139673115899648
hello I'm thread 4 with pthread_id 139673107506944
hello I'm thread 1 with pthread_id 139673132685056
hello I'm thread 2 with pthread_id 139673124292352
count = 159276966

./a.out 5
hello I'm thread 0 with pthread_id 140580986918656
hello I'm thread 1 with pthread_id 140580978525952
hello I'm thread 3 with pthread_id 140580961740544
hello I'm thread 2 with pthread_id 140580970133248
hello I'm thread 4 with pthread_id 140580953347840
count = 132356636

解决方法是使用 pthread_mutex_t 变量对 count 进行访问。如果用户无法仅通过检查 C 代码来看到此修复，则在 GDB 中运行并在对 count 变量的访问周围放置断点可能会帮助程序员发现问题。

以下是该程序的 GDB 运行中的一些示例命令：

(gdb) break worker_loop   # Set a breakpoint for all spawned threads
(gdb) break 77 thread 4   # Set a breakpoint just for thread 4
(gdb) info threads        # List information about all threads
(gdb) where               # List stack of thread that hit the breakpoint
(gdb) print i             # List values of its local variable i
(gdb) thread 2            # Switch to different thread's (2) context
(gdb) print i             # List thread 2's local variables i

下面的示例显示的是具有 3 个线程的 racecond 程序的 GDB 运行的部分输出（run 3），显示了 GDB 调试会话上下文中的 GDB 线程命令示例。主线程始终是 GDB 线程号 1，三个派生线程是 GDB 线程 2 到 4。

在调试多线程程序时，GDB 用户必须在发出命令时跟踪存在哪些线程。例如，当命中 main 中的断点时，仅存在线程 1（主线程）。因此，GDB 用户必须等到线程创建后才能仅为特定线程设置断点（本示例显示仅在程序中的第 77 行为线程 4 设置断点）。查看此输出时，请注意何时设置和删除断点，并注意当使用 GDB 的 thread 命令切换线程上下文时每个线程的局部变量 i 的值：

$ gcc -g racecond.c -pthread

$ gdb ./a.out
(gdb) break main
Breakpoint 1 at 0x919: file racecond.c, line 28.
(gdb) run 3
Starting program: ...
[Thread debugging using libthread_db enabled] ...

Breakpoint 1, main (argc=2, argv=0x7fffffffe388) at racecond.c:28
28	    if (argc != 2) {
(gdb) list 76
71	  myid = *((int *)arg);
72
73	  printf("hello I'm thread %d with pthread_id %lu\n",
74	      myid, pthread_self());
75
76	  for (i = 0; i < 10000; i++) {
77	      count += i;
78	  }
79
80	  return (void *)0;

(gdb) break 76
Breakpoint 2 at 0x555555554b06: file racecond.c, line 76.
(gdb) cont
Continuing.

[New Thread 0x7ffff77c4700 (LWP 5833)]
hello I'm thread 0 with pthread_id 140737345505024
[New Thread 0x7ffff6fc3700 (LWP 5834)]
hello I'm thread 1 with pthread_id 140737337112320
[New Thread 0x7ffff67c2700 (LWP 5835)]
[Switching to Thread 0x7ffff77c4700 (LWP 5833)]

Thread 2 "a.out" hit Breakpoint 2, worker_loop (arg=0x555555757280)
    at racecond.c:76
76	  for (i = 0; i < 10000; i++) {
(gdb) delete 2

(gdb) break 77 thread 4
Breakpoint 3 at 0x555555554b0f: file racecond.c, line 77.
(gdb) cont
Continuing.

hello I'm thread 2 with pthread_id 140737328719616
[Switching to Thread 0x7ffff67c2700 (LWP 5835)]

Thread 4 "a.out" hit Breakpoint 3, worker_loop (arg=0x555555757288)
    at racecond.c:77
77	      count += i;
(gdb) print i
$2 = 0
(gdb) cont
Continuing.
[Switching to Thread 0x7ffff67c2700 (LWP 5835)]

Thread 4 "a.out" hit Breakpoint 3, worker_loop (arg=0x555555757288)
    at racecond.c:77
77	      count += i;
(gdb) print i
$4 = 1

(gdb) thread 3
[Switching to thread 3 (Thread 0x7ffff6fc3700 (LWP 5834))]
#0  0x0000555555554b12 in worker_loop (arg=0x555555757284) at racecond.c:77
77	      count += i;
(gdb) print i
$5 = 0

(gdb) thread 2
[Switching to thread 2 (Thread 0x7ffff77c4700 (LWP 5833))]
#0  worker_loop (arg=0x555555757280) at racecond.c:77
77	      count += i;
(gdb) print i
$6 = 1

3.7. 总结

本章总结了我们对 C 编程语言的介绍。与其他高级编程语言相比，C 是一种相对较小的编程语言，具有一些程序员构建程序的基本结构。由于 C 语言抽象更接近计算机执行的底层机器代码，因此 C 程序员可以编写比使用其他编程语言提供的高级抽象编写的等效代码运行效率更高的代码。特别是，C 程序员对其程序如何使用内存有更多的控制权，这会对程序的性能产生重大影响。 C 是计算机系统编程语言，其中低级控制和效率至关重要。

在后续章节中，我们使用 C 示例来说明计算机系统是如何设计来运行程序的。

从简单的石碑和洞穴壁画到书面文字和留声机凹槽，人类一直在寻求记录和存储信息。在本章中，我们将描述人类最新的重大存储突破——数字计算——如何表示信息。我们还说明了如何解释数字数据的含义。

现代计算机利用各种介质来存储信息（例如磁盘、光盘、闪存、磁带和简单电路）。我们稍后将在第 11 章 中描述存储设备的特征；然而，对于本次讨论来说，介质在很大程度上是无关紧要的——无论是扫描 DVD 表面的激光还是在磁盘上滑动的磁头，存储设备的输出最终都是一系列电信号。为了简化电路，每个信号都是二进制，这意味着它只能采用两种状态之一：不存在电压（解释为零）和存在电压（解释为一）。本章探讨系统如何将信息编码为二进制，而不管原始存储介质是什么。

在二进制中，每个信号对应一个位（二进制数字）信息：零或一。令人惊讶的是，所有数据都可以仅使用零和一来表示。当然，随着信息复杂性的增加，表示信息所需的位数也随之增加。幸运的是，位序列中每增加一位，唯一值的数量就会加倍，因此 N 位序列可以表示2^N个唯一值。

图 1 说明了可表示值的数量随着位序列长度的增加而增长。单个位可以表示两个值：0 和 1。两个位可以表示四个值：两个都以 0 开头的一位值（00 和 01），以及两个以 1 开头的一位值（10 和 11）。相同的模式适用于扩展现有位序列的任何附加位：新位可以是 0 或 1，并且在任何一种情况下，其余位都表示与添加新位之前相同的值范围。因此，添加额外的位会以指数方式增加新序列可以表示的值的数量。

图 1. 可以用一到四位表示的值。带下划线的位对应于来自上面行的前缀。

由于单个位不能代表太多信息，因此存储系统通常将位分组为更长的序列以存储更多有趣的值。最普遍的分组是字节，它是八位的集合。一个字节代表 28 = 256 个唯一值 (0-255) — 足以枚举英语字母和常见标点符号。字节是计算机系统中可寻址内存的最小单位，这意味着程序不能要求少于八位来存储变量。

现代 CPU 通常还将字定义为 32 位或 64 位，具体取决于硬件的设计。字的大小决定了系统硬件用于将数据从一个组件移动到另一个组件（例如，在内存和寄存器之间）的“默认”大小。这些更大的序列对于存储数字是必要的，因为程序通常需要计算高于 256 的数字！

如果您用 C 语言编程，您就会知道必须在使用变量之前声明它。此类声明告知 C 编译器有关变量二进制表示形式的两个重要属性：为其分配的位数，以及程序打算解释这些位的方式。从概念上讲，位数很简单，因为编译器只需查找与声明的类型相关联的位数（例如，char是一个字节）并将该内存量与变量相关联。位序列的解释在概念上更有趣。计算机内存中的所有数据都以位的形式存储，但位没有 固有 含义。例如，即使只有一个位，您也可以用多种不同的方式解释该位的两个值：向上和向下、黑色和白色、是和否、开和关等。

扩展位序列的长度扩大了其解释的范围。例如，char变量使用美国信息交换标准代码 (ASCII) 编码标准，该标准定义了八位二进制值如何对应于英文字母和标点符号。 表 1 显示了 ASCII 标准的一小部分（如需完整参考，请在命令行上运行“man ascii”）。没有什么特殊原因为什么字符“X”需要对应01011000，所以不用费心去记这个表。重要的是每个存储字母的程序都同意其位序列解释，这就是标准委员会定义 ASCII 的原因。

表 1. 八位 ASCII 字符编码标准的一个小片段

任何信息都可以二进制编码，包括图形和音频等丰富的数据。例如，假设图像编码方案定义 00、01、10 和 11 对应于白色、橙色、蓝色和黑色。 图 2 展示了我们如何使用这种简单的两位编码策略仅使用 12 个字节来绘制鱼的原始图像。在 a 部分中，图像的每个单元相当于一个两位序列。 b 和 c 部分分别将相应的二进制编码显示为两位和字节序列。尽管出于学习目的而简化了示例编码方案，但总体思路与真实图形系统使用的类似，尽管具有更多位用于更广泛的颜色。

图 2. 简单鱼图像的 (a) 图像表示、(b) 两位单元表示和 (c) 字节表示。

刚刚介绍了两种编码方案，相同的位序列 01011010 对于文本编辑器来说可能意味着字符Z，而图形程序可能会将其解释为鱼尾鳍的一部分。哪种解释是正确的取决于上下文。尽管底层的位是相同的，但人类经常发现某些解释比其他解释更容易理解（例如，将鱼视为彩色细胞而不是字节表）。

本章的其余部分主要讨论二进制数的表示和操作，但总体要点值得重复：所有信息都以 0 和 1 的形式存储在计算机内存中，并且由程序或运行程序的人员来解释这些位的含义。

看到二进制序列可以用各种非数字方式解释，让我们将注意力转向数字。具体来说，我们将从无符号数字开始，这些数字可以解释为零或正数，但它们永远不能为负数（它们没有 符号）。

4.1.1. 小数

我们先不从二进制开始，而是先检查一下我们已经习惯使用的数字系统，即十进制数字系统，它使用 base 为 10。Base 10 意味着解释和表示十进制值的两个重要属性。

1. 以 10 为基数的数字中的任何单个数字都存储 10 个唯一值 (0-9) 之一。要存储大于 9 的值，该值必须进位 到左侧的附加数字。例如，如果一位数字从最大值 (9) 开始，我们加 1，则结果需要两位数字 (9 + 1 = 10)。相同的模式适用于任何数字，无论其在数字中的位置如何（例如，5080 + 20 = 5100）。
2. 数字中每个数字的位置决定了该数字对于数字总价值的重要性。将从右到左的数字标记为 d0、d1、d2 等，每个连续的数字比下一个数字贡献 十 倍。例如，取值 8425（图 1）。

图 1. 以 10 为基数的数字中每个数字的重要性，使用您在小学时可能给每个数字起的名称。

对于示例值 8425，“个位”中的 5 贡献 5 (5 × 10⁰)。 “十位”的 2 贡献 20 (2 × 10¹)。 “百位”中的 4 贡献了 400 (4 × 10²)，最后，“千位”中的 8 贡献了 8000 (8 × 10³)。更正式地说，可以将 8425 表示为

(8 × 10³)    +    (4 × 10²)    +    (2 × 10¹)    +    (5 × 10⁰)

这种以 10 为底的指数递增模式就是它被称为 base 10 数字系统的原因。将位置编号分配给从右到左从 d0 开始的数字意味着每个数字 di 为总价值贡献 10i 。因此，任何 N 位十进制数的总值可以表示为：

(d_N-1 × 10^N-1)  + (d_N-2 × 10^N-2) + …​ + (d₂ × 10²) + (d₁ × 10¹) + (d₀ × 10⁰)

幸运的是，正如我们很快就会看到的，非常相似的模式也适用于其他数字系统。

4.1.2. 无符号二进制数

虽然您可能从未考虑过将十进制数描述为 10 的幂的具体公式，但 { 个位, 十位, 百位, 等. } 位的概念应该会让您感到熟悉。幸运的是，类似的术语适用于其他数字系统，例如二进制。当然，其他数字系统中的基数不同，因此每个数字位置对其数值的贡献量不同。

二进制数字系统使用基数 2，而不是十进制的 10。以与我们刚才对十进制相同的方式进行分析，可以发现几个相似之处（用 2 代替 10）：

1. 以 2 为基数的数字中的任何单个位都存储两个唯一值（0 或 1）之一。要存储大于 1 的值，二进制编码必须进位 到左侧的附加位。例如，如果一位从最大值 (1) 开始，并且我们向其加 1，则结果需要两位 (1 + 1 = 0b10)。相同的模式适用于任何位，无论其在数字中的位置如何（例如，0b100100 + 0b100 = 0b101000）。
2. 数字中每一位的位置决定了该位对于数字的数值的重要性。将从右到左的数字标记为 d0、d1、d2 等，每个连续位的贡献比下一位多 两倍 。

第一点意味着二进制计数遵循与十进制相同的模式：通过简单地枚举值并添加数字（位）。由于本节重点介绍_无符号_数字（仅零和正数），因此很自然地从零开始计数。 表 1 显示了如何计算二进制中的前几个自然数。从表中可以看出，以二进制计数很快就会增加位数。直观上，这种增长是有道理的，因为每个二进制数字（两个可能的值）代表的信息少于十进制数字（10 个可能的值）。

表 1. 二进制与十进制计数的比较

关于标记数字的第二点看起来非常熟悉！事实上，它与十进制非常相似，以至于可以得出几乎相同的解释二进制数的公式。只需将每个指数底部的 10 替换为 2：

(d_N-1 × 2^N-1) +  (d_N-2 × 2^N-2) +  …​ +  (d₂ × 2²) + (d₁ × 2¹) + (d₀ × 2⁰)

应用此公式会产生任何二进制数的 无符号 解释。例如，取 0b1000：

(1 × 2³) + (0 × 2²) + (0 × 2¹) + (0 × 2⁰)

  =    8 + 0 + 0 + 0    =    8

这是一个更长的单字节示例，0b10110100：

(1 × 2⁷) + (0 × 2⁶) + (1 × 2⁵) + (1 × 2⁴) + (0 × 2³) + (1 × 2²) + (0 × 2¹) + (0 × 2⁰)

  =    128 + 0 + 32 + 16 + 0 + 4 + 0 + 0    =    180

4.1.3. 十六进制

到目前为止，我们已经研究了两种数字系统：十进制和二进制。十进制因其对人类的舒适性而引人注目，而二进制则与数据在硬件中存储的方式相匹配。值得注意的是，它们的表达能力是相当的。也就是说，没有任何数字可以在一个系统中表示而不能在另一个系统中表示。考虑到它们的等价性，您可能会感到惊讶，我们将讨论另一种数字系统：以 16 为基数的十六进制系统。

有了两个完美的数字系统，您可能想知道为什么我们需要另一个。答案主要是方便。如表 1 所示，二进制位序列快速增长到大量数字。人类往往很难理解仅包含 0 和 1 的长序列。尽管十进制更紧凑，但它的基数 10 与二进制的基数 2 不匹配。

十进制不容易捕获可以使用固定位数表示的范围。例如，假设一台旧计算机使用 16 位内存地址。其有效地址范围为 0b0000000000000000 到 0b1111111111111111。以十进制表示，地址范围从 0 到 65535。显然，十进制表示比长二进制序列更紧凑，但除非您记住它们的转换，否则很难推理十进制数字。在使用 32 位或 64 位地址的现代设备上，这两个问题只会变得更糟！

这些长位序列正是十六进制的 16 进制的亮点。大基数允许每个数字表示足够的信息，使十六进制数变得紧凑。此外，由于基数本身就是 2 的幂 (24 = 16)，因此很容易将十六进制映射到二进制，反之亦然。为了完整起见，我们用十进制和二进制同样的方式来分析十六进制：

1. 16 进制数字中的任何单个数字都存储 16 个唯一值之一。超过 10 个值对十六进制提出了新的挑战——传统的 10 位数字的最大值为 9。按照惯例，十六进制使用字母来表示大于 9 的值，其中 A 代表 10，B 代表 11，最多 F 代表 15。与其他系统一样，要存储大于 15 的值，数字必须进位到左侧的附加数字。例如，如果一位数字从最大值 (F) 开始，并且我们向其加 1，则结果需要两位数字（0xF + 0x1 = 0x10；请注意，我们使用 0x 表示十六进制数字）。
2. 数字中每个数字的位置决定了该数字对于数字的数值的重要性。将从右到左的数字标记为 d0、d1、d2 等，每个连续数字的贡献比下一个数字多 16 倍。

毫不奇怪，解释数字的相同可靠公式也适用于以 16 为基数的十六进制：

(d_N-1 × 16^N-1) + (d_N-2 × 16^N-2) + …​ + (d₂ × 16²) + (d₁ × 16¹) + (d₀ × 16⁰)

例如，要确定 0x23C8 的十进制值：

 >  (2 × 16³)    +    (3 × 16²)    +    (C × 16¹)    +    (8 × 16⁰)

  = (2 × 16³)    +    (3 × 16²)    +    (12 × 16¹)    +    (8 × 16⁰)   =    (2 × 4096)    +    (3 × 256)    +    (12 × 16)    +    (8 × 1)   =    8192 + 768 + 192 + 8    =    9160

4.1.4. 存储限制

从概念上讲，无符号整数有无限多个。在实践中，出于多种原因，程序员必须在存储变量之前选择专用于变量的位数：

• 在存储一个值之前，程序必须为其分配存储空间。在 C 中，声明变量会根据其类型告知编译器需要多少内存。
• 硬件存储设备的容量是有限的。虽然系统的主内存通常很大并且不太可能成为限制因素，但 CPU 内用作临时“暂存空间”的存储位置（即寄存器）受到更多限制。 CPU 使用的寄存器受到字大小的限制（通常为 32 或 64 位，具体取决于 CPU 架构）。
• 程序经常将数据从一个存储设备移动到另一存储设备（例如，在 CPU 寄存器和主存储器之间）。随着值变大，存储设备需要更多的电线来在它们之间传递信号。因此，扩展存储会增加硬件的复杂性，并为其他组件留下更少的物理空间。

用于存储整数的位数决定了其可表示值的范围。 图 2 描绘了我们如何概念化无限和有限无符号整数存储空间。

图 2. (a) 无限无符号数轴和 (b) 有限无符号数轴的图示。后者在任一端点“环绕”（溢出）。

尝试向变量存储比变量大小允许的更大的值称为整数溢出。本章将溢出的详细信息推迟到后面的部分。现在，可以把它想象成汽车的里程表，如果它试图增加超过其最大值，它就会“翻转”回零。同样，从零减一得到最大值。

此时，关于无符号二进制，一个自然要问的问题是“N 位可以存储的最大正值是多少？”换句话说，给定一个全 1 的 N 位序列，该序列代表什么值？非正式地推理这个问题，上一节中的分析表明，N 位产生 2^N 个唯一的位序列。由于这些序列之一必须表示数字 0，因此会留下 2^N - 1 个介于 1 到 2^N - 1 之间的正值。因此，N 位无符号二进制数的最大值必须是 2^N - 1。

例如，8 位提供 28 = 256 个唯一序列。这些序列之一 0b00000000 被保留为 0，剩下 255 个序列用于存储正值。因此，8 位变量表示 1 到 255 之间的正值，其中最大的是 255。

您可能会在不同的环境中遇到本章中介绍的三种进制数基。在某些情况下，您可能需要从一种基础转换为另一种基础。本节首先展示如何在二进制和十六进制之间进行转换，因为这两者很容易相互映射。之后，我们将探讨十进制之间的转换。

4.2.1. 二进制和十六进制之间的转换

由于二进制和十六进制的基数都是 2 的幂，因此两者之间的转换相对简单。具体来说，每个十六进制数字保存 16 个唯一值之一，四位也代表 24 = 16 个唯一值，使得它们的表达能力相当。 表 1 枚举了任何四位序列与任何单个十六进制数字之间的一对一映射。

表 1. 所有四位序列与一位十六进制数之间的对应关系

请注意，表 1 的内容相当于简单地在两种数字系统中从 0 数到 15，因此无需记住它。有了这个映射，您可以在任一方向上转换任意数量的连续位或十六进制数字：

• 将 0xB491 转换为二进制，只需将每个十六进制数字替换为相应的二进制值即可：

  B    4    9    1
1011 0100 1001 0001  ->  0b1011010010010001

• 将 0b1111011001 转换为十六进制，首先将这些位从右到左分成四个块。如果最左边的块没有四位，则可以用前导零填充。然后，替换相应的十六进制值：

1111011001  ->  11 1101 1001  ->  0011 1101 1001
								  ^ padding

0011 1101 1001
  3    D    9  ->  0x3D9

4.2.2. 转换为十进制

幸运的是，将值转换为十进制是我们在本章前面的部分中一直在做的事情。给定一个以任意基数B的数字，将从右到左的系数标记为d0、d1、d2等，可以使用将值转换为十进制的通用公式：

(d_N-1 × B^N-1)    +    (d_N-2 × B^N-2)    +    …​    +    (d₂ × B²)    +    (d₁ × B¹)    +    (d₀ × B⁰)

4.2.3. 从十进制转换

从十进制转换为其他系统需要更多的工作。非正式地，目标是执行与上一个公式相反的操作：确定每个数字的值，以便根据数字的位置，将每一项相加得到源十进制数。以与我们描述小数位（“个”位、“十”位等）相同的方式来思考目标基本系统中的每个数字可能会有所帮助。例如，考虑从十进制转换为十六进制。十六进制数的每一位都对应于 16 的越来越大的幂，表 2 列出了前几个幂。

表 2. 16 的幂。

例如，要将 9742 转换为十六进制，请考虑：

• 9742 可以容纳 65536 的多少倍数(换句话说，9742被65536整除商是多少)？ （也就是说，“65536”这个地方的值是多少？）

  生成的十六进制值不需要任何 65536 的倍数，因为值 (9742) 小于 65536，因此 d4 应设置为 0。请注意，通过相同的逻辑，所有更高编号的数字也将为 0，因为每个数字将贡献比 65536 更大的值。到目前为止，结果仅包含：

• _9742 能容纳多少 4096 的倍数？ （也就是说，“4096”这个地方的价值是多少？）

  4096 整除 9742 两次 (2 × 4096 = 8192)，因此 d3 的值应为 2。因此，d3 将为整体值贡献 8192，因此结果仍必须占 9742 - 8192 = 1550。

• 1550 能容纳多少 256 的倍数？ （也就是说，“256”位的值是多少？）

  256 整除 1550 六次 (6 × 256 = 1536)，因此 d2 的值应为 6，剩下 1550 - 1536 = 14。

• 14 能容纳多少 16 的倍数？ （也就是说，“十六”位的值是多少？）

  14不能被16整除，因此 d1 必须为 0。

• 最后，14 能容纳多少个 1 的倍数？ （换句话说，“个”位的值是多少？）

  答案当然是 14，十六进制用数字E表示。

因此，十进制 9742 对应于 0x260E。

十进制转二进制：二的幂

相同的过程也适用于二进制（或任何其他数字系统），前提是您使用适当基数的幂。 表 3 列出了 2 的前几个幂，这将有助于将示例十进制值 422 转换为二进制。

表 3. 2 的幂

因为单个位只允许存储 0 或 1，所以转换为二进制时，问题不再是 “不同层级指数的基数能整除的商(系数)？”。相反，问一个更简单的问题：“2 的下一次幂(指数)能整除吗？” 例如，在转换 422 时：

• 256 整除 422，因此 d8 应为 1。剩下 422 - 256 = 166。
• 128 整除 166，所以 d7 应该是 1。剩下 166 - 128 = 38。
• 64 无法整除 38，因此 d6 应为 0。
• 32 整除 38，所以 d5 应该是 1。剩下 38 - 32 = 6。
• 16 无法整除 6，因此 d4 应为 0。
• 8 无法整除 6，因此 d3 应为 0。
• 4 整除 6，所以 d2 应该是 1。剩下 6 - 4 = 2。
• 2 适合 2，因此 d1 应为 1。这样就剩下 2 - 2 = 0。（注意：达到 0 后，所有剩余数字将始终为 0。）
• 1 无法整除 0，因此 d0 应为 0。

因此，十进制 422 对应于 0b110100110。

十进制转二进制：重复除法(辗转相除法)

我们刚刚描述的方法通常对于熟悉 2 的相关幂的学生来说效果很好（例如，对于 422，转换器必须认识到它应该从 d8 开始，因为
= 512 太大）。

另一种方法不需要知道二的幂。相反，此方法通过检查十进制数的奇偶校验（偶数或奇数）状态并重复将其除以二（向下四舍五入）以确定每个连续位来构建二进制结果。请注意，它从_右到左_构建结果位序列。如果十进制值为偶数，则下一位应为零；如果是奇数，下一位应该是 1。当除法达到零时，转换完成。

例如，转换 422 时：

• 422 是偶数，因此 d0 应为 0。（这是最右边的位。）
• 422 / 2 = 211，这是奇数，因此 d1 应为 1。
• 211 / 2 = 105，这是奇数，因此 d2 应为 1。
• 105 / 2 = 52，是偶数，因此 d3 应为 0。
• 52 / 2 = 26，是偶数，因此 d4 应为 0。
• 26 / 2 = 13，这是奇数，因此 d5 应为 1。
• 13 / 2 = 6，是偶数，因此 d6 应为 0。
• 6 / 2 = 3，这是奇数，因此 d7 应为 1。
• 3 / 2 = 1，这是奇数，因此 d8 应为 1。
• 1 / 2 = 0，因此任何编号为 9 或以上的数字都将为 0，并且算法终止。

正如预期的那样，此方法生成相同的二进制序列：0b110100110。

到目前为止，我们将二进制数的讨论限制为 无符号（严格非负）整数。本节介绍了包含负数的二进制的另一种解释。鉴于变量的存储空间有限，有符号二进制编码必须区分负值、零和正值。操作带符号的数字还需要一个对数字取反的过程。

有符号二进制编码必须将位序列划分为负值和非负值。在实践中，系统设计师构建 通用 系统，因此 50% / 50% 的分割是一个不错的中间选择。因此，本章介绍的有符号数编码表示相同数量的负值和非负值。

有符号数编码使用一位来区分 负 数集和 非负 数集。按照惯例，最左边的位指示数字是负数 (1) 还是非负数 (0)。最左边的位称为高位或最高有效位。

本章介绍了两种可能的有符号二进制编码 — 有符号量值 和 二进制补码。尽管在实践中仅使用其中一种编码（二进制补码），但对它们进行比较将有助于说明它们的重要特征。

4.3.1. 有符号量值

有符号量值（signed magnitude）表示将高阶位专门视为符号位。也就是说，高位是 0 还是 1 并不影响数字的绝对值，它只决定该值是正（高位 0）还是负（高位 1）。与二进制补码相比，带符号的大小使得十进制转换和求反过程相对简单：

• 要计算 N 位有符号量值序列的十进制值，请使用熟悉的无符号方法 计算数字 d0 到 d_N-2 的值。然后，检查最高有效位d_N-1：如果为1，则值为负数；否则就不是负数。
• 要对某个值求反，只需翻转最高有效位即可更改其符号。

图 1 显示四位有符号量值序列如何与十进制值相对应。乍一看，有符号量值可能因其简单性而显得很有吸引力。不幸的是，它有两个主要缺点，使其没有吸引力。第一个是它呈现了 两个 零的表示形式。例如，对于四位，带符号的量值表示 零 (0b0000) 和 负零 (0b1000)。因此，它给硬件设计者带来了挑战，因为硬件需要考虑两个可能的二进制序列，尽管它们具有不同的位值，但它们在数值上相等。只需用一种方式来表示如此重要的数字，硬件设计师的工作就会容易得多。

图 1. 长度为 4 的位序列的带符号量值的逻辑布局。

有符号量值的另一个缺点是它在负值和零之间表现出不方便的不连续性。虽然我们稍后会更详细地介绍溢出，但向四位序列 0b1111 添加 1 会“翻转”回 0b0000。对于带符号的量值，此效应意味着 0b1111 (-7) + 1 可能会被误认为 0 而不是预期的 -6。这个问题是可以解决的，但该解决方案再次使硬件设计变得复杂，本质上将负整数和非负整数之间的任何转换变成需要额外小心的特殊情况。

由于这些原因，符号大小在实践中基本上消失了，而补码占据了主导地位。

4.3.2. 补码(Two’s Complement)

二进制补码编码以一种优雅的方式解决了有符号幅度的问题。与带符号的大小一样，二进制补码数的高位指示该值是否应解释为负数。但相比之下，高位也会影响数字的值。那么，如何才能做到这两点呢？

计算 N 位二进制补码的十进制值类似于熟悉的无符号方法，只不过高位对整体值的贡献被否定。也就是说，对于 N 位二进制补码序列，不是第一位为总和贡献d_N-1 × 2^N-1，而是贡献 -d_N-1 × 2^N-1 （注意负号）。因此，如果最高有效位是 1，则总值将为负，因为第一位对总和贡献的绝对值最大。否则，第一位对总和没有任何贡献，并且结果为非负数。完整的公式是：

- (d_N-1 × 2^N-1)    +    (d_N-2 × 2^N-2)    +    …​    +    (d₂ × 2²)    +    (d₁ × 2¹)    +    (d₀ × 2⁰) ^ 请注意第一个项的前导负号！

图 2 展示了二进制补码形式的四位序列的布局。该定义仅编码零的一种表示形式——全为 0 的位序列。仅使用单个 zero 序列，二进制补码表示的负值比正值多一个。以四位序列为例，二进制补码表示最小值为 0b1000（-8），但最大值仅为 0b0111（7）。幸运的是，这种怪癖不会妨碍硬件设计，也很少会给应用程序带来问题。

图 2. 长度为 4 的位序列的二进制补码值的逻辑布局。

与有符号的大小相比，二进制补码还简化了负数和零之间的转换。无论用于存储它的位数有多少，由全 1 组成的二进制补码数将始终保持值 -1。将 1 添加到全 1 的位序列“翻转”为零，这使得补码变得很方便，因为 -1 + 1 应该 产生零。

负值与取反

对二进制补码取反比对带符号的数值取反要稍微棘手一些。要否定 N 位值，请确定其相对于 2^{N 的补码（这就是编码名称的来源）。换句话说，要对 N 位值 X 求反，请找到一个位序列 Y（X 的补码），使得 X + Y = 2N。}

Fortunately, there’s a quick shortcut for negating a two’s complement number in practice: flip all the bits and add one. For example, to negate the eight-bit value 13, first determine the binary value of 13. Because 13 is the sum of 8, 4, and 1, set the bits in positions 3, 2, and 0: 幸运的是，在实践中，有一个快速的捷径可以对二进制补码求反：翻转所有位并加一。例如，要对八位值 13 求反，首先确定 13 的二进制值。因为 13 是 8、4 和 1 的和，所以将位设置在位置 3、2 和 0：

00001101  (decimal 13)

接下来，“翻转位”（将所有零更改为一，反之亦然）：

11110010

最后，加 1 得到 0b11110011。果然，应用解释二进制补码位序列的公式显示该值为 -13：

-(1 × 2⁷)    +    (1 × 2⁶)    +    (1 × 2⁵)    +    (1 × 2⁴)    +    (0 × 2³)    +    (0 × 2²)    +    (1 × 2¹)    +    (1 × 2⁰)

  =    -128 + 64 + 32 + 16 + 0 + 0 + 2 + 1    =    -13

如果您好奇为什么这个看似神奇的捷径有效，请更正式地考虑 13 的八位求反。要找到 13 的补码，请求解 0b00001101 (13) + Y = 0b100000000（2⁸，需要额外的位来表示）。该方程可以重新排列为 Y = 0b100000000 - 0b00001101。这显然是一个减法问题：

 100000000  (256)
- 00001101   (13)

虽然这样的减法可能看起来令人畏惧，但我们可以用一种更容易计算的方式将其表示为 (0b011111111 + 1) - 0b00001101。请注意，此更改只是将 28 (256) 表示为 (255 + 1)。更改后，算术如下所示：

 011111111  (255)  + 00000001  (1)
- 00001101   (13)

事实证明，对于任何位值 b，1 - b 相当于“翻转”该位。因此，前面示例中的整个减法可以简化为仅翻转较低数字的所有位。剩下的就是将 256 表示为 255 + 1 时剩下的 +1 相加。将它们放在一起，我们可以简单地翻转一个值的位并加 1 来计算其补码！

int example = -100;

/* Print example int using both signed and unsigned placeholders. */ >printf("%d %u\n", example, example);

return 0; }

 
 即使此代码将同一变量（`example`）传递给`printf`两次，它也会打印`-100 4294967196`。小心正确地解释变量的值！

符号位扩展

有时，您可能会发现自己想要对使用不同位数存储的两个数字执行算术运算。例如，在 C 中，您可能想要添加一个 32 位int和一个 16 位short。在这种情况下，较小的数字需要符号扩展，这是一种奇特的说法，它的最高有效位根据需要重复多次，以将位序列的长度扩展到目标长度。尽管编译器会在 C 语言中为您处理这些位，但了解该过程的工作原理仍然很有帮助。

例如，要将四位序列 0b0110 (6) 扩展为八位序列，请采用高位 (0) 并将其添加到前面四次以生成扩展值：0b00000110（仍然是 6）。将 0b1011 (-5) 扩展为八位序列类似地采用高位（这次是 1）并将其四次添加到结果扩展值：0b11111011（仍然是 -5）。要验证正确性，请考虑添加每个新位后值如何变化：

    0b1011 =                       -8 + 0 + 2 + 1  =  -5
   0b11011 =                  -16 + 8 + 0 + 2 + 1  =  -5
  0b111011 =             -32 + 16 + 8 + 0 + 2 + 1  =  -5
 0b1111011 =        -64 + 32 + 16 + 8 + 0 + 2 + 1  =  -5
0b11111011 =  -128 + 64 + 32 + 16 + 8 + 0 + 2 + 1  =  -5

正如示例所证明的，非负数（高位零）在前面添加零后仍保持非负数。同样，负数（1 的高位）在将其添加到扩展值之后仍然为负数。

提供了无符号和有符号整数的二进制表示形式后，我们就可以在算术运算中使用它们了。幸运的是，由于它们的编码，无论我们选择将操作数或结果解释为有符号还是无符号，对于算术过程来说 并不重要。这一观察结果对于硬件设计人员来说是个好消息，因为它允许他们构建一组可以共享无符号和有符号操作的硬件组件。 [硬件章节](https://diveintosystems.org/book/C5-Arch/ Circuits.html#_ Circuits) 更详细地描述了执行算术的电路。

幸运的是，您在小学中学到的用于对十进制数进行算术运算的纸笔算法也适用于二进制数。尽管硬件可能不会以完全相同的方式计算它们，但您至少应该能够理解计算的意义。

4.4.1. 加法

回想一下，在二进制数中，每个数字只包含 0 或 1。因此，当将两个都是 1 的位相加时，结果会执行到下一位数字（例如，1 + 1 = 0b10，这需要两个位来表示）。在实践中，程序会添加多位变量，其中一位数字的结果 进位输出(carry out) 会通过 进位输入(carrying in) 影响下一位数字。

一般来说，当对两个二进制数（A 和 B）进行数字求和时，根据前一位数字的 DigitA、DigitB 和 Carryin 的值，有 八种 可能的结果。 表 1 列举了添加一对位可能产生的八种可能性。 Carryin 列是指从前一个数字向和中输入进位，Carryout 列表示将这对数字相加是否会将进位输入到下一个数字中。

表 1. 添加两个二进制数字（A 和 B）以及可能从前一个数字进位(Carry In)的八种可能结果

考虑两个四位二进制数的相加。首先将数字排列起来，使其对应的数字垂直匹配，然后按从低位数字 (d0) 到高位数字 (d3) 的顺序将每个对应数字相加。例如，添加 0b0010 + 0b1011：

该示例显示 1 从 d1 传送到 d2。这种情况类似于将两个十进制数字相加，其总和大于 9。例如，当 5 + 8 = 13 相加时，结果个位包含 3，并且 1 进位到十位。

第一个操作数 (0b0010) 有一个前导 0，因此对于二进制补码和无符号解释来说，它都代表 2。如果将第二个操作数 (0b1011) 解释为带符号的二进制补码值，则表示 -5。否则，如果解释为无符号值，则表示 11。幸运的是，操作数的解释不会影响计算结果的步骤。也就是说，计算结果 (0b1101) 表示 13（无符号：2 + 11）或 -3（有符号：2 + -5），这两者都是正确的，具体取决于第二个操作数的解释。

更一般地，当解释为 无符号 时，四位序列表示范围 [0, 15] 内的值。当解释为 signed 时，它表示范围 [-8, 7]。在前面的示例中，无论哪种方式，结果都符合可表示的范围，但我们可能并不总是那么幸运。例如，当添加0b1100（无符号12）+ 0b0111（7）时，答案应该是19，但四位不能代表19：

请注意，此示例中的加法从最高有效位开始携带 1，这种条件称为整个算术运算的 执行。在此示例中，进位表明算术输出需要额外的位来存储预期结果。然而，当执行四位算术时，没有地方可以放置进位的额外位，因此硬件只是丢弃或截断它，留下 0b0011 作为结果。当然，如果目标是加上12+7，那么3的结果可能会令人惊讶。令人惊讶的是 溢出(overflow) 的结果。我们将在后面的部分中探讨如何检测溢出以及它为何会产生这样的结果。

[!NOTE] 多位加法器电路还支持进位输入(carry in)，其行为类似于最右边数字的进位（即，它充当 d0 的_进位_ 输入）。进位在执行加法时没有用——它被隐式设置为 0，这就是为什么它没有出现在前面的示例中。然而，进位确实与使用加法器电路的其他操作相关，最值得注意的是4.4.2. 减法。

4.4.2. 减法

减法结合了两种熟悉的运算：求反和加法。换句话说，减去 7 - 3 相当于将运算表示为 7 + (-3)。这种减法的描述与硬件的行为方式非常吻合——CPU 已经包含用于求反和加法的电路，因此重用这些电路而不是构建一个全新的减法器是有意义的。回想一下，对二进制数求反的一个简单过程是取反并加一。

考虑示例 0b0111 (7) - 0b0011 (3)，它首先将 3 发送到位翻转电路。为了获得“加一”，它利用了加法器电路的进位。也就是说，减法不是将一个数字传送到另一个数字，而是将 进位 传送给加法器的 d0。将进位设置为 1 会将所得的“个位”值增加 1，这正是获得求反的“加一”部分所需的值。将所有内容放在一起，该示例将如下所示：

虽然加法的完整结果会带入一个额外的数字，但截断的结果 (0b0100) 表示预期结果 (4)。与前面的加法示例不同，从高位进位不一定表示减法存在溢出问题。

在减去负值时，先执行减法，然后执行加法也有效。例如，7 - (-3) 产生 10：

我们进一步探讨在4.5 数字溢出中执行（或不执行）的含义。

4.4.3. 乘法和除法

本节简要介绍二进制与整数的乘法和除法。特别是，它展示了手动计算结果的方法，并且不反映现代硬件的行为。该描述并不全面，因为本章的其余部分主要关注加法和减法。

乘法

要进行二进制数相乘，请使用常见的纸笔策略，一次考虑一位数字并将结果相加。例如，将 0b0101 (5) 与 0b0011 (3) 相乘相当于求和：

• d0 乘以 0b101 (5) 的结果：0b0101 (5)
• 将 d1 乘以 0b101 (5) 并将结果向左移动一位数的结果：0b1010 (10)。

  0101       0101       0101
x 0011  =  x    1  +  x   10  =  101 + 1010  =  1111 (15)

(整数) 除法

与刚刚描述的其他运算不同，除法有可能产生非整数结果。对整数进行除法时要记住的主要一点是，在大多数语言（例如 C、Python 2 和 Java）中，结果的小数部分会被截断。除此之外，二进制除法使用大多数学生在小学学习的相同长形式方法。例如，计算 11 / 3 会产生整数结果 3：

    ____
11 |1011

    00__   11 (3) doesn't fit into 1 (1) or 10 (2),
11 |1011   so the first two digits of the result are 00.

    001_   11 (3) fits into 101 (5) once.
11 |1011

    101    101 (5) - 11 (3) leaves 10 (2).
  -  11
     10

    0011
11 |1011   11 (3) fits into 101 (5) once again.
     101

此时，算术已产生预期的整数结果 0011 (3)，并且硬件会截断所有小数部分。如果您有兴趣确定积分余数，请使用模运算符 (%)；例如，11%3=2。

尽管整数的数量在数学上是无限的，但实际上，计算机内存中的数字类型占用固定数量的位数。正如我们在本章中所暗示的那样，使用固定位数意味着程序可能无法表示它们想要存储的值。例如，对加法的讨论表明，将两个合法值相加可以产生无法表示的结果。缺乏存储空间来表示其结果的计算已溢出。

4.5.1. 里程表仪表盘(Odometer Analogy)

为了描述溢出的特征，考虑一个非计算领域的例子：汽车的里程表。里程表计算汽车行驶的里程数，无论是数字式还是模拟式，它只能显示这么多（以 10 为基数）数字。如果汽车行驶的里程数超过了里程表所能表示的里程数，里程表就会“翻转”回零，因为无法表达真实值。例如，对于标准的六位里程表，它表示的最大值是 999999。再行驶一英里应该显示 1000000，但是像溢出加法示例 一样，1 从六位可用数字中执行，只留下000000。

为简单起见，让我们继续分析仅限一位小数的里程表。也就是说，里程表代表范围 [0, 9]，因此每行驶 10 英里后里程表就会重置为零。直观地说明里程表的范围，它可能看起来像图 1。 图 1. 一位数里程表潜在值的直观描述

由于一位数的里程表在达到 10 时会翻转，因此绘制圆形会强调圆顶部（并且仅在顶部）的不连续性。具体来说，通过将 1 与除 9 之外的任何值相加，结果将达到预期值。另一方面，添加一到九会跳转到一个不自然跟随它的值（零）。更一般地说，当执行任何跨越九和零之间不连续性的算术时，计算将会溢出。例如，考虑添加 8 + 4，如 图 2 所示。

图 2. 8 + 4 相加的结果，仅保留一位小数。跨越 0 和 9 之间的不连续性表示发生了溢出。

在这里，总和得到 2，而不是预期的 12。请注意，与 8 相加的许多其他值（例如，8 + 14）也将得到 2，唯一的区别是计算将需要绕圈进行额外的行程。因此，无论汽车行驶2英里、12英里还是152英里，最终里程表的读数都是2。

任何行为类似于里程表的设备都执行模运算。在这种情况下，所有算术都是以模 10 为模数的，因为一位十进制数字仅代表 10 个值。因此，给定任意行驶里程数，我们可以通过将距离除以 10 并将余数作为结果来计算里程表的读数。如果里程表有两位小数而不是一位，则模数将更改为 100，因为它可以表示更大的值范围：[0, 99]。同样，时钟以小时模数 12 执行模算术。

4.5.2. 二进制整数溢出

看过熟悉的溢出形式后，让我们转向二进制数字编码。回想一下，N 位存储代表 2N 个唯一的位序列，并且这些序列可以用不同的方式解释（如 无符号 或 有符号）。在一种解释下产生正确结果的某些操作可能会根据另一种解释而出现溢出，因此硬件需要针对每种解释以不同的方式识别溢出。

例如，假设机器使用四位序列来计算 0b0010 (2) - 0b0101 (5)。通过减法过程 运行此运算会生成二进制结果 0b1101。将此结果解释为有符号值会产生 -3 (-8 + 4 + 1)，即 2 - 5 的预期结果（无溢出）。或者，将其解释为 无符号 值会产生 13 (8 + 4 + 1)，这是不正确的并且清楚地表明溢出。进一步审视这个例子，它本能地有一定道理——结果应该是负数，有符号的解释允许负数，而无符号的则不允许。

无符号溢出

无符号 数字的行为与十进制里程计示例类似，因为两者都只表示非负值。 N 位表示 [0, 2^N- 1] 范围内的无符号值，使所有算术都以 2^N 为模数。 图 3 展示了四位序列的无符号解释在模块化空间中的排列。

图 3. 四位无符号值在模空间中的排列。所有算术都是关于 2⁴ (16) 的模数。

鉴于无符号解释不能容纳负值，不连续性再次位于最大值和零之间。因此，任何跨越 2^N-1和 0 之间除法的操作都会导致无符号溢出。更简单地说，如果执行加法（这应该使结果 更大）产生较小的结果，则加法会导致无符号溢出。对称地，如果执行减法（这应该使结果 更小）产生更大的结果，则减法会导致无符号溢出。

作为检测加法和减法无符号溢出的快捷方式，请回忆一下这些运算的 carry out 和 carry in位。 carry out 是计算结果中最高有效位的进位。设置后，carry in 通过将 1 进位到算术运算的最低有效位来增加结果的值。作为求反过程的一部分，carry in 仅设置为 1 以进行减法。

无符号算术的快捷方式是：carry out必须与carry in匹配，否则运算会导致溢出。直观上，这个快捷方式之所以有效，是因为：

• 对于加法 (carry in = 0)，结果应大于（或等于）第一个操作数。但是，如果总和需要额外的存储位(carry out = 1)，则从总和中截断该额外位会产生较小的结果（溢出）。例如，在无符号四位数字空间中，添加 0b1100 (12) + 0b1101 (13) 需要 五个 bit位来存储结果 0b 11001 (25)。当截断为只有四位时，结果表示 0b1001 (9)，它小于操作数（因此，溢出）。
• 对于减法（carry in = 1），结果应小于（或等于）第一个操作数。由于减法是作为加法和求反的组合执行的，因此减法问题应该产生较小的结果。加法最终得到较小值的唯一方法是截断其总和（carry out = 1）。如果不需要截断（carry out = 0），减法会产生更大的结果（溢出）。

让我们看一下四位减法的两个例子：一个溢出，一个不溢出。首先，考虑 0b0111 (7) - 0b1001 (9)。减法过程将此计算视为：

计算 没有 从 d3 中进位(carry out)，因此不会发生截断，并且 (1) 中的进位(carry in)无法匹配进位 (0)。结果 0b1110 (14) 比任一操作数都大，因此对于 7 - 9 显然是不正确的（溢出）。

接下来，考虑 0b0111 (7) - 0b0101 (5)。减法过程将此计算视为：

计算对 d4 执行一位，导致 (1) 中的进位与 (1) 中的进位匹配。截断结果 0b0010 (2) 正确表示减法运算的预期结果（无溢出）。

有符号溢出

溢出背后的相同直觉也适用于有符号二进制解释：模数空间中存在不连续性。然而，由于有符号解释允许负数，因此在 0 附近不会出现不连续性。回想一下，二进制补码 干净利落地从 -1 (0b1111…​111)“翻转”到 0 (0b0000…​000)。因此，不连续性存在于数字空间的另一端，即最大正值和最小负值相遇的地方。

图 4 显示了四位序列的带符号解释在模块化空间中的排列。请注意，一半值是负值，另一半是非负值，并且不连续性位于它们之间的最小/最大分界处。

图 4. 四位有符号值在模空间中的排列。由于带符号的解释允许负值，因此不连续性不再位于零。

执行有符号算术时，生成接近零的结果始终是安全的。也就是说，任何减少结果绝对值的操作都不会溢出，因为溢出不连续性存在于可表示值的幅度最大的地方。

因此，系统通过将操作数的最高有效位与结果的最高有效位进行比较来检测带符号加法和减法中的溢出。对于减法，首先根据加法重新排列算术（例如，将 5 - 2 重写为 5 + -2）。

• 如果加法的操作数具有 不同 高位值（即，一个操作数为负，另一个为正），则不会有符号溢出，因为结果的绝对值必须小于（或等于）任一操作数。结果是朝 _零方向移动。
• 如果加法的操作数具有相同的高位值（即均为正或均为负），则正确的结果也必须具有相同的高位位值。因此，当将两个具有相同符号的操作数相加时，如果结果的符号与操作数的符号不同，则会发生有符号溢出。

考虑以下四位有符号二进运算示例：

• 5 - 4 相当于 5 + -4。第一个操作数 (5) 为正，而第二个操作数 (-4) 为负，因此结果必须向零移动，其中 不会溢出。
• 4 + 2（均为正数）产生 6（也是正数），因此 不会发生溢出。
• -5 - 1 相当于 -5 + -1（均为负数）并产生 -6（也是负数），因此 不会发生溢出。
• 4 + 5（均为正数）产生 -7（负数）。由于操作数具有相同的符号，但与结果的符号不匹配，因此此操作 溢出。
• -3 - 8 相当于 -3 + -8（均为负数）并产生 5（正数）。由于操作数具有相同的符号，但与结果的符号不匹配，因此此操作 溢出。

4.5.3. 溢出总结

一般来说，当算术运算在其结果可以表示的最小值和最大值之间移动时，就会发生整数溢出。如果您对有符号溢出和无符号溢出的规则有疑问，请考虑 N 位序列的最小值和最大值：

• 最小 unsigned 值为 0（因为无符号编码不能表示负数），最大无符号值为 2^N-1（因为一位序列保留为零）。因此，不连续性在 2^N-1 和 0 之间。
• 最小 signed 值为 -2^N-1（因为一半序列保留为负值），最大值为2^N-1-1（因为在另一半中，一个值保留为零）。因此，不连续性介于 2^N-1-1 和 -2^N-1 之间。

4.5.4. 溢出后果

虽然您可能不会经常遇到整数溢出，但溢出有可能以显着（并且可能具有破坏性）的方式破坏程序。

例如，2014 年，PSY 流行的江南 Style 音乐视频可能会溢出 YouTube 用于跟踪视频点击率的 32 位计数器。因此，YouTube 转而使用 64 位计数器。

另一个相对无害的例子出现在 1980 年的街机游戏 吃豆人 中。游戏开发者使用无符号的八位值来跟踪玩家在游戏关卡中的进度。因此，如果专家玩家的级别超过 255 级（八位无符号整数的最大值），那么一半的棋盘最终会出现严重故障，如图5所示。

图 5. Pac-Man 游戏板在达到 256 级时“吓坏了”

一个更悲惨的溢出例子出现在 20 世纪 80 年代中期的 Therac-25 放射治疗机的历史中。 Therac-25 存在多个设计问题，其中一个问题是增加真值标志变量而不是将其设置为常量。经过足够的使用后，标志溢出，导致其错误地翻转到零（假）并绕过安全机制。 Therac-25 最终对 6 名患者造成严重伤害（在某些情况下甚至导致死亡）。

除了前面描述的标准算术运算之外，CPU 还支持二进制之外不常见的运算。这些按位运算符直接将 5.3 逻辑门 的行为应用于比特位序列，使它们能够在硬件中直接有效地实现。与程序员通常使用加法和减法来操作变量的数值解释不同，程序员通常使用按位运算符来修改变量中的特定位。例如，程序可能会对变量中的某个位位置进行编码以保存真/假含义，并且按位运算允许程序操纵变量的各个位来更改该特定位。

4.6.1. 按位与(Bitwise AND)

按位与运算符 (&) 计算两个输入位序列。对于输入的每个数字，如果两个输入在该位置均为 1，则它会在输出的相应位置输出 1。否则，它会输出该数字 0。 表 1 显示了两个值 A 和 B 的按位 AND 的真值表。

表 1. 按位与两个值的结果 (A AND B)

例如，要按位与 0b011010 与 0b110110，首先将两个序列对齐。垂直检查每个数字，如果两个数字均为 1，则将该列的结果设置为 1。否则，将该列的结果设置为 0：

        011010
    AND 110110  Only digits 1 and 4 are 1's in BOTH inputs, so
Result: 010010  those are the only digits set to 1 in the output.

要在 C 中执行按位 AND，请将 C 的按位 AND 运算符 (&) 放在两个操作数变量之间。这是用 C 语言执行的相同示例：

int x = 26;
int y = 54;

printf("Result: %d\n", x & y);  // Prints 18

4.6.2. 按位或(Bitwise OR)

按位 OR 运算符 (|) 的行为类似于按位 AND 运算符，不同之处在于，如果相应位置的输入中的一个或两个都为 1，则它会为数字输出 1。否则，它会输出该数字 0。 表 2 显示两个值 A 和 B 按位或的真值表。

表 2. 按位或运算两个值的结果 (A OR B)

例如，要按位或 0b011010 与 0b110110，首先将两个序列对齐。垂直检查每个数字，如果任一数字为 1，则将该列的结果设置为 1：

        011010
     OR 110110     Only digit 0 contains a 0 in both inputs, so it's
Result: 111110     the only digit not set to 1 in the result.

要在 C 中执行按位或，请将 C 的按位或运算符 (|) 放在两个操作数之间。这是用 C 语言执行的相同示例：

int x = 26;
int y = 54;

printf("Result: %d\n", x | y);  // Prints 62

4.6.3. 按位异或(XOR, Exclusive OR)

按位 XOR 运算符 (^) 的行为类似于按位 OR 运算符，不同之处在于，仅当输入中的 恰好一个（但不是两个）在相应位置为 1 时，它才会为数字输出 1。否则，它会输出该数字 0。 表 3 显示了两个值 A 和 B 的按位异或的真值表。

表 3. 按位异或两个值的结果 (A XOR B)

例如，要按位异或 0b011010 与 0b110110，首先将两个序列对齐。垂直检查每个数字，如果 只有一个 数字为 1，则将该列的结果设置为 1：

        011010
    XOR 110110     Digits 2, 3, and 6 contain a 1 in exactly one of
Result: 101100     the two inputs.

要在 C 中执行按位异或，请将 C 的按位异或运算符 (^) 放在两个操作数之间。这是用 C 语言执行的相同示例：

int x = 26;
int y = 54;

printf("Result: %d\n", x ^ y);  // Prints 44

4.6.4. 按位非

按位非运算符 (~) 仅对一个操作数进行运算。对于序列中的每一位，它只是翻转该位，使 0 变为 1，反之亦然。 表 4 显示按位 NOT 运算符的真值表。

表 4. 按位对值进行求值 (A) 的结果

例如，要按位 NOT 0b011010，请反转每位的值：

    NOT 011010
Result: 100101

要在 C 中执行按位 NOT，请在操作数前面放置一个波形符 (~)。这是用 C 语言执行的相同示例：

int x = 26;

printf("Result: %d\n", ~x); // Prints -27

4.6.5. 移位

另一个重要的按位运算涉及将操作数位的位置左移（<<）或右移（>>）。左移和右移运算符都采用两个操作数：要移位的位序列和应移位的位数。

左移

将序列向左移动_N_位会将其每个位向左移动 N 次，从而将新的零附加到序列的右侧。例如，将八位序列 0b00101101 向左移位两位会产生 0b10110100。右侧的两个零被附加到序列的末尾，因为结果仍然需要是八位序列。

在没有溢出的情况下，向左移位 增加 结果的值，因为位向让对数字的值贡献更大的2的幂的方向移动。然而，对于固定数量的位数，任何移位到超出数字最大容量的位置的位都会被截断。例如，将八位序列 0b11110101（无符号解释 245）向左移位一位会生成 0b11101010（无符号解释 234）。这里，移出的高位被截断，使得结果变小。

要在 C 中执行左移位，请在值和要移动该值的位数之间放置两个小于字符 (<<)：

int x = 13;  // 13 is 0b00001101

printf("Result: %d\n", x << 3);  // Prints 104 (0b01101000)

右移

右移类似于左移——任何移出变量容量的位（例如，从末尾向右移）都会因截断而消失。然而，右移引入了一个额外的考虑因素：结果左侧前面的新位可能需要全为零或全一，具体取决于要移位的变量的类型及其高位位值。从概念上讲，选择在前面添加零或一类似于符号扩展。因此，右移存在两种不同的变体：

• 逻辑右移总是在结果的高位前添加零。逻辑移位用于移位 无符号 变量，因为无符号值的最高有效位中的前导 1 并不意味着该值为负数。例如，使用逻辑移位将 0b10110011 向右移动两位会产生 0b00101100。
• 算术右移会将移位值的最高有效位的副本添加到每个新位位置中。算术移位适用于有符号变量，因此保留高位的符号非常重要。例如，使用算术移位将 0b10110011 向右移动两位会得到 0b11101100。

幸运的是，在用 C 语言编程时，如果正确声明了变量，通常不需要担心这种区别。如果您的程序包含右移位运算符 (>>)，则几乎每个 C 编译器都会根据移位变量的类型自动执行适当类型的移位。也就是说，如果使用 unsigned 限定符声明移位变量，编译器将执行逻辑移位。否则，它将执行算术移位。

#include <stdio.h>

 int main(int argc, char **argv) {

</div>

 >     /* Unsigned integer value: u_val. */
 >     unsigned int u_val = 0xFF000000;
>
>      /* Signed integer value: s_val. */
>      int s_val = 0xFF000000;
>
 >   printf("%08X\n", u_val >> 12);  // logical right shift
 >   printf("%08X\n", s_val >> 12);  // arithmetic right shift
>
>   return 0;
>}
> ```
> 
> 该程序声明了两个 32 位整数：一个为无符号整数 (`u_val`)，另一个为有符号整数 (`s_val`)。它将两个整数初始化为相同的起始值：由 8 个 1 组成的序列，后跟 24 个 0 (`0b1111111100000000000000000000000000`)，然后将两个值向右移动 12 个位置。执行时，会打印：
> 
> ```bash
> $ ./a.out
> 000FF000
> FFFFF000
>```
>
> 由于前导 1 并不表示无符号`u_val`为“负”，因此编译器使用指令仅在其前面添加零。移位后的结果包含 12 个零、8 个 1 和另外 12 个零 (`0b00000000000011111111000000000000`)。另一方面，前导 1 **确实** 表示 `s_val` 为“负”，因此编译器会在移位值的前面添加 1，生成 20 个 1，后跟 12 个零 (`0b11111111111111111111000000000000`)。

#include <stdio.h>

int main(int argc, char **argv) {
    // Initialize a four-byte integer with easily distinguishable byte values
    int value = 0xAABBCCDD;

    // Initialize a character pointer to the address of the integer.
    char *p = (char *) &value;

    // For each byte in the integer, print its memory address and value.
    int i;
    for (i = 0; i < sizeof(value); i++) {
        printf("Address: %p, Value: %02hhX\n", p, *p);
        p += 1;
    }

    return 0;
}

$ ./a.out
Address: 0x7ffc0a234928, Value: DD
Address: 0x7ffc0a234929, Value: CC
Address: 0x7ffc0a23492a, Value: BB
Address: 0x7ffc0a23492b, Value: AA

    0100 1010
      4    A  ->  0x4A

        0001 1000 0101
          1    8    5  ->  0x185

NOT(A)    # is 1 when A is 0
NOT(B)    # is 1 when B is 0

NOT(A) AND NOT(B)    # is 1 when A and B are both 0

A AND B   # is 1 when A and B are both 1

(NOT(A) AND NOT(B)) OR (A AND B)  # is 1 when A and B are both 0 or both 1

SUM: (NOT(A) AND B) OR (A AND NOT(B))     # 1 when exactly one of A or B is 1
CARRY OUT:  A AND B                       # 1 when both A and B are 1

x = 6 + 8;

if( (x + 8) != 0 ) {
    x++;
}

MOV M[0x84], Reg1     # move value at memory address 0x84 to register Reg1
ADD 2, Reg1, Reg1     # add 2 to value in Reg1 and store result in Reg1
MOV 4, Reg2           # copy the value 4 to register Reg2
ADD Reg2, Reg2, Reg2  # compute Reg2 + Reg2, store result in Reg2
JMP L1<0x14>          # jump to executing code at L1 (code address 0x14)

MOV M[0x84], Reg1    # move value at memory address 0x84 to register Reg1
ADD 2, Reg1, Reg1    # add 2 to value in Reg1 and store result in Reg1

MOV 4, Reg2           # copy the value 4 to register Reg2
ADD Reg2, Reg2, Reg2  # compute Reg2 + Reg2, store result in Reg2

int result = *x; // x holds an int
int temp = *y;   // y holds another int

if (result <= temp) {
	result = result - temp;
}
else {
	result = result + temp;
}
return result;

  MOV M[0x84], Reg1     # move value at memory address 0x84 to register Reg1
  MOV M[0x88], Reg2     # move value at memory address 0x88 to register Reg2
  CMP Reg1, Reg2        # compare value in Reg1 to value in Reg2
  JLE L1<0x14>          # switch code execution to L1 if Reg1 less than Reg2
  ADD Reg1, Reg2, Reg1  # compute Reg1 + Reg2, store result in Reg1
  JMP L2<0x20>          # switch code execution to L2 (code address 0x20)
L1:
  SUB Reg1, Reg2, Reg1  # compute Reg1 - Reg2, store in Reg1
L2:
  RET                   # return from function

#include <stdio.h>

int adder() {
    int a;
    return a + 2;
}

int assign() {
    int y = 40;
    return y;
}

int main(void) {
    int x;
    assign();
    x = adder();
    printf("x is: %d\n", x);
    return 0;
}

$ gcc -o example example.c
$ ./example
x is: 42

$ uname -m
x86_64

#include <stdio.h>

//adds two to an integer and returns the result
int adder2(int a) {
    return a + 2;
}

int main(void){
    int x = 40;
    x = adder2(x);
    printf("x is: %d\n", x);
    return 0;
}

$ gcc -o adder adder.c

$ objdump -d adder > output
$ less output

0000000000400526 <adder2>:
  400526:       55                      push   %rbp
  400527:       48 89 e5                mov    %rsp,%rbp
  40052a:       89 7d fc                mov    %edi,-0x4(%rbp)
  40052d:       8b 45 fc                mov    -0x4(%rbp),%eax
  400530:       83 c0 02                add    $0x2,%eax
  400533:       5d                      pop    %rbp
  400534:       c3                      retq

mov    -0x4(%rbp),%eax
add    $0x2,%eax