c++ - 有没有办法根据参数使用 'new XXXX'？

Question

我正在开展一个项目，该项目使用反向波兰表示法模拟科学计算器。我的文字，例如“1”、“1.23”、“2/3”等，与它们的类型一起存储在堆栈中。例如，使用我的类型(出于各种原因我定义了 Double、Integer 等)，“1”将存储为 Integer，“1.23”将存储为 Double 等。

class Litteral {
  public:
     virtual QString toString () const = 0;
};

我想做如下:当用户输入一个运算符，比如+，我需要在我的堆栈上弹出()两次，执行操作，然后推送()。我已经做了运营商的认可。当用户键入 + 时，我执行给定的算法。 我的问题是，当 + 被识别并且两个 pop() 完成时，我需要真正执行 + 并且我需要创建一个正确类型的对象。 例如，如果我有一个 Integer 和一个 Double，我必须:

Litteral* l = new Double(pop1+pop2);

但是如果我有两个整数，我将不得不:

Litteral* l = new Integer(pop1 + pop2);

等等... 我可以使用大量的“if”来执行正确的“new XXXX()”，但我觉得这不是一个好的解决方案。 我也考虑过使用模板方法，用于执行相应的算法，但我必须创建尽可能多的版本，因为有可能的组合。它仍然是人类可能的，但同样，它感觉不干净。 有什么干净的方法可以做到这一点吗？

谢谢

编辑: 例如，当我弹出 2 个整数时，我想执行一个给定的操作。此操作的结果必须是整数。但结果并不总是整数，这取决于我弹出的内容。如果是 Integer 和 Double，则结果将是 Double。所以我必须做的"new"类型取决于我弹出的东西。 而且我不想用开关/倍数“if”来实现它。我不想那样做:

if ((typeid(*q1) == typeid(Integer)) && (typeid(*q2) == typeid(Double)))  { //...}

编辑 2:

Literal& pop1 = stack.top(); 
stack.pop(); 
Literal& pop2 = stack.top(); 
stack.pop(); 
Literal& toAdd = (*pop1.clone() + *pop2.clone()); 

错误:“operator+”不匹配(操作数类型为“Literal”和“Literal”)

类(class):

class Literal { 
    public: virtual QString toString () const = 0; 
      virtual int getValue() const = 0; 
      virtual Litteral * clone() const = 0; 
      virtual Litteral& operator+(const Integer& l) = 0; 
}; 

class Integer: public Literal { 
    friend class LitteralManager; 
    int value; 
    public: 
      Integer(int v) :value(v) {} 
      Integer(const Entier& e) { value = e.getValue(); }; 
      virtual QString toString () const; 
      int getValue() const { return value; } 
      virtual Entier& operator+(const Entier& e);
      Entier * clone() const; 
};

Answer 1

#include <cassert>
#include <typeinfo>

using namespace std;

struct Double;
struct Integer;

struct Literal {
    virtual Literal* operator + (const Literal&) const = 0;
    virtual Literal* operator + (const Double&)  const = 0;
    virtual Literal* operator + (const Integer&) const = 0;};

struct Double : Literal {
    Literal* operator + (const Literal& rhs) const {
        return rhs + *this;}

    Literal* operator + (const Double& rhs) const {
        return new Double;}

    Literal* operator + (const Integer& rhs) const {
        return new Double;}};

struct Integer : Literal {
    Literal* operator + (const Literal& rhs) const {
        return rhs + *this;}

    Literal* operator + (const Double& rhs) const {
        return new Double;}

    Literal* operator + (const Integer& rhs) const {
        return new Integer;}};

int main () {
    {
    Literal* p = new Double;
    Literal* q = new Double;
    Literal* r = *p + *q;
    assert(typeid(*r) == typeid(Double));
    }

    {
    Literal* p = new Double;
    Literal* q = new Integer;
    Literal* r = *p + *q;
    assert(typeid(*r) == typeid(Double));
    }

    {
    Literal* p = new Integer;
    Literal* q = new Double;
    Literal* r = *p + *q;
    assert(typeid(*r) == typeid(Double));
    }

    {
    Literal* p = new Integer;
    Literal* q = new Integer;
    Literal* r = *p + *q;
    assert(typeid(*r) == typeid(Integer));
    }

    return 0;}