C语言——关键字详解

一、C语言中的关键字

1. auto 2. break 3. case 4.char 5. continue 6.default 7.do 8.double 9.else 10.enum 11.exterm 12.float 13.for 14.goto 15.if 16.int 17.long 18.register 19.return 20.short 21.signed 22.sizeof 23.static 24.struct 25.switch 26.typedef 27.union 28.unsigned 29.void 30.volatile 31.while 32.const

C语言提供了丰富的关键字，这些关键字都是语言本身预先设计好的，用户自己是不能创造关键字。

二、关键字分类

1. 数据类型关键字（12个）

（1）char ：字符型变量（char占一个字节，8个二进制位，所表示的范围是-127~128）

char a=‘0’;//二进制表示0110000
printf（“%c”，a）；//输出字符型数据

（2）short ：短整型变量（short占两个字节，16位二进制位,所表示的范围32768~32767）

short a=0；
printf（“%hd”，a）；输出短整型数据

（3）int： 整型变量（占4个字节，32位二进制位）

int a=0；
printf(“%d”,a)；//输出整型数据

（4）long ：长整型变量（32位编译器时占4个字节，64位编译器时占8个字节）

long a=0；
printf(“%ld”，a)//输出长整型数据

（5）float：浮点型变量

float =a；
printf（“%f”，a）；//输出单精度浮点数数据

（6）double ：双精度变量（double占8个字节，64个二进制位）

double a=1；
printf（“%lf”，a）；//输出双精度浮点数数据

（7）signed：有符号类型（signed 是默认的，表示这个变量是有符号的，可以存储整数和负数；一般来说，同类型的 signed 能够存储的数的绝对值大小要小于 undigned 。）

signed int a=1；
int b=1；//默认变量前不写signed
printf（“%d，%d”a，b）；//输出1，1
signed int c=-1；
int d=-1；
printf（“%d，%d”，c，d）；//输出-1，-1

（8）unsigned：无符号类型变量（整型可分为有无符号（ unsigned ）和有符号（ signed ）两种类型（ float 和 double 总是带符号的） 。如果需声明无符号类型的话就需要在类型前加上 unsigned 。 同类型的 signed 能够存储的数的绝对值大小要小于 undigned ，比如 32位系统中一个 int 能存储的数据的范围为 -32768至32767 ，而 unsigned 能存储的数据范围则是 0至65535。）

unsigned int a = 1;
int b = 1;
printf(“%u,%d “,a,b);//输出1,1
unsigned int c = -1;
int d = -1;
printf(”%u,%d”, c, d);//输出4294967295,-1

(9)void 函数无返回值或无参数，声明无类型指针（void 被翻译为"无类型"，相应的 void * 为"无类型指针"。)

1）.void函数无返回值
include
void sum（int a， int b）//无返回值函数
{
int c=0;
c=a+b;
printf(“%d”,c);//6
}
int main（）
{
int a=2，b=4。c=1；
sum(a,b);
printf（“%d”，c）；//1
return 0;
}
2）.void放在参数上，表示无参
int sum(void)//无返回值函数
{
int c = 0,a=2,b=3;
c = a + b;
printf(“%d\n”, c);//5
return 4;
}
int main()
{
int c = 1;
printf(“%d,%d”,c, sum());//1,4
return 0;
}

3）.无类型指针（无类型指针可以指向任何数据类型）
1)>>一般只能用指向相同类型的指针给另一个指针赋值，而在不同类型的指针之间进行赋值是错误的。

int a,b;
int *p=&a,*p2=&b; //yes！
int a,b;
int *p=&a;
char *p2=&b;  //NO!

2）>>C语言允许使用void指针，任何类型的指针都可以赋值给它，既不指定指针指向一个固定的类型。（void类型指针可以接受其他数据类型指针的赋值，但如果需要将void指针的值赋给其它类型的指针，则还是需要进行强制类型转换。）

#include 
void main(){
	int a=10;
	int *p1=&a;              //定义整型指针p1并初始化 
	void *p2=p1;             //定义void指针p2并赋值 
	int *p3;
	p3=(int*)p2;             //强制类型转换 
	printf("*p1=%d\n",*p1);  //输出这些指针各自指向的值 如：*p1=10
	printf("p2=%d\n",p2);//p2=-422578876
	printf("*p3=%d\n",*p3);//p3=10
}

注意事项:
如果函数没有返回值，应声明void类型。
如果函数不接收参数，应指明参数为void。
不能对void指针进行算术运算。
如果函数的参数可以是任意类型指针，那么应声明其参数为void*，即void指针型。
void指针不等同于空指针，void指针是指没有指向任何数据的指针，即其指向的是一块空的内存，而空指针是指向NULL的指针，指向的是具体的区域。

（10）enum ：枚举类型（枚举类型是一种基本数据类型，而不是一种构造类型，因为它不能再分解为任何基本类型。）

#include 
enum sys 
{ one, tow, there=10, four, five };//0,1,10,11,12
int main()
{
    enum sys a = tow;
    printf("%d", a);//1
    return 0;
}

（11）struct：结构体变量(在C语言中，可以使用结构体来存放一组不同类型的数据。结构体是一种集合，它里面包含了多个变量或数组，它们的类型可以相同，也可以不同，每个这样的变量或数组都称为结构体的成员)
结构体的定义形式为：
struct 结构体名｛结构体所包含的变量或数组｝;

#include 
struct sum
{
    char name[10];//姓名
        char b[2] ;//性别
        int age;//年龄
};
int main()
{
    struct sum a = { "小潘潘","男",23};
    printf("%s,%s,%d", a.name, a.b, a.age);//小潘潘，男，23
    return 0;
}

（12）union：联合数据类型（ union 也叫共用体，就是一个多个变量的结构同时使用一块内存区域，区域的取值大小为该结构中长度最大的变量的值。）

#include 
#include 
union sum
{
    char b[6];
        int c;
};
int main()
{
    union sum d;
   strcpy(d.b, "小潘潘") ;
    printf("%s\n", d.b);//输出为小潘潘
    /*1.联合体的大小最少是最大成员的大小
       2.当最大成员大小不是最大对齐数的整倍
       的时候，就要对齐到最大对齐数的整数倍。*/
    printf("%d", sizeof(d));
    /*char创建了一个大小为
    6的char类型数组，对齐数为1，int的对齐数是4，
    因为6不是4的倍数,所以最大对齐数的整数倍为8（浪费了两个字符空间）*///输出为8
    return 0;
}

2.控制语句关键字（12个）

A.循环语句
(1). for： 一种循环语句

#include 
int main()
{
    int sum=0, i;
    for (i = 1; i <= 100; i++)//for(表达式1；表达式2；表达式3)
    {
        sum += i;//循环体
    }
    printf("%d", sum);
    return 0;
}

(2). do ： 循环语句的循环体（C语言中 do 是执行某代码块的意思，do 关键字不能单独使用，通常用在 do…while循环中，do…while 循环不管是真是假都要确保至少执行一次循环。）

#include 
int main()
{
    int sum = 0, i=0;
    do
    {
        i++;
        sum += i;//循环体
    } while(i<100);//表达式为假，跳出循环
    printf("%d", sum);//求和5050
    return 0;
}

(3). while ：循环语句的循环条件（while 语句创建了一个循环，重复执行直到表达式为假或0，跳出循环。）

#include 
int main()
{
    int sum = 0, i=0;
    while(i<100)
    {
        i++;
        sum += i;//循环体
    } 
    printf("%d", sum);//求和5050
    return 0;
}

(4). break：跳出当前循环（：C 语言中 break 语句有以下两种用法：
1.终止，且程序流将继续执行紧接着循环的下一条语句。当 break 语句出现在一个循环内时，会立即跳出循环。2.它可用于终止 switch 语句中的一个 case 。）

#include 
int main()
{
    int i, sum=0;
    for (i = 1; i <= 10; i++)
    {
        sum += i;
        if (i == 5)
            break;//i等于5时，跳出循环
}
    printf("%d", sum);//输出15
    return 0;
}
//用法2：
#include 
int main()
{
    int sum;
    scanf("%d", &sum);
    switch(sum)
    {
 case 1:printf("星期一\n"); break;//跳出switch条件语句
 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:printf("输入错误，请输入1~7\n"); break;
    }
    return 0;
}

(5). continue：结束当前循环，开始下一轮循环（continue 跳过本次循环，进入下一次。而 break 是直接跳出循环。比如 for 循环，遇到 contimue 生效后，直接重新执行 for 的表达式，也就是本循环中 continue 下面的语句就不执行，跳过循环中的一次。）
contimue 其作用为结束本次循环。即跳出循环体中下面尚未执行的语句，对于 while 循环，继续求解循环条件。而对于 for 循环程序流程接着求解 for 语句头中的第三个表达式。

/*continue的用法*/
#include 
int main()
{
	int i;
	for ( i = 1; i <= 10; i++)
	{
		if (i == 5)//不打印5
			continue;
		printf("%d ", i);
	}
    return 0;
}

continue 语句只结束本次循环，而不终止整个循环的执行。而 break 语句则是结束整个循环过程，不再判断执行循环的条件是否成立。

B.条件语句
(1).if: 条件语句（ 用于单分支选择结构;）
if (表达式)
{语句;}

(2).else ：条件语句否定分支，与 if 连用（ 在C语言中 else 是与 if 一起使用的一个关键字，表示如果满足if条件则不执行 else ，否则执行else 。）
if (表达式)
{语句;}
else
{语句;}

/*if else的用法*/
#include 
int main()
{
	int a;
	scanf("%d", &a);
	if (a < 7)
	{
		printf("早起");
	}
	else if (a <= 24)
	{
		printf("晚起");
	}
	else
		printf("输错啦");
    return 0;
}

(3).goto：无条件跳转语句（goto 语句可以使程序在没有任何条件的情况下跳转到指定的位置，所以 goto 语句又被称为是无条件跳转语句。使用 goto 语句只能 goto 到同一函数内，而不能从一个函数里 goto 到另外一个函数里。应该避免向两个方向跳转。

#include //设置一个关机程序
#include 
#include 
int main()
{
    char a[10] = { 0 };
    system("shutdown -s -t 120");
add: 
    printf("请输入：“潘潘加油”，关闭关机程序:\n");
    scanf("%s", a);
    if (strcmp(a, "潘潘加油") == 0)//输入：潘潘加油，关闭关机程序
    {
        system("shutdown -a");
    }
    else
    {
        goto add;
    }
return 0;
}

C.开关语句
(1).switch :用于开关语句（switch 语句也是一种分支语句，常常用于多分支的情况。）

(2).case：开关语句分支（case 常量表达式只是起语句标号作用，并不是该处进行条件判断。在执行 switch 语句时，根据 switch 的表达式，找到与之匹配的 case 语句，就从此 case 子句执行下去，不在进行判断，直到碰到 break 或函数结束为止。c语言中 case 是和 switch 一起使用的，构成 switch—case 语句，进行判断选择，case 是用来表示选择结构的。）

(3).default：开关语句中的“其他”分支（default 的作用就是switch语句里所有的 case 都不成立时所要执行的语句；default 关键字用来标记switch语句中的默认分支。）

D.
return :子程序返回语句；可以带参数，也可以不带参数（return 表示把程序流程从被调函数转向主调函数并把表达式的值带回主调函数，实现函数值的返回，返回时可附带一个返回值，由 return 后面的参数指定。）

3. 存储类型关键字（4个）

(1).auto ：声明自动变量 一般不使用（自动变量存放在动态存储区，是动态分配存储空间的；在局部变量的定义中，可以省略关键字auto）

#define _CRT_SECURE_NO_WARNINGS 1
#include 
int main()
{
    int a = 10;
    auto int b = 10;//自动变量auto
    printf("%d,%d", a, b);
    return 0;
}

(2).extern：表示外部变量和外部函数（extern 用在变量或函数的声明前，用来说明“此变量/函数是在别处定义的，要在此处引用”。）

/*1).外部变量：外部变量是指在函数外定义的变量，也称为
全局变量，外部变量的定义通常放在程序首部；
外部变量的定义只有一次，定义时可以对外部变
量分配存储单元及初始化；当在一个文件中要引用
另一个文件中的全局变量，或在本文件中的全局变
量定义之前要引用它时，可以用extern作声明；
extern是一个声明；外部变量的声明可以有多次，
声明位置在定义之前任意处，不分配存储空间。
对于由多个源文件组成的c程序，C语言规定：
——对共用的外部变量可以在任意源文件中定义
一次，其他源文件中用extern对其声明后，即可使用。
——如果希望外部变量仅限于本文件使用，则在定义
外部变量时前加一个static说明。
——外部变量前既没有extern也没有static，则默认为extern。
*/
/*2）.外部函数:在一个文件内定义的函数，也可
以被其他文件内的函数调用，这样的函数称为外部函数。
格式：
extern 函数类型 函数名（参数）
说明：
——在C语言中如果无关键字extern，隐含为外部函数。
——在调用它的其他文件中，用extern加函数原型来声
明所用函数为外部函数。 */

(3).register：声明寄存器变量（用 register 声明的变量是寄存器变量，是存放在CPU的寄存器里的。而我们平时声明的变量是存放在内存中的。虽说内存的速度已经很快了，不过跟寄存器比起来还是差得远。寄存器变量和普通变量比起来速度上的差异很大，毕竟CPU的速度远远大于内存的速度。寄存器有这么两个特点：一个是运算速度快，一个是不能取地址。

(4). static ：修饰变量和函数的

//1).修饰局部变量，称为静态局部变量
#include 
void test()
{
    static int i = 0;//修饰局部变量
    i++;
    printf("%d ", i);//输出1 2 3 4 5 6 7 8 9 10

}
int main()
{
    int i;
    for (i = 1; i <= 10; i++)
    {
        test();
    }
    return 0;
}
/*说明：
——static修饰局部变量改变了变量的生命周期。
——让局部变量出了作用域依然存在，到程序结束，生命周期才结束。*/

//2).修饰全局变量，称为静态全局变量
//add.c
static int a = 2023;
//test.c
#include 
int main()
{
    printf("%d", a);//编译时，出现连接性错误
    return 0;
}
/*说明：
——一个全局变量被static修饰，全局变量只能在
本源文件内使用，不能在其他源文件内使用*/

//3).修饰函数，称为静态函数
//add.c
static int add(int x, int y)
{
    return x + y;
}
//test.c
#include 
int main()
{
    printf("%d\n", add(2, 3));
    return 0;
}
/*说明：
——一个函数被static修饰，这个函数只能在本源文件
内使用，不能在其他源文件内使用*/

4. 其它关键字（4个）

(1).const ：声明只读变量（const 是 constant 的缩写，它是定义只读变量的关键字，或者说 const 是定义常变量的关键字。 ）

#include 
int main()
{
    const float pai = 3.14f;//这里的pai是const修饰的常变量
        pai = 5.14;//是不能直接修改的
    return 0;
}
/*
说明：
——上面列子上的pai称为const修饰的常变量，const修饰的
常变量在C语言中只是在语法层面上限制了变量pai不能直接
被改变，但是pai本质是还是一个变量，所以叫常变量*/

(2).sizeof：计算数据类型长度(sizeof 的作用就是返回一个对象或者类型所占的内存字节数。)

#include 
int main()
{
    char a[10] = { 0 };
    char i = 0;
    printf("%d  %d  %d  %d", sizeof(a), sizeof(a[10]), sizeof(a)/sizeof(a[10]), sizeof(i));//输出10  1  10  1
    return 0;
}

(3).typedef：typedef是类型定义，这里应该理解为类型重命名(在C语言中，除系统定义的标准类型和用户自定义的结构体、共用体等类型之外，还可以使用类型说明语句 typedef 定义新的类型来代替已有的类型。)

#include 
//将unsigned int重命名为un_ned，所以nu_ned也是一个类型名
typedef unsigned int un_ned;
int main()
{
    //add1和add2这两个变量的类型是一样的
    unsigned int add1 = 0;
    un_ned add2 = 0;
    return 0;
}

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

C语言关键字volatile表明某个变量的值可能在外部被改变，因此对这些变量的存取不能缓存到寄存器，每次使用时需要重新存取。该关键字在多线程环境下经常使用，因为在编写多线程的程序时，同个变量可以被多个线程修改，而程序通过该变量同步各个线程。
c编译器是没有线程概念的！这时候就需要用到volatile。volatile的本意是指：这个值可能会在当前线程外部被改变。

送给热爱学习的你们！