оператор перегрузки << для std :: tuple - возможные упрощения? - PullRequest
7 голосов
/ 12 февраля 2012

Я использовал ответ на вопрос SO "итерации по кортежу" , чтобы написать метод для перегрузки <<.Этот метод был протестирован и, по-видимому, корректно работает с g++ 4.7 в Debian squeeze.

Однако этот метод является своего рода обходным, поскольку кажется, что << явно не может быть создан (я нашел пост об этом здесь ).Итак, нужно определить строковый метод и затем вызвать его.У меня есть аналогичный метод для вектора, который является более прямым.У кого-нибудь есть предложения о том, как исключить дополнительный шаг создания строкового метода, используя тот же подход или иным образом?Заранее спасибо.

#include <tuple>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>

using std::ostream;
using std::cout;
using std::endl;
using std::vector;
using std::string;

// Print vector<T>.
template<typename T> ostream& operator <<(ostream& out, const vector<T> & vec)
{
  unsigned int i;
  out << "[";
  for(i=0; i<vec.size(); i++)
    {
      out << vec[i];
      if(i < vec.size() - 1)
    out << ", ";
    }
  out << "]";
  return out;
}

////////////////////////////////////////////////////////////////

// Print tuple.
template<std::size_t I = 0, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), string>::type
stringval(const std::tuple<Tp...> & t)
{
  std::stringstream buffer;
  buffer << "]";
  return buffer.str();
}

template<std::size_t I = 0, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), string>::type
stringval(const std::tuple<Tp...> & t)
{
  std::stringstream buffer;
  size_t len = sizeof...(Tp);
  if(I==0)
      buffer << "[";
  buffer << std::get<I>(t);
  if(I < len - 1)
    buffer << ", ";
  buffer << stringval<I + 1, Tp...>(t);
  return buffer.str();
}

template<typename... Tp> ostream& operator <<(ostream& out, const std::tuple<Tp...> & t)
{
  out << stringval(t);
  return out;
}

int
main()
{
  typedef std::tuple<int, float, double> T;
  std::tuple<int, float, double> t = std::make_tuple(2, 3.14159F, 2345.678);
  cout << t << endl;
}

При компиляции это дает

[2, 3.14159, 2345.68]

Ответы [ 4 ]

5 голосов
/ 12 февраля 2012

Вы можете просто передать std::ostream& в эту функцию stringval и использовать out << вместо buffer <<.

Демо

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

template <size_t n, typename... T>
typename std::enable_if<(n >= sizeof...(T))>::type
    print_tuple(std::ostream&, const std::tuple<T...>&)
{}

template <size_t n, typename... T>
typename std::enable_if<(n < sizeof...(T))>::type
    print_tuple(std::ostream& os, const std::tuple<T...>& tup)
{
    if (n != 0)
        os << ", ";
    os << std::get<n>(tup);
    print_tuple<n+1>(os, tup);
}

template <typename... T>
std::ostream& operator<<(std::ostream& os, const std::tuple<T...>& tup)
{
    os << "[";
    print_tuple<0>(os, tup);
    return os << "]";
}
3 голосов
/ 26 октября 2015

Нерекурсивное C ++ 17 -стороннее решение, основанное на выражениях свертывания (C ++ 17), индексных последовательностях (C ++ 14), лямбда-функциях и пакетах параметров шаблона (оба C ++11):

#include <tuple>
#include <iostream>
#include <ostream>
#include <utility>

template< typename F, typename ...types >
F
for_all(F f, types &&... values)
{
    (f(std::forward< types >(values)), ...);
    return std::move(f);
}

template< typename F, typename ...types, std::size_t ...indices >
F
for_all_indices(F f, std::tuple< types... > const & t, std::index_sequence< indices... >)
{
    return for_all(std::move(f), std::get< indices >(t)...);
}

template< typename first, typename ...rest > // non-nullary tuples only
std::ostream &
operator << (std::ostream & out, std::tuple< first, rest... > const & t)
{
    //return ((out << std::get< first >(t)) << ... << std::get< rest >(t)); // simply prints extracted tuple elements w/o delimiters
    out << '[';
    for_all_indices([&out] (auto const & value) { out << value << ", "; }, t, std::index_sequence_for< rest... >{});
    return out << std::get< sizeof...(rest) >(t) << ']';
}

int
main()
{
    std::cout << std::make_tuple(1, 2.F, 3.0) << std::endl;
    return 0;
}

LIVE DEMO

1 голос
/ 21 апреля 2016

Возможно, вам не нужен C ++ 17 (который еще не выпущен) для достижения нерекурсивного (на самом деле рекурсивного, но более естественного) решения. То есть вам не нужны выражения свертывания, вам нужны только последовательности индексов (C ++ 14) и пакеты параметров шаблона (C ++ 11).

#include <iostream>
#include <sstream>
#include <utility>
#include <tuple>
#include <string>

template<class T>
std::ostringstream& concat_to_stream(std::ostringstream &oss, T &&arg) {
  oss << arg;
  return oss;
}

template<class First, class ...Rest>
std::ostringstream& concat_to_stream(std::ostringstream &oss, First &&firstArg, Rest &&... restArgs) {
  oss << firstArg << ", ";
  return concat_to_stream(oss, std::forward<Rest &&>(restArgs)...);
}

template<class ...Types>
std::string concat_to_string(Types &&... args) {
  std::ostringstream oss;
  oss << '[';
  concat_to_stream(oss, std::forward<Types &&>(args)...);
  oss << ']';
  return oss.str();
}

template<class Tuple, size_t... Indices>
std::string help_concat(const Tuple &tuple, std::index_sequence<Indices...>) {
  return concat_to_string(std::get<Indices>(tuple)...);
};

template<class ...Types>
std::string tuple_to_string(const std::tuple<Types...> &tuple) {
  return help_concat(tuple, std::make_index_sequence<sizeof...(Types)>{});
};

template<class ...Types>
std::ostream &operator<<(std::ostream &os, const std::tuple<Types...> &tuple) {
  return os << tuple_to_string(tuple);
}

int main() {
  std::tuple<int, double, std::string> sample_tuple = std::make_tuple(3, 1.723, "Hi!");
  std::cout << sample_tuple << '\n'; // [3, 1.723, Hi!]
  return 0;
}

Рекурсивная часть - это часть concat_to_stream, которая довольно естественна и распространена. Ключевая часть - help_concat, которую я изучаю из Реализация std :: tuple с нуля: часть 6, tuple_cat Take 1 .

Метод заключается в использовании фиктивной переменной std::index_sequence в списке параметров для вывода size_t... Indices в списке параметров шаблона, что позволяет нам "сгладить" содержимое std::tuple в списке переменных параметров, который может быть принят с помощью функции concat_to_string.

0 голосов
/ 06 сентября 2016

Вот нерекурсивная версия, использующая std :: integer_sequence и некоторые другие связанные методы.

template<class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple_impl(std::basic_ostream<Ch,Tr>& os,
                      const Tuple& t,
                      std::index_sequence<Is...>)
{
    using swallow = int[];
    (void)swallow{0, (void(os << (Is == 0? "" : ", ") << std::get<Is>(t)), 0)...};
}

template<class Ch, class Tr, class... Args>
decltype(auto) operator<<(std::basic_ostream<Ch, Tr>& os,
                          const std::tuple<Args...>& t)
{
    os << "(";
    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
    return os << ")";
}

изначально она отсюда: http://en.cppreference.com/w/cpp/utility/integer_sequence

...