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