编写一个结构体，结构体中有3个成员分别，在结构体中写入一个show()函数用来显示结构体成员， 分别用gcc，g++ 去编译，查看编译结果；

以下是一个简单的结构体示例，包含三个成员变量和一个 `show` 函数：

#include <stdio.h>

struct Person {
    char name[20];
    int age;
    float salary;

    void show() {
        printf("Name: %s\n", name);
        printf("Age: %d\n", age);
        printf("Salary: %.2f\n", salary);
    }
};

int main() {
    struct Person p = {"Tom", 25, 5000.5};
    p.show();
    return 0;
}

使用 gcc 编译：

gcc -o struct_example struct_example.c

使用 g++ 编译：

g++ -o struct_example struct_example.c

编译成功后会生成可执行文件 `struct_example`，运行该文件即可看到输出结果：

Name: Tom
Age: 25
Salary: 5000.50

相关问题

用c语言写一个小游戏，运用结构体，链表，二维数组，文件等知识

好的，我可以给你提供一个简单的游戏示例：猜数字游戏。

游戏规则如下：

1. 程序随机生成一个 1-100 之间的整数。

2. 玩家有 10 次机会猜测该数字，每次猜测后程序会告诉玩家猜的数字是大于还是小于答案。

3. 如果玩家在 10 次内猜中了答案，游戏结束并提示胜利；如果 10 次内没有猜中，游戏结束并提示失败。

接下来是代码实现：

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

// 定义链表结构体
struct record {
    int round;  // 猜数字的轮数
    int guess;  // 玩家猜的数字
    char result[10];  // 猜测结果，"大于"或"小于"
    struct record *next;  // 指向下一个节点
};

// 定义全局变量
int answer;  // 答案
int round;  // 当前轮数
struct record *head = NULL;  // 链表头指针

// 函数声明
void generateAnswer();  // 生成答案
void playGame();  // 玩猜数字游戏
void saveRecord(int guess, char *result);  // 保存猜测记录到链表
void showHistory();  // 显示猜测记录
void saveToFile();  // 将猜测记录保存到文件
void loadFromFile();  // 从文件中加载猜测记录

int main() {
    int choice;
    srand(time(NULL));  // 初始化随机数种子
    loadFromFile();  // 加载以前的猜测记录

    do {
        printf("=== 猜数字游戏 ===\n");
        printf("1. 开始新游戏\n");
        printf("2. 查看猜测记录\n");
        printf("3. 退出游戏\n");
        printf("请选择操作：");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                generateAnswer();  // 生成答案
                playGame();  // 玩猜数字游戏
                saveToFile();  // 将猜测记录保存到文件
                break;
            case 2:
                showHistory();  // 显示猜测记录
                break;
            case 3:
                printf("谢谢游玩！\n");
                break;
            default:
                printf("无效操作！\n");
                break;
        }
    } while (choice != 3);

    return 0;
}

void generateAnswer() {
    answer = rand() % 100 + 1;
    round = 1;
}

void playGame() {
    int guess;

    printf("=== 第%d轮 ===\n", round);
    printf("猜一个 1-100 之间的整数：");
    scanf("%d", &guess);

    while (guess != answer && round < 10) {
        if (guess > answer) {
            printf("猜大了！\n");
            saveRecord(guess, "大于");  // 保存猜测记录到链表
        } else {
            printf("猜小了！\n");
            saveRecord(guess, "小于");  // 保存猜测记录到链表
        }

        round++;
        printf("=== 第%d轮 ===\n", round);
        printf("猜一个 1-100 之间的整数：");
        scanf("%d", &guess);
    }

    if (guess == answer) {
        printf("恭喜你猜对了！\n");
    } else {
        printf("很遗憾，你没有猜中。正确答案是%d。\n", answer);
    }
}

void saveRecord(int guess, char *result) {
    // 创建新节点
    struct record *newRecord = (struct record*)malloc(sizeof(struct record));
    newRecord->round = round;
    newRecord->guess = guess;
    strcpy(newRecord->result, result);
    newRecord->next = NULL;

    if (head == NULL) {  // 如果链表为空，添加为头节点
        head = newRecord;
    } else {  // 否则添加到末尾
        struct record *p = head;
        while (p->next != NULL) {
            p = p->next;
        }
        p->next = newRecord;
    }
}

void showHistory() {
    if (head == NULL) {  // 链表为空，没有猜测记录
        printf("没有猜测记录。\n");
    } else {
        printf("猜测记录：\n");
        struct record *p = head;
        while (p != NULL) {  // 遍历链表，打印每个节点的信息
            printf("第%d轮，猜%d，结果：%s\n", p->round, p->guess, p->result);
            p = p->next;
        }
    }
}

void saveToFile() {
    FILE *fp = fopen("guess_history.txt", "w");  // 以写入方式打开文件
    if (fp == NULL) {  // 文件打开失败
        printf("无法保存猜测记录到文件！\n");
    } else {
        struct record *p = head;
        while (p != NULL) {  // 遍历链表，将每个节点的信息写入文件
            fprintf(fp, "%d %d %s\n", p->round, p->guess, p->result);
            p = p->next;
        }
        fclose(fp);  // 关闭文件
        printf("猜测记录已保存到文件！\n");
    }
}

void loadFromFile() {
    FILE *fp = fopen("guess_history.txt", "r");  // 以读取方式打开文件
    if (fp == NULL) {  // 文件不存在，无需加载
        return;
    }

    char line[20];
    while (fgets(line, sizeof(line), fp) != NULL) {  // 从文件中读取每行数据
        int round, guess;
        char result[10];
        sscanf(line, "%d %d %s", &round, &guess, result);  // 解析数据到变量中
        saveRecord(guess, result);  // 将数据添加到链表中
    }

    fclose(fp);  // 关闭文件
    printf("猜测记录已从文件中加载！\n");
}

在这个示例中，我们使用了结构体来定义猜测记录，链表来保存猜测记录，二维数组和文件来实现猜测记录的读写。当然，这只是一个简单的示例，你可以根据自己的兴趣和需求来设计更加复杂的游戏和数据结构。

qt creator 主窗口解析json文件，将读取到的数据写入结构体，传值到子窗口中，修改后的结构体再传回到主窗口

首先，你需要在主窗口中创建一个读取json文件的函数，使用QJsonDocument和QJsonObject来解析json文件，并将数据写入结构体中。这个函数可能类似于以下代码：

#include <QFile>
#include <QJsonDocument>
#include <QJsonObject>

struct MyData {
    QString name;
    int age;
    QString address;
};

void MainWindow::loadJsonFile(QString filename, MyData& data) {
    QFile file(filename);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        qDebug() << "Failed to open file:" << filename;
        return;
    }

    QByteArray jsonData = file.readAll();
    QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonData);

    QJsonObject jsonObj = jsonDoc.object();
    data.name = jsonObj["name"].toString();
    data.age = jsonObj["age"].toInt();
    data.address = jsonObj["address"].toString();
}

接下来，你需要在主窗口中创建一个槽函数来打开子窗口，并将结构体传递给子窗口。这个函数可能类似于以下代码：

void MainWindow::openChildWindow() {
    ChildWindow* childWindow = new ChildWindow(this);
    childWindow->setData(m_data);
    connect(childWindow, &ChildWindow::dataChanged, this, &MainWindow::onDataChanged);
    childWindow->show();
}

在这里，我们假设你已经在主窗口中定义了一个结构体变量m_data来存储读取到的数据，openChildWindow()函数会创建一个子窗口并调用子窗口的setData()函数将m_data传递给它。

在子窗口中，你需要定义一个setData()函数来接收主窗口传递过来的结构体，并将它存储在一个成员变量中。这个函数可能类似于以下代码：

void ChildWindow::setData(const MyData& data) {
    m_data = data;
    ui->nameEdit->setText(data.name);
    ui->ageSpinBox->setValue(data.age);
    ui->addressEdit->setText(data.address);
}

在这里，我们假设你已经在子窗口中定义了一个MyData类型的成员变量m_data，setData()函数会将主窗口传递过来的结构体存储在这个成员变量中，并将结构体中的数据显示在对应的控件中。

当用户在子窗口中修改了数据后，你需要在子窗口中定义一个槽函数来将修改后的结构体传递给主窗口。这个函数可能类似于以下代码：

void ChildWindow::on_okButton_clicked() {
    m_data.name = ui->nameEdit->text();
    m_data.age = ui->ageSpinBox->value();
    m_data.address = ui->addressEdit->text();

    emit dataChanged(m_data);
    close();
}

在这里，我们假设你在子窗口中定义了一个名为dataChanged的信号，用于将修改后的结构体传递给主窗口。当用户点击子窗口中的确认按钮时，on_okButton_clicked()函数会将修改后的结构体存储在m_data中，并通过dataChanged信号将它传递给主窗口。

最后，在主窗口中，你需要定义一个槽函数来接收子窗口传递过来的修改后的结构体，并更新主窗口中的数据。这个函数可能类似于以下代码：

void MainWindow::onDataChanged(const MyData& data) {
    m_data = data;
    ui->nameLabel->setText(data.name);
    ui->ageLabel->setText(QString::number(data.age));
    ui->addressLabel->setText(data.address);
}

在这里，我们假设你已经在主窗口中定义了一个MyData类型的变量m_data，onDataChanged()函数会将子窗口传递过来的修改后的结构体存储在这个变量中，并将结构体中的数据显示在对应的标签控件中。

综上所述，你可以通过以上步骤在Qt Creator中实现解析json文件，将数据写入结构体，传递到子窗口中，修改后再传回到主窗口中的功能。