【C++模版之旅】项目中一次活用C++模板(traits)的经历

以前曾在一个项目中碰到过一个挺简单的问题，但一时又不能用普通常规的方法去很好的解决，最后通过C++模板的活用，通过traits相对比较巧妙的解决了这个问题。本文主要想重现问题发生，若干解决方案的比较，以及最后如何去解决的过程，也许最终的方案也并不是最好的方案，但至少个人觉得从发现到思考到解决到改善，这是一个对帮助个人成长很不错的过程，所以凭记忆想把它记录下来，分享给大家。

先描述下问题，项目中有这样一个接口类会暴露给外部使用，接口类定义如下（类方法名称以及描述该问题无关的内容会有所修改、省略或删除）：

class IContainer
{
public:
                virtual RESULT Insert(const std::string& key, const ExportData& data) = 0;
                virtual RESULT Delete(const std::string& key) = 0;
                virtual RESULT Find(const std::string& key, ExportData& data) = 0;
};

从内容和名称很容易看出该接口不外乎一个容器，可以进行增、改、查操作，太简单了，这样的接口类会有什么样的问题呢？从接口类的方法中可以发现在Insert和Find方法中都有一个数据类型ExportData，分别作为输入与输出，而现在有这样的需求：

1. ExportData需要仅支持整型（long），浮点型（double），字符串（string）以及二进制（void*, size）4种类型的操作（不支持int或float）

2. ExportData需要考虑结构的尺寸，尽量减少空间冗余

3. 即使对以上4种不同数据类型进行操作，还是希望在从ExportData中Get或Set真实数据时，使用的方法能统一

4. 当调用者尝试使用了以上4种类型以外的数据类型时，能通过返回错误让调用方知道类型不匹配

需求描述完毕，怎么做？如何去定义和实现ExportData？是不是很简单，第一感觉马上就能解决问题，而且有n种方法。

第一种方案，为ExportData定义GetData和SetData方法，并且为4种类型分别重载方法，代码如下：

class ExportData
{
public:
       long GetData() {
              return m_lData;
       }
       void SetData(long data) {
              m_lData = data;
       }
       string GetData() {
              return m_strData;
       }
       void SetData(string data) {
              m_strData = data;
       }
       // ...... overload the other two types

private:
       long m_lData;
       string m_strData;
       // ...... overload the other two types
};

马上发现问题了，首先GetData方法只通过返回值无法重载，但马上想到我们可以稍微改动下解决这个问题：

void GetData(long& data) {
       data = m_lData;
}
void SetData(long data) {
       m_lData = data;
}
void GetData(string& data) {
       data = m_strData;
}
void SetData(const string& data) {
       m_strData = data;
}

但仔细看下还是有问题，没有满足需求2中的要求，即使用户使用的是整型数据，其他三种数据类型在结构中还是存在，内部数据有冗余。

那使用类模板不就可以解决这个问题吗？代码如下所示：

template<typename T>
class ExportData
{
public:
       T GetData() {
              return m_lData;
       }
       void SetData(T data) {
              m_data = data;
       }
private:
       T m_data;
};

如此简单，这样就没有冗余了，但是这样却把所有只要支持赋值操作的类型都支持了，不满足需求1。很多人这时肯定会想到，这时使用下traits不就能解决这个问题了吗？(关于traits可以参考《活用C++模板之traits》)

template<typename T>
class ExportData
{
public:
       RESULT GetData(T& data) {
              return ERROR;
       }
       RESULT SetData(const T& data) {
              return ERROR;
       }
};
template<>
class ExportData<long>
{
public:
       RESULT GetData(long& data) {
              data = m_data;
              return OK;
       }
       RESULT SetData(const long& data) {
              m_data = data;
              return OK;
       }
private:
       long m_data;
};

template<>
class ExportData<double>
...... // just like the implementation of long
template<>
class ExportData<string>
...... // just like the implementation of long
template<>
class ExportData<Binary>
...... // just like the implementation of long

满足需求1仅支持四种类型，满足需求2没有冗余，满足需求3统一的调用形式，但是对于需求4的问题，有点问题，因为当你使用int或者float时仍旧支持，也就是只要数据间可以隐式转换，就不会返回错误提示调用方，那就再改善下吧：

template<typename T>
struct TypeTraits
{
       static const DATA_TYPE field_type = TYPE_UNSUPPORTED;
};
template<>
struct TypeTraits<std::string>
{
       static const DATA_TYPE field_type = TYPE_UTF8;
};
template<>
struct TypeTraits<long>
{
       static const DATA_TYPE field_type = TYPE_INEGER;
};
template<>
struct TypeTraits<double>
{
       static const DATA_TYPE field_type = TYPE_REAL;
};
template<>
struct TypeTraits<Binary>
{
       static const DATA_TYPE field_type = TYPE_BINARY;
};

以上先通过Traits的方法获得一个可以用来判断是否是我们支持的数据类型的方式，成立则不支持，不成立则支持，判断方式如下：

TypeTraits<long>::field_type == TYPE_UNSUPPORTED

然后ExportData如下实现：

template<typename T>
class ExportData
{
public:
       RESULT GetData(T& data) {
              return ERROR;
       }
       RESULT SetData(const T& data) {
              return ERROR;
       }
};
template<>
class ExportData<long>
{
public:
       RESULT GetData(long& data) {
              if (TypeTraits<long>::field_type == TYPE_UNSUPPORTED) {
                     return ERROR;
              }
              data = m_data;
              return OK;
       }
       RESULT SetData(const long& data) {
              m_data = data;
              return OK;
       }
private:
       long m_data;
};

现在只有这四种类型会被支持，其他类型都会返回错误，似乎所有的需求都支持了，那这就是最终的解决方案吗？

不是！

我们忽略了ExportData在哪被使用了，它被用在了接口类的virtual方法中了，而由于C++编译的一些特性，C++语言本身是不支持虚函数本身又是模板函数的，也就是说以下接口类的定义编译绝对通不过（至于为什么C++不支持，这跟C++编译方式有关，这里就不解释了，如果有这样疑问的可以在回复中给我留言）：

class IContainer
{
public:
               template<typename T>
                virtual RESULT Insert(const std::string& key, const ExportData<T>& data) = 0;

                virtual RESULT Delete(const std::string& key) = 0;

               template<typename T>
                virtual RESULT Find(const std::string& key, ExportData<T>& data) = 0;
};

而IContainer本身不是只跟某个类型相关的，也就是不可能把IContainer定义成模板类。怎么办呢？

由于virtual函数不能同时又是模板函数，所以ExportData类不能定义为模板类，那能尝试把ExportData类的Get和Set方法设置为模板方法来解决吗？这样做还是会存在一个问题，由于不能使模板类，那类成员变量的数据怎么去支持4种类型呢？答案是都处理成类型无关的二进制数据，也就是说保存数据的首地址以及数据大小，在Get和Set时根据当前类型通过memcpy进行拷贝来转换成指定类型。看下代码吧，TypeTraits的定义跟上面一样，这里就不重复了：

class ExportData
{
public:
       ExportData() : _data(NULL), _size(0){}
       ExportData(const ExportData& data) {
              _data = NULL;
              _size = 0;
              AssignData(data._data, data._size);
              _type = data._type;
       }
       ~ExportData() {
              if (_data) {
                     delete[] _data;
                     _data = NULL;
              }
       }
       ExportData& operator=(const ExportData& data) {
              this->AssignData(data._data, data._size);
              this->_type = data._type;
              return *this;

       template<typename T>
       RESULT SetData(const T& data) {
              if (TypeTraits<T>::field_type == TYPE_UNSUPPORTED) {
                     return ERROR;
              }
              AssignData((const char*)&data, sizeof(T));
              _type = TypeTraits<T>::field_type;
              return OK;
       }
       template<>
       RESULT SetData<std::string>(const std::string& data) {
              AssignData(data.c_str(), data.size());
              _type = TYPE_UTF8;
              return OK;
       }
       template<>
       RESULT SetData<Binary>(const Binary& data) {
              AssignData(data.GetBlobAddr(), data.GetSize());
              _type = TYPE_BLOB;
              return OK;
       }

       template<typename T>
       RESULT GetData(T& data) const {
              if (TypeTraits<T>::field_type == TYPE_UNSUPPORTED ||
                     _data == NULL ||
                     TypeTraits<T>::field_type != _type) {
                     return ERROR;
              }
              memcpy(&data, _data, _size);
              return OK;
       }
       template<>
       RESULT GetData<std::string>(std::string& data) const {
              if (TYPE_UTF8 != _type || _data == NULL) {
                     data = "";
                     return ERROR;
              }
              data.assign(_data, _size);
              return OK;
       }
       template<>
       RESULT GetData<Binary>(Binary& data) const {
              if (TYPE_BLOB != _type || _data == NULL) {
                     data.SetBlobData(NULL, 0);
                     return ERROR;
              }
              data.SetBlobData(_data, _size);
              return OK;
       }
private:
       void AssignData(const char* data, unsigned int size) {
              if (_data) {
                     delete[] _data;
                     _data = NULL;
              }
              _size = size;
              _data = new char[size];
              memcpy(_data, data, _size);
       }
       char*  _data;
       unsigned long _size;
       DATA_TYPE _type;
};

这就是当时的解决方案，可以算是满足了前面提出的4点需求，调用的时候代码如下：

ExportData data;
RESULT res = OK;
res = data.SetData<string>("DataTest");
assert(OK == res);

string str;
res = data.GetData<string>(str);
assert(OK == res);

res = data.SetData<long>(111);
long  ldata = 0;
res = data.GetData<long>(ldata);
assert(OK == res);

我想肯定还有更好的解决方法，比如可以尝试在编译时就提示类型不支持而不是在运行时通过返回错误来提示。如果有更好的解决方案，欢迎一起讨论。