C语言32个关键词功能详解

由ANSI标准定义的C语言关键字共32个:

1 *auto  double  int  struct  break  else  long  switch
2 *case  enum  register  typedef  char  extern  return  union
3 *const  float  short  unsigned  continue  for  signed  void
4 *default  goto  sizeof  volatile  do  if  while  static

ANSI标准

根据关ANSI：美国国家标准学会（AMERICAN NATIONAL STANDARDS INSTITUTE:ANSI）成立于1918年。当时，美国的许多企业和专业技术团体，已开始了标准化工作，但因彼此间没有协调，存在不少矛盾和问题。为了进一步提高效率，数百个科技学会、协会组织和团体，均认为有必要成立一个专门的标准化机构，并制订统一的通用标准。

ANSI的历史由来
1918年，美国材料试验协会（ASTM）、与美国机械工程师协会（ASME）、美国矿业与冶金工程师协会（ASMME）、美国土木工程师协会（ASCE）、美国电气工程师协会（AIEE）等组织，共同成立了美国工程标准委员会（AESC），美国政府的三个部（商务部、陆军部、海军部）也参与了该委员会的筹备工作。
1928年，美国工程标准委员会改组为美国标准协会（ASA），为致力于国际标准化事业和消费品方面的标准化。
1966年8月，又改组为：美利坚合众国标准学会（USASI）。
1969年10月6日改成现名：美国国家标准学会（ANSI）。

键字的作用，可以将关键字分为数据类型关键字和流程控制关键字两大类。

1.数据类型关键字

A基本数据类型（5个）

1>  void：声明函数无返回值或无参数，声明无类型指针，显式丢弃运算结果  
2>  char：字符型类型数据，属于整型数据的一种 
3>  int：整型数据，通常为编译器指定的机器字长 
4>  float：单精度浮点型数据，属于浮点数据的一种 
5>  double：双精度浮点型数据，属于浮点数据的一种

B类型修饰关键字（4个）

1>  short：修饰int，短整型数据，可省略被修饰的int  
2>  long：修饰int，长整形数据，可省略被修饰的int 
3>  signed：修饰整型数据，有符号数据类型  
4>  unsigned：修饰整型数据，无符号数据类型

C复杂类型关键字（5个）

1>  struct：结构体声明  
2>  union：共用体声明  
3>  enum：枚举声明  
4>  typedef：声明类型别名 
5>  sizeof：得到特定类型或特定类型变量的大小

D存储级别关键字（6个）

1>  auto：指定为自动变量，由编译器自动分配及释放。通常在栈上分配 
2>  static：指定为静态变量，分配在静态变量区，修饰函数时，指定函数作用域为文件内部 
3>  extern：指定对应变量为外部变量，即在另外的目标文件中定义，可以认为是约定由另外文件声明 
4>  const：与volatile合称“cv特性”，指定变量不可被当前线程/进程改变（但有可能被系统或其他线程/进程改变）

2.流程控制关键字

A跳转结构（4个）

1>  return：用在函数体中，返回特定值（或者是void值，即不返回值）  
2>  continue：结束当前循环，开始下一轮循环 
3>  break：跳出当前循环或switch结构  
4>  goto：无条件跳转语句

B分支结构（5个）

1>  if：条件语句  else：条件语句否定分支（与if连用）  
2>  switch：开关语句（多重分支语句）  
3>  case：开关语句中的分支标记 
4>  default：开关语句中的“其他”分治，可选

C循环结构（3个）

1>  for：for循环结构，for(1;2;3)4;的执行顺序为1->2->4->3->2...循环，其中2为循环条件 
2>  do：do循环结构，do 1 while(2);的执行顺序是1->2->1...循环，2为循环条件 
3>  while：while循环结构，while(1) 2;的执行顺序是1->2->1...循环，1为循环条件
     以上循环语句，当循环条件表达式为真则继续循环，为假则跳出循环。

标准C语言的32个关键字

1、基本数据类型： signed unsigned char int float double short long void
2、构造数据类型： struct union enum
3、数据存储类别： auto static extern register
4、数据优化： const volatile
5、9条基本语句： if else switch case break default while do for return continue goto
6、其它： typedef sizeof

预编译处理符 “#”
1> #include
2> #define 
3> #ifdef
4> #ifndef
5> #if
6> #else
7> #else if
8> #endif 
等等。

一、基本数据类型

> 1、unsigned :无符号的

    //用来声明一个无符号的变量。
    unsigned char var; //var的范围：0~255

> 2、signed :有符号的(可以省略不写)

    //用来声明一个有符号的变量。
    signed char var; //var的范围：-128~127

> 3、char :字符型

    //用来声明一个字符型变量。
    //占一个字节空间
    char var;

> 4、int :整型

    //用来声明一个整型变量。
    //C51：占两个字节空间,ARM：占四个字节
    int var; 

> 5、float :浮点型

    //用来声明一个浮点型(实型)变量。
    //最多能表示到7个有效数据位。
    //占四个字节空间
    float var;

>  6、double :双精度型

    //用来声明一个双精度实型变量。
    //最多能表示到15~16个有效数据位。
    //占四个字节空间 ,有的系统占八个字节
    double var; 

> 7、short :短整型

    //用来声明一个短整型变量。
    //C51：跟int一样,ARM：占两个字节
    short var; 

> 8、long :长整型

    //用来声明一个长整型变量。
    //ARM：跟int一样,C51：占四个字节
    long var; 

> 9、void :空型

    //表示一个函数没有返回值,或者无形参。
    void function(void);

二、构造数据类型

> 1、struct
    //用来声明一种结构体类型。
    struct stu{
        char sex;
        int age;
        float score;
        struct stu *Next;
    };
    struct stu var; 

> 2、union

    //用来声明一种共用体类型。
    //该类型的变量所在空间的大小以其成员占最大的那个为准,
    //存入该变量中的值以程序中最后存入的数值为当前值
    union non{
        char sex;
        int age;
        float score;
    };
    union non var; 

> 3、enum

    //用来声明一种枚举类型。
    //规定枚举类型的变量,只能在限定的范围内取值
    //否则,编译会出现警告(达到数据安全的效果)
    enum em 
        {a = 23,b,c,d = 56,e}; //其中b=24,c=25,e=57
    enum em var;

三、数据的存储类别

> 1、auto :自动的(可省略不写)
    //定义一个局部变量,默认为auto类型的,
    //当它所在的函数调用结束时,释放内存
    //使用时才分配内存,用完即释放
    auto char var; 

> 2、static :静态的

    //①定义一个局部变量,该变量在定义时只进行
    //一次初始化,以后每次调用它所在的函数,其值
    //都会保持上一次调用的结果,它所在的空间不会
    //被释放
    
    //②被static修饰的全局变量,则只能在它所在的C
    //源文件中使用,其它文件不能调用,(内部全局变量)
    //③被static修饰的函数,只能在该函数所在的C源文
    //件中被调用,其它文件不能调用,(内部函数)
    static char var;
    static void function();

> 3、extern :外部的

    //①想要调用别的C源文件中的某一个全局变量,
    //可以使用该关键字在该文件中修饰声明该变量
    //即可调用(前提是该变量没有被static修饰)
    //该类型的变量也是一直占着内存不释放
    
    //②想要调用别的C源文件中的某一个函数,
    //可以使用该关键字在该文件中修饰声明该函数
    //即可调用(前提是该函数没有被static修饰)
    extern char var;
    extern void function();

> 4、register :寄存器的

    //被这个关键字修饰的变量,建议编译器将该变量在
    //使用时放到CPU内部寄存器中,以提高执行效率
    //注意：该关键字只是"建议",到底有没有将变量放到
    //寄存器中无从得知。一般使用在循环次数比较多的
    //地方。
    //在使用时才分配内存,用完即释放
    register long i = 30000;

四、数据优化

> 1、const :常的
    //常变量：被const关键字声明的变量,其值不能被改变。
    //即在声明该变量时必须要初始化该变量。
    //var本身还是一个变量。(数据安全检测)
    const char var = 100;
    char arr[var]; //试图声明一个长度为100的字符型数组
    //在MDK (ARM)中可以使用常变量来声明数组的长度
    //在VC++编译环境中也可以。
    //在C51-keil中不可以使用常变量来声明数组的长度
    char *const p;
    //指针变量p不可改变,但是它指向的地址里面的值可变 
    char const *p; 或 const char *p;
    //指针变量p可以改变,但是它所指向的地址里面的值不能改变 
    const char * const p; //p地址不可改变,里面的值也不能变

> 2、volatile :随时会改变的

    //被volatile修饰的变量或寄存器会意想不到地发生改变。
    //①某些变量或寄存器(如状态寄存器)可能会受硬件影响;
    //②在多线程任务中,被其它线程修改(共享内存段);
    //③一个在中断服务中使用到的全局变量
    //④编译器会对C程序进行优化;
    //为了保证程序不被优化,保证CPU取到的数据是最新的
    //(即提醒CPU每次都必须到内存中取出变量当前的值而不
    //是取cache或者寄存器中的备份),使用该关键字修饰,如：
    int *p; *p = 1; *p = 2;
    //编译时,编译器会对上面的语句进行优化,
    //会直接优化成：
    int *p; *p = 2;
    //为了保证上面的语句不被优化,加volatile修饰变量：
    int * volatile p;

五、9条语句

四种结构：

> 1、顺序结构：0条 //声明语句、运算语句、赋值语句等等

> 2、选择结构：2条 //多选一

    ①、if -else if -else if ... else
    if(表达式1) 
    {语句s;}
    else if(表达式2) 
    {语句s;}
    else if(表达式3) 
    {语句s;}
    else
    {语句s;}
    //用法:顺序判断if后的"表达式"是否为真
    //如果碰到为真的情况,则执行其下面的{}里的"语句"
    //执行完后,即退出这个"多选一"的结构 

    ②、switch-case-break
    switch(变量) 
    {
        case 常量1：语句;...;break;
        case 常量2：语句;...;break;
        case 常量3：语句;...;break;
        default:语句; 
    }
    //用法：顺序判断"变量"是否与"常量"相等,
    //如果相等,则执行该常量：后的"语句s",遇到break即跳出
    //这个结构
    unsigned char i = 6;
    unsigned char dat;
    switch(i)
    {
        case 3:dat = 5;break;
        case 5:dat = 34;break;
        case 6:dat = 99;break;
        case 7:dat = 56;break;
        case 6:dat = 100;break;
        default:dat = 68; //默认执行
    }
    //注：如果少了break,则顺序判断i的值与
    //case后面的常量是否相等,如果相等,则执行其
    //后面的语句,以后不再判断,再继续执行下面的
    //每一条case 后面的语句,直到default.
    //这种用法不使用！
    

> 3、循环结构：3条

    ①、for
    for(语句1;语句2;语句3) 
    {
        语句4;
        语句...;
    }
    //用法：语句1：条件初始化
    //     语句2：判断语句,判断条件是否成立
    //     语句3：修改条件语句
    //先执行语句1,再进行对语句2的判断,如果成立
    //则执行{}里的语句4...,再执行语句3,在判断
    //语句2是否依然成立,。当语句2不成立时,结束循环

    ②、while
    while(表达式) 
    {
        语句;
        ....;
    }
    //用法：先判断“表达式”是否成立,如果成立
    //则执行{}里的语句,执行完再次判断“表达式”
    //是否依然成立,成立则继续执行{},不成立则结束
    //此循环结构。

如何来设计一个死循环？两种方法：
    for(;;)
    while(1)
    
     ③、do-while
    do{
        语句1;
        ...;
    }while(表达式);
    //用法：先执行{}里的语句,执行完后,判断
    //"表达式"是否成立,如果成立,继续执行{};
    //如果不成立,则结束循环
    

> 4、转移结构：4条

    ①、break
    //仅用于跳出循环结构
    //且仅能跳出一层循环结构
    for(i=10;i>0;i--)
    {
        t = 10;
        while(t--)
        {
            dat++;
            if(dat == 3)
                break;//跳出while()结构。
        } 
    }
    
    ②、continue
    //用于终止本次循环,继续从下次循环开始
    //正式程序中不使用,仅用于调试程序
    char buf = 10;
    while(buf--)
    { 
        a++;
        b++;
        continue;//遇到continue则结束这次循环
        d++; //这条永远都不会执行到 
        e++; //这条永远都不会执行到 
    }

    ③、goto
    //无条件转移 
    //一般都不建议在大的程序当中使用
    unsigned char dat=10;
    while(dat--)
    { 
        a++;
        b++;
 Lable: c++;
        if(c == 3)
            goto Lable;//直接跳到Lable标号去 
        d++;
    }

    ④、return
    //用于函数返回,
    //在函数调用时,遇到return即返回。
    //如果需要返回某个值,在其后加上返回值。
    //返回值类型必须和函数类型一致。
    void function()
    {
        char a,b; 
        a++;
        return; //遇到return即返回调用处
        b++; //不会被执行
        return; //不会被执行
    }

六、其它

> 1、typedef : 类型重定义
    typedef unsigned char uchar;
    //用uchar重新定义unsigned char
    #define uchar unsigned char
    //用uchar 替换unsigned char
跟宏定义的区别：
    ①、typedef 是在编译阶段进行定义
        宏定义是在预编译处理阶段完成展开
    ②、typedef 是类型重新定义,不是简单地替换
        宏定义只是简单的替换,没有定义
    typedef unsigned char* M;
    #define M unsigned char*
    M p1,p2;
    //对于typedef来说：p1是指针变量,p2也是
    //对于宏定义来说：p1是指针变量,p2是普通变量
    

> 2、sizeof

    //用来求类型所占的字节数
    int var = 10;
    char g; 
    g = sizeof(var++);//g = 4;
    //注意：var++该条语句没有被执行！
    //()里的语句是不会被执行的。