39 #ifndef _BASIC_STRING_TCC 40 #define _BASIC_STRING_TCC 1 42 #pragma GCC system_header 46 namespace std _GLIBCXX_VISIBILITY(default)
48 _GLIBCXX_BEGIN_NAMESPACE_VERSION
50 #if _GLIBCXX_USE_CXX11_ABI 52 template<
typename _CharT,
typename _Traits,
typename _Alloc>
53 const typename basic_string<_CharT, _Traits, _Alloc>::size_type
56 template<
typename _CharT,
typename _Traits,
typename _Alloc>
59 swap(basic_string& __s) _GLIBCXX_NOEXCEPT
64 _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());
67 if (__s._M_is_local())
69 if (length() && __s.length())
71 _CharT __tmp_data[_S_local_capacity + 1];
72 traits_type::copy(__tmp_data, __s._M_local_buf,
73 _S_local_capacity + 1);
74 traits_type::copy(__s._M_local_buf, _M_local_buf,
75 _S_local_capacity + 1);
76 traits_type::copy(_M_local_buf, __tmp_data,
77 _S_local_capacity + 1);
79 else if (__s.length())
81 traits_type::copy(_M_local_buf, __s._M_local_buf,
82 _S_local_capacity + 1);
83 _M_length(__s.length());
89 traits_type::copy(__s._M_local_buf, _M_local_buf,
90 _S_local_capacity + 1);
91 __s._M_length(length());
98 const size_type __tmp_capacity = __s._M_allocated_capacity;
99 traits_type::copy(__s._M_local_buf, _M_local_buf,
100 _S_local_capacity + 1);
101 _M_data(__s._M_data());
102 __s._M_data(__s._M_local_buf);
103 _M_capacity(__tmp_capacity);
107 const size_type __tmp_capacity = _M_allocated_capacity;
108 if (__s._M_is_local())
110 traits_type::copy(_M_local_buf, __s._M_local_buf,
111 _S_local_capacity + 1);
112 __s._M_data(_M_data());
113 _M_data(_M_local_buf);
117 pointer __tmp_ptr = _M_data();
118 _M_data(__s._M_data());
119 __s._M_data(__tmp_ptr);
120 _M_capacity(__s._M_allocated_capacity);
122 __s._M_capacity(__tmp_capacity);
125 const size_type __tmp_length = length();
126 _M_length(__s.length());
127 __s._M_length(__tmp_length);
130 template<
typename _CharT,
typename _Traits,
typename _Alloc>
131 typename basic_string<_CharT, _Traits, _Alloc>::pointer
132 basic_string<_CharT, _Traits, _Alloc>::
133 _M_create(size_type& __capacity, size_type __old_capacity)
137 if (__capacity > max_size())
138 std::__throw_length_error(__N(
"basic_string::_M_create"));
143 if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
145 __capacity = 2 * __old_capacity;
147 if (__capacity > max_size())
148 __capacity = max_size();
153 return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
160 template<
typename _CharT,
typename _Traits,
typename _Alloc>
161 template<
typename _InIterator>
163 basic_string<_CharT, _Traits, _Alloc>::
164 _M_construct(_InIterator __beg, _InIterator __end,
168 size_type __capacity = size_type(_S_local_capacity);
170 while (__beg != __end && __len < __capacity)
172 _M_data()[__len++] = *__beg;
178 while (__beg != __end)
180 if (__len == __capacity)
183 __capacity = __len + 1;
184 pointer __another = _M_create(__capacity, __len);
185 this->_S_copy(__another, _M_data(), __len);
188 _M_capacity(__capacity);
190 _M_data()[__len++] = *__beg;
197 __throw_exception_again;
200 _M_set_length(__len);
203 template<
typename _CharT,
typename _Traits,
typename _Alloc>
204 template<
typename _InIterator>
206 basic_string<_CharT, _Traits, _Alloc>::
207 _M_construct(_InIterator __beg, _InIterator __end,
211 if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
212 std::__throw_logic_error(__N(
"basic_string::" 213 "_M_construct null not valid"));
215 size_type __dnew =
static_cast<size_type
>(
std::distance(__beg, __end));
217 if (__dnew > size_type(_S_local_capacity))
219 _M_data(_M_create(__dnew, size_type(0)));
225 { this->_S_copy_chars(_M_data(), __beg, __end); }
229 __throw_exception_again;
232 _M_set_length(__dnew);
235 template<
typename _CharT,
typename _Traits,
typename _Alloc>
237 basic_string<_CharT, _Traits, _Alloc>::
238 _M_construct(size_type __n, _CharT __c)
240 if (__n > size_type(_S_local_capacity))
242 _M_data(_M_create(__n, size_type(0)));
247 this->_S_assign(_M_data(), __n, __c);
252 template<
typename _CharT,
typename _Traits,
typename _Alloc>
254 basic_string<_CharT, _Traits, _Alloc>::
255 _M_assign(
const basic_string& __str)
259 const size_type __rsize = __str.length();
260 const size_type __capacity = capacity();
262 if (__rsize > __capacity)
264 size_type __new_capacity = __rsize;
265 pointer __tmp = _M_create(__new_capacity, __capacity);
268 _M_capacity(__new_capacity);
272 this->_S_copy(_M_data(), __str._M_data(), __rsize);
274 _M_set_length(__rsize);
278 template<
typename _CharT,
typename _Traits,
typename _Alloc>
284 if (__res < length())
287 const size_type __capacity = capacity();
288 if (__res != __capacity)
290 if (__res > __capacity
291 || __res > size_type(_S_local_capacity))
293 pointer __tmp = _M_create(__res, __capacity);
294 this->_S_copy(__tmp, _M_data(), length() + 1);
299 else if (!_M_is_local())
301 this->_S_copy(_M_local_data(), _M_data(), length() + 1);
302 _M_destroy(__capacity);
303 _M_data(_M_local_data());
308 template<
typename _CharT,
typename _Traits,
typename _Alloc>
310 basic_string<_CharT, _Traits, _Alloc>::
311 _M_mutate(size_type __pos, size_type __len1,
const _CharT* __s,
314 const size_type __how_much = length() - __pos - __len1;
316 size_type __new_capacity = length() + __len2 - __len1;
317 pointer __r = _M_create(__new_capacity, capacity());
320 this->_S_copy(__r, _M_data(), __pos);
322 this->_S_copy(__r + __pos, __s, __len2);
324 this->_S_copy(__r + __pos + __len2,
325 _M_data() + __pos + __len1, __how_much);
329 _M_capacity(__new_capacity);
332 template<
typename _CharT,
typename _Traits,
typename _Alloc>
334 basic_string<_CharT, _Traits, _Alloc>::
335 _M_erase(size_type __pos, size_type __n)
337 const size_type __how_much = length() - __pos - __n;
339 if (__how_much && __n)
340 this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
342 _M_set_length(length() - __n);
345 template<
typename _CharT,
typename _Traits,
typename _Alloc>
348 resize(size_type __n, _CharT __c)
350 const size_type __size = this->size();
352 this->append(__n - __size, __c);
353 else if (__n < __size)
354 this->_M_erase(__n, __size - __n);
357 template<
typename _CharT,
typename _Traits,
typename _Alloc>
358 basic_string<_CharT, _Traits, _Alloc>&
359 basic_string<_CharT, _Traits, _Alloc>::
360 _M_append(
const _CharT* __s, size_type __n)
362 const size_type __len = __n + this->size();
364 if (__len <= this->capacity())
367 this->_S_copy(this->_M_data() + this->size(), __s, __n);
370 this->_M_mutate(this->size(), size_type(0), __s, __n);
372 this->_M_set_length(__len);
376 template<
typename _CharT,
typename _Traits,
typename _Alloc>
377 template<
typename _InputIterator>
378 basic_string<_CharT, _Traits, _Alloc>&
379 basic_string<_CharT, _Traits, _Alloc>::
380 _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
381 _InputIterator __k1, _InputIterator __k2,
384 const basic_string __s(__k1, __k2);
385 const size_type __n1 = __i2 - __i1;
386 return _M_replace(__i1 -
begin(), __n1, __s._M_data(),
390 template<
typename _CharT,
typename _Traits,
typename _Alloc>
391 basic_string<_CharT, _Traits, _Alloc>&
392 basic_string<_CharT, _Traits, _Alloc>::
393 _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
396 _M_check_length(__n1, __n2,
"basic_string::_M_replace_aux");
398 const size_type __old_size = this->size();
399 const size_type __new_size = __old_size + __n2 - __n1;
401 if (__new_size <= this->capacity())
403 pointer __p = this->_M_data() + __pos1;
405 const size_type __how_much = __old_size - __pos1 - __n1;
406 if (__how_much && __n1 != __n2)
407 this->_S_move(__p + __n2, __p + __n1, __how_much);
410 this->_M_mutate(__pos1, __n1, 0, __n2);
413 this->_S_assign(this->_M_data() + __pos1, __n2, __c);
415 this->_M_set_length(__new_size);
419 template<
typename _CharT,
typename _Traits,
typename _Alloc>
420 basic_string<_CharT, _Traits, _Alloc>&
421 basic_string<_CharT, _Traits, _Alloc>::
422 _M_replace(size_type __pos, size_type __len1,
const _CharT* __s,
423 const size_type __len2)
425 _M_check_length(__len1, __len2,
"basic_string::_M_replace");
427 const size_type __old_size = this->size();
428 const size_type __new_size = __old_size + __len2 - __len1;
430 if (__new_size <= this->capacity())
432 pointer __p = this->_M_data() + __pos;
434 const size_type __how_much = __old_size - __pos - __len1;
435 if (_M_disjunct(__s))
437 if (__how_much && __len1 != __len2)
438 this->_S_move(__p + __len2, __p + __len1, __how_much);
440 this->_S_copy(__p, __s, __len2);
445 if (__len2 && __len2 <= __len1)
446 this->_S_move(__p, __s, __len2);
447 if (__how_much && __len1 != __len2)
448 this->_S_move(__p + __len2, __p + __len1, __how_much);
451 if (__s + __len2 <= __p + __len1)
452 this->_S_move(__p, __s, __len2);
453 else if (__s >= __p + __len1)
454 this->_S_copy(__p, __s + __len2 - __len1, __len2);
457 const size_type __nleft = (__p + __len1) - __s;
458 this->_S_move(__p, __s, __nleft);
459 this->_S_copy(__p + __nleft, __p + __len2,
466 this->_M_mutate(__pos, __len1, __s, __len2);
468 this->_M_set_length(__new_size);
472 template<
typename _CharT,
typename _Traits,
typename _Alloc>
473 typename basic_string<_CharT, _Traits, _Alloc>::size_type
475 copy(_CharT* __s, size_type __n, size_type __pos)
const 477 _M_check(__pos,
"basic_string::copy");
478 __n = _M_limit(__pos, __n);
479 __glibcxx_requires_string_len(__s, __n);
481 _S_copy(__s, _M_data() + __pos, __n);
486 #else // !_GLIBCXX_USE_CXX11_ABI 488 template<
typename _CharT,
typename _Traits,
typename _Alloc>
489 const typename basic_string<_CharT, _Traits, _Alloc>::size_type
490 basic_string<_CharT, _Traits, _Alloc>::
491 _Rep::_S_max_size = (((npos -
sizeof(_Rep_base))/
sizeof(_CharT)) - 1) / 4;
493 template<
typename _CharT,
typename _Traits,
typename _Alloc>
495 basic_string<_CharT, _Traits, _Alloc>::
496 _Rep::_S_terminal = _CharT();
498 template<
typename _CharT,
typename _Traits,
typename _Alloc>
499 const typename basic_string<_CharT, _Traits, _Alloc>::size_type
500 basic_string<_CharT, _Traits, _Alloc>::npos;
504 template<
typename _CharT,
typename _Traits,
typename _Alloc>
505 typename basic_string<_CharT, _Traits, _Alloc>::size_type
506 basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
507 (
sizeof(_Rep_base) +
sizeof(_CharT) +
sizeof(size_type) - 1) /
514 template<
typename _CharT,
typename _Traits,
typename _Alloc>
515 template<
typename _InIterator>
517 basic_string<_CharT, _Traits, _Alloc>::
518 _S_construct(_InIterator __beg, _InIterator __end,
const _Alloc& __a,
521 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 522 if (__beg == __end && __a == _Alloc())
523 return _S_empty_rep()._M_refdata();
528 while (__beg != __end && __len <
sizeof(__buf) /
sizeof(_CharT))
530 __buf[__len++] = *__beg;
533 _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
534 _M_copy(__r->_M_refdata(), __buf, __len);
537 while (__beg != __end)
539 if (__len == __r->_M_capacity)
542 _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
543 _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
544 __r->_M_destroy(__a);
547 __r->_M_refdata()[__len++] = *__beg;
553 __r->_M_destroy(__a);
554 __throw_exception_again;
556 __r->_M_set_length_and_sharable(__len);
557 return __r->_M_refdata();
560 template<
typename _CharT,
typename _Traits,
typename _Alloc>
561 template <
typename _InIterator>
563 basic_string<_CharT, _Traits, _Alloc>::
564 _S_construct(_InIterator __beg, _InIterator __end,
const _Alloc& __a,
565 forward_iterator_tag)
567 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 568 if (__beg == __end && __a == _Alloc())
569 return _S_empty_rep()._M_refdata();
572 if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
573 __throw_logic_error(__N(
"basic_string::_S_construct null not valid"));
575 const size_type __dnew =
static_cast<size_type
>(
std::distance(__beg,
578 _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
580 { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
583 __r->_M_destroy(__a);
584 __throw_exception_again;
586 __r->_M_set_length_and_sharable(__dnew);
587 return __r->_M_refdata();
590 template<
typename _CharT,
typename _Traits,
typename _Alloc>
592 basic_string<_CharT, _Traits, _Alloc>::
593 _S_construct(size_type __n, _CharT __c,
const _Alloc& __a)
595 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 596 if (__n == 0 && __a == _Alloc())
597 return _S_empty_rep()._M_refdata();
600 _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
602 _M_assign(__r->_M_refdata(), __n, __c);
604 __r->_M_set_length_and_sharable(__n);
605 return __r->_M_refdata();
608 template<
typename _CharT,
typename _Traits,
typename _Alloc>
611 : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
612 __str.get_allocator()),
613 __str.get_allocator())
616 template<
typename _CharT,
typename _Traits,
typename _Alloc>
619 : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
622 template<
typename _CharT,
typename _Traits,
typename _Alloc>
625 : _M_dataplus(_S_construct(__str._M_data()
626 + __str._M_check(__pos,
627 "basic_string::basic_string"),
628 __str._M_data() + __str._M_limit(__pos, __n)
629 + __pos, _Alloc()), _Alloc())
632 template<
typename _CharT,
typename _Traits,
typename _Alloc>
635 size_type __n,
const _Alloc& __a)
636 : _M_dataplus(_S_construct(__str._M_data()
637 + __str._M_check(__pos,
638 "basic_string::basic_string"),
639 __str._M_data() + __str._M_limit(__pos, __n)
644 template<
typename _CharT,
typename _Traits,
typename _Alloc>
647 : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
651 template<
typename _CharT,
typename _Traits,
typename _Alloc>
654 : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
655 __s + npos, __a), __a)
658 template<
typename _CharT,
typename _Traits,
typename _Alloc>
661 : _M_dataplus(_S_construct(__n, __c, __a), __a)
665 template<
typename _CharT,
typename _Traits,
typename _Alloc>
666 template<
typename _InputIterator>
668 basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a)
669 : _M_dataplus(_S_construct(__beg, __end, __a), __a)
672 #if __cplusplus >= 201103L 673 template<
typename _CharT,
typename _Traits,
typename _Alloc>
676 : _M_dataplus(_S_construct(__l.
begin(), __l.
end(), __a), __a)
680 template<
typename _CharT,
typename _Traits,
typename _Alloc>
685 if (_M_rep() != __str._M_rep())
688 const allocator_type __a = this->get_allocator();
689 _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.
get_allocator());
690 _M_rep()->_M_dispose(__a);
696 template<
typename _CharT,
typename _Traits,
typename _Alloc>
701 __glibcxx_requires_string_len(__s, __n);
702 _M_check_length(this->size(), __n,
"basic_string::assign");
703 if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
704 return _M_replace_safe(size_type(0), this->size(), __s, __n);
708 const size_type __pos = __s - _M_data();
710 _M_copy(_M_data(), __s, __n);
712 _M_move(_M_data(), __s, __n);
713 _M_rep()->_M_set_length_and_sharable(__n);
718 template<
typename _CharT,
typename _Traits,
typename _Alloc>
725 _M_check_length(size_type(0), __n,
"basic_string::append");
726 const size_type __len = __n + this->size();
727 if (__len > this->capacity() || _M_rep()->_M_is_shared())
728 this->reserve(__len);
729 _M_assign(_M_data() + this->size(), __n, __c);
730 _M_rep()->_M_set_length_and_sharable(__len);
735 template<
typename _CharT,
typename _Traits,
typename _Alloc>
740 __glibcxx_requires_string_len(__s, __n);
743 _M_check_length(size_type(0), __n,
"basic_string::append");
744 const size_type __len = __n + this->size();
745 if (__len > this->capacity() || _M_rep()->_M_is_shared())
747 if (_M_disjunct(__s))
748 this->reserve(__len);
751 const size_type __off = __s - _M_data();
752 this->reserve(__len);
753 __s = _M_data() + __off;
756 _M_copy(_M_data() + this->size(), __s, __n);
757 _M_rep()->_M_set_length_and_sharable(__len);
762 template<
typename _CharT,
typename _Traits,
typename _Alloc>
767 const size_type __size = __str.
size();
770 const size_type __len = __size + this->size();
771 if (__len > this->capacity() || _M_rep()->_M_is_shared())
772 this->reserve(__len);
773 _M_copy(_M_data() + this->size(), __str._M_data(), __size);
774 _M_rep()->_M_set_length_and_sharable(__len);
779 template<
typename _CharT,
typename _Traits,
typename _Alloc>
784 __str._M_check(__pos,
"basic_string::append");
785 __n = __str._M_limit(__pos, __n);
788 const size_type __len = __n + this->size();
789 if (__len > this->capacity() || _M_rep()->_M_is_shared())
790 this->reserve(__len);
791 _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
792 _M_rep()->_M_set_length_and_sharable(__len);
797 template<
typename _CharT,
typename _Traits,
typename _Alloc>
800 insert(size_type __pos,
const _CharT* __s, size_type __n)
802 __glibcxx_requires_string_len(__s, __n);
803 _M_check(__pos,
"basic_string::insert");
804 _M_check_length(size_type(0), __n,
"basic_string::insert");
805 if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
806 return _M_replace_safe(__pos, size_type(0), __s, __n);
810 const size_type __off = __s - _M_data();
811 _M_mutate(__pos, 0, __n);
812 __s = _M_data() + __off;
813 _CharT* __p = _M_data() + __pos;
814 if (__s + __n <= __p)
815 _M_copy(__p, __s, __n);
817 _M_copy(__p, __s + __n, __n);
820 const size_type __nleft = __p - __s;
821 _M_copy(__p, __s, __nleft);
822 _M_copy(__p + __nleft, __p + __n, __n - __nleft);
828 template<
typename _CharT,
typename _Traits,
typename _Alloc>
829 typename basic_string<_CharT, _Traits, _Alloc>::iterator
831 erase(iterator __first, iterator __last)
833 _GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last
834 && __last <= _M_iend());
839 const size_type __size = __last - __first;
842 const size_type __pos = __first - _M_ibegin();
843 _M_mutate(__pos, __size, size_type(0));
844 _M_rep()->_M_set_leaked();
845 return iterator(_M_data() + __pos);
851 template<
typename _CharT,
typename _Traits,
typename _Alloc>
854 replace(size_type __pos, size_type __n1,
const _CharT* __s,
857 __glibcxx_requires_string_len(__s, __n2);
858 _M_check(__pos,
"basic_string::replace");
859 __n1 = _M_limit(__pos, __n1);
860 _M_check_length(__n1, __n2,
"basic_string::replace");
862 if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
863 return _M_replace_safe(__pos, __n1, __s, __n2);
864 else if ((__left = __s + __n2 <= _M_data() + __pos)
865 || _M_data() + __pos + __n1 <= __s)
868 size_type __off = __s - _M_data();
869 __left ? __off : (__off += __n2 - __n1);
870 _M_mutate(__pos, __n1, __n2);
871 _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
878 return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
882 template<
typename _CharT,
typename _Traits,
typename _Alloc>
887 const size_type __size =
sizeof(_Rep_base) +
888 (this->_M_capacity + 1) *
sizeof(_CharT);
889 _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(
this), __size);
892 template<
typename _CharT,
typename _Traits,
typename _Alloc>
897 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 898 if (_M_rep() == &_S_empty_rep())
901 if (_M_rep()->_M_is_shared())
903 _M_rep()->_M_set_leaked();
906 template<
typename _CharT,
typename _Traits,
typename _Alloc>
909 _M_mutate(size_type __pos, size_type __len1, size_type __len2)
911 const size_type __old_size = this->size();
912 const size_type __new_size = __old_size + __len2 - __len1;
913 const size_type __how_much = __old_size - __pos - __len1;
915 if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
918 const allocator_type __a = get_allocator();
919 _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
922 _M_copy(__r->_M_refdata(), _M_data(), __pos);
924 _M_copy(__r->_M_refdata() + __pos + __len2,
925 _M_data() + __pos + __len1, __how_much);
927 _M_rep()->_M_dispose(__a);
928 _M_data(__r->_M_refdata());
930 else if (__how_much && __len1 != __len2)
933 _M_move(_M_data() + __pos + __len2,
934 _M_data() + __pos + __len1, __how_much);
936 _M_rep()->_M_set_length_and_sharable(__new_size);
939 template<
typename _CharT,
typename _Traits,
typename _Alloc>
944 if (__res != this->capacity() || _M_rep()->_M_is_shared())
947 if (__res < this->size())
948 __res = this->size();
949 const allocator_type __a = get_allocator();
950 _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
951 _M_rep()->_M_dispose(__a);
956 template<
typename _CharT,
typename _Traits,
typename _Alloc>
961 if (_M_rep()->_M_is_leaked())
962 _M_rep()->_M_set_sharable();
963 if (__s._M_rep()->_M_is_leaked())
964 __s._M_rep()->_M_set_sharable();
967 _CharT* __tmp = _M_data();
968 _M_data(__s._M_data());
976 const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
977 this->get_allocator());
983 template<
typename _CharT,
typename _Traits,
typename _Alloc>
986 _S_create(size_type __capacity, size_type __old_capacity,
987 const _Alloc& __alloc)
991 if (__capacity > _S_max_size)
992 __throw_length_error(__N(
"basic_string::_S_create"));
1017 const size_type __pagesize = 4096;
1018 const size_type __malloc_header_size = 4 *
sizeof(
void*);
1026 if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
1027 __capacity = 2 * __old_capacity;
1032 size_type __size = (__capacity + 1) *
sizeof(_CharT) +
sizeof(_Rep);
1034 const size_type __adj_size = __size + __malloc_header_size;
1035 if (__adj_size > __pagesize && __capacity > __old_capacity)
1037 const size_type __extra = __pagesize - __adj_size % __pagesize;
1038 __capacity += __extra /
sizeof(_CharT);
1040 if (__capacity > _S_max_size)
1041 __capacity = _S_max_size;
1042 __size = (__capacity + 1) *
sizeof(_CharT) +
sizeof(_Rep);
1047 void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
1048 _Rep *__p =
new (__place) _Rep;
1049 __p->_M_capacity = __capacity;
1057 __p->_M_set_sharable();
1061 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1064 _M_clone(
const _Alloc& __alloc, size_type __res)
1067 const size_type __requested_cap = this->_M_length + __res;
1068 _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
1070 if (this->_M_length)
1071 _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
1073 __r->_M_set_length_and_sharable(this->_M_length);
1074 return __r->_M_refdata();
1077 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1082 const size_type __size = this->size();
1083 _M_check_length(__size, __n,
"basic_string::resize");
1085 this->append(__n - __size, __c);
1086 else if (__n < __size)
1091 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1092 template<
typename _InputIterator>
1096 _InputIterator __k2, __false_type)
1099 const size_type __n1 = __i2 - __i1;
1100 _M_check_length(__n1, __s.
size(),
"basic_string::_M_replace_dispatch");
1101 return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
1105 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1111 _M_check_length(__n1, __n2,
"basic_string::_M_replace_aux");
1112 _M_mutate(__pos1, __n1, __n2);
1114 _M_assign(_M_data() + __pos1, __n2, __c);
1118 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1124 _M_mutate(__pos1, __n1, __n2);
1126 _M_copy(_M_data() + __pos1, __s, __n2);
1130 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1131 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1133 copy(_CharT* __s, size_type __n, size_type __pos)
const 1135 _M_check(__pos,
"basic_string::copy");
1136 __n = _M_limit(__pos, __n);
1137 __glibcxx_requires_string_len(__s, __n);
1139 _M_copy(__s, _M_data() + __pos, __n);
1143 #endif // !_GLIBCXX_USE_CXX11_ABI 1145 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1147 operator+(
const _CharT* __lhs,
1150 __glibcxx_requires_string(__lhs);
1152 typedef typename __string_type::size_type __size_type;
1153 const __size_type __len = _Traits::length(__lhs);
1154 __string_type __str;
1155 __str.reserve(__len + __rhs.
size());
1156 __str.append(__lhs, __len);
1157 __str.append(__rhs);
1161 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1166 typedef typename __string_type::size_type __size_type;
1167 __string_type __str;
1168 const __size_type __len = __rhs.
size();
1169 __str.reserve(__len + 1);
1170 __str.append(__size_type(1), __lhs);
1171 __str.append(__rhs);
1175 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1176 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1178 find(
const _CharT* __s, size_type __pos, size_type __n)
const 1180 __glibcxx_requires_string_len(__s, __n);
1181 const size_type __size = this->size();
1182 const _CharT* __data = _M_data();
1185 return __pos <= __size ? __pos : npos;
1189 for (; __pos <= __size - __n; ++__pos)
1190 if (traits_type::eq(__data[__pos], __s[0])
1191 && traits_type::compare(__data + __pos + 1,
1192 __s + 1, __n - 1) == 0)
1198 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1199 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1201 find(_CharT __c, size_type __pos)
const _GLIBCXX_NOEXCEPT
1203 size_type __ret = npos;
1204 const size_type __size = this->size();
1207 const _CharT* __data = _M_data();
1208 const size_type __n = __size - __pos;
1209 const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
1211 __ret = __p - __data;
1216 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1217 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1219 rfind(
const _CharT* __s, size_type __pos, size_type __n)
const 1221 __glibcxx_requires_string_len(__s, __n);
1222 const size_type __size = this->size();
1225 __pos =
std::min(size_type(__size - __n), __pos);
1226 const _CharT* __data = _M_data();
1229 if (traits_type::compare(__data + __pos, __s, __n) == 0)
1232 while (__pos-- > 0);
1237 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1238 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1240 rfind(_CharT __c, size_type __pos)
const _GLIBCXX_NOEXCEPT
1242 size_type __size = this->size();
1245 if (--__size > __pos)
1247 for (++__size; __size-- > 0; )
1248 if (traits_type::eq(_M_data()[__size], __c))
1254 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1255 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1259 __glibcxx_requires_string_len(__s, __n);
1260 for (; __n && __pos < this->size(); ++__pos)
1262 const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
1269 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1270 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1274 __glibcxx_requires_string_len(__s, __n);
1275 size_type __size = this->size();
1278 if (--__size > __pos)
1282 if (traits_type::find(__s, __n, _M_data()[__size]))
1285 while (__size-- != 0);
1290 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1291 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1295 __glibcxx_requires_string_len(__s, __n);
1296 for (; __pos < this->size(); ++__pos)
1297 if (!traits_type::find(__s, __n, _M_data()[__pos]))
1302 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1303 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1307 for (; __pos < this->size(); ++__pos)
1308 if (!traits_type::eq(_M_data()[__pos], __c))
1313 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1314 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1318 __glibcxx_requires_string_len(__s, __n);
1319 size_type __size = this->size();
1322 if (--__size > __pos)
1326 if (!traits_type::find(__s, __n, _M_data()[__size]))
1334 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1335 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1339 size_type __size = this->size();
1342 if (--__size > __pos)
1346 if (!traits_type::eq(_M_data()[__size], __c))
1354 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1359 _M_check(__pos,
"basic_string::compare");
1360 __n = _M_limit(__pos, __n);
1361 const size_type __osize = __str.
size();
1362 const size_type __len =
std::min(__n, __osize);
1363 int __r = traits_type::compare(_M_data() + __pos, __str.
data(), __len);
1365 __r = _S_compare(__n, __osize);
1369 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1373 size_type __pos2, size_type __n2)
const 1375 _M_check(__pos1,
"basic_string::compare");
1376 __str._M_check(__pos2,
"basic_string::compare");
1377 __n1 = _M_limit(__pos1, __n1);
1378 __n2 = __str._M_limit(__pos2, __n2);
1379 const size_type __len =
std::min(__n1, __n2);
1380 int __r = traits_type::compare(_M_data() + __pos1,
1381 __str.
data() + __pos2, __len);
1383 __r = _S_compare(__n1, __n2);
1387 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1392 __glibcxx_requires_string(__s);
1393 const size_type __size = this->size();
1394 const size_type __osize = traits_type::length(__s);
1395 const size_type __len =
std::min(__size, __osize);
1396 int __r = traits_type::compare(_M_data(), __s, __len);
1398 __r = _S_compare(__size, __osize);
1402 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1405 compare(size_type __pos, size_type __n1,
const _CharT* __s)
const 1407 __glibcxx_requires_string(__s);
1408 _M_check(__pos,
"basic_string::compare");
1409 __n1 = _M_limit(__pos, __n1);
1410 const size_type __osize = traits_type::length(__s);
1411 const size_type __len =
std::min(__n1, __osize);
1412 int __r = traits_type::compare(_M_data() + __pos, __s, __len);
1414 __r = _S_compare(__n1, __osize);
1418 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1421 compare(size_type __pos, size_type __n1,
const _CharT* __s,
1422 size_type __n2)
const 1424 __glibcxx_requires_string_len(__s, __n2);
1425 _M_check(__pos,
"basic_string::compare");
1426 __n1 = _M_limit(__pos, __n1);
1427 const size_type __len =
std::min(__n1, __n2);
1428 int __r = traits_type::compare(_M_data() + __pos, __s, __len);
1430 __r = _S_compare(__n1, __n2);
1435 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1442 typedef typename __istream_type::ios_base __ios_base;
1443 typedef typename __istream_type::int_type __int_type;
1444 typedef typename __string_type::size_type __size_type;
1446 typedef typename __ctype_type::ctype_base __ctype_base;
1448 __size_type __extracted = 0;
1449 typename __ios_base::iostate __err = __ios_base::goodbit;
1450 typename __istream_type::sentry __cerb(__in,
false);
1458 __size_type __len = 0;
1460 const __size_type __n = __w > 0 ?
static_cast<__size_type
>(__w)
1462 const __ctype_type& __ct = use_facet<__ctype_type>(__in.
getloc());
1463 const __int_type __eof = _Traits::eof();
1464 __int_type __c = __in.
rdbuf()->sgetc();
1466 while (__extracted < __n
1467 && !_Traits::eq_int_type(__c, __eof)
1468 && !__ct.is(__ctype_base::space,
1469 _Traits::to_char_type(__c)))
1471 if (__len ==
sizeof(__buf) /
sizeof(_CharT))
1473 __str.
append(__buf,
sizeof(__buf) /
sizeof(_CharT));
1476 __buf[__len++] = _Traits::to_char_type(__c);
1478 __c = __in.
rdbuf()->snextc();
1480 __str.
append(__buf, __len);
1482 if (_Traits::eq_int_type(__c, __eof))
1483 __err |= __ios_base::eofbit;
1488 __in._M_setstate(__ios_base::badbit);
1489 __throw_exception_again;
1496 __in._M_setstate(__ios_base::badbit);
1501 __err |= __ios_base::failbit;
1507 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1514 typedef typename __istream_type::ios_base __ios_base;
1515 typedef typename __istream_type::int_type __int_type;
1516 typedef typename __string_type::size_type __size_type;
1518 __size_type __extracted = 0;
1519 const __size_type __n = __str.
max_size();
1520 typename __ios_base::iostate __err = __ios_base::goodbit;
1521 typename __istream_type::sentry __cerb(__in,
true);
1527 const __int_type __idelim = _Traits::to_int_type(__delim);
1528 const __int_type __eof = _Traits::eof();
1529 __int_type __c = __in.
rdbuf()->sgetc();
1531 while (__extracted < __n
1532 && !_Traits::eq_int_type(__c, __eof)
1533 && !_Traits::eq_int_type(__c, __idelim))
1535 __str += _Traits::to_char_type(__c);
1537 __c = __in.
rdbuf()->snextc();
1540 if (_Traits::eq_int_type(__c, __eof))
1541 __err |= __ios_base::eofbit;
1542 else if (_Traits::eq_int_type(__c, __idelim))
1545 __in.
rdbuf()->sbumpc();
1548 __err |= __ios_base::failbit;
1552 __in._M_setstate(__ios_base::badbit);
1553 __throw_exception_again;
1560 __in._M_setstate(__ios_base::badbit);
1564 __err |= __ios_base::failbit;
1572 #if _GLIBCXX_EXTERN_TEMPLATE > 0 1579 operator<<(basic_ostream<char>&,
const string&);
1587 #ifdef _GLIBCXX_USE_WCHAR_T 1594 operator<<(basic_ostream<wchar_t>&,
const wstring&);
1604 _GLIBCXX_END_NAMESPACE_VERSION
basic_string & erase(size_type __pos=0, size_type __n=npos)
Remove characters.
void setstate(iostate __state)
Sets additional flags in the error state.
basic_string & append(const basic_string &__str)
Append a string to this string.
basic_streambuf< _CharT, _Traits > * rdbuf() const
Accessing the underlying buffer.
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
streamsize width() const
Flags access.
allocator_type get_allocator() const noexcept
Return copy of allocator used to construct this string.
Managing sequences of characters and character-like objects.
static const size_type npos
Value returned by various member functions when they fail.
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
const _CharT * data() const noexcept
Return const pointer to contents.
constexpr const _Tp * begin(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to the first element of the initializer_list.
size_type max_size() const noexcept
Returns the size() of the largest possible string.
Template class basic_istream.
basic_istream< _CharT, _Traits > & getline(basic_istream< _CharT, _Traits > &__is, basic_string< _CharT, _Traits, _Alloc > &__str, _CharT __delim)
Read a line from stream into a string.
void resize(size_type __n, _CharT __c)
Resizes the string to the specified number of characters.
ISO C++ entities toplevel namespace is std.
basic_string()
Default constructor creates an empty string.
void reserve(size_type __res_arg=0)
Attempt to preallocate enough memory for specified number of characters.
Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recog...
locale getloc() const
Locale access.
Forward iterators support a superset of input iterator operations.
constexpr const _Tp * end(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to one past the last element of the initializer_list. ...
size_type copy(_CharT *__s, size_type __n, size_type __pos=0) const
Copy substring into C string.
iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
void swap(basic_string &__s)
Swap contents with another string.
size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
Primary class template ctype facet.This template class defines classification and conversion function...