libstdc++
basic_string.h
Go to the documentation of this file.
1 // Components for manipulating sequences of characters -*- C++ -*-
2 
3 // Copyright (C) 1997-2022 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/alloc_traits.h>
40 #include <debug/debug.h>
41 
42 #if __cplusplus >= 201103L
43 #include <initializer_list>
44 #endif
45 
46 #if __cplusplus >= 201703L
47 # include <string_view>
48 #endif
49 
50 #if ! _GLIBCXX_USE_CXX11_ABI
51 # include "cow_string.h"
52 #else
53 namespace std _GLIBCXX_VISIBILITY(default)
54 {
55 _GLIBCXX_BEGIN_NAMESPACE_VERSION
56 _GLIBCXX_BEGIN_NAMESPACE_CXX11
57 
58 #ifdef __cpp_lib_is_constant_evaluated
59 // Support P0980R1 in C++20.
60 # define __cpp_lib_constexpr_string 201907L
61 #elif __cplusplus >= 201703L && _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
62 // Support P0426R1 changes to char_traits in C++17.
63 # define __cpp_lib_constexpr_string 201611L
64 #endif
65 
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  {
88  rebind<_CharT>::other _Char_alloc_type;
89 
90 #if __cpp_lib_constexpr_string < 201907L
91  typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
92 #else
93  template<typename _Traits2, typename _Dummy_for_PR85282>
94  struct _Alloc_traits_impl : __gnu_cxx::__alloc_traits<_Char_alloc_type>
95  {
97 
98  [[__gnu__::__always_inline__]]
99  static constexpr typename _Base::pointer
100  allocate(_Char_alloc_type& __a, typename _Base::size_type __n)
101  {
102  pointer __p = _Base::allocate(__a, __n);
104  // Begin the lifetime of characters in allocated storage.
105  for (size_type __i = 0; __i < __n; ++__i)
106  std::construct_at(__builtin_addressof(__p[__i]));
107  return __p;
108  }
109  };
110 
111  template<typename _Dummy_for_PR85282>
112  struct _Alloc_traits_impl<char_traits<_CharT>, _Dummy_for_PR85282>
113  : __gnu_cxx::__alloc_traits<_Char_alloc_type>
114  {
115  // std::char_traits begins the lifetime of characters.
116  };
117 
118  using _Alloc_traits = _Alloc_traits_impl<_Traits, void>;
119 #endif
120 
121  // Types:
122  public:
123  typedef _Traits traits_type;
124  typedef typename _Traits::char_type value_type;
125  typedef _Char_alloc_type allocator_type;
126  typedef typename _Alloc_traits::size_type size_type;
127  typedef typename _Alloc_traits::difference_type difference_type;
128  typedef typename _Alloc_traits::reference reference;
129  typedef typename _Alloc_traits::const_reference const_reference;
130  typedef typename _Alloc_traits::pointer pointer;
131  typedef typename _Alloc_traits::const_pointer const_pointer;
132  typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
133  typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
134  const_iterator;
135  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
136  typedef std::reverse_iterator<iterator> reverse_iterator;
137 
138  /// Value returned by various member functions when they fail.
139  static const size_type npos = static_cast<size_type>(-1);
140 
141  protected:
142  // type used for positions in insert, erase etc.
143 #if __cplusplus < 201103L
144  typedef iterator __const_iterator;
145 #else
146  typedef const_iterator __const_iterator;
147 #endif
148 
149  private:
150 #if __cplusplus >= 201703L
151  // A helper type for avoiding boiler-plate.
152  typedef basic_string_view<_CharT, _Traits> __sv_type;
153 
154  template<typename _Tp, typename _Res>
155  using _If_sv = enable_if_t<
156  __and_<is_convertible<const _Tp&, __sv_type>,
157  __not_<is_convertible<const _Tp*, const basic_string*>>,
158  __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
159  _Res>;
160 
161  // Allows an implicit conversion to __sv_type.
162  _GLIBCXX20_CONSTEXPR
163  static __sv_type
164  _S_to_string_view(__sv_type __svt) noexcept
165  { return __svt; }
166 
167  // Wraps a string_view by explicit conversion and thus
168  // allows to add an internal constructor that does not
169  // participate in overload resolution when a string_view
170  // is provided.
171  struct __sv_wrapper
172  {
173  _GLIBCXX20_CONSTEXPR explicit
174  __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
175 
176  __sv_type _M_sv;
177  };
178 
179  /**
180  * @brief Only internally used: Construct string from a string view
181  * wrapper.
182  * @param __svw string view wrapper.
183  * @param __a Allocator to use.
184  */
185  _GLIBCXX20_CONSTEXPR
186  explicit
187  basic_string(__sv_wrapper __svw, const _Alloc& __a)
188  : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
189 #endif
190 
191  // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
192  struct _Alloc_hider : allocator_type // TODO check __is_final
193  {
194 #if __cplusplus < 201103L
195  _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
196  : allocator_type(__a), _M_p(__dat) { }
197 #else
198  _GLIBCXX20_CONSTEXPR
199  _Alloc_hider(pointer __dat, const _Alloc& __a)
200  : allocator_type(__a), _M_p(__dat) { }
201 
202  _GLIBCXX20_CONSTEXPR
203  _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
204  : allocator_type(std::move(__a)), _M_p(__dat) { }
205 #endif
206 
207  pointer _M_p; // The actual data.
208  };
209 
210  _Alloc_hider _M_dataplus;
211  size_type _M_string_length;
212 
213  enum { _S_local_capacity = 15 / sizeof(_CharT) };
214 
215  union
216  {
217  _CharT _M_local_buf[_S_local_capacity + 1];
218  size_type _M_allocated_capacity;
219  };
220 
221  _GLIBCXX20_CONSTEXPR
222  void
223  _M_data(pointer __p)
224  { _M_dataplus._M_p = __p; }
225 
226  _GLIBCXX20_CONSTEXPR
227  void
228  _M_length(size_type __length)
229  { _M_string_length = __length; }
230 
231  _GLIBCXX20_CONSTEXPR
232  pointer
233  _M_data() const
234  { return _M_dataplus._M_p; }
235 
236  _GLIBCXX20_CONSTEXPR
237  pointer
238  _M_local_data()
239  {
240 #if __cplusplus >= 201103L
241  return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
242 #else
243  return pointer(_M_local_buf);
244 #endif
245  }
246 
247  _GLIBCXX20_CONSTEXPR
248  const_pointer
249  _M_local_data() const
250  {
251 #if __cplusplus >= 201103L
253 #else
254  return const_pointer(_M_local_buf);
255 #endif
256  }
257 
258  _GLIBCXX20_CONSTEXPR
259  void
260  _M_capacity(size_type __capacity)
261  { _M_allocated_capacity = __capacity; }
262 
263  _GLIBCXX20_CONSTEXPR
264  void
265  _M_set_length(size_type __n)
266  {
267  _M_length(__n);
268  traits_type::assign(_M_data()[__n], _CharT());
269  }
270 
271  _GLIBCXX20_CONSTEXPR
272  bool
273  _M_is_local() const
274  {
275  if (_M_data() == _M_local_data())
276  {
277  if (_M_string_length > _S_local_capacity)
278  __builtin_unreachable();
279  return true;
280  }
281  return false;
282  }
283 
284  // Create & Destroy
285  _GLIBCXX20_CONSTEXPR
286  pointer
287  _M_create(size_type&, size_type);
288 
289  _GLIBCXX20_CONSTEXPR
290  void
291  _M_dispose()
292  {
293  if (!_M_is_local())
294  _M_destroy(_M_allocated_capacity);
295  }
296 
297  _GLIBCXX20_CONSTEXPR
298  void
299  _M_destroy(size_type __size) throw()
300  { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
301 
302 #if __cplusplus < 201103L || defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
303  // _M_construct_aux is used to implement the 21.3.1 para 15 which
304  // requires special behaviour if _InIterator is an integral type
305  template<typename _InIterator>
306  void
307  _M_construct_aux(_InIterator __beg, _InIterator __end,
308  std::__false_type)
309  {
310  typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
311  _M_construct(__beg, __end, _Tag());
312  }
313 
314  // _GLIBCXX_RESOLVE_LIB_DEFECTS
315  // 438. Ambiguity in the "do the right thing" clause
316  template<typename _Integer>
317  void
318  _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
319  { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
320 
321  void
322  _M_construct_aux_2(size_type __req, _CharT __c)
323  { _M_construct(__req, __c); }
324 #endif
325 
326  // For Input Iterators, used in istreambuf_iterators, etc.
327  template<typename _InIterator>
328  _GLIBCXX20_CONSTEXPR
329  void
330  _M_construct(_InIterator __beg, _InIterator __end,
332 
333  // For forward_iterators up to random_access_iterators, used for
334  // string::iterator, _CharT*, etc.
335  template<typename _FwdIterator>
336  _GLIBCXX20_CONSTEXPR
337  void
338  _M_construct(_FwdIterator __beg, _FwdIterator __end,
340 
341  _GLIBCXX20_CONSTEXPR
342  void
343  _M_construct(size_type __req, _CharT __c);
344 
345  _GLIBCXX20_CONSTEXPR
346  allocator_type&
347  _M_get_allocator()
348  { return _M_dataplus; }
349 
350  _GLIBCXX20_CONSTEXPR
351  const allocator_type&
352  _M_get_allocator() const
353  { return _M_dataplus; }
354 
355  // Ensure that _M_local_buf is the active member of the union.
356  __attribute__((__always_inline__))
357  _GLIBCXX14_CONSTEXPR
358  pointer
359  _M_use_local_data() _GLIBCXX_NOEXCEPT
360  {
361 #if __cpp_lib_is_constant_evaluated
363  for (size_type __i = 0; __i <= _S_local_capacity; ++__i)
364  _M_local_buf[__i] = _CharT();
365 #endif
366  return _M_local_data();
367  }
368 
369  private:
370 
371 #ifdef _GLIBCXX_DISAMBIGUATE_REPLACE_INST
372  // The explicit instantiations in misc-inst.cc require this due to
373  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64063
374  template<typename _Tp, bool _Requires =
375  !__are_same<_Tp, _CharT*>::__value
376  && !__are_same<_Tp, const _CharT*>::__value
377  && !__are_same<_Tp, iterator>::__value
378  && !__are_same<_Tp, const_iterator>::__value>
379  struct __enable_if_not_native_iterator
380  { typedef basic_string& __type; };
381  template<typename _Tp>
382  struct __enable_if_not_native_iterator<_Tp, false> { };
383 #endif
384 
385  _GLIBCXX20_CONSTEXPR
386  size_type
387  _M_check(size_type __pos, const char* __s) const
388  {
389  if (__pos > this->size())
390  __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
391  "this->size() (which is %zu)"),
392  __s, __pos, this->size());
393  return __pos;
394  }
395 
396  _GLIBCXX20_CONSTEXPR
397  void
398  _M_check_length(size_type __n1, size_type __n2, const char* __s) const
399  {
400  if (this->max_size() - (this->size() - __n1) < __n2)
401  __throw_length_error(__N(__s));
402  }
403 
404 
405  // NB: _M_limit doesn't check for a bad __pos value.
406  _GLIBCXX20_CONSTEXPR
407  size_type
408  _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT
409  {
410  const bool __testoff = __off < this->size() - __pos;
411  return __testoff ? __off : this->size() - __pos;
412  }
413 
414  // True if _Rep and source do not overlap.
415  bool
416  _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT
417  {
418  return (less<const _CharT*>()(__s, _M_data())
419  || less<const _CharT*>()(_M_data() + this->size(), __s));
420  }
421 
422  // When __n = 1 way faster than the general multichar
423  // traits_type::copy/move/assign.
424  _GLIBCXX20_CONSTEXPR
425  static void
426  _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
427  {
428  if (__n == 1)
429  traits_type::assign(*__d, *__s);
430  else
431  traits_type::copy(__d, __s, __n);
432  }
433 
434  _GLIBCXX20_CONSTEXPR
435  static void
436  _S_move(_CharT* __d, const _CharT* __s, size_type __n)
437  {
438  if (__n == 1)
439  traits_type::assign(*__d, *__s);
440  else
441  traits_type::move(__d, __s, __n);
442  }
443 
444  _GLIBCXX20_CONSTEXPR
445  static void
446  _S_assign(_CharT* __d, size_type __n, _CharT __c)
447  {
448  if (__n == 1)
449  traits_type::assign(*__d, __c);
450  else
451  traits_type::assign(__d, __n, __c);
452  }
453 
454  // _S_copy_chars is a separate template to permit specialization
455  // to optimize for the common case of pointers as iterators.
456  template<class _Iterator>
457  _GLIBCXX20_CONSTEXPR
458  static void
459  _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
460  {
461  for (; __k1 != __k2; ++__k1, (void)++__p)
462  traits_type::assign(*__p, *__k1); // These types are off.
463  }
464 
465  _GLIBCXX20_CONSTEXPR
466  static void
467  _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) _GLIBCXX_NOEXCEPT
468  { _S_copy_chars(__p, __k1.base(), __k2.base()); }
469 
470  _GLIBCXX20_CONSTEXPR
471  static void
472  _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
473  _GLIBCXX_NOEXCEPT
474  { _S_copy_chars(__p, __k1.base(), __k2.base()); }
475 
476  _GLIBCXX20_CONSTEXPR
477  static void
478  _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) _GLIBCXX_NOEXCEPT
479  { _S_copy(__p, __k1, __k2 - __k1); }
480 
481  _GLIBCXX20_CONSTEXPR
482  static void
483  _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
484  _GLIBCXX_NOEXCEPT
485  { _S_copy(__p, __k1, __k2 - __k1); }
486 
487  _GLIBCXX20_CONSTEXPR
488  static int
489  _S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT
490  {
491  const difference_type __d = difference_type(__n1 - __n2);
492 
493  if (__d > __gnu_cxx::__numeric_traits<int>::__max)
494  return __gnu_cxx::__numeric_traits<int>::__max;
495  else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
496  return __gnu_cxx::__numeric_traits<int>::__min;
497  else
498  return int(__d);
499  }
500 
501  _GLIBCXX20_CONSTEXPR
502  void
503  _M_assign(const basic_string&);
504 
505  _GLIBCXX20_CONSTEXPR
506  void
507  _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
508  size_type __len2);
509 
510  _GLIBCXX20_CONSTEXPR
511  void
512  _M_erase(size_type __pos, size_type __n);
513 
514  public:
515  // Construct/copy/destroy:
516  // NB: We overload ctors in some cases instead of using default
517  // arguments, per 17.4.4.4 para. 2 item 2.
518 
519  /**
520  * @brief Default constructor creates an empty string.
521  */
522  _GLIBCXX20_CONSTEXPR
523  basic_string()
524  _GLIBCXX_NOEXCEPT_IF(is_nothrow_default_constructible<_Alloc>::value)
525  : _M_dataplus(_M_local_data())
526  {
527  _M_use_local_data();
528  _M_set_length(0);
529  }
530 
531  /**
532  * @brief Construct an empty string using allocator @a a.
533  */
534  _GLIBCXX20_CONSTEXPR
535  explicit
536  basic_string(const _Alloc& __a) _GLIBCXX_NOEXCEPT
537  : _M_dataplus(_M_local_data(), __a)
538  {
539  _M_use_local_data();
540  _M_set_length(0);
541  }
542 
543  /**
544  * @brief Construct string with copy of value of @a __str.
545  * @param __str Source string.
546  */
547  _GLIBCXX20_CONSTEXPR
548  basic_string(const basic_string& __str)
549  : _M_dataplus(_M_local_data(),
550  _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
551  {
552  _M_construct(__str._M_data(), __str._M_data() + __str.length(),
554  }
555 
556  // _GLIBCXX_RESOLVE_LIB_DEFECTS
557  // 2583. no way to supply an allocator for basic_string(str, pos)
558  /**
559  * @brief Construct string as copy of a substring.
560  * @param __str Source string.
561  * @param __pos Index of first character to copy from.
562  * @param __a Allocator to use.
563  */
564  _GLIBCXX20_CONSTEXPR
565  basic_string(const basic_string& __str, size_type __pos,
566  const _Alloc& __a = _Alloc())
567  : _M_dataplus(_M_local_data(), __a)
568  {
569  const _CharT* __start = __str._M_data()
570  + __str._M_check(__pos, "basic_string::basic_string");
571  _M_construct(__start, __start + __str._M_limit(__pos, npos),
573  }
574 
575  /**
576  * @brief Construct string as copy of a substring.
577  * @param __str Source string.
578  * @param __pos Index of first character to copy from.
579  * @param __n Number of characters to copy.
580  */
581  _GLIBCXX20_CONSTEXPR
582  basic_string(const basic_string& __str, size_type __pos,
583  size_type __n)
584  : _M_dataplus(_M_local_data())
585  {
586  const _CharT* __start = __str._M_data()
587  + __str._M_check(__pos, "basic_string::basic_string");
588  _M_construct(__start, __start + __str._M_limit(__pos, __n),
590  }
591 
592  /**
593  * @brief Construct string as copy of a substring.
594  * @param __str Source string.
595  * @param __pos Index of first character to copy from.
596  * @param __n Number of characters to copy.
597  * @param __a Allocator to use.
598  */
599  _GLIBCXX20_CONSTEXPR
600  basic_string(const basic_string& __str, size_type __pos,
601  size_type __n, const _Alloc& __a)
602  : _M_dataplus(_M_local_data(), __a)
603  {
604  const _CharT* __start
605  = __str._M_data() + __str._M_check(__pos, "string::string");
606  _M_construct(__start, __start + __str._M_limit(__pos, __n),
608  }
609 
610  /**
611  * @brief Construct string initialized by a character %array.
612  * @param __s Source character %array.
613  * @param __n Number of characters to copy.
614  * @param __a Allocator to use (default is default allocator).
615  *
616  * NB: @a __s must have at least @a __n characters, &apos;\\0&apos;
617  * has no special meaning.
618  */
619  _GLIBCXX20_CONSTEXPR
620  basic_string(const _CharT* __s, size_type __n,
621  const _Alloc& __a = _Alloc())
622  : _M_dataplus(_M_local_data(), __a)
623  {
624  // NB: Not required, but considered best practice.
625  if (__s == 0 && __n > 0)
626  std::__throw_logic_error(__N("basic_string: "
627  "construction from null is not valid"));
628  _M_construct(__s, __s + __n, std::forward_iterator_tag());
629  }
630 
631  /**
632  * @brief Construct string as copy of a C string.
633  * @param __s Source C string.
634  * @param __a Allocator to use (default is default allocator).
635  */
636 #if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
637  // _GLIBCXX_RESOLVE_LIB_DEFECTS
638  // 3076. basic_string CTAD ambiguity
639  template<typename = _RequireAllocator<_Alloc>>
640 #endif
641  _GLIBCXX20_CONSTEXPR
642  basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
643  : _M_dataplus(_M_local_data(), __a)
644  {
645  // NB: Not required, but considered best practice.
646  if (__s == 0)
647  std::__throw_logic_error(__N("basic_string: "
648  "construction from null is not valid"));
649  const _CharT* __end = __s + traits_type::length(__s);
650  _M_construct(__s, __end, forward_iterator_tag());
651  }
652 
653  /**
654  * @brief Construct string as multiple characters.
655  * @param __n Number of characters.
656  * @param __c Character to use.
657  * @param __a Allocator to use (default is default allocator).
658  */
659 #if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
660  // _GLIBCXX_RESOLVE_LIB_DEFECTS
661  // 3076. basic_string CTAD ambiguity
662  template<typename = _RequireAllocator<_Alloc>>
663 #endif
664  _GLIBCXX20_CONSTEXPR
665  basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
666  : _M_dataplus(_M_local_data(), __a)
667  { _M_construct(__n, __c); }
668 
669 #if __cplusplus >= 201103L
670  /**
671  * @brief Move construct string.
672  * @param __str Source string.
673  *
674  * The newly-created string contains the exact contents of @a __str.
675  * @a __str is a valid, but unspecified string.
676  */
677  _GLIBCXX20_CONSTEXPR
678  basic_string(basic_string&& __str) noexcept
679  : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
680  {
681  if (__str._M_is_local())
682  {
683  traits_type::copy(_M_local_buf, __str._M_local_buf,
684  __str.length() + 1);
685  }
686  else
687  {
688  _M_data(__str._M_data());
689  _M_capacity(__str._M_allocated_capacity);
690  }
691 
692  // Must use _M_length() here not _M_set_length() because
693  // basic_stringbuf relies on writing into unallocated capacity so
694  // we mess up the contents if we put a '\0' in the string.
695  _M_length(__str.length());
696  __str._M_data(__str._M_local_data());
697  __str._M_set_length(0);
698  }
699 
700  /**
701  * @brief Construct string from an initializer %list.
702  * @param __l std::initializer_list of characters.
703  * @param __a Allocator to use (default is default allocator).
704  */
705  _GLIBCXX20_CONSTEXPR
706  basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
707  : _M_dataplus(_M_local_data(), __a)
708  { _M_construct(__l.begin(), __l.end(), std::forward_iterator_tag()); }
709 
710  _GLIBCXX20_CONSTEXPR
711  basic_string(const basic_string& __str, const _Alloc& __a)
712  : _M_dataplus(_M_local_data(), __a)
713  { _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); }
714 
715  _GLIBCXX20_CONSTEXPR
716  basic_string(basic_string&& __str, const _Alloc& __a)
717  noexcept(_Alloc_traits::_S_always_equal())
718  : _M_dataplus(_M_local_data(), __a)
719  {
720  if (__str._M_is_local())
721  {
722  traits_type::copy(_M_local_buf, __str._M_local_buf,
723  __str.length() + 1);
724  _M_length(__str.length());
725  __str._M_set_length(0);
726  }
727  else if (_Alloc_traits::_S_always_equal()
728  || __str.get_allocator() == __a)
729  {
730  _M_data(__str._M_data());
731  _M_length(__str.length());
732  _M_capacity(__str._M_allocated_capacity);
733  __str._M_data(__str._M_local_buf);
734  __str._M_set_length(0);
735  }
736  else
737  _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag());
738  }
739 #endif // C++11
740 
741 #if __cplusplus >= 202100L
742  basic_string(nullptr_t) = delete;
743  basic_string& operator=(nullptr_t) = delete;
744 #endif // C++23
745 
746  /**
747  * @brief Construct string as copy of a range.
748  * @param __beg Start of range.
749  * @param __end End of range.
750  * @param __a Allocator to use (default is default allocator).
751  */
752 #if __cplusplus >= 201103L
753  template<typename _InputIterator,
754  typename = std::_RequireInputIter<_InputIterator>>
755 #else
756  template<typename _InputIterator>
757 #endif
758  _GLIBCXX20_CONSTEXPR
759  basic_string(_InputIterator __beg, _InputIterator __end,
760  const _Alloc& __a = _Alloc())
761  : _M_dataplus(_M_local_data(), __a), _M_string_length(0)
762  {
763 #if __cplusplus >= 201103L
764  _M_construct(__beg, __end, std::__iterator_category(__beg));
765 #else
766  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
767  _M_construct_aux(__beg, __end, _Integral());
768 #endif
769  }
770 
771 #if __cplusplus >= 201703L
772  /**
773  * @brief Construct string from a substring of a string_view.
774  * @param __t Source object convertible to string view.
775  * @param __pos The index of the first character to copy from __t.
776  * @param __n The number of characters to copy from __t.
777  * @param __a Allocator to use.
778  */
779  template<typename _Tp,
780  typename = enable_if_t<is_convertible_v<const _Tp&, __sv_type>>>
781  _GLIBCXX20_CONSTEXPR
782  basic_string(const _Tp& __t, size_type __pos, size_type __n,
783  const _Alloc& __a = _Alloc())
784  : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }
785 
786  /**
787  * @brief Construct string from a string_view.
788  * @param __t Source object convertible to string view.
789  * @param __a Allocator to use (default is default allocator).
790  */
791  template<typename _Tp, typename = _If_sv<_Tp, void>>
792  _GLIBCXX20_CONSTEXPR
793  explicit
794  basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
795  : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }
796 #endif // C++17
797 
798  /**
799  * @brief Destroy the string instance.
800  */
801  _GLIBCXX20_CONSTEXPR
802  ~basic_string()
803  { _M_dispose(); }
804 
805  /**
806  * @brief Assign the value of @a str to this string.
807  * @param __str Source string.
808  */
809  _GLIBCXX20_CONSTEXPR
810  basic_string&
811  operator=(const basic_string& __str)
812  {
813  return this->assign(__str);
814  }
815 
816  /**
817  * @brief Copy contents of @a s into this string.
818  * @param __s Source null-terminated string.
819  */
820  _GLIBCXX20_CONSTEXPR
821  basic_string&
822  operator=(const _CharT* __s)
823  { return this->assign(__s); }
824 
825  /**
826  * @brief Set value to string of length 1.
827  * @param __c Source character.
828  *
829  * Assigning to a character makes this string length 1 and
830  * (*this)[0] == @a c.
831  */
832  _GLIBCXX20_CONSTEXPR
833  basic_string&
834  operator=(_CharT __c)
835  {
836  this->assign(1, __c);
837  return *this;
838  }
839 
840 #if __cplusplus >= 201103L
841  /**
842  * @brief Move assign the value of @a str to this string.
843  * @param __str Source string.
844  *
845  * The contents of @a str are moved into this string (without copying).
846  * @a str is a valid, but unspecified string.
847  */
848  // _GLIBCXX_RESOLVE_LIB_DEFECTS
849  // 2063. Contradictory requirements for string move assignment
850  _GLIBCXX20_CONSTEXPR
851  basic_string&
852  operator=(basic_string&& __str)
853  noexcept(_Alloc_traits::_S_nothrow_move())
854  {
855  if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
856  && !_Alloc_traits::_S_always_equal()
857  && _M_get_allocator() != __str._M_get_allocator())
858  {
859  // Destroy existing storage before replacing allocator.
860  _M_destroy(_M_allocated_capacity);
861  _M_data(_M_local_data());
862  _M_set_length(0);
863  }
864  // Replace allocator if POCMA is true.
865  std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
866 
867  if (__str._M_is_local())
868  {
869  // We've always got room for a short string, just copy it
870  // (unless this is a self-move, because that would violate the
871  // char_traits::copy precondition that the ranges don't overlap).
872  if (__builtin_expect(std::__addressof(__str) != this, true))
873  {
874  if (__str.size())
875  this->_S_copy(_M_data(), __str._M_data(), __str.size());
876  _M_set_length(__str.size());
877  }
878  }
879  else if (_Alloc_traits::_S_propagate_on_move_assign()
880  || _Alloc_traits::_S_always_equal()
881  || _M_get_allocator() == __str._M_get_allocator())
882  {
883  // Just move the allocated pointer, our allocator can free it.
884  pointer __data = nullptr;
885  size_type __capacity;
886  if (!_M_is_local())
887  {
888  if (_Alloc_traits::_S_always_equal())
889  {
890  // __str can reuse our existing storage.
891  __data = _M_data();
892  __capacity = _M_allocated_capacity;
893  }
894  else // __str can't use it, so free it.
895  _M_destroy(_M_allocated_capacity);
896  }
897 
898  _M_data(__str._M_data());
899  _M_length(__str.length());
900  _M_capacity(__str._M_allocated_capacity);
901  if (__data)
902  {
903  __str._M_data(__data);
904  __str._M_capacity(__capacity);
905  }
906  else
907  __str._M_data(__str._M_local_buf);
908  }
909  else // Need to do a deep copy
910  assign(__str);
911  __str.clear();
912  return *this;
913  }
914 
915  /**
916  * @brief Set value to string constructed from initializer %list.
917  * @param __l std::initializer_list.
918  */
919  _GLIBCXX20_CONSTEXPR
920  basic_string&
921  operator=(initializer_list<_CharT> __l)
922  {
923  this->assign(__l.begin(), __l.size());
924  return *this;
925  }
926 #endif // C++11
927 
928 #if __cplusplus >= 201703L
929  /**
930  * @brief Set value to string constructed from a string_view.
931  * @param __svt An object convertible to string_view.
932  */
933  template<typename _Tp>
934  _GLIBCXX20_CONSTEXPR
935  _If_sv<_Tp, basic_string&>
936  operator=(const _Tp& __svt)
937  { return this->assign(__svt); }
938 
939  /**
940  * @brief Convert to a string_view.
941  * @return A string_view.
942  */
943  _GLIBCXX20_CONSTEXPR
944  operator __sv_type() const noexcept
945  { return __sv_type(data(), size()); }
946 #endif // C++17
947 
948  // Iterators:
949  /**
950  * Returns a read/write iterator that points to the first character in
951  * the %string.
952  */
953  _GLIBCXX20_CONSTEXPR
954  iterator
955  begin() _GLIBCXX_NOEXCEPT
956  { return iterator(_M_data()); }
957 
958  /**
959  * Returns a read-only (constant) iterator that points to the first
960  * character in the %string.
961  */
962  _GLIBCXX20_CONSTEXPR
963  const_iterator
964  begin() const _GLIBCXX_NOEXCEPT
965  { return const_iterator(_M_data()); }
966 
967  /**
968  * Returns a read/write iterator that points one past the last
969  * character in the %string.
970  */
971  _GLIBCXX20_CONSTEXPR
972  iterator
973  end() _GLIBCXX_NOEXCEPT
974  { return iterator(_M_data() + this->size()); }
975 
976  /**
977  * Returns a read-only (constant) iterator that points one past the
978  * last character in the %string.
979  */
980  _GLIBCXX20_CONSTEXPR
981  const_iterator
982  end() const _GLIBCXX_NOEXCEPT
983  { return const_iterator(_M_data() + this->size()); }
984 
985  /**
986  * Returns a read/write reverse iterator that points to the last
987  * character in the %string. Iteration is done in reverse element
988  * order.
989  */
990  _GLIBCXX20_CONSTEXPR
991  reverse_iterator
992  rbegin() _GLIBCXX_NOEXCEPT
993  { return reverse_iterator(this->end()); }
994 
995  /**
996  * Returns a read-only (constant) reverse iterator that points
997  * to the last character in the %string. Iteration is done in
998  * reverse element order.
999  */
1000  _GLIBCXX20_CONSTEXPR
1001  const_reverse_iterator
1002  rbegin() const _GLIBCXX_NOEXCEPT
1003  { return const_reverse_iterator(this->end()); }
1004 
1005  /**
1006  * Returns a read/write reverse iterator that points to one before the
1007  * first character in the %string. Iteration is done in reverse
1008  * element order.
1009  */
1010  _GLIBCXX20_CONSTEXPR
1011  reverse_iterator
1012  rend() _GLIBCXX_NOEXCEPT
1013  { return reverse_iterator(this->begin()); }
1014 
1015  /**
1016  * Returns a read-only (constant) reverse iterator that points
1017  * to one before the first character in the %string. Iteration
1018  * is done in reverse element order.
1019  */
1020  _GLIBCXX20_CONSTEXPR
1021  const_reverse_iterator
1022  rend() const _GLIBCXX_NOEXCEPT
1023  { return const_reverse_iterator(this->begin()); }
1024 
1025 #if __cplusplus >= 201103L
1026  /**
1027  * Returns a read-only (constant) iterator that points to the first
1028  * character in the %string.
1029  */
1030  _GLIBCXX20_CONSTEXPR
1031  const_iterator
1032  cbegin() const noexcept
1033  { return const_iterator(this->_M_data()); }
1034 
1035  /**
1036  * Returns a read-only (constant) iterator that points one past the
1037  * last character in the %string.
1038  */
1039  _GLIBCXX20_CONSTEXPR
1040  const_iterator
1041  cend() const noexcept
1042  { return const_iterator(this->_M_data() + this->size()); }
1043 
1044  /**
1045  * Returns a read-only (constant) reverse iterator that points
1046  * to the last character in the %string. Iteration is done in
1047  * reverse element order.
1048  */
1049  _GLIBCXX20_CONSTEXPR
1050  const_reverse_iterator
1051  crbegin() const noexcept
1052  { return const_reverse_iterator(this->end()); }
1053 
1054  /**
1055  * Returns a read-only (constant) reverse iterator that points
1056  * to one before the first character in the %string. Iteration
1057  * is done in reverse element order.
1058  */
1059  _GLIBCXX20_CONSTEXPR
1060  const_reverse_iterator
1061  crend() const noexcept
1062  { return const_reverse_iterator(this->begin()); }
1063 #endif
1064 
1065  public:
1066  // Capacity:
1067  /// Returns the number of characters in the string, not including any
1068  /// null-termination.
1069  _GLIBCXX20_CONSTEXPR
1070  size_type
1071  size() const _GLIBCXX_NOEXCEPT
1072  { return _M_string_length; }
1073 
1074  /// Returns the number of characters in the string, not including any
1075  /// null-termination.
1076  _GLIBCXX20_CONSTEXPR
1077  size_type
1078  length() const _GLIBCXX_NOEXCEPT
1079  { return _M_string_length; }
1080 
1081  /// Returns the size() of the largest possible %string.
1082  _GLIBCXX20_CONSTEXPR
1083  size_type
1084  max_size() const _GLIBCXX_NOEXCEPT
1085  { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
1086 
1087  /**
1088  * @brief Resizes the %string to the specified number of characters.
1089  * @param __n Number of characters the %string should contain.
1090  * @param __c Character to fill any new elements.
1091  *
1092  * This function will %resize the %string to the specified
1093  * number of characters. If the number is smaller than the
1094  * %string's current size the %string is truncated, otherwise
1095  * the %string is extended and new elements are %set to @a __c.
1096  */
1097  _GLIBCXX20_CONSTEXPR
1098  void
1099  resize(size_type __n, _CharT __c);
1100 
1101  /**
1102  * @brief Resizes the %string to the specified number of characters.
1103  * @param __n Number of characters the %string should contain.
1104  *
1105  * This function will resize the %string to the specified length. If
1106  * the new size is smaller than the %string's current size the %string
1107  * is truncated, otherwise the %string is extended and new characters
1108  * are default-constructed. For basic types such as char, this means
1109  * setting them to 0.
1110  */
1111  _GLIBCXX20_CONSTEXPR
1112  void
1113  resize(size_type __n)
1114  { this->resize(__n, _CharT()); }
1115 
1116 #if __cplusplus >= 201103L
1117 #pragma GCC diagnostic push
1118 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1119  /// A non-binding request to reduce capacity() to size().
1120  _GLIBCXX20_CONSTEXPR
1121  void
1122  shrink_to_fit() noexcept
1123  { reserve(); }
1124 #pragma GCC diagnostic pop
1125 #endif
1126 
1127 #if __cplusplus > 202002L
1128 #define __cpp_lib_string_resize_and_overwrite 202110L
1129  template<typename _Operation>
1130  constexpr void
1131  resize_and_overwrite(size_type __n, _Operation __op);
1132 #endif
1133 
1134  /**
1135  * Returns the total number of characters that the %string can hold
1136  * before needing to allocate more memory.
1137  */
1138  _GLIBCXX20_CONSTEXPR
1139  size_type
1140  capacity() const _GLIBCXX_NOEXCEPT
1141  {
1142  return _M_is_local() ? size_type(_S_local_capacity)
1143  : _M_allocated_capacity;
1144  }
1145 
1146  /**
1147  * @brief Attempt to preallocate enough memory for specified number of
1148  * characters.
1149  * @param __res_arg Number of characters required.
1150  * @throw std::length_error If @a __res_arg exceeds @c max_size().
1151  *
1152  * This function attempts to reserve enough memory for the
1153  * %string to hold the specified number of characters. If the
1154  * number requested is more than max_size(), length_error is
1155  * thrown.
1156  *
1157  * The advantage of this function is that if optimal code is a
1158  * necessity and the user can determine the string length that will be
1159  * required, the user can reserve the memory in %advance, and thus
1160  * prevent a possible reallocation of memory and copying of %string
1161  * data.
1162  */
1163  _GLIBCXX20_CONSTEXPR
1164  void
1165  reserve(size_type __res_arg);
1166 
1167  /**
1168  * Equivalent to shrink_to_fit().
1169  */
1170 #if __cplusplus > 201703L
1171  [[deprecated("use shrink_to_fit() instead")]]
1172 #endif
1173  _GLIBCXX20_CONSTEXPR
1174  void
1175  reserve();
1176 
1177  /**
1178  * Erases the string, making it empty.
1179  */
1180  _GLIBCXX20_CONSTEXPR
1181  void
1182  clear() _GLIBCXX_NOEXCEPT
1183  { _M_set_length(0); }
1184 
1185  /**
1186  * Returns true if the %string is empty. Equivalent to
1187  * <code>*this == ""</code>.
1188  */
1189  _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1190  bool
1191  empty() const _GLIBCXX_NOEXCEPT
1192  { return this->size() == 0; }
1193 
1194  // Element access:
1195  /**
1196  * @brief Subscript access to the data contained in the %string.
1197  * @param __pos The index of the character to access.
1198  * @return Read-only (constant) reference to the character.
1199  *
1200  * This operator allows for easy, array-style, data access.
1201  * Note that data access with this operator is unchecked and
1202  * out_of_range lookups are not defined. (For checked lookups
1203  * see at().)
1204  */
1205  _GLIBCXX20_CONSTEXPR
1206  const_reference
1207  operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
1208  {
1209  __glibcxx_assert(__pos <= size());
1210  return _M_data()[__pos];
1211  }
1212 
1213  /**
1214  * @brief Subscript access to the data contained in the %string.
1215  * @param __pos The index of the character to access.
1216  * @return Read/write reference to the character.
1217  *
1218  * This operator allows for easy, array-style, data access.
1219  * Note that data access with this operator is unchecked and
1220  * out_of_range lookups are not defined. (For checked lookups
1221  * see at().)
1222  */
1223  _GLIBCXX20_CONSTEXPR
1224  reference
1225  operator[](size_type __pos)
1226  {
1227  // Allow pos == size() both in C++98 mode, as v3 extension,
1228  // and in C++11 mode.
1229  __glibcxx_assert(__pos <= size());
1230  // In pedantic mode be strict in C++98 mode.
1231  _GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size());
1232  return _M_data()[__pos];
1233  }
1234 
1235  /**
1236  * @brief Provides access to the data contained in the %string.
1237  * @param __n The index of the character to access.
1238  * @return Read-only (const) reference to the character.
1239  * @throw std::out_of_range If @a n is an invalid index.
1240  *
1241  * This function provides for safer data access. The parameter is
1242  * first checked that it is in the range of the string. The function
1243  * throws out_of_range if the check fails.
1244  */
1245  _GLIBCXX20_CONSTEXPR
1246  const_reference
1247  at(size_type __n) const
1248  {
1249  if (__n >= this->size())
1250  __throw_out_of_range_fmt(__N("basic_string::at: __n "
1251  "(which is %zu) >= this->size() "
1252  "(which is %zu)"),
1253  __n, this->size());
1254  return _M_data()[__n];
1255  }
1256 
1257  /**
1258  * @brief Provides access to the data contained in the %string.
1259  * @param __n The index of the character to access.
1260  * @return Read/write reference to the character.
1261  * @throw std::out_of_range If @a n is an invalid index.
1262  *
1263  * This function provides for safer data access. The parameter is
1264  * first checked that it is in the range of the string. The function
1265  * throws out_of_range if the check fails.
1266  */
1267  _GLIBCXX20_CONSTEXPR
1268  reference
1269  at(size_type __n)
1270  {
1271  if (__n >= size())
1272  __throw_out_of_range_fmt(__N("basic_string::at: __n "
1273  "(which is %zu) >= this->size() "
1274  "(which is %zu)"),
1275  __n, this->size());
1276  return _M_data()[__n];
1277  }
1278 
1279 #if __cplusplus >= 201103L
1280  /**
1281  * Returns a read/write reference to the data at the first
1282  * element of the %string.
1283  */
1284  _GLIBCXX20_CONSTEXPR
1285  reference
1286  front() noexcept
1287  {
1288  __glibcxx_assert(!empty());
1289  return operator[](0);
1290  }
1291 
1292  /**
1293  * Returns a read-only (constant) reference to the data at the first
1294  * element of the %string.
1295  */
1296  _GLIBCXX20_CONSTEXPR
1297  const_reference
1298  front() const noexcept
1299  {
1300  __glibcxx_assert(!empty());
1301  return operator[](0);
1302  }
1303 
1304  /**
1305  * Returns a read/write reference to the data at the last
1306  * element of the %string.
1307  */
1308  _GLIBCXX20_CONSTEXPR
1309  reference
1310  back() noexcept
1311  {
1312  __glibcxx_assert(!empty());
1313  return operator[](this->size() - 1);
1314  }
1315 
1316  /**
1317  * Returns a read-only (constant) reference to the data at the
1318  * last element of the %string.
1319  */
1320  _GLIBCXX20_CONSTEXPR
1321  const_reference
1322  back() const noexcept
1323  {
1324  __glibcxx_assert(!empty());
1325  return operator[](this->size() - 1);
1326  }
1327 #endif
1328 
1329  // Modifiers:
1330  /**
1331  * @brief Append a string to this string.
1332  * @param __str The string to append.
1333  * @return Reference to this string.
1334  */
1335  _GLIBCXX20_CONSTEXPR
1336  basic_string&
1337  operator+=(const basic_string& __str)
1338  { return this->append(__str); }
1339 
1340  /**
1341  * @brief Append a C string.
1342  * @param __s The C string to append.
1343  * @return Reference to this string.
1344  */
1345  _GLIBCXX20_CONSTEXPR
1346  basic_string&
1347  operator+=(const _CharT* __s)
1348  { return this->append(__s); }
1349 
1350  /**
1351  * @brief Append a character.
1352  * @param __c The character to append.
1353  * @return Reference to this string.
1354  */
1355  _GLIBCXX20_CONSTEXPR
1356  basic_string&
1357  operator+=(_CharT __c)
1358  {
1359  this->push_back(__c);
1360  return *this;
1361  }
1362 
1363 #if __cplusplus >= 201103L
1364  /**
1365  * @brief Append an initializer_list of characters.
1366  * @param __l The initializer_list of characters to be appended.
1367  * @return Reference to this string.
1368  */
1369  _GLIBCXX20_CONSTEXPR
1370  basic_string&
1371  operator+=(initializer_list<_CharT> __l)
1372  { return this->append(__l.begin(), __l.size()); }
1373 #endif // C++11
1374 
1375 #if __cplusplus >= 201703L
1376  /**
1377  * @brief Append a string_view.
1378  * @param __svt An object convertible to string_view to be appended.
1379  * @return Reference to this string.
1380  */
1381  template<typename _Tp>
1382  _GLIBCXX20_CONSTEXPR
1383  _If_sv<_Tp, basic_string&>
1384  operator+=(const _Tp& __svt)
1385  { return this->append(__svt); }
1386 #endif // C++17
1387 
1388  /**
1389  * @brief Append a string to this string.
1390  * @param __str The string to append.
1391  * @return Reference to this string.
1392  */
1393  _GLIBCXX20_CONSTEXPR
1394  basic_string&
1395  append(const basic_string& __str)
1396  { return this->append(__str._M_data(), __str.size()); }
1397 
1398  /**
1399  * @brief Append a substring.
1400  * @param __str The string to append.
1401  * @param __pos Index of the first character of str to append.
1402  * @param __n The number of characters to append.
1403  * @return Reference to this string.
1404  * @throw std::out_of_range if @a __pos is not a valid index.
1405  *
1406  * This function appends @a __n characters from @a __str
1407  * starting at @a __pos to this string. If @a __n is is larger
1408  * than the number of available characters in @a __str, the
1409  * remainder of @a __str is appended.
1410  */
1411  _GLIBCXX20_CONSTEXPR
1412  basic_string&
1413  append(const basic_string& __str, size_type __pos, size_type __n = npos)
1414  { return this->append(__str._M_data()
1415  + __str._M_check(__pos, "basic_string::append"),
1416  __str._M_limit(__pos, __n)); }
1417 
1418  /**
1419  * @brief Append a C substring.
1420  * @param __s The C string to append.
1421  * @param __n The number of characters to append.
1422  * @return Reference to this string.
1423  */
1424  _GLIBCXX20_CONSTEXPR
1425  basic_string&
1426  append(const _CharT* __s, size_type __n)
1427  {
1428  __glibcxx_requires_string_len(__s, __n);
1429  _M_check_length(size_type(0), __n, "basic_string::append");
1430  return _M_append(__s, __n);
1431  }
1432 
1433  /**
1434  * @brief Append a C string.
1435  * @param __s The C string to append.
1436  * @return Reference to this string.
1437  */
1438  _GLIBCXX20_CONSTEXPR
1439  basic_string&
1440  append(const _CharT* __s)
1441  {
1442  __glibcxx_requires_string(__s);
1443  const size_type __n = traits_type::length(__s);
1444  _M_check_length(size_type(0), __n, "basic_string::append");
1445  return _M_append(__s, __n);
1446  }
1447 
1448  /**
1449  * @brief Append multiple characters.
1450  * @param __n The number of characters to append.
1451  * @param __c The character to use.
1452  * @return Reference to this string.
1453  *
1454  * Appends __n copies of __c to this string.
1455  */
1456  _GLIBCXX20_CONSTEXPR
1457  basic_string&
1458  append(size_type __n, _CharT __c)
1459  { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
1460 
1461 #if __cplusplus >= 201103L
1462  /**
1463  * @brief Append an initializer_list of characters.
1464  * @param __l The initializer_list of characters to append.
1465  * @return Reference to this string.
1466  */
1467  _GLIBCXX20_CONSTEXPR
1468  basic_string&
1469  append(initializer_list<_CharT> __l)
1470  { return this->append(__l.begin(), __l.size()); }
1471 #endif // C++11
1472 
1473  /**
1474  * @brief Append a range of characters.
1475  * @param __first Iterator referencing the first character to append.
1476  * @param __last Iterator marking the end of the range.
1477  * @return Reference to this string.
1478  *
1479  * Appends characters in the range [__first,__last) to this string.
1480  */
1481 #if __cplusplus >= 201103L
1482  template<class _InputIterator,
1483  typename = std::_RequireInputIter<_InputIterator>>
1484  _GLIBCXX20_CONSTEXPR
1485 #else
1486  template<class _InputIterator>
1487 #endif
1488  basic_string&
1489  append(_InputIterator __first, _InputIterator __last)
1490  { return this->replace(end(), end(), __first, __last); }
1491 
1492 #if __cplusplus >= 201703L
1493  /**
1494  * @brief Append a string_view.
1495  * @param __svt An object convertible to string_view to be appended.
1496  * @return Reference to this string.
1497  */
1498  template<typename _Tp>
1499  _GLIBCXX20_CONSTEXPR
1500  _If_sv<_Tp, basic_string&>
1501  append(const _Tp& __svt)
1502  {
1503  __sv_type __sv = __svt;
1504  return this->append(__sv.data(), __sv.size());
1505  }
1506 
1507  /**
1508  * @brief Append a range of characters from a string_view.
1509  * @param __svt An object convertible to string_view to be appended from.
1510  * @param __pos The position in the string_view to append from.
1511  * @param __n The number of characters to append from the string_view.
1512  * @return Reference to this string.
1513  */
1514  template<typename _Tp>
1515  _GLIBCXX20_CONSTEXPR
1516  _If_sv<_Tp, basic_string&>
1517  append(const _Tp& __svt, size_type __pos, size_type __n = npos)
1518  {
1519  __sv_type __sv = __svt;
1520  return _M_append(__sv.data()
1521  + std::__sv_check(__sv.size(), __pos, "basic_string::append"),
1522  std::__sv_limit(__sv.size(), __pos, __n));
1523  }
1524 #endif // C++17
1525 
1526  /**
1527  * @brief Append a single character.
1528  * @param __c Character to append.
1529  */
1530  _GLIBCXX20_CONSTEXPR
1531  void
1532  push_back(_CharT __c)
1533  {
1534  const size_type __size = this->size();
1535  if (__size + 1 > this->capacity())
1536  this->_M_mutate(__size, size_type(0), 0, size_type(1));
1537  traits_type::assign(this->_M_data()[__size], __c);
1538  this->_M_set_length(__size + 1);
1539  }
1540 
1541  /**
1542  * @brief Set value to contents of another string.
1543  * @param __str Source string to use.
1544  * @return Reference to this string.
1545  */
1546  _GLIBCXX20_CONSTEXPR
1547  basic_string&
1548  assign(const basic_string& __str)
1549  {
1550 #if __cplusplus >= 201103L
1551  if (_Alloc_traits::_S_propagate_on_copy_assign())
1552  {
1553  if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
1554  && _M_get_allocator() != __str._M_get_allocator())
1555  {
1556  // Propagating allocator cannot free existing storage so must
1557  // deallocate it before replacing current allocator.
1558  if (__str.size() <= _S_local_capacity)
1559  {
1560  _M_destroy(_M_allocated_capacity);
1561  _M_data(_M_use_local_data());
1562  _M_set_length(0);
1563  }
1564  else
1565  {
1566  const auto __len = __str.size();
1567  auto __alloc = __str._M_get_allocator();
1568  // If this allocation throws there are no effects:
1569  auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1);
1570  _M_destroy(_M_allocated_capacity);
1571  _M_data(__ptr);
1572  _M_capacity(__len);
1573  _M_set_length(__len);
1574  }
1575  }
1576  std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
1577  }
1578 #endif
1579  this->_M_assign(__str);
1580  return *this;
1581  }
1582 
1583 #if __cplusplus >= 201103L
1584  /**
1585  * @brief Set value to contents of another string.
1586  * @param __str Source string to use.
1587  * @return Reference to this string.
1588  *
1589  * This function sets this string to the exact contents of @a __str.
1590  * @a __str is a valid, but unspecified string.
1591  */
1592  _GLIBCXX20_CONSTEXPR
1593  basic_string&
1594  assign(basic_string&& __str)
1595  noexcept(_Alloc_traits::_S_nothrow_move())
1596  {
1597  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1598  // 2063. Contradictory requirements for string move assignment
1599  return *this = std::move(__str);
1600  }
1601 #endif // C++11
1602 
1603  /**
1604  * @brief Set value to a substring of a string.
1605  * @param __str The string to use.
1606  * @param __pos Index of the first character of str.
1607  * @param __n Number of characters to use.
1608  * @return Reference to this string.
1609  * @throw std::out_of_range if @a pos is not a valid index.
1610  *
1611  * This function sets this string to the substring of @a __str
1612  * consisting of @a __n characters at @a __pos. If @a __n is
1613  * is larger than the number of available characters in @a
1614  * __str, the remainder of @a __str is used.
1615  */
1616  _GLIBCXX20_CONSTEXPR
1617  basic_string&
1618  assign(const basic_string& __str, size_type __pos, size_type __n = npos)
1619  { return _M_replace(size_type(0), this->size(), __str._M_data()
1620  + __str._M_check(__pos, "basic_string::assign"),
1621  __str._M_limit(__pos, __n)); }
1622 
1623  /**
1624  * @brief Set value to a C substring.
1625  * @param __s The C string to use.
1626  * @param __n Number of characters to use.
1627  * @return Reference to this string.
1628  *
1629  * This function sets the value of this string to the first @a __n
1630  * characters of @a __s. If @a __n is is larger than the number of
1631  * available characters in @a __s, the remainder of @a __s is used.
1632  */
1633  _GLIBCXX20_CONSTEXPR
1634  basic_string&
1635  assign(const _CharT* __s, size_type __n)
1636  {
1637  __glibcxx_requires_string_len(__s, __n);
1638  return _M_replace(size_type(0), this->size(), __s, __n);
1639  }
1640 
1641  /**
1642  * @brief Set value to contents of a C string.
1643  * @param __s The C string to use.
1644  * @return Reference to this string.
1645  *
1646  * This function sets the value of this string to the value of @a __s.
1647  * The data is copied, so there is no dependence on @a __s once the
1648  * function returns.
1649  */
1650  _GLIBCXX20_CONSTEXPR
1651  basic_string&
1652  assign(const _CharT* __s)
1653  {
1654  __glibcxx_requires_string(__s);
1655  return _M_replace(size_type(0), this->size(), __s,
1656  traits_type::length(__s));
1657  }
1658 
1659  /**
1660  * @brief Set value to multiple characters.
1661  * @param __n Length of the resulting string.
1662  * @param __c The character to use.
1663  * @return Reference to this string.
1664  *
1665  * This function sets the value of this string to @a __n copies of
1666  * character @a __c.
1667  */
1668  _GLIBCXX20_CONSTEXPR
1669  basic_string&
1670  assign(size_type __n, _CharT __c)
1671  { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
1672 
1673  /**
1674  * @brief Set value to a range of characters.
1675  * @param __first Iterator referencing the first character to append.
1676  * @param __last Iterator marking the end of the range.
1677  * @return Reference to this string.
1678  *
1679  * Sets value of string to characters in the range [__first,__last).
1680  */
1681 #if __cplusplus >= 201103L
1682  template<class _InputIterator,
1683  typename = std::_RequireInputIter<_InputIterator>>
1684  _GLIBCXX20_CONSTEXPR
1685 #else
1686  template<class _InputIterator>
1687 #endif
1688  basic_string&
1689  assign(_InputIterator __first, _InputIterator __last)
1690  { return this->replace(begin(), end(), __first, __last); }
1691 
1692 #if __cplusplus >= 201103L
1693  /**
1694  * @brief Set value to an initializer_list of characters.
1695  * @param __l The initializer_list of characters to assign.
1696  * @return Reference to this string.
1697  */
1698  _GLIBCXX20_CONSTEXPR
1699  basic_string&
1700  assign(initializer_list<_CharT> __l)
1701  { return this->assign(__l.begin(), __l.size()); }
1702 #endif // C++11
1703 
1704 #if __cplusplus >= 201703L
1705  /**
1706  * @brief Set value from a string_view.
1707  * @param __svt The source object convertible to string_view.
1708  * @return Reference to this string.
1709  */
1710  template<typename _Tp>
1711  _GLIBCXX20_CONSTEXPR
1712  _If_sv<_Tp, basic_string&>
1713  assign(const _Tp& __svt)
1714  {
1715  __sv_type __sv = __svt;
1716  return this->assign(__sv.data(), __sv.size());
1717  }
1718 
1719  /**
1720  * @brief Set value from a range of characters in a string_view.
1721  * @param __svt The source object convertible to string_view.
1722  * @param __pos The position in the string_view to assign from.
1723  * @param __n The number of characters to assign.
1724  * @return Reference to this string.
1725  */
1726  template<typename _Tp>
1727  _GLIBCXX20_CONSTEXPR
1728  _If_sv<_Tp, basic_string&>
1729  assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
1730  {
1731  __sv_type __sv = __svt;
1732  return _M_replace(size_type(0), this->size(),
1733  __sv.data()
1734  + std::__sv_check(__sv.size(), __pos, "basic_string::assign"),
1735  std::__sv_limit(__sv.size(), __pos, __n));
1736  }
1737 #endif // C++17
1738 
1739 #if __cplusplus >= 201103L
1740  /**
1741  * @brief Insert multiple characters.
1742  * @param __p Const_iterator referencing location in string to
1743  * insert at.
1744  * @param __n Number of characters to insert
1745  * @param __c The character to insert.
1746  * @return Iterator referencing the first inserted char.
1747  * @throw std::length_error If new length exceeds @c max_size().
1748  *
1749  * Inserts @a __n copies of character @a __c starting at the
1750  * position referenced by iterator @a __p. If adding
1751  * characters causes the length to exceed max_size(),
1752  * length_error is thrown. The value of the string doesn't
1753  * change if an error is thrown.
1754  */
1755  _GLIBCXX20_CONSTEXPR
1756  iterator
1757  insert(const_iterator __p, size_type __n, _CharT __c)
1758  {
1759  _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1760  const size_type __pos = __p - begin();
1761  this->replace(__p, __p, __n, __c);
1762  return iterator(this->_M_data() + __pos);
1763  }
1764 #else
1765  /**
1766  * @brief Insert multiple characters.
1767  * @param __p Iterator referencing location in string to insert at.
1768  * @param __n Number of characters to insert
1769  * @param __c The character to insert.
1770  * @throw std::length_error If new length exceeds @c max_size().
1771  *
1772  * Inserts @a __n copies of character @a __c starting at the
1773  * position referenced by iterator @a __p. If adding
1774  * characters causes the length to exceed max_size(),
1775  * length_error is thrown. The value of the string doesn't
1776  * change if an error is thrown.
1777  */
1778  void
1779  insert(iterator __p, size_type __n, _CharT __c)
1780  { this->replace(__p, __p, __n, __c); }
1781 #endif
1782 
1783 #if __cplusplus >= 201103L
1784  /**
1785  * @brief Insert a range of characters.
1786  * @param __p Const_iterator referencing location in string to
1787  * insert at.
1788  * @param __beg Start of range.
1789  * @param __end End of range.
1790  * @return Iterator referencing the first inserted char.
1791  * @throw std::length_error If new length exceeds @c max_size().
1792  *
1793  * Inserts characters in range [beg,end). If adding characters
1794  * causes the length to exceed max_size(), length_error is
1795  * thrown. The value of the string doesn't change if an error
1796  * is thrown.
1797  */
1798  template<class _InputIterator,
1799  typename = std::_RequireInputIter<_InputIterator>>
1800  _GLIBCXX20_CONSTEXPR
1801  iterator
1802  insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
1803  {
1804  _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1805  const size_type __pos = __p - begin();
1806  this->replace(__p, __p, __beg, __end);
1807  return iterator(this->_M_data() + __pos);
1808  }
1809 #else
1810  /**
1811  * @brief Insert a range of characters.
1812  * @param __p Iterator referencing location in string to insert at.
1813  * @param __beg Start of range.
1814  * @param __end End of range.
1815  * @throw std::length_error If new length exceeds @c max_size().
1816  *
1817  * Inserts characters in range [__beg,__end). If adding
1818  * characters causes the length to exceed max_size(),
1819  * length_error is thrown. The value of the string doesn't
1820  * change if an error is thrown.
1821  */
1822  template<class _InputIterator>
1823  void
1824  insert(iterator __p, _InputIterator __beg, _InputIterator __end)
1825  { this->replace(__p, __p, __beg, __end); }
1826 #endif
1827 
1828 #if __cplusplus >= 201103L
1829  /**
1830  * @brief Insert an initializer_list of characters.
1831  * @param __p Iterator referencing location in string to insert at.
1832  * @param __l The initializer_list of characters to insert.
1833  * @throw std::length_error If new length exceeds @c max_size().
1834  */
1835  _GLIBCXX20_CONSTEXPR
1836  iterator
1837  insert(const_iterator __p, initializer_list<_CharT> __l)
1838  { return this->insert(__p, __l.begin(), __l.end()); }
1839 
1840 #ifdef _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
1841  // See PR libstdc++/83328
1842  void
1843  insert(iterator __p, initializer_list<_CharT> __l)
1844  {
1845  _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1846  this->insert(__p - begin(), __l.begin(), __l.size());
1847  }
1848 #endif
1849 #endif // C++11
1850 
1851  /**
1852  * @brief Insert value of a string.
1853  * @param __pos1 Position in string to insert at.
1854  * @param __str The string to insert.
1855  * @return Reference to this string.
1856  * @throw std::length_error If new length exceeds @c max_size().
1857  *
1858  * Inserts value of @a __str starting at @a __pos1. If adding
1859  * characters causes the length to exceed max_size(),
1860  * length_error is thrown. The value of the string doesn't
1861  * change if an error is thrown.
1862  */
1863  _GLIBCXX20_CONSTEXPR
1864  basic_string&
1865  insert(size_type __pos1, const basic_string& __str)
1866  { return this->replace(__pos1, size_type(0),
1867  __str._M_data(), __str.size()); }
1868 
1869  /**
1870  * @brief Insert a substring.
1871  * @param __pos1 Position in string to insert at.
1872  * @param __str The string to insert.
1873  * @param __pos2 Start of characters in str to insert.
1874  * @param __n Number of characters to insert.
1875  * @return Reference to this string.
1876  * @throw std::length_error If new length exceeds @c max_size().
1877  * @throw std::out_of_range If @a pos1 > size() or
1878  * @a __pos2 > @a str.size().
1879  *
1880  * Starting at @a pos1, insert @a __n character of @a __str
1881  * beginning with @a __pos2. If adding characters causes the
1882  * length to exceed max_size(), length_error is thrown. If @a
1883  * __pos1 is beyond the end of this string or @a __pos2 is
1884  * beyond the end of @a __str, out_of_range is thrown. The
1885  * value of the string doesn't change if an error is thrown.
1886  */
1887  _GLIBCXX20_CONSTEXPR
1888  basic_string&
1889  insert(size_type __pos1, const basic_string& __str,
1890  size_type __pos2, size_type __n = npos)
1891  { return this->replace(__pos1, size_type(0), __str._M_data()
1892  + __str._M_check(__pos2, "basic_string::insert"),
1893  __str._M_limit(__pos2, __n)); }
1894 
1895  /**
1896  * @brief Insert a C substring.
1897  * @param __pos Position in string to insert at.
1898  * @param __s The C string to insert.
1899  * @param __n The number of characters to insert.
1900  * @return Reference to this string.
1901  * @throw std::length_error If new length exceeds @c max_size().
1902  * @throw std::out_of_range If @a __pos is beyond the end of this
1903  * string.
1904  *
1905  * Inserts the first @a __n characters of @a __s starting at @a
1906  * __pos. If adding characters causes the length to exceed
1907  * max_size(), length_error is thrown. If @a __pos is beyond
1908  * end(), out_of_range is thrown. The value of the string
1909  * doesn't change if an error is thrown.
1910  */
1911  _GLIBCXX20_CONSTEXPR
1912  basic_string&
1913  insert(size_type __pos, const _CharT* __s, size_type __n)
1914  { return this->replace(__pos, size_type(0), __s, __n); }
1915 
1916  /**
1917  * @brief Insert a C string.
1918  * @param __pos Position in string to insert at.
1919  * @param __s The C string to insert.
1920  * @return Reference to this string.
1921  * @throw std::length_error If new length exceeds @c max_size().
1922  * @throw std::out_of_range If @a pos is beyond the end of this
1923  * string.
1924  *
1925  * Inserts the first @a n characters of @a __s starting at @a __pos. If
1926  * adding characters causes the length to exceed max_size(),
1927  * length_error is thrown. If @a __pos is beyond end(), out_of_range is
1928  * thrown. The value of the string doesn't change if an error is
1929  * thrown.
1930  */
1931  _GLIBCXX20_CONSTEXPR
1932  basic_string&
1933  insert(size_type __pos, const _CharT* __s)
1934  {
1935  __glibcxx_requires_string(__s);
1936  return this->replace(__pos, size_type(0), __s,
1937  traits_type::length(__s));
1938  }
1939 
1940  /**
1941  * @brief Insert multiple characters.
1942  * @param __pos Index in string to insert at.
1943  * @param __n Number of characters to insert
1944  * @param __c The character to insert.
1945  * @return Reference to this string.
1946  * @throw std::length_error If new length exceeds @c max_size().
1947  * @throw std::out_of_range If @a __pos is beyond the end of this
1948  * string.
1949  *
1950  * Inserts @a __n copies of character @a __c starting at index
1951  * @a __pos. If adding characters causes the length to exceed
1952  * max_size(), length_error is thrown. If @a __pos > length(),
1953  * out_of_range is thrown. The value of the string doesn't
1954  * change if an error is thrown.
1955  */
1956  _GLIBCXX20_CONSTEXPR
1957  basic_string&
1958  insert(size_type __pos, size_type __n, _CharT __c)
1959  { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
1960  size_type(0), __n, __c); }
1961 
1962  /**
1963  * @brief Insert one character.
1964  * @param __p Iterator referencing position in string to insert at.
1965  * @param __c The character to insert.
1966  * @return Iterator referencing newly inserted char.
1967  * @throw std::length_error If new length exceeds @c max_size().
1968  *
1969  * Inserts character @a __c at position referenced by @a __p.
1970  * If adding character causes the length to exceed max_size(),
1971  * length_error is thrown. If @a __p is beyond end of string,
1972  * out_of_range is thrown. The value of the string doesn't
1973  * change if an error is thrown.
1974  */
1975  _GLIBCXX20_CONSTEXPR
1976  iterator
1977  insert(__const_iterator __p, _CharT __c)
1978  {
1979  _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1980  const size_type __pos = __p - begin();
1981  _M_replace_aux(__pos, size_type(0), size_type(1), __c);
1982  return iterator(_M_data() + __pos);
1983  }
1984 
1985 #if __cplusplus >= 201703L
1986  /**
1987  * @brief Insert a string_view.
1988  * @param __pos Position in string to insert at.
1989  * @param __svt The object convertible to string_view to insert.
1990  * @return Reference to this string.
1991  */
1992  template<typename _Tp>
1993  _GLIBCXX20_CONSTEXPR
1994  _If_sv<_Tp, basic_string&>
1995  insert(size_type __pos, const _Tp& __svt)
1996  {
1997  __sv_type __sv = __svt;
1998  return this->insert(__pos, __sv.data(), __sv.size());
1999  }
2000 
2001  /**
2002  * @brief Insert a string_view.
2003  * @param __pos1 Position in string to insert at.
2004  * @param __svt The object convertible to string_view to insert from.
2005  * @param __pos2 Start of characters in str to insert.
2006  * @param __n The number of characters to insert.
2007  * @return Reference to this string.
2008  */
2009  template<typename _Tp>
2010  _GLIBCXX20_CONSTEXPR
2011  _If_sv<_Tp, basic_string&>
2012  insert(size_type __pos1, const _Tp& __svt,
2013  size_type __pos2, size_type __n = npos)
2014  {
2015  __sv_type __sv = __svt;
2016  return this->replace(__pos1, size_type(0),
2017  __sv.data()
2018  + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"),
2019  std::__sv_limit(__sv.size(), __pos2, __n));
2020  }
2021 #endif // C++17
2022 
2023  /**
2024  * @brief Remove characters.
2025  * @param __pos Index of first character to remove (default 0).
2026  * @param __n Number of characters to remove (default remainder).
2027  * @return Reference to this string.
2028  * @throw std::out_of_range If @a pos is beyond the end of this
2029  * string.
2030  *
2031  * Removes @a __n characters from this string starting at @a
2032  * __pos. The length of the string is reduced by @a __n. If
2033  * there are < @a __n characters to remove, the remainder of
2034  * the string is truncated. If @a __p is beyond end of string,
2035  * out_of_range is thrown. The value of the string doesn't
2036  * change if an error is thrown.
2037  */
2038  _GLIBCXX20_CONSTEXPR
2039  basic_string&
2040  erase(size_type __pos = 0, size_type __n = npos)
2041  {
2042  _M_check(__pos, "basic_string::erase");
2043  if (__n == npos)
2044  this->_M_set_length(__pos);
2045  else if (__n != 0)
2046  this->_M_erase(__pos, _M_limit(__pos, __n));
2047  return *this;
2048  }
2049 
2050  /**
2051  * @brief Remove one character.
2052  * @param __position Iterator referencing the character to remove.
2053  * @return iterator referencing same location after removal.
2054  *
2055  * Removes the character at @a __position from this string. The value
2056  * of the string doesn't change if an error is thrown.
2057  */
2058  _GLIBCXX20_CONSTEXPR
2059  iterator
2060  erase(__const_iterator __position)
2061  {
2062  _GLIBCXX_DEBUG_PEDASSERT(__position >= begin()
2063  && __position < end());
2064  const size_type __pos = __position - begin();
2065  this->_M_erase(__pos, size_type(1));
2066  return iterator(_M_data() + __pos);
2067  }
2068 
2069  /**
2070  * @brief Remove a range of characters.
2071  * @param __first Iterator referencing the first character to remove.
2072  * @param __last Iterator referencing the end of the range.
2073  * @return Iterator referencing location of first after removal.
2074  *
2075  * Removes the characters in the range [first,last) from this string.
2076  * The value of the string doesn't change if an error is thrown.
2077  */
2078  _GLIBCXX20_CONSTEXPR
2079  iterator
2080  erase(__const_iterator __first, __const_iterator __last)
2081  {
2082  _GLIBCXX_DEBUG_PEDASSERT(__first >= begin() && __first <= __last
2083  && __last <= end());
2084  const size_type __pos = __first - begin();
2085  if (__last == end())
2086  this->_M_set_length(__pos);
2087  else
2088  this->_M_erase(__pos, __last - __first);
2089  return iterator(this->_M_data() + __pos);
2090  }
2091 
2092 #if __cplusplus >= 201103L
2093  /**
2094  * @brief Remove the last character.
2095  *
2096  * The string must be non-empty.
2097  */
2098  _GLIBCXX20_CONSTEXPR
2099  void
2100  pop_back() noexcept
2101  {
2102  __glibcxx_assert(!empty());
2103  _M_erase(size() - 1, 1);
2104  }
2105 #endif // C++11
2106 
2107  /**
2108  * @brief Replace characters with value from another string.
2109  * @param __pos Index of first character to replace.
2110  * @param __n Number of characters to be replaced.
2111  * @param __str String to insert.
2112  * @return Reference to this string.
2113  * @throw std::out_of_range If @a pos is beyond the end of this
2114  * string.
2115  * @throw std::length_error If new length exceeds @c max_size().
2116  *
2117  * Removes the characters in the range [__pos,__pos+__n) from
2118  * this string. In place, the value of @a __str is inserted.
2119  * If @a __pos is beyond end of string, out_of_range is thrown.
2120  * If the length of the result exceeds max_size(), length_error
2121  * is thrown. The value of the string doesn't change if an
2122  * error is thrown.
2123  */
2124  _GLIBCXX20_CONSTEXPR
2125  basic_string&
2126  replace(size_type __pos, size_type __n, const basic_string& __str)
2127  { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
2128 
2129  /**
2130  * @brief Replace characters with value from another string.
2131  * @param __pos1 Index of first character to replace.
2132  * @param __n1 Number of characters to be replaced.
2133  * @param __str String to insert.
2134  * @param __pos2 Index of first character of str to use.
2135  * @param __n2 Number of characters from str to use.
2136  * @return Reference to this string.
2137  * @throw std::out_of_range If @a __pos1 > size() or @a __pos2 >
2138  * __str.size().
2139  * @throw std::length_error If new length exceeds @c max_size().
2140  *
2141  * Removes the characters in the range [__pos1,__pos1 + n) from this
2142  * string. In place, the value of @a __str is inserted. If @a __pos is
2143  * beyond end of string, out_of_range is thrown. If the length of the
2144  * result exceeds max_size(), length_error is thrown. The value of the
2145  * string doesn't change if an error is thrown.
2146  */
2147  _GLIBCXX20_CONSTEXPR
2148  basic_string&
2149  replace(size_type __pos1, size_type __n1, const basic_string& __str,
2150  size_type __pos2, size_type __n2 = npos)
2151  { return this->replace(__pos1, __n1, __str._M_data()
2152  + __str._M_check(__pos2, "basic_string::replace"),
2153  __str._M_limit(__pos2, __n2)); }
2154 
2155  /**
2156  * @brief Replace characters with value of a C substring.
2157  * @param __pos Index of first character to replace.
2158  * @param __n1 Number of characters to be replaced.
2159  * @param __s C string to insert.
2160  * @param __n2 Number of characters from @a s to use.
2161  * @return Reference to this string.
2162  * @throw std::out_of_range If @a pos1 > size().
2163  * @throw std::length_error If new length exceeds @c max_size().
2164  *
2165  * Removes the characters in the range [__pos,__pos + __n1)
2166  * from this string. In place, the first @a __n2 characters of
2167  * @a __s are inserted, or all of @a __s if @a __n2 is too large. If
2168  * @a __pos is beyond end of string, out_of_range is thrown. If
2169  * the length of result exceeds max_size(), length_error is
2170  * thrown. The value of the string doesn't change if an error
2171  * is thrown.
2172  */
2173  _GLIBCXX20_CONSTEXPR
2174  basic_string&
2175  replace(size_type __pos, size_type __n1, const _CharT* __s,
2176  size_type __n2)
2177  {
2178  __glibcxx_requires_string_len(__s, __n2);
2179  return _M_replace(_M_check(__pos, "basic_string::replace"),
2180  _M_limit(__pos, __n1), __s, __n2);
2181  }
2182 
2183  /**
2184  * @brief Replace characters with value of a C string.
2185  * @param __pos Index of first character to replace.
2186  * @param __n1 Number of characters to be replaced.
2187  * @param __s C string to insert.
2188  * @return Reference to this string.
2189  * @throw std::out_of_range If @a pos > size().
2190  * @throw std::length_error If new length exceeds @c max_size().
2191  *
2192  * Removes the characters in the range [__pos,__pos + __n1)
2193  * from this string. In place, the characters of @a __s are
2194  * inserted. If @a __pos is beyond end of string, out_of_range
2195  * is thrown. If the length of result exceeds max_size(),
2196  * length_error is thrown. The value of the string doesn't
2197  * change if an error is thrown.
2198  */
2199  _GLIBCXX20_CONSTEXPR
2200  basic_string&
2201  replace(size_type __pos, size_type __n1, const _CharT* __s)
2202  {
2203  __glibcxx_requires_string(__s);
2204  return this->replace(__pos, __n1, __s, traits_type::length(__s));
2205  }
2206 
2207  /**
2208  * @brief Replace characters with multiple characters.
2209  * @param __pos Index of first character to replace.
2210  * @param __n1 Number of characters to be replaced.
2211  * @param __n2 Number of characters to insert.
2212  * @param __c Character to insert.
2213  * @return Reference to this string.
2214  * @throw std::out_of_range If @a __pos > size().
2215  * @throw std::length_error If new length exceeds @c max_size().
2216  *
2217  * Removes the characters in the range [pos,pos + n1) from this
2218  * string. In place, @a __n2 copies of @a __c are inserted.
2219  * If @a __pos is beyond end of string, out_of_range is thrown.
2220  * If the length of result exceeds max_size(), length_error is
2221  * thrown. The value of the string doesn't change if an error
2222  * is thrown.
2223  */
2224  _GLIBCXX20_CONSTEXPR
2225  basic_string&
2226  replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
2227  { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
2228  _M_limit(__pos, __n1), __n2, __c); }
2229 
2230  /**
2231  * @brief Replace range of characters with string.
2232  * @param __i1 Iterator referencing start of range to replace.
2233  * @param __i2 Iterator referencing end of range to replace.
2234  * @param __str String value to insert.
2235  * @return Reference to this string.
2236  * @throw std::length_error If new length exceeds @c max_size().
2237  *
2238  * Removes the characters in the range [__i1,__i2). In place,
2239  * the value of @a __str is inserted. If the length of result
2240  * exceeds max_size(), length_error is thrown. The value of
2241  * the string doesn't change if an error is thrown.
2242  */
2243  _GLIBCXX20_CONSTEXPR
2244  basic_string&
2245  replace(__const_iterator __i1, __const_iterator __i2,
2246  const basic_string& __str)
2247  { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
2248 
2249  /**
2250  * @brief Replace range of characters with C substring.
2251  * @param __i1 Iterator referencing start of range to replace.
2252  * @param __i2 Iterator referencing end of range to replace.
2253  * @param __s C string value to insert.
2254  * @param __n Number of characters from s to insert.
2255  * @return Reference to this string.
2256  * @throw std::length_error If new length exceeds @c max_size().
2257  *
2258  * Removes the characters in the range [__i1,__i2). In place,
2259  * the first @a __n characters of @a __s are inserted. If the
2260  * length of result exceeds max_size(), length_error is thrown.
2261  * The value of the string doesn't change if an error is
2262  * thrown.
2263  */
2264  _GLIBCXX20_CONSTEXPR
2265  basic_string&
2266  replace(__const_iterator __i1, __const_iterator __i2,
2267  const _CharT* __s, size_type __n)
2268  {
2269  _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2270  && __i2 <= end());
2271  return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
2272  }
2273 
2274  /**
2275  * @brief Replace range of characters with C string.
2276  * @param __i1 Iterator referencing start of range to replace.
2277  * @param __i2 Iterator referencing end of range to replace.
2278  * @param __s C string value to insert.
2279  * @return Reference to this string.
2280  * @throw std::length_error If new length exceeds @c max_size().
2281  *
2282  * Removes the characters in the range [__i1,__i2). In place,
2283  * the characters of @a __s are inserted. If the length of
2284  * result exceeds max_size(), length_error is thrown. The
2285  * value of the string doesn't change if an error is thrown.
2286  */
2287  _GLIBCXX20_CONSTEXPR
2288  basic_string&
2289  replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
2290  {
2291  __glibcxx_requires_string(__s);
2292  return this->replace(__i1, __i2, __s, traits_type::length(__s));
2293  }
2294 
2295  /**
2296  * @brief Replace range of characters with multiple characters
2297  * @param __i1 Iterator referencing start of range to replace.
2298  * @param __i2 Iterator referencing end of range to replace.
2299  * @param __n Number of characters to insert.
2300  * @param __c Character to insert.
2301  * @return Reference to this string.
2302  * @throw std::length_error If new length exceeds @c max_size().
2303  *
2304  * Removes the characters in the range [__i1,__i2). In place,
2305  * @a __n copies of @a __c are inserted. If the length of
2306  * result exceeds max_size(), length_error is thrown. The
2307  * value of the string doesn't change if an error is thrown.
2308  */
2309  _GLIBCXX20_CONSTEXPR
2310  basic_string&
2311  replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
2312  _CharT __c)
2313  {
2314  _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2315  && __i2 <= end());
2316  return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
2317  }
2318 
2319  /**
2320  * @brief Replace range of characters with range.
2321  * @param __i1 Iterator referencing start of range to replace.
2322  * @param __i2 Iterator referencing end of range to replace.
2323  * @param __k1 Iterator referencing start of range to insert.
2324  * @param __k2 Iterator referencing end of range to insert.
2325  * @return Reference to this string.
2326  * @throw std::length_error If new length exceeds @c max_size().
2327  *
2328  * Removes the characters in the range [__i1,__i2). In place,
2329  * characters in the range [__k1,__k2) are inserted. If the
2330  * length of result exceeds max_size(), length_error is thrown.
2331  * The value of the string doesn't change if an error is
2332  * thrown.
2333  */
2334 #if __cplusplus >= 201103L
2335  template<class _InputIterator,
2336  typename = std::_RequireInputIter<_InputIterator>>
2337  _GLIBCXX20_CONSTEXPR
2338  basic_string&
2339  replace(const_iterator __i1, const_iterator __i2,
2340  _InputIterator __k1, _InputIterator __k2)
2341  {
2342  _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2343  && __i2 <= end());
2344  __glibcxx_requires_valid_range(__k1, __k2);
2345  return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
2346  std::__false_type());
2347  }
2348 #else
2349  template<class _InputIterator>
2350 #ifdef _GLIBCXX_DISAMBIGUATE_REPLACE_INST
2351  typename __enable_if_not_native_iterator<_InputIterator>::__type
2352 #else
2353  basic_string&
2354 #endif
2355  replace(iterator __i1, iterator __i2,
2356  _InputIterator __k1, _InputIterator __k2)
2357  {
2358  _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2359  && __i2 <= end());
2360  __glibcxx_requires_valid_range(__k1, __k2);
2361  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
2362  return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
2363  }
2364 #endif
2365 
2366  // Specializations for the common case of pointer and iterator:
2367  // useful to avoid the overhead of temporary buffering in _M_replace.
2368  _GLIBCXX20_CONSTEXPR
2369  basic_string&
2370  replace(__const_iterator __i1, __const_iterator __i2,
2371  _CharT* __k1, _CharT* __k2)
2372  {
2373  _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2374  && __i2 <= end());
2375  __glibcxx_requires_valid_range(__k1, __k2);
2376  return this->replace(__i1 - begin(), __i2 - __i1,
2377  __k1, __k2 - __k1);
2378  }
2379 
2380  _GLIBCXX20_CONSTEXPR
2381  basic_string&
2382  replace(__const_iterator __i1, __const_iterator __i2,
2383  const _CharT* __k1, const _CharT* __k2)
2384  {
2385  _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2386  && __i2 <= end());
2387  __glibcxx_requires_valid_range(__k1, __k2);
2388  return this->replace(__i1 - begin(), __i2 - __i1,
2389  __k1, __k2 - __k1);
2390  }
2391 
2392  _GLIBCXX20_CONSTEXPR
2393  basic_string&
2394  replace(__const_iterator __i1, __const_iterator __i2,
2395  iterator __k1, iterator __k2)
2396  {
2397  _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2398  && __i2 <= end());
2399  __glibcxx_requires_valid_range(__k1, __k2);
2400  return this->replace(__i1 - begin(), __i2 - __i1,
2401  __k1.base(), __k2 - __k1);
2402  }
2403 
2404  _GLIBCXX20_CONSTEXPR
2405  basic_string&
2406  replace(__const_iterator __i1, __const_iterator __i2,
2407  const_iterator __k1, const_iterator __k2)
2408  {
2409  _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2410  && __i2 <= end());
2411  __glibcxx_requires_valid_range(__k1, __k2);
2412  return this->replace(__i1 - begin(), __i2 - __i1,
2413  __k1.base(), __k2 - __k1);
2414  }
2415 
2416 #if __cplusplus >= 201103L
2417  /**
2418  * @brief Replace range of characters with initializer_list.
2419  * @param __i1 Iterator referencing start of range to replace.
2420  * @param __i2 Iterator referencing end of range to replace.
2421  * @param __l The initializer_list of characters to insert.
2422  * @return Reference to this string.
2423  * @throw std::length_error If new length exceeds @c max_size().
2424  *
2425  * Removes the characters in the range [__i1,__i2). In place,
2426  * characters in the range [__k1,__k2) are inserted. If the
2427  * length of result exceeds max_size(), length_error is thrown.
2428  * The value of the string doesn't change if an error is
2429  * thrown.
2430  */
2431  _GLIBCXX20_CONSTEXPR
2432  basic_string& replace(const_iterator __i1, const_iterator __i2,
2433  initializer_list<_CharT> __l)
2434  { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
2435 #endif // C++11
2436 
2437 #if __cplusplus >= 201703L
2438  /**
2439  * @brief Replace range of characters with string_view.
2440  * @param __pos The position to replace at.
2441  * @param __n The number of characters to replace.
2442  * @param __svt The object convertible to string_view to insert.
2443  * @return Reference to this string.
2444  */
2445  template<typename _Tp>
2446  _GLIBCXX20_CONSTEXPR
2447  _If_sv<_Tp, basic_string&>
2448  replace(size_type __pos, size_type __n, const _Tp& __svt)
2449  {
2450  __sv_type __sv = __svt;
2451  return this->replace(__pos, __n, __sv.data(), __sv.size());
2452  }
2453 
2454  /**
2455  * @brief Replace range of characters with string_view.
2456  * @param __pos1 The position to replace at.
2457  * @param __n1 The number of characters to replace.
2458  * @param __svt The object convertible to string_view to insert from.
2459  * @param __pos2 The position in the string_view to insert from.
2460  * @param __n2 The number of characters to insert.
2461  * @return Reference to this string.
2462  */
2463  template<typename _Tp>
2464  _GLIBCXX20_CONSTEXPR
2465  _If_sv<_Tp, basic_string&>
2466  replace(size_type __pos1, size_type __n1, const _Tp& __svt,
2467  size_type __pos2, size_type __n2 = npos)
2468  {
2469  __sv_type __sv = __svt;
2470  return this->replace(__pos1, __n1,
2471  __sv.data()
2472  + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"),
2473  std::__sv_limit(__sv.size(), __pos2, __n2));
2474  }
2475 
2476  /**
2477  * @brief Replace range of characters with string_view.
2478  * @param __i1 An iterator referencing the start position
2479  to replace at.
2480  * @param __i2 An iterator referencing the end position
2481  for the replace.
2482  * @param __svt The object convertible to string_view to insert from.
2483  * @return Reference to this string.
2484  */
2485  template<typename _Tp>
2486  _GLIBCXX20_CONSTEXPR
2487  _If_sv<_Tp, basic_string&>
2488  replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
2489  {
2490  __sv_type __sv = __svt;
2491  return this->replace(__i1 - begin(), __i2 - __i1, __sv);
2492  }
2493 #endif // C++17
2494 
2495  private:
2496  template<class _Integer>
2497  _GLIBCXX20_CONSTEXPR
2498  basic_string&
2499  _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
2500  _Integer __n, _Integer __val, __true_type)
2501  { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
2502 
2503  template<class _InputIterator>
2504  _GLIBCXX20_CONSTEXPR
2505  basic_string&
2506  _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
2507  _InputIterator __k1, _InputIterator __k2,
2508  __false_type);
2509 
2510  _GLIBCXX20_CONSTEXPR
2511  basic_string&
2512  _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
2513  _CharT __c);
2514 
2515  _GLIBCXX20_CONSTEXPR
2516  basic_string&
2517  _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
2518  const size_type __len2);
2519 
2520  _GLIBCXX20_CONSTEXPR
2521  basic_string&
2522  _M_append(const _CharT* __s, size_type __n);
2523 
2524  public:
2525 
2526  /**
2527  * @brief Copy substring into C string.
2528  * @param __s C string to copy value into.
2529  * @param __n Number of characters to copy.
2530  * @param __pos Index of first character to copy.
2531  * @return Number of characters actually copied
2532  * @throw std::out_of_range If __pos > size().
2533  *
2534  * Copies up to @a __n characters starting at @a __pos into the
2535  * C string @a __s. If @a __pos is %greater than size(),
2536  * out_of_range is thrown.
2537  */
2538  _GLIBCXX20_CONSTEXPR
2539  size_type
2540  copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
2541 
2542  /**
2543  * @brief Swap contents with another string.
2544  * @param __s String to swap with.
2545  *
2546  * Exchanges the contents of this string with that of @a __s in constant
2547  * time.
2548  */
2549  _GLIBCXX20_CONSTEXPR
2550  void
2551  swap(basic_string& __s) _GLIBCXX_NOEXCEPT;
2552 
2553  // String operations:
2554  /**
2555  * @brief Return const pointer to null-terminated contents.
2556  *
2557  * This is a handle to internal data. Do not modify or dire things may
2558  * happen.
2559  */
2560  _GLIBCXX20_CONSTEXPR
2561  const _CharT*
2562  c_str() const _GLIBCXX_NOEXCEPT
2563  { return _M_data(); }
2564 
2565  /**
2566  * @brief Return const pointer to contents.
2567  *
2568  * This is a pointer to internal data. It is undefined to modify
2569  * the contents through the returned pointer. To get a pointer that
2570  * allows modifying the contents use @c &str[0] instead,
2571  * (or in C++17 the non-const @c str.data() overload).
2572  */
2573  _GLIBCXX20_CONSTEXPR
2574  const _CharT*
2575  data() const _GLIBCXX_NOEXCEPT
2576  { return _M_data(); }
2577 
2578 #if __cplusplus >= 201703L
2579  /**
2580  * @brief Return non-const pointer to contents.
2581  *
2582  * This is a pointer to the character sequence held by the string.
2583  * Modifying the characters in the sequence is allowed.
2584  */
2585  _GLIBCXX20_CONSTEXPR
2586  _CharT*
2587  data() noexcept
2588  { return _M_data(); }
2589 #endif
2590 
2591  /**
2592  * @brief Return copy of allocator used to construct this string.
2593  */
2594  _GLIBCXX20_CONSTEXPR
2595  allocator_type
2596  get_allocator() const _GLIBCXX_NOEXCEPT
2597  { return _M_get_allocator(); }
2598 
2599  /**
2600  * @brief Find position of a C substring.
2601  * @param __s C string to locate.
2602  * @param __pos Index of character to search from.
2603  * @param __n Number of characters from @a s to search for.
2604  * @return Index of start of first occurrence.
2605  *
2606  * Starting from @a __pos, searches forward for the first @a
2607  * __n characters in @a __s within this string. If found,
2608  * returns the index where it begins. If not found, returns
2609  * npos.
2610  */
2611  _GLIBCXX20_CONSTEXPR
2612  size_type
2613  find(const _CharT* __s, size_type __pos, size_type __n) const
2614  _GLIBCXX_NOEXCEPT;
2615 
2616  /**
2617  * @brief Find position of a string.
2618  * @param __str String to locate.
2619  * @param __pos Index of character to search from (default 0).
2620  * @return Index of start of first occurrence.
2621  *
2622  * Starting from @a __pos, searches forward for value of @a __str within
2623  * this string. If found, returns the index where it begins. If not
2624  * found, returns npos.
2625  */
2626  _GLIBCXX20_CONSTEXPR
2627  size_type
2628  find(const basic_string& __str, size_type __pos = 0) const
2629  _GLIBCXX_NOEXCEPT
2630  { return this->find(__str.data(), __pos, __str.size()); }
2631 
2632 #if __cplusplus >= 201703L
2633  /**
2634  * @brief Find position of a string_view.
2635  * @param __svt The object convertible to string_view to locate.
2636  * @param __pos Index of character to search from (default 0).
2637  * @return Index of start of first occurrence.
2638  */
2639  template<typename _Tp>
2640  _GLIBCXX20_CONSTEXPR
2641  _If_sv<_Tp, size_type>
2642  find(const _Tp& __svt, size_type __pos = 0) const
2643  noexcept(is_same<_Tp, __sv_type>::value)
2644  {
2645  __sv_type __sv = __svt;
2646  return this->find(__sv.data(), __pos, __sv.size());
2647  }
2648 #endif // C++17
2649 
2650  /**
2651  * @brief Find position of a C string.
2652  * @param __s C string to locate.
2653  * @param __pos Index of character to search from (default 0).
2654  * @return Index of start of first occurrence.
2655  *
2656  * Starting from @a __pos, searches forward for the value of @a
2657  * __s within this string. If found, returns the index where
2658  * it begins. If not found, returns npos.
2659  */
2660  _GLIBCXX20_CONSTEXPR
2661  size_type
2662  find(const _CharT* __s, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
2663  {
2664  __glibcxx_requires_string(__s);
2665  return this->find(__s, __pos, traits_type::length(__s));
2666  }
2667 
2668  /**
2669  * @brief Find position of a character.
2670  * @param __c Character to locate.
2671  * @param __pos Index of character to search from (default 0).
2672  * @return Index of first occurrence.
2673  *
2674  * Starting from @a __pos, searches forward for @a __c within
2675  * this string. If found, returns the index where it was
2676  * found. If not found, returns npos.
2677  */
2678  _GLIBCXX20_CONSTEXPR
2679  size_type
2680  find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT;
2681 
2682  /**
2683  * @brief Find last position of a string.
2684  * @param __str String to locate.
2685  * @param __pos Index of character to search back from (default end).
2686  * @return Index of start of last occurrence.
2687  *
2688  * Starting from @a __pos, searches backward for value of @a
2689  * __str within this string. If found, returns the index where
2690  * it begins. If not found, returns npos.
2691  */
2692  _GLIBCXX20_CONSTEXPR
2693  size_type
2694  rfind(const basic_string& __str, size_type __pos = npos) const
2695  _GLIBCXX_NOEXCEPT
2696  { return this->rfind(__str.data(), __pos, __str.size()); }
2697 
2698 #if __cplusplus >= 201703L
2699  /**
2700  * @brief Find last position of a string_view.
2701  * @param __svt The object convertible to string_view to locate.
2702  * @param __pos Index of character to search back from (default end).
2703  * @return Index of start of last occurrence.
2704  */
2705  template<typename _Tp>
2706  _GLIBCXX20_CONSTEXPR
2707  _If_sv<_Tp, size_type>
2708  rfind(const _Tp& __svt, size_type __pos = npos) const
2709  noexcept(is_same<_Tp, __sv_type>::value)
2710  {
2711  __sv_type __sv = __svt;
2712  return this->rfind(__sv.data(), __pos, __sv.size());
2713  }
2714 #endif // C++17
2715 
2716  /**
2717  * @brief Find last position of a C substring.
2718  * @param __s C string to locate.
2719  * @param __pos Index of character to search back from.
2720  * @param __n Number of characters from s to search for.
2721  * @return Index of start of last occurrence.
2722  *
2723  * Starting from @a __pos, searches backward for the first @a
2724  * __n characters in @a __s within this string. If found,
2725  * returns the index where it begins. If not found, returns
2726  * npos.
2727  */
2728  _GLIBCXX20_CONSTEXPR
2729  size_type
2730  rfind(const _CharT* __s, size_type __pos, size_type __n) const
2731  _GLIBCXX_NOEXCEPT;
2732 
2733  /**
2734  * @brief Find last position of a C string.
2735  * @param __s C string to locate.
2736  * @param __pos Index of character to start search at (default end).
2737  * @return Index of start of last occurrence.
2738  *
2739  * Starting from @a __pos, searches backward for the value of
2740  * @a __s within this string. If found, returns the index
2741  * where it begins. If not found, returns npos.
2742  */
2743  _GLIBCXX20_CONSTEXPR
2744  size_type
2745  rfind(const _CharT* __s, size_type __pos = npos) const
2746  {
2747  __glibcxx_requires_string(__s);
2748  return this->rfind(__s, __pos, traits_type::length(__s));
2749  }
2750 
2751  /**
2752  * @brief Find last position of a character.
2753  * @param __c Character to locate.
2754  * @param __pos Index of character to search back from (default end).
2755  * @return Index of last occurrence.
2756  *
2757  * Starting from @a __pos, searches backward for @a __c within
2758  * this string. If found, returns the index where it was
2759  * found. If not found, returns npos.
2760  */
2761  _GLIBCXX20_CONSTEXPR
2762  size_type
2763  rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT;
2764 
2765  /**
2766  * @brief Find position of a character of string.
2767  * @param __str String containing characters to locate.
2768  * @param __pos Index of character to search from (default 0).
2769  * @return Index of first occurrence.
2770  *
2771  * Starting from @a __pos, searches forward for one of the
2772  * characters of @a __str within this string. If found,
2773  * returns the index where it was found. If not found, returns
2774  * npos.
2775  */
2776  _GLIBCXX20_CONSTEXPR
2777  size_type
2778  find_first_of(const basic_string& __str, size_type __pos = 0) const
2779  _GLIBCXX_NOEXCEPT
2780  { return this->find_first_of(__str.data(), __pos, __str.size()); }
2781 
2782 #if __cplusplus >= 201703L
2783  /**
2784  * @brief Find position of a character of a string_view.
2785  * @param __svt An object convertible to string_view containing
2786  * characters to locate.
2787  * @param __pos Index of character to search from (default 0).
2788  * @return Index of first occurrence.
2789  */
2790  template<typename _Tp>
2791  _GLIBCXX20_CONSTEXPR
2792  _If_sv<_Tp, size_type>
2793  find_first_of(const _Tp& __svt, size_type __pos = 0) const
2794  noexcept(is_same<_Tp, __sv_type>::value)
2795  {
2796  __sv_type __sv = __svt;
2797  return this->find_first_of(__sv.data(), __pos, __sv.size());
2798  }
2799 #endif // C++17
2800 
2801  /**
2802  * @brief Find position of a character of C substring.
2803  * @param __s String containing characters to locate.
2804  * @param __pos Index of character to search from.
2805  * @param __n Number of characters from s to search for.
2806  * @return Index of first occurrence.
2807  *
2808  * Starting from @a __pos, searches forward for one of the
2809  * first @a __n characters of @a __s within this string. If
2810  * found, returns the index where it was found. If not found,
2811  * returns npos.
2812  */
2813  _GLIBCXX20_CONSTEXPR
2814  size_type
2815  find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
2816  _GLIBCXX_NOEXCEPT;
2817 
2818  /**
2819  * @brief Find position of a character of C string.
2820  * @param __s String containing characters to locate.
2821  * @param __pos Index of character to search from (default 0).
2822  * @return Index of first occurrence.
2823  *
2824  * Starting from @a __pos, searches forward for one of the
2825  * characters of @a __s within this string. If found, returns
2826  * the index where it was found. If not found, returns npos.
2827  */
2828  _GLIBCXX20_CONSTEXPR
2829  size_type
2830  find_first_of(const _CharT* __s, size_type __pos = 0) const
2831  _GLIBCXX_NOEXCEPT
2832  {
2833  __glibcxx_requires_string(__s);
2834  return this->find_first_of(__s, __pos, traits_type::length(__s));
2835  }
2836 
2837  /**
2838  * @brief Find position of a character.
2839  * @param __c Character to locate.
2840  * @param __pos Index of character to search from (default 0).
2841  * @return Index of first occurrence.
2842  *
2843  * Starting from @a __pos, searches forward for the character
2844  * @a __c within this string. If found, returns the index
2845  * where it was found. If not found, returns npos.
2846  *
2847  * Note: equivalent to find(__c, __pos).
2848  */
2849  _GLIBCXX20_CONSTEXPR
2850  size_type
2851  find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
2852  { return this->find(__c, __pos); }
2853 
2854  /**
2855  * @brief Find last position of a character of string.
2856  * @param __str String containing characters to locate.
2857  * @param __pos Index of character to search back from (default end).
2858  * @return Index of last occurrence.
2859  *
2860  * Starting from @a __pos, searches backward for one of the
2861  * characters of @a __str within this string. If found,
2862  * returns the index where it was found. If not found, returns
2863  * npos.
2864  */
2865  _GLIBCXX20_CONSTEXPR
2866  size_type
2867  find_last_of(const basic_string& __str, size_type __pos = npos) const
2868  _GLIBCXX_NOEXCEPT
2869  { return this->find_last_of(__str.data(), __pos, __str.size()); }
2870 
2871 #if __cplusplus >= 201703L
2872  /**
2873  * @brief Find last position of a character of string.
2874  * @param __svt An object convertible to string_view containing
2875  * characters to locate.
2876  * @param __pos Index of character to search back from (default end).
2877  * @return Index of last occurrence.
2878  */
2879  template<typename _Tp>
2880  _GLIBCXX20_CONSTEXPR
2881  _If_sv<_Tp, size_type>
2882  find_last_of(const _Tp& __svt, size_type __pos = npos) const
2883  noexcept(is_same<_Tp, __sv_type>::value)
2884  {
2885  __sv_type __sv = __svt;
2886  return this->find_last_of(__sv.data(), __pos, __sv.size());
2887  }
2888 #endif // C++17
2889 
2890  /**
2891  * @brief Find last position of a character of C substring.
2892  * @param __s C string containing characters to locate.
2893  * @param __pos Index of character to search back from.
2894  * @param __n Number of characters from s to search for.
2895  * @return Index of last occurrence.
2896  *
2897  * Starting from @a __pos, searches backward for one of the
2898  * first @a __n characters of @a __s within this string. If
2899  * found, returns the index where it was found. If not found,
2900  * returns npos.
2901  */
2902  _GLIBCXX20_CONSTEXPR
2903  size_type
2904  find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
2905  _GLIBCXX_NOEXCEPT;
2906 
2907  /**
2908  * @brief Find last position of a character of C string.
2909  * @param __s C string containing characters to locate.
2910  * @param __pos Index of character to search back from (default end).
2911  * @return Index of last occurrence.
2912  *
2913  * Starting from @a __pos, searches backward for one of the
2914  * characters of @a __s within this string. If found, returns
2915  * the index where it was found. If not found, returns npos.
2916  */
2917  _GLIBCXX20_CONSTEXPR
2918  size_type
2919  find_last_of(const _CharT* __s, size_type __pos = npos) const
2920  _GLIBCXX_NOEXCEPT
2921  {
2922  __glibcxx_requires_string(__s);
2923  return this->find_last_of(__s, __pos, traits_type::length(__s));
2924  }
2925 
2926  /**
2927  * @brief Find last position of a character.
2928  * @param __c Character to locate.
2929  * @param __pos Index of character to search back from (default end).
2930  * @return Index of last occurrence.
2931  *
2932  * Starting from @a __pos, searches backward for @a __c within
2933  * this string. If found, returns the index where it was
2934  * found. If not found, returns npos.
2935  *
2936  * Note: equivalent to rfind(__c, __pos).
2937  */
2938  _GLIBCXX20_CONSTEXPR
2939  size_type
2940  find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
2941  { return this->rfind(__c, __pos); }
2942 
2943  /**
2944  * @brief Find position of a character not in string.
2945  * @param __str String containing characters to avoid.
2946  * @param __pos Index of character to search from (default 0).
2947  * @return Index of first occurrence.
2948  *
2949  * Starting from @a __pos, searches forward for a character not contained
2950  * in @a __str within this string. If found, returns the index where it
2951  * was found. If not found, returns npos.
2952  */
2953  _GLIBCXX20_CONSTEXPR
2954  size_type
2955  find_first_not_of(const basic_string& __str, size_type __pos = 0) const
2956  _GLIBCXX_NOEXCEPT
2957  { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
2958 
2959 #if __cplusplus >= 201703L
2960  /**
2961  * @brief Find position of a character not in a string_view.
2962  * @param __svt A object convertible to string_view containing
2963  * characters to avoid.
2964  * @param __pos Index of character to search from (default 0).
2965  * @return Index of first occurrence.
2966  */
2967  template<typename _Tp>
2968  _If_sv<_Tp, size_type>
2969  _GLIBCXX20_CONSTEXPR
2970  find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
2971  noexcept(is_same<_Tp, __sv_type>::value)
2972  {
2973  __sv_type __sv = __svt;
2974  return this->find_first_not_of(__sv.data(), __pos, __sv.size());
2975  }
2976 #endif // C++17
2977 
2978  /**
2979  * @brief Find position of a character not in C substring.
2980  * @param __s C string containing characters to avoid.
2981  * @param __pos Index of character to search from.
2982  * @param __n Number of characters from __s to consider.
2983  * @return Index of first occurrence.
2984  *
2985  * Starting from @a __pos, searches forward for a character not
2986  * contained in the first @a __n characters of @a __s within
2987  * this string. If found, returns the index where it was
2988  * found. If not found, returns npos.
2989  */
2990  _GLIBCXX20_CONSTEXPR
2991  size_type
2992  find_first_not_of(const _CharT* __s, size_type __pos,
2993  size_type __n) const _GLIBCXX_NOEXCEPT;
2994 
2995  /**
2996  * @brief Find position of a character not in C string.
2997  * @param __s C string containing characters to avoid.
2998  * @param __pos Index of character to search from (default 0).
2999  * @return Index of first occurrence.
3000  *
3001  * Starting from @a __pos, searches forward for a character not
3002  * contained in @a __s within this string. If found, returns
3003  * the index where it was found. If not found, returns npos.
3004  */
3005  _GLIBCXX20_CONSTEXPR
3006  size_type
3007  find_first_not_of(const _CharT* __s, size_type __pos = 0) const
3008  _GLIBCXX_NOEXCEPT
3009  {
3010  __glibcxx_requires_string(__s);
3011  return this->find_first_not_of(__s, __pos, traits_type::length(__s));
3012  }
3013 
3014  /**
3015  * @brief Find position of a different character.
3016  * @param __c Character to avoid.
3017  * @param __pos Index of character to search from (default 0).
3018  * @return Index of first occurrence.
3019  *
3020  * Starting from @a __pos, searches forward for a character
3021  * other than @a __c within this string. If found, returns the
3022  * index where it was found. If not found, returns npos.
3023  */
3024  _GLIBCXX20_CONSTEXPR
3025  size_type
3026  find_first_not_of(_CharT __c, size_type __pos = 0) const
3027  _GLIBCXX_NOEXCEPT;
3028 
3029  /**
3030  * @brief Find last position of a character not in string.
3031  * @param __str String containing characters to avoid.
3032  * @param __pos Index of character to search back from (default end).
3033  * @return Index of last occurrence.
3034  *
3035  * Starting from @a __pos, searches backward for a character
3036  * not contained in @a __str within this string. If found,
3037  * returns the index where it was found. If not found, returns
3038  * npos.
3039  */
3040  _GLIBCXX20_CONSTEXPR
3041  size_type
3042  find_last_not_of(const basic_string& __str, size_type __pos = npos) const
3043  _GLIBCXX_NOEXCEPT
3044  { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
3045 
3046 #if __cplusplus >= 201703L
3047  /**
3048  * @brief Find last position of a character not in a string_view.
3049  * @param __svt An object convertible to string_view containing
3050  * characters to avoid.
3051  * @param __pos Index of character to search back from (default end).
3052  * @return Index of last occurrence.
3053  */
3054  template<typename _Tp>
3055  _GLIBCXX20_CONSTEXPR
3056  _If_sv<_Tp, size_type>
3057  find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
3058  noexcept(is_same<_Tp, __sv_type>::value)
3059  {
3060  __sv_type __sv = __svt;
3061  return this->find_last_not_of(__sv.data(), __pos, __sv.size());
3062  }
3063 #endif // C++17
3064 
3065  /**
3066  * @brief Find last position of a character not in C substring.
3067  * @param __s C string containing characters to avoid.
3068  * @param __pos Index of character to search back from.
3069  * @param __n Number of characters from s to consider.
3070  * @return Index of last occurrence.
3071  *
3072  * Starting from @a __pos, searches backward for a character not
3073  * contained in the first @a __n characters of @a __s within this string.
3074  * If found, returns the index where it was found. If not found,
3075  * returns npos.
3076  */
3077  _GLIBCXX20_CONSTEXPR
3078  size_type
3079  find_last_not_of(const _CharT* __s, size_type __pos,
3080  size_type __n) const _GLIBCXX_NOEXCEPT;
3081  /**
3082  * @brief Find last position of a character not in C string.
3083  * @param __s C string containing characters to avoid.
3084  * @param __pos Index of character to search back from (default end).
3085  * @return Index of last occurrence.
3086  *
3087  * Starting from @a __pos, searches backward for a character
3088  * not contained in @a __s within this string. If found,
3089  * returns the index where it was found. If not found, returns
3090  * npos.
3091  */
3092  _GLIBCXX20_CONSTEXPR
3093  size_type
3094  find_last_not_of(const _CharT* __s, size_type __pos = npos) const
3095  _GLIBCXX_NOEXCEPT
3096  {
3097  __glibcxx_requires_string(__s);
3098  return this->find_last_not_of(__s, __pos, traits_type::length(__s));
3099  }
3100 
3101  /**
3102  * @brief Find last position of a different character.
3103  * @param __c Character to avoid.
3104  * @param __pos Index of character to search back from (default end).
3105  * @return Index of last occurrence.
3106  *
3107  * Starting from @a __pos, searches backward for a character other than
3108  * @a __c within this string. If found, returns the index where it was
3109  * found. If not found, returns npos.
3110  */
3111  _GLIBCXX20_CONSTEXPR
3112  size_type
3113  find_last_not_of(_CharT __c, size_type __pos = npos) const
3114  _GLIBCXX_NOEXCEPT;
3115 
3116  /**
3117  * @brief Get a substring.
3118  * @param __pos Index of first character (default 0).
3119  * @param __n Number of characters in substring (default remainder).
3120  * @return The new string.
3121  * @throw std::out_of_range If __pos > size().
3122  *
3123  * Construct and return a new string using the @a __n
3124  * characters starting at @a __pos. If the string is too
3125  * short, use the remainder of the characters. If @a __pos is
3126  * beyond the end of the string, out_of_range is thrown.
3127  */
3128  _GLIBCXX20_CONSTEXPR
3129  basic_string
3130  substr(size_type __pos = 0, size_type __n = npos) const
3131  { return basic_string(*this,
3132  _M_check(__pos, "basic_string::substr"), __n); }
3133 
3134  /**
3135  * @brief Compare to a string.
3136  * @param __str String to compare against.
3137  * @return Integer < 0, 0, or > 0.
3138  *
3139  * Returns an integer < 0 if this string is ordered before @a
3140  * __str, 0 if their values are equivalent, or > 0 if this
3141  * string is ordered after @a __str. Determines the effective
3142  * length rlen of the strings to compare as the smallest of
3143  * size() and str.size(). The function then compares the two
3144  * strings by calling traits::compare(data(), str.data(),rlen).
3145  * If the result of the comparison is nonzero returns it,
3146  * otherwise the shorter one is ordered first.
3147  */
3148  _GLIBCXX20_CONSTEXPR
3149  int
3150  compare(const basic_string& __str) const
3151  {
3152  const size_type __size = this->size();
3153  const size_type __osize = __str.size();
3154  const size_type __len = std::min(__size, __osize);
3155 
3156  int __r = traits_type::compare(_M_data(), __str.data(), __len);
3157  if (!__r)
3158  __r = _S_compare(__size, __osize);
3159  return __r;
3160  }
3161 
3162 #if __cplusplus >= 201703L
3163  /**
3164  * @brief Compare to a string_view.
3165  * @param __svt An object convertible to string_view to compare against.
3166  * @return Integer < 0, 0, or > 0.
3167  */
3168  template<typename _Tp>
3169  _GLIBCXX20_CONSTEXPR
3170  _If_sv<_Tp, int>
3171  compare(const _Tp& __svt) const
3172  noexcept(is_same<_Tp, __sv_type>::value)
3173  {
3174  __sv_type __sv = __svt;
3175  const size_type __size = this->size();
3176  const size_type __osize = __sv.size();
3177  const size_type __len = std::min(__size, __osize);
3178 
3179  int __r = traits_type::compare(_M_data(), __sv.data(), __len);
3180  if (!__r)
3181  __r = _S_compare(__size, __osize);
3182  return __r;
3183  }
3184 
3185  /**
3186  * @brief Compare to a string_view.
3187  * @param __pos A position in the string to start comparing from.
3188  * @param __n The number of characters to compare.
3189  * @param __svt An object convertible to string_view to compare
3190  * against.
3191  * @return Integer < 0, 0, or > 0.
3192  */
3193  template<typename _Tp>
3194  _GLIBCXX20_CONSTEXPR
3195  _If_sv<_Tp, int>
3196  compare(size_type __pos, size_type __n, const _Tp& __svt) const
3197  noexcept(is_same<_Tp, __sv_type>::value)
3198  {
3199  __sv_type __sv = __svt;
3200  return __sv_type(*this).substr(__pos, __n).compare(__sv);
3201  }
3202 
3203  /**
3204  * @brief Compare to a string_view.
3205  * @param __pos1 A position in the string to start comparing from.
3206  * @param __n1 The number of characters to compare.
3207  * @param __svt An object convertible to string_view to compare
3208  * against.
3209  * @param __pos2 A position in the string_view to start comparing from.
3210  * @param __n2 The number of characters to compare.
3211  * @return Integer < 0, 0, or > 0.
3212  */
3213  template<typename _Tp>
3214  _GLIBCXX20_CONSTEXPR
3215  _If_sv<_Tp, int>
3216  compare(size_type __pos1, size_type __n1, const _Tp& __svt,
3217  size_type __pos2, size_type __n2 = npos) const
3218  noexcept(is_same<_Tp, __sv_type>::value)
3219  {
3220  __sv_type __sv = __svt;
3221  return __sv_type(*this)
3222  .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
3223  }
3224 #endif // C++17
3225 
3226  /**
3227  * @brief Compare substring to a string.
3228  * @param __pos Index of first character of substring.
3229  * @param __n Number of characters in substring.
3230  * @param __str String to compare against.
3231  * @return Integer < 0, 0, or > 0.
3232  *
3233  * Form the substring of this string from the @a __n characters
3234  * starting at @a __pos. Returns an integer < 0 if the
3235  * substring is ordered before @a __str, 0 if their values are
3236  * equivalent, or > 0 if the substring is ordered after @a
3237  * __str. Determines the effective length rlen of the strings
3238  * to compare as the smallest of the length of the substring
3239  * and @a __str.size(). The function then compares the two
3240  * strings by calling
3241  * traits::compare(substring.data(),str.data(),rlen). If the
3242  * result of the comparison is nonzero returns it, otherwise
3243  * the shorter one is ordered first.
3244  */
3245  _GLIBCXX20_CONSTEXPR
3246  int
3247  compare(size_type __pos, size_type __n, const basic_string& __str) const;
3248 
3249  /**
3250  * @brief Compare substring to a substring.
3251  * @param __pos1 Index of first character of substring.
3252  * @param __n1 Number of characters in substring.
3253  * @param __str String to compare against.
3254  * @param __pos2 Index of first character of substring of str.
3255  * @param __n2 Number of characters in substring of str.
3256  * @return Integer < 0, 0, or > 0.
3257  *
3258  * Form the substring of this string from the @a __n1
3259  * characters starting at @a __pos1. Form the substring of @a
3260  * __str from the @a __n2 characters starting at @a __pos2.
3261  * Returns an integer < 0 if this substring is ordered before
3262  * the substring of @a __str, 0 if their values are equivalent,
3263  * or > 0 if this substring is ordered after the substring of
3264  * @a __str. Determines the effective length rlen of the
3265  * strings to compare as the smallest of the lengths of the
3266  * substrings. The function then compares the two strings by
3267  * calling
3268  * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
3269  * If the result of the comparison is nonzero returns it,
3270  * otherwise the shorter one is ordered first.
3271  */
3272  _GLIBCXX20_CONSTEXPR
3273  int
3274  compare(size_type __pos1, size_type __n1, const basic_string& __str,
3275  size_type __pos2, size_type __n2 = npos) const;
3276 
3277  /**
3278  * @brief Compare to a C string.
3279  * @param __s C string to compare against.
3280  * @return Integer < 0, 0, or > 0.
3281  *
3282  * Returns an integer < 0 if this string is ordered before @a __s, 0 if
3283  * their values are equivalent, or > 0 if this string is ordered after
3284  * @a __s. Determines the effective length rlen of the strings to
3285  * compare as the smallest of size() and the length of a string
3286  * constructed from @a __s. The function then compares the two strings
3287  * by calling traits::compare(data(),s,rlen). If the result of the
3288  * comparison is nonzero returns it, otherwise the shorter one is
3289  * ordered first.
3290  */
3291  _GLIBCXX20_CONSTEXPR
3292  int
3293  compare(const _CharT* __s) const _GLIBCXX_NOEXCEPT;
3294 
3295  // _GLIBCXX_RESOLVE_LIB_DEFECTS
3296  // 5 String::compare specification questionable
3297  /**
3298  * @brief Compare substring to a C string.
3299  * @param __pos Index of first character of substring.
3300  * @param __n1 Number of characters in substring.
3301  * @param __s C string to compare against.
3302  * @return Integer < 0, 0, or > 0.
3303  *
3304  * Form the substring of this string from the @a __n1
3305  * characters starting at @a pos. Returns an integer < 0 if
3306  * the substring is ordered before @a __s, 0 if their values
3307  * are equivalent, or > 0 if the substring is ordered after @a
3308  * __s. Determines the effective length rlen of the strings to
3309  * compare as the smallest of the length of the substring and
3310  * the length of a string constructed from @a __s. The
3311  * function then compares the two string by calling
3312  * traits::compare(substring.data(),__s,rlen). If the result of
3313  * the comparison is nonzero returns it, otherwise the shorter
3314  * one is ordered first.
3315  */
3316  _GLIBCXX20_CONSTEXPR
3317  int
3318  compare(size_type __pos, size_type __n1, const _CharT* __s) const;
3319 
3320  /**
3321  * @brief Compare substring against a character %array.
3322  * @param __pos Index of first character of substring.
3323  * @param __n1 Number of characters in substring.
3324  * @param __s character %array to compare against.
3325  * @param __n2 Number of characters of s.
3326  * @return Integer < 0, 0, or > 0.
3327  *
3328  * Form the substring of this string from the @a __n1
3329  * characters starting at @a __pos. Form a string from the
3330  * first @a __n2 characters of @a __s. Returns an integer < 0
3331  * if this substring is ordered before the string from @a __s,
3332  * 0 if their values are equivalent, or > 0 if this substring
3333  * is ordered after the string from @a __s. Determines the
3334  * effective length rlen of the strings to compare as the
3335  * smallest of the length of the substring and @a __n2. The
3336  * function then compares the two strings by calling
3337  * traits::compare(substring.data(),s,rlen). If the result of
3338  * the comparison is nonzero returns it, otherwise the shorter
3339  * one is ordered first.
3340  *
3341  * NB: s must have at least n2 characters, &apos;\\0&apos; has
3342  * no special meaning.
3343  */
3344  _GLIBCXX20_CONSTEXPR
3345  int
3346  compare(size_type __pos, size_type __n1, const _CharT* __s,
3347  size_type __n2) const;
3348 
3349 #if __cplusplus >= 202002L
3350  constexpr bool
3351  starts_with(basic_string_view<_CharT, _Traits> __x) const noexcept
3352  { return __sv_type(this->data(), this->size()).starts_with(__x); }
3353 
3354  constexpr bool
3355  starts_with(_CharT __x) const noexcept
3356  { return __sv_type(this->data(), this->size()).starts_with(__x); }
3357 
3358  constexpr bool
3359  starts_with(const _CharT* __x) const noexcept
3360  { return __sv_type(this->data(), this->size()).starts_with(__x); }
3361 
3362  constexpr bool
3363  ends_with(basic_string_view<_CharT, _Traits> __x) const noexcept
3364  { return __sv_type(this->data(), this->size()).ends_with(__x); }
3365 
3366  constexpr bool
3367  ends_with(_CharT __x) const noexcept
3368  { return __sv_type(this->data(), this->size()).ends_with(__x); }
3369 
3370  constexpr bool
3371  ends_with(const _CharT* __x) const noexcept
3372  { return __sv_type(this->data(), this->size()).ends_with(__x); }
3373 #endif // C++20
3374 
3375 #if __cplusplus > 202002L
3376  constexpr bool
3377  contains(basic_string_view<_CharT, _Traits> __x) const noexcept
3378  { return __sv_type(this->data(), this->size()).contains(__x); }
3379 
3380  constexpr bool
3381  contains(_CharT __x) const noexcept
3382  { return __sv_type(this->data(), this->size()).contains(__x); }
3383 
3384  constexpr bool
3385  contains(const _CharT* __x) const noexcept
3386  { return __sv_type(this->data(), this->size()).contains(__x); }
3387 #endif // C++23
3388 
3389  // Allow basic_stringbuf::__xfer_bufptrs to call _M_length:
3390  template<typename, typename, typename> friend class basic_stringbuf;
3391  };
3392 _GLIBCXX_END_NAMESPACE_CXX11
3393 _GLIBCXX_END_NAMESPACE_VERSION
3394 } // namespace std
3395 #endif // _GLIBCXX_USE_CXX11_ABI
3396 
3397 namespace std _GLIBCXX_VISIBILITY(default)
3398 {
3399 _GLIBCXX_BEGIN_NAMESPACE_VERSION
3400 
3401 #if __cpp_deduction_guides >= 201606
3402 _GLIBCXX_BEGIN_NAMESPACE_CXX11
3403  template<typename _InputIterator, typename _CharT
3404  = typename iterator_traits<_InputIterator>::value_type,
3405  typename _Allocator = allocator<_CharT>,
3406  typename = _RequireInputIter<_InputIterator>,
3407  typename = _RequireAllocator<_Allocator>>
3408  basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
3409  -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
3410 
3411  // _GLIBCXX_RESOLVE_LIB_DEFECTS
3412  // 3075. basic_string needs deduction guides from basic_string_view
3413  template<typename _CharT, typename _Traits,
3414  typename _Allocator = allocator<_CharT>,
3415  typename = _RequireAllocator<_Allocator>>
3416  basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
3417  -> basic_string<_CharT, _Traits, _Allocator>;
3418 
3419  template<typename _CharT, typename _Traits,
3420  typename _Allocator = allocator<_CharT>,
3421  typename = _RequireAllocator<_Allocator>>
3422  basic_string(basic_string_view<_CharT, _Traits>,
3423  typename basic_string<_CharT, _Traits, _Allocator>::size_type,
3424  typename basic_string<_CharT, _Traits, _Allocator>::size_type,
3425  const _Allocator& = _Allocator())
3426  -> basic_string<_CharT, _Traits, _Allocator>;
3427 _GLIBCXX_END_NAMESPACE_CXX11
3428 #endif
3429 
3430  // operator+
3431  /**
3432  * @brief Concatenate two strings.
3433  * @param __lhs First string.
3434  * @param __rhs Last string.
3435  * @return New string with value of @a __lhs followed by @a __rhs.
3436  */
3437  template<typename _CharT, typename _Traits, typename _Alloc>
3438  _GLIBCXX20_CONSTEXPR
3439  basic_string<_CharT, _Traits, _Alloc>
3442  {
3444  __str.append(__rhs);
3445  return __str;
3446  }
3447 
3448  /**
3449  * @brief Concatenate C string and string.
3450  * @param __lhs First string.
3451  * @param __rhs Last string.
3452  * @return New string with value of @a __lhs followed by @a __rhs.
3453  */
3454  template<typename _CharT, typename _Traits, typename _Alloc>
3455  _GLIBCXX20_CONSTEXPR
3456  basic_string<_CharT,_Traits,_Alloc>
3457  operator+(const _CharT* __lhs,
3458  const basic_string<_CharT,_Traits,_Alloc>& __rhs);
3459 
3460  /**
3461  * @brief Concatenate character and string.
3462  * @param __lhs First string.
3463  * @param __rhs Last string.
3464  * @return New string with @a __lhs followed by @a __rhs.
3465  */
3466  template<typename _CharT, typename _Traits, typename _Alloc>
3467  _GLIBCXX20_CONSTEXPR
3468  basic_string<_CharT,_Traits,_Alloc>
3469  operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
3470 
3471  /**
3472  * @brief Concatenate string and C string.
3473  * @param __lhs First string.
3474  * @param __rhs Last string.
3475  * @return New string with @a __lhs followed by @a __rhs.
3476  */
3477  template<typename _CharT, typename _Traits, typename _Alloc>
3478  _GLIBCXX20_CONSTEXPR
3479  inline basic_string<_CharT, _Traits, _Alloc>
3481  const _CharT* __rhs)
3482  {
3484  __str.append(__rhs);
3485  return __str;
3486  }
3487 
3488  /**
3489  * @brief Concatenate string and character.
3490  * @param __lhs First string.
3491  * @param __rhs Last string.
3492  * @return New string with @a __lhs followed by @a __rhs.
3493  */
3494  template<typename _CharT, typename _Traits, typename _Alloc>
3495  _GLIBCXX20_CONSTEXPR
3496  inline basic_string<_CharT, _Traits, _Alloc>
3498  {
3499  typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
3500  typedef typename __string_type::size_type __size_type;
3501  __string_type __str(__lhs);
3502  __str.append(__size_type(1), __rhs);
3503  return __str;
3504  }
3505 
3506 #if __cplusplus >= 201103L
3507  template<typename _CharT, typename _Traits, typename _Alloc>
3508  _GLIBCXX20_CONSTEXPR
3509  inline basic_string<_CharT, _Traits, _Alloc>
3510  operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
3511  const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3512  { return std::move(__lhs.append(__rhs)); }
3513 
3514  template<typename _CharT, typename _Traits, typename _Alloc>
3515  _GLIBCXX20_CONSTEXPR
3516  inline basic_string<_CharT, _Traits, _Alloc>
3517  operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3518  basic_string<_CharT, _Traits, _Alloc>&& __rhs)
3519  { return std::move(__rhs.insert(0, __lhs)); }
3520 
3521  template<typename _CharT, typename _Traits, typename _Alloc>
3522  _GLIBCXX20_CONSTEXPR
3523  inline basic_string<_CharT, _Traits, _Alloc>
3524  operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
3525  basic_string<_CharT, _Traits, _Alloc>&& __rhs)
3526  {
3527 #if _GLIBCXX_USE_CXX11_ABI
3528  using _Alloc_traits = allocator_traits<_Alloc>;
3529  bool __use_rhs = false;
3530  if _GLIBCXX17_CONSTEXPR (typename _Alloc_traits::is_always_equal{})
3531  __use_rhs = true;
3532  else if (__lhs.get_allocator() == __rhs.get_allocator())
3533  __use_rhs = true;
3534  if (__use_rhs)
3535 #endif
3536  {
3537  const auto __size = __lhs.size() + __rhs.size();
3538  if (__size > __lhs.capacity() && __size <= __rhs.capacity())
3539  return std::move(__rhs.insert(0, __lhs));
3540  }
3541  return std::move(__lhs.append(__rhs));
3542  }
3543 
3544  template<typename _CharT, typename _Traits, typename _Alloc>
3545  _GLIBCXX20_CONSTEXPR
3546  inline basic_string<_CharT, _Traits, _Alloc>
3547  operator+(const _CharT* __lhs,
3548  basic_string<_CharT, _Traits, _Alloc>&& __rhs)
3549  { return std::move(__rhs.insert(0, __lhs)); }
3550 
3551  template<typename _CharT, typename _Traits, typename _Alloc>
3552  _GLIBCXX20_CONSTEXPR
3553  inline basic_string<_CharT, _Traits, _Alloc>
3554  operator+(_CharT __lhs,
3555  basic_string<_CharT, _Traits, _Alloc>&& __rhs)
3556  { return std::move(__rhs.insert(0, 1, __lhs)); }
3557 
3558  template<typename _CharT, typename _Traits, typename _Alloc>
3559  _GLIBCXX20_CONSTEXPR
3560  inline basic_string<_CharT, _Traits, _Alloc>
3561  operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
3562  const _CharT* __rhs)
3563  { return std::move(__lhs.append(__rhs)); }
3564 
3565  template<typename _CharT, typename _Traits, typename _Alloc>
3566  _GLIBCXX20_CONSTEXPR
3567  inline basic_string<_CharT, _Traits, _Alloc>
3568  operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
3569  _CharT __rhs)
3570  { return std::move(__lhs.append(1, __rhs)); }
3571 #endif
3572 
3573  // operator ==
3574  /**
3575  * @brief Test equivalence of two strings.
3576  * @param __lhs First string.
3577  * @param __rhs Second string.
3578  * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
3579  */
3580  template<typename _CharT, typename _Traits, typename _Alloc>
3581  _GLIBCXX20_CONSTEXPR
3582  inline bool
3583  operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3585  _GLIBCXX_NOEXCEPT
3586  { return __lhs.compare(__rhs) == 0; }
3587 
3588  template<typename _CharT>
3589  _GLIBCXX20_CONSTEXPR
3590  inline
3591  typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
3592  operator==(const basic_string<_CharT>& __lhs,
3593  const basic_string<_CharT>& __rhs) _GLIBCXX_NOEXCEPT
3594  { return (__lhs.size() == __rhs.size()
3595  && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
3596  __lhs.size())); }
3597 
3598  /**
3599  * @brief Test equivalence of string and C string.
3600  * @param __lhs String.
3601  * @param __rhs C string.
3602  * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
3603  */
3604  template<typename _CharT, typename _Traits, typename _Alloc>
3605  _GLIBCXX20_CONSTEXPR
3606  inline bool
3607  operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3608  const _CharT* __rhs)
3609  { return __lhs.compare(__rhs) == 0; }
3610 
3611 #if __cpp_lib_three_way_comparison
3612  /**
3613  * @brief Three-way comparison of a string and a C string.
3614  * @param __lhs A string.
3615  * @param __rhs A null-terminated string.
3616  * @return A value indicating whether `__lhs` is less than, equal to,
3617  * greater than, or incomparable with `__rhs`.
3618  */
3619  template<typename _CharT, typename _Traits, typename _Alloc>
3620  constexpr auto
3621  operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3622  const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept
3623  -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
3624  { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
3625 
3626  /**
3627  * @brief Three-way comparison of a string and a C string.
3628  * @param __lhs A string.
3629  * @param __rhs A null-terminated string.
3630  * @return A value indicating whether `__lhs` is less than, equal to,
3631  * greater than, or incomparable with `__rhs`.
3632  */
3633  template<typename _CharT, typename _Traits, typename _Alloc>
3634  constexpr auto
3635  operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3636  const _CharT* __rhs) noexcept
3637  -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
3638  { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
3639 #else
3640  /**
3641  * @brief Test equivalence of C string and string.
3642  * @param __lhs C string.
3643  * @param __rhs String.
3644  * @return True if @a __rhs.compare(@a __lhs) == 0. False otherwise.
3645  */
3646  template<typename _CharT, typename _Traits, typename _Alloc>
3647  inline bool
3648  operator==(const _CharT* __lhs,
3650  { return __rhs.compare(__lhs) == 0; }
3651 
3652  // operator !=
3653  /**
3654  * @brief Test difference of two strings.
3655  * @param __lhs First string.
3656  * @param __rhs Second string.
3657  * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise.
3658  */
3659  template<typename _CharT, typename _Traits, typename _Alloc>
3660  inline bool
3661  operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3663  _GLIBCXX_NOEXCEPT
3664  { return !(__lhs == __rhs); }
3665 
3666  /**
3667  * @brief Test difference of C string and string.
3668  * @param __lhs C string.
3669  * @param __rhs String.
3670  * @return True if @a __rhs.compare(@a __lhs) != 0. False otherwise.
3671  */
3672  template<typename _CharT, typename _Traits, typename _Alloc>
3673  inline bool
3674  operator!=(const _CharT* __lhs,
3676  { return !(__lhs == __rhs); }
3677 
3678  /**
3679  * @brief Test difference of string and C string.
3680  * @param __lhs String.
3681  * @param __rhs C string.
3682  * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise.
3683  */
3684  template<typename _CharT, typename _Traits, typename _Alloc>
3685  inline bool
3686  operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3687  const _CharT* __rhs)
3688  { return !(__lhs == __rhs); }
3689 
3690  // operator <
3691  /**
3692  * @brief Test if string precedes string.
3693  * @param __lhs First string.
3694  * @param __rhs Second string.
3695  * @return True if @a __lhs precedes @a __rhs. False otherwise.
3696  */
3697  template<typename _CharT, typename _Traits, typename _Alloc>
3698  inline bool
3699  operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3701  _GLIBCXX_NOEXCEPT
3702  { return __lhs.compare(__rhs) < 0; }
3703 
3704  /**
3705  * @brief Test if string precedes C string.
3706  * @param __lhs String.
3707  * @param __rhs C string.
3708  * @return True if @a __lhs precedes @a __rhs. False otherwise.
3709  */
3710  template<typename _CharT, typename _Traits, typename _Alloc>
3711  inline bool
3712  operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3713  const _CharT* __rhs)
3714  { return __lhs.compare(__rhs) < 0; }
3715 
3716  /**
3717  * @brief Test if C string precedes string.
3718  * @param __lhs C string.
3719  * @param __rhs String.
3720  * @return True if @a __lhs precedes @a __rhs. False otherwise.
3721  */
3722  template<typename _CharT, typename _Traits, typename _Alloc>
3723  inline bool
3724  operator<(const _CharT* __lhs,
3726  { return __rhs.compare(__lhs) > 0; }
3727 
3728  // operator >
3729  /**
3730  * @brief Test if string follows string.
3731  * @param __lhs First string.
3732  * @param __rhs Second string.
3733  * @return True if @a __lhs follows @a __rhs. False otherwise.
3734  */
3735  template<typename _CharT, typename _Traits, typename _Alloc>
3736  inline bool
3739  _GLIBCXX_NOEXCEPT
3740  { return __lhs.compare(__rhs) > 0; }
3741 
3742  /**
3743  * @brief Test if string follows C string.
3744  * @param __lhs String.
3745  * @param __rhs C string.
3746  * @return True if @a __lhs follows @a __rhs. False otherwise.
3747  */
3748  template<typename _CharT, typename _Traits, typename _Alloc>
3749  inline bool
3751  const _CharT* __rhs)
3752  { return __lhs.compare(__rhs) > 0; }
3753 
3754  /**
3755  * @brief Test if C string follows string.
3756  * @param __lhs C string.
3757  * @param __rhs String.
3758  * @return True if @a __lhs follows @a __rhs. False otherwise.
3759  */
3760  template<typename _CharT, typename _Traits, typename _Alloc>
3761  inline bool
3762  operator>(const _CharT* __lhs,
3764  { return __rhs.compare(__lhs) < 0; }
3765 
3766  // operator <=
3767  /**
3768  * @brief Test if string doesn't follow string.
3769  * @param __lhs First string.
3770  * @param __rhs Second string.
3771  * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
3772  */
3773  template<typename _CharT, typename _Traits, typename _Alloc>
3774  inline bool
3775  operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3777  _GLIBCXX_NOEXCEPT
3778  { return __lhs.compare(__rhs) <= 0; }
3779 
3780  /**
3781  * @brief Test if string doesn't follow C string.
3782  * @param __lhs String.
3783  * @param __rhs C string.
3784  * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
3785  */
3786  template<typename _CharT, typename _Traits, typename _Alloc>
3787  inline bool
3788  operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3789  const _CharT* __rhs)
3790  { return __lhs.compare(__rhs) <= 0; }
3791 
3792  /**
3793  * @brief Test if C string doesn't follow string.
3794  * @param __lhs C string.
3795  * @param __rhs String.
3796  * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
3797  */
3798  template<typename _CharT, typename _Traits, typename _Alloc>
3799  inline bool
3800  operator<=(const _CharT* __lhs,
3802  { return __rhs.compare(__lhs) >= 0; }
3803 
3804  // operator >=
3805  /**
3806  * @brief Test if string doesn't precede string.
3807  * @param __lhs First string.
3808  * @param __rhs Second string.
3809  * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
3810  */
3811  template<typename _CharT, typename _Traits, typename _Alloc>
3812  inline bool
3813  operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3815  _GLIBCXX_NOEXCEPT
3816  { return __lhs.compare(__rhs) >= 0; }
3817 
3818  /**
3819  * @brief Test if string doesn't precede C string.
3820  * @param __lhs String.
3821  * @param __rhs C string.
3822  * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
3823  */
3824  template<typename _CharT, typename _Traits, typename _Alloc>
3825  inline bool
3826  operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3827  const _CharT* __rhs)
3828  { return __lhs.compare(__rhs) >= 0; }
3829 
3830  /**
3831  * @brief Test if C string doesn't precede string.
3832  * @param __lhs C string.
3833  * @param __rhs String.
3834  * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
3835  */
3836  template<typename _CharT, typename _Traits, typename _Alloc>
3837  inline bool
3838  operator>=(const _CharT* __lhs,
3840  { return __rhs.compare(__lhs) <= 0; }
3841 #endif // three-way comparison
3842 
3843  /**
3844  * @brief Swap contents of two strings.
3845  * @param __lhs First string.
3846  * @param __rhs Second string.
3847  *
3848  * Exchanges the contents of @a __lhs and @a __rhs in constant time.
3849  */
3850  template<typename _CharT, typename _Traits, typename _Alloc>
3851  _GLIBCXX20_CONSTEXPR
3852  inline void
3855  _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
3856  { __lhs.swap(__rhs); }
3857 
3858 
3859  /**
3860  * @brief Read stream into a string.
3861  * @param __is Input stream.
3862  * @param __str Buffer to store into.
3863  * @return Reference to the input stream.
3864  *
3865  * Stores characters from @a __is into @a __str until whitespace is
3866  * found, the end of the stream is encountered, or str.max_size()
3867  * is reached. If is.width() is non-zero, that is the limit on the
3868  * number of characters stored into @a __str. Any previous
3869  * contents of @a __str are erased.
3870  */
3871  template<typename _CharT, typename _Traits, typename _Alloc>
3872  basic_istream<_CharT, _Traits>&
3873  operator>>(basic_istream<_CharT, _Traits>& __is,
3874  basic_string<_CharT, _Traits, _Alloc>& __str);
3875 
3876  template<>
3877  basic_istream<char>&
3879 
3880  /**
3881  * @brief Write string to a stream.
3882  * @param __os Output stream.
3883  * @param __str String to write out.
3884  * @return Reference to the output stream.
3885  *
3886  * Output characters of @a __str into os following the same rules as for
3887  * writing a C string.
3888  */
3889  template<typename _CharT, typename _Traits, typename _Alloc>
3893  {
3894  // _GLIBCXX_RESOLVE_LIB_DEFECTS
3895  // 586. string inserter not a formatted function
3896  return __ostream_insert(__os, __str.data(), __str.size());
3897  }
3898 
3899  /**
3900  * @brief Read a line from stream into a string.
3901  * @param __is Input stream.
3902  * @param __str Buffer to store into.
3903  * @param __delim Character marking end of line.
3904  * @return Reference to the input stream.
3905  *
3906  * Stores characters from @a __is into @a __str until @a __delim is
3907  * found, the end of the stream is encountered, or str.max_size()
3908  * is reached. Any previous contents of @a __str are erased. If
3909  * @a __delim is encountered, it is extracted but not stored into
3910  * @a __str.
3911  */
3912  template<typename _CharT, typename _Traits, typename _Alloc>
3913  basic_istream<_CharT, _Traits>&
3914  getline(basic_istream<_CharT, _Traits>& __is,
3915  basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
3916 
3917  /**
3918  * @brief Read a line from stream into a string.
3919  * @param __is Input stream.
3920  * @param __str Buffer to store into.
3921  * @return Reference to the input stream.
3922  *
3923  * Stores characters from is into @a __str until &apos;\n&apos; is
3924  * found, the end of the stream is encountered, or str.max_size()
3925  * is reached. Any previous contents of @a __str are erased. If
3926  * end of line is encountered, it is extracted but not stored into
3927  * @a __str.
3928  */
3929  template<typename _CharT, typename _Traits, typename _Alloc>
3930  inline basic_istream<_CharT, _Traits>&
3933  { return std::getline(__is, __str, __is.widen('\n')); }
3934 
3935 #if __cplusplus >= 201103L
3936  /// Read a line from an rvalue stream into a string.
3937  template<typename _CharT, typename _Traits, typename _Alloc>
3938  inline basic_istream<_CharT, _Traits>&
3940  basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
3941  { return std::getline(__is, __str, __delim); }
3942 
3943  /// Read a line from an rvalue stream into a string.
3944  template<typename _CharT, typename _Traits, typename _Alloc>
3945  inline basic_istream<_CharT, _Traits>&
3948  { return std::getline(__is, __str); }
3949 #endif
3950 
3951  template<>
3952  basic_istream<char>&
3953  getline(basic_istream<char>& __in, basic_string<char>& __str,
3954  char __delim);
3955 
3956 #ifdef _GLIBCXX_USE_WCHAR_T
3957  template<>
3958  basic_istream<wchar_t>&
3959  getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
3960  wchar_t __delim);
3961 #endif
3962 
3963 _GLIBCXX_END_NAMESPACE_VERSION
3964 } // namespace
3965 
3966 #if __cplusplus >= 201103L
3967 
3968 #include <ext/string_conversions.h>
3969 #include <bits/charconv.h>
3970 
3971 namespace std _GLIBCXX_VISIBILITY(default)
3972 {
3973 _GLIBCXX_BEGIN_NAMESPACE_VERSION
3974 _GLIBCXX_BEGIN_NAMESPACE_CXX11
3975 
3976 #if _GLIBCXX_USE_C99_STDLIB
3977  // 21.4 Numeric Conversions [string.conversions].
3978  inline int
3979  stoi(const string& __str, size_t* __idx = 0, int __base = 10)
3980  { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
3981  __idx, __base); }
3982 
3983  inline long
3984  stol(const string& __str, size_t* __idx = 0, int __base = 10)
3985  { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
3986  __idx, __base); }
3987 
3988  inline unsigned long
3989  stoul(const string& __str, size_t* __idx = 0, int __base = 10)
3990  { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
3991  __idx, __base); }
3992 
3993  inline long long
3994  stoll(const string& __str, size_t* __idx = 0, int __base = 10)
3995  { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
3996  __idx, __base); }
3997 
3998  inline unsigned long long
3999  stoull(const string& __str, size_t* __idx = 0, int __base = 10)
4000  { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
4001  __idx, __base); }
4002 
4003  // NB: strtof vs strtod.
4004  inline float
4005  stof(const string& __str, size_t* __idx = 0)
4006  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
4007 
4008  inline double
4009  stod(const string& __str, size_t* __idx = 0)
4010  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
4011 
4012  inline long double
4013  stold(const string& __str, size_t* __idx = 0)
4014  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
4015 #endif // _GLIBCXX_USE_C99_STDLIB
4016 
4017  // DR 1261. Insufficent overloads for to_string / to_wstring
4018 
4019  inline string
4020  to_string(int __val)
4021 #if _GLIBCXX_USE_CXX11_ABI && (__CHAR_BIT__ * __SIZEOF_INT__) <= 32
4022  noexcept // any 32-bit value fits in the SSO buffer
4023 #endif
4024  {
4025  const bool __neg = __val < 0;
4026  const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val;
4027  const auto __len = __detail::__to_chars_len(__uval);
4028  string __str(__neg + __len, '-');
4029  __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
4030  return __str;
4031  }
4032 
4033  inline string
4034  to_string(unsigned __val)
4035 #if _GLIBCXX_USE_CXX11_ABI && (__CHAR_BIT__ * __SIZEOF_INT__) <= 32
4036  noexcept // any 32-bit value fits in the SSO buffer
4037 #endif
4038  {
4039  string __str(__detail::__to_chars_len(__val), '\0');
4040  __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
4041  return __str;
4042  }
4043 
4044  inline string
4045  to_string(long __val)
4046 #if _GLIBCXX_USE_CXX11_ABI && (__CHAR_BIT__ * __SIZEOF_LONG__) <= 32
4047  noexcept // any 32-bit value fits in the SSO buffer
4048 #endif
4049  {
4050  const bool __neg = __val < 0;
4051  const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val;
4052  const auto __len = __detail::__to_chars_len(__uval);
4053  string __str(__neg + __len, '-');
4054  __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
4055  return __str;
4056  }
4057 
4058  inline string
4059  to_string(unsigned long __val)
4060 #if _GLIBCXX_USE_CXX11_ABI && (__CHAR_BIT__ * __SIZEOF_LONG__) <= 32
4061  noexcept // any 32-bit value fits in the SSO buffer
4062 #endif
4063  {
4064  string __str(__detail::__to_chars_len(__val), '\0');
4065  __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
4066  return __str;
4067  }
4068 
4069  inline string
4070  to_string(long long __val)
4071  {
4072  const bool __neg = __val < 0;
4073  const unsigned long long __uval
4074  = __neg ? (unsigned long long)~__val + 1ull : __val;
4075  const auto __len = __detail::__to_chars_len(__uval);
4076  string __str(__neg + __len, '-');
4077  __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
4078  return __str;
4079  }
4080 
4081  inline string
4082  to_string(unsigned long long __val)
4083  {
4084  string __str(__detail::__to_chars_len(__val), '\0');
4085  __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
4086  return __str;
4087  }
4088 
4089 #if _GLIBCXX_USE_C99_STDIO
4090  // NB: (v)snprintf vs sprintf.
4091 
4092  inline string
4093  to_string(float __val)
4094  {
4095  const int __n =
4096  __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
4097  return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
4098  "%f", __val);
4099  }
4100 
4101  inline string
4102  to_string(double __val)
4103  {
4104  const int __n =
4105  __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
4106  return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
4107  "%f", __val);
4108  }
4109 
4110  inline string
4111  to_string(long double __val)
4112  {
4113  const int __n =
4114  __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
4115  return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
4116  "%Lf", __val);
4117  }
4118 #endif // _GLIBCXX_USE_C99_STDIO
4119 
4120 #if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_WCHAR
4121  inline int
4122  stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
4123  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
4124  __idx, __base); }
4125 
4126  inline long
4127  stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
4128  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
4129  __idx, __base); }
4130 
4131  inline unsigned long
4132  stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
4133  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
4134  __idx, __base); }
4135 
4136  inline long long
4137  stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
4138  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
4139  __idx, __base); }
4140 
4141  inline unsigned long long
4142  stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
4143  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
4144  __idx, __base); }
4145 
4146  // NB: wcstof vs wcstod.
4147  inline float
4148  stof(const wstring& __str, size_t* __idx = 0)
4149  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
4150 
4151  inline double
4152  stod(const wstring& __str, size_t* __idx = 0)
4153  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
4154 
4155  inline long double
4156  stold(const wstring& __str, size_t* __idx = 0)
4157  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
4158 
4159 #ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF
4160  // DR 1261.
4161  inline wstring
4162  to_wstring(int __val)
4163  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
4164  L"%d", __val); }
4165 
4166  inline wstring
4167  to_wstring(unsigned __val)
4168  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4169  4 * sizeof(unsigned),
4170  L"%u", __val); }
4171 
4172  inline wstring
4173  to_wstring(long __val)
4174  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
4175  L"%ld", __val); }
4176 
4177  inline wstring
4178  to_wstring(unsigned long __val)
4179  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4180  4 * sizeof(unsigned long),
4181  L"%lu", __val); }
4182 
4183  inline wstring
4184  to_wstring(long long __val)
4185  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4186  4 * sizeof(long long),
4187  L"%lld", __val); }
4188 
4189  inline wstring
4190  to_wstring(unsigned long long __val)
4191  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4192  4 * sizeof(unsigned long long),
4193  L"%llu", __val); }
4194 
4195  inline wstring
4196  to_wstring(float __val)
4197  {
4198  const int __n =
4199  __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
4200  return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
4201  L"%f", __val);
4202  }
4203 
4204  inline wstring
4205  to_wstring(double __val)
4206  {
4207  const int __n =
4208  __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
4209  return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
4210  L"%f", __val);
4211  }
4212 
4213  inline wstring
4214  to_wstring(long double __val)
4215  {
4216  const int __n =
4217  __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
4218  return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
4219  L"%Lf", __val);
4220  }
4221 #endif // _GLIBCXX_HAVE_BROKEN_VSWPRINTF
4222 #endif // _GLIBCXX_USE_WCHAR_T && _GLIBCXX_USE_C99_WCHAR
4223 
4224 _GLIBCXX_END_NAMESPACE_CXX11
4225 _GLIBCXX_END_NAMESPACE_VERSION
4226 } // namespace
4227 
4228 #endif /* C++11 */
4229 
4230 #if __cplusplus >= 201103L
4231 
4232 #include <bits/functional_hash.h>
4233 
4234 namespace std _GLIBCXX_VISIBILITY(default)
4235 {
4236 _GLIBCXX_BEGIN_NAMESPACE_VERSION
4237 
4238  // DR 1182.
4239 
4240 #ifndef _GLIBCXX_COMPATIBILITY_CXX0X
4241  /// std::hash specialization for string.
4242  template<>
4243  struct hash<string>
4244  : public __hash_base<size_t, string>
4245  {
4246  size_t
4247  operator()(const string& __s) const noexcept
4248  { return std::_Hash_impl::hash(__s.data(), __s.length()); }
4249  };
4250 
4251  template<>
4252  struct __is_fast_hash<hash<string>> : std::false_type
4253  { };
4254 
4255  /// std::hash specialization for wstring.
4256  template<>
4257  struct hash<wstring>
4258  : public __hash_base<size_t, wstring>
4259  {
4260  size_t
4261  operator()(const wstring& __s) const noexcept
4262  { return std::_Hash_impl::hash(__s.data(),
4263  __s.length() * sizeof(wchar_t)); }
4264  };
4265 
4266  template<>
4267  struct __is_fast_hash<hash<wstring>> : std::false_type
4268  { };
4269 #endif /* _GLIBCXX_COMPATIBILITY_CXX0X */
4270 
4271 #ifdef _GLIBCXX_USE_CHAR8_T
4272  /// std::hash specialization for u8string.
4273  template<>
4274  struct hash<u8string>
4275  : public __hash_base<size_t, u8string>
4276  {
4277  size_t
4278  operator()(const u8string& __s) const noexcept
4279  { return std::_Hash_impl::hash(__s.data(),
4280  __s.length() * sizeof(char8_t)); }
4281  };
4282 
4283  template<>
4284  struct __is_fast_hash<hash<u8string>> : std::false_type
4285  { };
4286 #endif
4287 
4288  /// std::hash specialization for u16string.
4289  template<>
4290  struct hash<u16string>
4291  : public __hash_base<size_t, u16string>
4292  {
4293  size_t
4294  operator()(const u16string& __s) const noexcept
4295  { return std::_Hash_impl::hash(__s.data(),
4296  __s.length() * sizeof(char16_t)); }
4297  };
4298 
4299  template<>
4300  struct __is_fast_hash<hash<u16string>> : std::false_type
4301  { };
4302 
4303  /// std::hash specialization for u32string.
4304  template<>
4305  struct hash<u32string>
4306  : public __hash_base<size_t, u32string>
4307  {
4308  size_t
4309  operator()(const u32string& __s) const noexcept
4310  { return std::_Hash_impl::hash(__s.data(),
4311  __s.length() * sizeof(char32_t)); }
4312  };
4313 
4314  template<>
4315  struct __is_fast_hash<hash<u32string>> : std::false_type
4316  { };
4317 
4318 #if __cplusplus >= 201402L
4319 
4320 #define __cpp_lib_string_udls 201304L
4321 
4322  inline namespace literals
4323  {
4324  inline namespace string_literals
4325  {
4326 #pragma GCC diagnostic push
4327 #pragma GCC diagnostic ignored "-Wliteral-suffix"
4328 
4329 #if __cpp_lib_constexpr_string >= 201907L
4330 # define _GLIBCXX_STRING_CONSTEXPR constexpr
4331 #else
4332 # define _GLIBCXX_STRING_CONSTEXPR
4333 #endif
4334 
4335  _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4336  inline basic_string<char>
4337  operator""s(const char* __str, size_t __len)
4338  { return basic_string<char>{__str, __len}; }
4339 
4340  _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4341  inline basic_string<wchar_t>
4342  operator""s(const wchar_t* __str, size_t __len)
4343  { return basic_string<wchar_t>{__str, __len}; }
4344 
4345 #ifdef _GLIBCXX_USE_CHAR8_T
4346  _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4347  inline basic_string<char8_t>
4348  operator""s(const char8_t* __str, size_t __len)
4349  { return basic_string<char8_t>{__str, __len}; }
4350 #endif
4351 
4352  _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4353  inline basic_string<char16_t>
4354  operator""s(const char16_t* __str, size_t __len)
4355  { return basic_string<char16_t>{__str, __len}; }
4356 
4357  _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4358  inline basic_string<char32_t>
4359  operator""s(const char32_t* __str, size_t __len)
4360  { return basic_string<char32_t>{__str, __len}; }
4361 
4362 #undef _GLIBCXX_STRING_CONSTEXPR
4363 #pragma GCC diagnostic pop
4364  } // inline namespace string_literals
4365  } // inline namespace literals
4366 
4367 #if __cplusplus >= 201703L
4368  namespace __detail::__variant
4369  {
4370  template<typename> struct _Never_valueless_alt; // see <variant>
4371 
4372  // Provide the strong exception-safety guarantee when emplacing a
4373  // basic_string into a variant, but only if moving the string cannot throw.
4374  template<typename _Tp, typename _Traits, typename _Alloc>
4375  struct _Never_valueless_alt<std::basic_string<_Tp, _Traits, _Alloc>>
4376  : __and_<
4377  is_nothrow_move_constructible<std::basic_string<_Tp, _Traits, _Alloc>>,
4378  is_nothrow_move_assignable<std::basic_string<_Tp, _Traits, _Alloc>>
4379  >::type
4380  { };
4381  } // namespace __detail::__variant
4382 #endif // C++17
4383 #endif // C++14
4384 
4385 _GLIBCXX_END_NAMESPACE_VERSION
4386 } // namespace std
4387 
4388 #endif // C++11
4389 
4390 #endif /* _BASIC_STRING_H */
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
Definition: complex:332
constexpr bool is_constant_evaluated() noexcept
Returns true only when called during constant evaluation.
Definition: type_traits:3520
typename enable_if< _Cond, _Tp >::type enable_if_t
Alias template for enable_if.
Definition: type_traits:2608
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition: move.h:49
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:104
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
Definition: any:429
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:230
constexpr iterator_traits< _Iter >::iterator_category __iterator_category(const _Iter &)
basic_string< wchar_t > wstring
A string of wchar_t.
Definition: stringfwd.h:80
ISO C++ entities toplevel namespace is std.
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition: bitset:1475
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition: bitset:1543
basic_istream< _CharT, _Traits > & getline(basic_istream< _CharT, _Traits > &__is, basic_string< _CharT, _Traits, _Alloc > &__str, _CharT __delim)
Read a line from stream into a string.
constexpr _Iterator __base(_Iterator __it)
char_type widen(char __c) const
Widens characters.
Definition: basic_ios.h:449
Template class basic_ostream.
Definition: ostream:59
Primary class template hash.
integral_constant
Definition: type_traits:63
Basis for explicit traits specializations.
Definition: char_traits.h:334
Managing sequences of characters and character-like objects.
Definition: cow_string.h:115
const_reverse_iterator crbegin() const noexcept
Definition: cow_string.h:895
void swap(basic_string &__s) noexcept(/*conditional */)
Swap contents with another string.
Definition: cow_string.h:3448
void push_back(_CharT __c)
Append a single character.
Definition: cow_string.h:1331
const_iterator cend() const noexcept
Definition: cow_string.h:886
size_type find_first_of(const basic_string &__str, size_type __pos=0) const noexcept
Find position of a character of string.
Definition: cow_string.h:2411
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
Definition: cow_string.h:2206
basic_string substr(size_type __pos=0, size_type __n=npos) const
Get a substring.
Definition: cow_string.h:2743
size_type find(const _CharT *__s, size_type __pos, size_type __n) const noexcept
Find position of a C substring.
size_type find_last_not_of(const basic_string &__str, size_type __pos=npos) const noexcept
Find last position of a character not in string.
Definition: cow_string.h:2660
int compare(const basic_string &__str) const
Compare to a string.
Definition: cow_string.h:2762
reverse_iterator rend()
Definition: cow_string.h:860
size_type find_first_not_of(const basic_string &__str, size_type __pos=0) const noexcept
Find position of a character not in string.
Definition: cow_string.h:2578
void insert(iterator __p, size_type __n, _CharT __c)
Insert multiple characters.
Definition: cow_string.h:1497
basic_string & operator+=(const basic_string &__str)
Append a string to this string.
Definition: cow_string.h:1166
basic_string & assign(const basic_string &__str)
Set value to contents of another string.
Definition: cow_string.h:3160
reverse_iterator rbegin()
Definition: cow_string.h:842
basic_string & replace(size_type __pos, size_type __n, const basic_string &__str)
Replace characters with value from another string.
Definition: cow_string.h:1779
reference front()
Definition: cow_string.h:1119
void pop_back()
Remove the last character.
Definition: cow_string.h:1754
size_type copy(_CharT *__s, size_type __n, size_type __pos=0) const
Copy substring into C string.
Definition: cow_string.h:3644
size_type length() const noexcept
Returns the number of characters in the string, not including any null-termination.
Definition: cow_string.h:919
size_type find_last_of(const basic_string &__str, size_type __pos=npos) const noexcept
Find last position of a character of string.
Definition: cow_string.h:2495
size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
Definition: cow_string.h:913
size_type rfind(const basic_string &__str, size_type __pos=npos) const noexcept
Find last position of a string.
Definition: cow_string.h:2332
void shrink_to_fit() noexcept
A non-binding request to reduce capacity() to size().
Definition: cow_string.h:959
void resize(size_type __n, _CharT __c)
Resizes the string to the specified number of characters.
Definition: cow_string.h:3570
void reserve()
Equivalent to shrink_to_fit().
Definition: cow_string.h:3623
const _CharT * data() const noexcept
Return const pointer to contents.
Definition: cow_string.h:2218
const_reference at(size_type __n) const
Provides access to the data contained in the string.
Definition: cow_string.h:1080
iterator begin()
Definition: cow_string.h:803
basic_string & append(const basic_string &__str)
Append a string to this string.
Definition: cow_string.h:3242
const_reverse_iterator crend() const noexcept
Definition: cow_string.h:904
iterator end()
Definition: cow_string.h:822
basic_string & operator=(const basic_string &__str)
Assign the value of str to this string.
Definition: cow_string.h:725
const_reference operator[](size_type __pos) const noexcept
Subscript access to the data contained in the string.
Definition: cow_string.h:1041
void clear() noexcept
Definition: cow_string.h:1004
bool empty() const noexcept
Definition: cow_string.h:1026
reference back()
Definition: cow_string.h:1141
static const size_type npos
Value returned by various member functions when they fail.
Definition: cow_string.h:328
allocator_type get_allocator() const noexcept
Return copy of allocator used to construct this string.
Definition: cow_string.h:2240
const_iterator cbegin() const noexcept
Definition: cow_string.h:878
basic_string & erase(size_type __pos=0, size_type __n=npos)
Remove characters.
Definition: cow_string.h:1709
~basic_string() noexcept
Destroy the string instance.
Definition: cow_string.h:717
size_type capacity() const noexcept
Definition: cow_string.h:969
basic_string() noexcept
Default constructor creates an empty string.
Definition: cow_string.h:521
size_type max_size() const noexcept
Returns the size() of the largest possible string.
Definition: cow_string.h:924
Uniform interface to all pointer-like types.
Definition: ptr_traits.h:195
Marking input iterators.
Forward iterators support a superset of input iterator operations.
Uniform interface to C++98 and C++11 allocators.