# -Wall： 打印所有警告；
gcc -std=c11 -pedantic foo.c
gcc -Wall -Wextra -std=c2x -pedantic foo.c

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

#include <stdio.h>

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

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

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

char c = '6';
int x = c;  // x 值是 54
int y = c - '0'; // y 值是 6

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

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

int a = 0x1A2B;
int b = 0x1a2b; // 十六进制
int c = 012; // 八进制
int x = 0b101010;  // 二进制
printf("%x", a);
printf("%o\n", c);
printf("%d\n", x);

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

// 示例：
uint16_t x = UINT16_C(12);
intmax_t y = INTMAX_C(3490);

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

// 未初始化，为随机值
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] = {}; // C23 之前不支持，必须至少指定一个元素的值。C23 支持空初始化表达式。

// GNU C 扩展：指定 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} };

// 复合字面量初始化，相比大扩展多了数组类型的类型转换（int[]）
int globalArray[] = (int[]){ 1, 2, 3, 4, 5 };

// 数组作为函数参数类型时等效为指针类型，一维数组的长度被忽略（多维数组参数不能忽略长度）
int foo(const int sz[10]);
// 等效于
int foo(const int sz[]);
// 等效于
int foo(const int *sz);

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

// 等效于 int *arr
void printArray(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] 或 *(sz+N) 访问数组元素
	}
}

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

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

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

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++); // 后缀单目运算符优先级最高
}

int x[12];
printf("%zu\n", sizeof x);     // 48，表达式
printf("%zu\n", sizeof(int));  // 4，类型
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" };

#include <stdio.h>

// 多维数组参数：可以省略一维，但必须指定后续维度的数组长度
void print_2D_array(int a[2][3]) { // 等效为：int a[][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);
}

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

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

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

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

// 多维数组字面量初始化, 每一维都是一级 {}
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},  // 未列出的元素为 0
	{5, 6}
};
/* 1 2 */
/* 3 0 */
/* 5 6 */

int a[3][2] = {
        {1, 2},
        // {3, 4},
        {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 a[3][2] = {}; // 错误：必须指定一个值

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

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

// 编译器扩展的 0 长数组
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 最后一个成员，不指定大小;
struct len_string {
	int length;
	char data[];
};

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

#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]）;
	int v[n * 100];

	// 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 的函数声明, 长度部分可以使用 * 或变量
void foo(size_t x, int a[*]); // 函数声明
void foo(size_t x, int a[x]); // 函数声明

// 函数定义，必须用变量指定长度
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!
	func(b);  // OK!
	func(c);  // Undefined behavior! c is under 4 elements!
}

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

int g(const int a[const 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[] = "abcd";
// 数组长度要包含最后的 '\0'
char string[5] = "abcd";

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

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

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

#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!"

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

int main(void)
{
    char *s = "Hello, world!";

    printf("The string is %zu bytes long.\n", strlen(s));
}

int my_strlen(char *s)
{
    int count = 0;

    while (s[count] != '\0')  // Single quotes for single char
        count++;

    return count;
}

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

    // 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;
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 *x;
if ((x = malloc(sizeof(int) * 10)) == NULL) {
	printf("Error allocating 10 ints\n");
}

#include <stdio.h>

int main(void)
{
    int i = 10;

    printf("The value of i is %d\n", i);

    // 将指针转换为 void * 来比慢编译器警告。
    printf("And its address is %p\n", (void *)&i);
}

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

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

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

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

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

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

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!

const int x = 20;
int *p = &x;
//    ^       ^
//    |       |
//  int*    const int*

// initialization discards 'const' qualifier from pointer type target

*p = 40;  // 未定义行为

// s1 和 s2 可以是任意类型的指针
void *memcpy(void *s1, void *s2, size_t n);
void *my_memcpy(void *dest, void *src, int byte_count)
{
	// 使用 src 和 dest 前，需要转换为具体类型的指针
	char *s = src, *d = dest;
	while (byte_count--) {
		*d++ = *s++;
	}
	return dest;
}

struct animal {
	char *name;
	int leg_count;
};

// malloc() 返回的是 void * 类型指针，需要转为为具体类型指针
int *p = malloc(sizeof(int));
*p = 12;
printf("%d\n", *p);  // 12
free(p);

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

atomic_int x;

int thread1(void *arg)
{
	// 函数体内未使用 arg 变量，可以转换为 void 类型来避免编译告警。
	(void)arg;
}

struct point
{
	int x, y;
} first_point, second_point;

struct point
{
	int x, y;
};

// struct 关键字不可少，可以使用 typedef 简化。
struct point first_point, second_point;

struct point
{
	int x, y;
};

struct point
{
	int x, y;
} first_point = { 5, 10 };

// 全量初始化
struct point first_point = { 5, 10 };

// 部分成员初始化，未初始化的成员为 0
struct point first_point = { 5 };

// 指定成员初始化，未初始化的成员为 0
struct point first_point = { .y = 10, .x = 5 };

struct point first_point = { y: 10, x: 5 };

struct rectangle
{
	struct point top_left, bottom_right;
};

// 大括号初始化
struct rectangle my_rectangle = { {0, 5}, {10, 0} };

// 指定初始化
struct spaceship s = {
        .manufacturer="General Products",
        .ci={
          .window_count = 8,
          .o2level = 21
        }
};

// 嵌套初始化
struct cabin_information {
	int window_count;
	int o2level;
};

struct spaceship {
	char *manufacturer;
	struct cabin_information ci;
};

int main(void)
{
	struct spaceship s = {
		.manufacturer="General Products",
		// 嵌套初始化
		.ci.window_count = 8,
		.ci.o2level = 21
	};

	printf("%s: %d seats, %d%% oxygen\n", s.manufacturer, s.ci.window_count, s.ci.o2level);
}

#include <stdio.h>

struct passenger {
	char *name;
	int covid_vaccinated;
};

#define MAX_PASSENGERS 8

struct spaceship {
	char *manufacturer;
  // 常量宏是编译期常量，可以作为数组的长度
	struct passenger passenger[MAX_PASSENGERS];
};

int main(void) {
	struct spaceship s = {
		.manufacturer="General Products",
		.passenger = {
			// 一次初始化一个成员
			[0].name = "Gridley, Lewis",
			[0].covid_vaccinated = 0,
			// 一次初始化所有成员
			[7] = {.name="Brown, Teela", .covid_vaccinated=1},
		}
	};
	printf("Passengers for %s ship:\n", s.manufacturer);

	for (int i = 0; i < MAX_PASSENGERS; i++)
		if (s.passenger[i].name != NULL)
			printf("    %s (%svaccinated)\n", s.passenger[i].name, s.passenger[i].covid_vaccinated? "": "not ");
}

// 匿名 struct 也代表一个类型，可以定义对应变量
struct {
	char *name;
	int leg_count, speed;
} a, b, c;

// 以下是赋值而非初始化，c.speed 的值是未知的。
a.name = "antelope";
c.leg_count = 4;

// 两种类型名都 OK
typedef struct animal {
	char *name;
	int leg_count, speed;
} animal;

struct animal y;
animal z;

// 只能使用 animal 类型
typedef struct {
	char *name;
	int leg_count, speed;
} animal;

//struct animal y;  // 错误
animal z;           // OK

void set_price(struct car *c, float new_price) {
	(*c).price = new_price;
}

// 同类型 struct 值之间可以赋值
struct car a, b;
b = a;

#include <stdio.h>

struct person {
	char *name;
	char gender;
	int age;
	int weight;

	// 匿名成员
	struct {
		int area_code;
		long phone_number;
	};
};

int main(void) {
	struct person p = {"jim", 'F', 28, 65, {21, 444444}};
	printf("%d\n", p.area_code);
	return 0;
}

// 匿名 union 成员
struct person {
	char *name;
	union {
		char gender;
		int id;
	};
	int age;
};

int main(void) {
	struct person jim = {"jim", 'F', 20};
	printf("jim.gender = %c, jim.id = %d\n", jim.gender, jim.id);
	return 0;
}

// 更复杂的情况
struct v
{
	union {
		struct { int i, j; };
		struct { long k, l; } w;
	};
	int m;
} v1;

v1.i = 2;   // valid
v1.k = 3;   // invalid: inner structure is not anonymous
v1.w.k = 5; // valid

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

struct node {
	int data;
	struct node *next; // 指针 OK，但不能是 struct node next;
};

int main(void)
{
	struct node *head;

	head = malloc(sizeof(struct node));
	head->data = 11;
	head->next = malloc(sizeof(struct node));
	head->next->data = 22;
	head->next->next = malloc(sizeof(struct node));
	head->next->next->data = 33;
	head->next->next->next = NULL;

	for (struct node *cur = head; cur != NULL; cur = cur->next) {
		printf("%d\n", cur->data);
	}
}

#include <stdio.h>

struct parent {
	int a, b;
};

struct child {
	struct parent super;  // MUST be first
	int c, d;
};

// Making the argument `void*` so we can pass any type into it (namely a struct parent or struct child)
void print_parent(void *p)
{
	// Expects a struct parent--but a struct child will also work because the pointer points to the struct parent in the first field:
	struct parent *self = p;

	printf("Parent: %d, %d\n", self->a, self->b);
}

void print_child(struct child *self)
{
	printf("Child: %d, %d\n", self->c, self->d);
}

int main(void)
{
	struct child c = {.super.a=1, .super.b=2, .c=3, .d=4};

	print_child(&c);
	print_parent(&c);  // Also works even though it's a struct child!
}

struct Example {
    char a;    // 1 字节
    int b;     // 4 字节
    short c;   // 2 字节
};

Offset  Member   Size
0       a        1
1-3     padding  3
4       b        4
8-9     c        2
10-11   padding  2

// 设置对齐方式为 1 字节边界
#pragma pack(push, 1)
struct PackedExample {
 	char a;
 	int b;
 	short c;
};
  // 恢复默认对齐方式
#pragma pack(pop)

Offset  Member   Size
0       a        1
1-4     b        4
5-6     c        2

struct PackedExample {
    char a;
    int b;
    short c;
} __attribute__((packed));

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

char c1 = 3;
char c2 __attribute__((aligned(16))) = 4 ;

int main(void)
{
 	printf("c1: %p\n", &c1);
 	printf("c2: %p\n", &c2);
 	return 0;
}

/* c1: 00402000 */
/* c2: 00402010 */

struct data {
 	char a;
 	short b __attribute__((aligned(4)));
 	int c ;
};

/* size: 12 */
/* &s.a: 0028FF30 */
/* &s.b: 0028FF34 */
/* &s.c: 0028FF38 */

struct data{
 	char a;
 	short b ;
 	int c ;
} __attribute__((packed,aligned(8)));

int main(void)
{
 	struct data s;
 	printf("size: %d\n", sizeof(s));
 	printf("&s.a: %p\n", &s.a);
 	printf("&s.b: %p\n", &s.b);
 	printf("&s.c: %p\n", &s.c);
}

/* size: 8 */
/*  &s.a: 0028FF30 */
/*  &s.b: 0028FF31 */
/*  &s.c: 0028FF33 */

// 按指定类型大小对齐
char alignas(int) c;

// 按指定大小（或常量表达式）值对齐
char alignas(8) c;

// 使用 <stddef.h> 中指定的类型最大对齐方式
char alignas(max_align_t) c;

#include <stdalign.h>
#include <stdio.h>

// every object of type struct sse_t will be aligned to 16-byte boundary
struct sse_t
{
 	alignas(16) float sse_data[4];
};

// every object of type struct data will be aligned to 128-byte boundary
struct data
{
 	char x;
 	alignas(128) char cacheline[128]; // over-aligned array of char, not array of over-aligned chars
};

int main(void)
{

 	printf("sizeof(data) = %zu (1 byte + 127 bytes padding + 128-byte array)\n", sizeof(struct data));
 	printf("alignment of sse_t is %zu\n", alignof(struct sse_t));

 	alignas(2048) struct data d; // this instance of data is aligned even stricter
 	(void)d; // suppresses "maybe unused" warning
}

#include <stdalign.h>
#include <stdio.h>

// every object of type struct sse_t will be aligned to 16-byte boundary (note: needs support for DR 444)
struct sse_t
{
    alignas(16) float sse_data[4];
};

// every object of type struct data will be aligned to 128-byte boundary
struct data
{
    char x;
    alignas(128) char cacheline[128]; // over-aligned array of char, not array of over-aligned chars
};

int main(void)
{
    printf("sizeof(data) = %zu (1 byte + 127 bytes padding + 128-byte array)\n", sizeof(struct data));

    printf("alignment of sse_t is %zu\n", alignof(struct sse_t));

    alignas(2048) struct data d; // this instance of data is aligned even stricter
    (void)d; // suppresses "maybe unused" warning
}

/* sizeof(data) = 256 (1 byte + 127 bytes padding + 128-byte array) */
/* alignment of sse_t is 16 */

#include <stdalign.h>
#include <stdio.h>     // for printf()
#include <stddef.h>    // for max_align_t

struct t {
 	int a;
 	char b;
 	float c;
};

int main(void)
{
 	printf("char       : %zu\n", alignof(char));
 	printf("short      : %zu\n", alignof(short));
 	printf("int        : %zu\n", alignof(int));
 	printf("long       : %zu\n", alignof(long));
 	printf("long long  : %zu\n", alignof(long long));
 	printf("double     : %zu\n", alignof(double));
 	printf("long double: %zu\n", alignof(long double));
 	printf("struct t   : %zu\n", alignof(struct t));
 	printf("max_align_t: %zu\n", alignof(max_align_t));
}

char       : 1
short      : 2
int        : 4
long       : 8
long long  : 8
double     : 8
long double: 16
struct t   : 16
max_align_t: 16

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

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

#include <stdio.h>
#include <stddef.h>

struct foo {
 	int a;
 	char b;
 	int c;
 	char d;
};

int main(void)
{
  // 返回 size_t 类型，使用 %zu 打印
 	printf("%zu\n", offsetof(struct foo, a)); // 0
 	printf("%zu\n", offsetof(struct foo, b)); // 4
 	printf("%zu\n", offsetof(struct foo, c)); // 8
 	printf("%zu\n", offsetof(struct foo, d));// 12
}

struct card
{
 	unsigned int suit : 2; // 可以赋值：0-3
 	unsigned int face_value : 4; // 可以赋值：0-15
};

// sizeof(struct foo) == 12，a 和 c 会合并到一个 int 的 4 Byte 中
struct foo {
 	unsigned int a:1;
 	unsigned int c:1;
 	unsigned int b;
 	unsigned int d;
};

// sizeof(struct foo) == 16
struct foo {
 	unsigned int a:1;   // a 和 b 不会被合并，为了确保 b 对齐，a 和 b 之间插入 3 Byte padding。
 	unsigned int b;
 	unsigned int c:1;
 	unsigned int d;
};

struct foo {
 	unsigned char a:2;
 	unsigned char :5;   // <-- unnamed bit-field!
 	unsigned char b:1;
};

struct foo { // a 和 b 使用一个 int，c 和 d 使用另一个 int
 	unsigned int a:1;
 	unsigned int b:2;
 	unsigned int :0;   // <--Zero-width unnamed bit-field
 	unsigned int c:3;
 	unsigned int d:4;
};

union numbers
{
	int i;
	float f;
} first_number, second_number;

union numbers first_number, second_number;

union numbers
{
	int i;
	float f;
};
union numbers first_number = { 5 }; // 初始化第一个成员
union numbers first_number = { f: 3.14159 }; // 初始化指定成员
union numbers first_number = { .f = 3.14159 }; // 建议的方式

union numbers
{
	int i;
	float f;
} first_number = { 5 };

union numbers
{
	int i;
	float f;
};
union numbers first_number;
first_number.i = 5;
first_number.f = 3.9;

union numbers *second_number =&first_number;
second_number->i = 6;

// This size of a union is equal to the size of its largest member. Consider the first union example from this section:
union numbers
{
	int i;
	float f;
};

#include <stdio.h>

union foo {
	float b;
	short a;
};

int main(void)
{
	union foo x;
	x.b = 3.14159;
	printf("%f\n", x.b);  // 3.14159, fair enough
	printf("%d\n", x.a);  // But what about this?
}

// 3.141590
// 4048

union foo { int i; double d; };
int x;
double y;
union foo z;

// both x and y can be cast to type union foo and the following assignments
z = (union foo) x;
z = (union foo) y;

// are shorthand equivalents of these
z = (union foo) { .i = x };
z = (union foo) { .d = y };

union numbers
{
	int i;
	float f;
};
union numbers number_array [3] = { {3}, {4}, {5} };

union numbers number_array [3];
number_array[0].i = 2;

struct {
	int x, y;
} s;
s.x = 34;
s.y = 90;
printf("%d %d\n", s.x, s.y);

union foo {
	struct {       // unnamed!
		int x, y;
	} a;

	struct {       // unnamed!
		int z, w;
	} b;
};
union foo f;
f.a.x = 1;
f.a.y = 2;
// 或
f.b.z = 3;
f.b.w = 4;

#include <stdio.h>

// foo 的这些成员共享同一块内存
union foo {
	int a, b, c, d, e, f;
	float g, h;
	char i, j, k, l;
};

int main(void)
{
	union foo x;

	int *foo_int_p = (int *)&x;  // 都指向 x 内存的开始
	float *foo_float_p = (float *)&x;

	x.a = 12;
	printf("%d\n", x.a);           // 12
	printf("%d\n", *foo_int_p);    // 12, again

	x.g = 3.141592;
	printf("%f\n", x.g);           // 3.141592
	printf("%f\n", *foo_float_p);  // 3.141592, again
}

// 反向也 OK
union foo x;
int *foo_int_p = (int *)&x;             // Pointer to int field
union foo *p = (union foo *)foo_int_p;  // Back to pointer to union
p->a = 12;  // This line the same as...
x.a = 12;   // this one.

#include <stdio.h>

struct common {
	int type;   // common initial sequence
};

struct antelope {
	int type;   // common initial sequence

	int loudness;
};

struct octopus {
	int type;   // common initial sequence

	int sea_creature;
	float intelligence;
};

union animal {
	struct common common;
	struct antelope antelope;
	struct octopus octopus;
};

#define ANTELOPE 1
#define OCTOPUS  2

void print_animal(union animal *x)
{
	switch (x->common.type) {
    case ANTELOPE:
  		printf("Antelope: loudness=%d\n", x->antelope.loudness);
  		break;
    case OCTOPUS:
  		printf("Octopus : sea_creature=%d\n", x->octopus.sea_creature);
  		printf("          intelligence=%f\n", x->octopus.intelligence);
  		break;
    default:
      printf("Unknown animal type\n");
	}
}

int main(void)
{
	union animal a = {.antelope.type=ANTELOPE, .antelope.loudness=12};
	union animal b = {.octopus.type=OCTOPUS, .octopus.sea_creature=1, .octopus.intelligence=12.8};

	print_animal(&a);
	print_animal(&b);
}

struct v
{
	union // anonymous union
	{
		struct { int i, j; }; // anonymous structure
		struct { long k, l; } w;
	};

	int m;
} v1;

v1.i = 2;   // valid
v1.k = 3;   // invalid: inner structure is not anonymous
v1.w.k = 5; // valid

#include <stdio.h>

struct foo {
	int x, y;
};

struct foo f(void)
{
	return (struct foo){.x=34, .y=90};
}

int main(void)
{
	struct foo a = f();  // Copy is made
	printf("%d %d\n", a.x, a.y);
}

enum app_status {PENDING, RUNNING, CANCELD, DONE, FAILED}; // 定义枚举类型
enum app_status {PENDING, RUNNING, CANCELD=10, DONE, FAILED}; // DONE=11，FAILED=12，

// 值可以重复
enum {
	X=2,
	Y=2,
	Z=2
};

enum {
	A,    // 0, default starting value
	B,    // 1
	C=4,  // 4, manually set
	D,    // 5
	E,    // 6
	F=3   // 3, manually set
	G,    // 4
	H     // 5
};

// 最后一个成员后面可以加逗号
enum {
	X=2,
	Y=18,
	Z=-2,
};

// 声明枚举类型的同时定义变量
enum resource {
	SHEEP,
	WHEAT,
	WOOD,
	BRICK,
	ORE
} r = BRICK, s = WOOD;

// 匿名 enum
enum {
	SHEEP,
	WHEAT,
	WOOD,
	BRICK,
	ORE
} r = BRICK, s = WOOD;

// 定义枚举类型
enum resource {
	SHEEP,
	WHEAT,
	WOOD,
	BRICK,
	ORE
};

// 声明枚举类型的变量：
enum resource r = BRICK; // 枚举成员名称位于全局作用域，所以可以直接使用。
if (r == BRICK) {
	printf("I'll trade you a brick for two sheep.\n");
}

// 定义枚举类的同时, 定义两个变量值.
enum color { RED, GREEN, BLUE } c = RED, *cp = &c;

// 枚举值可以作为编译时常量使用.
int myarr[WOOD];
enum color { RED, GREEN, BLUE } r = RED;

switch(r)
{
  case RED:
  	puts("red");
  	break;
  case GREEN:
  	puts("green");
  	break;
  case BLUE:
  	puts("blue");
  	break;
}
enum { TEN = 10 };
struct S { int x : TEN; }; // OK

// enum 值可以用于需要整型值的地方
enum { ONE = 1, TWO } e;
long n = ONE; // promotion
double d = ONE; // conversion
e = 1.2; // conversion, e is now ONE
e = e + 1; // e is now TWO

#include <stdio.h>
enum Color {
	RED,
	GREEN,
	BLUE
};
int main() {
	enum Color color = RED;
	int *pColor = &color; // 可以取枚举变量的地址
	// int *pRed = &RED; // 错误：不能取枚举成员的地址

	return 0;
}