常量是程序中固定不变的值。常量可以是字面量（如10、3.14），也可以使用#define或const关键字定义。

语法：
#define 常量名 值
const 数据类型 常量名 = 值;
示例：
#define PI 3.14159          // 使用#define定义常量
const int MAX_SCORE = 100;  // 使用const定义常量

2. 数据类型关键字

C语言提供了多种数据类型关键字，用于定义不同类型的数据。以下是C语言的基本数据类型关键字：

数据类型关键字描述
int 整型（整数）
float 单精度浮点型（小数）
double 双精度浮点型（更高精度小数）
char 字符型（单个字符）
void 无类型（通常用于函数返回值）

数据类型关键字	描述
`int`	整型（整数）
`float`	单精度浮点型（小数）
`double`	双精度浮点型（更高精度小数）
`char`	字符型（单个字符）
`void`	无类型（通常用于函数返回值）

3. C语言基本数据类型

3.1 整型（`int`）

在 C 语言中，int是一种基本的数据类型，用于定义整型变量。

3.1.1 定义与含义

int是 “integer”（整数）的缩写，用于声明一个变量可以存储整数数值。这些整数包括正整数、负整数和零，例如1、-5、0等。

3.1.2 内存占用和取值范围

在不同的 C 语言实现和不同的操作系统环境下，int类型所占用的内存空间和取值范围可能会有所不同，但通常情况下，int类型在 32 位系统中占用 4 个字节（32 位）的内存空间。其取值范围一般是从-2^31到2^31 - 1，即从-2147483648到2147483647。

3.1.3 声明和初始化

声明：声明int整型变量的一般形式为int 变量名;。例如，int num;声明了一个名为num的int类型变量。
初始化：可以在声明变量的同时对其进行初始化，即赋予它一个初始值。例如，int num = 10;声明了一个名为num的int型变量，并将其初始化为10。也可以先声明后初始化，如int num; num = 10;。

3.1.4 运算操作

int整型变量可以参与各种数学运算，如加法（+）、减法（-）、乘法（*）、除法（/）和取余（%）等运算。

特别注意：在除法运算中，如果两个操作数都是整数，结果将是整数，会舍去小数部分。如5 / 2的结果是2，而不是2.5。

例如：

#include <stdio.h>

int main() {
    // 定义两个整型变量 a 和 b，并分别初始化为 10 和 3
    int a = 10;
    int b = 3;

    // 进行加法运算，将结果存储在 sum 变量中
    int sum = a + b;
    // 进行减法运算，将结果存储在 difference 变量中
    int difference = a - b;
    // 进行乘法运算，将结果存储在 product 变量中
    int product = a * b;
    // 进行除法运算，将结果存储在 quotient 变量中
    // 注意：由于 a 和 b 都是整数，除法结果会舍去小数部分
    int quotient = a / b;
    // 进行取余运算，将结果存储在 remainder 变量中
    int remainder = a % b;

    // 输出加法运算的结果
    printf("和：%d\n", sum);
    // 输出减法运算的结果
    printf("差：%d\n", difference);
    // 输出乘法运算的结果
    printf("积：%d\n", product);
    // 输出除法运算的结果
    printf("商：%d\n", quotient);
    // 输出取余运算的结果
    printf("余数：%d\n", remainder);

    // 返回 0 表示程序正常结束
    return 0;
}

3.1.5 实际应用场景

int整型变量在 C 语言编程中非常常见，广泛应用于各种场景。比如，用于计数，如循环中的计数器控制循环次数；表示数组的下标，用于访问数组中的元素；存储和处理各种整数值的数据，如年龄、人数、学号等。

例如：

#include <stdio.h>

int main() {
    // 定义一个整型变量 age 来表示年龄，并初始化为 25
    int age = 25;
    // 定义一个整型变量 classSize 来表示班级的学生人数，并初始化为 30
    int classSize = 30;

    // 输出年龄信息
    printf("年龄：%d 岁\n", age);
    // 输出班级人数信息
    printf("班级人数：%d 人\n", classSize);

    // 使用 for 循环遍历班级中的每个学生
    // 循环变量 i 从 0 开始，每次递增 1，直到 i 小于 classSize
    for (int i = 0; i < classSize; i++) {
        // 输出每个学生的学号
        // 由于学号通常从 1 开始，所以使用 i + 1 作为学号
        printf("学生学号：%d\n", i + 1);
    }

    // 返回 0 表示程序正常结束
    return 0;
}

3.2 浮点型（`float`和`double）`

在 C 语言中，浮点型变量用于存储带有小数部分的数值，也就是实数。

3.2.1 定义与含义

浮点型是一种能够表示包含小数部分数值的数据类型。在实际应用中，很多时候我们需要处理像 3.14、0.001 这样的非整数数值，这时就会用到浮点型变量。C 语言提供了两种主要的浮点型数据类型：float（单精度浮点型）和 double（双精度浮点型）。

3.2.2 内存占用和取值范围

float：通常在内存中占用 4 个字节（32 位）。它能表示大约 6 到 7 位有效数字，取值范围大约是 ±1.18×10⁻³⁸ 到 ±3.40×10³⁸。
double：一般占用 8 个字节（64 位）的内存空间。它能表示大约 15 到 16 位有效数字，取值范围比 float 更大，约为 ±2.23×10⁻³⁰⁸ 到 ±1.80×10³⁰⁸。

3.2.3 声明和初始化

声明：
声明 float 类型变量的一般形式为 float 变量名;。例如，float num; 声明了一个名为 num 的 float 类型变量。
声明 double 类型变量的一般形式为 double 变量名;。例如，double d_num; 声明了一个名为 d_num 的 double 类型变量。

初始化：
可以在声明变量的同时对其进行初始化。对于 float 类型，初始化常量后面要加上 f 或 F，如 float num = 3.14f;；对于 double 类型，直接赋值即可，如 double d_num = 3.14159;。也可以先声明后初始化，如 float num; num = 3.14f; 和 double d_num; d_num = 3.14159;。

3.2.4 运算操作

浮点型变量可以参与各种数学运算，如加法（+）、减法（-）、乘法（*）、除法（/）等运算。

例如：

#include <stdio.h>

int main() {
    // 定义两个单精度浮点型变量 a 和 b，并分别初始化为 3.14 和 2.71
    float a = 3.14f;
    float b = 2.71f;

    // 进行加法运算，将结果存储在 sum 变量中
    float sum = a + b;
    // 进行减法运算，将结果存储在 difference 变量中
    float difference = a - b;
    // 进行乘法运算，将结果存储在 product 变量中
    float product = a * b;
    // 进行除法运算，将结果存储在 quotient 变量中
    float quotient = a / b;

    // 输出加法运算的结果，保留两位小数
    printf("和：%.2f\n", sum);
    // 输出减法运算的结果，保留两位小数
    printf("差：%.2f\n", difference);
    // 输出乘法运算的结果，保留两位小数
    printf("积：%.2f\n", product);
    // 输出除法运算的结果，保留两位小数
    printf("商：%.2f\n", quotient);

    // 返回 0 表示程序正常结束
    return 0;
}

在上述代码中，使用 %.2f 格式化输出结果，保留两位小数。

3.2.5 实际应用场景

浮点型变量在 C 语言编程中也非常常见，广泛应用于各种需要处理小数的场景。比如，用于科学计算，如物理公式中的计算；表示货币金额；在图形处理中表示坐标、角度等。
#include <stdio.h>

int main() {
    // 定义一个单精度浮点型变量 price，用于表示商品的价格，初始值为 9.99 元
    float price = 9.99f;
    // 定义一个单精度浮点型变量 pi，用于表示圆周率，初始值为 3.14159
    float pi = 3.14159f;
    // 定义一个单精度浮点型变量 radius，用于表示圆的半径，初始值为 5.0
    float radius = 5.0f;

    // 根据圆的面积公式 S = π * r * r 计算圆的面积，并将结果存储在 area 变量中
    float area = pi * radius * radius;

    // 输出商品的价格，保留两位小数
    printf("商品价格：%.2f 元\n", price);
    // 输出圆的半径和对应的面积，半径和面积都保留两位小数
    printf("半径为 %.2f 的圆的面积：%.2f\n", radius, area);

    // 返回 0 表示程序正常结束
    return 0;
}
在这个例子中，使用 float 类型变量来表示商品价格、圆周率和半径，并计算圆的面积，最后输出相关信息。

3.3 字符型（`char`）

在 C 语言中，char 是一种基本的数据类型，用于定义字符型变量。

3.3.1 定义与含义

char 是 “character”（字符）的缩写，用于声明一个变量可以存储单个字符。在计算机中，字符是以对应的 ASCII 码值（或其他字符编码，如 Unicode）的形式存储的。因此，char 类型本质上是一个整数类型，它可以存储一个字节（8 位）的数据，范围通常是 -128 到 127 （有符号 char）或者 0 到 255 （无符号 char），这取决于编译器的实现。常见的字符如字母（'A', 'a'）、数字（'0', '9'）、标点符号（',', '.'）等都可以用 char 类型来表示。

3.3.2 内存占用和取值范围

内存占用：char 类型通常占用 1 个字节（8 位）的内存空间。
取值范围：
有符号 char：范围是 -128 到 127。可以使用 signed char 显式声明有符号字符类型，不过一般直接使用 char 时，默认是有符号的（具体取决于编译器）。
无符号 char：范围是 0 到 255，使用 unsigned char 来声明。

3.3.3 声明和初始化

声明：声明 char 型变量的一般形式为 char 变量名;。例如，char ch; 声明了一个名为 ch 的 char 类型变量。
初始化：可以在声明变量的同时对其进行初始化，即赋予它一个字符常量。字符常量是用单引号括起来的单个字符，例如 'A'、'5' 等。示例如下：
char ch = 'A'; // 声明并初始化一个 char 型变量 ch，其值为字符 'A'
也可以先声明后初始化，如：
char ch;
ch = 'B'; // 先声明 ch，再将其初始化为字符 'B'

3.3.4 运算操作

char 型变量可以参与一些运算，因为它本质上是整数类型。常见的运算包括：

赋值运算：可以将一个字符常量赋值给 char 型变量，如上述示例。
算术运算：可以进行加减等算术运算，运算时会基于字符对应的 ASCII 码值进行。例如：
#include <stdio.h>

int main() {
    char ch = 'A';
    char new_ch = ch + 1; // 字符 'A' 的 ASCII 码值加 1
    printf("原来的字符: %c，新的字符: %c\n", ch, new_ch);
    return 0;
}
在上述代码中，字符 'A' 的 ASCII 码值是 65，加 1 后得到 66，对应的字符是 'B'，所以输出结果为原来的字符是 'A'，新的字符是 'B'。

3.3.5 实际应用场景

char 型变量在 C 语言编程中非常常见，广泛应用于各种场景。比如：

处理文本数据：在处理字符串时，字符串实际上是由一系列 char 类型的字符组成的数组。例如，存储和处理用户输入的姓名、句子等。
字符判断：可以根据字符的 ASCII 码值进行判断，如判断一个字符是否为字母、数字等。示例代码如下：
#include <stdio.h>

int main() {
    char ch = 'a';
    if (ch >= 'a' && ch <= 'z') {
        printf("%c 是小写字母\n", ch);
    } else {
        printf("%c 不是小写字母\n", ch);
    }
    return 0;
}
在这个例子中，通过比较字符 ch 的 ASCII 码值，判断它是否为小写字母。

3.4 无类型（`void`）

3.4.1 定义与含义

在 C 语言里，void 并非像 int 那样用于定义普通变量。void 类型的字面意思是 “无类型” 或者 “空类型”，它主要有以下几种特殊用途：

1. 函数返回类型

当一个函数不需要返回任何值时，就可以将其返回类型声明为 void。这表明该函数执行特定的操作，但不会给调用者返回一个具体的数据。

2. 函数参数列表

在函数定义时，如果函数不接受任何参数，参数列表可以写成 void。不过在现代 C 语言中，也可以直接使用空括号 () 来表示。

3. 通用指针类型

void * 是一种通用的指针类型，它可以指向任意类型的数据。这种指针可以存储任何类型变量的地址，但在使用时通常需要进行显式的类型转换。

3.4.2 不同场景下的表现

1. 作为函数返回类型
#include <stdio.h>

// 定义一个返回类型为 void 的函数，用于打印问候语
void greet() {
    printf("Hello, World!\n");
}

int main() {
    // 调用 greet 函数
    greet();
    return 0;
}
在这个例子中，greet 函数的返回类型是 void，意味着它不返回任何值，只是执行打印问候语的操作。

2. 作为函数参数列表
#include <stdio.h>

// 定义一个不接受任何参数的函数，参数列表使用 void
void printMessage(void) {
    printf("This is a message.\n");
}

int main() {
    // 调用 printMessage 函数
    printMessage();
    return 0;
}
这里 printMessage 函数的参数列表是 void，表示该函数不接受任何参数。

3. 作为通用指针类型
#include <stdio.h>

int main() {
    int num = 10;
    // 定义一个 void 指针，指向 int 类型的变量 num
    void *ptr = &num;

    // 由于 void 指针不能直接解引用，需要进行类型转换
    int *intPtr = (int *)ptr;
    printf("The value of num is: %d\n", *intPtr);

    return 0;
}
在这段代码中，void * 类型的指针 ptr 指向了一个 int 类型的变量 num。但因为 void 指针不能直接解引用，所以需要将其转换为 int * 类型的指针后再进行操作。

3.4.3 注意事项

不能定义 void 型变量：因为 void 表示无类型，所以不能像 int 那样直接定义一个 void 类型的变量，例如 void var; 这样的代码是不合法的。
void 指针使用时需转换：当使用 void * 指针时，在进行解引用或者进行一些需要特定类型操作时，必须先将其转换为合适的指针类型。