Когда использовать функцию std:: вместо наследования?

В некоторых случаях std::function может заменить наследование. Следующие два фрагмента кода очень похожи (примерно одинаковые затраты при вызове функции, почти одинаковое использование в подписях и в большинстве случаев функция std:: не требует от нас дополнительной копии A):

struct Function
{
    virtual int operator()( int ) const =0;
};
struct A
    : public Function
{
    int operator()( int x ) const override { return x; }
};

Используя std::function, мы можем переписать это как

using Function = std::function<int (int)>;
struct A
{
    int operator()( int x ) const { return x; }
};

Чтобы сделать более понятным, как связаны два фрагмента: оба они могут использоваться следующим образом:

int anotherFunction( Function const& f, int x ) { return f( x ) + f( x ); }

int main( int argc, char **argv )
{
    A f;
    anotherFunction( f, 5 );
    return 0;
}

Последний подход более гибкий, потому что нам не нужно выводить наши классы из некоторого общего базового класса. Единственная связь между Function -подобными объектами основана на их возможностях. Что касается объектно-ориентированного программирования, то его можно считать менее чистым (но не в плане функционального программирования, конечно).

Кроме того, существуют ли другие различия между этими двумя решениями? Существуют ли какие-либо общие рекомендации, когда использовать какое из решений или это только вопрос личных предпочтений? Есть ли случаи, когда одно решение выходит из другого?

Ответы

Ответ 1

Небольшая поправка: обратите внимание, что это:

int anotherFunction( Function f, int x ) { return f( x ) + f( x ); }

Не будет компилироваться с решением наследования, так как Function берется значением и является абстрактным. Если бы это не было абстрактным, с другой стороны, вы бы получили нарезку, чего вы не хотите.

Скорее всего, вам понадобится взять ваш Function -положенный объект по ссылке (возможно, по ссылке const), чтобы воспользоваться полиморфизмом:

int anotherFunction( Function const& f, int x ) { return f( x ) + f( x ); }

И это не очень функционально, поэтому, если вы увлекаетесь функциональным программированием (как вам кажется), вы можете избежать его только из-за этого.

Тем не менее, вот что я хотел бы дать:

  • Если вы можете, используйте шаблоны:

    template<typename F>
int anotherFunction(F f, int x) { return f(x) + f(x); }

    В общем случае, когда он может быть использован вообще, статический (компиляционный, основанный на шаблоне) полиморфизм считается предпочтительным для динамического (на основе времени, наследования) полиморфизма, из-за:

    • Превосходная гибкость: вам не нужно изменять определение ваших типов и делать их производными от общего базового класса, чтобы они могли использоваться в целом. Это позволяет вам, например, написать:

      anotherFunction([] (int x) { return x * 2; }, 42);

      Также как:

      anotherFunction(myFxn, 42); // myFxn is a regular function

      Или даже:

      anotherFunction(my_functor(), 42); // my_functor is a class

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

  • Если вы не можете использовать шаблоны, потому что функция, которая будет вызываться, будет определена во время выполнения, использовать std::function:

     int anotherFunction(std::function<int (int)> f, int x) 
 { 
     return f(x) + f(x); 
 }

    Это также даст вам достаточную гибкость для передачи в lambdas, указателях функций, функторов, в основном любого вызываемого объекта. См., Например, fooobar.com/info/43185/....

    Использование std::function может привести к значительным непродолжительным накладным расходам в отношении дизайна на основе шаблонов и, возможно, также незначительных незначительных накладных расходов в отношении жестко закодированного решения наследования, подобного тому, которое вы начертите, но оно дает вам гибкость и стандартная идиома. Более того, как всегда, когда производительность вызывает беспокойство, делайте измерения для подтверждения любого предположения - вы можете получить неожиданные результаты.

    Обычно вам нужно прибегнуть к подобному дизайну на основе std::function, если вы хотите хранить вызываемые объекты любого типа для последующего вызова, как в случае Конструкция шаблона команды или когда у вас есть гетерогенная коллекция вызываемых объектов, которые нужно обрабатывать и вызывать в общем случае. Для обсуждения вопроса о том, когда использовать std::function вместо шаблонов, см. fooobar.com/info/43185/....

  • Итак, когда вы должны прибегать к жесткому кодированию с использованием наследования? Ну, во всех тех случаях, когда 1. и 2. не жизнеспособны - честно говоря, я не могу сейчас придумать, но я уверен, что кто-то может придумать угловой случай. Обратите внимание, что С++ 11 не требуется для использования std::function -подобной идиомы, поскольку Boost имеет реализацию boost::function и boost::bind, которая была датирована (и послужила источником вдохновения для) С++ 11 std::function и std::bind.

TL; DR: используйте шаблоны или std::function.