Упрощенная реализация boost::any

#include <iostream>
#include <vector>
#include <typeinfo>
 
template <typename T> struct rem_ref      { typedef T type; };
template <typename T> struct rem_ref<T &> { typedef T type; };
 
struct any {
    any() : m_content( 0 ) {}
 
    template <typename T>
    any( const T & value ) : m_content( new holder<T>( value ) ) {}
 
    any( const any & other ) : m_content( other.m_content ? other.m_content->clone() : 0 ) {}
 
    ~any() { delete m_content; }
 
    const std::type_info & type() const {
        return m_content ? m_content->type() : typeid( void );
    }
 
private:
    struct placeholder {
        virtual ~placeholder() {}
        virtual const std::type_info & type() const = 0;
        virtual placeholder * clone() const = 0;
    };
 
    template <typename T>
    struct holder : placeholder {
        holder( const T & value ) : held( value ) {}
        virtual const std::type_info & type() const { return typeid( T ); }
        virtual placeholder * clone() const { return new holder( held ); }
        T held;
    };
 
    placeholder * m_content;
 
    template <typename T> friend T * any_cast( any * );
};
 
template <typename T>
T * any_cast( any * operand ) {
    return operand && operand->type() == typeid( T ) ? & static_cast<any::holder<T> *>(operand->m_content)->held : 0;
}
 
template <typename T>
T * any_cast_ptr_to( any & operand ) {
    return any_cast<typename rem_ref<T>::type>( &operand );
}
 
struct A {
    int val;
    A( int val ) : val( val ) {}
};
 
int main()
{
    std::vector<any> v;
 
    v.push_back( 123 );         // int
    v.push_back( 'C' );         // char
    v.push_back( 3.1415f );     // float
    v.push_back( v[0] );        // int
    v.push_back( A( 999 ) );    // A
    v.push_back( 3.1415 );      // double
 
    for ( std::vector<any>::iterator i = v.begin(); i != v.end(); ++i )
    {
        { // int
            int * p = any_cast_ptr_to<int>( *i );
            if ( p ) {
                std::cout << "int\t = " << *p << std::endl;
                continue;
            }
        }
 
        { // char
            char * p = any_cast_ptr_to<char>( *i );
            if ( p ) {
                std::cout << "char\t = " << *p << std::endl;
                continue;
            }
        }
 
        { // double
            double * p = any_cast_ptr_to<double>( *i );
            if ( p ) {
                std::cout << "double\t = " << *p << std::endl;
                continue;
            }
        }
 
        { // A
            A * p = any_cast_ptr_to<A>( *i );
            if ( p ) {
                std::cout << "A::val\t = " << p->val << std::endl;
                continue;
            }
        }
 
        std::cout << "unknown type\n";
    }
}