Namespaces
Variants

std::forward_as_tuple

Depuis fr.cppreference.net
 
 
Bibliothèque d'utilitaires
Support linguistique
Support des types (types de base, RTTI)
Macros de test de fonctionnalités de la bibliothèque (C++20)
Utilitaires de programme
Fonctions variadiques
Support des coroutines (C++20)
Support des contrats (C++26)
Comparaison à trois voies
(C++20)
(C++20)(C++20)(C++20)    
(C++20)(C++20)(C++20)

Utilitaires généraux
Opérateurs relationnels (obsolète en C++20)
 
 
Défini dans l'en-tête <tuple>
template< class... Types >
std::tuple<Types&&...> forward_as_tuple( Types&&... args ) noexcept;
(depuis C++11)
(constexpr depuis C++14)

Construit un tuple de références vers les arguments dans args adapté pour être transmis comme argument à une fonction. Le tuple a des membres de données de référence rvalue lorsque des rvalues sont utilisées comme arguments, et autrement a des membres de données de référence lvalue.

Paramètres

args - zéro ou plusieurs arguments pour construire le tuple

Valeur de retour

Un objet std::tuple créé comme si par std:: tuple < Types && ... > ( std:: forward < Types > ( args ) ... )

Notes

Si les arguments sont des temporaires, forward_as_tuple ne prolonge pas leur durée de vie ; ils doivent être utilisés avant la fin de l'expression complète.

Exemple

#include <iostream>
#include <map>
#include <string>
#include <tuple>
int main()
{
    std::map<int, std::string> m;
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple(6),
              std::forward_as_tuple(9, 'g'));
    std::cout << "m[6] = " << m[6] << '\n';
    // The following is an error: it produces a
    // std::tuple<int&&, char&&> holding two dangling references.
    //
    // auto t = std::forward_as_tuple(20, 'a');
    // m.emplace(std::piecewise_construct, std::forward_as_tuple(10), t);
}

Sortie :

m[6] = ggggggggg

Voir aussi

(C++11)
crée un objet tuple du type défini par les types d'arguments
(modèle de fonction)
(C++11)
crée un tuple de références de lvalue ou décompose un tuple en objets individuels
(modèle de fonction)
(C++11)
crée un tuple en concaténant un nombre quelconque de tuples
(modèle de fonction)
(C++17)
appelle une fonction avec un tuple d'arguments
(modèle de fonction)