万能类型的设计

摘要: 在项目中,我们往往需要有一种类型,可以将各种既定的类型存储起来,实现多种类型的相同操作;配置文件的解析中应用最为普遍......

/**
万能类型
AnyType.h
**/
#include <string>

#define AnyType_FOREACH_TYPES(Operator) \
AnyType_FOREACH_TYPES3(Operator, int, double, bool)

#define AnyType_FOREACH_TYPES3(Operator, Type1, Type2, Type3) \
AnyType_FOREACH_TYPES2(Operator, Type2, Type3)\
AnyType_FOREACH_TYPES1(Operator, Type1)
#define AnyType_FOREACH_TYPES2(Operator, Type1, Type2) \
AnyType_FOREACH_TYPES1(Operator, Type2)\
AnyType_FOREACH_TYPES1(Operator, Type1)
#define AnyType_FOREACH_TYPES1(Operator, Type) \
Operator(Type)
static void AnyType_throw(std::string exception)
{
throw exception;
}
#define AnyType_THROW(exception) AnyType_throw(exception);

class DllClass CAnyType
{
public:
//定义枚举
#define AnyType_DEFINE_ENUM_TYPE(Type) Type ## Enum
#define AnyType_DEFINE_TYPE_ENUMS(Type) AnyType_DEFINE_ENUM_TYPE(Type),
enum AnyTypeEnum
{
AnyType_FOREACH_TYPES(AnyType_DEFINE_TYPE_ENUMS)
AnyTypeEnumBuffer
};
public:
CAnyType(void);
CAnyType(const CAnyType& other);
~CAnyType(void);
//定义构造
#define AnyType_DEFINE_CONSTRUCTOR(Type) \
CAnyType(Type value);
#define AnyType_CREATE_CONSTRUCTOR(Type) \
CAnyType::CAnyType(Type value)\
{\
m_type = AnyType_DEFINE_ENUM_TYPE(Type);\
m_data = new Type(value);\
}
AnyType_FOREACH_TYPES(AnyType_DEFINE_CONSTRUCTOR);

//定义类型运算符
#define AnyType_DEFINE_TYPE_OPERATOR(Type) \
operator Type()const;
#define AnyType_CREATE_TYPE_OPERATOR(Type) \
CAnyType::operator Type()const\
{\
if (m_type == AnyType_DEFINE_ENUM_TYPE(Type))\
{\
return *((Type*)m_data);\
}\
AnyType_THROW("类型不匹配");\
return Type();\
}
AnyType_FOREACH_TYPES(AnyType_DEFINE_TYPE_OPERATOR);

//定义赋值运算符
CAnyType& operator=(const CAnyType& other);
#define AnyType_DEFINE_ASSIGNMENT(Type) \
CAnyType& operator =(const Type& other);
#define AnyType_CREATE_ASSIGNMENT(Type) \
CAnyType& CAnyType::operator =(const Type& other)\
{\
*this = CAnyType(other);\
return *this;\
};
AnyType_FOREACH_TYPES(AnyType_DEFINE_ASSIGNMENT);

//类型说明
std::string GetTypeString()const;
CAnyType::AnyTypeEnum GetTypeEnum()const;
private:
void * m_data;
AnyTypeEnum m_type;
void ClearData();
};

/**
万能类型
AnyType.cpp
**/
#include "AnyType.h"

CAnyType::CAnyType(void)
{
m_type = /*CAnyType::AnyTypeEnum::*/AnyTypeEnumBuffer;
m_data = 0;
}

CAnyType::CAnyType( const CAnyType& other )
{
*this = other;
}

CAnyType& CAnyType::operator=( const CAnyType& other )
{
if (m_type != other.m_type)
{
ClearData();
}
#define AnyType_OPERATOR_DENGYU(Type) \
case AnyType_DEFINE_ENUM_TYPE(Type):\
if (m_type == other.m_type)\
{\
*((Type*)m_data) = *((Type*)(other.m_data));\
}\
else\
{\
m_data = new Type(*((Type*)(other.m_data)));\
}\
break;
switch(other.m_type)
{
AnyType_FOREACH_TYPES(AnyType_OPERATOR_DENGYU);
default:
break;
}
m_type = other.m_type;
return *this;
}

CAnyType::~CAnyType(void)
{
ClearData();
}

std::string CAnyType::GetTypeString()const
{
std::string ret;
#define AnyType_GETTYPESTRING(Type) \
case AnyType_DEFINE_ENUM_TYPE(Type):\
ret = #Type;\
break;
switch(m_type)
{
AnyType_FOREACH_TYPES(AnyType_GETTYPESTRING);
default:
break;
}
return ret;
}
CAnyType::AnyTypeEnum CAnyType::GetTypeEnum()const
{
return m_type;
}

void CAnyType::ClearData()
{
if (m_data != 0)
{
#define AnyType_DELETE_DATA(Type) \
if (m_type == AnyType_DEFINE_ENUM_TYPE(Type))\
{\
delete (Type*)m_data;\
break;\
}
while(true)
{
AnyType_FOREACH_TYPES(AnyType_DELETE_DATA);
break;
}
}
m_type = AnyTypeEnumBuffer;
}

AnyType_FOREACH_TYPES(AnyType_CREATE_CONSTRUCTOR);
AnyType_FOREACH_TYPES(AnyType_CREATE_TYPE_OPERATOR);
AnyType_FOREACH_TYPES(AnyType_CREATE_ASSIGNMENT);

大量使用C语言的宏,省去了非常多的麻烦,在头文件文件的最前面可以注册各种类型,