Pretty-print std::tuple

J'ai eu ce travail d'amende dans le C++11 (gcc 4.7). Il y a je suis sûr que certains pièges, je n'ai pas envisagé, mais je pense que le code est facile à lire et à et pas compliqué. La seule chose qui peut être étrange est la "garde" struct tuple_printer que de nous assurer de mettre fin lorsque le dernier élément est atteint. Autre chose étrange, peut-être sizeof...(Types) qui retourne le nombre de types de Types de type de pack. Il est utilisé pour déterminer l'indice du dernier élément (taille...(Types) - 1).

template<typename Type, unsigned N, unsigned Last>
struct tuple_printer {

    static void print(std::ostream& out, const Type& value) {
        out << std::get<N>(value) << ", ";
        tuple_printer<Type, N + 1, Last>::print(out, value);
    }
};

template<typename Type, unsigned N>
struct tuple_printer<Type, N, N> {

    static void print(std::ostream& out, const Type& value) {
        out << std::get<N>(value);
    }

};

template<typename... Types>
std::ostream& operator<<(std::ostream& out, const std::tuple<Types...>& value) {
    out << "(";
    tuple_printer<std::tuple<Types...>, 0, sizeof...(Types) - 1>::print(out, value);
    out << ")";
    return out;
}

En C++17 nous pouvons accomplir cela avec un peu moins de code en profitant de Plier les expressions, en particulier unaire de gauche pli:

template<class TupType, size_t... I>
void print(const TupType& _tup, std::index_sequence<I...>)
{
    std::cout << "(";
    (..., (std::cout << (I == 0? "" : ", ") << std::get<I>(_tup)));
    std::cout << ")\n";
}

template<class... T>
void print (const std::tuple<T...>& _tup)
{
    print(_tup, std::make_index_sequence<sizeof...(T)>());
}

Démonstration En Direct sorties:

(5, Bonjour, -0.1)

donné

auto a = std::make_tuple(5, "Hello", -0.1);
print(a);

---

Explication

Notre unaire de gauche pli est de la forme

... op pack

où op dans notre scénario est l'opérateur virgule, et pack est l'expression contenant notre tuple dans une non développés contexte comme:

(..., (std::cout << std::get<I>(myTuple))

Donc, si j'ai un n-uplet de la sorte:

auto myTuple = std::make_tuple(5, "Hello", -0.1);

Et un std::integer_sequence dont les valeurs sont spécifiées par un non-type de modèle (voir code ci-dessus)

size_t... I

Alors l'expression

(..., (std::cout << std::get<I>(myTuple))

Obtient élargi en

((std::cout << std::get<0>(myTuple)), (std::cout << std::get<1>(myTuple))), (std::cout << std::get<2>(myTuple));

Qui permet d'imprimer

5Hello-0.1

Qui est brut, nous avons donc besoin de faire un peu plus de la ruse pour ajouter une virgule de séparation à être imprimée pour la première fois, sauf si c'est le premier élément.

Pour accomplir cela, nous allons modifier l' pack partie de la fois l'expression d'imprimer " ," si l'indice actuel I n'est pas le premier, d'où le (I == 0? "" : ", ") partie^*:

(..., (std::cout << (I == 0? "" : ", ") << std::get<I>(_tup)));

Et maintenant nous allons obtenir

5, Bonjour, -0.1

Qui ressemble plus belle (Note: je voulais le même résultat que cette réponse)

^{*Remarque: Vous pouvez procéder de la virgule de séparation dans une variété de façons de faire que ce que j'ai. J'ai d'abord ajouté des virgules conditionnellement après au lieu de avant par des tests contre les std::tuple_size<TupType>::value - 1, mais c'était trop long, donc j'ai testé au lieu contre sizeof...(I) - 1, mais à la fin j'ai copié Xeo et nous avons fini avec ce que j'ai.}

Basé sur AndyG code en C++17

#include <iostream>
#include <tuple>
template<class TupType, size_t... I>
std::ostream& tuple_print(std::ostream& os,
const TupType& _tup, std::index_sequence<I...>)
{
os << "(";
(..., (os << (I == 0 ? "" : ", ") << std::get<I>(_tup)));
os << ")";
return os;
}
template<class... T>
std::ostream& operator<< (std::ostream& os, const std::tuple<T...>& _tup)
{
return tuple_print(os, _tup, std::make_index_sequence<sizeof...(T)>());
}
int main()
{
std::cout << "deep tuple: " << std::make_tuple("Hello",
0.1, std::make_tuple(1,2,3,"four",5.5), 'Z')
<< std::endl;
return 0;
}

avec sortie:

deep tuple: (Hello, 0.1, (1, 2, 3, four, 5.5), Z)

Un autre, similaire à @Tony Olsson, y compris une spécialisation pour le tuple vide, comme suggéré par @Kerrek SB.

#include <tuple>
#include <iostream>
template<class Ch, class Tr, size_t I, typename... TS>
struct tuple_printer
{
static void print(std::basic_ostream<Ch,Tr> & out, const std::tuple<TS...> & t)
{
tuple_printer<Ch, Tr, I-1, TS...>::print(out, t);
if (I < sizeof...(TS))
out << ",";
out << std::get<I>(t);
}
};
template<class Ch, class Tr, typename... TS>
struct tuple_printer<Ch, Tr, 0, TS...>
{
static void print(std::basic_ostream<Ch,Tr> & out, const std::tuple<TS...> & t)
{
out << std::get<0>(t);
}
};
template<class Ch, class Tr, typename... TS>
struct tuple_printer<Ch, Tr, -1, TS...>
{
static void print(std::basic_ostream<Ch,Tr> & out, const std::tuple<TS...> & t)
{}
};
template<class Ch, class Tr, typename... TS>
std::ostream & operator<<(std::basic_ostream<Ch,Tr> & out, const std::tuple<TS...> & t)
{
out << "(";
tuple_printer<Ch, Tr, sizeof...(TS) - 1, TS...>::print(out, t);
return out << ")";
}