struct vec3f_t
{
    vec3f_t(float x, float y, float z)
        :x(x), y(y), z(z)
    {
    }
    float x, y, z;
};

template <class T>
text_print::text_out_t<T> &operator <<(text_print::text_out_t<T> &to, const vec3f_t &in_vec)
{
    return to << '(' << in_vec.x <<',' << in_vec.y <<',' << in_vec.z <<')';
}

#include <iostream>

int main()
{
    char buf[1000];
    vec3f_t v(1, 2, 3);
    text_print::text_out(buf) << "hello" <<',' <<' ' <<"world" <<v << 1 <<1U <<-1ULL <<-1LL <<'\0';
    printf("[%s]\n", buf);
    
    std::string str;
    text_print::text_out(std::back_inserter(str)) << "hello" <<',' <<' ' <<"world" <<v;
    std::cout << str <<std::endl;

std::cout
 << std::boolalpha << std::dec << std::fixed << std::hex << std::internal 
 << std::left << std::oct << std::right << std::scientific << std::showbase 
 << std::showpoint << std::showpos << std::skipws << std::unitbuf 
 << std::uppercase << std::adjutfield << std::basefield << std::floatfield 
 <<1;

для типа double

<<left  (text_print::f(1.123, 4, 20))
<<center(text_print::e(1.123, 4, 20))
<<right (text_print::g(1.123, 4, 20))
  |                  | |      |  ^в поле шириной 20
  |                  | |      ^четыре знака после запятой
  |                  | ^что распечатываем
  |                  ^в "%g/%e/%f" формате
  ^выронять слева/посередине/справа. Префикса "text_print", так как koenig lookup
  
для целых:
<<sign("-", " ", "+", (text_print::x(12345, 10, 20)))
<<sign("-", "+", "+", (text_print::o(12345, 10, 20)))
<<sign("-", "", "",   (text_print::d(12345, 10, 20)))
  |                                  |      |   ^поле шириной 20
  |                                  |      ^дополнить до 10 символов нулями
  |                                  ^что печатаем
  ^как ставим знак перед отрицательным, нулем, положительным?

MyDoubleFormater        dfmt( 4, 20 );

Или

MyDoubleFormater        dfmt;

dfmt << frac(4) << width( 20 ) << left;

std::cout << text_print::f( 1.123, dfmt );

Можно предусмотреть и такую возможность 

std::cout << dfmt << text_print::f(1.123);

T_B>А чем плох, скажем, boost::format (+std::cout)?

Здравствуйте, CyberZX, Вы писали:

CZX>>Кстати, строки и работа с текстом больная тема в С++. Не хватает быстрой, удобной и безопасной библиотеки.
CZX>тема вполне здоровая. всего хватает.

std::streams
безопасность
отлично!(compile-time)

удобство
плохо(как с std::ostring stream написать printf("%+10.4f %d %d %d %d %08x\n", 1.123f, 1, 2, 3, 4, address);?

эффективность
плохо

расширямость
отлично

boost::format

безопасность
хорошо (кидает исключения при неверном format string)

удобство
отлично

эффективность
ужасно

расширямость
отлично

printf family

безопасность
отвратительно.
(но хороший компилятор, вроде ICC/GCC делают предупреждения при неверном format string в compile-time, в отличие от boost::format).

удобство
хорошо
Большой жирный минус – нельзя вводить пользовательские типы

эффективность
хорошо. Если пишем не http сервер, жить можно.

расширямость
нету.

Здравствуйте, CyberZX, Вы писали:

CZX>boost::format, string_stream, boost::lexical_cast/istream
* _Winnie стошнило *
std :: streams — самая одиозная, неоднозначная, неэффективная часть стандартной библиотеки. boost::format и lexical_cast основаны на ней.

(шепотом) Ты же не вызываешь boost::formst/lexical_cast/stringstream на каждом кадре, например для вывода FPS или жизней?
Вот попробуй небольшое упражнение.

Напиши программу.

int main()
{
    std::string s = str(boost::format("%d") % 1);
}

Протрассируй в asm все иструкции с зажатой клавишей F11. Лично у меня терпения не хватило.
Попробуй протрассировать хотя бы только С/С++(с заходом во все функции). Потом отчитаешься, сколько минут на это ушло. И ты увидишь только часть этого отвратительного, жирного, ненужного, омерзительного кода.
Кстати, в Страуструпе тоже есть такое упражнение.

Даже в .NET скорость форматирования строки в 3 раза быстрей. Это ж надо умудриться так испоганить самый мощный и эффективный язык.
System::String *str = System::String::Format("{0}", __box(1));

* _Winnie пошел за другим тазиком *

std::fstream — единственная "буферизирующая" (смешно, нелепо и печально) в своем роде библиотека ввода/вывода, посимвольный ввод/вывод в которой работает медленней, чем жесткий диск! Обычно говорят, что скорость ввода лимитируется механикой жесткого диска. Мда. std::fstream показывает что навороченная типобезопасная абстрация может тормозить медленней, чем механический жесткий диск.
Дельфисты будут над нами смеяться! Програмисты на Йава и .НЕТ тоже.

Кстати, по ходу дела нашел того самого Шлемиля из статьи —

        for (i =0; i<n; i++)
        {
            strcat(outstr, va_arg(substr, char *));
        }

std::ostream str;
...
str<<btl::fmt_begin()<<btl::fmt("Text %_1, %2, 
%3",11,12,13)<<btl::fmt_end();

struct my_struct {
    int x;
    double y;
    std::string name;
};
stdfuture::ostream& operator<<(stdfuture::ostream& os, const my_struct ms) {
    return os << ms.x << ms.y << ms.name;
}
...
    cout << my_struct();
    ASNstream asn;
    asn << my_struct();
    XDRstream xdr;
    xdr << my_struct();

typedef double Coordinate;

class FormatCoordinate
{
private:
  Coordinate c;
public:
  explicit FormatCoordinate(Coordinate c)
  : c_(c)
  {}

  template <typename CharT, typename TraitsT>
  friend std::basic_ostream<CharT, TraitsT>& 
  operator<<(std::basic_ostream<CharT, TraitsT>& o, const FormatCoordinate& f)
  {
    boost::io::basic_ios_all_saver<CharT, TraitsT> saver(o);
    return o << std::setprecision(4) << f.c_;
  }
};

class Vector3d
{
private:
  Coordinate x_, y_, z_;
public:
  // skipped
  Coordinate x() const;
  Coordinate y() const;
  Coordinate z() const;
};

class FormatVector3d
{
private:
  const Vector3d& v_;
public:
  explicit FormatVector3d(const Vector3d& v)
  : v_(v), separator_(listSeparator)
  {}

  template <typename CharT, typename TraitsT>
  friend std::basic_ostream<CharT, TraitsT>& 
  operator<<(std::basic_ostream<CharT, TraitsT>& o, const FormatVector3d& f)
  {
    return o << "(" <<
      FormatCoordinate(f.v_.x()) << ", " <<
      FormatCoordinate(f.v_.y()) << ", " <<
      FormatCoordinate(f.v_.z()) << ")";
  }
};

C>typedef double Coordinate;

C>class FormatCoordinate
C>{
C>private:
C>  Coordinate c;
C>public:
C>  explicit FormatCoordinate(Coordinate c)
C>  : c_(c)
C>  {}

C>  template <typename CharT, typename TraitsT>
C>  friend std::basic_ostream<CharT, TraitsT>& 
C>  operator<<(std::basic_ostream<CharT, TraitsT>& o, const FormatCoordinate& f)
C>  {
C>    boost::io::basic_ios_all_saver<CharT, TraitsT> saver(o);
C>    return o << std::setprecision(4) << f.c_;
C>  }
C>};
C>

C>class Vector3d
C>{
C>private:
C>  Coordinate x_, y_, z_;
C>public:
C>  // skipped
C>  Coordinate x() const;
C>  Coordinate y() const;
C>  Coordinate z() const;
C>};

C>class FormatVector3d
C>{
C>private:
C>  const Vector3d& v_;
C>public:
C>  explicit FormatVector3d(const Vector3d& v)
C>  : v_(v), separator_(listSeparator)
C>  {}

C>  template <typename CharT, typename TraitsT>
C>  friend std::basic_ostream<CharT, TraitsT>& 
C>  operator<<(std::basic_ostream<CharT, TraitsT>& o, const FormatVector3d& f)
C>  {
C>    return o << "(" <<
C>      FormatCoordinate(f.v_.x()) << ", " <<
C>      FormatCoordinate(f.v_.y()) << ", " <<
C>      FormatCoordinate(f.v_.z()) << ")";
C>  }
C>};
C>

template <class T>
text_print::text_out_t<T> &operator <<(text_print::text_out_t<T> &to, const vec3f_t &in_vec)
{
    return to << '(' << in_vec.x <<',' << in_vec.y <<',' << in_vec.z <<')';
}

C>А хотеть выводить Vector3d с разной шириной и разной точностью для каждой компоненты не надо. Это неизящно