UpdatedAug 4, 2026

Initialization Forms

Question Variations

"What is the difference between `T x(1)` and `T x{1}`?"
"Why does brace initialization reject narrowing?"
"How do initializer-list constructors affect overload resolution?"
"What is value initialization?"

Why This Is Asked

Initialization syntax changes conversion behavior and overload selection in C++. This question tests whether you can use brace initialization deliberately, avoid accidental narrowing, and recognize cases where braces choose a different constructor than parentheses.

Key Concepts

Copy initialization uses = and can consider implicit conversions.
Direct initialization uses parentheses.
List initialization uses braces and rejects narrowing conversions.
std::initializer_list constructors can take priority during list initialization.

Question Variations

“What is the difference between T x(1) and T x{1}?”
“Why does brace initialization reject narrowing?”
“How do initializer-list constructors affect overload resolution?”
“What is value initialization?”

Answers by Technology

+ Add Variant

C++Improve this answer ✏️

Expected Answer (C++23)

C++ supports copy initialization, direct initialization, and list initialization. Braces use list initialization and reject narrowing conversions, which can prevent silent loss of information. However, braces can prefer an std::initializer_list constructor, so they are not always interchangeable with parentheses.

Choose the form that expresses the intended construction and understand how the target type’s constructors participate in overload resolution.

#include <vector>

int main() {
    int count{3};
    // int truncated{3.5}; // Error: narrowing conversion.

    std::vector<int> values{3, 4}; // Two elements: 3 and 4.
    std::vector<int> repeated(3, 4); // Three elements, each 4.

    return values.size() == 2 && repeated.size() == 3 ? 0 : 1;
}

Why It Matters

Initialization choices can change a program’s meaning while looking superficially similar. Brace initialization catches lossy conversions, and understanding constructor selection prevents subtle container and API bugs.

Common Mistakes

Assuming braces and parentheses always choose the same constructor: An initializer-list overload can change the result.
Using parentheses when narrowing should be rejected: A conversion may compile but lose data.
Interpreting std::vector<int>{3, 4} as a size and fill value: It constructs a two-element vector.

Follow-up Questions

What does value initialization do for an int? (Answer: It initializes it to zero.)
Why might an API offer an initializer_list constructor? (Answer: To support natural brace-list construction from a set of values.)