C++ - Make pointer to superclass match subclass argument in function - c++

Question

I've searched before asking but din't found anything working for my problem.
I would like to make a pointer to superclass (that really always refers to one of the subclasses) match a subclass argument (pointer or const reference) in a function.
Context : create an "advanced" calculator in c++.
Let me give you more details the classes being used in this issue of mine :
First we have the Literals :
class Literal {};
class IntegerLiteral : public Literal {};
class RealLiteral : public Literal {};
class RationalLiteral : public Literal {};
//....
We have a stack used to save the Literal objects by storing their adresses
// If st is instance of stack then :
st.top(); // returns a Literal*
And we have Operator objects that will interact with the stack by unstacking the correct numbers of Literal* (depending on the operator's arity), applying the operator on the Literal* objects and finally stack the result.
class Operator {
int n; // operator arity
public:
virtual void executeOperator(stack *st) = 0; //
};
One of the Operator subclass (for example) :
class PlusOperator : public Operator {
public:
virtual void execute(StackUTComputer *st) override {
Literal* arg1 = st->top();
Literal* arg2 = st->top();
Literal* result = applyOperator(arg1, arg2);
st->pop(); st->pop();
st->push(result);
}
Literal* execute(IntegerLiteral* a, IntegerLiteral* b) {
return new IntegerLiteral(a->getValue() + b->getValue());
}
Literal* execute(IntegerLiteral* a, RealLiteral* b) {
return new RealLiteral(a->getValue() + b->getValue());
}
Literal* execute(IntegerLiteral* a, RationalLiteral* b) {
return new RationalLiteral(
a->getValue() + (a->getValue()*b->getDenominator()),
b->getDenominator()
);
}
// ...
};
My purpose here (by overloading the function applyOperator) is to "magically" let the computer know which function call depending on the real type of Literal unstacked by the operator (the class Literal is abstract : the stack will always contain specifics Literal's subclasses).
But it does not work the way I want.
I mean that the call applyOperator(arg1, arg2) (with arg1 and arg2 being Literal*) is invalid because no functions match the signature.
I'm aware that I kind of use the c++ polymorphism int the other way that it's normally used (that is give a subclass argument to a function that take a superclass argument).
I don't know how to turn around my architecture in order to properly use the polymorphism et maybe there is some syntax helpful solution in order to make my idea work.
Either way, I'm grateful for your help !!
Raphael.

Answer 1

There is a way to do it with polymorphism as intended (without dynamic_cast):
#include <iostream>
#include <memory>
#include <string>
struct IntegerLiteral;
struct RealLiteral;
struct Literal {
virtual void add(const Literal &) = 0;
virtual void add(const IntegerLiteral &) = 0;
virtual void add(const RealLiteral &) = 0;
virtual void add_to(Literal &) const = 0;
virtual void add_to(IntegerLiteral &) const = 0;
virtual void add_to(RealLiteral &) const = 0;
virtual std::ostream &print(std::ostream &os) const = 0;
virtual ~Literal() = default;
};
std::ostream &operator<<(std::ostream &os, const Literal &l) {
return l.print(os);
}
struct IntegerLiteral : Literal {
IntegerLiteral(int i)
: i(i) {}
int i = 0;
void add(const Literal &other) override {
//now we know one operand is an IntegerLiteral and can pass on that information to the other Literal
other.add_to(*this);
}
void add(const IntegerLiteral &other) override {
i += other.i;
}
void add(const RealLiteral &other) override;
void add_to(Literal &other) const override {
other.add(*this);
}
void add_to(IntegerLiteral &other) const override {
other.i += i;
}
void add_to(RealLiteral &other) const override;
std::ostream &print(std::ostream &os) const override {
return os << i;
}
};
struct RealLiteral : Literal {
RealLiteral(double d)
: d(d) {}
double d = 0;
void add(const Literal &other) override {
other.add_to(*this);
}
void add(const IntegerLiteral &other) override {
d += other.i;
}
void add(const RealLiteral &other) override {
d += other.d;
}
void add_to(Literal &other) const override {
other.add(*this);
}
void add_to(IntegerLiteral &other) const override {
//now we know both operands and can do the calculation
other.i += d;
}
void add_to(RealLiteral &other) const override {
other.d += d;
}
std::ostream &print(std::ostream &os) const override {
return os << d;
}
};
void IntegerLiteral::add(const RealLiteral &other) {
i += other.d;
}
void IntegerLiteral::add_to(RealLiteral &other) const {
other.d += i;
}
int main() {
std::unique_ptr<Literal> l1 = std::make_unique<RealLiteral>(3.14);
std::unique_ptr<Literal> l2 = std::make_unique<IntegerLiteral>(42);
l1->add(*l2);
std::cout << *l1 << '\n';
}
DEMO
You need a ton of code to make this work and it gets quadratically worse with every Literal you add and twice as bad with every operator. Also if you forget to override a function you are likely to get an infinite loop and a stack overflow at run time.
A much better approach (easier to write and faster to run) would be to just use double or BigNum for everything and not bother with polymorphism.

Answer 2

You are mixing different concepts, which are ad hoc polymorphism (overloads) and subtype polymorphism, which in is implemented through late binding of methods through virtual tables.
Basically what happens is that the compiler chooses which overloaded method to call at compile time, not at runtime. This makes impossible what you are trying to do without using RTTI.
The compiler is not able to determine which will be the type of the two Literal instances, and C++ supports only early binding when dealing with non virtual methods. The only thing that it can deduce at compile time is the fact that both arguments are of type Literal* so it looks for that overload only.
You need a sort of dynamic switch to do what you want, which can be obtained through the use of dynamic_cast (or similar hand made solutions).