News : Standard C++

Home » Blog » Categories » News

« Prev Next »

News

Reminder: CppCon 2024 Early Bird ends on Friday

By Blog Staff | Jun 17, 2024 03:21 PM | Tags: None

The opening keynote of CppCon 2024 is just 89 days away!

If you're interested in savings, the Early Bird discount for on-line and on-site tickets is available until this Friday, June 21. After that tickets will still be available right up to the conference, but at the full ticket price.

To register for CppCon 2024 with the Early Bird discount, click this link this week.

For details of on-line and on-site tickets, see the Registration page which includes information about student registration discounts, group rates, the CppCon Academy (extra pre- and post-conference classes by world-renowned instructors), the diversity dinner, the "Meet the Presenters" banquet, and much more!

Why Can’t I Find the Injected Name of a Templated Class’s Templated Base Class? -- Raymond Chen

By Blog Staff | Jun 17, 2024 11:28 AM | Tags: None

Some time ago, I wrote about how injected class names were the C++ feature you didn’t even realize that you were using. Injected class names let you use the plain name for the class being defined without needing to fully qualify it with namespaces and template parameters. Furthermore, injected class names are public and can be inherited.

“But wait, I’m trying to use the injected class name of my base class, but the compiler won’t accept it.”

Why Can’t I Find the Injected Name of a Templated Class’s Templated Base Class?

by Raymond Chen

From the article:

Some time ago, I wrote about how injected class names were the C++ feature you didn’t even realize that you were using. Injected class names let you use the plain name for the class being defined without needing to fully qualify it with namespaces and template parameters. Furthermore, injected class names are public and can be inherited.

“But wait, I’m trying to use the injected class name of my base class, but the compiler won’t accept it.”
template<typename T>
struct Base
{
    Base(T value);
};

template<typename T>
struct Derived : Base<T>
{
    Derived(T value) : Base(value) {}
};
This generates a compiler error.

CppCon 2023 Filling the Bucket: Reading Code, C++ Code Interviews & Exams -- Amir Kirsh

By Blog Staff | Jun 16, 2024 10:57 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: Filling the Bucket: Reading Code, C++ Code Interviews & Exams

by Amir Kirsh

Summary of the talk:

We are going to review and practice a reading code challenge. Reading code skills are quite important, maybe even more than writing code. So let's dive together into filling the bucket code reading challenge!

CppCon 2023 Back to Basics: The Rule of Five in C++ -- Andre Kostur

By Blog Staff | Jun 13, 2024 11:31 AM | Tags: None

Back to Basics: The Rule of Five in C++

by Andre Kostur

Summary of the talk:

Designing a class to behave correctly when copied and moved takes a lot of thought. The Core Guidelines provide guidance to streamline that work. In this talk we are going to look at the Core Guideline known as "the Rule of Five", how it came about, and is there anything better.

An Informal Comparison of the Three Major Implementations of std::string -- Raymond Chen

By Blog Staff | Jun 12, 2024 11:38 AM | Tags: None

We saw some time ago that the three major implementations of std::string are all quite different...

An informal comparison of the three major implementations of std::string

by Raymond Chen

From the article:

In the original version of this article, I got the sense of the “small/large” bit backward in the clang implementation. This in turn led to redoing the code generation and new code golfing results.

We’ll compare these versions based on the complexity of some commonly-used operations.

C++ Safety with Herb Sutter

By Jordi Mon Companys | Jun 11, 2024 11:52 PM | Tags: security memory_safety c++23

The U.S. government released a report calling on the technical community to proactively reduce the attack surface area of software infrastructure. Herb tackles the concerns cast on C++ on memory safety.

C++ Safety with Herb Sutter

by Jordi Mon Companys in Software Engineering Daily

From the interview:

It's really, really important as native languages C and C++, not to have our heads in the sand and say, "Oh, well, we've been hearing this for years. All is well." No, it's not. We have work to do. But it's also important not to go to the other extreme, and think that, "Oh, if we just magically wave a wand and make all the world's software, suddenly convert overnight to memory-safe languages", which would be great if it can be done. It's not technically feasible. ut even if we could do that, we're not going to make most of the attacks go away.

CppCon 2023 Exceptionally Bad: The Misuse of Exceptions in C++ & How to Do Better -- Peter Muldoon

By Blog Staff | Jun 11, 2024 11:32 AM | Tags: None

Exceptionally Bad: The Misuse of Exceptions in C++ & How to Do Better

by Peter Muldoon

Summary of the talk:

Exceptions were originally heralded as a new modern way to handle errors. However the C++ community is split as to whether exceptions are useful or should be banned outright. It has not helped the pro-exception lobby that in their enthusiasm to embrace exceptions, a lot of code has been written that puts exceptions in a bad light.

In this talk, We will present the original intent/history of exceptions and a brief overview of how exception mechanics work and how they circumvent the usual stack return mechanism to set the stage. we will then examine the philosophy of using exceptions and then the many cases of exception misuse including resource management, retries, hierarchies, data passing and control flow to name but a few.

For each case, we will then suggest better ways to handle each specific situation. In many cases, exceptions are often dropped in favor of some other more appropriate paradigm.
Finally, we will introduce situations that can truly benefit from exceptions and what a model exception class might look like.

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

By Blog Staff | Jun 10, 2024 03:44 PM | Tags: None

Last time, we refined our change counter-based stateful but coalescing update notification. This version still relies on a UI thread to do two things: (1) make the final final change counter check and the subsequent callback atomic, and (2) to serialize the callbacks.

Adding State to the Update Notification Pattern, Part 7

by Raymond Chen

From the article:

If we don’t have a UI thread, then we open a race condition.

class EditControl
{
    ⟦ ... existing class members ... ⟧

    std::atomic<unsigned> m_latestId;
};

winrt::fire_and_forget
EditControl::TextChanged(std::string text)
{
    auto lifetime = get_strong();

    auto id = m_latestId.fetch_add(1, std::memory_order_relaxed);

    co_await winrt::resume_background();

    if (!IsLatestId(id))) co_return;

    std::vector<std::string> matches;
    for (auto&& candidate : FindCandidates(text)) {
        if (candidate.Verify()) {
            matches.push_back(candidate.Text());
        }
        if (!IsLatestId(id))) co_return;
    }

    // co_await winrt::resume_foreground(Dispatcher());

    if (!IsLatestId(id))) co_return;

    SetAutocomplete(matches);
}

CppCon 2023 You Should Use Address Sanitizer -- Brody Holden

By Blog Staff | Jun 8, 2024 10:42 AM | Tags: None

Lightning Talk: You Should Use AddressSanitizer

by Brody Holden

Summary of the talk:

This talk aims to get you, yes you, to use Address Sanitizer. ASan will detect various memory errors and is worth your time.

Understand Internals of std::expected -- Bartlomiej Filipek

By Blog Staff | Jun 7, 2024 03:39 PM | Tags: None

In the article about std::expected, I introduced the type and showed some basic examples, and in this text, you’ll learn how it is implemented.

Understand Internals of std::expected

by Bartlomiej Filipek

From the article:

In short, std::expected should contain two data members: the actual expected value and the unexpected error object. So, in theory, we could use a simple structure:
template <class _Ty, class _Err> 
struct expected {  
     /*... lots of code ... */  
     _Ty _Value;  
     _Err _Unexpected; 
}; 
However, there are better solutions than this. Here are some obvious issues for our “struct” approach.

The size of the object is the sum of the Value type and the Error type (plus padding if needed).

Two data members are “active” and initialized, which might not be possible - for example, what if the Value type has no default constructor? The Standard requires that std::expected" holds either a value of type Tor an error of typeE` within its storage.

We’d have to guarantee that _Ty cannot be a reference type or an array type; it must be a Destructible Type.

Similarly for the _Err type we have to guarantee that it’s also Destructible, and must be a valid template argument for std::unexpected (so not an array, non-object type, nor cv-qualified type).

Plus, we’d have to write a lot of code that creates an API for the type