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