C++: Добавяне на методи към йерархия на полиморфен клас без нарушаване на SRP?

Има модел на ацикличен посетител, който елиминира необходимостта да знаете за всеки подклас. Разчита на dynamic_cast, но може да е това, от което се нуждаете.

Няма нищо лошо в това класът да се отпечата сам. Това не нарушава SRP, тъй като отпечатването не представлява отговорност.

Не забравяйте, че отговорността се определя като причина за промяна. Не променяте клас, защото вашите изисквания за печат се променят. Класът трябва да изпраща само двойки име-стойност до субекта, отговорен за отпечатването, наречен форматор. Тази процедура за изпращане на двойки име-стойност никога не се променя сама. Всички промени в него се предизвикват само от други промени, които не са свързани с печата (когато например добавите поле, вие също добавяте неговото представяне към процедурата за печат).

Форматиращият не трябва да знае нищо за класовете, които отпечатва, а просто да представя двойките име-стойност според някакъв набор от изисквания. Форматиращият модул се променя, когато се променят изискванията за печат. Следователно отпечатването ще бъде отговорност единствено на форматиращия.

Ще трябва да потърсите някакъв посетител на решение за двойно изпращане, за да направите това. Подходът за двойно изпращане е малко по-лек, така че какво ще кажете за нещо подобно:

In A:

class Processor
{
public:
  virtual void Process(const A &a)const {}
  virtual void Process(const B &b)const {}
  virtual void Process(const C &c)const {}
  virtual void Process(const D &d)const {}
  virtual void Process(const E &e)const {}
};

In A:

class A
{
public:
  virtual void Process(const Processor &processor) 
  {
    processor.Process(*this);
  }
};

След това във всеки производен клас заменете Process с идентична дефиниция:

virtual void Process(const Processor &processor) 
{
  processor.Process(*this);
}

Това ще гарантира, че се извиква правилното претоварване в Process.

Сега създайте поточен процесор:

class StreamProcessor : public Processor
{
private:
 OutputStream &m_OS;

public:
  StreamProcessor(OutputStream &os) : m_OS(os)
  {
  }

  virtual void Processor(const A &a)const
  {
   m_os << "got a A";
  }

  virtual void Processor(const B &b)const
  {
   m_os << "got a B";
  }

  virtual void Processor(const C &c)const
  {
   m_os << "got a C";
  }

  // etc
};

И тогава:

 OutputStream &operator<<(OutputStream &os, A &a)
 {
   PrintProcessor(os);
   a.Process(PrintProcessor);
   return os;
 }

Можете да предоставите интерфейс за отговорност за отпечатване и да запазите общите отговорности под йерархията на вашия клас. Пример:

class Printer { public: virtual void print(OutputStream &os) = 0; }
class A { public: virtual ~A() {} ... };
class B: public A, public Printer { ... }; // this needs print function, use interface.
class C: public B { ... };
class D: public A { ... };