类定义内成员字段初始化：=与{}两种方式的差异探究

Great question! Let's break down the differences (and similarities) between using = and {} for in-class member initialization in C++.

Key Differences #

• Explicit constructor restrictions
  If your member is a class type with an explicit constructor, using = will fail to compile, while {} works perfectly. For example:

  class C {
  public:
      explicit C(int) {} // Explicit constructor
  };
  
  class A {
      C c = 1; // ❌ Error: can't use explicit constructor in copy initialization
      C c{1}; // ✅ OK: direct list initialization
  };
  

  This is because = triggers copy initialization, which can't invoke explicit constructors, whereas {} uses direct initialization.

• Narrowing conversion prevention
  List initialization with {} strictly prohibits narrowing conversions (like converting a double to int, or a large integer to a smaller type), while = allows them (often with a compiler warning, but not an error). Example:

  class A {
      int a = 3.14; // ⚠️ Compiles (with warning), narrows double to int
      int a{3.14}; // ❌ Compile error: narrowing conversion not allowed
  };
  

  This is a big win for type safety if you want to avoid accidental data loss.

Efficiency: Are {} Faster? #

For most practical purposes, no—there's no performance difference between the two in in-class initialization:

• For built-in types (like int, bool, pointers), both syntaxes generate identical machine code. The compiler treats them exactly the same.
• For class types, while = technically triggers copy initialization (which would involve creating a temporary and copying it), modern C++ compilers (C++11 and later) use Return Value Optimization (RVO) to eliminate the copy entirely. This means the object is constructed directly in the member's memory space, just like with {}.

The only exception is if the class has a deleted copy constructor (or it's implicitly deleted, e.g., because the class has a move-only member). In that case, = will fail to compile, but {} (direct initialization) will still work.

When Are They Identical? #

If you're initializing built-in types, or class types without explicit constructors or narrowing concerns, the two syntaxes are just sugar for the same underlying logic. The compiler will generate the same initialization code for both int a = 1; and int a{1}; in a class definition.

内容的提问来源于stack exchange，提问作者Bruice