The difference between assignment initialization and direct initialization in C++

In C++, assignment initialization (also known as copy initialization) and direct initialization (also known as construct initialization) often produce the same results, in some cases they have different meanings and behaviors.

Copy Initialization

Use the equal sign=How to perform initialization. This form looks like "assigning" the right value to the variable on the left.

int a = 10; // Basic Typestd::string str = "Hello"; // Class Type

For the underlying data type, this way is simply to assign values ​​to variables. But for class types, the compiler may call an implicit type conversion constructor to complete the initialization process and then perform a copy construction (although modern compilers usually optimize unnecessary copies).

Direct Initialization

Use brackets()Or braces{}How to perform initialization. This approach indicates more explicitly which constructor to call.

int b(20); // Basic Typestd::string str("Hello"); // Class Type

Or use the list initialization introduced by C++11:

int c{30}; // List initialization, suitable for basic types and class typesstd::string str{"Hello"}; // List initialization

Direct initialization can avoid some problems caused by implicit type conversion and is necessary for some cases, such as selecting a specific constructor for initialization when there are multiple constructors.

Examples of differences

Consider the following example:

#include <iostream>
#include <string>

class MyClass {
public:
    MyClass(int) { std::cout << "Constructor from int\n"; }
    MyClass(const MyClass&) { std::cout << "Copy constructor\n"; }
};

int main() {
    // Assignment initialization    MyClass obj1 = 1; // Implicitly convert to MyClass, and then copy the construct    // Output: Constructor from int    // Copy constructor (may be optimized)
    // Direct initialization    MyClass obj2(1); // Directly call the int constructor    // Output: Constructor from int
    return 0;
}

In this example:

• Forobj1Use assignment initialization, first you need to use implicit type conversion fromintConvert toMyClass, and then the copy constructor may be called to create the final object (if not optimized by the compiler).
• Forobj2Use direct initialization, then the direct call fromintarriveMyClassThe constructor avoids additional copy construction steps.

Therefore, direct initialization is usually more efficient when it comes to class types and provides better control over the initialization process. For basic data types, the effects of the two initialization methods are basically the same, and the main difference is the code style and readability.

Need to pay attention

1. Implicit type conversion

• Assignment initializationImplicit type conversion may be triggered, which can lead to unexpected results or performance overhead. For example, if there is an implicit conversion constructor from one type to another, the compiler will try to do this conversion and then perform a copy construct (although modern compilers usually optimize unnecessary copies).
• Direct initializationIt is possible to specify more explicitly which constructor you want to call, thus avoiding unnecessary implicit conversions.

2. List initialization (C++11 and above)

Use braces{}Performing list initialization can effectively prevent narrowing conversions, that is, the situation where accuracy may be lost when converting from a larger numerical range to a smaller numerical range. For example:

int x{10.5}; // Compilation error：Unable to implicitly convert floating point numbers to integers

3. Copy construction and move semantics (C++11 and above)

In C++11 and later, moving semantics are introduced. If your object supports moving constructors, direct initialization can sometimes better utilize this feature to improve performance, especially when dealing with temporary objects.

4. Complex types and custom classes

For complex types or custom classes, direct initialization is usually more recommended because it provides more precise control over the construction process. In addition, in some cases, only direct initialization can complete specific construction operations, such as using multiple parameters to construct objects.

5. Readability and consistency

Although the two initialization methods work the same in many cases, maintaining a consistent initialization style helps improve the readability and maintainability of the code. It is a good practice to choose an initialization style and use it uniformly throughout your project.

This is the end of this article about the difference between assignment initialization and direct initialization in C++. For more related contents of C++ assignment initialization and direct initialization, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!