仿boost::any的泛型指针类any的实现

在boost库中，any是一种特殊容器，只能容纳一个元素，但这个元素可以是任意的类型----int、double、string、标准容器或者任何自定义类型。程序可以用any保存任意的数据，也可以在任何需要的时候取出any中的数据。any类目前已经加入到c++17标准中，在vs2017中include<any>头文件即可使用。

vs2017里的标准库any的头文件最后有句提示:

#pragma message("class any is only available with C++17 or later.")  也就是说此any类无法在支持C++17标准之前的编译器中使用。

 仿boost的any实现如下，代码加了注释，方便读者学习理解

//any类设计要点
//1.any类不能是一个模板类形如int i;any<int>anyValue=i;无意义，还不如直接写int anyValue =i;
//2.any必须提供模板构造函数（赋值操作不必是模板的），才能完成如下操作:
//  int i; long j; struct X; X x;any anyValue(i); anyValue=j; anyValue =x;
//3.必须提供某些有关它所保存的对象型别的信息。
//4.它必须能保存数值且提供某种方法将它保存的数值“取出来”。
//5.数据不能放在any类里，这会使any类成为模板类，不符合1的要求。
//  数据应该动态存放，即动态分配一个数据的容器来存放数据，而any类中则保存指向这个容器的指针。
//  明确地说，是指向这个容器的基类的指针，这是因为容器本身必须为模板，而any类中的指针成员又必须不是泛型的。
//  因为any不能是泛型的，所以any中所有数据成员都不能是泛型的。
//  所以，结论是：为容器准备一个非泛型的基类，而让指针指向该基类。
#pragma once
#include <memory>
#include <typeindex>
#include <exception>
#include <iostream>
struct Any
{
    Any(void) : m_tpIndex(std::type_index(typeid(void))) { 
        std::cout << "Any(void) function called!" << std::endl; }
    Any(const Any& that) : m_ptr(that.Clone()), m_tpIndex(that.m_tpIndex) { 
        std::cout << "Any(const Any& that) called!" << std::endl; }
    Any(Any && that) : m_ptr(std::move(that.m_ptr)), m_tpIndex(that.m_tpIndex) { 
        std::cout << " Any(Any && that) function called!" << std::endl; }
    //创建智能指针时，对于一般的类型，通过std::decay来移除引用和cv符，从而获取原始类型
    //cv符即const和violate
    //类似int i;long j;anyValue(i),anyValue(j)时调用模板构造函数
    //注意构造函数中的new Derived。由于Derived是模板类,U里包含的类型信息可以完整的被保留。
    //构造函数本身又可以传进任意类型，这样就实现了类型类型擦除
    template<typename U, class = typename std::enable_if<!std::is_same<typename std::decay<U>::type, Any>::value, U>::type> 
    Any(U && value) : m_ptr(new Derived < typename std::decay<U>::type>(std::forward<U>(value))),\
        m_tpIndex(std::type_index(typeid(typename std::decay<U>::type))){
        std::cout << "Any(U && value) template function called!" << std::endl;} 
    template<class U> bool Is() const
    {
        std::cout << "Any::Is() template function called!" << std::endl;
        return m_tpIndex == std::type_index(typeid(U));
    }
    bool IsNull() const {
        std::cout << "Any::IsNull() function called!" << std::endl;
        return !bool(m_ptr);
    }
    //AnyCast方法的思想是期望程序员们清楚自己在做什么，要不然就给他个异常瞧瞧。
    
    //AnyCast模仿了boost提供的any_cast<>模板方法，在这里是Any的成员函数
    //取出原始类型，需要客户提供类型信息 如 anyValue.AnyCast<int>
    //m_tpIndex里保存了关于原始数据的型别信息，不存在boost::any实现时丢失型别信息的情况
    //所以boost单独提供了any_cast版本出来，而这里不需要
    template<class U>
    U& AnyCast()
    {
        std::cout << "Any::AnyCast() template function called!" << std::endl;
        //判断类型信息是否匹配，不匹配报错
        if (!Is<U>())
        {
            std::cout << "can not cast " << typeid(U).name() << " to " << m_tpIndex.name() << std::endl;
            throw std::logic_error{ "bad cast" };
        }
        //匹配了,则取出原始数据
        auto derived = dynamic_cast<Derived<U>*> (m_ptr.get());
        return derived->m_value;
    }
    //赋值操作重载不是模板函数，不存在模板无穷递归即循环赋值问题
    Any& operator=(const Any& a)
    {
        std::cout << "Any& operator= function called!" << std::endl;
        //防止自赋值
        if (m_ptr == a.m_ptr)
            return *this;
        //两个数据成员赋值
        m_ptr = a.Clone();
        m_tpIndex = a.m_tpIndex;
        return *this;
    }
private:
    struct Base;
    typedef std::unique_ptr<Base> BasePtr;   
    //泛型数据容器Derived的非泛型基类
    struct Base
    {
        virtual ~Base() {
            std::cout << " virtual ~Base() function called!" << std::endl;
        }  //虚析构函数，为保证派生类对象能用基类指针析构
        virtual BasePtr Clone() const = 0;   //复制容器
    };

    //Derived是个模板类，各个类成员之间可以共享类模板参数的信息
    //所以，可以方便地用原数据类型来进行各种操作
    template<typename T>
    struct Derived : Base
    {
        template<typename U>
        Derived(U && value) : m_value(std::forward<U>(value)) { 
            std::cout << "Derived(U && value) function called!" << std::endl;
        }
        BasePtr Clone() const
        {
            std::cout << "Derived::Clone() function called!" << std::endl;
            return BasePtr(new Derived<T>(m_value)); //改写虚函数，返回自身的复制体,动态构造
        }
        T m_value;    //原始数据保存的地方
    };
    //any类转发Clone操作给BasePtr的Clone方法，实现数据复制
    BasePtr Clone() const
    {
        std::cout << "Any::Clone() function called!" << std::endl;
        if (m_ptr != nullptr)
            return m_ptr->Clone();  
        return nullptr;
    }
    //通过基类指针擦除具体类型
    //any类赋值时需要创建派生类对象，这里用std::unique_ptr管理派生类对象生命周期
    BasePtr m_ptr;          
    std::type_index m_tpIndex; //提供关于型别的信息
};

 

测试代码如下：

// testany.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "any.hpp"
#include <string>
int _tmain(int argc, _TCHAR* argv[])
{
    Any n;
    std::cout << n.IsNull() << std::endl;
    std::string str = "Hello";
    //赋值操作，其实分两步进行
    //先调用any的移动构造函数把str转换为any类型
    //再调用any的赋值构造函数完成真正的赋值
    n = str;
    try
    {
        std::cout << n.AnyCast<int>() << '\n';
    }
    catch (std::exception& e)
    {
        std::cout << "Exception: " << e.what() << '\n';
    }
    std::cout << std::endl;
    std::cout << "-----------------------------" << std::endl;
    //直接初始化只调用移动构造函数,比采用赋值构造少了很多步骤，所以直接初始化效率更高
    Any n1(1);
    std::cout << n1.Is<int>() << '\n';
    std::cout << std::endl;
    std::cout << "-----------------------------" << std::endl;
    Any n2(std::move(n1));
    std::cout << n2.AnyCast<int>() << '\n';
    std::cout << std::endl;
    system("pause");
    return 0;
}

在vs2013上测试结果如下:

 参考：

Boost源码剖析之：泛型指针类any之海纳百川

 C++中的类型擦除（type erasure in c++）

（原创）c++中的类型擦除

（原创）用c++11打造好用的any