Source: Simple File Logger (by mateandmetal)

Hi there! This is a very simple (and elegant) file logger for C++. Feel free to use it for whatever you want.

FileLogger.hpp:

#ifndef FILELOGGER_HPP
#define FILELOGGER_HPP

#include <fstream>

// Use the namespace you want
namespace ige {

    class FileLogger {

        public:


            // If you can´t/dont-want-to use C++11, remove the "class" word after enum
            enum class e_logType { LOG_ERROR, LOG_WARNING, LOG_INFO };


           // ctor (remove parameters if you don´t need them)
           explicit FileLogger (const char *engine_version, const char *fname = "ige_log.txt")
                   :   numWarnings (0U),
                       numErrors (0U)
          {

               myFile.open (fname);

               // Write the first lines
               if (myFile.is_open()) {
                  myFile << "My Game Engine, version " << engine_version << std::endl;
                  myFile << "Log file created" << std::endl << std::endl;
               } // if

          }


          // dtor
          ~FileLogger () {

             if (myFile.is_open()) {
                 myFile << std::endl << std::endl;

                // Report number of errors and warnings
                myFile << numWarnings << " warnings" << std::endl;
                myFile << numErrors << " errors" << std::endl;

                myFile.close();
            } // if

        }


        // Overload << operator using log type
        friend FileLogger &operator << (FileLogger &logger, const e_logType l_type) {

            switch (l_type) {
                case ige::FileLogger::e_logType::LOG_ERROR:
                    logger.myFile << "[ERROR]: ";
                    ++logger.numErrors;
                    break;

                case ige::FileLogger::e_logType::LOG_WARNING:
                    logger.myFile << "[WARNING]: ";
                    ++logger.numWarnings;
                    break;

                default:
                    logger.myFile << "[INFO]: ";
                    break;
            } // sw


            return logger;

        }


        // Overload << operator using C style strings
        // No need for std::string objects here
        friend FileLogger &operator << (FileLogger &logger, const char *text) {

            logger.myFile << text << std::endl;
            return logger;

        }


        // Make it Non Copyable (or you can inherit from sf::NonCopyable if you want)
        FileLogger (const FileLogger &) = delete;
        FileLogger &operator= (const FileLogger &) = delete;



    private:

        std::ofstream           myFile;

        unsigned int            numWarnings;
        unsigned int            numErrors;

    }; // class end

}  // namespace


#endif // FILELOGGER_HPP

main.cpp:

#include "FileLogger.hpp"

int main()  {

    // Create object
    ige::FileLogger myLog ("1.0.4.2", "testfile.txt");

    // Writing warnings or errors to file is very easy and C++ style
    myLog << ige::FileLogger::e_logType::LOG_WARNING << "Hey! ... This is a warning message!";
    myLog << ige::FileLogger::e_logType::LOG_ERROR << "WOW! Something really wrong is happening here!";
    myLog << "This is just a simple text";

    return 0;

}

The resulting file looks like this:

My Game Engine, version 1.0.4.2
Log file created

[WARNING]: Hey! ... This is a warning message!
[ERROR]: WOW! Something really wrong is happening here!
This is just a simple text


1 warnings
1 errors