20 Strings library [strings]

20.3 String classes [string.classes]

20.3.2 Class template basic_­string [basic.string]

20.3.2.4 Capacity [string.capacity]

🔗
size_type size() const noexcept;
1
#
Returns: A count of the number of char-like objects currently in the string.
2
#
Complexity: Constant time.
🔗
size_type length() const noexcept;
3
#
Returns: size().
🔗
size_type max_size() const noexcept;
4
#
Returns: The largest possible number of char-like objects that can be stored in a basic_­string.
5
#
Complexity: Constant time.
🔗
void resize(size_type n, charT c);
6
#
Throws: length_­error if n > max_­size().
7
#
Effects: Alters the length of the string designated by *this as follows:
  • (7.1)
    If n <= size(), the function replaces the string designated by *this with a string of length n whose elements are a copy of the initial elements of the original string designated by *this.
  • (7.2)
    If n > size(), the function replaces the string designated by *this with a string of length n whose first size() elements are a copy of the original string designated by *this, and whose remaining elements are all initialized to c.
🔗
void resize(size_type n);
8
#
Effects: As if by resize(n, charT()).
🔗
size_type capacity() const noexcept;
9
#
Returns: The size of the allocated storage in the string.
10
#
Complexity: Constant time.
🔗
void reserve(size_type res_arg);
11
#
Effects: A directive that informs a basic_­string of a planned change in size, so that the storage allocation can be managed accordingly.
After reserve(), capacity() is greater or equal to the argument of reserve if reallocation happens; and equal to the previous value of capacity() otherwise.
Reallocation happens at this point if and only if the current capacity is less than the argument of reserve().
12
#
Throws: length_­error if res_­arg > max_­size().229
🔗
void shrink_to_fit();
13
#
Effects: shrink_­to_­fit is a non-binding request to reduce capacity() to size().
[ Note
:
The request is non-binding to allow latitude for implementation-specific optimizations.
— end note
 ]
It does not increase capacity(), but may reduce capacity() by causing reallocation.
14
#
Complexity: Linear in the size of the sequence.
15
#
Remarks: Reallocation invalidates all the references, pointers, and iterators referring to the elements in the sequence as well as the past-the-end iterator.
If no reallocation happens, they remain valid.
🔗
void clear() noexcept;
16
#
Effects: Behaves as if the function calls:
erase(begin(), end());
🔗
[[nodiscard]] bool empty() const noexcept;
17
#
Returns: size() == 0.
229)
reserve() uses allocator_­traits<Allocator>​::​allocate() which may throw an appropriate exception.