Question

我正在尝试实现一个简单的数据库接口，而不是可以处理不同的类型，包括自定义类。我想选择继承或模板，但似乎我使用两者都没有很好的结果。

标头文件

enum class RECORD_TYPE
{
    TYPE_LONG = 11,
    TYPE_STRING = 12
//other types
};

// the reason I created this class is to use it as function member parent 
class RecordType
{
public:
    RecordType(RECORD_TYPE record_type) : record_type_(record_type) {}
    RECORD_TYPE get_record_type()
    {
        return record_type_;
    }

protected:
    RECORD_TYPE record_type_;
};

template<class T>
class RecordType_t : public RecordType
{
public:
    RecordType_t(T value, RecordType type) : RecordType(type), value_(value) {}
    const T &get_value() const { return value_; }

protected:
    T value_;
};

class RecordType_long : public RecordType_t<long>
{
public:
    RecordType_long(long value) : RecordType_t(value, RECORD_TYPE::TYPE_LONG) {};
};

class RecordType_string : public RecordType_t<std::string>
{
public:
    RecordType_string(std::string value) : RecordType_t(value, RECORD_TYPE::TYPE_STRING) {};
};

用法

void add_record(const RecordType &record)
{   
    //here I need to know the type(string/long/custom) because the types have to be stored different
    switch (record.get_record_type())
    {
    case RECORD_TYPE::TYPE_LONG:
        //long x = record.get_value();

    case RECORD_TYPE::TYPE_STRING:
        //string x = record.get_value();
      //then do something with these values
    };
};

Database db;
RecordType_string str("test");
db.add_record(str);
RecordType_long lng(200);
db.add_record(lng)

我的主要问题（除了我很确定它设计不好的事实）是在函数add（）中我无法访问get_value（）成员函数所以我可以得到每种类型的价值观。因为，当然，在父类中，如果我创建了get_value（），我就不知道要返回什么类型。你能建议如何更好地实现这个目标吗？

谢谢

P.S。我可以从RecordType动态转换为RecordType_long / RecordType_string / etc但我在这里读到这真的是非常糟糕的设计。:)

Answer 1

问题是模板提供的多态行为与继承提供的行为正交。

前者提供parametric polimorphism，后者提供subtyping。

这两种不同类型的多态性在C ++中不会混合在一起。每个模板特化都是一个不同的类型，它与同一个模板的其他特化是正交的，这意味着这些类型与继承之间没有is-a关系。

因此，您的选择实际上取决于您打算使用的设计。例如，要让每种字段都保存在数据库中，您需要让每个实例管理自己的序列化，而不需要知道哪个是谁，例如：

class SerializableRecord
{
public:
  virtual void save(Database& db) const;
}

class RecordType_long : private RecordType_t<long>, public SerializableRecord
{
public:
  void save(Database& db) const override {
    long value = get_value();
    /* save it on database somehow */
  }
}

通过这种方式，您可以将多态和模板结合使用，但出于两个不同的目的，无需知道要保存哪种特定类型的记录，当然这也意味着您需要使用指针或对象切片发生。

另一个解决方案是使Database::save模板化并专门用于各种类型：

class Database {
  public:
    template<typename T> void save(const T& record);
}

template<> void Database::save<RecordType_t<long>>(const RecordType_t<long>& record) {
  long value = record.get_value();
  // ...
}

实际上你有很多选择，这取决于你需要达到的目标和结构本身的复杂性。

数据库接口使用继承和模板

1 个答案: