C++ виртуальная шаблонная функция(псевдо)

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

template<class T>
class Visitor{
   virtual void visit(T& value);
};
template<class... Ts>
class Storage{
     std::tuple<Visitor<Ts>*...> m_visitors;
     public:
     template<std::size_t I, class T>
     void visit(T& value){
        auto visitor = std::get<I>(m_visitors);
        visitor->visit(value);
     }
};

Тут возникает проблема с инициализацией визитёров - на каждый тип нужен свой экземпляр, но можно решить проблему при помощи обобщенных лямбд.

В Storage::visit I и T на самом деле связаны, но без метопрограммирования одно из другого получить не получится.

Другой вариант - передавать в качестве аргумента виртуальной функции std::variant с допустимыми типами, а уже реализация виртуальной функции решит, что делать с конкретными типами. Если типы-аргументы имеют разный размер, в std::variant можно передавать ссылки, а не значения (оборачивая их в std::reference_wrapper), или можно использовать boost::variant, который поддерживает обычные ссылки.

template<class... Ts>
class Storage{
  std::tuple<Ts...> m_values;
  virtual void visit(boost::variant<Ts&...> ref){}
public:
  Storage(std::tuple<Ts...> values): m_values(values) {}
  void callVisit(){
      std::apply([this](auto&... v) mutable{
        auto visit = [this](auto& v){ this->visit(v); return 0;};
        int unused[] = {visit(v)...}; // Вызов this->visit для всех значений кортежа
      }, m_values);
  }
};
template<class... Ts>
class StorageImpl: public Storage<Ts...>{
   void visit(boost::variant<Ts&...> ref) override {
       boost::apply_visitor([](auto& value){
          // тут по сути тело шаблонной виртуальной функции, value - шаблонный аргумент
       } ,ref);
   }
public:
   using Storage<Ts...>::Storage;
};

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

Ваш дизайн сейчас примерно соответствует такому: абстрактный класс Животное, в который вы одновременно запихиваете функции Летать и Плавать, и далее вы хотите из него порождать, например, Орла и Дельфина. Но это неверный подход. Где, в каком месте у вас "Животное вообще" должно летать? или плавать? Да, есть какие-нибудь летучие рыбы или там утки - но если вы поступаете так, то ограничиваете понятие животных только теми, кто может летать и плавать одновременно.

Если у вас будет код, который вы хотите - с запретом летать в производном классе, например - то к чему приведет ваш (вполне корректный) вызов через указатель на базовый абстрактный класс типа Животное->Летать при передаче ему какого-то Тигра? К ошибке времени выполнения.

В самом лучшем случае нужно дополнить иерархию абстрактными классами, скажем, Птицы и Водоплавающие, а уже потом на них строить конкретные классы. (Кстати, тогда летающие рыбы будут получаться множественным наследованием.) Не надо идти против природы.

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

Если и это непонятно - умываю руки, делайте квадратное колесо, а потом спрашивайте, как написать трактор, который будет способен тащить телегу с такими колесами...