What is uniform initialization in C++?

Uniform initialization using braces (e.g., int x {5};) was introduced in C++11 as a way to standardize initialization across different types. It has a few advantages over using the assignment operator =:

It prevents narrowing conversions. If you try to initialize a variable with a value that would require narrowing (like initializing an integer with a floating-point value), the compiler will throw an error:

1int x = 5.5; // Compiles, but loses data 
2int y {5.5}; // Fails to compile

It can be used to initialize any type, including user-defined types. This makes initialization syntax more consistent across types.

Uniform initialization can be used to initialize containers and complex types in a cleaner way, especially when the initialization involves multiple values:

1#include <vector>
2
3int main() {
4  // Old style
5  std::vector<int> v = {1, 2, 3};
6
7  // Uniform initialization
8  std::vector<int> v{1, 2, 3};
9}

Additionally, uniform initialization avoids the "most vexing parse" problem in certain situations. In the following example, the first line is ambiguous. It could be a variable x initialized with a temporary MyClass.

But C++ allows superfluous parentheses around function parameter declarations, so x could be declaring a function that returns MyClass and takes a MyClass parameter.

The second line is unambiguously a variable.

1class MyClass {};
2
3// Is this a variable or a function declaration?
4MyClass x(MyClass());
5
6// Clearly a variable
7MyClass y{MyClass()};

However, it's worth noting that uniform initialization isn't a complete replacement for the = syntax. In some cases, like with auto type deduction, the two forms can behave slightly differently.