C++ Initialization Story
$9.99
Minimum price
$19.99
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.

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 is a short quiz on constructors. You can check your knowledge from the first "part" of the book.
  • Chapter 7 (in progress): Type deduction.
  • 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, and 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.

Most sections are completed, but I'm still working on filling two chapters and polishing the quality.

Who is this book for?

The book is intended for beginner/intermediate C++ programmers who want to learn how to work with static and non-static class data members 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

About the Author

Bartłomiej Filipek
Bartłomiej Filipek

Bartłomiej (Bartek) Filipek is a C++ software developer with more than 12 years of professional experience. In 2010 he graduated from Jagiellonian University in Cracow, Poland with a Masters 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

$34.98
Suggested price
$14.99
Bundle Price
$64.93
Suggested price
$29.99
Bundle Price

Reader Testimonials

Jonathan Boccara
Jonathan Boccara

(fluentcpp.com)

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, and different kinds of data members. I like that it addresses the latest features of C++, including C++20.

Andreas Fertig
Andreas Fertig

andreasfertig.info

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

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
    • Code license
    • Formatting
    • Special sections
  • About the Author
  • Acknowledgements
  • Revision History
  • 1. Local Variables and Simple Types
    • Starting with simple types
    • Setting values to zero
    • Initialization with aggregates
    • Default data member initialization
    • Summary
  • 2. Classes and Initialization With Constructors
    • A simple class type
    • Basics of constructors
    • Body of a constructor
    • Adding constructors to DataPacket
    • Compiler-generated default constructors
    • Explicit constructors and conversions{#sectionexplicitctor}
    • 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
  • 4. Delegating and Inheriting Constructors
    • Delegating constructors
    • Limitations
    • Inheritance
    • Inheriting constructors
  • 5. Destructors
    • Basics
    • Objects allocated on the heap
    • Destructors and data members
    • Virtual destructors and polymorphism
    • Partially created objects
    • A compiler-generated destructor
    • Summary and use cases
  • 6. Initialization and Type Deduction
  • 7. Quiz on Special Member Functions
  • 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
    • NSDMI summary
    • NSDMI: Exercises
  • 9. Containers as Data Members
    • The basics
    • Using std::initializer list
    • Example implementation
    • More options (advanced)
    • Summary
  • 10. Non-regular Data Members
    • Constant non-static data members
    • References as data members
    • Pointers as data members
    • Moveable-only data members
    • Summary
  • 11. Non-local objects
    • Storage duration and linkage
    • Initialization of non-local static objects
    • Static variables in a function scope
    • constinit in C++20
    • About static data members
    • Motivation for inline variables
    • Exercise for inline variables
    • Global inline variables
    • constexpr and inline variables
    • Summary
  • 12. Aggregates and Designated Initializers in C++20
    • Aggregates in C++20
    • The basics of Designated Initializers
    • Rules
    • Advantages of designated initialization
    • Examples
    • Summary
  • 13. Techniques and Use Cases
    • Using explicit for strong types
    • Best way to initialize string data members
    • The copy and swap idiom
    • CRTP class counter
    • Several initialization types in one class
    • Vector like RAII object
    • Factory with self-registering types
    • Summary
  • 14. The Final Quiz
  • Appendix A - Rules for Special Member Function Generation
    • The diagram
    • Rules
  • Appendix B - Quiz and Exercises Answers
    • The quiz after Inheriting Constructors
    • The final quiz
    • Solution to the first coding problem
    • Solution to the second coding problem
    • Solution to the third coding problem
  • 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.

See full terms

Do Well. Do Good.

Authors have earned$11,948,857writing, publishing and selling on Leanpub, earning 80% royalties while saving up to 25 million pounds of CO2 and up to 46,000 trees.

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