Smelly std::pair and std::tuple

by Arne Mertz

Depending on their use, std::pair and std::tuple can be code smells. That’s why we should be careful around these two.

Having a code smell is not a no-go, it’s more like a red flag. It’s one of those things that are not a problem themselves but rather a hint that there might be a less obvious problem hidden in the code.

Dissecting An Optimization

by Jason Turner

In this episode of C++ Weekly we look at a unique optimization that Clang does. We take the assembly language apart instruction by instruction to determine what it is doing and how it is better than the other optimizations that are possible.

Constexpr Additions in C++17

by Arne Mertz

Last year, I have written about constexpr and compile time constants in general. Last week, the Draft International Standard for C++17 has been sent to its ballot. Time to provide some updates to earlier posts!

Does const mean thread-safe?

by Anthony Williams

There was a discussion recently on the cpplang slack about whether const meant thread-safe.

As with everything in life, it depends. In some ways, yes it does. In others, it does not. Read on for the details.

Singleton revisited

by Giuseppe Puoti

It happens quite often to deal with those annoying objects, used everywhere in your applications. This may be because of a poorly designed application but, sometime, it is simply an inevitable condition...

Reflections on the reflection proposals

by Jens Weller

A few weeks ago I wrote a short overview over the most interesting papers for the current C++ Committee meeting in Kona, Hawaii. The big surprise was that there were many papers on reflection, while there already is a very detailed proposal for reflection.

With the C++ committee currently in Kona discussing lots of proposals, there will be some changes to the on going effort for reflection, but the current proposals are detailed enough to give an overview.

Generating Sequences

By Anthony Williams

I was having a discussion with my son over breakfast about C++ and Python, and he asked me if C++ had anything equivalent to Python's range() function for generating a sequence of integers. I had to tell him that no, the C++ standard library didn't supply such a function, but there were algorithms for generating sequences (std::generate and std::generate_n) into an existing container, and you could write something that would provide a "virtual" container that would supply a sequence as you iterated over it with range-for...

Advanced Stateful Lambdas

by Jason Turner

In this episode Jason tries to see just how far he can take the idea of a “stateful lambda” by building one that can be manipulated and interacted with from the caller side.

Who owns who

by Thomas Young

A key take-away is that a simple reference counting strategy can be the ideal way to manage lifetimes for API objects, since, as the API designer we can choose to enforce a directed acyclic graph dependency structure.

Lambda Overdose

by Arne Mertz

Lambdas are a nice recent addition to C++. They are cool, they are hip, and they tend to be overused and misused.

Since lambda expressions came up in C++11 and got a huge boost in usability in C++14, they have been all the rage. Don’t get me wrong. Lambdas really are useful and cool and everything. But reading blog posts, the CppLang Slack channel and other sources lately has given me the impression that some people use lambdas in ways they should not be used...