C++ Initialization Story
Minimum price
Suggested price

C++ Initialization Story

A Guide Through All Initialization Options and Related C++ Areas

About the Book

Initialization in C++ is a hot topic! The internet is full of discussions about best practices, and there are even funny memes on that subject. The situation is not surprising, as there are more than a dozen ways to initialize a simple integer value, complex rules for the auto-type deduction, data members, and object lifetime nuances.

And here comes the book.

Throughout this text, you will learn practical options to initialize various categories of variables and data members in Modern C++. More specifically, this text teaches multiple types of initialization, constructors, non-static data member initialization, inline variables, designated initializers, and more. Additionally, you’ll see the changes and new techniques from C++11 to C++20 and lots of examples to round out your understanding.

Learn C++ from the perspective of C++ Initialization!

The plan is to explain most (if not all) parts of initialization, learn lots of excellent C++ techniques, and see what happens under the hood.

The goal of this book is to equip you with the following knowledge:

  • Explain rules about object initialization, including regular variables, data members, and non-local objects.
  • How to implement special member functions (constructors, destructors, copy/move operations) and when they are helpful.
  • How to efficiently initialize non-static data members using C++11 features like non-static data member initialization, inheriting, and delegating constructors.
  • How to streamline working with static variables and static data members with inline variables from C++17.
  • How to work with container-like members, non-copyable data members (like `const` data members) or move-able only data members, or even lambdas.
  • What is an aggregate, and how to create such objects with designated initializers from C++20.

The book contains 14 chapters in the following structure:

  • Chapters 1 to 5 create a foundation for the rest of the book. They cover basic initialization rules, constructors, destructors, and the basics of data members.
  • Chapter 6 on Type deduction - auto, decltype, AAA and more.
  • Chapter 7 is a quiz with 10 questions. You can check your knowledge from the first 6 chapters.
  • Chapter 8 describes Non-static Data Member Initialization (NSDMI), a powerful feature from C++11 that improves how we work with data members. At the end of the chapter, you can solve a few exercises.
  • Chapter 9 discusses how to initialize container-like data members.
  • Chapter 10 contains information about non-regular data members and how to handle them in a class. You'll learn about const data members, unique_ptr as a data member, and references.
  • Chapter 11 describes static non-local variables, static objects, various storage duration options, inline variables from C++17, and constinit from C++20.
  • Chapter 12 moves to C++20 and describes Designated Initializers, a handy feature based on similar thing from the C language.
  • Chapter 13 shows various techniques like passing strings into constructors, strong typing, CRTP class counter, Copy and swap idiom, self-registering types more.
  • Chapter 14 is the final quiz with questions from the whole book.

And there are two appendices:

  • Appendix A - a handy guide about rules for compiler-generated special member functions.
  • Appendix B - answers to quizzes and exercises.

Who is this book for?

The book is intended for beginner/intermediate C++ programmers who want to learn various aspects of initialization in Modern C++ (from C++11 to C++20).

You should know at least some of the basics of creating and using custom classes.

This text is also helpful for experienced programmers who know older C++ standards and want to move into C++17/C++20

See the reviews at:

>>  C++ Initialization Story by Bartłomiej Filipek @Goodreads

>> Adam Sawicki Coding Blog:Book Review


About the Author

Bartłomiej Filipek
Bartłomiej Filipek

Bartłomiej (Bartek) Filipek is a C++ software developer from the beautiful city of Cracow in Poland He started his professional coding career in 2007. In 2010 he graduated from Jagiellonian University in Cracow, Poland, with a Master's Degree in Computer Science.

Bartek currently works at Xara, where he develops features for advanced document editors. He also has experience with desktop graphics applications, game development, large-scale systems for aviation, writing graphics drivers and even biofeedback. In the past, Bartek has also taught programming (mostly game and graphics programming courses) at local universities in Cracow.

Since 2011 Bartek has been regularly blogging at bfilipek.com and cppstories.com. Initially, the topics revolved around graphics programming, but now the blog focuses on core C++. He's also a co-organiser of the C++ User Group in Cracow. You can hear Bartek in one @CppCast episode where he talks about C++17, blogging and text processing.

Since October 2018, Bartek has been a C++ Expert for the Polish National Body, which works directly with ISO/IEC JTC 1/SC 22 (C++ Standardisation Committee).

In the same month, Bartek was awarded his first MVP title for the years 2019/2020 by Microsoft.

In his spare time, he loves assembling Lego models with his little son.

See his blog at cppstories.com.

Bundles that include this book

Bought separately
Minimum price
Suggested price
Bought separately
Minimum price
Suggested price

Reader Testimonials

Jonathan Boccara
Jonathan Boccara


A new thorough and practical book from Bartek that will take you by the hand and give you an in-depth understanding of a core aspect of C++. The book starts with simple examples and then guides you through various aspects of constructors, different kinds of data members, and various initialization techniques. I like that it addresses the latest features of C++, including C++20.

Andreas Fertig
Andreas Fertig


C++ Initialization Story gives you an excellent overview of how to initialize different types of objects in Modern C++. I like the practical examples, detailed overview, and discussions of various techniques for custom types design.

Adrian Ostrowski
Adrian Ostrowski

Architect at Intel, Modern C++ enthusiast, and Author

Initialization in C++ is a complex subject, but C++ Initialization Story simplifies it in a way anyone can understand. Bartłomiej takes you on a journey full of practical examples, useful techniques, and best practices, showing you how they evolve with recent C++ standards. Not only will you learn about initialization but many other areas of the language as well. By the end of this book, you will have the skills to write idiomatic code and design bug-resistant types with ease.

Michael Goldshteyn
Michael Goldshteyn

Software Architect

Well-written and comprehensive book which provides a good opportunity for developers of all skill levels to thoroughly study this important aspect of C++. Bartek does an excellent job of taking a diverse topic and presenting it with plenty of examples and text that is both interesting to read and easy to comprehend. The ordering of the chapters of the book has been very well thought out and provides a great path through the topic, from fundamental ideas to more tangential topics.

Adam Sawicki
Adam Sawicki

Graphics Developer, asawicki.info

C++ is a complex language. This book explains not only variables initialization, but also constructors, move semantics, type deduction with "auto", and many other topics, up to the modern C++20. It does this in a very good way, with lots of examples.

Table of Contents

  • About the Book
    • Why should you read this book?
    • Learning objectives
    • The structure of the book
    • Who is this book for?
    • Prerequisites
    • Reader feedback & errata
    • Example code
    • Formatting & Layout
  • About the Author
  • Acknowledgements
  • Revision History
  • 1. Local Objects
    • Starting with custom type
    • Setting values to zero
    • Copy and direct initialization
    • Initialization with aggregates
    • Default data member initialization
    • Summary
  • 2. Initialization With Constructors
    • Defining a class
    • Basics of constructors
    • Body of a constructor
    • Adding constructors to DataPacket
    • Compiler-generated default constructors
    • Explicit constructors and conversions
    • Difference between direct and copy initialization
    • Implicit conversion and converting constructors
    • Constructor summary
  • 3. Copy and Move Operations
    • Copy constructor
    • Move constructor
    • Distinguishing from assignment
    • Adding debug logging to constructors
    • Trivial classes and user-provided default constructors
    • Summary
  • 4. Delegating and Inheriting Constructors
    • Delegating constructors
    • Limitations
    • Inheritance
    • Inheriting constructors
    • Summary
  • 5. Destructors
    • Basics
    • Objects allocated on the heap
    • Destructors and data members
    • Virtual destructors and polymorphism
    • Partially created objects
    • A compiler-generated destructor
    • Summary
  • 6. Type Deduction and Initialization
    • Deduction with auto
    • About value categories in C++
    • Rules for auto type deduction
    • Deduction with decltype
    • Printing type info
    • Structured bindings since C++17
    • Template Argument Deduction for Class Templates
    • Lifetime extension, references, and loops
    • Almost Always Auto
    • Summary
  • 7. Quiz from Chapters 1…6
  • 8. Non-Static Data Member Initialization
    • How it works
    • Investigation
    • Experiments
    • Other forms of NSDMI
    • Copy constructor and NSDMI
    • Move constructor and NSDMI
    • C++14 changes
    • C++20 changes
    • Limitations of NSDMI
    • NSDMI: Advantages and Disadvantages
    • Summary
  • 9. Containers as Data Members
    • The basics
    • Using std::initializer_list
    • Example implementation
    • The cost of copying elements
    • Some inconvenience - non-copyable types
    • More options (advanced)
    • Summary
  • 10. Non-regular Data Members
    • Constant non-static data members
    • Pointers as data members
    • Smart pointers as data members
    • References as data members
    • Summary
  • 11. Non-local objects
    • Storage duration and linkage
    • Initialization of non-local static objects
    • constinit in C++20
    • Static variables in a function scope
    • About static data members
    • Motivation for inline variables
    • Global inline variables
    • constexpr and inline variables
    • Summary
  • 12. Aggregates and Designated Initializers in C++20
    • Aggregates as of C++20
    • The basics of designated initializers
    • Rules for designated initializers
    • Advantages of designated initialization
    • Examples
    • Summary
  • 13. Techniques and Use Cases
    • Using explicit for strong types
    • Best way to initialize string data members
    • Reducing extra copies through emplace and in_place
    • The copy and swap idiom
    • CRTP class counter
    • Several initialization types in one class
    • Meyers Singleton and C++11
    • Factory with self-registering types and static initialization
    • Summary
  • 14. The Final Quiz And Exercises
    • Exercises
  • Appendix A - Rules for Special Member Function Generation
    • The diagram
    • Rule of zero
    • Rule of three (deprecated!)
    • Rule of 5 and 6 - modern C++
    • Moveable-only types
    • Polymorphic base classes
  • Appendix B - Quiz and Exercises Answers
  • References
  • Notes

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

Now, this is technically risky for us, since you'll have the book or course files either way. But we're so confident in our products and services, and in our authors and readers, that we're happy to offer a full money back guarantee for everything we sell.

You can only find out how good something is by trying it, and because of our 100% money back guarantee there's literally no risk to do so!

So, there's no reason not to click the Add to Cart button, is there?

See full terms...

80% Royalties. Earn $16 on a $20 book.

We pay 80% royalties. That's not a typo: you earn $16 on a $20 sale. If we sell 5000 non-refunded copies of your book or course for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earnedover $13 millionwriting, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub