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