Jak zaimplementować wygodne logowanie bez Singletonu?

Wybrałbym proste, pragmatyczne rozwiązanie:

Chcesz rozwiązania, które będzie dostępne globalnie. W większości staram się unikać globali, ale dla drwali, spójrzmy prawdzie w oczy, to zwykle niepraktyczne.

Potrzebujemy więc czegoś , aby było dostępne globalnie.

Ale nie chcemy dodatkowego ograniczenia" może być tylko jedno", które daje singleton. Niektóre z Twoich testów jednostkowych mogą chcieć utworzyć własny prywatny rejestrator. Inni mogą chcieć zastąpić może global logger.

Więc zrób to globalnie. Zwykła, prosta zmienna globalna.

To nadal nie rozwiązuje w pełni problemu z testami jednostkowymi, co prawda, ale nie zawsze możemy mieć wszystko, czego chcemy. ;)

Jak zaznaczono w komentarzu, należy wziąć pod uwagę kolejność inicjalizacji dla globali, która w C++ jest częściowo niezdefiniowana.

W moim kodzie to generalnie nie jest problem, bo rzadko mam więcej niż jeden globalny (mój logger), i trzymam się sztywno zgodnie z zasadą nigdy nie pozwalającą globalom polegać na sobie nawzajem .

Ale to jest coś, co trzeba wziąć pod uwagę, przynajmniej.

Bardzo podoba mi się poniższy interfejs, ponieważ używa streamingu. Oczywiście możesz dodać do niego kanały, czas i informacje o wątku. Innym możliwym rozszerzeniem jest użycie makr __FILE__ i __LINE__ i dodanie ich jako parametrów do konstruktora. Możesz nawet dodać zmienną funkcję szablonu, jeśli nie podoba Ci się składnia strumienia. Jeśli chcesz zapisać jakąś konfigurację, możesz dodać ją do niektórych zmiennych statycznych.

#include <iostream>
#include <sstream>

class LogLine {
public:
    LogLine(std::ostream& out = std::cout) : m_Out(out) {}
    ~LogLine() {
        m_Stream << "\n";
        m_Out << m_Stream.rdbuf();
        m_Out.flush();
    }
    template <class T>
    LogLine& operator<<(const T& thing) { m_Stream << thing; return *this; }
private:
    std::stringstream m_Stream;
    std::ostream& m_Out;
    //static LogFilter...
};

int main(int argc, char *argv[])
{
    LogLine() << "LogLine " << 4 << " the win....";
    return 0;
}

// file ILoggerImpl.h 

struct ILoggerImpl
{
    virtual ~ILoggerImpl() {}
    virtual void Info(std::string s) = 0;
    virtual void Warning(std::string s) = 0;
    virtual void Error(std::string s) = 0;
};


// file logger.h //
#include "ILoggerImpl.h"

class CLogger: public ILoggerImpl
{
public:
    CLogger():log(NULL) {  }

    //interface
    void Info(std::string s)  {if (NULL==log) return; log->Info(s); }
    void Warning(std::string s) {if (NULL==log) return; log->Warning(s); }
    void Error(std::string s) {if (NULL==log) return; log->Error(s); }


    //
    void BindImplementation(ILoggerImpl &ilog) { log = &ilog; }
    void UnbindImplementation(){ log = NULL; }


private:
    ILoggerImpl *log;
};


// file: loggers.h //

#include "logger.h"
extern CLogger Log1;
extern CLogger Log2;
extern CLogger Log3;
extern CLogger Log4;
extern CLogger LogB;



/// file: A.h //
#include "loggers.h"  

class A
{

public:
    void foo()
    {
        Log1.Info("asdhoj");
        Log2.Info("asdhoj");
        Log3.Info("asdhoj");

    }
private:

};


/// file: B.h //
#include "loggers.h"

class B
{

public:
    void bar()
    {
        Log1.Info("asdhoj");
        Log2.Info("asdhoj");
        LogB.Info("asdhoj");
        a.foo();
    }



private:

    A a;
};



////// file: main.cpp  ////////////////


#include "loggers.h"
#include "A.h"
#include "B.h"
#include "fileloger.h"
#include "xmllogger.h"

CLogger Log1;
CLogger Log2;
CLogger Log3;
CLogger Log4;
CLogger LogB;

// client code

int main()
{
    std::unique_ptr<ILoggerImpl> filelog1(new CFileLogger("C:\\log1.txt"));
    Log1.BindImplementation(*filelog1.get());

    std::unique_ptr<ILoggerImpl> xmllogger2(new CXmlLogger("C:\\log2.xml"));
    Log2.BindImplementation(*xmllogger2.get());

    std::unique_ptr<ILoggerImpl> xmllogger3(new CXmlLogger("C:\\logB.xml"));
    LogB.BindImplementation(*xmllogger3.get());


    B b;
    b.bar();



    return 0;
};



// testing code
///////file: test.cpp /////////////////////////////////

#include "loggers.h"
CLogger Log1;
CLogger Log2;
CLogger Log3;
CLogger Log4;

int main()
{
    run_all_tests();
}



///////file: test_a.cpp /////////////////////////////////

#include "A.h"

TEST(test1)
{
    A a;
}

TEST(test2, A_logs_to_Log1_when_foo_is_called())
{
    A a;
    std::unique_ptr<ILoggerImpl> filelog1Mock(new CFileLoggerMock("C:\\log1.txt"));
    Log1.BindImplementation(*filelog1.get());
    EXPECT_CALL(filelog1Mock  Info...);

    a.foo();
    Log1.UnbindImplementation();
}