173 lines
4.0 KiB
Plaintext
173 lines
4.0 KiB
Plaintext
[/
|
|
Copyright 2019 Glen Joseph Fernandes
|
|
(glenjofe@gmail.com)
|
|
|
|
Distributed under the Boost Software License, Version 1.0.
|
|
(http://www.boost.org/LICENSE_1_0.txt)
|
|
]
|
|
|
|
[section:noinit_adaptor noinit_adaptor]
|
|
|
|
[simplesect Authors]
|
|
|
|
* Glen Fernandes
|
|
|
|
[endsimplesect]
|
|
|
|
[section Overview]
|
|
|
|
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.
|
|
|
|
[endsect]
|
|
|
|
[section Examples]
|
|
|
|
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));
|
|
}
|
|
```
|
|
|
|
[endsect]
|
|
|
|
[section Reference]
|
|
|
|
```
|
|
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 */
|
|
```
|
|
|
|
[section Constructors]
|
|
|
|
[variablelist
|
|
[[`noinit_adaptor() noexcept;`]
|
|
[[variablelist
|
|
[[Effects][Value initializes the A base class.]]]]]
|
|
[[`template<class U> noinit_adaptor(U&& u) noexcept;`]
|
|
[[variablelist
|
|
[[Requires][`A` shall be constructible from `U`.]]
|
|
[[Effects][Initializes the `A` base class with `std::forward<U>(u)`.]]]]]
|
|
[[`template<class U> noinit_adaptor(const noinit_adaptor<U>& u) noexcept;`]
|
|
[[variablelist
|
|
[[Requires][`A` shall be constructible from `U`.]]
|
|
[[Effects][Initializes the `A` base class with
|
|
`static_cast<const U&>(u)`.]]]]]]
|
|
|
|
[endsect]
|
|
|
|
[section Member functions]
|
|
|
|
[variablelist
|
|
[[`template<class U> void construct(U* p);`]
|
|
[[variablelist
|
|
[[Effects][`::new((void*)p) U`.]]]]]
|
|
[[`template<class U, class V, class... Args> void construct(U* p, V&& v,
|
|
Args&&... args);`]
|
|
[[variablelist
|
|
[[Effects][`::new(void*)p) U(std::forward<V>(v),
|
|
std::forward<Args>(args)...)`.]]]]]
|
|
[[`template<class U> void destroy(U* p);`]
|
|
[[variablelist
|
|
[[Effects][`p->~U()`.]]]]]]
|
|
|
|
[endsect]
|
|
|
|
[section Operators]
|
|
|
|
[variablelist
|
|
[[`template<class T, class U> constexpr bool
|
|
operator==(const noinit_adaptor<T>& lhs,
|
|
const noinit_adaptor<U>& rhs) noexcept;`]
|
|
[[variablelist
|
|
[[Returns][`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;`]
|
|
[[variablelist
|
|
[[Returns][`!(lhs == rhs)`.]]]]]]
|
|
|
|
[endsect]
|
|
|
|
[section Free functions]
|
|
|
|
[variablelist
|
|
[[`template<class A> noinit_adaptor<A> noinit_adapt(const A& a) noexcept;`]
|
|
[[variablelist
|
|
[[Returns][`noinit_adaptor<A>(a)`.]]]]]]
|
|
|
|
[endsect]
|
|
|
|
[endsect]
|
|
|
|
[endsect]
|