MyLog(10) << "doing something with: " << obj.Name() << " and " << obj2.Name();

I>Это уже слишком много

// файл log.h

class LogStream
{
public:
  LogStream(const std::string &what, int severity);
  ~LogStream();
  
  LogStream& operator<<(...);
  ...
};

// файл logRel.h

struct Message
{
  time time;
  std::string what;  
  int severity;
  std::string msg;
};

struct IProcessor
{
  virtual void doLog(const Message &m) = 0;
};

void registerProcessor(const std::string &what, int severity, IProcessor *proc);

// файл log.cpp

struct LogData
{
  void reigster(const std::string &what, int severity, IProcessor *proc);
  void doLog(const Message &m);
  static LogData& get();
};

LogStream::~LogStream()
{
  Message m;
  ...
  LogData::get().doLog(m);
};

void registerProcessor(const std::string &what, int severity, IProcessor *proc)
{
  LogData::get().registerProcessor(what, severity, proc);
}

The service locator pattern is a design pattern used in software development to encapsulate the processes involved in obtaining a service with a strong abstraction layer. This pattern uses a central registry known as the "service locator" which on request returns the information necessary to perform a certain task.

Locator locator;
Logger* logger = locator.getLogger(className);

LogSystem ls = LogSystemSingleton.getInstance();
Logger* logger = ls.getLogger(className);

B>Locator locator;
B>Logger* logger = locator.getLogger(className);
B>

B>LogSystem ls = LogSystemSingleton.getInstance();
B>Logger* logger = ls.getLogger(className);
B>

classA::classA(ILogger* pLogger)
{
  this->pLogger = pLogger;
}

classA::SetLogger(ILogger* pLogger)
{
  this->pLogger = pLogger;
}

I>classA::classA(ILogger* pLogger)
I>{
  this->>pLogger = pLogger;
I>}
I>

I>classA::SetLogger(ILogger* pLogger)
I>{
  this->>pLogger = pLogger;
I>}
I>

MyLog(level) << "some message";

template<typename T>
T& get_instance_singletone()
{
   static T t;//работу в многопоточной среде убираем для наглядности.
   return t;
}