C++ Log File Class

C++ can become very
difficult to use especially with large projects where you can't see
all the variables. Here's a very simple C++ logging class that can take
logs for your software
without any effort. This will make you a better programmer as you won't have to rely on
debuggers like in
Microsoft's Visual Studio.

First you should create a project, with files like log.h and log.cpp. Let's show you the log.h
file:

#include
<fstream>

using namespace std;

class Log {

public:

Log(char*
filename);

~Log();

void Write(char*
logline);

private:

ofstream m_stream;

};

I included fstream for
ofstream (which is an
output file stream).

The logging class is called Log, it has one private (non-accessible variable by
non-class-members) member called m_stream which will be the
file stream to write our
logs.

I have 3 functions, one constructor called Log, which takes a
char pointer input filename, and a destructor ~Log to close our
file and avoid memory leaks, and finally a void Write function
which will take a logline char pointer.

Here's the log.cpp file:

#include "log.h"

Log::Log(char*
filename) {

m_stream.open(filename);

}

void Log::Write(char*
logline){

m_stream << logline
<<
endl;

}

Log::~Log(){

m_stream.close();

}

I included the log.h, then defined the implementation for the 3
functions.

The constructor will open the file delivered by filename on our
stream.

The Write function will take a string and write it to the log
using << operator, and will add a new
line (endl) to the end of each call.

~Log the destructor will close the stream.

This really helps with debugging, so now I'll demonstrate how it
can be used in a project. Of course the code can be improved so
that you write less code in your main project.

#include "log.h"

#include
<cstdlib>

int main(){

Log
*pLog = new
Log("errors.log");

pLog->Write("Going into
our loop");

for(int i
= 0; i < 10; i++){

char c[50];

sprintf(c, "Looped:
%d times", i);

pLog->Write(c);

}

return
0;

}

I created a Log class pointer, with the parameter "errors.log"
which will be my error logs file.

I call Write to write a line of errors to my log.

If you need to include integers or other variable types, it may
be an idea to use sprintf to add the integer i to a char, which you
can then write to your log.

Variadic Functions

If you want to avoid using sprintf, and just using Write with
va_list, or variadic argument lists:

pLog->Write("Looped: %d
times!", i);
// no sprintf needed!

Using the following modification to Write function, you can
create a C++ variadic
function. This should allow you to avoid using sprintf every
time.

#include
<stdarg.h>

void Log::Write(const
char* logline, ...){

va_list
argList;

char
cbuffer[1024];

va_start(argList, logline);

vsnprintf(cbuffer, 1024, logline, argList);

va_end(argList);

m_stream << cbuffer
<<
endl;

}

You can also modify it further, by adding time stamps and I have
done this.

Add the time.h and program.

void
SDRLog::Write(const char* logline, ...)
{
va_list
argList;
char
cbuffer[1024];
va_start(argList,
logline);
vsnprintf(cbuffer, 1024,
logline, argList);

va_end(argList);

char
buff[100];
time_t now =
time(0);
struct tm
*sTm;
sTm =
localtime(&now);//gmtime(&now);
strftime(buff,
sizeof(buff), "%Y-%m-%d %H:%M:%S", sTm);

m_stream
<< buff;
m_stream
<< ": ";
m_stream
<< cbuffer
<< endl;
}

now this code works well.