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"; 

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

這遠沒有調試過，可能還沒有編譯。

老實說？每個子流只需要一個不同的變量。無論如何，你都希望將它們手動整合到一起。