Instantiating a Qt File-Based Logger for Debugging in a C++ Library

The following page provides a nice s开发者_运维百科imple solution for file based logging in Qt for debugging without using a larger logging framework like the many that are suggested in other SO questions.

I'm writing a library and would like to instantiate a logger that the classes in the library can use (mostly for debugging purposes). There is no int main() function since it's a library. So would the best approach be to add the instantiation into a file like logger.h and have any classes include logger.h if it would like to do qDebug() << PREFIX << "Bla" as the link above suggests?

I pretty much agree with OrcunC but I'd recommend making that ofstream a little more accessible and capable of handling the Qt value types.

Here's my recommended process:

1. Create a global QIODevice that to which everything will be written. This will probably be a QFile.
2. Create a QTextStream wrapper around that QIODevice that you'll then use for all the logging.
3. If you want something slightly more complicated, create methods that do the filtering based on log level info.

For example:

// setup the global logger somewhere appropriate
QFile *file = new QFile("your.log");
file->open(QIODevice::ReadOnly);
QTextStream *qlogger = new QTextStream(file);

And once the global logger is initialized, you could reference it as a global:

#include "qlogger.h"
//... and within some method
*qlogger << "your log" << aQtValueType;

But you might want some filtering:

#include "qlogger.h"
// lower number = higher priority
void setCurrentLogLevel(int level) {
   globalLogLevel = level;
}
QTextStream* qLog(int level) {
   if (level <= globalLogLevel) {
       return qlogger;
   }
   return getNullLogger(); // implementation left to reader
}

And then you'd likely create an enum that represented the LogLevel and do something like this:

#include "qlogger.h"
//...
setCurrentLogLevel(LogLevel::Warning);
*qLog(LogLevel::Debug) << "this will be filtered" << yourQMap;
*qLog(LogLevel::Critical) << "not filtered" << yourQString;

As you'd be dealing with globals, carefully consider memory management issues.

If you follow the method in that link, ALL messages of the application output with qCritical(), qDebug(), qFatal() and qWarning() will flow into your handler.

So be careful! You may get not only your library's trace messages but the entire QT framework's messages. I guess this is not what you really want.

Instead of this as a simple solution define a global *ofstream* in your library and use it only within your library.

whenever you write a library in c++ or c , it is best practice to declare all your methods in a .h file and define the methods/classes in a .cpp/.c file. This serves 2 purposes.

1. The .h file needs to be used to compile a 3rd party application that is using your library, and the library itself is used at link time.
2. The developer who is using your library can use the .h file as a reference to your library since it contains all the declarations.

So ,yes , you need to declare methods in a .h file and have other classes include logger.h.