boost/utility/addressof.hpp

   1 // Copyright (C) 2002 Brad King (brad.king@kitware.com)
   2 //                    Douglas Gregor (gregod@cs.rpi.edu)
   3 //
   4 // Copyright (C) 2002, 2008 Peter Dimov
   5 //
   6 // Distributed under the Boost Software License, Version 1.0. (See
   7 // accompanying file LICENSE_1_0.txt or copy at
   8 // http://www.boost.org/LICENSE_1_0.txt)
   9
  10 // For more information, see http://www.boost.org
  11
  12 #ifndef BOOST_UTILITY_ADDRESSOF_HPP
  13 # define BOOST_UTILITY_ADDRESSOF_HPP
  14
  15 # include <boost/config.hpp>
  16 # include <boost/detail/workaround.hpp>
  17
  18 namespace boost
  19 {
  20
  21 namespace detail
  22 {
  23
  24 template<class T> struct addr_impl_ref
  25 {
  26     T & v_;
  27
  28     inline addr_impl_ref( T & v ): v_( v ) {}
  29     inline operator T& () const { return v_; }
  30
  31 private:
  32     addr_impl_ref & operator=(const addr_impl_ref &);
  33 };
  34
  35 template<class T> struct addressof_impl
  36 {
  37     static inline T * f( T & v, long )
  38     {
  39         return reinterpret_cast<T*>(
  40             &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
  41     }
  42
  43     static inline T * f( T * v, int )
  44     {
  45         return v;
  46     }
  47 };
  48
  49 } // namespace detail
  50
  51 template<class T> T * addressof( T & v )
  52 {
  53 #if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || defined( __SUNPRO_CC )
  54
  55     return boost::detail::addressof_impl<T>::f( v, 0 );
  56
  57 #else
  58
  59     return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
  60
  61 #endif
  62 }
  63
  64 #if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
  65
  66 namespace detail
  67 {
  68
  69 template<class T> struct addressof_addp
  70 {
  71     typedef T * type;
  72 };
  73
  74 } // namespace detail
  75
  76 template< class T, std::size_t N >
  77 typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
  78 {
  79     return &t;
  80 }
  81
  82 #endif
  83
  84 // Borland doesn't like casting an array reference to a char reference
  85 // but these overloads work around the problem.
  86 #if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
  87 template<typename T,std::size_t N>
  88 T (*addressof(T (&t)[N]))[N]
  89 {
  90    return reinterpret_cast<T(*)[N]>(&t);
  91 }
  92
  93 template<typename T,std::size_t N>
  94 const T (*addressof(const T (&t)[N]))[N]
  95 {
  96    return reinterpret_cast<const T(*)[N]>(&t);
  97 }
  98 #endif
  99
 100 } // namespace boost
 101
 102 #endif // BOOST_UTILITY_ADDRESSOF_HPP