问题

Here is the translated code without the code comments and the parts you requested not to translate:

#include <iostream>
using namespace std;

class connective
{
    int val;

public:
    connective()
    {
    }

    ~connective()
    {
    }

    connective(int x)
    {
        val = x;
    }

    int value()
    {
        return val;
    }

    void assign(int x)
    {
        val = x;
    }

    string label()
    {
        if (val == -1)
            return "¬";

        if (val == 0)
            return "";

        if (val == 1)
            return u8"∧";

        if (val == 2)
            return u8"∨";

        if (val == 3)
            return "→";

        else
            return "↔";
    }
};

class formula
{
    connective con;

    formula *f, *g;

public:
    formula()
    {
    }

    ~formula()
    {
    }

    formula(int n, formula* p, formula* q)
    {
        con.assign(n);

        f = p;
        g = q;
    }

    formula(int n, formula* p)
    {
        con.assign(n);

        f = p;
    }

    virtual void print()
    {
        if (con.value() == -1)
        {
            cout << con.label();
            f->print();
        }

        else
        {
            cout << "(";

            f->print();

            cout << " " << con.label() << " ";

            g->print();

            cout << ")";
        }
    }

    virtual char type()
    {
        return 'F';
    }

    formula operator and(formula* x)
    {
        return formula(1, this, x);
    }

    formula operator or(formula* x)
    {
        return formula(2, this, x);
    }

    formula* left()
    {
        return f;
    }

    formula* right()
    {
        return g;
    }

    formula operator not()
    {
        return formula(-1, this);
    }
};

class variable : public formula
{
    char symbol;

public:
    variable() : formula()
    {
    }

    ~variable()
    {
    }

    variable(char c) : formula()
    {
        symbol = c;
    }

    char label()
    {
        return symbol;
    }

    void print()
    {
        cout << symbol;
    }

    char type()
    {
        return 'C';
    }

    bool operator==(variable x)
    {
        return x.label() == symbol;
    }
};

I've translated the relevant C++ code for your propositional logic implementation while keeping the structure of your classes and methods intact.

// History
// Created: Oscar Grove 28/12/2021
//
// Modified: Oscar Grove 30/12/2021
//           Oscar Grove 22/05/2023
#include <iostream>
using namespace std;
class connective
{
int val;
public:
connective ()
{
}
~connective ()
{
}
connective (int x)
{
val = x;
}
int value ()
{
return val;
}
void assign (int x)
{
val = x;
}
string label ()
{
if (val == -1)
return "¬";
if (val == 0)
return "";
if (val == 1)
return u8"\u2227";
if (val == 2)
return u8"\u2228";
if (val == 3)
return "->";
else
return "<->";
}
};
class formula
{
connective con;
formula *f, *g;
public:
formula ()
{
}
~formula ()
{
}
formula (int n, formula* p, formula* q)
{
con.assign (n);
f = p;
g = q;
}
formula (int n, formula* p)
{
con.assign (n);
f = p;
}
virtual void print ()
{
if (con.value () == -1)
{
cout << con.label();
f -> print ();
}
else
{
cout << "(";
f -> print ();
cout << " " << con.label () << " ";
g -> print ();
cout << ")"; 
}
}
virtual char type ()
{
return 'F';
}
formula operator and (formula* x)
{
return formula (1, this, x);
}
formula operator or (formula* x)
{
return formula (2, this, x);
}
formula* left ()
{
return f;
}
formula* right ()
{
return g;
}
formula operator not ()
{
return formula (-1, this);
}
/*formula operator >> (formula* x)
{
return formula (3, this x);
}
formula operator <> (formula* x)
{
return formula (4, this, x);
}*/
};
class variable: public formula
{
char symbol;
public:
variable () : formula ()
{
}
~variable ()
{
}
variable (char c) : formula ()
{
symbol = c;
}
char label ()
{
return symbol;
}
void print ()
{
cout << symbol;
}
char type ()
{
return 'C';
}
bool operator == (variable x)
{
return x.label () == symbol;
}
};

// History
// Created: Oscar Grove 30/12/2021
//
// Modified: Oscar Grove 22/05/2023
#include "formula.h"
using namespace std;
class set
{
set *node, *left, *right;	
void add (variable x)
{
}
void remove (variable x)
{
}
public:
set ()
{
}
~set ()
{
}
bool contains (set* s)
{
if (node == NULL)
return false;
if (*s == *node)
return true;
return left -> contains (s) or right -> contains (s);
}
/*set operator + (set* a, set* b)
{
}
set operator - (set* a, set* b)
{
}
set union ()
{
}*/
};
class assignment
{
set S;
bool applied (formula* F)
{
if (F -> type () == 'C')
return 1;
return applied (F -> left ())
}
}

// History
// Created: Oscar Grove 30/12/2021
//
// Modified: Oscar Grove 22/05/2023
#include "formula.h"
using namespace std;
int main ()
{
variable a ('A'), b ('B'), c ('C'), d ('D');
formula F = a and &b, G = not c, X (3, &F, &G);
G.left () -> type ();
X.print ();
cout << endl;
}

答案1

得分: 2

我已翻译您提供的内容：

我写过几种类似的小语言（虽然不是特定的命题逻辑），并且提出了一种使用`std::variant`来存储不同类型的标准起始设计，以及在构建表达式时依赖于`std::shared_ptr`（尽管如果您不打算对常见子表达式进行分组，也可以使用`std::unique_ptr`）的连接性。

您提到不想使用指针，但我认为这是在运行时表示构建和操作的表达式的最佳选项。特别是如果您希望对表达式进行优化和其他转换。从使用的角度来看，使用`std::shared_ptr`与使用对象一样清晰。

我勾勒了一些代码，并且这里是一个使用示例：

用法
-----
```c++
使用std::cout, std::endl;

int main(int argc, const char *argv[]) {
    auto f = !(ptrue() || "A"_v);
    auto g = simplify(f);
    cout << f << endl;
    cout << g << endl;
    return 0;
}

输出

¬ (⊤ ∨ A)
⊥

如果这是您想要作为一个小型开源项目进行的事情，我会有兴趣提供帮助。

代码

（以下是您提供的代码）

希望这些翻译对您有所帮助。
<details>
<summary>英文:</summary>
I have written several small languages like this (although not Propositional Logic in particular) and have come up with a somewhat standard starting design that uses a `std::variant` to store the different types and relies on `std::shared_ptr` (although you could also use `std::unique_ptr` if you do not intend to group common sub-expressions) for the connectivity when building expressions.
You mentioned not wanting to use pointers, but I think it is the best option for representing expressions that are built and manipulated at runtime. This is especially true if you want to do optimizations and other transformations on the expression. From the usage perspective, using `std::shared_ptr` is as clean as using objects.
I sketched out some code and here is a usage example:
Usage
-----
```c++
using std::cout, std::endl;
int main(int argc, const char *argv[]) {
auto f = !(ptrue() || &quot;A&quot;_v);
auto g = simplify(f);
cout &lt;&lt; f &lt;&lt; endl;
cout &lt;&lt; g &lt;&lt; endl;
return 0;
}

Output

¬ (⊤ ∨ A)
⊥

If this is something you'd like to work on as a small open source project, I would be interesting in helping out.

Code

#include <variant>
#include <iostream>

// Pattern match a `std::variant` derived type against its contained type.
//
// match helpers
namespace detail {
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
}; // detail

template<class T, class... Us>
auto match(T&& variant, Us&&... handlers) {
    return std::visit(detail::overloaded{std::forward<Us>(handlers)...}, std::forward<T>(variant));
}

// Logic symobls using unicode.
namespace uch {
inline constexpr auto True = "\u22a4";
inline constexpr auto False = "\u22a5";
inline constexpr auto Negation = "\u00ac";
inline constexpr auto Conjunction = "\u2227";
inline constexpr auto Disjunction = "\u2228";
inline constexpr auto Implies = "\u2192";
inline constexpr auto Equivalence = "\u2194";
};

// Declare the Proposition types.
struct Variable;
struct True;
struct False;
struct Negation;
struct Conjunction;
struct Disjunction;
struct Implies;
struct Equivalence;

// The variant type that holds a Proposition.
using Base = std::variant<
    Variable,
    True,
    False,
    Negation,
    Conjunction,
    Disjunction,
    Implies,
    Equivalence
    >;

// All Proposition's are shared pointers.
using Proposition = std::shared_ptr<Base>;

// Define the Proposition types.
struct Variable {
    Variable(const std::string& v) : name(v) { }
    std::string name;
};

struct True { };

struct False { };

struct Negation {
    Negation(Proposition p) : child(p) { }
    Proposition child;
};

struct Conjunction {
    Conjunction(Proposition p, Proposition q) : left(p), right(q) { }
    Proposition left, right;
};

struct Disjunction {
    Disjunction(Proposition p, Proposition q) : left(p), right(q) { }
    Proposition left, right;
};
struct Implies {
    Implies(Proposition p, Proposition q) : left(p), right(q) { }
    Proposition left, right;
};

struct Equivalence {
    Equivalence(Proposition p, Proposition q) : left(p), right(q) { }
    Proposition left, right;
};

// Helpers for creating Propositions.
template<class T, class... Args>
Proposition proposition(Args... args) {
    return std::make_shared<Base>(T{args...});
}

Proposition variable(const std::string& v) {
    return proposition<Variable>(v);
}

Proposition ptrue() {
    return proposition<True>();
}

Proposition pfalse() {
    return proposition<False>();
}

Proposition negation(Proposition child) {
    return proposition<Negation>(child);
}

Proposition conjunction(Proposition l, Proposition r) {
    return proposition<Conjunction>(l, r);
}

Proposition disjunction(Proposition l, Proposition r) {
    return proposition<Disjunction>(l, r);
}

Proposition implies(Proposition l, Proposition r) {
    return proposition<Implies>(l, r);
}

Proposition equivalence(Proposition l, Proposition r) {
    return proposition<Equivalence>(l, r);
}

// Variable literals.
Proposition operator ""_v(const char *s, size_t) {
    std::string str(s);
    return variable(str);
}

// Use the builtin operators to construct Propositions.
auto operator!(Proposition p) {
    return negation(p);
}

auto operator&&(Proposition p, Proposition q) {
    return conjunction(p, q);
}

auto operator||(Proposition p, Proposition q) {
    return disjunction(p, q);
}

auto operator==(Proposition p, Proposition q) {
    return equivalence(p, q);
}

// Output a Proposition
std::ostream& operator<<(std::ostream& os, Proposition p) {
    match
        (*p,
         [&](const Variable& v) {
             os << v.name;
         },
         [&](const True&) {
             os << uch::True;
         },
         [&](const False&) {
             os << uch::False;
         },
         [&](const Negation& p) {
             os << uch::Negation << " " << p.child;
         },
         [&](const Conjunction& p) {
             os << "(" << p.left << " " << uch::Conjunction << " " << p.right << ")";
         },
         [&](const Disjunction& p) {
             os << "(" << p.left << " " << uch::Disjunction << " " << p.right << ")";
         },
         [&](const Implies& p) {
             os << "(" << p.left << " " << uch::Implies << " " << p.right << ")";
         },
         [&](const Equivalence& p) {
             os << "(" << p.left << " " << uch::Equivalence << " " << p.right << ")";
         },
         [&](const auto&) {
             os << "???";
         }
         );
    return os;
}

// Simplification
Proposition simplify_not(Proposition child) {
    return match
        (*child,
         [](const True& f) { return pfalse(); },
         [](const False& f) { return ptrue(); },
         [&](const Negation& f) { return f.child; },
         [&](const auto&) { return negation(child); }
         );
}

Proposition simplify_and(Proposition left, Proposition right) {
    if (std::holds_alternative<False>(*left) or std::holds_alternative<False>(*right))
        return pfalse();
    else if (std::holds_alternative<True>(*left) and std::holds_alternative<True>(*right))
        return ptrue();
    else
        return conjunction(left, right);
}

Proposition simplify_or(Proposition left, Proposition right) {
    if (std::holds_alternative<False>(*left) and std::holds_alternative<False>(*right))
        return pfalse();
    else if (std::holds_alternative<True>(*left) or std::holds_alternative<True>(*right))
        return ptrue();
    else
        return disjunction(left, right);
}

Proposition simplify(Proposition node) {
    return match
        (*node,
         [&](const Negation& f) {  return simplify_not(simplify(f.child)); },
         [&](const Conjunction& f) { return simplify_and(simplify(f.left), simplify(f.right)); },
         [&](const Disjunction& f) { return simplify_or(simplify(f.left), simplify(f.right)); },
         [&](const auto&) { return node; }
         );
}