Производительность парадигмы интерфейса (динамическое связывание или универсальное программирование)

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

Пример кода (только для справки)

A) динамическое связывание

namespace DB {
  // interface
  class CustomCode {
    public:
      virtual void operator()(char) const = 0;
  };
  class Lib {
    public:
      void feature(CustomCode const& c) {
        c('d');
      }
  };

  // user code
  class MyCode1 : public CustomCode {
    public:
      void operator()(char i) const {
        std::cout << "1: " << i << std::endl;
      }
  };
  class MyCode2 : public CustomCode {
    public:
      void operator()(char i) const {
        std::cout << "2: " << i << std::endl;
      }
  };

  void use() {
    Lib lib;
    lib.feature(MyCode1());
    lib.feature(MyCode2());
  }
}

B) общее программирование

namespace GP {
  //interface
  template <typename CustomCode> class Lib {
    public:
      void feature(CustomCode const& c) {
        c('g');
      }
  };

  // user code
  class MyCode1 {
    public:
      void operator()(char i) const {
        std::cout << "1: " << i << std::endl;
      }
  };
  class MyCode2 {
    public:
      void operator()(char i) const {
        std::cout << "2: " << i << std::endl;
      }
  };

  void use() {
    Lib<MyCode1> lib;
    lib.feature(MyCode1());
    //lib.feature(MyCode2());  <-- illegal
  }
}

Вопрос

Некоторые мысли

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

В любом случае, теоретически (TM) A немного медленнее во время выполнения из-за косвенного обращения к виртуальной функции, тогда как B предлагает отличную оптимизацию Возможности как методы могут быть встроены (и, конечно, у вас нет косвенности).
Однако мне часто кажется, что A немного более самодокументируется, потому что у вас есть понятный интерфейс, который вы должны реализовать (который обычно состоит из более чем одного метода), в то время как B немного более анархичен (что подразумевает его гибкость).

Ядро

1. Есть ли какие-либо общие результаты / сравнительные исследования этих парадигм?
2. Значительно ли ускорение?
3. А как насчет времени компиляции?
4. Какое значение имеет дизайн для интерфейсов в более крупные системы (я в основном использовал A для своих межмодульных интерфейсов, и я пока что не делал действительно больших проектов)?

Edit

Примечание: выражение «динамическое связывание лучше, потому что оно является более мощным »- это вовсе не ответ, потому что предварительным условием является то, что у вас есть случай, когда применимы оба подхода (в противном случае нет свободы выбора - по крайней мере, неразумно).