C 语言-个人参考手册

这是我的 C 语言个人参考手册。

1 C 版本

#

各 C 版本对应的 __STDC_VERSION__ 值：

• C89/C90：没有定义 __STDC_VERSION__。
• C95：199409L。
• C99：199901L。
• C11：201112L。
• C17/C18：201710L。

编译时使用 -std 参数指定使用的 C 版本：c90 c89 c99 c11 c1x c17 c18 c2x，gnu89 gnu90 gnu11 gnu1x gnu17 gnu18 gnu2x：

# -pedantic：检测到使用 GNU C 扩展时打印警告；
# -Wall ：检查所有警告；
gcc -std=c11 -pedantic foo.c
gcc -Wall -Wextra -std=c2x -pedantic foo.c

默认情况下，未指定 -std 参数时，clang 使用 C99 标准，gcc 使用 gnu17 标准。

• Linux kernel 在 2022 年将 C 版本从 -std=gnu89 切换为 -std=gnu11，Programming Language。

源码中可以使用宏来判断 C 版本，进行条件编译：

#if __STDC_VERSION__ >= 1999901L
#include <stdio.h>
#endif

1.1 C99 新增特性

#

C99 相较于 C89 标准引入了许多新特性，以下是一个完整列表：

1. 新数据类型 ：
   • `long long int` 类型，至少 64 位。
   • `_Bool` 类型，用于布尔值。
   • `complex` 和 `imaginary` 类型，用于复数。
2. 变量声明 ：允许在任何地方声明变量，而不仅限于代码块的开头。
3. 复合字面量 ：可以在任意位置创建匿名的数组或结构体实例。
4. 可变长数组 ：允许数组的长度在运行时确定。
5. 变量声明时设定初始值 ：允许变量声明时直接初始化。
6. 单行注释 ：支持 `//` 单行注释。
7. 新标准库函数 ：
   • `<tgmath.h>` 中的泛型数学函数。
   • `<stdbool.h>` 中的布尔类型和常量。
   • `<complex.h>` 中的复数类型和函数。
   • `<stdint.h>` 中的固定宽度整数类型。
8. 内联函数 ：使用 `inline` 关键字定义内联函数。
9. 新预处理器指令 ：
   • `#include` 指令支持通过 `<…>` 和 `""` 引入头文件。
   • `_func_` 预定义标识符，表示当前函数的名称。
10. 改进的浮点支持 ：更好的浮点数支持、四舍五入控制和新的数学库函数。
11. 变长宏参数 ： 支持变长参数的宏定义。
12. 指定初始化 ： 允许在初始化数组和结构体时指定索引或成员。
13. 支持 `restrict` 关键字 ：用于指示指针是唯一访问某个数据对象的方式，以帮助优化。
14. 支持 `_STDC_VERSION_` 宏 ： 用于检查标准版本。
15. 改进的输入输出函数 ： 新增的格式化输入输出函数。

示例：

#include <stdio.h>
#include <stdbool.h>
#include <complex.h>
#include <tgmath.h>
#include <stdint.h>

// 单行注释
struct Point {
	int x, y;
};

// 内联函数
inline int square(int x) {
	return x * x;
}

int main() {
	// 按需变量声明
	for (int i = 0; i < 5; i++) {
		printf("i = %d\n", i);
	}

	// 复合字面量
	struct Point p = (struct Point){.x = 1, .y = 2};
	printf("Point p: (%d, %d)\n", p.x, p.y);

	// 可变长数组
	int n = 5;
	int arr[n];
	for (int i = 0; i < n; i++) {
		arr[i] = i * i;
		printf("arr[%d] = %d\n", i, arr[i]);
	}

	// _Bool 类型和 <stdbool.h> 头文件
	_Bool flag = true;
	printf("flag = %d\n", flag);

	// 复数类型和 <complex.h> 头文件
	double complex z = 1.0 + 2.0 * I;
	printf("Complex z: %.2f + %.2fi\n", creal(z), cimag(z));

	// 泛型数学函数
	double result = sqrt(4.0);
	printf("sqrt(4.0) = %.2f\n", result);

	// 指定初始化
	int arr2[5] = {[1] = 10, [3] = 20};
	for (int i = 0; i < 5; i++) {
		printf("arr2[%d] = %d\n", i, arr2[i]);
	}

	// 变长宏参数
#define PRINT(...) printf(__VA_ARGS__)
	PRINT("This is a test: %d\n", 123);

	return 0;
}

1.2 C11 新增特性

#

原子操作

• 提供了原子操作和锁自由编程的支持，通过 <stdatomic.h> 头文件。
• 使用 `_Atomic` 类型说明符和相关函数。

多线程支持

• 引入了多线程支持，通过 <threads.h> 头文件。
• 包括 `thrd_t` 类型、`mtx_t` 类型、`cnd_t` 类型等。

泛型选择

• 使用 `_Generic` 关键字，实现类型安全的泛型编程。

静态断言

• 使用 `_Static_assert` 关键字，在编译时进行断言检查。

对齐支持

• 提供了对齐支持，通过 `<stdalign.h>` 头文件。
• 使用 `alignas` 和 `alignof` 关键字。

变长数组的改进

• 更加严格的变长数组初始化和使用规则。

匿名结构体和联合体

• 允许在结构体和联合体中使用匿名成员。

增强的Unicode支持

• 提供了对Unicode字符的支持，通过 <uchar.h> 头文件。
• 引入了 `char16_t` 和 `char32_t` 类型。

内存模型

• 定义了明确的内存模型，提供更好的并发编程支持。

关键字

• 引入了 `no_return` 关键字，指示函数不会返回。

改进的标准库函数

• 新增了一些标准库函数，如 `aligned_alloc`。

边界检查功能

• 提供了边界检查功能，通过 `<stdckdint.h>` 头文件。

K&R 函数声明的废弃

• 废弃了旧的K&R（Kernighan和Ritchie）函数声明方式。

示例：

#include <stdio.h>
#include <stdatomic.h>
#include <threads.h>
#include <stdalign.h>
#include <uchar.h>
#include <stdlib.h>

// 原子操作示例
atomic_int atomic_var = 0;

// 多线程示例
int thread_func(void *arg) {
    atomic_fetch_add(&atomic_var, 1);
    return 0;
}

// 静态断言示例
_Static_assert(sizeof(int) == 4, "int size is not 4 bytes");

// 对齐支持示例
struct AlignedStruct {
    alignas(16) int x;
    alignas(16) int y;
};

int main() {
    // 泛型选择示例
    #define max(a, b) _Generic((a), \
        int: ((a) > (b) ? (a) : (b)), \
        double: ((a) > (b) ? (a) : (b)) \
    )
    int a = 5, b = 10;
    printf("max(a, b) = %d\n", max(a, b));

    // 对齐支持示例
    struct AlignedStruct s;
    printf("Alignment of s: %zu\n", alignof(s));

    // Unicode 支持示例
    char16_t u16_str[] = u"Hello";
    char32_t u32_str[] = U"World";
    printf("u16_str: %ls\n", (wchar_t *)u16_str);
    printf("u32_str: %ls\n", (wchar_t *)u32_str);

    // 多线程示例
    thrd_t threads[10];
    for (int i = 0; i < 10; ++i) {
        thrd_create(&threads[i], thread_func, NULL);
    }
    for (int i = 0; i < 10; ++i) {
        thrd_join(threads[i], NULL);
    }
    printf("atomic_var = %d\n", atomic_var);

    return 0;
}

1.3 GNU C 扩展

#

完整列表参考：https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html

1. 语句表达式: Statements and Declarations in Expressions

   https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html

   括号封装的单条或多条复合语句，用作表达式，在定义宏时非常有用。

   // 语法:
   //  ({ 表达式1; 表达式2; 表达式3; })
   
   // 括号封装的单条语句
   #define max(a,b) ((a) > (b) ? (a) : (b))
   
   // 括号封装的多条复合语句，多条语句需要用大括号 block 包围
   ({ int y = foo (); int z;
   	if (y > 0) z = y;
   	else z = - y;
   	z; })
   
   #define maxint(a,b)					\
   	({int _a = (a), _b = (b); _a > _b ? _a : _b; })
   
   #define maxint3(a, b, c)						\
   	({int _a = (a), _b = (b), _c = (c); maxint (maxint (_a, _b), _c); })
   
   #define macro(a)  ({__typeof__(a) b = (a); b + 3; })
   template<typename T> T function(T a) { T b = a; return b + 3; }
   
   void foo ()
   {
   	macro (X ());
   	function (X ());
   }
   
   // 语句表达式也支持 goto 跳转
   int main(void)
   {
           int sum = 0;
           sum =
   		({
   			int s = 0;
   			for( int i = 0; i < 10; i++)
   				s = s + i;
   			goto here;
   			s;
   		});
           printf("sum = %d\n", sum);
   here:
           printf("here:\n");
           printf("sum = %d\n", sum);
           return 0;
   }
   

   宏:

   // 良好
   #define MAX(x,y) ((x) > (y) ? (x) : (y))
   
   int main(void)
   {
           int i = 2;
           int j = 6;
           printf("max=%d", MAX(i++,j++)); // 展开后两次自增运算
           return 0;
   }
   // 解决办法: 使用语句表达式
   #define MAX(x,y)({				\
   			int _x = x;		\
   			int _y = y;		\
   			_x > _y ? _x : _y;	\
   		})
   int main(void)
   {
           int i = 2;
           int j = 6;
           printf("max=%d", MAX(i++,j++));
           return 0;
   }
   // 上面的 MAX 只适用于 int 类型
   
   // 优秀: 适用于任意类型
   #define MAX(type,x,y)({				\
   			type _x = x;		\
   			type _y = y;		\
   			_x > _y ? _x : _y;	\
   		})
   int main(void)
   {
           int i = 2;
           int j = 6;
           printf("max=%d\n", MAX(int, i++, j++));
           printf("max=%f\n", MAX(float, 3.14, 3.15));
           return 0;
   }
   
   // 更好! 使用 GNU 提供的 typeof 扩展
   #define max(x, y) ({				\
   			typeof(x) _x = (x);	\
   			typeof(y) _y = (y);	\
   			(void) (&_x == &_y);	\
   			_x > _y ? _x : _y; })
   

   内核中应用:

   #define min_t(type, x, y) ({					\
   			type __min1 = (x);			\
   			type __min2 = (y);			\
   			__min1 < __min2 ? __min1 : __min2; })
   #define max_t(type, x, y) ({					\
   			type __max1 = (x);			\
   			type __max2 = (y);			\
   			__max1 > __max2 ? __max1 : __max2; })
   

2. 指定初始化: Designated Initializers

   指定初始化:

   int a[6] = { [4] = 29, [2] = 15 };
   // 支持数组 index 范围
   int widths[] = { [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 };
   
   union foo { int i; double d; };
   union foo f = { .d = 4 };
   int a[6] = { [1] = v1, v2, [4] = v4 };
   
   struct point ptarray[10] = { [2].y = yv2, [2].x = xv2, [0].x = xv0 };
   
   // 内核示例
   static const struct file_operations ab3100_otp_operations = {
   	.open        = ab3100_otp_open,
   	.read        = seq_read,
   	.llseek      = seq_lseek,
   	.release     = single_release,
   };
   

   这种指定初始化方式，不仅使用灵活，而且还有一个好处就是：代码易于维护。尤其是在 Linux 内核这种大型项目中，几万个文件，几千万的代码量，当成百上千个文件都使用 file_operations 这个结构体类型来定义变量并初始化时，那么一个很大的问题就来了：如果采用标准 C 那种按照固定顺序赋值，当我们的 file_operations 结构体类型发生改变时，如添加成员、减少成员、调整成员顺序，那么使用该结构体类型定义变量的大量 C 文件都需要重新调整初始化顺序，牵一发而动全身，想想这是多么可怕！

   我们通过指定初始化方式，就可以避免这个问题。无论file_operations 结构体类型如何变化，添加成员也好、减少成员也好、调整成员顺序也好，都不会影响其它文件的使用。有了指定初始化，再也不用加班修改代码了

3. typeof 表达式: Referring to a Type with typeof

   typeof 或 __typeof__ 返回类型或表达式结果值的类型。

   C23 标准化了 typeof 和 auto.

   typeof (x[0](1))
   typeof (int *)
   
   #define max(a,b)				\
   	({ typeof (a) _a = (a);			\
   		typeof (b) _b = (b);		\
   		_a > _b ? _a : _b; })
   
   typeof (*x) y[4];
   
   #define pointer(T)  typeof(T *)
   #define array(T, N) typeof(T [N])
   // array (pointer (char), 4) y;
   

   示例:

   
   int main(void)
   {
           int i = 2;
           typeof(i) k = 6;
           int *p = &k;
           typeof(p) q = &i;
           printf("k = %d\n", k);
           printf("*p= %d\n", *p);
           printf("i = %d\n" ,i);
           printf("*q= %d\n", *q);
           return 0;
   }
   
   /* k  = 6 */
   /* *p = 6 */
   /* i  = 2 */
   /* *q = 2 */
   
   typeof (int *) y;     // 把 y 定义为指向 int 类型的指针，相当于int *y;
   typeof (int)  *y;     //定义一个执行 int 类型的指针变量 y
   typeof (*x) y;        //定义一个指针 x 所指向类型 的指针变量y
   typeof (int) y[4];    //相当于定义一个：int y[4]
   typeof (*x) y[4];     //把 y 定义为指针 x 指向的数据类型的数组
   typeof (typeof (char *)[4]) y;//相当于定义字符指针数组：char *y[4];
   typeof(int x[4]) y;  //相当于定义：int y[4]
   
   #define MAX(x,y)({				\
   			typeof(x) _x = x;	\
   			typeof(x) _y = y;	\
   			_x > _y ? _x : _y;	\
   		})
   int main(void)
   {
           int i = 2;
           int j = 6;
           printf("max: %d\n", MAX(i, j));
           printf("max: %f\n", MAX(3.14, 3.15));
           return 0;
   }
   
   #define swap(a, b)				\
   	do {					\
           typeof(a) __tmp = (a);  \
   (a) = (b);         \
   (b) = __tmp; \
   } while (0)
   

   内核的 container_of 宏:

   1. type：结构体类型
   2. member：结构体内的成员
   3. ptr：结构体内成员member的地址

   #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
   #define  container_of(ptr, type, member) ({				\
   			const typeof( ((type *)0)->member ) *__mptr = (ptr); \
   			(type *)( (char *)__mptr - offsetof(type,member) );})
   
   struct student
   {
           int age;
           int num;
           int math;
   };
   int main(void)
   {
   	struct student stu = { 20, 1001, 99};
   	int *p = &stu.math;
   	struct student *stup = NULL;
   	stup = container_of( p, struct student, math);
   	printf("%p\n", stup);
   	printf("age: %d\n", stup->age);
   	printf("num: %d\n", stup->num);
   	return 0;
   }
   

4. Locally Declared Labels

   https://gcc.gnu.org/onlinedocs/gcc/Local-Labels.html

   label 默认是 func 作用域, 而该扩展定义的 label 只具有 block 作用域，在宏定义式非常有用：

   // 先声明 local lable
   
   __label__ label;
   __label__ label1, label2, /* … */;
   
   #define SEARCH(value, array, target)					\
   	do {								\
   		__label__ found;					\
   		typeof (target) _SEARCH_target = (target);		\
   		typeof (*(array)) *_SEARCH_array = (array);		\
   		int i, j;						\
   		int value;						\
   		for (i = 0; i < max; i++)				\
   			for (j = 0; j < max; j++)			\
   				if (_SEARCH_array[i][j] == _SEARCH_target) \
   				{ (value) = i; goto found; }		\
   		(value) = -1;						\
   	found:;								\
   	} while (0)
   
   // 等效的, 用语句表达式来重写:
   #define SEARCH(array, target)						\
   	({								\
   		__label__ found;					\
   		typeof (target) _SEARCH_target = (target);		\
   		typeof (*(array)) *_SEARCH_array = (array);		\
   		int i, j;						\
   		int value;						\
   		for (i = 0; i < max; i++)				\
   			for (j = 0; j < max; j++)			\
   				if (_SEARCH_array[i][j] == _SEARCH_target) \
   				{ value = i; goto found; }		\
   		value = -1;						\
   	found:								\
   		value;							\
   	})
   

5. Labels as Values

   https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html

   You can get the address of a label defined in the current function (or a containing function) with the unary operator ‘&&’. The value has type void *. This value is a constant and can be used wherever a constant of that type is valid. For example:

   使用 && 运算符来获得函数的 label 地址，返回 void * 类型指针，它是常量，可以用在任何需要常量值或指针的地方：

   void *ptr;
   /* … */
   ptr = &&foo;
   

   使用 goto 跳转来使用改值：

   goto *ptr;
   

   示例：

   // 创建一个数组
   static void *array[] = { &&foo, &&bar, &&hack };
   goto *array[i];
   
   static const int array[] = { &&foo - &&foo, &&bar - &&foo, &&hack - &&foo };
   goto *(&&foo + array[i]);
   

6. Nested Functions

   C 不允许在函数中定义嵌套函数，而该扩展则允许定义嵌套函数（GNU C++ 不支持嵌套函数）。

   嵌套函数名称只在所定义的 block 中有效，嵌套函数可以访问所在函数的变量（称为 lexical scoping）。

   foo (double a, double b)
   {
   	double square (double z) { return z * z; }
   	return square (a) + square (b);
   }
   
   bar (int *array, int offset, int size)
   {
   	int access (int *array, int index){ return array[index + offset]; }
   	int i;
   	/* … */
   	for (i = 0; i < size; i++)
   		/* … */ access (array, i) /* … */
   }
   

   嵌套函数可以跳转到所在函数的 local label：

   bar (int *array, int offset, int size)
   {
   	__label__ failure;
   	int access (int *array, int index)
   	{
   		if (index > size)
   			goto failure;
   		return array[index + offset];
   	}
   	int i;
   	/* … */
   	for (i = 0; i < size; i++)
   		/* … */ access (array, i) /* … */
   			/* … */
   			return 0;
   
   	/* Control comes here from access
   	   if it detects an error.  */
   failure:
   	return -1;
   }
   

7. Conditionals with Omitted Operands

   x ? : y
   // 等效于
   x ? x : y
   

8. Arrays of Length Zero

   struct line {
   	int length;
   	char contents[0]; // 占用空间为 0
   };
   
   struct line *thisline = (struct line *) malloc (sizeof (struct line) + this_length);
   thisline->length = this_length;
   

9. Structures with No Members

   该 struct 的大小为 0.

   struct empty {
   };
   

10. Unions with Flexible Array Members

GCC permits a C99 flexible array member (FAM) to be in a union:

```C
union with_fam {
  int a;
  int b[];
};
```

11. Structures with only Flexible Array Members

GCC permits a C99 flexible array member (FAM) to be alone in a structure:

```C
struct only_fam {
  int b[]; // 大小为 0
};
```

12. Arrays of Variable Length

Variable-length automatic arrays are allowed in ISO C99, and as an extension GCC
accepts them in C90 mode and in C++.

```C
FILE * concat_fopen (char *s1, char *s2, char *mode)
{
	char str[strlen (s1) + strlen (s2) + 1];
	strcpy (str, s1);
	strcat (str, s2);
	return fopen (str, mode);
}

// 函数参数也可以使用可变长度
struct entry tester (int len, char data[len][len])
{
	/* … */
}
```

13. Macros with a Variable Number of Arguments.

```C
// C99 标准
#define debug(format, ...) fprintf (stderr, format, __VA_ARGS__)

// GNU C 扩展
#define debug(format, args...) fprintf (stderr, format, args)
#define debug(format, ...) fprintf (stderr, format, ## __VA_ARGS__)
```

14. Non-Constant Initializers

```C
foo (float f, float g)
{
  float beat_freqs[2] = { f-g, f+g };
  /* … */
}
```

15. Compound Literals

```C
struct foo {int a; char b[2];} structure;
structure = ((struct foo) {x + y, 'a', 0});

// 等效为
{
  struct foo temp = {x + y, 'a', 0};
  structure = temp;
}
```

16. Case Ranges

```C
case 'A' ... 'Z':
```

17. Mixed Declarations, Labels and Code

<https://gcc.gnu.org/onlinedocs/gcc/Mixed-Labels-and-Declarations.html>

ISO C99 and ISO C++ allow declarations and code to be freely mixed within compound
statements. ISO C23 allows labels to be placed before declarations and at the end of
a compound statement. As an extension, GNU C also allows all this in C90 mode. For
example, you could do:

```C
int i;
/* … */
i++;
int j = i + 2;
```

18. Determining the Alignment of Functions, Types or Variables

The keyword `__alignof__` determines the alignment requirement of a function, object,
or a type, or the minimum alignment usually required by a type. Its syntax is just
like sizeof and C11 \_Alignof.

```C
#include <stdalign.h>
#include <stddef.h>
#include <stdio.h>

int main(void)
{
	printf("Alignment of char = %zu\n", alignof(char));
	printf("Alignment of max_align_t = %zu\n", alignof(max_align_t));
	printf("alignof(float[10]) = %zu\n", alignof(float[10]));
	printf("alignof(struct{char c; int n;}) = %zu\n",
	       alignof(struct {char c; int n;}));
}
```

19. An Inline Function is As Fast As a Macro

```C
static inline int inc (int *a)
{
  return (*a)++;
}
```

If you are writing a header file to be included in ISO C90 programs, write `__inline__`
instead of inline. See Alternate Keywords.

20. Getting the Return or Frame Address of a Function

```C
// Built-in Function:
void * __builtin_return_address (unsigned int level);
// Built-in Function:
void * __builtin_extract_return_addr (void *addr);
// Built-in Function:
void * __builtin_frame_address (unsigned int level);
// Built-in Function:
void * __builtin_stack_address ();
```

21. Support for offsetof

```C
primary:
        "__builtin_offsetof" "(" typename "," offsetof_member_designator ")"
offsetof_member_designator:
          identifier
        | offsetof_member_designator "." identifier
        | offsetof_member_designator "[" expr "]"

#define offsetof(type, member)  __builtin_offsetof (type, member)
```

22. Alternate Keywords

<https://gcc.gnu.org/onlinedocs/gcc/Alternate-Keywords.html>

`-ansi` and the various `-std` options `disable certain keywords`. This causes trouble when
you want to use GNU C extensions, or a general-purpose header file that should be
usable by all programs, including ISO C programs.

The keywords `asm, typeof and inline` are not available in programs compiled with `-ansi`
or `-std` (although inline can be used in a program compiled with -std=c99 or a later
standard). The ISO C99 keyword `restrict` is only available when `-std=gnu99` (which will
eventually be the default) or -std=c99 (or the equivalent -std=iso9899:1999), or an
option for a later standard version, is used.

The way to solve these problems is to `put ‘__’ at the beginning and end of each
problematical keyword`. For example, use `__asm__` instead of `asm`, and `__inline__`
instead of inline.

Other C compilers won’t accept these alternative keywords; if you want to compile
with another compiler, you can define the alternate keywords as macros to replace
them with the customary keywords. It looks like this:

```C
#ifndef __GNUC__
#define __asm__ asm
#endif
```

`-pedantic` and other options `cause warnings for many GNU C extensions`. You can
suppress such warnings using the keyword `__extension__`. Specifically:

1.  Writing <span class="underline"><span class="underline">extension</span></span> before an expression prevents warnings about extensions within
    that expression.  In C, writing:
2.  `[[__extension__ …]]`

    suppresses warnings about using ‘[[]]’ attributes in C versions that predate C23.

`__extension__` has no effect aside from this.

23. Function Names as Strings

<https://gcc.gnu.org/onlinedocs/gcc/Function-Names.html>

GCC provides three magic constants that hold `the name of the current function` as a
string. In C++11 and later modes, all three are treated as constant expressions and
can be used in constexpr constexts. The first of these constants is `__func__` , which
is part of the C99 standard:

The identifier `__func__` is implicitly declared by the translator as if, immediately
following the opening brace of each function definition, the declaration：

```C
static const char __func__[] = "function-name";
```

`__FUNCTION__` is another name for `__func__` , provided for backward compatibility with
old versions of GCC.

```C
extern "C" int printf (const char *, ...);

class a {
 public:
  void sub (int i)
    {
      printf ("__FUNCTION__ = %s\n", __FUNCTION__);
      printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__);
    }
};

int
main (void)
{
  a ax;
  ax.sub (0);
  return 0;
}

/* __FUNCTION__ = sub */
/* __PRETTY_FUNCTION__ = void a::sub(int) */
```

24. Binary Constants using the ‘0b’ Prefix

<https://gcc.gnu.org/onlinedocs/gcc/Binary-constants.html>

```C
i =       42;
i =     0x2a;
i =      052;
i = 0b101010;
```

25. Other Built-in Functions Provided by GCC

<https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html>

所有 GNU 内置函数都以 __builtin 开头,如 `__builtin_fabsfn`

26. Pragmas Accepted by GCC

<https://gcc.gnu.org/onlinedocs/gcc/Pragmas.html>

27. 示例：

```C
// 零长数组（可变长数组）
struct line {
	int length;
	char contents[0];
};

struct line *thisline = (struct line *)malloc (sizeof (struct line) + this_length);
thisline->length = this_length;

// 变长数组，数组长度可以是变量或表达式而非常量值；
FILE * concat_fopen (char *s1, char *s2, char *mode)
{
	char str[strlen (s1) + strlen (s2) + 1];
	strcpy (str, s1);
	strcat (str, s2);
	return fopen (str, mode);
}

// 数组成员的初始化可以是非常量表达式
void foo (float f, float g)
{
	float beat_freqs[2] = { f-g, f+g };
/* . . . */
}

// 复合字面量（非 GNU C 扩展的情况下，只允许在声明变量时使用字面量来初始化）
struct foo {int a; char b[2];} structure;
structure = (struct foo) {x + y, 'a', 0};
// 等效为
{
	struct foo temp = {x + y, 'a', 0};
	structure = temp;
}

// 也可以对数组使用复合字面量初始化
char **foo = (char *[]) { "x", "y", "z" };

// Compound literals for scalar types and union types are also allowed.
int i = ++(int) { 1 };

// C99 要求静态变量必须用常量来初始化, 但是 GNU C 允许使用复合字面量来初始化；
static struct foo x = (struct foo) {1, 'a', 'b'};
static int y[] = (int []) {1, 2, 3};
static int z[] = (int [3]) {1};

// 复合类型的数组初始化：
// 结构体数组
struct point
{
	int x, y;
};
struct point point_array[2] = { {4, 5}, {8, 9} };
point_array[0].x = 3;

// 使用变量作为成员初始值
struct point ptarray[10] = { [2].y = yv2, [2].x = xv2, [0].x = xv0 };

// 多维数组
int two_dimensions[2][5] = { {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10} };

// 联合数组
union numbers
{
	int i;
	float f;
};
union numbers number_array [3] = { {3}, {4}, {5} };


// case range，... 前后的空格是必须的。
case 'A' ... 'Z':
case 1 ... 5:

// 条件运算符忽略操作数
x?:y // 约等于 x?x:y, 但是 x 值会被求值一次
```

1.4 GNU C asm

#

GNU C 支持两种类型的内联汇编：

1. Basic asm：Assembler Instructions Without Operands

   asm asm-qualifiers ( AssemblerInstructions )
   

   只能在文件全局（top-level）使用，不支持输入、输出参数；

2. Extended Asm：Assembler Instructions with C Expression Operands

asm asm-qualifiers ( AssemblerTemplate
: OutputOperands
[ : InputOperands
[ : Clobbers ] ])

asm asm-qualifiers ( AssemblerTemplate
: OutputOperands
: InputOperands
: Clobbers
: GotoLabels)

示例：

__asm__ ("some instructions"
: /* No outputs. */
: "r" (Offset / 8))


int src = 1;
int dst;
asm ("mov %1, %0\n\t" // %1 %0 引用后面的变量
"add $1, %0"
: "=r" (dst) // 输出
: "r" (src)); // 输入

printf("%d\n", dst);

为汇编中引用的变量定义名称：

uint32_t Mask = 1234;
uint32_t Index;
asm ("bsfl %[aMask], %[aIndex]" // %[aIndex] 引用变量名
: [aIndex] "=r" (Index) // [aIndex] 为变量别名
: [aMask] "r" (Mask)
: "cc");

Clang 支持的 attribute: https://clang.llvm.org/docs/AttributeReference.html

2 源文件

#

源文件经过 parse 后形成如下类型的 token（称为词法解析）：

1. 标识符：用来命名 type、variable、struct, union、enumeration tags, their members, typedef names, labels, macros 等。
2. 关键字
3. 字面量：数值常量，字符常量，字符串常量，C99 支持的复合字面量
4. 运算符： 对操作数进行操作，组成表达式，可以是单目、双目、前缀或后缀。
5. 分隔符：用于分割 token，包含 ( ) [ ] { } ; , . : 。空白也用于分割 token，但它本身不是 token。
6. 空白和注释：包含 空格、tab、换行、\f 和 \v;, 空白字符会被忽略。

#include <stdio.h>

int main() {
	printf( "hello, world\n" );
	return 0;
}

// 等效于
#include <stdio.h> int main(){printf("hello, world\n");return 0;}

解析生成 token 后，需要进行语法分析，形成语句，包括表达式语句、if 语句、for 语句等。

3 类型

#

C 类型系统的核心思想是抽象和组合，struct/union/array/pointer 都是由基本类型组合而来的。函数也是语句的组合，语句是表达式或 if/while/for 等组合，表达式是操作符和操作数或表达式的组合。

对于复合类型，如数组、struct、union, 的初始化有两种方式：

1. 大括号表达式：大括号中的值必须是常量表达式，而且只能用于初始化，不能用于后续赋值。
2. C99 支持的复合字面量（Compound Literals）：可以用于初始化和后续赋值，字面量中可以使用变量。

3.1 基本类型

#

常量（字面量）类型：

// char 是 8 bits 的整型
printf("%d %d\n", 5, '5'); // 5 53

char c = '6';
int x = c;  // x has value 54, the code point for '6'
int y = c - '0'; // y has value 6, just like we want

long long int x;
// 等效于
long long x;

short int x;
// 等效于
short x;

int a = 0x1A2B;
int b = 0x1a2b;
printf("%x", a);

int a = 012;
printf("%o\n", a);

int x = 11111;  // Decimal 11111
int y = 00111;  // Decimal 73 (Octal 111)
int z = 01111;  // Decimal 585 (Octal 1111)

int x = 0b101010;    // Binary 101010
printf("%d\n", x);   // Prints 42 decimal

整型默认为 int，浮点默认为 double，通过给字面量添加 U 和 L 来改变字面量值的类型：

int           x = 1234; // int
long int      x = 1234L; // long
long long int x = 1234LL // long long

unsigned int           x = 1234U;
unsigned long int      x = 1234UL;
unsigned long long int x = 1234ULL;

float x       = 3.14f;
double x      = 3.14;
long double x = 3.14L;
printf("%e\n", 123456.0);  // Prints 1.234560e+05

没有 long long double！

I32LP64:

1. int/float：32 位；
2. long/long long/double/pointer：64 位；

注：long doubule 是 128 位。

arm64 位系统：

limits.h 头文件定义了这些类型的取值范围：

浮点类型大小固定（单位 byte）：

浮点数有效数字精度的最小值：

有效数字位数（精度）是指浮点数在表示和计算时能够保持的精确位数。对于单精度和双精度浮点数，有效数字位数是由浮点数的尾数部分（也称为有效数字或分数部分）的位数决定的。具体如下：

1. 单精度浮点数（32位）：
   • 符号位：1位
   • 指数部分：8位
   • 尾数部分：23位
2. 双精度浮点数（64位）：
   • 符号位：1位
   • 指数部分：11位
   • 尾数部分：52位

有效数字位数的计算

1. 单精度浮点数： 尾数部分有 23 位，但是因为浮点数采用规范化形式，隐藏了一位隐含的 1, 因此，总的有效数字位数为24位。 单精度浮点数的有效数字位数大约为 7 位十进制数 。（一位十进制大概 3bit，故共21bits）
2. 双精度浮点数： 尾数部分有52位，同样包含了一位隐含的1。 因此，总的有效数字位数为53 位。 双精度浮点数的有效数字位数大约为 16位十进制数 。

浮点数的有效数字位数可以通过以下公式估算，其中，nn 是尾数部分的总位数（包括隐含的1位）：

Decimal Digits≈log⁡10(2n)log⁡10(10)=n⋅log⁡10(2)log⁡10(10)≈n⋅0.3010Decimal Digits≈log10​(10)log10​(2n)​=log10​(10)n⋅log10​(2)​≈n⋅0.3010

/*
  0.12345
  0.123456
  0.1234567
  0.12345678
  0.123456791  <-- Things start going wrong
  0.1234567910
*/

#include <stdio.h>
#include <float.h>

int main(void)
{
	// Both these numbers have 6 significant digits, so they can be stored
	// accurately in a float:

	float f = 3.14159f;
	float g = 0.00000265358f;

	printf("%.5f\n", f);   // 3.14159       -- correct!
	printf("%.11f\n", g);  // 0.00000265358 -- correct!

	// Now add them up
	f += g;                // 3.14159265358 is what f _should_ be

	printf("%.11f\n", f);  // 3.14159274101 -- wrong!
}

3.2 C99 bool 和固定宽度整型

#

C99 stdbool.h 提供了 bool 类型和常量值 true/false 。

bool 类型占用 1 byte：

#ifndef __STDBOOL_H
#define __STDBOOL_H

#define bool _Bool
#define true 1
#define false 0

#endif /* __STDBOOL_H */

C99 stdint.h 中新增了以下类型，来解决之前 整型大小 不固定的问题：

• int8_t、int16_t、int32_t、int64_t
• uint8_t、uint16_t、uint32_t、uint64_t
• int_least8_t、int_least6_t、int_least32_t、int_least64_t
• int_fast8_t、int_fast6_t、int_fast32_t、int_fast64_t
• uintmax_t、uintptr_t

以及一些类型的最大、最小值：

INT8_MAX           INT8_MIN           UINT8_MAX
INT16_MAX          INT16_MIN          UINT16_MAX
INT32_MAX          INT32_MIN          UINT32_MAX
INT64_MAX          INT64_MIN          UINT64_MAX

INT_LEAST8_MAX     INT_LEAST8_MIN     UINT_LEAST8_MAX
INT_LEAST16_MAX    INT_LEAST16_MIN    UINT_LEAST16_MAX
INT_LEAST32_MAX    INT_LEAST32_MIN    UINT_LEAST32_MAX
INT_LEAST64_MAX    INT_LEAST64_MIN    UINT_LEAST64_MAX

INT_FAST8_MAX      INT_FAST8_MIN      UINT_FAST8_MAX
INT_FAST16_MAX     INT_FAST16_MIN     UINT_FAST16_MAX
INT_FAST32_MAX     INT_FAST32_MIN     UINT_FAST32_MAX
INT_FAST64_MAX     INT_FAST64_MIN     UINT_FAST64_MAX

INTMAX_MAX         INTMAX_MIN         UINTMAX_MAX

对于常量，可以使用下面的宏：

INT8_C(x)     UINT8_C(x)
INT16_C(x)    UINT16_C(x)
INT32_C(x)    UINT32_C(x)
INT64_C(x)    UINT64_C(x)
INTMAX_C(x)   UINTMAX_C(x)

uint16_t x = UINT16_C(12);
intmax_t y = INTMAX_C(3490);

3.3 数组

#

函数内的数组变量是在栈上分配的，需要显式初始化, 否则存的值是随机的：

#include <stdio.h>

int main(void)
{
	float f[4];  // 定义数组，值是随机的。

	f[0] = 3.14159;
	f[1] = 1.41421;
	f[2] = 1.61803;
	f[3] = 2.71828;

	for (int i = 0; i < 4; i++) {
		printf("%f\n", f[i]);
	}
}

数组初始化：

• 使用大括号形式初始化：大括号中的值必须都是 常量表达式 ，因为它们都在编译期间求值；
• 大括号指定 index 初始化：未指定的 index 值默认初始化为 0;
• C99 开始支持的复合字面量初始化；

// 未初始化，数组为随机值。
int my_array[5];

// 先声明再赋值
struct point point_array [3];
point_array[0].x = 2;
point_array[0].y = 3;

// 全量初始化，值必须都是常量表达式
int my_array[5] = { 0, 1, 2, 3, 4 };

// 部分初始化，剩余的部分都初始化为 0；
int my_array[5] = { 0, 1, 2 };
int my_array[5] = { 0 }; // 所有元素都为 0
// int my_array[5] = {}; // 错误，必须至少指定一个元素的值。

// GNU 扩展：指定 index range 初始化，未指定的部分都初始化为 0；
int new_array[100] = { [0 ... 9] = 1, [10 ... 98] = 2, 3 };

// 不指定数组长度，自动根据初始化字面量值来计算
int my_array[] = { 0, 1, 2, 3, 4 };
int my_array[] = { 0, 1, 2, [99] = 99 };

// 宏常量表达式作为数组长度
#define COUNT 5
int a[COUNT] = {[COUNT-3]=3, 2, 1};

// 结构数组初始化
struct point
{
	int x, y;
};
// 数组元素也使用大括号初始化
struct point point_array [3] = { {2, 3}, {4, 5}, {6, 7} };
// 初始化数组时可以指定 index
struct point point_array [3] = { [0]={2}, [1]={4, 5}, [2]={6, 7}};
// 初始化结构时可以指定部分 field
struct point point_array [3] = { {2}, {4, 5}, {6, 7} };

数组名表示内存的开始地址，它不是变量，编译器不会为数组名分配内存空间，故不能作为左值使用，所以数组之间不能相互赋值，函数也不能返回数组。但是数组名作为右值使用时（如将数组名作为实参传递），等效为指向首元素的指针。

• 函数不能返回数组类型 ，但是可以返回数组的指针或包含数组的 struct。
• 数组名不能做左值, 所以数组之间不能赋值 （但是相同的结构类型对象之间可以直接赋值）。

// 数组可以作为函数参数，等效为指针，一维数组的长度被忽略（多维数组参数不能忽略长度）
int foo(const int sz[10]);
// 等效于
int foo(const int sz[]);
// 等效于
int foo(const int *sz); // 建议：明确 sz 为指针。
// 不管使用哪种形式，函数内均可以使用 *(sz+N) 或 sz[N] 的方式来访问数组元素。

int a[2] = {0, 1};
int b[2] = {1, 2};
// 数组之间不能直接赋值：a 类型是数组，而 b 做右值是指针，两者类型不匹配。
a = b;

// arr 为指针类型。
void printArray(int arr[])  // 等效于 int *arr
{
        // arr 是指针类型，所以 sizeof 值为 8
	printf("Size of Array in Functions: %d\n", sizeof(arr));
	printf("Array Elements: ");
	for (int i = 0; i < 5; i++) {
		printf("%d ",arr[i]); // 不管哪种方式，都支持 arr[N]
	}
}

// 传入数组长度
void double_array(int *a, int len)
{
	for (int i = 0; i < len; i++)
		a[i] *= 2;
}

数组类型的 extern 变量声明： extern 也必须声明为数组类型，而不是指针类型 。这是因为编译器需要为指针变量分配内存，而数组名代表的是一块连续的内存区域首地址, 它不是变量，不需要单独为数组名分配内存。

// 数组变量定义
int array[5] = {1, 2, 3};

extern int array[]; // 正确
extern int *array; // 错误，编译时报错

数组 index 操作 A[i] 等效为指针表达式 (*((A)+(i))) ，所以数组名在表达式右边时等效为指针： ptr + N 的结果取决于 ptr 指向的对象类型，+ N 表示跳过 N 个该对象类型的地址空间；

int array[10];
int *ptr = array; // 数组作为右值时，等效为一个指针。
// array[0] == *ptr
// array[N] == *(ptr+N)
// ptr == array == &array[0]

aint arr[5] = { 10, 20, 30, 40, 50 };
int* ptr = &arr[0];
for (int i = 0; i < 5; i++) {
        printf("%d ", *ptr++); // 后缀单目运算符优先级最高
}

数组大小和元素数量：使用 sizeof 运算符获得 类型或表达式的结果值 的大小：

• sizeof 的参数可以是类型或表达式，对于类型，必须使用括号语法；
• sizeof 返回值类型是 size_t, 需要使用 %zu 来进行格式化；

int x[12];
printf("%zu\n", sizeof x);     // 48 total bytes
printf("%zu\n", sizeof(int));  // 4 bytes per int
printf("%zu\n", sizeof x / sizeof(int)); // 12

void foo(int x[12])
{
	printf("%zu\n", sizeof x);  // 8
	printf("%zu\n", sizeof(int)); // 4
	printf("%zu\n", sizeof x / sizeof(int)); // 2
}

在定义、声明或向函数传递多维数组变量时，除了第一维外需要明确指定其它维：

// 字符串是 char 数组。
char *name[]={"Illegal manth", "Jan", "Feb", "Mar"};

char aname[][15] = { "Illegal month", "Jan", "Feb", "Mar" };

向函数传递 int a[2][2] 类型的二维数组名称 a 时, 实际传递的是 &a[0], 因为 a[0] 是一维数组, 所以 &a[0] 是数组指针, 类型为 int(*)[2] 。在声明函数参数时, 可以使用以下任意一种：

1. int a[][2];
2. int (*a)[2];

#include <stdio.h>

// 多维数组参数：可以省略一维，但必须指定后续维度的数组长度。
// 或者：int a[][3] 或者 int (*a)[3]
void print_2D_array(int a[2][3]) {
	for (int row = 0; row < 2; row++) {
		for (int col = 0; col < 3; col++)
			printf("%d ", a[row][col]);
		printf("\n");
	}
}

int main(void) {
	int x[2][3] = {
		{1, 2, 3},
		{4, 5, 6}
	};
	print_2D_array(x);
}

类似的三维数组 int c[2][2][2], 在声明函数参数时, 可以使用以下任意一种:

1. int cc[][2][2];

2. int (*cc)[2][2];

3. c 是一个三维数组的名字, 相当于一个二维数组的指针, 所以 c+1 指向第二个二维数组。

4. cc 是一个指针, 指向一个 2*2 的 int 数组, 当 cc = c 时, cc 实际指向三维数组 c 的第一个二维数组.

5. c 是 3 维数组的数组名，作为右值时是指向一个 2*3 的二维数组的指针, 可以赋值：int (*cp)[2][3] = c;

6. c+1 指向第二个 2*3 数组的指针: int (*cp)[2][3] = c+1;

7. *(c+1) 或 c[1] 为 第二个 2*3 数组 ，而非该数组的第一个元素： int (*cp)[3] = c[1];

8. *(*(c+1) + 1) 或 c[1][1] 为一个 3 个元素的数组，而非该数组的第一个元素：int *c5 = c[1][1];

9. c[1][1][0] 才是数组数组的元素；

//一维数组：
int a[3];

// a 为一维数组名，作为右值是第一个元素的地址
int *p = a;

//二维数组：
int a[3][3]

// a 是一个二维数组名，作为右值时表示一个一维数组的首地址指针
int (*p)[3] = a;

// a+1 为第二个一维数组的首地址指针
int (*p)[3] = a+1;

// a[1] 是一个一维数组名 ，作为右值时表示该数组的首地址指针
int *p = a[1];

总结：

1. 建议函数参数使用 int a[][5][5] 而非 int (*a)[5][5] 形式；
2. 使用 int (*a)[5][5] 的方式和三维数组类似 int a[i][5][5] ；

多维数组的初始化:

// 多维数组字面量初始化, 每一维都是一级 {}
int c[2][2] = {{0,0}, {1,1}};
int b[][3][3] = 	  { // b
	{  //b[0]
		{1, 2, 3},  // b[0][0]
		{1, 2, 3}, // b[0][1]
		{1, 2, 3},
	},
	{
		{4, 5, 6}, // b[1][0]
		{4, 5, 6},
		{4, 5, 6},
	}
};

// 也可以打平列出多维数组的所有元素，根据元素数量自动计算第一维的值元素数量必须是后续
// 维度的整数倍（2*2 = 4）
int c[][2][2] = {
	0,0,0,0, // c[0]
	1,1,1,1, // c[1]
	2,2,2,2, // c[2]
}；

int a[3][2] = {
	{1, 2},
	{3},    // Left off the 4!
	{5, 6}
};
/* 1 2 */
/* 3 0 */
/* 5 6 */

int a[3][2] = {
        {1, 2},
        // {3, 4},   // Just cut this whole thing out
        {5, 6}
};

/* 1 2 */
/* 5 6 */
/* 0 0 */

// 多维数组也可以打平初始化
int a[3][2] = { 1, 2, 3, 4, 5, 6 };
/* 1 2 */
/* 3 4 */
/* 5 6 */

// 整个数组都是 0
int a[3][2] = {0};

struct 的最后一个 field 支持可变长数组（称为 Flexible Array Members），可以是编译器扩展的零长数组，或者 C99 开始支持的零长数组。零长数组不占用内存存储空间。

int buffer[0];
printf("%d\n", sizeof(buffer)); // 0

struct buffer{
    int len;
    int a[0];
};
 printf("%d\n", sizeof(struct buffer)); // 4

// 编译器扩展的 0 长数组，这样 malloc 分配的额外空间都可以给 data 成员用。
struct len_string {
	int length;
	char data[0];
};

struct len_string *s = malloc(sizeof *s + 40);
s->length = 40;
strcpy(s->data, "Hello, world!");

// C99 正式支持零长数组
struct len_string {
	int length;
	char data[]; // 必须是 struct 最后一个成员，不指定大小;
};

struct len_string *len_string_from_c_string(char *s)
{
	int len = strlen(s);

	// Allocate "len" more bytes than we'd normally need
	struct len_string *ls = malloc(sizeof *ls + len);

	ls->length = len;

	// Copy the string into those extra bytes
	memcpy(ls->data, s, len);

	return ls;
}

为何不用指针代替零长数组？

数组名用来表征一块连续内存存储空间的地址，而指针是一个变量，编译器要给它单独再分配一个内存空间，用来存放它指向的变量的地址；对于一个指针变量，编译器要为这个指针变量单独分配一个存储空间，然后在这个存储空间上存放另一个变量的地址，我们就说这个指针指向这个变量。而数组名，编译器不会再给其分配一个存储空间的，它仅仅是一个符号，跟函数名一样，用来表示一个地址。

struct buffer1{
	int len;
	int a[0];
};
struct buffer2{
	int len;
	int *a;
};
int main(void)
{
	printf("buffer1: %d\n", sizeof(struct buffer1));
	printf("buffer2: %d\n", sizeof(struct buffer2));
	return 0;
}

/* buffer1：4 */
/* buffer2：8 */

C99 支持可变长数组 Variable-Length Arrays (VLAs) ：在运行时而非编译时确定数组的长度，数组长度可以为变量。（linux kernel 不允许使用 VLA）

• 可变长数组在栈上分配，和 malloc() 相比，优点是：不需要手动 free 释放内存，sizeof() 返回数组的内存大小。
• 只能在 block 作用域中，如函数参数或自动变量，但不支持 file 或全局作用域。
• 不支持 static 类型 VLA，不支持用初始化表达式初始化 VLA，不支持在 struct/union 中使用 VLA；
• 可以在 block 作用域中用 typedef 来声明 VLA 类型多维数组;
• sizeof 可以正常使用，但是如果作为函数参数的 VLA, sizeof 返回的指针变量的大小。

#if __STDC_NO_VLA__ == 1
#error Sorry, need VLAs for this program!
#endif

#include <stdio.h>

int main(void)
{
	int n;

	printf("Enter a number: ");
	fflush(stdout);
	scanf(" %d", &n);

        // 可变长数组：数组长度可以是变量, 可实现栈上内存分配(类似于堆上内存分配的
        // malloc)
	int v[n];
	// int v[x * 100]; // OK

	// 可以正常使用 sizeof，返回数组总大小
	size_t num_elems = sizeof v / sizeof v[0];

	for (int i = 0; i < n; i++)
		v[i] = i * 10;

	for (int i = 0; i < n; i++)
		printf("v[%d] = %d\n", i, v[i]);
}

// 函数参数中数组也可以是可变长数组
void fvla(int m, int C[m][m])
{
	typedef int VLA[m][m];
	int D[m];
	int (*s)[m];
	s = malloc(m * sizeof(int));
	static int (*q)[m] = &B;

        //  static int E[m]; // Error: static duration VLA
        //  extern int F[m]; // Error: VLA with linkage
        //  extern int (*r)[m]; // Error: VM with linkage
}

VLA 作为函数参数：函数内 VLA 是一个指针，sizeof 返回指针大小。

// 对于使用 VLA 的函数声明, 长度部分可以使用 * 或变量名
void foo(size_t x, int a[*]); // 函数声明
void foo(size_t x, int a[x]); // OK, 函数声明

// 函数定义，必须用变量指定长度
void foo(size_t x, int a[x]) // x 是一个变量, 作为 a 数组的长度, 是一个可变长数组, 编
			     // 译器自动分配内存
{
	printf("%zu\n", sizeof a); // same as sizeof(int*) // 函数内, a 是一个指针变
				   // 量类型而非数组.
}

VLA 也支持 typedef 运算符，但是定义的数组大小为执行 typedef 时刻变量值：

#include <stdio.h>

int main(void)
{
	int w = 10;

	typedef int goat[w]; // goat 类型为固定大小的数组 int[10]

	// goat is an array of 10 ints
	goat x;   // 但是还是不能对 gota 进行字面量初始化。

	// Init with squares of numbers
	for (int i = 0; i < w; i++)
		x[i] = i*i;

	// Print them
	for (int i = 0; i < w; i++)
		printf("%d\n", x[i]);

	// Now let's change w...

	w = 20;

	// But goat is STILL an array of 10 ints, because that was the
	// value of w when the typedef executed.
}

多维 VLA：

int w = 10;
int h = 20;

int x[h][w];
int y[5][w];
int z[10][w][20];


// 向函数传递多维 VLA 数组
#include <stdio.h>

void print_matrix(int h, int w, int m[h][w])
{
	for (int row = 0; row < h; row++) {
		for (int col = 0; col < w; col++)
			printf("%2d ", m[row][col]);
		printf("\n");
	}
}

int main(void)
{
	int rows = 4;
	int cols = 7;

	int matrix[rows][cols];

	for (int row = 0; row < rows; row++)
		for (int col = 0; col < cols; col++)
			matrix[row][col] = row * col;

	print_matrix(rows, cols, matrix);
}

在使用数组类型的函数参数时，可以 在方括号中 指定 type qualifiters（const、volatile）和 static 关键字：

• int p[static 4] ：static 表示传入的数组 p 至少包含 4 个元素;
• const int a[const 20] ：表示 a 类型是 const int * const a ，20 会被忽略；
• double a[static restrict 10]：表示 a 数组至少有 10 个元素, 而且只会通过该指针来修改对应内存区域;

// 指针变量的 type qualifiters
int *const p;
int *volatile p;
int *const volatile p;
// etc.

// 数组的 type qualifiters 在方括号内指定
int func(int *const volatile p) {...}
int func(int p[const volatile]) {...}
int func(int p[const volatile 10]) {...}

// static N：表示 p 数组包含至少 4 个元素
int func(int p[static 4]) {...}

int main(void)
{
	int a[] = {11, 22, 33, 44};
	int b[] = {11, 22, 33, 44, 55};
	int c[] = {11, 22};

	func(a);  // OK! a is 4 elements, the minimum
	func(b);  // OK! b is at least 4 elements
	func(c);  // Undefined behavior! c is under 4 elements!
}

int f(const int a[20]) // 20 会被忽略
{
	// in this function, a has type const int* (pointer to const int)
}

int g(const int a[const 20]) // 20 会被忽略
{
	// in this function, a has type const int* const (const pointer to const int)
}

// restrict 表示只会通过该指针来修改对应内存区域(没有其它方式),编译器可以据此进行优化.
void fadd(double a[static restrict 10], const double b[static restrict 10])
{
	for (int i = 0; i < 10; i++) // loop can be unrolled and reordered
	{
		if (a[i] < 0.0)
			break;
		a[i] += b[i];
	}
}

3.4 字符串

#

C 没有字符串类型，它实际是以 ‘\0’ 结尾的 char 数组。

strlen() 计算字符串长度时不包含末尾的 ‘\0’ 字符, 返回值类型是 size_t, 使用 %zd 来打印.

char *string = "abcd";
char string[] = "abcd";
// 数组长度要包含最后的 '\0'
char string[5] = "abcd";

// 不能通过字符串指针来修改字符串
char *string = "abcd";
sring[0] = 'z';  // 错误

// 但是通过数组可以修改字符串中字符
char string[] = {'a', 'b', 'c', 'd', '\0'};
string[0] = 'z';

转义字符：

1. 特殊转义字符： \n \' \" \\ \a \b \f \r \t \v \?
2. 数值转义字符： \1, \123, \x4D, \u2620, \U00002620

#include <stdio.h>
#include <threads.h>

int main(void)
{
	printf("Use \\n for newline\n");  // Use \n for newline
	printf("Say \"hello\"!\n");       // Say "hello"!
	printf("%c\n", '\'');             // '

	for (int i = 10; i >= 0; i--) {
		printf("\rT minus %d second%s... \b", i, i != 1? "s": "");
		fflush(stdout);  // Force output to update
		thrd_sleep(&(struct timespec){.tv_sec=1}, NULL);
	}

	printf("\rLiftoff!             \n");
}

// \123（1-3 位八进制数，如 \0）
// \x4D（必须是2位）
// \u2620 （必须是4位）
// \U0001243F （必须是8位）
printf("A\102C\n");  // 102 is `B` in ASCII/UTF-8
printf("\xE2\x80\xA2 Bullet 1\n");
printf("\xE2\x80\xA2 Bullet 2\n");
printf("\xE2\x80\xA2 Bullet 3\n");

空白字符（空格、\t、换行）分割的字符串会被 自动连接 ，从而支持超长字符串换行。

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

int main(void)
{
	char s[] = "Hello, world!";
	char t[100];
	strcpy(t, s); // 需要确保 t 空间要足够容纳 s

	t[0] = 'z';

	printf("%s\n", s);  // "Hello, world!"
	printf("%s\n", t);  // "zello, world!"

3.5 指针

#

指针是针对于单个标识符的，所以建议 * 和标识符连在一起：

int *foo, *bar;
int *baz, quux; // baz 为指针，quux 为 int

char *name; // name 为指针类型
char *args[4]; // args 为数组类型：4 个元素的数组类型，元素类型为 chart *
char (*args)[4]; // args 为指针类型：指向包含 4 个 char 元素的数组

// max 为函数指针变量，只能指向签名为 int (int, int) 的函数
int (*max)(int, int);

// max 为函数指针类型：定义签名为 int (int, int) 的函数类型
typedef int (*max)(int, int);

对于数组 int a[2] ：

• a： 数组 a 元素的首地址，做右值时地址，类型为 int *a ;
• &a：指向一个 2 个 int 型数组的指针，类型为 int (*a)[2] ；
• a[i]：等效为 *(a+i) ，即加偏移后再解引用；

a[b] 等效为 *(a + b)，a 和 b 都可以是表达式，所以更准确的形式：(*((a) + (b)))

NULL 指针 ：C 和操作系统保证 NULL 指针对应的地址 0 永远不可能是有效的地址，所以返回指针的程序都使用特殊的 NULL 指针来表示程序出错。下面几个值是等效的：

• NULL
• 0
• ‘\0’
• (void *)0

int *x;
if ((x = malloc(sizeof(int) * 10)) == NULL) {
	printf("Error allocating 10 ints\n");
}

指针间的转换：安全的转换规则如下：

1. 任意指针类型值转换为 stdint.h 中定义的 intptr_t 或 uintptr_t ，这两个类型可以在转为整型；
2. 从 void * 转换，或转换为 void *
3. 从 char * 转换，或转换为 char * (或 signed char *, unsigned chart *)
4. struct 的指针转换为它的第一个成员的指针，或反之；

指针变量保存的是内存地址，也是一个整型值（对于 I32LP64 系统，int/float 是 32 位， double、long 和 pointer 都是 64 位）。所以，可以使用强制类型转换将一个整型字面量值类型转换为指针：

int *foo = (int *)(0x11111111);
// 常见的场景是宏定义：先将 0 转换为 void *, 然后再转换为任意类型指针, 再转换为
// intptr_t 值,再将 intptr_t 值转换为任意整型.
#define OFFSETOF(type, member) ((int)(intptr_t)&(((type *)(void*)0)->member) )

如果将类型 A 指针转换为另一个类型 B 指针，则 A 和 B 类型需要兼容 ，称为 strict aliasing (如通过 typedef 定义的 alias 就满足兼容性要求)。否则编译时 告警（非错误） 。

• A 必须是指针类型，所以上面的整型强制转换为指针不受该规则约束。

// OK
int a = 1;
int *p = &a;

// OK: 任意类型可以转换为 void * 指针，void * 指针也可以转换为任意类型指针
int ap = (int *)(void *) 0x12345678;

// 非兼容，告警
int a = 1;
float *p = (float *)&a;

// 非兼容，告警
int a = 0x12345678;
short b = *((short *)&a);

int main(void)
{
	int32_t v = 0x12345678;
	struct words *pw = (struct words *)&v;  // 非兼容，告警
	fun(&v, pw);
}

指针运算：指针指向的值类型大小决定了指针运算的地址递进大小

1. 减法：不是地址值直接相减的结果，而是 中间包含的元素数量 ，指针相减后的类型为 <stddef.h> 中定义的 ptrdiff_t ，使用 %td 或 %tX 打印；(类似的 size_t 使用 %zd 或 %zX 来打印);
2. 加法： p++; p+=n; 的结果 p 是在原来 p 值的基础上增加 n * sizeof(*p) ;

int cats[100];
// 数组名作为右值是代表指针, 故 cats + 20 表示第 20 个元素的地址
int *f = cats + 20;
int *g = cats + 60;
// 40, 即相差 40 个 int 元素
ptrdiff_t d = g - f;

int my_strlen(char *s) {
	char *p = s;
	while (*p != '\0')
		p++;
	return p - s;
}

// 使用使用前缀 t 来打印 ptrdiff_t 类型：
printf("%td\n", d);  // Print decimal: 40
printf("%tX\n", d);  // Print hex:     28


int a[] = {11, 22, 33, 44, 55, 999};
int *p = &a[0];
while (*p != 999) {
	printf("%d\n", *p);
	p++;
}

指针比较：

1. 指向 同一个数组或对象的不同位置 ，是可比较的。指向不同对象或数组时，比较结果未定义。
2. 比较 不同类型的指针 时会提示警告（非错误），除非它们都转换为 void * 类型。

int arr[5] = {1, 2, 3, 4, 5};
int *p1 = &arr[1];
int *p2 = &arr[3];
if (p1 < p2) {
	// OK：p1 和 p2 指向同一个数组的不同位置
}

int x = 10;
int y = 20;
int *p3 = &x;
int *p4 = &y;
if (p3 == p4) {
	// 警告，但结果未定义：p3 和 p4 指向不同的对象
}

int *p1;
float *p2;
if (p1 == p2) {
	// 警告：不能直接比较不同类型的指针
}

if ((void*)p1 == (void*)p2) {
	// OK：将指针转换为 void* 后可以进行比较
}

// ({xx}): GNU 扩展的语句表达式语法。
// &_max1 == &_max2: 用来检测两个地址比较是否 OK，如果不 OK，编译器会给出告警：
// warning：comparison of distinct pointer types lacks a cast
// (void) (&_max1 == &_max2); 前的 void 用来消除未使用的表达式结果告警。
#define max(x, y) ({				\
	typeof(x) _max1 = (x);			\
	typeof(y) _max2 = (y);			\
	(void) (&_max1 == &_max2);      \
_max1 > _max2 ? _max1 : _max2; })