A brief introduction to Concepts – Part 1

by Glennan Carnie

Concepts allow us to express constraints on template types with the goals of making generic code

• Easier to use
• Easier to debug
• Easier to write

In this pair of articles we’ll look at the basics of Concepts, their syntax and usage.  To be open up-front:  this article is designed to get you started, not to make you an expert on Concepts or generic code...

Did anybody consider adding a language pragma to C++?

For people who don't know, language pragmas are the way that ghc (Glasgow Haskell Compiler) allows you to turn on and off language features. In C++, this would mean that I can write something like:

#language <no_c_style_cast>

And that would disable C-style cast for that source file. Don't you think that it would be useful to standardize this to allow people to willingly disable some old legacy C++ features in newer code?

Simple data structures

by Arne Mertz

Keep simple data structures simple! There’s no need for artificial pseudo-encapsulation when all you have is a bunch of data...

The SoA Vector – Part 1: Optimizing the Traversal of a Collection

by Sidney Congard

I like C++ because it offers a good compromise between writing expressive and fast code. But, I discovered a problem where I didn’t know any way to hide the implementation detail away from its use: The “Structure of Arrays” (SoA) versus the “Array of Structures” (AoS) problem.

This is the first part of a series of two articles:

• what ‘SoA’ is about and what benefits it brings (part 1)
• how to implement an SoA vector in C++ (part 2)

So let’s see what those SoA and AoS are all about...

Overload 148 is now available

Revolution, Restoration and Revival.
Trends cycle in seasons. Frances Buontempo wonders what programmers should on the lookout for.

Diseconomies of Scale.
Bigger is not always better. Allan Kelly considers when smaller is more productive.

Flip Model: A Design Pattern.
Publishing dynamic, complex data to many clients in a threadsafe manner is challenging. Daniele Pallastrelli presents the Flip model pattern to overcome the challenges.

Memory Management Patterns in Business-Level Programs.
There are many memory management patterns. Sergey Ignatchenko considers these from an application level.

Compile-time Data Structures in C++17: Part 3, Map of Values.
A compile time map of values allows code to be tested more easily. Bronek Kozicki demonstrates how to avoid a central repository of values.

Algol 68 - A Retrospective.
Algol 68 has influenced programming languages in many ways. Daniel James reminds us just how many.

Measuring Throughput and the Impact of Cache-line Awareness.
How do you measure throughput? Richard Reich and Wesley Maness investigate suitable metrics.

Stop with the CTAD FUD!

by Colby Pike

Among the catalog of features introduced by C++17, you’ll find a feature known as Class Template Argument Deduction, often shortened to “CTAD”. It was one of the largest language changes in C++17, and with it comes a new syntax and a new set of rules to understand.

It’s still very early in the game for CTAD, but we’re already seeing many strong opinions about it without seeing its widespread effect on codebases. In particular, we’re seeing a lot of Fear, Uncertainty, and Doubt about CTAD...

Overview of std::map’s Insertion / Emplacement Methods in C++17

by Walletfox

TL;DR Go ahead and try out the C++17 emplacement / insertion methods. They offer a tangible improvement in terms of expressiveness and code safety.

Here are examples of code using them...

Deducing your intentions

by Andrzej Krzemieński

The language feature in C++17 known as class template argument deduction was intended to supersede factory functions like make_pair, make_tuple, make_optional, as described in p0091r2. This goal has not been fully achieved and we may still need to stick to make_ functions. In this post we will briefly describe what class template argument deduction is, and why it works differently than what people often expect...

Standard Ranges

by Eric Niebler

As you may have heard by now, Ranges got merged and will be part of C++20. This is huge news and represents probably the biggest shift the Standard Library has seen since it was first standardized way back in 1998.

This has been a long time coming. Personally, I’ve been working toward this since at least November 2013, when I opined, “In my opinion, it’s time for a range library for the modern world,” in a blog post on input ranges. Since then, I’ve been busy building that modern range library and nailing down its specification with the help of some very talented people.

Future blog posts will discuss how we got here and the gritty details of how the old stuff and the new stuff play together (we’re C++ programmers, we love gritty details), but this post is strictly about the what...

span: the best span

by Barry Revzin

This post is a response to RangeOf: A better span, which has many problems worth addressing in detail. While most of this post will deal with specifically std::span<T> (which is indeed the best span), the last section will also discuss a recent addition to the standard library: std::ranges::subrange<T*>...