24 Strings library [strings]

24.3 String classes [string.classes]

24.3.2 Class template basic_­string [basic.string]

24.3.2.4 basic_­string 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.

void reserve(size_type res_arg=0);

10
#

The member function reserve() is a directive that informs a basic_­string object of a planned change in size, so that it can manage the storage allocation accordingly.

11
#

Effects: After reserve(), capacity() is greater or equal to the argument of reserve. [ Note: Calling reserve() with a res_­arg argument less than capacity() is in effect a non-binding shrink request. A call with res_­arg <= size() is in effect a non-binding shrink-to-fit request.  — end note ]

12
#

Throws: length_­error if res_­arg > max_­size().227

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());

bool empty() const noexcept;

17
#

Returns: size() == 0.

227)

reserve() uses allocator_­traits<Allocator>​::​allocate() which may throw an appropriate exception.