Jonathan Boccara's blog

A new post every Tuesday and Friday morning

The real difference between struct and class

Published June 13, 2017 - 10 Comments

“Should I use a struct or a class?” Such is the question many C++ programmers ask themselves, or ask around to more experienced co-workers, when designing their code. There is sometimes a cloud of misconception about what the difference between struct and class technically is, particularly amongst the youngest developers. And once we get to understand the technical difference, […]

Using toString on Custom Types in C++

Published June 6, 2017 - 12 Comments

“Give me a string representation of this object.” This is a fairly ubiquitous sentence in programming, that many languages express in one brief statement: Java has .toString(), Python has str and Haskell has show, to cite just a few. My goal here is to propose a concise way to also express this in C++. Note: after I wrote […]

Expressive C++ Template Metaprogramming

Published June 2, 2017 - 3 Comments
Expressive template metaprogramming tmp

There is a part of C++ developers that appreciate template metaprogramming. And there are all the other C++ developers. While I consider myself falling rather in the camp of the aficionados, I’ve met a lot more people that don’t have a strong interest for it, or that even find it downright disgusting, than TMP enthusiasts. Which camp do you […]

Making Strong Types Hashable

Published May 30, 2017 - 5 Comments

Strong types are types that are built over primitive types, and add meaning to them. My purpose today is two-fold: showing you how to write an STL-compliant hash function for custom types so that they can be used in unordered containers such as std::unordered_map, making a hash function available for strong types. For more about the motivation […]

Strong Units Conversions

Published May 26, 2017 - 0 Comments

Strong types are a way to add a meaning to objects by giving them a meaningful name, by using types. This lets the compiler, human beings, and developers understand better the intent of a piece of code. We’ve been exploring strong types on Fluent C++. I focus here on how to define strong types conversions. If you want to catch […]

Strong types: inheriting the underlying type’s functionalities

Published May 23, 2017 - 4 Comments

This post is part of the series on strong types: Strongly typed constructors Strong types for strong interfaces Passing strong types by reference Strong lambdas: strong typing over generic types Good news: strong types are (mostly) free in C++ Inheriting functionalities from the underlying type Making strong types hashable Converting strong units to one another Metaclasses, the […]

The Curiously Recurring Template Pattern (CRTP)

Published May 12, 2017 - 11 Comments
CRTP definition curiously recurring recursive template pattern

The Curiously Recurring Template Pattern (CRTP) is a C++ idiom whose name was coined by James Coplien in 1995, in early C++ template code. The “C” in CRTP made it travel the years in the C++ community by being this: a Curiosity. We often find definitions of what CRTP is, and it is indeed an […]