前言
C语言为我们提供了丰富的关键字，这些关键字都是语言本身预先设定好的，用户自己是不能创造关键字的，现在先大致了解一下，先来把大致分一下类：
char short int long float double signed unsigned struct enum void union
if else switch case break default while continue for do while goto
typedef auto extern register static const
sizeof return volatile
一、数据类型关键字
(1) char、 short、 int、 long、 float、 double、 signed、 unsigned 等关键字
这几个关键字就不在这做过多介绍了，直接上链接看另一篇文章：C语言常见数据类型
(2) struct 结构体类型
struct表示是一种结构体类型，它由若干个成员组成；结构的每个成员可以是不同类型的变量(也可以是结构体变量)。struct是声明结构体变量的关键字，下面然我们来用用看：
比如说，一本书它有书名、书号、作者、价格等等，那来看下面代码：
//一本书它有书名、书号、作者、价格等
struct Book//struct是关键字，Book是结构体标签
//struct Book是结构体类型
{
//成员列表
char name[20];//书名
char num[20];//书号
char author[20];//作者
double price;//价格
}book1;//分号不能丢
//book1就是在声明类型的同时定义变量，同时也可以初始化
这就是一个简单的结构体的创建，还有别的方法创建结构体：
//匿名结构体类型(现在了解一下就行)
struct//这个结构体在声明的时候省略掉了结构体标签
{
int a;
char b;
float c;
}x;
再来试试结构体中包含一个类型为该结构本身的成员：
struct Node
{
int data;
struct Node* next;
};
接下来再试试写入数据；
#include <stdio.h>
struct Book
{
char name[20];
char num[20];
char author[20];
double price;
};
int main(void)
{
//拿struct Book结构体类型创建了C1这个书(结构体变量)
struct Book C1 = { "C language", "666666", "C语言", 10.5 };//结构体嵌套初始化
struct Book C2 = { "C pointer", "666666", "C指针", 20.6 };
return 0;
}
现在写入了信息，再来打印出来;(下面会用到" & . -> "操作符，可以看看这篇再了解复习一下：操作符详解)
int main(void)
{
struct Book C1 = { "C language", "666666", "C语言", 10.5 };
struct Book C2 = { "C pointer", "666666", "C指针", 20.6 };
//语法格式：结构体 . 成员名
printf("%s %s %s %.2lf\n", C1.name, C1.num, C1.author, C1.price);
printf("%s %s %s %.2lf\n", C2.name, C2.num, C2.author, C2.price);
printf("-----------------------------\n");
//&C1和C2的地址放到pc1和pc2中
struct Book* pc1 = &C1;
struct Book* pc2 = &C2;
//语法格式：结构体指针->成员名
printf("%s %s %s %.2lf\n", pc1->name, pc1->num, pc1->author, pc1->price);
printf("%s %s %s %.2lf\n", pc2->name, pc2->num, pc2->author, pc2->price);
return 0;
}
(3) enum 枚举
enum 就是枚举，枚举顾名思义就是一一列举，把可能的取值一一列举出来，利用关键字 enum 可以声明枚举变量，这也是一种数据类型。使用该类型可以定义枚举型变量，一个枚举变量包含了一组相关的标识符，其中每一个标识符都都对应一个整数值，称为枚举常量。
下面来定义一个简单的枚举类型：
//{}中的内容是枚举类型的可能取值，也叫 枚举常量
enum Day//星期
{
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun
};
//这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值
enum Color//颜色
{
RED = 2,
GREEN = 3,
BLUE = 4
};
(4) void
void 是无类型的意思，有的也叫空类型。常用在程序中对定义函数的参数类型、返回值、函数中指针类型进行声明；
void类型是不同于其他常见类型的，所以 void 类型不能够用来申明变量和常量。因为我们申明变量的时候需要明确告诉编译器，这个变量是什么类型，比如说是 int 类型，这样编译才好为这个变量去分配存储空间，但是你不能告诉编译器说我这是一个"空类型"，这样的话就会报错。
举个例子;
运用于函数参数类型中：
#include <stdio.h>
//我不需要Add函数返回值，所以Add函数的类型定义为void
void Add(int a, int b)
{
printf("%d\n", a + b);
//void是没有返回值的，在void函数里面不能使用return来返回数据
}
int main(void)
{
int a = 0, b = 3;
Add(a, b);//加法
return 0;
}
(5)union 联合体(共用体)
union 也被称为联合体(共用体)，联合体也是一种特殊的自定义类型，这种类型定义的变量也包含一系列的成员；
先来声明定义一个联合体;
#include <stdio.h>
//联合类型的声明
union Un
{
char c;
int i;
};
int main(void)
{
union Un un;//联合变量的定义
printf("%d\n", sizeof(un));//4
printf("%d\n", sizeof(un.c));//1
printf("%d\n", sizeof(un.i));//4
return 0;
}
联合体的特征是联合体的成员是共用同一块内存空间的，这样一个联合体变量的大小，至少是最大成员的大小（因为联合体至少得有能力保存最大的那个成员）
二、分支循环关键字
(1) if … else
先来看看 if 语句，if 语句的语法结构为：
语法结构：
if(表达式)
语句;
然后再看下面代码：
#include <stdio.h>
int main(void)
{
int n = 10;
if (n > 5)//if (表达式)
{
printf("n > 5\n");
}
return 0;
}
在代码中，n等于10所以在 if 的判断条件是为真，所以执行打印；
#include <stdio.h>
int main(void)
{
int x = 0;
if (x > 5)//if (表达式)
{
printf("x > 5\n");
}
return 0;
}
在这个代码中，x等于0.所以 if 语句的判断条件是为假，所以不执行打印；
看到这我们再来看看 if … else 怎么用：
语法结构:
if (表达式)
语句1;
else
语句2;
上实例：
#include <stdio.h>
int main(void)
{
int n = 4;
if (n > 5)
{
printf("n > 5\n");
}
else
{
printf("n < 5\n");
}
return 0;
}
在上述代码中，n等于4，在 if 语句的判断表达式中不成立为假，所以执行了 else 并打印，也可看下图方便理解：
而这是一个 if … else 单分支，也可以多分支喔:
#include <stdio.h>
int main(void)
{
//适当的使用{}可以使代码的逻辑更加清楚。
//代码风格很重要
int n = 4;
if (n > 0)
{
printf("n > 0\n");
}
else if (n < 0)
{
printf("n < 0\n");
}
else//如果后只有一个语句，可以省略大括号(但要注意，别把自己搞混了，不省略更好)
printf("n = 0\n");
return 0;
}
学到这 if … else 应该懂得差不多了，这里再补充一下，else是和它离的最近的if匹配的。
(2) switch 、case 、break 、default
switch语句也是一种分支语句，常常用于多分支的情况；
//语法结构:
switch (整形表达式)
{
语句项;
//语句项是一些case语句：
//如下：
case 整形常量表达式:
语句;
break;
...
default:
语句;
break;
}
//switch 、case 、break 、default经常一起使用
比如我们要输入1~7的数就判断输出对应的周几，用 if … else 太麻烦了，那用 switch 来写写看:
注：在switch语句项中，使用 case 关键字表示检验条件符合的各种情况，其后的语句是相应的操做(根据使用情况最好都加上break)。其中还有一个 default 关键字，作用是如果没有符合条件的情况，那么执行 default 后面默认的语句。
#include <stdio.h>
int main()
{
int day = 0;
scanf("%d", &day);//输入day然后进入switch
switch (day)
{
case 1:
printf("星期一\n");
break;//break语句终止并跳出循环，继续执行后面的代码
case 2:
printf("星期二\n");
break;
case 3:
printf("星期三\n");
break;
case 4:
printf("星期四\n");
break;
case 5:
printf("星期五\n");
break;
case 6:
printf("星期六\n");
break;
case 7:
printf("星期天\n");
break;
default://default可以出现在语句列表的任何位置，而且语句流会像执行一个case标签一样执行default子句
//在每个 switch 语句中都放一条default子句是个好习惯，甚至可以在后边再加一个 break
printf("输入错误。\n");
break;
}
return 0;
}
用 switch 语句写比一堆 if … else 方便多了，这个也可以用到写菜单上；
(3) while 、continue
前面已经学习了 if … else ，接下来学习 while 循环：
//while 语法结构
while (表达式)
循环语句;
比如我们打印1-10：
#include <stdio.h>
int main(void)
{
int i = 1;
while (i <= 10)
{
printf("%d ", i);
i = i + 1;
}
return 0;
}
在 while 循环中，也可以用 break ，并且还有一个新的关键字 continue:
#include <stdio.h>
int main(void)
{
int i = 1;
while (i <= 10)
{
if (i == 5)
{
break;
}
printf("%d ", i);
i = i + 1;
}
return 0;
}
在上面代码中，i 每进一次 while 循环就判断一次是否等于5，再打印一次并加1，直到 i 等于5的时候 break ，然后直接结束程序，由此可见，while 中的 break 是用于永久终止循环的。
接下来再介绍 continue 关键字：
#include <stdio.h>
int main(void)
{
int i = 0;
while (i < 10)
{
i = i + 1;
if (i == 5)
{
continue;
}
printf("%d ", i);
}
return 0;
}
在上面代码中，i 每进一次 while 循环就加1，然后判断是否等于5再打印 i，在 i 等于5是执行了 if 中的 continue，就并没有打印5，所以 continue 是用于终止本次循环的，也就是本次循环中 continue 后边的代码不会再执行，而是直接跳转到while语句的判断部分。进行下一次循环的入口判断。
(4) for
我们已经学习了 while 循环，再来学习 for 循环：
for (表达式1; 表达式2; 表达式3)
循环语句;
//表达式1为初始化部分，用于初始化循环变量的。
//表达式2为条件判断部分，用于判断循环时候终止。
//表达式3为调整部分，用于循环条件的调整。
大致了解后我们来写代码：
#include <stdio.h>
int main(void)
{
int i = 0;
for (i = 1; i <= 10; i++)//i开始等于1; i <= 10就继续执行; 执行完一次i++
{
printf("hehe\n");
}
return 0;
}
这个代码开始 i 等于1，进入一次循环 i++(i + 1)，判断条件是 i <= 10 就继续执行；
下面我们再来看看 break 和 continue 在 for 循环中如何应用：
#include <stdio.h>
int main()
{
int i = 0;
for (i = 1; i <= 10; i++)
{
if (i == 5)
break;
printf("%d ", i);
}
return 0;
}
从这里可以看出，break 在 for 循环中也是一样的用法，都是永久终止循环；
#include <stdio.h>
int main()
{
int i = 0;
for(i=1; i<=10; i++)
{
if(i == 5)
continue;
printf("%d ",i);
}
return 0;
}
在这里 i 等于5的时候执行了 continue ,然后跳过了5的打印，也是终止本次循环，使本次循环中 continue 后边的代码不会再执行，而是直接跳转到 for 语句的判断部分。进行下一次循环的入口判断；
注：不可在for 循环体内修改循环变量，防止 for 循环失去控制；for循环中的初始化部分，判断部分，调整部分是可以省略的；
(5) do … while
do 循环至少执行一次，使用的场景有限，所以不是经常使用：
do
{
循环语句;
} while (表达式);
在 do … while 循环中也能用 break 和 continue ：
#include <stdio.h>
int main()
{
int i = 1;
do
{
if (i == 5)
break;
printf("%d ", i);
i = i + 1;
} while (i <= 10);
return 0;
}
作用都是差不多的，当 i 等于5时执行了 break ，跳过了整个循环；
#include <stdio.h>
int main()
{
int i = 0;
do
{
i = i + 1;
if (5 == i)
continue;
printf("%d ", i);
} while (i < 10);
return 0;
}
在 i 等于5的时候执行了 continue ,然后跳过了5的打印，也是终止本次循环，使本次循环中 continue 后边的代码不会再执行，而是直接跳转到 for 语句的判断部分。进行下一次循环的入口判断；
(6) goto
C语言中提供了可以随意滥用的 goto语句和标记跳转的标号，可以使程序立即跳转到函数内部任意一条可执行语句。(我不怎么使用)
#include <stdio.h>
int main(void)
{
printf("1\n");
printf("2\n");
goto end;
printf("3\n");
printf("4\n");
printf("5\n");
end:
printf("6\n");
printf("7\n");
printf("8\n");
return 0;
}
由此可看出，程序执行到 goto end; 就跳到了 end: 处，中间代码不执行，goto 语句很少运用，但在某些场合能够运用，比如一次跳出两层或多层循环时，使用break是达不到目的的。它只能从最内层循环退出到上一层的循环。
三、变量声明关键字
(1) typedef
typedef 顾名思义是类型定义，我把理解为类型重命名，直接看代码：
#include <stdio.h>
//将 unsigned int 重命名为 un_int, 所以 un_int 也是一个类型名
typedef unsigned int un_int;
int main(void)
{
//这两个变量的类型是一样的
unsigned int num1 = 0;
un_int num2 = 0;
return 0;
}
在监视窗口可以看到，typedef 重命名后的 un_int 创建的变量也是 unsigned int 类型。
(2) auto
c语言中，关键字 auto 用于声明一个变量为自动变量，自动变量也称局部变量。将不在任何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义的变量视为局部变量。所有局部变量默认都是auto，一般省略不写，只使用auto修饰变量，变量的类型默认为整型。
(3) extern
extern 声明了程序中将要用到但尚未定义的外部变量。通常都用于声明在另一个 .c 文件的变量，看代码：
只看这个代码，并执行 test.c 文件的话，会报错 arr 未声名标识符，在看下面代码：
在 test.c 文件中使用了 extern 关键字，声明了在 test1.c 中的 arr 所以能够正常运行；
(4) register
register 关键字是将所修饰变量尽可能放到寄存器中，从而提高效率，这里要注意只是可能，不一定绝对。
首先来了解一下寄存器：
再看代码：
#include <stdio.h>
int main(void)
{
int a = 200;
register int b = 100;//建议放到寄存器(取决于编译器判断)
return 0;
}
(5) static
static是用来修饰变量和函数的，它可以修饰局部变量-称为静态局部变量，修饰全局变量-称为静态全局变量，修饰函数-称为静态函数；
修饰变量：
每调用一次 test 函数，就创建了一次 arr 出了 test 函数就销毁了，再来看看加 static 修饰：
变量加上了 static 修饰，static 修饰局部变量改变了变量的生命周期，让静态局部变量出了作用域依然存在，到程序结束，生命周期才结束。
注：一个全局变量被static修饰，使得这个全局变量只能在本源文件内使用，不能在其他源文件内使用(在编译的时候会出现连接性错误)。
一个函数被static修饰，使得这个函数只能在本源文件内使用，不能在其他源文件内使用(在编译的时候会出现连接性错误)。
修饰函数用法：
static int Add(int x, int y)
{
return c+y;
}
(6)const
const 可以修饰变量、数组、指针、函数参数，下面我们来看看大致用法：
C语言中使用const修饰变量，主要是保护变量以防止被修改。
在这个代码中，a 是可以被修改的；
而在这个代码中，变量 i 被 const 修饰，只有可读特性，不能够被更改，若想重新对 i 进行赋值是不可行的。
c语言中 const 还可以修饰数组，数组元素与变量类似，具有只读性，不能被更改。
在这个代码中，arr 中的任何元素都可以被修改；
而在这个代码中，数组 arr 被 const 修饰，只有可读特性，不能够被更改，若想重新对 arr 中的元素进行更改是不可行的。
c语言中const修饰指针有两种形式，1.用来修饰指向空间的值不能修改；2.修饰存放指针类容不可更改
#include <stdio.h>
int main(void)
{
int i = 0, j = 0;
//const修饰的是int* p1，即指向空间的值不可改变
const int* p1 = &i;
//*p1 = 10;//若改变p1指向的内容是不可以的
p1 = &j;//若改变p1指向的地址是可行的
//const修饰的是存放指针的p2，即p2存储的指针不可改变
int* const p2 = &j;
*p2 = 10;//若改变p2指向的内容是可以的
//p2 = &i;//若改变p2指向的地址是不可行的
return 0;
}
const关键字还可以修饰函数参数，对参数起限定作用，防止其在函数内部被修改(所限定函数可以是普通变量，也可以是指针变量)。
void test(const int* x, const int n)
{
*x = 100;//被const修饰过，*x的值是不可被修改的
n = 100;//被const修饰过，n的值是不可被修改的
}
四、
(1) sizeof
sizeof其实是一个关键字，并不是函数，siezof 的作用就是计算数据类型长度、数组大小、数组元素个数；
#include <stdio.h>
int main(void)
{
int a = 0;
int arr[] = { 1, 2, 3, 4, 5 };
printf("%d\n", sizeof(int));//int大小
printf("%d\n", sizeof(a));//a的大小
printf("%d\n", sizeof(arr));//arr数组大小
printf("%d\n", sizeof(arr) / sizeof(arr[0]));//数组元素个数
return 0;
}
(2) return
return 语句是用于返回的关键字，像 main 函数最后的 return 0; 就是代表程序正常退出，return 1;代表程序异常退出，return语句可以返回一个变量内的值或一个指针，也可用return0，表示返回为空。
(3) volatile
C中的 volatile 关键字和 const 对应，用来修饰变量，遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问，当要求使用 volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存 —— 来自搜索
总结
关键字的初步认识大概就这样，后续学习了更多知识再补充。