bsl::list

Name

Description

allocator_type

Allocator type used by this list.

const_iterator

Iterator providing non‐modifiable access to elements in this list.

const_pointer

Pointer to a non‐modifiable element in this list.

const_reference

Reference to a non‐modifiable element stored in this list.

const_reverse_iterator

Reverse iterator over non‐modifiable list elements.

difference_type

Signed integral type used to express distances between iterators.

iterator

Iterator providing modifiable access to elements in this list.

pointer

Pointer to a modifiable element in this list.

reference

Reference to an element stored in this list.

reverse_iterator

Reverse iterator over modifiable list elements.

size_type

Unsigned integral type large enough to hold any valid element count.

value_type

Type of the elements stored in this list.

Name

Description

list [constructor]

Constructors

~list [destructor]

Destroy this list by calling the destructor for each element and deallocating all allocated storage.

operator=

Assignment operators

append_range

Append to the end of this object the elements of the specified range. Note that range must meet the requirements of an input range and the values from range must have a type matching or convertible to (template parameter) VALUE.

assign

assign overloads

assign_range

Assign to this object the elements of the specified range. Note that range must meet the requirements of an input range and the values from range must have a type matching or convertible to (template parameter) VALUE.

back

back overloads

begin

begin overloads

cbegin

Return an iterator providing non‐modifiable access to the first value_type object in the ordered sequence of value_type objects maintained by this list, or the end iterator if this list is empty.

cend

Return the past‐the‐end (forward) iterator providing non‐modifiable access to this list.

clear

Remove all the elements from this list.

crbegin

Return a reverse iterator providing non‐modifiable access to the last element in this list, and the past‐the‐end reverse iterator if this list is empty.

crend

Return the past‐the‐end reverse iterator providing non‐modifiable access to this list.

emplace

Insert at the specified position in this list a newly created value_type object, constructed by forwarding get_allocator() (if required) and the specified (variable number of) arguments to the corresponding constructor of value_type, and return an iterator providing modifiable access to the newly created and inserted element. If an exception is thrown (other than by the copy constructor, move constructor, assignment operator, or move assignment operator of value_type), this method has no effect. This method requires that the (template parameter) VALUE be move‐insertable into this list and emplace‐constructible from arguments (see {Requirements on VALUE}). The behavior is undefined unless position is an iterator in the range [cbegin() .. cend()] (both endpoints included).

emplace_back

Append to the back of this list a newly created value_type object, constructed by forwarding get_allocator() (if required) and the specified (variable number of) arguments to the corresponding constructor of value_type. Return a reference providing modifiable access to the inserted element. If an exception is thrown (other than by the move constructor of a non‐copy‐insertable value_type), this method has no effect. This method requires that the (template parameter) VALUE be move‐insertable into this list and emplace‐constructible from arguments (see {Requirements on VALUE}).

emplace_front

Prepend to the front of this list a newly created value_type object, constructed by forwarding get_allocator() (if required) and the specified (variable number of) arguments to the corresponding constructor of value_type. Return a reference providing modifiable access to the inserted element. If an exception is thrown (other than by the move constructor of a non‐copy‐insertable value_type), this method has no effect. This method requires that the (template parameter) VALUE be move‐insertable into this list and emplace‐constructible from arguments (see {Requirements on VALUE}).

empty

Return true if this list has no elements, and false otherwise.

end

end overloads

erase

erase overloads

front

front overloads

get_allocator

Return a copy of the allocator used for memory allocation by this list.

insert

insert overloads

insert_range

Insert at the specified position in this object the elements of the specified range. Note that range must meet the requirements of an input range and the values from range must have a type matching or convertible to (template parameter) VALUE.

max_size

Return an upper bound on the largest number of elements that this list could possibly hold. Note that the return value of this function does not guarantee that this list can successfully grow that large, or even close to that large without running out of resources.

merge

merge overloads

pop_back

Remove and destroy the last element of this list. The behavior is undefined unless this list contains at least one element.

pop_front

Remove and destroy the first element of this list. The behavior is undefined unless this list contains at least one element.

prepend_range

Prepend to the front of this object the elements of the specified range. Note that range must meet the requirements of an input range and the values from range must have a type matching or convertible to (template parameter) VALUE.

push_back

push_back overloads

push_front

push_front overloads

rbegin

rbegin overloads

remove

Erase all the elements having the specified value from this list and return the number of erased elements.

remove_if

Erase all the elements in this list for which the specified unary predicate returns true and return the number of erased elements.

rend

rend overloads

resize

resize overloads

reverse

Reverse the order of the elements in this list.

size

Return the number of elements in this list.

sort

sort overloads

splice

splice overloads

swap

Exchange the value of this object with that of the specified other object; also exchange the allocator of this object with that of other if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This method provides the no‐throw exception‐safety guarantee. This operation has O[1] complexity if either this object was created with the same allocator as other or ALLOCATOR has the propagate_on_container_swap trait; otherwise, it has O[n + m] complexity, where n and m are the number of elements in this object and other, respectively. Note that this method`s support for swapping objects created with different allocators when ALLOCATOR does not have the propagate_on_container_swap trait is a departure from the C++ Standard.

unique

unique overloads

Name

Description

list<VALUE>

Deduce the template parameter VALUE from the value_type of the iterators supplied to the constructor of list.

list<VALUE>

Deduce the template parameter VALUE from the value_type of the intializer_list supplied to the constructor of list. This deduction guide does not participate unless the specified ALLOC is convertible to bsl::allocator<CHAR_TYPE>.

list<VALUE>

Deduce the template parameter VALUE from the value_type of the iterators supplied to the constructor of list. This deduction guide does not participate unless the specified ALLOC is convertible to bsl::allocator<CHAR_TYPE>.

list<VALUE>

Deduce the template parameter VALUE from the corresponding parameter supplied to the constructor of list. This deduction guide does not participate unless the supplied allocator is convertible to bsl::allocator<VALUE>.

list<VALUE, ALLOCATOR>

Deduce the template parameter VALUE from the value_type of the iterators supplied to the constructor of list. Deduce the template parameter ALLOCATOR from the allocator supplied to the constructor of list. This deduction guide does not participate unless the supplied allocator meets the requirements of a standard allocator.

list<ranges::range_value_t<t_RANGE>, t_ALLOCATOR>

Deduce the template parameters VALUE_TYPE and ALLOCATOR from the parameters supplied to the constructor of list.

Name

Description

bsl::List_NodeProctor

This class provides a proctor to free a node containing an uninitialized VALUE object in the event that an exception is thrown.

Name

Description

erase

Erase all the elements in the specified list l that compare equal to the specified value. Return the number of elements erased.

erase_if

Erase all the elements in the specified list l that satisfy the specified predicate predicate. Return the number of elements erased.

operator<=>

Perform a lexicographic three‐way comparison of the specified lhs and the specified rhs lists by using the comparison operators of VALUE on each element; return the result of that comparison.

operator==

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two list objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE be equality‐comparable (see {Requirements on VALUE}).

swap

Exchange the value of the specified a object with that of the specified b object; also exchange the allocator of a with that of b if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This function provides the no‐throw exception‐safety guarantee. This operation has O[1] complexity if either a was created with the same allocator as b or ALLOCATOR has the propagate_on_container_swap trait; otherwise, it has O[n + m] complexity, where n and m are the number of elements in a and b, respectively. Note that this function`s support for swapping objects created with different allocators when ALLOCATOR does not have the propagate_on_container_swap trait is a departure from the C++ Standard.