【C语言】32个关键字

C语言32个关键字

文章目录

• C语言32个关键字
• • 1.数据类型关键字
  • • 基本数据类型（5个）
    • 类型修饰关键字（4个）
    • 复杂类型关键字（5个）
    • 存储级别关键字（6个）
  • 2.流程控制关键字
  • • 跳转结构（4个）
    • 分支结构（5个）
    • 循环结构（3个）
    • 其它（2个）
  • 详解
  • • 基本数据类型
    • • 1.unsigned
      • 2.signed
      • 3.char
      • 4.int
      • 5.float
      • 6.double
      • 7.short
      • 8.long
      • 9.void
    • 构造数据类型
    • • 1.struct
      • 2.union
      • 3.enum
    • 数据的存储类别
    • • 1.auto
      • 2.static
      • 3.extern
      • 4.register
    • 数据优化
    • • 1.const
      • 2.volatile
    • 语句
    • 1.选择结构
    • • 1.if
      • 2.switch-case
    • 2.循环结构
    • • 1.for
      • 2.while
      • [3.do while](#3.do while)
    • 3.转移结构
    • • 1.break
      • 2.continue
      • 3.goto
      • 4.return
    • 其它
    • • 1.typedef
      • 2.sizeof

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

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

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

1.数据类型关键字

基本数据类型（5个）

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

类型修饰关键字（4个）

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

复杂类型关键字（5个）

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

存储级别关键字（6个）

auto	指定为自动变量，由编译器自动分配及释放。通常在栈上分配
static	指定为静态变量，分配在静态变量区，修饰函数时，指定函数作用域为文件内部（单片机开发中，此变量值执行一次）
extern	指定对应变量为外部变量，即在另外的目标文件中定义，可以认为是约定由另外文件声明 （在单片机开发中，声明的这个变量可以让多个文件访问到）
const	与volatile合称"cv特性"，指定变量不可被当前线程/进程改变（但有可能被系统或其他线程/进程改变）

2.流程控制关键字

跳转结构（4个）

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

分支结构（5个）

if	条件语句
else	条件语句否定分支（与if连用）
switch	开关语句（多重分支语句）
case	开关语句中的分支标记
default	开关语句中的"其他"分治，可选（一般条件都不符合，我们会走这个分支）

循环结构（3个）

for	循环结构
while	循环结构
do	循环结构

其它（2个）

typedef	给数据类型取别名
sizeof	计算对象所占内存空间大小

详解

基本数据类型

1.unsigned

unsigned :无符号的

• 用来声明一个无符号的变量

unsigned char var; //var的范围：0~255

2.signed

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

• 用来声明一个有符号的变量。

signed char var; //var的范围：-128~127

3.char

字符型

• 用来声明一个字符型变量
• 占一个字节空间
• 范围是 -128~127 ；uchar 表示无符号的类型，所以表示的范围是 0~255

4.int

int :整型

• 用来声明一个整型变量
• C51：占两个字节空间, ARM：占四个字节
• 当前主流的编译器中int 类型无论在 32 位或 64 位系统中都是 4 个字节。

int var; 

5.float

float :浮点型

• 用来声明一个浮点型(实型)变量
• 表示单精度浮点数，占 4 个字节
• 最多能表示到7个有效数据位

float var;

6.double

double :双精度型

• 用来声明一个双精度实型变量
• 占八个字节
• 最多能表示到15~16个有效数据位

double var;

7.short

short :短整型

• 用来声明一个短整型变量
• C51：跟int一样,ARM：占两个字节

short var; 

8.long

long :长整型

• 用来声明一个长整型变量
• ARM：跟int一样,C51：占四个字节

long var; 

9.void

void :空型

• 表示一个函数没有返回值,或者无形参

void function(void);

类型/编译器	16位编译器	32编译器	64编译器
void	0	0	0
char	1	1	1
char *	4	4	8
short int	2	2	2
int	4	4	4
float	4	4	4
double	8	8	8
long	4	4	8
long double	12	12	16
long long	8	8	8

一般来说习惯上用n,m,i,j,k 等表示int 类型的变量；c，ch 等表示字符类型变量；a 等表示数组；p 等表示指针。当然这仅仅是一般习惯，除了i,j,k 等可以用来表示循环变量外，别的字符变量名尽量不要使用。

构造数据类型

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; 

struct用法与union一样，两者不同的是结构体的各个成员会占用不同的内存，互相之间没有影响；而共用体的所有成员占用同一段内存，修改一个成员会影响其余所有成员。

一般union用的不多

3.enum

• 用来声明一种枚举类型
• 规定枚举类型的变量,只能在限定的范围内取值,否则,编译会出现警告(达到数据安全的效果)

enum em 
{a = 23,b,c,d = 56,e}; //其中b=24,c=25,e=57
enum em var;

数据的存储类别

1.auto

auto :自动的(可省略不写)

• 定义一个局部变量,默认为auto类型的
• 当它所在的函数调用结束时,释放内存
• 使用时才分配内存,用完即释放

auto char var; 

2.static

static :静态的

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

static char var;
static void function();

3.extern

注意：声明的变量和函数必须是全局的，如果只用在函数内部会报错

extern :外部的

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

extern char var;
extern void function();

4.register

register :寄存器的

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

register long i = 30000;

数据优化

1.const

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 :随时会改变的

• 被volatile修饰的变量或寄存器会意想不到地发生改变。
• 某些变量或寄存器(如状态寄存器)可能会受硬件影响
• 在多线程任务中,被其它线程修改(共享内存段)
• 一个在中断服务中使用到的全局变量
• 编译器会对C程序进行优化

//为了保证程序不被优化,保证CPU取到的数据是最新的
//(即提醒CPU每次都必须到内存中取出变量当前的值而不
//是取cache或者寄存器中的备份),使用该关键字修饰,如：
int *p; *p = 1; *p = 2;
//编译时,编译器会对上面的语句进行优化,
//会直接优化成：
int *p; *p = 2;
//为了保证上面的语句不被优化,加volatile修饰变量：
int * volatile p;

语句

1.选择结构

1.if

• 用法:顺序判断if后的"表达式"是否为真
• 如果碰到为真的情况,则执行其下面的{}里的"语句
• 执行完后,即退出这个"多选一"的结构

if -else if -else if ... else

if(表达式1) 
{语句s;}
else if(表达式2) 
{语句s;}
else if(表达式3) 
{语句s;}
else
{语句s;}

2.switch-case

• 用法：顺序判断"变量"是否与"常量"相等,
• 如果相等,则执行该常量：后的"语句",遇到break即跳出

switch(变量) 
{
    case 常量1：语句;...;break;
    case 常量2：语句;...;break;
    case 常量3：语句;...;break;
    default:语句; 
}

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。

2.循环结构

1.for

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

for(语句1;语句2;语句3) 
{
    语句4;
    语句...;
}

for(int i =0;i<5;i++)
{
    
}

2.while

• 用法：先判断"表达式"是否成立,如果成立则执行{}里的语句,执行完再次判断"表达式"是否依然成立,成立则继续执行{},不成立则结束

while(表达式) 
{
    语句;
    ....;
}

如何来设计一个死循环？两种方法：

for(;;)
while(1)

3.do while

• 用法：先执行{}里的语句,执行完后,判断"表达式"是否成立,如果成立,继续执行{};如果不成立,则结束循环

do{
    语句1;
    ...;
}while(表达式);

3.转移结构

1.break

• 仅用于跳出循环结构
• 且仅能跳出一层循环结构

for(i=10;i>0;i--)
{
    t = 10;
    while(t--)
    {
        dat++;
        if(dat == 3)
            break;//跳出while()结构。
    } 
}

2.continue

• 用于终止本次循环,继续从下次循环开始
• 正式程序中不使用,仅用于调试程序

char buf = 10;
while(buf--)
{ 
    a++;
    b++;
    continue;//遇到continue则结束这次循环
    d++; //这条永远都不会执行到 
    e++; //这条永远都不会执行到 
}

3.goto

• 无条件转移
• 一般都不建议在大的程序当中使用

unsigned char dat=10;
while(dat--)
{ 
    a++;
    b++;
    Lable: c++;
    if(c == 3)
        goto Lable;//直接跳到Lable标号去 
    d++;
}

4.return

• 用于函数返回,在函数调用时,遇到return即返回。
• 如果需要返回某个值,在其后加上返回值。
• 返回值类型必须和函数类型一致

void function()
{
    char a,b; 
    a++;
    return; //遇到return即返回调用处
    b++; //不会被执行
    return; //不会被执行
}

其它

1.typedef

typedef : 类型重定义

typedef与宏定义define的区别：

typedef	define
typedef 是在编译阶段进行定义	宏定义是在预编译处理阶段完成展开
typedef 是类型重新定义,不是简单地替换	宏定义只是简单的替换,没有定义

//1.用uchar重新定义unsigned char
typedef unsigned char uchar;

//2.用uchar 替换unsigned char
#define uchar unsigned char

typedef unsigned char* M;
#define M unsigned char*
M p1,p2;
//对于typedef来说：p1是指针变量,p2也是
//对于宏定义来说：p1是指针变量,p2是普通变量

2.sizeof

sizeof：用来求类型所占的字节数

int var = 10;
char g; 
g = sizeof(var++);//g = 4;
//注意：var++该条语句没有被执行！
//()里的语句是不会被执行的。