我有一个我希望能够流式传输的对象。但是我希望能够通过使用不同的格式以不同的方式流式传输它，或者我应该说描述这个对象的方式。我想知道这应该如何用流来解决。
我想要的是能够使用通用格式并使用某种格式适配器将通用格式转换为首选格式。
我还希望能够将格式与 Item 的实现分开，这样我就不必每次添加或更改新格式时都更改 Item。
这段代码大致说明了我想要什么。
Item item;
std::cout << "generic formatted:" << item;
std::cout << "custom formatted:" << CustomItemFormat() << item;
但这可能不可行或不切实际。
面对此类问题，流式库打算如何使用？
【问题讨论】：
IOStreams 不是很适合这种情况，但您可以使用格式库，例如 {fmt}，它提供了更好的可扩展性。例如：
struct Item {
int value;
};
template <>
struct fmt::formatter<Item> {
enum format { generic, custom };
format f = generic;
constexpr auto parse(parse_context &ctx) {
auto it = ctx.begin(), end = ctx.end();
if (it == end) return it;
if (*it == 'g') f = generic;
else if (*it == 'c') f = custom;
else return it;
return ++it;
}
template <typename FormatContext>
auto format(const Item& item, FormatContext &ctx) {
return format_to(ctx.out(), f == generic ? "{}" : "{:x}", item.value);
}
};
然后你可以使用Item对象和任何格式化函数，例如print：
fmt::print("{}", Item{42}); // Default generic format - value formatted as decimal
fmt::print("{:g}", Item{42}); // Explicit generic format
fmt::print("{:c}", Item{42}); // Custom format - value formatted as hex
免责声明：我是 {fmt} 的作者。
【讨论】：
尝试使用 Visitor 设计模式：
struct Object_Writer_Interface
{
virtual void write_member_i(int value) = 0;
virtual void write_member_c(char value) = 0;
};
struct Object
{
int i;
char c;
void write(Object_Writer_Interface * p_writer)
{
if (p_writer)
{
p_writer->write_member_i(i);
p_writer->write_member_c(c);
}
}
};
struct Stream_Object_Writer
: public Object_Writer_Interface
{
Stream_Object_Writer(std::ostream& out)
: m_out(out)
{ ; }
void write_member_i(int value)
{
m_out << i << '\n';
}
void write_member_c(char c)
{
m_out << "'" << c << "'\n";
}
std::ostream& m_out;
};
int main(void)
{
Object o;
o.i = 5;
o.c = 'M';
// Create a writer for std::cout
Stream_Object_Writer writer(std::cout);
// Write the object to std::cout using the writer
o.write(&writer);
return EXIT_SUCCESS;
}
使用这种设计，要将对象写入套接字，您需要从Object_Writer_Interface 派生一个类来处理套接字。同样，如果您想序列化对象。
我目前正在使用这种技术将对象写入 GUI 列表框、数据库记录和 Xml 文件。与重载operator << 的技术不同，我在开发新的Writers 时不必修改原理类。
【讨论】：
operator << 和上述设计都必须更改。这种设计的重点是新的 Writers 不会导致 Object 与 operator << 方法发生变化。如果不是，请给出 C++ 实现的示例。
我个人会写一套格式化程序。
格式化程序必须知道他们正在格式化的对象的内部结构
但让他们成为朋友应该没什么大不了的。
class X
{ friend std::ostream& operator<<(std::ostream& str,XML_Format const& formatter);
friend std::ostream& operator<<(std::ostream& str,Json_Format const& formatter);
friend std::ostream& operator<<(std::ostream& str,Fred_Format const& formatter);
public: int value() const {return 5;}
};
struct XML__Foram { X const& print; XML_Format(X const& v): print(v) {} };
struct Json_Format { X const& print; Json_Format(X const& v): print(v) {} };
struct Fred_Format { X const& print; Fred_Format(X const& v): print(v) {} };
std::ostream& operator<<(std::ostream& str,XML_Format const& formatter)
{
return str << "<XObj>" << formatter.print.value() << "</XObj>";
}
std::ostream& operator<<(std::ostream& str,Json_Format const& formatter)
{
return str << "{XObj:{" << formatter.print.value() << "}}";
}
std::ostream& operator<<(std::ostream& str,Fred_Format const& formatter)
{
return str << "Killl Kill Kill. Friday 13th";
}
int main()
{
X obj;
std::cout << XML_Format(obj) << std::endl;
}
【讨论】：
friend，而是使用Visitor 模式并创建自定义Writers。因此，无需为每种新格式添加新的operator <<，我只需从 Writer 接口派生即可。因此我没有修改工人阶级。
我想得越多，我开始怀疑我是否以错误的方式接近这个问题。也许我应该有一个通用的格式接口并设置项目的格式，以便项目可以使用这种格式输出自己。
这有意义吗？
【讨论】：
您需要编写一个流操纵器，它将信息存储在流中，然后由operator<<(std::ostream&,const Item&) 使用。请参阅this 答案的开头了解如何将用户数据存储在流中。
【讨论】：
Item.CustomItemFormat() 有什么不好？
另外还有一些旨在解决这个问题的设计模式，即访问者模式。
你也可以有 CustomItemFormat(Item)？
我不认为让流来解决这个问题是正确的方向，你应该把展示自己的任务委托给 Item 类
【讨论】：
是的，有可能，您正在寻找的神奇词是流manipulators。
看看这个问题：C++ custom stream manipulator that changes next item on stream
【讨论】：