CODEWITHSUNDEEP
c++filelogging
noddy
noddy

Reputation: 1010

Writing a Log file in C/C++

I want to write a log file in C++. I am processing certain things and thus I need to maintain a log of the properties of the things that I process so that I could revert back to this log file to see the properties of anything that interests me in particular... Could someone help me in achieving this?

Upvotes: 31

Views: 131427

Answers (6)

jamlee
jamlee

Reputation: 1353

#include<string>
#include <fstream>

inline std::string getCurrentDateTime( std::string s ){
    time_t now = time(0);
    struct tm  tstruct;
    char  buf[80];
    tstruct = *localtime(&now);
    if(s=="now")
        strftime(buf, sizeof(buf), "%Y-%m-%d %X", &tstruct);
    else if(s=="date")
        strftime(buf, sizeof(buf), "%Y-%m-%d", &tstruct);
    return  std::string(buf);
};

inline void Logger(std::string logMsg){
    std::string filePath = "./log_"+getCurrentDateTime("date")+".txt";
    std::string now = getCurrentDateTime("now");
    std::ofstream ofs(filePath.c_str(), std::ios_base::out | std::ios_base::app );
    ofs << now << '\t' << logMsg << '\n';
    ofs.close();
}

For example:

Logger("JAMLEE: ---------| start VT_SETMODE");

Upvotes: 1

Streamsoup
Streamsoup

Reputation: 884

This is quite handy; just plug into, e.g., some common header file to be called from anywhere in the program (a better approach would be to form a class with these functions)

inline string getCurrentDateTime( string s ){
    time_t now = time(0);
    struct tm  tstruct;
    char  buf[80];
    tstruct = *localtime(&now);
    if(s=="now")
        strftime(buf, sizeof(buf), "%Y-%m-%d %X", &tstruct);
    else if(s=="date")
        strftime(buf, sizeof(buf), "%Y-%m-%d", &tstruct);
    return string(buf);
};
inline void Logger( string logMsg ){

    string filePath = "/somedir/log_"+getCurrentDateTime("date")+".txt";
    string now = getCurrentDateTime("now");
    ofstream ofs(filePath.c_str(), std::ios_base::out | std::ios_base::app );
    ofs << now << '\t' << logMsg << '\n';
    ofs.close();
}

Usage: Logger("This is log message"); Writes a file (or appends existing file)

/somedir/log_2017-10-20.txt

with content:

2017-10-20 09:50:59 This is log message

Upvotes: 34

johnwbyrd
johnwbyrd

Reputation: 3758

You also might want to consider https://github.com/johnwbyrd/logog . It's a performance-oriented C++ logging system. However, if that's a little too intense for your project, good old cerr and cout work fine for this.

Upvotes: 0

user360907
user360907

Reputation:

The sort of thing you're trying to do is too in-depth to provide a complete solution on stack overflow. What you can do is check out the documentation for the logging library of your choice. In my case, that's Boost.Log, a logging library for the Boost C++ libraries the documentation for which can be found here.

It's pointed out at the bottom of the page I've just linked to that

This library is not an official part of Boost libraries collection although it has passed the review and is provisionally accepted. The review result is available here.

so make of that what you will.

Upvotes: 5

V.S.
V.S.

Reputation: 3004

The standard method of logging (in my experience) is to use either the stdout or stderr streams. In C++ to use these you would need to include iostream, and use as below:

#include <iostream>

int main(int argc, char* argv[])
{
  using std::cout;
  using std::cerr;
  using std::endl;

  cout << "Output message" << endl;
  cerr << "Error message" << endl;
}

This, however, only achieves printing to those outputs, which usually end up at a terminal. If you want to use these standard stream methods (which are quite readable) to output to a file, then you have to redirect your output somehow. One way of doing this is by using the freopen function, provided by cstdio. What this does is open a file, and moves a given stream to that file. See here for documentation. An example would be:

#include <iostream>
#include <cstdio>

int main(int argc, char* argv[])
{
  using namespace std;
  freopen( "output.txt", "w", stdout );
  freopen( "error.txt", "w", stderr );

  cout << "Output message" << endl;
  cerr << "Error message" << endl;
}

(I've changed to using namespace std; there just for conciseness.)

You're moving the standard output stream stdout (which is used by cout) to output.txt (in write mode), and you're moving stderr (which is used by cerr) to error.txt also in write mode.

Hopefully this does the trick.

Upvotes: 58

razlebe
razlebe

Reputation: 7144

Why not use one of the many logging frameworks available, like Apache log4cxx? I would suggest this rather than attempting to roll your own - why re-invent the wheel?

Upvotes: 4

Related Questions