用C++实现，并标好注释

以下是 C++ 的实现，已标注注释：

#include <iostream>
#include <vector>
#include <map>
#include <bitset>
#include <algorithm>
using namespace std;

// 定义逻辑运算函数
bool and_op(bool a, bool b) {
    return a && b;
}

bool or_op(bool a, bool b) {
    return a || b;
}

bool not_op(bool a) {
    return !a;
}

// 定义节点类
class Node {
public:
    Node(char data, Node* left = nullptr, Node* right = nullptr) :
        data(data), left(left), right(right) {}

    // 判断是否为叶子节点
    bool is_leaf() const {
        return left == nullptr && right == nullptr;
    }

    // 获取变量名集合
    set<char> get_vars() const {
        if (is_leaf()) {
            return {data};
        }
        else {
            set<char> vars_left = left->get_vars();
            set<char> vars_right = right->get_vars();
            vars_left.insert(vars_right.begin(), vars_right.end());
            return vars_left;
        }
    }

    // 数据成员
    char data;
    Node* left;
    Node* right;
};

// 递归求解函数
bool eval(const Node* node, const map<char, bool>& values) {
    if (node->is_leaf()) {
        return values.at(node->data);
    }
    else {
        bool left_value = eval(node->left, values);
        bool right_value = eval(node->right, values);
        char op = node->data;
        switch (op) {
            case '&': return and_op(left_value, right_value);
            case '|': return or_op(left_value, right_value);
            case '~': return not_op(left_value);
            default: throw runtime_error("Invalid operator: " + string(1, op));
        }
    }
}

// 表达式解析函数
Node* parse_expr(string expr) {
    vector<string> tokens;
    string token;
    for (char c : expr) {
        if (c == ' ') {
            if (!token.empty()) {
                tokens.push_back(token);
                token.clear();
            }
        }
        else {
            token += c;
        }
    }
    if (!token.empty()) {
        tokens.push_back(token);
    }

    vector<Node*> stack;
    for (const string& token : tokens) {
        if (token == "&" || token == "|" || token == "~") {
            Node* right = stack.back(); stack.pop_back();
            Node* left = stack.back(); stack.pop_back();
            stack.push_back(new Node(token[0], left, right));
        }
        else {
            stack.push_back(new Node(token[0]));
        }
    }
    return stack.back();
}

// 主函数
int main() {
    string expr;
    while (getline(cin, expr)) {
        // 解析表达式
        Node* root = parse_expr(expr);

        // 输出表头
        set<char> var_names = root->get_vars();
        vector<char> vars(var_names.begin(), var_names.end());
        sort(vars.begin(), vars.end());
        cout << vars[0];
        for (int i = 1; i < vars.size(); i++) {
            cout << " " << vars[i];
        }
        cout << " " << expr << endl;

        // 枚举所有可能的变量取值，并输出真值表
        int n = vars.size();
        for (int i = 0; i < (1 << n); i++) {
            map<char, bool> values;
            for (int j = 0; j < n; j++) {
                values[vars[j]] = (i >> j) & 1;
                cout << values[vars[j]] << " ";
            }
            bool result = eval(root, values);
            cout << result << endl;
        }
    }
    return 0;
}

需要注意的是，在 C++ 中，由于没有 `set` 类型的并集操作，我们需要手动实现 `get_vars` 函数来获取变量名集合。另外，在解析表达式时，我们使用了一个栈来辅助构造表达式树。最后，由于在 C++ 中没有 Python 中的 `bool` 类型和 `map` 类型，我们需要手动实现 `map<char, bool>` 类型来存储变量取值。