如何在c ++ 11中将值输出到流的元组

Question

我正在尝试编写一个流运算符<<,它可以输出到一个std::tuple流而不是一个流.所以基本上,我试图tee用c ++ 编写Unix 命令,并且:

std::tie(std::cout,std::clog) << 1;

我试图在c ++ 11中使用可变参数模板编程递归地编写流操作符.到目前为止我所拥有的内容如下面的代码所示.但是代码没有编译,错误信息很长.

我的问题是,如何修复代码使其工作？

编译g++ -std=c++11(gcc-4.8.1)的第一条错误消息是:

test.cpp:24:33: error: no match for 'operator<<' (operand types are 'std::tuple<std::basic_ostream<char, std::char_traits<char> >&, std::basic_ostream<char, std::char_traits<char> >&>' and 'int')
   std::tie(std::cout,std::cout) << 1;

PS我搜索了SO,并且有一些关于编写复合流对象的帖子.该代码涉及很多流和streambuf的内部.我在这里寻求的是一个简单/天真的解决方案,在十几行中完成类似的任务.

谢谢

---

我的代码:

#include <iostream>
#include <tuple>

template<typename _Value, typename Head, typename ... Tail>
struct _tee_stream {
  static std::tuple<Head,Tail...>& _print(std::tuple<Head,Tail...>& _s, const _Value& _t) {
    return std::make_tuple(std::get<0>(_s) << _t ,_tee_stream<Tail...,_Value>::_print(_s,_t));
  }
};

template<typename _Value>
struct _tee_stream<_Value, std::tuple<>> {
  static std::tuple<>& _print(std::tuple<>& _s, const _Value& _t)  {
    return _s;
  }
};

template< typename _Value, typename... _TElements>
std::tuple<_TElements...>& operator<<(std::tuple<_TElements...>& _s, const _Value& _t) {
  return _tee_stream<_Value, std::tuple<_TElements...>>::_print(_s, _t);
};

int main() {
  std::tie(std::cout,std::cout) << 1; //no compile
  std::make_tuple(std::cout,std::cout) << 1; //no compile either
}

---

更新: 以下是基于@ KerrekSB的示例代码对我有用的内容:

#include <iostream>
#include <tuple>
#include <utility>
#include <fstream>


template <unsigned int N>
struct tee_stream
{
  template <typename ...Args, typename T>
  static std::tuple<Args...> & print(std::tuple<Args...> & t, T && x)
  {
    std::get<sizeof...(Args) - N>(t) << x;
    tee_stream<N - 1>::print(t, std::forward<T>(x));
    return t;
  }
};

template <>
struct tee_stream<0>
{
  template <typename ...Args, typename T>
  static std::tuple<Args...> & print(std::tuple<Args...> &, T &&) {}
};

template <typename ...Args, typename T>
std::tuple<Args...> & operator<<(std::tuple<Args...> & t, T && x)
{
  return tee_stream<sizeof...(Args)>::print(t, std::forward<T>(x));
}

template <typename ...Args, typename T>
std::tuple<Args...> & operator<<(std::tuple<Args...> && t, T && x)
{
  return tee_stream<sizeof...(Args)>::print(t, std::forward<T>(x));
}

int main()
{
  std::ofstream os("a.txt");
  auto t = std::tie(std::cout, os);
  t << "Foo" << "Bar\n";
  std::tie(std::cout, os) << "Foo" << "Bar\n";
}

http://ideone.com/fBXuvP

---

@ Jarod42,

非常感谢.您的代码比我的原型更紧凑地执行递归/循环,并修复了我的代码中引用类型的使用.原始测试用例可以在您的演示中显示.但是,如果我在流中使用std::endl(而不是"Foo")或std::ofstream(而不是std::cout),我仍然无法编译您的版本,如下面的"不正常"行所示.知道如何解决这些问题吗？

#include <iostream>
#include <fstream>
#include <tuple>

#if 1 // Not in C++11 // make_index_sequence
#include <cstdint>

template <std::size_t...> struct index_sequence {};

template <std::size_t N, std::size_t... Is>
struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};

template <std::size_t... Is>
struct make_index_sequence<0u, Is...> : index_sequence<Is...> {};

#endif // make_index_sequence

namespace detail
{
  template <typename Tuple, typename T, std::size_t...Is>
  Tuple output(const Tuple& t, const T& x, index_sequence<Is...>) {
    return Tuple{(std::get<Is>(t) << x)...};
  }
}

template <typename ...Args, typename T>
std::tuple<Args&...> operator<<(const std::tuple<Args&...>& t, const T& x) {
  return detail::output(t, x, make_index_sequence<sizeof...(Args)>());
}

int main() {
  std::ofstream os("aa.txt");
  os << "Hi" << std::endl;

  std::tie(std::cout, std::cout) << "Foo" << "Bar"; //OK
  std::tie(std::cout, std::cout) << "Foo" << "Bar" << std::endl; //not OK on endl
  std::tie(std::cout, os) << 1 << "Foo" << "Bar"; //not OK on ofstream

  return 0;
}

Answer 1

您可以使用以下内容：

#if 1 // Not in C++11 // make_index_sequence
#include <cstdint>

template <std::size_t...> struct index_sequence {};

template <std::size_t N, std::size_t... Is>
struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};

template <std::size_t... Is>
struct make_index_sequence<0u, Is...> : index_sequence<Is...> {};

#endif // make_index_sequence

// Helper. C++11 cannot use: auto f() { return foo(); }
// Usage: auto f() -> Return(foo())
#define Return(ret) decltype(ret) { return ret; }

namespace detail
{
    template <typename Tuple, typename T, std::size_t...Is>
    auto output(const Tuple& t, const T& x, index_sequence<Is...>) ->
    Return (std::tie(std::get<Is>(t) << x...))
}

template <typename ...Args, typename T>
auto operator<<(const std::tuple<Args&...>& t, const T& x) ->
Return(detail::output(t, x, make_index_sequence<sizeof...(Args)>()))

活生生的例子