1// Components for manipulating sequences of characters -*- C++ -*-
2
3// Copyright (C) 1997-2021 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/** @file bits/basic_string.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{string}
28 */
29
30//
31// ISO C++ 14882: 21 Strings library
32//
33
34#ifndef _BASIC_STRING_H
35#define _BASIC_STRING_H 1
36
37#pragma GCC system_header
38
39#include <ext/atomicity.h>
40#include <ext/alloc_traits.h>
41#include <debug/debug.h>
42
43#if __cplusplus >= 201103L
44#include <initializer_list>
45#endif
46
47#if __cplusplus >= 201703L
48# include <string_view>
49#endif
50
51namespace std _GLIBCXX_VISIBILITY(default)
52{
53_GLIBCXX_BEGIN_NAMESPACE_VERSION
54
55#ifdef __cpp_lib_is_constant_evaluated
56// Support P1032R1 in C++20 (but not P0980R1 yet).
57# define __cpp_lib_constexpr_string 201811L
58#elif __cplusplus >= 201703L
59// Support P0426R1 changes to char_traits in C++17.
60# define __cpp_lib_constexpr_string 201611L
61#elif __cplusplus > 201703L
62#endif
63
64#if _GLIBCXX_USE_CXX11_ABI
65_GLIBCXX_BEGIN_NAMESPACE_CXX11
66 /**
67 * @class basic_string basic_string.h <string>
68 * @brief Managing sequences of characters and character-like objects.
69 *
70 * @ingroup strings
71 * @ingroup sequences
72 *
73 * @tparam _CharT Type of character
74 * @tparam _Traits Traits for character type, defaults to
75 * char_traits<_CharT>.
76 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
77 *
78 * Meets the requirements of a <a href="tables.html#65">container</a>, a
79 * <a href="tables.html#66">reversible container</a>, and a
80 * <a href="tables.html#67">sequence</a>. Of the
81 * <a href="tables.html#68">optional sequence requirements</a>, only
82 * @c push_back, @c at, and @c %array access are supported.
83 */
84 template<typename _CharT, typename _Traits, typename _Alloc>
85 class basic_string
86 {
87 typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
88 rebind<_CharT>::other _Char_alloc_type;
89 typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
90
91 // Types:
92 public:
93 typedef _Traits traits_type;
94 typedef typename _Traits::char_type value_type;
95 typedef _Char_alloc_type allocator_type;
96 typedef typename _Alloc_traits::size_type size_type;
97 typedef typename _Alloc_traits::difference_type difference_type;
98 typedef typename _Alloc_traits::reference reference;
99 typedef typename _Alloc_traits::const_reference const_reference;
100 typedef typename _Alloc_traits::pointer pointer;
101 typedef typename _Alloc_traits::const_pointer const_pointer;
102 typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
103 typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
104 const_iterator;
105 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
106 typedef std::reverse_iterator<iterator> reverse_iterator;
107
108 /// Value returned by various member functions when they fail.
109 static const size_type npos = static_cast<size_type>(-1);
110
111 protected:
112 // type used for positions in insert, erase etc.
113#if __cplusplus < 201103L
114 typedef iterator __const_iterator;
115#else
116 typedef const_iterator __const_iterator;
117#endif
118
119 private:
120#if __cplusplus >= 201703L
121 // A helper type for avoiding boiler-plate.
122 typedef basic_string_view<_CharT, _Traits> __sv_type;
123
124 template<typename _Tp, typename _Res>
125 using _If_sv = enable_if_t<
126 __and_<is_convertible<const _Tp&, __sv_type>,
127 __not_<is_convertible<const _Tp*, const basic_string*>>,
128 __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
129 _Res>;
130
131 // Allows an implicit conversion to __sv_type.
132 static __sv_type
133 _S_to_string_view(__sv_type __svt) noexcept
134 { return __svt; }
135
136 // Wraps a string_view by explicit conversion and thus
137 // allows to add an internal constructor that does not
138 // participate in overload resolution when a string_view
139 // is provided.
140 struct __sv_wrapper
141 {
142 explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
143 __sv_type _M_sv;
144 };
145
146 /**
147 * @brief Only internally used: Construct string from a string view
148 * wrapper.
149 * @param __svw string view wrapper.
150 * @param __a Allocator to use.
151 */
152 explicit
153 basic_string(__sv_wrapper __svw, const _Alloc& __a)
154 : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
155#endif
156
157 // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
158 struct _Alloc_hider : allocator_type // TODO check __is_final
159 {
160#if __cplusplus < 201103L
161 _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
162 : allocator_type(__a), _M_p(__dat) { }
163#else
164 _Alloc_hider(pointer __dat, const _Alloc& __a)
165 : allocator_type(__a), _M_p(__dat) { }
166
167 _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
168 : allocator_type(std::move(__a)), _M_p(__dat) { }
169#endif
170
171 pointer _M_p; // The actual data.
172 };
173
174 _Alloc_hider _M_dataplus;
175 size_type _M_string_length;
176
177 enum { _S_local_capacity = 15 / sizeof(_CharT) };
178
179 union
180 {
181 _CharT _M_local_buf[_S_local_capacity + 1];
182 size_type _M_allocated_capacity;
183 };
184
185 void
186 _M_data(pointer __p)
187 { _M_dataplus._M_p = __p; }
188
189 void
190 _M_length(size_type __length)
191 { _M_string_length = __length; }
192
193 pointer
194 _M_data() const
195 { return _M_dataplus._M_p; }
196
197 pointer
198 _M_local_data()
199 {
200#if __cplusplus >= 201103L
201 return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
202#else
203 return pointer(_M_local_buf);
204#endif
205 }
206
207 const_pointer
208 _M_local_data() const
209 {
210#if __cplusplus >= 201103L
211 return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
212#else
213 return const_pointer(_M_local_buf);
214#endif
215 }
216
217 void
218 _M_capacity(size_type __capacity)
219 { _M_allocated_capacity = __capacity; }
220
221 void
222 _M_set_length(size_type __n)
223 {
224 _M_length(length: __n);
225 traits_type::assign(_M_data()[__n], _CharT());
226 }
227
228 bool
229 _M_is_local() const
230 { return _M_data() == _M_local_data(); }
231
232 // Create & Destroy
233 pointer
234 _M_create(size_type&, size_type);
235
236 void
237 _M_dispose()
238 {
239 if (!_M_is_local())
240 _M_destroy(size: _M_allocated_capacity);
241 }
242
243 void
244 _M_destroy(size_type __size) throw()
245 { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
246
247 // _M_construct_aux is used to implement the 21.3.1 para 15 which
248 // requires special behaviour if _InIterator is an integral type
249 template<typename _InIterator>
250 void
251 _M_construct_aux(_InIterator __beg, _InIterator __end,
252 std::__false_type)
253 {
254 typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
255 _M_construct(__beg, __end, _Tag());
256 }
257
258 // _GLIBCXX_RESOLVE_LIB_DEFECTS
259 // 438. Ambiguity in the "do the right thing" clause
260 template<typename _Integer>
261 void
262 _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
263 { _M_construct_aux_2(req: static_cast<size_type>(__beg), c: __end); }
264
265 void
266 _M_construct_aux_2(size_type __req, _CharT __c)
267 { _M_construct(__req, __c); }
268
269 template<typename _InIterator>
270 void
271 _M_construct(_InIterator __beg, _InIterator __end)
272 {
273 typedef typename std::__is_integer<_InIterator>::__type _Integral;
274 _M_construct_aux(__beg, __end, _Integral());
275 }
276
277 // For Input Iterators, used in istreambuf_iterators, etc.
278 template<typename _InIterator>
279 void
280 _M_construct(_InIterator __beg, _InIterator __end,
281 std::input_iterator_tag);
282
283 // For forward_iterators up to random_access_iterators, used for
284 // string::iterator, _CharT*, etc.
285 template<typename _FwdIterator>
286 void
287 _M_construct(_FwdIterator __beg, _FwdIterator __end,
288 std::forward_iterator_tag);
289
290 void
291 _M_construct(size_type __req, _CharT __c);
292
293 allocator_type&
294 _M_get_allocator()
295 { return _M_dataplus; }
296
297 const allocator_type&
298 _M_get_allocator() const
299 { return _M_dataplus; }
300
301 private:
302
303#ifdef _GLIBCXX_DISAMBIGUATE_REPLACE_INST
304 // The explicit instantiations in misc-inst.cc require this due to
305 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64063
306 template<typename _Tp, bool _Requires =
307 !__are_same<_Tp, _CharT*>::__value
308 && !__are_same<_Tp, const _CharT*>::__value
309 && !__are_same<_Tp, iterator>::__value
310 && !__are_same<_Tp, const_iterator>::__value>
311 struct __enable_if_not_native_iterator
312 { typedef basic_string& __type; };
313 template<typename _Tp>
314 struct __enable_if_not_native_iterator<_Tp, false> { };
315#endif
316
317 size_type
318 _M_check(size_type __pos, const char* __s) const
319 {
320 if (__pos > this->size())
321 __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
322 "this->size() (which is %zu)"),
323 __s, __pos, this->size());
324 return __pos;
325 }
326
327 void
328 _M_check_length(size_type __n1, size_type __n2, const char* __s) const
329 {
330 if (this->max_size() - (this->size() - __n1) < __n2)
331 __throw_length_error(__N(__s));
332 }
333
334
335 // NB: _M_limit doesn't check for a bad __pos value.
336 size_type
337 _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT
338 {
339 const bool __testoff = __off < this->size() - __pos;
340 return __testoff ? __off : this->size() - __pos;
341 }
342
343 // True if _Rep and source do not overlap.
344 bool
345 _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT
346 {
347 return (less<const _CharT*>()(__s, _M_data())
348 || less<const _CharT*>()(_M_data() + this->size(), __s));
349 }
350
351 // When __n = 1 way faster than the general multichar
352 // traits_type::copy/move/assign.
353 static void
354 _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
355 {
356 if (__n == 1)
357 traits_type::assign(*__d, *__s);
358 else
359 traits_type::copy(__d, __s, __n);
360 }
361
362 static void
363 _S_move(_CharT* __d, const _CharT* __s, size_type __n)
364 {
365 if (__n == 1)
366 traits_type::assign(*__d, *__s);
367 else
368 traits_type::move(__d, __s, __n);
369 }
370
371 static void
372 _S_assign(_CharT* __d, size_type __n, _CharT __c)
373 {
374 if (__n == 1)
375 traits_type::assign(*__d, __c);
376 else
377 traits_type::assign(__d, __n, __c);
378 }
379
380 // _S_copy_chars is a separate template to permit specialization
381 // to optimize for the common case of pointers as iterators.
382 template<class _Iterator>
383 static void
384 _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
385 {
386 for (; __k1 != __k2; ++__k1, (void)++__p)
387 traits_type::assign(*__p, *__k1); // These types are off.
388 }
389
390 static void
391 _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) _GLIBCXX_NOEXCEPT
392 { _S_copy_chars(__p, __k1.base(), __k2.base()); }
393
394 static void
395 _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
396 _GLIBCXX_NOEXCEPT
397 { _S_copy_chars(__p, __k1.base(), __k2.base()); }
398
399 static void
400 _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) _GLIBCXX_NOEXCEPT
401 { _S_copy(d: __p, s: __k1, n: __k2 - __k1); }
402
403 static void
404 _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
405 _GLIBCXX_NOEXCEPT
406 { _S_copy(d: __p, s: __k1, n: __k2 - __k1); }
407
408 static int
409 _S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT
410 {
411 const difference_type __d = difference_type(__n1 - __n2);
412
413 if (__d > __gnu_cxx::__numeric_traits<int>::__max)
414 return __gnu_cxx::__numeric_traits<int>::__max;
415 else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
416 return __gnu_cxx::__numeric_traits<int>::__min;
417 else
418 return int(__d);
419 }
420
421 void
422 _M_assign(const basic_string&);
423
424 void
425 _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
426 size_type __len2);
427
428 void
429 _M_erase(size_type __pos, size_type __n);
430
431 public:
432 // Construct/copy/destroy:
433 // NB: We overload ctors in some cases instead of using default
434 // arguments, per 17.4.4.4 para. 2 item 2.
435
436 /**
437 * @brief Default constructor creates an empty string.
438 */
439 basic_string()
440 _GLIBCXX_NOEXCEPT_IF(is_nothrow_default_constructible<_Alloc>::value)
441 : _M_dataplus(_M_local_data())
442 { _M_set_length(n: 0); }
443
444 /**
445 * @brief Construct an empty string using allocator @a a.
446 */
447 explicit
448 basic_string(const _Alloc& __a) _GLIBCXX_NOEXCEPT
449 : _M_dataplus(_M_local_data(), __a)
450 { _M_set_length(n: 0); }
451
452 /**
453 * @brief Construct string with copy of value of @a __str.
454 * @param __str Source string.
455 */
456 basic_string(const basic_string& __str)
457 : _M_dataplus(_M_local_data(),
458 _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
459 { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
460
461 // _GLIBCXX_RESOLVE_LIB_DEFECTS
462 // 2583. no way to supply an allocator for basic_string(str, pos)
463 /**
464 * @brief Construct string as copy of a substring.
465 * @param __str Source string.
466 * @param __pos Index of first character to copy from.
467 * @param __a Allocator to use.
468 */
469 basic_string(const basic_string& __str, size_type __pos,
470 const _Alloc& __a = _Alloc())
471 : _M_dataplus(_M_local_data(), __a)
472 {
473 const _CharT* __start = __str._M_data()
474 + __str._M_check(__pos, "basic_string::basic_string");
475 _M_construct(__start, __start + __str._M_limit(__pos, npos));
476 }
477
478 /**
479 * @brief Construct string as copy of a substring.
480 * @param __str Source string.
481 * @param __pos Index of first character to copy from.
482 * @param __n Number of characters to copy.
483 */
484 basic_string(const basic_string& __str, size_type __pos,
485 size_type __n)
486 : _M_dataplus(_M_local_data())
487 {
488 const _CharT* __start = __str._M_data()
489 + __str._M_check(__pos, "basic_string::basic_string");
490 _M_construct(__start, __start + __str._M_limit(__pos, __n));
491 }
492
493 /**
494 * @brief Construct string as copy of a substring.
495 * @param __str Source string.
496 * @param __pos Index of first character to copy from.
497 * @param __n Number of characters to copy.
498 * @param __a Allocator to use.
499 */
500 basic_string(const basic_string& __str, size_type __pos,
501 size_type __n, const _Alloc& __a)
502 : _M_dataplus(_M_local_data(), __a)
503 {
504 const _CharT* __start
505 = __str._M_data() + __str._M_check(__pos, "string::string");
506 _M_construct(__start, __start + __str._M_limit(__pos, __n));
507 }
508
509 /**
510 * @brief Construct string initialized by a character %array.
511 * @param __s Source character %array.
512 * @param __n Number of characters to copy.
513 * @param __a Allocator to use (default is default allocator).
514 *
515 * NB: @a __s must have at least @a __n characters, &apos;\\0&apos;
516 * has no special meaning.
517 */
518 basic_string(const _CharT* __s, size_type __n,
519 const _Alloc& __a = _Alloc())
520 : _M_dataplus(_M_local_data(), __a)
521 { _M_construct(__s, __s + __n); }
522
523 /**
524 * @brief Construct string as copy of a C string.
525 * @param __s Source C string.
526 * @param __a Allocator to use (default is default allocator).
527 */
528#if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
529 // _GLIBCXX_RESOLVE_LIB_DEFECTS
530 // 3076. basic_string CTAD ambiguity
531 template<typename = _RequireAllocator<_Alloc>>
532#endif
533 basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
534 : _M_dataplus(_M_local_data(), __a)
535 {
536 const _CharT* __end = __s ? __s + traits_type::length(__s)
537 // We just need a non-null pointer here to get an exception:
538 : reinterpret_cast<const _CharT*>(__alignof__(_CharT));
539 _M_construct(__s, __end, random_access_iterator_tag());
540 }
541
542 /**
543 * @brief Construct string as multiple characters.
544 * @param __n Number of characters.
545 * @param __c Character to use.
546 * @param __a Allocator to use (default is default allocator).
547 */
548#if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
549 // _GLIBCXX_RESOLVE_LIB_DEFECTS
550 // 3076. basic_string CTAD ambiguity
551 template<typename = _RequireAllocator<_Alloc>>
552#endif
553 basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
554 : _M_dataplus(_M_local_data(), __a)
555 { _M_construct(__n, __c); }
556
557#if __cplusplus >= 201103L
558 /**
559 * @brief Move construct string.
560 * @param __str Source string.
561 *
562 * The newly-created string contains the exact contents of @a __str.
563 * @a __str is a valid, but unspecified string.
564 */
565 basic_string(basic_string&& __str) noexcept
566 : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
567 {
568 if (__str._M_is_local())
569 {
570 traits_type::copy(_M_local_buf, __str._M_local_buf,
571 _S_local_capacity + 1);
572 }
573 else
574 {
575 _M_data(__str._M_data());
576 _M_capacity(capacity: __str._M_allocated_capacity);
577 }
578
579 // Must use _M_length() here not _M_set_length() because
580 // basic_stringbuf relies on writing into unallocated capacity so
581 // we mess up the contents if we put a '\0' in the string.
582 _M_length(length: __str.length());
583 __str._M_data(__str._M_local_data());
584 __str._M_set_length(0);
585 }
586
587 /**
588 * @brief Construct string from an initializer %list.
589 * @param __l std::initializer_list of characters.
590 * @param __a Allocator to use (default is default allocator).
591 */
592 basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
593 : _M_dataplus(_M_local_data(), __a)
594 { _M_construct(__l.begin(), __l.end()); }
595
596 basic_string(const basic_string& __str, const _Alloc& __a)
597 : _M_dataplus(_M_local_data(), __a)
598 { _M_construct(__str.begin(), __str.end()); }
599
600 basic_string(basic_string&& __str, const _Alloc& __a)
601 noexcept(_Alloc_traits::_S_always_equal())
602 : _M_dataplus(_M_local_data(), __a)
603 {
604 if (__str._M_is_local())
605 {
606 traits_type::copy(_M_local_buf, __str._M_local_buf,
607 _S_local_capacity + 1);
608 _M_length(length: __str.length());
609 __str._M_set_length(0);
610 }
611 else if (_Alloc_traits::_S_always_equal()
612 || __str.get_allocator() == __a)
613 {
614 _M_data(__str._M_data());
615 _M_length(length: __str.length());
616 _M_capacity(capacity: __str._M_allocated_capacity);
617 __str._M_data(__str._M_local_buf);
618 __str._M_set_length(0);
619 }
620 else
621 _M_construct(__str.begin(), __str.end());
622 }
623
624#endif // C++11
625
626 /**
627 * @brief Construct string as copy of a range.
628 * @param __beg Start of range.
629 * @param __end End of range.
630 * @param __a Allocator to use (default is default allocator).
631 */
632#if __cplusplus >= 201103L
633 template<typename _InputIterator,
634 typename = std::_RequireInputIter<_InputIterator>>
635#else
636 template<typename _InputIterator>
637#endif
638 basic_string(_InputIterator __beg, _InputIterator __end,
639 const _Alloc& __a = _Alloc())
640 : _M_dataplus(_M_local_data(), __a)
641 { _M_construct(__beg, __end); }
642
643#if __cplusplus >= 201703L
644 /**
645 * @brief Construct string from a substring of a string_view.
646 * @param __t Source object convertible to string view.
647 * @param __pos The index of the first character to copy from __t.
648 * @param __n The number of characters to copy from __t.
649 * @param __a Allocator to use.
650 */
651 template<typename _Tp,
652 typename = enable_if_t<is_convertible_v<const _Tp&, __sv_type>>>
653 basic_string(const _Tp& __t, size_type __pos, size_type __n,
654 const _Alloc& __a = _Alloc())
655 : basic_string(_S_to_string_view(svt: __t).substr(__pos, __n), __a) { }
656
657 /**
658 * @brief Construct string from a string_view.
659 * @param __t Source object convertible to string view.
660 * @param __a Allocator to use (default is default allocator).
661 */
662 template<typename _Tp, typename = _If_sv<_Tp, void>>
663 explicit
664 basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
665 : basic_string(__sv_wrapper(_S_to_string_view(svt: __t)), __a) { }
666#endif // C++17
667
668 /**
669 * @brief Destroy the string instance.
670 */
671 ~basic_string()
672 { _M_dispose(); }
673
674 /**
675 * @brief Assign the value of @a str to this string.
676 * @param __str Source string.
677 */
678 basic_string&
679 operator=(const basic_string& __str)
680 {
681 return this->assign(__str);
682 }
683
684 /**
685 * @brief Copy contents of @a s into this string.
686 * @param __s Source null-terminated string.
687 */
688 basic_string&
689 operator=(const _CharT* __s)
690 { return this->assign(__s); }
691
692 /**
693 * @brief Set value to string of length 1.
694 * @param __c Source character.
695 *
696 * Assigning to a character makes this string length 1 and
697 * (*this)[0] == @a c.
698 */
699 basic_string&
700 operator=(_CharT __c)
701 {
702 this->assign(1, __c);
703 return *this;
704 }
705
706#if __cplusplus >= 201103L
707 /**
708 * @brief Move assign the value of @a str to this string.
709 * @param __str Source string.
710 *
711 * The contents of @a str are moved into this string (without copying).
712 * @a str is a valid, but unspecified string.
713 */
714 // _GLIBCXX_RESOLVE_LIB_DEFECTS
715 // 2063. Contradictory requirements for string move assignment
716 basic_string&
717 operator=(basic_string&& __str)
718 noexcept(_Alloc_traits::_S_nothrow_move())
719 {
720 if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
721 && !_Alloc_traits::_S_always_equal()
722 && _M_get_allocator() != __str._M_get_allocator())
723 {
724 // Destroy existing storage before replacing allocator.
725 _M_destroy(size: _M_allocated_capacity);
726 _M_data(_M_local_data());
727 _M_set_length(n: 0);
728 }
729 // Replace allocator if POCMA is true.
730 std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
731
732 if (__str._M_is_local())
733 {
734 // We've always got room for a short string, just copy it
735 // (unless this is a self-move, because that would violate the
736 // char_traits::copy precondition that the ranges don't overlap).
737 if (__builtin_expect(std::__addressof(__str) != this, true))
738 {
739 if (__str.size())
740 this->_S_copy(_M_data(), __str._M_data(), __str.size());
741 _M_set_length(n: __str.size());
742 }
743 }
744 else if (_Alloc_traits::_S_propagate_on_move_assign()
745 || _Alloc_traits::_S_always_equal()
746 || _M_get_allocator() == __str._M_get_allocator())
747 {
748 // Just move the allocated pointer, our allocator can free it.
749 pointer __data = nullptr;
750 size_type __capacity;
751 if (!_M_is_local())
752 {
753 if (_Alloc_traits::_S_always_equal())
754 {
755 // __str can reuse our existing storage.
756 __data = _M_data();
757 __capacity = _M_allocated_capacity;
758 }
759 else // __str can't use it, so free it.
760 _M_destroy(size: _M_allocated_capacity);
761 }
762
763 _M_data(__str._M_data());
764 _M_length(length: __str.length());
765 _M_capacity(capacity: __str._M_allocated_capacity);
766 if (__data)
767 {
768 __str._M_data(__data);
769 __str._M_capacity(__capacity);
770 }
771 else
772 __str._M_data(__str._M_local_buf);
773 }
774 else // Need to do a deep copy
775 assign(__str);
776 __str.clear();
777 return *this;
778 }
779
780 /**
781 * @brief Set value to string constructed from initializer %list.
782 * @param __l std::initializer_list.
783 */
784 basic_string&
785 operator=(initializer_list<_CharT> __l)
786 {
787 this->assign(__l.begin(), __l.size());
788 return *this;
789 }
790#endif // C++11
791
792#if __cplusplus >= 201703L
793 /**
794 * @brief Set value to string constructed from a string_view.
795 * @param __svt An object convertible to string_view.
796 */
797 template<typename _Tp>
798 _If_sv<_Tp, basic_string&>
799 operator=(const _Tp& __svt)
800 { return this->assign(__svt); }
801
802 /**
803 * @brief Convert to a string_view.
804 * @return A string_view.
805 */
806 operator __sv_type() const noexcept
807 { return __sv_type(data(), size()); }
808#endif // C++17
809
810 // Iterators:
811 /**
812 * Returns a read/write iterator that points to the first character in
813 * the %string.
814 */
815 iterator
816 begin() _GLIBCXX_NOEXCEPT
817 { return iterator(_M_data()); }
818
819 /**
820 * Returns a read-only (constant) iterator that points to the first
821 * character in the %string.
822 */
823 const_iterator
824 begin() const _GLIBCXX_NOEXCEPT
825 { return const_iterator(_M_data()); }
826
827 /**
828 * Returns a read/write iterator that points one past the last
829 * character in the %string.
830 */
831 iterator
832 end() _GLIBCXX_NOEXCEPT
833 { return iterator(_M_data() + this->size()); }
834
835 /**
836 * Returns a read-only (constant) iterator that points one past the
837 * last character in the %string.
838 */
839 const_iterator
840 end() const _GLIBCXX_NOEXCEPT
841 { return const_iterator(_M_data() + this->size()); }
842
843 /**
844 * Returns a read/write reverse iterator that points to the last
845 * character in the %string. Iteration is done in reverse element
846 * order.
847 */
848 reverse_iterator
849 rbegin() _GLIBCXX_NOEXCEPT
850 { return reverse_iterator(this->end()); }
851
852 /**
853 * Returns a read-only (constant) reverse iterator that points
854 * to the last character in the %string. Iteration is done in
855 * reverse element order.
856 */
857 const_reverse_iterator
858 rbegin() const _GLIBCXX_NOEXCEPT
859 { return const_reverse_iterator(this->end()); }
860
861 /**
862 * Returns a read/write reverse iterator that points to one before the
863 * first character in the %string. Iteration is done in reverse
864 * element order.
865 */
866 reverse_iterator
867 rend() _GLIBCXX_NOEXCEPT
868 { return reverse_iterator(this->begin()); }
869
870 /**
871 * Returns a read-only (constant) reverse iterator that points
872 * to one before the first character in the %string. Iteration
873 * is done in reverse element order.
874 */
875 const_reverse_iterator
876 rend() const _GLIBCXX_NOEXCEPT
877 { return const_reverse_iterator(this->begin()); }
878
879#if __cplusplus >= 201103L
880 /**
881 * Returns a read-only (constant) iterator that points to the first
882 * character in the %string.
883 */
884 const_iterator
885 cbegin() const noexcept
886 { return const_iterator(this->_M_data()); }
887
888 /**
889 * Returns a read-only (constant) iterator that points one past the
890 * last character in the %string.
891 */
892 const_iterator
893 cend() const noexcept
894 { return const_iterator(this->_M_data() + this->size()); }
895
896 /**
897 * Returns a read-only (constant) reverse iterator that points
898 * to the last character in the %string. Iteration is done in
899 * reverse element order.
900 */
901 const_reverse_iterator
902 crbegin() const noexcept
903 { return const_reverse_iterator(this->end()); }
904
905 /**
906 * Returns a read-only (constant) reverse iterator that points
907 * to one before the first character in the %string. Iteration
908 * is done in reverse element order.
909 */
910 const_reverse_iterator
911 crend() const noexcept
912 { return const_reverse_iterator(this->begin()); }
913#endif
914
915 public:
916 // Capacity:
917 /// Returns the number of characters in the string, not including any
918 /// null-termination.
919 size_type
920 size() const _GLIBCXX_NOEXCEPT
921 { return _M_string_length; }
922
923 /// Returns the number of characters in the string, not including any
924 /// null-termination.
925 size_type
926 length() const _GLIBCXX_NOEXCEPT
927 { return _M_string_length; }
928
929 /// Returns the size() of the largest possible %string.
930 size_type
931 max_size() const _GLIBCXX_NOEXCEPT
932 { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
933
934 /**
935 * @brief Resizes the %string to the specified number of characters.
936 * @param __n Number of characters the %string should contain.
937 * @param __c Character to fill any new elements.
938 *
939 * This function will %resize the %string to the specified
940 * number of characters. If the number is smaller than the
941 * %string's current size the %string is truncated, otherwise
942 * the %string is extended and new elements are %set to @a __c.
943 */
944 void
945 resize(size_type __n, _CharT __c);
946
947 /**
948 * @brief Resizes the %string to the specified number of characters.
949 * @param __n Number of characters the %string should contain.
950 *
951 * This function will resize the %string to the specified length. If
952 * the new size is smaller than the %string's current size the %string
953 * is truncated, otherwise the %string is extended and new characters
954 * are default-constructed. For basic types such as char, this means
955 * setting them to 0.
956 */
957 void
958 resize(size_type __n)
959 { this->resize(__n, _CharT()); }
960
961#if __cplusplus >= 201103L
962#pragma GCC diagnostic push
963#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
964 /// A non-binding request to reduce capacity() to size().
965 void
966 shrink_to_fit() noexcept
967 { reserve(); }
968#pragma GCC diagnostic pop
969#endif
970
971 /**
972 * Returns the total number of characters that the %string can hold
973 * before needing to allocate more memory.
974 */
975 size_type
976 capacity() const _GLIBCXX_NOEXCEPT
977 {
978 return _M_is_local() ? size_type(_S_local_capacity)
979 : _M_allocated_capacity;
980 }
981
982 /**
983 * @brief Attempt to preallocate enough memory for specified number of
984 * characters.
985 * @param __res_arg Number of characters required.
986 * @throw std::length_error If @a __res_arg exceeds @c max_size().
987 *
988 * This function attempts to reserve enough memory for the
989 * %string to hold the specified number of characters. If the
990 * number requested is more than max_size(), length_error is
991 * thrown.
992 *
993 * The advantage of this function is that if optimal code is a
994 * necessity and the user can determine the string length that will be
995 * required, the user can reserve the memory in %advance, and thus
996 * prevent a possible reallocation of memory and copying of %string
997 * data.
998 */
999 void
1000 reserve(size_type __res_arg);
1001
1002 /**
1003 * Equivalent to shrink_to_fit().
1004 */
1005#if __cplusplus > 201703L
1006 [[deprecated("use shrink_to_fit() instead")]]
1007#endif
1008 void
1009 reserve();
1010
1011 /**
1012 * Erases the string, making it empty.
1013 */
1014 void
1015 clear() _GLIBCXX_NOEXCEPT
1016 { _M_set_length(n: 0); }
1017
1018 /**
1019 * Returns true if the %string is empty. Equivalent to
1020 * <code>*this == ""</code>.
1021 */
1022 _GLIBCXX_NODISCARD bool
1023 empty() const _GLIBCXX_NOEXCEPT
1024 { return this->size() == 0; }
1025
1026 // Element access:
1027 /**
1028 * @brief Subscript access to the data contained in the %string.
1029 * @param __pos The index of the character to access.
1030 * @return Read-only (constant) reference to the character.
1031 *
1032 * This operator allows for easy, array-style, data access.
1033 * Note that data access with this operator is unchecked and
1034 * out_of_range lookups are not defined. (For checked lookups
1035 * see at().)
1036 */
1037 const_reference
1038 operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
1039 {
1040 __glibcxx_assert(__pos <= size());
1041 return _M_data()[__pos];
1042 }
1043
1044 /**
1045 * @brief Subscript access to the data contained in the %string.
1046 * @param __pos The index of the character to access.
1047 * @return Read/write reference to the character.
1048 *
1049 * This operator allows for easy, array-style, data access.
1050 * Note that data access with this operator is unchecked and
1051 * out_of_range lookups are not defined. (For checked lookups
1052 * see at().)
1053 */
1054 reference
1055 operator[](size_type __pos)
1056 {
1057 // Allow pos == size() both in C++98 mode, as v3 extension,
1058 // and in C++11 mode.
1059 __glibcxx_assert(__pos <= size());
1060 // In pedantic mode be strict in C++98 mode.
1061 _GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size());
1062 return _M_data()[__pos];
1063 }
1064
1065 /**
1066 * @brief Provides access to the data contained in the %string.
1067 * @param __n The index of the character to access.
1068 * @return Read-only (const) reference to the character.
1069 * @throw std::out_of_range If @a n is an invalid index.
1070 *
1071 * This function provides for safer data access. The parameter is
1072 * first checked that it is in the range of the string. The function
1073 * throws out_of_range if the check fails.
1074 */
1075 const_reference
1076 at(size_type __n) const
1077 {
1078 if (__n >= this->size())
1079 __throw_out_of_range_fmt(__N("basic_string::at: __n "
1080 "(which is %zu) >= this->size() "
1081 "(which is %zu)"),
1082 __n, this->size());
1083 return _M_data()[__n];
1084 }
1085
1086 /**
1087 * @brief Provides access to the data contained in the %string.
1088 * @param __n The index of the character to access.
1089 * @return Read/write reference to the character.
1090 * @throw std::out_of_range If @a n is an invalid index.
1091 *
1092 * This function provides for safer data access. The parameter is
1093 * first checked that it is in the range of the string. The function
1094 * throws out_of_range if the check fails.
1095 */
1096 reference
1097 at(size_type __n)
1098 {
1099 if (__n >= size())
1100 __throw_out_of_range_fmt(__N("basic_string::at: __n "
1101 "(which is %zu) >= this->size() "
1102 "(which is %zu)"),
1103 __n, this->size());
1104 return _M_data()[__n];
1105 }
1106
1107#if __cplusplus >= 201103L
1108 /**
1109 * Returns a read/write reference to the data at the first
1110 * element of the %string.
1111 */
1112 reference
1113 front() noexcept
1114 {
1115 __glibcxx_assert(!empty());
1116 return operator[](0);
1117 }
1118
1119 /**
1120 * Returns a read-only (constant) reference to the data at the first
1121 * element of the %string.
1122 */
1123 const_reference
1124 front() const noexcept
1125 {
1126 __glibcxx_assert(!empty());
1127 return operator[](0);
1128 }
1129
1130 /**
1131 * Returns a read/write reference to the data at the last
1132 * element of the %string.
1133 */
1134 reference
1135 back() noexcept
1136 {
1137 __glibcxx_assert(!empty());
1138 return operator[](this->size() - 1);
1139 }
1140
1141 /**
1142 * Returns a read-only (constant) reference to the data at the
1143 * last element of the %string.
1144 */
1145 const_reference
1146 back() const noexcept
1147 {
1148 __glibcxx_assert(!empty());
1149 return operator[](this->size() - 1);
1150 }
1151#endif
1152
1153 // Modifiers:
1154 /**
1155 * @brief Append a string to this string.
1156 * @param __str The string to append.
1157 * @return Reference to this string.
1158 */
1159 basic_string&
1160 operator+=(const basic_string& __str)
1161 { return this->append(__str); }
1162
1163 /**
1164 * @brief Append a C string.
1165 * @param __s The C string to append.
1166 * @return Reference to this string.
1167 */
1168 basic_string&
1169 operator+=(const _CharT* __s)
1170 { return this->append(__s); }
1171
1172 /**
1173 * @brief Append a character.
1174 * @param __c The character to append.
1175 * @return Reference to this string.
1176 */
1177 basic_string&
1178 operator+=(_CharT __c)
1179 {
1180 this->push_back(__c);
1181 return *this;
1182 }
1183
1184#if __cplusplus >= 201103L
1185 /**
1186 * @brief Append an initializer_list of characters.
1187 * @param __l The initializer_list of characters to be appended.
1188 * @return Reference to this string.
1189 */
1190 basic_string&
1191 operator+=(initializer_list<_CharT> __l)
1192 { return this->append(__l.begin(), __l.size()); }
1193#endif // C++11
1194
1195#if __cplusplus >= 201703L
1196 /**
1197 * @brief Append a string_view.
1198 * @param __svt An object convertible to string_view to be appended.
1199 * @return Reference to this string.
1200 */
1201 template<typename _Tp>
1202 _If_sv<_Tp, basic_string&>
1203 operator+=(const _Tp& __svt)
1204 { return this->append(__svt); }
1205#endif // C++17
1206
1207 /**
1208 * @brief Append a string to this string.
1209 * @param __str The string to append.
1210 * @return Reference to this string.
1211 */
1212 basic_string&
1213 append(const basic_string& __str)
1214 { return _M_append(s: __str._M_data(), n: __str.size()); }
1215
1216 /**
1217 * @brief Append a substring.
1218 * @param __str The string to append.
1219 * @param __pos Index of the first character of str to append.
1220 * @param __n The number of characters to append.
1221 * @return Reference to this string.
1222 * @throw std::out_of_range if @a __pos is not a valid index.
1223 *
1224 * This function appends @a __n characters from @a __str
1225 * starting at @a __pos to this string. If @a __n is is larger
1226 * than the number of available characters in @a __str, the
1227 * remainder of @a __str is appended.
1228 */
1229 basic_string&
1230 append(const basic_string& __str, size_type __pos, size_type __n = npos)
1231 { return _M_append(s: __str._M_data()
1232 + __str._M_check(__pos, "basic_string::append"),
1233 n: __str._M_limit(__pos, __n)); }
1234
1235 /**
1236 * @brief Append a C substring.
1237 * @param __s The C string to append.
1238 * @param __n The number of characters to append.
1239 * @return Reference to this string.
1240 */
1241 basic_string&
1242 append(const _CharT* __s, size_type __n)
1243 {
1244 __glibcxx_requires_string_len(__s, __n);
1245 _M_check_length(n1: size_type(0), n2: __n, s: "basic_string::append");
1246 return _M_append(__s, __n);
1247 }
1248
1249 /**
1250 * @brief Append a C string.
1251 * @param __s The C string to append.
1252 * @return Reference to this string.
1253 */
1254 basic_string&
1255 append(const _CharT* __s)
1256 {
1257 __glibcxx_requires_string(__s);
1258 const size_type __n = traits_type::length(__s);
1259 _M_check_length(n1: size_type(0), n2: __n, s: "basic_string::append");
1260 return _M_append(__s, __n);
1261 }
1262
1263 /**
1264 * @brief Append multiple characters.
1265 * @param __n The number of characters to append.
1266 * @param __c The character to use.
1267 * @return Reference to this string.
1268 *
1269 * Appends __n copies of __c to this string.
1270 */
1271 basic_string&
1272 append(size_type __n, _CharT __c)
1273 { return _M_replace_aux(pos1: this->size(), n1: size_type(0), n2: __n, __c); }
1274
1275#if __cplusplus >= 201103L
1276 /**
1277 * @brief Append an initializer_list of characters.
1278 * @param __l The initializer_list of characters to append.
1279 * @return Reference to this string.
1280 */
1281 basic_string&
1282 append(initializer_list<_CharT> __l)
1283 { return this->append(__l.begin(), __l.size()); }
1284#endif // C++11
1285
1286 /**
1287 * @brief Append a range of characters.
1288 * @param __first Iterator referencing the first character to append.
1289 * @param __last Iterator marking the end of the range.
1290 * @return Reference to this string.
1291 *
1292 * Appends characters in the range [__first,__last) to this string.
1293 */
1294#if __cplusplus >= 201103L
1295 template<class _InputIterator,
1296 typename = std::_RequireInputIter<_InputIterator>>
1297#else
1298 template<class _InputIterator>
1299#endif
1300 basic_string&
1301 append(_InputIterator __first, _InputIterator __last)
1302 { return this->replace(end(), end(), __first, __last); }
1303
1304#if __cplusplus >= 201703L
1305 /**
1306 * @brief Append a string_view.
1307 * @param __svt An object convertible to string_view to be appended.
1308 * @return Reference to this string.
1309 */
1310 template<typename _Tp>
1311 _If_sv<_Tp, basic_string&>
1312 append(const _Tp& __svt)
1313 {
1314 __sv_type __sv = __svt;
1315 return this->append(__sv.data(), __sv.size());
1316 }
1317
1318 /**
1319 * @brief Append a range of characters from a string_view.
1320 * @param __svt An object convertible to string_view to be appended from.
1321 * @param __pos The position in the string_view to append from.
1322 * @param __n The number of characters to append from the string_view.
1323 * @return Reference to this string.
1324 */
1325 template<typename _Tp>
1326 _If_sv<_Tp, basic_string&>
1327 append(const _Tp& __svt, size_type __pos, size_type __n = npos)
1328 {
1329 __sv_type __sv = __svt;
1330 return _M_append(s: __sv.data()
1331 + std::__sv_check(size: __sv.size(), __pos, s: "basic_string::append"),
1332 n: std::__sv_limit(size: __sv.size(), __pos, off: __n));
1333 }
1334#endif // C++17
1335
1336 /**
1337 * @brief Append a single character.
1338 * @param __c Character to append.
1339 */
1340 void
1341 push_back(_CharT __c)
1342 {
1343 const size_type __size = this->size();
1344 if (__size + 1 > this->capacity())
1345 this->_M_mutate(__size, size_type(0), 0, size_type(1));
1346 traits_type::assign(this->_M_data()[__size], __c);
1347 this->_M_set_length(__size + 1);
1348 }
1349
1350 /**
1351 * @brief Set value to contents of another string.
1352 * @param __str Source string to use.
1353 * @return Reference to this string.
1354 */
1355 basic_string&
1356 assign(const basic_string& __str)
1357 {
1358#if __cplusplus >= 201103L
1359 if (_Alloc_traits::_S_propagate_on_copy_assign())
1360 {
1361 if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
1362 && _M_get_allocator() != __str._M_get_allocator())
1363 {
1364 // Propagating allocator cannot free existing storage so must
1365 // deallocate it before replacing current allocator.
1366 if (__str.size() <= _S_local_capacity)
1367 {
1368 _M_destroy(size: _M_allocated_capacity);
1369 _M_data(_M_local_data());
1370 _M_set_length(n: 0);
1371 }
1372 else
1373 {
1374 const auto __len = __str.size();
1375 auto __alloc = __str._M_get_allocator();
1376 // If this allocation throws there are no effects:
1377 auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1);
1378 _M_destroy(size: _M_allocated_capacity);
1379 _M_data(__ptr);
1380 _M_capacity(capacity: __len);
1381 _M_set_length(n: __len);
1382 }
1383 }
1384 std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
1385 }
1386#endif
1387 this->_M_assign(__str);
1388 return *this;
1389 }
1390
1391#if __cplusplus >= 201103L
1392 /**
1393 * @brief Set value to contents of another string.
1394 * @param __str Source string to use.
1395 * @return Reference to this string.
1396 *
1397 * This function sets this string to the exact contents of @a __str.
1398 * @a __str is a valid, but unspecified string.
1399 */
1400 basic_string&
1401 assign(basic_string&& __str)
1402 noexcept(_Alloc_traits::_S_nothrow_move())
1403 {
1404 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1405 // 2063. Contradictory requirements for string move assignment
1406 return *this = std::move(__str);
1407 }
1408#endif // C++11
1409
1410 /**
1411 * @brief Set value to a substring of a string.
1412 * @param __str The string to use.
1413 * @param __pos Index of the first character of str.
1414 * @param __n Number of characters to use.
1415 * @return Reference to this string.
1416 * @throw std::out_of_range if @a pos is not a valid index.
1417 *
1418 * This function sets this string to the substring of @a __str
1419 * consisting of @a __n characters at @a __pos. If @a __n is
1420 * is larger than the number of available characters in @a
1421 * __str, the remainder of @a __str is used.
1422 */
1423 basic_string&
1424 assign(const basic_string& __str, size_type __pos, size_type __n = npos)
1425 { return _M_replace(pos: size_type(0), len1: this->size(), s: __str._M_data()
1426 + __str._M_check(__pos, "basic_string::assign"),
1427 len2: __str._M_limit(__pos, __n)); }
1428
1429 /**
1430 * @brief Set value to a C substring.
1431 * @param __s The C string to use.
1432 * @param __n Number of characters to use.
1433 * @return Reference to this string.
1434 *
1435 * This function sets the value of this string to the first @a __n
1436 * characters of @a __s. If @a __n is is larger than the number of
1437 * available characters in @a __s, the remainder of @a __s is used.
1438 */
1439 basic_string&
1440 assign(const _CharT* __s, size_type __n)
1441 {
1442 __glibcxx_requires_string_len(__s, __n);
1443 return _M_replace(pos: size_type(0), len1: this->size(), __s, len2: __n);
1444 }
1445
1446 /**
1447 * @brief Set value to contents of a C string.
1448 * @param __s The C string to use.
1449 * @return Reference to this string.
1450 *
1451 * This function sets the value of this string to the value of @a __s.
1452 * The data is copied, so there is no dependence on @a __s once the
1453 * function returns.
1454 */
1455 basic_string&
1456 assign(const _CharT* __s)
1457 {
1458 __glibcxx_requires_string(__s);
1459 return _M_replace(pos: size_type(0), len1: this->size(), __s,
1460 len2: traits_type::length(__s));
1461 }
1462
1463 /**
1464 * @brief Set value to multiple characters.
1465 * @param __n Length of the resulting string.
1466 * @param __c The character to use.
1467 * @return Reference to this string.
1468 *
1469 * This function sets the value of this string to @a __n copies of
1470 * character @a __c.
1471 */
1472 basic_string&
1473 assign(size_type __n, _CharT __c)
1474 { return _M_replace_aux(pos1: size_type(0), n1: this->size(), n2: __n, __c); }
1475
1476 /**
1477 * @brief Set value to a range of characters.
1478 * @param __first Iterator referencing the first character to append.
1479 * @param __last Iterator marking the end of the range.
1480 * @return Reference to this string.
1481 *
1482 * Sets value of string to characters in the range [__first,__last).
1483 */
1484#if __cplusplus >= 201103L
1485 template<class _InputIterator,
1486 typename = std::_RequireInputIter<_InputIterator>>
1487#else
1488 template<class _InputIterator>
1489#endif
1490 basic_string&
1491 assign(_InputIterator __first, _InputIterator __last)
1492 { return this->replace(begin(), end(), __first, __last); }
1493
1494#if __cplusplus >= 201103L
1495 /**
1496 * @brief Set value to an initializer_list of characters.
1497 * @param __l The initializer_list of characters to assign.
1498 * @return Reference to this string.
1499 */
1500 basic_string&
1501 assign(initializer_list<_CharT> __l)
1502 { return this->assign(__l.begin(), __l.size()); }
1503#endif // C++11
1504
1505#if __cplusplus >= 201703L
1506 /**
1507 * @brief Set value from a string_view.
1508 * @param __svt The source object convertible to string_view.
1509 * @return Reference to this string.
1510 */
1511 template<typename _Tp>
1512 _If_sv<_Tp, basic_string&>
1513 assign(const _Tp& __svt)
1514 {
1515 __sv_type __sv = __svt;
1516 return this->assign(__sv.data(), __sv.size());
1517 }
1518
1519 /**
1520 * @brief Set value from a range of characters in a string_view.
1521 * @param __svt The source object convertible to string_view.
1522 * @param __pos The position in the string_view to assign from.
1523 * @param __n The number of characters to assign.
1524 * @return Reference to this string.
1525 */
1526 template<typename _Tp>
1527 _If_sv<_Tp, basic_string&>
1528 assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
1529 {
1530 __sv_type __sv = __svt;
1531 return _M_replace(pos: size_type(0), len1: this->size(),
1532 s: __sv.data()
1533 + std::__sv_check(size: __sv.size(), __pos, s: "basic_string::assign"),
1534 len2: std::__sv_limit(size: __sv.size(), __pos, off: __n));
1535 }
1536#endif // C++17
1537
1538#if __cplusplus >= 201103L
1539 /**
1540 * @brief Insert multiple characters.
1541 * @param __p Const_iterator referencing location in string to
1542 * insert at.
1543 * @param __n Number of characters to insert
1544 * @param __c The character to insert.
1545 * @return Iterator referencing the first inserted char.
1546 * @throw std::length_error If new length exceeds @c max_size().
1547 *
1548 * Inserts @a __n copies of character @a __c starting at the
1549 * position referenced by iterator @a __p. If adding
1550 * characters causes the length to exceed max_size(),
1551 * length_error is thrown. The value of the string doesn't
1552 * change if an error is thrown.
1553 */
1554 iterator
1555 insert(const_iterator __p, size_type __n, _CharT __c)
1556 {
1557 _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1558 const size_type __pos = __p - begin();
1559 this->replace(__p, __p, __n, __c);
1560 return iterator(this->_M_data() + __pos);
1561 }
1562#else
1563 /**
1564 * @brief Insert multiple characters.
1565 * @param __p Iterator referencing location in string to insert at.
1566 * @param __n Number of characters to insert
1567 * @param __c The character to insert.
1568 * @throw std::length_error If new length exceeds @c max_size().
1569 *
1570 * Inserts @a __n copies of character @a __c starting at the
1571 * position referenced by iterator @a __p. If adding
1572 * characters causes the length to exceed max_size(),
1573 * length_error is thrown. The value of the string doesn't
1574 * change if an error is thrown.
1575 */
1576 void
1577 insert(iterator __p, size_type __n, _CharT __c)
1578 { this->replace(__p, __p, __n, __c); }
1579#endif
1580
1581#if __cplusplus >= 201103L
1582 /**
1583 * @brief Insert a range of characters.
1584 * @param __p Const_iterator referencing location in string to
1585 * insert at.
1586 * @param __beg Start of range.
1587 * @param __end End of range.
1588 * @return Iterator referencing the first inserted char.
1589 * @throw std::length_error If new length exceeds @c max_size().
1590 *
1591 * Inserts characters in range [beg,end). If adding characters
1592 * causes the length to exceed max_size(), length_error is
1593 * thrown. The value of the string doesn't change if an error
1594 * is thrown.
1595 */
1596 template<class _InputIterator,
1597 typename = std::_RequireInputIter<_InputIterator>>
1598 iterator
1599 insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
1600 {
1601 _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1602 const size_type __pos = __p - begin();
1603 this->replace(__p, __p, __beg, __end);
1604 return iterator(this->_M_data() + __pos);
1605 }
1606#else
1607 /**
1608 * @brief Insert a range of characters.
1609 * @param __p Iterator referencing location in string to insert at.
1610 * @param __beg Start of range.
1611 * @param __end End of range.
1612 * @throw std::length_error If new length exceeds @c max_size().
1613 *
1614 * Inserts characters in range [__beg,__end). If adding
1615 * characters causes the length to exceed max_size(),
1616 * length_error is thrown. The value of the string doesn't
1617 * change if an error is thrown.
1618 */
1619 template<class _InputIterator>
1620 void
1621 insert(iterator __p, _InputIterator __beg, _InputIterator __end)
1622 { this->replace(__p, __p, __beg, __end); }
1623#endif
1624
1625#if __cplusplus >= 201103L
1626 /**
1627 * @brief Insert an initializer_list of characters.
1628 * @param __p Iterator referencing location in string to insert at.
1629 * @param __l The initializer_list of characters to insert.
1630 * @throw std::length_error If new length exceeds @c max_size().
1631 */
1632 iterator
1633 insert(const_iterator __p, initializer_list<_CharT> __l)
1634 { return this->insert(__p, __l.begin(), __l.end()); }
1635
1636#ifdef _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
1637 // See PR libstdc++/83328
1638 void
1639 insert(iterator __p, initializer_list<_CharT> __l)
1640 {
1641 _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1642 this->insert(__p - begin(), __l.begin(), __l.size());
1643 }
1644#endif
1645#endif // C++11
1646
1647 /**
1648 * @brief Insert value of a string.
1649 * @param __pos1 Position in string to insert at.
1650 * @param __str The string to insert.
1651 * @return Reference to this string.
1652 * @throw std::length_error If new length exceeds @c max_size().
1653 *
1654 * Inserts value of @a __str starting at @a __pos1. If adding
1655 * characters causes the length to exceed max_size(),
1656 * length_error is thrown. The value of the string doesn't
1657 * change if an error is thrown.
1658 */
1659 basic_string&
1660 insert(size_type __pos1, const basic_string& __str)
1661 { return this->replace(__pos1, size_type(0),
1662 __str._M_data(), __str.size()); }
1663
1664 /**
1665 * @brief Insert a substring.
1666 * @param __pos1 Position in string to insert at.
1667 * @param __str The string to insert.
1668 * @param __pos2 Start of characters in str to insert.
1669 * @param __n Number of characters to insert.
1670 * @return Reference to this string.
1671 * @throw std::length_error If new length exceeds @c max_size().
1672 * @throw std::out_of_range If @a pos1 > size() or
1673 * @a __pos2 > @a str.size().
1674 *
1675 * Starting at @a pos1, insert @a __n character of @a __str
1676 * beginning with @a __pos2. If adding characters causes the
1677 * length to exceed max_size(), length_error is thrown. If @a
1678 * __pos1 is beyond the end of this string or @a __pos2 is
1679 * beyond the end of @a __str, out_of_range is thrown. The
1680 * value of the string doesn't change if an error is thrown.
1681 */
1682 basic_string&
1683 insert(size_type __pos1, const basic_string& __str,
1684 size_type __pos2, size_type __n = npos)
1685 { return this->replace(__pos1, size_type(0), __str._M_data()
1686 + __str._M_check(__pos2, "basic_string::insert"),
1687 __str._M_limit(__pos2, __n)); }
1688
1689 /**
1690 * @brief Insert a C substring.
1691 * @param __pos Position in string to insert at.
1692 * @param __s The C string to insert.
1693 * @param __n The number of characters to insert.
1694 * @return Reference to this string.
1695 * @throw std::length_error If new length exceeds @c max_size().
1696 * @throw std::out_of_range If @a __pos is beyond the end of this
1697 * string.
1698 *
1699 * Inserts the first @a __n characters of @a __s starting at @a
1700 * __pos. If adding characters causes the length to exceed
1701 * max_size(), length_error is thrown. If @a __pos is beyond
1702 * end(), out_of_range is thrown. The value of the string
1703 * doesn't change if an error is thrown.
1704 */
1705 basic_string&
1706 insert(size_type __pos, const _CharT* __s, size_type __n)
1707 { return this->replace(__pos, size_type(0), __s, __n); }
1708
1709 /**
1710 * @brief Insert a C string.
1711 * @param __pos Position in string to insert at.
1712 * @param __s The C string to insert.
1713 * @return Reference to this string.
1714 * @throw std::length_error If new length exceeds @c max_size().
1715 * @throw std::out_of_range If @a pos is beyond the end of this
1716 * string.
1717 *
1718 * Inserts the first @a n characters of @a __s starting at @a __pos. If
1719 * adding characters causes the length to exceed max_size(),
1720 * length_error is thrown. If @a __pos is beyond end(), out_of_range is
1721 * thrown. The value of the string doesn't change if an error is
1722 * thrown.
1723 */
1724 basic_string&
1725 insert(size_type __pos, const _CharT* __s)
1726 {
1727 __glibcxx_requires_string(__s);
1728 return this->replace(__pos, size_type(0), __s,
1729 traits_type::length(__s));
1730 }
1731
1732 /**
1733 * @brief Insert multiple characters.
1734 * @param __pos Index in string to insert at.
1735 * @param __n Number of characters to insert
1736 * @param __c The character to insert.
1737 * @return Reference to this string.
1738 * @throw std::length_error If new length exceeds @c max_size().
1739 * @throw std::out_of_range If @a __pos is beyond the end of this
1740 * string.
1741 *
1742 * Inserts @a __n copies of character @a __c starting at index
1743 * @a __pos. If adding characters causes the length to exceed
1744 * max_size(), length_error is thrown. If @a __pos > length(),
1745 * out_of_range is thrown. The value of the string doesn't
1746 * change if an error is thrown.
1747 */
1748 basic_string&
1749 insert(size_type __pos, size_type __n, _CharT __c)
1750 { return _M_replace_aux(pos1: _M_check(__pos, s: "basic_string::insert"),
1751 n1: size_type(0), n2: __n, __c); }
1752
1753 /**
1754 * @brief Insert one character.
1755 * @param __p Iterator referencing position in string to insert at.
1756 * @param __c The character to insert.
1757 * @return Iterator referencing newly inserted char.
1758 * @throw std::length_error If new length exceeds @c max_size().
1759 *
1760 * Inserts character @a __c at position referenced by @a __p.
1761 * If adding character causes the length to exceed max_size(),
1762 * length_error is thrown. If @a __p is beyond end of string,
1763 * out_of_range is thrown. The value of the string doesn't
1764 * change if an error is thrown.
1765 */
1766 iterator
1767 insert(__const_iterator __p, _CharT __c)
1768 {
1769 _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1770 const size_type __pos = __p - begin();
1771 _M_replace_aux(pos1: __pos, n1: size_type(0), n2: size_type(1), __c);
1772 return iterator(_M_data() + __pos);
1773 }
1774
1775#if __cplusplus >= 201703L
1776 /**
1777 * @brief Insert a string_view.
1778 * @param __pos Position in string to insert at.
1779 * @param __svt The object convertible to string_view to insert.
1780 * @return Reference to this string.
1781 */
1782 template<typename _Tp>
1783 _If_sv<_Tp, basic_string&>
1784 insert(size_type __pos, const _Tp& __svt)
1785 {
1786 __sv_type __sv = __svt;
1787 return this->insert(__pos, __sv.data(), __sv.size());
1788 }
1789
1790 /**
1791 * @brief Insert a string_view.
1792 * @param __pos1 Position in string to insert at.
1793 * @param __svt The object convertible to string_view to insert from.
1794 * @param __pos2 Start of characters in str to insert.
1795 * @param __n The number of characters to insert.
1796 * @return Reference to this string.
1797 */
1798 template<typename _Tp>
1799 _If_sv<_Tp, basic_string&>
1800 insert(size_type __pos1, const _Tp& __svt,
1801 size_type __pos2, size_type __n = npos)
1802 {
1803 __sv_type __sv = __svt;
1804 return this->replace(__pos1, size_type(0),
1805 __sv.data()
1806 + std::__sv_check(size: __sv.size(), pos: __pos2, s: "basic_string::insert"),
1807 std::__sv_limit(size: __sv.size(), pos: __pos2, off: __n));
1808 }
1809#endif // C++17
1810
1811 /**
1812 * @brief Remove characters.
1813 * @param __pos Index of first character to remove (default 0).
1814 * @param __n Number of characters to remove (default remainder).
1815 * @return Reference to this string.
1816 * @throw std::out_of_range If @a pos is beyond the end of this
1817 * string.
1818 *
1819 * Removes @a __n characters from this string starting at @a
1820 * __pos. The length of the string is reduced by @a __n. If
1821 * there are < @a __n characters to remove, the remainder of
1822 * the string is truncated. If @a __p is beyond end of string,
1823 * out_of_range is thrown. The value of the string doesn't
1824 * change if an error is thrown.
1825 */
1826 basic_string&
1827 erase(size_type __pos = 0, size_type __n = npos)
1828 {
1829 _M_check(__pos, s: "basic_string::erase");
1830 if (__n == npos)
1831 this->_M_set_length(__pos);
1832 else if (__n != 0)
1833 this->_M_erase(__pos, _M_limit(__pos, off: __n));
1834 return *this;
1835 }
1836
1837 /**
1838 * @brief Remove one character.
1839 * @param __position Iterator referencing the character to remove.
1840 * @return iterator referencing same location after removal.
1841 *
1842 * Removes the character at @a __position from this string. The value
1843 * of the string doesn't change if an error is thrown.
1844 */
1845 iterator
1846 erase(__const_iterator __position)
1847 {
1848 _GLIBCXX_DEBUG_PEDASSERT(__position >= begin()
1849 && __position < end());
1850 const size_type __pos = __position - begin();
1851 this->_M_erase(__pos, size_type(1));
1852 return iterator(_M_data() + __pos);
1853 }
1854
1855 /**
1856 * @brief Remove a range of characters.
1857 * @param __first Iterator referencing the first character to remove.
1858 * @param __last Iterator referencing the end of the range.
1859 * @return Iterator referencing location of first after removal.
1860 *
1861 * Removes the characters in the range [first,last) from this string.
1862 * The value of the string doesn't change if an error is thrown.
1863 */
1864 iterator
1865 erase(__const_iterator __first, __const_iterator __last)
1866 {
1867 _GLIBCXX_DEBUG_PEDASSERT(__first >= begin() && __first <= __last
1868 && __last <= end());
1869 const size_type __pos = __first - begin();
1870 if (__last == end())
1871 this->_M_set_length(__pos);
1872 else
1873 this->_M_erase(__pos, __last - __first);
1874 return iterator(this->_M_data() + __pos);
1875 }
1876
1877#if __cplusplus >= 201103L
1878 /**
1879 * @brief Remove the last character.
1880 *
1881 * The string must be non-empty.
1882 */
1883 void
1884 pop_back() noexcept
1885 {
1886 __glibcxx_assert(!empty());
1887 _M_erase(pos: size() - 1, n: 1);
1888 }
1889#endif // C++11
1890
1891 /**
1892 * @brief Replace characters with value from another string.
1893 * @param __pos Index of first character to replace.
1894 * @param __n Number of characters to be replaced.
1895 * @param __str String to insert.
1896 * @return Reference to this string.
1897 * @throw std::out_of_range If @a pos is beyond the end of this
1898 * string.
1899 * @throw std::length_error If new length exceeds @c max_size().
1900 *
1901 * Removes the characters in the range [__pos,__pos+__n) from
1902 * this string. In place, the value of @a __str is inserted.
1903 * If @a __pos is beyond end of string, out_of_range is thrown.
1904 * If the length of the result exceeds max_size(), length_error
1905 * is thrown. The value of the string doesn't change if an
1906 * error is thrown.
1907 */
1908 basic_string&
1909 replace(size_type __pos, size_type __n, const basic_string& __str)
1910 { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
1911
1912 /**
1913 * @brief Replace characters with value from another string.
1914 * @param __pos1 Index of first character to replace.
1915 * @param __n1 Number of characters to be replaced.
1916 * @param __str String to insert.
1917 * @param __pos2 Index of first character of str to use.
1918 * @param __n2 Number of characters from str to use.
1919 * @return Reference to this string.
1920 * @throw std::out_of_range If @a __pos1 > size() or @a __pos2 >
1921 * __str.size().
1922 * @throw std::length_error If new length exceeds @c max_size().
1923 *
1924 * Removes the characters in the range [__pos1,__pos1 + n) from this
1925 * string. In place, the value of @a __str is inserted. If @a __pos is
1926 * beyond end of string, out_of_range is thrown. If the length of the
1927 * result exceeds max_size(), length_error is thrown. The value of the
1928 * string doesn't change if an error is thrown.
1929 */
1930 basic_string&
1931 replace(size_type __pos1, size_type __n1, const basic_string& __str,
1932 size_type __pos2, size_type __n2 = npos)
1933 { return this->replace(__pos1, __n1, __str._M_data()
1934 + __str._M_check(__pos2, "basic_string::replace"),
1935 __str._M_limit(__pos2, __n2)); }
1936
1937 /**
1938 * @brief Replace characters with value of a C substring.
1939 * @param __pos Index of first character to replace.
1940 * @param __n1 Number of characters to be replaced.
1941 * @param __s C string to insert.
1942 * @param __n2 Number of characters from @a s to use.
1943 * @return Reference to this string.
1944 * @throw std::out_of_range If @a pos1 > size().
1945 * @throw std::length_error If new length exceeds @c max_size().
1946 *
1947 * Removes the characters in the range [__pos,__pos + __n1)
1948 * from this string. In place, the first @a __n2 characters of
1949 * @a __s are inserted, or all of @a __s if @a __n2 is too large. If
1950 * @a __pos is beyond end of string, out_of_range is thrown. If
1951 * the length of result exceeds max_size(), length_error is
1952 * thrown. The value of the string doesn't change if an error
1953 * is thrown.
1954 */
1955 basic_string&
1956 replace(size_type __pos, size_type __n1, const _CharT* __s,
1957 size_type __n2)
1958 {
1959 __glibcxx_requires_string_len(__s, __n2);
1960 return _M_replace(pos: _M_check(__pos, s: "basic_string::replace"),
1961 len1: _M_limit(__pos, off: __n1), __s, len2: __n2);
1962 }
1963
1964 /**
1965 * @brief Replace characters with value of a C string.
1966 * @param __pos Index of first character to replace.
1967 * @param __n1 Number of characters to be replaced.
1968 * @param __s C string to insert.
1969 * @return Reference to this string.
1970 * @throw std::out_of_range If @a pos > size().
1971 * @throw std::length_error If new length exceeds @c max_size().
1972 *
1973 * Removes the characters in the range [__pos,__pos + __n1)
1974 * from this string. In place, the characters of @a __s are
1975 * inserted. If @a __pos is beyond end of string, out_of_range
1976 * is thrown. If the length of result exceeds max_size(),
1977 * length_error is thrown. The value of the string doesn't
1978 * change if an error is thrown.
1979 */
1980 basic_string&
1981 replace(size_type __pos, size_type __n1, const _CharT* __s)
1982 {
1983 __glibcxx_requires_string(__s);
1984 return this->replace(__pos, __n1, __s, traits_type::length(__s));
1985 }
1986
1987 /**
1988 * @brief Replace characters with multiple characters.
1989 * @param __pos Index of first character to replace.
1990 * @param __n1 Number of characters to be replaced.
1991 * @param __n2 Number of characters to insert.
1992 * @param __c Character to insert.
1993 * @return Reference to this string.
1994 * @throw std::out_of_range If @a __pos > size().
1995 * @throw std::length_error If new length exceeds @c max_size().
1996 *
1997 * Removes the characters in the range [pos,pos + n1) from this
1998 * string. In place, @a __n2 copies of @a __c are inserted.
1999 * If @a __pos is beyond end of string, out_of_range is thrown.
2000 * If the length of result exceeds max_size(), length_error is
2001 * thrown. The value of the string doesn't change if an error
2002 * is thrown.
2003 */
2004 basic_string&
2005 replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
2006 { return _M_replace_aux(pos1: _M_check(__pos, s: "basic_string::replace"),
2007 n1: _M_limit(__pos, off: __n1), __n2, __c); }
2008
2009 /**
2010 * @brief Replace range of characters with string.
2011 * @param __i1 Iterator referencing start of range to replace.
2012 * @param __i2 Iterator referencing end of range to replace.
2013 * @param __str String value to insert.
2014 * @return Reference to this string.
2015 * @throw std::length_error If new length exceeds @c max_size().
2016 *
2017 * Removes the characters in the range [__i1,__i2). In place,
2018 * the value of @a __str is inserted. If the length of result
2019 * exceeds max_size(), length_error is thrown. The value of
2020 * the string doesn't change if an error is thrown.
2021 */
2022 basic_string&
2023 replace(__const_iterator __i1, __const_iterator __i2,
2024 const basic_string& __str)
2025 { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
2026
2027 /**
2028 * @brief Replace range of characters with C substring.
2029 * @param __i1 Iterator referencing start of range to replace.
2030 * @param __i2 Iterator referencing end of range to replace.
2031 * @param __s C string value to insert.
2032 * @param __n Number of characters from s to insert.
2033 * @return Reference to this string.
2034 * @throw std::length_error If new length exceeds @c max_size().
2035 *
2036 * Removes the characters in the range [__i1,__i2). In place,
2037 * the first @a __n characters of @a __s are inserted. If the
2038 * length of result exceeds max_size(), length_error is thrown.
2039 * The value of the string doesn't change if an error is
2040 * thrown.
2041 */
2042 basic_string&
2043 replace(__const_iterator __i1, __const_iterator __i2,
2044 const _CharT* __s, size_type __n)
2045 {
2046 _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2047 && __i2 <= end());
2048 return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
2049 }
2050
2051 /**
2052 * @brief Replace range of characters with C string.
2053 * @param __i1 Iterator referencing start of range to replace.
2054 * @param __i2 Iterator referencing end of range to replace.
2055 * @param __s C string value to insert.
2056 * @return Reference to this string.
2057 * @throw std::length_error If new length exceeds @c max_size().
2058 *
2059 * Removes the characters in the range [__i1,__i2). In place,
2060 * the characters of @a __s are inserted. If the length of
2061 * result exceeds max_size(), length_error is thrown. The
2062 * value of the string doesn't change if an error is thrown.
2063 */
2064 basic_string&
2065 replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
2066 {
2067 __glibcxx_requires_string(__s);
2068 return this->replace(__i1, __i2, __s, traits_type::length(__s));
2069 }
2070
2071 /**
2072 * @brief Replace range of characters with multiple characters
2073 * @param __i1 Iterator referencing start of range to replace.
2074 * @param __i2 Iterator referencing end of range to replace.
2075 * @param __n Number of characters to insert.
2076 * @param __c Character to insert.
2077 * @return Reference to this string.
2078 * @throw std::length_error If new length exceeds @c max_size().
2079 *
2080 * Removes the characters in the range [__i1,__i2). In place,
2081 * @a __n copies of @a __c are inserted. If the length of
2082 * result exceeds max_size(), length_error is thrown. The
2083 * value of the string doesn't change if an error is thrown.
2084 */
2085 basic_string&
2086 replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
2087 _CharT __c)
2088 {
2089 _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2090 && __i2 <= end());
2091 return _M_replace_aux(pos1: __i1 - begin(), n1: __i2 - __i1, n2: __n, __c);
2092 }
2093
2094 /**
2095 * @brief Replace range of characters with range.
2096 * @param __i1 Iterator referencing start of range to replace.
2097 * @param __i2 Iterator referencing end of range to replace.
2098 * @param __k1 Iterator referencing start of range to insert.
2099 * @param __k2 Iterator referencing end of range to insert.
2100 * @return Reference to this string.
2101 * @throw std::length_error If new length exceeds @c max_size().
2102 *
2103 * Removes the characters in the range [__i1,__i2). In place,
2104 * characters in the range [__k1,__k2) are inserted. If the
2105 * length of result exceeds max_size(), length_error is thrown.
2106 * The value of the string doesn't change if an error is
2107 * thrown.
2108 */
2109#if __cplusplus >= 201103L
2110 template<class _InputIterator,
2111 typename = std::_RequireInputIter<_InputIterator>>
2112 basic_string&
2113 replace(const_iterator __i1, const_iterator __i2,
2114 _InputIterator __k1, _InputIterator __k2)
2115 {
2116 _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2117 && __i2 <= end());
2118 __glibcxx_requires_valid_range(__k1, __k2);
2119 return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
2120 std::__false_type());
2121 }
2122#else
2123 template<class _InputIterator>
2124#ifdef _GLIBCXX_DISAMBIGUATE_REPLACE_INST
2125 typename __enable_if_not_native_iterator<_InputIterator>::__type
2126#else
2127 basic_string&
2128#endif
2129 replace(iterator __i1, iterator __i2,
2130 _InputIterator __k1, _InputIterator __k2)
2131 {
2132 _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2133 && __i2 <= end());
2134 __glibcxx_requires_valid_range(__k1, __k2);
2135 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
2136 return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
2137 }
2138#endif
2139
2140 // Specializations for the common case of pointer and iterator:
2141 // useful to avoid the overhead of temporary buffering in _M_replace.
2142 basic_string&
2143 replace(__const_iterator __i1, __const_iterator __i2,
2144 _CharT* __k1, _CharT* __k2)
2145 {
2146 _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2147 && __i2 <= end());
2148 __glibcxx_requires_valid_range(__k1, __k2);
2149 return this->replace(__i1 - begin(), __i2 - __i1,
2150 __k1, __k2 - __k1);
2151 }
2152
2153 basic_string&
2154 replace(__const_iterator __i1, __const_iterator __i2,
2155 const _CharT* __k1, const _CharT* __k2)
2156 {
2157 _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2158 && __i2 <= end());
2159 __glibcxx_requires_valid_range(__k1, __k2);
2160 return this->replace(__i1 - begin(), __i2 - __i1,
2161 __k1, __k2 - __k1);
2162 }
2163
2164 basic_string&
2165 replace(__const_iterator __i1, __const_iterator __i2,
2166 iterator __k1, iterator __k2)
2167 {
2168 _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2169 && __i2 <= end());
2170 __glibcxx_requires_valid_range(__k1, __k2);
2171 return this->replace(__i1 - begin(), __i2 - __i1,
2172 __k1.base(), __k2 - __k1);
2173 }
2174
2175 basic_string&
2176 replace(__const_iterator __i1, __const_iterator __i2,
2177 const_iterator __k1, const_iterator __k2)
2178 {
2179 _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2180 && __i2 <= end());
2181 __glibcxx_requires_valid_range(__k1, __k2);
2182 return this->replace(__i1 - begin(), __i2 - __i1,
2183 __k1.base(), __k2 - __k1);
2184 }
2185
2186#if __cplusplus >= 201103L
2187 /**
2188 * @brief Replace range of characters with initializer_list.
2189 * @param __i1 Iterator referencing start of range to replace.
2190 * @param __i2 Iterator referencing end of range to replace.
2191 * @param __l The initializer_list of characters to insert.
2192 * @return Reference to this string.
2193 * @throw std::length_error If new length exceeds @c max_size().
2194 *
2195 * Removes the characters in the range [__i1,__i2). In place,
2196 * characters in the range [__k1,__k2) are inserted. If the
2197 * length of result exceeds max_size(), length_error is thrown.
2198 * The value of the string doesn't change if an error is
2199 * thrown.
2200 */
2201 basic_string& replace(const_iterator __i1, const_iterator __i2,
2202 initializer_list<_CharT> __l)
2203 { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
2204#endif // C++11
2205
2206#if __cplusplus >= 201703L
2207 /**
2208 * @brief Replace range of characters with string_view.
2209 * @param __pos The position to replace at.
2210 * @param __n The number of characters to replace.
2211 * @param __svt The object convertible to string_view to insert.
2212 * @return Reference to this string.
2213 */
2214 template<typename _Tp>
2215 _If_sv<_Tp, basic_string&>
2216 replace(size_type __pos, size_type __n, const _Tp& __svt)
2217 {
2218 __sv_type __sv = __svt;
2219 return this->replace(__pos, __n, __sv.data(), __sv.size());
2220 }
2221
2222 /**
2223 * @brief Replace range of characters with string_view.
2224 * @param __pos1 The position to replace at.
2225 * @param __n1 The number of characters to replace.
2226 * @param __svt The object convertible to string_view to insert from.
2227 * @param __pos2 The position in the string_view to insert from.
2228 * @param __n2 The number of characters to insert.
2229 * @return Reference to this string.
2230 */
2231 template<typename _Tp>
2232 _If_sv<_Tp, basic_string&>
2233 replace(size_type __pos1, size_type __n1, const _Tp& __svt,
2234 size_type __pos2, size_type __n2 = npos)
2235 {
2236 __sv_type __sv = __svt;
2237 return this->replace(__pos1, __n1,
2238 __sv.data()
2239 + std::__sv_check(size: __sv.size(), pos: __pos2, s: "basic_string::replace"),
2240 std::__sv_limit(size: __sv.size(), pos: __pos2, off: __n2));
2241 }
2242
2243 /**
2244 * @brief Replace range of characters with string_view.
2245 * @param __i1 An iterator referencing the start position
2246 to replace at.
2247 * @param __i2 An iterator referencing the end position
2248 for the replace.
2249 * @param __svt The object convertible to string_view to insert from.
2250 * @return Reference to this string.
2251 */
2252 template<typename _Tp>
2253 _If_sv<_Tp, basic_string&>
2254 replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
2255 {
2256 __sv_type __sv = __svt;
2257 return this->replace(__i1 - begin(), __i2 - __i1, __sv);
2258 }
2259#endif // C++17
2260
2261 private:
2262 template<class _Integer>
2263 basic_string&
2264 _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
2265 _Integer __n, _Integer __val, __true_type)
2266 { return _M_replace_aux(pos1: __i1 - begin(), n1: __i2 - __i1, n2: __n, c: __val); }
2267
2268 template<class _InputIterator>
2269 basic_string&
2270 _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
2271 _InputIterator __k1, _InputIterator __k2,
2272 __false_type);
2273
2274 basic_string&
2275 _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
2276 _CharT __c);
2277
2278 basic_string&
2279 _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
2280 const size_type __len2);
2281
2282 basic_string&
2283 _M_append(const _CharT* __s, size_type __n);
2284
2285 public:
2286
2287 /**
2288 * @brief Copy substring into C string.
2289 * @param __s C string to copy value into.
2290 * @param __n Number of characters to copy.
2291 * @param __pos Index of first character to copy.
2292 * @return Number of characters actually copied
2293 * @throw std::out_of_range If __pos > size().
2294 *
2295 * Copies up to @a __n characters starting at @a __pos into the
2296 * C string @a __s. If @a __pos is %greater than size(),
2297 * out_of_range is thrown.
2298 */
2299 size_type
2300 copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
2301
2302 /**
2303 * @brief Swap contents with another string.
2304 * @param __s String to swap with.
2305 *
2306 * Exchanges the contents of this string with that of @a __s in constant
2307 * time.
2308 */
2309 void
2310 swap(basic_string& __s) _GLIBCXX_NOEXCEPT;
2311
2312 // String operations:
2313 /**
2314 * @brief Return const pointer to null-terminated contents.
2315 *
2316 * This is a handle to internal data. Do not modify or dire things may
2317 * happen.
2318 */
2319 const _CharT*
2320 c_str() const _GLIBCXX_NOEXCEPT
2321 { return _M_data(); }
2322
2323 /**
2324 * @brief Return const pointer to contents.
2325 *
2326 * This is a pointer to internal data. It is undefined to modify
2327 * the contents through the returned pointer. To get a pointer that
2328 * allows modifying the contents use @c &str[0] instead,
2329 * (or in C++17 the non-const @c str.data() overload).
2330 */
2331 const _CharT*
2332 data() const _GLIBCXX_NOEXCEPT
2333 { return _M_data(); }
2334
2335#if __cplusplus >= 201703L
2336 /**
2337 * @brief Return non-const pointer to contents.
2338 *
2339 * This is a pointer to the character sequence held by the string.
2340 * Modifying the characters in the sequence is allowed.
2341 */
2342 _CharT*
2343 data() noexcept
2344 { return _M_data(); }
2345#endif
2346
2347 /**
2348 * @brief Return copy of allocator used to construct this string.
2349 */
2350 allocator_type
2351 get_allocator() const _GLIBCXX_NOEXCEPT
2352 { return _M_get_allocator(); }
2353
2354 /**
2355 * @brief Find position of a C substring.
2356 * @param __s C string to locate.
2357 * @param __pos Index of character to search from.
2358 * @param __n Number of characters from @a s to search for.
2359 * @return Index of start of first occurrence.
2360 *
2361 * Starting from @a __pos, searches forward for the first @a
2362 * __n characters in @a __s within this string. If found,
2363 * returns the index where it begins. If not found, returns
2364 * npos.
2365 */
2366 size_type
2367 find(const _CharT* __s, size_type __pos, size_type __n) const
2368 _GLIBCXX_NOEXCEPT;
2369
2370 /**
2371 * @brief Find position of a string.
2372 * @param __str String to locate.
2373 * @param __pos Index of character to search from (default 0).
2374 * @return Index of start of first occurrence.
2375 *
2376 * Starting from @a __pos, searches forward for value of @a __str within
2377 * this string. If found, returns the index where it begins. If not
2378 * found, returns npos.
2379 */
2380 size_type
2381 find(const basic_string& __str, size_type __pos = 0) const
2382 _GLIBCXX_NOEXCEPT
2383 { return this->find(__str.data(), __pos, __str.size()); }
2384
2385#if __cplusplus >= 201703L
2386 /**
2387 * @brief Find position of a string_view.
2388 * @param __svt The object convertible to string_view to locate.
2389 * @param __pos Index of character to search from (default 0).
2390 * @return Index of start of first occurrence.
2391 */
2392 template<typename _Tp>
2393 _If_sv<_Tp, size_type>
2394 find(const _Tp& __svt, size_type __pos = 0) const
2395 noexcept(is_same<_Tp, __sv_type>::value)
2396 {
2397 __sv_type __sv = __svt;
2398 return this->find(__sv.data(), __pos, __sv.size());
2399 }
2400#endif // C++17
2401
2402 /**
2403 * @brief Find position of a C string.
2404 * @param __s C string to locate.
2405 * @param __pos Index of character to search from (default 0).
2406 * @return Index of start of first occurrence.
2407 *
2408 * Starting from @a __pos, searches forward for the value of @a
2409 * __s within this string. If found, returns the index where
2410 * it begins. If not found, returns npos.
2411 */
2412 size_type
2413 find(const _CharT* __s, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
2414 {
2415 __glibcxx_requires_string(__s);
2416 return this->find(__s, __pos, traits_type::length(__s));
2417 }
2418
2419 /**
2420 * @brief Find position of a character.
2421 * @param __c Character to locate.
2422 * @param __pos Index of character to search from (default 0).
2423 * @return Index of first occurrence.
2424 *
2425 * Starting from @a __pos, searches forward for @a __c within
2426 * this string. If found, returns the index where it was
2427 * found. If not found, returns npos.
2428 */
2429 size_type
2430 find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT;
2431
2432 /**
2433 * @brief Find last position of a string.
2434 * @param __str String to locate.
2435 * @param __pos Index of character to search back from (default end).
2436 * @return Index of start of last occurrence.
2437 *
2438 * Starting from @a __pos, searches backward for value of @a
2439 * __str within this string. If found, returns the index where
2440 * it begins. If not found, returns npos.
2441 */
2442 size_type
2443 rfind(const basic_string& __str, size_type __pos = npos) const
2444 _GLIBCXX_NOEXCEPT
2445 { return this->rfind(__str.data(), __pos, __str.size()); }
2446
2447#if __cplusplus >= 201703L
2448 /**
2449 * @brief Find last position of a string_view.
2450 * @param __svt The object convertible to string_view to locate.
2451 * @param __pos Index of character to search back from (default end).
2452 * @return Index of start of last occurrence.
2453 */
2454 template<typename _Tp>
2455 _If_sv<_Tp, size_type>
2456 rfind(const _Tp& __svt, size_type __pos = npos) const
2457 noexcept(is_same<_Tp, __sv_type>::value)
2458 {
2459 __sv_type __sv = __svt;
2460 return this->rfind(__sv.data(), __pos, __sv.size());
2461 }
2462#endif // C++17
2463
2464 /**
2465 * @brief Find last position of a C substring.
2466 * @param __s C string to locate.
2467 * @param __pos Index of character to search back from.
2468 * @param __n Number of characters from s to search for.
2469 * @return Index of start of last occurrence.
2470 *
2471 * Starting from @a __pos, searches backward for the first @a
2472 * __n characters in @a __s within this string. If found,
2473 * returns the index where it begins. If not found, returns
2474 * npos.
2475 */
2476 size_type
2477 rfind(const _CharT* __s, size_type __pos, size_type __n) const
2478 _GLIBCXX_NOEXCEPT;
2479
2480 /**
2481 * @brief Find last position of a C string.
2482 * @param __s C string to locate.
2483 * @param __pos Index of character to start search at (default end).
2484 * @return Index of start of last occurrence.
2485 *
2486 * Starting from @a __pos, searches backward for the value of
2487 * @a __s within this string. If found, returns the index
2488 * where it begins. If not found, returns npos.
2489 */
2490 size_type
2491 rfind(const _CharT* __s, size_type __pos = npos) const
2492 {
2493 __glibcxx_requires_string(__s);
2494 return this->rfind(__s, __pos, traits_type::length(__s));
2495 }
2496
2497 /**
2498 * @brief Find last position of a character.
2499 * @param __c Character to locate.
2500 * @param __pos Index of character to search back from (default end).
2501 * @return Index of last occurrence.
2502 *
2503 * Starting from @a __pos, searches backward for @a __c within
2504 * this string. If found, returns the index where it was
2505 * found. If not found, returns npos.
2506 */
2507 size_type
2508 rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT;
2509
2510 /**
2511 * @brief Find position of a character of string.
2512 * @param __str String containing characters to locate.
2513 * @param __pos Index of character to search from (default 0).
2514 * @return Index of first occurrence.
2515 *
2516 * Starting from @a __pos, searches forward for one of the
2517 * characters of @a __str within this string. If found,
2518 * returns the index where it was found. If not found, returns
2519 * npos.
2520 */
2521 size_type
2522 find_first_of(const basic_string& __str, size_type __pos = 0) const
2523 _GLIBCXX_NOEXCEPT
2524 { return this->find_first_of(__str.data(), __pos, __str.size()); }
2525
2526#if __cplusplus >= 201703L
2527 /**
2528 * @brief Find position of a character of a string_view.
2529 * @param __svt An object convertible to string_view containing
2530 * characters to locate.
2531 * @param __pos Index of character to search from (default 0).
2532 * @return Index of first occurrence.
2533 */
2534 template<typename _Tp>
2535 _If_sv<_Tp, size_type>
2536 find_first_of(const _Tp& __svt, size_type __pos = 0) const
2537 noexcept(is_same<_Tp, __sv_type>::value)
2538 {
2539 __sv_type __sv = __svt;
2540 return this->find_first_of(__sv.data(), __pos, __sv.size());
2541 }
2542#endif // C++17
2543
2544 /**
2545 * @brief Find position of a character of C substring.
2546 * @param __s String containing characters to locate.
2547 * @param __pos Index of character to search from.
2548 * @param __n Number of characters from s to search for.
2549 * @return Index of first occurrence.
2550 *
2551 * Starting from @a __pos, searches forward for one of the
2552 * first @a __n characters of @a __s within this string. If
2553 * found, returns the index where it was found. If not found,
2554 * returns npos.
2555 */
2556 size_type
2557 find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
2558 _GLIBCXX_NOEXCEPT;
2559
2560 /**
2561 * @brief Find position of a character of C string.
2562 * @param __s String containing characters to locate.
2563 * @param __pos Index of character to search from (default 0).
2564 * @return Index of first occurrence.
2565 *
2566 * Starting from @a __pos, searches forward for one of the
2567 * characters of @a __s within this string. If found, returns
2568 * the index where it was found. If not found, returns npos.
2569 */
2570 size_type
2571 find_first_of(const _CharT* __s, size_type __pos = 0) const
2572 _GLIBCXX_NOEXCEPT
2573 {
2574 __glibcxx_requires_string(__s);
2575 return this->find_first_of(__s, __pos, traits_type::length(__s));
2576 }
2577
2578 /**
2579 * @brief Find position of a character.
2580 * @param __c Character to locate.
2581 * @param __pos Index of character to search from (default 0).
2582 * @return Index of first occurrence.
2583 *
2584 * Starting from @a __pos, searches forward for the character
2585 * @a __c within this string. If found, returns the index
2586 * where it was found. If not found, returns npos.
2587 *
2588 * Note: equivalent to find(__c, __pos).
2589 */
2590 size_type
2591 find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
2592 { return this->find(__c, __pos); }
2593
2594 /**
2595 * @brief Find last position of a character of string.
2596 * @param __str String containing characters to locate.
2597 * @param __pos Index of character to search back from (default end).
2598 * @return Index of last occurrence.
2599 *
2600 * Starting from @a __pos, searches backward for one of the
2601 * characters of @a __str within this string. If found,
2602 * returns the index where it was found. If not found, returns
2603 * npos.
2604 */
2605 size_type
2606 find_last_of(const basic_string& __str, size_type __pos = npos) const
2607 _GLIBCXX_NOEXCEPT
2608 { return this->find_last_of(__str.data(), __pos, __str.size()); }
2609
2610#if __cplusplus >= 201703L
2611 /**
2612 * @brief Find last position of a character of string.
2613 * @param __svt An object convertible to string_view containing
2614 * characters to locate.
2615 * @param __pos Index of character to search back from (default end).
2616 * @return Index of last occurrence.
2617 */
2618 template<typename _Tp>
2619 _If_sv<_Tp, size_type>
2620 find_last_of(const _Tp& __svt, size_type __pos = npos) const
2621 noexcept(is_same<_Tp, __sv_type>::value)
2622 {
2623 __sv_type __sv = __svt;
2624 return this->find_last_of(__sv.data(), __pos, __sv.size());
2625 }
2626#endif // C++17
2627
2628 /**
2629 * @brief Find last position of a character of C substring.
2630 * @param __s C string containing characters to locate.
2631 * @param __pos Index of character to search back from.
2632 * @param __n Number of characters from s to search for.
2633 * @return Index of last occurrence.
2634 *
2635 * Starting from @a __pos, searches backward for one of the
2636 * first @a __n characters of @a __s within this string. If
2637 * found, returns the index where it was found. If not found,
2638 * returns npos.
2639 */
2640 size_type
2641 find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
2642 _GLIBCXX_NOEXCEPT;
2643
2644 /**
2645 * @brief Find last position of a character of C string.
2646 * @param __s C string containing characters to locate.
2647 * @param __pos Index of character to search back from (default end).
2648 * @return Index of last occurrence.
2649 *
2650 * Starting from @a __pos, searches backward for one of the
2651 * characters of @a __s within this string. If found, returns
2652 * the index where it was found. If not found, returns npos.
2653 */
2654 size_type
2655 find_last_of(const _CharT* __s, size_type __pos = npos) const
2656 _GLIBCXX_NOEXCEPT
2657 {
2658 __glibcxx_requires_string(__s);
2659 return this->find_last_of(__s, __pos, traits_type::length(__s));
2660 }
2661
2662 /**
2663 * @brief Find last position of a character.
2664 * @param __c Character to locate.
2665 * @param __pos Index of character to search back from (default end).
2666 * @return Index of last occurrence.
2667 *
2668 * Starting from @a __pos, searches backward for @a __c within
2669 * this string. If found, returns the index where it was
2670 * found. If not found, returns npos.
2671 *
2672 * Note: equivalent to rfind(__c, __pos).
2673 */
2674 size_type
2675 find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
2676 { return this->rfind(__c, __pos); }
2677
2678 /**
2679 * @brief Find position of a character not in string.
2680 * @param __str String containing characters to avoid.
2681 * @param __pos Index of character to search from (default 0).
2682 * @return Index of first occurrence.
2683 *
2684 * Starting from @a __pos, searches forward for a character not contained
2685 * in @a __str within this string. If found, returns the index where it
2686 * was found. If not found, returns npos.
2687 */
2688 size_type
2689 find_first_not_of(const basic_string& __str, size_type __pos = 0) const
2690 _GLIBCXX_NOEXCEPT
2691 { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
2692
2693#if __cplusplus >= 201703L
2694 /**
2695 * @brief Find position of a character not in a string_view.
2696 * @param __svt A object convertible to string_view containing
2697 * characters to avoid.
2698 * @param __pos Index of character to search from (default 0).
2699 * @return Index of first occurrence.
2700 */
2701 template<typename _Tp>
2702 _If_sv<_Tp, size_type>
2703 find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
2704 noexcept(is_same<_Tp, __sv_type>::value)
2705 {
2706 __sv_type __sv = __svt;
2707 return this->find_first_not_of(__sv.data(), __pos, __sv.size());
2708 }
2709#endif // C++17
2710
2711 /**
2712 * @brief Find position of a character not in C substring.
2713 * @param __s C string containing characters to avoid.
2714 * @param __pos Index of character to search from.
2715 * @param __n Number of characters from __s to consider.
2716 * @return Index of first occurrence.
2717 *
2718 * Starting from @a __pos, searches forward for a character not
2719 * contained in the first @a __n characters of @a __s within
2720 * this string. If found, returns the index where it was
2721 * found. If not found, returns npos.
2722 */
2723 size_type
2724 find_first_not_of(const _CharT* __s, size_type __pos,
2725 size_type __n) const _GLIBCXX_NOEXCEPT;
2726
2727 /**
2728 * @brief Find position of a character not in C string.
2729 * @param __s C string containing characters to avoid.
2730 * @param __pos Index of character to search from (default 0).
2731 * @return Index of first occurrence.
2732 *
2733 * Starting from @a __pos, searches forward for a character not
2734 * contained in @a __s within this string. If found, returns
2735 * the index where it was found. If not found, returns npos.
2736 */
2737 size_type
2738 find_first_not_of(const _CharT* __s, size_type __pos = 0) const
2739 _GLIBCXX_NOEXCEPT
2740 {
2741 __glibcxx_requires_string(__s);
2742 return this->find_first_not_of(__s, __pos, traits_type::length(__s));
2743 }
2744
2745 /**
2746 * @brief Find position of a different character.
2747 * @param __c Character to avoid.
2748 * @param __pos Index of character to search from (default 0).
2749 * @return Index of first occurrence.
2750 *
2751 * Starting from @a __pos, searches forward for a character
2752 * other than @a __c within this string. If found, returns the
2753 * index where it was found. If not found, returns npos.
2754 */
2755 size_type
2756 find_first_not_of(_CharT __c, size_type __pos = 0) const
2757 _GLIBCXX_NOEXCEPT;
2758
2759 /**
2760 * @brief Find last position of a character not in string.
2761 * @param __str String containing characters to avoid.
2762 * @param __pos Index of character to search back from (default end).
2763 * @return Index of last occurrence.
2764 *
2765 * Starting from @a __pos, searches backward for a character
2766 * not contained in @a __str within this string. If found,
2767 * returns the index where it was found. If not found, returns
2768 * npos.
2769 */
2770 size_type
2771 find_last_not_of(const basic_string& __str, size_type __pos = npos) const
2772 _GLIBCXX_NOEXCEPT
2773 { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
2774
2775#if __cplusplus >= 201703L
2776 /**
2777 * @brief Find last position of a character not in a string_view.
2778 * @param __svt An object convertible to string_view containing
2779 * characters to avoid.
2780 * @param __pos Index of character to search back from (default end).
2781 * @return Index of last occurrence.
2782 */
2783 template<typename _Tp>
2784 _If_sv<_Tp, size_type>
2785 find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
2786 noexcept(is_same<_Tp, __sv_type>::value)
2787 {
2788 __sv_type __sv = __svt;
2789 return this->find_last_not_of(__sv.data(), __pos, __sv.size());
2790 }
2791#endif // C++17
2792
2793 /**
2794 * @brief Find last position of a character not in C substring.
2795 * @param __s C string containing characters to avoid.
2796 * @param __pos Index of character to search back from.
2797 * @param __n Number of characters from s to consider.
2798 * @return Index of last occurrence.
2799 *
2800 * Starting from @a __pos, searches backward for a character not
2801 * contained in the first @a __n characters of @a __s within this string.
2802 * If found, returns the index where it was found. If not found,
2803 * returns npos.
2804 */
2805 size_type
2806 find_last_not_of(const _CharT* __s, size_type __pos,
2807 size_type __n) const _GLIBCXX_NOEXCEPT;
2808 /**
2809 * @brief Find last position of a character not in C string.
2810 * @param __s C string containing characters to avoid.
2811 * @param __pos Index of character to search back from (default end).
2812 * @return Index of last occurrence.
2813 *
2814 * Starting from @a __pos, searches backward for a character
2815 * not contained in @a __s within this string. If found,
2816 * returns the index where it was found. If not found, returns
2817 * npos.
2818 */
2819 size_type
2820 find_last_not_of(const _CharT* __s, size_type __pos = npos) const
2821 _GLIBCXX_NOEXCEPT
2822 {
2823 __glibcxx_requires_string(__s);
2824 return this->find_last_not_of(__s, __pos, traits_type::length(__s));
2825 }
2826
2827 /**
2828 * @brief Find last position of a different character.
2829 * @param __c Character to avoid.
2830 * @param __pos Index of character to search back from (default end).
2831 * @return Index of last occurrence.
2832 *
2833 * Starting from @a __pos, searches backward for a character other than
2834 * @a __c within this string. If found, returns the index where it was
2835 * found. If not found, returns npos.
2836 */
2837 size_type
2838 find_last_not_of(_CharT __c, size_type __pos = npos) const
2839 _GLIBCXX_NOEXCEPT;
2840
2841 /**
2842 * @brief Get a substring.
2843 * @param __pos Index of first character (default 0).
2844 * @param __n Number of characters in substring (default remainder).
2845 * @return The new string.
2846 * @throw std::out_of_range If __pos > size().
2847 *
2848 * Construct and return a new string using the @a __n
2849 * characters starting at @a __pos. If the string is too
2850 * short, use the remainder of the characters. If @a __pos is
2851 * beyond the end of the string, out_of_range is thrown.
2852 */
2853 basic_string
2854 substr(size_type __pos = 0, size_type __n = npos) const
2855 { return basic_string(*this,
2856 _M_check(__pos, s: "basic_string::substr"), __n); }
2857
2858 /**
2859 * @brief Compare to a string.
2860 * @param __str String to compare against.
2861 * @return Integer < 0, 0, or > 0.
2862 *
2863 * Returns an integer < 0 if this string is ordered before @a
2864 * __str, 0 if their values are equivalent, or > 0 if this
2865 * string is ordered after @a __str. Determines the effective
2866 * length rlen of the strings to compare as the smallest of
2867 * size() and str.size(). The function then compares the two
2868 * strings by calling traits::compare(data(), str.data(),rlen).
2869 * If the result of the comparison is nonzero returns it,
2870 * otherwise the shorter one is ordered first.
2871 */
2872 int
2873 compare(const basic_string& __str) const
2874 {
2875 const size_type __size = this->size();
2876 const size_type __osize = __str.size();
2877 const size_type __len = std::min(__size, __osize);
2878
2879 int __r = traits_type::compare(_M_data(), __str.data(), __len);
2880 if (!__r)
2881 __r = _S_compare(n1: __size, n2: __osize);
2882 return __r;
2883 }
2884
2885#if __cplusplus >= 201703L
2886 /**
2887 * @brief Compare to a string_view.
2888 * @param __svt An object convertible to string_view to compare against.
2889 * @return Integer < 0, 0, or > 0.
2890 */
2891 template<typename _Tp>
2892 _If_sv<_Tp, int>
2893 compare(const _Tp& __svt) const
2894 noexcept(is_same<_Tp, __sv_type>::value)
2895 {
2896 __sv_type __sv = __svt;
2897 const size_type __size = this->size();
2898 const size_type __osize = __sv.size();
2899 const size_type __len = std::min(__size, __osize);
2900
2901 int __r = traits_type::compare(_M_data(), __sv.data(), __len);
2902 if (!__r)
2903 __r = _S_compare(n1: __size, n2: __osize);
2904 return __r;
2905 }
2906
2907 /**
2908 * @brief Compare to a string_view.
2909 * @param __pos A position in the string to start comparing from.
2910 * @param __n The number of characters to compare.
2911 * @param __svt An object convertible to string_view to compare
2912 * against.
2913 * @return Integer < 0, 0, or > 0.
2914 */
2915 template<typename _Tp>
2916 _If_sv<_Tp, int>
2917 compare(size_type __pos, size_type __n, const _Tp& __svt) const
2918 noexcept(is_same<_Tp, __sv_type>::value)
2919 {
2920 __sv_type __sv = __svt;
2921 return __sv_type(*this).substr(__pos, __n).compare(__sv);
2922 }
2923
2924 /**
2925 * @brief Compare to a string_view.
2926 * @param __pos1 A position in the string to start comparing from.
2927 * @param __n1 The number of characters to compare.
2928 * @param __svt An object convertible to string_view to compare
2929 * against.
2930 * @param __pos2 A position in the string_view to start comparing from.
2931 * @param __n2 The number of characters to compare.
2932 * @return Integer < 0, 0, or > 0.
2933 */
2934 template<typename _Tp>
2935 _If_sv<_Tp, int>
2936 compare(size_type __pos1, size_type __n1, const _Tp& __svt,
2937 size_type __pos2, size_type __n2 = npos) const
2938 noexcept(is_same<_Tp, __sv_type>::value)
2939 {
2940 __sv_type __sv = __svt;
2941 return __sv_type(*this)
2942 .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
2943 }
2944#endif // C++17
2945
2946 /**
2947 * @brief Compare substring to a string.
2948 * @param __pos Index of first character of substring.
2949 * @param __n Number of characters in substring.
2950 * @param __str String to compare against.
2951 * @return Integer < 0, 0, or > 0.
2952 *
2953 * Form the substring of this string from the @a __n characters
2954 * starting at @a __pos. Returns an integer < 0 if the
2955 * substring is ordered before @a __str, 0 if their values are
2956 * equivalent, or > 0 if the substring is ordered after @a
2957 * __str. Determines the effective length rlen of the strings
2958 * to compare as the smallest of the length of the substring
2959 * and @a __str.size(). The function then compares the two
2960 * strings by calling
2961 * traits::compare(substring.data(),str.data(),rlen). If the
2962 * result of the comparison is nonzero returns it, otherwise
2963 * the shorter one is ordered first.
2964 */
2965 int
2966 compare(size_type __pos, size_type __n, const basic_string& __str) const;
2967
2968 /**
2969 * @brief Compare substring to a substring.
2970 * @param __pos1 Index of first character of substring.
2971 * @param __n1 Number of characters in substring.
2972 * @param __str String to compare against.
2973 * @param __pos2 Index of first character of substring of str.
2974 * @param __n2 Number of characters in substring of str.
2975 * @return Integer < 0, 0, or > 0.
2976 *
2977 * Form the substring of this string from the @a __n1
2978 * characters starting at @a __pos1. Form the substring of @a
2979 * __str from the @a __n2 characters starting at @a __pos2.
2980 * Returns an integer < 0 if this substring is ordered before
2981 * the substring of @a __str, 0 if their values are equivalent,
2982 * or > 0 if this substring is ordered after the substring of
2983 * @a __str. Determines the effective length rlen of the
2984 * strings to compare as the smallest of the lengths of the
2985 * substrings. The function then compares the two strings by
2986 * calling
2987 * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
2988 * If the result of the comparison is nonzero returns it,
2989 * otherwise the shorter one is ordered first.
2990 */
2991 int
2992 compare(size_type __pos1, size_type __n1, const basic_string& __str,
2993 size_type __pos2, size_type __n2 = npos) const;
2994
2995 /**
2996 * @brief Compare to a C string.
2997 * @param __s C string to compare against.
2998 * @return Integer < 0, 0, or > 0.
2999 *
3000 * Returns an integer < 0 if this string is ordered before @a __s, 0 if
3001 * their values are equivalent, or > 0 if this string is ordered after
3002 * @a __s. Determines the effective length rlen of the strings to
3003 * compare as the smallest of size() and the length of a string
3004 * constructed from @a __s. The function then compares the two strings
3005 * by calling traits::compare(data(),s,rlen). If the result of the
3006 * comparison is nonzero returns it, otherwise the shorter one is
3007 * ordered first.
3008 */
3009 int
3010 compare(const _CharT* __s) const _GLIBCXX_NOEXCEPT;
3011
3012 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3013 // 5 String::compare specification questionable
3014 /**
3015 * @brief Compare substring to a C string.
3016 * @param __pos Index of first character of substring.
3017 * @param __n1 Number of characters in substring.
3018 * @param __s C string to compare against.
3019 * @return Integer < 0, 0, or > 0.
3020 *
3021 * Form the substring of this string from the @a __n1
3022 * characters starting at @a pos. Returns an integer < 0 if
3023 * the substring is ordered before @a __s, 0 if their values
3024 * are equivalent, or > 0 if the substring is ordered after @a
3025 * __s. Determines the effective length rlen of the strings to
3026 * compare as the smallest of the length of the substring and
3027 * the length of a string constructed from @a __s. The
3028 * function then compares the two string by calling
3029 * traits::compare(substring.data(),__s,rlen). If the result of
3030 * the comparison is nonzero returns it, otherwise the shorter
3031 * one is ordered first.
3032 */
3033 int
3034 compare(size_type __pos, size_type __n1, const _CharT* __s) const;
3035
3036 /**
3037 * @brief Compare substring against a character %array.
3038 * @param __pos Index of first character of substring.
3039 * @param __n1 Number of characters in substring.
3040 * @param __s character %array to compare against.
3041 * @param __n2 Number of characters of s.
3042 * @return Integer < 0, 0, or > 0.
3043 *
3044 * Form the substring of this string from the @a __n1
3045 * characters starting at @a __pos. Form a string from the
3046 * first @a __n2 characters of @a __s. Returns an integer < 0
3047 * if this substring is ordered before the string from @a __s,
3048 * 0 if their values are equivalent, or > 0 if this substring
3049 * is ordered after the string from @a __s. Determines the
3050 * effective length rlen of the strings to compare as the
3051 * smallest of the length of the substring and @a __n2. The
3052 * function then compares the two strings by calling
3053 * traits::compare(substring.data(),s,rlen). If the result of
3054 * the comparison is nonzero returns it, otherwise the shorter
3055 * one is ordered first.
3056 *
3057 * NB: s must have at least n2 characters, &apos;\\0&apos; has
3058 * no special meaning.
3059 */
3060 int
3061 compare(size_type __pos, size_type __n1, const _CharT* __s,
3062 size_type __n2) const;
3063
3064#if __cplusplus > 201703L
3065 bool
3066 starts_with(basic_string_view<_CharT, _Traits> __x) const noexcept
3067 { return __sv_type(this->data(), this->size()).starts_with(__x); }
3068
3069 bool
3070 starts_with(_CharT __x) const noexcept
3071 { return __sv_type(this->data(), this->size()).starts_with(__x); }
3072
3073 bool
3074 starts_with(const _CharT* __x) const noexcept
3075 { return __sv_type(this->data(), this->size()).starts_with(__x); }
3076
3077 bool
3078 ends_with(basic_string_view<_CharT, _Traits> __x) const noexcept
3079 { return __sv_type(this->data(), this->size()).ends_with(__x); }
3080
3081 bool
3082 ends_with(_CharT __x) const noexcept
3083 { return __sv_type(this->data(), this->size()).ends_with(__x); }
3084
3085 bool
3086 ends_with(const _CharT* __x) const noexcept
3087 { return __sv_type(this->data(), this->size()).ends_with(__x); }
3088#endif // C++20
3089
3090#if __cplusplus > 202002L
3091 bool
3092 contains(basic_string_view<_CharT, _Traits> __x) const noexcept
3093 { return __sv_type(this->data(), this->size()).contains(__x); }
3094
3095 bool
3096 contains(_CharT __x) const noexcept
3097 { return __sv_type(this->data(), this->size()).contains(__x); }
3098
3099 bool
3100 contains(const _CharT* __x) const noexcept
3101 { return __sv_type(this->data(), this->size()).contains(__x); }
3102#endif // C++23
3103
3104 // Allow basic_stringbuf::__xfer_bufptrs to call _M_length:
3105 template<typename, typename, typename> friend class basic_stringbuf;
3106 };
3107_GLIBCXX_END_NAMESPACE_CXX11
3108#else // !_GLIBCXX_USE_CXX11_ABI
3109 // Reference-counted COW string implentation
3110
3111 /**
3112 * @class basic_string basic_string.h <string>
3113 * @brief Managing sequences of characters and character-like objects.
3114 *
3115 * @ingroup strings
3116 * @ingroup sequences
3117 *
3118 * @tparam _CharT Type of character
3119 * @tparam _Traits Traits for character type, defaults to
3120 * char_traits<_CharT>.
3121 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
3122 *
3123 * Meets the requirements of a <a href="tables.html#65">container</a>, a
3124 * <a href="tables.html#66">reversible container</a>, and a
3125 * <a href="tables.html#67">sequence</a>. Of the
3126 * <a href="tables.html#68">optional sequence requirements</a>, only
3127 * @c push_back, @c at, and @c %array access are supported.
3128 *
3129 * @doctodo
3130 *
3131 *
3132 * Documentation? What's that?
3133 * Nathan Myers <ncm@cantrip.org>.
3134 *
3135 * A string looks like this:
3136 *
3137 * @code
3138 * [_Rep]
3139 * _M_length
3140 * [basic_string<char_type>] _M_capacity
3141 * _M_dataplus _M_refcount
3142 * _M_p ----------------> unnamed array of char_type
3143 * @endcode
3144 *
3145 * Where the _M_p points to the first character in the string, and
3146 * you cast it to a pointer-to-_Rep and subtract 1 to get a
3147 * pointer to the header.
3148 *
3149 * This approach has the enormous advantage that a string object
3150 * requires only one allocation. All the ugliness is confined
3151 * within a single %pair of inline functions, which each compile to
3152 * a single @a add instruction: _Rep::_M_data(), and
3153 * string::_M_rep(); and the allocation function which gets a
3154 * block of raw bytes and with room enough and constructs a _Rep
3155 * object at the front.
3156 *
3157 * The reason you want _M_data pointing to the character %array and
3158 * not the _Rep is so that the debugger can see the string
3159 * contents. (Probably we should add a non-inline member to get
3160 * the _Rep for the debugger to use, so users can check the actual
3161 * string length.)
3162 *
3163 * Note that the _Rep object is a POD so that you can have a
3164 * static <em>empty string</em> _Rep object already @a constructed before
3165 * static constructors have run. The reference-count encoding is
3166 * chosen so that a 0 indicates one reference, so you never try to
3167 * destroy the empty-string _Rep object.
3168 *
3169 * All but the last paragraph is considered pretty conventional
3170 * for a C++ string implementation.
3171 */
3172 // 21.3 Template class basic_string
3173 template<typename _CharT, typename _Traits, typename _Alloc>
3174 class basic_string
3175 {
3176 typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
3177 rebind<_CharT>::other _CharT_alloc_type;
3178 typedef __gnu_cxx::__alloc_traits<_CharT_alloc_type> _CharT_alloc_traits;
3179
3180 // Types:
3181 public:
3182 typedef _Traits traits_type;
3183 typedef typename _Traits::char_type value_type;
3184 typedef _Alloc allocator_type;
3185 typedef typename _CharT_alloc_traits::size_type size_type;
3186 typedef typename _CharT_alloc_traits::difference_type difference_type;
3187#if __cplusplus < 201103L
3188 typedef typename _CharT_alloc_type::reference reference;
3189 typedef typename _CharT_alloc_type::const_reference const_reference;
3190#else
3191 typedef value_type& reference;
3192 typedef const value_type& const_reference;
3193#endif
3194 typedef typename _CharT_alloc_traits::pointer pointer;
3195 typedef typename _CharT_alloc_traits::const_pointer const_pointer;
3196 typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
3197 typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
3198 const_iterator;
3199 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
3200 typedef std::reverse_iterator<iterator> reverse_iterator;
3201
3202 protected:
3203 // type used for positions in insert, erase etc.
3204 typedef iterator __const_iterator;
3205
3206 private:
3207 // _Rep: string representation
3208 // Invariants:
3209 // 1. String really contains _M_length + 1 characters: due to 21.3.4
3210 // must be kept null-terminated.
3211 // 2. _M_capacity >= _M_length
3212 // Allocated memory is always (_M_capacity + 1) * sizeof(_CharT).
3213 // 3. _M_refcount has three states:
3214 // -1: leaked, one reference, no ref-copies allowed, non-const.
3215 // 0: one reference, non-const.
3216 // n>0: n + 1 references, operations require a lock, const.
3217 // 4. All fields==0 is an empty string, given the extra storage
3218 // beyond-the-end for a null terminator; thus, the shared
3219 // empty string representation needs no constructor.
3220
3221 struct _Rep_base
3222 {
3223 size_type _M_length;
3224 size_type _M_capacity;
3225 _Atomic_word _M_refcount;
3226 };
3227
3228 struct _Rep : _Rep_base
3229 {
3230 // Types:
3231 typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
3232 rebind<char>::other _Raw_bytes_alloc;
3233
3234 // (Public) Data members:
3235
3236 // The maximum number of individual char_type elements of an
3237 // individual string is determined by _S_max_size. This is the
3238 // value that will be returned by max_size(). (Whereas npos
3239 // is the maximum number of bytes the allocator can allocate.)
3240 // If one was to divvy up the theoretical largest size string,
3241 // with a terminating character and m _CharT elements, it'd
3242 // look like this:
3243 // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT)
3244 // Solving for m:
3245 // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1
3246 // In addition, this implementation quarters this amount.
3247 static const size_type _S_max_size;
3248 static const _CharT _S_terminal;
3249
3250 // The following storage is init'd to 0 by the linker, resulting
3251 // (carefully) in an empty string with one reference.
3252 static size_type _S_empty_rep_storage[];
3253
3254 static _Rep&
3255 _S_empty_rep() _GLIBCXX_NOEXCEPT
3256 {
3257 // NB: Mild hack to avoid strict-aliasing warnings. Note that
3258 // _S_empty_rep_storage is never modified and the punning should
3259 // be reasonably safe in this case.
3260 void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
3261 return *reinterpret_cast<_Rep*>(__p);
3262 }
3263
3264 bool
3265 _M_is_leaked() const _GLIBCXX_NOEXCEPT
3266 {
3267#if defined(__GTHREADS)
3268 // _M_refcount is mutated concurrently by _M_refcopy/_M_dispose,
3269 // so we need to use an atomic load. However, _M_is_leaked
3270 // predicate does not change concurrently (i.e. the string is either
3271 // leaked or not), so a relaxed load is enough.
3272 return __atomic_load_n(&this->_M_refcount, __ATOMIC_RELAXED) < 0;
3273#else
3274 return this->_M_refcount < 0;
3275#endif
3276 }
3277
3278 bool
3279 _M_is_shared() const _GLIBCXX_NOEXCEPT
3280 {
3281#if defined(__GTHREADS)
3282 // _M_refcount is mutated concurrently by _M_refcopy/_M_dispose,
3283 // so we need to use an atomic load. Another thread can drop last
3284 // but one reference concurrently with this check, so we need this
3285 // load to be acquire to synchronize with release fetch_and_add in
3286 // _M_dispose.
3287 return __atomic_load_n(&this->_M_refcount, __ATOMIC_ACQUIRE) > 0;
3288#else
3289 return this->_M_refcount > 0;
3290#endif
3291 }
3292
3293 void
3294 _M_set_leaked() _GLIBCXX_NOEXCEPT
3295 { this->_M_refcount = -1; }
3296
3297 void
3298 _M_set_sharable() _GLIBCXX_NOEXCEPT
3299 { this->_M_refcount = 0; }
3300
3301 void
3302 _M_set_length_and_sharable(size_type __n) _GLIBCXX_NOEXCEPT
3303 {
3304#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3305 if (__builtin_expect(this != &_S_empty_rep(), false))
3306#endif
3307 {
3308 this->_M_set_sharable(); // One reference.
3309 this->_M_length = __n;
3310 traits_type::assign(this->_M_refdata()[__n], _S_terminal);
3311 // grrr. (per 21.3.4)
3312 // You cannot leave those LWG people alone for a second.
3313 }
3314 }
3315
3316 _CharT*
3317 _M_refdata() throw()
3318 { return reinterpret_cast<_CharT*>(this + 1); }
3319
3320 _CharT*
3321 _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
3322 {
3323 return (!_M_is_leaked() && __alloc1 == __alloc2)
3324 ? _M_refcopy() : _M_clone(__alloc1);
3325 }
3326
3327 // Create & Destroy
3328 static _Rep*
3329 _S_create(size_type, size_type, const _Alloc&);
3330
3331 void
3332 _M_dispose(const _Alloc& __a) _GLIBCXX_NOEXCEPT
3333 {
3334#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3335 if (__builtin_expect(this != &_S_empty_rep(), false))
3336#endif
3337 {
3338 // Be race-detector-friendly. For more info see bits/c++config.
3339 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount);
3340 // Decrement of _M_refcount is acq_rel, because:
3341 // - all but last decrements need to release to synchronize with
3342 // the last decrement that will delete the object.
3343 // - the last decrement needs to acquire to synchronize with
3344 // all the previous decrements.
3345 // - last but one decrement needs to release to synchronize with
3346 // the acquire load in _M_is_shared that will conclude that
3347 // the object is not shared anymore.
3348 if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
3349 -1) <= 0)
3350 {
3351 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount);
3352 _M_destroy(__a);
3353 }
3354 }
3355 } // XXX MT
3356
3357 void
3358 _M_destroy(const _Alloc&) throw();
3359
3360 _CharT*
3361 _M_refcopy() throw()
3362 {
3363#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3364 if (__builtin_expect(this != &_S_empty_rep(), false))
3365#endif
3366 __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
3367 return _M_refdata();
3368 } // XXX MT
3369
3370 _CharT*
3371 _M_clone(const _Alloc&, size_type __res = 0);
3372 };
3373
3374 // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
3375 struct _Alloc_hider : _Alloc
3376 {
3377 _Alloc_hider(_CharT* __dat, const _Alloc& __a) _GLIBCXX_NOEXCEPT
3378 : _Alloc(__a), _M_p(__dat) { }
3379
3380 _CharT* _M_p; // The actual data.
3381 };
3382
3383 public:
3384 // Data Members (public):
3385 // NB: This is an unsigned type, and thus represents the maximum
3386 // size that the allocator can hold.
3387 /// Value returned by various member functions when they fail.
3388 static const size_type npos = static_cast<size_type>(-1);
3389
3390 private:
3391 // Data Members (private):
3392 mutable _Alloc_hider _M_dataplus;
3393
3394 _CharT*
3395 _M_data() const _GLIBCXX_NOEXCEPT
3396 { return _M_dataplus._M_p; }
3397
3398 _CharT*
3399 _M_data(_CharT* __p) _GLIBCXX_NOEXCEPT
3400 { return (_M_dataplus._M_p = __p); }
3401
3402 _Rep*
3403 _M_rep() const _GLIBCXX_NOEXCEPT
3404 { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
3405
3406 // For the internal use we have functions similar to `begin'/`end'
3407 // but they do not call _M_leak.
3408 iterator
3409 _M_ibegin() const _GLIBCXX_NOEXCEPT
3410 { return iterator(_M_data()); }
3411
3412 iterator
3413 _M_iend() const _GLIBCXX_NOEXCEPT
3414 { return iterator(_M_data() + this->size()); }
3415
3416 void
3417 _M_leak() // for use in begin() & non-const op[]
3418 {
3419 if (!_M_rep()->_M_is_leaked())
3420 _M_leak_hard();
3421 }
3422
3423 size_type
3424 _M_check(size_type __pos, const char* __s) const
3425 {
3426 if (__pos > this->size())
3427 __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
3428 "this->size() (which is %zu)"),
3429 __s, __pos, this->size());
3430 return __pos;
3431 }
3432
3433 void
3434 _M_check_length(size_type __n1, size_type __n2, const char* __s) const
3435 {
3436 if (this->max_size() - (this->size() - __n1) < __n2)
3437 __throw_length_error(__N(__s));
3438 }
3439
3440 // NB: _M_limit doesn't check for a bad __pos value.
3441 size_type
3442 _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT
3443 {
3444 const bool __testoff = __off < this->size() - __pos;
3445 return __testoff ? __off : this->size() - __pos;
3446 }
3447
3448 // True if _Rep and source do not overlap.
3449 bool
3450 _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT
3451 {
3452 return (less<const _CharT*>()(__s, _M_data())
3453 || less<const _CharT*>()(_M_data() + this->size(), __s));
3454 }
3455
3456 // When __n = 1 way faster than the general multichar
3457 // traits_type::copy/move/assign.
3458 static void
3459 _M_copy(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT
3460 {
3461 if (__n == 1)
3462 traits_type::assign(*__d, *__s);
3463 else
3464 traits_type::copy(__d, __s, __n);
3465 }
3466
3467 static void
3468 _M_move(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT
3469 {
3470 if (__n == 1)
3471 traits_type::assign(*__d, *__s);
3472 else
3473 traits_type::move(__d, __s, __n);
3474 }
3475
3476 static void
3477 _M_assign(_CharT* __d, size_type __n, _CharT __c) _GLIBCXX_NOEXCEPT
3478 {
3479 if (__n == 1)
3480 traits_type::assign(*__d, __c);
3481 else
3482 traits_type::assign(__d, __n, __c);
3483 }
3484
3485 // _S_copy_chars is a separate template to permit specialization
3486 // to optimize for the common case of pointers as iterators.
3487 template<class _Iterator>
3488 static void
3489 _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
3490 {
3491 for (; __k1 != __k2; ++__k1, (void)++__p)
3492 traits_type::assign(*__p, *__k1); // These types are off.
3493 }
3494
3495 static void
3496 _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) _GLIBCXX_NOEXCEPT
3497 { _S_copy_chars(__p, __k1.base(), __k2.base()); }
3498
3499 static void
3500 _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
3501 _GLIBCXX_NOEXCEPT
3502 { _S_copy_chars(__p, __k1.base(), __k2.base()); }
3503
3504 static void
3505 _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) _GLIBCXX_NOEXCEPT
3506 { _M_copy(__p, __k1, __k2 - __k1); }
3507
3508 static void
3509 _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
3510 _GLIBCXX_NOEXCEPT
3511 { _M_copy(__p, __k1, __k2 - __k1); }
3512
3513 static int
3514 _S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT
3515 {
3516 const difference_type __d = difference_type(__n1 - __n2);
3517
3518 if (__d > __gnu_cxx::__numeric_traits<int>::__max)
3519 return __gnu_cxx::__numeric_traits<int>::__max;
3520 else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
3521 return __gnu_cxx::__numeric_traits<int>::__min;
3522 else
3523 return int(__d);
3524 }
3525
3526 void
3527 _M_mutate(size_type __pos, size_type __len1, size_type __len2);
3528
3529 void
3530 _M_leak_hard();
3531
3532 static _Rep&
3533 _S_empty_rep() _GLIBCXX_NOEXCEPT
3534 { return _Rep::_S_empty_rep(); }
3535
3536#if __cplusplus >= 201703L
3537 // A helper type for avoiding boiler-plate.
3538 typedef basic_string_view<_CharT, _Traits> __sv_type;
3539
3540 template<typename _Tp, typename _Res>
3541 using _If_sv = enable_if_t<
3542 __and_<is_convertible<const _Tp&, __sv_type>,
3543 __not_<is_convertible<const _Tp*, const basic_string*>>,
3544 __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
3545 _Res>;
3546
3547 // Allows an implicit conversion to __sv_type.
3548 static __sv_type
3549 _S_to_string_view(__sv_type __svt) noexcept
3550 { return __svt; }
3551
3552 // Wraps a string_view by explicit conversion and thus
3553 // allows to add an internal constructor that does not
3554 // participate in overload resolution when a string_view
3555 // is provided.
3556 struct __sv_wrapper
3557 {
3558 explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
3559 __sv_type _M_sv;
3560 };
3561
3562 /**
3563 * @brief Only internally used: Construct string from a string view
3564 * wrapper.
3565 * @param __svw string view wrapper.
3566 * @param __a Allocator to use.
3567 */
3568 explicit
3569 basic_string(__sv_wrapper __svw, const _Alloc& __a)
3570 : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
3571#endif
3572
3573 public:
3574 // Construct/copy/destroy:
3575 // NB: We overload ctors in some cases instead of using default
3576 // arguments, per 17.4.4.4 para. 2 item 2.
3577
3578 /**
3579 * @brief Default constructor creates an empty string.
3580 */
3581 basic_string()
3582#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3583 _GLIBCXX_NOEXCEPT
3584 : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc())
3585#else
3586 : _M_dataplus(_S_construct(size_type(), _CharT(), _Alloc()), _Alloc())
3587#endif
3588 { }
3589
3590 /**
3591 * @brief Construct an empty string using allocator @a a.
3592 */
3593 explicit
3594 basic_string(const _Alloc& __a)
3595 : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
3596 { }
3597
3598 // NB: per LWG issue 42, semantics different from IS:
3599 /**
3600 * @brief Construct string with copy of value of @a str.
3601 * @param __str Source string.
3602 */
3603 basic_string(const basic_string& __str)
3604 : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
3605 __str.get_allocator()),
3606 __str.get_allocator())
3607 { }
3608
3609 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3610 // 2583. no way to supply an allocator for basic_string(str, pos)
3611 /**
3612 * @brief Construct string as copy of a substring.
3613 * @param __str Source string.
3614 * @param __pos Index of first character to copy from.
3615 * @param __a Allocator to use.
3616 */
3617 basic_string(const basic_string& __str, size_type __pos,
3618 const _Alloc& __a = _Alloc());
3619
3620 /**
3621 * @brief Construct string as copy of a substring.
3622 * @param __str Source string.
3623 * @param __pos Index of first character to copy from.
3624 * @param __n Number of characters to copy.
3625 */
3626 basic_string(const basic_string& __str, size_type __pos,
3627 size_type __n);
3628 /**
3629 * @brief Construct string as copy of a substring.
3630 * @param __str Source string.
3631 * @param __pos Index of first character to copy from.
3632 * @param __n Number of characters to copy.
3633 * @param __a Allocator to use.
3634 */
3635 basic_string(const basic_string& __str, size_type __pos,
3636 size_type __n, const _Alloc& __a);
3637
3638 /**
3639 * @brief Construct string initialized by a character %array.
3640 * @param __s Source character %array.
3641 * @param __n Number of characters to copy.
3642 * @param __a Allocator to use (default is default allocator).
3643 *
3644 * NB: @a __s must have at least @a __n characters, &apos;\\0&apos;
3645 * has no special meaning.
3646 */
3647 basic_string(const _CharT* __s, size_type __n,
3648 const _Alloc& __a = _Alloc())
3649 : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
3650 { }
3651
3652 /**
3653 * @brief Construct string as copy of a C string.
3654 * @param __s Source C string.
3655 * @param __a Allocator to use (default is default allocator).
3656 */
3657#if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
3658 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3659 // 3076. basic_string CTAD ambiguity
3660 template<typename = _RequireAllocator<_Alloc>>
3661#endif
3662 basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
3663 : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
3664 __s + npos, __a), __a)
3665 { }
3666
3667 /**
3668 * @brief Construct string as multiple characters.
3669 * @param __n Number of characters.
3670 * @param __c Character to use.
3671 * @param __a Allocator to use (default is default allocator).
3672 */
3673 basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
3674 : _M_dataplus(_S_construct(__n, __c, __a), __a)
3675 { }
3676
3677#if __cplusplus >= 201103L
3678 /**
3679 * @brief Move construct string.
3680 * @param __str Source string.
3681 *
3682 * The newly-created string contains the exact contents of @a __str.
3683 * @a __str is a valid, but unspecified string.
3684 */
3685 basic_string(basic_string&& __str)
3686#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3687 noexcept // FIXME C++11: should always be noexcept.
3688#endif
3689 : _M_dataplus(std::move(__str._M_dataplus))
3690 {
3691#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3692 __str._M_data(_S_empty_rep()._M_refdata());
3693#else
3694 __str._M_data(_S_construct(size_type(), _CharT(), get_allocator()));
3695#endif
3696 }
3697
3698 /**
3699 * @brief Construct string from an initializer %list.
3700 * @param __l std::initializer_list of characters.
3701 * @param __a Allocator to use (default is default allocator).
3702 */
3703 basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
3704 : _M_dataplus(_S_construct(__l.begin(), __l.end(), __a), __a)
3705 { }
3706
3707 basic_string(const basic_string& __str, const _Alloc& __a)
3708 : _M_dataplus(__str._M_rep()->_M_grab(__a, __str.get_allocator()), __a)
3709 { }
3710
3711 basic_string(basic_string&& __str, const _Alloc& __a)
3712 : _M_dataplus(__str._M_data(), __a)
3713 {
3714 if (__a == __str.get_allocator())
3715 {
3716#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3717 __str._M_data(_S_empty_rep()._M_refdata());
3718#else
3719 __str._M_data(_S_construct(size_type(), _CharT(), __a));
3720#endif
3721 }
3722 else
3723 _M_dataplus._M_p = _S_construct(__str.begin(), __str.end(), __a);
3724 }
3725#endif // C++11
3726
3727 /**
3728 * @brief Construct string as copy of a range.
3729 * @param __beg Start of range.
3730 * @param __end End of range.
3731 * @param __a Allocator to use (default is default allocator).
3732 */
3733 template<class _InputIterator>
3734 basic_string(_InputIterator __beg, _InputIterator __end,
3735 const _Alloc& __a = _Alloc())
3736 : _M_dataplus(_S_construct(__beg, __end, __a), __a)
3737 { }
3738
3739#if __cplusplus >= 201703L
3740 /**
3741 * @brief Construct string from a substring of a string_view.
3742 * @param __t Source object convertible to string view.
3743 * @param __pos The index of the first character to copy from __t.
3744 * @param __n The number of characters to copy from __t.
3745 * @param __a Allocator to use.
3746 */
3747 template<typename _Tp,
3748 typename = enable_if_t<is_convertible_v<const _Tp&, __sv_type>>>
3749 basic_string(const _Tp& __t, size_type __pos, size_type __n,
3750 const _Alloc& __a = _Alloc())
3751 : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }
3752
3753 /**
3754 * @brief Construct string from a string_view.
3755 * @param __t Source object convertible to string view.
3756 * @param __a Allocator to use (default is default allocator).
3757 */
3758 template<typename _Tp, typename = _If_sv<_Tp, void>>
3759 explicit
3760 basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
3761 : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }
3762#endif // C++17
3763
3764 /**
3765 * @brief Destroy the string instance.
3766 */
3767 ~basic_string() _GLIBCXX_NOEXCEPT
3768 { _M_rep()->_M_dispose(this->get_allocator()); }
3769
3770 /**
3771 * @brief Assign the value of @a str to this string.
3772 * @param __str Source string.
3773 */
3774 basic_string&
3775 operator=(const basic_string& __str)
3776 { return this->assign(__str); }
3777
3778 /**
3779 * @brief Copy contents of @a s into this string.
3780 * @param __s Source null-terminated string.
3781 */
3782 basic_string&
3783 operator=(const _CharT* __s)
3784 { return this->assign(__s); }
3785
3786 /**
3787 * @brief Set value to string of length 1.
3788 * @param __c Source character.
3789 *
3790 * Assigning to a character makes this string length 1 and
3791 * (*this)[0] == @a c.
3792 */
3793 basic_string&
3794 operator=(_CharT __c)
3795 {
3796 this->assign(1, __c);
3797 return *this;
3798 }
3799
3800#if __cplusplus >= 201103L
3801 /**
3802 * @brief Move assign the value of @a str to this string.
3803 * @param __str Source string.
3804 *
3805 * The contents of @a str are moved into this string (without copying).
3806 * @a str is a valid, but unspecified string.
3807 */
3808 basic_string&
3809 operator=(basic_string&& __str)
3810 _GLIBCXX_NOEXCEPT_IF(allocator_traits<_Alloc>::is_always_equal::value)
3811 {
3812 // NB: DR 1204.
3813 this->swap(__str);
3814 return *this;
3815 }
3816
3817 /**
3818 * @brief Set value to string constructed from initializer %list.
3819 * @param __l std::initializer_list.
3820 */
3821 basic_string&
3822 operator=(initializer_list<_CharT> __l)
3823 {
3824 this->assign(__l.begin(), __l.size());
3825 return *this;
3826 }
3827#endif // C++11
3828
3829#if __cplusplus >= 201703L
3830 /**
3831 * @brief Set value to string constructed from a string_view.
3832 * @param __svt An object convertible to string_view.
3833 */
3834 template<typename _Tp>
3835 _If_sv<_Tp, basic_string&>
3836 operator=(const _Tp& __svt)
3837 { return this->assign(__svt); }
3838
3839 /**
3840 * @brief Convert to a string_view.
3841 * @return A string_view.
3842 */
3843 operator __sv_type() const noexcept
3844 { return __sv_type(data(), size()); }
3845#endif // C++17
3846
3847 // Iterators:
3848 /**
3849 * Returns a read/write iterator that points to the first character in
3850 * the %string. Unshares the string.
3851 */
3852 iterator
3853 begin() // FIXME C++11: should be noexcept.
3854 {
3855 _M_leak();
3856 return iterator(_M_data());
3857 }
3858
3859 /**
3860 * Returns a read-only (constant) iterator that points to the first
3861 * character in the %string.
3862 */
3863 const_iterator
3864 begin() const _GLIBCXX_NOEXCEPT
3865 { return const_iterator(_M_data()); }
3866
3867 /**
3868 * Returns a read/write iterator that points one past the last
3869 * character in the %string. Unshares the string.
3870 */
3871 iterator
3872 end() // FIXME C++11: should be noexcept.
3873 {
3874 _M_leak();
3875 return iterator(_M_data() + this->size());
3876 }
3877
3878 /**
3879 * Returns a read-only (constant) iterator that points one past the
3880 * last character in the %string.
3881 */
3882 const_iterator
3883 end() const _GLIBCXX_NOEXCEPT
3884 { return const_iterator(_M_data() + this->size()); }
3885
3886 /**
3887 * Returns a read/write reverse iterator that points to the last
3888 * character in the %string. Iteration is done in reverse element
3889 * order. Unshares the string.
3890 */
3891 reverse_iterator
3892 rbegin() // FIXME C++11: should be noexcept.
3893 { return reverse_iterator(this->end()); }
3894
3895 /**
3896 * Returns a read-only (constant) reverse iterator that points
3897 * to the last character in the %string. Iteration is done in
3898 * reverse element order.
3899 */
3900 const_reverse_iterator
3901 rbegin() const _GLIBCXX_NOEXCEPT
3902 { return const_reverse_iterator(this->end()); }
3903
3904 /**
3905 * Returns a read/write reverse iterator that points to one before the
3906 * first character in the %string. Iteration is done in reverse
3907 * element order. Unshares the string.
3908 */
3909 reverse_iterator
3910 rend() // FIXME C++11: should be noexcept.
3911 { return reverse_iterator(this->begin()); }
3912
3913 /**
3914 * Returns a read-only (constant) reverse iterator that points
3915 * to one before the first character in the %string. Iteration
3916 * is done in reverse element order.
3917 */
3918 const_reverse_iterator
3919 rend() const _GLIBCXX_NOEXCEPT
3920 { return const_reverse_iterator(this->begin()); }
3921
3922#if __cplusplus >= 201103L
3923 /**
3924 * Returns a read-only (constant) iterator that points to the first
3925 * character in the %string.
3926 */
3927 const_iterator
3928 cbegin() const noexcept
3929 { return const_iterator(this->_M_data()); }
3930
3931 /**
3932 * Returns a read-only (constant) iterator that points one past the
3933 * last character in the %string.
3934 */
3935 const_iterator
3936 cend() const noexcept
3937 { return const_iterator(this->_M_data() + this->size()); }
3938
3939 /**
3940 * Returns a read-only (constant) reverse iterator that points
3941 * to the last character in the %string. Iteration is done in
3942 * reverse element order.
3943 */
3944 const_reverse_iterator
3945 crbegin() const noexcept
3946 { return const_reverse_iterator(this->end()); }
3947
3948 /**
3949 * Returns a read-only (constant) reverse iterator that points
3950 * to one before the first character in the %string. Iteration
3951 * is done in reverse element order.
3952 */
3953 const_reverse_iterator
3954 crend() const noexcept
3955 { return const_reverse_iterator(this->begin()); }
3956#endif
3957
3958 public:
3959 // Capacity:
3960 /// Returns the number of characters in the string, not including any
3961 /// null-termination.
3962 size_type
3963 size() const _GLIBCXX_NOEXCEPT
3964 { return _M_rep()->_M_length; }
3965
3966 /// Returns the number of characters in the string, not including any
3967 /// null-termination.
3968 size_type
3969 length() const _GLIBCXX_NOEXCEPT
3970 { return _M_rep()->_M_length; }
3971
3972 /// Returns the size() of the largest possible %string.
3973 size_type
3974 max_size() const _GLIBCXX_NOEXCEPT
3975 { return _Rep::_S_max_size; }
3976
3977 /**
3978 * @brief Resizes the %string to the specified number of characters.
3979 * @param __n Number of characters the %string should contain.
3980 * @param __c Character to fill any new elements.
3981 *
3982 * This function will %resize the %string to the specified
3983 * number of characters. If the number is smaller than the
3984 * %string's current size the %string is truncated, otherwise
3985 * the %string is extended and new elements are %set to @a __c.
3986 */
3987 void
3988 resize(size_type __n, _CharT __c);
3989
3990 /**
3991 * @brief Resizes the %string to the specified number of characters.
3992 * @param __n Number of characters the %string should contain.
3993 *
3994 * This function will resize the %string to the specified length. If
3995 * the new size is smaller than the %string's current size the %string
3996 * is truncated, otherwise the %string is extended and new characters
3997 * are default-constructed. For basic types such as char, this means
3998 * setting them to 0.
3999 */
4000 void
4001 resize(size_type __n)
4002 { this->resize(__n, _CharT()); }
4003
4004#if __cplusplus >= 201103L
4005#pragma GCC diagnostic push
4006#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
4007 /// A non-binding request to reduce capacity() to size().
4008 void
4009 shrink_to_fit() noexcept
4010 { reserve(); }
4011#pragma GCC diagnostic pop
4012#endif
4013
4014 /**
4015 * Returns the total number of characters that the %string can hold
4016 * before needing to allocate more memory.
4017 */
4018 size_type
4019 capacity() const _GLIBCXX_NOEXCEPT
4020 { return _M_rep()->_M_capacity; }
4021
4022 /**
4023 * @brief Attempt to preallocate enough memory for specified number of
4024 * characters.
4025 * @param __res_arg Number of characters required.
4026 * @throw std::length_error If @a __res_arg exceeds @c max_size().
4027 *
4028 * This function attempts to reserve enough memory for the
4029 * %string to hold the specified number of characters. If the
4030 * number requested is more than max_size(), length_error is
4031 * thrown.
4032 *
4033 * The advantage of this function is that if optimal code is a
4034 * necessity and the user can determine the string length that will be
4035 * required, the user can reserve the memory in %advance, and thus
4036 * prevent a possible reallocation of memory and copying of %string
4037 * data.
4038 */
4039 void
4040 reserve(size_type __res_arg);
4041
4042 /// Equivalent to shrink_to_fit().
4043#if __cplusplus > 201703L
4044 [[deprecated("use shrink_to_fit() instead")]]
4045#endif
4046 void
4047 reserve();
4048
4049 /**
4050 * Erases the string, making it empty.
4051 */
4052#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
4053 void
4054 clear() _GLIBCXX_NOEXCEPT
4055 {
4056 if (_M_rep()->_M_is_shared())
4057 {
4058 _M_rep()->_M_dispose(this->get_allocator());
4059 _M_data(_S_empty_rep()._M_refdata());
4060 }
4061 else
4062 _M_rep()->_M_set_length_and_sharable(0);
4063 }
4064#else
4065 // PR 56166: this should not throw.
4066 void
4067 clear()
4068 { _M_mutate(0, this->size(), 0); }
4069#endif
4070
4071 /**
4072 * Returns true if the %string is empty. Equivalent to
4073 * <code>*this == ""</code>.
4074 */
4075 _GLIBCXX_NODISCARD bool
4076 empty() const _GLIBCXX_NOEXCEPT
4077 { return this->size() == 0; }
4078
4079 // Element access:
4080 /**
4081 * @brief Subscript access to the data contained in the %string.
4082 * @param __pos The index of the character to access.
4083 * @return Read-only (constant) reference to the character.
4084 *
4085 * This operator allows for easy, array-style, data access.
4086 * Note that data access with this operator is unchecked and
4087 * out_of_range lookups are not defined. (For checked lookups
4088 * see at().)
4089 */
4090 const_reference
4091 operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
4092 {
4093 __glibcxx_assert(__pos <= size());
4094 return _M_data()[__pos];
4095 }
4096
4097 /**
4098 * @brief Subscript access to the data contained in the %string.
4099 * @param __pos The index of the character to access.
4100 * @return Read/write reference to the character.
4101 *
4102 * This operator allows for easy, array-style, data access.
4103 * Note that data access with this operator is unchecked and
4104 * out_of_range lookups are not defined. (For checked lookups
4105 * see at().) Unshares the string.
4106 */
4107 reference
4108 operator[](size_type __pos)
4109 {
4110 // Allow pos == size() both in C++98 mode, as v3 extension,
4111 // and in C++11 mode.
4112 __glibcxx_assert(__pos <= size());
4113 // In pedantic mode be strict in C++98 mode.
4114 _GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size());
4115 _M_leak();
4116 return _M_data()[__pos];
4117 }
4118
4119 /**
4120 * @brief Provides access to the data contained in the %string.
4121 * @param __n The index of the character to access.
4122 * @return Read-only (const) reference to the character.
4123 * @throw std::out_of_range If @a n is an invalid index.
4124 *
4125 * This function provides for safer data access. The parameter is
4126 * first checked that it is in the range of the string. The function
4127 * throws out_of_range if the check fails.
4128 */
4129 const_reference
4130 at(size_type __n) const
4131 {
4132 if (__n >= this->size())
4133 __throw_out_of_range_fmt(__N("basic_string::at: __n "
4134 "(which is %zu) >= this->size() "
4135 "(which is %zu)"),
4136 __n, this->size());
4137 return _M_data()[__n];
4138 }
4139
4140 /**
4141 * @brief Provides access to the data contained in the %string.
4142 * @param __n The index of the character to access.
4143 * @return Read/write reference to the character.
4144 * @throw std::out_of_range If @a n is an invalid index.
4145 *
4146 * This function provides for safer data access. The parameter is
4147 * first checked that it is in the range of the string. The function
4148 * throws out_of_range if the check fails. Success results in
4149 * unsharing the string.
4150 */
4151 reference
4152 at(size_type __n)
4153 {
4154 if (__n >= size())
4155 __throw_out_of_range_fmt(__N("basic_string::at: __n "
4156 "(which is %zu) >= this->size() "
4157 "(which is %zu)"),
4158 __n, this->size());
4159 _M_leak();
4160 return _M_data()[__n];
4161 }
4162
4163#if __cplusplus >= 201103L
4164 /**
4165 * Returns a read/write reference to the data at the first
4166 * element of the %string.
4167 */
4168 reference
4169 front()
4170 {
4171 __glibcxx_assert(!empty());
4172 return operator[](0);
4173 }
4174
4175 /**
4176 * Returns a read-only (constant) reference to the data at the first
4177 * element of the %string.
4178 */
4179 const_reference
4180 front() const noexcept
4181 {
4182 __glibcxx_assert(!empty());
4183 return operator[](0);
4184 }
4185
4186 /**
4187 * Returns a read/write reference to the data at the last
4188 * element of the %string.
4189 */
4190 reference
4191 back()
4192 {
4193 __glibcxx_assert(!empty());
4194 return operator[](this->size() - 1);
4195 }
4196
4197 /**
4198 * Returns a read-only (constant) reference to the data at the
4199 * last element of the %string.
4200 */
4201 const_reference
4202 back() const noexcept
4203 {
4204 __glibcxx_assert(!empty());
4205 return operator[](this->size() - 1);
4206 }
4207#endif
4208
4209 // Modifiers:
4210 /**
4211 * @brief Append a string to this string.
4212 * @param __str The string to append.
4213 * @return Reference to this string.
4214 */
4215 basic_string&
4216 operator+=(const basic_string& __str)
4217 { return this->append(__str); }
4218
4219 /**
4220 * @brief Append a C string.
4221 * @param __s The C string to append.
4222 * @return Reference to this string.
4223 */
4224 basic_string&
4225 operator+=(const _CharT* __s)
4226 { return this->append(__s); }
4227
4228 /**
4229 * @brief Append a character.
4230 * @param __c The character to append.
4231 * @return Reference to this string.
4232 */
4233 basic_string&
4234 operator+=(_CharT __c)
4235 {
4236 this->push_back(__c);
4237 return *this;
4238 }
4239
4240#if __cplusplus >= 201103L
4241 /**
4242 * @brief Append an initializer_list of characters.
4243 * @param __l The initializer_list of characters to be appended.
4244 * @return Reference to this string.
4245 */
4246 basic_string&
4247 operator+=(initializer_list<_CharT> __l)
4248 { return this->append(__l.begin(), __l.size()); }
4249#endif // C++11
4250
4251#if __cplusplus >= 201703L
4252 /**
4253 * @brief Append a string_view.
4254 * @param __svt The object convertible to string_view to be appended.
4255 * @return Reference to this string.
4256 */
4257 template<typename _Tp>
4258 _If_sv<_Tp, basic_string&>
4259 operator+=(const _Tp& __svt)
4260 { return this->append(__svt); }
4261#endif // C++17
4262
4263 /**
4264 * @brief Append a string to this string.
4265 * @param __str The string to append.
4266 * @return Reference to this string.
4267 */
4268 basic_string&
4269 append(const basic_string& __str);
4270
4271 /**
4272 * @brief Append a substring.
4273 * @param __str The string to append.
4274 * @param __pos Index of the first character of str to append.
4275 * @param __n The number of characters to append.
4276 * @return Reference to this string.
4277 * @throw std::out_of_range if @a __pos is not a valid index.
4278 *
4279 * This function appends @a __n characters from @a __str
4280 * starting at @a __pos to this string. If @a __n is is larger
4281 * than the number of available characters in @a __str, the
4282 * remainder of @a __str is appended.
4283 */
4284 basic_string&
4285 append(const basic_string& __str, size_type __pos, size_type __n = npos);
4286
4287 /**
4288 * @brief Append a C substring.
4289 * @param __s The C string to append.
4290 * @param __n The number of characters to append.
4291 * @return Reference to this string.
4292 */
4293 basic_string&
4294 append(const _CharT* __s, size_type __n);
4295
4296 /**
4297 * @brief Append a C string.
4298 * @param __s The C string to append.
4299 * @return Reference to this string.
4300 */
4301 basic_string&
4302 append(const _CharT* __s)
4303 {
4304 __glibcxx_requires_string(__s);
4305 return this->append(__s, traits_type::length(__s));
4306 }
4307
4308 /**
4309 * @brief Append multiple characters.
4310 * @param __n The number of characters to append.
4311 * @param __c The character to use.
4312 * @return Reference to this string.
4313 *
4314 * Appends __n copies of __c to this string.
4315 */
4316 basic_string&
4317 append(size_type __n, _CharT __c);
4318
4319#if __cplusplus >= 201103L
4320 /**
4321 * @brief Append an initializer_list of characters.
4322 * @param __l The initializer_list of characters to append.
4323 * @return Reference to this string.
4324 */
4325 basic_string&
4326 append(initializer_list<_CharT> __l)
4327 { return this->append(__l.begin(), __l.size()); }
4328#endif // C++11
4329
4330 /**
4331 * @brief Append a range of characters.
4332 * @param __first Iterator referencing the first character to append.
4333 * @param __last Iterator marking the end of the range.
4334 * @return Reference to this string.
4335 *
4336 * Appends characters in the range [__first,__last) to this string.
4337 */
4338 template<class _InputIterator>
4339 basic_string&
4340 append(_InputIterator __first, _InputIterator __last)
4341 { return this->replace(_M_iend(), _M_iend(), __first, __last); }
4342
4343#if __cplusplus >= 201703L
4344 /**
4345 * @brief Append a string_view.
4346 * @param __svt The object convertible to string_view to be appended.
4347 * @return Reference to this string.
4348 */
4349 template<typename _Tp>
4350 _If_sv<_Tp, basic_string&>
4351 append(const _Tp& __svt)
4352 {
4353 __sv_type __sv = __svt;
4354 return this->append(__sv.data(), __sv.size());
4355 }
4356
4357 /**
4358 * @brief Append a range of characters from a string_view.
4359 * @param __svt The object convertible to string_view to be appended
4360 * from.
4361 * @param __pos The position in the string_view to append from.
4362 * @param __n The number of characters to append from the string_view.
4363 * @return Reference to this string.
4364 */
4365 template<typename _Tp>
4366 _If_sv<_Tp, basic_string&>
4367 append(const _Tp& __svt, size_type __pos, size_type __n = npos)
4368 {
4369 __sv_type __sv = __svt;
4370 return append(__sv.data()
4371 + std::__sv_check(__sv.size(), __pos, "basic_string::append"),
4372 std::__sv_limit(__sv.size(), __pos, __n));
4373 }
4374#endif // C++17
4375
4376 /**
4377 * @brief Append a single character.
4378 * @param __c Character to append.
4379 */
4380 void
4381 push_back(_CharT __c)
4382 {
4383 const size_type __len = 1 + this->size();
4384 if (__len > this->capacity() || _M_rep()->_M_is_shared())
4385 this->reserve(__len);
4386 traits_type::assign(_M_data()[this->size()], __c);
4387 _M_rep()->_M_set_length_and_sharable(__len);
4388 }
4389
4390 /**
4391 * @brief Set value to contents of another string.
4392 * @param __str Source string to use.
4393 * @return Reference to this string.
4394 */
4395 basic_string&
4396 assign(const basic_string& __str);
4397
4398#if __cplusplus >= 201103L
4399 /**
4400 * @brief Set value to contents of another string.
4401 * @param __str Source string to use.
4402 * @return Reference to this string.
4403 *
4404 * This function sets this string to the exact contents of @a __str.
4405 * @a __str is a valid, but unspecified string.
4406 */
4407 basic_string&
4408 assign(basic_string&& __str)
4409 noexcept(allocator_traits<_Alloc>::is_always_equal::value)
4410 {
4411 this->swap(__str);
4412 return *this;
4413 }
4414#endif // C++11
4415
4416 /**
4417 * @brief Set value to a substring of a string.
4418 * @param __str The string to use.
4419 * @param __pos Index of the first character of str.
4420 * @param __n Number of characters to use.
4421 * @return Reference to this string.
4422 * @throw std::out_of_range if @a pos is not a valid index.
4423 *
4424 * This function sets this string to the substring of @a __str
4425 * consisting of @a __n characters at @a __pos. If @a __n is
4426 * is larger than the number of available characters in @a
4427 * __str, the remainder of @a __str is used.
4428 */
4429 basic_string&
4430 assign(const basic_string& __str, size_type __pos, size_type __n = npos)
4431 { return this->assign(__str._M_data()
4432 + __str._M_check(__pos, "basic_string::assign"),
4433 __str._M_limit(__pos, __n)); }
4434
4435 /**
4436 * @brief Set value to a C substring.
4437 * @param __s The C string to use.
4438 * @param __n Number of characters to use.
4439 * @return Reference to this string.
4440 *
4441 * This function sets the value of this string to the first @a __n
4442 * characters of @a __s. If @a __n is is larger than the number of
4443 * available characters in @a __s, the remainder of @a __s is used.
4444 */
4445 basic_string&
4446 assign(const _CharT* __s, size_type __n);
4447
4448 /**
4449 * @brief Set value to contents of a C string.
4450 * @param __s The C string to use.
4451 * @return Reference to this string.
4452 *
4453 * This function sets the value of this string to the value of @a __s.
4454 * The data is copied, so there is no dependence on @a __s once the
4455 * function returns.
4456 */
4457 basic_string&
4458 assign(const _CharT* __s)
4459 {
4460 __glibcxx_requires_string(__s);
4461 return this->assign(__s, traits_type::length(__s));
4462 }
4463
4464 /**
4465 * @brief Set value to multiple characters.
4466 * @param __n Length of the resulting string.
4467 * @param __c The character to use.
4468 * @return Reference to this string.
4469 *
4470 * This function sets the value of this string to @a __n copies of
4471 * character @a __c.
4472 */
4473 basic_string&
4474 assign(size_type __n, _CharT __c)
4475 { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
4476
4477 /**
4478 * @brief Set value to a range of characters.
4479 * @param __first Iterator referencing the first character to append.
4480 * @param __last Iterator marking the end of the range.
4481 * @return Reference to this string.
4482 *
4483 * Sets value of string to characters in the range [__first,__last).
4484 */
4485 template<class _InputIterator>
4486 basic_string&
4487 assign(_InputIterator __first, _InputIterator __last)
4488 { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
4489
4490#if __cplusplus >= 201103L
4491 /**
4492 * @brief Set value to an initializer_list of characters.
4493 * @param __l The initializer_list of characters to assign.
4494 * @return Reference to this string.
4495 */
4496 basic_string&
4497 assign(initializer_list<_CharT> __l)
4498 { return this->assign(__l.begin(), __l.size()); }
4499#endif // C++11
4500
4501#if __cplusplus >= 201703L
4502 /**
4503 * @brief Set value from a string_view.
4504 * @param __svt The source object convertible to string_view.
4505 * @return Reference to this string.
4506 */
4507 template<typename _Tp>
4508 _If_sv<_Tp, basic_string&>
4509 assign(const _Tp& __svt)
4510 {
4511 __sv_type __sv = __svt;
4512 return this->assign(__sv.data(), __sv.size());
4513 }
4514
4515 /**
4516 * @brief Set value from a range of characters in a string_view.
4517 * @param __svt The source object convertible to string_view.
4518 * @param __pos The position in the string_view to assign from.
4519 * @param __n The number of characters to assign.
4520 * @return Reference to this string.
4521 */
4522 template<typename _Tp>
4523 _If_sv<_Tp, basic_string&>
4524 assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
4525 {
4526 __sv_type __sv = __svt;
4527 return assign(__sv.data()
4528 + std::__sv_check(__sv.size(), __pos, "basic_string::assign"),
4529 std::__sv_limit(__sv.size(), __pos, __n));
4530 }
4531#endif // C++17
4532
4533 /**
4534 * @brief Insert multiple characters.
4535 * @param __p Iterator referencing location in string to insert at.
4536 * @param __n Number of characters to insert
4537 * @param __c The character to insert.
4538 * @throw std::length_error If new length exceeds @c max_size().
4539 *
4540 * Inserts @a __n copies of character @a __c starting at the
4541 * position referenced by iterator @a __p. If adding
4542 * characters causes the length to exceed max_size(),
4543 * length_error is thrown. The value of the string doesn't
4544 * change if an error is thrown.
4545 */
4546 void
4547 insert(iterator __p, size_type __n, _CharT __c)
4548 { this->replace(__p, __p, __n, __c); }
4549
4550 /**
4551 * @brief Insert a range of characters.
4552 * @param __p Iterator referencing location in string to insert at.
4553 * @param __beg Start of range.
4554 * @param __end End of range.
4555 * @throw std::length_error If new length exceeds @c max_size().
4556 *
4557 * Inserts characters in range [__beg,__end). If adding
4558 * characters causes the length to exceed max_size(),
4559 * length_error is thrown. The value of the string doesn't
4560 * change if an error is thrown.
4561 */
4562 template<class _InputIterator>
4563 void
4564 insert(iterator __p, _InputIterator __beg, _InputIterator __end)
4565 { this->replace(__p, __p, __beg, __end); }
4566
4567#if __cplusplus >= 201103L
4568 /**
4569 * @brief Insert an initializer_list of characters.
4570 * @param __p Iterator referencing location in string to insert at.
4571 * @param __l The initializer_list of characters to insert.
4572 * @throw std::length_error If new length exceeds @c max_size().
4573 */
4574 void
4575 insert(iterator __p, initializer_list<_CharT> __l)
4576 {
4577 _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
4578 this->insert(__p - _M_ibegin(), __l.begin(), __l.size());
4579 }
4580#endif // C++11
4581
4582 /**
4583 * @brief Insert value of a string.
4584 * @param __pos1 Position in string to insert at.
4585 * @param __str The string to insert.
4586 * @return Reference to this string.
4587 * @throw std::length_error If new length exceeds @c max_size().
4588 *
4589 * Inserts value of @a __str starting at @a __pos1. If adding
4590 * characters causes the length to exceed max_size(),
4591 * length_error is thrown. The value of the string doesn't
4592 * change if an error is thrown.
4593 */
4594 basic_string&
4595 insert(size_type __pos1, const basic_string& __str)
4596 { return this->insert(__pos1, __str, size_type(0), __str.size()); }
4597
4598 /**
4599 * @brief Insert a substring.
4600 * @param __pos1 Position in string to insert at.
4601 * @param __str The string to insert.
4602 * @param __pos2 Start of characters in str to insert.
4603 * @param __n Number of characters to insert.
4604 * @return Reference to this string.
4605 * @throw std::length_error If new length exceeds @c max_size().
4606 * @throw std::out_of_range If @a pos1 > size() or
4607 * @a __pos2 > @a str.size().
4608 *
4609 * Starting at @a pos1, insert @a __n character of @a __str
4610 * beginning with @a __pos2. If adding characters causes the
4611 * length to exceed max_size(), length_error is thrown. If @a
4612 * __pos1 is beyond the end of this string or @a __pos2 is
4613 * beyond the end of @a __str, out_of_range is thrown. The
4614 * value of the string doesn't change if an error is thrown.
4615 */
4616 basic_string&
4617 insert(size_type __pos1, const basic_string& __str,
4618 size_type __pos2, size_type __n = npos)
4619 { return this->insert(__pos1, __str._M_data()
4620 + __str._M_check(__pos2, "basic_string::insert"),
4621 __str._M_limit(__pos2, __n)); }
4622
4623 /**
4624 * @brief Insert a C substring.
4625 * @param __pos Position in string to insert at.
4626 * @param __s The C string to insert.
4627 * @param __n The number of characters to insert.
4628 * @return Reference to this string.
4629 * @throw std::length_error If new length exceeds @c max_size().
4630 * @throw std::out_of_range If @a __pos is beyond the end of this
4631 * string.
4632 *
4633 * Inserts the first @a __n characters of @a __s starting at @a
4634 * __pos. If adding characters causes the length to exceed
4635 * max_size(), length_error is thrown. If @a __pos is beyond
4636 * end(), out_of_range is thrown. The value of the string
4637 * doesn't change if an error is thrown.
4638 */
4639 basic_string&
4640 insert(size_type __pos, const _CharT* __s, size_type __n);
4641
4642 /**
4643 * @brief Insert a C string.
4644 * @param __pos Position in string to insert at.
4645 * @param __s The C string to insert.
4646 * @return Reference to this string.
4647 * @throw std::length_error If new length exceeds @c max_size().
4648 * @throw std::out_of_range If @a pos is beyond the end of this
4649 * string.
4650 *
4651 * Inserts the first @a n characters of @a __s starting at @a __pos. If
4652 * adding characters causes the length to exceed max_size(),
4653 * length_error is thrown. If @a __pos is beyond end(), out_of_range is
4654 * thrown. The value of the string doesn't change if an error is
4655 * thrown.
4656 */
4657 basic_string&
4658 insert(size_type __pos, const _CharT* __s)
4659 {
4660 __glibcxx_requires_string(__s);
4661 return this->insert(__pos, __s, traits_type::length(__s));
4662 }
4663
4664 /**
4665 * @brief Insert multiple characters.
4666 * @param __pos Index in string to insert at.
4667 * @param __n Number of characters to insert
4668 * @param __c The character to insert.
4669 * @return Reference to this string.
4670 * @throw std::length_error If new length exceeds @c max_size().
4671 * @throw std::out_of_range If @a __pos is beyond the end of this
4672 * string.
4673 *
4674 * Inserts @a __n copies of character @a __c starting at index
4675 * @a __pos. If adding characters causes the length to exceed
4676 * max_size(), length_error is thrown. If @a __pos > length(),
4677 * out_of_range is thrown. The value of the string doesn't
4678 * change if an error is thrown.
4679 */
4680 basic_string&
4681 insert(size_type __pos, size_type __n, _CharT __c)
4682 { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
4683 size_type(0), __n, __c); }
4684
4685 /**
4686 * @brief Insert one character.
4687 * @param __p Iterator referencing position in string to insert at.
4688 * @param __c The character to insert.
4689 * @return Iterator referencing newly inserted char.
4690 * @throw std::length_error If new length exceeds @c max_size().
4691 *
4692 * Inserts character @a __c at position referenced by @a __p.
4693 * If adding character causes the length to exceed max_size(),
4694 * length_error is thrown. If @a __p is beyond end of string,
4695 * out_of_range is thrown. The value of the string doesn't
4696 * change if an error is thrown.
4697 */
4698 iterator
4699 insert(iterator __p, _CharT __c)
4700 {
4701 _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
4702 const size_type __pos = __p - _M_ibegin();
4703 _M_replace_aux(__pos, size_type(0), size_type(1), __c);
4704 _M_rep()->_M_set_leaked();
4705 return iterator(_M_data() + __pos);
4706 }
4707
4708#if __cplusplus >= 201703L
4709 /**
4710 * @brief Insert a string_view.
4711 * @param __pos Position in string to insert at.
4712 * @param __svt The object convertible to string_view to insert.
4713 * @return Reference to this string.
4714 */
4715 template<typename _Tp>
4716 _If_sv<_Tp, basic_string&>
4717 insert(size_type __pos, const _Tp& __svt)
4718 {
4719 __sv_type __sv = __svt;
4720 return this->insert(__pos, __sv.data(), __sv.size());
4721 }
4722
4723 /**
4724 * @brief Insert a string_view.
4725 * @param __pos1 Position in string to insert at.
4726 * @param __svt The object convertible to string_view to insert from.
4727 * @param __pos2 Position in string_view to insert from.
4728 * @param __n The number of characters to insert.
4729 * @return Reference to this string.
4730 */
4731 template<typename _Tp>
4732 _If_sv<_Tp, basic_string&>
4733 insert(size_type __pos1, const _Tp& __svt,
4734 size_type __pos2, size_type __n = npos)
4735 {
4736 __sv_type __sv = __svt;
4737 return this->replace(__pos1, size_type(0), __sv.data()
4738 + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"),
4739 std::__sv_limit(__sv.size(), __pos2, __n));
4740 }
4741#endif // C++17
4742
4743 /**
4744 * @brief Remove characters.
4745 * @param __pos Index of first character to remove (default 0).
4746 * @param __n Number of characters to remove (default remainder).
4747 * @return Reference to this string.
4748 * @throw std::out_of_range If @a pos is beyond the end of this
4749 * string.
4750 *
4751 * Removes @a __n characters from this string starting at @a
4752 * __pos. The length of the string is reduced by @a __n. If
4753 * there are < @a __n characters to remove, the remainder of
4754 * the string is truncated. If @a __p is beyond end of string,
4755 * out_of_range is thrown. The value of the string doesn't
4756 * change if an error is thrown.
4757 */
4758 basic_string&
4759 erase(size_type __pos = 0, size_type __n = npos)
4760 {
4761 _M_mutate(_M_check(__pos, "basic_string::erase"),
4762 _M_limit(__pos, __n), size_type(0));
4763 return *this;
4764 }
4765
4766 /**
4767 * @brief Remove one character.
4768 * @param __position Iterator referencing the character to remove.
4769 * @return iterator referencing same location after removal.
4770 *
4771 * Removes the character at @a __position from this string. The value
4772 * of the string doesn't change if an error is thrown.
4773 */
4774 iterator
4775 erase(iterator __position)
4776 {
4777 _GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin()
4778 && __position < _M_iend());
4779 const size_type __pos = __position - _M_ibegin();
4780 _M_mutate(__pos, size_type(1), size_type(0));
4781 _M_rep()->_M_set_leaked();
4782 return iterator(_M_data() + __pos);
4783 }
4784
4785 /**
4786 * @brief Remove a range of characters.
4787 * @param __first Iterator referencing the first character to remove.
4788 * @param __last Iterator referencing the end of the range.
4789 * @return Iterator referencing location of first after removal.
4790 *
4791 * Removes the characters in the range [first,last) from this string.
4792 * The value of the string doesn't change if an error is thrown.
4793 */
4794 iterator
4795 erase(iterator __first, iterator __last);
4796
4797#if __cplusplus >= 201103L
4798 /**
4799 * @brief Remove the last character.
4800 *
4801 * The string must be non-empty.
4802 */
4803 void
4804 pop_back() // FIXME C++11: should be noexcept.
4805 {
4806 __glibcxx_assert(!empty());
4807 erase(size() - 1, 1);
4808 }
4809#endif // C++11
4810
4811 /**
4812 * @brief Replace characters with value from another string.
4813 * @param __pos Index of first character to replace.
4814 * @param __n Number of characters to be replaced.
4815 * @param __str String to insert.
4816 * @return Reference to this string.
4817 * @throw std::out_of_range If @a pos is beyond the end of this
4818 * string.
4819 * @throw std::length_error If new length exceeds @c max_size().
4820 *
4821 * Removes the characters in the range [__pos,__pos+__n) from
4822 * this string. In place, the value of @a __str is inserted.
4823 * If @a __pos is beyond end of string, out_of_range is thrown.
4824 * If the length of the result exceeds max_size(), length_error
4825 * is thrown. The value of the string doesn't change if an
4826 * error is thrown.
4827 */
4828 basic_string&
4829 replace(size_type __pos, size_type __n, const basic_string& __str)
4830 { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
4831
4832 /**
4833 * @brief Replace characters with value from another string.
4834 * @param __pos1 Index of first character to replace.
4835 * @param __n1 Number of characters to be replaced.
4836 * @param __str String to insert.
4837 * @param __pos2 Index of first character of str to use.
4838 * @param __n2 Number of characters from str to use.
4839 * @return Reference to this string.
4840 * @throw std::out_of_range If @a __pos1 > size() or @a __pos2 >
4841 * __str.size().
4842 * @throw std::length_error If new length exceeds @c max_size().
4843 *
4844 * Removes the characters in the range [__pos1,__pos1 + n) from this
4845 * string. In place, the value of @a __str is inserted. If @a __pos is
4846 * beyond end of string, out_of_range is thrown. If the length of the
4847 * result exceeds max_size(), length_error is thrown. The value of the
4848 * string doesn't change if an error is thrown.
4849 */
4850 basic_string&
4851 replace(size_type __pos1, size_type __n1, const basic_string& __str,
4852 size_type __pos2, size_type __n2 = npos)
4853 { return this->replace(__pos1, __n1, __str._M_data()
4854 + __str._M_check(__pos2, "basic_string::replace"),
4855 __str._M_limit(__pos2, __n2)); }
4856
4857 /**
4858 * @brief Replace characters with value of a C substring.
4859 * @param __pos Index of first character to replace.
4860 * @param __n1 Number of characters to be replaced.
4861 * @param __s C string to insert.
4862 * @param __n2 Number of characters from @a s to use.
4863 * @return Reference to this string.
4864 * @throw std::out_of_range If @a pos1 > size().
4865 * @throw std::length_error If new length exceeds @c max_size().
4866 *
4867 * Removes the characters in the range [__pos,__pos + __n1)
4868 * from this string. In place, the first @a __n2 characters of
4869 * @a __s are inserted, or all of @a __s if @a __n2 is too large. If
4870 * @a __pos is beyond end of string, out_of_range is thrown. If
4871 * the length of result exceeds max_size(), length_error is
4872 * thrown. The value of the string doesn't change if an error
4873 * is thrown.
4874 */
4875 basic_string&
4876 replace(size_type __pos, size_type __n1, const _CharT* __s,
4877 size_type __n2);
4878
4879 /**
4880 * @brief Replace characters with value of a C string.
4881 * @param __pos Index of first character to replace.
4882 * @param __n1 Number of characters to be replaced.
4883 * @param __s C string to insert.
4884 * @return Reference to this string.
4885 * @throw std::out_of_range If @a pos > size().
4886 * @throw std::length_error If new length exceeds @c max_size().
4887 *
4888 * Removes the characters in the range [__pos,__pos + __n1)
4889 * from this string. In place, the characters of @a __s are
4890 * inserted. If @a __pos is beyond end of string, out_of_range
4891 * is thrown. If the length of result exceeds max_size(),
4892 * length_error is thrown. The value of the string doesn't
4893 * change if an error is thrown.
4894 */
4895 basic_string&
4896 replace(size_type __pos, size_type __n1, const _CharT* __s)
4897 {
4898 __glibcxx_requires_string(__s);
4899 return this->replace(__pos, __n1, __s, traits_type::length(__s));
4900 }
4901
4902 /**
4903 * @brief Replace characters with multiple characters.
4904 * @param __pos Index of first character to replace.
4905 * @param __n1 Number of characters to be replaced.
4906 * @param __n2 Number of characters to insert.
4907 * @param __c Character to insert.
4908 * @return Reference to this string.
4909 * @throw std::out_of_range If @a __pos > size().
4910 * @throw std::length_error If new length exceeds @c max_size().
4911 *
4912 * Removes the characters in the range [pos,pos + n1) from this
4913 * string. In place, @a __n2 copies of @a __c are inserted.
4914 * If @a __pos is beyond end of string, out_of_range is thrown.
4915 * If the length of result exceeds max_size(), length_error is
4916 * thrown. The value of the string doesn't change if an error
4917 * is thrown.
4918 */
4919 basic_string&
4920 replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
4921 { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
4922 _M_limit(__pos, __n1), __n2, __c); }
4923
4924 /**
4925 * @brief Replace range of characters with string.
4926 * @param __i1 Iterator referencing start of range to replace.
4927 * @param __i2 Iterator referencing end of range to replace.
4928 * @param __str String value to insert.
4929 * @return Reference to this string.
4930 * @throw std::length_error If new length exceeds @c max_size().
4931 *
4932 * Removes the characters in the range [__i1,__i2). In place,
4933 * the value of @a __str is inserted. If the length of result
4934 * exceeds max_size(), length_error is thrown. The value of
4935 * the string doesn't change if an error is thrown.
4936 */
4937 basic_string&
4938 replace(iterator __i1, iterator __i2, const basic_string& __str)
4939 { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
4940
4941 /**
4942 * @brief Replace range of characters with C substring.
4943 * @param __i1 Iterator referencing start of range to replace.
4944 * @param __i2 Iterator referencing end of range to replace.
4945 * @param __s C string value to insert.
4946 * @param __n Number of characters from s to insert.
4947 * @return Reference to this string.
4948 * @throw std::length_error If new length exceeds @c max_size().
4949 *
4950 * Removes the characters in the range [__i1,__i2). In place,
4951 * the first @a __n characters of @a __s are inserted. If the
4952 * length of result exceeds max_size(), length_error is thrown.
4953 * The value of the string doesn't change if an error is
4954 * thrown.
4955 */
4956 basic_string&
4957 replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
4958 {
4959 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
4960 && __i2 <= _M_iend());
4961 return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
4962 }
4963
4964 /**
4965 * @brief Replace range of characters with C string.
4966 * @param __i1 Iterator referencing start of range to replace.
4967 * @param __i2 Iterator referencing end of range to replace.
4968 * @param __s C string value to insert.
4969 * @return Reference to this string.
4970 * @throw std::length_error If new length exceeds @c max_size().
4971 *
4972 * Removes the characters in the range [__i1,__i2). In place,
4973 * the characters of @a __s are inserted. If the length of
4974 * result exceeds max_size(), length_error is thrown. The
4975 * value of the string doesn't change if an error is thrown.
4976 */
4977 basic_string&
4978 replace(iterator __i1, iterator __i2, const _CharT* __s)
4979 {
4980 __glibcxx_requires_string(__s);
4981 return this->replace(__i1, __i2, __s, traits_type::length(__s));
4982 }
4983
4984 /**
4985 * @brief Replace range of characters with multiple characters
4986 * @param __i1 Iterator referencing start of range to replace.
4987 * @param __i2 Iterator referencing end of range to replace.
4988 * @param __n Number of characters to insert.
4989 * @param __c Character to insert.
4990 * @return Reference to this string.
4991 * @throw std::length_error If new length exceeds @c max_size().
4992 *
4993 * Removes the characters in the range [__i1,__i2). In place,
4994 * @a __n copies of @a __c are inserted. If the length of
4995 * result exceeds max_size(), length_error is thrown. The
4996 * value of the string doesn't change if an error is thrown.
4997 */
4998 basic_string&
4999 replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
5000 {
5001 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
5002 && __i2 <= _M_iend());
5003 return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
5004 }
5005
5006 /**
5007 * @brief Replace range of characters with range.
5008 * @param __i1 Iterator referencing start of range to replace.
5009 * @param __i2 Iterator referencing end of range to replace.
5010 * @param __k1 Iterator referencing start of range to insert.
5011 * @param __k2 Iterator referencing end of range to insert.
5012 * @return Reference to this string.
5013 * @throw std::length_error If new length exceeds @c max_size().
5014 *
5015 * Removes the characters in the range [__i1,__i2). In place,
5016 * characters in the range [__k1,__k2) are inserted. If the
5017 * length of result exceeds max_size(), length_error is thrown.
5018 * The value of the string doesn't change if an error is
5019 * thrown.
5020 */
5021 template<class _InputIterator>
5022 basic_string&
5023 replace(iterator __i1, iterator __i2,
5024 _InputIterator __k1, _InputIterator __k2)
5025 {
5026 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
5027 && __i2 <= _M_iend());
5028 __glibcxx_requires_valid_range(__k1, __k2);
5029 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
5030 return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
5031 }
5032
5033 // Specializations for the common case of pointer and iterator:
5034 // useful to avoid the overhead of temporary buffering in _M_replace.
5035 basic_string&
5036 replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
5037 {
5038 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
5039 && __i2 <= _M_iend());
5040 __glibcxx_requires_valid_range(__k1, __k2);
5041 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
5042 __k1, __k2 - __k1);
5043 }
5044
5045 basic_string&
5046 replace(iterator __i1, iterator __i2,
5047 const _CharT* __k1, const _CharT* __k2)
5048 {
5049 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
5050 && __i2 <= _M_iend());
5051 __glibcxx_requires_valid_range(__k1, __k2);
5052 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
5053 __k1, __k2 - __k1);
5054 }
5055
5056 basic_string&
5057 replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
5058 {
5059 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
5060 && __i2 <= _M_iend());
5061 __glibcxx_requires_valid_range(__k1, __k2);
5062 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
5063 __k1.base(), __k2 - __k1);
5064 }
5065
5066 basic_string&
5067 replace(iterator __i1, iterator __i2,
5068 const_iterator __k1, const_iterator __k2)
5069 {
5070 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
5071 && __i2 <= _M_iend());
5072 __glibcxx_requires_valid_range(__k1, __k2);
5073 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
5074 __k1.base(), __k2 - __k1);
5075 }
5076
5077#if __cplusplus >= 201103L
5078 /**
5079 * @brief Replace range of characters with initializer_list.
5080 * @param __i1 Iterator referencing start of range to replace.
5081 * @param __i2 Iterator referencing end of range to replace.
5082 * @param __l The initializer_list of characters to insert.
5083 * @return Reference to this string.
5084 * @throw std::length_error If new length exceeds @c max_size().
5085 *
5086 * Removes the characters in the range [__i1,__i2). In place,
5087 * characters in the range [__k1,__k2) are inserted. If the
5088 * length of result exceeds max_size(), length_error is thrown.
5089 * The value of the string doesn't change if an error is
5090 * thrown.
5091 */
5092 basic_string& replace(iterator __i1, iterator __i2,
5093 initializer_list<_CharT> __l)
5094 { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
5095#endif // C++11
5096
5097#if __cplusplus >= 201703L
5098 /**
5099 * @brief Replace range of characters with string_view.
5100 * @param __pos The position to replace at.
5101 * @param __n The number of characters to replace.
5102 * @param __svt The object convertible to string_view to insert.
5103 * @return Reference to this string.
5104 */
5105 template<typename _Tp>
5106 _If_sv<_Tp, basic_string&>
5107 replace(size_type __pos, size_type __n, const _Tp& __svt)
5108 {
5109 __sv_type __sv = __svt;
5110 return this->replace(__pos, __n, __sv.data(), __sv.size());
5111 }
5112
5113 /**
5114 * @brief Replace range of characters with string_view.
5115 * @param __pos1 The position to replace at.
5116 * @param __n1 The number of characters to replace.
5117 * @param __svt The object convertible to string_view to insert from.
5118 * @param __pos2 The position in the string_view to insert from.
5119 * @param __n2 The number of characters to insert.
5120 * @return Reference to this string.
5121 */
5122 template<typename _Tp>
5123 _If_sv<_Tp, basic_string&>
5124 replace(size_type __pos1, size_type __n1, const _Tp& __svt,
5125 size_type __pos2, size_type __n2 = npos)
5126 {
5127 __sv_type __sv = __svt;
5128 return this->replace(__pos1, __n1,
5129 __sv.data()
5130 + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"),
5131 std::__sv_limit(__sv.size(), __pos2, __n2));
5132 }
5133
5134 /**
5135 * @brief Replace range of characters with string_view.
5136 * @param __i1 An iterator referencing the start position
5137 to replace at.
5138 * @param __i2 An iterator referencing the end position
5139 for the replace.
5140 * @param __svt The object convertible to string_view to insert from.
5141 * @return Reference to this string.
5142 */
5143 template<typename _Tp>
5144 _If_sv<_Tp, basic_string&>
5145 replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
5146 {
5147 __sv_type __sv = __svt;
5148 return this->replace(__i1 - begin(), __i2 - __i1, __sv);
5149 }
5150#endif // C++17
5151
5152 private:
5153 template<class _Integer>
5154 basic_string&
5155 _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
5156 _Integer __val, __true_type)
5157 { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
5158
5159 template<class _InputIterator>
5160 basic_string&
5161 _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
5162 _InputIterator __k2, __false_type);
5163
5164 basic_string&
5165 _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
5166 _CharT __c);
5167
5168 basic_string&
5169 _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
5170 size_type __n2);
5171
5172 // _S_construct_aux is used to implement the 21.3.1 para 15 which
5173 // requires special behaviour if _InIter is an integral type
5174 template<class _InIterator>
5175 static _CharT*
5176 _S_construct_aux(_InIterator __beg, _InIterator __end,
5177 const _Alloc& __a, __false_type)
5178 {
5179 typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
5180 return _S_construct(__beg, __end, __a, _Tag());
5181 }
5182
5183 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5184 // 438. Ambiguity in the "do the right thing" clause
5185 template<class _Integer>
5186 static _CharT*
5187 _S_construct_aux(_Integer __beg, _Integer __end,
5188 const _Alloc& __a, __true_type)
5189 { return _S_construct_aux_2(static_cast<size_type>(__beg),
5190 __end, __a); }
5191
5192 static _CharT*
5193 _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
5194 { return _S_construct(__req, __c, __a); }
5195
5196 template<class _InIterator>
5197 static _CharT*
5198 _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
5199 {
5200 typedef typename std::__is_integer<_InIterator>::__type _Integral;
5201 return _S_construct_aux(__beg, __end, __a, _Integral());
5202 }
5203
5204 // For Input Iterators, used in istreambuf_iterators, etc.
5205 template<class _InIterator>
5206 static _CharT*
5207 _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
5208 input_iterator_tag);
5209
5210 // For forward_iterators up to random_access_iterators, used for
5211 // string::iterator, _CharT*, etc.
5212 template<class _FwdIterator>
5213 static _CharT*
5214 _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
5215 forward_iterator_tag);
5216
5217 static _CharT*
5218 _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
5219
5220 public:
5221
5222 /**
5223 * @brief Copy substring into C string.
5224 * @param __s C string to copy value into.
5225 * @param __n Number of characters to copy.
5226 * @param __pos Index of first character to copy.
5227 * @return Number of characters actually copied
5228 * @throw std::out_of_range If __pos > size().
5229 *
5230 * Copies up to @a __n characters starting at @a __pos into the
5231 * C string @a __s. If @a __pos is %greater than size(),
5232 * out_of_range is thrown.
5233 */
5234 size_type
5235 copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
5236
5237 /**
5238 * @brief Swap contents with another string.
5239 * @param __s String to swap with.
5240 *
5241 * Exchanges the contents of this string with that of @a __s in constant
5242 * time.
5243 */
5244 void
5245 swap(basic_string& __s)
5246 _GLIBCXX_NOEXCEPT_IF(allocator_traits<_Alloc>::is_always_equal::value);
5247
5248 // String operations:
5249 /**
5250 * @brief Return const pointer to null-terminated contents.
5251 *
5252 * This is a handle to internal data. Do not modify or dire things may
5253 * happen.
5254 */
5255 const _CharT*
5256 c_str() const _GLIBCXX_NOEXCEPT
5257 { return _M_data(); }
5258
5259 /**
5260 * @brief Return const pointer to contents.
5261 *
5262 * This is a pointer to internal data. It is undefined to modify
5263 * the contents through the returned pointer. To get a pointer that
5264 * allows modifying the contents use @c &str[0] instead,
5265 * (or in C++17 the non-const @c str.data() overload).
5266 */
5267 const _CharT*
5268 data() const _GLIBCXX_NOEXCEPT
5269 { return _M_data(); }
5270
5271#if __cplusplus >= 201703L
5272 /**
5273 * @brief Return non-const pointer to contents.
5274 *
5275 * This is a pointer to the character sequence held by the string.
5276 * Modifying the characters in the sequence is allowed.
5277 */
5278 _CharT*
5279 data() noexcept
5280 {
5281 _M_leak();
5282 return _M_data();
5283 }
5284#endif
5285
5286 /**
5287 * @brief Return copy of allocator used to construct this string.
5288 */
5289 allocator_type
5290 get_allocator() const _GLIBCXX_NOEXCEPT
5291 { return _M_dataplus; }
5292
5293 /**
5294 * @brief Find position of a C substring.
5295 * @param __s C string to locate.
5296 * @param __pos Index of character to search from.
5297 * @param __n Number of characters from @a s to search for.
5298 * @return Index of start of first occurrence.
5299 *
5300 * Starting from @a __pos, searches forward for the first @a
5301 * __n characters in @a __s within this string. If found,
5302 * returns the index where it begins. If not found, returns
5303 * npos.
5304 */
5305 size_type
5306 find(const _CharT* __s, size_type __pos, size_type __n) const
5307 _GLIBCXX_NOEXCEPT;
5308
5309 /**
5310 * @brief Find position of a string.
5311 * @param __str String to locate.
5312 * @param __pos Index of character to search from (default 0).
5313 * @return Index of start of first occurrence.
5314 *
5315 * Starting from @a __pos, searches forward for value of @a __str within
5316 * this string. If found, returns the index where it begins. If not
5317 * found, returns npos.
5318 */
5319 size_type
5320 find(const basic_string& __str, size_type __pos = 0) const
5321 _GLIBCXX_NOEXCEPT
5322 { return this->find(__str.data(), __pos, __str.size()); }
5323
5324 /**
5325 * @brief Find position of a C string.
5326 * @param __s C string to locate.
5327 * @param __pos Index of character to search from (default 0).
5328 * @return Index of start of first occurrence.
5329 *
5330 * Starting from @a __pos, searches forward for the value of @a
5331 * __s within this string. If found, returns the index where
5332 * it begins. If not found, returns npos.
5333 */
5334 size_type
5335 find(const _CharT* __s, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
5336 {
5337 __glibcxx_requires_string(__s);
5338 return this->find(__s, __pos, traits_type::length(__s));
5339 }
5340
5341 /**
5342 * @brief Find position of a character.
5343 * @param __c Character to locate.
5344 * @param __pos Index of character to search from (default 0).
5345 * @return Index of first occurrence.
5346 *
5347 * Starting from @a __pos, searches forward for @a __c within
5348 * this string. If found, returns the index where it was
5349 * found. If not found, returns npos.
5350 */
5351 size_type
5352 find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT;
5353
5354#if __cplusplus >= 201703L
5355 /**
5356 * @brief Find position of a string_view.
5357 * @param __svt The object convertible to string_view to locate.
5358 * @param __pos Index of character to search from (default 0).
5359 * @return Index of start of first occurrence.
5360 */
5361 template<typename _Tp>
5362 _If_sv<_Tp, size_type>
5363 find(const _Tp& __svt, size_type __pos = 0) const
5364 noexcept(is_same<_Tp, __sv_type>::value)
5365 {
5366 __sv_type __sv = __svt;
5367 return this->find(__sv.data(), __pos, __sv.size());
5368 }
5369#endif // C++17
5370
5371 /**
5372 * @brief Find last position of a string.
5373 * @param __str String to locate.
5374 * @param __pos Index of character to search back from (default end).
5375 * @return Index of start of last occurrence.
5376 *
5377 * Starting from @a __pos, searches backward for value of @a
5378 * __str within this string. If found, returns the index where
5379 * it begins. If not found, returns npos.
5380 */
5381 size_type
5382 rfind(const basic_string& __str, size_type __pos = npos) const
5383 _GLIBCXX_NOEXCEPT
5384 { return this->rfind(__str.data(), __pos, __str.size()); }
5385
5386 /**
5387 * @brief Find last position of a C substring.
5388 * @param __s C string to locate.
5389 * @param __pos Index of character to search back from.
5390 * @param __n Number of characters from s to search for.
5391 * @return Index of start of last occurrence.
5392 *
5393 * Starting from @a __pos, searches backward for the first @a
5394 * __n characters in @a __s within this string. If found,
5395 * returns the index where it begins. If not found, returns
5396 * npos.
5397 */
5398 size_type
5399 rfind(const _CharT* __s, size_type __pos, size_type __n) const
5400 _GLIBCXX_NOEXCEPT;
5401
5402 /**
5403 * @brief Find last position of a C string.
5404 * @param __s C string to locate.
5405 * @param __pos Index of character to start search at (default end).
5406 * @return Index of start of last occurrence.
5407 *
5408 * Starting from @a __pos, searches backward for the value of
5409 * @a __s within this string. If found, returns the index
5410 * where it begins. If not found, returns npos.
5411 */
5412 size_type
5413 rfind(const _CharT* __s, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
5414 {
5415 __glibcxx_requires_string(__s);
5416 return this->rfind(__s, __pos, traits_type::length(__s));
5417 }
5418
5419 /**
5420 * @brief Find last position of a character.
5421 * @param __c Character to locate.
5422 * @param __pos Index of character to search back from (default end).
5423 * @return Index of last occurrence.
5424 *
5425 * Starting from @a __pos, searches backward for @a __c within
5426 * this string. If found, returns the index where it was
5427 * found. If not found, returns npos.
5428 */
5429 size_type
5430 rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT;
5431
5432#if __cplusplus >= 201703L
5433 /**
5434 * @brief Find last position of a string_view.
5435 * @param __svt The object convertible to string_view to locate.
5436 * @param __pos Index of character to search back from (default end).
5437 * @return Index of start of last occurrence.
5438 */
5439 template<typename _Tp>
5440 _If_sv<_Tp, size_type>
5441 rfind(const _Tp& __svt, size_type __pos = npos) const
5442 noexcept(is_same<_Tp, __sv_type>::value)
5443 {
5444 __sv_type __sv = __svt;
5445 return this->rfind(__sv.data(), __pos, __sv.size());
5446 }
5447#endif // C++17
5448
5449 /**
5450 * @brief Find position of a character of string.
5451 * @param __str String containing characters to locate.
5452 * @param __pos Index of character to search from (default 0).
5453 * @return Index of first occurrence.
5454 *
5455 * Starting from @a __pos, searches forward for one of the
5456 * characters of @a __str within this string. If found,
5457 * returns the index where it was found. If not found, returns
5458 * npos.
5459 */
5460 size_type
5461 find_first_of(const basic_string& __str, size_type __pos = 0) const
5462 _GLIBCXX_NOEXCEPT
5463 { return this->find_first_of(__str.data(), __pos, __str.size()); }
5464
5465 /**
5466 * @brief Find position of a character of C substring.
5467 * @param __s String containing characters to locate.
5468 * @param __pos Index of character to search from.
5469 * @param __n Number of characters from s to search for.
5470 * @return Index of first occurrence.
5471 *
5472 * Starting from @a __pos, searches forward for one of the
5473 * first @a __n characters of @a __s within this string. If
5474 * found, returns the index where it was found. If not found,
5475 * returns npos.
5476 */
5477 size_type
5478 find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
5479 _GLIBCXX_NOEXCEPT;
5480
5481 /**
5482 * @brief Find position of a character of C string.
5483 * @param __s String containing characters to locate.
5484 * @param __pos Index of character to search from (default 0).
5485 * @return Index of first occurrence.
5486 *
5487 * Starting from @a __pos, searches forward for one of the
5488 * characters of @a __s within this string. If found, returns
5489 * the index where it was found. If not found, returns npos.
5490 */
5491 size_type
5492 find_first_of(const _CharT* __s, size_type __pos = 0) const
5493 _GLIBCXX_NOEXCEPT
5494 {
5495 __glibcxx_requires_string(__s);
5496 return this->find_first_of(__s, __pos, traits_type::length(__s));
5497 }
5498
5499 /**
5500 * @brief Find position of a character.
5501 * @param __c Character to locate.
5502 * @param __pos Index of character to search from (default 0).
5503 * @return Index of first occurrence.
5504 *
5505 * Starting from @a __pos, searches forward for the character
5506 * @a __c within this string. If found, returns the index
5507 * where it was found. If not found, returns npos.
5508 *
5509 * Note: equivalent to find(__c, __pos).
5510 */
5511 size_type
5512 find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
5513 { return this->find(__c, __pos); }
5514
5515#if __cplusplus >= 201703L
5516 /**
5517 * @brief Find position of a character of a string_view.
5518 * @param __svt An object convertible to string_view containing
5519 * characters to locate.
5520 * @param __pos Index of character to search from (default 0).
5521 * @return Index of first occurrence.
5522 */
5523 template<typename _Tp>
5524 _If_sv<_Tp, size_type>
5525 find_first_of(const _Tp& __svt, size_type __pos = 0) const
5526 noexcept(is_same<_Tp, __sv_type>::value)
5527 {
5528 __sv_type __sv = __svt;
5529 return this->find_first_of(__sv.data(), __pos, __sv.size());
5530 }
5531#endif // C++17
5532
5533 /**
5534 * @brief Find last position of a character of string.
5535 * @param __str String containing characters to locate.
5536 * @param __pos Index of character to search back from (default end).
5537 * @return Index of last occurrence.
5538 *
5539 * Starting from @a __pos, searches backward for one of the
5540 * characters of @a __str within this string. If found,
5541 * returns the index where it was found. If not found, returns
5542 * npos.
5543 */
5544 size_type
5545 find_last_of(const basic_string& __str, size_type __pos = npos) const
5546 _GLIBCXX_NOEXCEPT
5547 { return this->find_last_of(__str.data(), __pos, __str.size()); }
5548
5549 /**
5550 * @brief Find last position of a character of C substring.
5551 * @param __s C string containing characters to locate.
5552 * @param __pos Index of character to search back from.
5553 * @param __n Number of characters from s to search for.
5554 * @return Index of last occurrence.
5555 *
5556 * Starting from @a __pos, searches backward for one of the
5557 * first @a __n characters of @a __s within this string. If
5558 * found, returns the index where it was found. If not found,
5559 * returns npos.
5560 */
5561 size_type
5562 find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
5563 _GLIBCXX_NOEXCEPT;
5564
5565 /**
5566 * @brief Find last position of a character of C string.
5567 * @param __s C string containing characters to locate.
5568 * @param __pos Index of character to search back from (default end).
5569 * @return Index of last occurrence.
5570 *
5571 * Starting from @a __pos, searches backward for one of the
5572 * characters of @a __s within this string. If found, returns
5573 * the index where it was found. If not found, returns npos.
5574 */
5575 size_type
5576 find_last_of(const _CharT* __s, size_type __pos = npos) const
5577 _GLIBCXX_NOEXCEPT
5578 {
5579 __glibcxx_requires_string(__s);
5580 return this->find_last_of(__s, __pos, traits_type::length(__s));
5581 }
5582
5583 /**
5584 * @brief Find last position of a character.
5585 * @param __c Character to locate.
5586 * @param __pos Index of character to search back from (default end).
5587 * @return Index of last occurrence.
5588 *
5589 * Starting from @a __pos, searches backward for @a __c within
5590 * this string. If found, returns the index where it was
5591 * found. If not found, returns npos.
5592 *
5593 * Note: equivalent to rfind(__c, __pos).
5594 */
5595 size_type
5596 find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
5597 { return this->rfind(__c, __pos); }
5598
5599#if __cplusplus >= 201703L
5600 /**
5601 * @brief Find last position of a character of string.
5602 * @param __svt An object convertible to string_view containing
5603 * characters to locate.
5604 * @param __pos Index of character to search back from (default end).
5605 * @return Index of last occurrence.
5606 */
5607 template<typename _Tp>
5608 _If_sv<_Tp, size_type>
5609 find_last_of(const _Tp& __svt, size_type __pos = npos) const
5610 noexcept(is_same<_Tp, __sv_type>::value)
5611 {
5612 __sv_type __sv = __svt;
5613 return this->find_last_of(__sv.data(), __pos, __sv.size());
5614 }
5615#endif // C++17
5616
5617 /**
5618 * @brief Find position of a character not in string.
5619 * @param __str String containing characters to avoid.
5620 * @param __pos Index of character to search from (default 0).
5621 * @return Index of first occurrence.
5622 *
5623 * Starting from @a __pos, searches forward for a character not contained
5624 * in @a __str within this string. If found, returns the index where it
5625 * was found. If not found, returns npos.
5626 */
5627 size_type
5628 find_first_not_of(const basic_string& __str, size_type __pos = 0) const
5629 _GLIBCXX_NOEXCEPT
5630 { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
5631
5632 /**
5633 * @brief Find position of a character not in C substring.
5634 * @param __s C string containing characters to avoid.
5635 * @param __pos Index of character to search from.
5636 * @param __n Number of characters from __s to consider.
5637 * @return Index of first occurrence.
5638 *
5639 * Starting from @a __pos, searches forward for a character not
5640 * contained in the first @a __n characters of @a __s within
5641 * this string. If found, returns the index where it was
5642 * found. If not found, returns npos.
5643 */
5644 size_type
5645 find_first_not_of(const _CharT* __s, size_type __pos,
5646 size_type __n) const _GLIBCXX_NOEXCEPT;
5647
5648 /**
5649 * @brief Find position of a character not in C string.
5650 * @param __s C string containing characters to avoid.
5651 * @param __pos Index of character to search from (default 0).
5652 * @return Index of first occurrence.
5653 *
5654 * Starting from @a __pos, searches forward for a character not
5655 * contained in @a __s within this string. If found, returns
5656 * the index where it was found. If not found, returns npos.
5657 */
5658 size_type
5659 find_first_not_of(const _CharT* __s, size_type __pos = 0) const
5660 _GLIBCXX_NOEXCEPT
5661 {
5662 __glibcxx_requires_string(__s);
5663 return this->find_first_not_of(__s, __pos, traits_type::length(__s));
5664 }
5665
5666 /**
5667 * @brief Find position of a different character.
5668 * @param __c Character to avoid.
5669 * @param __pos Index of character to search from (default 0).
5670 * @return Index of first occurrence.
5671 *
5672 * Starting from @a __pos, searches forward for a character
5673 * other than @a __c within this string. If found, returns the
5674 * index where it was found. If not found, returns npos.
5675 */
5676 size_type
5677 find_first_not_of(_CharT __c, size_type __pos = 0) const
5678 _GLIBCXX_NOEXCEPT;
5679
5680#if __cplusplus >= 201703L
5681 /**
5682 * @brief Find position of a character not in a string_view.
5683 * @param __svt An object convertible to string_view containing
5684 * characters to avoid.
5685 * @param __pos Index of character to search from (default 0).
5686 * @return Index of first occurrence.
5687 */
5688 template<typename _Tp>
5689 _If_sv<_Tp, size_type>
5690 find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
5691 noexcept(is_same<_Tp, __sv_type>::value)
5692 {
5693 __sv_type __sv = __svt;
5694 return this->find_first_not_of(__sv.data(), __pos, __sv.size());
5695 }
5696#endif // C++17
5697
5698 /**
5699 * @brief Find last position of a character not in string.
5700 * @param __str String containing characters to avoid.
5701 * @param __pos Index of character to search back from (default end).
5702 * @return Index of last occurrence.
5703 *
5704 * Starting from @a __pos, searches backward for a character
5705 * not contained in @a __str within this string. If found,
5706 * returns the index where it was found. If not found, returns
5707 * npos.
5708 */
5709 size_type
5710 find_last_not_of(const basic_string& __str, size_type __pos = npos) const
5711 _GLIBCXX_NOEXCEPT
5712 { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
5713
5714 /**
5715 * @brief Find last position of a character not in C substring.
5716 * @param __s C string containing characters to avoid.
5717 * @param __pos Index of character to search back from.
5718 * @param __n Number of characters from s to consider.
5719 * @return Index of last occurrence.
5720 *
5721 * Starting from @a __pos, searches backward for a character not
5722 * contained in the first @a __n characters of @a __s within this string.
5723 * If found, returns the index where it was found. If not found,
5724 * returns npos.
5725 */
5726 size_type
5727 find_last_not_of(const _CharT* __s, size_type __pos,
5728 size_type __n) const _GLIBCXX_NOEXCEPT;
5729 /**
5730 * @brief Find last position of a character not in C string.
5731 * @param __s C string containing characters to avoid.
5732 * @param __pos Index of character to search back from (default end).
5733 * @return Index of last occurrence.
5734 *
5735 * Starting from @a __pos, searches backward for a character
5736 * not contained in @a __s within this string. If found,
5737 * returns the index where it was found. If not found, returns
5738 * npos.
5739 */
5740 size_type
5741 find_last_not_of(const _CharT* __s, size_type __pos = npos) const
5742 _GLIBCXX_NOEXCEPT
5743 {
5744 __glibcxx_requires_string(__s);
5745 return this->find_last_not_of(__s, __pos, traits_type::length(__s));
5746 }
5747
5748 /**
5749 * @brief Find last position of a different character.
5750 * @param __c Character to avoid.
5751 * @param __pos Index of character to search back from (default end).
5752 * @return Index of last occurrence.
5753 *
5754 * Starting from @a __pos, searches backward for a character other than
5755 * @a __c within this string. If found, returns the index where it was
5756 * found. If not found, returns npos.
5757 */
5758 size_type
5759 find_last_not_of(_CharT __c, size_type __pos = npos) const
5760 _GLIBCXX_NOEXCEPT;
5761
5762#if __cplusplus >= 201703L
5763 /**
5764 * @brief Find last position of a character not in a string_view.
5765 * @param __svt An object convertible to string_view containing
5766 * characters to avoid.
5767 * @param __pos Index of character to search back from (default end).
5768 * @return Index of last occurrence.
5769 */
5770 template<typename _Tp>
5771 _If_sv<_Tp, size_type>
5772 find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
5773 noexcept(is_same<_Tp, __sv_type>::value)
5774 {
5775 __sv_type __sv = __svt;
5776 return this->find_last_not_of(__sv.data(), __pos, __sv.size());
5777 }
5778#endif // C++17
5779
5780 /**
5781 * @brief Get a substring.
5782 * @param __pos Index of first character (default 0).
5783 * @param __n Number of characters in substring (default remainder).
5784 * @return The new string.
5785 * @throw std::out_of_range If __pos > size().
5786 *
5787 * Construct and return a new string using the @a __n
5788 * characters starting at @a __pos. If the string is too
5789 * short, use the remainder of the characters. If @a __pos is
5790 * beyond the end of the string, out_of_range is thrown.
5791 */
5792 basic_string
5793 substr(size_type __pos = 0, size_type __n = npos) const
5794 { return basic_string(*this,
5795 _M_check(__pos, "basic_string::substr"), __n); }
5796
5797 /**
5798 * @brief Compare to a string.
5799 * @param __str String to compare against.
5800 * @return Integer < 0, 0, or > 0.
5801 *
5802 * Returns an integer < 0 if this string is ordered before @a
5803 * __str, 0 if their values are equivalent, or > 0 if this
5804 * string is ordered after @a __str. Determines the effective
5805 * length rlen of the strings to compare as the smallest of
5806 * size() and str.size(). The function then compares the two
5807 * strings by calling traits::compare(data(), str.data(),rlen).
5808 * If the result of the comparison is nonzero returns it,
5809 * otherwise the shorter one is ordered first.
5810 */
5811 int
5812 compare(const basic_string& __str) const
5813 {
5814 const size_type __size = this->size();
5815 const size_type __osize = __str.size();
5816 const size_type __len = std::min(__size, __osize);
5817
5818 int __r = traits_type::compare(_M_data(), __str.data(), __len);
5819 if (!__r)
5820 __r = _S_compare(__size, __osize);
5821 return __r;
5822 }
5823
5824#if __cplusplus >= 201703L
5825 /**
5826 * @brief Compare to a string_view.
5827 * @param __svt An object convertible to string_view to compare against.
5828 * @return Integer < 0, 0, or > 0.
5829 */
5830 template<typename _Tp>
5831 _If_sv<_Tp, int>
5832 compare(const _Tp& __svt) const
5833 noexcept(is_same<_Tp, __sv_type>::value)
5834 {
5835 __sv_type __sv = __svt;
5836 const size_type __size = this->size();
5837 const size_type __osize = __sv.size();
5838 const size_type __len = std::min(__size, __osize);
5839
5840 int __r = traits_type::compare(_M_data(), __sv.data(), __len);
5841 if (!__r)
5842 __r = _S_compare(__size, __osize);
5843 return __r;
5844 }
5845
5846 /**
5847 * @brief Compare to a string_view.
5848 * @param __pos A position in the string to start comparing from.
5849 * @param __n The number of characters to compare.
5850 * @param __svt An object convertible to string_view to compare
5851 * against.
5852 * @return Integer < 0, 0, or > 0.
5853 */
5854 template<typename _Tp>
5855 _If_sv<_Tp, int>
5856 compare(size_type __pos, size_type __n, const _Tp& __svt) const
5857 noexcept(is_same<_Tp, __sv_type>::value)
5858 {
5859 __sv_type __sv = __svt;
5860 return __sv_type(*this).substr(__pos, __n).compare(__sv);
5861 }
5862
5863 /**
5864 * @brief Compare to a string_view.
5865 * @param __pos1 A position in the string to start comparing from.
5866 * @param __n1 The number of characters to compare.
5867 * @param __svt An object convertible to string_view to compare
5868 * against.
5869 * @param __pos2 A position in the string_view to start comparing from.
5870 * @param __n2 The number of characters to compare.
5871 * @return Integer < 0, 0, or > 0.
5872 */
5873 template<typename _Tp>
5874 _If_sv<_Tp, int>
5875 compare(size_type __pos1, size_type __n1, const _Tp& __svt,
5876 size_type __pos2, size_type __n2 = npos) const
5877 noexcept(is_same<_Tp, __sv_type>::value)
5878 {
5879 __sv_type __sv = __svt;
5880 return __sv_type(*this)
5881 .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
5882 }
5883#endif // C++17
5884
5885 /**
5886 * @brief Compare substring to a string.
5887 * @param __pos Index of first character of substring.
5888 * @param __n Number of characters in substring.
5889 * @param __str String to compare against.
5890 * @return Integer < 0, 0, or > 0.
5891 *
5892 * Form the substring of this string from the @a __n characters
5893 * starting at @a __pos. Returns an integer < 0 if the
5894 * substring is ordered before @a __str, 0 if their values are
5895 * equivalent, or > 0 if the substring is ordered after @a
5896 * __str. Determines the effective length rlen of the strings
5897 * to compare as the smallest of the length of the substring
5898 * and @a __str.size(). The function then compares the two
5899 * strings by calling
5900 * traits::compare(substring.data(),str.data(),rlen). If the
5901 * result of the comparison is nonzero returns it, otherwise
5902 * the shorter one is ordered first.
5903 */
5904 int
5905 compare(size_type __pos, size_type __n, const basic_string& __str) const;
5906
5907 /**
5908 * @brief Compare substring to a substring.
5909 * @param __pos1 Index of first character of substring.
5910 * @param __n1 Number of characters in substring.
5911 * @param __str String to compare against.
5912 * @param __pos2 Index of first character of substring of str.
5913 * @param __n2 Number of characters in substring of str.
5914 * @return Integer < 0, 0, or > 0.
5915 *
5916 * Form the substring of this string from the @a __n1
5917 * characters starting at @a __pos1. Form the substring of @a
5918 * __str from the @a __n2 characters starting at @a __pos2.
5919 * Returns an integer < 0 if this substring is ordered before
5920 * the substring of @a __str, 0 if their values are equivalent,
5921 * or > 0 if this substring is ordered after the substring of
5922 * @a __str. Determines the effective length rlen of the
5923 * strings to compare as the smallest of the lengths of the
5924 * substrings. The function then compares the two strings by
5925 * calling
5926 * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
5927 * If the result of the comparison is nonzero returns it,
5928 * otherwise the shorter one is ordered first.
5929 */
5930 int
5931 compare(size_type __pos1, size_type __n1, const basic_string& __str,
5932 size_type __pos2, size_type __n2 = npos) const;
5933
5934 /**
5935 * @brief Compare to a C string.
5936 * @param __s C string to compare against.
5937 * @return Integer < 0, 0, or > 0.
5938 *
5939 * Returns an integer < 0 if this string is ordered before @a __s, 0 if
5940 * their values are equivalent, or > 0 if this string is ordered after
5941 * @a __s. Determines the effective length rlen of the strings to
5942 * compare as the smallest of size() and the length of a string
5943 * constructed from @a __s. The function then compares the two strings
5944 * by calling traits::compare(data(),s,rlen). If the result of the
5945 * comparison is nonzero returns it, otherwise the shorter one is
5946 * ordered first.
5947 */
5948 int
5949 compare(const _CharT* __s) const _GLIBCXX_NOEXCEPT;
5950
5951 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5952 // 5 String::compare specification questionable
5953 /**
5954 * @brief Compare substring to a C string.
5955 * @param __pos Index of first character of substring.
5956 * @param __n1 Number of characters in substring.
5957 * @param __s C string to compare against.
5958 * @return Integer < 0, 0, or > 0.
5959 *
5960 * Form the substring of this string from the @a __n1
5961 * characters starting at @a pos. Returns an integer < 0 if
5962 * the substring is ordered before @a __s, 0 if their values
5963 * are equivalent, or > 0 if the substring is ordered after @a
5964 * __s. Determines the effective length rlen of the strings to
5965 * compare as the smallest of the length of the substring and
5966 * the length of a string constructed from @a __s. The
5967 * function then compares the two string by calling
5968 * traits::compare(substring.data(),__s,rlen). If the result of
5969 * the comparison is nonzero returns it, otherwise the shorter
5970 * one is ordered first.
5971 */
5972 int
5973 compare(size_type __pos, size_type __n1, const _CharT* __s) const;
5974
5975 /**
5976 * @brief Compare substring against a character %array.
5977 * @param __pos Index of first character of substring.
5978 * @param __n1 Number of characters in substring.
5979 * @param __s character %array to compare against.
5980 * @param __n2 Number of characters of s.
5981 * @return Integer < 0, 0, or > 0.
5982 *
5983 * Form the substring of this string from the @a __n1
5984 * characters starting at @a __pos. Form a string from the
5985 * first @a __n2 characters of @a __s. Returns an integer < 0
5986 * if this substring is ordered before the string from @a __s,
5987 * 0 if their values are equivalent, or > 0 if this substring
5988 * is ordered after the string from @a __s. Determines the
5989 * effective length rlen of the strings to compare as the
5990 * smallest of the length of the substring and @a __n2. The
5991 * function then compares the two strings by calling
5992 * traits::compare(substring.data(),s,rlen). If the result of
5993 * the comparison is nonzero returns it, otherwise the shorter
5994 * one is ordered first.
5995 *
5996 * NB: s must have at least n2 characters, &apos;\\0&apos; has
5997 * no special meaning.
5998 */
5999 int
6000 compare(size_type __pos, size_type __n1, const _CharT* __s,
6001 size_type __n2) const;
6002
6003#if __cplusplus > 201703L
6004 bool
6005 starts_with(basic_string_view<_CharT, _Traits> __x) const noexcept
6006 { return __sv_type(this->data(), this->size()).starts_with(__x); }
6007
6008 bool
6009 starts_with(_CharT __x) const noexcept
6010 { return __sv_type(this->data(), this->size()).starts_with(__x); }
6011
6012 bool
6013 starts_with(const _CharT* __x) const noexcept
6014 { return __sv_type(this->data(), this->size()).starts_with(__x); }
6015
6016 bool
6017 ends_with(basic_string_view<_CharT, _Traits> __x) const noexcept
6018 { return __sv_type(this->data(), this->size()).ends_with(__x); }
6019
6020 bool
6021 ends_with(_CharT __x) const noexcept
6022 { return __sv_type(this->data(), this->size()).ends_with(__x); }
6023
6024 bool
6025 ends_with(const _CharT* __x) const noexcept
6026 { return __sv_type(this->data(), this->size()).ends_with(__x); }
6027#endif // C++20
6028
6029#if __cplusplus > 202011L
6030 bool
6031 contains(basic_string_view<_CharT, _Traits> __x) const noexcept
6032 { return __sv_type(this->data(), this->size()).contains(__x); }
6033
6034 bool
6035 contains(_CharT __x) const noexcept
6036 { return __sv_type(this->data(), this->size()).contains(__x); }
6037
6038 bool
6039 contains(const _CharT* __x) const noexcept
6040 { return __sv_type(this->data(), this->size()).contains(__x); }
6041#endif // C++23
6042
6043# ifdef _GLIBCXX_TM_TS_INTERNAL
6044 friend void
6045 ::_txnal_cow_string_C1_for_exceptions(void* that, const char* s,
6046 void* exc);
6047 friend const char*
6048 ::_txnal_cow_string_c_str(const void *that);
6049 friend void
6050 ::_txnal_cow_string_D1(void *that);
6051 friend void
6052 ::_txnal_cow_string_D1_commit(void *that);
6053# endif
6054 };
6055#endif // !_GLIBCXX_USE_CXX11_ABI
6056
6057#if __cpp_deduction_guides >= 201606
6058_GLIBCXX_BEGIN_NAMESPACE_CXX11
6059 template<typename _InputIterator, typename _CharT
6060 = typename iterator_traits<_InputIterator>::value_type,
6061 typename _Allocator = allocator<_CharT>,
6062 typename = _RequireInputIter<_InputIterator>,
6063 typename = _RequireAllocator<_Allocator>>
6064 basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
6065 -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
6066
6067 // _GLIBCXX_RESOLVE_LIB_DEFECTS
6068 // 3075. basic_string needs deduction guides from basic_string_view
6069 template<typename _CharT, typename _Traits,
6070 typename _Allocator = allocator<_CharT>,
6071 typename = _RequireAllocator<_Allocator>>
6072 basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
6073 -> basic_string<_CharT, _Traits, _Allocator>;
6074
6075 template<typename _CharT, typename _Traits,
6076 typename _Allocator = allocator<_CharT>,
6077 typename = _RequireAllocator<_Allocator>>
6078 basic_string(basic_string_view<_CharT, _Traits>,
6079 typename basic_string<_CharT, _Traits, _Allocator>::size_type,
6080 typename basic_string<_CharT, _Traits, _Allocator>::size_type,
6081 const _Allocator& = _Allocator())
6082 -> basic_string<_CharT, _Traits, _Allocator>;
6083_GLIBCXX_END_NAMESPACE_CXX11
6084#endif
6085
6086 // operator+
6087 /**
6088 * @brief Concatenate two strings.
6089 * @param __lhs First string.
6090 * @param __rhs Last string.
6091 * @return New string with value of @a __lhs followed by @a __rhs.
6092 */
6093 template<typename _CharT, typename _Traits, typename _Alloc>
6094 basic_string<_CharT, _Traits, _Alloc>
6095 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6096 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6097 {
6098 basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
6099 __str.append(__rhs);
6100 return __str;
6101 }
6102
6103 /**
6104 * @brief Concatenate C string and string.
6105 * @param __lhs First string.
6106 * @param __rhs Last string.
6107 * @return New string with value of @a __lhs followed by @a __rhs.
6108 */
6109 template<typename _CharT, typename _Traits, typename _Alloc>
6110 basic_string<_CharT,_Traits,_Alloc>
6111 operator+(const _CharT* __lhs,
6112 const basic_string<_CharT,_Traits,_Alloc>& __rhs);
6113
6114 /**
6115 * @brief Concatenate character and string.
6116 * @param __lhs First string.
6117 * @param __rhs Last string.
6118 * @return New string with @a __lhs followed by @a __rhs.
6119 */
6120 template<typename _CharT, typename _Traits, typename _Alloc>
6121 basic_string<_CharT,_Traits,_Alloc>
6122 operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
6123
6124 /**
6125 * @brief Concatenate string and C string.
6126 * @param __lhs First string.
6127 * @param __rhs Last string.
6128 * @return New string with @a __lhs followed by @a __rhs.
6129 */
6130 template<typename _CharT, typename _Traits, typename _Alloc>
6131 inline basic_string<_CharT, _Traits, _Alloc>
6132 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6133 const _CharT* __rhs)
6134 {
6135 basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
6136 __str.append(__rhs);
6137 return __str;
6138 }
6139
6140 /**
6141 * @brief Concatenate string and character.
6142 * @param __lhs First string.
6143 * @param __rhs Last string.
6144 * @return New string with @a __lhs followed by @a __rhs.
6145 */
6146 template<typename _CharT, typename _Traits, typename _Alloc>
6147 inline basic_string<_CharT, _Traits, _Alloc>
6148 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
6149 {
6150 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
6151 typedef typename __string_type::size_type __size_type;
6152 __string_type __str(__lhs);
6153 __str.append(__size_type(1), __rhs);
6154 return __str;
6155 }
6156
6157#if __cplusplus >= 201103L
6158 template<typename _CharT, typename _Traits, typename _Alloc>
6159 inline basic_string<_CharT, _Traits, _Alloc>
6160 operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
6161 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6162 { return std::move(__lhs.append(__rhs)); }
6163
6164 template<typename _CharT, typename _Traits, typename _Alloc>
6165 inline basic_string<_CharT, _Traits, _Alloc>
6166 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6167 basic_string<_CharT, _Traits, _Alloc>&& __rhs)
6168 { return std::move(__rhs.insert(0, __lhs)); }
6169
6170 template<typename _CharT, typename _Traits, typename _Alloc>
6171 inline basic_string<_CharT, _Traits, _Alloc>
6172 operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
6173 basic_string<_CharT, _Traits, _Alloc>&& __rhs)
6174 {
6175#if _GLIBCXX_USE_CXX11_ABI
6176 using _Alloc_traits = allocator_traits<_Alloc>;
6177 bool __use_rhs = false;
6178 if _GLIBCXX17_CONSTEXPR (typename _Alloc_traits::is_always_equal{})
6179 __use_rhs = true;
6180 else if (__lhs.get_allocator() == __rhs.get_allocator())
6181 __use_rhs = true;
6182 if (__use_rhs)
6183#endif
6184 {
6185 const auto __size = __lhs.size() + __rhs.size();
6186 if (__size > __lhs.capacity() && __size <= __rhs.capacity())
6187 return std::move(__rhs.insert(0, __lhs));
6188 }
6189 return std::move(__lhs.append(__rhs));
6190 }
6191
6192 template<typename _CharT, typename _Traits, typename _Alloc>
6193 inline basic_string<_CharT, _Traits, _Alloc>
6194 operator+(const _CharT* __lhs,
6195 basic_string<_CharT, _Traits, _Alloc>&& __rhs)
6196 { return std::move(__rhs.insert(0, __lhs)); }
6197
6198 template<typename _CharT, typename _Traits, typename _Alloc>
6199 inline basic_string<_CharT, _Traits, _Alloc>
6200 operator+(_CharT __lhs,
6201 basic_string<_CharT, _Traits, _Alloc>&& __rhs)
6202 { return std::move(__rhs.insert(0, 1, __lhs)); }
6203
6204 template<typename _CharT, typename _Traits, typename _Alloc>
6205 inline basic_string<_CharT, _Traits, _Alloc>
6206 operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
6207 const _CharT* __rhs)
6208 { return std::move(__lhs.append(__rhs)); }
6209
6210 template<typename _CharT, typename _Traits, typename _Alloc>
6211 inline basic_string<_CharT, _Traits, _Alloc>
6212 operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
6213 _CharT __rhs)
6214 { return std::move(__lhs.append(1, __rhs)); }
6215#endif
6216
6217 // operator ==
6218 /**
6219 * @brief Test equivalence of two strings.
6220 * @param __lhs First string.
6221 * @param __rhs Second string.
6222 * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
6223 */
6224 template<typename _CharT, typename _Traits, typename _Alloc>
6225 inline bool
6226 operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6227 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6228 _GLIBCXX_NOEXCEPT
6229 { return __lhs.compare(__rhs) == 0; }
6230
6231 template<typename _CharT>
6232 inline
6233 typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
6234 operator==(const basic_string<_CharT>& __lhs,
6235 const basic_string<_CharT>& __rhs) _GLIBCXX_NOEXCEPT
6236 { return (__lhs.size() == __rhs.size()
6237 && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
6238 __lhs.size())); }
6239
6240 /**
6241 * @brief Test equivalence of string and C string.
6242 * @param __lhs String.
6243 * @param __rhs C string.
6244 * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
6245 */
6246 template<typename _CharT, typename _Traits, typename _Alloc>
6247 inline bool
6248 operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6249 const _CharT* __rhs)
6250 { return __lhs.compare(__rhs) == 0; }
6251
6252#if __cpp_lib_three_way_comparison
6253 /**
6254 * @brief Three-way comparison of a string and a C string.
6255 * @param __lhs A string.
6256 * @param __rhs A null-terminated string.
6257 * @return A value indicating whether `__lhs` is less than, equal to,
6258 * greater than, or incomparable with `__rhs`.
6259 */
6260 template<typename _CharT, typename _Traits, typename _Alloc>
6261 inline auto
6262 operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6263 const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept
6264 -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
6265 { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
6266
6267 /**
6268 * @brief Three-way comparison of a string and a C string.
6269 * @param __lhs A string.
6270 * @param __rhs A null-terminated string.
6271 * @return A value indicating whether `__lhs` is less than, equal to,
6272 * greater than, or incomparable with `__rhs`.
6273 */
6274 template<typename _CharT, typename _Traits, typename _Alloc>
6275 inline auto
6276 operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6277 const _CharT* __rhs) noexcept
6278 -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
6279 { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
6280#else
6281 /**
6282 * @brief Test equivalence of C string and string.
6283 * @param __lhs C string.
6284 * @param __rhs String.
6285 * @return True if @a __rhs.compare(@a __lhs) == 0. False otherwise.
6286 */
6287 template<typename _CharT, typename _Traits, typename _Alloc>
6288 inline bool
6289 operator==(const _CharT* __lhs,
6290 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6291 { return __rhs.compare(__lhs) == 0; }
6292
6293 // operator !=
6294 /**
6295 * @brief Test difference of two strings.
6296 * @param __lhs First string.
6297 * @param __rhs Second string.
6298 * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise.
6299 */
6300 template<typename _CharT, typename _Traits, typename _Alloc>
6301 inline bool
6302 operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6303 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6304 _GLIBCXX_NOEXCEPT
6305 { return !(__lhs == __rhs); }
6306
6307 /**
6308 * @brief Test difference of C string and string.
6309 * @param __lhs C string.
6310 * @param __rhs String.
6311 * @return True if @a __rhs.compare(@a __lhs) != 0. False otherwise.
6312 */
6313 template<typename _CharT, typename _Traits, typename _Alloc>
6314 inline bool
6315 operator!=(const _CharT* __lhs,
6316 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6317 { return !(__lhs == __rhs); }
6318
6319 /**
6320 * @brief Test difference of string and C string.
6321 * @param __lhs String.
6322 * @param __rhs C string.
6323 * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise.
6324 */
6325 template<typename _CharT, typename _Traits, typename _Alloc>
6326 inline bool
6327 operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6328 const _CharT* __rhs)
6329 { return !(__lhs == __rhs); }
6330
6331 // operator <
6332 /**
6333 * @brief Test if string precedes string.
6334 * @param __lhs First string.
6335 * @param __rhs Second string.
6336 * @return True if @a __lhs precedes @a __rhs. False otherwise.
6337 */
6338 template<typename _CharT, typename _Traits, typename _Alloc>
6339 inline bool
6340 operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6341 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6342 _GLIBCXX_NOEXCEPT
6343 { return __lhs.compare(__rhs) < 0; }
6344
6345 /**
6346 * @brief Test if string precedes C string.
6347 * @param __lhs String.
6348 * @param __rhs C string.
6349 * @return True if @a __lhs precedes @a __rhs. False otherwise.
6350 */
6351 template<typename _CharT, typename _Traits, typename _Alloc>
6352 inline bool
6353 operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6354 const _CharT* __rhs)
6355 { return __lhs.compare(__rhs) < 0; }
6356
6357 /**
6358 * @brief Test if C string precedes string.
6359 * @param __lhs C string.
6360 * @param __rhs String.
6361 * @return True if @a __lhs precedes @a __rhs. False otherwise.
6362 */
6363 template<typename _CharT, typename _Traits, typename _Alloc>
6364 inline bool
6365 operator<(const _CharT* __lhs,
6366 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6367 { return __rhs.compare(__lhs) > 0; }
6368
6369 // operator >
6370 /**
6371 * @brief Test if string follows string.
6372 * @param __lhs First string.
6373 * @param __rhs Second string.
6374 * @return True if @a __lhs follows @a __rhs. False otherwise.
6375 */
6376 template<typename _CharT, typename _Traits, typename _Alloc>
6377 inline bool
6378 operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6379 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6380 _GLIBCXX_NOEXCEPT
6381 { return __lhs.compare(__rhs) > 0; }
6382
6383 /**
6384 * @brief Test if string follows C string.
6385 * @param __lhs String.
6386 * @param __rhs C string.
6387 * @return True if @a __lhs follows @a __rhs. False otherwise.
6388 */
6389 template<typename _CharT, typename _Traits, typename _Alloc>
6390 inline bool
6391 operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6392 const _CharT* __rhs)
6393 { return __lhs.compare(__rhs) > 0; }
6394
6395 /**
6396 * @brief Test if C string follows string.
6397 * @param __lhs C string.
6398 * @param __rhs String.
6399 * @return True if @a __lhs follows @a __rhs. False otherwise.
6400 */
6401 template<typename _CharT, typename _Traits, typename _Alloc>
6402 inline bool
6403 operator>(const _CharT* __lhs,
6404 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6405 { return __rhs.compare(__lhs) < 0; }
6406
6407 // operator <=
6408 /**
6409 * @brief Test if string doesn't follow string.
6410 * @param __lhs First string.
6411 * @param __rhs Second string.
6412 * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
6413 */
6414 template<typename _CharT, typename _Traits, typename _Alloc>
6415 inline bool
6416 operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6417 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6418 _GLIBCXX_NOEXCEPT
6419 { return __lhs.compare(__rhs) <= 0; }
6420
6421 /**
6422 * @brief Test if string doesn't follow C string.
6423 * @param __lhs String.
6424 * @param __rhs C string.
6425 * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
6426 */
6427 template<typename _CharT, typename _Traits, typename _Alloc>
6428 inline bool
6429 operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6430 const _CharT* __rhs)
6431 { return __lhs.compare(__rhs) <= 0; }
6432
6433 /**
6434 * @brief Test if C string doesn't follow string.
6435 * @param __lhs C string.
6436 * @param __rhs String.
6437 * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
6438 */
6439 template<typename _CharT, typename _Traits, typename _Alloc>
6440 inline bool
6441 operator<=(const _CharT* __lhs,
6442 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6443 { return __rhs.compare(__lhs) >= 0; }
6444
6445 // operator >=
6446 /**
6447 * @brief Test if string doesn't precede string.
6448 * @param __lhs First string.
6449 * @param __rhs Second string.
6450 * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
6451 */
6452 template<typename _CharT, typename _Traits, typename _Alloc>
6453 inline bool
6454 operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6455 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6456 _GLIBCXX_NOEXCEPT
6457 { return __lhs.compare(__rhs) >= 0; }
6458
6459 /**
6460 * @brief Test if string doesn't precede C string.
6461 * @param __lhs String.
6462 * @param __rhs C string.
6463 * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
6464 */
6465 template<typename _CharT, typename _Traits, typename _Alloc>
6466 inline bool
6467 operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6468 const _CharT* __rhs)
6469 { return __lhs.compare(__rhs) >= 0; }
6470
6471 /**
6472 * @brief Test if C string doesn't precede string.
6473 * @param __lhs C string.
6474 * @param __rhs String.
6475 * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
6476 */
6477 template<typename _CharT, typename _Traits, typename _Alloc>
6478 inline bool
6479 operator>=(const _CharT* __lhs,
6480 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6481 { return __rhs.compare(__lhs) <= 0; }
6482#endif // three-way comparison
6483
6484 /**
6485 * @brief Swap contents of two strings.
6486 * @param __lhs First string.
6487 * @param __rhs Second string.
6488 *
6489 * Exchanges the contents of @a __lhs and @a __rhs in constant time.
6490 */
6491 template<typename _CharT, typename _Traits, typename _Alloc>
6492 inline void
6493 swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
6494 basic_string<_CharT, _Traits, _Alloc>& __rhs)
6495 _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
6496 { __lhs.swap(__rhs); }
6497
6498
6499 /**
6500 * @brief Read stream into a string.
6501 * @param __is Input stream.
6502 * @param __str Buffer to store into.
6503 * @return Reference to the input stream.
6504 *
6505 * Stores characters from @a __is into @a __str until whitespace is
6506 * found, the end of the stream is encountered, or str.max_size()
6507 * is reached. If is.width() is non-zero, that is the limit on the
6508 * number of characters stored into @a __str. Any previous
6509 * contents of @a __str are erased.
6510 */
6511 template<typename _CharT, typename _Traits, typename _Alloc>
6512 basic_istream<_CharT, _Traits>&
6513 operator>>(basic_istream<_CharT, _Traits>& __is,
6514 basic_string<_CharT, _Traits, _Alloc>& __str);
6515
6516 template<>
6517 basic_istream<char>&
6518 operator>>(basic_istream<char>& __is, basic_string<char>& __str);
6519
6520 /**
6521 * @brief Write string to a stream.
6522 * @param __os Output stream.
6523 * @param __str String to write out.
6524 * @return Reference to the output stream.
6525 *
6526 * Output characters of @a __str into os following the same rules as for
6527 * writing a C string.
6528 */
6529 template<typename _CharT, typename _Traits, typename _Alloc>
6530 inline basic_ostream<_CharT, _Traits>&
6531 operator<<(basic_ostream<_CharT, _Traits>& __os,
6532 const basic_string<_CharT, _Traits, _Alloc>& __str)
6533 {
6534 // _GLIBCXX_RESOLVE_LIB_DEFECTS
6535 // 586. string inserter not a formatted function
6536 return __ostream_insert(__os, __str.data(), __str.size());
6537 }
6538
6539 /**
6540 * @brief Read a line from stream into a string.
6541 * @param __is Input stream.
6542 * @param __str Buffer to store into.
6543 * @param __delim Character marking end of line.
6544 * @return Reference to the input stream.
6545 *
6546 * Stores characters from @a __is into @a __str until @a __delim is
6547 * found, the end of the stream is encountered, or str.max_size()
6548 * is reached. Any previous contents of @a __str are erased. If
6549 * @a __delim is encountered, it is extracted but not stored into
6550 * @a __str.
6551 */
6552 template<typename _CharT, typename _Traits, typename _Alloc>
6553 basic_istream<_CharT, _Traits>&
6554 getline(basic_istream<_CharT, _Traits>& __is,
6555 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
6556
6557 /**
6558 * @brief Read a line from stream into a string.
6559 * @param __is Input stream.
6560 * @param __str Buffer to store into.
6561 * @return Reference to the input stream.
6562 *
6563 * Stores characters from is into @a __str until &apos;\n&apos; is
6564 * found, the end of the stream is encountered, or str.max_size()
6565 * is reached. Any previous contents of @a __str are erased. If
6566 * end of line is encountered, it is extracted but not stored into
6567 * @a __str.
6568 */
6569 template<typename _CharT, typename _Traits, typename _Alloc>
6570 inline basic_istream<_CharT, _Traits>&
6571 getline(basic_istream<_CharT, _Traits>& __is,
6572 basic_string<_CharT, _Traits, _Alloc>& __str)
6573 { return std::getline(__is, __str, __is.widen('\n')); }
6574
6575#if __cplusplus >= 201103L
6576 /// Read a line from an rvalue stream into a string.
6577 template<typename _CharT, typename _Traits, typename _Alloc>
6578 inline basic_istream<_CharT, _Traits>&
6579 getline(basic_istream<_CharT, _Traits>&& __is,
6580 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
6581 { return std::getline(__is, __str, __delim); }
6582
6583 /// Read a line from an rvalue stream into a string.
6584 template<typename _CharT, typename _Traits, typename _Alloc>
6585 inline basic_istream<_CharT, _Traits>&
6586 getline(basic_istream<_CharT, _Traits>&& __is,
6587 basic_string<_CharT, _Traits, _Alloc>& __str)
6588 { return std::getline(__is, __str); }
6589#endif
6590
6591 template<>
6592 basic_istream<char>&
6593 getline(basic_istream<char>& __in, basic_string<char>& __str,
6594 char __delim);
6595
6596#ifdef _GLIBCXX_USE_WCHAR_T
6597 template<>
6598 basic_istream<wchar_t>&
6599 getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
6600 wchar_t __delim);
6601#endif
6602
6603_GLIBCXX_END_NAMESPACE_VERSION
6604} // namespace
6605
6606#if __cplusplus >= 201103L
6607
6608#include <ext/string_conversions.h>
6609#include <bits/charconv.h>
6610
6611namespace std _GLIBCXX_VISIBILITY(default)
6612{
6613_GLIBCXX_BEGIN_NAMESPACE_VERSION
6614_GLIBCXX_BEGIN_NAMESPACE_CXX11
6615
6616#if _GLIBCXX_USE_C99_STDLIB
6617 // 21.4 Numeric Conversions [string.conversions].
6618 inline int
6619 stoi(const string& __str, size_t* __idx = 0, int __base = 10)
6620 { return __gnu_cxx::__stoa<long, int>(convf: &std::strtol, name: "stoi", str: __str.c_str(),
6621 __idx, __base); }
6622
6623 inline long
6624 stol(const string& __str, size_t* __idx = 0, int __base = 10)
6625 { return __gnu_cxx::__stoa(convf: &std::strtol, name: "stol", str: __str.c_str(),
6626 __idx, __base); }
6627
6628 inline unsigned long
6629 stoul(const string& __str, size_t* __idx = 0, int __base = 10)
6630 { return __gnu_cxx::__stoa(convf: &std::strtoul,