前几天一个朋友给我看了1段代码:
any temp; //any is a class
temp = 1;
temp = "a";
temp = x; //x is a abstract class
看到这段代码着实下了1跳.初期的感觉象void*指针那样,又象variant变量。但感觉还是比较新颖的,-_-''也许我是菜鸟的原因,在脑袋转了一下后,我实现了自己的一个类,用来接受任何参数,起初我认为any应该是个typedef,而接收的类型也是前面知道的(-_-''又没弄清需求就去实现了),所以实现一个接收任何参数的类需要个typelist,和对每种类型的泛化,下面是class的定义:
template<typename _typelist>
class any
{
public:
typedef typename Loki::TL::TypeAtNonStrict<_typelist,0>::Result param1;
typedef typename Loki::TL::TypeAtNonStrict<_typelist,1>::Result param2;
typedef typename Loki::TL::TypeAtNonStrict<_typelist,2>::Result param3;
typedef typename Loki::TL::TypeAtNonStrict<_typelist,3>::Result param4;
typedef typename Loki::TL::TypeAtNonStrict<_typelist,4>::Result param5;
any(param1 param):
m_param1(param){}
any(param2 param):
m_param2(param){}
any(param3 param):
m_param3(param){}
any(param4 param):
m_param4(param){}
template<typename _Ty>
const _Ty& Get()
{
class CERROR_ACCESS_DENIED;
LOKI_STATIC_CHECK((Loki::TL::IndexOf<_typelist,_Ty>::value != - 1),CERROR_ACCESS_DENIED);
return __Access<_Ty>();
}
private:
template<typename _Ty>
_Ty& __Access();
template<>
param1& __Access<param1>() {return m_param1;}
template<>
param2& __Access<param2>() {return m_param2;}
template<>
param3& __Access<param3>() {return m_param3;}
template<>
param4& __Access<param4>() {return m_param4;}
param1 m_param1;
param2 m_param2;
param3 m_param3;
param4 m_param4;
};
typedef any<Loki::TYPE_LIST_3(int,float,char)> ANY;
这样似乎就可以接收任何类型了,也可以取出数据,取出时必须要知道相应的类型,而且,假如类型不在列表里面,则编译期出错
class CERROR_ACCESS_DENIED;
LOKI_STATIC_CHECK((Loki::TL::IndexOf<_typelist,_Ty>::value != - 1),CERROR_ACCESS_DENIED);
这样,-_-''似乎就可以了,只要所接收的类型可以拷贝即可。但有个明了的缺陷,那1就是接收的类型必须编译期写死,假如不写死的话,我个人开始的认为是加一个基类,-_-''
还是要3q我那位朋友,让我了解到boost::any的用法
下面是boost::any的具体分析,我们要达到下面几个要求:
1:可以接收任何类型的数据(具有value属性)
2: 可以方便的取出数据
3:型别安全,不象void*
下面是boost::any的实现,我按部分贴,而且省去我认为不重要的东西,因为太长了,这会影响我blog的收视率。
1:首先来看下他的构造和稀构(-_-''错别字)
any()
: content(0)
{
}
template<typename ValueType>
any(const ValueType & value)
: content(new holder<ValueType>(value))
{
}
any(const any & other)
: content(other.content ? other.content->clone() : 0)
{
}
~any()
{
delete content;
}
从构造函数可以看到,any可以接受默认的,任何其他值包括ant本身,在稀构里面可以看到对content的释放,content在这里是一个基类的指针,是any内部实现的,我们可以看到,在对any构造是有种方法:
(1)content(new holder<ValueType>(value))
(2)content(other.content ? other.content->clone() : 0)
稍后会看到holder是派生自content类型的一个模板实现,也许讲到这里,有些应该明白了any是怎么保存任何类型的吧,对于其他any的构造,我们发现调用了content的一个clone方法,很明显这是content的一个虚方法,这个方法的存在得以让我们运用虚函数的机制正确的拷贝对象,下面会看到这只是个简单的new操作。
2:来看下any的operator =的重载
any & swap(any & rhs)
{
std::swap(content, rhs.content);
return *this;
}
template<typename ValueType>
any & operator=(const ValueType & rhs)
{
any(rhs).swap(*this);
return *this;
}
any & operator=(const any & rhs)
{
any(rhs).swap(*this);
return *this;
}
3:下面来看下辅助类
bool empty() const
{
return !content;
}
const std::type_info & type() const
{
return content ? content->type() : typeid(void);
}
可以看到。一个empty,一个type,很形象。
4:下面来看下上面content所指的对象,以及any怎么保存任何类型,以及这种怎么保证型别安全
class placeholder
{
public: // structors
virtual ~placeholder()
{
}
public: // queries
virtual const std::type_info & type() const = 0;
virtual placeholder * clone() const = 0;
};
template<typename ValueType>
class holder : public placeholder
{
public: // structors
holder(const ValueType & value)
: held(value)
{
}
public: // queries
virtual const std::type_info & type() const
{
return typeid(ValueType);
}
virtual placeholder * clone() const
{
return new holder(held);
}
public: // representation
ValueType held;
};(-_-''格式矫正真是类啊)
placeholder就是上面content指向的对象,可以看到他定义的一些提供给any调用的函数和虚基本必须的虚稀构函数(可以看到any对content调用了delete)
下面是holder的实现,holder是一个模板,里面定义的
ValueType held;
很明星是any用来保存任何类型的,回顾下上面所说的any初始化content的2种方法
(1)content(new holder<ValueType>(value))
(2)content(other.content ? other.content->clone() : 0)
从这个地方可以看到怎么初始化holder对象,并保存到content.注意到这里的held是public的,这样就提供了对数据访问的功能,在访问的时候必须要知道具体要访问的类型,才能调用相应的static_cast或者dynamic_cast来操作,而这样其实也提供了型别安全的保证,eg:不象malloc,返回void*,然后()转换一下。
5:看下怎么访问any里面的属性值:这里就不列举出所有的实现,因为有些是对const的版本。
template<typename ValueType>
ValueType * any_cast(any * operand)
{
return operand && operand->type() == typeid(ValueType)
? &static_cast<any::holder<ValueType> *> (operand->content)->held
: 0;
}
template<typename ValueType>
ValueType any_cast(const any & operand)
{
typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;
const nonref * result = any_cast<nonref>(&operand);
if(!result)
boost::throw_exception(bad_any_cast());
return *result;
}//这里去掉1些原来实现的代码和注释
可以看到具体的实现方式&dynamic_cast的逻辑差不多,对引用的cast有可能抛出异常。通过上面这种方式,就达到了对数据的读取,读取时必须知道里面的数据类型。可以看出any只能保存一个值,-_-''不向我那个,可以同时保存不同类型的值。
6:extension
可以通过std::vector<boost::any> anys,来构建一个任何类型的列表,但访问比较麻烦。
也可以通过any来达到虚函数不能为template的限制(因为一个是静态的一个是动态的)
象下面:
class CBase
{
public:
virtual void Set(boost::any) = 0;
};
class CHild:
public CBase
{
public:
virtual void Set(boost::any param)
{
m_value = param;
}
private:
boost::any m_value;
};
CHild test;
CBase* ptr = &test;
ptr->Set(1);
ptr->Set('a');
7.finish...总算完成了...-_-''要变唐僧了...