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";

А>После того, как узнал про этот паттерн, постоянно хочется его применять . Кажется очень удобным иметь под рукой объект, в любом месте программы. То есть, и код структурируется по классам, и не нужно с передачей ссылок на объекты возиться. Но вот в "настоящих" ООП приложениях практически не встречаю его (обычно синглтоны — только объекты Application в различных фреймворках). До этого писал на С. Насколько "неправильной" для дизайна больших приложений может быть такая практика?

typedef Singleton<CService, ThreadingModel<Multi> > S_Service;

#define S_ServiceState Singleton<CService, ThreadingModel<Multi> >::instance().state()

if (S_ServiceState != FALSE)
{
...
}

class TMonostate
{
  static std::string s;

public:

  const std::string& getS() { return s; }
  
};

class MyClass
{
  void Log(PCWSTR message)
    {
       std::wstringstream ss;
         ss << //пишем контекст this
         ss << message;
         Logger::Instance().Write(ss.str());
    }
    
    void Meth()
    {
      Log(L"Entering meth...");
        ....
    }
}

class MyClassLogger: public Logger
{
   void operator()(MyClass* ctx, PCWSTR message)
     {
       std::wstringstream ss;
         ss << //пишем контекст ctx
         ss << message;
         Write(ss.str());
      }
}

class MyClass
{
  MyClassLogger log;
    void Meth()
    {
      log(this, L"Entering meth...");
        ....
    }
}

logSingleton.createCategory("someString");

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;
}

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