std::initializer list

std::initializer list (tsz. std::initializer lists)

1. (informatika) A std::initializer_list a C++11 szabványban bevezetett osztály, amely lehetővé teszi, hogy több értéket egyszerű, tömbszerű szintaxissal adjunk át függvényeknek vagy konstruktoroknak. Ez kulcsfontosságú a modern C++-ban az egyszerű és olvasható kódírás szempontjából.

A std::initializer_list<T> egy sablonos osztály, amely egy konstans méretű értékhalmazt reprezentál. Segítségével az alábbi szintaxist tudjuk használni:

std::vector<int> v = {1, 2, 3, 4}; // initializer list

A fenti kód kulisszái mögött valójában egy initializer_list<int> objektum jön létre, és azt kapja meg a std::vector konstruktora.

• Immutable (nem módosítható): Az initializer_list elemei konstansak.
• Könnyű iterálhatóság: Iterátorokkal bejárható.
• Szintaktikai cukor: Kódolvasás során egyszerű, természetes hatást kelt.
• Kezdőértékadás támogatása: Különösen hasznos konténerek inicializálására.

#include <iostream>
#include <initializer_list>

void print(std::initializer_list<int> list) {
    for (int x : list)
        std::cout << x << " ";
}

int main() {
    print({10, 20, 30, 40});
}

Kimenet:

10 20 30 40

class MyClass {
public:
    MyClass(std::initializer_list<int> list) {
        for (int i : list)
            std::cout << i << " ";
        std::cout << std::endl;
    }
};

int main() {
    MyClass obj = {5, 10, 15};
}

Az std::initializer_list általában két tagváltozót tartalmaz:

• Egy const T* típusú mutató az elemek tömbjére.
• Egy méret, amely megadja az elemek számát.

std::initializer_list<int> l = {1, 2, 3};
for (auto it = l.begin(); it != l.end(); ++it)
    std::cout << *it << " ";

1. Csak olvasható: Nem lehet módosítani az elemeket.
2. Élettartam: Az átadott lista ideiglenes objektum, így nem szabad a mutatóit elmenteni hosszabb távra.
3. Típus egyezés: Az initializer_list<T> minden elemének konvertálhatónak kell lennie a T típusra.

void fun(int);
void fun(std::initializer_list<int>);

fun(10);          // első verziót hívja
fun({10, 20});    // második verziót

#include <vector>

std::vector<std::string> words = {"apple", "banana", "cherry"};

A std::vector rendelkezik egy initializer_list konstruktora, így ez tökéletesen működik.

template<typename T>
void printList(std::initializer_list<T> list) {
    for (const auto& elem : list)
        std::cout << elem << " ";
}

• Ne keverd más típusokkal zavaró módon:

  MyClass obj{1}; // Lehet egyszerű konstruktorhívás vagy initializer_list!
  

  A {} néha kétértelmű, ha nincs megfelelő overload.

template <typename T>
class MyContainer {
    std::vector<T> elems;
public:
    MyContainer(std::initializer_list<T> list) : elems(list) {}
    void print() const {
        for (const T& e : elems) std::cout << e << " ";
        std::cout << std::endl;
    }
};

A std::initializer_list egy elegáns, olvasható és hatékony módja az adatok tömbszerű átadásának és inicializálásának C++11 óta. Főleg konténerosztályok, sablonfüggvények és variadikus konstruktorok használják ki. Használata azonban odafigyelést igényel az élettartam és típuskonverziók tekintetében.

• std::initializer list - Szótár.net (en-hu)
• std::initializer list - Sztaki (en-hu)
• std::initializer list - Merriam–Webster
• std::initializer list - Cambridge
• std::initializer list - WordNet
• std::initializer list - Яндекс (en-ru)
• std::initializer list - Google (en-hu)
• std::initializer list - Wikidata
• std::initializer list - Wikipédia (angol)