auto　　break　　case　　char　　const　　continue　　default　　do　　double　　else　　enum

extern　　float　　for　　goto　　if　　int　　long　　register　　return　　short　　signed　　

sizeof　　static　　struct　　switch　　typedef　　union　　unsigned　　void　　volatile　　while

注：关键字，先介绍下面几个

auto:

（auto）int a=10;(a叫局部变量，也叫自动变量，自动创建，自动销毁）（局部变量前面都有auto，auto被省略掉了）

register(寄存器关键字）

计算机 存储数据：

寄存器              访问速度越来越高

高速缓存          空间越来越小                            从内存里面拿数据给（cpu)中央处理器

内存                                                                   随着技术的发展，cpu处理数据的速度越来越快，但是内存的访问速度跟不上（整体的速度跟不上了）

硬盘                                                                   未来cpu处理的数据从寄存器里面拿，速度更快。先让内存里的数据加到告诉缓存，再把高速缓存里的数据加到寄存器，

                                                                          如果寄存器里没有数据，在从高速缓存里面去拿，如果高速缓存里没有，再从内存里去拿。（速度就上去了）

int main()

{

         register int a=10;  //把a定义成寄存器变量（建议作用）

         return 0；                                                     代码里的寄存器变量太多，没有那么多寄存器可以使用，所以最终有没有把a放到寄存器里面去，由编译器判断。

}

signed:

int main（）

{

       int a=10;

       int a=-2;    //int 定义的变量是有符号的，signed int   /  int,   signed被省略掉了（unsigned int num=0;定义一个无符号数)

}

typedef:顾名思义是类型定义，这里应该理解为类型重命名。

int main()

{ 

         typedef unsigned int u_int;(为unsigned int重新起一个名字u_int)

         unsigned int num=20;

         u_int num2=20;

         return 0;

}

static:在C语言中，static是用来修饰变量和函数的

1.修饰局部变量-静态局部变量

2.修饰全局变量-静态全局变量

3.修饰函数-静态函数

static修饰局部变量：局部变量的生命周期变长

void test()                                                              void test()

{      int a=1;                                                           {    static int a=1;   //a是一个静态的局部变量      static修饰局部变量，局部变量的生命周期变长

       a++;                                                                     a++;

       printf("a=%d\n",a);——>22222                            ptintf("a=%d\n",a);——>23456

 }                                                                              }

int main()                                                                      int main()

{                                                                                   {

       int i=0;                                                                         int i=0;

       while(i<5)                                                                    while(i<5)

       {                                                                                  {

            test();                                                                            test();

            i++;                                                                               i++;

        }                                                                                   }

    return 0;                                                                           return 0;

}                                                                                    }

static修饰全局变量：改变了变量的作用域，让静态的全局变量只能在自己所在的原文件内部使用，出了原文件就没法再使用了

在另一个文件里面定义一个变量：int g_val=2020;   //全局变量             再次定义为：static int g_val=2020;  //全局变量

原来文件的程序：                                                                                 

int main()                                                                                              int main()

{                                                                                                             {

          extern int g_val;      //extern声明外部符号的                                 extern int g_val;

          printf("g_val=%d\n",g_val);——>2020                                          printf("g_val=%d\n",g_val);——>无法执行（无法解析的外部符号）

          return 0;                                                                                         return 0;

}                                                                                                               }

static修饰函数：改变了函数的链接属性（外部链接属性变成了内部链接属性）

int main()                                       在另一个文件中定义一个函数：

{         

     extern int Add(int,int);                int Add(int x, int y);                 static int Add(int x,int y)     （用static修饰函数）

     int a=10;                                   {                                               {

     int b=20;                                            int z=x+y;                              int z=x+y;

     int sum=Add(a,b);                              return z;                                return z;

     printf("sum=%d\n",sum); --->30   }                                             }    (无法解析的外部符号，无法执行）

     return 0;

}

#define定义常量和宏：

#define MAX 100      

int main()

{

      int a=MAX;

      return 0;

}

宏：

#define MAX(X,Y)   (X>Y?X:Y)                    #define ADD(x,y) ((x)+(y))

int main()                                                      #in ude<stdio.h>

{                                                                     int main()

int a=10;                                                        {

int b=20;                                                                  int sum=ADD(2,3) ;

int max=MAX(a,b);                                                  printf("sum=%d\n",sum);

printf("max=%d\n",max)                                          return 0;

return 0;                                                            }

}