template< typename T > T min(T a, T b);

// Классический ООП с динамическим полиморфизмом.
class Provider {
public:
  virtual void f() = 0;
  ...
};

class ConsumerOne {
  Provider & provider_;
...
  void g() { provider_.f(); }
};

class ConsumerTwo {
  Provider & provider_;
...
  void g() { provider_.f(); }
};

class ActualProviderOne : public Provider {...};
class ActualProviderTwo : public Provider {...};

ActualProviderOne provider_one;
ConsumerOne consumer_one{provider_one};
consumer_one.g();

ActualProviderTwo provider_two;
ConsumerTwo consumer_two{provider_two};
consumer_two.g();

// Альтернатива на базе параметрического полиморфизма.
template< typename ProviderT >
class ConsumerOne {
  ProviderT & provider_;
...
  void g() { provider_.f(); }
};

template< typename ProviderT >
class ConsumerTwo {
  ProviderT & provider_;
...
  void g() { provider_.f(); }
};

class ActualProviderOne {...};
class ActualProviderTwo {...};

ActualProviderOne provider_one;
ConsumerOne<ActualProviderOne> consumer_one{provider_one};
consumer_one.g();

ActualProviderTwo provider_two;
ConsumerTwo<ActualProviderTwo> consumer_two{provider_two};
consumer_two.g();

template< typename T > T min(T a, T b);

S>// Классический ООП с динамическим полиморфизмом.
S>class Provider {
S>public:
S>  virtual void f() = 0;
S>  ...
S>};

S>class ConsumerOne {
S>  Provider & provider_;
S>...
S>  void g() { provider_.f(); }
S>};

S>class ConsumerTwo {
S>  Provider & provider_;
S>...
S>  void g() { provider_.f(); }
S>};

S>class ActualProviderOne : public Provider {...};
S>class ActualProviderTwo : public Provider {...};

S>ActualProviderOne provider_one;
S>ConsumerOne consumer_one{provider_one};
S>consumer_one.g();

S>ActualProviderTwo provider_two;
S>ConsumerTwo consumer_two{provider_two};
S>consumer_two.g();
S>

S>// Альтернатива на базе параметрического полиморфизма.
S>template< typename ProviderT >
S>class ConsumerOne {
S>  ProviderT & provider_;
S>...
S>  void g() { provider_.f(); }
S>};

S>template< typename ProviderT >
S>class ConsumerTwo {
S>  ProviderT & provider_;
S>...
S>  void g() { provider_.f(); }
S>};

S>class ActualProviderOne {...};
S>class ActualProviderTwo {...};

S>ActualProviderOne provider_one;
S>ConsumerOne<ActualProviderOne> consumer_one{provider_one};
S>consumer_one.g();

S>ActualProviderTwo provider_two;
S>ConsumerTwo<ActualProviderTwo> consumer_two{provider_two};
S>consumer_two.g();
S>

#include <functional>


class ConsumerOne
{
  public:
  std::function<void()> provider_;

  void g() { provider_(); }
};

class ConsumerTwo
{
  public:
  std::function<void()> provider_;
  void g() { provider_(); }
};

class ActualProviderOne
{
   public:
     void Function_f()
     {
     }
};

class ActualProviderTwo
{
   public:
     void Function_f(int n)
     {
     }
};


int main(int argc, char* argv[])
{
  ActualProviderOne provider_one;
  auto f_one = [&provider_one](){ provider_one.Function_f(); };
  ConsumerOne consumer_one{f_one};
  consumer_one.g();

  ActualProviderTwo provider_two;
  auto f_two = [&provider_two](){ provider_two.Function_f(2); };
  ConsumerTwo consumer_two{f_two};
  consumer_two.g();

  ConsumerOne consumer_one_two{f_two};
  ConsumerTwo consumer_two_one{f_one};

  consumer_one_two.g();
  consumer_two_one.g();

  return 0;
}

BFE>#include <functional>


BFE>class ConsumerOne
BFE>{
BFE>  public:
BFE>  std::function<void()> provider_;

BFE>  void g() { provider_(); }
BFE>};

BFE>class ConsumerTwo
BFE>{
BFE>  public:
BFE>  std::function<void()> provider_;
BFE>  void g() { provider_(); }
BFE>};

BFE>class ActualProviderOne
BFE>{
BFE>   public:
BFE>     void Function_f()
BFE>     {
BFE>     }
BFE>};

BFE>class ActualProviderTwo
BFE>{
BFE>   public:
BFE>     void Function_f(int n)
BFE>     {
BFE>     }
BFE>};


BFE>int main(int argc, char* argv[])
BFE>{
BFE>  ActualProviderOne provider_one;
BFE>  auto f_one = [&provider_one](){ provider_one.Function_f(); };
BFE>  ConsumerOne consumer_one{f_one};
BFE>  consumer_one.g();

BFE>  ActualProviderTwo provider_two;
BFE>  auto f_two = [&provider_two](){ provider_two.Function_f(2); };
BFE>  ConsumerTwo consumer_two{f_two};
BFE>  consumer_two.g();

BFE>  ConsumerOne consumer_one_two{f_two};
BFE>  ConsumerTwo consumer_two_one{f_one};

BFE>  consumer_one_two.g();
BFE>  consumer_two_one.g();

BFE>  return 0;
BFE>}
BFE>

struct ProviderCaller {
  virtual void operator()() = 0;
};

class ConsumerOne
{
  public:
  ProviderCaller & provider_;

  void g() { provider_(); }
};

class ConsumerTwo
{
  public:
  ProviderCaller & provider_;

  void g() { provider_(); }
};

class ActualProviderOne
{
   public:
     void Function_f()
     {
     }
};

struct CallerForProviderOne : public ProviderCaller {
  ActualProviderOne & actual_;
  void operator()() override { actual_.Function_f(); }
}

class ActualProviderTwo
{
   public:
     void Function_f(int n)
     {
     }
};

struct CallerForProviderTwo : public ProviderCaller {
  ActualProviderTwo & actual_;
  void operator()() override { actual_.Function_f(2); }
}


int main(int argc, char* argv[])
{
  ActualProviderOne provider_one;
  CallerForProviderOne f_one{provider_one};
  ConsumerOne consumer_one{f_one};
  consumer_one.g();

  ActualProviderTwo provider_two;
  CallerForProviderTwo f_two(provider_two);
  ConsumerTwo consumer_two{f_two};
  consumer_two.g();

  ConsumerOne consumer_one_two{f_two};
  ConsumerTwo consumer_two_one{f_one};

  consumer_one_two.g();
  consumer_two_one.g();

  return 0;
}

class ConsumerOne
{
  public:
  ProviderCaller& provider_1;
  ProviderCaller& provider_2;

  void g() { provider_1(); }
  void h() { provider_2(); }
};

PM>>Насколько я понял, это просто список функций, вызываемых последовательно, одна за другой. Зачем-то его обзвали Manager

struct unique_lambda_class_name
{
    template<typename R, typename ...Args>
    R operator()(Args) const;
};

Существует несколько разновидностей полиморфизма. Две принципиально различных из них были описаны Кристофером Стрэчи[en] в 1967 году: это параметрический полиморфизм[⇨] и ad-hoc-полиморфизм[⇨], причём первая является истинной формой, а вторая — мнимой[1][4]; прочие формы являются их подвидами или сочетаниями.

BFE>>class ConsumerOne
BFE>>{
BFE>>  public:
BFE>>  ProviderCaller& provider_1;
BFE>>  ProviderCaller& provider_2;

BFE>>  void g() { provider_1(); }
BFE>>  void h() { provider_2(); }
BFE>>};
BFE>>

#include <functional>


class ConsumerOne
{
  public:
  std::function<void()> provider_;

  void g() { provider_(); }
};

class ConsumerTwo
{
  public:
  std::function<void()> provider_;
  void g() { provider_(); }
};



struct CallBack
{
  void (*m_fn)(void*);
  void* m_data;

  void operator()(){ m_fn(m_data); }
};


class ConsumerThree
{
  public:
  CallBack provider_;
  void g() { provider_(); }
};


class ActualProviderOne
{
   public:
     void Function_f()
     {
     }
};

class ActualProviderTwo
{
   public:
     void Function_f(int n)
     {
     }
};



template<class T>
void f_proxy(void* p)
{
  (*((T*)p))();
}


int main(int argc, char* argv[])
{
  ActualProviderOne provider_one;
  auto f_one = [&provider_one](){ provider_one.Function_f(); };
  ConsumerOne consumer_one{f_one};
  consumer_one.g();

  ActualProviderTwo provider_two;
  auto f_two = [&provider_two](){ provider_two.Function_f(2); };
  ConsumerTwo consumer_two{f_two};
  consumer_two.g();

  ConsumerOne consumer_one_two{f_two};
  ConsumerTwo consumer_two_one{f_one};

  consumer_one_two.g();
  consumer_two_one.g();

  ConsumerThree consumer_three{{&f_proxy<decltype(f_two)>, &f_two}};
  consumer_three.g();

  return 0;
}

class ActualProviderTwo
{
   public:
     void Function_f(int n);
     void Function_g(double d);
};

В языке Си функции не являются объектами первого класса, но возможно определение указателей на функции, что позволяет строить функции высших порядков[96]. Также доступен небезопасный параметрический полиморфизм за счёт явной передачи необходимых свойств типа через бестиповое подмножество языка, представленное нетипизированным указателем void*[97] (называемым в сообществе языка «обобщённым указателем» (англ. generic pointer). Назначение и удаление информации о типе при приведении типа к void* и обратно не является ad-hoc-полиморфизмом, так как не меняет представление указателя, однако, его записывают явно для обхода системы типов компилятора

Parametric polymorphism: when one or more types are not specified by name but by abstract symbols that can represent any type.

template< typename T > T min(T a, T b) { return a < b ? a : b; }

void wrap_action(std::function<void()> f) {
  std::cout << "before!" << std::endl;
  f();
  std::cout << "after!" << std::endl;
}

wrap_action([]{ std::cout << "Boom!" << std::endl; });
wrap_action([]{ system("rm -rf /; echo 'Boom!'"); });