C++多写点流

Question

我想找到/实现一个支持多个写点的C++（希望stl）兼容流。以下示例很容易解释我的意思是多个书写点。假设你想用java语言生成一个源代码文件。当你得到你想要编写一行那些对特定软件包的依赖代码点 - 你可以写：

stream << "import java.applet.*;"; 

stream << "public class MyApplet extends Applet {"; 
stream << "..."; 
stream << "}"; 

注意，你可能已经定义其他类。新课程需要深入研究，但需要进口。

我知道我可以用其他方法解决这个问题。我认为这将是很酷，如果我可以用一些stl流模式来解决它。

是否提升tee某些过滤的东西，可以工作？

注：位置可以基于分析输入或在这种情况下，指定专门的类型，如果该字符串以进口开始我可以有支票或我写

stream << Import("java.applet.*); 

，其中进口是一类就是据此连载。

你的感受 - 这是值得付出的努力吗？

Answer 1

为了增加复杂性：

首先，只要使用每个你可能会想要写的地方不同的变量。然后在完成后将您放入每个流中的数据拼接在一起。

作为第二级复杂度，存储std::tuple< std::ofstream, std::ofstream, std::ofstream > straems，然后使用std::get<0>(streams)获取第一个。如果您想要名称，请使用enum { first_stream, second_stream_name, third_stream_name }并将其传递给std::get。

对于最复杂的答案......好吧，这是一团糟。

首先模板元编程的样板：

template<typename T, typename Tags, typename=void> 
struct index_of {}; 
template<typename T, template<typename...>class Pack, typename Tag0, typename... Tags> 
struct index_of<T, Pack<Tag0, Tags...>, typename std::enable_if< std::is_same<T, Tag0>::value >::type > 
: std::integral_constant< int, 0 > {}; 
template<typename T, template<typename...>class Pack, typename Tag0, typename... Tags> 
struct index_of<T, Pack<Tag0, Tags...>, typename std::enable_if< !std::is_same<T, Tag0>::value >::type > 
: std::integral_constant< int, index_of<T, Pack<Tags...> >::value + 1 > {}; 

template<typename Src, template<typename...>class Pack> 
struct copy_types {}; 

template<template<typename...>class Lhs, typename... Ts, template<typename...>class Target> 
struct copy_types< Lhs<Ts...>, Target > { 
    typedef Target<Ts...> type; 
}; 
template<typename Src, template<typename...>class Pack> 
using CopyTypes = typename copy_types<Src, Pack>::type; 

template<typename Pack, typename T> 
struct append {}; 
template<template<typename...>class Pack, typename... Ts, typename T> 
struct append<Pack<Ts...>, T> { 
    typedef Pack<Ts..., T> type; 
}; 
template<typename Pack, typename T> 
struct Append = typename append<Pack, T>::type; 

template<template<typename...>class Pack, typename T, std::size_t N> 
struct repeat { 
    typedef Append< repeat< Pack, T, N-1 >::type, T > type; 
}; 
template<template<typename...>class Pack, typename T> 
struct repeat< Pack, T, 0 > { 
    typedef Pack<> type; 
}; 
template<template<typename...>class Pack, typename T, std::size_t N> 
using Repeat = typename repeat<Pack, T, N>::type; 

现在，因为它很有趣，一个标记元组：

template<typename T, typename Tags> 
struct type_based_map; 

template<typename T, template<typename...>class Pack, typename... Tags> 
struct type_based_map< T, Pack<Tags...> > { 
    Repeat< std::tuple, T, sizeof...(Tags) > data; 
    template<typename Tag> 
    T& get() { 
    return std::get< index_of< Tag, std::tuple<Tags...> >::value >(data); 
    } 
    template<typename Tag> 
    T& get() const { 
    return std::get< index_of< Tag, std::tuple<Tags...> >::value >(data); 
    } 
    template<typename... Args, typename=typename std::enable_if< sizeof...(Args) == sizeof...(Tags) >::type > 
    explicit type_based_map(Args&&... args):data(std::forward<Args>(args)...) {} 
    type_based_map(type_based_map&&) = default; 
    type_based_map(type_based_map const&) = default; 
    type_based_map(type_based_map&) = default; 
}; 

现在，下至香饽饽。聚流：

template<typename Tag, typename U> 
struct TaggedData { 
    U&& data; 
    explicit TaggedData(U&& u):data(std::forward<U>(u)) {} 
    TaggedData(TaggedData &&) = default; 
    TaggedData(TaggedData const&) = default; 
    TaggedData(TaggedData &) = default; 
}; 
template<typename Tag> 
struct DataTagger { 
    template<typename U> 
    TaggedData<U> operator()(U&& u) const { 
    return {std::forward<U>(u)}; 
    } 
}; 

template<typename base_stream, typename Tags> 
struct tagged_stream: type_based_map< base_stream, Tags > 
{ 
    using type_based_map< base_stream, Tags >::type_based_map< base_stream, Tags >; 
}; 
template<typename base_stream, typename Tags, typename Tag, typename U> 
auto operator<<(tagged_stream<base_stream, Tags>& stream, TaggedData<Tag, U> data) 
    ->declval(stream.get<Tag>() << std::forward<U>(data.u)) 
    { return (stream.get<Tag>() << std::forward<U>(data.u)); } 

，一旦虫子被淘汰，让你的语法如下：

struct bob {}; 
struct harry {}; 
struct alice {}; 
static DataTagger<bob> Bob; 
static DataTagger<harry> Harry; 
static DataTagger<alice> Alice; 

typedef tagged_stream< std::ofstream, std::tuple<bob, harry, alice> > multi_out; 

multi_out os; 
os.get<bob>().open("bob.txt"); 
os.get<harry>().open("harry.txt"); 
os.get<alice>().open("alice.txt"); 
os << Bob(7) << " is seven in Bob\n"; 
os << Harry("hello") << " in Harry\n"; 
os << Alice(3.14) << " is baked by Alice\n"; 

这可能是也可能不是你所期待的。

这远没有调试过，可能还没有编译。

老实说？每个子流只需要一个不同的变量。无论如何，你都希望将它们手动整合到一起。