Inicialización uniforme en C++

La inicialización uniforme es una característica de C++ 11 que permite el uso de una sintaxis coherente para inicializar variables y objetos que van desde el tipo primitivo hasta los agregados. En otras palabras, introduce la inicialización de llaves que usa llaves ({}) para encerrar los valores del inicializador. La sintaxis es la siguiente:

type var_name{arg1, arg2, ....arg n}

Los siguientes son algunos de los ejemplos de las diferentes formas de inicializar diferentes tipos:

// uninitialized built-in type
int i;    

// initialized built-in type
int j=10; 

// initialized built-in type
int k(10);

// Aggregate initialization
int a[]={1, 2, 3, 4} 

// default constructor
X x1; 

// Parameterized constructor
X x2(1); 

// Parameterized constructor with single argument
X x3=3; 

// copy-constructor
X x4=x3; 

Si se inicializa con la inicialización de llaves, el código anterior se puede volver a escribir como: 

int i{};     // initialized built-in type, equals to int i{0};

int j{10}; // initialized built-in type

int a[]{1, 2, 3, 4} // Aggregate initialization

X x1{}; // default constructor

X x2{1}; // Parameterized constructor;

X x4{x3}; // copy-constructor

 Aplicaciones de inicialización uniforme

Inicialización de arreglos asignados dinámicamente : 

// C++ program to demonstrate initialization
// of dynamic array in C++ using uniform initialization
#include <bits/stdc++.h>
using namespace std;
int main()
{
    // declaring a dynamic array
    // and initializing using braces
    int* pi = new int[5]{ 1, 2, 3, 4, 5 };
 
    // printing the contents of the array
    for (int i = 0; i < 5; i++)
        cout << *(pi + i) << " ";
}

1 2 3 4 5 

Inicialización de un miembro de datos de array de una clase :

// C++ program to initialize
//  an array data member of a class
// with uniform initialization
#include <iostream>
using namespace std;
 
class A
{
    int arr[3];
 
public:
    // initializing array using
    // uniform initialization
    A(int x, int y, int z)
        : arr{ x, y, z } {};
 
    void show()
    {
        // printing the contents of the array
        for (int i = 0; i < 3; i++)
            cout << *(arr + i) <<" ";
    }
};
 
// Driver Code
int main()
{
    // New object created and the numbers
    // to initialize the array with, are passed
    // into it as arguments
    A a(1, 2, 3);
    a.show();
    return 0;
}

1 2 3 

Inicializar implícitamente los objetos para devolver : 

// C++ program to implicitly
// initialize an object to return
#include <iostream>
using namespace std;
 
// declaring a class 'A'
class A {
    // a and b are data members
    int a;
    int b;
 
    // constructor
public:
    A(int x, int y)
        : a(x)
        , b(y)
    {
    }
    void show() { cout << a << " " << b; }
};
 
A f(int a, int b)
{
    // The compiler automatically
    // deduces that the constructor
    // of the class A needs to be called
    // and the function parameters of f are
    // needed to be passed here
    return { a, b };
}
 
// Driver Code
int main()
{
    A x = f(1, 2);
    x.show();
    return 0;
}

1 2

Inicializar implícitamente el parámetro de función 

// C++ program to demonstrate how to
// initialize a function parameter
// using Uniform Initialization
 
#include <iostream>
using namespace std;
 
// declaring a class 'A'
class A {
 
    // a and b are data members
    int a;
    int b;
 
public:
    A(int x, int y)
        : a(x)
        , b(y)
    {
    }
    void show() { cout << a << " " << b; }
};
 
void f(A x) { x.show(); }
 
// Driver Code
int main()
{
 
    // calling function and initializing it's argument
    // using brace initialization
    f({ 1, 2 });
    return 0;
}

1 2