boost::any浅析

目录

• boost::any简介
• boost::any用法
• boost:any源码
  • any 类及内部类holder
  • 转型any_cast
  • 不安全转型unsafe_any_cast
• 使用boost::any注意事项
• 参考

boost::any简介

C语言中有void*指针用于存放、传递任意类型数据，C++中呢？
boost库就提供了这样一个类：boost::any，一个很短小的类，主要作用是定义一个变量存放任意类型的数据。

boost::any用法

可以在存储的时候，将要存储的对象类型转换为boost::any类型，而要使用的时候，用boost::any_cast转型为相应的类型。
注意：转型的时候，只能转型为存储时的类型或者能隐式转换的类型，如果转换为不能兼容的类型，可能会导致未定义行为。

#include <boost/any.hpp>
#include <iostream>
#include <list>
#include <vector>
using namespace std;

int main()
{
    vector<boost::any> vec;
    list<int> lst = {4,5,6};
    vec.emplace_back(1);
    vec.emplace_back(string("hello"));
    vec.emplace_back(lst);

    int d = boost::any_cast<int>(vec[0]); // 将vec[0]转型为int
    cout << d << endl;

    const string &s = boost::any_cast<string&>(vec[1]); // 将vec[1]转型为string&
    cout << s << endl;

    const list<int>& tmpLst = boost::any_cast<list<int>&>(vec[2]); // 将vec[2转型为list<int>&
    for (auto const& e : tmpLst) {
        cout << e << ' ';
    }
    cout << endl;
    return 0;
}

当我们不确定存储的any是何种类型时，可以利用RTTI技术typeid操作符进行判断

#include <boost/any.hpp>
#include <iostream>
#include <list>
#include <vector>
using namespace std;

int main()
{
    vector<boost::any> vec;
    list<int> lst = {4,5,6};
    vec.emplace_back(1);
    vec.emplace_back(string("hello"));
    vec.emplace_back(lst);

    vector<boost::any>::iterator it; // vector<boost::any>迭代器
    boost::any anyone;
    for (it = vec.begin(); it != vec.end(); ++it) {
        anyone = *it;

        if (anyone.type() == typeid(int)) { // typeid获取指定类型type_info类信息
            cout << boost::any_cast<int>(anyone) << endl;
        }
        else if(anyone.type() == typeid(string)) {
            cout << boost::any_cast<string>(anyone) << endl;
        }
        else {
            cout << "unknow type" << endl;
        }
    }
    return 0;
}

boost:any源码

实现any功能主要由三个部分组成：
1）any类；
2）内部类holder保存数据，其基类placeholder声明接口；
3）获取数据时，通过any_cast转型；

any 类及内部类holder

any class中实际存储用户实参的是指针成员content，content实际指向的是holder类型对象，而holder是一个内部类，其基类placeholder。

placeholder主要定义2个接口，用于帮助any获取content所指向的对象类型信息，以及深度克隆any成员content所指对象。
holder实现placeholder接口，非常重要一点是内部持有held，通过传入any实参拷贝构造或移动构造而来。也就是说，如果传入any的是右值，实参对象会移动构造held；如果传入any的是左值，实参对象会拷贝构造held。

注意：
1）传给any的实参必须是对象（或基本类型）本身，可以是左值，也可以是右值，但不能是地址，除非要通过any保存的是指针本身。

class any{    public: // structors
        // 一组构造函数
        any() BOOST_NOEXCEPT
          : content(0)
        {
        }

        template<typename ValueType>
        any(const ValueType & value)
          : content(new holder<ValueType>(value)) // 构造一个holder对象, 并由content接管
        {
        }

        any(const any & other)
          : content(other.content ? other.content->clone() : 0) // 拷贝other所指对象, 深度拷贝
        {
        }

#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
        // Move constructor
        any(any&& other) BOOST_NOEXCEPT
          : content(other.content)
        {
            other.content = 0;
        }

        // Perfect forwarding of ValueType
        template<typename ValueType>
        any(ValueType&& value, typename boost::disable_if<boost::is_same<any&, ValueType> >::type* = 0)
          : content(new holder< typename remove_reference<ValueType>::type >(static_cast<ValueType&&>(value)))
        {
        }
#endif
        // 析构函数
        ~any() BOOST_NOEXCEPT
        {
            delete content;
        }

    public: // modifiers
        // swap成员函数
        any & swap(any & rhs) BOOST_NOEXCEPT
        {
            std::swap(content, rhs.content);
            return *this;
        }

#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
        template<typename ValueType>
        any & operator=(const ValueType & rhs)
        {
            any(rhs).swap(*this);
            return *this;
        }

        any & operator=(any rhs)
        {
            any(rhs).swap(*this);
            return *this;
        }

#else
        any & operator=(const any& rhs)
        {
            any(rhs).swap(*this);
            return *this;
        }

        // move assignement
        any & operator=(any&& rhs) BOOST_NOEXCEPT
        {
            rhs.swap(*this);
            any().swap(rhs);
            return *this;
        }

        // Perfect forwarding of ValueType
        template <class ValueType>
        any & operator=(ValueType&& rhs)
        {
            any(static_cast<ValueType&&>(rhs)).swap(*this);
            return *this;
        }
#endif

    public: // queries

        bool empty() const BOOST_NOEXCEPT
        {
            return !content;
        }

        const std::type_info & type() const
        {
            return content ? content->type() : typeid(void);
        }

#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
    private: // types
#else
    public: // types (public so any_cast can be non-friend)
#endif

        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) // 这里会发生拷贝构造, 通过value拷贝构造held
            {
            }

#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
            holder(ValueType&& value)
              : held(static_cast< ValueType&& >(value)) // 这里会发生移动构造, 通过value移动构造held
            {
            }
#endif
        public: // queries
            // 获取ValueType的类型信息, 返回type_info对象
            virtual const std::type_info & type() const
            {
                return typeid(ValueType);
            }
            // 拷贝构造一个holder对象, 返回一个placeholder指针
            virtual placeholder * clone() const
            {
                return new holder(held);
            }

        public: // representation
            ValueType held; // held是对象类型, ValueType是要存储对象的原生类型, 通过模板参数传入

        private: // intentionally left unimplemented
            holder & operator=(const holder &); // 没有实现
        };

#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;

#else
    public: // representation (public so any_cast can be non-friend)

#endif
        placeholder * content;
    };

转型any_cast

any通过统一的placeholder类型指针content保存传入实参对象，那么当要使用时，如何知道取出并转换成所需类型呢？
boost为any提供转型操作any_cast<>，any_cast可以将any保存的对象转换成指定类型。

any_cast有多个重载版本，

//-----------------------------------------------------
// 一组any_cast函数模板

    // 参数是any*
    template<typename ValueType>
    ValueType * any_cast(any * operand) BOOST_NOEXCEPT
    {
        // 当operand非空, 且所指对象类型名与 模板参数ValueType类型名相同时, 
        // 将operator所指对象用static_cast转型为模板参数对应的指针类型; 否则, 返回空指针
        return operand &&
#ifdef BOOST_AUX_ANY_TYPE_ID_NAME
            std::strcmp(operand->type().name(), typeid(ValueType).name()) == 0
#else
            operand->type() == typeid(ValueType)
#endif
            ? &static_cast<any::holder<ValueType> *>(operand->content)->held
            : 0;
    }

    // 参数是const any*
    template<typename ValueType>
    inline const ValueType * any_cast(const any * operand) BOOST_NOEXCEPT
    {
        return any_cast<ValueType>(const_cast<any *>(operand));
    }

    // 参数是any&, 注意引用不能是空, 否则抛出异常
    // 由于返回值是ValueType, 会发生对operator代表对象的拷贝构造
    template<typename ValueType>
    ValueType any_cast(any & operand)
    {
        // 定义内嵌类型nonref, 可用于去除引用(左值引用, 右值引用)
        typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;


#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        // If 'nonref' is still reference type, it means the user has not
        // specialized 'remove_reference'.

        // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro
        // to generate specialization of remove_reference for your class
        // See type traits library documentation for details
        BOOST_STATIC_ASSERT(!is_reference<nonref>::value);
#endif
        // result是operand去除引用的指针类型
        nonref * result = any_cast<nonref>(&operand);
        if(!result)
            boost::throw_exception(bad_any_cast());
        return *result;
    }

    // 参数是const any&
    template<typename ValueType>
    inline ValueType any_cast(const any & operand)
    {
        typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;

#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        // The comment in the above version of 'any_cast' explains when this
        // assert is fired and what to do.
        BOOST_STATIC_ASSERT(!is_reference<nonref>::value);
#endif
        // 将operator转型为const nonref& (这里ValueType是去除const, 引用后的ValueType)
        return any_cast<const nonref &>(const_cast<any &>(operand));
    }

不安全转型unsafe_any_cast

类似于安全转型any_cast，但不做any实际存储对象类的与要转型的模板是否一致的类型验证。不推荐使用。

    // Note: The "unsafe" versions of any_cast are not part of the
    // public interface and may be removed at any time. They are
    // required where we know what type is stored in the any and can't
    // use typeid() comparison, e.g., when our types may travel across
    // different shared libraries.
    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));
    }

使用boost::any注意事项

虽说boost::any能存放任意类型，但调用了被存放对象的成员函数。如果被存放对象禁用copy操作，那么就不能直接存放对象本身，因为会调用被存放对象的copy构造函数。

且看下面代码：

#include "muduo/base/noncopyable.h"

#include <boost/any.hpp>
#include <iostream>
#include <memory>

using namespace std;

class Context : muduo::noncopyable // 禁用拷贝
{
public:
	Context(int val)
		: val_(val)
	{}

	void print()
	{
		cout << "val = " << val_;
	}

private:
	int val_;
};

int main()
{
	auto context = new Context(10);
	boost::any any = context;

	auto conn = boost::any_cast<Context>(&any);
	conn->print();
	return 0;
}

Context 类禁用拷贝，如果直接将context通过boost::any any = context;，会调用template<typename ValueType> any & operator=(const ValueType & rhs)

        template<typename ValueType>
        any & operator=(const ValueType & rhs)
        {
            any(rhs).swap(*this); // 这里用rhs构造any，因此会调用any的构造函数
            return *this;
        }

上面代码中，用rhs构造了临时对象any，因此会调用any的构造函数

        template<typename ValueType>
        any(const ValueType & value)
          : content(new holder<ValueType>(value)) // 构造一个holder对象, 并由content接管
        {
        }

注意到这里ValueType类型可以推导出来为Context类型，而new holder<ValueType>(value)会导致调用ValueType即Context的拷贝构造函数，而Context的拷贝构造函数已经禁用，这样做会导致错误，甚至程序崩溃。

解决办法：
将any存放对象由禁用拷贝到Context对象，改为指向Context对象的智能指针shared_ptr，来替代直接存放对象。

int main()
{
	shared_ptr<Context> context(new Context(10)); // 存放对象改为shared_ptr<>，允许拷贝
	boost::any any = context;

	auto conn = boost::any_cast<shared_ptr<Context>>(any);
	conn->print();
	return 0;
}

参考

https://blog.csdn.net/u010216743/article/details/77772078
https://zhuanlan.zhihu.com/p/326781049