C语言网络编程使用epoll监听10个客户端，每个客户端对应不同事件的代码 要求：使用结构体和链表

以下是一个使用epoll监听10个客户端，并根据不同事件处理的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/epoll.h>

#define MAX_EVENTS 10
#define MAX_BUFFER_SIZE 1024

// 客户端结构体
typedef struct {
    int fd; // 客户端文件描述符
    char buffer[MAX_BUFFER_SIZE]; // 接收数据缓冲区
    int buffer_len; // 缓冲区数据长度
} Client;

// 创建客户端结构体
Client* create_client(int fd) {
    Client* client = (Client*)malloc(sizeof(Client));
    client->fd = fd;
    client->buffer_len = 0;
    memset(client->buffer, 0, MAX_BUFFER_SIZE);
    return client;
}

// 销毁客户端结构体
void destroy_client(Client* client) {
    free(client);
}

int main() {
    int epoll_fd, num_ready;
    struct epoll_event events[MAX_EVENTS];

    // 创建epoll实例
    epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("Failed to create epoll");
        return 1;
    }

    // 创建监听socket并添加到epoll实例中
    int listen_fd = create_listen_socket(); // 创建监听socket的函数需要自行实现
    if (listen_fd == -1) {
        perror("Failed to create listen socket");
        return 1;
    }

    struct epoll_event event;
    event.events = EPOLLIN; // 监听读事件
    event.data.ptr = create_client(listen_fd); // 将监听socket包装成一个客户端结构体
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &event) == -1) {
        perror("Failed to add listen socket to epoll");
        return 1;
    }

    while (1) {
        // 等待事件发生
        num_ready = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (num_ready == -1) {
            perror("Failed to wait for events");
            return 1;
        }

        // 处理发生的事件
        for (int i = 0; i < num_ready; i++) {
            Client* client = (Client*)events[i].data.ptr;
            int client_fd = client->fd;

            // 如果是监听socket的事件，表示有新的连接
            if (client_fd == listen_fd) {
                int new_client_fd = accept_new_connection(listen_fd); // 接受新连接的函数需要自行实现
                if (new_client_fd == -1) {
                    perror("Failed to accept new connection");
                    continue;
                }

                // 创建新的客户端结构体并添加到epoll实例中
                struct epoll_event new_event;
                new_event.events = EPOLLIN; // 监听读事件
                new_event.data.ptr = create_client(new_client_fd);
                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, new_client_fd, &new_event) == -1) {
                    perror("Failed to add new client to epoll");
                    continue;
                }
                printf("New client connected: %d\n", new_client_fd);
            }
            else {
                // 处理客户端的读事件
                if (events[i].events & EPOLLIN) {
                    // 读取数据
                    int bytes_read = read(client_fd, client->buffer + client->buffer_len, MAX_BUFFER_SIZE - client->buffer_len);
                    if (bytes_read == -1) {
                        perror("Failed to read from client");
                        // 关闭连接并从epoll实例中删除
                        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
                        destroy_client(client);
                        continue;
                    }
                    else if (bytes_read == 0) {
                        // 客户端关闭连接
                        printf("Client disconnected: %d\n", client_fd);
                        // 关闭连接并从epoll实例中删除
                        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
                        destroy_client(client);
                        continue;
                    }
                    else {
                        // 处理接收到的数据，根据需要进行相应操作
                        client->buffer_len += bytes_read;
                        printf("Received data from client %d: %s\n", client_fd, client->buffer);
                    }
                }

                // 处理客户端的写事件（可选）
                if (events[i].events & EPOLLOUT) {
                    // 发送数据给客户端
                    int bytes_written = write(client_fd, client->buffer, client->buffer_len);
                    if (bytes_written == -1) {
                        perror("Failed to write to client");
                        // 关闭连接并从epoll实例中删除
                        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
                        destroy_client(client);
                        continue;
                    }
                    else {
                        // 处理发送成功后的逻辑，根据需要进行相应操作
                        printf("Sent data to client %d\n", client_fd);
                    }
                }
            }
        }
    }

    // 关闭监听socket和epoll实例
    close(listen_fd);
    close(epoll_fd);

    return 0;
}

请注意，上述代码中的一些函数（如`create_listen_socket()`和`accept_new_connection()`）需要根据实际情况进行实现。此外，还可以根据需求添加其他事件的处理逻辑。