#include <memory>
#include <vector>
#include <cassert>

#include <boost/mpl/vector.hpp>
#include <boost/mpl/at.hpp>

#include <iostream>

struct polymorphic_object
{
    virtual ~polymorphic_object(){}
    virtual void print(std::ostream&sout)const=0;
};

typedef boost::mpl::vector<int,char,double> object_types;

template<unsigned Itype>
struct polymorphic_derived
: polymorphic_object
{
    typedef typename boost::mpl::at_c<object_types,Itype>::type value_type;
    value_type my_value;
    
    polymorphic_derived(value_type const&a_value=value_type())
      : my_value(a_value)
    {
    }
    
    void print(std::ostream&sout)const
    {
        sout<<"polymorphic_derived<"<<Itype<<">("<<my_value<<")\n";
    }
};

template<>
  struct
polymorphic_derived<1>
: polymorphic_object
{
    static unsigned const Itype=1;
    typedef char value_type;
    value_type my_value;
    
    polymorphic_derived(char a_value='a')
    : my_value(a_value)
    {
    }
    
    void print(std::ostream&sout)const
    {
        sout<<"polymorphic_derived<"<<Itype<<">("<<my_value<<")\n";
    }
}
#if 1
__attribute__ ((aligned(4*alignof(polymorphic_object))))
#endif
;

  std::ostream&
operator<<(std::ostream& sout, polymorphic_object const& x)
{
    x.print(sout);
    return sout;
}  

template<typename Abstract>
struct polymorphic_container
{
      std::vector<char>
    my_storage
      //storage for fields
      ;
      std::vector<std::size_t>
    my_offsets
      //field offsets
      ;
      template<typename Field>
      void
    push_back
      ( Field const& a_field
      )
      {
          std::size_t now_size=my_storage.size();
          std::cout<<"now_size="<<now_size<<"\n";
          std::size_t f_align=alignof(Field);
          std::cout<<"f_align="<<f_align<<"\n";
          std::size_t remainder=now_size%f_align;
          std::size_t padding=(0<remainder)?(f_align-remainder):0;
          std::cout<<"padding="<<padding<<"\n";
          std::size_t f_offset=now_size+padding;
          std::cout<<"f_offset="<<f_offset<<"\n";
          assert(f_offset%f_align==0);
          std::size_t f_size=sizeof(Field);
          std::cout<<"f_size="<<f_size<<"\n";
          std::size_t new_size=f_offset+f_size;
          std::cout<<"new_size="<<new_size<<"\n";
          my_storage.resize(new_size);
          void*f_ptr=&my_storage[0]+f_offset;
          new(f_ptr) Field(a_field);
          my_offsets.push_back(f_offset);
      }
      Abstract const&
    operator[](unsigned i)const
      {
          char const*b_ptr=&my_storage.begin()[0];
          char const*c_ptr=b_ptr+my_offsets[i];
          void const*v_ptr=static_cast<void const*>(c_ptr);
          Abstract const*a_ptr=static_cast<Abstract const*>(v_ptr);
          return *a_ptr;
      }
};    

  std::ostream& 
operator<<
  ( std::ostream& sout
  , polymorphic_container<polymorphic_object> const& x
  )
{
    sout<<"{ ";
    unsigned const n=x.my_offsets.size();
    for(unsigned i=0; i<n; ++i)
    {
        if(0<i)sout<<", "; 
        polymorphic_object const&o=x[i];
        o.print(sout);
    }
    sout<<"}\n";
    return sout;
}  

int main()
{
    polymorphic_container<polymorphic_object> cont;
    std::cout<<"cont(empty):\n";
    std::cout<<cont;
    cont.push_back(polymorphic_derived<2>(100.01));
    cont.push_back(polymorphic_derived<2>(200.02));
    cont.push_back(polymorphic_derived<0>(300));
    cont.push_back(polymorphic_derived<1>('c'));
    std::cout<<"cont.push_backs:\n";
    std::cout<<cont;
    return 0;
}