C++实现命题逻辑公式类的多态运算符重载问题及方案

问题背景 #

尝试在C++类中编码实现命题逻辑对应的公式结构。
命题逻辑中的公式可分为三类：

• 变量
• 某个公式的否定式
• 由连接词连接两个公式构成的复合公式

最初无法找到将三类不同结构定义到同一个类中的方法，因此将三者声明为同一基类下的不同子类。开发过程中遇到技术问题：自定义运算符未正确覆盖C++默认运算符行为，其中&&运算符的返回值为bool类型，而非预期的shared_ptr<formula>类型。

解决方案 #

在基类中维护指向自身类型的shared_ptr成员，避免对象切片问题，即可实现符合预期的运算符重载。完整实现代码如下：

#include <iostream>
#include <memory>

using namespace std;

// {0, 1, 2}
// {and, or, implies}

class formula
{
    shared_ptr<formula> F;

public:
    formula ()
    {}

    formula (shared_ptr<formula> f)
    {
        F = f;
    }

    formula (formula* f)
    {
        F = shared_ptr<formula> (f);
    }
    
    virtual bool evaluate ()
    {
        return F -> evaluate ();
    }

    virtual string type ()
    {
        return F -> type ();
    }

    shared_ptr<formula> address ()
    {
        return F;
    }

    virtual void assign (bool b)
    {
        F -> assign (b);
    }

    formula operator&& (formula f);
    formula operator|| (formula f);
    formula operator>> (formula f);
    formula operator! ();
};

class variable : public formula
{
    bool value;

public:
    void assign (bool b)
    {
        value = b;
    }
    
    bool evaluate ()
    {
        return value;
    }

    string type ()
    {
        return "variable";
    }
};

class negation : public formula
{
    shared_ptr<formula> arg;

public: 
    negation (formula f)
    {
        arg = f.address ();
    }

    bool evaluate ()
    {
        return !(arg -> evaluate ());
    }

    string type ()
    {
        return "negation";
    }
};

class connected : public formula
{
    shared_ptr<formula> lhs, rhs;
    int C;

public:
    connected (formula f, formula g, int c)
    {
        lhs = f.address ();
        rhs = g.address ();
        C = c;
    }

    bool evaluate ()
    {
        if (C == 0)
            return lhs -> evaluate () && rhs -> evaluate ();

        else if (C == 1)
            return lhs -> evaluate () || rhs -> evaluate ();

        else
            return !(lhs -> evaluate ()) || rhs -> evaluate ();
    }

    string type ()
    {
        return "connected";
    }
};

formula formula::operator&& (formula g)
{
    shared_ptr<formula> temp (new connected (*this, g, 0));
    formula f (temp);
    return f;
}

formula formula::operator|| (formula g)
{
    shared_ptr<formula> temp (new connected (*this, g, 1));
    formula f (temp);
    return f;
}

formula formula::operator>> (formula g)
{
    shared_ptr<formula> temp (new connected (*this, g, 2));
    formula f (temp);
    return f;
}

formula formula::operator! ()
{
    shared_ptr<formula> temp (new negation (*this));
    formula f (temp);
    return f;
}

int main ()
{
    formula A (new variable), B (new variable);

    A.assign(true);
    B.assign(false);

    formula x = A&&B, y = A||B, z = A>>B, w = !B;

    cout << boolalpha;
    cout << x.evaluate () << endl;
    cout << y.evaluate () << endl;
    cout << z.evaluate () << endl;
    cout << w.evaluate () << endl << endl;

    B.assign(true);
    cout << boolalpha;
    cout << x.evaluate () << endl;
    cout << y.evaluate () << endl;
    cout << z.evaluate () << endl;
    cout << w.evaluate () << endl;
}

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