std::initializer_list: construcción y trampas

std::initializer_list<T> es un objeto proxy, similar a un std::span [C++20], que proporciona acceso a un array temporal de objetos de tipo T generado por el compilador. No es un contenedor en sí mismo, sino una “vista” sobre una región de memoria que el compilador gestiona de forma implícita. Su propósito es permitir que los constructores de clases y las funciones acepten una sintaxis de lista de inicialización con llaves {...} de forma uniforme, sin necesidad de sobrecargar el operador de expansión para cada combinación de argumentos posible.

El mecanismo interno es sencillo pero delicado: cuando escribes {1, 2, 3}, el compilador construye un array temporal en el stack (o en una sección de datos del binario) y crea un objeto std::initializer_list que contiene punteros al principio y al final de ese array. Por esta razón, copiar un std::initializer_list es extremadamente barato: solo se copian los punteros, no los elementos. Sin embargo, esta misma propiedad es la que define su semántica de vida.

Debes usar std::initializer_list principalmente cuando estés implementando tus propios contenedores (como un std::vector personalizado) o cuando una función necesite recibir una cantidad arbitraria de elementos del mismo tipo de manera cómoda. Si solo necesitas una lista de argumentos constantes, quizás una plantilla con variadic templates sea mejor, pero para inicialización de colecciones, std::initializer_list es el estándar.

Si ignoras las reglas de su tiempo de vida, el desastre es inevitable. Como el array subyacente es un objeto temporal, cualquier intento de extraer una referencia o un puntero de la lista para usarlo fuera del ámbito donde se creó la lista resultará en un puntero colgante (dangling pointer).

#include <iostream>
#include <vector>
#include <string>
#include <initializer_list>
#include <algorithm>

// Un contenedor personalizado que utiliza std::initializer_list
class RegistroDatos {
public:
    RegistroDatos() = default;

    // Constructor que permite la sintaxis: RegistroDatos r = {"a", "b"};
    RegistroDatos(std::initializer_list<std::string> items) {
        for (const auto& item : items) {
            datos.push_back(item);
        }
    }

    void imprimir() const {
        for (const auto& s : datos) std::cout << s << " ";
        std::cout << std::endl;
    }

private:
    std::vector<std::string> datos;
};

// Función que acepta una lista de enteros
void calcular_suma(std::initializer_list<int> lista) {
    int suma = 0;
    for (int n : lista) {
        suma += n;
    }
    std::cout << "Suma de la lista: " << suma << std::endl;
}

int main() {
    // 1. La gran diferencia: Constructor de tamaño vs Constructor de lista
    // v1 llama al constructor std::vector(size_t n) -> 5 elementos con valor 0
    std::vector<int> v1(5); 
    
    // v2 llama al constructor std::vector(std::initializer_list<int>) -> 1 elemento con valor 5
    std::vector<int> v2{5}; 
    
    // v3 usa la lista para inicializar elementos
    std::vector<int> v3 = {1, 2, 3, 4, 5};

    // 2. Deducción de tipo con auto
    // auto x = {1, 2, 3}; deduciría std::initializer_list<int>
    auto lista_auto = {10, 20, 30}; 

    // 3. Uso de nuestro contenedor con sintaxis de llaves
    RegistroDatos reg = {"C++", "es", "potente"};
    reg.imprimir();

    // 4. Llamada directa con lista temporal
    calcular_suma({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});

    // 5. Narrowing conversions (Error de compilación)
    // std::vector<int> v_error = {1.5, 2.2}; // Esto fallaría por conversión de estrechamiento

    return 0;
}

Para compilar este ejemplo: g++ -std=c++20 -Wall -Wextra -Wpedantic -o ejemplo ejemplo.cpp

Análisis del código

Fíjate en la distinción entre v1(5) y v2{5}. Este es uno de los puntos donde más errores comete la gente al transicionar de C a C++. El uso de paréntesis () invoca un constructor de la clase, en este caso el que recibe un size_t. El uso de llaves {} tiene una prioridad especial: si el compilador encuentra un constructor que acepta std::initializer_list, lo elegirá por encima de los demás, incluso si hay una coincidencia de tipos más exacta para otro constructor.

En el caso de lista_auto, al usar auto con una lista de inicialización, el compilador no deduce un std::vector ni un std::array, sino directamente el tipo std::initializer_list<int>. Esto es una característica clave de la deducción de tipos en C++.

En la clase RegistroDatos, el constructor recibe std::initializer_list<std::string>. Cuando llamamos a RegistroDatos reg = {"C++", "es", "potente"};, el compilador genera un array temporal de std::string en el stack y le pasa ese array a nuestro constructor. El bucle for interno recorre esos elementos usando los iteradores begin() y end() que el objeto list proporciona.

El error frecuente

El peligro real surge cuando intentas “escapar” de la vida útil del array temporal. Un error clásico es intentar devolver un puntero a un elemento de una lista recibida por valor.

// ERROR CRÍTICO: Devuelve un puntero a memoria que dejará de existir
const int* peligroso(std::initializer_list<int> lista) {
    return &lista.front(); 
}

int main() {
    const int* ptr = peligroso({1, 2, 3});
    // En este punto, el array {1, 2, 3} ya ha sido destruido.
    // *ptr es un acceso a memoria inválida (Undefined Behavior).
    std::cout << *ptr << std::endl; 
}

Si compilas esto con -fsanitize=address, AddressSanitizer detectará inmediatamente el error de acceso a memoria (use-after-scope). El objeto list en la función peligroso es una copia local que apunta a un array temporal creado en la llamada. En cuanto peligroso termina, el array desaparece y el punrero ptr queda invalidado. Nunca guardes referencias ni punteros que apunten a los elementos de un std::initializer_list a menos que estés absolutamente seguro de que la lista original sobrevivirá al puntero.

N° 133