|  | Home | Libraries | People | FAQ | More | 
        The header <boost/core/noinit_adaptor.hpp> provides the class template
        boost::noinit_adaptor that converts any allocator
        into one whose construct(ptr)
        performs default initialization via placement new, and whose destroy(ptr) invokes
        value_type destructor directly.
      
The following example shows use of this allocator adaptor to achieve default initialization of elements of a trivial type, which are later assigned values.
#include <boost/core/noinit_adaptor.hpp> #include <numeric> #include <vector> int main() { std::vector<int, boost::noinit_adaptor<std::allocator<int> > > v(5); std::iota(v.begin(), v.end(), 1); }
        The allocate_shared_noinit
        function templates are now implemented simply using allocate_shared
        with noinit_adaptor.
      
template<class T, class A> enable_if_t<is_unbounded_array_v<T>, shared_ptr<T> > allocate_shared_noinit(const A& a, size_t n) { return allocate_shared<T>(boost::noinit_adapt(a), n); } template<class T, class A> enable_if_t<!is_unbounded_array_v<T>, shared_ptr<T> > allocate_shared_noinit(const A& a) { return allocate_shared<T>(boost::noinit_adapt(a)); }
namespace boost { template<class A> struct noinit_adaptor : A { template<class U> struct rebind { typedef noinit_adaptor<typename std::allocator_traits<A>::template rebind_alloc<U> > other; }; noinit_adaptor() noexcept; template<class U> noinit_adaptor(U&& u) noexcept; template<class U> noinit_adaptor(const noinit_adaptor<U>& u) noexcept; template<class U> void construct(U* p); template<class U, class V, class... Args> void construct(U* p, V&& v, Args&&... args); template<class U> void destroy(U* p); }; template<class T, class U> bool operator==(const noinit_adaptor<T>& lhs, const noinit_adaptor<U>& rhs) noexcept; template<class T, class U> bool operator!=(const noinit_adaptor<T>& lhs, const noinit_adaptor<U>& rhs) noexcept; template<class A> noinit_adaptor<A> noinit_adapt(const A& a) noexcept; } /* boost */
noinit_adaptor() noexcept;
Value initializes the A base class.
template<class U> noinit_adaptor(U&& u) noexcept;
                      A shall be
                      constructible from U.
                    
                      Initializes the A
                      base class with std::forward<U>(u).
                    
template<class U> noinit_adaptor(const noinit_adaptor<U>&
            u)
            noexcept;
                      A shall be
                      constructible from U.
                    
                      Initializes the A
                      base class with static_cast<const
                      U&>(u).
                    
template<class U> void construct(U* p);
                      ::new((void*)p) U.
                    
template<class U, class V, class... Args>
            void construct(U* p, V&& v, Args&&... args);
                      ::new(void*)p) U(std::forward<V>(v), std::forward<Args>(args)...).
                    
template<class U> void destroy(U* p);
                      p->~U().
                    
template<class T, class U> constexpr bool
            operator==(const noinit_adaptor<T>& lhs, const noinit_adaptor<U>&
            rhs)
            noexcept;
                      static_cast<const T&>(lhs) ==
                      static_cast<const U&>(rhs).
                    
template<class T, class U> constexpr bool
            operator!=(const noinit_adaptor<T>& lhs, const noinit_adaptor<U>&
            rhs)
            noexcept;
                      !(lhs
                      == rhs).
                    
template<class A> noinit_adaptor<A> noinit_adapt(const A& a) noexcept;
                      noinit_adaptor<A>(a).