The RAII design pattern can be utilized to create simple and intuitive logging facilities, like the one we will present now. Through the useful macro LOG_FUNC, the proposed ScopeLogger will easily create function call graphs at run time, to allow easy debugging and tracking of program execution.

Here’s the implementation:

// ---- header ----

#include <string>

// Following macro is not entirely portable, but works in MSVS & GCC
#define LOG_FUNC ScopeLogger s##__LINE__(__FUNCTION__)

struct ScopeLogger {
        ScopeLogger (const std::string &str);
        ~ScopeLogger ();

    private:
        std::string indent (unsigned ind) const;

        static unsigned indent_;
        const std::string msg_;
};

// ---- source ----

#include <iostream>

unsigned ScopeLogger::indent_ = 0;

ScopeLogger::ScopeLogger (const std::string &str)
 : msg_(str) {
    std::cout << indent(indent_++) << "[+] " << msg_ << std::endl;
}

ScopeLogger::~ScopeLogger () {
    std::cout << indent(--indent_) << "[-] " << msg_ << std::endl;
}

std::string ScopeLogger::indent (unsigned ind) const {
    return std::string(ind<<1, ' ');
}

Note that, as commented above, the macro LOG_FUNC is not entirely portable; The usage of the non-standard pre-defined macro __FUNCTION__ is not guaranteed to work on every compiler, although Microsoft’s Visual Studio & GCC do support it. (GCC also supports a __PRETTY_FUNCTION__ macro which can be even more useful)

The code can be extended further: extra functionality can be added to the ScopeLogger class if needed, and compile time reliance on _DEBUG can be added (to disable output in a release build, for example).

Here’s an example of the generated call graph:

antrikot:~/work/sandbox/log> ./scopelogger.out
[+] main
  [+] run
  [-] run
  [+] work
    [+] attempt
    [-] attempt
  [-] work
  [+] attempt
  [-] attempt
  [+] run
  [-] run
[-] main

Generated by the following code:

#include "scopelogger.h"

bool run () {
    LOG_FUNC;

    static unsigned num = 1;
    return num--;
}

void attempt () {
    LOG_FUNC;
}

bool work () {
    LOG_FUNC;

    static bool state = true;
    if (state)
        attempt();
    return state -= state;
}

int main () {
    LOG_FUNC;

    while (run())
        if (!work())
            attempt();

    return 0;
}

This example only illustrates how easy using this facility actually is, whilst the generated output is just priceless for debugging or understanding execution flow.