Phil Endecott wrote:
Andrey Semashev wrote:
Lars Viklund wrote: That's the key problem - it's like printf, thus makes extensibility for user-defined types difficult, if possible.
No, Boost.Format is based on iostreams internally, so it automatically makes use of any operator<< functions that have been defined for user-defined types. It is also unlike printf in that it largely ignores the actual letter in the format specifier; see the recent thread about uint8_t being formatted as a char even when %d is used, for example.
Ah, you're right. I must have messed it with some other printf-like library I dealt with. This looks like a very nice but heavy solution to me. If only it could perform at least as fast as regular stream output... I'm still finding myself using itoa & co. instead of sprintf, lexical_cast or ostringstream quite often just because it's easy and fast. I think Boost.Format performance could be noticeably higher if the value concept of the formatter was separated from the formatting functionality. This is better to be shown in example: // This creates an object that may be used like // current boost::format object and may be implemented similarly boost::formatter fmt("%1%, %2%, %3%"); fmt % a % b % c; std::cout << fmt.str(); // The "format" function returns an object of unnamed type, // which is essentially a tuple of pointers to the formatting // string and references to the arguments passed std::cout << boost::format("Hello: %1%, %2%, %3%", a, b, c); The advantage of boost::format above is that there are no additional dynamic allocations and neither format string (or its part) nor a, b or c are copied. The drawback is that the same argument may be output multiple times if its identifier is mentioned more than once in the format string. But I think, this case is quite uncommon.
All of the current formatted I/O mechanisms have their problems. I don't have any good ideas about how to fix them, but maybe variadic templates will give someone a clever idea...
With variadic templates Boost.Format could become a true formatting manipulator, taking all formatted parameters as arguments rather than by feeding operator% (see boost::format in my code snippet above). It seems to me there's too much compromise in this operator usage, and the size of the "Choices made" section tells me I'm right.