Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::make_tuple — créer un tuple avec des types déduits

std::make_tuple de <tuple> crée un tuple dont les types des éléments sont déduits à partir des arguments. Il stocke normalement des valeurs, mais std::ref et std::cref permettent de créer des éléments de référence plutôt que des copies.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

#include <tuple>
template<class... TTypes>
constexpr std::tuple<std::unwrap_ref_decay_t<TTypes>...>
make_tuple(TTypes&&... t);

std::make_tuple(args...)

std::make_tuple(args...), fourni par <tuple>, crée un std::tuple sans qu’il soit nécessaire d’indiquer explicitement les types de ses éléments. Chaque argument initialise l’élément correspondant ; les lvalues ordinaires sont copiées, tandis que les rvalues peuvent être déplacées si leur type le permet.

Le type de chaque élément est déterminé par std::unwrap_ref_decay_t<TTypes>. On retire d’abord l’éventuelle référence. Si le type restant est un type tableau, on obtient un pointeur vers le type des éléments du tableau, dont les qualificatifs sont conservés. S’il s’agit d’un type fonction, on obtient un pointeur vers une fonction de ce type. Ce n’est que dans les autres cas que les qualificatifs const et volatile de premier niveau sont supprimés. Par exemple, un littéral de chaîne ordinaire est un tableau de const char : l’élément du tuple est donc de type const char*, et non char* ou std::string.

Après cette transformation, std::reference_wrapper<T> est déballé en T&. Utilisez std::ref(x) pour conserver une référence à x, ou std::cref(x) pour conserver une référence à un objet constant. Le tuple ne prolonge pas la durée de vie de l’objet auquel une telle référence se rapporte ; cet objet doit toujours exister chaque fois que la référence est utilisée.

Contrairement à std::make_tuple, std::tie crée un tuple de références lvalue, tandis que std::forward_as_tuple crée un tuple de références destiné au transfert d’arguments et exige une attention particulière avec les objets temporaires. Dans l’exemple, le premier élément conserve une copie de 7, tandis que le second fait référence à value. L’appel std::get<1>(data) ne fait que renvoyer une référence à value ; c’est l’opération += 1 qui incrémente value par l’intermédiaire de cette référence.

Exemples

#include <functional>
#include <iostream>
#include <tuple>
#include <type_traits>

int main() {
    int value = 7;
    auto data = std::make_tuple(value, std::ref(value));
    static_assert(std::is_same_v<decltype(data), std::tuple<int, int&>>);

    value = 9;
    std::get<1>(data) += 1;
    std::cout << std::get<0>(data) << ' '
              << std::get<1>(data) << ' ' << value << '\n';
}

Résultat

7 10 10

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources