home | help 
std::forward_list(3)	       C++ Standard Libary	    std::forward_list(3)

NAME
     std::forward_list - std::forward_list

Synopsis
	Defined in header <forward_list>
	template<

	    class  T,							     (1)
     (since C++11)
	    class Allocator = std::allocator<T>

	> class forward_list;
	namespace pmr {

	    template< class T >
	    using forward_list =  std::forward_list<T,			     (2)
     (since C++17)
	std::pmr::polymorphic_allocator<T>>;

	}

	std::forward_list  is  a  container that supports fast insertion and re-
     moval of
	elements from anywhere in the container. Fast random access is not  sup-
     ported. It is
	implemented  as  a  singly-linked  list. Compared to std::list this con-
     tainer provides
	more space efficient storage when bidirectional iteration is not needed.

	Adding, removing and moving the elements within the list, or across sev-
     eral lists,
	does not invalidate the iterators currently referring to other	elements
     in the list.
	However, an iterator or reference referring to an element is invalidated
     when the
	corresponding element is removed (via erase_after) from the list.

	std::forward_list  meets  the  requirements of Container (except for the
     size member
	function and that operator=='s complexity  is  always  linear),  Alloca-
     torAwareContainer
	and SequenceContainer.

Template parameters
		    The type of the elements.

		    The  requirements that are imposed on the elements depend on
     the
		    actual operations performed on the container. Generally,  it
     is     (until
		    required  that element type is a complete type and meets the
     C++17)
		    requirements of Erasable, but many member functions impose
		    stricter requirements.
		    The requirements that are imposed on the elements depend  on
     the
		    actual  operations performed on the container. Generally, it
     is
		    required  that  element  type  meets  the  requirements   of
     Erasable, but
	T	   -  many  member  functions impose stricter requirements. This
     container
		    (but not its members) can be instantiated with an incomplete
		    element type if the allocator satisfies the  allocator  com-
     pleteness (since
		    requirements.
     C++17)

			      Feature-test    macro		  Value      Std
     Feature
									    Min-
     imal
		    __cpp_lib_incomplete_container_elements 201505L (C++17)  in-
     complete
									    type
									    sup-
     port

		    An allocator that is used to acquire/release memory and to
		    construct/destroy the elements in that memory. The type must
     meet the
		    requirements of Allocator.
	Allocator - The behavior is undefined
		    (until C++20)
		    The program is ill-formed
		    (since C++20) if Allocator::value_type is not the same as T.

Member types
	Member type	Definition
	value_type	T
	allocator_type	Allocator
	size_type	Unsigned integer type (usually std::size_t)
	difference_type Signed integer type (usually std::ptrdiff_t)
	reference	value_type&
	const_reference const value_type&
	pointer 	std::allocator_traits<Allocator>::pointer
	const_pointer	std::allocator_traits<Allocator>::const_pointer
	iterator	LegacyForwardIterator to value_type
	const_iterator	LegacyForwardIterator to const value_type

Member functions
	constructor	   constructs the forward_list
			   (public member function)
	destructor	   destructs the forward_list
			   (public member function)
	operator=	   assigns values to the container
			   (public member function)
	assign		   assigns values to the container
			   (public member function)
	assign_range	   assigns a range of values to the container
	(C++23) 	   (public member function)
	get_allocator	   returns the associated allocator
			   (public member function)

Element access
	front		   access the first element
			   (public member function)

Iterators
	before_begin	   returns an iterator to the element before beginning
	cbefore_begin	   (public member function)
	begin		   returns an iterator to the beginning
	cbegin		   (public member function)
	end		   returns an iterator to the end
	cend		   (public member function)

Capacity
	empty		   checks whether the container is empty
			   (public member function)
	max_size	   returns the maximum possible number of elements
			   (public member function)

Modifiers
	clear		   clears the contents
			   (public member function)
	insert_after	   inserts elements after an element
			   (public member function)
	emplace_after	   constructs elements in-place after an element
			   (public member function)
	insert_range_after inserts a range of elements after an element
	(C++23) 	   (public member function)
	erase_after	   erases an element after an element
			   (public member function)
	push_front	   inserts an element to the beginning
			   (public member function)
	emplace_front	   constructs an element in-place at the beginning
			   (public member function)
	prepend_range	   adds a range of elements to the beginning
	(C++23) 	   (public member function)
	pop_front	   removes the first element
			   (public member function)
	resize		   changes the number of elements stored
			   (public member function)
	swap		   swaps the contents
			   (public member function)

Operations
	merge		   merges two sorted lists
			   (public member function)
	splice_after	   moves elements from another forward_list
			   (public member function)
	remove		   removes elements satisfying specific criteria
	remove_if	   (public member function)
	reverse 	   reverses the order of the elements
			   (public member function)
	unique		   removes consecutive duplicate elements
			   (public member function)
	sort		   sorts the elements
			   (public member function)

Non-member functions
	operator==
	operator!=
	operator<
	operator<=
	operator>
	operator>=		      lexicographically  compares  the values of
     two
	operator<=>		     forward_lists
	(C++11) 		     (function template)
	(C++11)(removed in C++20)
	(C++11)(removed in C++20)
	(C++11)(removed in C++20)
	(C++11)(removed in C++20)
	(C++11)(removed in C++20)
	(C++20)
	std::swap(std::forward_list) specializes the std::swap algorithm
	(C++11) 		     (function template)
	erase(std::forward_list)     erases  all  elements  satisfying	specific
     criteria
	erase_if(std::forward_list)  (function template)
	(C++20)

	  Deduction guides (since C++17)

Notes
	    Feature-test macro	     Value    Std		    Feature
	__cpp_lib_containers_ranges  202202L (C++23) Ranges construction and in-
     sertion for
						    containers

Example
	 This section is incomplete
	 Reason: no example

Category:
	  * Todo no example

http://cppreference.com 	   2024.06.10		    std::forward_list(3)
home | help