Line data Source code
1 : // nonstandard construct and destroy functions -*- C++ -*-
2 :
3 : // Copyright (C) 2001-2024 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 : *
27 : * Copyright (c) 1994
28 : * Hewlett-Packard Company
29 : *
30 : * Permission to use, copy, modify, distribute and sell this software
31 : * and its documentation for any purpose is hereby granted without fee,
32 : * provided that the above copyright notice appear in all copies and
33 : * that both that copyright notice and this permission notice appear
34 : * in supporting documentation. Hewlett-Packard Company makes no
35 : * representations about the suitability of this software for any
36 : * purpose. It is provided "as is" without express or implied warranty.
37 : *
38 : *
39 : * Copyright (c) 1996,1997
40 : * Silicon Graphics Computer Systems, Inc.
41 : *
42 : * Permission to use, copy, modify, distribute and sell this software
43 : * and its documentation for any purpose is hereby granted without fee,
44 : * provided that the above copyright notice appear in all copies and
45 : * that both that copyright notice and this permission notice appear
46 : * in supporting documentation. Silicon Graphics makes no
47 : * representations about the suitability of this software for any
48 : * purpose. It is provided "as is" without express or implied warranty.
49 : */
50 :
51 : /** @file bits/stl_construct.h
52 : * This is an internal header file, included by other library headers.
53 : * Do not attempt to use it directly. @headername{memory}
54 : */
55 :
56 : #ifndef _STL_CONSTRUCT_H
57 : #define _STL_CONSTRUCT_H 1
58 :
59 : #include <new>
60 : #include <bits/move.h>
61 : #include <bits/stl_iterator_base_types.h> // for iterator_traits
62 : #include <bits/stl_iterator_base_funcs.h> // for advance
63 :
64 : /* This file provides the C++17 functions std::destroy_at, std::destroy, and
65 : * std::destroy_n, and the C++20 function std::construct_at.
66 : * It also provides std::_Construct, std::_Destroy,and std::_Destroy_n functions
67 : * which are defined in all standard modes and so can be used in C++98-14 code.
68 : * The _Destroy functions will dispatch to destroy_at during constant
69 : * evaluation, because calls to that function are intercepted by the compiler
70 : * to allow use in constant expressions.
71 : */
72 :
73 : namespace std _GLIBCXX_VISIBILITY(default)
74 : {
75 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
76 :
77 : #if __glibcxx_raw_memory_algorithms // >= C++17
78 : template <typename _Tp>
79 : _GLIBCXX20_CONSTEXPR inline void
80 : destroy_at(_Tp* __location)
81 : {
82 : if constexpr (__cplusplus > 201703L && is_array_v<_Tp>)
83 : {
84 : for (auto& __x : *__location)
85 : std::destroy_at(std::__addressof(__x));
86 : }
87 : else
88 : __location->~_Tp();
89 : }
90 :
91 : #if __cpp_constexpr_dynamic_alloc // >= C++20
92 : template<typename _Tp, typename... _Args>
93 : constexpr auto
94 : construct_at(_Tp* __location, _Args&&... __args)
95 : noexcept(noexcept(::new((void*)0) _Tp(std::declval<_Args>()...)))
96 : -> decltype(::new((void*)0) _Tp(std::declval<_Args>()...))
97 : { return ::new((void*)__location) _Tp(std::forward<_Args>(__args)...); }
98 : #endif // C++20
99 : #endif// C++17
100 :
101 : /**
102 : * Constructs an object in existing memory by invoking an allocated
103 : * object's constructor with an initializer.
104 : */
105 : #if __cplusplus >= 201103L
106 : template<typename _Tp, typename... _Args>
107 : _GLIBCXX20_CONSTEXPR
108 : inline void
109 0 : _Construct(_Tp* __p, _Args&&... __args)
110 : {
111 : #if __cpp_constexpr_dynamic_alloc // >= C++20
112 : if (std::__is_constant_evaluated())
113 : {
114 : // Allow std::_Construct to be used in constant expressions.
115 : std::construct_at(__p, std::forward<_Args>(__args)...);
116 : return;
117 : }
118 : #endif
119 0 : ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
120 0 : }
121 : #else
122 : template<typename _T1, typename _T2>
123 : inline void
124 : _Construct(_T1* __p, const _T2& __value)
125 : {
126 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
127 : // 402. wrong new expression in [some_]allocator::construct
128 : ::new(static_cast<void*>(__p)) _T1(__value);
129 : }
130 : #endif
131 :
132 : template<typename _T1>
133 : inline void
134 : _Construct_novalue(_T1* __p)
135 : { ::new((void*)__p) _T1; }
136 :
137 : template<typename _ForwardIterator>
138 : _GLIBCXX20_CONSTEXPR void
139 : _Destroy(_ForwardIterator __first, _ForwardIterator __last);
140 :
141 : /**
142 : * Destroy the object pointed to by a pointer type.
143 : */
144 : template<typename _Tp>
145 : _GLIBCXX14_CONSTEXPR inline void
146 0 : _Destroy(_Tp* __pointer)
147 : {
148 : #if __cpp_constexpr_dynamic_alloc // >= C++20
149 : std::destroy_at(__pointer);
150 : #else
151 0 : __pointer->~_Tp();
152 : #endif
153 0 : }
154 :
155 : template<bool>
156 : struct _Destroy_aux
157 : {
158 : template<typename _ForwardIterator>
159 : static _GLIBCXX20_CONSTEXPR void
160 0 : __destroy(_ForwardIterator __first, _ForwardIterator __last)
161 : {
162 0 : for (; __first != __last; ++__first)
163 0 : std::_Destroy(std::__addressof(*__first));
164 0 : }
165 : };
166 :
167 : template<>
168 : struct _Destroy_aux<true>
169 : {
170 : template<typename _ForwardIterator>
171 : static void
172 0 : __destroy(_ForwardIterator, _ForwardIterator) { }
173 : };
174 :
175 : /**
176 : * Destroy a range of objects. If the value_type of the object has
177 : * a trivial destructor, the compiler should optimize all of this
178 : * away, otherwise the objects' destructors must be invoked.
179 : */
180 : template<typename _ForwardIterator>
181 : _GLIBCXX20_CONSTEXPR inline void
182 0 : _Destroy(_ForwardIterator __first, _ForwardIterator __last)
183 : {
184 : typedef typename iterator_traits<_ForwardIterator>::value_type
185 : _Value_type;
186 : #if __cplusplus >= 201103L
187 : // A deleted destructor is trivial, this ensures we reject such types:
188 : static_assert(is_destructible<_Value_type>::value,
189 : "value type is destructible");
190 : #endif
191 : #if __cpp_constexpr_dynamic_alloc // >= C++20
192 : if (std::__is_constant_evaluated())
193 : return std::_Destroy_aux<false>::__destroy(__first, __last);
194 : #endif
195 : std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
196 0 : __destroy(__first, __last);
197 0 : }
198 :
199 : template<bool>
200 : struct _Destroy_n_aux
201 : {
202 : template<typename _ForwardIterator, typename _Size>
203 : static _GLIBCXX20_CONSTEXPR _ForwardIterator
204 : __destroy_n(_ForwardIterator __first, _Size __count)
205 : {
206 : for (; __count > 0; (void)++__first, --__count)
207 : std::_Destroy(std::__addressof(*__first));
208 : return __first;
209 : }
210 : };
211 :
212 : template<>
213 : struct _Destroy_n_aux<true>
214 : {
215 : template<typename _ForwardIterator, typename _Size>
216 : static _ForwardIterator
217 : __destroy_n(_ForwardIterator __first, _Size __count)
218 : {
219 : std::advance(__first, __count);
220 : return __first;
221 : }
222 : };
223 :
224 : /**
225 : * Destroy a range of objects. If the value_type of the object has
226 : * a trivial destructor, the compiler should optimize all of this
227 : * away, otherwise the objects' destructors must be invoked.
228 : */
229 : template<typename _ForwardIterator, typename _Size>
230 : _GLIBCXX20_CONSTEXPR inline _ForwardIterator
231 : _Destroy_n(_ForwardIterator __first, _Size __count)
232 : {
233 : typedef typename iterator_traits<_ForwardIterator>::value_type
234 : _Value_type;
235 : #if __cplusplus >= 201103L
236 : // A deleted destructor is trivial, this ensures we reject such types:
237 : static_assert(is_destructible<_Value_type>::value,
238 : "value type is destructible");
239 : #endif
240 : #if __cpp_constexpr_dynamic_alloc // >= C++20
241 : if (std::__is_constant_evaluated())
242 : return std::_Destroy_n_aux<false>::__destroy_n(__first, __count);
243 : #endif
244 : return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
245 : __destroy_n(__first, __count);
246 : }
247 :
248 : #if __glibcxx_raw_memory_algorithms // >= C++17
249 : template <typename _ForwardIterator>
250 : _GLIBCXX20_CONSTEXPR inline void
251 : destroy(_ForwardIterator __first, _ForwardIterator __last)
252 : {
253 : std::_Destroy(__first, __last);
254 : }
255 :
256 : template <typename _ForwardIterator, typename _Size>
257 : _GLIBCXX20_CONSTEXPR inline _ForwardIterator
258 : destroy_n(_ForwardIterator __first, _Size __count)
259 : {
260 : return std::_Destroy_n(__first, __count);
261 : }
262 : #endif // C++17
263 :
264 : _GLIBCXX_END_NAMESPACE_VERSION
265 : } // namespace std
266 :
267 : #endif /* _STL_CONSTRUCT_H */
|
