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
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;
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());
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
52. 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
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());
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
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());
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
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());
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());
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
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 |
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
57. If
*this
and
str are the same object,
the member has no effect
.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);
Effects:
Move assigns as a sequence container (
[container.requirements]),
except that iterators, pointers and references may be invalidated
. 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);