October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
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.
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
}
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_pendingTextfrom multiple threads.
By Blog Staff | May 8, 2024 10:07 AM | 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!
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.
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::, which fails fast on any unhandled exception. This saves us from having to worry about recovering from exceptions. (At least for now.)fire_ and_ forget
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, andformatted_sizefunctions. They no longer take astd::string_viewas the format string, but instead astd::format_string(or, for the wide-character overloadsstd::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 withmake_format_argsormake_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
parsefunction of theformatterclasses described in this article.
By Blog Staff | Apr 30, 2024 12:36 PM | Tags: None
In software development, handling notifications efficiently is pivotal, particularly in user interface scenarios. While traditional notification patterns inform handlers of changes, they often lack crucial state information. In this article, we explore the intricacies of managing stateful updates within the context of C++/WinRT, addressing challenges such as race conditions and ensuring that notification handlers operate on the most recent data for optimal user experience.
Adding State to the Update Notification Pattern, Part 1
by Raymond Chen
From the article:
Some time ago, we looked at the update notification pattern, but in those cases, the notification carried no state.
Consider the case where you want to call a notification handler, and the handler also receives a copy of data derived from the most recent state, rather than just being called to be told that something changed and forcing them to figure out what changed.
For example, suppose you want to add autocomplete to an edit control, but calculating the autocomplete results is potentially slow, so you want to do it in the background. But while you are calculating the autocomplete results, the user might type into the edit control, and you want the final autocomplete results to reflect the most recent edit in the edit control, rather than any results from what the edit control used to contain at some point in the past.
By Ansel Sermersheim | Apr 26, 2024 12:39 PM | Tags: None
New video on the CopperSpice YouTube Channel:
Declarations Gone Wrong
by Barbara Geller and Ansel Sermersheim
About the video:
A new C++ video has been uploaded to our YouTube channel about how declarations work and what happens when they go wrong.
Do you know which part of a declaration is the declarator? How about what can happen with multiple variables in one declaration statement? Let us entertain you with the surprising details, including some most programmers have never seen or considered.
Please take a look and remember to subscribe.
By Giovanni Dicanio | Apr 26, 2024 12:38 PM | Tags: None
Windows EXE files can contain resources, including binary resources. In particular, you can embedd one or more DLLs into an EXE, and then extract them at run-time. Let's learn more about that in the following article:
Embedding (and Extracting) Binary Files like DLLs into an EXE as Resources
by Giovanni Dicanio
From the article:
A Windows .EXE executable file can contain binary resources, which are basically arbitrary binary data embedded in the file.
In particular, it’s possible to embed one or more DLLs as binary resources into an EXE. In this article, I’ll first show you how to embed a DLL as a binary resource into an EXE using the Visual Studio IDE; then, you’ll learn how to access that binary resource data using proper Windows API calls.
(...)
Once you have embedded a binary resource, like a DLL, into your EXE, you can access the resource’s binary data using some specific Windows APIs. (...)
The above “API dance” can be translated into the following C++ code: (...)
I uploaded on GitHub a C++ demo code that extracts a DLL embedded as a resource in the EXE, and, for testing purposes, invokes a function exported from the extracted DLL.
By John Farrier | Apr 26, 2024 12:37 PM | Tags: None
From the White House to the NSA to Bjarne Stroustrup has an opinion on C++ and Memory Safety. Let's examine this from a historical context and see where this debate may lead.
Looking for Pointers: The C++ Memory Safety Debate
by John Farrier
From the article:
The dialogue around C++ and memory safety has intensified following recent evaluations by authoritative bodies. The White House’s Office of the National Cyber Director issued a compelling call for a pivot toward memory-safe programming languages. This stance is predicated on a history of cyber vulnerabilities linked to memory safety issues, influencing national security and the broader digital ecosystem’s integrity.
This debate takes place against a backdrop of historical precedence, technological evolution, and a reevaluation of programming language safety standards, underscoring the need for a nuanced understanding of memory safety within the context of C++.