Book review: C++ Initialization Story
Tags: cpp
Published: 2023-07-03 18:35:18

---
title: Book review: C++ Initialization Story
published: true
date: 2023-03-27 19:23:47 UTC
tags: cpp
canonical_url: https://asawicki.info/news_1766_book_review_c_initialization_story
---

Courtesy its author Bartłomiej Filipek (author of [cppstories.com](https://www.cppstories.com/) website), I was given an opportunity to read a book **“C++ Initialization Story"**. Below you will find my review.

![](https://asawicki.info/files/Book_CPP_init_story.jpg)

How many ways are there to initialize a variable in C++? I can think of at least the following:

```
int i1;
int i2; i2 = 123;
int i3 = 123;
int i4(); // function declaration not a variable
int i5(123);
int i6 = int(123);
int i7{};
int i8 = {};
int i9 = int{};
int iA{123};
int iB = {123};
int iC = int{123};
```

Do you know the difference between them? Which variable stays uinitialized, which is initialized with a value 0 or 123? What if I used a custom type instead of the basic `int`? How many copies of the object would be created? What if that type was a class having some custom constructors? Which constructor would get called? What if it was a `std::vector` or some other container?

Question like this is the foundation of this book, but topics covered by it are much wider. This book is a relatively big one. On 279 pages, the author treats the topic of "initialization" as an opportunity to describe various concepts of C++ language. Modern versions of the language standard are covered, up to C++23, but features that require new versions are explicitly marked as such. The book is not about some exotic quirks and tricks that can be done by stretching the language to its limits, but it is about concepts that are fundamental in any C++ program.

Initialization of local variables, as shown in the code above, is just the subject of the first chapter. Then initialization of "non-static data members" is described, which basically means variables inside structures and classes. Constructors obviously play the major role here, so their syntax and behavior is also described in details here. When talking about constructors, description of assignment operators and destructors follows naturally. Of course, these language constructs are described also in light of move semantics introduced by C++11. For example, did you know that `std::vector<T>` on resize will be able to use move constructor of your type `T` instead of performing a copy only when the move constructor is marked as `noexcept`?

Another topic related to initialization is an automatic deduction of types: `auto` keyword and template arguments. Special kinds of variables - `static` and `thread_local` are also described. The book also teaches new language constructs added for convenient variable initialization, like structured binding, designated initializers, or `static inline`. If you only used the old version if C++ so far, do you know that following syntax is now possible? Do you know what it means?

```
auto[iter, inserted] = mySet.insert(10);

Point p {
    .x = 10.0,
    .y = 20.0
};

class C {
    static inline int classCounter = 0;
```

When it comes to the difficulty level of the book, I would call it intermediate. Only some knowledge of C++ is required. Author explains every topic covered from very basics and shows simple code samples. The book additionally features a quiz in the middle and at the end, as well as a chapter with "techniques and use cases". For example, did you know that the most robust and efficient way to initialize a class with a string is to pass it by... value?

```
struct StringWrapper {
    std::string str_;
    StringWrapper(std::string str) : str_{std::move(str)} { }
```

For a long time I've been skeptical about new language standards like C++11, C++14, C++17, C++20. C++ is a tough language already, so every fresh addition only adds more complexity to it. It used to remind me of some elaborated, tricky Boost-style templates. But now, the more I use new features of the language (at least in my personal code), the more I like it. I always liked RAII and `unique_ptr`, but now with move semantics, return value optimization, `std::optional`, `std::variant`, and many other additions to the language small and big, it all starts to fit together. Code is clean, concise, readable, safe (no explicit `new` or `delete`!), and efficient at the same time. I now think that it is not an inherent feature of C++ to be verbose (with tons of boilerplate code required) and unsafe (with memory access violation errors easy to make), it is the old-fashioned approach of treating is as "C with classes". I hope that over time more and more developers, especially those who make key decisions in software projects, will also notice that and will allow using modern C++.

The book can be bought as ebook on **[leanpub.com](https://leanpub.com/cppinitbook)**, as well as in printed version on **[Amazon](https://www.amazon.com/dp/B0BW38DDBK?&linkCode=sl1&tag=bfilipek-20&linkId=76565ec8504083fbaae116133da82c20&language=en_US&ref_=as_li_ss_tl)**. I can strongly recommend it - it is really good! See also my reviews of previous book by this author: ["C++17 in Detail"](news_1715_book_review_c17_in_detail) and ["C++ Lambda Story"](news_1739_book_review_c_lambda_story).