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