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
51namespace 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 {
83 typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
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
207 return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
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,
277 std::input_iterator_tag);
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,
284 std::forward_iterator_tag);
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 <nc[email protected].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>
3144 class basic_string
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;
3167 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
3168 typedef std::reverse_iterator<iterator> reverse_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 */
3548 basic_string()
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 **/
3632 basic_string(basic_string&& __str)
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&
3751 operator=(basic_string&& __str)
3752 _GLIBCXX_NOEXCEPT_IF(allocator_traits<_Alloc>::is_always_equal::value)
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&
3764 operator=(initializer_list<_CharT> __l)
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
4111 front()
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
4133 back()
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&
4189 operator+=(initializer_list<_CharT> __l)
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&
4268 append(initializer_list<_CharT> __l)
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&
4350 assign(basic_string&& __str)
4351 noexcept(allocator_traits<_Alloc>::is_always_equal::value)
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&
4439 assign(initializer_list<_CharT> __l)
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
4517 insert(iterator __p, initializer_list<_CharT> __l)
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,
5035 initializer_list<_CharT> __l)
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
5384 noexcept(is_same<_Tp, __sv_type>::value)
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
5552 noexcept(is_same<_Tp, __sv_type>::value)
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
5715 noexcept(is_same<_Tp, __sv_type>::value)
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
5775 noexcept(is_same<_Tp, __sv_type>::value)
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>
6023 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6024 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6025 {
6026 basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
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>
6060 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6061 const _CharT* __rhs)
6062 {
6063 basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
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>
6076 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
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,
6145 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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,
6167 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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,
6192 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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,
6205 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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,
6230 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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,
6255 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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
6267 operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6268 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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
6280 operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
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,
6293 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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,
6306 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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,
6331 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
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,
6344 const basic_string<_CharT, _Traits, _Alloc>&