学习的好苗子

Appearance

C语言深入与专业化 ​

在掌握了C语言的基础知识和实战应用后，我们将进一步深入学习C语言的高级特性和专业化应用，包括编译原理、内存管理、高级数据结构以及行业应用方向。

编译原理基础 ​

预处理、编译、汇编、链接过程 ​

C程序从源代码到可执行文件需要经过四个主要阶段：

bash
# 预处理阶段 - 展开宏定义、包含头文件
gcc -E hello.c -o hello.i

# 编译阶段 - 将预处理后的文件编译成汇编代码
gcc -S hello.i -o hello.s

# 汇编阶段 - 将汇编代码转换成目标文件
gcc -c hello.s -o hello.o

# 链接阶段 - 将目标文件和库文件链接成可执行文件
gcc hello.o -o hello

让我们通过一个简单的例子来理解这个过程：

c
// hello.c
#include <stdio.h>
#define MAX 100

int main() {
    printf("Hello, World! MAX = %d\n", MAX);
    return 0;
}
  1. 预处理阶段：展开#include和#define，生成.i文件
  2. 编译阶段：将C代码转换为汇编代码，生成.s文件
  3. 汇编阶段：将汇编代码转换为机器码，生成.o目标文件
  4. 链接阶段：链接C标准库中的printf函数，生成可执行文件

目标文件与可执行文件结构 ​

目标文件和可执行文件通常包含以下几个部分：

  1. ELF头部：包含文件的基本信息
  2. 程序头部表：描述段信息（可执行文件特有）
  3. 节区：
    • .text：代码段，存放程序指令
    • .data：已初始化数据段，存放已初始化的全局变量和静态变量
    • .bss：未初始化数据段，存放未初始化的全局变量和静态变量
    • .rodata：只读数据段，存放字符串常量等
  4. 节区头部表：描述节区信息
c
#include <stdio.h>

// 全局已初始化变量 - 存放在.data段
int global_var = 10;

// 全局未初始化变量 - 存放在.bss段
int global_uninit_var;

// 全局常量 - 存放在.rodata段
const char* message = "Hello, World!";

// 静态变量
void function() {
    static int static_var = 20;  // 存放在.data段
    static int static_uninit;    // 存放在.bss段
}

int main() {
    // 局部变量 - 存放在栈上
    int local_var = 30;
    
    // 字符串常量 - 存放在.rodata段
    printf("Local variable: %d\n", local_var);
    
    return 0;
}

静态链接与动态链接的区别 ​

链接是将多个目标文件合并成一个可执行文件的过程，分为静态链接和动态链接两种方式：

静态链接：

  • 在编译时将库代码直接嵌入到可执行文件中
  • 优点：程序独立运行，不依赖外部库文件
  • 缺点：文件体积大，库更新需要重新编译程序
bash
# 静态链接示例
gcc -static hello.c -o hello_static

动态链接：

  • 在运行时才加载库文件
  • 优点：文件体积小，多个程序可共享同一库文件
  • 缺点：需要目标系统中有相应的库文件
bash
# 动态链接示例（默认方式）
gcc hello.c -o hello_dynamic

内存管理深入 ​

内存分区 ​

C程序运行时的内存可以分为以下几个区域：

  1. 栈区（Stack）：由编译器自动分配和释放，存放局部变量、函数参数等
  2. 堆区（Heap）：由程序员手动分配和释放，存放动态分配的数据
  3. 数据段（Data Segment）：存放全局变量和静态变量
  4. 代码段（Code Segment）：存放程序指令
c
#include <stdio.h>
#include <stdlib.h>

// 全局变量 - 数据段
int global_var = 100;

// 全局未初始化变量 - BSS段
int global_uninit;

void function() {
    // 局部变量 - 栈区
    int local_var = 200;
    static int static_var = 300;  // 静态变量 - 数据段
    
    printf("局部变量地址: %p\n", &local_var);
    printf("静态变量地址: %p\n", &static_var);
}

int main() {
    // 局部变量 - 栈区
    int main_local = 400;
    
    // 动态分配内存 - 堆区
    int* heap_ptr = (int*)malloc(sizeof(int));
    *heap_ptr = 500;
    
    printf("全局变量地址: %p\n", &global_var);
    printf("全局未初始化变量地址: %p\n", &global_uninit);
    printf("main函数局部变量地址: %p\n", &main_local);
    printf("堆区变量地址: %p\n", heap_ptr);
    
    function();
    
    free(heap_ptr);  // 释放堆内存
    return 0;
}

内存对齐原理与优化 ​

内存对齐是为了提高CPU访问内存的效率，现代CPU通常要求数据在特定边界上对齐。

c
#include <stdio.h>
#include <stddef.h>

// 未对齐的结构体
struct Unaligned {
    char a;      // 1字节
    int b;       // 4字节
    char c;      // 1字节
    double d;    // 8字节
};

// 对齐的结构体
struct Aligned {
    double d;    // 8字节
    int b;       // 4字节
    char a;      // 1字节
    char c;      // 1字节
};

int main() {
    printf("未对齐结构体大小: %zu\n", sizeof(struct Unaligned));
    printf("对齐结构体大小: %zu\n", sizeof(struct Aligned));
    
    // 查看成员偏移量
    printf("\n未对齐结构体成员偏移:\n");
    printf("a: %zu\n", offsetof(struct Unaligned, a));
    printf("b: %zu\n", offsetof(struct Unaligned, b));
    printf("c: %zu\n", offsetof(struct Unaligned, c));
    printf("d: %zu\n", offsetof(struct Unaligned, d));
    
    printf("\n对齐结构体成员偏移:\n");
    printf("d: %zu\n", offsetof(struct Aligned, d));
    printf("b: %zu\n", offsetof(struct Aligned, b));
    printf("a: %zu\n", offsetof(struct Aligned, a));
    printf("c: %zu\n", offsetof(struct Aligned, c));
    
    return 0;
}

内存泄漏检测工具（Valgrind） ​

Valgrind是一个强大的内存调试工具，可以帮助检测内存泄漏、非法内存访问等问题。

bash
# 编译程序（需要调试信息）
gcc -g -o memory_test memory_test.c

# 使用Valgrind检测内存问题
valgrind --tool=memcheck --leak-check=full ./memory_test

示例程序：

c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void memoryLeakExample() {
    // 分配内存但未释放 - 内存泄漏
    char* ptr1 = (char*)malloc(100);
    strcpy(ptr1, "Hello, World!");
    printf("%s\n", ptr1);
    // 忘记调用 free(ptr1);
    
    // 重复释放 - 非法操作
    char* ptr2 = (char*)malloc(50);
    free(ptr2);
    // free(ptr2); // 重复释放会导致错误
    
    // 访问已释放的内存 - 非法操作
    char* ptr3 = (char*)malloc(30);
    free(ptr3);
    // strcpy(ptr3, "This is dangerous!"); // 访问已释放内存
}

int main() {
    memoryLeakExample();
    return 0;
}

高级数据结构与算法 ​

哈希表实现与冲突解决 ​

哈希表是一种通过哈希函数将键映射到值的数据结构，提供快速的查找、插入和删除操作。

c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define HASH_TABLE_SIZE 100

// 哈希表节点
typedef struct HashNode {
    char* key;
    int value;
    struct HashNode* next;
} HashNode;

// 哈希表
typedef struct {
    HashNode* buckets[HASH_TABLE_SIZE];
} HashTable;

// 哈希函数
unsigned int hash(const char* key) {
    unsigned int hash = 5381;
    int c;
    while ((c = *key++)) {
        hash = ((hash << 5) + hash) + c;  // hash * 33 + c
    }
    return hash % HASH_TABLE_SIZE;
}

// 初始化哈希表
HashTable* createHashTable() {
    HashTable* table = (HashTable*)malloc(sizeof(HashTable));
    for (int i = 0; i < HASH_TABLE_SIZE; i++) {
        table->buckets[i] = NULL;
    }
    return table;
}

// 插入键值对
void hashTableInsert(HashTable* table, const char* key, int value) {
    unsigned int index = hash(key);
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->key = strdup(key);
    newNode->value = value;
    newNode->next = table->buckets[index];
    table->buckets[index] = newNode;
}

// 查找值
int hashTableSearch(HashTable* table, const char* key) {
    unsigned int index = hash(key);
    HashNode* current = table->buckets[index];
    
    while (current != NULL) {
        if (strcmp(current->key, key) == 0) {
            return current->value;
        }
        current = current->next;
    }
    
    return -1;  // 未找到
}

// 删除键值对
void hashTableDelete(HashTable* table, const char* key) {
    unsigned int index = hash(key);
    HashNode* current = table->buckets[index];
    HashNode* prev = NULL;
    
    while (current != NULL) {
        if (strcmp(current->key, key) == 0) {
            if (prev == NULL) {
                table->buckets[index] = current->next;
            } else {
                prev->next = current->next;
            }
            free(current->key);
            free(current);
            return;
        }
        prev = current;
        current = current->next;
    }
}

// 释放哈希表
void freeHashTable(HashTable* table) {
    for (int i = 0; i < HASH_TABLE_SIZE; i++) {
        HashNode* current = table->buckets[i];
        while (current != NULL) {
            HashNode* temp = current;
            current = current->next;
            free(temp->key);
            free(temp);
        }
    }
    free(table);
}

红黑树实现 ​

红黑树是一种自平衡的二叉搜索树，保证了最坏情况下操作的时间复杂度为O(log n)。

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

// 红黑树节点颜色
typedef enum {
    RED,
    BLACK
} Color;

// 红黑树节点
typedef struct RBNode {
    int data;
    Color color;
    struct RBNode* left;
    struct RBNode* right;
    struct RBNode* parent;
} RBNode;

// 红黑树
typedef struct {
    RBNode* root;
    RBNode* nil;  // 哨兵节点，代表NIL
} RBTree;

// 创建新节点
RBNode* createNode(RBTree* tree, int data) {
    RBNode* node = (RBNode*)malloc(sizeof(RBNode));
    node->data = data;
    node->color = RED;
    node->left = tree->nil;
    node->right = tree->nil;
    node->parent = tree->nil;
    return node;
}

// 初始化红黑树
RBTree* createRBTree() {
    RBTree* tree = (RBTree*)malloc(sizeof(RBTree));
    tree->nil = (RBNode*)malloc(sizeof(RBNode));
    tree->nil->color = BLACK;
    tree->nil->left = NULL;
    tree->nil->right = NULL;
    tree->nil->parent = NULL;
    tree->root = tree->nil;
    return tree;
}

// 左旋转
void leftRotate(RBTree* tree, RBNode* x) {
    RBNode* y = x->right;
    x->right = y->left;
    
    if (y->left != tree->nil) {
        y->left->parent = x;
    }
    
    y->parent = x->parent;
    
    if (x->parent == tree->nil) {
        tree->root = y;
    } else if (x == x->parent->left) {
        x->parent->left = y;
    } else {
        x->parent->right = y;
    }
    
    y->left = x;
    x->parent = y;
}

// 右旋转
void rightRotate(RBTree* tree, RBNode* y) {
    RBNode* x = y->left;
    y->left = x->right;
    
    if (x->right != tree->nil) {
        x->right->parent = y;
    }
    
    x->parent = y->parent;
    
    if (y->parent == tree->nil) {
        tree->root = x;
    } else if (y == y->parent->right) {
        y->parent->right = x;
    } else {
        y->parent->left = x;
    }
    
    x->right = y;
    y->parent = x;
}

// 插入修复
void insertFixup(RBTree* tree, RBNode* z) {
    while (z->parent->color == RED) {
        if (z->parent == z->parent->parent->left) {
            RBNode* y = z->parent->parent->right;
            if (y->color == RED) {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            } else {
                if (z == z->parent->right) {
                    z = z->parent;
                    leftRotate(tree, z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                rightRotate(tree, z->parent->parent);
            }
        } else {
            RBNode* y = z->parent->parent->left;
            if (y->color == RED) {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            } else {
                if (z == z->parent->left) {
                    z = z->parent;
                    rightRotate(tree, z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                leftRotate(tree, z->parent->parent);
            }
        }
    }
    tree->root->color = BLACK;
}

// 插入节点
void rbTreeInsert(RBTree* tree, int data) {
    RBNode* z = createNode(tree, data);
    RBNode* y = tree->nil;
    RBNode* x = tree->root;
    
    while (x != tree->nil) {
        y = x;
        if (z->data < x->data) {
            x = x->left;
        } else {
            x = x->right;
        }
    }
    
    z->parent = y;
    
    if (y == tree->nil) {
        tree->root = z;
    } else if (z->data < y->data) {
        y->left = z;
    } else {
        y->right = z;
    }
    
    z->left = tree->nil;
    z->right = tree->nil;
    z->color = RED;
    
    insertFixup(tree, z);
}

动态规划与贪心算法 ​

动态规划和贪心算法是解决优化问题的两种重要方法。

c
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

// 动态规划：斐波那契数列
int fibonacciDP(int n) {
    if (n <= 1) return n;
    
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    dp[0] = 0;
    dp[1] = 1;
    
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i-1] + dp[i-2];
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

// 动态规划：最长公共子序列
int lcsLength(char* X, char* Y, int m, int n) {
    int** dp = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        dp[i] = (int*)malloc((n + 1) * sizeof(int));
    }
    
    for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= n; j++) {
            if (i == 0 || j == 0) {
                dp[i][j] = 0;
            } else if (X[i-1] == Y[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
            } else {
                dp[i][j] = (dp[i-1][j] > dp[i][j-1]) ? dp[i-1][j] : dp[i][j-1];
            }
        }
    }
    
    int result = dp[m][n];
    
    for (int i = 0; i <= m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

// 贪心算法：活动选择问题
typedef struct {
    int start;
    int finish;
} Activity;

int compareActivities(const void* a, const void* b) {
    Activity* actA = (Activity*)a;
    Activity* actB = (Activity*)b;
    return actA->finish - actB->finish;
}

int maxActivities(Activity activities[], int n) {
    // 按结束时间排序
    qsort(activities, n, sizeof(Activity), compareActivities);
    
    int count = 1;
    int i = 0;
    
    for (int j = 1; j < n; j++) {
        if (activities[j].start >= activities[i].finish) {
            count++;
            i = j;
        }
    }
    
    return count;
}

行业应用方向 ​

操作系统开发 ​

操作系统内核开发是C语言的重要应用领域之一。内核模块通常需要直接操作硬件和管理系统资源。

c
// 简单的内核模块示例（Linux）
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>

// 模块许可声明
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple kernel module");
MODULE_VERSION("1.0");

// 模块初始化函数
static int __init hello_init(void) {
    printk(KERN_INFO "Hello, Kernel!\n");
    return 0;
}

// 模块退出函数
static void __exit hello_exit(void) {
    printk(KERN_INFO "Goodbye, Kernel!\n");
}

// 注册初始化和退出函数
module_init(hello_init);
module_exit(hello_exit);

嵌入式系统 ​

嵌入式系统开发对C语言的要求更高，需要考虑内存限制、实时性等因素。

c
// 嵌入式系统中的实时任务调度示例
#include <stdint.h>

#define MAX_TASKS 10
#define TASK_READY 0
#define TASK_RUNNING 1
#define TASK_WAITING 2

// 任务控制块
typedef struct {
    void (*taskFunc)(void);  // 任务函数指针
    uint32_t stackPointer;   // 栈指针
    uint32_t priority;       // 优先级
    uint8_t state;           // 任务状态
    uint32_t delayTicks;     // 延迟计数
} TaskControlBlock;

// 任务列表
TaskControlBlock taskList[MAX_TASKS];
uint8_t currentTask = 0;
uint8_t taskCount = 0;

// 创建任务
int createTask(void (*taskFunc)(void), uint32_t priority) {
    if (taskCount >= MAX_TASKS) {
        return -1;  // 任务数已达上限
    }
    
    taskList[taskCount].taskFunc = taskFunc;
    taskList[taskCount].priority = priority;
    taskList[taskCount].state = TASK_READY;
    taskList[taskCount].delayTicks = 0;
    taskCount++;
    
    return 0;
}

// 任务调度器
void scheduler(void) {
    uint8_t nextTask = currentTask;
    uint32_t highestPriority = 0;
    
    // 查找最高优先级的就绪任务
    for (int i = 0; i < taskCount; i++) {
        if (taskList[i].state == TASK_READY && 
            taskList[i].priority > highestPriority) {
            highestPriority = taskList[i].priority;
            nextTask = i;
        }
    }
    
    // 切换到下一个任务
    if (nextTask != currentTask) {
        taskList[currentTask].state = TASK_READY;
        currentTask = nextTask;
        taskList[currentTask].state = TASK_RUNNING;
    }
}

高性能计算 ​

在高性能计算领域，C语言因其接近硬件的特性和高效的执行效率而被广泛使用。

c
// 向量化计算示例（使用SIMD指令）
#include <immintrin.h>  // AVX指令集

// 普通数组加法
void arrayAdd(float* a, float* b, float* result, int n) {
    for (int i = 0; i < n; i++) {
        result[i] = a[i] + b[i];
    }
}

// 向量化数组加法（AVX）
void vectorizedArrayAdd(float* a, float* b, float* result, int n) {
    int i = 0;
    
    // 处理8个元素为一组
    for (; i <= n - 8; i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vresult = _mm256_add_ps(va, vb);
        _mm256_store_ps(&result[i], vresult);
    }
    
    // 处理剩余元素
    for (; i < n; i++) {
        result[i] = a[i] + b[i];
    }
}

进阶项目 ​

参与开源项目 ​

参与开源项目是提升C语言技能的有效途径。以下是一些知名的C语言开源项目：

  1. Linux内核：https://github.com/torvalds/linux
  2. Redis：https://github.com/redis/redis
  3. Nginx：https://github.com/nginx/nginx
  4. Git：https://github.com/git/git
  5. Vim：https://github.com/vim/vim

开发轻量级操作系统内核 ​

开发一个简单的操作系统内核可以帮助深入理解计算机系统的工作原理。

c
// 简单的操作系统内核示例
#include <stdint.h>

// 内存管理
#define KERNEL_START 0x100000
#define PAGE_SIZE 4096

typedef struct {
    uint32_t present : 1;
    uint32_t rw : 1;
    uint32_t user : 1;
    uint32_t accessed : 1;
    uint32_t dirty : 1;
    uint32_t unused : 7;
    uint32_t frame : 20;
} page_t;

typedef struct {
    page_t pages[1024];
} page_table_t;

// 进程管理
typedef struct {
    uint32_t id;
    uint32_t esp, ebp;
    uint32_t eip;
    uint32_t page_directory;
    uint32_t state;
} process_t;

// 系统调用
#define SYS_WRITE 0
#define SYS_READ 1
#define SYS_EXIT 2

int system_call(int call_num, int arg1, int arg2, int arg3) {
    switch (call_num) {
        case SYS_WRITE:
            // 实现写操作
            return 0;
        case SYS_READ:
            // 实现读操作
            return 0;
        case SYS_EXIT:
            // 实现退出操作
            return 0;
        default:
            return -1;
    }
}

// 内核主函数
void kernel_main() {
    // 初始化硬件
    // 初始化内存管理
    // 初始化进程管理
    // 启动第一个进程
    
    while (1) {
        // 调度进程
        // 处理中断
    }
}

实现高性能网络库 ​

开发一个基于TCP/UDP的高性能网络库可以深入理解网络编程。

c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <errno.h>

#define MAX_EVENTS 1024
#define BUFFER_SIZE 4096

// 网络库上下文
typedef struct {
    int epoll_fd;
    int server_fd;
    struct epoll_event events[MAX_EVENTS];
} NetworkContext;

// 初始化网络库
NetworkContext* initNetwork(int port) {
    NetworkContext* ctx = (NetworkContext*)malloc(sizeof(NetworkContext));
    
    // 创建服务器套接字
    ctx->server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (ctx->server_fd < 0) {
        perror("socket creation failed");
        free(ctx);
        return NULL;
    }
    
    // 设置套接字为非阻塞
    int flags = fcntl(ctx->server_fd, F_GETFL, 0);
    fcntl(ctx->server_fd, F_SETFL, flags | O_NONBLOCK);
    
    // 绑定地址
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(port);
    
    if (bind(ctx->server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind failed");
        close(ctx->server_fd);
        free(ctx);
        return NULL;
    }
    
    // 监听连接
    if (listen(ctx->server_fd, SOMAXCONN) < 0) {
        perror("listen failed");
        close(ctx->server_fd);
        free(ctx);
        return NULL;
    }
    
    // 创建epoll实例
    ctx->epoll_fd = epoll_create1(0);
    if (ctx->epoll_fd < 0) {
        perror("epoll_create1 failed");
        close(ctx->server_fd);
        free(ctx);
        return NULL;
    }
    
    // 将服务器套接字添加到epoll
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = ctx->server_fd;
    if (epoll_ctl(ctx->epoll_fd, EPOLL_CTL_ADD, ctx->server_fd, &ev) < 0) {
        perror("epoll_ctl failed");
        close(ctx->server_fd);
        close(ctx->epoll_fd);
        free(ctx);
        return NULL;
    }
    
    return ctx;
}

// 处理事件
void handleEvents(NetworkContext* ctx) {
    int nfds = epoll_wait(ctx->epoll_fd, ctx->events, MAX_EVENTS, -1);
    
    for (int i = 0; i < nfds; i++) {
        if (ctx->events[i].data.fd == ctx->server_fd) {
            // 处理新连接
            struct sockaddr_in client_addr;
            socklen_t client_len = sizeof(client_addr);
            int client_fd = accept(ctx->server_fd, (struct sockaddr*)&client_addr, &client_len);
            
            if (client_fd >= 0) {
                // 设置客户端套接字为非阻塞
                int flags = fcntl(client_fd, F_GETFL, 0);
                fcntl(client_fd, F_SETFL, flags | O_NONBLOCK);
                
                // 将客户端套接字添加到epoll
                struct epoll_event ev;
                ev.events = EPOLLIN | EPOLLET;  // 边缘触发
                ev.data.fd = client_fd;
                epoll_ctl(ctx->epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);
            }
        } else {
            // 处理客户端数据
            char buffer[BUFFER_SIZE];
            int bytes_read = read(ctx->events[i].data.fd, buffer, BUFFER_SIZE);
            
            if (bytes_read > 0) {
                // 回显数据
                write(ctx->events[i].data.fd, buffer, bytes_read);
            } else if (bytes_read == 0) {
                // 客户端关闭连接
                close(ctx->events[i].data.fd);
                epoll_ctl(ctx->epoll_fd, EPOLL_CTL_DEL, ctx->events[i].data.fd, NULL);
            } else {
                if (errno != EAGAIN && errno != EWOULDBLOCK) {
                    perror("read failed");
                    close(ctx->events[i].data.fd);
                    epoll_ctl(ctx->epoll_fd, EPOLL_CTL_DEL, ctx->events[i].data.fd, NULL);
                }
            }
        }
    }
}

// 运行网络库
void runNetwork(NetworkContext* ctx) {
    printf("Network library started\n");
    
    while (1) {
        handleEvents(ctx);
    }
}

// 清理资源
void cleanupNetwork(NetworkContext* ctx) {
    if (ctx) {
        close(ctx->server_fd);
        close(ctx->epoll_fd);
        free(ctx);
    }
}

通过学习这些高级主题和完成进阶项目，你将能够深入理解C语言在各种专业领域的应用，并具备开发复杂系统的能力。记住，C语言是一门需要不断实践和深入学习的语言，只有通过不断的编码和项目实践，才能真正掌握其精髓。