C++ 11: Quelle est la différence entre boost :: make_tuple et std :: make_tuple?

Question

http://en.cppreference.com/w/cpp/utility/tuple/make_tuple (pour le code de commodité est collé)

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

std::tuple<int, int> f() // this function returns multiple values 
{ 
    int x = 5; 
    return std::make_tuple(x, 7); // return {x,7}; in C++17 
} 

int main() 
{ 
    // heterogeneous tuple construction 
    int n = 1; 
    auto t = std::make_tuple(10, "Test", 3.14, std::ref(n), n); 
    n = 7; 
    std::cout << "The value of t is " << "(" 
       << std::get<0>(t) << ", " << std::get<1>(t) << ", " 
       << std::get<2>(t) << ", " << std::get<3>(t) << ", " 
       << std::get<4>(t) << ")\n"; 

    // function returning multiple values 
    int a, b; 
    std::tie(a, b) = f(); 
    std::cout << a << " " << b << "\n"; 
} 

https://theboostcpplibraries.com/boost.tuple

#include <boost/tuple/tuple.hpp> 
#include <boost/tuple/tuple_io.hpp> 
#include <string> 
#include <iostream> 

int main() 
{ 
    typedef boost::tuple<std::string, int, bool> animal; 
    animal a = boost::make_tuple("cat", 4, true); 
    a.get<0>() = "dog"; 
    std::cout << std::boolalpha << a << '\n'; 
} 

Il semblerait basé sur la documentation boost :: make_tuple et std :: make_tuple sont exactement interchangeables.

Sont-ils vraiment interchangeables? Dans quelles circonstances ne le sont-ils pas?

Dans la documentation de boost, il dit que boost :: tuple et std :: tuple sont les mêmes dans C++ 11

Dans la documentation std il dit make_tuple retourne un std :: tuple.

Alors, y a-t-il des nuances qui me manquent?

Answer 1

Il n'y a pas de différence fonctionnelle.

boost::tuple a été créé il y a près de deux décennies, et std::tuple a été introduit à la base bibliothèque standard C++ 11, en 2011, il y a seulement 6 ans.

Ils ne sont pas "interchangeables", pour une définition donnée du terme "interchangeable". Vous ne pouvez pas affecter un std::tuple<> à un boost::tuple<> ou vice-versa, car même si leur implémentation est la même, ils représentent toujours des objets distincts. Cependant, parce qu'ils sont essentiellement les mêmes, vous pouvez faire une recherche → remplacer par boost::tuple → std::tuple et plus-ou-moins arriver avec le comportement identique et exécutant le code, et parce que la dépendance sur les bibliothèques de boost n'est pas quelque chose tous les programmeurs peut avoir, il est presque universellement recommandé que tout projet qui a accès à = = C++ 11 préfèrent std::tuple dans tous les cas.

EDIT:

Comme l'a souligné @Nir, il y a quelques différences syntaxiques entre boost::tuple et std::tuple, impliquant notamment la syntaxe get<>(), qui est également une fonction de membre de boost::tuple et seulement une fonction libre pour std::tuple.