A Recap on string_view

by Jonathan Boccara

The string capabilities of C++ have little evolved since C++98, until C++17 brought a major evolution: std::string_view.

Let’s look at what string_view is about and what it can bring to your code, by making it more expressive and making it run faster...

unique_ptr, shared_ptr, weak_ptr, or reference_wrapper for class relationships

by Hitesh Kumar

Classes communicate with each other by having handles as members that refer to other classes. The choice of those referring-handles (e.g., pointers or references) is mostly driven by ownership or control-over-lifetime semantics.

Modern C++: Safety and Expressiveness with override and final

by Bartlomiej Filipek

While C++11 is with us for a decade now, it’s good to go back and recall some of its best features. Today I’d like to consider override and final keywords which add a crucial safety when you build class hierarchies with lots of virtual member functions.

See how to prevent common bugs, and how to leverage tools to make your code safer...

An Improved Thread with C++20

by Rainer Grimm

std::jthread stands for joining thread. In addition to std::thread (C++11), std::jthread automatically joins in its destructor and can cooperatively be interrupted. Read in this post to know why std::jthread should be your first choice...

Colony – A brief history of timing

by Matt Bentley

Back in 2014 I began designing a game engine. Experienced programmers and curmudgeonly lecturers will tell you that if you make a game engine, you’ll never make a game – which is true, but sort of irrelevant. You will learn so much from making a game engine, you probably won’t care about the game by the end of it. The main reason I wanted to develop a game engine was that I was tired of seeing very basic 2D games with incredibly bad performance even on fast computers. If we got 15 frames-per-second on Intel 386 processors in the 1990s, why was it so hard for modern 2D games to achieve the same speed on exponentially-better hardware?

Overload 161 is now available

In. Sub. Ordinate.
By Frances Buontempo
Mindless rebellion is mindless. Frances Buontempo encourages mindful consideration of when to refuse.

A Case Against Blind Use of C++ Parallel Algorithms
By Lucian Radu Teodorescu
C++17 introduced parallel algorithms. Lucian Radu Teodorescu reminds us we need to think when we use them.

C++ – an Invisible Foundation of Everything
By Bjarne Stroustrup
What is C++ and why do people still use it? Bjarne Stroustrup provides a short note answering these questions.

Test Precisely and Concretely
By Kevlin Henney
Tests can hit complete coverage but fail to communicate. Kevlin Henney reminds us that assertions should be necessary, sufficient, and comprehensible.

Afterwood
By Chris Oldwood
Think you’ve learnt it all? Chris Oldwood reminds us that unlearning then becomes our next problem.

Book “Beginning C++20”

by Marc Gregoire

My friend Peter Van Weert finished a new edition of “Beginning C++20” for which I was technical editor. It’s a great book to learn C++20 for programmers new to C++ and those who may be looking for a refresh primer on C++ in general...

Book “C++ Lambda Story”

by Marc Gregoire

A friend of mine published a new book, titled “C++ Lambda Story”. The book explains everything you need to know about lambda expressions in C++...

GotW #99 Solution: Postconditions

by Herb Sutter

Postconditions are directly related to assertions (see GotW #97)... but how, exactly? And since we can already write postconditions using assertions, why would having language support benefit us more for writing postconditions more than for writing (ordinary) assertions?

How std::any Works

by Jonathan Boccara

In the previous post we’ve seen a very nice technique to use value semantics with inheritance and virtual methods, which was made possible by std::any.

Given its usefulness, it would be interesting to better understand std::any. Indeed, std::any is sometimes said to be “the modern void*“. But it does much more than a void*...