24 Strings library [strings]

24.3 String classes [string.classes]

24.3.2 Class template basic_­string [basic.string]

24.3.2.2 basic_­string constructors and assignment operators [string.cons]

explicit basic_string(const Allocator& a) noexcept;
Effects: Constructs an object of class basic_­string.
The postconditions of this function are indicated in Table 55.
Table 55basic_­string(const Allocator&) effects
Element
Value
data()
a non-null pointer that is copyable and can have 0 added to it
size()
0
capacity()
an unspecified value
basic_string(const basic_string& str); basic_string(basic_string&& str) noexcept;
Effects: Constructs an object of class basic_­string as indicated in Table 56.
In the second form, str is left in a valid state with an unspecified value.
Table 56basic_­string(const basic_­string&) effects
Element
Value
data()
points at the first element of an allocated copy of the array whose first element is pointed at by str.data()
size()
str.size()
capacity()
a value at least as large as size()
basic_string(const basic_string& str, size_type pos, const Allocator& a = Allocator());
Throws: out_­of_­range if pos > str.size().
Effects: Constructs an object of class basic_­string and determines the effective length rlen of the initial string value as str.size() - pos, as indicated in Table 57.
basic_string(const basic_string& str, size_type pos, size_type n, const Allocator& a = Allocator());
Throws: out_­of_­range if pos > str.size().
Effects: Constructs an object of class basic_­string and determines the effective length rlen of the initial string value as the smaller of n and str.size() - pos, as indicated in Table 57.
Table 57basic_­string(const basic_­string&, size_­type, const Allocator&) and
basic_­string(const basic_­string&, size_­type, size_­type, const Allocator&) effects
Element
Value
data()
points at the first element of an allocated copy of rlen consecutive elements of the string controlled by str beginning at position pos
size()
rlen
capacity()
a value at least as large as size()
template<class T> basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then behaves the same as:
basic_string(sv.substr(pos, n), a);
Remarks: This constructor shall not participate in overload resolution unless is_­convertible_­v<const T&, basic_­string_­view<charT, traits>> is true.
explicit basic_string(basic_string_view<charT, traits> sv, const Allocator& a = Allocator());
Effects: Same as basic_­string(sv.data(), sv.size(), a).
basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
Requires: s points to an array of at least n elements of charT.
Effects: Constructs an object of class basic_­string and determines its initial string value from the array of charT of length n whose first element is designated by s, as indicated in Table 58.
Table 58basic_­string(const charT*, size_­type, const Allocator&) effects
Element
Value
data()
points at the first element of an allocated copy of the array whose first element is pointed at by s
size()
n
capacity()
a value at least as large as size()
basic_string(const charT* s, const Allocator& a = Allocator());
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
Effects: Constructs an object of class basic_­string and determines its initial string value from the array of charT of length traits​::​length(s) whose first element is designated by s, as indicated in Table 59.
Table 59basic_­string(const charT*, const Allocator&) effects
Element
Value
data()
points at the first element of an allocated copy of the array whose first element is pointed at by s
size()
traits​::​length(s)
capacity()
a value at least as large as size()
basic_string(size_type n, charT c, const Allocator& a = Allocator());
Requires: n < npos.
Effects: Constructs an object of class basic_­string and determines its initial string value by repeating the char-like object c for all n elements, as indicated in Table 60.
Table 60basic_­string(size_­t, charT, const Allocator&) effects
Element
Value
data()
points at the first element of an allocated array of n elements, each storing the initial value c
size()
n
capacity()
a value at least as large as size()
template<class InputIterator> basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
Effects: If InputIterator is an integral type, equivalent to:
basic_string(static_cast<size_type>(begin), static_cast<value_type>(end), a);
Otherwise constructs a string from the values in the range [begin, end), as indicated in the Sequence Requirements table (see [sequence.reqmts]).
basic_string(initializer_list<charT> il, const Allocator& a = Allocator());
Effects: Same as basic_­string(il.begin(), il.end(), a).
basic_string(const basic_string& str, const Allocator& alloc); basic_string(basic_string&& str, const Allocator& alloc);
Effects: Constructs an object of class basic_­string as indicated in Table 61.
The stored allocator is constructed from alloc.
In the second form, str is left in a valid state with an unspecified value.
Table 61basic_­string(const basic_­string&, const Allocator&)
and basic_­string(basic_­string&&, const Allocator&) effects
Element
Value
data()
points at the first element of an allocated copy of the array whose first element is pointed at by the original value of str.data().
size()
the original value of str.size()
capacity()
a value at least as large as size()
get_­allocator()
alloc
Throws: The second form throws nothing if alloc == str.get_­allocator().
template<class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> basic_string(InputIterator, InputIterator, Allocator = Allocator()) -> basic_string<typename iterator_traits<InputIterator>::value_type, char_traits<typename iterator_traits<InputIterator>::value_type>, Allocator>;
Remarks: Shall not participate in overload resolution if InputIterator is a type that does not qualify as an input iterator, or if Allocator is a type that does not qualify as an allocator ([container.requirements.general]).
basic_string& operator=(const basic_string& str);
Effects: If *this and str are not the same object, modifies *this as shown in Table 62.
If *this and str are the same object, the member has no effect.
Returns: *this.
Table 62operator=(const basic_­string&) effects
Element
Value
data()
points at the first element of an allocated copy of the array whose first element is pointed at by str.data()
size()
str.size()
capacity()
a value at least as large as size()
basic_string& operator=(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value || allocator_traits<Allocator>::is_always_equal::value);
Effects: Move assigns as a sequence container, except that iterators, pointers and references may be invalidated.
Returns: *this.
basic_string& operator=(basic_string_view<charT, traits> sv);
Effects: Equivalent to: return assign(sv);
basic_string& operator=(const charT* s);
Returns: *this = basic_­string(s).
Remarks: Uses traits​::​length().
basic_string& operator=(charT c);
Returns: *this = basic_­string(1, c).
basic_string& operator=(initializer_list<charT> il);
Effects: As if by: *this = basic_­string(il);
Returns: *this.