C 语言-个人参考手册

gcc -std=c11 -pedantic foo.c
gcc -Wall -Wextra -std=c2x -pedantic foo.c

#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;
	}
	for (int i = 0; i < n; 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;
}

#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. 0 长数组（可变长数组）；
struct line {
  int length;
  char contents[0];
};
struct line *thisline = (struct line *)malloc (sizeof (struct line) + this_length);
thisline->length = this_length;

// 2. 变长数组，数组长度可以是变量或表达式，而非常量值；
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);
}

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

// 组合字面量（非 GNU C 扩展，只运行在声明变量时使用字面量来初始化）
struct foo {int a; char b[2];} structure;

// Here is an example of constructing a struct foo with a compound literal:
structure = ((struct foo) {x + y, 'a', 0});

// This is equivalent to writing the following:
{
  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 值会被求值一次

__attribute__ ((access (read_only, 1)))
int puts (const char*)

void f () __attribute__ ((weak, alias ("__f")));

void* my_memalign (size_t, size_t) __attribute__ ((alloc_align (1)));

#define StrongAlias(TargetFunc, AliasDecl) \
  extern __typeof__ (TargetFunc) AliasDecl \
  __attribute__ ((alias (#TargetFunc), copy (TargetFunc)));

extern __attribute__ ((alloc_size (1), malloc, nothrow))
void* allocate (size_t);
StrongAlias (allocate, alloc);

int old_fn () __attribute__ ((deprecated));

void fatal () __attribute__ ((noreturn));

int var_target;
extern int __attribute__ ((alias ("var_target"))) var_alias;

int x __attribute__ ((aligned (16))) = 0;

struct foo { int x[2] __attribute__ ((aligned (8))); };

struct __attribute__ ((aligned (16))) foo
{
	int i1;
	int i2;
	unsigned long long x __attribute__ ((warn_if_not_aligned (16)));
};


struct foo
{
	char a;
	int x[2] __attribute__ ((packed));
};


struct duart a __attribute__ ((section ("DUART_A"))) = { 0 };
struct duart b __attribute__ ((section ("DUART_B"))) = { 0 };
char stack[10000] __attribute__ ((section ("STACK"))) = { 0 };
int init_data __attribute__ ((section ("INITDATA")));

struct __attribute__ ((aligned (8))) S { short f[3]; };
typedef int more_aligned_int __attribute__ ((aligned (8)));

struct __attribute__ ((aligned)) S { short f[3]; };

typedef int T1 __attribute__ ((deprecated));
T1 x;
typedef T1 T2;
T2 y;
typedef T1 T3 __attribute__ ((deprecated));
T3 z __attribute__ ((deprecated));

struct my_unpacked_struct
{
	char c;
	int i;
};
struct __attribute__ ((__packed__)) my_packed_struct
{
	char c;
	int i;
	struct my_unpacked_struct s;
};

[[gnu::always_inline]] [[gnu::hot]] [[gnu::const]] [[nodiscard]]
inline int f(); // declare f with four attributes

[[noreturn]] void f()
{
	// Some code that does not return
	// back the control to the caller
	// In this case the function returns
	// back to the caller without a value
	// This is the reason why the
	// warning "noreturn' function does return' arises
}

[[deprecated("Reason for deprecation")]]

// For Class/Struct/Union
struct [[deprecated]] S;

// For Functions
[[deprecated]] void f();

// For namespaces
namespace [[deprecated]] ns{}

// For variables (including static data members)
[[deprecated]] int x;

// Set debug mode in compiler or 'R'
[[maybe_unused]] char mg_brk = 'D';


void process_alert(Alert alert)
{
	switch (alert) {
	case Alert::Red:
		evacuate();
		// Compiler emits a warning here
		// thinking it is done by mistake

	case Alert::Orange:
		trigger_alarm();
		// this attribute needs semicolon
		[[fallthrough]];
		// Warning suppressed by [[fallthrough]]
	case Alert::Yellow:
		record_alert();
		return;
	case Alert::Green:
		return;
	}
}

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");

#include <stdio.h>

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

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

#include <stdio.h>

struct MyStruct {
	int a;
	float b;
};

int main() {
	int val1 = 10;
	float val2 = 3.14;


	// 使用大括号初始化，只能使用常量表达式
	struct MyStruct myStruct1 = {.a = 1, .b = 0.1};
	// myStruct1 = {.a = 1, .b = 0.1}; // 错误

	// 使用复合字面量初始化，可以使用变量
	struct MyStruct myStruct2 = (struct MyStruct){ .a = val1, .b = val2 };
	// 赋值，OK
	myStruct2 = (struct MyStruct){ .a = val1, .b = 4.5 };

	// 打印结构体成员
	printf("a: %d, b: %.2f\n", myStruct.a, myStruct.b);

	int *p = (int []){1 ,2 ,3 ,4};
	printf("%d\n", p[1]);  // 2
	return 0;
}

// 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

// These two lines are equivalent:
long long int x;
long long x;

// And so are these:
short int x;
short x;

int a = 0x1A2B;   // Hexadecimal
int b = 0x1a2b;   // Case doesn't matter for hex digits
printf("%x", a);  // Print a hex number, "1a2b"

int a = 012;
printf("%o\n", a);  // Print an octal number, "12"

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           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

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!
}

#ifndef __STDBOOL_H
#define __STDBOOL_H

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

#endif /* __STDBOOL_H */

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)

// Again, these work only with constant integer values.
//For example, we can use one of these to assign constant values like so:

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

#include <stdio.h>

int main(void)
{
	int i;
	float f[4];  // Declare an array of 4 floats
	f[0] = 3.14159;  // Indexing starts at 0, of course.
	f[1] = 1.41421;
	f[2] = 1.61803;
	f[3] = 2.71828;
	// Print them all out:
	for (i = 0; i < 4; i++) {
		printf("%f\n", f[i]);
	}
}

// 全量初始化
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] = {}; // 错误，必须至少指定一个元素的值。

// 指定 index 初始化
int my_array[5] = { [2] 5, [4] 9 };
int my_array[5] = { [2] = 5, [4] = 9 }; // 建议

// GNU 扩展：指定 index range 初始化
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} };
struct point point_array [3] = { {2}, {4, 5}, {6, 7} };
struct point point_array [3] = { [0]={2}, [1]={4, 5}, [2]={6, 7}};
struct point point_array [3];
point_array[0].x = 2;
point_array[0].y = 3;

int
my_function (int number)
{
  int my_array[number];
  …;
}

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 做右值是指针，两者类型不匹配。

#include <stdio.h>

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

#include <stdio.h>
void double_array(int *a, int len)
{
	// Multiply each element by 2
	// This doubles the values in x in main() since x and a both point
	// to the same array in memory!

	for (int i = 0; i < len; i++)
		a[i] *= 2;
}

int main(void)
{
	int x[5] = {1, 2, 3, 4, 5};
	double_array(x, 5); // 传递数组的同时，传递数组的长度。
	for (int i = 0; i < 5; i++)
		printf("%d\n", x[i]);  // 2, 4, 6, 8, 10!
}

int array[10]
int *ptr = array
// array = arrayB // 错误，数组名不能用作左值。
// array[0] == *ptr
// array[N] == *(ptr+N)
// ptr == array == &array[0]

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

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

#include <stdio.h>

void print_2D_array(int a[2][3]) // 或者 int a[][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);
}

#include <stdio.h>

int main(void)
{
    int a[5] = {11, 22, 33, 44, 55};
    int *p;

    p = &a[0];  // p points to the array
                // Well, to the first element, actually
    // 等效为
    p = a;

    printf("%d\n", *p);  // Prints "11"
}

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

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

// 多维数组字面量初始化, 每一维都是一级 {}
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};

int x[12];  // 12 ints

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

printf("%zu\n", sizeof x / sizeof(int));  // 48/4 = 12 ints!

// x 为指针类型
void foo(int x[12])
{
	printf("%zu\n", sizeof x);     // 8?! What happened to 48?
	printf("%zu\n", sizeof(int));  // 4 bytes per int

	printf("%zu\n", sizeof x / sizeof(int));  // 8/4 = 2 ints?? WRONG.
}

#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);

	int v[n]; // 可变长数组, 数组长度可以是个变量, 可实现栈上内存分配(类似于堆上内存分配的 malloc)
	// 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]) // OK: block scope/auto duration pointer to VLA
{
	typedef int VLA[m][m]; // OK: block scope VLA
	int D[m];              // OK: block scope/auto duration VLA

//  static int E[m]; // Error: static duration VLA
//  extern int F[m]; // Error: VLA with linkage

	int (*s)[m];     // OK: block scope/auto duration VM
	s = malloc(m * sizeof(int)); // OK: s points to VLA in allocated storage
//  extern int (*r)[m]; // Error: VM with linkage
	static int (*q)[m] = &B; // OK: block scope/static duration VM}
}

// 对于使用 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 是一个指针变量类型而非数组.
}

#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.
}

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
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];
	}
}

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

char *string = "abcd";
sring[0] = 'z';  // BAD NEWS: tried to mutate a string literal!

char string[] = {'a', 'b', 'c', 'd', '\0'};
string[0] = 'z'; //  No problem

// 初始化字符串数组后，不能再用字符串字面量来修改该数组
char lemon[26] = "custard";
lemon = "steak sauce";      /* Fails! */

#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

		// Sleep for 1 second
		thrd_sleep(&(struct timespec){.tv_sec=1}, NULL);
	}

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

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");

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

int main(void)
{
	char s[] = "Hello, world!";
	char t[100];  // Each char is one byte, so plenty of room

	// This makes a copy of the string!
	strcpy(t, s); // t 空间要足够大

	// We modify t
	t[0] = 'z';

	// And s remains unaffected because it's a different string
	printf("%s\n", s);  // "Hello, world!"

	// But t has been changed
	printf("%s\n", t);  // "zello, world!"

int *foo, *bar;  /* Two pointers. */
int *baz, quux;   /* A pointer and an integer variable. */

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);

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

// BAD
int a = 1;
float *p = (float *)&a;

// BAD
int a = 0x12345678;
short b = *((short *)&a);   // Violates strict aliasing

// BAD
#include <stdio.h>
#include <stdint.h>

struct words {
	int16_t v[2];
};

void fun(int32_t *pv, struct words *pw)
{
	for (int i = 0; i < 5; i++) {
		(*pv)++;
		// Print the 32-bit value and the 16-bit values:
		printf("%x, %x-%x\n", *pv, pw->v[1], pw->v[0]);
	}
}

int main(void)
{
	int32_t v = 0x12345678;
	struct words *pw = (struct words *)&v;  // Violates strict aliasing
	fun(&v, pw);
}

int *foo = (int *)(0x11111111)

int cats[100];
int *f = cats + 20;
int *g = cats + 60;
ptrdiff_t d = g - f;  // difference is 40

#include <stdio.h>

int my_strlen(char *s)
{
	// Start scanning from the beginning of the string
	char *p = s;

	// Scan until we find the NUL character
	while (*p != '\0')
		p++;

	// Return the difference in pointers
	return p - s;
}

int main(void)
{
	printf("%d\n", my_strlen("Hello, world!"));  // Prints "13"
}

// 可以使用使用前缀 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};  // Add 999 here as a sentinel
int *p = &a[0];  // p points to the 11
while (*p != 999) {       // While the thing p points to isn't 999
	printf("%d\n", *p);   // Print it
	p++;                  // Move p to point to the next int!
}

int arr[5] = {1, 2, 3, 4, 5};
int *p1 = &arr[1];
int *p2 = &arr[3];
if (p1 < p2) {
    // 合法：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) {
    // 合法：将指针转换为 void* 后进行比较
}

int modify(int **p)
{
	static int *state = (int *)0x88f9;
	*p = state; // 修改一级指针的值
	return *p
		}

int caller()
{
	int *p = NULL;
	modify(&p); // 在 modify 函数内修改指针 p 的值
}

const float pi = 3.14159f;

char a[] = "abcd";
const char *p = a;
p++;  // p 可以修改；
p[0] = 'A'; // Compiler error! Can't change what it points to

int *const p;   // We can't modify "p" with pointer arithmetic
p++;  // Compiler error!


int x = 10;
int *const p = &x;
*p = 20;   // Set "x" to 20, no problem

char **p;
p++;     // OK!
(*p)++;  // OK!

char **const p;
p++;     // Error!
(*p)++;  // OK!

char *const *p;
p++;     // OK!
(*p)++;  // Error!

char *const *const p;
p++;     // Error!
(*p)++;  // Error!