Скачать или смотреть Understanding C+ + initializer lists: Why Default Constructors are Invoked in Derived Classes

Learn why C+ + derived classes call default constructors, even with initializer lists, and how to design your classes effectively.
---
This video is based on the question https://stackoverflow.com/q/63108984/ asked by the user 'Damian Reiter' ( https://stackoverflow.com/u/8835422/ ) and on the answer https://stackoverflow.com/a/63109145/ provided by the user 'David Schwartz' ( https://stackoverflow.com/u/721269/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: C+ + initializer list members still calling default constructor?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding C+ + initializer lists: Why Default Constructors are Invoked in Derived Classes

When working with C+ + classes, you might encounter a perplexing situation involving constructors and initialization. This guide addresses one specific query that many developers face: Why does a derived class constructor call a default constructor in C+ + even when using an initializer list?

The Problem Explained

Consider the following situation where you have two classes, A and B, where B is derived from A:

[[See Video to Reveal this Text or Code Snippet]]

In the main() function, you are trying to instantiate B while passing a shared_ptr to an instance of A:

[[See Video to Reveal this Text or Code Snippet]]

However, when you attempt to compile this code, you might receive the error: no matching function for call to A::A(). This error occurs because, although you are passing a shared pointer to A into the constructor of B, the default constructor of A is being invoked, which isn’t defined.

The Underlying Cause

Inheritance Fundamentals

In C+ + , when you create a derived class (like B deriving from A), every instance of the derived class is also considered an instance of its base class. This means:

Constructing the Derived Class Necessitates Constructing the Base Class:

When you create an object of B, the constructor for A must also be called to construct the base part of the object.

Implicit Call to Default Constructor:

If the base class (A in this case) does not have a user-defined default constructor and you don't specify how to initialize A in B’s constructor, the compiler tries to call the default constructor of A. Since you haven’t defined this, it generates the aforementioned error.

The Role of the Initializer List

The initializer list in C+ + is a mechanism to initialize class members before the body of the constructor is executed. However, for inherited classes, it also applies to base classes. In this instance, you need to explicitly state how to initialize the base class, even when you are working with smart pointers for member variables.

Solution Approach

To fix the problem and prevent the default constructor from being called, you need to explicitly invoke the constructor of the base class A in the initializer list of B. Here’s how you can modify the code:

[[See Video to Reveal this Text or Code Snippet]]

Designing Your Classes Effectively

While resolving this issue, consider the following best practices for designing your classes:

Base Class Responsibilities: Ensure the base class (A in this case) only encapsulates the functionality that you want all derived classes to have. If you don't want B to inherit the data members of A, consider introducing a new base class that only contains the shared properties.

Example of Abstract Base Class:

If both A and B represent different kinds of instruments, a suitable base class, like Instrument, could only have properties like Play(), allowing for shared functionality.

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

Understanding how C+ + handles class inheritance and constructors is crucial for effective programming in this powerful language. By following best practices for class design and correctly using initializer lists, you can solve issues related to constructor calls and create robust applications.

If you're just starting out with C+ + or have faced similar issues, remember that carefully structuring your class hierarchy can save you a lot of headaches down the road!