Explore the full potential of C++ by mastering the standard library.

Become a C++ Programmer

The C++ standard library is a collection of all the tools and utilities available in C++. It received its latest update in 2017, known as C++17. The update introduces many new features that further optimize our code. This module will help us fully grasp C++ and use it to its full potential.

C++ Standard Library

[std::forward_list](http://en.cppreference.com/w/cpp/container/forward_list) is a singly linked list, which needs the header `<forward_list>`. `std::forward_list` has a drastically reduced interface and is optimized for minimal memory requirements.

`std::forward_list` has a lot in common with [`std::list`](https://www.educative.io/courses/cpp-standard-library-including-cpp-14-and-cpp-17/lists):

* It doesn't support the random access.
* The access of an arbitrary element is slow because in the worst case, we have to iterate forward through the whole list.
* To add or remove an element is fast, if the iterator points to the right place.
* If we add or remove an element, the iterator remains valid. 
* Operations always refer to the beginning of the `std::forward_list` or the position past the current element.

Being able to iterate through an `std::forward_list` forward has a great impact. The iterators cannot be decremented and therefore, operations like `--` (decrement) on iterators are not supported. For the same reason, `std::forward_list` has no backward iterator. `std::forward_list` is the only sequential container which doesn't know its size.

>🔑 **std::forward_list has a very special domain**
\
`std::forward_list` is the replacement for single linked lists. It's optimized for minimal memory management and performance if the insertion, extraction, or movement of elements only affects adjacent elements. This is typical for sorting algorithms.

The following are the special methods of `std::forward_list`:

| **Method** | **Description** |
|-|-|
| `forw.before_begin()` | Returns an iterator before the first element. | 
| `forw.emplace_after(pos, args...)` | Creates an element after `pos` with the arguments `args...`. |
| `forw.emplace_front(args...)` | Creates an element at the beginning of `forw` with the arguments `args...`. |
| `forw.erase_after(pos, ...)` | Removes from `forw` the element `pos` or a range of elements, starting with `pos`. |
| `forw.insert_after(pos, ...)` | Inserts new elements after `pos`. These elements can be single elements, ranges or initialiser lists. | 
| `forw.merge(c)` | Merges the sorted forward list c into the sorted forward list `forw`, so that `forw` keeps sorted. |
| `forw.merge(c, op)` | Merges the forward sorted list c into the forward sorted list `forw`, so that `forw` keeps sorted. Uses `op` as sorting criteria. |
| `forw.splice_after(pos, ...)` | Splits the elements in `forw` before `pos`. The elements can be single elements, ranges or lists. |
| `forw.unique()` | Removes adjacent element with the same value. |
| `forw.unique(pre)` | Removes adjacent elements, fulfilling the predicate `pre`. |

 Special methods of std::forward_list 

Let's have a look at how the unique methods of `std::forward_list` work.

[std::forward_list](http://en.cppreference.com/w/cpp/container/forward_list) is a singly linked list, which needs the header `<forward_list>`. `std::forward_list` has a drastically reduced interface and is optimized for minimal memory requirements.

`std::forward_list` has a lot in common with [`std::list`](https://www.educative.io/courses/cpp-standard-library-including-cpp-14-and-cpp-17/lists):

* It doesn't support the random access.
* The access of an arbitrary element is slow because in the worst case, we have to iterate forward through the whole list.
* To add or remove an element is fast, if the iterator points to the right place.
* If we add or remove an element, the iterator remains valid. 
* Operations always refer to the beginning of the `std::forward_list` or the position past the current element.

Being able to iterate through an `std::forward_list` forward has a great impact. The iterators cannot be decremented and therefore, operations like `--` (decrement) on iterators are not supported. For the same reason, `std::forward_list` has no backward iterator. `std::forward_list` is the only sequential container which doesn't know its size.

>🔑 **std::forward_list has a very special domain**
\
`std::forward_list` is the replacement for single linked lists. It's optimized for minimal memory management and performance if the insertion, extraction, or movement of elements only affects adjacent elements. This is typical for sorting algorithms.

The following are the special methods of `std::forward_list`:

| **Method** | **Description** |
|-|-|
| `forw.before_begin()` | Returns an iterator before the first element. | 
| `forw.emplace_after(pos, args...)` | Creates an element after `pos` with the arguments `args...`. |
| `forw.emplace_front(args...)` | Creates an element at the beginning of `forw` with the arguments `args...`. |
| `forw.erase_after(pos, ...)` | Removes from `forw` the element `pos` or a range of elements, starting with `pos`. |
| `forw.insert_after(pos, ...)` | Inserts new elements after `pos`. These elements can be single elements, ranges or initialiser lists. | 
| `forw.merge(c)` | Merges the sorted forward list c into the sorted forward list `forw`, so that `forw` keeps sorted. |
| `forw.merge(c, op)` | Merges the forward sorted list c into the forward sorted list `forw`, so that `forw` keeps sorted. Uses `op` as sorting criteria. |
| `forw.splice_after(pos, ...)` | Splits the elements in `forw` before `pos`. The elements can be single elements, ranges or lists. |
| `forw.unique()` | Removes adjacent element with the same value. |
| `forw.unique(pre)` | Removes adjacent elements, fulfilling the predicate `pre`. |

 Special methods of std::forward_list 

Let's have a look at how the unique methods of `std::forward_list` work.

A forward list is the primitive form of the list structure we studied in the previous lesson. Nevertheless, forward lists are still useful.

The Standard Library

Overview

Application of Libraries

Useful Functions

Adaptors for Functions

Pairs and Tuples

Reference Wrappers

Smart Pointers

Type Traits

Time Library

std::any, std::optional, and std::variant

Containers in General

Sequential Containers

Associative Containers in General

Ordered Associative Containers

Unordered Associative Containers

Adaptors for Containers

Iterators

Callable Units

Algorithms

Non-Modifying Algorithms

Modifying Algorithms

More Algorithms

New Algorithms with C++17

Numeric

Strings

String View

Regular Expressions

Input and Output Streams

Conclusion

Forward Lists