开篇废话：
本文意在回顾 C 语言中的关键字，整理文件发现当时做的这些笔记还是蛮用心的，有临摹
前辈的足迹也有自己的理解和体会。时至今日2018已经跨过一半，对不起过去半年，今天
拿这篇关键字开篇，开启自己的程序猿心路，主要记录一下自己遇到的问题和学习的经历，
方便自己。如果能对别也有用那就更开心了，由于自己还很菜，理解和体会都很有限，如
果你打开发现了错误还请不吝赐教，随便评论，不要客气，我都会很感激的。首篇废话就
这么多吧，我可能废话比较多，哈哈，批评我吧~
C 关键字
/** * 到目前C语言中有32+5+7=44个关键字，具体如下： * * ->C89关键字 * * char short int unsigned * long float double struct * union void enum signed * const volatile typedef auto * register static extern break * case continue default do * else for goto if * return switch while sizeof * * ->C99新增关键字 * * _Bool _Complex[复杂的] _Imaginary[虚构的] inline restrict[限定/约束] * * * ->C11新增关键字 * * _Alignas Alignof _Atomic _Generic * _Noreturn _Static_assert _Thread_local * **/
C89 32个关键字解释
/*
1) char
解释：
声明变量的时候用，char 占1个字节8bit,多数系统上是有符号的(arm 上无符号)
范围 [-128, 127]
在工程项目中开发推荐用
int8_t -> singned char
uint8_t -> unsigned char
*/
char c = 'p';
/*
2) short
解释：
声明变量的时候用，short占2个字节，为无符号的，默认自带signed
范围[-2^15, 2^15-1]2^15 = 32800
推荐使用 int16_t or uint16_t 类型
*/
short port = 8080;
/*
3) int
解释：
声明变量的时候用，int声明的变量占4个字节，有符号，范围[-2^31,2^31-1]2^31
推荐使用：int32_t or uint32_t 类型开发，方便移植
*/
int i = 0;
/*
4) unsigned
解释：
变量类型修饰符，被修饰的变量就是无符号的，范围>=0,unsigned 只能修饰整型的变量
当然你用这个修饰变量的时候，再使用++和--运算的时候一定要小心。
*/
unsigned int i = 0; //正确
unsigned short s = 0; //正确
unsigned float f = 0.11f; //错误
/*
5) long
解释：
声明变量的时候使用，长整型x86上4个字节,x64上8个字节，一定不比int字节数少
c99之后出现long long 类型为8个字节
*/
long l = 4;
long long ll = 8;
/*
6) float
解释：
声明变量的时候用，4个字节，精度是6-7位，
详细精度可以看：https://blog.csdn.net/dxy612/article/details/5518477
*/
float f = -0.12f;
/*
7) double
解释：
声明变量的时候用，8个字节，精度在15-16位左右，有的时候压缩内存用float代替
*/
double d = 2e13;
/*
8) struct
解释：
定义结构体，这个关键字用法很广，是大头。C的重要的思路就是面向过程编程，
撑起面向过程的大头就是结构体。
*/
// 普通结构体
struct node {
int id;
struct node *next;
};
struct node n = {1,NULL};
// 匿名结构体
struct {
int id;
char* name;
} per = {2,"Tom"};
/*
9) union
解释：
定义共用体，用法很花哨，常在特殊库函数封装中用到，技巧很强
*/
// 普通定义
union type {
char c;
int i;
float f;
};
union type t = {.f = 3.33f};
// 匿名定义
union {...} t = {...};
//类型匿名定义
struct cjson {
struct cjson *next; //采用链表结构处理，放弃二叉树结构，优化内存
unsigned char type; // 数据类型和方式定义，一个美好的愿望
char *key; // json内容那块的key名称
union {
char *vs; // type == _CJSON_STRING, 是一个字符串
double vd; // type == _CJSON_NUMBER, 是一个num值((int)c->vd)转成int或bool
};
};
/*
什么是大小端？
Endian表示数据在存储器中的存放顺序，
大端(Big Endian): 是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的
高地址中，这样的存储模式有点儿类似把数据当做字符串顺序处理：地址由小向大增加，
儿数据从高位往低位。
小端(Little Endian): 是指数据的高字节保存在内存的高地址中，而数据的低字节保存在
内存的低地址中，这种存储模式将地址的高低和数据位权有效的结合起来，高地址部分权值
高，低地址部分权值低，和我们的逻辑方法一致。
这两种模式，泥瓦匠记忆宫殿：“小端低低”。这样就知道小端的模式，反之大端的模式。
https://www.cnblogs.com/Alandre/p/4878841.html
*/
// 在来一种union用法，判断大小端，笔试题中长见
inline bool
sh_isbig(void)
{
static union {
unsigned short s;
unsigned char c;
}U = {1}; // 1 -> 0x0001;
return U.c == 0;
}
/*
10) void
解释：
这个关键字用法很多，也是用在函数声明中，或函数参数
*/
// 函数声明
extern void foo();
// 函数参数约束
extern void foo(void); //函数参数为void表示函数是无参数的，否则是任意的
// 万能类型定义，指针随便转
void* vp = NULL;
/*
11) enum
解释：
枚举类型，C中枚举类型很简陋，相当于一种变相的INT宏常量，估计也许是INT宏
常量和枚举并存的原因
问题1
有些面试题中会问你enum 和#define 的区别：
1. #define 宏常量是在预编译阶段进行简单的替换；enum常量则是在编译的时候确定其值
2. 一般在调试器里，可以调试枚举常量，但不是不能调试宏常量。
3. 枚举可以一次定义大量相关的常量，而#define 宏一次只能定义一个。
问题2
1. 枚举能做的事，#define 宏能不能做到？如果能，那为什么还需要枚举？
答：能，枚举可以自增1，这样不用每一个值都定义，而宏必须每个值都定义，
而枚举是一个集合，代表一类值，像代码中的颜色归为一类方便使用，而#define不能形成集合
2. sizeof(ColorVal)的值是多少？为什么?
enum Color{
GREEN = 1,
RED,
BLUE,
GREEN_RED = 10,
GREEN_BLUE
}ColorVal;
答：值为4，ColorVal一个枚举变量，而枚举变量代表一个整数。
*/
//
// flag_e -全局操作基本行为返回的枚举，用于判断返回值状态的状态码
// >=0 标识Success状态，< 0 标识Error状态
//
// 枚举变量完全可以等同于int变量使用，枚举值等同于宏INT常量使用，枚举的默认值
// 是以1为单位从上向下递增。
//
typedef enum {
Success_Exit =2, //希望存在，设置之前已经存在了
Success_Close =1, //文件描述符读取关闭，读取完毕也返回这个
Success_Base =0, // 结果正确的返回宏
Error_Base =-1, //错误类型，所有错误都用它，在不清楚的情况下
Error_Parm =-2, //调用参数错误
Error_Alloc =-3, //内存分配错误
Error_Fd =-4, //文件打开失败
} flag_e;
/*
12) signed
解释：
变量声明类型修饰符，有符号型，对比unsigned无符号型，变量声明默认基本都是
singned ，所有多数别就省略了
*/
signed int piyo = 0x12345678;
/*
13) const
解释：
const 修饰的变量表示是一个不可修改的量，和常量有点区别，
*/
// 声明不可修改的量
const int age = 24;
// 修饰指针
const int *pa = NULL; //pa指向的值(*pa)是不能修改
int *const pt = NULL; //pt不能指向新的指针，pt指向的值(*pt)可以修改
const int *const pc = NULL; //pc和pc指向的值(*pc)都不能修改
/*
14) volatile
解释：
声明变量修饰符，可变的，当变量前面有这个修饰符，编译器不再从寄存器中取值
直接内存读取写入，保证实时性，常在多线程代码中
*/
// 具体轮询器
struct srl {
mq_t mq; // 消息队列
pthread_t th; // 具体线程
die_f run; // 每个消息都会调用run(pop())
volatile bool loop; // true表示还在继续
};
// 以后再使用loop的时候，其他线程修改，当前线程也能正确的获取它的值
/*
15) typedef
解释：
类型重定义修饰符，重新定义新的类型，给变量去别名
*/
// 声明普通类型
typedef void* list_t;
// 声明不完全类型，头文件中不存在struct tree
typedef struct tree * tree_t;
// 重定义变量类型
typedef unsigned long int ub4; /* unsigned 4-byte quantities*/
typedef unsigned char ub1; /* unsigned 1-byte quantities*/
// 定义一个函数指针
typedef uint32_t (*crc_func)(uint32_t crc, const void *buf, size_t len);
// 使用
crc_func crc32c; //声明一个crc_func类型的变量，实际就是一个函数指针，指向函数的首地址
/*
16) auto
解释：
变量类型声明符，auto变量存放在动态存储区，随和声明周期{开始}，结束而立即释放，存在在栈上
默认变量都是auto的，基本是不写
*/
//演示
{
// 生存期开始
int a = 0;
auto int p = 1;
// 生存期结束
}
/*
17) register
解释：
修饰变量，这个关键字请求编译器尽可能的将变量存放在CPU内部寄存器中而不是通过内存寻址访问
以提高效率，注意是尽可能，不是绝对。
实用register修饰的注意点
虽然寄存器的速度非常快 ，但是实用register修饰符也要些限制的，register变量必须是能被cpu寄存器所能接受的类型
意味着register变量必须是一个单个的值，并且其长度应小于或等于整型的长度，而且register变量
可能不存在在内存中，所以不能用取地址运算符"&"来获取register变量的地址。
*/
#include <limits.h>
register int i = 0;
while (i < INT_MAX) {
++i;
}
/*
18) static
解释：
static用法很广，修饰变量，函数，从字面上看static 很安静，这个关键字在C++
中做了扩展，在C语言中重要就前面提到的两个作用。
1. 修饰变量
变量又分为局部变量和全局变量，但它们都在内存的静态区。
静态全局变量，作用域仅限于变量被定义的文件中，其他文件即使用extern声明也没有办法使用
准确的说：作用域是从定义之处开始，到文件结尾处结束，
静态局部变量：在函数体里面定义的，就只能在这个函数里用了，同一个文档中的其他函数也
用不了，由于被static修饰的变量总是存在内存的静态区，所有即使这个函数运行结束，这个
静态变量的值也不会被销毁，函数下次使用时任然能用这个值。
看下面一段代码:
static int j;
void fun1(void) {
static int i = 0;
i++;
}
void fun2(void) {
j = 0;
j++;
}
int main()
{
int k = 0;
for(k = 0; k < 10; k++) {
fun1();
fun2();
}
return 0;
}
此时i和j的值分别是多少？
我们来分析一下哈：
首先毫无疑问，j 是个全局静态变量，调用一次fun2()后，它的值始终没有变，所有调用10次值还是1
i这个变量是一个局部静态变量，值存放在内存的静态区，调用一次fun1()结束后它的值不会被销毁，
函数下次调用的时候任然使用这个值，所有调用10次它的值一次为，1,2,3,4,5,6,7,8,9,10,11
2. 修饰函数
函数前面加static使得函数成为静态函数，但此处"static"的含义不是指存储方式，而是指对函数作用域
仅局限于本文件(所有称内部函数)使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义
的函数是否会与其他文件中的函数同名。
// C99之后加的static新用法，编译器优化
/ static 只能修饰函数第一维，表示数组最小长度,方便编译器一下取出所有内存进行优化
*/
int sum(int a[static 10]) { ... }
/*
19) extern
解释：
extern (外面的，外来的)可以置于变量或函数前，以表明变量或函数的定义在别的文件中
下面代码用到的这些变量或函数是外来的，不是本文件中定义的，提示连接器遇到此变量
和函数时在其他模块中解析/绑定此标识符。
*/
// 声明引用全局变量
extern int G_arg;
// 声明引用全局函数，（主动声明，希望外部可以调用）
extern int kill(int sig, int val);
// 当然有时候extern不写，对于变量不写会出现重定义，对于函数时可以缺省的
/*
20) break
解释：
结束语句，主要用于循环的跳出，只能跳出到当前层级，也用于switch语句中
跳出swithc嵌套
*/
// 演示 for循环
for(;;) {
// 符合条件跳转
if(n == 10)
break; // 跳出for循环
}
/*
21) 22) 23) switch & case & default
解释：
21)switch ：条件分支语句，很复杂的if else if时候可以用switch
22)case : 语句中分支语句，确定走哪个分支
23)default: switch 分支的默认分支，所有case都没有进入就到default分支
*/
// 演示
switch (errcode) {
case SSL_ERROR_ZERO_RETURN:
/* Possibly a clean shutdown. */
if (SSL_get_shutdown(bev_ssl->ssl) & SSL_RECEIVED_SHUTDOWN)
event = BEV_EVENT_EOF;
else
dirty_shutdown = 1;
break;
case SSL_ERROR_SYSCALL:
/* IO error; possibly a dirty shutdown. */
if ((ret == 0 || ret == -1) && ERR_peek_error() == 0)
dirty_shutdown = 1;
break;
case SSL_ERROR_SSL:
/* Protocol error. */
break;
case SSL_ERROR_WANT_X509_LOOKUP:
/* XXXX handle this. */
break;
case SSL_ERROR_NONE:
case SSL_ERROR_WANT_READ:
case SSL_ERROR_WANT_WRITE:
case SSL_ERROR_WANT_CONNECT:
case SSL_ERROR_WANT_ACCEPT:
default:
/* should be impossible; treat as normal error. */
event_warnx("BUG: Unexpected OpenSSL error code %d", errcode);
break;
}
/*
24) continue
解释：
跳过此次(本轮)循环，直接进行条件判断操作，进入下一轮循环，
for和while循环有些区别，for会执行第三个后面的语句
*/
// 演示
for(int i = 0; i < 20; ++i) {
if(i % 2 == 0)
continue; // 满足if跳到 ++i，再到条件 i<20
}
/*
25) do ... 26) while 27) for
解释:
C 语言中的三种循环
25) do: do循环，先执行循环体，在执行条件判断，先保证循环体执行一遍在判断条件
在一个菜单的程序设计的时候用do...while 比较好，首先给出选择。
26) while: 循环，先判断while后的条件，只有条件真才执行里面的代码块，
常用的还有就是一种死循环的写法 while(1)
27) for: 循环，for循环很容易的控制循环次数，多用于事先知道循环次数的情况下
*/
// 演示
/* do -while 循环 */
do {
event_loop(EVLOOP_ONCE | EVLOOP_NONBLOCK);
xcount++;
} while (count != fired);
/* while 循环 */
while(1) {
if('#' == GetInputChar())
break;
}
/* for 循环 */
for (i = 0; i < 25; i++) {
tv = run_once();
if (tv == NULL)
exit(1);
fprintf(stdout, "%ld\n",
tv->tv_sec * 1000000L + tv->tv_usec);
}
/*
28) if ... 29) else
解释：
28) if: if分支语句，可以单独使用,可嵌套
29) else: else分支，必须和if分支对应，和if分支条件相反
*/
n = recv(fd, (char*)&ch, sizeof(ch), 0);
if (n >= 0)
count += n;
else
failures++;
if (writes) {
if (widx >= num_pipes)
widx -= num_pipes;
n = send(pipes[2 * widx + 1], "e", 1, 0);
if (n != 1)
failures++;
writes--;
fired++;
}
/*
30) goto
解释：
关于goto这个关键字，褒贬很多，原因就在于它太自由，可以灵活的跳转，在结构化
编程中它有了很多争议，如果不加以限制，它的自由跳转的确会破坏结构化设计的风格
所有使用它一定要慎重，下面我们用一段真实代码展示它的魅力，
*/
// 演示
if (evbuffer_expand_fast_(buf, to_alloc, 2) < 0) {
goto done;
}
for (n = 0; n < n_vec; n++) {
/* XXX each 'add' call here does a bunch of setup that's
* obviated by evbuffer_expand_fast_, and some cleanup that we
* would like to do only once. Instead we should just extract
* the part of the code that's needed. */
if (evbuffer_add(buf, vec[n].iov_base, vec[n].iov_len) < 0) {
goto done;
}
res += vec[n].iov_len;
}
done:
EVBUFFER_UNLOCK(buf);
return res;
/*
31) return
解释：
return 用来终止一个函数并返回其后面跟着的值
使用return 不可返回指向“栈内存”的“指针”，因为该内存在函数体结束后就被自动释放了
*/
// 演示
#include <stdio.h>
int main(int arg, char* argv[]) {
......
return EXIT_SUCCESS;
}
/*
32) sizeof
解释：
也称为sizeof运算符，计算变量或类型的字节大小，它常被误认为是个函数
面试中也经常有它出现，下面我们看看它的用法
*/
// 演示 x86上
int *p = NULL;
sizeof(p) 的值是多少 ---> 4
sizeof(*p)呢？ ---> 4
int a[100];
sizeof(a)的值是多少 ---> 400
sizeof(a[100])的值 ---> 4
sizeof(&a)的值 ---> 4
sizeof(&a[0])的值 ---> 4
int b[100];
void func(int b[100]) {
sizeof(b); // sizeof(b)的值 ---> 4
}
// 常用一种写法获取数组长度
#define LEN(arr) (sizeof(arr) / sizeof(*(arr)))
#define LEN(arr) (sizeof(arr) / sizeof(arr[0]))
到此 C89 的32个关键字都就介绍完了，对于 C99 和 C11的关键字，后续完善.....
后记：
《意颓废》
意颓废，人难寐。
夜夜长街空买醉。
路茫茫，断离肠。
梦牵魂索，独守西窗，伤！伤！伤 。
花儿碎，风流泪。
曲悲弦断连心肺。
恋成殇，心透凉。
一朝白头，只为情狂，怆！怆！怆。
