Discover C++17's new features and tools to optimize your code. Explore fundamentals and advanced techniques, and gain insights through hands-on coding exercises to master C++.

cpp17.tar.gz

c++17

C++17N

adaptor

C++ is one of the most prominent programming languages in the world. Along with optimized performance, the diverse functionality it offers has kept the language relevant for two decades. The C++ Standard Library, which is the collection of all the tools and utilities available in C++, received its latest update in 2017. Known as C++17, the update introduces many new features that further optimize our code.

Join us in this course as we venture into the vast world of C++17. We’ll examine the fundamentals of the language, before moving on to more complex yet powerful tools. You can also experiment with the code provided and hence, gain a higher understanding of how things work. This course is perfect for anyone willing to fully grasp C++ and use it to its full potential. Welcome aboard!

Rick Audet

Arguably the quickest and easiest way to get up to speed on
the most important parts of the C++ standard library. Recommended for any modern C++ programmer.

Senior Engineer, Dolby Laboratories

Odin Holmes

Das Buch beinhaltet, wie der Name schon sagt, eine recht ausführliche Beschreibung der STL. Dabei merkt Mann deutlich dass der Autor auch selber auf hohem Niveau programmiert. Es gibt oft den ein oder andere Tipp oder Wink in die richtige Richtung die bei Bücher von Berufsautoren oft fehlen. Z.B. die Aussage dass std::vector für 95% aller Fälle die beste Wahl ist oder dass std::async meistens die erste Wahl sein sollte lenkt der Leser geschickt in die richtige Richtung.

Auch die Auswahl an Komponente aus der STL ist sehr gut getroffen (keiner kann in ein kürzen Buch die ganze STL beschreiben). Oft sehe ich, vor allem in Deutschsprachige Literatur, dass die Auswahl eher auf Komponente trifft die leicht zu beschreiben sind und nicht auf die Nützlichen. Eine gute und dennoch kürze Beschreibung vom std::regex z.B. ist weiß Gott nicht einfach aber in diesem Fall ist es der Autor sehr gelungen.

CEO/CTO at Auto-Intern GmbH

Ramon Wartala

Die 215 Seiten plus Index des ’C++ kurz & gut’ vom Autor Rainer Grimm stellen ein gelungene Destillat viel umfangreicherer Texte zum Thema da. So nimmt das Kapitel über die klassischen Algorithmen der Standardbibliothek ganze 131 Seiten ein. Selbst kurze Beispiele für die Anwendung der wichtigsten Bestandteile der Standardbibliothek passen eng gedruckt in das schmale Büchlein. Auch wenn heute Tools wie Dash oder entsprechend ausgestattete IDEs, mehr und mehr den Platz derartiger Desktop-Referenzen einnehmen, ist das ’kurz & gut’ zu C++ Standardbibliothek ein leichter und mobiler Begleiter für jeden C++ Entwickler. Und als Kindle Version um so bequemer mitzunehmen.

Director Technology at Performance Media GmbH

C++ Standard Library including C++ 14 & C++ 17

[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 supports no random access.
* The access of an arbitrary element is slow because in the worst case you 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 you add or remove an element, the iterator stays valid. 
* Operations always refer to the beginning of the `std::forward_list` or the position past the current element.

The characteristic that you can iterate a `std::forward_list` forward has a great impact. So the iterators cannot be decremented and therefore, operations like `It--` on iterators are not supported. For the same reason, `std::forward_list` has no backward iterator. `std::forward_list` is the only sequential container that 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 affect adjacent elements. This is typical for a sort algorithm.


These 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 after `pos` new elements. 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 supports no random access.
* The access of an arbitrary element is slow because in the worst case you 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 you add or remove an element, the iterator stays valid. 
* Operations always refer to the beginning of the `std::forward_list` or the position past the current element.

The characteristic that you can iterate a `std::forward_list` forward has a great impact. So the iterators cannot be decremented and therefore, operations like `It--` on iterators are not supported. For the same reason, `std::forward_list` has no backward iterator. `std::forward_list` is the only sequential container that 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 affect adjacent elements. This is typical for a sort algorithm.


These 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 after `pos` new elements. 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.

Introduction

The Standard Library

Overview

Application of Libraries

Utilities

Useful Functions

Adaptors for Functions

Pairs and Tuples

Reference Wrappers

Smart Pointers

Type Traits

Time Library

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

Interface of All Containers

Sequential Containers

Associative Containers

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

File Systems

Multithreading

Forward Lists