Использование std :: streams для форматирования вывода

Попробуйте использовать шаблон дизайна Посетитель:

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 для обработки сокета. Точно так же, если вы хотите сериализовать Object.

В настоящее время я использую эту технику для записи объектов в списки графического интерфейса пользователя, записи базы данных и файлы Xml. В отличие от метода перегрузки operator <<, мне не пришлось изменять основной класс при разработке новых Writers.

Лично я бы написал набор средств форматирования.
Средства форматирования должны знать внутреннее устройство объекта, который они форматируют, но подружить их не должно быть большой проблемой.

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

Да, возможно, волшебное слово, которое вы ищете, - это потоковые манипуляторы.

Ознакомьтесь с этим вопросом: Пользовательский манипулятор потока C ++, который изменится следующим элемент в потоке

Вам нужно написать манипулятор потока, который хранит информацию в потоке, который затем используется operator<<(std::ostream&,const Item&). См. Начало этого ответа о том, как хранить пользовательские данные в потоке.

Что такого плохого в Item.CustomItemFormat ()?

В качестве альтернативы есть несколько шаблонов проектирования, направленных на решение этой проблемы, а именно шаблон посетителя.

У вас также может быть CustomItemFormat (Item)?

Я не думаю, что обращение к потокам для решения этой проблемы является правильным направлением, вы должны делегировать задачу демонстрации себя классу 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}.