Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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
       removal of
	  elements from	anywhere in the	container. Fast	random access  is  not
       supported. 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
       several lists,
	  does	not invalidate the iterators currently referring to other ele-
       ments in	the list.
	  However, an iterator or reference referring to an element is invali-
       dated 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  im-
       pose
		      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	incom-
       plete
		      element type if the allocator  satisfies	the  allocator
       completeness (since
		      requirements.
       C++17)

				Feature-test  macro		 Value	   Std
       Feature
									      Min-
       imal
		      __cpp_lib_incomplete_container_elements 201505L  (C++17)
       incomplete
									      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	begin-
       ning
	  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
       insertion for
						      containers

Example
	   This	section	is incomplete
	   Reason: no example

Category:
	    * Todo no example

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

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::forward_list&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help