std:: tuple

Le modèle de classe std::tuple est une collection de taille fixe de valeurs hétérogènes. Il s'agit d'une généralisation de std::pair .

Si std:: is_trivially_destructible < Ti > :: value est true pour chaque Ti dans Types , le destructeur de std::tuple est trivial.

Si un programme déclare une spécialisation explicite ou une spécialisation partielle de std::tuple , le programme est mal formé, aucun diagnostic requis.

Paramètres du modèle

Fonctions membres

Fonctions non membres

Concepts auxiliaires

Classes d'assistance

Spécialisations d'assistance

Cette spécialisation de std::enable_nonlocking_formatter_optimization permet une implémentation efficace de std::print et std::println pour l'affichage d'un objet tuple lorsque chaque type d'élément l'autorise.

Guides de déduction (depuis C++17)

Notes

Puisque la "forme" d'un tuple – sa taille, les types de ses éléments et l'ordre de ces types – fait partie de sa signature de type, elles doivent toutes être disponibles à la compilation et ne peuvent dépendre que d'autres informations disponibles à la compilation. Cela signifie que de nombreuses opérations conditionnelles sur les tuples – en particulier l'ajout conditionnel en tête/queue et le filtrage – ne sont possibles que si les conditions peuvent être évaluées à la compilation. Par exemple, étant donné un std :: tuple < int , double , int > , il est possible de filtrer sur les types – par exemple retourner un std :: tuple < int , int > – mais pas de filtrer sur le fait que chaque élément est positif ou non (ce qui aurait une signature de type différente selon les valeurs d'exécution du tuple), sauf si tous les éléments étaient eux-mêmes constexpr .

En guise de solution de contournement, on peut travailler avec des tuples de std:: optional , mais il n'existe toujours aucun moyen d'ajuster la taille en fonction des informations d'exécution.

Jusqu'à N4387 (appliqué comme rapport de défaut pour C++11), une fonction ne pouvait pas retourner un tuple en utilisant l'initialisation par liste de copie :

std::tuple<int, int> foo_tuple()
{
    return {1, -1};  // Erreur jusqu'à N4387
    return std::tuple<int, int>{1, -1}; // Fonctionne toujours
    return std::make_tuple(1, -1); // Fonctionne toujours
}

Exemple

#include <iostream>
#include <stdexcept>
#include <string>
#include <tuple>
std::tuple<double, char, std::string> get_student(int id)
{
    switch (id)
    {
        case 0: return {3.8, 'A', "Lisa Simpson"};
        case 1: return {2.9, 'C', "Milhouse Van Houten"};
        case 2: return {1.7, 'D', "Ralph Wiggum"};
        case 3: return {0.6, 'F', "Bart Simpson"};
    }
    throw std::invalid_argument("id");
}
int main()
{
    const auto student0 = get_student(0);
    std::cout << "ID: 0, "
              << "GPA: " << std::get<0>(student0) << ", "
              << "grade: " << std::get<1>(student0) << ", "
              << "name: " << std::get<2>(student0) << '\n';
    const auto student1 = get_student(1);
    std::cout << "ID: 1, "
              << "GPA: " << std::get<double>(student1) << ", "
              << "grade: " << std::get<char>(student1) << ", "
              << "name: " << std::get<std::string>(student1) << '\n';
    double gpa2;
    char grade2;
    std::string name2;
    std::tie(gpa2, grade2, name2) = get_student(2);
    std::cout << "ID: 2, "
              << "GPA: " << gpa2 << ", "
              << "grade: " << grade2 << ", "
              << "name: " << name2 << '\n';
    // C++17 structured binding:
    const auto [gpa3, grade3, name3] = get_student(3);
    std::cout << "ID: 3, "
              << "GPA: " << gpa3 << ", "
              << "grade: " << grade3 << ", "
              << "name: " << name3 << '\n';
}

ID: 0, GPA: 3.8, grade: A, name: Lisa Simpson
ID: 1, GPA: 2.9, grade: C, name: Milhouse Van Houten
ID: 2, GPA: 1.7, grade: D, name: Ralph Wiggum
ID: 3, GPA: 0.6, grade: F, name: Bart Simpson

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Références

Voir aussi