doc/alignment_of.qbk

[/ 
  Copyright 2007 John Maddock.
  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:alignment_of alignment_of]
   template <class T>
   struct alignment_of : public __integral_constant<std::size_t, ALIGNOF(T)> {};
  
__inherit Class template `alignment_of` inherits from 
`__integral_constant<std::size_t, ALIGNOF(T)>`, where `ALIGNOF(T)` is the
alignment of type T.  

['Note: strictly speaking you should only rely on 
the value of `ALIGNOF(T)` being a multiple of the true alignment of T, although
in practice it does compute the correct value in all the cases we know about.]

__header ` #include <boost/type_traits/alignment_of.hpp>` or ` #include <boost/type_traits.hpp>`

__examples

[:`alignment_of<int>` inherits from `__integral_constant<std::size_t, ALIGNOF(int)>`.]

[:`alignment_of<char>::type` is the type `__integral_constant<std::size_t, ALIGNOF(char)>`.]

[:`alignment_of<double>::value` is an integral constant 
expression with value `ALIGNOF(double)`.]

[:`alignment_of<T>::value_type` is the type `std::size_t`.]

[important
Visual C++ users should note that MSVC has varying definitions of "alignment".
For example consider the following code:

``
   typedef long long align_t;
   assert(boost::alignment_of<align_t>::value % 8 == 0);
   align_t a;
   assert(((std::uintptr_t)&a % 8) == 0);
   char c = 0;
   align_t a1;
   assert(((std::uintptr_t)&a1 % 8) == 0);
``

In this code, even though `boost::alignment_of<align_t>` reports that `align_t` has 8-byte
alignment, the final assert will fail for a 32-bit build because `a1` is not aligned on an
8 byte boundary.  Note that had we used the MSVC intrinsic `__alignof` in place of `boost::alignment_of`
we would still get the same result.  In fact for MSVC alignment requirements (and promises) only really 
apply to dynamic storage, and not the stack.
]

[endsect]