template<class T> struct aligned_ptr_reference        { typedef T& type;    };
template<>        struct aligned_ptr_reference<void>  { typedef void type;  };

template<class T,size_t N> struct alignement_traits
{
  BOOST_STATIC_CONSTANT( size_t, ptr_size = sizeof(void*) );
  typedef typename boost::uint_t<ptr_size*CHAR_BIT>::least type;

  BOOST_STATIC_CONSTANT( size_t
                        , alignement = (1<<N) < sizeof(T)
                                    ? sizeof(T)
                                    : (1<<N)
                      );
};

template<size_t N> struct alignement_traits<void,N>
{
  BOOST_STATIC_CONSTANT( size_t, ptr_size = sizeof(void*) );
  typedef typename boost::uint_t<ptr_size*CHAR_BIT>::least type;

  BOOST_STATIC_CONSTANT( size_t
                       , alignement = (1<<N)
                       );
};

template<class T, size_t N> inline
typename alignement_traits<T,N>::type align_pointer( void* ptr )
{
  typedef alignement_traits<T,N> traits;
  typedef typename traits::type           type;
  return     ((type)ptr+traits::alignement+traits::ptr_size)
          & ~(traits::alignement-1);
}

template<size_t N,class U> inline U align_value( U val )
{
  typedef alignement_traits<U,N> traits;
  return  (val+traits::alignement) & ~(traits::alignement-1);
}

inline void** unaligned_base( void* ptr ) { return ((void**)ptr-1); }

template<class T, size_t N> inline void* aligned_realloc( T* data ,size_t sz )
{
  typedef alignement_traits<T,N> traits;
  typedef typename traits::type           type;

  void* pa = realloc( data ? *unaligned_base(data) : 0
                    , (traits::ptr_size+traits::alignement-1)+sz
                    );

  void* ptr = (void*)(align_pointer<T,N>(pa));

  *unaligned_base(ptr)=pa;

  return ptr;
}

template<class T, size_t N> inline
void* aligned_alloc( size_t sz ) { return aligned_realloc<T,N>(0,sz); }

inline void aligned_free( void* ptr )
{
  free( *unaligned_base(ptr) );
}

int main()
{
  float* tab = (float*)aligned_alloc<float,4>(13);
  cout << tab << endl;

  cout << align_value<4>(53) << endl;
  aligned_free(tab);
}

0x8050440
64