libstdc++
allocator.h
Go to the documentation of this file.
1 // Allocators -*- C++ -*-
2 
3 // Copyright (C) 2001-2019 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /*
26  * Copyright (c) 1996-1997
27  * Silicon Graphics Computer Systems, Inc.
28  *
29  * Permission to use, copy, modify, distribute and sell this software
30  * and its documentation for any purpose is hereby granted without fee,
31  * provided that the above copyright notice appear in all copies and
32  * that both that copyright notice and this permission notice appear
33  * in supporting documentation. Silicon Graphics makes no
34  * representations about the suitability of this software for any
35  * purpose. It is provided "as is" without express or implied warranty.
36  */
37 
38 /** @file bits/allocator.h
39  * This is an internal header file, included by other library headers.
40  * Do not attempt to use it directly. @headername{memory}
41  */
42 
43 #ifndef _ALLOCATOR_H
44 #define _ALLOCATOR_H 1
45 
46 #include <bits/c++allocator.h> // Define the base class to std::allocator.
47 #include <bits/memoryfwd.h>
48 #if __cplusplus >= 201103L
49 #include <type_traits>
50 #endif
51 
52 #define __cpp_lib_incomplete_container_elements 201505
53 #if __cplusplus >= 201103L
54 # define __cpp_lib_allocator_is_always_equal 201411
55 #endif
56 
57 namespace std _GLIBCXX_VISIBILITY(default)
58 {
59 _GLIBCXX_BEGIN_NAMESPACE_VERSION
60 
61  /**
62  * @addtogroup allocators
63  * @{
64  */
65 
66  /// allocator<void> specialization.
67  template<>
68  class allocator<void>
69  {
70  public:
71  typedef size_t size_type;
72  typedef ptrdiff_t difference_type;
73  typedef void* pointer;
74  typedef const void* const_pointer;
75  typedef void value_type;
76 
77  template<typename _Tp1>
78  struct rebind
79  { typedef allocator<_Tp1> other; };
80 
81 #if __cplusplus >= 201103L
82  // _GLIBCXX_RESOLVE_LIB_DEFECTS
83  // 2103. std::allocator propagate_on_container_move_assignment
85 
86  typedef true_type is_always_equal;
87 
88  template<typename _Up, typename... _Args>
89  void
90  construct(_Up* __p, _Args&&... __args)
92  { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
93 
94  template<typename _Up>
95  void
96  destroy(_Up* __p)
98  { __p->~_Up(); }
99 #endif
100  };
101 
102  /**
103  * @brief The @a standard allocator, as per [20.4].
104  *
105  * See https://gcc.gnu.org/onlinedocs/libstdc++/manual/memory.html#std.util.memory.allocator
106  * for further details.
107  *
108  * @tparam _Tp Type of allocated object.
109  */
110  template<typename _Tp>
111  class allocator : public __allocator_base<_Tp>
112  {
113  public:
114  typedef size_t size_type;
115  typedef ptrdiff_t difference_type;
116  typedef _Tp* pointer;
117  typedef const _Tp* const_pointer;
118  typedef _Tp& reference;
119  typedef const _Tp& const_reference;
120  typedef _Tp value_type;
121 
122  template<typename _Tp1>
123  struct rebind
124  { typedef allocator<_Tp1> other; };
125 
126 #if __cplusplus >= 201103L
127  // _GLIBCXX_RESOLVE_LIB_DEFECTS
128  // 2103. std::allocator propagate_on_container_move_assignment
130 
131  typedef true_type is_always_equal;
132 #endif
133 
134  // _GLIBCXX_RESOLVE_LIB_DEFECTS
135  // 3035. std::allocator's constructors should be constexpr
136  _GLIBCXX20_CONSTEXPR
137  allocator() _GLIBCXX_NOTHROW { }
138 
139  _GLIBCXX20_CONSTEXPR
140  allocator(const allocator& __a) _GLIBCXX_NOTHROW
141  : __allocator_base<_Tp>(__a) { }
142 
143 #if __cplusplus >= 201103L
144  // Avoid implicit deprecation.
145  allocator& operator=(const allocator&) = default;
146 #endif
147 
148  template<typename _Tp1>
149  _GLIBCXX20_CONSTEXPR
150  allocator(const allocator<_Tp1>&) _GLIBCXX_NOTHROW { }
151 
152  ~allocator() _GLIBCXX_NOTHROW { }
153 
154  friend bool
155  operator==(const allocator&, const allocator&) _GLIBCXX_NOTHROW
156  { return true; }
157 
158  friend bool
159  operator!=(const allocator&, const allocator&) _GLIBCXX_NOTHROW
160  { return false; }
161 
162  // Inherit everything else.
163  };
164 
165  template<typename _T1, typename _T2>
166  inline bool
167  operator==(const allocator<_T1>&, const allocator<_T2>&)
168  _GLIBCXX_NOTHROW
169  { return true; }
170 
171  template<typename _T1, typename _T2>
172  inline bool
173  operator!=(const allocator<_T1>&, const allocator<_T2>&)
174  _GLIBCXX_NOTHROW
175  { return false; }
176 
177  // Invalid allocator<cv T> partial specializations.
178  // allocator_traits::rebind_alloc can be used to form a valid allocator type.
179  template<typename _Tp>
180  class allocator<const _Tp>
181  {
182  public:
183  typedef _Tp value_type;
184  template<typename _Up> allocator(const allocator<_Up>&) { }
185  };
186 
187  template<typename _Tp>
188  class allocator<volatile _Tp>
189  {
190  public:
191  typedef _Tp value_type;
192  template<typename _Up> allocator(const allocator<_Up>&) { }
193  };
194 
195  template<typename _Tp>
196  class allocator<const volatile _Tp>
197  {
198  public:
199  typedef _Tp value_type;
200  template<typename _Up> allocator(const allocator<_Up>&) { }
201  };
202 
203  /// @} group allocator
204 
205  // Inhibit implicit instantiations for required instantiations,
206  // which are defined via explicit instantiations elsewhere.
207 #if _GLIBCXX_EXTERN_TEMPLATE
208  extern template class allocator<char>;
209  extern template class allocator<wchar_t>;
210 #endif
211 
212  // Undefine.
213 #undef __allocator_base
214 
215  // To implement Option 3 of DR 431.
216  template<typename _Alloc, bool = __is_empty(_Alloc)>
217  struct __alloc_swap
218  { static void _S_do_it(_Alloc&, _Alloc&) _GLIBCXX_NOEXCEPT { } };
219 
220  template<typename _Alloc>
221  struct __alloc_swap<_Alloc, false>
222  {
223  static void
224  _S_do_it(_Alloc& __one, _Alloc& __two) _GLIBCXX_NOEXCEPT
225  {
226  // Precondition: swappable allocators.
227  if (__one != __two)
228  swap(__one, __two);
229  }
230  };
231 
232  // Optimize for stateless allocators.
233  template<typename _Alloc, bool = __is_empty(_Alloc)>
234  struct __alloc_neq
235  {
236  static bool
237  _S_do_it(const _Alloc&, const _Alloc&)
238  { return false; }
239  };
240 
241  template<typename _Alloc>
242  struct __alloc_neq<_Alloc, false>
243  {
244  static bool
245  _S_do_it(const _Alloc& __one, const _Alloc& __two)
246  { return __one != __two; }
247  };
248 
249 #if __cplusplus >= 201103L
250  template<typename _Tp, bool
251  = __or_<is_copy_constructible<typename _Tp::value_type>,
252  is_nothrow_move_constructible<typename _Tp::value_type>>::value>
253  struct __shrink_to_fit_aux
254  { static bool _S_do_it(_Tp&) noexcept { return false; } };
255 
256  template<typename _Tp>
257  struct __shrink_to_fit_aux<_Tp, true>
258  {
259  static bool
260  _S_do_it(_Tp& __c) noexcept
261  {
262 #if __cpp_exceptions
263  try
264  {
265  _Tp(__make_move_if_noexcept_iterator(__c.begin()),
266  __make_move_if_noexcept_iterator(__c.end()),
267  __c.get_allocator()).swap(__c);
268  return true;
269  }
270  catch(...)
271  { return false; }
272 #else
273  return false;
274 #endif
275  }
276  };
277 #endif
278 
279 _GLIBCXX_END_NAMESPACE_VERSION
280 } // namespace std
281 
282 #endif
ISO C++ entities toplevel namespace is std.
integral_constant
Definition: type_traits:58
is_nothrow_destructible
Definition: type_traits:879
is_nothrow_constructible
Definition: type_traits:963
The standard allocator, as per [20.4].
Definition: allocator.h:112
An allocator that uses global new, as per [20.4].
Definition: new_allocator.h:59