La inicialización uniforme [C++11], mediante el uso de llaves {}, es la capacidad de utilizar una única sintaxis para inicializar prácticamente cualquier constructo en C++: desde variables primitivas y agregados (structs), hasta objetos de clases complejas, arrays y contenedores de la STL. Este mecanismo busca unificar la sintaxis y resolver la inconsistencia histórica de usar (), = o la ausencia de símbolos según el contexto. Su mayor beneficio es la prevención de conversiones con pérdida de precisión (narrowing conversions): si intentas inicializar un int con un double usando {}, el compilador lanzará un error en tiempo de compilación, mientras que con () el valor se truncaría silenciosamente. Sin embargo, esta uniformidad tiene una regla de prioridad crítica: el uso de llaves siempre prioriza los constructores que aceptan un std::initializer_list. Si un objeto tiene un constructor que acepta una lista de elementos, el compilador elegirá ese camino incluso si un constructor con una firma numérica distinta parece coincidir mejor, lo que puede transformar una intención de definir el tamaño de un contenedor en una intención de definir sus elementos.
#include <iostream>
#include <vector>
#include <string>
// Un agregado (aggregate) para demostrar inicialización directa
struct Config {
int id;
double ratio;
};
// Clase con dos constructores que pueden causar ambigüedad
class Buffer {
public:
// Constructor para definir tamaño y valor inicial
Buffer(size_t size, int val) : size_(size), default_val_(val) {
std::cout << "Constructor: tamaño " << size_ << ", valor " << default_val_ << "\n";
}
// Constructor de initializer_list
Buffer(std::initializer_list<int> list) : size_(list.size()), default_val_(0) {
std::cout << "Constructor de lista: elementos = " << list.size() << "\n";
}
size_t size_;
int default_val_;
};
int main() {
// 1. Inicialización de agregado
Config cfg{42, 3.14};
// 2. El dilema de std::vector: ¿Tamaño o elementos?
// v_list tiene 2 elementos: 10 y 20
std::vector<int> v_list{10, 20};
// v_size tiene 10 elementos, todos con valor 20
std::vector<int> v_size(10, 20);
// 3. Buffer y la prioridad de initializer_list
// Llama al constructor de (size_t, int)
Buffer b_size(10, 5);
// Llama al constructor de std::initializer_list<int>
Buffer b_list{10, 5};
// 4. Resolución del "Most Vexing Parse"
// Buffer b_func(); // Error: Esto es una declaración de función, no un objeto
Buffer b_obj{}; // Correcto: Inicializa con valores por defecto
// 5. Deducción de tipo con llaves
auto lista_auto = {1, 2, 3}; // El tipo deducido es std::initializer_list<int>
std::cout << "v_list size: " << v_list.size() << "\n";
std::cout << "v_size size: " << v_size.size() << "\n";
std::cout << "lista_auto size: " << lista_auto.size() << "\n";
return 0;
}
Desglose del concepto
Al analizar el código, lo primero que debemos notar es cómo las llaves resuelven el Most Vexing Parse. En la línea donde intentamos declarar Buffer b_func();, el compilador interpretaría aquello como una declaración de una función llamada b_func que devuelve un Buffer y no recibe argumentos. Al usar Buffer b_obj{};, la sintaxis de inicialización uniforme le indica inequívocamente al compilador que estamos instanciando un objeto con la inicialización por defecto.
En el caso de Config cfg{42, 3.14};, estamos usando inicialización de agregados. Como Config es un struct simple sin constructores definidos por el usuario, las llaves asignan los valores a sus miembros en orden.
El punto más crítico reside en la diferencia entre v_list y v_size. Al usar std::vector<int> v_list{10, 20};, el compilador ve que el constructor que acepta std::initializer_list<int> es una opción válida y tiene prioridad. Por tanto, crea un vector con dos elementos. En cambio, al usar std::vector<int> v_size(10, 20);, estamos llamando al constructor tradicional de (size_t, const T&), lo que reserva espacio para 10 elementos inicializados en 20.
Observa también la variable lista_auto. Al usar auto lista_auto = {1, 2, 3};, el compilador no deduce un std::vector ni un std::array; deduce específicamente el tipo std::initializer_list<int>. Esto es una consecuencia directa de cómo las llaves empaquetan los valores.
Finalmente, la clase Buffer ilustra la “trampa” de la prioridad: aunque Buffer b_list{10, 5}; parece que debería llamar al constructor de (size_t, int), el compilador prefiere el constructor de std::initializer_list porque las llaves tienen un significado semántico especial para los tipos de contenedor.
El error frecuente
Uno de los errores más sutiles y frustrantes ocurre cuando intentas inicializar un contenedor con un solo valor, esperando que sea el valor de los elementos, pero terminas creando un contenedor con un único elemento.
// Intención: Un vector con 5 elementos, todos con valor 100
std::vector<int> v_wrong{5, 100};
// Resultado: Un vector con 2 elementos: el 5 y el 100.
// Intención: Un vector con 100 elementos, todos con valor 5
std::vector<int> v_fail{100};
// Resultado: Un vector con 1 solo elemento: el 100.
Este comportamiento ocurre porque el compilador prioriza la lista de inicialización. Si usas llaves, el compilador asume que cada valor dentro de las llaves es un elemento individual del contenedor. Si tu intención es definir la capacidad o tamaño, debes usar paréntesis (). Si usas {}, debes estar preparado para que el compilador interprete cada coma como un nuevo objeto dentro de la colección.
N° 13