C++ C++；基于继承的铸造

我有一个名为addV的方法，它接受两个参数

静态自动添加（值*lval，值*rval）

值类型是一个父类，它有IntegerValue、StringValue、FloatValue等子类。 我永远不知道哪个孩子会被送到addV。确定它然后添加它的最简单、最优雅的方法是什么

示例：lval=IntegerValue（10），rval=StringValue（“Bruce”），return=StringValue（“1Bruce”）

示例：lval=StringValue（“Tom”），rval=IntegerValue（2），return=StringValue（“Tom2”）

示例：lval=IntegerValue（1），rval=FloatValue（3.0），return=FloatValue（4.0）

我有一个关于做这件事的想法，但是使用基本类型

价值等级：

class Value {
protected:
    typedef enum{
        UndefinedType, 
        IntegerType, 
        ObjectType, 
        FloatType, 
        StringType, 
        BooleanType, 
        Last
    } DataType;

    public:
    virtual DataType returnType(){
        return UndefinedType;
    };
};

class IntegerValue: public Value{
public:
    int32_t val;

    IntegerValue(int32_t val) : val(val){}

    DataType returnType(){
        return Value::IntegerType;
    };
};

class FloatValue: public Value{
public:
    float val;

    FloatValue(float val) : val(val) {}

    DataType returnType(){
        return Value::FloatType;
    };
};

class StringValue: public Value{
public:
    string val;

    StringValue(string val) : val(val){}

    DataType returnType(){
        return Value::StringType;
    };
};

整数值类：

class Value {
protected:
    typedef enum{
        UndefinedType, 
        IntegerType, 
        ObjectType, 
        FloatType, 
        StringType, 
        BooleanType, 
        Last
    } DataType;

    public:
    virtual DataType returnType(){
        return UndefinedType;
    };
};

class IntegerValue: public Value{
public:
    int32_t val;

    IntegerValue(int32_t val) : val(val){}

    DataType returnType(){
        return Value::IntegerType;
    };
};

class FloatValue: public Value{
public:
    float val;

    FloatValue(float val) : val(val) {}

    DataType returnType(){
        return Value::FloatType;
    };
};

class StringValue: public Value{
public:
    string val;

    StringValue(string val) : val(val){}

    DataType returnType(){
        return Value::StringType;
    };
};

浮动值类别：

class Value {
protected:
    typedef enum{
        UndefinedType, 
        IntegerType, 
        ObjectType, 
        FloatType, 
        StringType, 
        BooleanType, 
        Last
    } DataType;

    public:
    virtual DataType returnType(){
        return UndefinedType;
    };
};

class IntegerValue: public Value{
public:
    int32_t val;

    IntegerValue(int32_t val) : val(val){}

    DataType returnType(){
        return Value::IntegerType;
    };
};

class FloatValue: public Value{
public:
    float val;

    FloatValue(float val) : val(val) {}

    DataType returnType(){
        return Value::FloatType;
    };
};

class StringValue: public Value{
public:
    string val;

    StringValue(string val) : val(val){}

    DataType returnType(){
        return Value::StringType;
    };
};

StringValue类：

class Value {
protected:
    typedef enum{
        UndefinedType, 
        IntegerType, 
        ObjectType, 
        FloatType, 
        StringType, 
        BooleanType, 
        Last
    } DataType;

    public:
    virtual DataType returnType(){
        return UndefinedType;
    };
};

class IntegerValue: public Value{
public:
    int32_t val;

    IntegerValue(int32_t val) : val(val){}

    DataType returnType(){
        return Value::IntegerType;
    };
};

class FloatValue: public Value{
public:
    float val;

    FloatValue(float val) : val(val) {}

    DataType returnType(){
        return Value::FloatType;
    };
};

class StringValue: public Value{
public:
    string val;

    StringValue(string val) : val(val){}

    DataType returnType(){
        return Value::StringType;
    };
};

---

我将从以下内容开始：

enum ValueTypesEnum {
   IntValueE = 0,
   FloatValueE = 1,
   StringValueE = 2
};


class Value {
public:
   virtual Value *create() = 0;
   virtual ValueTypesEnum getType() = 0;
   Value *max(Value *other) {
      if (getType() > other->getType()) {
         return this;
      } else {
         return other;
      }
   }
};


template <ValueTypesEnum MyType, class ValueT>
class ValueFactory:public Value {
public:
   ValueTypesEnum getType() {
      return MyType;
   }
   Value *create() {
      return new ValueT();
   }
};


class IntValue: public ValueFactory<IntValueE, IntValue> {
};

class FloatValue: public ValueFactory<FloatValueE, FloatValue> {
};

class StringValue: public ValueFactory<StringValueE, StringValue> {
};


Value *addV(Value *lval, Value *rval) {
   lval->max(rval)->create();
   // change to: return lval->max(rval)->create()->set(lval)->add(rval);
}

enum ValueTypesEnum{
IntValueE=0，
FloatValueE=1，
StringValueE=2
};
阶级价值{
公众：
虚拟值*create（）=0；
虚拟值typesEnum getType（）=0；
值*最大值（值*其他）{
如果（getType（）>其他->getType（））{
归还这个；
}否则{
归还他人；
}
}
};
模板
类别价值工厂：公共价值{
公众：
ValueTypesEnum getType（）{
返回MyType；
}
值*create（）{
返回新值（）；
}
};
IntValue类：公共价值工厂{
};
类别价值：公共价值工厂{
};
类别：公共价值工厂{
};
值*addV（值*lval，值*rval）{
lval->max（rval）->create（）；
//更改为：return lval->max（rval）->create（）->set（lval）->add（rval）；
}

然后在新创建的值中添加设置元素的实现

---

通过在具体类中实现

set

和

add

虚拟方法。

看起来您需要某种类型的虚拟方法。如何做到这一点取决于您可以使用的类型信息。例如，您的

值

类是否有某种标记可用于标识对象的运行时类型。对于这样的多次分派，有几种不同的策略。要考虑的权衡是查找时间（线性与对数与常量）和维护成本（更可能是将来添加新的类型或新的函数）。所以这是唯一的方法之一？该值有一个名为returnType的方法，该方法从枚举列表返回类型。如果您有一个

returnType

函数，您可以打开该函数的结果，

static\u cast

指向正确类型的指针，然后分派到这些类型的专用函数。我稍后将尝试使用该函数。我还考虑过尝试enable_if（如果它在没有模板的情况下工作的话）。这是对现有代码的重新构造，如果我正确地阅读了它，您是在将枚举传递给类吗？加法类将只是少数几个使用这种结构的类之一。“我以后得玩这个了。”阿德里安兹。实际上，我试图使您的具体值类实现独立于枚举值本身。它还建议，当给定两个值类型时，应该创建哪种类型的信息可以通过枚举值秩存储在枚举本身中。这里唯一没有提到的是

set

和

add

值的实现，这实际上是使应用程序工作的关键。好的，我想我已经开始了解您是如何尝试这样做的。我会尽快给出结果。如果我尝试像这样实例化这个类“Value*iv=new IntValue（）；”我会得到一个错误，说“/Values.h:39:16:error:没有从“IntValue”到“Value*”的可行转换返回ValueT（）；”我不确定该怎么做，create方法是干什么的？如果我错了，也请纠正我，但是这个设计在每个和单个值子类中都有add方法？而我只需要1个核心add方法。您需要更改行

returnvaluet（）到
返回新值t（）我将在答案中进行编辑。。。