39#ifndef _BASIC_STRING_TCC
40#define _BASIC_STRING_TCC 1
42#pragma GCC system_header
46namespace 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_set_length(__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,
386 const basic_string __s(__k1, __k2, this->get_allocator());
387 const size_type __n1 = __i2 - __i1;
388 return _M_replace(__i1 -
begin(), __n1, __s._M_data(),
392 template<
typename _CharT,
typename _Traits,
typename _Alloc>
393 basic_string<_CharT, _Traits, _Alloc>&
394 basic_string<_CharT, _Traits, _Alloc>::
395 _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
398 _M_check_length(__n1, __n2,
"basic_string::_M_replace_aux");
400 const size_type __old_size = this->size();
401 const size_type __new_size = __old_size + __n2 - __n1;
403 if (__new_size <= this->capacity())
405 pointer __p = this->_M_data() + __pos1;
407 const size_type __how_much = __old_size - __pos1 - __n1;
408 if (__how_much && __n1 != __n2)
409 this->_S_move(__p + __n2, __p + __n1, __how_much);
412 this->_M_mutate(__pos1, __n1, 0, __n2);
415 this->_S_assign(this->_M_data() + __pos1, __n2, __c);
417 this->_M_set_length(__new_size);
421 template<
typename _CharT,
typename _Traits,
typename _Alloc>
422 basic_string<_CharT, _Traits, _Alloc>&
423 basic_string<_CharT, _Traits, _Alloc>::
424 _M_replace(size_type __pos, size_type __len1,
const _CharT* __s,
425 const size_type __len2)
427 _M_check_length(__len1, __len2,
"basic_string::_M_replace");
429 const size_type __old_size = this->size();
430 const size_type __new_size = __old_size + __len2 - __len1;
432 if (__new_size <= this->capacity())
434 pointer __p = this->_M_data() + __pos;
436 const size_type __how_much = __old_size - __pos - __len1;
437 if (_M_disjunct(__s))
439 if (__how_much && __len1 != __len2)
440 this->_S_move(__p + __len2, __p + __len1, __how_much);
442 this->_S_copy(__p, __s, __len2);
447 if (__len2 && __len2 <= __len1)
448 this->_S_move(__p, __s, __len2);
449 if (__how_much && __len1 != __len2)
450 this->_S_move(__p + __len2, __p + __len1, __how_much);
453 if (__s + __len2 <= __p + __len1)
454 this->_S_move(__p, __s, __len2);
455 else if (__s >= __p + __len1)
456 this->_S_copy(__p, __s + __len2 - __len1, __len2);
459 const size_type __nleft = (__p + __len1) - __s;
460 this->_S_move(__p, __s, __nleft);
461 this->_S_copy(__p + __nleft, __p + __len2,
468 this->_M_mutate(__pos, __len1, __s, __len2);
470 this->_M_set_length(__new_size);
474 template<
typename _CharT,
typename _Traits,
typename _Alloc>
475 typename basic_string<_CharT, _Traits, _Alloc>::size_type
477 copy(_CharT* __s, size_type __n, size_type __pos)
const
479 _M_check(__pos,
"basic_string::copy");
480 __n = _M_limit(__pos, __n);
481 __glibcxx_requires_string_len(__s, __n);
483 _S_copy(__s, _M_data() + __pos, __n);
490 template<
typename _CharT,
typename _Traits,
typename _Alloc>
491 const typename basic_string<_CharT, _Traits, _Alloc>::size_type
492 basic_string<_CharT, _Traits, _Alloc>::
493 _Rep::_S_max_size = (((npos -
sizeof(_Rep_base))/
sizeof(_CharT)) - 1) / 4;
495 template<
typename _CharT,
typename _Traits,
typename _Alloc>
497 basic_string<_CharT, _Traits, _Alloc>::
498 _Rep::_S_terminal = _CharT();
500 template<
typename _CharT,
typename _Traits,
typename _Alloc>
501 const typename basic_string<_CharT, _Traits, _Alloc>::size_type
506 template<
typename _CharT,
typename _Traits,
typename _Alloc>
507 typename basic_string<_CharT, _Traits, _Alloc>::size_type
508 basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
509 (
sizeof(_Rep_base) +
sizeof(_CharT) +
sizeof(size_type) - 1) /
516 template<
typename _CharT,
typename _Traits,
typename _Alloc>
517 template<
typename _InIterator>
519 basic_string<_CharT, _Traits, _Alloc>::
520 _S_construct(_InIterator __beg, _InIterator __end,
const _Alloc& __a,
523#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
524 if (__beg == __end && __a == _Alloc())
525 return _S_empty_rep()._M_refdata();
530 while (__beg != __end && __len <
sizeof(__buf) /
sizeof(_CharT))
532 __buf[__len++] = *__beg;
535 _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
536 _M_copy(__r->_M_refdata(), __buf, __len);
539 while (__beg != __end)
541 if (__len == __r->_M_capacity)
544 _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
545 _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
546 __r->_M_destroy(__a);
549 __r->_M_refdata()[__len++] = *__beg;
555 __r->_M_destroy(__a);
556 __throw_exception_again;
558 __r->_M_set_length_and_sharable(__len);
559 return __r->_M_refdata();
562 template<
typename _CharT,
typename _Traits,
typename _Alloc>
563 template <
typename _InIterator>
565 basic_string<_CharT, _Traits, _Alloc>::
566 _S_construct(_InIterator __beg, _InIterator __end,
const _Alloc& __a,
567 forward_iterator_tag)
569#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
570 if (__beg == __end && __a == _Alloc())
571 return _S_empty_rep()._M_refdata();
574 if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
575 __throw_logic_error(__N(
"basic_string::_S_construct null not valid"));
577 const size_type __dnew =
static_cast<size_type
>(
std::distance(__beg,
580 _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
582 { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
585 __r->_M_destroy(__a);
586 __throw_exception_again;
588 __r->_M_set_length_and_sharable(__dnew);
589 return __r->_M_refdata();
592 template<
typename _CharT,
typename _Traits,
typename _Alloc>
594 basic_string<_CharT, _Traits, _Alloc>::
595 _S_construct(size_type __n, _CharT __c,
const _Alloc& __a)
597#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
598 if (__n == 0 && __a == _Alloc())
599 return _S_empty_rep()._M_refdata();
602 _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
604 _M_assign(__r->_M_refdata(), __n, __c);
606 __r->_M_set_length_and_sharable(__n);
607 return __r->_M_refdata();
610 template<
typename _CharT,
typename _Traits,
typename _Alloc>
613 : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
614 __str.get_allocator()),
615 __str.get_allocator())
618 template<
typename _CharT,
typename _Traits,
typename _Alloc>
621 : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
624 template<
typename _CharT,
typename _Traits,
typename _Alloc>
627 : _M_dataplus(_S_construct(__str._M_data()
628 + __str._M_check(__pos,
629 "basic_string::basic_string"),
630 __str._M_data() + __str._M_limit(__pos, npos)
634 template<
typename _CharT,
typename _Traits,
typename _Alloc>
637 : _M_dataplus(_S_construct(__str._M_data()
638 + __str._M_check(__pos,
639 "basic_string::basic_string"),
640 __str._M_data() + __str._M_limit(__pos, __n)
641 + __pos, _Alloc()), _Alloc())
644 template<
typename _CharT,
typename _Traits,
typename _Alloc>
647 size_type __n,
const _Alloc& __a)
648 : _M_dataplus(_S_construct(__str._M_data()
649 + __str._M_check(__pos,
650 "basic_string::basic_string"),
651 __str._M_data() + __str._M_limit(__pos, __n)
656 template<
typename _CharT,
typename _Traits,
typename _Alloc>
658 basic_string(
const _CharT* __s, size_type __n,
const _Alloc& __a)
659 : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
663 template<
typename _CharT,
typename _Traits,
typename _Alloc>
666 : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
667 __s + npos, __a), __a)
670 template<
typename _CharT,
typename _Traits,
typename _Alloc>
672 basic_string(size_type __n, _CharT __c,
const _Alloc& __a)
673 : _M_dataplus(_S_construct(__n, __c, __a), __a)
677 template<
typename _CharT,
typename _Traits,
typename _Alloc>
678 template<
typename _InputIterator>
680 basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a)
681 : _M_dataplus(_S_construct(__beg, __end, __a), __a)
684#if __cplusplus >= 201103L
685 template<
typename _CharT,
typename _Traits,
typename _Alloc>
688 : _M_dataplus(_S_construct(__l.
begin(), __l.
end(), __a), __a)
692 template<
typename _CharT,
typename _Traits,
typename _Alloc>
697 if (_M_rep() != __str._M_rep())
700 const allocator_type __a = this->get_allocator();
701 _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.
get_allocator());
702 _M_rep()->_M_dispose(__a);
708 template<
typename _CharT,
typename _Traits,
typename _Alloc>
711 assign(
const _CharT* __s, size_type __n)
713 __glibcxx_requires_string_len(__s, __n);
714 _M_check_length(this->size(), __n,
"basic_string::assign");
715 if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
716 return _M_replace_safe(size_type(0), this->size(), __s, __n);
720 const size_type __pos = __s - _M_data();
722 _M_copy(_M_data(), __s, __n);
724 _M_move(_M_data(), __s, __n);
725 _M_rep()->_M_set_length_and_sharable(__n);
730 template<
typename _CharT,
typename _Traits,
typename _Alloc>
733 append(size_type __n, _CharT __c)
737 _M_check_length(size_type(0), __n,
"basic_string::append");
738 const size_type __len = __n + this->size();
739 if (__len > this->capacity() || _M_rep()->_M_is_shared())
740 this->reserve(__len);
741 _M_assign(_M_data() + this->size(), __n, __c);
742 _M_rep()->_M_set_length_and_sharable(__len);
747 template<
typename _CharT,
typename _Traits,
typename _Alloc>
750 append(
const _CharT* __s, size_type __n)
752 __glibcxx_requires_string_len(__s, __n);
755 _M_check_length(size_type(0), __n,
"basic_string::append");
756 const size_type __len = __n + this->size();
757 if (__len > this->capacity() || _M_rep()->_M_is_shared())
759 if (_M_disjunct(__s))
760 this->reserve(__len);
763 const size_type __off = __s - _M_data();
764 this->reserve(__len);
765 __s = _M_data() + __off;
768 _M_copy(_M_data() + this->size(), __s, __n);
769 _M_rep()->_M_set_length_and_sharable(__len);
774 template<
typename _CharT,
typename _Traits,
typename _Alloc>
779 const size_type __size = __str.
size();
782 const size_type __len = __size + this->size();
783 if (__len > this->capacity() || _M_rep()->_M_is_shared())
784 this->reserve(__len);
785 _M_copy(_M_data() + this->size(), __str._M_data(), __size);
786 _M_rep()->_M_set_length_and_sharable(__len);
791 template<
typename _CharT,
typename _Traits,
typename _Alloc>
796 __str._M_check(__pos,
"basic_string::append");
797 __n = __str._M_limit(__pos, __n);
800 const size_type __len = __n + this->size();
801 if (__len > this->capacity() || _M_rep()->_M_is_shared())
802 this->reserve(__len);
803 _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
804 _M_rep()->_M_set_length_and_sharable(__len);
809 template<
typename _CharT,
typename _Traits,
typename _Alloc>
812 insert(size_type __pos,
const _CharT* __s, size_type __n)
814 __glibcxx_requires_string_len(__s, __n);
815 _M_check(__pos,
"basic_string::insert");
816 _M_check_length(size_type(0), __n,
"basic_string::insert");
817 if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
818 return _M_replace_safe(__pos, size_type(0), __s, __n);
822 const size_type __off = __s - _M_data();
823 _M_mutate(__pos, 0, __n);
824 __s = _M_data() + __off;
825 _CharT* __p = _M_data() + __pos;
826 if (__s + __n <= __p)
827 _M_copy(__p, __s, __n);
829 _M_copy(__p, __s + __n, __n);
832 const size_type __nleft = __p - __s;
833 _M_copy(__p, __s, __nleft);
834 _M_copy(__p + __nleft, __p + __n, __n - __nleft);
840 template<
typename _CharT,
typename _Traits,
typename _Alloc>
841 typename basic_string<_CharT, _Traits, _Alloc>::iterator
843 erase(iterator __first, iterator __last)
845 _GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last
846 && __last <= _M_iend());
851 const size_type __size = __last - __first;
854 const size_type __pos = __first - _M_ibegin();
855 _M_mutate(__pos, __size, size_type(0));
856 _M_rep()->_M_set_leaked();
857 return iterator(_M_data() + __pos);
863 template<
typename _CharT,
typename _Traits,
typename _Alloc>
866 replace(size_type __pos, size_type __n1,
const _CharT* __s,
869 __glibcxx_requires_string_len(__s, __n2);
870 _M_check(__pos,
"basic_string::replace");
871 __n1 = _M_limit(__pos, __n1);
872 _M_check_length(__n1, __n2,
"basic_string::replace");
874 if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
875 return _M_replace_safe(__pos, __n1, __s, __n2);
876 else if ((__left = __s + __n2 <= _M_data() + __pos)
877 || _M_data() + __pos + __n1 <= __s)
880 size_type __off = __s - _M_data();
881 __left ? __off : (__off += __n2 - __n1);
882 _M_mutate(__pos, __n1, __n2);
883 _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
890 return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
894 template<
typename _CharT,
typename _Traits,
typename _Alloc>
899 const size_type __size =
sizeof(_Rep_base) +
900 (this->_M_capacity + 1) *
sizeof(_CharT);
901 _Raw_bytes_alloc(__a).deallocate(
reinterpret_cast<char*
>(
this), __size);
904 template<
typename _CharT,
typename _Traits,
typename _Alloc>
906 basic_string<_CharT, _Traits, _Alloc>::
909#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
910 if (_M_rep() == &_S_empty_rep())
913 if (_M_rep()->_M_is_shared())
915 _M_rep()->_M_set_leaked();
918 template<
typename _CharT,
typename _Traits,
typename _Alloc>
920 basic_string<_CharT, _Traits, _Alloc>::
921 _M_mutate(size_type __pos, size_type __len1, size_type __len2)
923 const size_type __old_size = this->size();
924 const size_type __new_size = __old_size + __len2 - __len1;
925 const size_type __how_much = __old_size - __pos - __len1;
927 if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
930 const allocator_type __a = get_allocator();
931 _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
934 _M_copy(__r->_M_refdata(), _M_data(), __pos);
936 _M_copy(__r->_M_refdata() + __pos + __len2,
937 _M_data() + __pos + __len1, __how_much);
939 _M_rep()->_M_dispose(__a);
940 _M_data(__r->_M_refdata());
942 else if (__how_much && __len1 != __len2)
945 _M_move(_M_data() + __pos + __len2,
946 _M_data() + __pos + __len1, __how_much);
948 _M_rep()->_M_set_length_and_sharable(__new_size);
951 template<
typename _CharT,
typename _Traits,
typename _Alloc>
956 if (__res != this->capacity() || _M_rep()->_M_is_shared())
959 if (__res < this->size())
960 __res = this->size();
961 const allocator_type __a = get_allocator();
962 _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
963 _M_rep()->_M_dispose(__a);
968 template<
typename _CharT,
typename _Traits,
typename _Alloc>
974 if (_M_rep()->_M_is_leaked())
975 _M_rep()->_M_set_sharable();
976 if (__s._M_rep()->_M_is_leaked())
977 __s._M_rep()->_M_set_sharable();
978 if (this->get_allocator() == __s.get_allocator())
980 _CharT* __tmp = _M_data();
981 _M_data(__s._M_data());
988 __s.get_allocator());
989 const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
990 this->get_allocator());
996 template<
typename _CharT,
typename _Traits,
typename _Alloc>
999 _S_create(size_type __capacity, size_type __old_capacity,
1000 const _Alloc& __alloc)
1004 if (__capacity > _S_max_size)
1005 __throw_length_error(__N(
"basic_string::_S_create"));
1030 const size_type __pagesize = 4096;
1031 const size_type __malloc_header_size = 4 *
sizeof(
void*);
1039 if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
1040 __capacity = 2 * __old_capacity;
1045 size_type __size = (__capacity + 1) *
sizeof(_CharT) +
sizeof(_Rep);
1047 const size_type __adj_size = __size + __malloc_header_size;
1048 if (__adj_size > __pagesize && __capacity > __old_capacity)
1050 const size_type __extra = __pagesize - __adj_size % __pagesize;
1051 __capacity += __extra /
sizeof(_CharT);
1053 if (__capacity > _S_max_size)
1054 __capacity = _S_max_size;
1055 __size = (__capacity + 1) *
sizeof(_CharT) +
sizeof(_Rep);
1060 void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
1061 _Rep *__p =
new (__place) _Rep;
1062 __p->_M_capacity = __capacity;
1070 __p->_M_set_sharable();
1074 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1076 basic_string<_CharT, _Traits, _Alloc>::_Rep::
1077 _M_clone(
const _Alloc& __alloc, size_type __res)
1080 const size_type __requested_cap = this->_M_length + __res;
1081 _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
1083 if (this->_M_length)
1084 _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
1086 __r->_M_set_length_and_sharable(this->_M_length);
1087 return __r->_M_refdata();
1090 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1093 resize(size_type __n, _CharT __c)
1095 const size_type __size = this->size();
1096 _M_check_length(__size, __n,
"basic_string::resize");
1098 this->append(__n - __size, __c);
1099 else if (__n < __size)
1104 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1105 template<
typename _InputIterator>
1109 _InputIterator __k2, __false_type)
1112 const size_type __n1 = __i2 - __i1;
1113 _M_check_length(__n1, __s.size(),
"basic_string::_M_replace_dispatch");
1114 return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
1118 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1119 basic_string<_CharT, _Traits, _Alloc>&
1120 basic_string<_CharT, _Traits, _Alloc>::
1121 _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
1124 _M_check_length(__n1, __n2,
"basic_string::_M_replace_aux");
1125 _M_mutate(__pos1, __n1, __n2);
1127 _M_assign(_M_data() + __pos1, __n2, __c);
1131 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1132 basic_string<_CharT, _Traits, _Alloc>&
1133 basic_string<_CharT, _Traits, _Alloc>::
1134 _M_replace_safe(size_type __pos1, size_type __n1,
const _CharT* __s,
1137 _M_mutate(__pos1, __n1, __n2);
1139 _M_copy(_M_data() + __pos1, __s, __n2);
1143 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1144 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1146 copy(_CharT* __s, size_type __n, size_type __pos)
const
1148 _M_check(__pos,
"basic_string::copy");
1149 __n = _M_limit(__pos, __n);
1150 __glibcxx_requires_string_len(__s, __n);
1152 _M_copy(__s, _M_data() + __pos, __n);
1158 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1163 __glibcxx_requires_string(__lhs);
1165 typedef typename __string_type::size_type __size_type;
1167 rebind<_CharT>::other _Char_alloc_type;
1169 const __size_type __len = _Traits::length(__lhs);
1170 __string_type __str(_Alloc_traits::_S_select_on_copy(
1172 __str.reserve(__len + __rhs.
size());
1173 __str.append(__lhs, __len);
1174 __str.append(__rhs);
1178 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1179 basic_string<_CharT, _Traits, _Alloc>
1183 typedef typename __string_type::size_type __size_type;
1185 rebind<_CharT>::other _Char_alloc_type;
1187 __string_type __str(_Alloc_traits::_S_select_on_copy(
1189 const __size_type __len = __rhs.
size();
1190 __str.reserve(__len + 1);
1191 __str.append(__size_type(1), __lhs);
1192 __str.append(__rhs);
1196 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1197 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1199 find(
const _CharT* __s, size_type __pos, size_type __n)
const
1202 __glibcxx_requires_string_len(__s, __n);
1203 const size_type __size = this->size();
1206 return __pos <= __size ? __pos : npos;
1207 if (__pos >= __size)
1210 const _CharT __elem0 = __s[0];
1211 const _CharT*
const __data = data();
1212 const _CharT* __first = __data + __pos;
1213 const _CharT*
const __last = __data + __size;
1214 size_type __len = __size - __pos;
1216 while (__len >= __n)
1219 __first = traits_type::find(__first, __len - __n + 1, __elem0);
1225 if (traits_type::compare(__first, __s, __n) == 0)
1226 return __first - __data;
1227 __len = __last - ++__first;
1232 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1233 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1235 find(_CharT __c, size_type __pos)
const _GLIBCXX_NOEXCEPT
1237 size_type __ret = npos;
1238 const size_type __size = this->size();
1241 const _CharT* __data = _M_data();
1242 const size_type __n = __size - __pos;
1243 const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
1245 __ret = __p - __data;
1250 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1251 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1253 rfind(
const _CharT* __s, size_type __pos, size_type __n)
const
1256 __glibcxx_requires_string_len(__s, __n);
1257 const size_type __size = this->size();
1260 __pos =
std::min(size_type(__size - __n), __pos);
1261 const _CharT* __data = _M_data();
1264 if (traits_type::compare(__data + __pos, __s, __n) == 0)
1267 while (__pos-- > 0);
1272 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1273 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1275 rfind(_CharT __c, size_type __pos)
const _GLIBCXX_NOEXCEPT
1277 size_type __size = this->size();
1280 if (--__size > __pos)
1282 for (++__size; __size-- > 0; )
1283 if (traits_type::eq(_M_data()[__size], __c))
1289 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1290 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1292 find_first_of(
const _CharT* __s, size_type __pos, size_type __n)
const
1295 __glibcxx_requires_string_len(__s, __n);
1296 for (; __n && __pos < this->size(); ++__pos)
1298 const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
1305 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1306 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1308 find_last_of(
const _CharT* __s, size_type __pos, size_type __n)
const
1311 __glibcxx_requires_string_len(__s, __n);
1312 size_type __size = this->size();
1315 if (--__size > __pos)
1319 if (traits_type::find(__s, __n, _M_data()[__size]))
1322 while (__size-- != 0);
1327 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1328 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1333 __glibcxx_requires_string_len(__s, __n);
1334 for (; __pos < this->size(); ++__pos)
1335 if (!traits_type::find(__s, __n, _M_data()[__pos]))
1340 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1341 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1345 for (; __pos < this->size(); ++__pos)
1346 if (!traits_type::eq(_M_data()[__pos], __c))
1351 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1352 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1357 __glibcxx_requires_string_len(__s, __n);
1358 size_type __size = this->size();
1361 if (--__size > __pos)
1365 if (!traits_type::find(__s, __n, _M_data()[__size]))
1373 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1374 typename basic_string<_CharT, _Traits, _Alloc>::size_type
1378 size_type __size = this->size();
1381 if (--__size > __pos)
1385 if (!traits_type::eq(_M_data()[__size], __c))
1393 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1398 _M_check(__pos,
"basic_string::compare");
1399 __n = _M_limit(__pos, __n);
1400 const size_type __osize = __str.
size();
1401 const size_type __len =
std::min(__n, __osize);
1402 int __r = traits_type::compare(_M_data() + __pos, __str.
data(), __len);
1404 __r = _S_compare(__n, __osize);
1408 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1412 size_type __pos2, size_type __n2)
const
1414 _M_check(__pos1,
"basic_string::compare");
1415 __str._M_check(__pos2,
"basic_string::compare");
1416 __n1 = _M_limit(__pos1, __n1);
1417 __n2 = __str._M_limit(__pos2, __n2);
1418 const size_type __len =
std::min(__n1, __n2);
1419 int __r = traits_type::compare(_M_data() + __pos1,
1420 __str.
data() + __pos2, __len);
1422 __r = _S_compare(__n1, __n2);
1426 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1429 compare(
const _CharT* __s)
const _GLIBCXX_NOEXCEPT
1431 __glibcxx_requires_string(__s);
1432 const size_type __size = this->size();
1433 const size_type __osize = traits_type::length(__s);
1434 const size_type __len =
std::min(__size, __osize);
1435 int __r = traits_type::compare(_M_data(), __s, __len);
1437 __r = _S_compare(__size, __osize);
1441 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1444 compare(size_type __pos, size_type __n1,
const _CharT* __s)
const
1446 __glibcxx_requires_string(__s);
1447 _M_check(__pos,
"basic_string::compare");
1448 __n1 = _M_limit(__pos, __n1);
1449 const size_type __osize = traits_type::length(__s);
1450 const size_type __len =
std::min(__n1, __osize);
1451 int __r = traits_type::compare(_M_data() + __pos, __s, __len);
1453 __r = _S_compare(__n1, __osize);
1457 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1460 compare(size_type __pos, size_type __n1,
const _CharT* __s,
1461 size_type __n2)
const
1463 __glibcxx_requires_string_len(__s, __n2);
1464 _M_check(__pos,
"basic_string::compare");
1465 __n1 = _M_limit(__pos, __n1);
1466 const size_type __len =
std::min(__n1, __n2);
1467 int __r = traits_type::compare(_M_data() + __pos, __s, __len);
1469 __r = _S_compare(__n1, __n2);
1474 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1481 typedef typename __istream_type::ios_base __ios_base;
1482 typedef typename __istream_type::int_type __int_type;
1483 typedef typename __string_type::size_type __size_type;
1485 typedef typename __ctype_type::ctype_base __ctype_base;
1487 __size_type __extracted = 0;
1488 typename __ios_base::iostate __err = __ios_base::goodbit;
1489 typename __istream_type::sentry __cerb(__in,
false);
1497 __size_type __len = 0;
1499 const __size_type __n = __w > 0 ?
static_cast<__size_type
>(__w)
1501 const __ctype_type& __ct = use_facet<__ctype_type>(__in.
getloc());
1502 const __int_type __eof = _Traits::eof();
1503 __int_type __c = __in.
rdbuf()->sgetc();
1505 while (__extracted < __n
1506 && !_Traits::eq_int_type(__c, __eof)
1507 && !__ct.is(__ctype_base::space,
1508 _Traits::to_char_type(__c)))
1510 if (__len ==
sizeof(__buf) /
sizeof(_CharT))
1512 __str.
append(__buf,
sizeof(__buf) /
sizeof(_CharT));
1515 __buf[__len++] = _Traits::to_char_type(__c);
1517 __c = __in.
rdbuf()->snextc();
1519 __str.
append(__buf, __len);
1521 if (_Traits::eq_int_type(__c, __eof))
1522 __err |= __ios_base::eofbit;
1527 __in._M_setstate(__ios_base::badbit);
1528 __throw_exception_again;
1535 __in._M_setstate(__ios_base::badbit);
1540 __err |= __ios_base::failbit;
1546 template<
typename _CharT,
typename _Traits,
typename _Alloc>
1547 basic_istream<_CharT, _Traits>&
1553 typedef typename __istream_type::ios_base __ios_base;
1554 typedef typename __istream_type::int_type __int_type;
1555 typedef typename __string_type::size_type __size_type;
1557 __size_type __extracted = 0;
1558 const __size_type __n = __str.
max_size();
1559 typename __ios_base::iostate __err = __ios_base::goodbit;
1560 typename __istream_type::sentry __cerb(__in,
true);
1566 const __int_type __idelim = _Traits::to_int_type(__delim);
1567 const __int_type __eof = _Traits::eof();
1568 __int_type __c = __in.
rdbuf()->sgetc();
1570 while (__extracted < __n
1571 && !_Traits::eq_int_type(__c, __eof)
1572 && !_Traits::eq_int_type(__c, __idelim))
1574 __str += _Traits::to_char_type(__c);
1576 __c = __in.
rdbuf()->snextc();
1579 if (_Traits::eq_int_type(__c, __eof))
1580 __err |= __ios_base::eofbit;
1581 else if (_Traits::eq_int_type(__c, __idelim))
1584 __in.
rdbuf()->sbumpc();
1587 __err |= __ios_base::failbit;
1591 __in._M_setstate(__ios_base::badbit);
1592 __throw_exception_again;
1599 __in._M_setstate(__ios_base::badbit);
1603 __err |= __ios_base::failbit;
1611#if _GLIBCXX_EXTERN_TEMPLATE
1617# if __cplusplus <= 201703L && _GLIBCXX_EXTERN_TEMPLATE > 0
1618 extern template class basic_string<char>;
1619# elif ! _GLIBCXX_USE_CXX11_ABI
1622 extern template basic_string<char>::size_type
1623 basic_string<char>::_Rep::_S_empty_rep_storage[];
1627 basic_istream<char>&
1630 basic_ostream<char>&
1631 operator<<(basic_ostream<char>&,
const string&);
1633 basic_istream<char>&
1634 getline(basic_istream<char>&,
string&,
char);
1636 basic_istream<char>&
1637 getline(basic_istream<char>&,
string&);
1639#ifdef _GLIBCXX_USE_WCHAR_T
1640# if __cplusplus <= 201703L && _GLIBCXX_EXTERN_TEMPLATE > 0
1641 extern template class basic_string<wchar_t>;
1642# elif ! _GLIBCXX_USE_CXX11_ABI
1643 extern template basic_string<wchar_t>::size_type
1644 basic_string<wchar_t>::_Rep::_S_empty_rep_storage[];
1648 basic_istream<wchar_t>&
1651 basic_ostream<wchar_t>&
1652 operator<<(basic_ostream<wchar_t>&,
const wstring&);
1654 basic_istream<wchar_t>&
1657 basic_istream<wchar_t>&
1662_GLIBCXX_END_NAMESPACE_VERSION
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
_Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
_Tp * end(valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the valarray.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
basic_string< wchar_t > wstring
A string of wchar_t.
ISO C++ entities toplevel namespace is std.
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
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.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
void setstate(iostate __state)
Sets additional flags in the error state.
basic_streambuf< _CharT, _Traits > * rdbuf() const
Accessing the underlying buffer.
Template class basic_istream.
Uniform interface to all allocator types.
Managing sequences of characters and character-like objects.
void swap(basic_string &__s) noexcept(/*conditional */)
Swap contents with another string.
size_type find_first_of(const basic_string &__str, size_type __pos=0) const noexcept
Find position of a character of string.
const _CharT * data() const noexcept
Return const pointer to contents.
size_type find(const _CharT *__s, size_type __pos, size_type __n) const noexcept
Find position of a C substring.
size_type find_last_not_of(const basic_string &__str, size_type __pos=npos) const noexcept
Find last position of a character not in string.
int compare(const basic_string &__str) const
Compare to a string.
void reserve(size_type __res_arg=0)
Attempt to preallocate enough memory for specified number of characters.
size_type find_first_not_of(const basic_string &__str, size_type __pos=0) const noexcept
Find position of a character not in string.
void insert(iterator __p, size_type __n, _CharT __c)
Insert multiple characters.
basic_string & assign(const basic_string &__str)
Set value to contents of another string.
size_type copy(_CharT *__s, size_type __n, size_type __pos=0) const
Copy substring into C string.
size_type find_last_of(const basic_string &__str, size_type __pos=npos) const noexcept
Find last position of a character of string.
size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
size_type rfind(const basic_string &__str, size_type __pos=npos) const noexcept
Find last position of a string.
void resize(size_type __n, _CharT __c)
Resizes the string to the specified number of characters.
basic_string & append(const basic_string &__str)
Append a string to this string.
static const size_type npos
Value returned by various member functions when they fail.
allocator_type get_allocator() const noexcept
Return copy of allocator used to construct this string.
basic_string() noexcept
Default constructor creates an empty string.
size_type max_size() const noexcept
Returns the size() of the largest possible string.
basic_string & erase(size_type __pos=0, size_type __n=npos)
Remove characters.
basic_string & replace(size_type __pos, size_type __n, const basic_string &__str)
Replace characters with value from another string.
Thrown as part of forced unwinding.
streamsize width() const
Flags access.
locale getloc() const
Locale access.
Primary class template ctype facet.
Forward iterators support a superset of input iterator operations.
Uniform interface to C++98 and C++11 allocators.