liveBook · Manning

Uniform initialization

As explained in 100 C++ Mistakes and How to Avoid Them

Uniform initialization is C++ initialization syntax using braces that provides consistent initialization semantics and rejects narrowing conversions.

Uniform initialization uses braces to give variables, containers, and complex objects a consistent initialization form. It also rejects narrowing conversions, such as silently placing a double into an int. section 3.5

Replace setup code with braces

Instead of repeatedly calling push_back to build a vector, initialize it directly with its values, then initialize the count with braces. The result is shorter and easier to read.

Uniform initialization provides:

  • Consistent syntax across variable types. section 3.5
  • Protection against narrowing conversions. section 3.5
  • Initializer-list support for constructors and containers. section 3.5
Listing 2.10 Using in-class initialization for readability
class Complex {
private:
    double real = 0;                                         #1
    double imag{0};                                          #2
public:
    Complex() {}
    Complex(double r, double i) : real(r), imag(i) {}
    double getImag() const { return imag; }
};
 
int main() {
    Complex c1;                                              #3
    // Complex c2(3);                                        #4
    Complex c3(-2, -2);
    return 0;
}

Compare assignment-style and braced in-class defaults while keeping constructor-supplied values available. section 2.5

How 100 C++ Mistakes and How to Avoid Them covers it

How deep it goes
Defines the syntax, explains its benefits, and demonstrates containers and variables, but does not detail language-resolution rules.
Examples
Demonstrates vector construction, count initialization, and braced defaults for Complex data members.
What it assumes
Assumes basic C++ variables, vectors, classes, constructors, and initialization, while teaching the uniform brace form directly.
What you can do after
Apply it to initialize variables, containers, and complex objects while avoiding silent narrowing conversions.
How it connects
Connects uniform initialization with in-class initialization, constructors, containers, initializer lists, and narrowing conversions.

Also explained in

Compare how 2 books explain uniform initialization →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of 100 C++ Mistakes and How to Avoid Them. The section links point to the parts of the book it draws on.