Polymorphic operator (updated (c++) - c++

Question

I am trying to code a formula from propositional logic in a c++ class.
A formula can be:
A variable
A negation of a formula
Two formulas joined by a connective
I could not fined a way to define these three different structures into one class so I decided to declare them as different subclasses. The problem I am having is when declaring the opperators they do not seem to override the standard ones correctly. && is returning a bool instead of a shared_ptr
Solved: just used a shared_ptr in the baseclass to itself to avoid any slicing.
#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;
}

Answer 1

You define && to accept arguments of types formula and shared_ptr<formula>. This is weirdly asymmetric and will confuse you to no end. Then you are trying to apply it to two shared_ptr<formula>s. It is not going to work.
As a stopgap measure, change
cerr << (A&&B) -> type () << endl;
to
cerr << (*A && B) -> type () << endl;
However this is unsustainable in the long run.
I would recommend split formula in two classes, formula and formula_impl, where formula_impl contains all the virtual functions of the former formula and formula contains a shared_ptr<formula_impl>. formula implements what it can (operator&& and in the future maybe other things, like operator! and operator|| and whatnot) and delegates evaluate etc. to the formula_impl pointed to by the shared pointers. The end user only sees formula, never formula_impl.
formula should also define static functions that return a variable, a negation, and a conjunction.
Some additional notes.
assign is not a very good choice for a virtual function. You can only assign a variable. It makes no sense for other types of formulas. I would get rid of this function entirely, and pass the value to the constructor of variable instead.
Base class implementations should not print "error", or do anything else. They should be pure virtual functions instead.
Magic numbers (0 is conjunction, 1 is disjunction) are not a good idea. Define a enum. Treat the default case as an error.