C++20

The Next Big Thing: C++20

C++20 will be the next big C++ standard after C++11. As C++11 did it, C++20 will change the way we program modern C++. This change is, in particular, true for Ranges, Coroutines, Concepts, and Modules. To understand this next big step in the evolution of C++, let me put it in this post in the historical context of C++ standards.

Read more
Tags: C++20
Views: 130285

Defining Concepts

I wrote a few posts about using concepts. Concepts are a named set of requirements. Let's define a few concepts in this post.

Read more
Views: 33199

Placeholders - The Second

The unification of templates, concepts, and placeholders goes on. This time, I will have a closer look at constrained (concepts) and unconstrained (auto) placeholders in the context of templates.

Read more
Views: 18489

Concepts - Placeholders

C++11 has auto unconstrained placeholders. You can use concepts in C++20 as constrained placeholders. What seems at first glimpse not so thrilling is for me the decisive quantum leap. C++ templates will become an easy to use C++ feature.

Read more
Views: 23733

Task Blocks

Task blocks use the well-known fork-join paradigm for the parallel execution of tasks.

Read more
Tags: C++20
Views: 39700

Transactional Memory

Transactional memory is based on the idea of a transaction from the database theory. Transactional memory shall make the handling of threads a lot easier. That for two reasons. Data races and deadlocks disappear. Transactions are composable.

Read more
Tags: C++20
Views: 32221

Coroutines

Coroutines are functions that can suspend and resume their execution while keeping their state. The evolution in C++20 goes one step further.

Read more
Tags: C++20
Views: 82297

Latches And Barriers

Latches and barriers are simple to thread synchronisation mechanism which enables it that some threads wait until a counter becomes zero. We will presumably in C++20 get latches and barriers in three variations: std::latch, std::barrier, and std::flex_barrier.

Read more
Tags: C++20
Views: 50441

std::future Extensions

Tasks in the form of promises and futures have in C++11 an ambivalent reputation. On the one hand, they are a lot easier to use than threads or condition variables; on the other hand, they have a great deficiency. They can not be composed. C++20 will overcome this deficiency.

Read more
Tags: C++20, tasks
Views: 52234

Atomic Smart Pointers

C++20 will have atomic smart pointers. To be exactly, we will get a std::atomic_shared_ptr and a std::atomic_weak_ptr. But why? std::shared_ptr and std::weak_ptr are already thread-safe. Sort of. Let me dive into the details.

Read more
Tags: C++20
Views: 164784

Mentoring

Stay Informed about my Mentoring

English Books

Course: Modern C++ Concurrency in Practice

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

Course: Embedded Programming with Modern C++

Course: Generic Programming (Templates)

Course: C++ Fundamentals for Professionals

Interactive Course: The All-in-One Guide to C++20

Subscribe to the newsletter (+ pdf bundle)

Blog archive

Source Code

Visitors

Today 2924

Yesterday 4105

Week 33942

Month 163447

All 10708563

Currently are 129 guests and no members online

Kubik-Rubik Joomla! Extensions

Latest comments