29#ifndef _MALLOC_ALLOCATOR_H
30#define _MALLOC_ALLOCATOR_H 1
37#if __cplusplus >= 201103L
41namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
43_GLIBCXX_BEGIN_NAMESPACE_VERSION
56 template<
typename _Tp>
60 typedef size_t size_type;
61 typedef ptrdiff_t difference_type;
63 typedef const _Tp* const_pointer;
64 typedef _Tp& reference;
65 typedef const _Tp& const_reference;
66 typedef _Tp value_type;
68 template<
typename _Tp1>
72#if __cplusplus >= 201103L
82 template<
typename _Tp1>
84 _GLIBCXX_USE_NOEXCEPT { }
89 address(reference __x)
const _GLIBCXX_NOEXCEPT
93 address(const_reference __x)
const _GLIBCXX_NOEXCEPT
99 allocate(size_type __n,
const void* = 0)
101 if (__n > this->max_size())
102 std::__throw_bad_alloc();
106#if __cplusplus > 201402L && _GLIBCXX_HAVE_ALIGNED_ALLOC
107 if (
alignof(_Tp) >
alignof(std::max_align_t))
109 __ret =
static_cast<_Tp*
>(::aligned_alloc(
alignof(_Tp),
113# define _GLIBCXX_CHECK_MALLOC_RESULT
117 __ret =
static_cast<_Tp*
>(std::malloc(__n *
sizeof(_Tp)));
119 std::__throw_bad_alloc();
120#ifdef _GLIBCXX_CHECK_MALLOC_RESULT
121#undef _GLIBCXX_CHECK_MALLOC_RESULT
122 if (
reinterpret_cast<std::size_t
>(__ret) %
alignof(_Tp))
125 deallocate(__ret, __n);
126 std::__throw_bad_alloc();
134 deallocate(pointer __p, size_type)
135 { std::free(
static_cast<void*
>(__p)); }
138 max_size()
const _GLIBCXX_USE_NOEXCEPT
139 {
return size_t(-1) /
sizeof(_Tp); }
141#if __cplusplus >= 201103L
142 template<
typename _Up,
typename... _Args>
144 construct(_Up* __p, _Args&&... __args)
145 { ::new((
void *)__p) _Up(std::forward<_Args>(__args)...); }
147 template<
typename _Up>
149 destroy(_Up* __p) { __p->~_Up(); }
154 construct(pointer __p,
const _Tp& __val)
155 { ::new((
void *)__p) value_type(__val); }
158 destroy(pointer __p) { __p->~_Tp(); }
162 template<
typename _Tp>
167 template<
typename _Tp>
169 operator!=(
const malloc_allocator<_Tp>&,
const malloc_allocator<_Tp>&)
172_GLIBCXX_END_NAMESPACE_VERSION
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
GNU extensions for public use.
An allocator that uses malloc.