boost any类库的使用和内部实现细节

boost any类库的使用

功能

基本小例子

将任何数据保存到any类中

#include <assert.h>
#include <boost/any.hpp>

#include <string>
#include <vector>
#include <map>

using namespace std;
using namespace boost;

class Student
{
public:
Student() : age_(25) {}
Student(int age) : age_(age) {}

int GetAge() const
{
return age_;
}
private:
int age_;
};

int calc_max(int data1, int data2)
{
return data1 > data2 ? data1 : data2;
}

int main(int argc, char **argv)
{
int a[] = {1, 2, 3, 4, 5};
vector<int> iv(a, a + 5);
map<string, int> info;
int i = 100;

info["zs"] = 10;
info["ls"] = 5;

//======================支持将任何类型通过构造函数来创建any对象======================

// 将基本数据类型保存到any类中
any any1(10);
any any2("hello world");
any any3(2.5f);
any any4(3.14);
any any5(a);
any any6(&i);

// 将对象保存到any类中
any any7(string("hello world"));
any any8(iv);
any any9(info);

// 将用户自己定义的类型对象保存到any类中
Student stu;
any any10(stu);

// 可以使用某个现有的any对象来进行拷贝构造
any any11(any9);

// ================也可以讲任何类型复制给any对象========
any10 = Student();
any10 = any3;

any10 = 1;
any10 = &calc_max;
any10 = any3;
any10 = vector<int>();

//any any12(int()); //千万不能这样写
//any any12(&calc_max);
//any12 = any10;

return 0;
}

从any对象中获取值

/*
* app.cpp
*
*  Created on: 2015年11月3日
*      Author: TwoFlyLiu
*/
#include <assert.h>
#include <boost/any.hpp>
#include <boost/type_index.hpp>

#include <string>
#include <vector>
#include <map>
#include <iostream>

using namespace std;
using namespace boost;

template <typename T>
struct append_const_to_ptr
{
typedef const T * type;
};

template <typename T>
struct append_const_to_ptr<const T>
{
typedef const T *type;
};

// 这个宏的设计意图是为了解决，boost any库以数组构造any对象，所产生的类型衰减问题。
// 经过测试：mingw编译器对于int a[]还是const int a[]，最后衰减成的类型都是int const*类型。
// 而对于vc编译器来讲，则比较正常，对于int a[]，会衰减成int *，对于const int a[]，则会衰减成int const *
// 这个宏的目的，就是设置真正的衰减后的类型，这样在any_cast中，就不会发生类型转换的错误
#if defined(__GNUC__)
#define DECAY_ARRAY_TYPE(value_type) append_const_to_ptr<value_type>::type
#elif defined(_MSC_VER)
#define DECAY_ARRAY_TYPE(value_type) value_type *
#endif

int main(int argc, char **argv)
{
int a[5] = {1, 2, 3, 4, 5};
vector<int> iv(a, a + 5);
map<string, int> info;
int i = 100;

info["zs"] = 10;
info["ls"] = 5;

any object_or_val(i);

// 通过boost::any_cast来从any中获取任何类型的值。
// 有两大种any_cast重载函数，
// 一种是：
// template <typename ValueType> ValueType &any_cast(any &)，可能会抛出bad_any_cast异常，当转换类型和实际类型不一致时候，会抛出异常
// template <typename ValueType> ValueType &any_cast(any *)

assert(100 == *any_cast<int>(&object_or_val));
try
{
assert(100 == any_cast<const int>(object_or_val));
}
catch(boost::bad_any_cast &e)
{
cout << "error" << endl;
}

object_or_val = a; //这儿需要注意，对于数组来讲，当他传进去时，内部类型会衰减成指针类型
cout << typeindex::type_index(object_or_val.type()) << endl;

// DECAY_ARRAY_TYPE自己定义的，用来解决vc编译器和mingw编译器衰减规则不同问题。
// 具体问题，看上面这个宏的定义
assert(a[0] == **any_cast<DECAY_ARRAY_TYPE(int)>(&object_or_val));
try
{
assert(a == any_cast<DECAY_ARRAY_TYPE(int)>(object_or_val));
} catch(boost::bad_any_cast &)
{
cout << "error" << endl;
}

object_or_val = iv;
assert(iv == *any_cast<vector<int> >(&object_or_val));
try
{
any_cast<vector<int> >(object_or_val);
}
catch(boost::bad_any_cast &)
{
cout << "error" << endl;
}

object_or_val = info;
assert((info == *any_cast<map<string, int> >(&object_or_val)));
try
{
any_cast<map<string, int> >(object_or_val);

// 使用指针作为参数，转换不成功会返回空指针
assert(0 == any_cast<string>(&object_or_val));

// 使用引用作为参数，转换不成功则会抛出boost::bad_any_cast异常
// 这儿因为类型不一致，所以内部会抛出异常（有意的，为了说明档转换成的类型和内部类型不一致的时候，会抛出异常）
// any_cast<string>(object_or_val);
}
catch(boost::bad_any_cast &)
{
cout << "Error" << endl;
}

// 其实还有unsafe_any_cast，非常不推荐使用它，强烈抵制啊
object_or_val = i;
cout << *unsafe_bad_cast<int>(&object_or_val) << endl;

return 0;
}

template <typename ValueType> ValueType *any_cast(any *) BOOST_NOEXCEPT

template <typename ValueType> ValueType *any_cast(const any *) BOOST_NOEXCEPT

template <typename ValueType> ValueType &any_cast(any &)

template <typename ValueType> ValueType &any_cast(const any &)

template <typename ValueType> ValueType *unsafe_any_cast(any *) BOOST_NOEXCEPT

template <typename ValueType> ValueType *unsafe_any_cast(const any *) BOOST_NOEXCEPT

int const *

DECAY_ARRAY_TYPE

访问/修改any对象的内部状态

#include <boost/any.hpp>
#include <iostream>
#include <assert.h>

using namespace std;
using namespace boost;

int main(int argc, char **argv)
{
int data = 10;
any value;

assert(value.empty()); //empty()方法用来返回内部是否保存数据
value = data;
assert(!value.empty()); //很明显当内部保存数据的时候，empty方法就不返回true了

// type方法用来返回内部类型信息boost::typeindex::type_info类型，其实这个类型是boost::typeindex::type_index类，内部数据类型。具体还请看boost TypeIndex库，可以看前面写的博客，也可以看官方文档
assert(typeindex::type_id<int>() == value.type());

// 输出any对象内部具体的数据类型
cout << "value type : " << typeindex::type_index(value.type()) << endl;

// 清除内部保存的数据，这样它又变成空了
value.clear();
assert(value.empty());

return 0;
}

any a; assert(a.empty());

any a(5); a.clear(); assert(a.empty());

any a(5); assert(a.type() == boost::typeindex::type_id<int>())

any类的swap方法

#include <boost/any.hpp>
#include <iostream>
#include <string>
#include <assert.h>

using namespace boost;
using namespace std;

int main(int argc, char **argv)
{
string hello("hello world");
int data = 20;

any val1(hello);
any val2(data);

assert(typeindex::type_id<string>() == val1.type());
assert(typeindex::type_id<int>() == val2.type());

val1.swap(val2);
assert(typeindex::type_id<string>() == val2.type());
assert(typeindex::type_id<int>() == val1.type());

swap(val1, val2);  //也支持全局的swap方法
assert(typeindex::type_id<string>() == val1.type());
assert(typeindex::type_id<int>() == val2.type());

return 0;
}

boost any类库的实现

any类的实现

place_holder类的实现

namespace boost{
class any
{
...
// 我认为这儿placeholder就是一个抽象类（这儿类似于java中的接口概念）。通过它，我们可以获取内部数据类型，和拷贝自己信息到一个新对象中
class placeholder
{
public:
virtual ~placeholder() {}
public:
//获取内部数据类型
virtual const boost::typeinde::typ
1023f
e_info & type() const BOOST_NOEXCEPT =0;
//原型方法，用于拷贝自身对象信息到新的placeholder对象中
virtual placeholder * clone() const =0;
};
...
};
}

holder类的实现

namespace boost{
class any
{
...
template <typename ValueType>
class holder : public placeholder
{
public:
// 通过指定类型数据来构造holder对象
holder(const ValueType &value) : held(value){}

// 如果支持右值引用，则利用右值引用提高程序性能
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
holder(ValueType&& value)
: held(static_cast< ValueType&& >(value))
{
}
#endif

public: // 实现placeholder中的抽象方法
virtual const boost::typeinde::type_info & type() const BOOST_NOEXCEPT
{
return boost::typeindex::type_id<ValueType>().type_info();
}
//原型方法，用于拷贝自身对象信息到新的placeholder对象中
virtual placeholder * clone() const
{
return new holder(held);
}

public:
ValueType held; // 真正内部保存的值
private:
// 当holder构造好的时候，不支持在关边内部的值。其实这儿实现比较无关主要，如果你禁用它的话，那么你也要拷贝右值引用的情况
holder & operator=(const holder &);
//下面这个方法是我后添加的，主要是为了和上面成对
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
holder & operator=(holder &&);
#endif
};
...
};
}

any类的几种构造器和析构器实现

namespace boost {

class any
{
public:
// 空的话，则不保存任何数据
any() BOOST_NOEXCEPT : content(0) {}

//  利用placeholder的clone方法，就可以实现内部数据的拷贝了
any(const any &other)
: content(other.content ? other.content->clone() : 0) {}

// 一个关键构造，模板构造器，因为他any类才可以使用任何类型值来构造
// 通过这个构造器也可以看出，
// 不管ValueType是否有cv修饰，最终保存到holder类内部的类型总是不含有cv的
// 如果ValueType是数据的话，他也会通过decay type_traits类衰减成指针的。只是这儿还是会有上面提到的，对于不同编译器的衰减类型不同问题，关键还是看上面any类的使用部分。
template <typename ValueType>
any(const ValueType & value)
: content(new holder<typename remove_cv<typename decay<const ValueType>::type>::type>(value)) {}

//如果支持右值引用的话，则提供移动构造来优化程序性能
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
// 移动构造器
any(any&& other) BOOST_NOEXCEPT
: content(other.content)
{
other.content = 0;
}

// 如果ValueType不是any&引用类型，并且也不是常量的话，才会将value之完美转发到holder的held成员中。
// 这儿有意思的是disable_if这个模板类，利用它可以对ValueType的具体类型就行限制
template<typename ValueType>
any(ValueType&& value
, typename boost::disable_if<boost::is_same<any&, ValueType> >::type* = 0 // disable if value has type `any&`
, typename boost::disable_if<boost::is_const<ValueType> >::type* = 0) // disable if value has type `const ValueType&&`
: content(new holder< typename decay<ValueType>::type >(static_cast<ValueType&&>(value)))
{
}
#endif

// 析构器，删除content，这样不会发生内存泄露问题
~any()
{
delete content;
}

...
private:
placeholder *content; //用来表示真实的内部数据
};

}

any类重载的赋值运算符

namespace boost {

class any
{
public:
// 交换内部的数据成员。这个方法在重载==运算符中被大量使用
any & swap(any & rhs) BOOST_NOEXCEPT
{
std::swap(content, rhs.content);
return *this;
}

// 不支持右值引用的情况
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
// 这儿为了避免发生资源泄露，使用了swap方法
// 细节：
// 1. 利用rhs构建了一个临时的any对象
// 2. 然后将临时any对象和*this对象进行交换。这样临时any对象保存*this中的数据，而*this则保存原来临时any对象利用rhs构建的数据
// 3. 当临时any对象超出作用域的时候，析构函数会被调用，内部数据content会被删除，这样原来的内部数据就会被删除调用这样就不会发生资源泄露问题
template <typename ValueType>
any & operator==(const ValueType &rhs)
{
any(rhs).swap(*this);
return *this;
}

// 有意使用值，不适用引用
// 因为如果使用引用的话，还要在内部构建一个临时变量，然后进行交换，还不如让编译器帮我们构建临时变量
any & operator==(any rhs)
{
//rhs.swap(*this);
any(rhs).swap(*this); //这儿是原来boost库中的实现，不管我认为应该使用上面的写法，这样少构造一个any对象
return *this;
}

// 支持右值情况，则利用右值进行优化
#else
any & operator==(const any & rhs)
{
any(rhs).swap(*this);
return *this;
}

// 这儿因为右值引用他是不会发生超出作用域析构的，所以新建了一个临时any对象来析构右值引用中的值，这儿是个小技巧
any & operator==(any &&rhs)
{
rhs.swap(*this);
any().swap(rhs);
return *this;
}

// 直接利用任意右值引用数值来优化any对象的构造
// 这儿仍然是通过static_cast<ValueType&&>来实现完美转发
// 仍然利用swap方法和临时变量来保证原来的any对象内部的资源会被释放掉
template <typename ValueType>
any & operator==(const ValueType &value)
{
// 这儿static_cast<ValueType&&>(value)等价于forward<ValueType>(value)
any(static_cast<ValueType&&>(value)).swap(*this);
return *this;
}
#endif
...
};
}

namespace boost {

class any
{
public:
...
// 原来获取内部数据是否为空
bool empty() const BOOST_NOEXCEPT
{
return !content;
}

// 删除内部数据，仍然利用，临时变量和swap方法
// 这种手段可以保证资源能被安全释放掉
void clear() BOOST_NOEXCEPT
{
any().swap(*this);
}

// 用来获取内部保存的数据类型信息
// 如果内部没有数据的话，则保存的是void的数据类型，如果有数据的话
//则直接调用placeholder接口提供的type方法
const boost::typeindex::type_info & type() const BOOST_NOEXCEPT
{
return content ? content->type() : boost::typeindex::type<void>().type_info();
}
...
};

}

全局swap方法

namespace boost
{
inline void swap(any & lhs, any & rhs) BOOST_NOEXCEPT
{
lhs.swap(rhs);
}
}

any_cast模板方法的实现

template<typename ValueType>ValueType * any_cast(any *) BOOST_NOEXCEPT

template<typename ValueType>ValueType * any_cast(any *) BOOST_NOEXCEPT

namespace boost {
class any
{
// 如果支持成员友元模板
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
private: // representation

template<typename ValueType>
friend ValueType * any_cast(any *) BOOST_NOEXCEPT;

template<typename ValueType>
friend ValueType * unsafe_any_cast(any *) BOOST_NOEXCEPT;
#endif
};
}

namespace boost{

//因为是友元，或者holder和placeholder设置为public，所以他能访问到any中的内部数据和内部定义的两个lz

// 功能就是讲operand转换为ValueType值，以指针形式返回
// 细节：
// 1. 检测operand是否为空，如果为空，则直接返回0
// 2. 检测ValueType不带cv修饰的类型是否和any对象内部数据类型一致，
// 只有一致的时候，才会将真正的数据进行返回，否则返回0
template<typename ValueType>
ValueType * any_cast(any * operand) BOOST_NOEXCEPT
{
// typename remove_cv<ValueType>::type获取的是不带cv修饰的类型
return operand && operand->type() == boost::typeindex::type_id<ValueType>()
? &static_cast<any::holder<BOOST_DEDUCED_TYPENAME remove_cv<ValueType>::type> *>(operand->content)->held
: 0;
}

// 内部就是调用非const版本，所以功能和上面的方法完全一致，详情，看上面的那个方法
template<typename ValueType>
inline const ValueType * any_cast(const any * operand) BOOST_NOEXCEPT
{
return any_cast<ValueType>(const_cast<any *>(operand));
}
}

namespace boost{

//一个常量类，当rtti关闭的时候，继承std::bad_cast异常类
//当rtti启用的时候，继承std::exception异常
class bad_any_cast:
#ifdef BOOST_NO_RTTI
public std::bad_cast
#else
public std::exception
#endif
{
public:
virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
{
return "boost::bad_any_cast: "
"failed conversion using boost::any_cast";
}
};

namespace boost {

// 他是any_cast引用版本的核心实现部分，其他版本都是调用它
// 他的内部实现依赖于any_cast的指针版本
// 细节：
// 1. 利用any_cast的指针版本来指针返回值
// 2. 如果获取到的返回值为0的话，则抛出bad_any_cast异常
// 3. 最后将返回值的引用类型返回
template<typename ValueType>
ValueType any_cast(any & operand)
{
typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref; // 去除ValueType的引用修饰

// 调用的是any_cast的指针版本
nonref * result = any_cast<nonref>(&operand);

// 值为空的话，则抛出异常
if(!result)
boost::throw_exception(bad_any_cast());

// Attempt to avoid construction of a temporary object in cases when
// `ValueType` is not a reference. Example:
// `static_cast<std::string>(*result);`
// which is equal to `std::string(*result);`
typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
boost::is_reference<ValueType>,
ValueType,
BOOST_DEDUCED_TYPENAME boost::add_reference<ValueType>::type
>::type ref_type; // ValueType的引用值

// 用来避免构造多余的临时变量
return static_cast<ref_type>(*result);
}

// 调用上面的版本
// 他在内部首先把引用修饰给去除掉了，然后调用上面的版本
// 所以他的行为和上面版本的行为基本一致，详细看上面的那个方法
template<typename ValueType>
inline ValueType any_cast(const any & operand)
{
typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;
return any_cast<const nonref &>(const_cast<any &>(operand));
}

// 获取右值any对象的数据，因为any对象是右值，其内部数据也是右值
// 而右值只有右值和const引用能够接受，所以内部首先有个static_assert
// 用来保证ValueType是右值引用，或者常量引用
// 内部调用的是any_cast的引用版本，所以他也可能会抛出异常，具体看ValueType & any_cast(any &operand)这个版本方法
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template<typename ValueType>
inline ValueType any_cast(any&& operand)
{
BOOST_STATIC_ASSERT_MSG(
boost::is_rvalue_reference<ValueType&&>::value /*true if ValueType is rvalue or just a value*/
|| boost::is_const< typename boost::remove_reference<ValueType>::type >::value,
"boost::any_cast shall not be used for getting nonconst references to temporary objects"
);
return any_cast<ValueType>(operand);
}
#endif
}

首先，any_cast的指针版本和引用版本他们都能实现安全转换，当operand为0，或者转换类型和实际类型不一致的时候，指针版本返回0，引用版本抛出boost::bad_any_cast异常。
any_cast支持包括常量和非常常量的真正和引用版本。也就是说他们可以接收非const类型，可以接收const类型，支持比较全。

namespace boost {
// 不检查operand是否为空，类型是否一致，直接访问内部数据，可能会造成严重错误，用时要小心。不然让operand位空，或者类型不一致
template<typename ValueType>
inline ValueType * unsafe_any_cast(any * operand) BOOST_NOEXCEPT
{
return &static_cast<any::holder<ValueType> *>(operand->content)->held;
}

//调用的是上面版本，详情见上面
template<typename ValueType>
inline const ValueType * unsafe_any_cast(const any * operand) BOOST_NOEXCEPT
{
return unsafe_any_cast<ValueType>(const_cast<any *>(operand));
}
}

总结

any a(int())