Question

I currently have a logging system that takes a char* and var args and then uses them to do a printf. This works well with C-style strings, but I’d something that’s a little cleaner. Currently if I use std::stringstream I must create the stringstream outside of the logging system, and then use the char* to the string given by the stringstream. It looks something like this:

std::stringstream strStream;
strStream << "The value of x is: " << x;
logging::print( strStream.str().c_str() );

What I would like is to pass the paramaters into the function as if I was using them directly with a stringstream. Which would look something like this from the user’s point of view:

logging::printStream("The value of x is: " << x);

or possibly like this:

logging::printStream("The value of x is: ", x);

Is there any way to use logging in such a way that I can use a stringstream without having to create it outside of the logging system’s functions?

This is especially important because I intend to create a macro that prevents any of the function parameters from compiling in shipping builds. The macro will be useless if I have to create the stringstream outside of it and pass it in. Technically I could make a macro that does the stringstream stuff I’m talking about in this question, but that’s pretty messy as I won’t always be using stringstreams with this logging, so I would have a macro for the standard logging, and a different macro for using stringstreams that within it calls the macro for standard logging.

Answer 1

I came up with two HACK solutions, but they should work. The first doesn’t use the scope resolution operator and is safer. The second uses a noop int variable to fake out the scoping.

#define logging_printStream(token) { std::stringstream o; o << token; logging::print(o.str().c_str()); }

namespace logging { int noop; }
#define printStream(token) noop = 0; { std::stringstream o; o << token; logging::print(o.str().c_str()); }

int main(int argc, const char** argv)
{
    int i = 1;

    // MORE SAFE
    logging_printStream(i)
    logging_printStream("is this magic? " << (i ? "yes" : "no"))

    // LESS SAFE
    logging::printStream(i)
    logging::printStream("is this magic? " << (i ? "yes" : "no"))
}

---

I updated logging__printStream to logging_printStream because of 17.6.4.3.2

17.6.4.3.2 Global names [global.names]

Certain sets of names and function signatures are always reserved to the implementation:

• Each name that contains a double underscore _ _ or begins with an underscore followed by an uppercase letter (2.12) is reserved to the implementation for any use.
• Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.

I left the declaration of main alone because of 3.6.1

3.6.1 Main function [basic.start.main]

A program shall contain a global function called main, which is the designated start of the program. It is implementation-defined whether a program in a freestanding environment is required to define a main function. An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined.