The Usual Arithmetic Confusions

by Shafik Yaghmour

There are a lot of aspects of C++ that are not well understood and lead to all sorts of confusion. The usual arithmetic conversions and the integral promotions are two such aspects. Certain binary operators (arithmetic, relational and spaceship) require their operands to have a common type. The usual arithmetic conversions are the set of steps that gets operands to a common type. While the integral promotions brings integral types smaller than int and unsigned int to either int or unsigned int depending on which one can represent all the values of the source type. This is one of the areas in C++ that comes directly from C, so pretty much all of these examples applies to C as well as C++...

Fixing the crash that seems to be on a std::move operation

by Raymond Chen

Last time, we looked at a crash that was root-caused to an order of evaluation bug if compiled as C++14. One solution to the problem is to switch to C++17 mode, but presumably the customer isn’t willing to make that drastic a change to their product yet. Maybe there’s something we can do that is less disruptive...

The mystery of the crash that seems to be on a std::move operation

by Raymond Chen

A customer was encountering a crash that appeared only on the ARM version of their program...

How we used C++20 to eliminate an entire class of runtime bugs

by Cameron DaCamara

C++20 is here and has been supported in MSVC since 16.11, but today’s post is not about how you can use it, but rather how we used it to effectively eliminate an entire class of runtime bugs by hoisting a check into compile-time. Let’s get right into it!

C++20 Concurrency: part-3 request_stop and stop_token for std::jthread

by Gajendra Gulgulia

In this article, we explore the latest feature of C++20’s std::jthreadthat allows one to signal a stop or cancellation to an already executing thread in certain situation...

C++20 Concurrency — Part 2: jthreads

by Gajendra Gulgulia

In this part of the issue, I’ll discuss about the new std::jthread that helps us avoid the boilerplate code for joining the conventional std::thread in the first section. In the end, I’ll also mention about the std::swap algorithm’s specialization introduced in C++20 to swap the underlying thread handles associated with std::jthread ...

20 Smaller yet Handy C++20 Features

by Bartlomiej Filipek

C++20 is huge and filled with lots of large features. Just to mention a few: Modules, Coroutines, Concepts, Ranges, Calendar & Timezone, Formatting library.

But, as you know, that’s not all.

Depending on how we count, C++20 brought around 80 Library features and 70 language changes, so there’s a lot to cover

In this article, I’ll show you 20 smaller C++20 things that are very handy and good to know. Ten language elements, and ten more for the Standard Library. Most of them with a cool example.

Let’s jump right into the text!

Improving Stability with Modern C++, Part 4 — Memory Management

by Ralph Kootker

When we started learning C++, we were all taught that every new needs a corresponding delete. But sometimes we'd forget, or some code might throw an exception we weren't ready for, and then we'd leak memory. [...] With rare exceptions, C++ programmers should not have to write new or delete ever again.

Design and evolution of constexpr in C++

by Evgeny Shulgin

The authors suffered greatly from the inability to use STL containers and wrote the std::vector and std::map analogues. Inside, these analogues have std::array that can work in constexpr. Proposal [P0784] Standard containers and constexpr studies the possibility of inputting STL containers in constexpr evaluations. Note. It's important to know what an allocator is. STL containers work with memory through it. What kind of an allocator — is specified through the tempte argument. If you want to get into the topic, read this article.

The Interesting Evolution of std::equal_range

by Jonathan Boccara

The good old std::equal_range STL algorithm, which has been in the STL since C++98, has evolved along with the versions of C++.

Starting from a poor interface and now a much better one, its story is an interesting example of how to improve the abstraction of an interface...