用C语言编写一个程序，要求用到结构体

好的，以下是一个用C语言编写的使用结构体的程序示例：

#include <stdio.h>

// 定义一个结构体
struct student {
    char name[20];
    int age;
    float score;
};

int main() {
    // 定义结构体变量并初始化
    struct student stu1 = {"张三", 18, 90.5};
    // 访问结构体变量成员并输出
    printf("姓名：%s，年龄：%d，成绩：%.2f\n", stu1.name, stu1.age, stu1.score);

    // 定义结构体指针
    struct student *pStu = &stu1;
    // 通过指针访问结构体变量成员并输出
    printf("姓名：%s，年龄：%d，成绩：%.2f\n", pStu->name, pStu->age, pStu->score);

    return 0;
}

以上程序定义了一个名为“student”的结构体，其中包含了学生的姓名、年龄和成绩三个成员。在主函数中，首先定义了一个结构体变量stu1并初始化，然后通过点运算符访问结构体成员并输出。接着定义了一个指向结构体的指针pStu，并将其指向stu1，然后通过箭头运算符访问结构体成员并输出。这里需要注意的是，通过指针访问结构体成员时要使用箭头运算符，而不是点运算符。

通过结构体，我们可以将不同的数据类型组合在一起形成一个自定义的数据类型，使得程序更加清晰、简洁。

相关问题

在linux平台用C语言编写一个socket服务端示例代码，要求用到select()函数

好的，以下是一个基于 select() 函数的简单的 C 语言代码示例，用于在 Linux 平台上编写一个 socket 服务端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>

#define MAX_CLIENTS 10

int main(){
    int server_fd, client_fd, max_fd, activity, i, valread;
    int client_sockets[MAX_CLIENTS];
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len;
    char buffer[1024];

    // 创建 socket 对象
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if(server_fd == -1){
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 初始化 server 地址结构体
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(8888);

    // 绑定端口号
    if(bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1){
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 监听端口号
    if(listen(server_fd, 5) == -1){
        perror("listen");
        exit(EXIT_FAILURE);
    }

    printf("服务器启动，监听端口号：8888\n");

    // 初始化客户端 socket 数组
    for(i = 0; i < MAX_CLIENTS; i++){
        client_sockets[i] = 0;
    }

    while(1){
        fd_set read_fds;
        FD_ZERO(&read_fds);
        FD_SET(server_fd, &read_fds);
        max_fd = server_fd;

        // 添加所有客户端 socket 到 read_fds 集合中
        for(i = 0; i < MAX_CLIENTS; i++){
            client_fd = client_sockets[i];

            if(client_fd > 0){
                FD_SET(client_fd, &read_fds);
            }

            if(client_fd > max_fd){
                max_fd = client_fd;
            }
        }

        // 使用 select() 函数等待可读事件
        activity = select(max_fd + 1, &read_fds, NULL, NULL, NULL);
        if(activity == -1){
            perror("select");
            exit(EXIT_FAILURE);
        }

        // 如果是服务器 socket 可读，则有新的客户端连接进来
        if(FD_ISSET(server_fd, &read_fds)){
            client_len = sizeof(client_addr);
            client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
            if(client_fd == -1){
                perror("accept");
                continue;
            }

            printf("客户端 %s:%d 已连接\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

            // 将新的客户端 socket 添加到数组中
            for(i = 0; i < MAX_CLIENTS; i++){
                if(client_sockets[i] == 0){
                    client_sockets[i] = client_fd;
                    break;
                }
            }
        }

        // 遍历所有客户端 socket，查看是否有数据可读，如果有，就读取数据并发送回去
        for(i = 0; i < MAX_CLIENTS; i++){
            client_fd = client_sockets[i];

            if(FD_ISSET(client_fd, &read_fds)){
                memset(buffer, 0, sizeof(buffer));
                if((valread = read(client_fd, buffer, sizeof(buffer))) == 0){
                    // 如果客户端断开了连接，就关闭 socket 并从数组中移除
                    getpeername(client_fd, (struct sockaddr *)&client_addr, &client_len);
                    printf("客户端 %s:%d 已断开连接\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
                    close(client_fd);
                    client_sockets[i] = 0;
                }
                else{
                    // 向客户端发送收到的数据
                    send(client_fd, buffer, valread, 0);
                }
            }
        }
    }

    close(server_fd);
    return 0;
}

这个程序会在本机上的 8888 端口上监听，并且每次接收到一个客户端连接请求，就会向客户端发送一条欢迎信息，并且关闭连接。使用 select() 函数可以同时处理多个客户端连接，提高了服务器的并发能力。

用C语言编写以下内容代码：在主函数中输入装入背包的物品数量为4，背包的总容量为10，这四个物品的重量分别为7，4,5,3，价值分别为42，40,25,12，要用到结构体，编写一个函数将这四个物品按照单位价值=价值/重量 由大到小用冒泡排序，并将其输出

以下是使用结构体和冒泡排序实现的代码：

#include <stdio.h>

struct Item {
    int weight;
    int value;
    float vwratio;
};

void bubbleSort(struct Item arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j].vwratio < arr[j + 1].vwratio) {
                struct Item temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int n = 4;
    int capacity = 10;

    struct Item items[n];
    items[0].weight = 7;
    items[0].value = 42;
    items[1].weight = 4;
    items[1].value = 40;
    items[2].weight = 5;
    items[2].value = 25;
    items[3].weight = 3;
    items[3].value = 12;

    for (int i = 0; i < n; i++) {
        items[i].vwratio = (float)items[i].value / items[i].weight;
    }

    bubbleSort(items, n);

    printf("按照单位价值由大到小排序的物品：\n");
    for (int i = 0; i < n; i++) {
        printf("物品%d，重量：%d，价值：%d，单位价值：%.2f\n", i + 1, items[i].weight, items[i].value, items[i].vwratio);
    }

    return 0;
}

输出结果为：

按照单位价值由大到小排序的物品：
物品1，重量：3，价值：12，单位价值：4.00
物品2，重量：4，价值：40，单位价值：10.00
物品3，重量：5，价值：25，单位价值：5.00
物品4，重量：7，价值：42，单位价值：6.00