С++. Шаблоны и информация о пользователях во время выполнения

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

Можно ли это сделать с помощью шаблонов? Ответ «Да», и это выглядит так, используя C++11 и shared_ptr:

template<class T>
std::shared_ptr<T> getIntegrator(pFunction whichFunction, int order)
{
    return std::make_shared<T>(whichFunction, order);
}

И в вашем абоненте:

std::shared_ptr<Integrator> integrator;
if (whichIntegrator  == "Euler")
{
    integrator = getIntegrator<Euler>(whichFunction, order);
}
else if(whichIntegrator  == "RungeKutta")
{
    integrator = getIntegrator<RungeKutta>(whichFunction, order);
}

Еще одно замечание: вы должны быть очень осторожны с утечками памяти здесь, вы обновляетесь и возражаете, и если вы никогда не выпускаете ее, у вас будет утечка.

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

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

Я бы взял ваш on_integrateButton_clicked и изменил его на что-то вроде этого:

void MainWindow::on_integrateButton_clicked() {
  string whichIntegrator = getUserChoice();

  runInNewThread( [whichIntegrator,whichFunction,order]() {
    struct functor {
      FunctionType func;
      OrderType order;
      functor( FunctionType func_in, OrderType order_in):func(std::move(func_in)), order(std::move(order_in)) {}
      template<typename Integrator>
      void operator()( Integrator* integrator ) {
        // code using integrator here, not a virtual interface to it, an actual instance of the final type
      }
    };
    RunWithChosenIntegrator( whichIntegrator, functor(whichFunction,order) );
  } );
}

Как видите, код выглядит немного задом наперед.

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

Однако обычно для таких проблем достаточно полиморфизма во время выполнения или стирания типов.

Теперь RunWithChosenIntegrator немного странный зверь. У него будет такая подпись:

template<typename Functor>
void RunWithChosenIntegrator( std::string const&whichIntegrator, Functor&& func ) {
  if (whichIntegrator == "bob") {
    BobIntegrator bob;
    func( &bob );
  } else if (whichIntegrator == "alice" ) {
    AliceIntegrator alice;
    func( &alice ):
  }
}

как видите, мы вызываем func с другим типом объекта на основе параметра whichIntegrator. Есть забавные способы даже генерировать цепочки if/else if с помощью метапрограммирования, но это, вероятно, не стоит изучать, пока вы не освоитесь с базовым программированием шаблонов.

Functor func должен иметь возможность принимать указатели на любые и все типы, с которыми мы его вызываем. Простым примером может быть func, который просто принимает указатель на базовый класс, а тот, который я привел выше, принимает тип шаблона T*.

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

Сомневаюсь, что здесь так.