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;
1
#
Effects: Constructs an object of class basic_­string.
The postconditions of this function are indicated in Table 50.
Table 50 — basic_­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;
2
#
Effects: Constructs an object of class basic_­string as indicated in Table 51.
In the second form, str is left in a valid state with an unspecified value.
Table 51 — basic_­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());
3
#
Throws: out_­of_­range if pos > str.size().
4
#
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 52.
🔗
basic_string(const basic_string& str, size_type pos, size_type n, const Allocator& a = Allocator());
5
#
Throws: out_­of_­range if pos > str.size().
6
#
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 52.
Table 52 — basic_­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());
7
#
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);
8
#
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());
9
#
Effects: Same as basic_­string(sv.data(), sv.size(), a).
🔗
basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
10
#
Requires: s points to an array of at least n elements of charT.
11
#
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 53.
Table 53 — basic_­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());
12
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
13
#
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 54.
Table 54 — basic_­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());
14
#
Requires: n < npos.
15
#
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 55.
Table 55 — basic_­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());
16
#
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());
17
#
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);
18
#
Effects: Constructs an object of class basic_­string as indicated in Table 56.
The stored allocator is constructed from alloc.
In the second form, str is left in a valid state with an unspecified value.
Table 56 — basic_­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
19
#
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>;
20
#
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);
21
#
Effects: If *this and str are not the same object, modifies *this as shown in Table 57.
22
#
If *this and str are the same object, the member has no effect.
23
#
Returns: *this.
Table 57 — operator=(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);
24
#
Effects: Move assigns as a sequence container ([container.requirements]), except that iterators, pointers and references may be invalidated.
25
#
Returns: *this.
🔗
basic_string& operator=(basic_string_view<charT, traits> sv);
26
#
Effects: Equivalent to: return assign(sv);
🔗
basic_string& operator=(const charT* s);
27
#
Returns: *this = basic_­string(s).
28
#
Remarks: Uses traits​::​length().
🔗
basic_string& operator=(charT c);
29
#
Returns: *this = basic_­string(1, c).
🔗
basic_string& operator=(initializer_list<charT> il);
30
#
Effects: As if by: *this = basic_­string(il);
31
#
Returns: *this.