c++unionsboost-variantboost-any

How do boost::variant and boost::any work?


How do variant and any from the boost library work internally? In a project I am working on, I currently use a tagged union. I want to use something else, because unions in C++ don't let you use objects with constructors, destructors or overloaded assignment operators.

I queried the size of any and variant, and did some experiments with them. In my platform, variant takes the size of its longest possible type plus 8 bytes: I think it my just be 8 bytes o type information and the rest being the stored value. On the other hand, any just takes 8 bytes. Since i'm on a 64-bit platform, I guess any just holds a pointer.

How does Any know what type it holds? How does Variant achieve what it does through templates? I would like to know more about these classes before using them.


Solution

  • If you read the boost::any documentation they provide the source for the idea: http://www.two-sdg.demon.co.uk/curbralan/papers/ValuedConversions.pdf

    It's basic information hiding, an essential C++ skill to have. Learn it!

    Since the highest voted answer here is totally incorrect, and I have my doubts that people will actually go look at the source to verify that fact, here's a basic implementation of an any like interface that will wrap any type with an f() function and allow it to be called:

    struct f_any
    {
       f_any() : ptr() {}
       ~f_any() { delete ptr; }
       bool valid() const { return ptr != 0; }
       void f() { assert(ptr); ptr->f(); }
    
       struct placeholder
       {
         virtual ~placeholder() {}
         virtual void f() const = 0;
       };
    
       template < typename T >
       struct impl : placeholder
       {
         impl(T const& t) : val(t) {}
         void f() const { val.f(); }
         T val;
        };
       // ptr can now point to the entire family of 
       // struct types generated from impl<T>
       placeholder * ptr;
    
       template < typename T >
       f_any(T const& t) : ptr(new impl<T>(t)) {}
    
      // assignment, etc...
    };
    

    boost::any does the same basic thing except that f() actually returns typeinfo const& and provides other information access to the any_cast function to work.