: Standard C++

Home » Blog » Categories »

« Prev Next »

CppCon 2022 C++20’s Coroutines for Beginners -- Andreas Fertig

By Blog Staff | Jul 5, 2023 05:00 PM | Tags: None

Registration is now open for CppCon 2023! The conference starts on October 1 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2023!

C++20’s Coroutines for Beginners

by Andreas Fertig

Summary of the talk:

You've heard about this new feature in C++20, coroutines, but it's the first time you have encountered this term? Then this talk is what you're looking for. We start from the beginning with just "normal" functions. Next, we introduce coroutines.

Using them, we explore the various customization points C++ offers. We look at what the new keywords co_await, co_yield, and co_return are for.

Sadly, we also have to talk about how to write a generator for a coroutine since there is no STL part for that in C++20.

Another distinction we make is between cooperative and preemptive multitasking, opening the door for another beauty of coroutines, why we don't need locks.

By the end of this talk, you've learned what coroutines are and where you can use them.

The Move Constructor That You Have to Declare, Even Though You Don’t ... -- Raymond Chen

By Blog Staff | Jul 4, 2023 05:07 PM | Tags: None

You may have a class that you want to participate in RVO or NRVO, but you also don’t want it to be moved. For example, it may contain a std::mutex, which is not movable. But you nevertheless have to declare a move constructor. What can you do?

The Move Constructor That You Have to Declare, Even Though You Don’t Want Anyone to Actually Call It

by Raymond Chen

From the article:

Blah blah blah C++ return value optimization (RVO), named return value optimization (NRVO), and copy elision.

RVO support was optional in C++11 but became mandatory in C++17. NRVO support remains optional (but recommended).

To allow NRVO in C++17 (or RVO and NRVO in C++11), a move constructor must be available, even though the compiler will not call it if the optimization is employed.

You may have a class that you want to participate in RVO or NRVO, but you also don’t want it to be moved. For example, it may contain a std::mutex, which is not movable. But you nevertheless have to declare a move constructor. What can you do?

Declare the move constructor, but...

Need Something Sorted? Sleep On It! -- Kevlin Henney

By Blog Staff | Jul 3, 2023 10:49 AM | Tags: None

Sorting algorithms have been thoroughly studied. Kevlin Henney takes an unexpected paradigm journey into sleep sort.

Need Something Sorted? Sleep On It!

by Kevlin Henney

From the article:

A decade ago, I first presented a lightning talk entitled ‘Cool Code’. This short talk evolved into a full talk whose iterations I presented over the next half decade. The focus? Code that, for some reason or other, can be considered cool. For example, code that has played a significant role in historical events, such as the source for the Apollo Guidance Computer [Apollo]. Or code that is audacious – if not seemingly impossible – given its constraints, such as David Horne’s 1K chess [Frogley01]. There is code that is both simple and profound, such as Peter Norvig’s fits-on-a-slide spelling corrector [Norvig16]. And code that demonstrates ingenuity and humour, such as Yusuke Endoh’s Qlobe [Endoh10].

Leaving aside its content for a moment, one of the most interesting things about the talk was its...

Modern C++ In-Depth — Transparent Comparisons

By Jens Maurer | Jul 3, 2023 02:20 AM | Tags: intermediate c++14

Less overhead for associative container lookup

Modern C++ In-Depth — Transparent Comparisons

by Michael Kristofik

From the article:

Searching for an element in a container normally requires constructing an object of the container’s key_type. If the key is small, such as one you’d normally pass by value, it isn’t a performance concern. But what if the key is large?

CppCon 2022 Using Modern C++ to Eliminate Virtual Functions -- Jonathan Gopel

By Blog Staff | Jun 30, 2023 04:56 PM | Tags: None

Using Modern C++ to Eliminate Virtual Functions

by Jonathan Gopel

Summary of the talk:

As of C++20, there are no cases in which statically linked programs require virtual functions. This talk will explore techniques for replacing runtime polymorphism with compile-time polymorphism such that virtual functions are never necessary. This talk will also address the higher-order concern of when it might make sense to avoid virtual functions or remove them from a codebase, as that decision ultimately is a design decision that only the author of the code can make. Attendees can expect to come away with a stronger understanding of the purposes of virtual functions and the mechanisms in modern C++ that can now be used to achieve those same purposes.

Why You Should Only Rarely Use std::move -- Andreas Fertig

By Blog Staff | Jun 30, 2023 10:40 AM | Tags: None

std::move can allow the efficient transfer of resources from object to to object. Andreas Fertig reminds us that using std::move inappropriately can make code less efficient.

Why You Should Only Rarely Use std::move

by Andreas Fertig

From the article:

The example in Listing 1 is the code I used to make my point: don’t use std::move on temporaries! Plus, in general, trust the compiler and only use std::move rarely. For this article, let’s focus on the example code.
class S {
public:
  S() { printf("default constructor\n"); }
  ~S() { printf("deconstructor\n"); }
  // Copy constructor ①
  S(const S&) { printf("copy constructor\n"); }
  // Move constructor ②
  S(S&&) { printf("move constructor\n"); }
};
void Use()
{
  S obj{
    S{} // Creating obj with a temporary of S ③
  };
}
Listing 1
Here we see a, well, perfectly movable class. I left the assignment operations out. They are not relevant. Aside from the constructor and destructor, we see in ① the copy constructor and in ② the move constructor. All special members print a message to identify them when they are called.
Further down in Use, we see ③, a temporary object of S used to initialize obj, also of type S. This is the typical situation where move semantics excels over a copy (assuming the class in question has movable members). The output I expect, and I wanted to show my participants, is:

Type Safe C++ enum Extensions -- Alf Steinbach

By Blog Staff | Jun 28, 2023 07:36 AM | Tags: None

Is it possible to extend a value type in C++? Alf Steinbach describes how to extend enum values.

Type Safe C++ enum Extensions

by Alf Steinbach

From the article:

Consider if an enum like the following,
  enum class Suit{
  spades, hearts, diamonds, clubs };
could be extended like
  enum class Suit_with_joker extends Suit {
    joker };
where

Suit_with_joker has all the enumerators of Suit plus the joker enumerator; and

enumerators introduced in Suit_with_joker get integer values following those of Suit; and

any Suit value is also a Suit_with_joker value.

This would be an example of what I’ll call a value type extension.

The apparently backwards is-a relationship in the last point, where any value of the original type is-a value of the derived type, is characteristic of value type extensions.

C++20 totally lacks support for value type extensions, of enum types or other types.

CppCon 2022 Finding Whether a Number is a Power of 2 -- Ankur Satle

By Blog Staff | Jun 27, 2023 04:50 PM | Tags: None

Lightning Talk: Finding Whether a Number is a Power of 2

by Ankur Satle

Summary of the talk:

I asked this question on social media and got many diverse responses. I will present the various approaches and compare them. I will finish with the options C++20 provides with the bit header. https://en.cppreference.com/w/cpp/numeric/has_single_bit

CppCon 2022 Who is Looking for a C++ Job? -- Jens Weller

By Blog Staff | Jun 26, 2023 04:48 PM | Tags: None

Lightning Talk: Who is Looking for a C++ Job?

by Jens Weller

Summary of the talk:

A few insights on who has been applying for C++ jobs and visited the Meeting C++ online job fairs.

It’s Great That You Provide Operator Overloads, But It’s Also Nice to Have Names -- Raymond Chen

By Blog Staff | Jun 25, 2023 05:08 PM | Tags: None

Operator overloading. Looks great. Reduces verbosity. Until it doesn’t.

It’s Great That You Provide Operator Overloads, But It’s Also Nice to Have Names

by Raymond Chen

From the article:

Consider this overloaded function call operator:
struct StorageLoader
{
    template<DataType>
    DataType operator()(StorageOptions<DataType> const* options);
};
The idea is that you can use the function call operator on a StorageLoader object to load data from storage, using a StorageOptions to describe how you want it to be loaded.