: Standard C++

Home » Blog » Categories »

« Prev Next »

CppCon 2023 A Journey Into Non-Virtual Polymorphism in C++ -- Rudyard Merriam

By Blog Staff | May 13, 2024 01:17 PM | Tags: None

Registration is now open for CppCon 2024! The conference starts on September 15 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 2024!

CppCon 2023 A Journey Into Non-Virtual Polymorphism in C++

by Rudyard Merriam

Summary of the talk:

Join me on an introductory journey into polymorphism that doesn't use class inheritance and virtual functions. I'll share my amazement at how polymorphism permeates C++. Then we'll visit the long-used Curiously Recurring Template Pattern (CRTP) with its modernization using implicit this.

Do you like lambdas? So does the override pattern, which uses them to handle std::tuples and std::variants with std::apply and std::visit.

Want to walk through a container of disparate types invoking their functions? You'll see this and all the above in code examples galore.

Afterward, you'll be eager to learn more on your own!

Pure Virtual C++ 2024 Recordings Available

By TartanLlama | May 13, 2024 08:09 AM | Tags: community

The recordings for all Pure Virtual C++ 2024 sessions are now online. This includes the 5 main sessions plus over a dozen pre-conference videos.

Pure Virtual C++ 2024 Recordings Available

By Sy Brand

From the article:

All recordings for our Pure Virtual C++ 2024 conference are now available. Thanks to everyone who came along and hope to see you again next year! You can find the full playlist on YouTube.

Adding State to the Update Notification Pattern, Part 4 -- Raymond Chen

By Blog Staff | May 10, 2024 05:36 PM | Tags: None

In our previous discussion, we explored the intricacies of stateful but coalescing update notifications, shedding light on the pivotal role of the UI thread in implicit serialization. However, what if this luxury of implicit synchronization is absent? Delving into an alternate version of our solution, we confront the looming specter of race conditions and the necessity for meticulous thread management to ensure seamless operation. Join us as we navigate the complexities of thread synchronization and embark on a quest to refine our approach to asynchronous work handling.

Adding State to the Update Notification Pattern, Part 4

by Raymond Chen

From the article:

Last time, we developed a stateful but coalescing update notification, and we noted that the UI thread was doing a lot of heavy lifting. What if you don’t have a UI thread to do implicit serialization for you?

If there were no resume_foreground(Dispatcher()), we would have a race if a TextChanged occurs after the worker has decided to exit, but before it has had a chance to mark itself as not busy. Here’s an alternate version that demonstrates the race.

CppCon 2023 A Fast, Concurrent Data Loader for Time-Series Data -- Glenn Philen

By Blog Staff | May 10, 2024 01:15 PM | Tags: None

Lightning Talk: A Fast, Concurrent Data Loader for Time-Series Data

by Glenn Philen

Summary of the talk:

In this talk, I briefly share the design of a high performance data loader used to iterating over time series data stored on disk across many individual files. The data loader aggregates data streams from different sources and of different kinds of data, orders it by timestamp, and feeds it to an offline test harness concurrently and without locking.

C++ on Sea 2024 Full Schedule Announced -- C++ on Sea

By philsquared | May 10, 2024 04:48 AM | Tags: community

The C++ on Sea 2024 schedule is out, with 2-day workshops, 4-tracks of main conference, 2 lightning talk sessions and even a Movie Night!

Full schedule for 2024

by C++ on Sea

From the article:

We now have the full schedule for 2024 - and it's a doozy! We also have a few new features this year.

Trip Report: Winter ISO C++ Meeting in Tokyo, Japan -- David Sankel

By Blog Staff | May 9, 2024 02:38 PM | Tags: None

Another meeting, another slew of potential changes to standard C++. In this recap, I’ll summarize the working draft’s most significant changes, spotlight my favorite proposal at the meeting, Member customization points for Senders and Receivers, and discuss a handful of notable developments.

Trip Report: Winter ISO C++ Meeting in Tokyo, Japan

by David Sankel

From the article:

What’s new in the draft standard?

This snippet summarizes the notable changes:


	// wg21.link/p2573r2

	void newapi();

	void oldapi() = delete(“oldapi() is outdated, use newapi() instead”);

	

	void f() {

	    std::println(); // Shorthand for ‘std::println(“”)’. wg21.link/p3142r0

	

	    // Paths can be printed/formatted now. wg21.link/p2845r8

	    std::println(“Here’s a path: {}”,

	                 std::filesystem::path(“/stlab/chains”));

	

	    std::vector<int> x{1, 2, 3};

	    std::array<int,3> y{4, 5, 6};

	

	    // Outputs 1, 2, 3, 4, 5, and 6 separated by newlines.

	    for( auto i : std::views::concat(x, y) ) // concat is new from

	        std::cout << i << std::endl;         // wg21.link/p2542r8

	}

Adding State to the Update Notification Pattern, Part 3 -- Raymond Chen

By Blog Staff | May 8, 2024 05:32 PM | Tags: None

In our continued exploration of efficient stateful update notifications, we delve into optimizing our existing solution to mitigate unnecessary background work. By introducing periodic checks for pending text and leveraging mutex protection, we aim to streamline the process and enhance performance. However, as we unravel these optimizations, we confront the complexities of managing thread safety and delve into the intricacies of background thread synchronization.

Adding State to the Update Notification Pattern, Part 3

by Raymond Chen

From the article:

Last time, we developed a stateful but coalescing update notification, and we noted that the code does a lot of unnecessary work because the worker thread calculates all the matches, even if the work has been superseded by another request.

We can add an optimization to abandon the background work if it notices that its efforts are going to waste: Periodically check whether there is any pending text. This will cost us a mutex, however, to protect access to m_pendingText from multiple threads.

CppCon 2023 Interfaces in C++ -- Megh Parikh

By Blog Staff | May 8, 2024 10:07 AM | Tags: None

Lightning Talk: Interfaces in C++ - Megh Parikh - CppCon 2023

by Megh Parikh

Summary of the talk:

I explain some of the ways to make interfaces, both static and dynamic in this talk, and how concepts can be optionally used.

Adding State to the Update Notification Pattern, Part 2 -- Raymond Chen

By Blog Staff | May 6, 2024 05:21 PM | Tags: None

In the realm of asynchronous programming, managing stateful update notifications presents a daunting challenge. In our ongoing exploration, we scrutinize a solution that aims to address this challenge by seamlessly handling multiple requests for work while ensuring that only the last one triggers a notification. However, beneath the surface of this endeavor lies a tangle of legal intricacies and logical pitfalls, urging us to dissect, refine, and ultimately fortify our approach.

Adding State to the Update Notification Pattern, Part 2

by Raymond Chen

From the article:

Last time, we started looking at solving the problem of a stateful but coalescing update notification, where multiple requests for work can arrive, and your only requirement is that you send a notification for the last one. Any time a new request for work arrives, it replaces the existing one.

One attempt to fix this is to check if the work is already in progress, and if so, then hand off the new query to the existing worker. We are using winrt::fire_and_forget, which fails fast on any unhandled exception. This saves us from having to worry about recovering from exceptions. (At least for now.)

User-Defined Formatting in std::format -- Spencer Collyer

By Blog Staff | May 2, 2024 12:42 PM | Tags: None

std::format allows us to format values quickly and safely. Spencer Collyer demonstrates how to provide formatting for a simple user-defined class.

User-Defined Formatting in std::format

by Spencer Collyer

From the article:

Since my previous article was first published, based on the draft C++20 standard, the paper [P2216] was published which changes the interface of the format, format_to, format_to_n, and formatted_size functions. They no longer take a std::string_view as the format string, but instead a std::format_string (or, for the wide-character overloads std::wformat_string). This forces the format string to be a constant at compile time. This has the major advantage that compile time checks can be carried out to ensure it is valid.

The interfaces of the equivalent functions prefixed with v (e.g. vformat) has not changed and they can still take runtime-defined format specs.

One effect of this is that if you need to determine the format spec at runtime then you have to use the v-prefixed functions and pass the arguments as an argument pack created with make_format_args or make_wformat_args. This will impact you if, for instance, you want to make your program available in multiple languages, where you would read the format spec from some kind of localization database.

Another effect is on error reporting in the functions that parse the format spec. We will deal with this when describing the parse function of the formatter classes described in this article.