C语言32个关键字

C语言共有32个关键字：

auto：声明自动变量，缺省时编译器一般默认为auto

signed ：声明有符号类型变量

unsigned ：声明无符号类型变量

default ：开关语句中的“其他”分支

break ：跳出当前循环

register ：声明寄存器变量

static：声明静态变量

int：声明整型变量

double：声明双精度变量

long： 声明长整型变量

char ：声明字符型变量

float ：声明浮点型变量

short ：声明短整型变量

sizeof：计算对象所占内存空间大小

if ：条件语句

else： 条件语句否定分支(与if 连用)

switch：用于开关语句

case：开关语句分支

do ：循环语句的循环体

while ：循环语句的循环条件

for ：一种循环语句(可意会不可言传)

goto：无条件跳转语句

void ：声明函数无返回值或无参数，声明空类型指针

return：子程序返回语句(可以带参数，也可不带参数)

const ：声明只读变量

volatile：说明变量在程序执行中可被隐含地改变

extern ：声明变量是在其他文件正声明(也可以看做是引用变量)

struct：声明结构体变量

union ：声明联合数据类型

enum：声明枚举类型

typedef ：用以给数据类型取别名(当然还有其他作用)

continue： 结束当前循环，开始下一轮循环

 

 

1、声明与定义：

定义创建了对象并为对象分配了内存，声明没有分配内存；

 

2、register ：声明寄存器变量

   请求编辑器尽可能的将变量存在CPU内部寄存器中来提高效率，而不是通过内存寻址访问；由于CPU寄存器有限，故register变量不能定义太多。

寄存器：CPU与内存的中转站；CPU有很多寄存器，一块块小的存储空间，其存储速度快。

register变量必须是一个单个的值，并且长度应小于或等于整型的长度；而且register变量可能不存放在内存中，故不能使用取址运算符“&”获取其地址。

 

3、static ：声明静态变量

  （1）修饰变量

   全局变量和局部变量都存在内存的静态区；

静态全局变量作用域：仅限于变量被定义的文件中；其他文件，即使加“extern”声明也没法使用它；

静态局部变量作用域：仅限于变量被定义的函数中；运行结果不会被销毁，下次使用仍然能用到这个值。

例子：

#include<stdio.h>

static int j;   //静态全局变量

void fun1(void)

{

     static int i = 0;  //静态局部变量

     i++;

     printf("i=%d,",i);

}

void fun2(void)

{

     j = 0;

     j++;

     printf("j=%d;",j);

}

int main()

{

     int k;

     for(k=0; k<10; k++)

     {

            fun1();

            fun2();

     }

            return 0;

}

//结果：i=1,j=1;i=2,j=1;i=3,j=1;i=4,j=1;i=5,j=1;i=6,j=1;i=7,j=1;i=8,j=1;i=9,j=1;i=10,j=1;

（2）修饰函数

静态函数：此时static不是指存储方式，而是对函数作用域仅限于本文件（内部函数）。

 

4、基本数据类型

int：声明整型变量；double：声明双精度变量；long： 声明长整型变量；char ：声明字符型变量；float ：声明浮点型变量；short ：声明短整型变量。

C数据类型

（1）基本类型

    A.数值类型

      a.整型

       1短整型short  2整型int   3长整形long

      b.浮点型

       1单精度型float   2双精度double

    B.字符类型char

（2）构造类型

A.数组

B.结构体struct

C.共用体unoin

D.枚举类型enum

（3）指针类型

（4）空类型void

 

 数据类型：“模子”（32位系统中占据内存）可以用sizeof测试

short ：2byte

int ：4 byte

long ：4 byte

float ：4 byte

double：8 byte

char ：1 byte

 

5、sizeof ：计算对象所占内存空间大小

计算变量所占空间大小时，后边括号可以省略；计算类型大小时，不能省略。

   例子：

    #include<stdio.h>

void main(void)

{

    int a,b,c,d,i=0;

    a=sizeof(int);

    b=sizeof(i);

//  c=sizeof int;

    d=sizeof i;

    printf("a=%d,b=%d,c=%d,d=%d\n",a,b,c,d);

}

//结果：a=4,b=4,c=-858993460,d=4

  其中，sizeof  int；是错误的

 

  sizeof （int） *p

 例子：

#include<stdio.h>

void main(void)

{

     int a,b,c,d,e,f;

     int* p=NULL;

     int q[100];

     a=sizeof(p);

     b=sizeof(*p);

     c=sizeof(q);

     d=sizeof(q[100]);

     e=sizeof(&a);

     f=sizeof(&q[0]);

     printf("a=%d,b=%d,c=%d,d=%d,e=%d,f=%d\n",a,b,c,d,e,f);

}

//结果：a=4,b=4,c=400,d=4,e=4,f=4

 

6、signed、unsigned 关键字

一个32位的 signed int类型整数其值表示法范围为：-2^31-2^31-1；

8 位的char类型数其值表示的范围为:-2^7-2^7-1。

一个 32位的 unsigned int类型整数其值表示法范围为：0-2^32-1；

8位的 char类型数其值表示的范围为： 0-2^8-1

 

7、if、else组合

if ：条件语句；else： 条件语句否定分支(与if 连用)

bool a=FALSE；初始化为FALSE，比较好

  A.bool 变量与“零值”比较：即：bool a=FALSE；（bool是逻辑型变量的定义符，具有yes值和no值）

   （1）if（a= =0）；       if（a= =1）；

   （2）if（a= =TRUE）；    if（a= =FALSE）；

   （3）if（a）；           if（！a）；

写法（1）a不一定是整型变量；FALSE被定义为0，TRUE不都是1，在VB中定义为-1；所以这两种写法不好；写法（3）不错；

  B.float变量与“零值”比较：float b=0.0；

   （1）if（b= =0.0）；             if（b！=0.0）；

   （2）if（b>=-EPSINON）&&(b<=EPSINON)；    // EPSINON为定义好的精度

由于double和float都受精度限制，故用0.0不合适

  C.指针变量与“零值”比较：

int* p=NULL；  //定义指针一定要同时初始化

（1）if（p==0）；      if(p！=0)；

（2）if（p）；         if（！p）；

（3）if（NULL==p）；    if（NULL！=p）；

写法(1)容易把p误认为是整型，写法（2）容易把p误认为是bool变量，写法（3）正确

 

注：else与最近的if配对；if括号后边加“；”相当于执行空语句。

 

8、switch、case 组合

 switch ：用于开关语句；case ：开关语句分支

if与else一般适用于两个分支或嵌套表示少量的分支；swich与case适用于多分支；

形式：

swich(variable)

{

    case valuel；执行函数；break；

case value2；执行函数；break；

case valueN；执行函数；break；

default：执行函数；break；

}

   注：不要忘break；一定要加default；case 后边的值只能是整型或字符型的常量或常量表达式。

 

9、do、while、for 关键字

do ：循环语句的循环体；while ：循环语句的循环条件；for ：一种循环语句(可意会不可言传)

while循环：

如：输入“#”才可以停下来

while（1）

{

       if（‘#‘==GetInput（））

{break；}

}

   break表示终止本层循环；continue表示终止本次循环；

do while循环：先执行do后边的代码，再判断while后边值；

for 循环：可以控制循环次数。

注：循环嵌套时，长循环放在最内层。

 

10、goto语句

  goto ：无条件跳转语句；

可能跳过了变量的初始化、重要的计算等；

形式：

……

Goto a；

a：

……

 

11、void关键字 

void ：声明函数无返回值或无参数，声明空类型指针；

（1）对函数返回的限定；

（2）对函数参数的限定；

void*定义类型，转换时，无需要强制类型转换；

如：void *p1； int *2；  可以直接：p1=p2；  但p2=p1是错误的；

注：“空类型”可以包含“有型类”，但“有型类”不能包含“空类型”；

void修饰函数返回值和参数：如果函数没有返回值，用void声明；默认是表示返回整型值；

void指针:不能对void指针进行算法操作，

如：

void* p；

p++；  //错误

p+=1； //错误

void不能代表一个真实的变量：因为定义变量时必须分配内存空间；void为抽象。

 

12、return 关键字

 return ：子程序返回语句(可以带参数，也可不带参数)；

用来终止一个函数并返回其后边跟着的值；

形式：

return（val）；  //括号一般不省略

例子：

  char* fun（void）

{

           Char str[30];

…

Return str;  //错误

}

   Str属于局部变量，位于栈内存中，在fun结束后被释放后值被销毁，故返回str将导致错误。

 

13、const关键字

  const ：声明只读变量

不变；被它修饰的值是常量，即只读变量；与define宏类似，但是这个可不是关键字；

定义const变量，具有不可变性；

节省空间，避免不必要的内存分配；

如：

#define M 3    //没有分号

const N=5；

……

int i=N；     //此时分配内存，不再分配

int I=M；     //分配内存

int j=N；     //没有分配内存

int J=M；     //再次分配内存

修饰一般变量：int const i=2；  或  const int i=2；

修饰数组：int consti=a[2]；  或  const int i=a[2]；

修饰指针：

  const int *p；   //p可变，p指向的对象不可变

  int const *p；   //p可变，p指向的对象不可变

  int* const p；   //p不可变，p指向的对象可变

  cons tint *const p； //指针和p指向的对象都不可变

修饰函数的参数：void fun（const int i）；

修饰函数的返回值：const int fun（void）； //返回值不可改变

Extern const int i=10；  //错误，函数中i值不能变

 

 

14、最易变的关键字：volatile

  volatile： 说明变量在程序执行中可被隐含地改变；

 例子：

  volatile inti=10;

int j = i；//(3)语句

int k = i；//(4)语句

 

15、extern关键字

extern ：声明变量是在其他文件正声明(也可以看做是引用变量)

外面的、外来的意思，不是本文件定义的

 

16、struct关键字    （结构体）

struct ：声明结构体变量

函数的参数尽量不多于4个，多于4个时候，容易出错，此时可以用结构体压缩参数个数；

结构体所占的内存大小是其成员所占内存之和；打包封装

如：

  Struct student

{

}stu；

Sizeof（stu）的值是1

      

      struct与class的区别：struct的成员默认情况下属性是public，而class成员是private

 

结构体的定义：

（1）只有结构体定义：

1.   struct stuff{  

2.          char job[20];  

3.          int age;  

4.          float height;  

5.  }; 

（2）附加变量初始化的结构体定义

1.  //直接带变量名Huqinwei  

2.  struct stuff{  

3.          char job[20];  

4.          int age;  

5.          float height;  

6.  }Huqinwei; 

等价于：

1.  struct stuff{  

2.          char job[20];  

3.          int age;  

4.          float height;  

5.  };  

6.  struct stuff Huqinwei; 

（3）如果该结构体只用一个变量a，而不再需要用

1.  struct stuff yourname;  

定义第二个变量，那么，附加变量初始化的结构体定义还可进一步简化出第三种：

1.  struct{  

2.          char job[20];  

3.          int age;  

4.          float height;  

5.  }a;

占用内存空间：

struct结构体，在结构体定义的时候不能申请内存空间，不过如果是结构体变量，声明的时候就可以分配——两者关系就像C++的类与对象，对象才分配内存（不过严格讲，作为代码段，结构体定义部分“.text”真的就不占空间了么？）。

 

17、union关键字

union ：声明联合数据类型；与struct用法非常类似。union 主要用来压缩空间。

union 维护足够的空间来置放多个数据成员中的“一种”，而不是为每一个数据成员配置空间，在union中所有的数据成员共用一个空间，同一时间只能储存其中一个数据成员，所有的数据成员具有相同的起始地址。

例子：

unionStateMachine

{

charcharacter;

int number;

char *str;

double exp;

};

一个union只配置一个足够大的空间来容纳最大长度的数据成员，以上最大长度是double型，故StateMachine的空间大小就是double数据类型的大小。

大小端模式对union类型数据的影响

例子：

union

{

int i;

char a[2];

}*p, u;

p =&u;

p->a[0] =0x39;

p->a[1] =0x38;

注：p，i的值应该是多少呢？

这里需要考虑存储模式：大端模式和小端模式

大端模式：字数据的高字节存在低地址中，而字数据的低字节则存放在高地址中。

小端模式：字数据的高字节存储在高地址中，而字数据的低字节则存放在低地址中。

union型数据所占的空间等于其最大的成员所占的空间。

 

18、enum关键字

enum ：声明枚举类型

定义方式如下：

enumenum_type_name

{

ENUM_CONST_1,

ENUM_CONST_2,

...

ENUM_CONST_n

}enum_variable_name;

注意：enum_type_name 是自定义的一种数据数据类型名，而enum_variable_name为enum_type_name类型的一个变量，也就是我们平时常说的枚举变量。实际上enum_type_name

类型是对一个变量取值范围的限定，而花括号内是它的取值范围，即enum_type_name 类型

的变量enum_variable_name 只能取值为花括号内的任何一个值，如果赋给该类型变量的值

不在列表中，则会报错或者警告。ENUM_CONST_1、ENUM_CONST_2、...、ENUM_CONST_n，这些成员都是常量，也就是我们平时所说的枚举常量（常量一般用大写）。enum 变量类型还可以给其中的常量符号赋值，如果不赋值则会从被赋初值的那个常量开始依次加1，如果都没有赋值，它们的值从0 开始依次递增1。如分别用一个常数表示不同颜色：

          enumColor

{

GREEN = 1,

RED,

BLUE,

GREEN_RED =10,

GREEN_BLUE

}ColorVal；

     其中各常量名代表的数值分别为：

GREEN = 1

RED = 2

BLUE = 3

GREEN_RED =10

GREEN_BLUE =11

枚举与#define宏的区别：

（1）#define宏常量是在预编译阶段进行简单替换，枚举常量则是在编译的时候确定其值；

（2）一般在编辑器里，可以调试枚举常量，但是不能调试宏常量；

（3）枚举可以一次定义大量相关的常量，而#define宏一次只能定义一个。

 

19、typedef关键字

typedef ：用以给数据类型取别名(当然还有其他作用)

形式：

typedefstruct student

{

//code

}Stu_st,*Stu_pst;//命名规则请参考本章前面部分

A）struct student stu1；和Stu_st stu1；没有区别。

B）struct student *stu2；和Stu_pst stu2；和Stu_st *stu2；没有区别。

 

typedef 与#define 的区别:

E）#define  INT32  int

unsigned  INT32  i = 10；

F）typedef  int  int32；

Unsigned  int 32  j= 10；

   其中，F）编译会出错，用typedef 取的别名不支持这种类型扩展；

G)  #define  PCHAR  char*

PCHAR  p3, p4;

H） typedef char*  pchar;

pchar  p1, p2;

G)和F）编译都没错，但是p4在这里不是指针，只是一个char类型的字符。