我的目标是要有几个流。您可以在下面查看工作代码。
我正在尝试使用可变参数模板,但失败了。下一个代码如何“变”?
有几个非常相似的变量,因此我想可以使用可变参数模板将其重写,但我不知道如何。
template<typename T>
struct IsOn
{
T *pt;
bool isOn;
IsOn(T& t, bool b):pt(&t),isOn(b) {}
};
struct tmy
{
vector<IsOn<ostream>> v0;
vector<IsOn<ofstream>> v1;
vector<IsOn<stringstream>> v2;
};
template<typename T>
tmy& operator<<(tmy& rt,T& t) {
int len;
len=rt.v0.size();
for(int i=0; i<len;++i) if(rt.v0[i].isOn) (*rt.v0[i].pt)<<t;
len=rt.v1.size();
for(int i=0; i<len;++i) if(rt.v1[i].isOn) (*rt.v1[i].pt)<<t;
len=rt.v2.size();
for(int i=0; i<len;++i) if(rt.v2[i].isOn) (*rt.v2[i].pt)<<t;
return rt;
}
int main(int argc, char** argv) {
tmy my;
my.v0.push_back(IsOn<ostream>(cout, true));
my.v0.push_back(IsOn<ostream>(cerr, false));
my.v0.push_back(IsOn<ostream>(clog, true));
my<<"hi twice!";
}
感谢您的尝试!
ps我知道这里存在boost::tee,但是我有稍微不同的问题,可以在这里阅读:How to declare an "implicit conversion" in a variadic template?
最佳答案
好的,我有两件事可以解决,但我认为这没有什么意义:
#include <iostream>
template<typename ... Streams>
struct StreamCont
{
};
template<typename Stream>
struct StreamCont<Stream>
{
Stream & stream;
StreamCont(Stream & st) : stream(st) {};
};
template<typename Stream, typename ... Next>
struct StreamCont<Stream, Next...>
{
Stream & stream;
StreamCont<Next...> next;
StreamCont(Stream & st, Next&... next) : stream(st), next(next...) {};
};
template<typename Stream, typename Arg>
StreamCont<Stream>& operator<<(StreamCont<Stream> & str, Arg arg)
{
str.stream << arg;
return str;
};
template<typename ... Streams, typename Arg>
StreamCont<Streams...>& operator<<(StreamCont<Streams...> & str, Arg arg)
{
str.stream << arg;
str.next << arg;
return str;
};
/* std::endl signature:
template< class CharT, class Traits >
std::basic_ostream<CharT, Traits>& endl( std::basic_ostream<CharT, Traits>& os );
so this only works if all streams are equal
*/
template<typename Stream>
StreamCont<Stream>& operator<<(StreamCont<Stream> & str, Stream&(*func)(Stream&) )
{
func(str.stream);
return str;
};
template<typename First, typename ... Streams>
StreamCont<First, Streams...>& operator<<(StreamCont<First, Streams...> & str, First&(*func)(First&) )
{
func(str.stream);
str.next << func;
return str;
};
int main()
{
StreamCont<std::ostream, std::ostream, std::ostream>
multi_stream(std::cout, std::cerr, std::clog);
multi_stream << 42 << std::endl;
return 0;
}
对数组执行相同的操作可能更有意义,即:
#include <iostream>
#include <array>
template<typename Stream, size_t Size, typename Arg>
std::array<Stream*, Size>& operator<<(std::array<Stream*, Size>& str, const Arg &arg)
{
for (auto s : str)
*s << arg;
return str;
};
template<typename Stream, size_t Size>
std::array<Stream*, Size>& operator<<(std::array<Stream*, Size>& str, Stream& (*func)(Stream&))
{
for (auto s : str)
*s << func;
return str;
};
int main()
{
std::array<std::ostream*, 3> strs = {&std::cout, &std::cerr, &std::clog};
strs << 42 << std::endl;
return 0;
}
希望能有所帮助,我不知道您是否可以编写一个自定义的ostream重载(请参见boost.iostreams),而仅使用stream_bufs并将它们组合到您的自定义类中是否更好。