这是本节的多页打印视图。 点击此处打印.

返回本页常规视图.

C 语言

extern 作用

extern 影响程序的链接过程，表示对变量或函数的声明，真正的定义在其他地方。

  • 函数默认是外部链接（extern）
  • 而变量而言，文件级别的定义为 extern，block 级别的为内部。

在 C 中声明全局变量的方式：

  • 在头文件中使用 extern 声明（ int i 这种形式称为 tentative definition ）
  • 在一个 C 文件中定义，
  • 其他文件直接引用头文件即可
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int i1 = 10;         /* definition, external linkage */
static int i2 = 20;  /* definition, internal linkage */
extern int i3 = 30;  /* definition, external linkage */
int i4;              /* tentative definition, external linkage */
static int i5;       /* tentative definition, internal linkage */

int i1;              /* valid tentative definition */
int i2;              /* not legal, linkage disagreement with previous */
int i3;              /* valid tentative definition */
int i4;              /* valid tentative definition */
int i5;              /* not legal, linkage disagreement with previous */

// 在 link 阶段，变量默认是 external 的，使用 static 可以变成 internal 的
// 任何文件级别的变量，都按照 static memory model 分配，不管有没有 extern/static 修饰
static int a = 1;

// 在 link 阶段，函数默认是外部链接，使用 static 可以变成内部链接
int add(int x, int y) {
  // block 级别的变量在 link 阶段默认是 internal 的，可以使用 extern 改成外部链接，但是很少这么做
  // 内存模型是 auto 的，使用 static 会改变内存模型为 static
  int a = 10;
  return x + y + a;
}

const

解读声明的诀窍是从右向左阅读。具体如下：

  • int const A constant integer
  • int const * A (variable) pointer to a constant integer
  • int * const A constant pointer to a (variable) integer
  • int * const * A pointer to a constant pointer to an integer
  • int const * * A pointer to a pointer to a constant integer
  • int const * const * A pointer to a constant pointer to a constant integer

可以看出， const 总是修饰它左边的内容，与 * 的规律是一致的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include<stdio.h>

extern int a;

// const 只能限定 b，foo 可以修改其指向的元素
void set_elmt(int *foo, int const *b) {
  foo[0] = 3;
  // error: read-only variable is not assignable
  /* b[1] = 4; */
}

int main() {
  printf("a = %d\n", a);

  int foo[10] = {};
  int const *b = foo;
  set_elmt(foo, b);
  printf("a = %d\n", *foo);
}

局限性

下面演示说明：对于 const 的 struct，其内部的成员是可以被修改的

 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

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

typedef struct {
  int *counter1, *counter2;
} counter_s;

void check_counter(int *ctr){ assert(*ctr !=0); }

double ratio(counter_s const *in){
  check_counter(in->counter2);
  return *in->counter1/(*in->counter2+0.0);
}

int main(){
  counter_s cc = {
    // Designated Initializers
    .counter1=malloc(sizeof(int)),
    .counter2=malloc(sizeof(int))
  };
  *cc.counter1 = *cc.counter2 = 1;
  printf("ratio = %f\n",ratio(&cc));

}

指针与数组的区别

数组名和指针之间存在一个重要区别:

  • 指针是一个变量，因此像 pa=a 和 pa++ 这样的操作是合法的。
  • 但数组名并不是一个变量，因此类似 a=pa 和 a++ 这样的用法是非法的。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int a[10];
int *pa = &a[0];
// 等价于
int *pa = a;
// valid
pa = a
pa ++

// invalid
a = pa
a++
1
2

char amessage[] = "now is the time"; /* an array */
char *pmessage = "now is the time"; /* a pointer */
  • 可以通过 amessage 修改字符串内容，但是不能修改 amessage 的指向
  • 可以修改 pmessage 的指向，但是不能修改字符串的内容
    字符指针与数组的区别

    字符指针与数组的区别

如何解读 C 声明

变量声明的语法模仿了变量可能出现在表达式中的语法结构，从而使两者显得更加一致和自然。

The syntax of the declaration for a variable mimics the syntax of expressions in which the variable might appear.

1

double *dp, atof(char *);

上面的声明可以解读为：

  • 在表达式 *dp 和 atof(s) 都会产生一个 double 类型的值。
  • atof 的参数是一个指向 char 的指针
1

int *A[100];

这意味着我们可以使用 *A[i] 表达式来获取一个整数值，所以 A ：

  1. 必须是一个数组（因为它可以用下标访问）
  2. 数组的元素必须是指针（因为它可以被解引用）

所有 A 的类型是：数组（100 个元素），元素类型是指向整数的指针。

1

int (*A)[100];

类似的，由于我们可以使用 (*A)[0] 表达式来获取一个整数值，所以 A：

  • 必须是一个指针（因为它可以被解引用）
  • 指针指向的内容必须是一个数组（因为它可以用下标访问）

所以 A 的类型是：指向一个包含 100 个整数的数组的指针。

参考：c - What is "Syntax of Expression" - Stack Overflow

1 -

一些必须安装的包：

  • Compiler. gcc or clang
  • GDB. debugger
  • Valgrind, 检查内存错误
  • gprof, 性能分析器
  • make, so you never have to call your compiler directly.
  • pkg-config, for finding libraries
  • doxygen, 生成文档
  • text editor. Emacs of course.

其他扩展（heavy-duty）的工具：

  • Autotools: autoconf, automake, libtool
  • Git
  • Alternate shells, such as ZShell

一次常用的 C 三方库：

  • libcURL
  • libGLib
  • libGSL
  • libSQLite3
  • libXML2

关于库包命名方案，并没有统一的标准，因此你需要摸清你的包管理器是如何将一个单一的库拆分成多个部分来处理的。 通常，会有一个面向普通用户的基础包，以及一个提供给开发者用于自身开发工作的附加包（通常是以 -dev 或 -devel 为后缀的开发包）。

要记得同时选中基础包和开发包。一些系统还会将文档拆分到另一个独立的包中。另外，有些系统要求你单独下载调试符号包，如果遇到这种情况，当你首次在缺少调试符号的情况下运行 GDB 时，它一般会引导你完成相关步骤。

2 - 列表插入

向有序列表插入一新元素。不是很友好的做法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

list l = (list) malloc(sizeof(struct list));
l -> val = val;
if(the_list == NULL || the_list -> val >= val)
  {
    /* insert the element first */
    l -> next = the_list;
    the_list = l;
  } else {
  list q = the_list;
  list p = q -> next;
  for(; p && p -> val < val; q = p, p = p -> next)
    ;
  l -> next = p;
  q -> next = l;
 }

更加 idiom 的做法：

1
2
3
4
5
6
7

list *p;
list l = (list) malloc(sizeof(struct list));
l -> val = val;
for(p = &the_list; *p && (*p) -> val < val; p = &((*p) -> next))
  ;
l -> next = *p;
*p = l;

3 - Makefile 指南

Make 是一个自动化构建工具，最初由 Stuart Feldman 在 1977 年开发。它通过读取名为 Makefile 的文件来确定如何编译和链接程序。Makefile 包含了一系列的规则，定义了目标文件、依赖关系和构建命令。

1
2
3
4
5
6

P=program_name
OBJECTS=
CFLAGS = -g -Wall -O3
LDLIBS=
CC=c99
$(P): $(OBJECTS)

基本概念

  • 目标（Target） ：Makefile 中要生成的文件，通常是可执行文件或对象文件。
  • 依赖（Dependency） ：目标文件生成所需的源文件或其他目标文件。
  • 命令（Command） ：生成目标文件所需执行的命令，通常是编译或链接命令。
  • 变量（Variable） ：用于存储常用的值，如编译器选项、文件列表等，便于维护和修改。
  • 模式规则（Pattern Rule） ：定义了一种通用的规则，可以应用于多个目标文件，使用通配符表示。
  • 伪目标（Phony Target） ：不对应实际文件的目标，通常用于执行特定任务，如清理临时文件。

  • 自动变量（Automatic Variable） ：在规则的命令中使用的特殊变量，如 $@ （目标文件名）、 $< （第一个依赖文件名）等。

    1
2
3
4

    # $@ = target name
# $* = target name without suffix
# $< = target dependence
$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $*.c

高级特性

  • 并行构建（Parallel Build） ：Make 支持并行执行多个任务，通过 `-j` 选项指定并行任务数，提高构建速度。
  • 调试（Debugging） ：Make 提供了一些选项，如 `–debug`，用于调试 Makefile 的执行过程，帮助定位问题。

  • 内置规则（Built-in Rules） ：Make 自带了一些默认的规则，可以自动处理常见的文件类型，如 .c 到 .o 的编译。当 GNU Make 判断你需要通过目标文件来生成可执行程序时，它会采用以下规则：

    1

    $(CC) $(LDFLAGS) first.o second.o $(LDLIBS)

    查看 make 默认规则可以使用下面的命令：

    1

    make -p > default_rules
  • 后缀规则（Suffix Rule） ：一种特殊的模式规则，基于文件后缀名定义转换规则，如 .c 到 .o
  • 命令行选项（Command Line Options） ：Make 提供了多种命令行选项，如 -f 指定 Makefile 文件， -n 仅显示将要执行的命令等。
  • 错误处理（Error Handling） ：Make 在执行命令时，如果遇到错误，默认会停止执行，可以通过 -k 选项继续执行其他任务。