两种POD成员变量初始化方式在性能、代码量等方面是否等价？业界有何偏好？

Great question! First, let's clarify the code examples (fixing a small typo in 方式一 where the constructor referenced isWord_ instead of the member isWord):

方式一 (Constructor Initializer List)

class Trie {
public:
    Trie() : isWord(false) { }
    vector<Trie*> child(keyLength);
    bool isWord;
};

方式二 (In-Class Default Initialization)

class Trie {
public:
    Trie();
    vector<Trie*> child(keyLength);
    bool isWord = false;
};

Let's break down the details:

Performance & Generated Code Size #

For POD types like bool isWord, these two approaches are effectively identical in modern C++ compilers (GCC, Clang, MSVC):

• Both generate code that sets isWord to false during object construction—there’s no measurable performance gap, and the resulting machine code size will be the same.
• For the vector<Trie*> child(keyLength) member: whether initialized directly in the class or moved to a constructor initializer list, the compiler produces identical code, as it’s just invoking the vector’s constructor with keyLength as an argument.

The only minor distinction here is code duplication: with in-class initialization (方式二), you avoid repeating the same initialization logic across multiple constructors, which keeps your source code cleaner (though compilers may still deduplicate identical machine code automatically).

Semantic Differences #

While performance matches, there’s a critical semantic gap:

• 方式一: The initialization is tied exclusively to this specific constructor. If you add another Trie constructor that doesn’t explicitly initialize isWord, that member will be left uninitialized (leading to undefined behavior for POD types).
• 方式二: The = false sets a default value that applies to all constructors unless a constructor explicitly overrides it via its own initializer list. This guarantees isWord is always initialized, even if you add new constructors later.

Industry Preference #

Since C++11 introduced in-class non-static member initialization, the industry has strongly favored 方式二’s approach for three key reasons:

• Less repetition: No need to copy-paste the same initializations into every constructor of the class.
• Better readability: A member’s default value is declared right next to its type and name, so anyone reading the class definition can immediately see its default state.
• Safer initialization: Eliminates the risk of forgetting to initialize a member in a new constructor, which can lead to hard-to-debug undefined behavior.

That said, constructor initializer lists are still mandatory for:

• Initializing reference members (references must be bound at construction time and can’t have a default in-class value).
• Initializing const members whose value depends on constructor parameters.
• Calling base class constructors with specific arguments.

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