C++ Initialization Story
C++ Initialization Story
A Guide Through All Initialization Options and Related C++ Areas
About the Book
Initialization in C++ is a hot topic! The internet is full of discussions about best practices, and there are even funny memes on that subject. The situation is not surprising, as there are more than a dozen ways to initialize a simple integer value, complex rules for the auto-type deduction, data members, and object lifetime nuances.
And here comes the book.
Throughout this text, you will learn practical options to initialize various categories of variables and data members in Modern C++. More specifically, this text teaches multiple types of initialization, constructors, non-static data member initialization, inline variables, designated initializers, and more. Additionally, you’ll see the changes and new techniques from C++11 to C++20 and lots of examples to round out your understanding.
Learn C++ from the perspective of C++ Initialization!
The plan is to explain most (if not all) parts of initialization, learn lots of excellent C++ techniques, and see what happens under the hood.
The goal of this book is to equip you with the following knowledge:
- Explain rules about object initialization, including regular variables, data members, and non-local objects.
- How to implement special member functions (constructors, destructors, copy/move operations) and when they are helpful.
- How to efficiently initialize non-static data members using C++11 features like non-static data member initialization, inheriting, and delegating constructors.
- How to streamline working with static variables and static data members with inline variables from C++17.
- How to work with container-like members, non-copyable data members (like `const` data members) or move-able only data members, or even lambdas.
- What is an aggregate, and how to create such objects with designated initializers from C++20.
The book contains 14 chapters in the following structure:
- Chapters 1 to 5 create a foundation for the rest of the book. They cover basic initialization rules, constructors, destructors, and the basics of data members.
- Chapter 6 on Type deduction - auto, decltype, AAA and more.
- Chapter 7 is a quiz with 10 questions. You can check your knowledge from the first 6 chapters.
- Chapter 8 describes Non-static Data Member Initialization (NSDMI), a powerful feature from C++11 that improves how we work with data members. At the end of the chapter, you can solve a few exercises.
- Chapter 9 discusses how to initialize container-like data members.
- Chapter 10 contains information about non-regular data members and how to handle them in a class. You'll learn about const data members, unique_ptr as a data member, and references.
- Chapter 11 describes static non-local variables, static objects, various storage duration options, inline variables from C++17, and constinit from C++20.
- Chapter 12 moves to C++20 and describes Designated Initializers, a handy feature based on similar thing from the C language.
- Chapter 13 shows various techniques like passing strings into constructors, strong typing, CRTP class counter, Copy and swap idiom, self-registering types more.
- Chapter 14 is the final quiz with questions from the whole book.
And there are two appendices:
- Appendix A - a handy guide about rules for compiler-generated special member functions.
- Appendix B - answers to quizzes and exercises.
Most sections are completed, but I'm still working on filling two chapters and polishing the quality.
Who is this book for?
The book is intended for beginner/intermediate C++ programmers who want to learn various aspects of initialization in Modern C++ (from C++11 to C++20).
You should know at least some of the basics of creating and using custom classes.
This text is also helpful for experienced programmers who know older C++ standards and want to move into C++17/C++20
See the reviews at:
A new thorough and practical book from Bartek that will take you by the hand and give you an in-depth understanding of a core aspect of C++. The book starts with simple examples and then guides you through various aspects of constructors, and different kinds of data members. I like that it addresses the latest features of C++, including C++20.
C++ Initialization Story gives you an excellent overview of how to initialize different types of objects in Modern C++. I like the practical examples, detailed overview, and discussions of various techniques for custom types design.
Architect at Intel, Modern C++ enthusiast, and Author
Initialization in C++ is a complex subject, but C++ Initialization Story simplifies it in a way anyone can understand. Bartłomiej takes you on a journey full of practical examples, useful techniques, and best practices, showing you how they evolve with recent C++ standards. Not only will you learn about initialization but many other areas of the language as well. By the end of this book, you will have the skills to write idiomatic code and design bug-resistant types with ease.
About the Book
- Why should you read this book?
- Learning objectives
- The structure of the book
- Who is this book for?
- Reader feedback & errata
- Example code
- Special sections
- About the Author
- Revision History
1. Local Objects
- Starting with custom type
- Setting values to zero
- Copy and direct initialization
- Initialization with aggregates
- Default data member initialization
2. Initialization With Constructors
- Defining a class
- Basics of constructors
- Body of a constructor
Adding constructors to
- Compiler-generated default constructors
- Explicit constructors and conversions
- Difference between direct and copy initialization
- Implicit conversion and converting constructors
- Constructor summary
3. Copy and Move Operations
- Copy constructor
- Move constructor
- Distinguishing from assignment
- Adding debug logging to constructors
- Trivial classes and user-provided default constructors
4. Delegating and Inheriting Constructors
- Delegating constructors
- Inheriting constructors
- Objects allocated on the heap
- Destructors and data members
- Virtual destructors and polymorphism
- Partially created objects
- A compiler-generated destructor
6. Type Deduction and Initialization
- About value categories in C++
- Printing type info
- Structured bindings since C++17
- Template Argument Deduction for Class Templates
- Lifetime extension, references, and loops
- Almost Always Auto
- Deduction with
- 7. Quiz from Chapters 1…6
8. Non-Static Data Member Initialization
- How it works
- Other forms of NSDMI
- Copy constructor and NSDMI
- Move constructor and NSDMI
- C++14 changes
- C++20 changes
- Limitations of NSDMI
- NSDMI: Advantages and Disadvantages
- NSDMI summary
9. Containers as Data Members
- The basics
- Example implementation
- The cost of copying elements
- Some inconvenience - non-copyable types
- More options (advanced)
10. Non-regular Data Members
- Constant non-static data members
- Pointers as data members
- Smart pointers as data members
- References as data members
11. Non-local objects
- Storage duration and linkage
- Initialization of non-local static objects
- Static variables in a function scope
- About static data members
- Motivation for inline variables
- Global inline variables
12. Aggregates and Designated Initializers in C++20
- Aggregates as of C++20
- The basics of designated initializers
- Rules for designated initializers
- Advantages of designated initialization
13. Techniques and Use Cases
explicitfor strong types
Best way to initialize
Reducing extra copies through
- The copy and swap idiom
- CRTP class counter
- Several initialization types in one class
- Meyers Singleton and C++11
- Factory with self-registering types and static initialization
14. The Final Quiz And Exercises
Appendix A - Rules for Special Member Function Generation
- The diagram
- Rule of zero
- Rule of three (deprecated!)
- Rule of 5 and 6 - modern C++
- Moveable-only types
- Polymorphic base classes
- Appendix B - Quiz and Exercises Answers
The Leanpub 60-day 100% Happiness Guarantee
Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
See full terms
80% Royalties. Earn $16 on a $20 book.
We pay 80% royalties. That's not a typo: you earn $16 on a $20 sale. If we sell 5000 non-refunded copies of your book or course for $20, you'll earn $80,000.
(Yes, some authors have already earned much more than that on Leanpub.)
In fact, authors have earnedover $12 million USDwriting, publishing and selling on Leanpub.
Learn more about writing on Leanpub
Free Updates. DRM Free.
If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).
Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.
Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.