你能用c语言写一个构造合式公式的真值表吗

当然可以，下面是一个用C语言实现构造合式公式的真值表的示例代码：

#include <stdio.h>

// 定义布尔类型
typedef enum {
    false,
    true
} bool;

// 定义布尔运算符类型
typedef enum {
    AND,
    OR,
    NOT
} Operator;

// 定义布尔表达式类型
typedef struct {
    bool value;         // 表达式的取值
    bool is_variable;   // 是否是变量
    char variable;      // 变量名
    Operator op;        // 运算符
    struct BooleanExpression* left;  // 左子表达式
    struct BooleanExpression* right; // 右子表达式
} BooleanExpression;

// 创建变量节点
BooleanExpression* createVariable(char variable) {
    BooleanExpression* expr = (BooleanExpression*)malloc(sizeof(BooleanExpression));
    expr->value = false;
    expr->is_variable = true;
    expr->variable = variable;
    return expr;
}

// 创建非运算节点
BooleanExpression* createNot(BooleanExpression* expr) {
    BooleanExpression* not_expr = (BooleanExpression*)malloc(sizeof(BooleanExpression));
    not_expr->value = false;
    not_expr->is_variable = false;
    not_expr->op = NOT;
    not_expr->left = expr;
    not_expr->right = NULL;
    return not_expr;
}

// 创建二元运算节点
BooleanExpression* createBinary(BooleanExpression* left, Operator op, BooleanExpression* right) {
    BooleanExpression* binary_expr = (BooleanExpression*)malloc(sizeof(BooleanExpression));
    binary_expr->value = false;
    binary_expr->is_variable = false;
    binary_expr->op = op;
    binary_expr->left = left;
    binary_expr->right = right;
    return binary_expr;
}

// 计算布尔表达式的取值
bool evaluate(BooleanExpression* expr) {
    if (expr->is_variable) {
        // 变量节点的取值由外部传入
        return expr->value;
    }
    switch (expr->op) {
        case NOT:
            return !evaluate(expr->left);
        case AND:
            return evaluate(expr->left) && evaluate(expr->right);
        case OR:
            return evaluate(expr->left) || evaluate(expr->right);
        default:
            return false;
    }
}

// 打印布尔表达式
void printExpr(BooleanExpression* expr) {
    if (expr->is_variable) {
        printf("%c", expr->variable);
    } else {
        switch (expr->op) {
            case NOT:
                printf("!");
                printExpr(expr->left);
                break;
            case AND:
                printf("(");
                printExpr(expr->left);
                printf(" && ");
                printExpr(expr->right);
                printf(")");
                break;
            case OR:
                printf("(");
                printExpr(expr->left);
                printf(" || ");
                printExpr(expr->right);
                printf(")");
                break;
            default:
                break;
        }
    }
}

// 构造合式公式的真值表
void truthTable(BooleanExpression* expr) {
    // 计算变量个数
    int var_count = 0;
    char var_list[26] = {0};
    for (int i = 0; i < strlen(expr); i++) {
        char ch = expr[i];
        if (ch >= 'a' && ch <= 'z') {
            bool found = false;
            for (int j = 0; j < var_count; j++) {
                if (var_list[j] == ch) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                var_list[var_count++] = ch;
            }
        }
    }
    // 打印表头
    for (int i = 0; i < var_count; i++) {
        printf("%c ", var_list[i]);
    }
    printf("%s\n", expr);
    // 构造真值表
    int row_count = pow(2, var_count);
    for (int i = 0; i < row_count; i++) {
        // 初始化变量节点的取值
        for (int j = 0; j < var_count; j++) {
            BooleanExpression* var_expr = createVariable(var_list[j]);
            var_expr->value = (i & (1 << j)) ? true : false;
        }
        // 计算表达式的取值
        bool result = evaluate(expr);
        // 打印一行真值
        for (int j = 0; j < var_count; j++) {
            printf("%d ", (i & (1 << j)) ? 1 : 0);
        }
        printf("%d\n", result);
    }
}

int main() {
    // 构造布尔表达式
    BooleanExpression* p = createVariable('p');
    BooleanExpression* not_p = createNot(p);
    BooleanExpression* q = createVariable('q');
    BooleanExpression* q_or_not_p = createBinary(q, OR, not_p);
    BooleanExpression* p_and_q_or_not_p = createBinary(p, AND, q_or_not_p);
    // 打印布尔表达式
    printExpr(p_and_q_or_not_p);
    printf("\n");
    // 构造真值表
    truthTable(p_and_q_or_not_p);
    return 0;
}

此代码实现了构造合式公式的真值表的功能，仅供参考。