C语言基础关键字的含义和使用方法

​关键字在C语言中扮演着非常重要的角色，它们定义了语言的基本构造和语法规则，通过使用关键字，开发者可以创建变量、定义数据类型、控制程序流程（如循环和条件判断）、声明函数等。由于这些字是保留的，所以编程者不能将它们用作自定义的标识符，以避免与语言本身的语法产生冲突。不同的编译器和版本会有不同的扩展关键字，常用C语言标准是C89、C99、C11、C17、C23，c/c++ 标准可以在以下标准官网查看：
https://en.cppreference.com/w/c/23
https://isocpp.org/
https://www.iec.ch/homepage
以下是最常见的C语言关键字。

关键字类型

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

其中数据类型关键字包括：char、double、float、int、long、short、signed、struct、union、unsigned、void、enum，用于声明不同类型的数据或函数。

控制语句关键字包括：循环语句的for、do、while、break、continue；条件语句的if、else、goto；开关语句的switch、case、default；以及返回语句的return，用于控制程序的流程。

存储类型关键字包括：auto、extern、register、static、typedef，这些关键字用于指定变量的存储类型和可见性。

其他关键字包括：const、sizeof、volatile。

数据类型关键字

​
数据类型关键字含义表如下：

关键字	含义
char	字符数据类型，用于存储单个字符，通常占用1个字节。
double	双精度浮点数数据类型，可以存储大范围和高精度的实数，通常占用8个字节。
float	单精度浮点数数据类型，用于存储实数，精度和范围较double小，通常占用4个字节。
int	整型数据类型，用于存储整数，大小依赖于编译器和平台，通常是4个字节。
long	长整型数据类型，用于存储较大的整数，大小依赖于编译器和平台，通常至少4个字节。
short	短整型数据类型，用于存储较小的整数，通常占用2个字节。
signed	有符号数据类型，与整型结合使用，表示可以存储正数和负数（默认是有符号的）。
struct	定义一个结构体类型，结构体是一种用户自定义的数据类型，包含多个数据成员。
union	定义一个联合体类型，允许在相同内存位置存储不同类型的数据，但一次只能存储一种。
unsigned	无符号数据类型，与整型结合使用，表示只能存储非负整数。
void	无类型，常用于表示函数不返回任何值，或用于通用指针类型（void*）。
enum	定义枚举类型，枚举是一种包含命名整型常量的用户定义类型，提供更易读和类型检查。

可以看到除了字符数据和整数、浮点数、非负整数(unsigned)以外，还存在枚举类型、结构体、联合体及无类型关键字.

整数、浮点数、非负整数的运用：

#include <stdio.h>

int main() {  
    // char 
    char c = 'A';  
    printf("字符类型: %c\n", c);  
  
    // double  
    double d = 3.141592653589793;  
    printf("双精度浮点类型: %f\n", d);  
  
    // float 
    float f = 3.14f;  
    printf("单精度浮点类型: %f\n", f);  
  
    // int 类型  
    int i = 10;  
    printf("整型: %d\n", i);  
  
    // long 类型  
    long l = 123456789L;  
    printf("长整型: %ld\n", l);  
  
    // short 类型  
    short s = 123;  
    printf("短整型: %d\n", s);  
  
    // signed 类型（通常int默认就是signed int）  
    signed int si = -10;  
    printf("有符号整型: %d\n", si);  
   
    // unsigned 类型  
    unsigned int ui = 4294967295; // 最大的32位无符号整数  
    printf("无符号整型: %u\n", ui);  

    return 0;  
}

以上代码运行结果：

枚举类型：

枚举是一种用户定义的数据类型，它允许为整数值分配有意义的名称，通过使用枚举，可以使用描述性的名称而不是数字来表示特定的值，

#include <stdio.h>  
  
// 定义枚举类型Pig  
enum Pig { GGBOND, FEIFEI, CHAORENQIANG };  
  
int main() {  
    enum Pig favoritName = GGBOND; // 声明并初始化枚举变量  
  
    // 使用 switch 语句根据枚举值进行不同的操作  
    switch (favoritName) {  
        case FEIFEI:  
            printf("My favoriteName is FEIFEI.\n");  
            break;  
        case GGBOND:  
            printf("My favoriteName is GGBOND.\n");  
            break;  
        case CHAORENQIANG:  
            printf("My favoriteName is CHAORENQIANG.\n");  
            break;  
        default:  
            printf("Unknown pig's name.\n");  
            break;  
    }  
  
    return 0;  
}

结构体：

结构体通常用于表示具有多个属性的复杂对象，如一只包含姓名、年龄和地址的猪猪，它允许将不同类型的数据组合成一个单一的复合类型。

#include <stdio.h>  
#include <string.h>  
  
// 定义结构体类型 PIG  
struct PIG {  
    char name[50];  // [50]表示访问结构体成员name中索引为50的字符
    int age;  
};  
  
int main() {  
    struct PIG PIG; // 声明结构体变量  
    strcpy(PIG.name, "GGBond");
    PIG.age = 18; 
  
    printf("Name: %s\n", PIG.name);  
    printf("Age: %d\n", PIG.age);  
  
    return 0;  
}

联合体：

联合体也是一种用户定义的数据类型，它允许在相同的内存位置存储不同的数据类型，但一次只能存储其中之一,一般用于节省内存，因为它只分配足够的内存来存储其最大的成员，所有成员都共享这块内存。

#include <stdio.h>  
#include <string.h>
  
// 定义联合体类型 Data  
union Data {  
    int i;  
    float f;  
    char str[20];  
};  
  
int main() {  
    union Data data; // 声明联合体变量  
    data.i = 10; // 给整型成员赋值  
    printf("Integer value: %d\n", data.i); 
  
    data.f = 3.14f; // 给浮点型成员赋值，整型值被覆盖  
    printf("Float value: %f\n", data.f); 
  
    strcpy(data.str, "Hello GGBond"); // 给字符串成员赋值，整型和浮点型值都将覆盖  
    printf("String value: %s\n", data.str); 
  
    return 0;  
}
// 通常不会在一个联合体中混合使用不同类型的成员，并频繁地改变值，可能会导致未定义的行为。

#### 无类型：
void类型常用于函数返回类型，表示该函数不返回任何值，它也可以用作指针类型void*，表示一个通用指针，可以指向任何类型的数据（常用于泛型编程或处理不同类型数据的函数）。

#include <stdio.h>  
  
// 声明一个返回类型为 void 的函数，表示该函数不返回任何值  
void printMessage(const char *message) {  
    printf("%s\n", message);  
}  
  
int main() {  
    printMessage("Hello GGBond!"); // 调用函数，不期望返回值  
    return 0;  
}

控制语句关键字

关键字	描述
for	用于创建一个循环，该循环将重复执行一段代码，直到满足某个条件。通常用于已知循环次数的场景。
do	与while一起使用，创建一个后测试的循环。即无论条件是否满足，循环体至少会执行一次。
while	用于创建一个循环，只要指定的条件为真，就会重复执行一段代码。
break	用于立即退出循环或switch语句，跳过循环或switch语句中剩余的代码，并继续执行紧随其后的语句。
continue	用于跳过当前循环的剩余代码，并立即开始下一次循环迭代。
条件语句
if	用于基于某个条件来执行代码。如果条件为真，则执行if语句后的代码块。
else	与if语句一起使用，如果if语句的条件为假，则执行else语句后的代码块。
goto	用于无条件地跳转到程序中指定的标签处继续执行。通常不建议使用，因为它可能使程序流程变得难以理解和维护。
开关语句
switch	用于基于一个表达式的值来选择多个代码块之一来执行。通常用于多个条件分支的场景。
case	在switch语句中使用，表示一个具体的分支条件。如果switch表达式的值与某个case标签的值匹配，则执行该case后的代码。
default	在switch语句中使用，表示当没有case标签与switch表达式的值匹配时执行的默认代码块。
返回语句
return	用于从函数中返回一个值，并结束函数的执行。如果函数没有返回值，则可以使用return;来提前退出函数。

这个表格简要概述了这些关键字在C语言中的基本含义。在实际编程中，这些关键字的使用可能会更加复杂和灵活。

循环语句：

for循环：

#include <stdio.h>  
  
int main() {  
    int i;  
    for (i = 0; i < 5; i++) {  
        printf("%d ", i);  
    }  
    return 0;  
}  

do-while 循环

#include <stdio.h>  
  
int main() {  
    int i = 0;  
    do {  
        printf("%d ", i);  
        i++;  
    } while (i < 5);  
    return 0;  
}  

break 语句

#include <stdio.h>  
  
int main() {  
    int i;  
    for (i = 0; i < 10; i++) {  
        if (i == 5) {  
            break; // 当 i 循环到 5 时退出循环  
        }  
        printf("%d ", i);  
    }  
    return 0;  
}  

条件语句

if判断

#include <stdio.h>  
  
int main() {  
    int x = 10;  
    if (x > 5) {  
        printf("x is greater than 5\n");  
    }  
    return 0;  
}  

else 语句

#include <stdio.h>  
  
int main() {  
    int x = 3;  
    if (x > 5) {  
        printf("x is greater than 5\n");  
    } else {  
        printf("x is not greater than 5\n");  
    }  
    return 0;  
}  

continue:
用于在循环中跳过当前迭代的剩余部分，并立即开始下一次迭代

#include <stdio.h>  
  
int main() {  
    for (int i = 0; i < 10; i++) {  
        if (i % 2 == 0) {  
            continue; // 跳过偶数，只打印奇数  
        }  
        printf("%d\n", i);  
    }  
    return 0;  
}

goto:
用于无条件跳转到程序中指定的标签位置。尽管goto在现代编程中通常不推荐使用，因为它可能导致代码流程难以追踪和理解，在某些特定情况下使用

#include <stdio.h>  
  
int main() {  
    int i;  
    for (i = 0; i < 10; i++) {  
        if (i == 5) {  
            goto skip_loop; // 当i等于5时，跳出循环  
        }  
        printf("%d\n", i);  
    }  
skip_loop:  
    printf("Loop skipped when i was %d\n", i);  
    return 0;  
}

case和default:
用于switch语句中，用于根据不同的条件执行不同的代码块。case后面跟的是要匹配的值，而default是当没有case匹配时执行的代码块。

#include <stdio.h>  
  
int main() {  
    int day = 4; 
    switch (day) {  
        case 1:  
            printf("Monday\n");  
            break;  
        case 2:  
            printf("Tuesday\n");  
            break;  
        case 3:  
            printf("Wednesday\n");  
            break;  
        case 4:  
            printf("Thursday\n");  
            break;  
        case 5:  
            printf("Friday\n");  
            break;  
        case 6:  
            printf("Saturday\n");  
            break;  
        case 0:  
            printf("Sunday\n");  
            break;  
        default:  
            printf("Invalid day number\n"); // 如果day不是0到6之间的数字，将执行此语句  
            break;  
    }  
    return 0;  
}

开关语句

switch 语句

#include <stdio.h>  
  
int main() {  
    int day = 3;  
    switch (day) {  
        case 1:  
            printf("Monday\n");  
            break;  
        case 2:  
            printf("Tuesday\n");  
            break;  
        case 3:  
            printf("Wednesday\n");  
            break;  
        default:  
            printf("Other day\n");  
    }  
    return 0;  
}  

返回语句

return 语句

#include <stdio.h>  
  
int add(int a, int b) {  
    return a + b; // 返回 a 和 b 的和  
}  
  
int main() {  
    int sum = add(3, 4);  
    printf("Sum: %d\n", sum);  
    return 0;  
}  

存储类型关键字

关键字	含义
auto	声明变量的生存期为自动，即变量在进入其声明的程序块时建立，在该程序块活动时存在，退出该程序块时撤销。但在现代C语言中，由于所有非全局变量的缺省值都假定为auto，因此这个关键字很少显式使用。
extern	声明一个变量或函数是在其他地方定义的，具有外部链接。它告诉编译器这个变量或函数是在其他文件中定义的，编译器会在链接阶段将其与其他文件中的定义进行关联。通常用于跨文件共享变量或函数。
register	提示编译器该变量是一个频繁使用的变量，如果可能的话，应该将它存储在CPU的寄存器中以提高访问速度。但现代编译器通常会自动进行优化，因此这个关键字的实际效果可能因编译器而异。
static	用于修饰局部变量、全局变量和函数。对于局部变量，它会使变量存储在静态区，函数返回时值保持不变，且下次进入函数时依然存在。对于全局变量，它会限制变量的作用域仅在当前文件内，避免不同文件同名变量的冲突。对于函数，它会使函数只能在声明它的文件内可见。
typedef	为现有的数据类型定义一个新的名称。它通常用于简化复杂的类型声明或为某种类型创建更具描述性的名称。typedef并不创建新的数据类型，而是为现有的数据类型创建一个别名。

auto:
用于声明自动变量，但在C语言中，局部变量默认就是自动变量，基本很少使用：

#include <stdio.h>  
  
int main() {  
    auto int a = 10; // 这里的auto是可选的，因为局部变量默认就是自动变量  
    printf("Value of a: %d\n", a);  
    return 0;  
}

extern:
用于声明全局变量或函数，表明它们的定义在别的文件中,以下是在一个文件夹中新建两个文件 GGBond1.c和GGBond2.c,随后编译运行GGBond2.c文件

// GGBond1.c
#include <stdio.h>  
  
int global_var = 10; // 全局变量定义  
  
void print_global_var() {  
    printf("Value of global_var: %d\n", global_var);  
}

// GGBond2.c
#include <stdio.h>  
  
extern int global_var; // 声明在其他文件中定义的全局变量  
extern void print_global_var(); // 声明在其他文件中定义的函数  
  
int main() {  
    printf("Accessing global_var from another file: %d\n", global_var);  
    print_global_var(); // 调用在其他文件中定义的函数  
    return 0;  
}

编写完成后在终端同时编译两个文件：

gcc GGBond1.c GGBond2.c -o GGBond2

运行编译好的GGBond2文件：

./GGBond

register:
这个关键字用来建议编译器将变量存储在寄存器中以提高访问速度，但现代编译器通常会自动进行优化，基本很少使用：

#include <stdio.h>  
 
int main() {  
   register int counter = 0; // 建议编译器将counter存储在寄存器中  
   for (int i = 0; i < 10000; i++) {  
       counter++;  
   }  
   printf("Counter: %d\n", counter);  
   return 0;  
}

static:
这个关键字有多个用途，包括定义静态变量和静态函数。静态变量在程序执行期间只初始化一次，而静态函数只能在定义它的文件中访问。

#include <stdio.h>  
 
void static_function() { // 静态函数，只能在当前文件中调用  
   static int call_count = 0; // 静态变量，只初始化一次  
   call_count++;  
   printf("static_function called %d times\n", call_count);  
}  
 
int main() {  
   static_function();
   static_function();
   return 0;  
}

typedef:
这个关键字用于为数据类型定义别名，使代码更易读和维护（强烈推荐使用）

#include <stdio.h>  
  
typedef unsigned long ulong; // 为unsigned long定义别名ulong  
typedef struct {  
    int x;  
    int y;  
} Point; // 为结构体定义别名Point  
  
int main() {  
    ulong number = 123456789012345UL; // 使用别名ulong代替unsigned long  
    Point p = {5, 10}; // 使用别名Point代替结构体名称  
    printf("Number: %lu, Point: (%d, %d)\n", number, p.x, p.y);  
    return 0;  
}

restrict：
用于告诉编译器，两个或多个指针不会指向相同的内存地址，从而允许编译器进行更优化的内存访问。

/*
构建一个add_arrays函数，使用restrict关键字来表明a、b和c三个指针不会指向相同的内存区域,
允许编译器在生成代码时进行更优化的内存访问。
*/
#include <stdio.h>  
  
void add_arrays(const int *restrict a, const int *restrict b, int *restrict c, int n) {  
    for (int i = 0; i < n; i++) {  
        c[i] = a[i] + b[i];  
    }  
}  
  
int main() {  
    int a[5] = {1, 2, 3, 4, 5};  
    int b[5] = {6, 7, 8, 9, 10};  
    int c[5];  
    add_arrays(a, b, c, 5);  
     
    for (int i = 0; i < 5; i++) {  
        printf("%d ", c[i]);  
    }    
    return 0;  
}

inline:
用于建议编译器将函数的调用替换为函数体的直接插入，以减少函数调用的开销。

#include <stdio.h>  
  
inline int square(int x) {  
    return x * x;  
}  
  
int main() {  
    int x = 5;  
    printf("The square of %d is %d\n", x, square(x));  
      
    return 0;  
}

其他类型关键字

关键字	含义
const	声明一个变量的值是不可变的，即常量。这意味着一旦赋值后，其值就不能被修改。这有助于增加代码的可读性和安全性，防止意外修改不应改变的值。
sizeof	运算符，用于获取特定类型或对象在内存中所占的字节大小。这有助于内存管理和优化，以及确保数据结构的大小符合预期。
volatile	告诉编译器不要优化涉及该变量的代码，因为它可能会在程序运行时被意外地改变。这通常用于多线程环境、硬件访问或中断服务程序中，以确保每次使用该变量时都从内存中重新读取其值，而不是使用缓存的值。

这些关键字在C语言编程中起着重要作用，帮助开发者更精确地控制变量的行为和内存使用。

声明常亮关键字

声明常量使用const关键字，被他声明的值在程序运行期间不能被修改

#include <stdio.h>  
  
int main() {  
    const int a = 10; // 声明一个常量整数a，并初始化为10,如果尝试修改a的值，编译器会报错  
    int a = 20; 
    printf("Value of a: %d\n", a); 
  
    return 0;  
}

运行后会报错，删掉 int a = 20; 即可正常运行：

test.c: In function ‘main’:
test.c:6:9: error: conflicting type qualifiers for ‘a’
    6 |     int a = 20;
      |         ^
test.c:4:15: note: previous definition of ‘a’ with type ‘int’
    4 |     const int a = 10; // 声明一个常量整数a，并初始化为10
      |               ^

sizeof 关键字

sizeof是一个运算符，用于获取数据类型或对象在内存中所占的字节数

#include <stdio.h>  
  
int main() {  
    printf("Size of char: %zu bytes\n", sizeof(char));  
    printf("Size of int: %zu bytes\n", sizeof(int));  
    printf("Size of float: %zu bytes\n", sizeof(float));  
    printf("Size of double: %zu bytes\n", sizeof(double));  
  
    int array[10];  
    printf("Size of array: %zu bytes\n", sizeof(array));  

    char GGBond[10];
    printf("Size of GGBond: %zu bytes\n", sizeof(GGBond));
  
    struct ExampleStruct {  
        int a;  
        float b;  
    };  
    printf("Size of struct ExampleStruct: %zu bytes\n", sizeof(struct ExampleStruct));  
  
    return 0;  
}

volatile 关键字

volatile关键字用于告诉编译器，某个变量的值可能会在编译器无法检测到的情况下被改变，因此编译器不应对其进行优化。这通常用于多线程编程、硬件访问或信号处理等场景。

#include <stdio.h>  
#include <stdbool.h>  
#include <unistd.h> // 使用里面的sleep函数  
#include <pthread.h> // 多线程操作  
  
volatile bool stop = false; 
  
void* threadFunction(void* arg) {  
    while (!stop) {  
        // 模拟一些工作  
        sleep(1);  
    }  
    return NULL;  
}  
  
int main() {  
    pthread_t thread;  
    pthread_create(&thread, NULL, threadFunction, NULL);  
    sleep(5); // 主线程休眠5秒  
    stop = true; // 修改volatile变量停止工作线程  
    pthread_join(thread, NULL); // 等待工作线程结束  
    printf("Thread stopped.\n");  
  
    return 0;  
}
/*
stop变量被声明为volatile，以确保当主线程修改它的值时，
工作线程能够立即看到这个变化，而不会因为编译器的优化而延迟或忽略这个变化
*/

关键字总表

数据类型关键字

关键字	含义
char	字符类型
double	双精度浮点类型
float	单精度浮点类型
int	整型
long	长整型
short	短整型
signed	有符号整型（可省略，因为整型默认就是有符号的）
unsigned	无符号整型

存储类别关键字

关键字	含义
auto	自动变量（默认存储类别）
extern	外部变量声明
register	寄存器变量
static	静态变量

控制语句关键字

关键字	含义
break	跳出循环或switch语句
case	switch语句中的一个分支标签
continue	跳过当前循环的剩余部分，进入下一次循环
default	switch语句中的默认分支标签
do	do-while循环的开始
else	if语句的else分支
for	for循环
goto	无条件跳转到指定的标签
if	条件语句
return	从函数中返回
switch	switch选择结构
while	while循环

其他关键字

关键字	含义
const	定义常量或只读变量
inline	建议编译器内联函数（即将函数调用替换为函数体）
restrict	指出指针是访问其指向对象的唯一方式
sizeof	获取数据类型或对象的大小（字节为单位）
typedef	为数据类型定义别名
volatile	提示编译器该变量可能会被意外改变

复杂数据类型和结构关键字

关键字	含义
enum	枚举类型
struct	结构体类型
union	联合类型

Markdown版本总表

**数据类型关键字**

| 关键字 | 含义 |
| --- | --- |
| `char` | 字符类型 |
| `double` | 双精度浮点类型 |
| `float` | 单精度浮点类型 |
| `int` | 整型 |
| `long` | 长整型 |
| `short` | 短整型 |
| `signed` | 有符号整型（可省略，因为整型默认就是有符号的） |
| `unsigned` | 无符号整型 |

**存储类别关键字**

| 关键字 | 含义 |
| --- | --- |
| `auto` | 自动变量（默认存储类别） |
| `extern` | 外部变量声明 |
| `register` | 寄存器变量 |
| `static` | 静态变量 |

**控制语句关键字**

| 关键字 | 含义 |
| --- | --- |
| `break` | 跳出循环或switch语句 |
| `case` | switch语句中的一个分支标签 |
| `continue` | 跳过当前循环的剩余部分，进入下一次循环 |
| `default` | switch语句中的默认分支标签 |
| `do` | do-while循环的开始 |
| `else` | if语句的else分支 |
| `for` | for循环 |
| `goto` | 无条件跳转到指定的标签 |
| `if` | 条件语句 |
| `return` | 从函数中返回 |
| `switch` | switch选择结构 |
| `while` | while循环 |

**其他关键字**

| 关键字 | 含义 |
| --- | --- |
| `const` | 定义常量或只读变量 |
| `inline` | 建议编译器内联函数（即将函数调用替换为函数体） |
| `restrict` | 指出指针是访问其指向对象的唯一方式 |
| `sizeof` | 获取数据类型或对象的大小（字节为单位） |
| `typedef` | 为数据类型定义别名 |
| `volatile` | 提示编译器该变量可能会被意外改变 |

**复杂数据类型和结构关键字**

| 关键字 | 含义 |
| --- | --- |
| `enum` | 枚举类型 |
| `struct` | 结构体类型 |
| `union` | 联合类型 |