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