C语言关键字详解

C语言有32个关键字，这些关键字是预定义的标识符，具有特殊的含义。下面我将这32个关键字按照功能分成几类，并提供一些简单的示例代码。

数据类型关键字

1. char

char是表示字符类型的关键字，用于声明单个字符或字符数组。

char = 1字节

示例代码：

char c = 'A'; // 声明一个字符变量c，初始值为字符'A'
char str[] = "Hello, world!"; // 声明一个字符数组str，初始值为字符串"Hello, world!"

2. int

int是表示整数类型的关键字，用于声明整型变量或数组。

int = 4字节

示例代码：

int x = 10; // 声明一个整型变量x，初始值为10
int arr[5] = {1, 2, 3, 4, 5}; // 声明一个包含5个整数的数组arr，初始值为1, 2, 3, 4, 5

3. float

float是表示浮点数类型的关键字，用于声明单精度浮点型变量或数组。

float = 4字节

示例代码：

float f = 3.14f; // 声明一个单精度浮点型变量f，初始值为3.14
float arr[3] = {1.2f, 2.3f, 3.4f}; // 声明一个包含3个单精度浮点数的数组arr，初始值为1.2, 2.3, 3.4

4. double

double是表示双精度浮点数类型的关键字，用于声明双精度浮点型变量或数组。

double = 8字节

示例代码：

double d = 3.1415926535; // 声明一个双精度浮点型变量d，初始值为3.1415926535
double arr[2] = {1.0, 2.0}; // 声明一个包含2个双精度浮点数的数组arr，初始值为1.0, 2.0

5. short

short 关键字用于声明短整数类型变量，通常用于需要限制变量范围时。

short = 2字节

示例代码：

short s = 10; // 声明一个短整数类型变量 s，初始值为 10

6. long

long 关键字用于声明长整数类型变量，可以存储更大范围的整数。

long = 4字节 ，long long = 8字节

示例代码：

long l = 100000L; // 声明一个长整数类型变量 l，初始值为 100000

7. unsigned

unsigned 关键字用于声明无符号整数类型变量，只能存储非负整数。

示例代码：

unsigned int u = 10; // 声明一个无符号整数类型变量 u，初始值为 10

8. signed

signed 关键字用于声明有符号整数类型变量，可以存储正数、负数或零。

示例代码：

signed int s = -10; // 声明一个有符号整数类型变量 s，初始值为 -10

9. void

void是一个特殊的数据类型关键字，表示无类型或无返回值。它通常用于函数声明中表示函数没有返回值。

示例代码：

void print_hello() { // 声明一个无返回值的函数print_hello
    printf("Hello, world!\n");
}

控制流关键字

10. if

if是用于条件语句的关键字，用于根据条件执行不同的代码块。

示例代码：

int main
{
    int x = 10;
    if (x > 0) { // 如果x大于0就执行下面的代码块
        printf("x is positive.\n");
    } else { // 否则执行这里的代码块
        printf("x is non-positive.\n");
    }
}

11. else

else是与if配合使用的关键字，用于在if条件不成立时执行一段代码块。

示例代码：

int main{
    {
    int x = 10;
    if (x > 0) {
        printf("x is positive.\n");
    } else { // 如果x小于等于0就执行这里的代码块
        printf("x is non-positive.\n");
    }
}

12. switch

switch是用于多分支选择的关键字，根据表达式的值跳转到不同的分支执行相应的代码块。

示例代码：

int option = 2;
switch (option) {
    case 1: // 如果option的值是1，执行这里的代码块
        printf("You chose option 1.\n");
        break;
    case 2: // 如果option的值是2，执行这里的代码块
        printf("You chose option 2.\n");
        break;
    case 3: // 如果option的值是3，执行这里的代码块
        printf("You chose option 3.\n");
        break;
    default: // 如果option的值不是1、2、3中的任何一个，执行这里的代码块
        printf("Invalid option.\n");
        break;
}

13. case

case是与switch配合使用的关键字，用于指定每个分支的值。

示例代码：

int main
{
    int option = 2;
     switch (option) {
        case 1:
            printf("You chose option 1.\n");
            break;
        case 2: // 当option的值为2时，执行这里的代码块
            printf("You chose option 2.\n");
            break;
        case 3:
            printf("You chose option 3.\n");
            break;
        default:
            printf("Invalid option.\n");
            break;
    }
}

14. default

default是与switch配合使用的关键字，用于指定当没有匹配的case分支时要执行的代码块。

示例代码：

int option = 4;
switch (option) {
    case 1:
        printf("You chose option 1.\n");
        break;
    case 2:
        printf("You chose option 2.\n");
        break;
    case 3:
        printf("You chose option 3.\n");
        break;
    default: // 当option的值不是1、2、3中的任何一个时，执行这里的代码块
        printf("Invalid option.\n");
        break;
}

15. while

while是用于循环语句的关键字，用于在条件成立时重复执行一段代码块。

示例代码：

int i = 0;
while (i < 10) { // 只要i小于10就一直执行下面的代码块
    printf("%d ", i);
    i++;
}
printf("\n");

16. do-while

do是与while配合使用的关键字，用于先执行一次代码块，然后在条件成立时重复执行。

示例代码：

int i = 0;
do { // 先执行一次下面的代码块，然后只要i小于10就一直重复执行
    printf("%d ", i);
    i++;
} while (i < 10);
printf("\n");

17. for

for是用于循环语句的关键字，用于指定循环的起始值、终止值和步长。

示例代码：

int main()
{
    int i=0;
    for (int i = 0; i < 10; i++) { // 从0到9，每次增加1，重复执行下面的代码块
        printf("%d ", i);
    }
    printf("\n");

}

18. break

break是用于跳出循环语句的关键字，用于在循环内部提前终止循环。

示例代码：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 当i等于5时跳出循环
    }
    printf("%d ", i);
}
printf("\n");

19. continue

continue是用于跳过循环中的当前迭代的关键字，用于在循环内部跳过某些迭代。

示例代码：

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue; // 当i是偶数时跳过本次迭代
    }
    printf("%d ", i);
}
printf("\n");

20. goto

goto 是分支语句关键字，用于无条件地跳转到程序的另一个位置。

示例代码：

int i = 0;
start:
printf("%d\n", i);
i++;
if (i < 10) {
    goto start;
}

函数关键字

21. return

return是用于函数中返回值的关键字，用于将某个值作为函数的返回值。

示例代码：

int add(int x, int y) { // 声明一个函数add，用于计算两个整数的和
    return x + y; // 将x和y的和作为函数的返回值
}

存储类关键字

22. auto

auto是一种存储类关键字，用于在函数内部声明自动变量，即存储在函数栈中的变量。如果没有指定存储类别，则默认为auto。

示例代码：

void foo() {
    auto int x = 10; // 声明一个自动变量x，初始值为10
    printf("%d\n", x);
}

23. static

static是一种存储类关键字，用于在函数内部声明静态变量，即在程序生命周期内保持不变的变量。静态变量存储在全局数据区或程序栈中，取决于它们的作用域和存储类型。

示例代码：

void foo() {
    static int x = 0; // 声明一个静态变量x，初始值为0
    x++;
    printf("%d\n", x);
}

24. extern

extern是一种存储类关键字，用于在一个文件中声明另一个文件中定义的变量或函数，以便使它们在当前文件中可用。

示例代码：

// file1.c
int x; // 声明一个全局变量x

// file2.c
extern int x; // 在file2.c中声明全局变量x，以便在file2.c中使用它

void foo() {
    x = 10; // 在foo函数中修改全局变量x的值
}

25. register

register是一种存储类关键字，用于声明寄存器变量，即将变量存储在CPU的寄存器中，以便加快访问速度。但是，对于大多数现代编译器，register关键字已经不再有太大的作用，编译器会自动进行寄存器优化。

示例代码：

void foo() {
    register int x = 10; // 声明一个寄存器变量x，初始值为10
    printf("%d\n", x);
}

其他关键字

26. sizeof

sizeof是一个操作符，而不是关键字，用于返回数据类型或变量的大小，以字节为单位。

示例代码：

int arr[5] = {1, 2, 3, 4, 5};
int size = sizeof(arr); // 返回arr数组的大小，即20（5个整数，每个整数占4个字节）

27. typedef

typedef是一种关键字，用于创建自定义数据类型的别名。

示例代码：

typedef int my_int; // 将int类型重命名为my_int类型

my_int x = 10; // 声明一个my_int类型的变量x，初始值为10

28. struct

struct是一种关键字，用于定义结构体类型，即由多个不同数据类型的变量组成的复合数据类型。

示例代码：

struct Person {
    char name[20];
    int age;
};

struct Person p1 = {"Alice", 20}; // 声明一个Person类型的结构体变量p1，初始值为{"Alice", 20}

29. union

union是一种关键字，用于定义联合类型，即由多个不同数据类型的变量共享同一块内存的复合数据类型。

示例代码：

union Data {
    int i;
    float f;
    char str[20];
};

union Data data;
data.i = 10;
printf("%d\n", data.i); // 输出10
data.f = 3.14f;
printf("%f\n", data.f); // 输出3.14
strcpy(data.str, "Hello");
printf("%s\n", data.str); // 输出"Hello"

30. enum

enum是一种关键字，用于定义枚举类型，即由一组常量组成的数据类型。

示例代码：

enum Color {
    RED,
    GREEN,
    BLUE
};

enum Color c = RED; // 声明一个Color类型的枚举变量c，初始值为RED

31. const

const是一种关键字，用于声明常量，即值不可更改的变量。

示例代码：

const int x = 10; // 声明一个常量x，初始值为10
x = 20; // 错误：不能修改常量的值

32. volatile

volatile是一种关键字，用于告诉编译器，变量的值可能在外部被修改，因此不能进行某些优化，例如缓存变量的值。

示例代码：

volatile int x = 10; // 声明一个volatile变量x，初始值为10

这就是 C 语言中的所有关键字。如果大家发现有任何其他问题，请在评论区随时指出.