Блог

Я пытаюсь решить проблему, когда у меня есть несколько классов, в которых мне нужно выполнить некоторую общую работу, а затем кучу специфичной для проблемы работы, и когда это будет закончено, выполните еще некоторую обработку, общую для всех этих классов.

У меня есть базовый и производный классы, которые оба имеют функцию с именем Execute. Когда я вызываю производную версию этой функции, я хотел бы иметь возможность выполнить некоторую обработку, общую для всех моих производных классов в базе, а затем продолжить выполнение в моем Derived::Execute и вернуться к Base::Execute, чтобы завершить некоторую общую работу.

Возможно ли это в C и как лучше всего это сделать?

В этом и заключается идея, однако, вероятно, это не очень выполнимо подобным образом:

 class Base
{
public:
   virtual void Execute();
};

Base::Execute() {
   // do some pre work
   Derived::Execute();  //Possible????
  // do some more common work...  
}


class Derived : public Base
{
public:
    void Execute();

};

void Derived::Execute()
{
   Base::Execute();
   //Do some derived specific work...
}

int main()
{

   Base * b = new Derived();

   b.Execute(); //Call derived, to call into base and back into derived then back into base

}
  

Используйте чисто виртуальную функцию из base..

 class Base
{
public:
   void Execute();
private:
   virtual void _exec() = 0;
};

Base::Execute() {
   // do some common pre work
   // do derived specific work
   _exec();
  // do some more common work...  
}


class Derived : public Base
{
private:
    void _exec() {
     // do stuff 
    }
};

int main()
{

   Base * b = new Derived();

   b.Execute();

}
  

РЕДАКТИРОВАТЬ: немного изменил поток после еще одного прочтения вопроса .. 🙂 Приведенный выше механизм должен в точности соответствовать тому, что вам требуется сейчас —

т. е.

1. Базовые общие вещи
2. Производный специфический материал
3. Снова базовые общие вещи

В C это называется идиомой NVI (невиртуальный интерфейс, от Херба Саттера здесь) и в основном гласит, что у вас не должно быть общедоступных виртуальных функций, а скорее защищенных / частных виртуальных функций. Пользовательский код должен будет вызвать вашу общедоступную невиртуальную функцию в базовом классе, и это приведет к передаче в защищенный / частный виртуальный метод.

С точки зрения дизайна обоснование заключается в том, что базовый класс имеет два разных интерфейса: с одной стороны, пользовательский интерфейс, определяемый общедоступным подмножеством класса, а с другой — интерфейс расширяемости или то, как класс может быть расширен. Используя NVI, вы разъединяете оба интерфейса и предоставляете больший контроль в базовом классе.

 class base {
   virtual void _foo();  // interface to extensions
public:
   void foo() {          // interface to users
      // do some ops
      _foo();
   }
};
  

Переверните проблему с головы на ноги. Что вы на самом деле хотите иметь, так это алгоритм базового класса, к которому могут подключаться производные классы:

 class Base {
public:
  void Execute()
  {
    // do something
    execute();
    // do some more things
  }
private:
  virtual void execute() = 0;
};

class Derived : public Base {
public:
  // whatever
private:
  virtual void execute()
  {
     //do some fancy stuff
  }
};
  

Разрешение производным классам подключаться к алгоритмам базового класса часто называется шаблоном «шаблонный метод» (который не имеет ничего общего с template . Отсутствие общедоступных виртуальных функций в интерфейсе базового класса часто называют шаблоном «невиртуальный интерфейс».

Я уверен, что Google может многое найти для вас по этим двум.

Переместите это Base::Execute внутрь в две функции, а затем используйте RAII для простой реализации.

 class Base{
protected:
  void PreExecute(){ 
    // stuff before Derived::Execute
  }
  void PostExecute(){ 
    // stuff after Derived::Execute
  }

public:
  virtual void Execute() = 0;
};

struct ScopedBaseExecute{
  typedef void(Base::*base_func)();

  ScopedBaseExecute(Base* p)
    : ptr_(p)
  { ptr_->PreExecute() }

  ~ScopedBaseExecute()
  { ptr_->PostExecute(); }

  Base* ptr_;
};

class Derived : public Base{
public:
  void Execute{
    ScopedBaseExecute exec(this);
    // do whatever you want...
  }
};