根据c++中的特定类型执行代码

我正在尝试将我以前用函数式语言(OCaml)编写的一些代码重写为c++。

我的问题可以缩短为:

• 我有一堆值
• 一个值可以是一个可变类型(即一组不同类型的值，例如int, float, std::string, std::list等等)
• 我想定义对值工作的操作符(例如，弹出两个值并推动它们之和的加法操作)
• 一些操作符根据在堆栈上找到的类型表现不同，理想情况下，一些操作符甚至根据类型改变参数的数量(一个简单的例子:加法操作符可以弹出一个值，如果它是std::list，则将操作符应用于列表的所有值之间，否则弹出另一个值并进行加法，如果它们都是float)

到目前为止，我已经能够通过使用模板使其工作，例如。

class Value
{
  public:
    Value(Type type) : type(type) { }
    virtual string svalue() const = 0;
    virtual string lvalue();
    virtual bool equals(Value *value) const = 0;
    virtual Value* clone() const = 0;
    const Type type;
    virtual ~Value() { };
}
template <class T>
class TValue : public Value
{
  protected:
    T value;
  public:
    TValue(Type type, T value) : Value(type), value(value) {}
    void set(T value) { this->value = value; }
    T get() const { return this->value; }
};
class Int : public TValue<int>
{
  private:
  public:  
    Int(int value) : TValue<int>(TYPE_INT, value) { };
    virtual string svalue() const;
    virtual bool equals(Value *value) const { return this->value == ((TValue<int>*)value)->get(); }
    virtual Value *clone() const { return new Int(value); }
};

，然后通过

Value *v1, *v2,
case OP_PLUS:
{
  if (vm->popTwo(&v1, &v2))
  {  
    switch (v1->type << 4 | v2->type)
    {
      case TYPES(TYPE_INT, TYPE_INT): vm->push(new Int(((Int*)v1)->get() + ((Int*)v2)->get())); break;
      case TYPES(TYPE_FLOAT, TYPE_INT): vm->push(new Float(((Float*)v1)->get() + ((Int*)v2)->get())); break;
      case TYPES(TYPE_INT, TYPE_FLOAT): vm->push(new Float(((Int*)v1)->get() + ((Float*)v2)->get())); break;
      case TYPES(TYPE_FLOAT, TYPE_FLOAT): vm->push(new Float(((Float*)v1)->get() + ((Float*)v2)->get())); break;
    }
  }
  break;
}

现在，这可以工作了，但是我不喜欢这种方法，因为它听起来很笨拙，它需要大量的类型强制转换，而且一点也不优雅(与我的函数实现相比)。我开始研究boost库，看看我是否能找到一种更好的方式来管理一切，在开始之前，我试图定义一种不同的方式来定义操作符，如

template <Opcode T, class X, class A>
class Unary
{
public:
  static A* ptr(X* x)
  {
    cout << "Missing instruction!" << endl;
    return NULL;
  };
};

template <>
class Unary<OP_MINUS, Float, Float>
{
  public:
    static Float *ptr(Float *x) { return new Float(-x->get()); };
}; 

这样我就可以写

Float *a = new Float(10);
Float *r = Unary<OP_MINUS, Float, Float>::ptr(f);

这可以工作，但我仍然无法看到我应该如何以通用的方式管理它，以便我可以根据堆栈上找到的内容和使用的操作符调用正确的函数。

boost会帮助我吗?我想要的是一个解决方案，是类型安全和优雅的同时，但boost有这么多不同的库，我很难理解要找什么。如果我缺少一些更容易的东西，我不需要使用它，我没有想到在为这种任务放弃函数式语言时会发现这么多困难。