1 // Definition of gcc4-compatible Copy-on-Write basic_string -*- C++ -*-
3 // Copyright (C) 1997-2024 Free Software Foundation, Inc.
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)
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.
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.
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/>.
25 /** @file bits/cow_string.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{string}
29 * Defines the reference-counted COW string implementation.
33 #define _COW_STRING_H 1
35 #if ! _GLIBCXX_USE_CXX11_ABI
37 #include <ext/atomicity.h> // _Atomic_word, __is_single_threaded
39 namespace std
_GLIBCXX_VISIBILITY(default)
41 _GLIBCXX_BEGIN_NAMESPACE_VERSION
44 * @class basic_string basic_string.h <string>
45 * @brief Managing sequences of characters and character-like objects.
52 * @tparam _CharT Type of character
53 * @tparam _Traits Traits for character type, defaults to
54 * char_traits<_CharT>.
55 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
57 * Meets the requirements of a <a href="tables.html#65">container</a>, a
58 * <a href="tables.html#66">reversible container</a>, and a
59 * <a href="tables.html#67">sequence</a>. Of the
60 * <a href="tables.html#68">optional sequence requirements</a>, only
61 * @c push_back, @c at, and @c %array access are supported.
66 * Documentation? What's that?
67 * Nathan Myers <ncm@cantrip.org>.
69 * A string looks like this:
74 * [basic_string<char_type>] _M_capacity
75 * _M_dataplus _M_refcount
76 * _M_p ----------------> unnamed array of char_type
79 * Where the _M_p points to the first character in the string, and
80 * you cast it to a pointer-to-_Rep and subtract 1 to get a
81 * pointer to the header.
83 * This approach has the enormous advantage that a string object
84 * requires only one allocation. All the ugliness is confined
85 * within a single %pair of inline functions, which each compile to
86 * a single @a add instruction: _Rep::_M_data(), and
87 * string::_M_rep(); and the allocation function which gets a
88 * block of raw bytes and with room enough and constructs a _Rep
89 * object at the front.
91 * The reason you want _M_data pointing to the character %array and
92 * not the _Rep is so that the debugger can see the string
93 * contents. (Probably we should add a non-inline member to get
94 * the _Rep for the debugger to use, so users can check the actual
97 * Note that the _Rep object is a POD so that you can have a
98 * static <em>empty string</em> _Rep object already @a constructed before
99 * static constructors have run. The reference-count encoding is
100 * chosen so that a 0 indicates one reference, so you never try to
101 * destroy the empty-string _Rep object.
103 * All but the last paragraph is considered pretty conventional
104 * for a Copy-On-Write C++ string implementation.
106 // 21.3 Template class basic_string
107 template<typename _CharT
, typename _Traits
, typename _Alloc
>
110 typedef typename
__gnu_cxx::__alloc_traits
<_Alloc
>::template
111 rebind
<_CharT
>::other _CharT_alloc_type
;
112 typedef __gnu_cxx::__alloc_traits
<_CharT_alloc_type
> _CharT_alloc_traits
;
116 typedef _Traits traits_type
;
117 typedef typename
_Traits::char_type value_type
;
118 typedef _Alloc allocator_type
;
119 typedef typename
_CharT_alloc_traits::size_type size_type
;
120 typedef typename
_CharT_alloc_traits::difference_type difference_type
;
121 #if __cplusplus < 201103L
122 typedef typename
_CharT_alloc_type::reference reference
;
123 typedef typename
_CharT_alloc_type::const_reference const_reference
;
125 typedef value_type
& reference
;
126 typedef const value_type
& const_reference
;
128 typedef typename
_CharT_alloc_traits::pointer pointer
;
129 typedef typename
_CharT_alloc_traits::const_pointer const_pointer
;
130 typedef __gnu_cxx::__normal_iterator
<pointer
, basic_string
> iterator
;
131 typedef __gnu_cxx::__normal_iterator
<const_pointer
, basic_string
>
133 typedef std::reverse_iterator
<const_iterator
> const_reverse_iterator
;
134 typedef std::reverse_iterator
<iterator
> reverse_iterator
;
137 // type used for positions in insert, erase etc.
138 typedef iterator __const_iterator
;
141 // _Rep: string representation
143 // 1. String really contains _M_length + 1 characters: due to 21.3.4
144 // must be kept null-terminated.
145 // 2. _M_capacity >= _M_length
146 // Allocated memory is always (_M_capacity + 1) * sizeof(_CharT).
147 // 3. _M_refcount has three states:
148 // -1: leaked, one reference, no ref-copies allowed, non-const.
149 // 0: one reference, non-const.
150 // n>0: n + 1 references, operations require a lock, const.
151 // 4. All fields==0 is an empty string, given the extra storage
152 // beyond-the-end for a null terminator; thus, the shared
153 // empty string representation needs no constructor.
158 size_type _M_capacity
;
159 _Atomic_word _M_refcount
;
162 struct _Rep
: _Rep_base
165 typedef typename
__gnu_cxx::__alloc_traits
<_Alloc
>::template
166 rebind
<char>::other _Raw_bytes_alloc
;
168 // (Public) Data members:
170 // The maximum number of individual char_type elements of an
171 // individual string is determined by _S_max_size. This is the
172 // value that will be returned by max_size(). (Whereas npos
173 // is the maximum number of bytes the allocator can allocate.)
174 // If one was to divvy up the theoretical largest size string,
175 // with a terminating character and m _CharT elements, it'd
177 // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT)
179 // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1
180 // In addition, this implementation quarters this amount.
181 static const size_type _S_max_size
;
182 static const _CharT _S_terminal
;
184 // The following storage is init'd to 0 by the linker, resulting
185 // (carefully) in an empty string with one reference.
186 static size_type _S_empty_rep_storage
[];
189 _S_empty_rep() _GLIBCXX_NOEXCEPT
191 // NB: Mild hack to avoid strict-aliasing warnings. Note that
192 // _S_empty_rep_storage is never modified and the punning should
193 // be reasonably safe in this case.
194 void* __p
= reinterpret_cast<void*>(&_S_empty_rep_storage
);
195 return *reinterpret_cast<_Rep
*>(__p
);
199 _M_is_leaked() const _GLIBCXX_NOEXCEPT
201 #if defined(__GTHREADS)
202 // _M_refcount is mutated concurrently by _M_refcopy/_M_dispose,
203 // so we need to use an atomic load. However, _M_is_leaked
204 // predicate does not change concurrently (i.e. the string is either
205 // leaked or not), so a relaxed load is enough.
206 return __atomic_load_n(&this->_M_refcount
, __ATOMIC_RELAXED
) < 0;
208 return this->_M_refcount
< 0;
213 _M_is_shared() const _GLIBCXX_NOEXCEPT
215 #if defined(__GTHREADS)
216 // _M_refcount is mutated concurrently by _M_refcopy/_M_dispose,
217 // so we need to use an atomic load. Another thread can drop last
218 // but one reference concurrently with this check, so we need this
219 // load to be acquire to synchronize with release fetch_and_add in
221 if (!__gnu_cxx::__is_single_threaded())
222 return __atomic_load_n(&this->_M_refcount
, __ATOMIC_ACQUIRE
) > 0;
224 return this->_M_refcount
> 0;
228 _M_set_leaked() _GLIBCXX_NOEXCEPT
229 { this->_M_refcount
= -1; }
232 _M_set_sharable() _GLIBCXX_NOEXCEPT
233 { this->_M_refcount
= 0; }
236 _M_set_length_and_sharable(size_type __n
) _GLIBCXX_NOEXCEPT
238 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
239 if (__builtin_expect(this != &_S_empty_rep(), false))
242 this->_M_set_sharable(); // One reference.
243 this->_M_length
= __n
;
244 traits_type::assign(this->_M_refdata()[__n
], _S_terminal
);
245 // grrr. (per 21.3.4)
246 // You cannot leave those LWG people alone for a second.
252 { return reinterpret_cast<_CharT
*>(this + 1); }
255 _M_grab(const _Alloc
& __alloc1
, const _Alloc
& __alloc2
)
257 return (!_M_is_leaked() && __alloc1
== __alloc2
)
258 ? _M_refcopy() : _M_clone(__alloc1
);
263 _S_create(size_type
, size_type
, const _Alloc
&);
266 _M_dispose(const _Alloc
& __a
) _GLIBCXX_NOEXCEPT
268 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
269 if (__builtin_expect(this != &_S_empty_rep(), false))
272 // Be race-detector-friendly. For more info see bits/c++config.
273 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount
);
274 // Decrement of _M_refcount is acq_rel, because:
275 // - all but last decrements need to release to synchronize with
276 // the last decrement that will delete the object.
277 // - the last decrement needs to acquire to synchronize with
278 // all the previous decrements.
279 // - last but one decrement needs to release to synchronize with
280 // the acquire load in _M_is_shared that will conclude that
281 // the object is not shared anymore.
282 if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount
,
285 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount
);
292 _M_destroy(const _Alloc
&) throw();
297 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
298 if (__builtin_expect(this != &_S_empty_rep(), false))
300 __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount
, 1);
305 _M_clone(const _Alloc
&, size_type __res
= 0);
308 // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
309 struct _Alloc_hider
: _Alloc
311 _Alloc_hider(_CharT
* __dat
, const _Alloc
& __a
) _GLIBCXX_NOEXCEPT
312 : _Alloc(__a
), _M_p(__dat
) { }
314 _CharT
* _M_p
; // The actual data.
318 // Data Members (public):
319 // NB: This is an unsigned type, and thus represents the maximum
320 // size that the allocator can hold.
321 /// Value returned by various member functions when they fail.
322 static const size_type npos
= static_cast<size_type
>(-1);
325 // Data Members (private):
326 mutable _Alloc_hider _M_dataplus
;
329 _M_data() const _GLIBCXX_NOEXCEPT
330 { return _M_dataplus
._M_p
; }
333 _M_data(_CharT
* __p
) _GLIBCXX_NOEXCEPT
334 { return (_M_dataplus
._M_p
= __p
); }
337 _M_rep() const _GLIBCXX_NOEXCEPT
338 { return &((reinterpret_cast<_Rep
*> (_M_data()))[-1]); }
340 // For the internal use we have functions similar to `begin'/`end'
341 // but they do not call _M_leak.
343 _M_ibegin() const _GLIBCXX_NOEXCEPT
344 { return iterator(_M_data()); }
347 _M_iend() const _GLIBCXX_NOEXCEPT
348 { return iterator(_M_data() + this->size()); }
351 _M_leak() // for use in begin() & non-const op[]
353 if (!_M_rep()->_M_is_leaked())
358 _M_check(size_type __pos
, const char* __s
) const
360 if (__pos
> this->size())
361 __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
362 "this->size() (which is %zu)"),
363 __s
, __pos
, this->size());
368 _M_check_length(size_type __n1
, size_type __n2
, const char* __s
) const
370 if (this->max_size() - (this->size() - __n1
) < __n2
)
371 __throw_length_error(__N(__s
));
374 // NB: _M_limit doesn't check for a bad __pos value.
376 _M_limit(size_type __pos
, size_type __off
) const _GLIBCXX_NOEXCEPT
378 const bool __testoff
= __off
< this->size() - __pos
;
379 return __testoff
? __off
: this->size() - __pos
;
382 // True if _Rep and source do not overlap.
384 _M_disjunct(const _CharT
* __s
) const _GLIBCXX_NOEXCEPT
386 return (less
<const _CharT
*>()(__s
, _M_data())
387 || less
<const _CharT
*>()(_M_data() + this->size(), __s
));
390 // When __n = 1 way faster than the general multichar
391 // traits_type::copy/move/assign.
393 _M_copy(_CharT
* __d
, const _CharT
* __s
, size_type __n
) _GLIBCXX_NOEXCEPT
396 traits_type::assign(*__d
, *__s
);
398 traits_type::copy(__d
, __s
, __n
);
402 _M_move(_CharT
* __d
, const _CharT
* __s
, size_type __n
) _GLIBCXX_NOEXCEPT
405 traits_type::assign(*__d
, *__s
);
407 traits_type::move(__d
, __s
, __n
);
411 _M_assign(_CharT
* __d
, size_type __n
, _CharT __c
) _GLIBCXX_NOEXCEPT
414 traits_type::assign(*__d
, __c
);
416 traits_type::assign(__d
, __n
, __c
);
419 // _S_copy_chars is a separate template to permit specialization
420 // to optimize for the common case of pointers as iterators.
421 template<class _Iterator
>
423 _S_copy_chars(_CharT
* __p
, _Iterator __k1
, _Iterator __k2
)
425 for (; __k1
!= __k2
; ++__k1
, (void)++__p
)
426 traits_type::assign(*__p
, *__k1
); // These types are off.
430 _S_copy_chars(_CharT
* __p
, iterator __k1
, iterator __k2
) _GLIBCXX_NOEXCEPT
431 { _S_copy_chars(__p
, __k1
.base(), __k2
.base()); }
434 _S_copy_chars(_CharT
* __p
, const_iterator __k1
, const_iterator __k2
)
436 { _S_copy_chars(__p
, __k1
.base(), __k2
.base()); }
439 _S_copy_chars(_CharT
* __p
, _CharT
* __k1
, _CharT
* __k2
) _GLIBCXX_NOEXCEPT
440 { _M_copy(__p
, __k1
, __k2
- __k1
); }
443 _S_copy_chars(_CharT
* __p
, const _CharT
* __k1
, const _CharT
* __k2
)
445 { _M_copy(__p
, __k1
, __k2
- __k1
); }
448 _S_compare(size_type __n1
, size_type __n2
) _GLIBCXX_NOEXCEPT
450 const difference_type __d
= difference_type(__n1
- __n2
);
452 if (__d
> __gnu_cxx::__numeric_traits
<int>::__max
)
453 return __gnu_cxx::__numeric_traits
<int>::__max
;
454 else if (__d
< __gnu_cxx::__numeric_traits
<int>::__min
)
455 return __gnu_cxx::__numeric_traits
<int>::__min
;
461 _M_mutate(size_type __pos
, size_type __len1
, size_type __len2
);
467 _S_empty_rep() _GLIBCXX_NOEXCEPT
468 { return _Rep::_S_empty_rep(); }
470 #if __cplusplus >= 201703L
471 // A helper type for avoiding boiler-plate.
472 typedef basic_string_view
<_CharT
, _Traits
> __sv_type
;
474 template<typename _Tp
, typename _Res
>
475 using _If_sv
= enable_if_t
<
476 __and_
<is_convertible
<const _Tp
&, __sv_type
>,
477 __not_
<is_convertible
<const _Tp
*, const basic_string
*>>,
478 __not_
<is_convertible
<const _Tp
&, const _CharT
*>>>::value
,
481 // Allows an implicit conversion to __sv_type.
483 _S_to_string_view(__sv_type __svt
) noexcept
486 // Wraps a string_view by explicit conversion and thus
487 // allows to add an internal constructor that does not
488 // participate in overload resolution when a string_view
492 explicit __sv_wrapper(__sv_type __sv
) noexcept
: _M_sv(__sv
) { }
497 * @brief Only internally used: Construct string from a string view
499 * @param __svw string view wrapper.
500 * @param __a Allocator to use.
503 basic_string(__sv_wrapper __svw
, const _Alloc
& __a
)
504 : basic_string(__svw
._M_sv
.data(), __svw
._M_sv
.size(), __a
) { }
508 // Construct/copy/destroy:
509 // NB: We overload ctors in some cases instead of using default
510 // arguments, per 17.4.4.4 para. 2 item 2.
513 * @brief Default constructor creates an empty string.
516 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
519 #if __cpp_concepts && __glibcxx_type_trait_variable_templates
520 requires is_default_constructible_v
<_Alloc
>
522 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
523 : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc())
525 : _M_dataplus(_S_construct(size_type(), _CharT(), _Alloc()), _Alloc())
530 * @brief Construct an empty string using allocator @a a.
533 basic_string(const _Alloc
& __a
)
534 : _M_dataplus(_S_construct(size_type(), _CharT(), __a
), __a
)
537 // NB: per LWG issue 42, semantics different from IS:
539 * @brief Construct string with copy of value of @a str.
540 * @param __str Source string.
542 basic_string(const basic_string
& __str
)
543 : _M_dataplus(__str
._M_rep()->_M_grab(_Alloc(__str
.get_allocator()),
544 __str
.get_allocator()),
545 __str
.get_allocator())
548 // _GLIBCXX_RESOLVE_LIB_DEFECTS
549 // 2583. no way to supply an allocator for basic_string(str, pos)
551 * @brief Construct string as copy of a substring.
552 * @param __str Source string.
553 * @param __pos Index of first character to copy from.
554 * @param __a Allocator to use.
556 basic_string(const basic_string
& __str
, size_type __pos
,
557 const _Alloc
& __a
= _Alloc());
560 * @brief Construct string as copy of a substring.
561 * @param __str Source string.
562 * @param __pos Index of first character to copy from.
563 * @param __n Number of characters to copy.
565 basic_string(const basic_string
& __str
, size_type __pos
,
568 * @brief Construct string as copy of a substring.
569 * @param __str Source string.
570 * @param __pos Index of first character to copy from.
571 * @param __n Number of characters to copy.
572 * @param __a Allocator to use.
574 basic_string(const basic_string
& __str
, size_type __pos
,
575 size_type __n
, const _Alloc
& __a
);
578 * @brief Construct string initialized by a character %array.
579 * @param __s Source character %array.
580 * @param __n Number of characters to copy.
581 * @param __a Allocator to use (default is default allocator).
583 * NB: @a __s must have at least @a __n characters, '\\0'
584 * has no special meaning.
586 basic_string(const _CharT
* __s
, size_type __n
,
587 const _Alloc
& __a
= _Alloc())
588 : _M_dataplus(_S_construct(__s
, __s
+ __n
, __a
), __a
)
592 * @brief Construct string as copy of a C string.
593 * @param __s Source C string.
594 * @param __a Allocator to use (default is default allocator).
596 #if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
597 // _GLIBCXX_RESOLVE_LIB_DEFECTS
598 // 3076. basic_string CTAD ambiguity
599 template<typename
= _RequireAllocator
<_Alloc
>>
601 basic_string(const _CharT
* __s
, const _Alloc
& __a
= _Alloc())
602 : _M_dataplus(_S_construct(__s
, __s
? __s
+ traits_type::length(__s
) :
603 __s
+ npos
, __a
), __a
)
607 * @brief Construct string as multiple characters.
608 * @param __n Number of characters.
609 * @param __c Character to use.
610 * @param __a Allocator to use (default is default allocator).
612 basic_string(size_type __n
, _CharT __c
, const _Alloc
& __a
= _Alloc())
613 : _M_dataplus(_S_construct(__n
, __c
, __a
), __a
)
616 #if __cplusplus >= 201103L
618 * @brief Move construct string.
619 * @param __str Source string.
621 * The newly-created string contains the exact contents of @a __str.
622 * @a __str is a valid, but unspecified string.
624 basic_string(basic_string
&& __str
) noexcept
625 : _M_dataplus(std::move(__str
._M_dataplus
))
627 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
628 // Make __str use the shared empty string rep.
629 __str
._M_data(_S_empty_rep()._M_refdata());
631 // Rather than allocate an empty string for the rvalue string,
632 // just share ownership with it by incrementing the reference count.
633 // If the rvalue string was the unique owner then there are exactly
635 if (_M_rep()->_M_is_shared())
636 __gnu_cxx::__atomic_add_dispatch(&_M_rep()->_M_refcount
, 1);
638 _M_rep()->_M_refcount
= 1;
643 * @brief Construct string from an initializer %list.
644 * @param __l std::initializer_list of characters.
645 * @param __a Allocator to use (default is default allocator).
647 basic_string(initializer_list
<_CharT
> __l
, const _Alloc
& __a
= _Alloc())
648 : _M_dataplus(_S_construct(__l
.begin(), __l
.end(), __a
), __a
)
651 basic_string(const basic_string
& __str
, const _Alloc
& __a
)
652 : _M_dataplus(__str
._M_rep()->_M_grab(__a
, __str
.get_allocator()), __a
)
655 basic_string(basic_string
&& __str
, const _Alloc
& __a
)
656 : _M_dataplus(__str
._M_data(), __a
)
658 if (__a
== __str
.get_allocator())
660 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
661 __str
._M_data(_S_empty_rep()._M_refdata());
663 __str
._M_data(_S_construct(size_type(), _CharT(), __a
));
667 _M_dataplus
._M_p
= _S_construct(__str
.begin(), __str
.end(), __a
);
671 #if __cplusplus >= 202100L
672 basic_string(nullptr_t
) = delete;
673 basic_string
& operator=(nullptr_t
) = delete;
677 * @brief Construct string as copy of a range.
678 * @param __beg Start of range.
679 * @param __end End of range.
680 * @param __a Allocator to use (default is default allocator).
682 template<class _InputIterator
>
683 basic_string(_InputIterator __beg
, _InputIterator __end
,
684 const _Alloc
& __a
= _Alloc())
685 : _M_dataplus(_S_construct(__beg
, __end
, __a
), __a
)
688 #if __cplusplus >= 201703L
690 * @brief Construct string from a substring of a string_view.
691 * @param __t Source object convertible to string view.
692 * @param __pos The index of the first character to copy from __t.
693 * @param __n The number of characters to copy from __t.
694 * @param __a Allocator to use.
696 template<typename _Tp
,
697 typename
= enable_if_t
<is_convertible_v
<const _Tp
&, __sv_type
>>>
698 basic_string(const _Tp
& __t
, size_type __pos
, size_type __n
,
699 const _Alloc
& __a
= _Alloc())
700 : basic_string(_S_to_string_view(__t
).substr(__pos
, __n
), __a
) { }
703 * @brief Construct string from a string_view.
704 * @param __t Source object convertible to string view.
705 * @param __a Allocator to use (default is default allocator).
707 template<typename _Tp
, typename
= _If_sv
<_Tp
, void>>
709 basic_string(const _Tp
& __t
, const _Alloc
& __a
= _Alloc())
710 : basic_string(__sv_wrapper(_S_to_string_view(__t
)), __a
) { }
714 * @brief Destroy the string instance.
716 ~basic_string() _GLIBCXX_NOEXCEPT
717 { _M_rep()->_M_dispose(this->get_allocator()); }
720 * @brief Assign the value of @a str to this string.
721 * @param __str Source string.
724 operator=(const basic_string
& __str
)
725 { return this->assign(__str
); }
728 * @brief Copy contents of @a s into this string.
729 * @param __s Source null-terminated string.
732 operator=(const _CharT
* __s
)
733 { return this->assign(__s
); }
736 * @brief Set value to string of length 1.
737 * @param __c Source character.
739 * Assigning to a character makes this string length 1 and
740 * (*this)[0] == @a c.
743 operator=(_CharT __c
)
745 this->assign(1, __c
);
749 #if __cplusplus >= 201103L
751 * @brief Move assign the value of @a str to this string.
752 * @param __str Source string.
754 * The contents of @a str are moved into this string (without copying).
755 * @a str is a valid, but unspecified string.
758 operator=(basic_string
&& __str
)
759 _GLIBCXX_NOEXCEPT_IF(allocator_traits
<_Alloc
>::is_always_equal::value
)
767 * @brief Set value to string constructed from initializer %list.
768 * @param __l std::initializer_list.
771 operator=(initializer_list
<_CharT
> __l
)
773 this->assign(__l
.begin(), __l
.size());
778 #if __cplusplus >= 201703L
780 * @brief Set value to string constructed from a string_view.
781 * @param __svt An object convertible to string_view.
783 template<typename _Tp
>
784 _If_sv
<_Tp
, basic_string
&>
785 operator=(const _Tp
& __svt
)
786 { return this->assign(__svt
); }
789 * @brief Convert to a string_view.
790 * @return A string_view.
792 operator __sv_type() const noexcept
793 { return __sv_type(data(), size()); }
798 * Returns a read/write iterator that points to the first character in
799 * the %string. Unshares the string.
802 begin() // FIXME C++11: should be noexcept.
805 return iterator(_M_data());
809 * Returns a read-only (constant) iterator that points to the first
810 * character in the %string.
813 begin() const _GLIBCXX_NOEXCEPT
814 { return const_iterator(_M_data()); }
817 * Returns a read/write iterator that points one past the last
818 * character in the %string. Unshares the string.
821 end() // FIXME C++11: should be noexcept.
824 return iterator(_M_data() + this->size());
828 * Returns a read-only (constant) iterator that points one past the
829 * last character in the %string.
832 end() const _GLIBCXX_NOEXCEPT
833 { return const_iterator(_M_data() + this->size()); }
836 * Returns a read/write reverse iterator that points to the last
837 * character in the %string. Iteration is done in reverse element
838 * order. Unshares the string.
841 rbegin() // FIXME C++11: should be noexcept.
842 { return reverse_iterator(this->end()); }
845 * Returns a read-only (constant) reverse iterator that points
846 * to the last character in the %string. Iteration is done in
847 * reverse element order.
849 const_reverse_iterator
850 rbegin() const _GLIBCXX_NOEXCEPT
851 { return const_reverse_iterator(this->end()); }
854 * Returns a read/write reverse iterator that points to one before the
855 * first character in the %string. Iteration is done in reverse
856 * element order. Unshares the string.
859 rend() // FIXME C++11: should be noexcept.
860 { return reverse_iterator(this->begin()); }
863 * Returns a read-only (constant) reverse iterator that points
864 * to one before the first character in the %string. Iteration
865 * is done in reverse element order.
867 const_reverse_iterator
868 rend() const _GLIBCXX_NOEXCEPT
869 { return const_reverse_iterator(this->begin()); }
871 #if __cplusplus >= 201103L
873 * Returns a read-only (constant) iterator that points to the first
874 * character in the %string.
877 cbegin() const noexcept
878 { return const_iterator(this->_M_data()); }
881 * Returns a read-only (constant) iterator that points one past the
882 * last character in the %string.
885 cend() const noexcept
886 { return const_iterator(this->_M_data() + this->size()); }
889 * Returns a read-only (constant) reverse iterator that points
890 * to the last character in the %string. Iteration is done in
891 * reverse element order.
893 const_reverse_iterator
894 crbegin() const noexcept
895 { return const_reverse_iterator(this->end()); }
898 * Returns a read-only (constant) reverse iterator that points
899 * to one before the first character in the %string. Iteration
900 * is done in reverse element order.
902 const_reverse_iterator
903 crend() const noexcept
904 { return const_reverse_iterator(this->begin()); }
910 /// Returns the number of characters in the string, not including any
911 /// null-termination.
913 size() const _GLIBCXX_NOEXCEPT
915 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 && __OPTIMIZE__
916 if (_S_empty_rep()._M_length
!= 0)
917 __builtin_unreachable();
919 return _M_rep()->_M_length
;
922 /// Returns the number of characters in the string, not including any
923 /// null-termination.
925 length() const _GLIBCXX_NOEXCEPT
928 /// Returns the size() of the largest possible %string.
930 max_size() const _GLIBCXX_NOEXCEPT
931 { return _Rep::_S_max_size
; }
934 * @brief Resizes the %string to the specified number of characters.
935 * @param __n Number of characters the %string should contain.
936 * @param __c Character to fill any new elements.
938 * This function will %resize the %string to the specified
939 * number of characters. If the number is smaller than the
940 * %string's current size the %string is truncated, otherwise
941 * the %string is extended and new elements are %set to @a __c.
944 resize(size_type __n
, _CharT __c
);
947 * @brief Resizes the %string to the specified number of characters.
948 * @param __n Number of characters the %string should contain.
950 * This function will resize the %string to the specified length. If
951 * the new size is smaller than the %string's current size the %string
952 * is truncated, otherwise the %string is extended and new characters
953 * are default-constructed. For basic types such as char, this means
957 resize(size_type __n
)
958 { this->resize(__n
, _CharT()); }
960 #if __cplusplus >= 201103L
961 #pragma GCC diagnostic push
962 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
963 /// A non-binding request to reduce capacity() to size().
965 shrink_to_fit() noexcept
967 #pragma GCC diagnostic pop
970 #ifdef __glibcxx_string_resize_and_overwrite // C++ >= 23
971 /** Resize the string and call a function to fill it.
973 * @param __n The maximum size requested.
974 * @param __op A callable object that writes characters to the string.
976 * This is a low-level function that is easy to misuse, be careful.
978 * Calling `str.resize_and_overwrite(n, op)` will reserve at least `n`
979 * characters in `str`, evaluate `n2 = std::move(op)(str.data(), n)`,
980 * and finally set the string length to `n2` (adding a null terminator
981 * at the end). The function object `op` is allowed to write to the
982 * extra capacity added by the initial reserve operation, which is not
983 * allowed if you just call `str.reserve(n)` yourself.
985 * This can be used to efficiently fill a `string` buffer without the
986 * overhead of zero-initializing characters that will be overwritten
989 * The callable `op` must not access the string directly (only through
990 * the pointer passed as its first argument), must not write more than
991 * `n` characters to the string, must return a value no greater than `n`,
992 * and must ensure that all characters up to the returned length are
993 * valid after it returns (i.e. there must be no uninitialized values
994 * left in the string after the call, because accessing them would
995 * have undefined behaviour). If `op` exits by throwing an exception
996 * the behaviour is undefined.
1000 template<typename _Operation
>
1002 resize_and_overwrite(size_type __n
, _Operation __op
);
1003 #endif // __glibcxx_string_resize_and_overwrite
1005 #if __cplusplus >= 201103L
1006 /// Non-standard version of resize_and_overwrite for C++11 and above.
1007 template<typename _Operation
>
1009 __resize_and_overwrite(size_type __n
, _Operation __op
);
1013 * Returns the total number of characters that the %string can hold
1014 * before needing to allocate more memory.
1017 capacity() const _GLIBCXX_NOEXCEPT
1018 { return _M_rep()->_M_capacity
; }
1021 * @brief Attempt to preallocate enough memory for specified number of
1023 * @param __res_arg Number of characters required.
1024 * @throw std::length_error If @a __res_arg exceeds @c max_size().
1026 * This function attempts to reserve enough memory for the
1027 * %string to hold the specified number of characters. If the
1028 * number requested is more than max_size(), length_error is
1031 * The advantage of this function is that if optimal code is a
1032 * necessity and the user can determine the string length that will be
1033 * required, the user can reserve the memory in %advance, and thus
1034 * prevent a possible reallocation of memory and copying of %string
1038 reserve(size_type __res_arg
);
1040 /// Equivalent to shrink_to_fit().
1041 #if __cplusplus > 201703L
1042 [[deprecated("use shrink_to_fit() instead")]]
1048 * Erases the string, making it empty.
1050 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
1052 clear() _GLIBCXX_NOEXCEPT
1054 if (_M_rep()->_M_is_shared())
1056 _M_rep()->_M_dispose(this->get_allocator());
1057 _M_data(_S_empty_rep()._M_refdata());
1060 _M_rep()->_M_set_length_and_sharable(0);
1063 // PR 56166: this should not throw.
1066 { _M_mutate(0, this->size(), 0); }
1070 * Returns true if the %string is empty. Equivalent to
1071 * <code>*this == ""</code>.
1073 _GLIBCXX_NODISCARD
bool
1074 empty() const _GLIBCXX_NOEXCEPT
1075 { return this->size() == 0; }
1079 * @brief Subscript access to the data contained in the %string.
1080 * @param __pos The index of the character to access.
1081 * @return Read-only (constant) reference to the character.
1083 * This operator allows for easy, array-style, data access.
1084 * Note that data access with this operator is unchecked and
1085 * out_of_range lookups are not defined. (For checked lookups
1089 operator[] (size_type __pos
) const _GLIBCXX_NOEXCEPT
1091 __glibcxx_assert(__pos
<= size());
1092 return _M_data()[__pos
];
1096 * @brief Subscript access to the data contained in the %string.
1097 * @param __pos The index of the character to access.
1098 * @return Read/write reference to the character.
1100 * This operator allows for easy, array-style, data access.
1101 * Note that data access with this operator is unchecked and
1102 * out_of_range lookups are not defined. (For checked lookups
1103 * see at().) Unshares the string.
1106 operator[](size_type __pos
)
1108 // Allow pos == size() both in C++98 mode, as v3 extension,
1109 // and in C++11 mode.
1110 __glibcxx_assert(__pos
<= size());
1111 // In pedantic mode be strict in C++98 mode.
1112 _GLIBCXX_DEBUG_PEDASSERT(__cplusplus
>= 201103L || __pos
< size());
1114 return _M_data()[__pos
];
1118 * @brief Provides access to the data contained in the %string.
1119 * @param __n The index of the character to access.
1120 * @return Read-only (const) reference to the character.
1121 * @throw std::out_of_range If @a n is an invalid index.
1123 * This function provides for safer data access. The parameter is
1124 * first checked that it is in the range of the string. The function
1125 * throws out_of_range if the check fails.
1128 at(size_type __n
) const
1130 if (__n
>= this->size())
1131 __throw_out_of_range_fmt(__N("basic_string::at: __n "
1132 "(which is %zu) >= this->size() "
1135 return _M_data()[__n
];
1139 * @brief Provides access to the data contained in the %string.
1140 * @param __n The index of the character to access.
1141 * @return Read/write reference to the character.
1142 * @throw std::out_of_range If @a n is an invalid index.
1144 * This function provides for safer data access. The parameter is
1145 * first checked that it is in the range of the string. The function
1146 * throws out_of_range if the check fails. Success results in
1147 * unsharing the string.
1153 __throw_out_of_range_fmt(__N("basic_string::at: __n "
1154 "(which is %zu) >= this->size() "
1158 return _M_data()[__n
];
1161 #if __cplusplus >= 201103L
1163 * Returns a read/write reference to the data at the first
1164 * element of the %string.
1169 __glibcxx_assert(!empty());
1170 return operator[](0);
1174 * Returns a read-only (constant) reference to the data at the first
1175 * element of the %string.
1178 front() const noexcept
1180 __glibcxx_assert(!empty());
1181 return operator[](0);
1185 * Returns a read/write reference to the data at the last
1186 * element of the %string.
1191 __glibcxx_assert(!empty());
1192 return operator[](this->size() - 1);
1196 * Returns a read-only (constant) reference to the data at the
1197 * last element of the %string.
1200 back() const noexcept
1202 __glibcxx_assert(!empty());
1203 return operator[](this->size() - 1);
1209 * @brief Append a string to this string.
1210 * @param __str The string to append.
1211 * @return Reference to this string.
1214 operator+=(const basic_string
& __str
)
1215 { return this->append(__str
); }
1218 * @brief Append a C string.
1219 * @param __s The C string to append.
1220 * @return Reference to this string.
1223 operator+=(const _CharT
* __s
)
1224 { return this->append(__s
); }
1227 * @brief Append a character.
1228 * @param __c The character to append.
1229 * @return Reference to this string.
1232 operator+=(_CharT __c
)
1234 this->push_back(__c
);
1238 #if __cplusplus >= 201103L
1240 * @brief Append an initializer_list of characters.
1241 * @param __l The initializer_list of characters to be appended.
1242 * @return Reference to this string.
1245 operator+=(initializer_list
<_CharT
> __l
)
1246 { return this->append(__l
.begin(), __l
.size()); }
1249 #if __cplusplus >= 201703L
1251 * @brief Append a string_view.
1252 * @param __svt The object convertible to string_view to be appended.
1253 * @return Reference to this string.
1255 template<typename _Tp
>
1256 _If_sv
<_Tp
, basic_string
&>
1257 operator+=(const _Tp
& __svt
)
1258 { return this->append(__svt
); }
1262 * @brief Append a string to this string.
1263 * @param __str The string to append.
1264 * @return Reference to this string.
1267 append(const basic_string
& __str
);
1270 * @brief Append a substring.
1271 * @param __str The string to append.
1272 * @param __pos Index of the first character of str to append.
1273 * @param __n The number of characters to append.
1274 * @return Reference to this string.
1275 * @throw std::out_of_range if @a __pos is not a valid index.
1277 * This function appends @a __n characters from @a __str
1278 * starting at @a __pos to this string. If @a __n is is larger
1279 * than the number of available characters in @a __str, the
1280 * remainder of @a __str is appended.
1283 append(const basic_string
& __str
, size_type __pos
, size_type __n
= npos
);
1286 * @brief Append a C substring.
1287 * @param __s The C string to append.
1288 * @param __n The number of characters to append.
1289 * @return Reference to this string.
1292 append(const _CharT
* __s
, size_type __n
);
1295 * @brief Append a C string.
1296 * @param __s The C string to append.
1297 * @return Reference to this string.
1300 append(const _CharT
* __s
)
1302 __glibcxx_requires_string(__s
);
1303 return this->append(__s
, traits_type::length(__s
));
1307 * @brief Append multiple characters.
1308 * @param __n The number of characters to append.
1309 * @param __c The character to use.
1310 * @return Reference to this string.
1312 * Appends __n copies of __c to this string.
1315 append(size_type __n
, _CharT __c
);
1317 #if __cplusplus >= 201103L
1319 * @brief Append an initializer_list of characters.
1320 * @param __l The initializer_list of characters to append.
1321 * @return Reference to this string.
1324 append(initializer_list
<_CharT
> __l
)
1325 { return this->append(__l
.begin(), __l
.size()); }
1329 * @brief Append a range of characters.
1330 * @param __first Iterator referencing the first character to append.
1331 * @param __last Iterator marking the end of the range.
1332 * @return Reference to this string.
1334 * Appends characters in the range [__first,__last) to this string.
1336 template<class _InputIterator
>
1338 append(_InputIterator __first
, _InputIterator __last
)
1339 { return this->replace(_M_iend(), _M_iend(), __first
, __last
); }
1341 #if __cplusplus >= 201703L
1343 * @brief Append a string_view.
1344 * @param __svt The object convertible to string_view to be appended.
1345 * @return Reference to this string.
1347 template<typename _Tp
>
1348 _If_sv
<_Tp
, basic_string
&>
1349 append(const _Tp
& __svt
)
1351 __sv_type __sv
= __svt
;
1352 return this->append(__sv
.data(), __sv
.size());
1356 * @brief Append a range of characters from a string_view.
1357 * @param __svt The object convertible to string_view to be appended
1359 * @param __pos The position in the string_view to append from.
1360 * @param __n The number of characters to append from the string_view.
1361 * @return Reference to this string.
1363 template<typename _Tp
>
1364 _If_sv
<_Tp
, basic_string
&>
1365 append(const _Tp
& __svt
, size_type __pos
, size_type __n
= npos
)
1367 __sv_type __sv
= __svt
;
1368 return append(__sv
.data()
1369 + std::__sv_check(__sv
.size(), __pos
, "basic_string::append"),
1370 std::__sv_limit(__sv
.size(), __pos
, __n
));
1375 * @brief Append a single character.
1376 * @param __c Character to append.
1379 push_back(_CharT __c
)
1381 const size_type __len
= 1 + this->size();
1382 if (__len
> this->capacity() || _M_rep()->_M_is_shared())
1383 this->reserve(__len
);
1384 traits_type::assign(_M_data()[this->size()], __c
);
1385 _M_rep()->_M_set_length_and_sharable(__len
);
1389 * @brief Set value to contents of another string.
1390 * @param __str Source string to use.
1391 * @return Reference to this string.
1394 assign(const basic_string
& __str
);
1396 #if __cplusplus >= 201103L
1398 * @brief Set value to contents of another string.
1399 * @param __str Source string to use.
1400 * @return Reference to this string.
1402 * This function sets this string to the exact contents of @a __str.
1403 * @a __str is a valid, but unspecified string.
1406 assign(basic_string
&& __str
)
1407 noexcept(allocator_traits
<_Alloc
>::is_always_equal::value
)
1415 * @brief Set value to a substring of a string.
1416 * @param __str The string to use.
1417 * @param __pos Index of the first character of str.
1418 * @param __n Number of characters to use.
1419 * @return Reference to this string.
1420 * @throw std::out_of_range if @a pos is not a valid index.
1422 * This function sets this string to the substring of @a __str
1423 * consisting of @a __n characters at @a __pos. If @a __n is
1424 * is larger than the number of available characters in @a
1425 * __str, the remainder of @a __str is used.
1428 assign(const basic_string
& __str
, size_type __pos
, size_type __n
= npos
)
1429 { return this->assign(__str
._M_data()
1430 + __str
._M_check(__pos
, "basic_string::assign"),
1431 __str
._M_limit(__pos
, __n
)); }
1434 * @brief Set value to a C substring.
1435 * @param __s The C string to use.
1436 * @param __n Number of characters to use.
1437 * @return Reference to this string.
1439 * This function sets the value of this string to the first @a __n
1440 * characters of @a __s. If @a __n is is larger than the number of
1441 * available characters in @a __s, the remainder of @a __s is used.
1444 assign(const _CharT
* __s
, size_type __n
);
1447 * @brief Set value to contents of a C string.
1448 * @param __s The C string to use.
1449 * @return Reference to this string.
1451 * This function sets the value of this string to the value of @a __s.
1452 * The data is copied, so there is no dependence on @a __s once the
1456 assign(const _CharT
* __s
)
1458 __glibcxx_requires_string(__s
);
1459 return this->assign(__s
, traits_type::length(__s
));
1463 * @brief Set value to multiple characters.
1464 * @param __n Length of the resulting string.
1465 * @param __c The character to use.
1466 * @return Reference to this string.
1468 * This function sets the value of this string to @a __n copies of
1472 assign(size_type __n
, _CharT __c
)
1473 { return _M_replace_aux(size_type(0), this->size(), __n
, __c
); }
1476 * @brief Set value to a range of characters.
1477 * @param __first Iterator referencing the first character to append.
1478 * @param __last Iterator marking the end of the range.
1479 * @return Reference to this string.
1481 * Sets value of string to characters in the range [__first,__last).
1483 template<class _InputIterator
>
1485 assign(_InputIterator __first
, _InputIterator __last
)
1486 { return this->replace(_M_ibegin(), _M_iend(), __first
, __last
); }
1488 #if __cplusplus >= 201103L
1490 * @brief Set value to an initializer_list of characters.
1491 * @param __l The initializer_list of characters to assign.
1492 * @return Reference to this string.
1495 assign(initializer_list
<_CharT
> __l
)
1496 { return this->assign(__l
.begin(), __l
.size()); }
1499 #if __cplusplus >= 201703L
1501 * @brief Set value from a string_view.
1502 * @param __svt The source object convertible to string_view.
1503 * @return Reference to this string.
1505 template<typename _Tp
>
1506 _If_sv
<_Tp
, basic_string
&>
1507 assign(const _Tp
& __svt
)
1509 __sv_type __sv
= __svt
;
1510 return this->assign(__sv
.data(), __sv
.size());
1514 * @brief Set value from a range of characters in a string_view.
1515 * @param __svt The source object convertible to string_view.
1516 * @param __pos The position in the string_view to assign from.
1517 * @param __n The number of characters to assign.
1518 * @return Reference to this string.
1520 template<typename _Tp
>
1521 _If_sv
<_Tp
, basic_string
&>
1522 assign(const _Tp
& __svt
, size_type __pos
, size_type __n
= npos
)
1524 __sv_type __sv
= __svt
;
1525 return assign(__sv
.data()
1526 + std::__sv_check(__sv
.size(), __pos
, "basic_string::assign"),
1527 std::__sv_limit(__sv
.size(), __pos
, __n
));
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().
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.
1545 insert(iterator __p
, size_type __n
, _CharT __c
)
1546 { this->replace(__p
, __p
, __n
, __c
); }
1549 * @brief Insert a range of characters.
1550 * @param __p Iterator referencing location in string to insert at.
1551 * @param __beg Start of range.
1552 * @param __end End of range.
1553 * @throw std::length_error If new length exceeds @c max_size().
1555 * Inserts characters in range [__beg,__end). If adding
1556 * characters causes the length to exceed max_size(),
1557 * length_error is thrown. The value of the string doesn't
1558 * change if an error is thrown.
1560 template<class _InputIterator
>
1562 insert(iterator __p
, _InputIterator __beg
, _InputIterator __end
)
1563 { this->replace(__p
, __p
, __beg
, __end
); }
1565 #if __cplusplus >= 201103L
1567 * @brief Insert an initializer_list of characters.
1568 * @param __p Iterator referencing location in string to insert at.
1569 * @param __l The initializer_list of characters to insert.
1570 * @throw std::length_error If new length exceeds @c max_size().
1573 insert(iterator __p
, initializer_list
<_CharT
> __l
)
1575 _GLIBCXX_DEBUG_PEDASSERT(__p
>= _M_ibegin() && __p
<= _M_iend());
1576 this->insert(__p
- _M_ibegin(), __l
.begin(), __l
.size());
1581 * @brief Insert value of a string.
1582 * @param __pos1 Position in string to insert at.
1583 * @param __str The string to insert.
1584 * @return Reference to this string.
1585 * @throw std::length_error If new length exceeds @c max_size().
1587 * Inserts value of @a __str starting at @a __pos1. If adding
1588 * characters causes the length to exceed max_size(),
1589 * length_error is thrown. The value of the string doesn't
1590 * change if an error is thrown.
1593 insert(size_type __pos1
, const basic_string
& __str
)
1594 { return this->insert(__pos1
, __str
, size_type(0), __str
.size()); }
1597 * @brief Insert a substring.
1598 * @param __pos1 Position in string to insert at.
1599 * @param __str The string to insert.
1600 * @param __pos2 Start of characters in str to insert.
1601 * @param __n Number of characters to insert.
1602 * @return Reference to this string.
1603 * @throw std::length_error If new length exceeds @c max_size().
1604 * @throw std::out_of_range If @a pos1 > size() or
1605 * @a __pos2 > @a str.size().
1607 * Starting at @a pos1, insert @a __n character of @a __str
1608 * beginning with @a __pos2. If adding characters causes the
1609 * length to exceed max_size(), length_error is thrown. If @a
1610 * __pos1 is beyond the end of this string or @a __pos2 is
1611 * beyond the end of @a __str, out_of_range is thrown. The
1612 * value of the string doesn't change if an error is thrown.
1615 insert(size_type __pos1
, const basic_string
& __str
,
1616 size_type __pos2
, size_type __n
= npos
)
1617 { return this->insert(__pos1
, __str
._M_data()
1618 + __str
._M_check(__pos2
, "basic_string::insert"),
1619 __str
._M_limit(__pos2
, __n
)); }
1622 * @brief Insert a C substring.
1623 * @param __pos Position in string to insert at.
1624 * @param __s The C string to insert.
1625 * @param __n The number of characters to insert.
1626 * @return Reference to this string.
1627 * @throw std::length_error If new length exceeds @c max_size().
1628 * @throw std::out_of_range If @a __pos is beyond the end of this
1631 * Inserts the first @a __n characters of @a __s starting at @a
1632 * __pos. If adding characters causes the length to exceed
1633 * max_size(), length_error is thrown. If @a __pos is beyond
1634 * end(), out_of_range is thrown. The value of the string
1635 * doesn't change if an error is thrown.
1638 insert(size_type __pos
, const _CharT
* __s
, size_type __n
);
1641 * @brief Insert a C string.
1642 * @param __pos Position in string to insert at.
1643 * @param __s The C string to insert.
1644 * @return Reference to this string.
1645 * @throw std::length_error If new length exceeds @c max_size().
1646 * @throw std::out_of_range If @a pos is beyond the end of this
1649 * Inserts the first @a n characters of @a __s starting at @a __pos. If
1650 * adding characters causes the length to exceed max_size(),
1651 * length_error is thrown. If @a __pos is beyond end(), out_of_range is
1652 * thrown. The value of the string doesn't change if an error is
1656 insert(size_type __pos
, const _CharT
* __s
)
1658 __glibcxx_requires_string(__s
);
1659 return this->insert(__pos
, __s
, traits_type::length(__s
));
1663 * @brief Insert multiple characters.
1664 * @param __pos Index in string to insert at.
1665 * @param __n Number of characters to insert
1666 * @param __c The character to insert.
1667 * @return Reference to this string.
1668 * @throw std::length_error If new length exceeds @c max_size().
1669 * @throw std::out_of_range If @a __pos is beyond the end of this
1672 * Inserts @a __n copies of character @a __c starting at index
1673 * @a __pos. If adding characters causes the length to exceed
1674 * max_size(), length_error is thrown. If @a __pos > length(),
1675 * out_of_range is thrown. The value of the string doesn't
1676 * change if an error is thrown.
1679 insert(size_type __pos
, size_type __n
, _CharT __c
)
1680 { return _M_replace_aux(_M_check(__pos
, "basic_string::insert"),
1681 size_type(0), __n
, __c
); }
1684 * @brief Insert one character.
1685 * @param __p Iterator referencing position in string to insert at.
1686 * @param __c The character to insert.
1687 * @return Iterator referencing newly inserted char.
1688 * @throw std::length_error If new length exceeds @c max_size().
1690 * Inserts character @a __c at position referenced by @a __p.
1691 * If adding character causes the length to exceed max_size(),
1692 * length_error is thrown. If @a __p is beyond end of string,
1693 * out_of_range is thrown. The value of the string doesn't
1694 * change if an error is thrown.
1697 insert(iterator __p
, _CharT __c
)
1699 _GLIBCXX_DEBUG_PEDASSERT(__p
>= _M_ibegin() && __p
<= _M_iend());
1700 const size_type __pos
= __p
- _M_ibegin();
1701 _M_replace_aux(__pos
, size_type(0), size_type(1), __c
);
1702 _M_rep()->_M_set_leaked();
1703 return iterator(_M_data() + __pos
);
1706 #if __cplusplus >= 201703L
1708 * @brief Insert a string_view.
1709 * @param __pos Position in string to insert at.
1710 * @param __svt The object convertible to string_view to insert.
1711 * @return Reference to this string.
1713 template<typename _Tp
>
1714 _If_sv
<_Tp
, basic_string
&>
1715 insert(size_type __pos
, const _Tp
& __svt
)
1717 __sv_type __sv
= __svt
;
1718 return this->insert(__pos
, __sv
.data(), __sv
.size());
1722 * @brief Insert a string_view.
1723 * @param __pos1 Position in string to insert at.
1724 * @param __svt The object convertible to string_view to insert from.
1725 * @param __pos2 Position in string_view to insert from.
1726 * @param __n The number of characters to insert.
1727 * @return Reference to this string.
1729 template<typename _Tp
>
1730 _If_sv
<_Tp
, basic_string
&>
1731 insert(size_type __pos1
, const _Tp
& __svt
,
1732 size_type __pos2
, size_type __n
= npos
)
1734 __sv_type __sv
= __svt
;
1735 return this->replace(__pos1
, size_type(0), __sv
.data()
1736 + std::__sv_check(__sv
.size(), __pos2
, "basic_string::insert"),
1737 std::__sv_limit(__sv
.size(), __pos2
, __n
));
1742 * @brief Remove characters.
1743 * @param __pos Index of first character to remove (default 0).
1744 * @param __n Number of characters to remove (default remainder).
1745 * @return Reference to this string.
1746 * @throw std::out_of_range If @a pos is beyond the end of this
1749 * Removes @a __n characters from this string starting at @a
1750 * __pos. The length of the string is reduced by @a __n. If
1751 * there are < @a __n characters to remove, the remainder of
1752 * the string is truncated. If @a __p is beyond end of string,
1753 * out_of_range is thrown. The value of the string doesn't
1754 * change if an error is thrown.
1757 erase(size_type __pos
= 0, size_type __n
= npos
)
1759 _M_mutate(_M_check(__pos
, "basic_string::erase"),
1760 _M_limit(__pos
, __n
), size_type(0));
1765 * @brief Remove one character.
1766 * @param __position Iterator referencing the character to remove.
1767 * @return iterator referencing same location after removal.
1769 * Removes the character at @a __position from this string. The value
1770 * of the string doesn't change if an error is thrown.
1773 erase(iterator __position
)
1775 _GLIBCXX_DEBUG_PEDASSERT(__position
>= _M_ibegin()
1776 && __position
< _M_iend());
1777 const size_type __pos
= __position
- _M_ibegin();
1778 _M_mutate(__pos
, size_type(1), size_type(0));
1779 _M_rep()->_M_set_leaked();
1780 return iterator(_M_data() + __pos
);
1784 * @brief Remove a range of characters.
1785 * @param __first Iterator referencing the first character to remove.
1786 * @param __last Iterator referencing the end of the range.
1787 * @return Iterator referencing location of first after removal.
1789 * Removes the characters in the range [first,last) from this string.
1790 * The value of the string doesn't change if an error is thrown.
1793 erase(iterator __first
, iterator __last
);
1795 #if __cplusplus >= 201103L
1797 * @brief Remove the last character.
1799 * The string must be non-empty.
1802 pop_back() // FIXME C++11: should be noexcept.
1804 __glibcxx_assert(!empty());
1805 erase(size() - 1, 1);
1810 * @brief Replace characters with value from another string.
1811 * @param __pos Index of first character to replace.
1812 * @param __n Number of characters to be replaced.
1813 * @param __str String to insert.
1814 * @return Reference to this string.
1815 * @throw std::out_of_range If @a pos is beyond the end of this
1817 * @throw std::length_error If new length exceeds @c max_size().
1819 * Removes the characters in the range [__pos,__pos+__n) from
1820 * this string. In place, the value of @a __str is inserted.
1821 * If @a __pos is beyond end of string, out_of_range is thrown.
1822 * If the length of the result exceeds max_size(), length_error
1823 * is thrown. The value of the string doesn't change if an
1827 replace(size_type __pos
, size_type __n
, const basic_string
& __str
)
1828 { return this->replace(__pos
, __n
, __str
._M_data(), __str
.size()); }
1831 * @brief Replace characters with value from another string.
1832 * @param __pos1 Index of first character to replace.
1833 * @param __n1 Number of characters to be replaced.
1834 * @param __str String to insert.
1835 * @param __pos2 Index of first character of str to use.
1836 * @param __n2 Number of characters from str to use.
1837 * @return Reference to this string.
1838 * @throw std::out_of_range If @a __pos1 > size() or @a __pos2 >
1840 * @throw std::length_error If new length exceeds @c max_size().
1842 * Removes the characters in the range [__pos1,__pos1 + n) from this
1843 * string. In place, the value of @a __str is inserted. If @a __pos is
1844 * beyond end of string, out_of_range is thrown. If the length of the
1845 * result exceeds max_size(), length_error is thrown. The value of the
1846 * string doesn't change if an error is thrown.
1849 replace(size_type __pos1
, size_type __n1
, const basic_string
& __str
,
1850 size_type __pos2
, size_type __n2
= npos
)
1851 { return this->replace(__pos1
, __n1
, __str
._M_data()
1852 + __str
._M_check(__pos2
, "basic_string::replace"),
1853 __str
._M_limit(__pos2
, __n2
)); }
1856 * @brief Replace characters with value of a C substring.
1857 * @param __pos Index of first character to replace.
1858 * @param __n1 Number of characters to be replaced.
1859 * @param __s C string to insert.
1860 * @param __n2 Number of characters from @a s to use.
1861 * @return Reference to this string.
1862 * @throw std::out_of_range If @a pos1 > size().
1863 * @throw std::length_error If new length exceeds @c max_size().
1865 * Removes the characters in the range [__pos,__pos + __n1)
1866 * from this string. In place, the first @a __n2 characters of
1867 * @a __s are inserted, or all of @a __s if @a __n2 is too large. If
1868 * @a __pos is beyond end of string, out_of_range is thrown. If
1869 * the length of result exceeds max_size(), length_error is
1870 * thrown. The value of the string doesn't change if an error
1874 replace(size_type __pos
, size_type __n1
, const _CharT
* __s
,
1878 * @brief Replace characters with value of a C string.
1879 * @param __pos Index of first character to replace.
1880 * @param __n1 Number of characters to be replaced.
1881 * @param __s C string to insert.
1882 * @return Reference to this string.
1883 * @throw std::out_of_range If @a pos > size().
1884 * @throw std::length_error If new length exceeds @c max_size().
1886 * Removes the characters in the range [__pos,__pos + __n1)
1887 * from this string. In place, the characters of @a __s are
1888 * inserted. If @a __pos is beyond end of string, out_of_range
1889 * is thrown. If the length of result exceeds max_size(),
1890 * length_error is thrown. The value of the string doesn't
1891 * change if an error is thrown.
1894 replace(size_type __pos
, size_type __n1
, const _CharT
* __s
)
1896 __glibcxx_requires_string(__s
);
1897 return this->replace(__pos
, __n1
, __s
, traits_type::length(__s
));
1901 * @brief Replace characters with multiple characters.
1902 * @param __pos Index of first character to replace.
1903 * @param __n1 Number of characters to be replaced.
1904 * @param __n2 Number of characters to insert.
1905 * @param __c Character to insert.
1906 * @return Reference to this string.
1907 * @throw std::out_of_range If @a __pos > size().
1908 * @throw std::length_error If new length exceeds @c max_size().
1910 * Removes the characters in the range [pos,pos + n1) from this
1911 * string. In place, @a __n2 copies of @a __c are inserted.
1912 * If @a __pos is beyond end of string, out_of_range is thrown.
1913 * If the length of result exceeds max_size(), length_error is
1914 * thrown. The value of the string doesn't change if an error
1918 replace(size_type __pos
, size_type __n1
, size_type __n2
, _CharT __c
)
1919 { return _M_replace_aux(_M_check(__pos
, "basic_string::replace"),
1920 _M_limit(__pos
, __n1
), __n2
, __c
); }
1923 * @brief Replace range of characters with string.
1924 * @param __i1 Iterator referencing start of range to replace.
1925 * @param __i2 Iterator referencing end of range to replace.
1926 * @param __str String value to insert.
1927 * @return Reference to this string.
1928 * @throw std::length_error If new length exceeds @c max_size().
1930 * Removes the characters in the range [__i1,__i2). In place,
1931 * the value of @a __str is inserted. If the length of result
1932 * exceeds max_size(), length_error is thrown. The value of
1933 * the string doesn't change if an error is thrown.
1936 replace(iterator __i1
, iterator __i2
, const basic_string
& __str
)
1937 { return this->replace(__i1
, __i2
, __str
._M_data(), __str
.size()); }
1940 * @brief Replace range of characters with C substring.
1941 * @param __i1 Iterator referencing start of range to replace.
1942 * @param __i2 Iterator referencing end of range to replace.
1943 * @param __s C string value to insert.
1944 * @param __n Number of characters from s to insert.
1945 * @return Reference to this string.
1946 * @throw std::length_error If new length exceeds @c max_size().
1948 * Removes the characters in the range [__i1,__i2). In place,
1949 * the first @a __n characters of @a __s are inserted. If the
1950 * length of result exceeds max_size(), length_error is thrown.
1951 * The value of the string doesn't change if an error is
1955 replace(iterator __i1
, iterator __i2
, const _CharT
* __s
, size_type __n
)
1957 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1
&& __i1
<= __i2
1958 && __i2
<= _M_iend());
1959 return this->replace(__i1
- _M_ibegin(), __i2
- __i1
, __s
, __n
);
1963 * @brief Replace range of characters with C string.
1964 * @param __i1 Iterator referencing start of range to replace.
1965 * @param __i2 Iterator referencing end of range to replace.
1966 * @param __s C string value to insert.
1967 * @return Reference to this string.
1968 * @throw std::length_error If new length exceeds @c max_size().
1970 * Removes the characters in the range [__i1,__i2). In place,
1971 * the characters of @a __s are inserted. If the length of
1972 * result exceeds max_size(), length_error is thrown. The
1973 * value of the string doesn't change if an error is thrown.
1976 replace(iterator __i1
, iterator __i2
, const _CharT
* __s
)
1978 __glibcxx_requires_string(__s
);
1979 return this->replace(__i1
, __i2
, __s
, traits_type::length(__s
));
1983 * @brief Replace range of characters with multiple characters
1984 * @param __i1 Iterator referencing start of range to replace.
1985 * @param __i2 Iterator referencing end of range to replace.
1986 * @param __n Number of characters to insert.
1987 * @param __c Character to insert.
1988 * @return Reference to this string.
1989 * @throw std::length_error If new length exceeds @c max_size().
1991 * Removes the characters in the range [__i1,__i2). In place,
1992 * @a __n copies of @a __c are inserted. If the length of
1993 * result exceeds max_size(), length_error is thrown. The
1994 * value of the string doesn't change if an error is thrown.
1997 replace(iterator __i1
, iterator __i2
, size_type __n
, _CharT __c
)
1999 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1
&& __i1
<= __i2
2000 && __i2
<= _M_iend());
2001 return _M_replace_aux(__i1
- _M_ibegin(), __i2
- __i1
, __n
, __c
);
2005 * @brief Replace range of characters with range.
2006 * @param __i1 Iterator referencing start of range to replace.
2007 * @param __i2 Iterator referencing end of range to replace.
2008 * @param __k1 Iterator referencing start of range to insert.
2009 * @param __k2 Iterator referencing end of range to insert.
2010 * @return Reference to this string.
2011 * @throw std::length_error If new length exceeds @c max_size().
2013 * Removes the characters in the range [__i1,__i2). In place,
2014 * characters in the range [__k1,__k2) are inserted. If the
2015 * length of result exceeds max_size(), length_error is thrown.
2016 * The value of the string doesn't change if an error is
2019 template<class _InputIterator
>
2021 replace(iterator __i1
, iterator __i2
,
2022 _InputIterator __k1
, _InputIterator __k2
)
2024 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1
&& __i1
<= __i2
2025 && __i2
<= _M_iend());
2026 __glibcxx_requires_valid_range(__k1
, __k2
);
2027 typedef typename
std::__is_integer
<_InputIterator
>::__type _Integral
;
2028 return _M_replace_dispatch(__i1
, __i2
, __k1
, __k2
, _Integral());
2031 // Specializations for the common case of pointer and iterator:
2032 // useful to avoid the overhead of temporary buffering in _M_replace.
2034 replace(iterator __i1
, iterator __i2
, _CharT
* __k1
, _CharT
* __k2
)
2036 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1
&& __i1
<= __i2
2037 && __i2
<= _M_iend());
2038 __glibcxx_requires_valid_range(__k1
, __k2
);
2039 return this->replace(__i1
- _M_ibegin(), __i2
- __i1
,
2044 replace(iterator __i1
, iterator __i2
,
2045 const _CharT
* __k1
, const _CharT
* __k2
)
2047 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1
&& __i1
<= __i2
2048 && __i2
<= _M_iend());
2049 __glibcxx_requires_valid_range(__k1
, __k2
);
2050 return this->replace(__i1
- _M_ibegin(), __i2
- __i1
,
2055 replace(iterator __i1
, iterator __i2
, iterator __k1
, iterator __k2
)
2057 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1
&& __i1
<= __i2
2058 && __i2
<= _M_iend());
2059 __glibcxx_requires_valid_range(__k1
, __k2
);
2060 return this->replace(__i1
- _M_ibegin(), __i2
- __i1
,
2061 __k1
.base(), __k2
- __k1
);
2065 replace(iterator __i1
, iterator __i2
,
2066 const_iterator __k1
, const_iterator __k2
)
2068 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1
&& __i1
<= __i2
2069 && __i2
<= _M_iend());
2070 __glibcxx_requires_valid_range(__k1
, __k2
);
2071 return this->replace(__i1
- _M_ibegin(), __i2
- __i1
,
2072 __k1
.base(), __k2
- __k1
);
2075 #if __cplusplus >= 201103L
2077 * @brief Replace range of characters with initializer_list.
2078 * @param __i1 Iterator referencing start of range to replace.
2079 * @param __i2 Iterator referencing end of range to replace.
2080 * @param __l The initializer_list of characters to insert.
2081 * @return Reference to this string.
2082 * @throw std::length_error If new length exceeds @c max_size().
2084 * Removes the characters in the range [__i1,__i2). In place,
2085 * characters in the range [__k1,__k2) are inserted. If the
2086 * length of result exceeds max_size(), length_error is thrown.
2087 * The value of the string doesn't change if an error is
2090 basic_string
& replace(iterator __i1
, iterator __i2
,
2091 initializer_list
<_CharT
> __l
)
2092 { return this->replace(__i1
, __i2
, __l
.begin(), __l
.end()); }
2095 #if __cplusplus >= 201703L
2097 * @brief Replace range of characters with string_view.
2098 * @param __pos The position to replace at.
2099 * @param __n The number of characters to replace.
2100 * @param __svt The object convertible to string_view to insert.
2101 * @return Reference to this string.
2103 template<typename _Tp
>
2104 _If_sv
<_Tp
, basic_string
&>
2105 replace(size_type __pos
, size_type __n
, const _Tp
& __svt
)
2107 __sv_type __sv
= __svt
;
2108 return this->replace(__pos
, __n
, __sv
.data(), __sv
.size());
2112 * @brief Replace range of characters with string_view.
2113 * @param __pos1 The position to replace at.
2114 * @param __n1 The number of characters to replace.
2115 * @param __svt The object convertible to string_view to insert from.
2116 * @param __pos2 The position in the string_view to insert from.
2117 * @param __n2 The number of characters to insert.
2118 * @return Reference to this string.
2120 template<typename _Tp
>
2121 _If_sv
<_Tp
, basic_string
&>
2122 replace(size_type __pos1
, size_type __n1
, const _Tp
& __svt
,
2123 size_type __pos2
, size_type __n2
= npos
)
2125 __sv_type __sv
= __svt
;
2126 return this->replace(__pos1
, __n1
,
2128 + std::__sv_check(__sv
.size(), __pos2
, "basic_string::replace"),
2129 std::__sv_limit(__sv
.size(), __pos2
, __n2
));
2133 * @brief Replace range of characters with string_view.
2134 * @param __i1 An iterator referencing the start position
2136 * @param __i2 An iterator referencing the end position
2138 * @param __svt The object convertible to string_view to insert from.
2139 * @return Reference to this string.
2141 template<typename _Tp
>
2142 _If_sv
<_Tp
, basic_string
&>
2143 replace(const_iterator __i1
, const_iterator __i2
, const _Tp
& __svt
)
2145 __sv_type __sv
= __svt
;
2146 return this->replace(__i1
- begin(), __i2
- __i1
, __sv
);
2151 template<class _Integer
>
2153 _M_replace_dispatch(iterator __i1
, iterator __i2
, _Integer __n
,
2154 _Integer __val
, __true_type
)
2155 { return _M_replace_aux(__i1
- _M_ibegin(), __i2
- __i1
, __n
, __val
); }
2157 template<class _InputIterator
>
2159 _M_replace_dispatch(iterator __i1
, iterator __i2
, _InputIterator __k1
,
2160 _InputIterator __k2
, __false_type
);
2163 _M_replace_aux(size_type __pos1
, size_type __n1
, size_type __n2
,
2167 _M_replace_safe(size_type __pos1
, size_type __n1
, const _CharT
* __s
,
2170 // _S_construct_aux is used to implement the 21.3.1 para 15 which
2171 // requires special behaviour if _InIter is an integral type
2172 template<class _InIterator
>
2174 _S_construct_aux(_InIterator __beg
, _InIterator __end
,
2175 const _Alloc
& __a
, __false_type
)
2177 typedef typename iterator_traits
<_InIterator
>::iterator_category _Tag
;
2178 return _S_construct(__beg
, __end
, __a
, _Tag());
2181 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2182 // 438. Ambiguity in the "do the right thing" clause
2183 template<class _Integer
>
2185 _S_construct_aux(_Integer __beg
, _Integer __end
,
2186 const _Alloc
& __a
, __true_type
)
2187 { return _S_construct_aux_2(static_cast<size_type
>(__beg
),
2191 _S_construct_aux_2(size_type __req
, _CharT __c
, const _Alloc
& __a
)
2192 { return _S_construct(__req
, __c
, __a
); }
2194 template<class _InIterator
>
2196 _S_construct(_InIterator __beg
, _InIterator __end
, const _Alloc
& __a
)
2198 typedef typename
std::__is_integer
<_InIterator
>::__type _Integral
;
2199 return _S_construct_aux(__beg
, __end
, __a
, _Integral());
2202 // For Input Iterators, used in istreambuf_iterators, etc.
2203 template<class _InIterator
>
2205 _S_construct(_InIterator __beg
, _InIterator __end
, const _Alloc
& __a
,
2206 input_iterator_tag
);
2208 // For forward_iterators up to random_access_iterators, used for
2209 // string::iterator, _CharT*, etc.
2210 template<class _FwdIterator
>
2212 _S_construct(_FwdIterator __beg
, _FwdIterator __end
, const _Alloc
& __a
,
2213 forward_iterator_tag
);
2216 _S_construct(size_type __req
, _CharT __c
, const _Alloc
& __a
);
2221 * @brief Copy substring into C string.
2222 * @param __s C string to copy value into.
2223 * @param __n Number of characters to copy.
2224 * @param __pos Index of first character to copy.
2225 * @return Number of characters actually copied
2226 * @throw std::out_of_range If __pos > size().
2228 * Copies up to @a __n characters starting at @a __pos into the
2229 * C string @a __s. If @a __pos is %greater than size(),
2230 * out_of_range is thrown.
2233 copy(_CharT
* __s
, size_type __n
, size_type __pos
= 0) const;
2236 * @brief Swap contents with another string.
2237 * @param __s String to swap with.
2239 * Exchanges the contents of this string with that of @a __s in constant
2243 swap(basic_string
& __s
)
2244 _GLIBCXX_NOEXCEPT_IF(allocator_traits
<_Alloc
>::is_always_equal::value
);
2246 // String operations:
2248 * @brief Return const pointer to null-terminated contents.
2250 * This is a handle to internal data. Do not modify or dire things may
2254 c_str() const _GLIBCXX_NOEXCEPT
2255 { return _M_data(); }
2258 * @brief Return const pointer to contents.
2260 * This is a pointer to internal data. It is undefined to modify
2261 * the contents through the returned pointer. To get a pointer that
2262 * allows modifying the contents use @c &str[0] instead,
2263 * (or in C++17 the non-const @c str.data() overload).
2266 data() const _GLIBCXX_NOEXCEPT
2267 { return _M_data(); }
2269 #if __cplusplus >= 201703L
2271 * @brief Return non-const pointer to contents.
2273 * This is a pointer to the character sequence held by the string.
2274 * Modifying the characters in the sequence is allowed.
2276 * The standard requires this function to be `noexcept` but for the
2277 * Copy-On-Write string implementation it can throw. This function
2278 * allows modifying the string contents directly, which means we
2279 * must copy-on-write to unshare it, which requires allocating memory.
2282 data() noexcept(false)
2290 * @brief Return copy of allocator used to construct this string.
2293 get_allocator() const _GLIBCXX_NOEXCEPT
2294 { return _M_dataplus
; }
2297 * @brief Find position of a C substring.
2298 * @param __s C string to locate.
2299 * @param __pos Index of character to search from.
2300 * @param __n Number of characters from @a s to search for.
2301 * @return Index of start of first occurrence.
2303 * Starting from @a __pos, searches forward for the first @a
2304 * __n characters in @a __s within this string. If found,
2305 * returns the index where it begins. If not found, returns
2309 find(const _CharT
* __s
, size_type __pos
, size_type __n
) const
2313 * @brief Find position of a string.
2314 * @param __str String to locate.
2315 * @param __pos Index of character to search from (default 0).
2316 * @return Index of start of first occurrence.
2318 * Starting from @a __pos, searches forward for value of @a __str within
2319 * this string. If found, returns the index where it begins. If not
2320 * found, returns npos.
2323 find(const basic_string
& __str
, size_type __pos
= 0) const
2325 { return this->find(__str
.data(), __pos
, __str
.size()); }
2328 * @brief Find position of a C string.
2329 * @param __s C string to locate.
2330 * @param __pos Index of character to search from (default 0).
2331 * @return Index of start of first occurrence.
2333 * Starting from @a __pos, searches forward for the value of @a
2334 * __s within this string. If found, returns the index where
2335 * it begins. If not found, returns npos.
2338 find(const _CharT
* __s
, size_type __pos
= 0) const _GLIBCXX_NOEXCEPT
2340 __glibcxx_requires_string(__s
);
2341 return this->find(__s
, __pos
, traits_type::length(__s
));
2345 * @brief Find position of a character.
2346 * @param __c Character to locate.
2347 * @param __pos Index of character to search from (default 0).
2348 * @return Index of first occurrence.
2350 * Starting from @a __pos, searches forward for @a __c within
2351 * this string. If found, returns the index where it was
2352 * found. If not found, returns npos.
2355 find(_CharT __c
, size_type __pos
= 0) const _GLIBCXX_NOEXCEPT
;
2357 #if __cplusplus >= 201703L
2359 * @brief Find position of a string_view.
2360 * @param __svt The object convertible to string_view to locate.
2361 * @param __pos Index of character to search from (default 0).
2362 * @return Index of start of first occurrence.
2364 template<typename _Tp
>
2365 _If_sv
<_Tp
, size_type
>
2366 find(const _Tp
& __svt
, size_type __pos
= 0) const
2367 noexcept(is_same
<_Tp
, __sv_type
>::value
)
2369 __sv_type __sv
= __svt
;
2370 return this->find(__sv
.data(), __pos
, __sv
.size());
2375 * @brief Find last position of a string.
2376 * @param __str String to locate.
2377 * @param __pos Index of character to search back from (default end).
2378 * @return Index of start of last occurrence.
2380 * Starting from @a __pos, searches backward for value of @a
2381 * __str within this string. If found, returns the index where
2382 * it begins. If not found, returns npos.
2385 rfind(const basic_string
& __str
, size_type __pos
= npos
) const
2387 { return this->rfind(__str
.data(), __pos
, __str
.size()); }
2390 * @brief Find last position of a C substring.
2391 * @param __s C string to locate.
2392 * @param __pos Index of character to search back from.
2393 * @param __n Number of characters from s to search for.
2394 * @return Index of start of last occurrence.
2396 * Starting from @a __pos, searches backward for the first @a
2397 * __n characters in @a __s within this string. If found,
2398 * returns the index where it begins. If not found, returns
2402 rfind(const _CharT
* __s
, size_type __pos
, size_type __n
) const
2406 * @brief Find last position of a C string.
2407 * @param __s C string to locate.
2408 * @param __pos Index of character to start search at (default end).
2409 * @return Index of start of last occurrence.
2411 * Starting from @a __pos, searches backward for the value of
2412 * @a __s within this string. If found, returns the index
2413 * where it begins. If not found, returns npos.
2416 rfind(const _CharT
* __s
, size_type __pos
= npos
) const _GLIBCXX_NOEXCEPT
2418 __glibcxx_requires_string(__s
);
2419 return this->rfind(__s
, __pos
, traits_type::length(__s
));
2423 * @brief Find last position of a character.
2424 * @param __c Character to locate.
2425 * @param __pos Index of character to search back from (default end).
2426 * @return Index of last occurrence.
2428 * Starting from @a __pos, searches backward for @a __c within
2429 * this string. If found, returns the index where it was
2430 * found. If not found, returns npos.
2433 rfind(_CharT __c
, size_type __pos
= npos
) const _GLIBCXX_NOEXCEPT
;
2435 #if __cplusplus >= 201703L
2437 * @brief Find last position of a string_view.
2438 * @param __svt The object convertible to string_view to locate.
2439 * @param __pos Index of character to search back from (default end).
2440 * @return Index of start of last occurrence.
2442 template<typename _Tp
>
2443 _If_sv
<_Tp
, size_type
>
2444 rfind(const _Tp
& __svt
, size_type __pos
= npos
) const
2445 noexcept(is_same
<_Tp
, __sv_type
>::value
)
2447 __sv_type __sv
= __svt
;
2448 return this->rfind(__sv
.data(), __pos
, __sv
.size());
2453 * @brief Find position of a character of string.
2454 * @param __str String containing characters to locate.
2455 * @param __pos Index of character to search from (default 0).
2456 * @return Index of first occurrence.
2458 * Starting from @a __pos, searches forward for one of the
2459 * characters of @a __str within this string. If found,
2460 * returns the index where it was found. If not found, returns
2464 find_first_of(const basic_string
& __str
, size_type __pos
= 0) const
2466 { return this->find_first_of(__str
.data(), __pos
, __str
.size()); }
2469 * @brief Find position of a character of C substring.
2470 * @param __s String containing characters to locate.
2471 * @param __pos Index of character to search from.
2472 * @param __n Number of characters from s to search for.
2473 * @return Index of first occurrence.
2475 * Starting from @a __pos, searches forward for one of the
2476 * first @a __n characters of @a __s within this string. If
2477 * found, returns the index where it was found. If not found,
2481 find_first_of(const _CharT
* __s
, size_type __pos
, size_type __n
) const
2485 * @brief Find position of a character of C string.
2486 * @param __s String containing characters to locate.
2487 * @param __pos Index of character to search from (default 0).
2488 * @return Index of first occurrence.
2490 * Starting from @a __pos, searches forward for one of the
2491 * characters of @a __s within this string. If found, returns
2492 * the index where it was found. If not found, returns npos.
2495 find_first_of(const _CharT
* __s
, size_type __pos
= 0) const
2498 __glibcxx_requires_string(__s
);
2499 return this->find_first_of(__s
, __pos
, traits_type::length(__s
));
2503 * @brief Find position of a character.
2504 * @param __c Character to locate.
2505 * @param __pos Index of character to search from (default 0).
2506 * @return Index of first occurrence.
2508 * Starting from @a __pos, searches forward for the character
2509 * @a __c within this string. If found, returns the index
2510 * where it was found. If not found, returns npos.
2512 * Note: equivalent to find(__c, __pos).
2515 find_first_of(_CharT __c
, size_type __pos
= 0) const _GLIBCXX_NOEXCEPT
2516 { return this->find(__c
, __pos
); }
2518 #if __cplusplus >= 201703L
2520 * @brief Find position of a character of a string_view.
2521 * @param __svt An object convertible to string_view containing
2522 * characters to locate.
2523 * @param __pos Index of character to search from (default 0).
2524 * @return Index of first occurrence.
2526 template<typename _Tp
>
2527 _If_sv
<_Tp
, size_type
>
2528 find_first_of(const _Tp
& __svt
, size_type __pos
= 0) const
2529 noexcept(is_same
<_Tp
, __sv_type
>::value
)
2531 __sv_type __sv
= __svt
;
2532 return this->find_first_of(__sv
.data(), __pos
, __sv
.size());
2537 * @brief Find last position of a character of string.
2538 * @param __str String containing characters to locate.
2539 * @param __pos Index of character to search back from (default end).
2540 * @return Index of last occurrence.
2542 * Starting from @a __pos, searches backward for one of the
2543 * characters of @a __str within this string. If found,
2544 * returns the index where it was found. If not found, returns
2548 find_last_of(const basic_string
& __str
, size_type __pos
= npos
) const
2550 { return this->find_last_of(__str
.data(), __pos
, __str
.size()); }
2553 * @brief Find last position of a character of C substring.
2554 * @param __s C string containing characters to locate.
2555 * @param __pos Index of character to search back from.
2556 * @param __n Number of characters from s to search for.
2557 * @return Index of last occurrence.
2559 * Starting from @a __pos, searches backward for one of the
2560 * first @a __n characters of @a __s within this string. If
2561 * found, returns the index where it was found. If not found,
2565 find_last_of(const _CharT
* __s
, size_type __pos
, size_type __n
) const
2569 * @brief Find last position of a character of C string.
2570 * @param __s C string containing characters to locate.
2571 * @param __pos Index of character to search back from (default end).
2572 * @return Index of last occurrence.
2574 * Starting from @a __pos, searches backward for one of the
2575 * characters of @a __s within this string. If found, returns
2576 * the index where it was found. If not found, returns npos.
2579 find_last_of(const _CharT
* __s
, size_type __pos
= npos
) const
2582 __glibcxx_requires_string(__s
);
2583 return this->find_last_of(__s
, __pos
, traits_type::length(__s
));
2587 * @brief Find last position of a character.
2588 * @param __c Character to locate.
2589 * @param __pos Index of character to search back from (default end).
2590 * @return Index of last occurrence.
2592 * Starting from @a __pos, searches backward for @a __c within
2593 * this string. If found, returns the index where it was
2594 * found. If not found, returns npos.
2596 * Note: equivalent to rfind(__c, __pos).
2599 find_last_of(_CharT __c
, size_type __pos
= npos
) const _GLIBCXX_NOEXCEPT
2600 { return this->rfind(__c
, __pos
); }
2602 #if __cplusplus >= 201703L
2604 * @brief Find last position of a character of string.
2605 * @param __svt An object convertible to string_view containing
2606 * characters to locate.
2607 * @param __pos Index of character to search back from (default end).
2608 * @return Index of last occurrence.
2610 template<typename _Tp
>
2611 _If_sv
<_Tp
, size_type
>
2612 find_last_of(const _Tp
& __svt
, size_type __pos
= npos
) const
2613 noexcept(is_same
<_Tp
, __sv_type
>::value
)
2615 __sv_type __sv
= __svt
;
2616 return this->find_last_of(__sv
.data(), __pos
, __sv
.size());
2621 * @brief Find position of a character not in string.
2622 * @param __str String containing characters to avoid.
2623 * @param __pos Index of character to search from (default 0).
2624 * @return Index of first occurrence.
2626 * Starting from @a __pos, searches forward for a character not contained
2627 * in @a __str within this string. If found, returns the index where it
2628 * was found. If not found, returns npos.
2631 find_first_not_of(const basic_string
& __str
, size_type __pos
= 0) const
2633 { return this->find_first_not_of(__str
.data(), __pos
, __str
.size()); }
2636 * @brief Find position of a character not in C substring.
2637 * @param __s C string containing characters to avoid.
2638 * @param __pos Index of character to search from.
2639 * @param __n Number of characters from __s to consider.
2640 * @return Index of first occurrence.
2642 * Starting from @a __pos, searches forward for a character not
2643 * contained in the first @a __n characters of @a __s within
2644 * this string. If found, returns the index where it was
2645 * found. If not found, returns npos.
2648 find_first_not_of(const _CharT
* __s
, size_type __pos
,
2649 size_type __n
) const _GLIBCXX_NOEXCEPT
;
2652 * @brief Find position of a character not in C string.
2653 * @param __s C string containing characters to avoid.
2654 * @param __pos Index of character to search from (default 0).
2655 * @return Index of first occurrence.
2657 * Starting from @a __pos, searches forward for a character not
2658 * contained in @a __s within this string. If found, returns
2659 * the index where it was found. If not found, returns npos.
2662 find_first_not_of(const _CharT
* __s
, size_type __pos
= 0) const
2665 __glibcxx_requires_string(__s
);
2666 return this->find_first_not_of(__s
, __pos
, traits_type::length(__s
));
2670 * @brief Find position of a different character.
2671 * @param __c Character to avoid.
2672 * @param __pos Index of character to search from (default 0).
2673 * @return Index of first occurrence.
2675 * Starting from @a __pos, searches forward for a character
2676 * other than @a __c within this string. If found, returns the
2677 * index where it was found. If not found, returns npos.
2680 find_first_not_of(_CharT __c
, size_type __pos
= 0) const
2683 #if __cplusplus >= 201703L
2685 * @brief Find position of a character not in a string_view.
2686 * @param __svt An object convertible to string_view containing
2687 * characters to avoid.
2688 * @param __pos Index of character to search from (default 0).
2689 * @return Index of first occurrence.
2691 template<typename _Tp
>
2692 _If_sv
<_Tp
, size_type
>
2693 find_first_not_of(const _Tp
& __svt
, size_type __pos
= 0) const
2694 noexcept(is_same
<_Tp
, __sv_type
>::value
)
2696 __sv_type __sv
= __svt
;
2697 return this->find_first_not_of(__sv
.data(), __pos
, __sv
.size());
2702 * @brief Find last position of a character not in string.
2703 * @param __str String containing characters to avoid.
2704 * @param __pos Index of character to search back from (default end).
2705 * @return Index of last occurrence.
2707 * Starting from @a __pos, searches backward for a character
2708 * not contained in @a __str within this string. If found,
2709 * returns the index where it was found. If not found, returns
2713 find_last_not_of(const basic_string
& __str
, size_type __pos
= npos
) const
2715 { return this->find_last_not_of(__str
.data(), __pos
, __str
.size()); }
2718 * @brief Find last position of a character not in C substring.
2719 * @param __s C string containing characters to avoid.
2720 * @param __pos Index of character to search back from.
2721 * @param __n Number of characters from s to consider.
2722 * @return Index of last occurrence.
2724 * Starting from @a __pos, searches backward for a character not
2725 * contained in the first @a __n characters of @a __s within this string.
2726 * If found, returns the index where it was found. If not found,
2730 find_last_not_of(const _CharT
* __s
, size_type __pos
,
2731 size_type __n
) const _GLIBCXX_NOEXCEPT
;
2733 * @brief Find last position of a character not in C string.
2734 * @param __s C string containing characters to avoid.
2735 * @param __pos Index of character to search back from (default end).
2736 * @return Index of last occurrence.
2738 * Starting from @a __pos, searches backward for a character
2739 * not contained in @a __s within this string. If found,
2740 * returns the index where it was found. If not found, returns
2744 find_last_not_of(const _CharT
* __s
, size_type __pos
= npos
) const
2747 __glibcxx_requires_string(__s
);
2748 return this->find_last_not_of(__s
, __pos
, traits_type::length(__s
));
2752 * @brief Find last position of a different character.
2753 * @param __c Character to avoid.
2754 * @param __pos Index of character to search back from (default end).
2755 * @return Index of last occurrence.
2757 * Starting from @a __pos, searches backward for a character other than
2758 * @a __c within this string. If found, returns the index where it was
2759 * found. If not found, returns npos.
2762 find_last_not_of(_CharT __c
, size_type __pos
= npos
) const
2765 #if __cplusplus >= 201703L
2767 * @brief Find last position of a character not in a string_view.
2768 * @param __svt An object convertible to string_view containing
2769 * characters to avoid.
2770 * @param __pos Index of character to search back from (default end).
2771 * @return Index of last occurrence.
2773 template<typename _Tp
>
2774 _If_sv
<_Tp
, size_type
>
2775 find_last_not_of(const _Tp
& __svt
, size_type __pos
= npos
) const
2776 noexcept(is_same
<_Tp
, __sv_type
>::value
)
2778 __sv_type __sv
= __svt
;
2779 return this->find_last_not_of(__sv
.data(), __pos
, __sv
.size());
2784 * @brief Get a substring.
2785 * @param __pos Index of first character (default 0).
2786 * @param __n Number of characters in substring (default remainder).
2787 * @return The new string.
2788 * @throw std::out_of_range If __pos > size().
2790 * Construct and return a new string using the @a __n
2791 * characters starting at @a __pos. If the string is too
2792 * short, use the remainder of the characters. If @a __pos is
2793 * beyond the end of the string, out_of_range is thrown.
2796 substr(size_type __pos
= 0, size_type __n
= npos
) const
2797 { return basic_string(*this,
2798 _M_check(__pos
, "basic_string::substr"), __n
); }
2801 * @brief Compare to a string.
2802 * @param __str String to compare against.
2803 * @return Integer < 0, 0, or > 0.
2805 * Returns an integer < 0 if this string is ordered before @a
2806 * __str, 0 if their values are equivalent, or > 0 if this
2807 * string is ordered after @a __str. Determines the effective
2808 * length rlen of the strings to compare as the smallest of
2809 * size() and str.size(). The function then compares the two
2810 * strings by calling traits::compare(data(), str.data(),rlen).
2811 * If the result of the comparison is nonzero returns it,
2812 * otherwise the shorter one is ordered first.
2815 compare(const basic_string
& __str
) const
2817 const size_type __size
= this->size();
2818 const size_type __osize
= __str
.size();
2819 const size_type __len
= std::min(__size
, __osize
);
2821 int __r
= traits_type::compare(_M_data(), __str
.data(), __len
);
2823 __r
= _S_compare(__size
, __osize
);
2827 #if __cplusplus >= 201703L
2829 * @brief Compare to a string_view.
2830 * @param __svt An object convertible to string_view to compare against.
2831 * @return Integer < 0, 0, or > 0.
2833 template<typename _Tp
>
2835 compare(const _Tp
& __svt
) const
2836 noexcept(is_same
<_Tp
, __sv_type
>::value
)
2838 __sv_type __sv
= __svt
;
2839 const size_type __size
= this->size();
2840 const size_type __osize
= __sv
.size();
2841 const size_type __len
= std::min(__size
, __osize
);
2843 int __r
= traits_type::compare(_M_data(), __sv
.data(), __len
);
2845 __r
= _S_compare(__size
, __osize
);
2850 * @brief Compare to a string_view.
2851 * @param __pos A position in the string to start comparing from.
2852 * @param __n The number of characters to compare.
2853 * @param __svt An object convertible to string_view to compare
2855 * @return Integer < 0, 0, or > 0.
2857 template<typename _Tp
>
2859 compare(size_type __pos
, size_type __n
, const _Tp
& __svt
) const
2860 noexcept(is_same
<_Tp
, __sv_type
>::value
)
2862 __sv_type __sv
= __svt
;
2863 return __sv_type(*this).substr(__pos
, __n
).compare(__sv
);
2867 * @brief Compare to a string_view.
2868 * @param __pos1 A position in the string to start comparing from.
2869 * @param __n1 The number of characters to compare.
2870 * @param __svt An object convertible to string_view to compare
2872 * @param __pos2 A position in the string_view to start comparing from.
2873 * @param __n2 The number of characters to compare.
2874 * @return Integer < 0, 0, or > 0.
2876 template<typename _Tp
>
2878 compare(size_type __pos1
, size_type __n1
, const _Tp
& __svt
,
2879 size_type __pos2
, size_type __n2
= npos
) const
2880 noexcept(is_same
<_Tp
, __sv_type
>::value
)
2882 __sv_type __sv
= __svt
;
2883 return __sv_type(*this)
2884 .substr(__pos1
, __n1
).compare(__sv
.substr(__pos2
, __n2
));
2889 * @brief Compare substring to a string.
2890 * @param __pos Index of first character of substring.
2891 * @param __n Number of characters in substring.
2892 * @param __str String to compare against.
2893 * @return Integer < 0, 0, or > 0.
2895 * Form the substring of this string from the @a __n characters
2896 * starting at @a __pos. Returns an integer < 0 if the
2897 * substring is ordered before @a __str, 0 if their values are
2898 * equivalent, or > 0 if the substring is ordered after @a
2899 * __str. Determines the effective length rlen of the strings
2900 * to compare as the smallest of the length of the substring
2901 * and @a __str.size(). The function then compares the two
2902 * strings by calling
2903 * traits::compare(substring.data(),str.data(),rlen). If the
2904 * result of the comparison is nonzero returns it, otherwise
2905 * the shorter one is ordered first.
2908 compare(size_type __pos
, size_type __n
, const basic_string
& __str
) const
2910 _M_check(__pos
, "basic_string::compare");
2911 __n
= _M_limit(__pos
, __n
);
2912 const size_type __osize
= __str
.size();
2913 const size_type __len
= std::min(__n
, __osize
);
2914 int __r
= traits_type::compare(_M_data() + __pos
, __str
.data(), __len
);
2916 __r
= _S_compare(__n
, __osize
);
2921 * @brief Compare substring to a substring.
2922 * @param __pos1 Index of first character of substring.
2923 * @param __n1 Number of characters in substring.
2924 * @param __str String to compare against.
2925 * @param __pos2 Index of first character of substring of str.
2926 * @param __n2 Number of characters in substring of str.
2927 * @return Integer < 0, 0, or > 0.
2929 * Form the substring of this string from the @a __n1
2930 * characters starting at @a __pos1. Form the substring of @a
2931 * __str from the @a __n2 characters starting at @a __pos2.
2932 * Returns an integer < 0 if this substring is ordered before
2933 * the substring of @a __str, 0 if their values are equivalent,
2934 * or > 0 if this substring is ordered after the substring of
2935 * @a __str. Determines the effective length rlen of the
2936 * strings to compare as the smallest of the lengths of the
2937 * substrings. The function then compares the two strings by
2939 * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
2940 * If the result of the comparison is nonzero returns it,
2941 * otherwise the shorter one is ordered first.
2944 compare(size_type __pos1
, size_type __n1
, const basic_string
& __str
,
2945 size_type __pos2
, size_type __n2
= npos
) const
2947 _M_check(__pos1
, "basic_string::compare");
2948 __str
._M_check(__pos2
, "basic_string::compare");
2949 __n1
= _M_limit(__pos1
, __n1
);
2950 __n2
= __str
._M_limit(__pos2
, __n2
);
2951 const size_type __len
= std::min(__n1
, __n2
);
2952 int __r
= traits_type::compare(_M_data() + __pos1
,
2953 __str
.data() + __pos2
, __len
);
2955 __r
= _S_compare(__n1
, __n2
);
2960 * @brief Compare to a C string.
2961 * @param __s C string to compare against.
2962 * @return Integer < 0, 0, or > 0.
2964 * Returns an integer < 0 if this string is ordered before @a __s, 0 if
2965 * their values are equivalent, or > 0 if this string is ordered after
2966 * @a __s. Determines the effective length rlen of the strings to
2967 * compare as the smallest of size() and the length of a string
2968 * constructed from @a __s. The function then compares the two strings
2969 * by calling traits::compare(data(),s,rlen). If the result of the
2970 * comparison is nonzero returns it, otherwise the shorter one is
2974 compare(const _CharT
* __s
) const _GLIBCXX_NOEXCEPT
2976 __glibcxx_requires_string(__s
);
2977 const size_type __size
= this->size();
2978 const size_type __osize
= traits_type::length(__s
);
2979 const size_type __len
= std::min(__size
, __osize
);
2980 int __r
= traits_type::compare(_M_data(), __s
, __len
);
2982 __r
= _S_compare(__size
, __osize
);
2986 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2987 // 5 String::compare specification questionable
2989 * @brief Compare substring to a C string.
2990 * @param __pos Index of first character of substring.
2991 * @param __n1 Number of characters in substring.
2992 * @param __s C string to compare against.
2993 * @return Integer < 0, 0, or > 0.
2995 * Form the substring of this string from the @a __n1
2996 * characters starting at @a pos. Returns an integer < 0 if
2997 * the substring is ordered before @a __s, 0 if their values
2998 * are equivalent, or > 0 if the substring is ordered after @a
2999 * __s. Determines the effective length rlen of the strings to
3000 * compare as the smallest of the length of the substring and
3001 * the length of a string constructed from @a __s. The
3002 * function then compares the two string by calling
3003 * traits::compare(substring.data(),__s,rlen). If the result of
3004 * the comparison is nonzero returns it, otherwise the shorter
3005 * one is ordered first.
3008 compare(size_type __pos
, size_type __n1
, const _CharT
* __s
) const
3010 __glibcxx_requires_string(__s
);
3011 _M_check(__pos
, "basic_string::compare");
3012 __n1
= _M_limit(__pos
, __n1
);
3013 const size_type __osize
= traits_type::length(__s
);
3014 const size_type __len
= std::min(__n1
, __osize
);
3015 int __r
= traits_type::compare(_M_data() + __pos
, __s
, __len
);
3017 __r
= _S_compare(__n1
, __osize
);
3022 * @brief Compare substring against a character %array.
3023 * @param __pos Index of first character of substring.
3024 * @param __n1 Number of characters in substring.
3025 * @param __s character %array to compare against.
3026 * @param __n2 Number of characters of s.
3027 * @return Integer < 0, 0, or > 0.
3029 * Form the substring of this string from the @a __n1
3030 * characters starting at @a __pos. Form a string from the
3031 * first @a __n2 characters of @a __s. Returns an integer < 0
3032 * if this substring is ordered before the string from @a __s,
3033 * 0 if their values are equivalent, or > 0 if this substring
3034 * is ordered after the string from @a __s. Determines the
3035 * effective length rlen of the strings to compare as the
3036 * smallest of the length of the substring and @a __n2. The
3037 * function then compares the two strings by calling
3038 * traits::compare(substring.data(),s,rlen). If the result of
3039 * the comparison is nonzero returns it, otherwise the shorter
3040 * one is ordered first.
3042 * NB: s must have at least n2 characters, '\\0' has
3043 * no special meaning.
3046 compare(size_type __pos
, size_type __n1
, const _CharT
* __s
,
3047 size_type __n2
) const
3049 __glibcxx_requires_string_len(__s
, __n2
);
3050 _M_check(__pos
, "basic_string::compare");
3051 __n1
= _M_limit(__pos
, __n1
);
3052 const size_type __len
= std::min(__n1
, __n2
);
3053 int __r
= traits_type::compare(_M_data() + __pos
, __s
, __len
);
3055 __r
= _S_compare(__n1
, __n2
);
3059 #if __cplusplus > 201703L
3061 starts_with(basic_string_view
<_CharT
, _Traits
> __x
) const noexcept
3062 { return __sv_type(this->data(), this->size()).starts_with(__x
); }
3065 starts_with(_CharT __x
) const noexcept
3066 { return __sv_type(this->data(), this->size()).starts_with(__x
); }
3068 [[__gnu__::__nonnull__
]]
3070 starts_with(const _CharT
* __x
) const noexcept
3071 { return __sv_type(this->data(), this->size()).starts_with(__x
); }
3074 ends_with(basic_string_view
<_CharT
, _Traits
> __x
) const noexcept
3075 { return __sv_type(this->data(), this->size()).ends_with(__x
); }
3078 ends_with(_CharT __x
) const noexcept
3079 { return __sv_type(this->data(), this->size()).ends_with(__x
); }
3081 [[__gnu__::__nonnull__
]]
3083 ends_with(const _CharT
* __x
) const noexcept
3084 { return __sv_type(this->data(), this->size()).ends_with(__x
); }
3087 #if __cplusplus > 202011L
3089 contains(basic_string_view
<_CharT
, _Traits
> __x
) const noexcept
3090 { return __sv_type(this->data(), this->size()).contains(__x
); }
3093 contains(_CharT __x
) const noexcept
3094 { return __sv_type(this->data(), this->size()).contains(__x
); }
3096 [[__gnu__::__nonnull__
]]
3098 contains(const _CharT
* __x
) const noexcept
3099 { return __sv_type(this->data(), this->size()).contains(__x
); }
3102 # ifdef _GLIBCXX_TM_TS_INTERNAL
3104 ::_txnal_cow_string_C1_for_exceptions(void* that
, const char* s
,
3107 ::_txnal_cow_string_c_str(const void *that
);
3109 ::_txnal_cow_string_D1(void *that
);
3111 ::_txnal_cow_string_D1_commit(void *that
);
3115 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3116 const typename basic_string
<_CharT
, _Traits
, _Alloc
>::size_type
3117 basic_string
<_CharT
, _Traits
, _Alloc
>::
3118 _Rep::_S_max_size
= (((npos
- sizeof(_Rep_base
))/sizeof(_CharT
)) - 1) / 4;
3120 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3122 basic_string
<_CharT
, _Traits
, _Alloc
>::
3123 _Rep::_S_terminal
= _CharT();
3125 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3126 const typename basic_string
<_CharT
, _Traits
, _Alloc
>::size_type
3127 basic_string
<_CharT
, _Traits
, _Alloc
>::npos
;
3129 // Linker sets _S_empty_rep_storage to all 0s (one reference, empty string)
3130 // at static init time (before static ctors are run).
3131 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3132 typename basic_string
<_CharT
, _Traits
, _Alloc
>::size_type
3133 basic_string
<_CharT
, _Traits
, _Alloc
>::_Rep::_S_empty_rep_storage
[
3134 (sizeof(_Rep_base
) + sizeof(_CharT
) + sizeof(size_type
) - 1) /
3137 // NB: This is the special case for Input Iterators, used in
3138 // istreambuf_iterators, etc.
3139 // Input Iterators have a cost structure very different from
3140 // pointers, calling for a different coding style.
3141 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3142 template<typename _InIterator
>
3144 basic_string
<_CharT
, _Traits
, _Alloc
>::
3145 _S_construct(_InIterator __beg
, _InIterator __end
, const _Alloc
& __a
,
3148 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3149 if (__beg
== __end
&& __a
== _Alloc())
3150 return _S_empty_rep()._M_refdata();
3152 // Avoid reallocation for common case.
3154 size_type __len
= 0;
3155 while (__beg
!= __end
&& __len
< sizeof(__buf
) / sizeof(_CharT
))
3157 __buf
[__len
++] = *__beg
;
3160 _Rep
* __r
= _Rep::_S_create(__len
, size_type(0), __a
);
3161 _M_copy(__r
->_M_refdata(), __buf
, __len
);
3164 while (__beg
!= __end
)
3166 if (__len
== __r
->_M_capacity
)
3168 // Allocate more space.
3169 _Rep
* __another
= _Rep::_S_create(__len
+ 1, __len
, __a
);
3170 _M_copy(__another
->_M_refdata(), __r
->_M_refdata(), __len
);
3171 __r
->_M_destroy(__a
);
3174 __r
->_M_refdata()[__len
++] = *__beg
;
3180 __r
->_M_destroy(__a
);
3181 __throw_exception_again
;
3183 __r
->_M_set_length_and_sharable(__len
);
3184 return __r
->_M_refdata();
3187 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3188 template <typename _InIterator
>
3190 basic_string
<_CharT
, _Traits
, _Alloc
>::
3191 _S_construct(_InIterator __beg
, _InIterator __end
, const _Alloc
& __a
,
3192 forward_iterator_tag
)
3194 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3195 if (__beg
== __end
&& __a
== _Alloc())
3196 return _S_empty_rep()._M_refdata();
3198 // NB: Not required, but considered best practice.
3199 if (__gnu_cxx::__is_null_pointer(__beg
) && __beg
!= __end
)
3200 __throw_logic_error(__N("basic_string::_S_construct null not valid"));
3202 const size_type __dnew
= static_cast<size_type
>(std::distance(__beg
,
3204 // Check for out_of_range and length_error exceptions.
3205 _Rep
* __r
= _Rep::_S_create(__dnew
, size_type(0), __a
);
3207 { _S_copy_chars(__r
->_M_refdata(), __beg
, __end
); }
3210 __r
->_M_destroy(__a
);
3211 __throw_exception_again
;
3213 __r
->_M_set_length_and_sharable(__dnew
);
3214 return __r
->_M_refdata();
3217 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3219 basic_string
<_CharT
, _Traits
, _Alloc
>::
3220 _S_construct(size_type __n
, _CharT __c
, const _Alloc
& __a
)
3222 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3223 if (__n
== 0 && __a
== _Alloc())
3224 return _S_empty_rep()._M_refdata();
3226 // Check for out_of_range and length_error exceptions.
3227 _Rep
* __r
= _Rep::_S_create(__n
, size_type(0), __a
);
3229 _M_assign(__r
->_M_refdata(), __n
, __c
);
3231 __r
->_M_set_length_and_sharable(__n
);
3232 return __r
->_M_refdata();
3235 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3236 basic_string
<_CharT
, _Traits
, _Alloc
>::
3237 basic_string(const basic_string
& __str
, size_type __pos
, const _Alloc
& __a
)
3238 : _M_dataplus(_S_construct(__str
._M_data()
3239 + __str
._M_check(__pos
,
3240 "basic_string::basic_string"),
3241 __str
._M_data() + __str
._M_limit(__pos
, npos
)
3245 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3246 basic_string
<_CharT
, _Traits
, _Alloc
>::
3247 basic_string(const basic_string
& __str
, size_type __pos
, size_type __n
)
3248 : _M_dataplus(_S_construct(__str
._M_data()
3249 + __str
._M_check(__pos
,
3250 "basic_string::basic_string"),
3251 __str
._M_data() + __str
._M_limit(__pos
, __n
)
3252 + __pos
, _Alloc()), _Alloc())
3255 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3256 basic_string
<_CharT
, _Traits
, _Alloc
>::
3257 basic_string(const basic_string
& __str
, size_type __pos
,
3258 size_type __n
, const _Alloc
& __a
)
3259 : _M_dataplus(_S_construct(__str
._M_data()
3260 + __str
._M_check(__pos
,
3261 "basic_string::basic_string"),
3262 __str
._M_data() + __str
._M_limit(__pos
, __n
)
3266 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3267 basic_string
<_CharT
, _Traits
, _Alloc
>&
3268 basic_string
<_CharT
, _Traits
, _Alloc
>::
3269 assign(const basic_string
& __str
)
3271 if (_M_rep() != __str
._M_rep())
3274 const allocator_type __a
= this->get_allocator();
3275 _CharT
* __tmp
= __str
._M_rep()->_M_grab(__a
, __str
.get_allocator());
3276 _M_rep()->_M_dispose(__a
);
3282 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3283 basic_string
<_CharT
, _Traits
, _Alloc
>&
3284 basic_string
<_CharT
, _Traits
, _Alloc
>::
3285 assign(const _CharT
* __s
, size_type __n
)
3287 __glibcxx_requires_string_len(__s
, __n
);
3288 _M_check_length(this->size(), __n
, "basic_string::assign");
3289 if (_M_disjunct(__s
) || _M_rep()->_M_is_shared())
3290 return _M_replace_safe(size_type(0), this->size(), __s
, __n
);
3294 const size_type __pos
= __s
- _M_data();
3296 _M_copy(_M_data(), __s
, __n
);
3298 _M_move(_M_data(), __s
, __n
);
3299 _M_rep()->_M_set_length_and_sharable(__n
);
3304 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3305 basic_string
<_CharT
, _Traits
, _Alloc
>&
3306 basic_string
<_CharT
, _Traits
, _Alloc
>::
3307 append(size_type __n
, _CharT __c
)
3311 _M_check_length(size_type(0), __n
, "basic_string::append");
3312 const size_type __len
= __n
+ this->size();
3313 if (__len
> this->capacity() || _M_rep()->_M_is_shared())
3314 this->reserve(__len
);
3315 _M_assign(_M_data() + this->size(), __n
, __c
);
3316 _M_rep()->_M_set_length_and_sharable(__len
);
3321 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3322 basic_string
<_CharT
, _Traits
, _Alloc
>&
3323 basic_string
<_CharT
, _Traits
, _Alloc
>::
3324 append(const _CharT
* __s
, size_type __n
)
3326 __glibcxx_requires_string_len(__s
, __n
);
3329 _M_check_length(size_type(0), __n
, "basic_string::append");
3330 const size_type __len
= __n
+ this->size();
3331 if (__len
> this->capacity() || _M_rep()->_M_is_shared())
3333 if (_M_disjunct(__s
))
3334 this->reserve(__len
);
3337 const size_type __off
= __s
- _M_data();
3338 this->reserve(__len
);
3339 __s
= _M_data() + __off
;
3342 _M_copy(_M_data() + this->size(), __s
, __n
);
3343 _M_rep()->_M_set_length_and_sharable(__len
);
3348 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3349 basic_string
<_CharT
, _Traits
, _Alloc
>&
3350 basic_string
<_CharT
, _Traits
, _Alloc
>::
3351 append(const basic_string
& __str
)
3353 const size_type __size
= __str
.size();
3356 const size_type __len
= __size
+ this->size();
3357 if (__len
> this->capacity() || _M_rep()->_M_is_shared())
3358 this->reserve(__len
);
3359 _M_copy(_M_data() + this->size(), __str
._M_data(), __size
);
3360 _M_rep()->_M_set_length_and_sharable(__len
);
3365 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3366 basic_string
<_CharT
, _Traits
, _Alloc
>&
3367 basic_string
<_CharT
, _Traits
, _Alloc
>::
3368 append(const basic_string
& __str
, size_type __pos
, size_type __n
)
3370 __str
._M_check(__pos
, "basic_string::append");
3371 __n
= __str
._M_limit(__pos
, __n
);
3374 const size_type __len
= __n
+ this->size();
3375 if (__len
> this->capacity() || _M_rep()->_M_is_shared())
3376 this->reserve(__len
);
3377 _M_copy(_M_data() + this->size(), __str
._M_data() + __pos
, __n
);
3378 _M_rep()->_M_set_length_and_sharable(__len
);
3383 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3384 basic_string
<_CharT
, _Traits
, _Alloc
>&
3385 basic_string
<_CharT
, _Traits
, _Alloc
>::
3386 insert(size_type __pos
, const _CharT
* __s
, size_type __n
)
3388 __glibcxx_requires_string_len(__s
, __n
);
3389 _M_check(__pos
, "basic_string::insert");
3390 _M_check_length(size_type(0), __n
, "basic_string::insert");
3391 if (_M_disjunct(__s
) || _M_rep()->_M_is_shared())
3392 return _M_replace_safe(__pos
, size_type(0), __s
, __n
);
3396 const size_type __off
= __s
- _M_data();
3397 _M_mutate(__pos
, 0, __n
);
3398 __s
= _M_data() + __off
;
3399 _CharT
* __p
= _M_data() + __pos
;
3400 if (__s
+ __n
<= __p
)
3401 _M_copy(__p
, __s
, __n
);
3402 else if (__s
>= __p
)
3403 _M_copy(__p
, __s
+ __n
, __n
);
3406 const size_type __nleft
= __p
- __s
;
3407 _M_copy(__p
, __s
, __nleft
);
3408 _M_copy(__p
+ __nleft
, __p
+ __n
, __n
- __nleft
);
3414 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3415 typename basic_string
<_CharT
, _Traits
, _Alloc
>::iterator
3416 basic_string
<_CharT
, _Traits
, _Alloc
>::
3417 erase(iterator __first
, iterator __last
)
3419 _GLIBCXX_DEBUG_PEDASSERT(__first
>= _M_ibegin() && __first
<= __last
3420 && __last
<= _M_iend());
3422 // NB: This isn't just an optimization (bail out early when
3423 // there is nothing to do, really), it's also a correctness
3424 // issue vs MT, see libstdc++/40518.
3425 const size_type __size
= __last
- __first
;
3428 const size_type __pos
= __first
- _M_ibegin();
3429 _M_mutate(__pos
, __size
, size_type(0));
3430 _M_rep()->_M_set_leaked();
3431 return iterator(_M_data() + __pos
);
3437 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3438 basic_string
<_CharT
, _Traits
, _Alloc
>&
3439 basic_string
<_CharT
, _Traits
, _Alloc
>::
3440 replace(size_type __pos
, size_type __n1
, const _CharT
* __s
,
3443 __glibcxx_requires_string_len(__s
, __n2
);
3444 _M_check(__pos
, "basic_string::replace");
3445 __n1
= _M_limit(__pos
, __n1
);
3446 _M_check_length(__n1
, __n2
, "basic_string::replace");
3448 if (_M_disjunct(__s
) || _M_rep()->_M_is_shared())
3449 return _M_replace_safe(__pos
, __n1
, __s
, __n2
);
3450 else if ((__left
= __s
+ __n2
<= _M_data() + __pos
)
3451 || _M_data() + __pos
+ __n1
<= __s
)
3453 // Work in-place: non-overlapping case.
3454 size_type __off
= __s
- _M_data();
3455 __left
? __off
: (__off
+= __n2
- __n1
);
3456 _M_mutate(__pos
, __n1
, __n2
);
3457 _M_copy(_M_data() + __pos
, _M_data() + __off
, __n2
);
3462 // TODO: overlapping case.
3463 const basic_string
__tmp(__s
, __n2
);
3464 return _M_replace_safe(__pos
, __n1
, __tmp
._M_data(), __n2
);
3468 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3470 basic_string
<_CharT
, _Traits
, _Alloc
>::_Rep::
3471 _M_destroy(const _Alloc
& __a
) throw ()
3473 const size_type __size
= sizeof(_Rep_base
)
3474 + (this->_M_capacity
+ 1) * sizeof(_CharT
);
3475 _Raw_bytes_alloc(__a
).deallocate(reinterpret_cast<char*>(this), __size
);
3478 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3480 basic_string
<_CharT
, _Traits
, _Alloc
>::
3483 // No need to create a new copy of an empty string when a non-const
3484 // reference/pointer/iterator into it is obtained. Modifying the
3485 // trailing null character is undefined, so the ref/pointer/iterator
3486 // is effectively const anyway.
3490 if (_M_rep()->_M_is_shared())
3492 _M_rep()->_M_set_leaked();
3495 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3497 basic_string
<_CharT
, _Traits
, _Alloc
>::
3498 _M_mutate(size_type __pos
, size_type __len1
, size_type __len2
)
3500 const size_type __old_size
= this->size();
3501 const size_type __new_size
= __old_size
+ __len2
- __len1
;
3502 const size_type __how_much
= __old_size
- __pos
- __len1
;
3504 if (__new_size
> this->capacity() || _M_rep()->_M_is_shared())
3507 const allocator_type __a
= get_allocator();
3508 _Rep
* __r
= _Rep::_S_create(__new_size
, this->capacity(), __a
);
3511 _M_copy(__r
->_M_refdata(), _M_data(), __pos
);
3513 _M_copy(__r
->_M_refdata() + __pos
+ __len2
,
3514 _M_data() + __pos
+ __len1
, __how_much
);
3516 _M_rep()->_M_dispose(__a
);
3517 _M_data(__r
->_M_refdata());
3519 else if (__how_much
&& __len1
!= __len2
)
3522 _M_move(_M_data() + __pos
+ __len2
,
3523 _M_data() + __pos
+ __len1
, __how_much
);
3525 _M_rep()->_M_set_length_and_sharable(__new_size
);
3528 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3530 basic_string
<_CharT
, _Traits
, _Alloc
>::
3531 reserve(size_type __res
)
3533 const size_type __capacity
= capacity();
3535 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3536 // 2968. Inconsistencies between basic_string reserve and
3537 // vector/unordered_map/unordered_set reserve functions
3538 // P0966 reserve should not shrink
3539 if (__res
<= __capacity
)
3541 if (!_M_rep()->_M_is_shared())
3544 // unshare, but keep same capacity
3548 const allocator_type __a
= get_allocator();
3549 _CharT
* __tmp
= _M_rep()->_M_clone(__a
, __res
- this->size());
3550 _M_rep()->_M_dispose(__a
);
3554 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3556 basic_string
<_CharT
, _Traits
, _Alloc
>::
3557 swap(basic_string
& __s
)
3558 _GLIBCXX_NOEXCEPT_IF(allocator_traits
<_Alloc
>::is_always_equal::value
)
3560 if (_M_rep()->_M_is_leaked())
3561 _M_rep()->_M_set_sharable();
3562 if (__s
._M_rep()->_M_is_leaked())
3563 __s
._M_rep()->_M_set_sharable();
3564 if (this->get_allocator() == __s
.get_allocator())
3566 _CharT
* __tmp
= _M_data();
3567 _M_data(__s
._M_data());
3570 // The code below can usually be optimized away.
3573 const basic_string
__tmp1(_M_ibegin(), _M_iend(),
3574 __s
.get_allocator());
3575 const basic_string
__tmp2(__s
._M_ibegin(), __s
._M_iend(),
3576 this->get_allocator());
3582 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3583 typename basic_string
<_CharT
, _Traits
, _Alloc
>::_Rep
*
3584 basic_string
<_CharT
, _Traits
, _Alloc
>::_Rep::
3585 _S_create(size_type __capacity
, size_type __old_capacity
,
3586 const _Alloc
& __alloc
)
3588 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3589 // 83. String::npos vs. string::max_size()
3590 if (__capacity
> _S_max_size
)
3591 __throw_length_error(__N("basic_string::_S_create"));
3593 // The standard places no restriction on allocating more memory
3594 // than is strictly needed within this layer at the moment or as
3595 // requested by an explicit application call to reserve(n).
3597 // Many malloc implementations perform quite poorly when an
3598 // application attempts to allocate memory in a stepwise fashion
3599 // growing each allocation size by only 1 char. Additionally,
3600 // it makes little sense to allocate less linear memory than the
3601 // natural blocking size of the malloc implementation.
3602 // Unfortunately, we would need a somewhat low-level calculation
3603 // with tuned parameters to get this perfect for any particular
3604 // malloc implementation. Fortunately, generalizations about
3605 // common features seen among implementations seems to suffice.
3607 // __pagesize need not match the actual VM page size for good
3608 // results in practice, thus we pick a common value on the low
3609 // side. __malloc_header_size is an estimate of the amount of
3610 // overhead per memory allocation (in practice seen N * sizeof
3611 // (void*) where N is 0, 2 or 4). According to folklore,
3612 // picking this value on the high side is better than
3613 // low-balling it (especially when this algorithm is used with
3614 // malloc implementations that allocate memory blocks rounded up
3615 // to a size which is a power of 2).
3616 const size_type __pagesize
= 4096;
3617 const size_type __malloc_header_size
= 4 * sizeof(void*);
3619 // The below implements an exponential growth policy, necessary to
3620 // meet amortized linear time requirements of the library: see
3621 // http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
3622 // It's active for allocations requiring an amount of memory above
3623 // system pagesize. This is consistent with the requirements of the
3624 // standard: http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html
3625 if (__capacity
> __old_capacity
&& __capacity
< 2 * __old_capacity
)
3626 __capacity
= 2 * __old_capacity
;
3628 // NB: Need an array of char_type[__capacity], plus a terminating
3629 // null char_type() element, plus enough for the _Rep data structure.
3630 // Whew. Seemingly so needy, yet so elemental.
3631 size_type __size
= (__capacity
+ 1) * sizeof(_CharT
) + sizeof(_Rep
);
3633 const size_type __adj_size
= __size
+ __malloc_header_size
;
3634 if (__adj_size
> __pagesize
&& __capacity
> __old_capacity
)
3636 const size_type __extra
= __pagesize
- __adj_size
% __pagesize
;
3637 __capacity
+= __extra
/ sizeof(_CharT
);
3638 // Never allocate a string bigger than _S_max_size.
3639 if (__capacity
> _S_max_size
)
3640 __capacity
= _S_max_size
;
3641 __size
= (__capacity
+ 1) * sizeof(_CharT
) + sizeof(_Rep
);
3644 // NB: Might throw, but no worries about a leak, mate: _Rep()
3646 void* __place
= _Raw_bytes_alloc(__alloc
).allocate(__size
);
3647 _Rep
*__p
= new (__place
) _Rep
;
3648 __p
->_M_capacity
= __capacity
;
3649 // ABI compatibility - 3.4.x set in _S_create both
3650 // _M_refcount and _M_length. All callers of _S_create
3651 // in basic_string.tcc then set just _M_length.
3652 // In 4.0.x and later both _M_refcount and _M_length
3653 // are initialized in the callers, unfortunately we can
3654 // have 3.4.x compiled code with _S_create callers inlined
3655 // calling 4.0.x+ _S_create.
3656 __p
->_M_set_sharable();
3660 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3662 basic_string
<_CharT
, _Traits
, _Alloc
>::_Rep::
3663 _M_clone(const _Alloc
& __alloc
, size_type __res
)
3665 // Requested capacity of the clone.
3666 const size_type __requested_cap
= this->_M_length
+ __res
;
3667 _Rep
* __r
= _Rep::_S_create(__requested_cap
, this->_M_capacity
,
3669 if (this->_M_length
)
3670 _M_copy(__r
->_M_refdata(), _M_refdata(), this->_M_length
);
3672 __r
->_M_set_length_and_sharable(this->_M_length
);
3673 return __r
->_M_refdata();
3676 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3678 basic_string
<_CharT
, _Traits
, _Alloc
>::
3679 resize(size_type __n
, _CharT __c
)
3681 const size_type __size
= this->size();
3682 _M_check_length(__size
, __n
, "basic_string::resize");
3684 this->append(__n
- __size
, __c
);
3685 else if (__n
< __size
)
3687 // else nothing (in particular, avoid calling _M_mutate() unnecessarily.)
3690 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3691 template<typename _InputIterator
>
3692 basic_string
<_CharT
, _Traits
, _Alloc
>&
3693 basic_string
<_CharT
, _Traits
, _Alloc
>::
3694 _M_replace_dispatch(iterator __i1
, iterator __i2
, _InputIterator __k1
,
3695 _InputIterator __k2
, __false_type
)
3697 const basic_string
__s(__k1
, __k2
);
3698 const size_type __n1
= __i2
- __i1
;
3699 _M_check_length(__n1
, __s
.size(), "basic_string::_M_replace_dispatch");
3700 return _M_replace_safe(__i1
- _M_ibegin(), __n1
, __s
._M_data(),
3704 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3705 basic_string
<_CharT
, _Traits
, _Alloc
>&
3706 basic_string
<_CharT
, _Traits
, _Alloc
>::
3707 _M_replace_aux(size_type __pos1
, size_type __n1
, size_type __n2
,
3710 _M_check_length(__n1
, __n2
, "basic_string::_M_replace_aux");
3711 _M_mutate(__pos1
, __n1
, __n2
);
3713 _M_assign(_M_data() + __pos1
, __n2
, __c
);
3717 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3718 basic_string
<_CharT
, _Traits
, _Alloc
>&
3719 basic_string
<_CharT
, _Traits
, _Alloc
>::
3720 _M_replace_safe(size_type __pos1
, size_type __n1
, const _CharT
* __s
,
3723 _M_mutate(__pos1
, __n1
, __n2
);
3725 _M_copy(_M_data() + __pos1
, __s
, __n2
);
3729 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3731 basic_string
<_CharT
, _Traits
, _Alloc
>::
3734 #if __cpp_exceptions
3735 if (length() < capacity() || _M_rep()->_M_is_shared())
3738 const allocator_type __a
= get_allocator();
3739 _CharT
* __tmp
= _M_rep()->_M_clone(__a
);
3740 _M_rep()->_M_dispose(__a
);
3743 catch (const __cxxabiv1::__forced_unwind
&)
3746 { /* swallow the exception */ }
3750 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3751 typename basic_string
<_CharT
, _Traits
, _Alloc
>::size_type
3752 basic_string
<_CharT
, _Traits
, _Alloc
>::
3753 copy(_CharT
* __s
, size_type __n
, size_type __pos
) const
3755 _M_check(__pos
, "basic_string::copy");
3756 __n
= _M_limit(__pos
, __n
);
3757 __glibcxx_requires_string_len(__s
, __n
);
3759 _M_copy(__s
, _M_data() + __pos
, __n
);
3760 // 21.3.5.7 par 3: do not append null. (good.)
3764 #ifdef __glibcxx_string_resize_and_overwrite // C++ >= 23
3765 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3766 template<typename _Operation
>
3767 [[__gnu__::__always_inline__
]]
3769 basic_string
<_CharT
, _Traits
, _Alloc
>::
3770 __resize_and_overwrite(const size_type __n
, _Operation __op
)
3771 { resize_and_overwrite
<_Operation
&>(__n
, __op
); }
3774 #if __cplusplus >= 201103L
3775 template<typename _CharT
, typename _Traits
, typename _Alloc
>
3776 template<typename _Operation
>
3778 basic_string
<_CharT
, _Traits
, _Alloc
>::
3779 #ifdef __glibcxx_string_resize_and_overwrite // C++ >= 23
3780 resize_and_overwrite(const size_type __n
, _Operation __op
)
3782 __resize_and_overwrite(const size_type __n
, _Operation __op
)
3785 const size_type __capacity
= capacity();
3787 if (__n
> __capacity
|| _M_rep()->_M_is_shared())
3790 struct _Terminator
{
3791 ~_Terminator() { _M_this
->_M_rep()->_M_set_length_and_sharable(_M_r
); }
3792 basic_string
* _M_this
;
3795 _Terminator __term
{this, 0};
3796 auto __r
= std::move(__op
)(__p
+ 0, __n
+ 0);
3797 #ifdef __cpp_lib_concepts
3798 static_assert(ranges::__detail::__is_integer_like
<decltype(__r
)>);
3800 static_assert(__gnu_cxx::__is_integer_nonstrict
<decltype(__r
)>::__value
,
3801 "resize_and_overwrite operation must return an integer");
3803 _GLIBCXX_DEBUG_ASSERT(__r
>= 0 && __r
<= __n
);
3804 __term
._M_r
= size_type(__r
);
3805 if (__term
._M_r
> __n
)
3806 __builtin_unreachable();
3811 _GLIBCXX_END_NAMESPACE_VERSION
3813 #endif // ! _GLIBCXX_USE_CXX11_ABI
3814 #endif // _COW_STRING_H