Pure Virtual C++ 2021 Schedule Available

by Sy Brand

The schedule for Pure Virtual C++ 2021 is now live on the event website. Remember to sign up to be the first to access our extra on-demand C++ demos and get more virtual surprises...

Five Awesome C++ Papers for the Q1 2021 and C++23 Status

by Bartlomiej Filipek

Between 2018 and 2020, I released several articles with top 5 proposals just around a new ISO C++ meeting happened. Since March 2020, this pattern broke as the meeting went online. Why not restart the series? We can look at the recent papers from a whole Quarter.

Let’s start!

C++ coroutines: Allowing the awaiter to be destroyed while suspended

by Raymond Chen

One issue that we dealt with when we created our co_await awaitable signal was the case of the awaiter being destroyed while suspended. We had been ignoring that problem in our coroutine promise, but we can’t keep our head in the sand forever. Let’s take a look around and see where we are.

Clang 12.0.0 is released

This document contains the release notes for the Clang C/C++/Objective-C frontend, part of the LLVM Compiler Infrastructure, release 12.0.0. Here we describe the status of Clang in some detail, including major improvements from the previous release and new feature work. For the general LLVM release notes, see the LLVM documentation. All LLVM releases may be downloaded from the LLVM releases web site.

For more information about Clang or LLVM, including information about the latest release, please see the Clang Web Site or the LLVM Web Site.

Note that if you are reading this file from a Git checkout or the main Clang web page, this document applies to the next release, not the current one. To see the release notes for a specific release, please see the releases page...

Pros and Cons of Alternative Function Syntax in C++

by Petr Zemek

C++11 introduced an alternative syntax for writing function declarations. Instead of putting the return type before the name of the function (e.g. int func()), the new syntax allows us to write it after the parameters (e.g. auto func() -> int). This leads to a couple of questions: Why was such an alternative syntax added? Is it meant to be a replacement for the original syntax? To help you with these questions, the present blog post tries to summarize the advantages and disadvantages of this newly added syntax...

C++ coroutines: Getting rid of our reference count

by Raymond Chen

In an earlier installment, we simplified our promise_ptr type, and one of the consequences of this is that there are no remaining caller of increment_ref. This means that we don’t need a reference count at all and can rely on the state changes to tell us when to destroy the promise: When the awaiter has obtained the result or, or when the coroutine completes and discovers that the awaiter has abandoned its effort to obtain the result...

C++ coroutines: Getting rid of our mutex

by Raymond Chen

Our coroutine implementation uses a mutex to guard against the race condition where a coroutine completes at the same time another thread tries to wait for its completion. The race condition in question is this one...

Visual Studio Code C++ Extension April 2021 Update: CUDA C/C++ IntelliSense and Apple Silicon Support

by Julia Reid

The April 2021 update of the Visual Studio Code C++ extension is now available! This latest release offers brand new features—such as IntelliSense for CUDA C/C++ and native language server support for Apple Silicon— along with a bunch of enhancements and bug fixes. To find out more about all the enhancements, check out our release notes on GitHub...

C++ coroutines: Making it impossible to co_await a task twice

by Raymond Chen

One design limitation of the coroutine implementation we’ve been developing is that it supports only one co_await client. We enforce this with a runtime assertion, but what if the problem occurs in the release build?

C++ coroutines: Tradeoffs of making the promise be the shared state

by Raymond Chen

Last time, we traced the lifetimes of the objects involved in the coroutine function. Now we can look at some of the tradeoffs we’ve made in our design and see how the decisions are intertwined...