Normally when I write programs - especially daemons, like Crossroads - I make sure that I implement a layered logging facility. For example: errors and warnings are always logged, informational messages only when flag -v is used, and debug messages only when flag -d is used. Standard approach, right?

A likely C way to implement this, might be to have functions errormsg(), warningmsg() and so on. Inside the "verbose information" function, a flag is inspected to see whether -v was given on the command line. To illustrate:

void verbosemsg(char const *fmt, ...) {
    if (! flag_verbose)
        return;

    .
    . /* Here the message is actually output, e.g. using
    .  * va_start(), vprintf(), va_end()
    .  */
    .
}

/* Example of calling code */
verbosemsg ("Running at PID %d\n", getpid());

So far so good, except that Crossroads isn't a C program, but a C++ program. So, keeping in mind "good C++ style", a printf-like approach is a big no-no, right? Ok, let's then try a true OO-approach. I've illustrated some concepts in the following code. It's a bit lengthier (because it's a working piece of code), and defines a helper class msgstring, so that it's possible to append an integer to a string. The msgstring is output in class verbosemsg.

#include <iostream>
#include <sstream>
#include <string>

using namespace std;

// msgstring is derived from string, to enable "+ int"
// Other appending operators can be added ad lib.
class msgstring: public string {
public:
    // Start with a simple char*
    msgstring(char const *s): string(s) {
    }

    // Or with a string
    msgstring(string const &s): string(s) {
    }

    // Concatenation with an int
    msgstring const &operator+ (int i) {
	ostringstream o;
	o << i;
	*this += o.str();
	return *this;
    }
};

// for testing:
bool flag_verbose = true;

class verbosemsg {
public:
    // Constructor that outputs info when flag_verbose is true
    verbosemsg (msgstring const &s) {
	if (flag_verbose)
	    cout << s;
    }
};

// main() to test it all
int main() {
    verbosemsg (msgstring("Hello World!\n"));
    int i = 42;
    verbosemsg (msgstring("The answer is.. ") + i + "\n");
    return 0;
}

But here's the catch. When no verbose messages are generated, then the overhead in the C version is: one call, one if. The overhead in the C++ version is way bigger: the entire message must be constructed, overloaded + operators are called to concatenate information, and that object is passed via reference to verbosemsg. Only then is the if condition evaluated. The result? The C++ code is much slower. Really.

So now what? It's quite a pickle. I see the following options:

• Populate the C++ code with if-statements that prevent the overhead when flag_verbose is false. The evaluation of the flag would then not occur inside verbosemsg but in the calling code, which might look like:

  // main() to test it all
  int main() {
      if (flag_verbose)
          verbosemsg (msgstring("Hello World!\n"));
  
      int i = 42;
  
      if (flag_verbose)
          verbosemsg (msgstring("The answer is.. ") + i + "\n");
  
      return 0;
  }
      

  Yech! The whole idea of isolating flag_verbose inside verbosemsg was to avoid having if-conditions all over the place!
• Use the plain-old printf() style messaging, such as the C function void verbosemsg(char const *fmt, ...) that is shown at the top.

  This isn't OO-ish, it isn't type-safe (though gcc does a fine job of warning against a mismatch between the format string and remaining arguments), but -- it's fast.

Upon reading the above, Eddie wrote me to point out that the construct if(condition) generateoutput(string + string ...) is very common in Java, to make sure that logging doesn't hog up too many resources. He further remarked that it's a shame that Java doesn't have preprocessing. Else, one could wrap the whole thing in a macro.

Thinking about it: yes, that's pretty usable. It moves the if-condition into the caller's code without the necessity to type the if-statement all the time. So here's a quick and dirty illustration of the concept. May the source be with you.

#include <iostream>
#include <sstream>
#include <string>

using namespace std;

/* Class Mstr: derived from string to allow for overloading '+'
 * which handles concatenation of the string with other types
 */
class Mstr: public string {
public:
    Mstr(string s): string(s) {}
    Mstr(char const *s): string(s) {}
    Mstr const &operator+ (int i) {
	ostringstream o;
	o << i;
	*this += o.str();
	return *this;
    }
};

/* Class Msg: encapsulates the on/off state of the verbose flag,
 * and defines a method msg() that outputs an Mstr. Caller must
 * wrap the msg() call in a if-condition that tests Msg::on().
 */
class Msg {
public:
    static void msg (Mstr const &m) {
	cout << m;
    }
    static void on(bool o) {
	enabled = o;
    }
    static bool on() {
	return enabled;
    }
private:
    static bool enabled;
};
bool Msg::enabled = false;

/* For easy usage:
 * Macro verbosemsg() handles the if-condition of Msg::on()
 * and optionally calls Msg::msg() to generate output
 */
#define verbosemsg(x) if (Msg::on()) Msg::msg(x)

/* And of course, main() to test it with a couple of
 * verbose statements. */
int main() {
    Msg::on(true);
    
    verbosemsg("Hello World!\n");
    for (int i = 1; i < 5; i++)
	verbosemsg(Mstr("Loop: ") + i + "\n");

    return 0;
}