C++ format macro / inline ostringstream

by

You’ve all pretty much nailed this already. But it’s a little challenging to follow. So let me take a stab at summarizing what you’ve said…

That difficulties here are that:

  • We are playing with a temporary ostringstream object, so taking addresses is contra-indicated.

  • Because it’s a temporary, we cannot trivially convert to an ostream object through casting.

  • Both the constructor [obviously] and str() are class ostringstream methods.
    (Yes, we need to use .str(). Using the ostringstream object directly would wind up invoking ios::operator void*(), returning a pointer-like good/bad value and not a string object.)

  • operator<<(...) exists as both inherited ostream methods and global functions. In all cases it returns an ostream& reference.

  • The choices here for ostringstream()<<"foo" are the inherited method ostream::operator<<(void* ) and the global function operator<<(ostream&,const char* ). The inherited ostream::operator<<(void* ) wins out because we can’t convert to an ostream object reference to invoke the global function. [Kudos to coppro!]

So, to pull this off, we need to:

  • Allocate a temporary ostringstream.
  • Convert it to an ostream.
  • Append data.
  • Convert it back to an ostringstream.
  • And invoke str().

Allocating: ostringstream().

Converting: There are several choices. Others have suggested:

  • ostringstream() << std::string() // Kudos to *David Norman*
  • ostringstream() << std::dec // Kudos to *cadabra*

Or we could use:

We cannot use:

  • operator<<( ostringstream(), "" )
  • (ostream &) ostringstream()

Appending: Straightforward now.

Converting back: We could just use (ostringstream&). But a dynamic_cast would be safer. In the unlikely event dynamic_cast returned NULL (it shouldn’t), the following .str() will trigger a coredump.

Invoking str(): Guess.

Putting it all together.

#define FORMAT(ITEMS)                                             \
  ( ( dynamic_cast<ostringstream &> (                             \
         ostringstream() . seekp( 0, ios_base::cur ) << ITEMS )   \
    ) . str() )

References:

.

More Related Contents:

  1. Inline functions vs Preprocessor macros
  2. Can we have recursive macros?
  3. Is there a __CLASS__ macro in C++?
  4. Foreach macro on macros arguments
  5. What does the Q_OBJECT macro do? Why do all Qt objects need this macro?
  6. C++ – enum vs. const vs. #define
  7. Printing an array in C++?
  8. How to reuse an ostringstream?
  9. Instantiate class from name?
  10. warning: format not a string literal and no format arguments
  11. Construct path for #include directive with macro
  12. How to identify platform/compiler from preprocessor macros?
  13. Is #pragma once part of the C++11 standard?
  14. Are C++ Templates just Macros in disguise?
  15. Is there a way to get function name inside a C++ function?
  16. Why do I need double layer of indirection for macros?
  17. Reason why not to have a DELETE macro for C++
  18. What is the difference between a macro and a const in C++?
  19. macro definition containing #include directive
  20. Self-unrolling macro loop in C/C++
  21. Can I redefine a C++ macro then define it back?
  22. Align cout format as table’s columns
  23. How to find out cl.exe’s built-in macros
  24. Generate include file name in a macro
  25. Problem with Macros
  26. QTableView printing
  27. Expand macro inside string literal
  28. Is there anyway to write the following as a C++ macro?
  29. What’s the difference between istringstream, ostringstream and stringstream? / Why not use stringstream in every case?
  30. How can I define a string literal on the GCC command line?

Leave a Comment