C++多个写入点流
C++ Multiple writing points stream
我想找到/实现一个支持多个写点的c++(希望是stl)兼容流。我所说的多个写作点的意思很容易通过下面的例子来解释。假设您想要生成一个源代码文件,比如用java语言。当你想写一行依赖于特定包的代码时,你可以写:
stream << "import java.applet.*;";
stream << "public class MyApplet extends Applet {";
stream << "...";
stream << "}";
请注意,您可能已经定义了其他类。新类需要转到底部,但导入需要转到顶部。
我知道我可以用其他方法解决这个问题。不过,我认为如果我能用一些stl流模式来解决它,那会很酷。
带过滤功能的boost tee能起作用吗?
注意:位置可以基于分析输入或指定专用类型。在这种情况下,我可以检查字符串是否以import开头,或者我是否要写
stream << Import("java.applet.*);
其中Import是一个相应序列化的类。
你觉得这值得付出努力吗?
按照复杂性增加的顺序:
首先,只需为你可能想写的每个地方使用不同的变量。然后在完成后将放入每个流中的数据缝合在一起。
作为第二个复杂度级别,存储一个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 Bobn";
os << Harry("hello") << " in Harryn";
os << Alice(3.14) << " is baked by Alicen";
这可能是你想要的,也可能不是你想要的。
这还远远没有调试好,可能还没有编译。
老实说?只是每个子流有一个不同的变量。无论如何,您都需要在最后手动将它们重新集成在一起。
- C++将浮点指针值舍入为小数位数
- 浮点定向舍入和优化
- 根据浮点符号对浮点进行舍入的最简单方法是什么
- 浮点数学运算后舍入不一致
- 将浮点值向上舍入为整数,这有多可靠
- 浮点舍入不正确
- 如何将整数位放入浮点
- C++将一些浮点值放入字符串中
- 将浮点数舍入为预定义点的常规网格
- 浮点计算和舍入
- 如何在 +、-、* 和 / 中舍入误差后计算浮点精度
- C++从.txt读取浮点值,并将它们放入未知大小的 2D 数组中
- C++ 将特殊浮点值舍入为整数
- 浮点舍入,将0.5舍入为0
- 浮点舍入
- 将浮点转换为无符号短整型时出现舍入问题
- 浮点到双精度转换的舍入误差
- 如何在第 "." 点之后将数字放入数组中
- 将任意长度的浮点值舍入为n位数字
- 舍入浮点值