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