\n6. Initialization and Type Deduction

Content available in the full version of the book.

",{"_421":422,"_43":44,"_47":16,"_45":46,"_64":65,"_423":424,"_522":419},"previewContent","

\n About the Book\n
- \n Why should you read this book?\n
- \n Learning objectives\n
- \n The structure of the book\n
- \n Who is this book for?\n
- \n Prerequisites\n
- \n Reader feedback & errata\n
- \n Example code\n
- \n Formatting & Layout\n
\n
\n About the Author\n
\n Acknowledgements\n
\n Revision History\n
\n 1. Local Variables and Simple Types\n
- \n Starting with simple types\n
- \n Setting values to zero\n
- \n Initialization with aggregates\n
- \n Default data member initialization\n
- \n Summary\n
\n
\n 2. Classes and Initialization With Constructors\n
- \n A simple class type\n
- \n Basics of constructors\n
- \n Body of a constructor\n
- \n Adding constructors to DataPacket\n
- \n Compiler-generated default constructors\n
- \n Explicit constructors\n
- \n Difference between direct and copy initialization\n
- \n Constructor summary\n
\n
\n 3. Copy and Move Constructors\n
- \n Copy constructor\n
- \n Move constructor\n
- \n Distinguishing from assignment\n
- \n Adding logging to constructors\n
- \n Trivial classes and user-declared/user-provided default constructors\n
\n
\n 4. Delegating and Inheriting Constructors\n
- \n Limitations\n
- \n Inheritance\n
- \n Inheriting constructors\n
\n
\n 5. Destructors\n
- \n Basics\n
- \n Objects allocated on the heap\n
- \n Destructors and data members\n
- \n Virtual destructors and polymorphism\n
- \n Partially created objects\n
- \n Use Cases\n
- \n A compiler-generated destructor\n
\n
\n 6. Initialization and Type Deduction\n
\n 7. Quiz on Constructors\n
\n 8. Non-Static Data Member Initialization\n
- \n How it works\n
- \n Investigation\n
- \n Experiments\n
- \n Other forms of NSDMI\n
- \n Copy constructor and NSDMI\n
- \n Move constructor and NSDMI\n
- \n C++14 changes\n
- \n C++20 changes\n
- \n Limitations of NSDMI\n
- \n NSDMI: Advantages and Disadvantages\n
- \n NSDMI summary\n
- \n NSDMI: Exercises\n
\n
\n 9. Containers as Data Members\n
- \n The basics\n
- \n Using std::initializer list\n
- \n Example implementation\n
\n
\n 10. Non-regular Data Members\n
- \n Constant non-static data members\n
- \n References as data members\n
- \n Pointers as data members\n
- \n Moveable-only data members\n
- \n Summary\n
\n
\n 11. Inline Variables in C++17\n
- \n About static data members\n
- \n Motivation for inline variables\n
- \n Exercise for inline variables\n
- \n Global inline variables\n
- \n Constexpr and inline variables\n
\n
\n 12. Aggregates and Designated Initializers in C++20\n
- \n Aggregates in C++20\n
- \n The basics of Designated Initializers\n
- \n Rules\n
- \n Advantages of designated initialization\n
- \n Examples\n
- \n Summary\n
- \n The summary example\n
- \n Compiler support\n
\n
\n 13. Techniques and Use Cases\n
- \n Using explicit for strong types\n
- \n Best way to initialize string data members\n
- \n The copy and swap idiom\n
- \n Several initialization types in one class\n
- \n Vector like RAII object\n
- \n Factory with self-registering types\n
- \n Summary\n
\n
\n 14. The Final Quiz\n
\n Appendix A - Quiz and Exercises Answers\n
\n References\n
\n Notes\n

\nAbout the Book

\n\n

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.

\n\n

And here comes the book.

\n\n

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.

\n\n

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.

\n\n

\nWhy should you read this book?

\n\n

With Modern C++ (since C++11), we have many new features to streamline work and simplify our code. One area of improvement is initialization. Modern C++ added new initialization rules, trying to make it easy while keeping old behavior and compatibility (mainly from the C language). Sometimes the rules might seem confusing and complex, though, and even the ISO committee might need to correct some things along the way. The book will help you navigate through those principles and understand this topic better. What’s more, initialization is just one aspect of this text. You’ll learn all related topics around classes, constructors, destructors, object lifetime, or even how the compiler processes data at start-up.

\n\n

\nLearning objectives

\n\n

The goal is to equip you with the following knowledge:

\n\n

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.

\n\n

\nThe structure of the book

\n\n

The book contains 14 chapters in the following structure:

\n\n

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 describes type deduction that can be used to declare objects: auto, decltype, Almost Always Auto rule, structured bindings.
Chapter 7 is a quiz with 10 questions from the first “part” of the book.
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, and 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.

\n\n

And there are two appendices:

\n\n

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

\n\n

\nWho is this book for?

\n\n

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).

\n\n

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

\n\n

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

\n\n

\nPrerequisites

\n\n

You should have basic knowledge of C++ expressions and primitive types.
You should be able to implement an elementary class with several data members. Know how to create and manipulate objects of such a class in a basic way.

\n\n

\nReader feedback & errata

\n\n

If you spot an error, a typo, a grammar mistake, or anything else (especially logical issues!) that should be corrected, please send your feedback to bartek@cppstories.com or submit an issue at github.com/fenbf/cppinitbook_public/issues.

\n\n

Here’s the errata with the list of fixes:

\n\n

www.cppstories.com/p/cppinitbook/

\n\n

Your feedback matters! Writing an honest review can help with the book promotion and the quality of my further work. The book has a dedicated page at GoodReads. Please share your feedback at:

\n\n

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

\n\n

Or write a review at Amazon if you get this book in print form.

\n\n

\nExample code

\n\n

You can find source code of all examples in this separate GitHub public repository.

\n\n

https://github.com/fenbf/cppinitbook_public/tree/main/examples

\n\n

You can browse individual files or download the whole branch:

\n\n

https://github.com/fenbf/cppinitbook_public/archive/refs/heads/main.zip

\n\n

\nCode license

\n\n

The code for the book is available under the MIT License model.

\n\n

\nFormatting & Layout

\n\n

Code samples are presented in a monospaced font, similar to the following example:

\n\n

Title Of the Example

#include <iostream>\n\nint main() {\n    const std::string text { \"Hello World\" };\n    std::cout << text << '\\n';\n}\n

\n\n\n\n

Or shorter snippets (without a title and sometimes include statements):

\n\n

int foo() {\n    return std::clamp(100, 1000, 1001);\n}\n

\n\n\n\n

When available, you’ll also see a link to online compilers where you can play with the code. For example:

\n\n

Example title. Run @Compiler Explorer

#include <iostream>\n\nint main() {\n    std::cout << \"Hello World!\";\n}\n

\n\n\n\n

You can click on the link in the title, and then it should open the website of a given online compiler (in the above case, it’s Compiler Explorer). You can compile the sample, see the output, and experiment with the code directly in your browser. Here’s a basic overview of Compiler Explorer:

\n\n\n

\"A — A Compiler Explorer layout used in the book

\n\n\n

Snippets of longer programs might be shortened to present only the core mechanics. They may lack some #include statements or have a “compressed” line. Click on the Online Compiler link to see the full version of the program or see them in the public repository.

\n\n

\nRecommendation for Compiler Explorer and C++ Reference

\n\n

When executing the examples on Compiler Explorer, you may select a term (keyword, class, function, container or other) and then right-click (or equivalent). A context menu will appear and you can select Search on CppReference, which will take you to the C++ Reference documentation of the corresponding browser language, if such C++ Reference version exists¹.

\n\n

\nSyntax highlighting limitations

\n\n

The current version of the book might show some limitations regarding syntax highlighting.

\n\n

For example:

\n\n

The first method of a class is not highlighted - First method of class not highlighted in C++ · Issue #791.
Template method is not highlighted C++ lexer doesn’t recognize function if return type is templated · Issue #1138.
Modern C++ attributes are sometimes not appropriately recognized.

\n\n

Other issues for C++ and Pygments: C++ Issues · github/pygments/pygments.

\n\n

\nSpecial sections

\n\n

Throughout the book, you can also see the following sections:

\n\n\n\n\n\n\n\n\n

\nAbout the Author

\n\n

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

\n\n

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.

\n\n

Since 2011 Bartek has been regularly blogging at cppstories.com (started as bfilipek.com). The blog focuses on core C++ and getting up-to-date with the C++ Standards. 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.

\n\n

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).\nBartek was awarded his first MVP title for the years 2019/2020 by Microsoft.

\n\n

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

\n\n

Bartek is the author of C++17 In Detail and C++ Lambda Story.

\n\n\n

\nAcknowledgements

\n\n

This book wouldn’t be possible without valuable input from many C++ experts and friends.

\n\n

I especially would like to thank to the following people:

\n\n

JFT (John Taylor),
Mariusz Jaskółka,
Florin Chertes (see his profile at LinkedIn),
Konrad Jaśkowiec (see his profile at LinkedIn),
Professor Boguslaw Cyganek (see his profile at AGH university page),
Dawid Pilarski (see his blog at panicsoftware.com),
Javier Estrada (see his blog at javierestrada.blog),
Jonathan Boccara (from fluentcpp.com),
Andreas Fertig (see his blog at andreasfertig.blog),
Peter Sommerlad (see his website and training info at sommerlad.ch),
Timur Doumler (see his website at timur.audio and his Twitter),
Michael Goldshteyn, Software Architect.

\n\n

They spent a lot of time on finding even little things that could be improved and extended.

\n\n

Last but not least, I got a lot of valuable feedback from my blog readers, Patreon Discord Server (See C++Stories @Patreon), and discussions at C++ Polska. Thank you all!

\n\n

With all of the help from those kind people, the book quality got better and better!

\n\n\n

\nRevision History

\n\n

20th June 2022 - The first public version! Missing parts: some sections in 10. Containers as Data Members, some sections in 11. Non-regular Data Members.
22nd June 2022 - new sections on NSDMI, direct init and parens, more about inheriting constructors, link to GoodReads, wording, hotfixes.
24th June 2022 - updated the “copy and move constructor” chapter, typos and small wording improvements.
16th July 2022 - Containers as Data Members chapter rewritten, noexcept consistency and noexcept move operations advantages in the move constructor section, wording, fixes, layout.
13th September 2022 - changed title to “C++ Initialization Story”, adapted book structure, rewritten “Non-local objects” chapter (previously only on inline variables), new extracted chapter on Techniques, new section on CRTP.
18th November 2022 - heavily updated and completed “Non-regular data members” chapter, constinit and thread_local sections in the “Non-local objects” chapter, filled the “implicit conversion” section in the Constructors chapter.
23rd December 2022 - content completed! Added Deduction chapter, filled missing sections in the Techniques chapter. Layout improvements, a few more questions, exercises and fixes.
4th February 2023 - updated layout, wording improvements, fixes, improve consistency of examples.
27th February 2023 - the first edition in Print!
13th April 2023 - the final quiz questions 6th and 8th clarification, small layout fixes.
19th June 2023 - a batch of minor fixes and clarifications based on user feedback.

\n\n\n\n\n

\n1. Local Variables and Simple Types

\n\n

Let’s start simple and ask, “what is initialization?” When we go to the definition from C++Reference, we can read:

\n\n\n\n

We can translate this definition to the following example:

\n\n

void foo() {\n    int x = 42;\n    // ... use 'x' later...\n}\n

\n\n\n\n

Above, we have a function with a local variable x. The variable is declared as integer and initialized with the value 42. This is not the only way you can assign that initial value. Here are some more options:

\n\n

struct Point { int x; int y; };           // declare a custom type\nPoint createPoint(int x) { return {x, -x}; }\nint main() {\n    int x { 42 };                         // list initialization\n    double y = { 100.0 };                 // copy list initialization\n    auto ptr = std::make_unique<float>(90.5f); // auto type deduction\n    auto z = createPoint(42);             // through a factory function\n    std::string s (10, 'x');              // calling a constructor\n    Point p { 10 };                       // aggregate initialization\n    std::array<float, 100> numbers { 1.1f, 2.2f }; // array initialization\n    // ...\n}\n

\n\n\n\n

You can also come up with many other forms of setting a value. We can also extend the syntax on class data members, static variables, thread locals, or even dynamic memory allocations.

\n\n

In theory, initialization is a simple task: “put a value into a memory location of a newly created variable”. However, such action relates to many different parts of an application (local vs. non-local scope) and various places in the memory (like stack vs. heap). That’s why the syntax or the behavior might be slightly different.

\n\n

In C++, we have at least the following forms of initialization:

\n\n

aggregate initialization
constant initialization
default initialization
direct initialization
copy initialization
list initialization
reference initialization
value initialization
zero initialization
plus related topics like copy elision, static variables, conversion sequences, constructors, assignment, dynamic memory, storage, and more.

\n\n

While the list sounds complex, we’ll move through those topics step by step revealing core concepts. Later we’ll address more advanced examples and see what happens inside the C++ machinery.

\n\n

While we can explain most cases on integers and other numerical types, it’s best to work on something more practical. The book starts with some elementary custom types, then considers various issues we might have with their early implementations. Later the types will expand, giving us more context and compelling use cases.

\n\n

\nStarting with simple types

\n\n

Defining a class or a struct (a custom type) in C++ allows you to model your problem domain and solve problems more naturally. Rather than working with a bunch of variables and functions, it’s best to group them and provide a consistent API (Application Programming Interface). C++ provides a set of built-in types, including boolean, integral, character, and floating-point. Additionally, you can use objects from the Standard Library, like various collections, std::string, std::vector, std::map, std::set, and many others. You can collect these essential components and build your types.

\n\n

To create a background for our main topic, let’s start with a type representing Car Information for a car listing app. A system reads the car/truck information from a database and displays it in the application. For an easy start, the type holds four members: name (a std::string), production year, number of seats, and engine power.

\n\n\n

\n\n\n

Below there’s the first version of the code for that CarInfo type:

\n\n

Ex 1.1. Simple CarInfo structure. Run @Compiler Explorer

#include <iostream>\n#include <string>\n\nstruct CarInfo {\n    std::string name;\n    unsigned year;\n    unsigned seats;\n    double power;\n};\n\nint main() {\n    CarInfo firstCar;\n    firstCar.name = \"Renault Megane\"; \n    firstCar.year = 2003;\n    firstCar.seats = 5;\n    firstCar.power = 116;\n    std::cout << \"name: \" << firstCar.name << '\\n';\n    std::cout << \"year: \" << firstCar.year << '\\n';\n    std::cout << \"seats: \" << firstCar.seats << '\\n';\n    std::cout << \"power (hp): \" << firstCar.power << '\\n';\n}\n

\n\n\n\n

In the above example, we defined a simple structure that holds data for a CarInfo. The code is super simple, contains some issues, and follows the style of C++03. In the following few chapters, I’ll guide you through the code and help you understand the problems and how to eliminate them. We’ll also modernize it to include the latest C++ (up to C++20) features.

\n\n

First: name, year, seats and power are called non-static data members. Each instance of the CarInfo class has its own set of those members. In other words, we group variables to create a representation for models in our problem domain. A user-defined type might also have static data members, which are data shared between all instances of a given type. For example, we could imagine a static member variable called numAllCars that would indicate the total number of cars created in our program. We’ll talk about static data members later in chapter 11 Static Variables.

\n\n

Now, let’s investigate the code in detail. The definition and the declaration of the variable firstCar in the main() function:

\n\n

CarInfo firstCar;\n

\n\n\n\n

It is called default initialization and, since our struct is simple, will leave all data members of built-in types with indeterminate values. Similarly, you can get the same (potentially buggy effect) for simple types when declared in function (as such variables have automatic storage duration) ²:

\n\n

void foo() {\n    int i;     // indeterminate value!\n    double d;  // indeterminate value!\n}\n

\n\n\n\n

The std::string data member name, on the other hand, will have an empty state (an empty string) because its default constructor will be called. More on that later.

\n\n

Once the object is created and uninitialized, we can access its members and set proper values. By default, struct has public access to its members (and class has private access). This way, we can access and change their values directly.

\n\n\n\n

\nSetting values to zero

\n\n

You might feel very unsatisfied that after creating a CarInfo object, most data members have some indeterminate values. We can fix this and make sure data is at least set to “zero”. Have a look:

\n\n

Ex 1.2. Value initialization for CarInfo structure. Run @Compiler Explorer

CarInfo emptyCar{};\nstd::cout << \"name: \" << emptyCar.name << '\\n';\nstd::cout << \"year: \" << emptyCar.year << '\\n';\nstd::cout << \"seats: \" << emptyCar.seats << '\\n';\nstd::cout << \"power (hp): \" << emptyCar.power << '\\n';\n

\n\n\n\n

The output:

\n\n

name: \nyear: 0\nseats: 0\npower (hp): 0\n

\n\n\n\n

The initialization with empty braces {} is called value initialization and by default (for built-in types and classes with default constructors that are neither user-provided nor deleted), sets data to “zero” (adapted for different types). This is similar to declaring and defining the following variables:

\n\n

int i{};     // i == 0\ndouble d{};  // d == 0.0\nstd::string s{}; // s is an empty string\n\nint j = {}; // other form of value initialization\nstd::string str = {}; // ...\n

\n\n\n\n

This time the storage duration doesn’t matter, and value initialization works the same for static, dynamic, thread-local, or automatic variables. For types with default constructors (more on that later), the code will call them and, in the case of string s; will initialize it to an empty string.

\n\n

\nInitialization with aggregates

\n\n

Our structure is very simple, and for such types, C++ has special rules where we can initialize their internal values with so-called aggregate initialization. We can use such syntax also for arrays. Here are some basic examples:

\n\n

Ex 1.3. Aggregate Initialization basic syntax. Run @Compiler Explorer

// arrays:\nint arr[] { 1, 2, 3, 4 };\nfloat numbers[] = { 0.1f, 1.1f, 2.2f, 3.f, 4.f, 5. };\nint nums[10] { 1 }; // 1, and then all 0s\n\n// structures:\nstruct Point { int x; int y; };\nstruct Line { Point p1; Point p2; };\nLine longLone {0, 0, 100, 100};\nLine anotherLine = {100}; // rest set to 0\nLine shortLine {{-10, -10}, {10, 10}}; // nested\n

\n\n\n\n

In summary, for the above code:

\n\n

Each array element, or non-static class member, in order of array subscript/appearance in the class definition, is copy-initialized from the corresponding clause of the initializer list.
You can use list initialization for arrays, and when the number of elements is not provided, the compiler will deduce the count.
If you pass fewer elements in the initializer list than the number of elements in the array, the remaining elements will be value initialized. For built-in types, it means the value of zero.
For structures, you can use a single initializer list or nested one; the expansion will be recursive.
If you provide fewer values than the number of data members in the aggregate, then the remaining data members (in the declaration order) will be effectively value initialized.

\n\n

The first bullet point says that each element is copy initialized. We’ll return to this topic and explain the difference between a copy vs. direct initialization syntax once we know explicit constructors.

\n\n

For our structure, we can write the following test code:

\n\n

Ex 1.4. Aggregate initialization for the CarInfo structure. Run @Compiler Explorer

struct CarInfo {\n    std::string name;\n    unsigned year;\n    unsigned seats;\n    double power;\n};\n\nvoid printInfo(const CarInfo& c) {\n    std::cout << c.name << \", \"\n              << c.year << \" year, \"\n              << c.seats << \" seats, \"\n              << c.power << \" hp\\n\";\n}\n\nint main() {\n    CarInfo firstCar{\"Megane\", 2003, 5, 116 };\n    printInfo(firstCar);\n    CarInfo partial{\"unknown\"};\n    printInfo(partial);\n    CarInfo largeCar{\"large car\", 1975, 10};\n    printInfo(largeCar);\n}\n

\n\n\n\n

This will output:

\n\n

Megane, 2003 year, 5 seats, 116 hp\nunknown, 0 year, 0 seats, 0 hp\nlarge car, 1975 year, 10 seats, 0 hp\n

\n\n\n\n

To give you the full picture, as of C++20, here’s the definition of an aggregate type from the C++ Standard: dcl.init.aggr.

\n\n\n\n

Don’t worry if you’re not familiar with all of the cases listed above. We’ll discuss them along the way and see more aggregates in the further parts. There’s also a dedicated chapter about Aggregates and Designated Initialization in C++20.

\n\n

\nDefault data member initialization

\n\n

What if you want to provide some default value for your data member? With value initialization, you can get zeros for various types, but sometimes it might not be good enough.

\n\n

Since C++14, we can leverage Non-static Data Member Initializers (NSDMI), also called Default Member Initializers, to provide default values for aggregates. Have a look:

\n\n

Ex 1.5. Default member initialization and aggregates. Run @Compiler Explorer

#include <iostream>\n#include <string>\n\nstruct CarInfo {\n    std::string name { \"unknown\" };\n    unsigned year { 1920 };\n    unsigned seats { 4 };\n    double power { 100. };\n};\n\nvoid printInfo(const CarInfo& c) { /* */ }\n\nint main() {\n    CarInfo unknown;\n    printInfo(unknown);\n    CarInfo zeroed{};\n    printInfo(zeroed);\n    CarInfo partial{\"large car\", 1975};\n    printInfo(partial);\n}\n

\n\n\n\n

This will print:

\n\n

unknown, 1920 year, 4 seats, 100 hp\nunknown, 1920 year, 4 seats, 100 hp\nlarge car, 1975 year, 4 seats, 100 hp\n

\n\n\n\n

The syntax is quite intuitive; you can initialize a data member at the place where it’s declared. This can prevent accidental bugs where your data has some indeterminate value. As you can see from the example, even if you use default initialization or value initialization, data members will get values that were provided in the struct declaration. If you give fewer values in the aggregate initializer, the remaining members will get their defaults from the declaration.

\n\n

Technically, in-class member initializers have been available since C++11, but aggregate types weren’t supported initially. In this section, we’ve only scratched the surface of this handy technique. See the dedicated chapter for this topic: Non-static data member initialization chapter.

\n\n

\nSummary

\n\n

In this chapter, we covered some simple custom types and looked at ways to initialize their data members. We went from objects with indeterminate values to zero initialization, and then we learned about aggregates and techniques to provide default values.

\n\n

Things to keep in mind:

\n\n

Default initialization for objects and variables yields indeterminate values for built-in types or default-initialize complex types (like std::string and set it to an empty string). That’s why it’s essential to be sure your objects and simple variables are always initialized.
Value initialization like int x{}; for built-in types effectively yields zero initialization for them so that they will be zero (in their type).
With value initialization CarInfo car{}; all data members will be zero-initialized (for built-in types) or default initialized for complex types.
Aggregates are simple types or arrays with all public data members; we can initialize them with an aggregate initialization syntax.
Thanks to the in-class member initializer feature, you can provide default values for your data members.

\n\n

What’s next?

\n\n

While simple types are handy, in C++, we often need to build large objects where data members depend on each other or have invariants. In such cases, it’s best to hide them behind member functions and give access to them under certain conditions. That’s why in the next chapter, we’ll look at class’s and constructors. We’ll also expand the knowledge that we got so far.

\n\n

\n2. Classes and Initialization With Constructors

\n\n

In the previous chapter, you’ve seen that C++ might treat simple structures with all public data members as an aggregate class. Still, aggregates might not be enough if we want better data encapsulation and a more complex class API. For full flexibility in C++, we can leverage constructors that are special member functions invoked when an object is created.

\n\n

\nA simple class type

\n\n

As a background example, let’s create a type that will hold some elementary network data. To complicate things, we’d like to compute a basic checksum for the data part. Such a checksum might be handy for checking if the data was transferred correctly across the Internet (read more @Wikipedia).

\n\n

Ex 2.1. Simple DataPacket class. Run @Compiler Explorer

#include <iostream>\n#include <numeric>\n\nsize_t calcCheckSum(const std::string& s) {\n    return std::accumulate(s.begin(), s.end(), static_cast<size_t>(0));\n}\n\nclass DataPacket {\nprivate:\n    std::string data_;\n    size_t checkSum_;\n    size_t serverId_;\n\npublic:\n    const std::string& getData() const { return data_; }\n    void setData(const std::string& data) {\n        data_ = data;\n        checkSum_ = calcCheckSum(data);\n    }\n    size_t getCheckSum() const { return checkSum_; }\n    size_t getServerId() const { return serverId_; }\n    void setServerId(size_t serverId) { serverId_ = serverId; }\n};\n

\n\n\n\n

The class above contains three non-static data members: data_, checkSum_ and serverID_. I’m using the underscore suffix to indicate private data members, a common practice in many codebases. See Google C++ Style Guide.

\n\n

To keep things simple, I implemented the calcCheckSum function in terms of std::accumulate(), which is an algorithm from the C++ Standard Library. This code starts from 0 (we can use 0UZ since C++23 instead of explicit static_cast) and adds numerical values of letters from the input std::string. For example, for \"HELLO\", we’ll get the following computations:

\n\n\n

\"Calculating — Calculating simple checksum for a string

\n\n\n

DataPacket has so-called getters and setters - functions that return or change a particular data member. For example getData() returns the data_ data member, while setData(...) allows to change it.

\n\n

One important topic is that getters usually have const applied at the end. This means that a given member function is constant and cannot change the value of the members (unless they are mutable). If you have a const object, you can only call its const member functions. Applying const might improve program design as it’s usually easier to reason about the state of const instances. For more information, see this C++ core guideline: Con.2: By default, make member functions const.

\n\n\n\n

Here’s the continuation of the example where we create and use the object of the DataPacket class:

\n\n

Ex 2.2. Simple DataPacket class, continuation. Run @Compiler Explorer

int main() {\n    DataPacket packet;\n    packet.setData(\"Programming World\");\n    std::cout << packet.getCheckSum() << '\\n';\n}\n

\n\n\n\n

The code doesn’t access data members directly but calls member functions to operate on the object and change its properties.

\n\n

You can notice public and private parts in the class declaration. The order of those sections is just a coding convention and they group elements together based on their access modifier. In short, a member under the public keyword can be accessed from the outside (like calling a member function or accessing a data member). On the other hand, members under the private section cannot be accessed from ³. In C++, you can also add protected to your class declaration, which means that member functions or fields are not accessible outside. Still, they are accessible to all inherited classes (assuming public inheritance, members become private outside, but public to derived types, see more about different inheritance options @C++Reference).

\n\n

For example, in the main() function above, I cannot write:

\n\n

DataPacket packet;\npacket.serverId = 10; // error: 'size_t DataPacket::serverId' \n                    // is private within this context \n

\n\n\n\n\n\n

Since our class doesn’t have any user-defined constructors (more on them in the next section), we can also use value initialization syntax to set values to zero or default values:

\n\n

Ex 2.3. Value initialization for the DataPacket class. Run @Compiler Explorer

int main() {\n    DataPacket packet{};\n    std::cout << \"data: \" << packet.getData() << '\\n';\n    std::cout << \"checkSum: \" << packet.getCheckSum() << '\\n';\n    std::cout << \"serverId: \" << packet.getServerId() << '\\n';\n}\n

\n\n\n\n

This will generate the following output:

\n\n

data: \ncheckSum: 0\nserverId: 0\n

\n\n\n\n

However, the main difference now is that because we moved the data members to the private section, the class is not an aggregate. That’s why we cannot use aggregate initialization to set all values at once. To fix this, we need to look at constructors. And that is the plan for further sections.

\n\n

\nBasics of constructors

\n\n

A constructor is a special member function without a name, but we declare it using the enclosing class name. You cannot invoke a constructor like other member functions. Instead, the compiler calls it when an object of its class is being initialized. It has the following basic syntax:

\n\n

class/struct ClassName {\n  // ...  \n/*explicit*/ ClassName(parameter-list) = default/=delete\n  : base-class-initializer\n  , member-init \n  { /*body*/ }\n  // ... \n};\n

\n\n\n\n

A constructor has the following parts:

\n\n

constructor has no name, but we define it using the name of the class,
optional explicit - keyword to block implicit conversions on a given class type,
\nClassName - the name of the given class type (they have to match),
\nparameter-list- a list of parameters, as in a regular function, might be empty
optional = default/=delete specifies if a constructor should be deleted (not present) or defaulted by the compiler,
\n: - indicates the start of the member/base initialization list, required when base-class-initializer or member-init lists are present,
optional base-class-initializer - a list of base classes’ constructors that we explicitly want to call,
optional member-init - a list of data members where we can directly initialize them,
\n{/*body*/} - a function body.

\n\n\n\n

Let’s have a look at one snippet:

\n\n

class Product {\npublic:\n    Product() : id_{-1}, name_{\"none\"} { } // a default constructor\n    explicit Product(int id, const std::string& name) \n        : id_{id}, name_{name} { }\n\nprivate:\n    int id_;\n    std::string name_;\n};\n

\n\n\n\n

The above example shows a class Product with two constructors. The first one is called a default constructor; it has no arguments. The second one takes two arguments. As you can notice, C++ allows multiple constructors that look like overloaded functions (they differ by the number or types of arguments). Each constructor also has a regular function body where you can execute some code; in our case, they are both empty for now. I also applied the explicit keyword on the second constructor; we’ll talk about it later.

\n\n

The primary function of constructors is to perform some actions at the start of a lifetime of an object. Usually, it means data member initialization, resource allocation (opening a file, a socket, memory allocation), or even doing some special logic (like logging).

\n\n

In our case, constructors touch only data members inside a special section of constructors called member initializer list: like, id_{-1}, name_{\"none\"}. Inside this initializer list, we can also call constructors of base classes (if any). Later, we’ll address inheritance in the Inheritance section.

\n\n

The member initializer list is more efficient than using the body of a constructor. Sometimes it’s even the only option to initialize the value, as with types that are not assignable. See the following alternative:

\n\n

class Product {\npublic:\n    Product() { id_ = 0; name_ = \"none\"; } \n\nprivate:\n    int id_;\n    std::string name_;\n};\n

\n\n\n\n

The code will yield the same values for data members as in the previous example, but the data members are set in two steps rather than one. With the member initializer list data members are set directly, same as calling: int id_ { 0 } or std::string name_ {\"none\"}. On the other hand, if we use assignment in the constructor body, it requires two steps:

\n\n

// step 1: default init:\nint id_; // indeterminate value!\nstd::string name_; // default ctor called\n// step 2: assignment:\nid_ = 0;\nname_ = \"none\";\n

\n\n\n\n

While this might not be a big issue for built-in simple types like int , you’ll need some more CPU cycles for larger objects like strings.

\n\n

There’s also one important aspect about the initializer list: the order of initialization. This is covered in The C++ Specification: 11.10.3 Classes:

\n\n\n\n

When I write:

\n\n

class Product {\npublic:\n    Product() : name_{\"none\"}, id_{-1} { }\n\nprivate:\n    int id_;\n    std::string name_;\n};\n

\n\n\n\n

The values will be set correctly, but the order will differ from what we think. A compiler might show us a warning in this case. Here’s the warning from GCC compiled with -Wall option (experiment @Compiler Explorer):

\n\n

<source>: In constructor 'Product::Product()':\n<source>:15:17: warning: 'Product::name_' will be initialized after [-Wreorder]\n   15 |     std::string name_;\n      |                 ^~~~~\n<source>:14:9: warning:   'int Product::id_' [-Wreorder]\n   14 |     int id_;\n      |         ^~~\n

\n\n\n\n

The initialization order might be critical when you imply some dependency on the values. For example, we can write the following artificial sample:

\n\n

struct S {\n    int x;\n    int y;\n    int z;\n\n    S(): x{0}, y{1}, z{x+y} { }\n    // S(): y{0}, z{0}, x{z+y}, { }\n};\n

\n\n\n\n

In the above example, the first constructor initializes x and y and then uses those values to initialize z. This is complicated and might be hard to read, but it works correctly. On the other hand, in the second (commented out) constructor, the order of initialization will create an undefined behavior for initializing x, as z and y won’t be initialized yet. It’s best to avoid such dependencies to minimize the risk of bugs.

\n\n

Let’s see how a constructor works by creating some objects of the Product class:

\n\n

Product none;\n

\n\n\n\n

In the first example, we created the none object, which is default constructed. The compiler will call our default constructor; thus, the data members will be initialized to id_ = -1 and name_ = \"none\".

\n\n

Product car(10, \"car\");\n

\n\n\n\n

The example uses the form of direct initialization which calls the constructor with two arguments. After the call data members will be: id_ = 10 and name_ = \"car\".

\n\n

And the last example:

\n\n

Product tvSet{100, \"tv set\" }; \n

\n\n\n\n

This time we also called a constructor with two arguments, but the syntax is called * direct list initialization* - \"{}\". Please notice that I also used this form of initialization inside the initializer list in constructors.

\n\n

Here’s the complete example:

\n\n

Ex 2.4. Constructors for the Product class. Run @Compiler Explorer

#include <iostream>\n#include <string>\n\nclass Product {\npublic:\n    Product() : id_{-1}, name_{\"none\"} { } // a default constructor\n    explicit Product(int id, const std::string& name) \n        : id_{id}, name_{name} { }\n\n    int Id() const { return id_; }\n    std::string Name() const { return name_; }\n\nprivate:\n    int id_;\n    std::string name_;\n};\n\nint main() {\n    Product none;\n    std::cout << none.Id() << \", \" << none.Name() << '\\n';\n\n    Product car(10, \"super car\");\n    std::cout << car.Id() << \", \" << car.Name() << '\\n';\n\n    Product tvSet{77, \"tv set\" }; \n    std::cout << tvSet.Id() << \", \" << tvSet.Name() << '\\n';\n}\n

\n\n\n\n

You might also scratch your head and ask why I declared the name parameter as const std::string& rather than just std::string&. First, we don’t want to modify this parameter in the constructor’s body. What’s more, const T& - const references can bind to “temporary” objects like a string literal \"super car\". Without a const reference, we would have to pass some named string object. Alternatively, we can pass the name by value and perform a “move operation” on that argument. Further in the book, I’ll address this topic in detail, see chapter: A Use Case - Best Way to\nInitialize string Data Members.

\n\n

\nMore on uniform initialization

\n\n

Content available in the full version of the book.

\n\n

\nBody of a constructor

\n\n

After the member initializer list, each constructor has a regular function body, { ... }, where you can perform additional steps to modify variables or call other functions. The only difference between a regular function and a constructor is that a constructor cannot return any values. Typically, a constructor throws an exception to report an error.

\n\n

Here’s a small example that shows how to add some logging into a constructor body and throw an exception on error:

\n\n

Ex 2.7. Logging in a constructor. Run @Compiler Explorer

#include <iostream>\n#include <stdexcept> // for std::invalid_argument\n\nconstexpr int LOWEST_ID_VALUE = -100;\n\nclass Product {\npublic:\n    explicit Product(int id, const std::string& name) \n        : id_{id}, name_{name}\n    {\n        std::cout << \"Product(): \" << id_ << \", \" << name_ << '\\n';\n        if (id_ < LOWEST_ID_VALUE)\n            throw std::invalid_argument{\"id lower than LOWEST_ID_VALUE!\"};\n    }\n\n    std::string Name() const { return name_; }\n\nprivate:\n    int id_;\n    std::string name_;\n};\n\nint main() {\n    try {\n        Product car(10, \"car\");\n        std::cout << car.Name() << \" created\\n\";\n        Product box(-101, \"box\");\n        std::cout << box.Name() << \" created\\n\";\n    }\n    catch (const std::exception& ex) {\n        std::cout << \"Error - \" << ex.what() << '\\n';\n    }\n}\n

\n\n\n\n

The above example shows a constructor that performs logging and basic parameter checking. It uses a LOWEST_ID_VALUE, a global constant marked with the constexpr keyword (the second time we used this keyword).

\n\n\n\n

If you run this program, you can see the following output:

\n\n

Product(): 10, car\ncar created\nProduct(): -101, box\nError - id cannot be lower than LOWEST_ID_VALUE!\n

\n\n\n\n

Please notice that while two constructors were called, we can see that only the first one succeeded. Since the constructor for box threw an exception, this object is not treated as fully created. More on that later, when we’ll talk about destructors.

\n\n

\nAdding constructors to `DataPacket`\n

\n\n

After the introduction, we can start adding constructors to our DataPacket class.

\n\n

Ex 2.8. Adding constructors. Run @Compiler Explorer

class DataPacket {\n    std::string data_;\n    size_t checkSum_;\n    size_t serverId_;\n\npublic:\n    DataPacket()\n    : data_{}\n    , checkSum_{0}\n    , serverId_{0}\n    { }\n    \n    explicit DataPacket(const std::string& data, size_t serverId)\n    : data_{data}\n    , checkSum_{calcCheckSum(data)}\n    , serverId_{serverId}\n    { }\n\n    const std::string& getData() const { return data_; }\n    void setData(const std::string& data) {\n        data_ = data;\n        checkSum_ = calcCheckSum(data);\n    }\n    size_t getCheckSum() const { return checkSum_; }\n    \n    void setServerId(size_t id) { serverId_ = id; }\n    size_t getServerId() const { return serverId_; }\n};\n

\n\n\n\n

And here’s the demo code that creates some objects:

\n\n

Ex 2.9. Adding constructors, Demo. Run @Compiler Explorer

void printInfo(const DataPacket& packet) {\n    std::cout << \"data: \" << packet.getData() << '\\n';\n    std::cout << \"checkSum: \" << packet.getCheckSum() << '\\n';\n    std::cout << \"serverId: \" << packet.getServerId() << '\\n';\n}\n\nint main() {\n    DataPacket empty;\n    printInfo(empty);\n    DataPacket zeroed{};\n    printInfo(zeroed);\n    DataPacket packet{\"Hello World\", 101};\n    printInfo(packet);\n    DataPacket reply{\"Hi, how are you?\", 404};\n    printInfo(reply);\n}\n

\n\n\n\n

The output:

\n\n

data: \ncheckSum: 0\nserverId: 0\ndata: \ncheckSum: 0\nserverId: 0\ndata: Hello World\ncheckSum: 1052\nserverId: 101\ndata: Hi, how are you?\ncheckSum: 1375\nserverId: 404\n

\n\n\n\n

In the above example, we used two constructors:

\n\n

The first one is a default constructor and initializes data members to default values. It will be called for default and value initialization.
The second constructor takes several arguments and matches them with data members. This constructor makes it easy to pass parameters all at once (previously, we needed to call setters). This one takes two parameters, but we can initialize as many data members as we need. For example, the constructors ensure the checkSum_ variable matches data_. Since those two members are related, thanks to constructors and the setData member function, we keep the relation safe.

\n\n

We can also use default member initializers inside a class, but we’ll address that in detail in a separate chapter.

\n\n

\nCompiler-generated default constructors

\n\n

While C++ allows you to implement various constructors, it can make your life easier by automatically declaring and defining an implicit default constructor.

\n\n

In other words, if you write a class type with no default constructor:

\n\n

class Example {\npublic:\n    std::string Name() const { return name_; }\n    \nprivate:\n    std::string name_;\n};\n

\n\n\n\n

Then the compiler will create an implicit empty constructor:

\n\n

inline Example() noexcept { }\n

\n\n\n\n

A simple rule is that if a class has no user-declared constructors, the compiler will create a default one if possible.

\n\n

Have a look:

\n\n

Ex 2.10. Implicit default constructor. Run @Compiler Explorer

struct Value {\n    int x;\n};\n\nstruct CtorValue {\n    CtorValue(int v): x{v} { }\n    int x;\n};\n\nint main() {\n    Value v;         // fine, default constructor available\n    // CtorValue y;     // error! no default ctor available\n    CtorValue z{10}; // using custom ctor\n}\n

\n\n\n\n

As you can see above, the compiler will create an implicit default constructor for the Value class (since it has no other constructors), but it won’t generate a default constructor for the CtorValue class. Also, notice that Value::x will have an indeterminate value as a default constructor is empty and won’t set any value for x.

\n\n\n\n

You can control the creation of such a default constructor using two keywords, default and delete. In short, default tells the compiler to use the default implementation, while delete blocks the implementation.

\n\n

Ex 2.11. Default and Delete Constructors. Run @Compiler Explorer

struct Value {\n    Value() = default;\n\n    int x;\n};\n\nstruct CtorValue {\n    CtorValue() = default;\n    CtorValue(int v): x{v} { }\n    int x;\n};\n\nstruct DeletedValue {\n    DeletedValue() = delete;\n    DeletedValue(int v): x{v} { }\n    int x;\n};\n\nint main() {\n    Value v;         // fine, default constructor available    \n    CtorValue y;     // ok now, default ctor available\n    CtorValue z{10}; // using custom ctor    \n    // DeletedValue w;   // err, deleted ctor!\n    DeletedValue u{10}; // using custom ctor\n}\n

\n\n\n\n

In the above example, you can see that we declare Value() = default; this tells the compiler to create an empty (doing nothing) implementation. Also, in the CtorValue class, we also use the same technique, and, as you can notice, the default construction works now. The third class has = delete as its default constructor, and you’ll get an error if you want to create an object of this class using its default constructor.

\n\n

The implicit default constructor won’t be created if your type has data members that are not default-constructible or inherits from a type that is not default-constructible. That includes references, const data members, unions, and others. See the complete list here @C++Reference.

\n\n\n\n

\nExplicit constructors

\n\n

Content available in the full version of the book.

\n\n

\nDifference between direct and copy initialization

\n\n

Content available in the full version of the book.

\n\n

\nEven more

\n\n

Content available in the full version of the book.

\n\n

\nConstructor summary

\n\n

This chapter was probably the longest, as we had to prepare the background for the rest of the book. Once you know the basics of how data members can be initialized through constructors, we can move further and explore various new C++ features and examples.

\n\n

Now, it’s essential to summarize two other types of constructors: copy and move. Read on to the next chapter.

\n\n

\n3. Copy and Move Constructors

\n\n

Regular constructors allow you to invoke some logic and initialize data members when an object is created from a list of arguments. But C++ also has two special constructor types that let you control a situation when an object is created using an instance of the same class type. Those constructors are called copy and move constructors. Let’s have a look.

\n\n

\nCopy constructor

\n\n

A copy constructor is a special member function taking an object of the same type as the first argument, usually by const reference.

\n\n

ClassName(const ClassName&);\n

\n\n\n\n

Technically it might have other parameters, but they all have to have default values assigned.

\n\n

It’s used and called when you create an object using a variable of the same type, to be precise, when you use copy initialization.

\n\n

Product base { 42, \"base product\" }; // an initial object\n\n// various forms of initialization, where a copy constructor is called\nProduct other { base };  \nProduct another(base); \nProduct oneMore = base;\nProduct arr[] = { base, other, oneMore };\n

\n\n\n\n

Implementing a copy constructor might be necessary when your class has data members that shouldn’t be shallow copied, like pointers, resource ids (like file handles), etc.

\n\n

\nA canonical implementation of a copy constructor

\n\n

Implementing a copy constructor is straightforward and very similar to regular constructors. The only difference is that you have a single parameter which is a (const) reference to an object of that same type.

\n\n

For the Product class, we can write the following:

\n\n

class Product {\npublic:\n    explicit Product(int id, const std::string& name) \n        : id_{id}, name_{name}\n    {\n        std::cout << \"Product(): \" << id_ << \", \" << name_ << '\\n';\n    }\n\n    // copy constructor\n    Product(const Product& other)\n        : id_{other.id_}, name_{other.name_}\n    { }\n\nprivate:\n    int id_;\n    std::string name_;\n};\n

\n\n\n\n

As you can see, the copy constructor uses the member initialization list to copy the data from other. Please notice that there’s no need to use public getters, as we have access to all private data members. The compiler requires you to use a reference, so writing Product(Product other) won’t be treated as a copy constructor.

\n\n\n\n

Here’s another example where logging is enabled:

\n\n

Ex 3.1. An example of a logging copy constructor. Run @Compiler Explorer

#include <iostream>\n#include <string>\n\nclass Product {\npublic:\n    explicit Product(int id, const std::string& name) \n        : id_{id}, name_{name}\n    {\n        std::cout << \"Product(): \" << id_ << \", \" << name_ << '\\n';\n    }\n\n    Product(const Product& other)\n        : id_{other.id_}, name_{other.name_}\n    {\n        std::cout << \"Product(copy): \" << id_ << \", \" << name_ << '\\n';\n    }\n\n    const std::string& Name() const { return name_; }\n\nprivate:\n    int id_;\n    std::string name_;\n};\n\nint main() {\n    Product base { 42, \"base product\" }; // an initial object\n    std::cout << base.Name() << \" created\\n\";\n    std::cout << \"Product other { base };\\n\";\n    Product other { base };  \n    std::cout << \"Product another(base);\\n\";\n    Product another(base); \n    std::cout << \"Product oneMore = base;\\n\";\n    Product oneMore = base;\n    std::cout << \"Product arr[] = { base, other, oneMore };\\n\";\n    Product arr[] = { base, other, oneMore };\n}\n

\n\n\n\n

If you run the code, you should see the following output:

\n\n

Product(): 42, base product\nbase product created\nProduct other { base };\nProduct(copy): 42, base product\nProduct another(base);\nProduct(copy): 42, base product\nProduct oneMore = base;\nProduct(copy): 42, base product\nProduct arr[] = { base, other, oneMore };\nProduct(copy): 42, base product\nProduct(copy): 42, base product\nProduct(copy): 42, base product\n

\n\n\n\n

In the first line, we construct base product, and then use it to copy-construct all other instances.

\n\n\n\n

\nA compiler-generated copy constructor

\n\n

Content available in the full version of the book.

\n\n

\nMove constructor

\n\n

Move constructors take rvalue references of the same type.

\n\n

ClassName(ClassName&&);\n

\n\n\n\n

In short, rvalue references are temporary objects, usually appearing on the right-hand side of an expression and which value is about to expire.

\n\n

For example:

\n\n

std::string hello { \"Hello\"}; // lvalue, a regular object\nstd::string world { \"World\"}; // lvalue\nstd::string msg = hello + world;\n

\n\n\n\n

Above, the expression hello + world creates a temporary object. It doesn’t have a name, and we cannot access it easily. Such temporary objects will end their lifetime immediately after the expression completes (unless it’s assigned to a const or rvalue reference⁴), so we can steal resources from them safely. It doesn’t make sense in the case of built-in types like integers or floats, as we need to copy values anyway. But in the case of strings or memory buffers, we can avoid data copy and just reassign the pointers.

\n\n

Move constructors are a way to support the case with initialization from temporary objects. In many cases, they are an optimization over regular copy constructor calls. Additionally, they can also be used to pass “ownership” of the resource, for example, with smart pointers.

\n\n

You can mark a regular object as expiring with the std::move function when you have a regular object with a name. This tells the compiler that the object’s value is no longer needed, so it’s safe to “steal” resources from it.

\n\n

Have a look at this example:

\n\n

Ex 3.3. Move Constructor. Run @Compiler Explorer

#include <iostream>\n#include <string>\n\nclass Product {\npublic:\n    explicit Product(int id, const std::string& name) \n        : id_{id}, name_{name}\n    {\n        std::cout << \"Product(): \" << id_ << \", \" << name_ << '\\n';\n    }\n\n    Product(Product&& other)\n        : id_{other.id_}, name_{std::move(other.name_)}\n    {\n        std::cout << \"Product(move): \" << id_ << \", \" << name_ << '\\n';\n    }\n\n    const std::string& name() const { return name_; }\n\nprivate:\n    int id_;\n    std::string name_;\n};\n\nint main() {\n    Product tvSet {100, \"tv set\"};\n    std::cout << tvSet.name() << \" created...\\n\";\n    Product setV2 { std::move(tvSet) };\n    std::cout << setV2.name() << \" created...\\n\";\n    std::cout << \"old value: \" << tvSet.name() << '\\n';\n}\n

\n\n\n\n

When you run the code, you can see the following output:

\n\n

Product(): 100, tv set\ntv set created...\nProduct(move): 100, tv set\ntv set created...\nold value: \n

\n\n\n\n

As you can see, we create the first object, and then mark it as expiring. This gives a chance for the compiler to call the move constructor.

\n\n

Product(Product&& other)\n        : id_(other.id_), name_(std::move(other.name_))\n

\n\n\n\n

The above implementation is similar, but we need to pay attention to details. Since id_ is just an integer, all we can do is copy the value. We cannot perform any optimizations here. As for the name_ member, we can initialize it with std::move(other.name_). We encounter the first problem, other.name_ is a name, so not a temporary (a temporary has no name); we can not move (take, steal) its contents. That is why we tell the compiler to interpret it as temporary by using the expression std::move(other.name_). This will invoke the move constructor for std::string, and, potentially, “steal” the buffer from other.name_.

\n\n

The move constructor must ensure that the other object is left in an unspecified but valid state. In our case, we can see it in the last line of the output. The line old value: ends with nothing, so the string was simply cleared.

\n\n\n\n

\n`noexcept` and move constructors

\n\n

Content available in the full version of the book.

\n\n

\nA compiler-generated move constructor

\n\n

Content available in the full version of the book.

\n\n

\nDistinguishing from assignment

\n\n

Content available in the full version of the book.

\n\n

\nAdding logging to constructors

\n\n

As an exercise, let’s add logging to our DataPacket class and see when each constructor is called:

\n\n

Ex 3.6. Logging in the DataPacket class. Run @Compiler Explorer

 1 class DataPacket {\n 2     std::string data_;\n 3     size_t checkSum_;\n 4     size_t serverId_;\n 5 \n 6 public:\n 7     DataPacket()\n 8     : data_{}\n 9     , checkSum_{0}\n10     , serverId_{0}\n11     { }\n12     \n13     explicit DataPacket(const std::string& data, size_t serverId)\n14     : data_{data}\n15     , checkSum_{calcCheckSum(data)}\n16     , serverId_{serverId}\n17     { \n18         std::cout << \"Ctor for \\\"\" << data_ << \"\\\"\\n\";\n19     }\n20 \n21     DataPacket(const DataPacket& other) \n22     : data_{other.data_}\n23     , checkSum_{other.checkSum_}\n24     , serverId_{other.serverId_}\n25     {\n26         std::cout << \"Copy ctor for \\\"\" << data_ << \"\\\"\\n\";\n27     }\n28 \n29     DataPacket(DataPacket&& other) \n30     : data_{std::move(other.data_)}   // move string member...\n31     , checkSum_{other.checkSum_}       // no need to move built-in types...\n32     , serverId_{other.serverId_}  \n33     {\n34         other.checkSum_ = 0; // leave this in a proper state\n35         std::cout << \"Move ctor for \\\"\" << data_ << \"\\\"\\n\";\n36     }\n37 \n38     DataPacket& operator=(const DataPacket& other) {\n39         if (this != &other) {\n40             data_ = other.data_;\n41             checkSum_ = other.checkSum_;\n42             serverId_ = other.serverId_;\n43             std::cout << \"Assignment for \\\"\" << data_ << \"\\\"\\n\";\n44         }\n45         return *this;\n46     }\n47 \n48     DataPacket& operator=(DataPacket&& other) {\n49         if (this != &other) {\n50             data_ = std::move(other.data_);\n51             checkSum_ = other.checkSum_;\n52             other.checkSum_ = 0; // leave this in a proper state\n53             serverId_ = other.serverId_;\n54             std::cout << \"Move Assignment for \\\"\" << data_ << \"\\\"\\n\";\n55         }\n56         return *this;\n57     }\n58 \n59     // getters/setters\n60 };\n

\n\n\n\n

And here’s the main() function:

\n\n

Ex 3.6. Logging in the DataPacket class, the main function. Run @Compiler Explorer

 1 int main() {\n 2     DataPacket firstMsg {\"first msg\", 101 };\n 3     DataPacket copyMsg { firstMsg };\n 4 \n 5     DataPacket secondMsg { \"second msg\", 202 };\n 6     copyMsg = secondMsg;\n 7     \n 8     DataPacket movedMsg { std::move(secondMsg)};\n 9     // now we stole the data, so it should be empty...\n10     std::cout << \"secondMsg's data after move ctor): \\\"\" \n11               << secondMsg.getData() << \"\\\", sum: \" \n12               << secondMsg.getCheckSum() << '\\n';\n13 \n14     movedMsg = std::move(firstMsg);\n15 \n16     // now we stole the name, so it should be empty...\n17     std::cout << \"firstMsg's data after move ctor): \\\"\" \n18               << firstMsg.getData() << \"\\\", sum: \" \n19               << firstMsg.getCheckSum() << '\\n';\n20 }\n

\n\n\n\n

When you run the example, you should see the following output:

\n\n

Ctor for \"first msg\"\nCopy ctor for \"first msg\"\nCtor for \"second msg\"\nAssignment for \"second msg\"\nMove ctor for \"second msg\"\nsecondMsg's data after move ctor): \"\", sum: 0\nMove Assignment for \"first msg\"\nfirstMsg's data after move ctor): \"\", sum: 0\n

\n\n\n\n

The example creates several DataPacket objects, and with each creation, you can see that the compiler invokes the appropriate constructor or an assignment operator. For instance, in line 3, we need a copy constructor call. On the other hand, line 5 shows an assignment (copyMsg already exists). In the last section of main(), lines 8 and 14, there are calls to std::move(), which marks secondMsg and firstMsg as an rvalue reference, from which the contents could be moved. This means that the object is unimportant later, and we can “steal” from it. In this case, the compiler will call a move constructor or move assignment operator.

\n\n

\nTrivial classes and user-declared/user-provided default constructors

\n\n

Content available in the full version of the book.

\n\n

\n4. Delegating and Inheriting Constructors

\n\n

Content available in the full version of the book.

\n\n

\nLimitations

\n\n

Content available in the full version of the book.

\n\n

\nInheritance

\n\n

Content available in the full version of the book.

\n\n

\nInheriting constructors

\n\n

In our previous example with DebugPropertyInfo we didn’t have any new data members, only some new member functions. The code showed a single constructor called the base class constructor. Since C++11, you can tell the compiler to “reuse” the code:

\n\n

Ex 4.4. Inheriting constructors. Run @Compiler Explorer

 1 class DebugDataPacket : public DataPacket {\n 2 public:\n 3     using DataPacket::DataPacket;\n 4 \n 5     void DebugPrint(std::ostream& os) {\n 6         os << getData() << \", \" << getCheckSum() << '\\n';\n 7     }\n 8 };\n 9 \n10 int main() {\n11     DebugDataPacket hello{\"hello!\", 404};\n12     hello.DebugPrint(std::cout);\n13 }\n

\n\n\n\n

Consider line 3 - using DataPacket::DataPacket;. This tells the compiler that it can use all constructors from the base class, ignoring access modifiers. It means that all public constructors are visible and can be called, but the protected will still be protected in that context. Still, if you want to limit the access to constructors, you must explicitly write constructors for DebugDataPacket.

\n\n

We completed all information about constructors, but it’s good to mention one more thing: destructors. See in the next chapter.

\n\n

\n5. Destructors

\n\n

While constructors are responsible for various situations where an object is created, C++ also offers a way to handle object destruction. C++ doesn’t provide any form of garbage collection available in many popular programming languages, but thanks to precise lifetime specification, you can be confident when your object will be destroyed.

\n\n

Each class has a special member function called a destructor. If you don’t write one, the compiler prepares a default implementation. A destructor is called when an object ends its lifetime. In most cases, it means that an object goes out of the scope (for stack-allocated variables), or when a delete operator is called (for heap-allocated variables). Additionally, when you have a user-defined class, it will automatically call destructors for its data members.\nFor more information about lifetime, see a good summary at C++Reference page.

\n\n

\nBasics

\n\n

Before we move on, it would be good to expand our terminology. So far I mentioned “object” to refer to entities of some type and relied on our “intuition” on how to access such entities. But the C++ Standard defines an object in the following terms (simplified, based on C++ Draft - intro.object):

\n\n\n\n

And continuing:

\n\n\n\n

Here’s a basic scenario for a destructor that handles a case where the lifetime of an object ends:

\n\n

Ex 5.1. A logging destructor. Run @Compiler Explorer

#include <iostream>\n#include <string>\n\nclass Product {\npublic:    \n    explicit Product(const char* name, unsigned id)\n    : name_(name)\n    , id_(id)\n    { \n        std::cout << name << \", id \" << id << '\\n';\n    }\n\n    ~Product() {\n        std::cout << name_ << \" destructor...\\n\";\n    }\n\n    std::string Name() const { return name_; }\n    unsigned Id() const { return id_; }\n\nprivate:\n    std::string name_; \n    unsigned id_; \n};\n

\n\n\n\n

The example contains the following special member function:

\n\n

~Product() {\n    std::cout << name_ << \" destructor...\\n\";\n}\n

\n\n\n\n

The syntax is unique as it has no parameters and has the ~ prefix. You can also have only one destructor in a class. What’s more, a destructor doesn’t return any value.

\n\n

Now, let’s create two objects of that type:

\n\n

Ex 5.1. A logging destructor, continuation. Run @Compiler Explorer

int main() {\n   {\n       Product tvset(\"TV Set\", 123);\n   }\n   {\n       Product car(\"Mustang\", 999);\n   }\n}\n

\n\n\n\n

In our case, the constructor and the destructor is used to perform the logging. When you run the example, you’ll see the following output:

\n\n

TV Set, id 123\nTV Set destructor...\nMustang, id 999\nMustang destructor...\n

\n\n\n\n

I specifically enclosed objects (created on the stack) in separate scopes so that their lifetime ends when their scope ends. On the other hand, if we have code:

\n\n

int main() {\n    Product tvset(\"TV Set\", 123);\n    Product car(\"Mustang\", 999);\n}\n

\n\n\n\n

Then both tvset and car share the same lifetime scope so that we can expect the following output:

\n\n

TV Set, id 123\nMustang, id 999\nMustang destructor...\nTV Set destructor..\n

\n\n\n\n

As you can see, the destructors are called in the reverse order of how they were created. It’s because the stack is a LIFO structure (Last In First Out). tvset was created first and added to the stack, then car is added. When the function goes out of the scope, the stack is cleared, taking elements in the reverse order. So car is deleted first, and then tvset. This is illustrated by the following diagram:

\n\n\n

\"Adding — Adding and removing objects from the stack.

\n\n\n

\nObjects allocated on the heap

\n\n

Content available in the full version of the book.

\n\n

\nDestructors and data members

\n\n

Content available in the full version of the book.

\n\n

\nVirtual destructors and polymorphism

\n\n

Content available in the full version of the book.

\n\n

\nPartially created objects

\n\n

Content available in the full version of the book.

\n\n

\nUse Cases

\n\n

The primary use case for destructors is when you need to release resources allocated in a constructor. For example, you allocate some memory when the object is created, and then the memory must be released to avoid memory leaks. Similarly, you can open a file or a database connection, and then you must ensure the file or the connection is closed when the object goes out of scope. Fortunately, in Modern C++, there are fewer and fewer places where you need custom destructors. For example, when your data members are standard containers (like std::vector<int>, or std::map<std::string, int>) in your classes, then you can rely on default destructors to do the job. Standard containers like std::vector<int> might allocate memory buffers, but they also manage that buffer and release it properly, so you don’t need to take any action when using them in a class.

\n\n

\nA compiler-generated destructor

\n\n

Content available in the full version of the book.

\n\n

\n6. Initialization and Type Deduction

\n\n

Content available in the full version of the book.

\n\n

\n7. Quiz on Constructors

\n\n

Congratulations!

\n\n

You’ve just completed the section on the basics and constructors.

\n\n

Here’s a quick quiz. Try answering the following questions, and then we will continue our journey :)

\n\n

\n1. Can a constructor have a different name than the class name?

\n\n

Yes
No
Yes, but it can be only named self()\n

\n\n

\n2. What operations are called in the following code? Pick one option.

\n\n

std::string s { \"Hello World\" };\nstd::string other = s;\n

\n\n\n\n

A constructor is called for s. Then, as assignment operation is called for other.
A constructor is called for s, and then a copy constructor is called to create other.
A constructor is called for s, and then another regular constructor is called for other.

\n\n

More questions available in the full version of the book.

\n\n\n

\n8. Non-Static Data Member Initialization

\n\n

You’ve learned a lot of techniques related to constructors! You can initialize data members in various constructors, delegate them to reuse code, and inherit them from base classes. Yet, we can still improve on assigning default values for data members. I mentioned this feature in the first chapter, where we gave default values for aggregates. We can do the same for classes. And in this chapter, we’ll look at the full syntax and options related to this feature.

\n\n

Please have a look at the example below:

\n\n

Ex 8.1. NSDMI Basics. Run @CompilerExplorer

class DataPacket {\n    std::string data_;\n    size_t checkSum_ { 0 };\n    size_t serverId_ { 0 };\n\npublic:\n    DataPacket() = default;\n    \n    DataPacket(const std::string& data, size_t serverId)\n    : data_{data}\n    , checkSum_{calcCheckSum(data)}\n    , serverId_{serverId}\n    { }\n\n    // getters and setters...\n};\n

\n\n\n\n

As you can see, the variables are assigned their default values individually in their place of declaration. There’s no need to set values inside a constructor. It’s much better than using a default constructor because it combines declaration and initialization code. This way, it’s harder to leave data members uninitialized!

\n\n

Let’s explore this handy feature of Modern C++ in detail.

\n\n

\nHow it works

\n\n

This section shows how the compiler “expands” the code to initialize data members.

\n\n

For a simple declaration:

\n\n

struct SimpleType {\n    int field { 0 };\n};\n

\n\n\n\n

The code has to behave similarly as you’d define a constructor ⁵:

\n\n

struct SimpleType {\n    SimpleType() : field(0) { }\n\n    int field;\n};\n

\n\n\n\n

Experiment with the basic code below:

\n\n

Ex 8.2. Basic Non-static data member initialization. Run @Compiler Explorer

#include <iostream>\n\nstruct SimpleType {\n    int field { 0 };\n};\n\nint main() {\n    SimpleType st;\n    std::cout << \"st.field is \" << st.field << '\\n';\n}\n

\n\n\n\n

As a small exercise, you can experiment with the above sample and assign different values to the field data member.

\n\n

\nInvestigation

\n\n

With some “machinery,” we can see when the compiler performs the initialization.

\n\n

Let’s consider the following type:

\n\n

struct SimpleType {\n    int a { initA() }; \n    std::string b { initB() }; \n    \n    // ...\n};\n

\n\n\n\n

The implementation of initA() and initB() functions have side effects, and they log extra messages:

\n\n

int initA() {\n    std::cout << \"initA() called\\n\";\n    return 1;\n}\n\nstd::string initB() {\n    std::cout << \"initB() called\\n\";\n    return \"Hello\";\n}\n

\n\n\n\n

This allows us to see when the code is called.

\n\n

\nExperiments

\n\n

Now, we can experiment and write some additional constructors:

\n\n

struct SimpleType {\n    int a { initA() }; \n    std::string b { initB() }; \n\n    SimpleType() { }\n    SimpleType(int x) : a(x) { }\n};\n

\n\n\n\n

Next, we can run our test and see the results.

\n\n

Ex 8.3. Calling init functions. Live code @Compiler Explorer

#include <iostream>\n#include <string>\n\nint initA() {\n    std::cout << \"initA() called\\n\";\n    return 1;\n}\n\nstd::string initB() {\n    std::cout << \"initB() called\\n\";\n    return \"Hello\";\n}\n\nstruct SimpleType {\n    int a { initA() }; \n    std::string b { initB() }; \n\n    SimpleType() { }\n    SimpleType(int x) : a(x) { }\n};\n\nint main() {\n    std::cout << \"SimpleType t0\\n\";    \n    SimpleType t0;\n    std::cout << \"SimpleType t1(10)\\n\";    \n    SimpleType t1(10);\n}\n

\n\n\n\n

After running the code, we can see the following output:

\n\n

SimpleType t1\ninitA() called\ninitB() called\nSimpleType t1(10)\ninitB() called\n

\n\n\n\n

You can observe the following:

\n\n

t0 is default-initialized; therefore, both fields are initialized with their default values. In other words, the compiler calls {initA()} and {initB{}}. Please notice that they are initialized in the order they appear in the class/struct declaration.

\n\n

In the second case, for t1, only one value is default initialized, and the other comes from the constructor parameter.

\n\n

As you might already guess, the compiler initializes the fields as if the fields were initialized in a “member initialization list”. Therefore, they get the default values before the constructor’s body is invoked.

\n\n

In other words, the compiler “conceptually” expands the code:

\n\n

struct SimpleType {\n    int a { initA() }; \n    std::string b { initB() }; \n\n    SimpleType() { }\n    SimpleType(int x) : a(x) { }\n};\n

\n\n\n\n

Into:

\n\n

struct SimpleType {\n    int a; \n    std::string b; \n\n    SimpleType() : a(initA()), b(initB()) { }\n    SimpleType(int x) : a(x), b(initB())  { }\n};\n

\n\n\n\n

We can also visualize it using the following diagram:

\n\n\n

\n\n\n

\nOther forms of NSDMI

\n\n

Content available in the full version of the book.

\n\n

\nCopy constructor and NSDMI

\n\n

Content available in the full version of the book.

\n\n

\nMove constructor and NSDMI

\n\n

Content available in the full version of the book.

\n\n

\nC++14 changes

\n\n

Originally, in C++11, if you used default member initialization, your class couldn’t be an aggregate type:

\n\n

struct Point { float x = 1.0f; float y = 2.0f; };\n\n// won't compile in C++11\nPoint myPt { 10.0f, 11.0f };\n

\n\n\n\n

The above code won’t work when compiling with the C++11 flag because you cannot aggregate-initialize our Point structure. It’s not an aggregate.

\n\n

Fortunately, C++14 provides a solution to this problem, and that’s this line:

\n\n

Point myPt { 10.0f, 11.0f};\n

\n\n\n\n

The code works as expected now. You can see and play with the full code below:

\n\n

Ex 10.1. Aggregates and NSDMI in C++14. Run @CompilerExplorer

#include <iostream>\n\nstruct Point { float x = 1.0f; float y = 2.0f; };\n\nint main()\n{\n    Point myPt { 10.0f };\n    std::cout << myPt.x << \", \" << myPt.y << '\\n';\n}\n

\n\n\n\n

\nC++20 changes

\n\n

Content available in the full version of the book.

\n\n

\nLimitations of NSDMI

\n\n

Content available in the full version of the book.

\n\n

\nNSDMI: Advantages and Disadvantages

\n\n

Let’s summarize non-static data member initialization.

\n\n

\nAdvantages of NSDMI

\n\n

Content available in the full version of the book.

\n\n

\nAny negative sides of NSDMI?

\n\n

Content available in the full version of the book.

\n\n

\nNSDMI summary

\n\n

Before C++11, the best way to initialize data members was through a member initialization list inside a constructor. Thanks to C++11, we can now initialize data members in the place where we declare them, and the initialization happens just before the constructor body kicks in.

\n\n

In the chapter, we covered the syntax, how it works with various types of constructors and the limitations. You also saw changes made in C++14 (aggregate classes) and missing bitfield initialization fixed in C++20.

\n\n

The C++ Core Guidelines advise using NSDMI in at least two sections.

\n\n

C++ Core Guidelines - C.48:

\n\n\n\n

And in C++ Core Guidelines - C.45

\n\n\n\n\n\n

\nNSDMI: Exercises

\n\n

Check your skills with two coding exercises.

\n\n

\nThe first exercise

\n\n

Content available in the full version of the book.

\n\n

\nThe second exercise

\n\n

Content available in the full version of the book.

\n\n

\n9. Containers as Data Members

\n\n

CarInfo, DataPacket, and Product types used relatively simple data members like integers, doubles, or strings. While std::string is, in fact, a container (of characters), we tend to use it as an elementary type. In this section, I’d like to discuss more complex data members like arrays, vectors, or maps.

\n\n

\nThe basics

\n\n

Content available in the full version of the book.

\n\n

\nUsing `std::initializer` list

\n\n

(*) this section will be added in the future.

\n\n

\nExample implementation

\n\n

Content available in the full version of the book.

\n\n

\n10. Non-regular Data Members

\n\n

Thus far, we spoke about mutable non-static data members like integers, doubles, or strings. Such objects are regular, meaning they are copyable, default constructible, and equally comparable. In C++20 there’s even a concept for that purpose: std::regular, see @C++Reference.

\n\n

However, you can also have other categories of objects in a class. For example, a custom type might contain constant data members, pointers, references, or moveable only fields like unique pointers or mutexes. For such members, we have immediate issues with default copy constructors (the compiler won’t create them).

\n\n

In this chapter, we’ll shed some light on such cases.

\n\n

\nConstant non-static data members

\n\n

Content available in the full version of the book.

\n\n

\nReferences as data members

\n\n

(*) this section will be added in the future.

\n\n

\nPointers as data members

\n\n

(*) this section will be added in the future.

\n\n

\nMoveable-only data members

\n\n

(*) this section will be added in the future.

\n\n

\nSummary

\n\n

Having discussed other categories of non-static data members, we can now examine static data members. How to use them in Modern C++? See the next chapter.

\n\n

\n11. Inline Variables in C++17

\n\n

In this chapter, you’ll see how to enhance and simplify code using inline variables from C++17.

\n\n

\nAbout static data members

\n\n

In general, each and every instance (object) of a class has non-static data members as its own data fields; each instance is separate from the other. If we consider a type (a class) representing a Fruit and it has a data member named “mass”, then each particular instance of that Fruit class has a “mass” member belonging to it. If we have 10 Fruit objects, the “mass” data member is replicated ten times. On the other hand, each type can also have static data members that are not bound to any instance of the class. In the case of our Fruit class, we can specify a so-called static variable named “default mass”, accessible to each Fruit instance, but it wouldn’t be part of any instance. In other words, it’s like a global variable in the namespace of the Fruit type.

\n\n

Consider the following example:

\n\n

Ex 12.1. Simple static Data Member. Run @Compiler Explorer

#include <iostream>\n\nstruct Value {\n    int x;\n\n    static int y;\n};\n\nint Value::y = 0; // definition\n\nint main() {\n    Value v { 10 };\n    std::cout << \"sizeof(int): \" << sizeof(int) << '\\n';\n    std::cout << \"sizeof(Value): \" << sizeof(Value) << '\\n';\n    std::cout << \"v.x: \" << v.x << '\\n';\n    Value::y = 10;\n    std::cout << \"Value::y: \" << Value::y << '\\n';\n}\n

\n\n\n\n

When you run this program, you’ll see the following output:

\n\n

sizeof(int): 4\nsizeof(Value): 4\nv.x: 10\nValue::y: 10\n

\n\n\n\n

static int y declared in the scope of the Value class created a variable that is not part of any Value type instance. You can see that it doesn’t contribute to the size of the whole class. It’s the same as the size of the int type.

\n\n

In the further sections, let’s consider a more practical use case for such class members.

\n\n

\nMotivation for inline variables

\n\n

In C++11/14, if you wanted to add a static data member to a class, you needed to declare it and define it later in one compilation unit. In the example from the previous section, we defined it in the same compilation unit as the main() function. Commonly, such variables are defined in the corresponding implementation file.

\n\n

For example:

\n\n

Ex 12.2. Static data member, multiple files. Run @Wandbox

// a header file:\nstruct OtherType {\n    static int classCounter;\n\n    // ...\n};\n\n// implementation, cpp file\nint OtherType::classCounter = 0;\n

\n\n\n\n

This time we also used Wandbox online compiler - as it’s easy to create and compile multiple files:

\n\n\n

\n\n\n

As you can see above, classCounter is an int, and you have to write it twice: in a header file and then in the CPP file.

\n\n\n

\n\n\n

The only exception to this rule (even before C++11) is a static constant integral variable that you can declare and initialize in one place:

\n\n

class MyType {\n    static const int ImportantValue = 42;\n};\n

\n\n\n\n

You do not have to define ImportantValue in a CPP file.

\n\n

Fortunately, C++17 gave us inline variables, which means we can define a static inline variable inside a class without defining them in a CPP file.

\n\n

Ex 12.3. Static inline member. Run @Wandbox

// a header file, C++17:\nstruct OtherType {\n    static inline int classCounter = 0;\n\n    // ...\n};\n

\n\n\n\n

The compiler (and the linker) guarantees that there’s precisely one definition of this static variable for all translation units that include the class declaration. Inline variables remain static class variables, so they will be initialized before the main() function is called.

\n\n\n

\n\n\n

This feature makes it much easier to develop header-only libraries because there’s no need to create CPP files for static variables or use hacks to keep them in a header file (for example, by creating static member functions with static variables inside).

\n\n

See the example below:

\n\n

// CountedType.h\nstruct CountedType {\n    static inline int classCounter = 0;\n\n    // simple counting... only ctor and dtor implemented...\n    CountedType() { ++classCounter; }\n    ~CountedType() { --classCounter; }\n};\n

\n\n\n\n

And the main() function:

\n\n

Ex 12.4. Static inline member. Run @Wandbox

#include <iostream>\n#include \"CountedType.h\"\n\nint main() {\n    {\n        CountedType c0;\n        CountedType c1;\n        std::cout << CountedType::classCounter << '\\n';\n    }\n    std::cout << CountedType::classCounter << '\\n';\n}\n

\n\n\n\n

The code above declares classCounter inside CountedType, which is a static data member. The class is defined in a separate header file. Thanks to C++17, we can declare the variable as inline. Then, there’s no need to write a corresponding definition later. Without inline, the code wouldn’t compile.

\n\n

Later, in the main() function, the example creates two objects of CountedType. The static variable is incremented when there’s a call to the constructor. When an object is destroyed, the variable is decremented. We can output this value and see the current count of objects.

\n\n

\nExercise for inline variables

\n\n

Content available in the full version of the book.

\n\n

\nGlobal inline variables

\n\n

Content available in the full version of the book.

\n\n

\nConstexpr and inline variables

\n\n

Content available in the full version of the book.

\n\n

\n12. Aggregates and Designated Initializers in C++20

\n\n

Across the book, you’ve seen a lot of cases for intuitively simple structures with all public data members. Such types, along with arrays, are called Aggregates. In this chapter, we’ll look at some C++20 changes and new ways to initialize such objects.

\n\n

\nAggregates in C++20

\n\n

To sum up, as of C++20, here’s the definition of an aggregate type from the C++ Standard: dcl.init.aggr.

\n\n\n\n

Here are some examples of aggregates:

\n\n

Ex 13.1. Aggregate classes, several examples. Run @Compiler Explorer

struct Base { int x {42}; };\nstruct Derived : Base { int y; };\n\nstruct Param { \n    std::string name; \n    int val; \n    void Parse();  // member functions allowed\n};\n\nint main() {\n    Derived d {100, 1000};    \n    std::cout << \"d.x \" << d.x << \", d.y \" << d.y << '\\n';\n    Derived d2 { 1 };\n    std::cout << \"d2.x \" << d2.x << \", d2.y \" << d2.y << '\\n';\n    Param p {\"value\", 10};\n    std::cout << \"p.name \" << p.name << \", p.val \" << p.val << '\\n';\n\n    double arr[] { 1.1, 2.2, 3.3, 4.4};\n    std::cout << \"arr[0] \" << arr[0] << '\\n';\n    Param params[] {{\"val\", 10}, {\"name\", 42}};\n    std::cout << \"params[0].name \" << params[0].name << '\\n';\n}\n

\n\n\n\n

In C++20, in some limited cases, you can also use parens X(args...) to initialize an aggregate:

\n\n

// C++20 and parens:\nPoint pt (1, 2);\n// Point pt = (1, 2); // doesn't work\n\ndouble params[] (9.81, 3.14, 1.44);\n// double paramsDeduced[] = (9.81, 3.14, 1.44); // won't deduce\nint arrX[10]  (1, 2, 3, 4); // rest is 0\n

\n\n\n\n

Such improvement helps, especially in a generic template code where you want to work with various types of objects. For example, the following code wasn’t possible until C++20:

\n\n

Ex 13.2. Aggregates and parens for make_unique. Run @Compiler Explorer

struct Point { int x; int y; };\n\nint main() {\n    auto ptr = std::make_unique<Point>(10, 20);\n}\n

\n\n\n\n

make_unique takes a variable number of arguments and passes them to a constructor. This function uses parens to call the constructor. Since aggregates has no user-declared constructors, then such syntax generated errors. With the C++20 change, the code works fine now. Suppose you want to dig more into this topic. In that case, I highly recommend reading C++20’s parenthesized aggregate initialization has some downsides – Arthur O’Dwyer, which discusses pros and cons of this new initialization syntax.

\n\n

\nThe basics of Designated Initializers

\n\n

The C++20 Standard also gives us another handy way to initialize data members. The new feature is called designated initializers, which might be familiar to C programmers.

\n\n

As of C++20, to initialize an aggregate object, you can write the following:

\n\n

Type obj = { .designator = val, .designator { val2 }, ... };\n

\n\n\n\n

For example:

\n\n

struct Point { double x; double y; };\nPoint p { .x = 10.0, .y = 20.0 };\n

\n\n\n\n

Designator points to a name of a non-static data member from our class, like .x or .y.

\n\n

One of the main reasons to use this new kind of initialization is to increase readability. Compare the following initialization forms:

\n\n

struct Date {\n    int year;\n    int month;\n    int day;\n};\n\n// new\nDate inFutureCpp20 { .year = 2050, .month = 4, .day = 10 };\n// old\nDate inFutureOld   { 2050, 4, 10 };\n

\n\n\n\n

In the case of the Date class, it might be unclear what the order of days/month or month/days is. With designated initializers (inFutureCpp20), it’s very easy to see the order of data members.

\n\n

\nRules

\n\n

Content available in the full version of the book.

\n\n

\nAdvantages of designated initialization

\n\n

Readability: A designator points to the specific data member, so it’s impossible to make mistakes here.
Flexibility: You can skip some data members and rely on default values for others.
Compatibility with C: In C99, it’s popular to use a similar form of initialization (although even more relaxed). With the C++20 feature, it’s possible to have very similar code and share it.
Standardization: Some compilers, like GCC or Clang, already had some extensions for this feature, so it’s a natural step to enable it in all compilers.

\n\n

\nExamples

\n\n

Content available in the full version of the book.

\n\n

\nSummary

\n\n

As you can see, designated initializers are handy and usually more readable way of initializing aggregate types. The new technique is also common in other programming languages, like C or Python, so having it in C++ makes the programming experience even better.

\n\n

\nThe summary example

\n\n

Content available in the full version of the book.

\n\n

\nCompiler support

\n\n

Here’s a table with support for the features we discussed:

\n\n

Content available in the full version of the book.

\n\n

\n13. Techniques and Use Cases

\n\n

Across the book, we’ve touched on many different topics, sometimes only in a theoretical way. In this chapter, however, I grouped many of those features and demonstrated their benefits in several practical use cases.

\n\n

You’ll learn about the following aspects:

\n\n

Strong types and the explicit keyword,
Initializing string data members,
Copy and Swap Idiom as a potential simplification of copy and move operations,
CRTP,
Creating a simple resource manager (RAII) class.
Factory With Self-Registering Types
And more!

\n\n

Let’s start.

\n\n

\nUsing `explicit` for strong types

\n\n

If you recall the first chapter, I used double to indicate horsepower (hp) inside the CarInfo structure. However, we might quickly encounter a problem where we forget about the unit and treat it as Watts instead. Can we somehow limit such problematic cases?

\n\n

The answer is positive, and the main idea is to wrap the data member double power in a separate class type with explicit constructors. That it will be harder to misuse it, such an approach is called Strong Typing.

\n\n

Have a look at two similar wrapper types:

\n\n

Ex 13.1. Strong types and area units classes. Run @Compiler Explorer

constexpr double ToWattsRatio { 745.699872 };\n\nclass HorsePower;\n\nclass WattPower {\npublic:\n    WattPower() = default;\n    explicit WattPower(double p) : power_{p} { }\n    explicit WattPower(const HorsePower& h);\n\n    double getValue() const { return power_; }\nprivate:\n    double power_ {0.};\n};\n\nclass HorsePower {\npublic:\n    HorsePower() = default;\n    explicit HorsePower(double p) : power_{p} { }\n    explicit HorsePower(const WattPower& w);\n\n    double getValue() const { return power_; }\nprivate:\n    double power_ {0.};\n};\n

\n\n\n\n

As you can see, we have two types that use explicit constructors to initialize their private data members. To create an object, you have to write the correct type name explicitly, and thus it should limit the chance of mistakes.

\n\n

And here is the implementation of the converting constructors as well as stream operators for easy output:

\n\n

Ex 13.2. Strong Types and area units, implementation. Run @Compiler Explorer

constexpr double ToWattsRatio { 745.699872 };\n\nclass HorsePower;\n\nclass WattPower {\n    /* as before */\n};\n\nclass HorsePower {\n    /* as before */\n};\n\nWattPower::WattPower(const HorsePower& h) \n: power_{h.getValue()*ToWattsRatio} \n{ }\n\nHorsePower::HorsePower(const WattPower& w) \n: power_{w.getValue()/ToWattsRatio} \n{ }\n\nstd::ostream& operator<<(std::ostream& os, const WattPower& w) {\n    os << w.getValue() << \"W\";\n    return os;\n}\n\nstd::ostream& operator<<(std::ostream& os, const HorsePower& h) {\n    os << h.getValue() << \"hp\";\n    return os;\n}\n

\n\n\n\n

The interface allows us to convert between various units safely.

\n\n

//HorsePower hp = 10.; // not possible, copy initialization\nHorsePower hp{ 10. }; // fine\nWattPower w { 1. }; // fine\nWattPower watts { hp }; // fine, performs the proper conversion for us!\n

\n\n\n\n

Additionally, we have the output support that writes out the proper unit name.

\n\n

We can use the solution now:

\n\n

void printInfo(const CarInfo& c) {\n    std::cout << c.name << \", \"\n              << c.year << \" year, \"\n              << c.seats << \" seats, \"\n              << c.power << '\\n';\n}\n\nint main() {\n    CarInfo firstCar{\"Megane\", 2003, 5, HorsePower{116}};\n    printInfo(firstCar);   \n    CarInfo superCar{\"Ferrari\", 2022, 2, HorsePower{300}};\n    printInfo(superCar);\n    superCar.power = HorsePower{WattPower{500000}};\n    printInfo(superCar);\n}\n

\n\n\n\n

And we’ll get the following output:

\n\n

Megane, 2003 year, 5 seats, 116hp\nFerrari, 2022 year, 2 seats, 300hp\nFerrari, 2022 year, 2 seats, 670.511hp\n

\n\n\n\n

While I had to be more explicit and write the types, the code can be safer as it’s harder to type something accidentally.

\n\n\n\n\n\n

\nBest way to initialize `string` data members

\n\n

Content available in the full version of the book.

\n\n

\nThe copy and swap idiom

\n\n

Content available in the full version of the book.\n## CRTP class counter {#sectioncrtp}

\n\n

Content available in the full version of the book.

\n\n

\nSeveral initialization types in one class

\n\n

As the demo of various initialization techniques, I’d like to show code that creates N random “application windows.”

\n\n

Here are the core points of the demo:

\n\n

A Window class contains basic parameters like name (on the title bar), width, height, and some flags (bits per pixel, visibility).
The demo selects a random number X and will try to generate X Window objects.
Each object will have a random name composed of predefined words and a random size.
The application prints each window using std::cout.
As an additional check, an InstanceCounter class counts the number of Window objects. We can use this helper to verify the correctness of the demo.

\n\n

Here’s the first part that defines the Flags object:

\n\n

Ex 13.5. The Flags type. Run @Compiler Explorer

struct Flags {\n    unsigned bppMode_ : 4 { 0 }; // bits per pixel\n    unsigned visible_ : 1 { 1 };\n    unsigned extData  : 2 { 0 };\n};\n

\n\n\n\n

Here’s the main class:

\n\n

Ex 13.5. The Window type. Run @Compiler Explorer

class Window : public InstanceCounter<Window> {        \n    static constexpr unsigned default_width { 1028 };\n    static constexpr unsigned default_height { 768 };\n    static constexpr unsigned default_bpp { 8 };\n    \n    unsigned width_ { default_width };\n    unsigned height_ { default_height };\n    Flags flags_ {.bppMode_ { default_bpp } };\n    std::string title_ { \"Default Window\" };\n    \npublic:\n    Window() = default;\n    explicit Window(std::string title) : title_(std::move(title)) { }\n    Window(std::string title, unsigned w, unsigned h) :\n    width_(w), height_(h), title_(std::move(title)) {}\n    \n    friend std::ostream& operator<<(std::ostream& os, const Window& w) {\n        os << w.title_ << \": \" << w.width_ << \"x\" << w.height_; \n        return os;\n    }\n};\n

\n\n\n\n

The Window class uses several features discussed in the book:

\n\n

NSDMI to initialize data members,
designated initializers from C++20, combined with NSDMI for the flags_ data member,
Custom constructors that offer several options to initialize the data members,
We inherit from InstanceCounter, so each constructor invocation for the Window will also invoke the appropriate constructor in InstanceCounter. Similarly, the InstanceCounter destructor will be nicely called from the implicit default destructor of the Window class.

\n\n

And now the final demo code:

\n\n

Ex 13.5. The Window type. Run @Compiler Explorer

void WindowDemo() {\n    std::random_device rd;  \n    std::mt19937 gen(rd());\n    std::uniform_int_distribution<> distrib(0, 20);\n\n    const int windowCount = std::uniform_int_distribution<>(2, 10)(gen);\n    std::cout << \"Generating \" << windowCount << \" random Windows\\n\";\n\n    const std::array adjs { \"regular \", \"empty \", \"blue \", \"super \" };\n    const std::array nouns { \"app\", \"tool\", \"console\", \"game\" };\n    const std::array sizes { 1080u, 1920u, 768u, 320u, 640u, 3840u, 800u };\n\n    std::vector<Window> windows;\n    for (int i = 0; i < windowCount; ++i) {\n        auto r = distrib(gen);\n        auto r2 = distrib(gen);\n        auto name = std::string { adjs[(r + i) % adjs.size()] } + \n                     nouns[r2 % nouns.size()];\n        Window w{name, sizes[r2 % sizes.size()], \n                 sizes[r % sizes.size()]};\n        windows.push_back(w);\n    }\n\n    for (const auto& w : windows)\n        std::cout << w << '\\n';\n\n    std::cout << \"Created \" << Window::GetInstanceCounter() << \" Windows\\n\";\n}\n\nint main() {\n    WindowDemo();\n\n    if (Window::GetInstanceCounter() != 0) {\n        std::cout << Window::GetInstanceCounter() \n                  << \" Windows are still alive!\\n\";\n    }\n}\n

\n\n\n\n

Here’s the possible output:

\n\n

Generating 8 random Windows\nsuper tool: 320x320\nregular tool: 320x640\nsuper game: 1080x768\nsuper game: 640x1080\nregular tool: 1920x3840\nempty tool: 1920x3840\nblue game: 320x768\nempty console: 320x320\nCreated 8 Windows\n

\n\n\n\n

In WindowDemo, the code declares some basic data and generates a random number. Later, in the main loop, we generate random numbers to pick values from adjs, nouns, and sizes arrays. Once the data is ready, I can create a Window object and place it in the std::vector. To show the creation of the Window object, I used push_back on a vector, but we can optimize it and call emplace_back, which doesn’t need a temporary object:

\n\n

windows.emplace_back(name, sizes[r2 % sizes.size()], sizes[r % sizes.size()]);\n

\n\n\n\n

Later there’s another loop that prints all windows.

\n\n\n\n

The code uses InstanceCounter as a bonus debugging facility to ensure we have the correct number of active objects. When WindowDemo() finishes, all instances should be removed, and we can double-check it inside main().

\n\n

\nVector like RAII object

\n\n

(*) this section will be added in the future.

\n\n

\nFactory with self-registering types

\n\n

(*) this section will be added in the future.

\n\n

\nSummary

\n\n

(*) this section will be added in the future.

\n\n

\n14. The Final Quiz

\n\n

Check your knowledge from this mini-book!

\n\n

\n1. Which C++ Standard did add in-class default member initializers?

\n\n

C++98
C++11
C++14
C++17

\n\n

\n2. Can you use `auto` type deduction for non-static data members?

\n\n

Yes, since C++11
No
Yes, since C++20

\n\n

\n3. Do you need to define a `static inline` data member in a separate `cpp` file?

\n\n

No, the definition happens at the same place where a static inline member is declared.
Yes, the compiler needs the definition in a cpp file.
Yes, the compiler needs a definition in all translation units that use this variable.

\n\n

\n4. Can a static inline variable be non-constant?

\n\n

Yes, it’s just a regular variable.
No, inline variables must be constant.

\n\n

\n5. Consider the following code:

\n\n

struct S {\n    int a { 10 };\n    int b { 42 };\n};\n

\n\n\n\n

What’s the output of the following line?

\n\n

S s { 1 };\nstd::cout << s.a << \", \" << s.b;\n

\n\n\n\n

1, 0
10, 42
1, 42

\n\n

\n6. Consider the following code:

\n\n

class C {\n    C(int x) : a(x) { }\n\n    int a { 10 };\n    int b { 42 };\n};\n\nC c(0);\n

\n\n\n\n

More questions available in the full version of the book.

\n\n\n\n\n

\nAppendix A - Quiz and Exercises Answers

\n\n

Content available in the full version of the book.

\n\n\n

\nReferences

\n\n

Related materials and links about data member initialization in C++:

\n\n

Proposals for C++ features:

\n\n

\nN2756 - Non-static data member initializers for C++11,
\nP0683 - Default Bit Field Initializer for C++20,
\nP0386 - Inline Variables C++17,
\nP0329 - Designated Initializers C++20,
\nP0960 and P1975 - Aggregate initialization from a parenthesized list for C++20.

\n\n

Valuable resources for C++:

\n\n

\nC++ Standard Draft - N4868 (October 2020 pre-virtual-plenary working draft/C++20 plus editorial changes),
\nC++ compiler support - C++Reference - a list of features and their compiler support since C++11,
\nC++ Core Guidelines - a community-edited and open guideline for C++ style, lead by Bjarne Stroustrup and Herb Sutter.

\n\n

Books:

\n\n

\n“Embracing Modern C++ Safely” by J. Lakos, V. Romeo , R. Khlebnikov, A. Meredith, a wonderful and very detailed book about latest C++ features, from C++11 till C++14 in the 1st edition.
\n“Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14” by Scott Meyers

\n\n

Presentations:

\n\n

\nCore C++ 2019: Initialisation in modern C++ by Timur Doumler,
\nCppCon 2018: “The Nightmare of Initialization in C” by Nicolai Josuttis,
\nCppCon 2021: Back To Basics: The Special Member Functions by Klaus Iglberger,
\nACCU 2022: What Classes We Design and How - by Peter Sommerlad,
\nCppCon 2018 “The Bits Between the Bits: How We Get to main()” - by Matt Godbolt.

\n\n

Articles and other links:

\n\n

\nNon-Static Data Members Initialization - C++ Stories - initial source for the book,
\nWhat happens to your static variables at the start of the program? - C++ Stories,
\nAlways Almost Auto Style by Herb Sutter,
\nC++ Core Guidelines - C51 and C52 - about delegating and inheriting constructors,
\nModern C++ Features - Inherited and Delegating Constructors by Arne Mertz,
\nTrivial, standard-layout, POD, and literal types at Microsoft Docs,
\nModern C++ Features - Uniform Initialization and initializer_list by Arne Mertz,
\nThe cost of std::initializer_list by Andrzej Krzemieński,
\nObjects, their lifetimes and pointers by Dawid Pilarski,
\nTutorial: When to Write Which Special Member by Jonathan Müller,
\nThe implication of const or reference member variables in C++ by Lesley Lai,
\nBrace initialization of user-defined types by Glennan Carnie.

\nNotes

1Thanks to Javier Estrada for suggesting this cool tip!↩

\n\n

2In contrast, static and thread-local objects will be zero-initialized. ↩

\n\n

3Unless accessed by friend functions or classes.↩

\n\n

4The lifetime of a temporary object may be extended by binding to a const lvalue reference or to an rvalue reference. See more at https://en.cppreference.com/w/cpp/language/lifetime.↩

\n\n

5Technically, those types will be different as the version without the constructor will be considered an aggregate type, but for the purpose of the discussion, it’s not essential now.↩

\n\n\n

\n\n

\n\n","tocStructure",[425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521],{"_74":75,"_43":76,"_69":-5,"_77":78,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":84,"_69":-5,"_77":85,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":90,"_69":-5,"_77":91,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":93,"_69":-5,"_77":94,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":96,"_69":-5,"_77":97,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":99,"_69":-5,"_77":100,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":102,"_69":-5,"_77":103,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":105,"_69":-5,"_77":106,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":108,"_69":-5,"_77":109,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":111,"_69":-5,"_77":112,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":115,"_69":-5,"_77":116,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":119,"_69":-5,"_77":120,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":123,"_69":-5,"_77":124,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":127,"_69":-5,"_77":128,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":130,"_69":-5,"_77":131,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":133,"_69":-5,"_77":134,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":136,"_69":-5,"_77":137,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":139,"_69":-5,"_77":140,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":142,"_69":-5,"_77":143,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":146,"_69":-5,"_77":147,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":149,"_69":-5,"_77":150,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":152,"_69":-5,"_77":153,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":155,"_69":-5,"_77":156,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":158,"_69":-5,"_77":159,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":161,"_69":-5,"_77":162,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":164,"_69":-5,"_77":165,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":167,"_69":-5,"_77":168,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":170,"_69":-5,"_77":171,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":174,"_69":-5,"_77":175,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":177,"_69":-5,"_77":178,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":180,"_69":-5,"_77":181,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":183,"_69":-5,"_77":184,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":186,"_69":-5,"_77":187,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":189,"_69":-5,"_77":190,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":193,"_69":-5,"_77":194,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":196,"_69":-5,"_77":197,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":199,"_69":-5,"_77":200,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":202,"_69":-5,"_77":203,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":206,"_69":-5,"_77":207,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":209,"_69":-5,"_77":210,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":212,"_69":-5,"_77":213,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":215,"_69":-5,"_77":216,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":218,"_69":-5,"_77":219,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":221,"_69":-5,"_77":222,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":224,"_69":-5,"_77":225,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":227,"_69":-5,"_77":228,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":231,"_69":-5,"_77":232,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":235,"_69":-5,"_77":236,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":239,"_69":-5,"_77":240,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":242,"_69":-5,"_77":243,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":245,"_69":-5,"_77":246,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":248,"_69":-5,"_77":249,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":251,"_69":-5,"_77":252,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":254,"_69":-5,"_77":255,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":257,"_69":-5,"_77":258,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":260,"_69":-5,"_77":261,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":263,"_69":-5,"_77":264,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":266,"_69":-5,"_77":267,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":269,"_69":-5,"_77":270,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":272,"_69":-5,"_77":273,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":275,"_69":-5,"_77":276,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":279,"_69":-5,"_77":280,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":282,"_69":-5,"_77":283,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":285,"_69":-5,"_77":286,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":288,"_69":-5,"_77":289,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":292,"_69":-5,"_77":293,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":295,"_69":-5,"_77":296,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":298,"_69":-5,"_77":299,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":301,"_69":-5,"_77":302,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":139,"_69":-5,"_77":304,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":306,"_69":-5,"_77":307,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":310,"_69":-5,"_77":311,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":313,"_69":-5,"_77":314,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":316,"_69":-5,"_77":317,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":319,"_69":-5,"_77":320,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":322,"_69":-5,"_77":323,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":325,"_69":-5,"_77":326,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":329,"_69":-5,"_77":330,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":332,"_69":-5,"_77":333,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":335,"_69":-5,"_77":336,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":338,"_69":-5,"_77":339,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":341,"_69":-5,"_77":342,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":139,"_69":-5,"_77":344,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":346,"_69":-5,"_77":347,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":349,"_69":-5,"_77":350,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":352,"_69":-5,"_77":353,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":356,"_69":-5,"_77":357,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":359,"_69":-5,"_77":360,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":362,"_69":-5,"_77":363,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":365,"_69":-5,"_77":366,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":368,"_69":-5,"_77":369,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":371,"_69":-5,"_77":372,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":83,"_43":139,"_69":-5,"_77":374,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":376,"_69":-5,"_77":377,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":380,"_69":-5,"_77":381,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":384,"_69":-5,"_77":385,"_70":79,"_86":-5,"_87":-5,"_88":-5},{"_74":75,"_43":388,"_69":-5,"_77":389,"_70":79,"_86":-5,"_87":-5,"_88":-5},"publicChapterContent","nextChapter","sections",[],"routes/_store+/_layout","routes/_store+/_readers+/_layout","actionData","errors"]

\n6. Initialization and Type Deduction

Table of Contents

\nAbout the Book

\nWhy should you read this book?

\nLearning objectives

\nThe structure of the book

\nWho is this book for?

\nPrerequisites

\nReader feedback & errata

\nExample code

\nCode license

\nFormatting & Layout

\nRecommendation for Compiler Explorer and C++ Reference

\nSyntax highlighting limitations

\nSpecial sections

\nAbout the Author

\nAcknowledgements

\nRevision History

\n1. Local Variables and Simple Types

\nStarting with simple types

\nSetting values to zero

\nInitialization with aggregates

\nDefault data member initialization

\nSummary

\n2. Classes and Initialization With Constructors

\nA simple class type

\nBasics of constructors

\nMore on uniform initialization

\nBody of a constructor

\nAdding constructors to DataPacket\n

\nCompiler-generated default constructors

\nExplicit constructors

\nDifference between direct and copy initialization

\nEven more

\nConstructor summary

\n3. Copy and Move Constructors

\nCopy constructor

\nA canonical implementation of a copy constructor

\nA compiler-generated copy constructor

\nMove constructor

\nnoexcept and move constructors

\nA compiler-generated move constructor

\nDistinguishing from assignment

\nAdding logging to constructors

\nTrivial classes and user-declared/user-provided default constructors

\n4. Delegating and Inheriting Constructors

\nLimitations

\nInheritance

\nInheriting constructors

\n5. Destructors

\nBasics

\nObjects allocated on the heap

\nDestructors and data members

\nVirtual destructors and polymorphism

\nPartially created objects

\nUse Cases

\nA compiler-generated destructor

\n6. Initialization and Type Deduction

\n7. Quiz on Constructors

\n1. Can a constructor have a different name than the class name?

\n2. What operations are called in the following code? Pick one option.

\n8. Non-Static Data Member Initialization

\nHow it works

\nInvestigation

\nExperiments

\nOther forms of NSDMI

\nCopy constructor and NSDMI

\nMove constructor and NSDMI

\nC++14 changes

\nC++20 changes

\nLimitations of NSDMI

\nNSDMI: Advantages and Disadvantages

\nAdvantages of NSDMI

\nAny negative sides of NSDMI?

\nNSDMI summary

\nNSDMI: Exercises

\nThe first exercise

\nThe second exercise

\n9. Containers as Data Members

\nThe basics

\nAdding constructors to `DataPacket`\n

\n`noexcept` and move constructors

\nUsing `std::initializer` list

\nUsing `explicit` for strong types

\nBest way to initialize `string` data members

\n2. Can you use `auto` type deduction for non-static data members?

\n3. Do you need to define a `static inline` data member in a separate `cpp` file?