Need some advice on how to deal with the log file in my game.

The way I do things at the moment is :

#ifdef USE_LOG_FILE
   logfile << "some message about something.\n";
#endif

So the code only runs if there's a define for USE_LOG_FILE in a header somewhere.

What I'm thinking of doing instead is :-

if(use_log)
{
   logfile << "........\n";
}

Where the use_log is a variable set in the config file for the game.

This way means that the code is always run, even if it's just checking the if condition.

Is this way an acceptable way to do things ?

I prefer it because it means the log file doesn't have to get created.

Certainly. The checks aren't going to affect the game performance, and it means the logs can easily be enabled after the application has already been deployed, which is not possible when using the preprocessor method.

The only downside is that if the logs are never needed, the executable will be bigger than necessary. But the additional size is most likely insignificant, so this is a mostly moot point.

That applies to both methods.

Thanks.

This is usually done like:

#ifdef USE_LOG_FILE
#define LOG(blah) logfile<<(blah)
#else
#define LOG(blah)
#endif
...
LOG(".....\n");

Also nice. You could similarly stick that into an inlined function and have an easier time typing it; You can even use varargs to make it behave more like you'd expect a logging function to behave.

Though maybe I'm saying obvious things.

And an example in plain C:

That looks almost identical to mine, except that I add a timestamp to each line as it is written to the log.

Yeah, LennyLen, and with some changes and a macro or two you can get _LINE_ and _FILE_ in there as well. Just flex it to your own needs.

Also very useful, but not vital since you can gleam it from __FILE__ and __LINE__, is __func__. However, __func__ is C99 and MSVC calls it __FUNCTION__. Luckily, Allegro 5 is awesome and will automatically define __func__ as __FUNCTION__ for MSVC and will simply define it to "???" where not supported. I'd recommend log lines like:

__FILE__:__LINE__:__func__: Super important message

I.e.

kernel.c:1924:farbiktubennagen: Holy shit look a dog!!!!!

I like these threads. Pinned !

GCC also has __FUNCTION__ it also has __PRETTY_FUNCTION__ which helps out with C++ somewhat.

Thanks for the help guys.

I like

if(use_log)
{
   logfile << "Initialising tertiary subsystem 3.\n";
}

It's super simple.

If I have to use conditional includes then there's two versions of the program, one which can do logs and another that can't. I'd rather have one program that can do both depending on config file.

I think I'll do

LOG(x) (if(use_log) logfile << x << "\n";)

That type of #define is good, too. In fact, I'd definitely recommend that over two executables considering you want it to be enabled/disabled by the user. You could still use #define LOG(x) (use_log ? logfile << __FILE__ << ":" __LINE__ ":" << __PRETTY_FUNCTION__ << ": " << (x) : (void) 0)

I'm pretty sure that putting an if statement in parenthesis is invalid. You will have to use the tertiary operator like boolean_value ? true_execution : (void) 0, as most implementations of assert do.

The general issue of "; in macro?" is solved by a construct, seemingly ugly but fully working:
#define MYMACRO do { your stuff } while (0)

I'd imagine that the assert method would be more efficient, only because I haven't yet found an implementation of assert that uses the do {} while(0) kludge.

(Untested, but you get the idea...)

Logger null;
Logger disabled("my.log", false);
Logger log("my.log");

null << "This isn't logged anywhere.";
disabled << "This either.";
log << "This is.";

I second bamccaig, although I abstract my log even further to point to any ostream and then OutputLog() retrieves a reference.

   OutputLog() << "Write this to the log ...." << endl;

It doesn't allow for disabling the log but I usually only use the log for diagnostic purposes.