: Standard C++

Home » Blog » Categories »

« Prev Next »

AddressSanitizer continue_on_error -- Jim Radigan

By Blog Staff | Jul 25, 2023 02:53 PM | Tags: None

Visual Studio 17.6 comes with new functionality in the Address Sanitizer runtime which provides a new “checked build” for C and C++. This new runtime mode diagnoses and reports hidden memory safety errors, with zero false positives, as your app runs.

AddressSanitizer continue_on_error

by Jim Radigan

From the article:

C++ memory safety errors are a top concern for the industry. In Visual Studio 17.6, we deliver a new experimental Address Sanitizer feature: continue_on_error (COE). We’ll remove the experimental label in 17.8. You compile as before, by simply adding the compiler flag -fsanitizer=address. With 17.6 you can enable the COE functionality by setting environment variables from the command line.

CppCon 2022 C++23 - What's In It For You? -- Marc Gregoire

By Blog Staff | Jul 25, 2023 06:01 AM | 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++23 - What's In It For You?

by Marc Gregoire

Summary of the talk:

C++23, the next release of the C++ standard, is scheduled to be released in 2023. The update introduces new features to the core language and to the Standard Library. If you want to stay up to date with the latest features that are upcoming with this new release, then this session is for you.

The session includes core language topics such as consteval if statements, multidimensional subscript operators, decay copy, unreachable code, and more. New Standard Library features that will be shown include monadic operations for std::optional, std::flat_map, std::flat_set, a stacktrace library, changes to the ranges library, improvements to std::format, std::expected, and many more.

The session will include references to other sessions at CppCon, if applicable, for more deep-dive information on any particular topic.

Monitor Object -- Rainer Grimm

By Blog Staff | Jul 20, 2023 02:47 PM | Tags: None

The Monitor Object design pattern synchronizes concurrent member function execution to ensure that only one member function runs within an object at a time. It also allows an object's member functions to schedule their execution sequences cooperatively.

Monitor Object

by Rainer Grimm

From the article:

Problem

If many threads access a shared object concurrently, the following challenges exist.

Due to the concurrent access, the shared object must be protected from non-synchronized read and write operations to avoid data races.

The necessary synchronization should be part of the implementation, not the interface.

When a thread is done with the shared object, a notification should be triggered so the next thread can use the shared object. This mechanism helps avoid and improves the system's overall performance.

After the execution of a member function, the invariants of the shared object must hold.

Solution

A client (thread) can access the Monitor Object's synchronized member functions, and due to the monitor lock, only one synchronized member function can run at any given time. Each Monitor Object has a monitor condition that notifies the waiting clients.

CppCon 2022 The Most Important Optimizations to Apply in Your C++ Programs -- Jan Bielak

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

The Most Important Optimizations to Apply in Your C++ Programs

by Jan Bielak

Summary of the talk:

Writing efficient programs is hard. This is because it requires a lot of knowledge, experience and strategic thinking. There have been many talks on optimization and often each addresses a single concept. Being able to achieve a bird’s eye view of factors affecting performance often requires many hours of researching the topic. To lessen the mental burden of optimizing programs, I have picked out the techniques, I believe are most important. During the talk, I will present them in an organized manner and provide practical examples of how they can be applied.

I will first discuss what I believe are the main goals efficient programs strive to achieve. Then, I will present the general methods of achieving those goals. Then, for the majority of the talk, we will discuss a few dozen performance opportunities. For each of them, I will explain the underlying mechanism of how the optimisation works. I will avoid bluntly giving guidelines to follow without explanation. Each of the techniques naturally comes with its costs, and those will be discussed as well.

I will additionally discuss various performance pitfalls. These are sometimes called “premature pessimisations” in contrast to the often used term of “premature optimizations”. I will show examples of optimizations which do not incur any cost on program readability or maintainability and as such should be considered performance best practices. Avoiding their use doesn’t improve code in any manner, while making it slower.

This talk is intended for a diverse audience, as after all, probably most of the C++ community is interested in performance. It is appropriate for hobbyists and professionals alike, with varying experience with the language, due to the gradual increase in difficulty of examples. It will be a time productively spent.

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

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

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

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.