#include <iostream>
#include <list>
#include <cstring>

#define CHECK std::cout << *reinterpret_cast<int*>(array) << '|' << *array << '\n';

class bytearray
{
      int8_t *array;
      size_t size;

public:

      bytearray():
      array(0),//wegen ideone 0
      size(0) {}

      explicit bytearray(size_t s):
      array(new int8_t[s]()),
      size(s) {}

      bytearray(bytearray&& b):
      array(b.array),
      size(b.size)
      {}

      bytearray(bytearray const& a):
      array(new int8_t[a.size]),
      size(a.size)
      {
            memcpy(array, a.array, size);
      }

      template<class T>
      explicit bytearray(T const& val):
      array(0)//auch wegen ideone...
      {
            set<T>(val);
      }

      template<class T>
      T get()
      {
            return *reinterpret_cast<T*>(array);
      }

      template<class T>
      void set(T const& val)
      {
            if(array)
                  delete array;
            array = new int8_t[size = sizeof val];
            std::memcpy(array, &val, size);
      }

      template<class T>
      T* get_ptr()
      {
            return reinterpret_cast<T*>(array);
      }

      ~bytearray()
      {
            size = 0;
            delete array;
      }
};

class _memory_manager
{
      std::list<bytearray> ARRAY;

public:

      template<class type>
      type* allocate(type const&  = type());

} memory_manager;

template<class type>
type* _memory_manager::allocate(type const& val)
{
      ARRAY.push_back(bytearray());
      ARRAY.back().set<type>(val);
      return ARRAY.back().get_ptr<type>();
}

struct A
{
      int i;
      double *db;

      A():
      i(3),
      db(memory_manager.allocate<double>(9)) {}
};

int main()
{
      int *i = memory_manager.allocate<int>(5);
      A* a = memory_manager.allocate<A>();
      std::cout << *i << '\n';
      std::cout << *a->db << '\n';
}