New post at C++ Stories: Under the Covers of C++ Lambdas

See a new blog post at C++ Stories!

This time it's a guest post by Andreas Fertig who explains the problems of translating lambda syntax into the closure type.

See here:

Under the Covers of C++ Lambdas: Captures, Captures, Captures @C++Stories

 

The First New Article on C++ Stories!

Since more than a year I've been developing a "shadow" website called C++ Stories that will eventually take please of this blog. The site is live and most of my articles are also available there.

Today I'm happy to invite you to a fresh new post available only at cppstories.com!

Have a look:

How to Share Code with Const and Non-Const Functions in C++

Runtime Polymorphism with std::variant and std::visit

Runtime polymorphism usually connects with v-tables and virtual functions. However, in this blog post, I’ll show you a modern C++ technique that leverages std::variant and std::visit. This C++17 technique might offer not only better performance and value semantics but also interesting design patterns.

C++20 Ranges, Projections, std::invoke and if constexpr

Continuing the topic from last week, let’s dive into the topic of std::invoke. This helper template function helps with uniform syntax call for various callable object types and can greatly reduce the complexity of our generic code.

17 Smaller but Handy C++17 Features

When you see an article about new C++ features, most of the time you’ll have a description of major elements. Looking at C++17, there are a lot of posts (including articles from this blog) about structured bindings, filesystem, parallel algorithms, if constexpr, std::optional, std::variant… and other prominent C++17 additions.

But how about some smaller parts? Library or language improvements that didn’t require decades to standardise or violent “battles” at the ISO meetings.

In this article, I’ll show you 17 (plus a few extra!) smaller C++17 things that will improve your code.

Increased Complexity of C++20 Range Algorithms Declarations - Is It Worth?

With the addition of Ranges and Concepts in C++20, our good old algorithm interfaces got super long “rangified” versions. For example, copy is now 4 lines long… and it’s just the declaration!

template <ranges::input_range R, std::weakly_incrementable O>
requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr ranges::copy_result<ranges::borrowed_iterator_t<R>, O>
copy(R&& r, O result);

How to decipher such a long declaration? What benefits do we get instead? Is it worth it? Let’s find out.

How To Stay Sane with Modern C++

C++ grows very fast! For example, the number of pages of the C++ standard went from 879 pages for C++98/03 to 1834 for C++20! Nearly 1000 pages! What’s more, with each revision of C++, we get several dozens of new features. Have a look at my blog post with all C++17 features, it shows 48 items, and my C++20 reference card lists 47 elements!

Do you need to learn all of that stuff to write good code?

How to stay sane in the C++ world today?

How to Pass a Variadic Pack as the First Argument of a Function in C++

Variadic templates and argument packs which are available since C++11 give flexibility in situations when you don’t know the number of inputs upfront. However, they are limited and can only appear at the end of the type sequence.

Have a look at today’s blog post from Jonathan Boccara, who describes a technique that might improve this situation. We’ll also look into the future.

How I Improved My Legacy C++ Project with PVS-Studio

Since a few months, I’ve been refactoring my old C++/OpenGL project. Thus far, I used compilers (MSVC and Clang), my knowledge or free tools. At some point, I also got a chance to leverage a solid static analysis tool - PVS-Studio. The tool helped me with identifying 8 critical issues not to mention good code style and performance enhancements (in total 137 warnings)

Read on to see my report.

Replacing unique_ptr with C++17's std::variant a Practical Experiment

Some time ago I wrote about a new way to implement runtime polymorphism which is based not on virtual functions but on std::visit and std::variant. Please have a look at this new blog post where I experiment with this approach on my home project. The experiment is more practical than artificial examples.

See advantages, disadvantages and practical code issues.

6 Efficient Things You Can Do to Refactor a C++ Project

I took my old pet project from 2006, experimented, refactored it and made it more "modern C++". Here are my lessons and six practical steps that you can apply in your projects.

Let’s start

C++17: Polymorphic Allocators, Debug Resources and Custom Types

In my previous article on polymorphic allocators, we discussed some basic ideas. For example, you’ve seen a pmr::vector that holds pmr::string using a monotonic resource. How about using a custom type in such a container? How to enable it? Let’s see.

How to Check String or String View Prefixes and Suffixes in C++20

Up to (and including) C++17 if you wanted to check the start or the end in a string you have to use custom solutions, boost or other third-party libraries. Fortunately, this changes with C++20.

See the article where I’ll show you the new functionalities and discuss a couple of examples.

C++ Lambda Week: Some Tricks

We’re on the last day of the lambda week. We have all the essential knowledge, and now we can learn some tricks!