forward_list Class

 

The new home for Visual Studio documentation is Visual Studio 2017 Documentation on docs.microsoft.com.

The latest version of this topic can be found at forward_list Class.

Describes an object that controls a varying-length sequence of elements. The sequence is stored as a singly-linked list of nodes, each containing a member of type Type.

template <class Type,   
    class Allocator = allocator<Type>>  
class forward_list   

Parameters

ParameterDescription
TypeThe element data type to be stored in the forward_list.
AllocatorThe stored allocator object that encapsulates details about the forward_list allocation and deallocation of memory. This parameter is optional. The default value is allocator< Type>.

A forward_list object allocates and frees storage for the sequence it controls through a stored object of class Allocator that is based on allocator Class (commonly known as std::allocator). For more information, see Allocators. An allocator object must have the same external interface as an object of template class allocator.

System_CAPS_ICON_note.jpg Note

The stored allocator object is not copied when the container object is assigned.

Iterators, pointers and references might become invalid when elements of their controlled sequence are erased through forward_list. Insertions and splices performed on the controlled sequence through forward_list do not invalidate iterators.

Additions to the controlled sequence might occur by calls to forward_list::insert_after, which is the only member function that calls the constructor Type(const T&). forward_list might also call move constructors. If such an expression throws an exception, the container object inserts no new elements and rethrows the exception. Thus, an object of template class forward_list is left in a known state when such exceptions occur.

Constructors

forward_listConstructs an object of type forward_list.

Typedefs

allocator_typeA type that represents the allocator class for a forward list object.
const_iteratorA type that provides a constant iterator for the forward list.
const_pointerA type that provides a pointer to a const element in a forward list.
const_referenceA type that provides a constant reference to an element in the forward list.
difference_typeA signed integer type that can be used to represent the number of elements of a forward list in a range between elements pointed to by iterators.
iteratorA type that provides an iterator for the forward list.
pointerA type that provides a pointer to an element in the forward list.
referenceA type that provides a reference to an element in the forward list.
size_typeA type that represents the unsigned distance between two elements.
value_typeA type that represents the type of element stored in a forward list.

Member Functions

assignErases elements from a forward list and copies a new set of elements to a target forward list.
before_beginReturns an iterator addressing the position before the first element in a forward list.
beginReturns an iterator addressing the first element in a forward list.
cbefore_beginReturns a const iterator addressing the position before the first element in a forward list.
cbeginReturns a const iterator addressing the first element in a forward list.
cendReturns a const iterator that addresses the location succeeding the last element in a forward list.
clearErases all the elements of a forward list.
emplace_afterMove constructs a new element after a specified position.
emplace_frontAdds an element constructed in place to the beginning of the list.
emptyTests whether a forward list is empty.
endReturns an iterator that addresses the location succeeding the last element in a forward list.
erase_afterRemoves elements from the forward list after a specified position.
frontReturns a reference to the first element in a forward list.
get_allocatorReturns a copy of the allocator object used to construct a forward list.
insert_afterAdds elements to the forward list after a specified position.
max_sizeReturns the maximum length of a forward list.
mergeRemoves the elements from the argument list, inserts them into the target forward list, and orders the new, combined set of elements in ascending order or in some other specified order.
pop_frontDeletes the element at the beginning of a forward list.
push_frontAdds an element to the beginning of a forward list.
removeErases elements in a forward list that matches a specified value.
remove_ifErases elements from a forward list for which a specified predicate is satisfied.
resizeSpecifies a new size for a forward list.
reverseReverses the order in which the elements occur in a forward list.
sortArranges the elements in ascending order or with an order specified by a predicate.
splice_afterRestitches links between nodes.
swapExchanges the elements of two forward lists.
uniqueRemoves adjacent elements that pass a specified test.

Operators

operator=Replaces the elements of the forward list with a copy of another forward list.

Header: <forward_list>

Namespace: std

A type that represents the allocator class for a forward list object.

typedef Allocator allocator_type;  

Remarks

allocator_type is a synonym for the template parameter Allocator.

Erases elements from a forward list and copies a new set of elements to a target forward list.

 
void assign(
    size_type Count,   
    const Type& Val);

void assign(
    initializer_list<Type> IList);

template <class InputIterator>  
void assign(InputIterator First, InputIterator Last);

Parameters

ParameterDescription
firstThe beginning of the replacement range.
lastThe end of the replacement range.
countThe number of elements to assign.
valThe value to assign each element.
TypeThe type of the value.
IListThe initializer_list to copy.

Remarks

If the forward_list is an integer type, the first member function behaves the same as assign((size_type)First, (Type)Last). Otherwise, the first member function replaces the sequence controlled by *this with the sequence [ First, Last), which must not overlap the initial controlled sequence.

The second member function replaces the sequence controlled by *this with a repetition of Count elements of value Val.

The third member function copies the elements of the initializer_list into the forward_list.

Returns an iterator addressing the position before the first element in a forward list.

const_iterator before_begin() const;

 
iterator before_begin();

Return Value

A forward iterator that points just before the first element of the sequence (or just before the end of an empty sequence).

Remarks

Returns an iterator addressing the first element in a forward list.

const_iterator begin() const;

 
iterator begin();

Return Value

A forward iterator that points at the first element of the sequence (or just beyond the end of an empty sequence).

Remarks

Returns a const iterator addressing the position before the first element in a forward list.

const_iterator cbefore_begin() const;

Return Value

A forward iterator that points just before the first element of the sequence (or just before the end of an empty sequence).

Remarks

Returns a const iterator that addresses the first element in the range.

const_iterator cbegin() const;

Return Value

A const forward-access iterator that points at the first element of the range, or the location just beyond the end of an empty range (for an empty range, cbegin() == cend()).

Remarks

With the return value of cbegin, the elements in the range cannot be modified.

You can use this member function in place of the begin() member function to guarantee that the return value is const_iterator. Typically, it's used in conjunction with the auto type deduction keyword, as shown in the following example. In the example, consider Container to be a modifiable (non- const) container of any kind that supports begin() and cbegin().

 
auto i1 = Container.begin();
// i1 is Container<T>::iterator   
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator  

Returns a const iterator that addresses the location just beyond the last element in a range.

const_iterator cend() const;

Return Value

A forward-access iterator that points just beyond the end of the range.

Remarks

cend is used to test whether an iterator has passed the end of its range.

You can use this member function in place of the end() member function to guarantee that the return value is const_iterator. Typically, it's used in conjunction with the auto type deduction keyword, as shown in the following example. In the example, consider Container to be a modifiable (non- const) container of any kind that supports end() and cend().

 
auto i1 = Container.end();
// i1 is Container<T>::iterator   
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator  

The value returned by cend should not be dereferenced.

Erases all the elements of a forward list.

void clear();

Remarks

This member function calls erase_after(before_begin(), end()).

A type that provides a constant iterator for the forward list.

typedef implementation-defined const_iterator;  

Remarks

const_iterator describes an object that can serve as a constant forward iterator for the controlled sequence. It is described here as a synonym for an implementation-defined type.

A type that provides a pointer to a const element in a forward list.

typedef typename Allocator::const_pointer  
    const_pointer; 

Remarks

A type that provides a constant reference to an element in the forward list.

typedef typename Allocator::const_reference const_reference;  

Remarks

A signed integer type that can be used to represent the number of elements of a forward list in a range between elements pointed to by iterators.

typedef typename Allocator::difference_type difference_type;  

Remarks

difference_type describes an object that can represent the difference between the addresses of any two elements in the controlled sequence.

Move constructs a new element after a specified position.

template <class T>  
iterator emplace_after(const_iterator _Where, Type&& val);

Parameters

ParameterDescription
_WhereThe position in the target forward list where the new element is constructed.
valThe constructor argument.

Return Value

An iterator that designates the newly inserted element.

Remarks

This member function inserts an element with the constructor arguments val just after the element pointed to by _Where in the controlled sequence. Its behavior is otherwise the same as forward_list::insert_after.

Adds an element constructed in place to the beginning of the list.

template <class Type>  
void emplace_front(Type&& val);

Parameters

ParameterDescription
valThe element added to the beginning of the forward list.

Remarks

This member function inserts an element with the constructor arguments _ val at the end of the controlled sequence.

If an exception is thrown, the container is left unaltered and the exception is rethrown.

Tests whether a forward list is empty.

bool empty() const;

Return Value

true if the forward list is empty; otherwise, false.

Returns an iterator that addresses the location succeeding the last element in a forward list.

const_iterator end() const;

 
iterator end();

Return Value

A forward iterator that points just beyond the end of the sequence.

Removes elements from the forward list after a specified position.

iterator erase_after(const_iterator _Where);

iterator erase_after(const_iterator first, const_iterator last);

Parameters

ParameterDescription
_WhereThe position in the target forward list where the element is erased.
firstThe beginning of the range to erase.
lastThe end of the range to erase.

Return Value

An iterator that designates the first element remaining beyond any elements removed, or forward_list::end if no such element exists.

Remarks

The first member function removes the element of the controlled sequence just after _Where.

The second member function removes the elements of the controlled sequence in the range ( first, last) (neither end point is included).

Erasing N elements causes N destructor calls. Reallocation occurs, so iterators and references become invalid for the erased elements.

The member functions never throw an exception.

Constructs an object of type forward_list.

forward_list();

explicit forward_list(const Allocator& Al);

explicit forward_list(size_type Count);

forward_list(size_type Count, const Type& Val);

forward_list(size_type Count, const Type& Val,  
    const Allocator& Al);

forward_list(const forward_list& Right);

forward_list(const forward_list& Right, const Allocator& Al);

forward_list(forward_list&& Right);

forward_list(forward_list&& Right, const Allocator& Al);

forward_list(
initializer_list<Type> IList,  
    const Alloc& Al);

template <class InputIterator>  
forward_list(InputIterator First, InputIterator Last);

template <class InputIterator>  
forward_list(InputIterator First, InputIterator Last,  
    const Allocator& Al);

Parameters

ParameterDescription
AlThe allocator class to use with this object.
CountThe number of elements in the list constructed.
ValThe value of the elements in the list constructed.
RightThe list of which the constructed list is to be a copy.
FirstThe position of the first element in the range of elements to be copied.
LastThe position of the first element beyond the range of elements to be copied.
IListThe initializer_list to copy.

Remarks

All constructors store an allocator and initialize the controlled sequence. The allocator object is the argument Al, if present. For the copy constructor, it is right.get_allocator(). Otherwise, it is Allocator().

The first two constructors specify an empty initial controlled sequence.

The third constructor specifies a repetition of Count elements of value Type().

The fourth and fifth constructors specify a repetition of Count elements of value Val.

The sixth constructor specifies a copy of the sequence controlled by Right. If InputIterator is an integer type, the next two constructors specify a repetition of (size_type)First elements of value (Type)Last. Otherwise, the next two constructors specify the sequence [First, Last).

The ninth and tenth constructors are the same as the sixth, but with an rvalue reference.

The last constructor specifies the initial controlled sequence with an object of class initializer_list<Type>.

Returns a reference to the first element in a forward list.

reference front();

const_reference front() const;

Return Value

A reference to the first element of the controlled sequence, which must be non-empty.

Returns a copy of the allocator object used to construct a forward list.

allocator_type get_allocator() const;

Return Value

The stored allocator object.

Adds elements to the forward list after a specified position.

iterator insert_after(
    const_iterator Where,   
    const Type& Val);

void insert_after(
    const_iterator Where, size_type Count,   
    const Type& Val);

void insert_after(
    const iterator Where,  
    initializer_list<Type> IList);

iterator insert_after(
    const_iterator Where,   
    Type&& Val);

template <class InputIterator>  
void insert_after(
    const_iterator Where,   
    InputIterator First,  
    InputIterator Last);

Parameters

ParameterDescription
WhereThe position in the target forward list where the first element is inserted.
CountThe number of elements to insert.
FirstThe beginning of the insertion range.
LastThe end of the insertion range.
ValThe element added to the forward list.
IListThe initializer_list to insert.

Return Value

An iterator that designates the newly inserted element (first and last member functions only).

Remarks

Each of the member functions inserts—just after the element pointed to by Where in the controlled sequence—a sequence that' specified by the remaining operands.

The first member function inserts an element that has value Val and returns an iterator that designates the newly inserted element.

The second member function inserts a repetition of Count elements of value Val.

If InputIterator is an integer type, the third member function behaves the same as insert(it, (size_type)First, (Type)Last). Otherwise, it inserts the sequence [First, Last), which must not overlap the initial controlled sequence.

The fourth member function inserts the sequence that's specified by an object of class initializer_list<Type>.

The last member function is the same as the first, but with an rvalue reference.

Inserting N elements causes N constructor calls. Reallocation occurs, but no iterators or references become invalid.

If an exception is thrown during the insertion of one or more elements, the container is left unaltered and the exception is rethrown.

A type that provides an iterator for the forward list.

typedef implementation-defined iterator;  

Remarks

iterator describes an object that can serve as a forward iterator for the controlled sequence. It is described here as a synonym for an implementation-defined type.

Returns the maximum length of a forward list.

size_type max_size() const;

Return Value

The length of the longest sequence that the object can control.

Remarks

Combines two sorted sequences into a single sorted sequence in linear time. Removes the elements from the argument list, and inserts them into this forward_list. The two lists should be sorted by the same compare function object before the call to merge. The combined list will be sorted by that compare function object.

void merge(forward_list& right);

template <class Predicate>  
void merge(forward_list& right, Predicate comp);

Parameters

ParameterDescription
rightThe forward list to merge from.
compThe compare function object that is used to sort elements.

Remarks

forward_list::merge removes the elements from the forward_list`` right``, and inserts them into this forward_list. Both sequences must be ordered by the same predicate, described below. The combined sequence is also ordered by that compare function object.

For the iterators Pi and Pj designating elements at positions i and j, the first member function imposes the order !(*Pj < *Pi) whenever i < j. (The elements are sorted in ascending order.) The second member function imposes the order ! comp(*Pj, *Pi) whenever i < j.

No pairs of elements in the original controlled sequence are reversed in the resulting controlled sequence. If a pair of elements in the resulting controlled sequence compares equal ( !(*Pi < *Pj) && !(*Pj < *Pi)), an element from the original controlled sequence appears before an element from the sequence controlled by right.

An exception occurs only if comp throws an exception. In that case, the controlled sequence is left in unspecified order and the exception is rethrown.

Replaces the elements of the forward list with a copy of another forward list.

forward_list& operator=(const forward_list& right);

forward_list& operator=(initializer_list<Type> _IList);

forward_list& operator=(forward_list&& right);

Parameters

ParameterDescription
rightThe forward list being copied into the forward list.
_IListA brace-enclosed initializer list, which behaves just like a sequence of elements of type Type.

Remarks

The first member operator replaces the controlled sequence with a copy of the sequence controlled by right.

The second member operator replaces the controlled sequence from an object of class initializer_list<Type>.

The third member operator is the same as the first, but with an rvalue reference.

A type that provides a pointer to an element in the forward list.

typedef typename Allocator::pointer pointer;  

Remarks

Deletes the element at the beginning of a forward list.

void pop_front();

Remarks

The first element of the forward list must be non-empty.

The member function never throws an exception.

Adds an element to the beginning of a forward list.

void push_front(const Type& val);

void push_front(Type&& val);

Parameters

ParameterDescription
valThe element added to the beginning of the forward list.

Remarks

If an exception is thrown, the container is left unaltered and the exception is rethrown.

A type that provides a reference to an element in the forward list.

typedef typename Allocator::reference reference;  

Remarks

Erases elements in a forward list that matches a specified value.

void remove(const Type& val);

Parameters

ParameterDescription
valThe value which, if held by an element, will result in that element's removal from the list.

Remarks

The member function removes from the controlled sequence all elements, designated by the iterator P, for which *P == val.

The member function never throws an exception.

Erases elements from a forward list for which a specified predicate is satisfied.

template <class Predicate>  
void remove_if(Predicate pred);

Parameters

ParameterDescription
predThe unary predicate which, if satisfied by an element, results in the deletion of that element from the list.

Remarks

The member function removes from the controlled sequence all elements, designated by the iterator P, for which pred(*P) is true.

An exception occurs only if pred throws an exception. In that case, the controlled sequence is left in an unspecified state and the exception is rethrown.

Specifies a new size for a forward list.

void resize(size_type _Newsize);

void resize(size_type _Newsize, const Type& val);

Parameters

ParameterDescription
_NewsizeThe number of elements in the resized forward list.
valThe value to use for padding.

Remarks

The member functions both ensure that the number of elements in the list henceforth is _Newsize. If it must make the controlled sequence longer, the first member function appends elements with value Type(), while the second member function appends elements with value val. To make the controlled sequence shorter, both member functions effectively call erase_after(begin() + _Newsize - 1, end()).

Reverses the order in which the elements occur in a forward list.

void reverse();

Remarks

A type that represents the unsigned distance between two elements.

typedef typename Allocator::size_type size_type;  

Remarks

The unsigned integer type describes an object that can represent the length of any controlled sequence.

Arranges the elements in ascending order or with an order specified by a predicate.

void sort();

template <class Predicate>  
void sort(Predicate pred);

Parameters

ParameterDescription
predThe ordering predicate.

Remarks

Both member functions order the elements in the controlled sequence by a predicate, described below.

For the iterators Pi and Pj designating elements at positions i and j, the first member function imposes the order !(*Pj < *Pi) whenever i < j. (The elements are sorted in ascending order.) The member template function imposes the order ! pred(*Pj, *Pi) whenever i < j. No ordered pairs of elements in the original controlled sequence are reversed in the resulting controlled sequence. (The sort is stable.)

An exception occurs only if pred throws an exception. In that case, the controlled sequence is left in unspecified order and the exception is rethrown.

Removes elements from a source forward_list and inserts them into a destination forward_list.

// insert the entire source forward_list  
void splice_after(const_iterator Where,
    forward_list& Source);

void splice_after(const_iterator Where,
    forward_list&& Source);

 
// insert one element of the source forward_list  
void splice_after(const_iterator Where,
    forward_list& Source,
    const_iterator Iter);

void splice_after(const_iterator Where,
    forward_list&& Source,
    const_iterator Iter);

 
// insert a range of elements from the source forward_list  
void splice_after(const_iterator Where,
    forward_list& Source,
    const_iterator First,
    const_iterator Last);

void splice_after(const_iterator Where,
    forward_list&& Source,
    const_iterator First,
    const_iterator Last);

Parameters

Where
The position in the destination forward_list after which to insert.

Source
The source forward_list that is to be inserted into the destination forward_list.

Iter
The element to be inserted from the source forward_list.

First
The first element in the range to be inserted from source forward_list.

Last
The first position beyond the range to be inserted from the source forward_list.

Remarks

The first pair of member functions inserts the sequence controlled by Source just after the element in the controlled sequence pointed to by Where. It also removes all elements from Source. ( &Source must not equal this.)

The second pair of member functions removes the element just after Iter in the sequence controlled by Source and inserts it just after the element in the controlled sequence pointed to by Where. (If Where == Iter || Where == ++Iter, no change occurs.)

The third pair of member functions (ranged splice) inserts the subrange designated by (First, Last) from the sequence controlled by Source just after the element in the controlled sequence pointed to by Where. It also removes the original subrange from the sequence controlled by Source. (If &Source == this, the range (First, Last) must not include the element pointed to by Where.)

If the ranged splice inserts N elements, and &Source != this, an object of class iterator is incremented N times.

No iterators, pointers, or references that designate spliced elements become invalid.

Example

// forward_list_splice_after.cpp  
// compile with: /EHsc /W4  
#include <forward_list>  
#include <iostream>  
  
using namespace std;  
  
template <typename S> void print(const S& s) {  
    for (const auto& p : s) {  
        cout << "(" << p << ") ";  
    }  
  
    cout << endl;  
}  
  
int main()  
{  
    forward_list<int> c1{ 10, 11 };  
    forward_list<int> c2{ 20, 21, 22 };  
    forward_list<int> c3{ 30, 31 };  
    forward_list<int> c4{ 40, 41, 42, 43 };  
  
    forward_list<int>::iterator where_iter;  
    forward_list<int>::iterator first_iter;  
    forward_list<int>::iterator last_iter;  
  
    cout << "Beginning state of lists:" << endl;  
    cout << "c1 = ";  
    print(c1);  
    cout << "c2 = ";  
    print(c2);  
    cout << "c3 = ";  
    print(c3);  
    cout << "c4 = ";  
    print(c4);  
  
    where_iter = c2.begin();  
    ++where_iter; // start at second element  
    c2.splice_after(where_iter, c1);  
    cout << "After splicing c1 into c2:" << endl;  
    cout << "c1 = ";  
    print(c1);  
    cout << "c2 = ";  
    print(c2);  
  
    first_iter = c3.begin();  
    c2.splice_after(where_iter, c3, first_iter);  
    cout << "After splicing the first element of c3 into c2:" << endl;  
    cout << "c3 = ";  
    print(c3);  
    cout << "c2 = ";  
    print(c2);  
  
    first_iter = c4.begin();  
    last_iter = c4.end();  
    // set up to get the middle elements  
    ++first_iter;  
    c2.splice_after(where_iter, c4, first_iter, last_iter);  
    cout << "After splicing a range of c4 into c2:" << endl;  
    cout << "c4 = ";  
    print(c4);  
    cout << "c2 = ";  
    print(c2);  
}  
  

Beginning state of lists:c1 = (10) (11)c2 = (20) (21) (22)c3 = (30) (31)c4 = (40) (41) (42) (43)After splicing c1 into c2:c1 =c2 = (20) (21) (10) (11) (22)After splicing the first element of c3 into c2:c3 = (30)c2 = (20) (21) (31) (10) (11) (22)After splicing a range of c4 into c2:c4 = (40) (41)c2 = (20) (21) (42) (43) (31) (10) (11) (22)  

Exchanges the elements of two forward lists.

void swap(forward_list& right);

Parameters

ParameterDescription
rightThe forward list providing the elements to be exchanged.

Remarks

The member function swaps the controlled sequences between *this and right. If get_allocator() == right.get_allocator(), it does so in constant time, it throws no exceptions, and it invalidates no references, pointers, or iterators that designate elements in the two controlled sequences. Otherwise, it performs a number of element assignments and constructor calls proportional to the number of elements in the two controlled sequences.

Eliminates all but the first element from every consecutive group of equal elements.

void unique();

template <class BinaryPredicate>  
void unique(BinaryPredicate comp);

Parameters

ParameterDescription
compThe binary predicate used to compare successive elements.

Remarks

Keeps the first of each unique element, and removes the rest. The elements must be sorted so that elements of equal value are adjacent in the list.

The first member function removes from the controlled sequence every element that compares equal to its preceding element. For the iterators Pi and Pj designating elements at positions i and j, the second member function removes every element for which i + 1 == j && comp(*Pi, *Pj).

For a controlled sequence of length N (> 0), the predicate comp(*Pi, *Pj) is evaluated N - 1 times.

An exception occurs only if comp throws an exception. In that case, the controlled sequence is left in an unspecified state and the exception is rethrown.

A type that represents the type of element stored in a forward list.

typedef typename Allocator::value_type value_type;  

Remarks

The type is a synonym for the template parameter _ Ty.

<forward_list>

Show: