是否有合法的方法来使用运算符＆lt;＆lt;？来打印元组和对？
我有一组模板/函数允许我打印一个元组/对，假设元组/对中的每个类型都为它定义了
operator<<
operator<<
std
operator<<
namespace std{}namespace tuples {
using ::std::tuple;
using ::std::make_tuple;
using ::std::get;
namespace detail {
template< typename...args >
size_t size( tuple<args...> const& )
{
return sizeof...(args);
};
template<size_t N>
struct for_each_ri_impl
{
template<typename Func, typename Tuple>
void operator()(Func func, Tuple const& arg)
{
for_each_ri_impl<N-1>()(func, arg );
func( get<N>( arg ), size(arg) - N - 1 );
}
};
template<>
struct for_each_ri_impl<0>
{
template<typename Func, typename Tuple>
void operator()(Func func, Tuple const& arg)
{
func( get<0>( arg ), size(arg) - 1 );
}
};
}//detail
template<typename Func, typename ... Args>
void for_each_ri( tuple<Args...>const& tup, Func func )
{
detail::for_each_ri_impl< sizeof...(Args)-1>()( func, tup );
}
struct printer {
std::ostream& out;
const std::string& str;
explicit printer( std::ostream& out=std::cout, std::string const& str="," ) : out(out), str(str) { }
template<typename T>void operator()(T const&t, size_t i=-1) const { out<<t; if(i) out<<str; }
};
//Should this next line go into namespace std? Is there another way?
template<typename ... Args>
std::ostream& operator<<(std::ostream& out, std::tuple< Args... > const& tup)
{
out << '[';
tuples::for_each_ri( tup, tuples::printer(out,", ") );
return out << ']';
}
} //tuples
//Edits --
int main()
{
using namespace std;
cout<<make_tuple(1,'a',"Hello")<<endl;
return 0;
}
没有找到相关结果
已邀请:
2 个回复
校勒魏寡
template< typename ...VA_ARGS > struct format_tuple { typedef tuple<VA_ARGS...> tuple_type; // any format variables const tuple_type & tup; format_tuple( const tuple_type& t): tup(t) {} }; template< typename ...VA_ARGS > format_tuple<VA_ARGS...> makeFormatTuple( const tuple<VA_ARGS...> & t ) { return format_tuple( t ); } template<typename ...VA_ARGS> std::ostream& operator<<( std::ostream& os, const format_tuple<VA_ARGS...> & ft ) { // original implementation }template<typename T1, typename T2, typename T3> class format_tuple_3; //etc template<typename T1, typename T2, typename T3> format_tuple_3<T1, T2, T3> makeFormatTuple( tuple<T1,T2,T3> const&); //etc泻伴墓荒
namespace kitsune_ymg { // Op<< overloads here. // Your "normal" stuff. void normal_stuff() { std::cout << std::pair<int, int>(42, 3); }namespace kitsune_ymg { namespace tuples { // Op<< overloads here. } using namespace tuples; // Your "normal" stuff. } namespace completely_separate_project { using kitsune_ymg::tuples; // Now you can use those op<< overloads in this scope, too. void perfectly_normal_beast() { std::cout << std::pair<int, int>(42, 3); } }