C++实现命题逻辑的两类问题：运算符扩展与赋值类开发

一、核心设计思路：用值语义替代继承避免切片问题 #

传统继承式的Formula基类会导致对象切片，推荐使用C++17的std::variant实现值语义的多态公式类型，无需指针即可安全持有不同类型的命题节点。

二、蕴含与双向蕴含运算符的实现 #

1. 公式类型定义 #

先定义所有命题逻辑节点类型，再用std::variant统一为Formula类型：

#include <variant>
#include <string>
#include <unordered_map>
#include <stdexcept>
#include <iostream>

// 前向声明各命题节点
struct Atomic;
struct Negation;
struct Conjunction;
struct Disjunction;
struct Implication;
struct Biconditional;

// 统一的Formula类型，值语义，无切片问题
using Formula = std::variant<Atomic, Negation, Conjunction, Disjunction, Implication, Biconditional>;

// 原子命题
struct Atomic {
    std::string name;
};

// 否定
struct Negation {
    Formula operand;
};

// 合取
struct Conjunction {
    Formula left;
    Formula right;
};

// 析取
struct Disjunction {
    Formula left;
    Formula right;
};

// 蕴含（A→B：前件antecedent，后件consequent）
struct Implication {
    Formula antecedent;
    Formula consequent;
};

// 双向蕴含（A↔B）
struct Biconditional {
    Formula left;
    Formula right;
};

2. 运算符重载 #

通过重载标准运算符或自定义函数，实现贴近数学写法的公式构造：

// 否定：!p
Negation operator!(Formula f) {
    return Negation{std::move(f)};
}

// 合取：p && q
Conjunction operator&&(Formula left, Formula right) {
    return Conjunction{std::move(left), std::move(right)};
}

// 析取：p || q
Disjunction operator||(Formula left, Formula right) {
    return Disjunction{std::move(left), std::move(right)};
}

// 蕴含：p >= q 等价于 p→q（C++无法直接重载→，用>=替代更直观）
Implication operator>=(Formula antecedent, Formula consequent) {
    return Implication{std::move(antecedent), std::move(consequent)};
}

// 双向蕴含：bicond(p, q) 等价于 p↔q
Biconditional bicond(Formula left, Formula right) {
    return Biconditional{std::move(left), std::move(right)};
}

三、Assignment类的实现：贴近数学定义的真值求值 #

利用std::visit和constexpr if替代switch分支，直接映射每个命题类型的数学求值规则：

class Assignment {
private:
    std::unordered_map<std::string, bool> prop_values;
public:
    // 为原子命题赋值
    void assign(const std::string& prop_name, bool value) {
        prop_values[prop_name] = value;
    }

    // 递归求值，完全对应数学定义
    bool evaluate(const Formula& formula) const {
        return std::visit([this](const auto& node) -> bool {
            using NodeType = std::decay_t<decltype(node)>;
            
            if constexpr (std::is_same_v<NodeType, Atomic>) {
                // 查找原子命题的赋值，未赋值则抛出异常
                auto it = prop_values.find(node.name);
                if (it == prop_values.end()) {
                    throw std::runtime_error("未赋值的原子命题：" + node.name);
                }
                return it->second;
            } 
            else if constexpr (std::is_same_v<NodeType, Negation>) {
                return !evaluate(node.operand);
            }
            else if constexpr (std::is_same_v<NodeType, Conjunction>) {
                return evaluate(node.left) && evaluate(node.right);
            }
            else if constexpr (std::is_same_v<NodeType, Disjunction>) {
                return evaluate(node.left) || evaluate(node.right);
            }
            else if constexpr (std::is_same_v<NodeType, Implication>) {
                // A→B 等价于 ¬A∨B
                bool a = evaluate(node.antecedent);
                bool b = evaluate(node.consequent);
                return !a || b;
            }
            else if constexpr (std::is_same_v<NodeType, Biconditional>) {
                // A↔B 等价于 (A→B)∧(B→A)，即A与B真值相同
                bool a = evaluate(node.left);
                bool b = evaluate(node.right);
                return a == b;
            }
            
            throw std::runtime_error("未知的命题类型");
        }, formula);
    }
};

四、使用示例 #

int main() {
    // 创建原子命题
    Formula p = Atomic{"p"};
    Formula q = Atomic{"q"};

    // 构造公式：p → (q ∧ ¬p)
    Formula formula = p >= (q && !p);

    // 创建赋值
    Assignment assn;
    assn.assign("p", true);
    assn.assign("q", false);

    // 求值并输出
    try {
        bool result = assn.evaluate(formula);
        std::cout << "公式真值：" << (result ? "真" : "假") << std::endl;
        // 预期输出：假
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

方案优势 #

• 无切片问题：std::variant实现值语义，无需指针即可安全管理不同类型的命题节点。
• 运算符直观：重载的运算符和自定义函数贴近数学写法，构造公式简洁自然。
• 求值逻辑清晰：constexpr if直接映射数学定义，无冗余switch分支，代码可读性高。

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