std::tuple

Angol

Főnév

(informatika) A std::tuple egy típusbiztos adattároló C++-ban, amely több különböző típusú értéket képes egyetlen változóban tárolni. Ez hasonló az std::pair-hez, de annál több elemet tartalmazhat.

📌 Főbb jellemzői:
✅ Különböző típusú adatok tárolása egyetlen objektumban.
✅ Az elemekhez index vagy típus alapján lehet hozzáférni.
✅ Könnyen kombinálható más STL elemekkel (std::get, std::tie, std::apply stb.).

1. `std::tuple` létrehozása és elemek elérése

📌 Alapvető használat

#include <iostream>
#include <tuple>

int main() {
    // Tuple létrehozása (int, double, string)
    std::tuple<int, double, std::string> adatok(42, 3.14, "Hello");

    // Elemtípusok szerinti lekérés
    std::cout << "Első érték: " << std::get<0>(adatok) << std::endl;
    std::cout << "Második érték: " << std::get<1>(adatok) << std::endl;
    std::cout << "Harmadik érték: " << std::get<2>(adatok) << std::endl;

    return 0;
}

🔹 Kimenet:

Első érték: 42  
Második érték: 3.14  
Harmadik érték: Hello

📌 Magyarázat:
- std::tuple<int, double, std::string> egy 3 elemből álló tuple.
- Az std::get<N>(tuple) segítségével index alapján érjük el az elemeket.

2. `std::make_tuple` – Könnyebb létrehozás

A std::make_tuple() segítségével rövidebb szintaxissal hozhatunk létre tuple-t:

#include <iostream>
#include <tuple>

int main() {
    auto adatok = std::make_tuple(10, 2.71, "C++");

    std::cout << std::get<0>(adatok) << " "
              << std::get<1>(adatok) << " "
              << std::get<2>(adatok) << std::endl;

    return 0;
}

🔹 Előnye:
- Nem kell külön megadni a típusokat (std::tuple<int, double, std::string> helyett egyszerűbb).

3. `std::tie` – Tuple kicsomagolása változókba

A std::tie() segítségével egy tuple tartalmát változókba helyezhetjük.

#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double, std::string> adatok(100, 9.81, "Gravity");

    int szam;
    double suly;
    std::string nev;

    // Tuple elemeinek szétbontása változókba
    std::tie(szam, suly, nev) = adatok;

    std::cout << szam << ", " << suly << ", " << nev << std::endl;
    return 0;
}

🔹 Előnye:
- Nem kell külön std::get<>-et használni minden egyes értékhez.

📌 Ha egy értéket kihagynánk, használjuk std::ignore-t:

std::tie(szam, std::ignore, nev) = adatok;

4. `std::tuple_size` és `std::tuple_element`

A tuple méretének és elemeinek típusának lekérésére használhatjuk ezeket a függvényeket.

#include <iostream>
#include <tuple>
#include <type_traits>  // Szükséges a type elemzéshez

int main() {
    std::tuple<int, double, std::string> adatok(5, 2.5, "Data");

    // Tuple mérete
    std::cout << "Tuple mérete: " << std::tuple_size<decltype(adatok)>::value << std::endl;

    // Tuple első elemének típusa
    using elso_elem_tipus = std::tuple_element<0, decltype(adatok)>::type;
    std::cout << "Első elem típusa: " << typeid(elso_elem_tipus).name() << std::endl;

    return 0;
}

🔹 Kimenet:

Tuple mérete: 3  
Első elem típusa: int

✅ Miért jó?
- std::tuple_size<tuple>: Megadja, hány elem van a tuple-ben.
- std::tuple_element<N, tuple>::type: Lekéri az adott indexű elem típusát.

5. `std::apply` – Tuple argumentumok átadása függvénynek

A std::apply() lehetővé teszi, hogy egy tuple tartalmát függvényparaméterként átadjuk.

📌 Példa:

#include <iostream>
#include <tuple>
#include <utility>

// Egy függvény három paraméterrel
void mutat(int a, double b, const std::string &c) {
    std::cout << "int: " << a << ", double: " << b << ", string: " << c << std::endl;
}

int main() {
    auto args = std::make_tuple(42, 3.14, "Hello");

    // Tuple elemeket függvényargumentumként átadjuk
    std::apply(mutat, args);

    return 0;
}

🔹 Előnye:
- Nem kell egyesével kiszedni az értékeket a tuple-ből.

6. Tuple összehasonlítás és kombinálás

📌 Tuple összehasonlítás

Két tuple összehasonlítható az <, >, ==, != operátorokkal.

#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double, char> t1(10, 2.5, 'A');
    std::tuple<int, double, char> t2(20, 2.5, 'B');

    if (t1 < t2) {
        std::cout << "t1 kisebb, mint t2" << std::endl;
    }

    return 0;
}

📌 Összehasonlítási sorrend:
1. Az első eltérő elem alapján dönt.
2. Ha az első elem megegyezik, akkor a második alapján hasonlít stb.

📌 Tuple egyesítés `std::tuple_cat` segítségével

#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double> t1(10, 2.5);
    std::tuple<std::string, char> t2("Hello", 'A');

    // Tuple összevonása
    auto t3 = std::tuple_cat(t1, t2);

    std::cout << std::get<0>(t3) << ", "
              << std::get<1>(t3) << ", "
              << std::get<2>(t3) << ", "
              << std::get<3>(t3) << std::endl;

    return 0;
}

✅ Miért jó?
- Két vagy több tuple egyesíthető egybe.

Összegzés

Funkció	Leírás
`std::tuple`	Több típusú adat egy változóban
`std::get<N>(tuple)`	Elem elérése index alapján
`std::make_tuple`	Tuple létrehozása egyszerűbben
`std::tie`	Tuple változókba bontása
`std::tuple_size`	Tuple elemeinek számát adja meg
`std::apply`	Tuple elemek átadása függvény paraméterként
`std::tuple_cat`	Tuple-k összefűzése

Az std::tuple hasznos több különböző típusú adat egyben tartására és dinamikus paraméterkezelésre!

További információk

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