C语言逻辑门电路实现：自动复用前序门输出的问题

核心思路 #

通过扩展原有逻辑门结构体添加输出缓存字段，结合输入复用处理函数，让后续门直接读取前序门的计算结果，无需重复输入。核心步骤：

1. 给结构体新增output字段，存储每个门的计算结果作为缓存；
2. 新增输入处理函数，支持复用前序门的输出；
3. 前3个门仍使用原getinput获取用户输入，后续门启用复用逻辑；
4. 门计算完成后更新缓存，供后续门调用。

完整代码实现 #

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

typedef enum { AND, OR, NOT, NAND, NOR } GateType;

// 保留原有结构体并扩展output字段
typedef struct {
    GateType type;
    int* inputs;    // 动态分配的输入数组
    int input_count;
    int output;     // 新增：存储该门的输出结果，用于后续复用
} LogicGate;

// 原有的用户输入获取函数
int getinput() {
    int val;
    do {
        printf("请输入0或1: ");
        scanf("%d", &val);
    } while (val != 0 && val != 1);
    return val;
}

// 新增：支持复用前序门输出的输入处理函数
int get_or_reuse_input(LogicGate* gates, int existing_gate_count, int input_seq) {
    printf("请输入第%d个输入（输入0/1，或输入-n复用第n个门的输出）: ", input_seq + 1);
    int val;
    scanf("%d", &val);

    if (val < 0) {
        int target_idx = -val - 1; // 转换为数组索引（输入-1对应第1个门，即数组索引0）
        if (target_idx < 0 || target_idx >= existing_gate_count) {
            printf("无效的门索引，请重新输入！\n");
            return get_or_reuse_input(gates, existing_gate_count, input_seq);
        }
        printf("自动复用第%d个门的输出: %d\n", target_idx + 1, gates[target_idx].output);
        return gates[target_idx].output;
    } else if (val != 0 && val != 1) {
        printf("输入无效，请重新输入0或1！\n");
        return get_or_reuse_input(gates, existing_gate_count, input_seq);
    }
    return val;
}

// 逻辑门计算函数，计算后更新output缓存
int calculate_gate(LogicGate* gate) {
    int result;
    switch (gate->type) {
        case AND:
            result = 1;
            for (int i = 0; i < gate->input_count; i++) result &= gate->inputs[i];
            break;
        case OR:
            result = 0;
            for (int i = 0; i < gate->input_count; i++) result |= gate->inputs[i];
            break;
        case NOT:
            result = !gate->inputs[0];
            break;
        case NAND:
            result = 1;
            for (int i = 0; i < gate->input_count; i++) result &= gate->inputs[i];
            result = !result;
            break;
        case NOR:
            result = 0;
            for (int i = 0; i < gate->input_count; i++) result |= gate->inputs[i];
            result = !result;
            break;
        default:
            result = 0;
            break;
    }
    gate->output = result;
    return result;
}

int main() {
    int total_gates;
    printf("请输入逻辑门总数: ");
    scanf("%d", &total_gates);

    // 动态分配逻辑门数组
    LogicGate* gates = (LogicGate*)malloc(total_gates * sizeof(LogicGate));
    if (!gates) {
        printf("内存分配失败！\n");
        return 1;
    }

    for (int i = 0; i < total_gates; i++) {
        printf("\n=== 配置第%d个逻辑门 ===\n", i + 1);
        printf("选择门类型(0=AND,1=OR,2=NOT,3=NAND,4=NOR): ");
        int type;
        scanf("%d", &type);
        gates[i].type = (GateType)type;

        // 根据门类型设置输入数量
        gates[i].input_count = (gates[i].type == NOT) ? 1 : 2;

        // 动态分配输入数组
        gates[i].inputs = (int*)malloc(gates[i].input_count * sizeof(int));
        if (!gates[i].inputs) {
            printf("内存分配失败！\n");
            // 释放已分配的内存
            for (int j = 0; j < i; j++) free(gates[j].inputs);
            free(gates);
            return 1;
        }

        // 前3个门直接获取用户输入，后续门启用复用逻辑
        for (int j = 0; j < gates[i].input_count; j++) {
            gates[i].inputs[j] = (i < 3) ? getinput() : get_or_reuse_input(gates, i, j);
        }

        // 计算并输出结果
        int output = calculate_gate(&gates[i]);
        printf("第%d个门的输出结果: %d\n", i + 1, output);
    }

    // 释放所有动态分配的内存
    for (int i = 0; i < total_gates; i++) free(gates[i].inputs);
    free(gates);
    return 0;
}

关键细节说明 #

• 结构体扩展：新增的output字段是复用逻辑的核心，每个门计算完成后会把结果存在这里，后续门可以直接读取；
• 输入复用规则：从第4个门开始，用户可以输入-n（n为前序门的序号）来复用该门的输出，程序会自动转换为数组索引并读取缓存值；
• 动态内存保留：所有门和输入数组的动态分配、释放逻辑完全保留，符合需求；
• 错误处理：对无效的门索引和输入值做了校验，避免程序崩溃。

可选优化 #

如果希望完全自动复用（无需用户手动输入负数），可以添加逻辑：在创建后续门时，自动列出所有已计算的门输出，让用户选择复用哪一个，或者预设复用规则（比如默认复用前一个门的输出）。

内容的提问来源于stack exchange，提问作者BraVeHurt