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