00000001_C语言基础

C语言基础

推荐阅读 《C语言开发手册》 或者 《C语言核心技术》

1. C语言关键字

C 语言有 32 个标准关键字（在不同的编译器中，关键字可能会有所不同，但标准 C 中的关键字是固定的）。这些关键字是 C 语言的保留字，具有特殊的意义，不能用作变量、函数名或任何标识符。

常见的关键字：

• 数据类型相关的关键字：int、char、float、double、long、short、unsigned、signed
• 控制流程相关的关键字：if、else、switch、case、while、for、break、continue、return、goto
• 存储类相关的关键字：static、extern、auto、register
• 其他关键字：sizeof（用于计算数据类型或变量的大小）、const（常量）、volatile（易变变量，用于告诉编译器该变量可能会在程序外部发生改变）

2. 数据类型与运算符

数据类型分类

C 语言的数据类型主要分为以下几类：

• 基本数据类型：如 int、float、double、char 等
• 构造数据类型：如 enum、struct、union
• 修饰符类型：如 long、short、signed、unsigned 等，用于修饰基本数据类型
• 指针类型：存储变量地址的数据类型
• 函数类型：指函数的返回值类型

基本数据类型

1. int：整数类型，通常占 4 字节，表示整数。
2. float：单精度浮点类型，通常占 4 字节，表示小数。
3. double：双精度浮点类型，通常占 8 字节，表示更精确的小数。
4. char：字符类型，通常占 1 字节，用来表示字符，实际上是整数类型，用 ASCII 码表示字符。
5. short：短整型，通常占 2 字节，用于存储较小范围的整数。
6. long：长整型，通常占 4 字节或 8 字节，用于存储较大范围的整数。

枚举类型（enum）

枚举类型允许你为一组相关的常量指定名字。例如：

enum Day { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

这里，Sunday 的值是 0，Monday 的值是 1，依此类推。你也可以为枚举指定特定的值：

enum Day { Sunday = 1, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

结构体（struct）

结构体用于将不同类型的数据组合在一起。例如：

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

Person 结构体包含一个字符串和一个整数。

联合体（union）

联合体与结构体类似，但联合体中所有成员共享同一内存空间。例如：

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

只有一个成员可以存储值，所有成员共用一块内存。

常量（const）与变量

• const：常量的修饰符，表示该变量的值不能改变。

const int MAX = 100;

• 变量：普通变量的值是可以修改的。

int count = 10;

运算符

C 语言支持多种运算符，主要分为以下几类：

1. 算术运算符：+、-、*、/、%
2. 关系运算符：==、!=、>、<、>=、<=
3. 逻辑运算符：&&（与）、||（或）、!（非）

运算符优先级

运算符的优先级决定了在没有括号的情况下，表达式中的运算顺序。常见的优先级顺序为：

• *、/、% 优先于 +、-
• ++、-- 优先于其他算术运算符
• && 和 || 的优先级低于算术运算符

类型转换与强制类型转换

• 隐式类型转换：例如，int 转为 float，自动进行类型转换。

int a = 5;
float b = a;  // 隐式转换

• 显式类型转换（强制类型转换）：通过强制转换运算符进行类型转换。

float a = 5.67;
int b = (int)a;  // 强制类型转换

3. 控制结构

条件语句

1. if-else：用于根据条件执行不同的代码块。

if (x > 0) {
    printf("Positive");
} else {
    printf("Non-positive");
}

2. switch-case：适用于多个条件的判断。

switch (x) {
    case 1:
        printf("One");
        break;
    case 2:
        printf("Two");
        break;
    default:
        printf("Other");
}

循环语句

1. for：常用于已知次数的循环。

for (int i = 0; i < 10; i++) {
    printf("%d\n", i);
}

2. while：当循环条件为真时继续循环。

int i = 0;
while (i < 10) {
    printf("%d\n", i);
    i++;
}

3. do-while：先执行一次循环，再判断条件。

int i = 0;
do {
    printf("%d\n", i);
    i++;
} while (i < 10);

跳转语句

1. break：用于退出循环或 switch 语句。
2. continue：跳过当前循环的剩余部分，继续执行下一次循环。
3. goto：跳转到程序中的指定标签位置，但一般不推荐使用。

4. 函数与递归

函数定义与调用

C 语言通过函数来组织代码，实现模块化编程。函数的基本结构如下：

return_type function_name(parameters) {
    // 函数体
}

调用函数时，可以传递参数并返回值。例如：

int add(int a, int b) {
    return a + b;
}

int result = add(5, 10);

传值与传地址

• 传值：将实际参数的值传递给函数，函数内对参数的修改不会影响原始数据。

void func(int x) {
    x = 5; // 只是修改了局部变量
}

• 传地址：通过传递参数的地址（指针），函数可以直接修改原始数据。

void func(int *x) {
    *x = 5; // 修改了原始变量
}

递归函数

递归是函数调用自身的一种方式。阶乘是递归的经典例子：

int factorial(int n) {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}

5. 指针

指针基础

指针是存储变量地址的数据类型。指针声明格式：

int *ptr; // ptr 是一个指向 int 类型的指针

指针的使用：

int x = 10;
int *ptr = &x;  // & 取地址符，ptr 存储了 x 的地址

指针与数组的关系

数组名就是数组的首地址，可以通过指针访问数组元素。

int arr[] = {1, 2, 3};
int *ptr = arr;
printf("%d", *(ptr + 1));  // 输出 2

指针与函数

函数指针用于指向函数地址，实现回调机制。

void hello() {
    printf("Hello, World!");
}

int main() {
    void (*func_ptr)() = hello;  // 函数指针
    func_ptr();  // 调用 hello 函数
    return 0;
}

动态内存分配

通过 malloc、calloc、realloc 和 free 函数来进行动态内存分配和释放。动态内存分配使得程序在运行时能够根据需要分配内存，而不是在编译时就固定下来。

动态内存分配

1. malloc（Memory Allocation）：分配指定字节数的内存块，并返回该内存块的指针。如果分配失败，返回 NULL。

int *ptr = (int *)malloc(10 * sizeof(int));  // 分配 10 个整数的内存
if (ptr == NULL) {
    printf("Memory allocation failed!\n");
}

2. calloc（Contiguous Allocation）：与 malloc 相似，但 calloc 会将分配的内存初始化为 0。

int *ptr = (int *)calloc(10, sizeof(int));  // 分配 10 个整数并初始化为 0

3. realloc（Reallocation）：改变已分配内存块的大小。如果原内存不足，可以通过 realloc 扩展它。如果分配成功，它返回新内存块的地址。

ptr = (int *)realloc(ptr, 20 * sizeof(int));  // 将内存大小调整为 20 个整数

4. free（释放内存）：释放之前分配的内存。释放内存后，指针指向的内存空间不再有效。

free(ptr);  // 释放 ptr 指向的内存

注意：在使用 malloc、calloc 和 realloc 后，应该检查返回的指针是否为 NULL，确保内存分配成功。

6. 数组与字符串

数组

数组是一个固定大小的连续内存块，用来存储相同类型的元素。C 语言中的数组下标从 0 开始。

int arr[5] = {1, 2, 3, 4, 5};
printf("%d", arr[2]);  // 输出 3

数组的大小在声明时确定，不能在运行时动态调整。如果想创建动态数组，必须使用指针和动态内存分配（malloc、calloc）。

字符串

在 C 语言中，字符串是由字符数组构成的。C 字符串以 \0 结束，表示字符串的结束。

char str[] = "Hello, World!";
printf("%c", str[0]);  // 输出 'H'

字符串常量实际上是一个指向第一个字符的指针：

char *str = "Hello, World!";

C 语言提供了多种函数来处理字符串，如 strlen（计算字符串长度）、strcpy（复制字符串）、strcmp（比较字符串）等。

#include <string.h>
char str1[20], str2[20];
strcpy(str1, "Hello");
strcpy(str2, "World");

if (strcmp(str1, str2) == 0) {
    printf("The strings are equal.\n");
} else {
    printf("The strings are not equal.\n");
}

7. 结构体与联合体

结构体（struct）

结构体是一种用户自定义的数据类型，它将不同类型的数据组合在一起。

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

结构体可以通过点运算符（.）来访问成员：

struct Person person1;
strcpy(person1.name, "John");
person1.age = 30;

printf("Name: %s, Age: %d\n", person1.name, person1.age);

// 结构体指针类型 使用 -> 成员运算符
struct Person * p_persion = &persion1;
printf("Name: %s, Age: %d\n", p_persion->name, p_persion->age);

联合体（union）

联合体与结构体相似，但在联合体中，所有成员共享相同的内存空间，这意味着同一时刻只能存储一个成员的值。它节省内存，但每次只能使用一个成员。

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

union Data data;
data.i = 10;
printf("Data i: %d\n", data.i);
data.f = 3.14;
printf("Data f: %f\n", data.f);  // 由于联合体共用内存，此时 data.i 内容不再有效

8. 文件操作

C 语言提供了一组函数来处理文件输入输出（I/O）。使用 fopen 打开文件，fclose 关闭文件，fprintf 和 fscanf 进行文件的读写。

打开文件

FILE *f = fopen("file.txt", "w");  // 以写模式打开文件
if (f == NULL) {
    printf("Error opening file!\n");
    return -1;
}

写文件

fprintf(f, "Hello, file!\n");  // 写入文件

读文件

char buffer[100];
FILE *f = fopen("file.txt", "r");
if (f != NULL) {
    while (fgets(buffer, sizeof(buffer), f) != NULL) {
        printf("%s", buffer);
    }
    fclose(f);
}

关闭文件

fclose(f);  // 关闭文件

9. 错误处理与调试

错误处理

C 语言没有内建的异常处理机制，但可以使用返回值、errno 和标准库中的错误处理函数来处理错误。例如：

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

FILE *f = fopen("nonexistent_file.txt", "r");
if (f == NULL) {
    perror("Error opening file");
    exit(EXIT_FAILURE);
}

perror 会打印出相应的错误信息，errno 提供了错误的详细代码。

调试技巧

1. 打印调试信息：在程序中插入 printf 语句，打印变量的值。
2. 使用调试器：如 gdb，能够逐步调试程序，查看变量值和调用栈。
3. 使用 assert：用于在调试时检查某个条件是否为真，如果为假则中止程序。

#include <assert.h>

int divide(int a, int b) {
    assert(b != 0);  // 如果 b == 0，程序会中止
    return a / b;
}