Finite State Machine with std::variant -- Bartlomiej Filipek

By Blog Staff | Jul 18, 2023 02:44 PM | Tags: None

In this blog post, I’ll show you how to convert a “regular” enum-style finite state machine into a modern version based on std::variant from C++17. This technique allows you to improve design, work with value types and enhance code quality.

Finite State Machine with std::variant

by Bartlomiej Filipek

From the article:

Let’s start with a basic example:

• we want to track a game player’s health status
• we’d like to respond to events like “Hit by a monster” or “Healing bonus.”
• when the health point goes to 0, then we have to restart the game only if there are some remaining lives available

Here’s a basic diagram with states and transitions:

CppCon 2022 Modernizing SFML in Cpp -- Chris Thrasher

By Blog Staff | Jul 17, 2023 01:53 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!

Lightning Talk: Modernizing SFML in Cpp

by Chris Thrasher

Summary of the talk:

Modernizing SFML, a game development library, from C++03 to C++17.

CppCon 2022 C++20 - A New Way of Meta-Programming? -- Kris Jusiak

By Blog Staff | Jul 13, 2023 02:49 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!

Lightning Talk: C++20 - A New Way of Meta-Programming?

by Kris Jusiak

Summary of the talk:

In this lightning talk we will explore a few template meta programming techniques which C++20 enables.

New C++ Features in GCC13 -- Marek Polacek

By Blog Staff | Jul 13, 2023 02:31 PM | Tags: None

The latest major version of the GNU Compiler Collection (GCC), 13.1, was released in April 2023. Like every major GCC release, this version brings many additions, improvements, bug fixes, and new features.

New C++ features in GCC 13

by Marek Polacek

From the article:

Like the article I wrote about GCC 10 and GCC 12, this article describes only new features implemented in the C++ front end; it does not discuss developments in the C++ language itself. Interesting changes in the standard C++ library that comes with GCC 13 are described in a separate blog post: New C features in GCC 13

CppCon 2022 Const Mayhem in C++ -- Ofek Shilon

By Blog Staff | Jul 11, 2023 01:42 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!

Lightning Talk: Const Mayhem in C++

by Ofek Shilon

Summary of the talk:

Did you know that:
(1) const methods can legally modify members?
(2) A const object cannot be default-initialized?   (this makes sense after a minute)
(2)(b) Unless... a default constructor is declared non-inline?
(3) The standard does not properly account for volatile members of const objects?
All this and (probably not much) more, at this lightning talk.

Active Object -- Rainer Grimm

By Blog Staff | Jul 11, 2023 11:16 AM | Tags: None

The active object design pattern decouples method execution from method invocation for objects that each reside in their own thread of control.The goal is to introduce concurrency, by using asynchronous method invocation and a scheduler for handling requests.

Active Object

by Rainer Grimm

From the article:

The Active Object decouples method invocation from method execution. The method invocation is performed on the client thread, but the method execution is on the Active Object. The Active Object has its thread and a list of method request objects (short request) to be executed. The client’s method invocation enqueues the requests on the Active Object’s list. The requests are dispatched to the servant.

When many threads access a shared object synchronized, the following challenges must be solved:

• A thread invoking a processing-intensive member function should not block the other threads invoking the same object for too long.
• It should be easy to synchronize access to a shared object.
• The concurrency characteristics of the executed requests should be adaptable to the concrete hardware and software.

CppCon 2022 An Introduction to Multithreading in C++20 -- Anthony Williams

By Blog Staff | Jul 7, 2023 02:35 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!

An Introduction to Multithreading in C++20

by Anthony Williams

Summary of the talk:

Where do you begin when you are writing your first multithreaded program using C++20? Whether you've got an existing single-threaded application, or you're starting from scratch, C++20 provides the basic tools to help. In this talk we'll look at the C++20 facilities you should reach for first, and how to use them safely.

Solving Undefined Behavior in Factories with constinit from C++20 -- Bartlomiej Filipek

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

A few years ago, I showed an interesting implementation for self-registering classes in factories. It works, but one step might be at the edge of Undefined behavior. Fortunately, with C++20, its new constinit keyword, we can update the code and ensure it’s super safe.

Solving Undefined Behavior in Factories with constinit from C++20

by Bartlomiej Filipek

From the article:

Let’s bring back the topic:

Here’s a typical factory function. It creates unique_ptr with ZipCompression or BZCompression based on the passed name/filename:

Here are some issues with this approach:

• Each time you write a new class, and you want to include it in the factory, you have to add another if in the Create() method. Easy to forget in a complex system.
• All the types must be known to the factory.
• In Create(), we arbitrarily used strings to represent types. Such representation is only visible in that single method. What if you’d like to use it somewhere else? Strings might be easily misspelled, especially if you have several places where they are compared.

All in all, we get a strong dependency between the factory and the classes.

But what if classes could register themselves? Would that help?

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...