#include <iostream>

class A;

template <class T>
void CallFunImpl(A* p, T t);


class A
{
  public:
    template <class T>
    void virtual_fun(T t)
    {
        CallFunImpl(this, t);
    }

    virtual int GetThisId()
    {
        return 0;
    }

    template <class T>
    void virtual_fun_(T t)
    {
        std::cout << "A:: t is " << t << std::endl;
    }
};



class B : public A
{
  public:
    virtual int GetThisId()
    {
        return 1;
    }

    template <class T>
    void virtual_fun_(T t)
    {
        std::cout << "B:: t is " << t << std::endl;
    }
};


class C : public A
{
  public:
    virtual int GetThisId()
    {
        return 2;
    }
};


class D : public A
{
  public:
    virtual int GetThisId()
    {
        return 3;
    }

    template <class T>
    void virtual_fun_(T t)
    {
        std::cout << "D:: t is " << t << std::endl;
    }
};


class E : public D
{
  public:
    virtual int GetThisId()
    {
        return 4;
    }

    template <class T>
    void virtual_fun_(T t)
    {
        std::cout << "E:: t is " << t << std::endl;
    }
};


template <class T>
void CallFunImpl(A* p, T t)
{
    switch(p->GetThisId())
    {
        case 0:                 p ->A::virtual_fun_(t); break;
        case 1: static_cast<B*>(p)->B::virtual_fun_(t); break;
        case 2: static_cast<C*>(p)->C::virtual_fun_(t); break;
        case 3: static_cast<D*>(p)->D::virtual_fun_(t); break;
        case 4: static_cast<E*>(p)->E::virtual_fun_(t); break;
    }
}


int main(int argc, char* argv[])
{
    A* arr[] = {new A, new B, new C, new D, new E};

    for(A* p : arr)
    {
        p->virtual_fun(1);
        p->virtual_fun('c');
        p->virtual_fun(1.1f);
    }

    E e;
    e.virtual_fun("I am virtual template function!");
    B b;
    b.virtual_fun("I am virtual template function!");

    return 0;
}

8.1 Virtual Function Templates
Virtual function templates are a powerful abstraction mechanismnot part of C++. Generating v-tables for virtual function templates requires a whole-program view and C++ traditionally relies almost exclusively on separate compilation of translation units. The prelinker technique described here should be able to synthesize v-tables for virtual function templates as it does for open-methods.

Future plans to extend our work include:

// file: A.hpp
class A
{
  public:
    template <class T>
    virtual void virt_fun(T t)
    {
        std::cout << "A::" << t << std::endl;
    }
};


// file: B.hpp
#include "A.hpp"

class B : public A
{
  public:
    template <class T>
    virtual void virt_fun(T t)
    {
        std::cout << "B::" << t << std::endl;
    }
};


// file: C.cpp
#include "A.hpp"

void fun_str(A* p)
{
    p->virt_fun("fun1");
}
// компиляция этого кода инстанцирует метод A::virt_fun<const char*>



// file: D.cpp
#include "A.hpp"

void fun_int(A* p)
{
    p->virt_fun(32);
}
// компиляция этого кода инстанцирует метод A::virt_fun<int>


// file: E.cpp
#include "B.hpp"

void fun_float()
{
    B b;
    b.virt_fun(1.1f);
}
// компиляция этого кода инстанцирует метод B::virt_fun<float>, но не метод A::virt_fun<float>


// file: M.cpp
#include "B.hpp"

extern void fun_str(A* p);
extern void fun_int(A* p);
extern void fun_float();

int main(int argc, char* argv[])
{
    Test oTest;

    A* arr[] = {new A, new B};

    for(A* p : arr)
    {
        fun_str(p);
        fun_int(p);
    }
    fun_float();
}
// Компиляция этого кода не инстанцирует ни одного метода virt_fun.
// Таким образом во всех скомпилированных файлах есть только одна реализация для B::virt_fun и это B::virt_fun<float> в E.obj,
// однако,
// известно, что для каждого инстанцированного метода A::virt_fun должн быть инстанцирован соответствующий B::virt_fun метод.
// Информация о том, какие A::virt_fun методы инстанцированы лежат в объектниках C.obj, D.obj и E.obj, но эта информация не доступна
// здесь, в M.obj.

// На стадии линковки, линковщик создаёт таблицу виртуальных функций virt_fun для класса A, для этого он ищет во всех объектниках 
// все инстанцирования методов A::virt_fun и находит:
// A::virt_fun<const char*> в C.obj
// A::virt_fun<int>         в D.obj
// таким образом, таблица виртуальных функций для класса A готова.
// Далее, исходя из информации о структуре класса B линковщик знает, что для каждой инстанцированой функции A::virt_fun должна
// существовать соответствующая функция B::virt_fun. Линковщик ищет реализацию B::virt_fun<const char*> и B::virt_fun<int>, но не 
// находит, поэтому сообщает программисту, что реализации этих функций не найдены.
// Видя такое дело, программист создаёт ещё один файл, в котором пишет код заставляющий компилятор создать указанные реализации,
// которых не хватает. Что это за код - сейчас стандартом не определено, но можно предложить, например, такой синтаксис:

// file: B_impl.cpp
#include "B.hpp"

//virtual
void B::virt_fun<const char*>(const char*) = default;

//virtual
void B::virt_fun<int>(int) = default;
// компиляция этого файла инстанцирует метод B::virt_fun<const char*> и метод B::virt_fun<int>


// После компиляции программист перезапускает линковку добавив B_impl.obj в параметры.
// На стадии поиска реализаций B::virt_fun линковщик находит:
// B::virt_fun<const char*> в B_impl.obj
// B::virt_fun<int>         в B_impl.obj
// B::virt_fun<float>       в E.obj
//
// Таким образом у линковщика есть вся необходимая информация для построения таблиц виртуальных функций и реализация этих функций:

// Для класса A:
//   A::virt_fun<const char*> в C.obj
//   A::virt_fun<int>         в D.obj
// Для класса B:
//   B::virt_fun<const char*> в B_impl.obj
//   B::virt_fun<int>         в B_impl.obj
//   B::virt_fun<float>       в E.obj

template <generic T>
class C
{
public:
    T c;
};

MD>template <generic T>
MD>class C
MD>{
MD>public:
MD>    T c;
MD>};
MD>

generic<class T>
class C
{
  T* c; // обязательное требование к параметризованным классам - независимость лэяута от параметра
public:
  virtual void set(T* x)   { c = x; }
  virtual T*   get() const { return c; }

  generic<class U> where
    U : DefaultConstructible<U>, // это значит, что в функцию init будет неявно передан словарь внешних операций над U, содержащий new
    U : T // это просто ограничение на тип - подсказка компилятору
  void init();
};

////// в таком случае реализацию можно будет вытащить прочь

generic<class T> generic<class U> void C<T>::init<U>() { set(new U); }

class C_gen
{
  void* c;
public:
  virtual void set(void* x) { c = x; }
  virtual void* get() const { return c; }
  virtual void init(DefaultConstructible* traits) { set(traits->call_new()); }
};

template<class T> class C_facade : public C_gen
{
public:
  void set(T* x) { C_gen::set(x); }
  T* get() const { return (T*)C_gen::get(); }
  template<class U> void init() { C_gen::init(DefaultConstructible_impl<U>::instance()); }
};

//virtual
void B::virt_fun<std::string>(std::string) = 0;

void B::virt_fun<int>(int) = default;

W>//virtual
W>void B::virt_fun<std::string>(std::string) = 0;
W>

BFE>void B::virt_fun<int>(int) = default;
BFE>

void С<int>::virt_fun<int>(int) = default;
void С<int>::virt_fun<float>(float) = default;
void С<float>::virt_fun<int>(int) = default;
void С<float>::virt_fun<float>(float) = default;
void С<some_traits<0>::type>::virt_fun<int>(int) = default;
void С<some_traits<0>::type>::virt_fun<float>(float) = default;
// .... and so on.

void make_some_virt(A* a)
{
  a->virt_fun(std::string("Hello!"));
}

class A
{
  // Такая функция буде сгенерирована для каждого наследника класса А, если она не определена явно или не помечена как =delete;
  virtual size_t size() const auto
  {
    return sizeof(*this);
  }
};

class A
{
  // Не-виртуальный шаблон, который по сути будет виртуальным
  template<typename T>
  void virt_impl(T x)
  {
    std::cout << x;
  }

  // Тот же суррогат виртуальности, только один раз записан
  virtual void virt_fun(int x) const auto {virt_impl(x);}
  virtual void virt_fun(float x) const auto {virt_impl(x);}
  virtual void virt_fun(std::string x) const auto {virt_impl(x);}
};

class B : public A
{
  // Переопределили реализацию, валидна не для всех типов
  template<typename T>
  void virt_impl(T x)
  {
    std::cout << x * x;
  }

  // Удаляем реализацию для строки, будет вызвана базовая.
  virtual void virt_fun(std::string x) const auto = delete;
}

W>void С<int>::virt_fun<int>(int) = default;
W>void С<int>::virt_fun<float>(float) = default;
W>void С<float>::virt_fun<int>(int) = default;
W>void С<float>::virt_fun<float>(float) = default;
W>void С<some_traits<0>::type>::virt_fun<int>(int) = default;
W>void С<some_traits<0>::type>::virt_fun<float>(float) = default;
W>// .... and so on.
W>

// file: virt_fun_impl.hpp
#include "C.hpp"
#include "D.hpp"
#include "E.hpp"
// end of file: virt_fun_impl.hpp

W>Так кто из двух программистов из примера выше сделал ошибку? Первый, написавший logger->write<MyNewType> её не сделал, так как MyNewType удовлетворяет всем ограничениям базового класса. Второй вообще код не менял. Код сам сломался. Или, быть может, их ошибкой была сама идея использовать виртуальные шаблонные функции!? Я уже почти уверен, что именно это

template <class T> void f(T t);

int main(int argc, char* argv[])
{
  f(1);
  return 0;
}

BFE>>Ничто не мешает определить несколько специализаций и для шаблонной виртуальной функции.

class HolderBase
{
  public:
    template <class Fn>
    virtual void Dispatch(Fn f)
    {
      // it should call Holder<T>::Dispatch(f);
    }
};


template <class T>
class Holder : public HolderBase
{
  public:
    Holder(const T& t)
      : m_t(t)
    {
    }

    template <class Fn>
    virtual void Dispatch(Fn f)
    {
      f(t);
    }
  private:
    T m_t;
};


class Queue
{
  public:
    template <class T>
    void push(T t)
    {
        m_queue.push(new Holder<T>(t));// TODO smart ptr?
    };

    template <class TDispatcher>
    void pop(TDispatcher oDispatcher)
    {
        assert(!m_queue.empty());

        HolderBase* p = m_queue.front(); // TODO RAII
        m_queue.pop();
        p->Dispatch(oDispatcher);
        delete p;
    };

    bool empty() const
    {
        return m_queue.empty();
    }
  private:
    std::queue<HolderBase*> m_queue;
};

#include <assert.h>
#include <iostream>
#include <queue>
#include <string>


class HolderBase
{
  public:
    template <class Fn>
    void Dispatch(Fn f)
    {
      // it should call Holder<T>::Dispatch(f);
    }
};


template <class T>
class Holder : public HolderBase
{
  public:
    Holder(const T& t)
      : m_t(t)
    {
    }

    template <class Fn>
    void Dispatch(Fn f)
    {
      f(t);
    }
  private:
    T m_t;
};


class Queue
{
  public:
    template <class T>
    void push(T t)
    {
        m_queue.push(new Holder<T>(t));// TODO smart ptr?
    };

    template <class TDispatcher>
    void pop(TDispatcher oDispatcher)
    {
        assert(!m_queue.empty());

        HolderBase* p = m_queue.front(); // TODO RAII
        m_queue.pop();
        p->Dispatch(oDispatcher);
        delete p;
    };

    bool empty() const
    {
        return m_queue.empty();
    }
  private:
    std::queue<HolderBase*> m_queue;
};


//-------------------------------------------------------------------------------------------DispatcherSet

template<class ...TDispatchers> 
class DispatcherSet;

template<class TDispatcher, class ...TDispatchers> 
class DispatcherSet<TDispatcher, TDispatchers...> : public TDispatcher, public DispatcherSet<TDispatchers...>
{
  public:
    DispatcherSet(TDispatcher oDispatcher, TDispatchers... oDispatchers)
      : TDispatcher                   (oDispatcher),
        DispatcherSet<TDispatchers...>(oDispatchers...)
    {
    }

    using TDispatcher::operator();
    using DispatcherSet<TDispatchers...>::operator();
};


template<class TDispatcher>
class DispatcherSet<TDispatcher> : public TDispatcher
{
  public:
    DispatcherSet(TDispatcher oDispatcher)
      : TDispatcher(oDispatcher)
    {
    }

    using TDispatcher::operator();
};


template<class ...TDispatchers> 
DispatcherSet<TDispatchers...> CreateDispatchers(TDispatchers... oDispatchers)
{
  return DispatcherSet<TDispatchers...>(oDispatchers...);
}

//-------------------------------------------------------------------------------------------

void IntLog(int n)
{
  std::cout << "IntLog: n = " << n << std::endl;
}


void StrLog(const std::string& str)
{
  std::cout << "StrLog: str = " << str << std::endl;
}
//-------------------------------------------------------------------------------------------


int main(int argc, char* argv[])
{
    Queue q;

    int n = 0;
    std::string str("asdf");
    q.push(n);
    q.push(str);

    auto oDispatcher = CreateDispatchers(
                                         [](int                n  ){ IntLog(n);   },
                                         [](const std::string& str){ StrLog(str); },
                                         [](float              f  ){ std::cout << "float = " << f << std::endl; }
                                        );
    // test
    //oDispatcher(n);
    //oDispatcher(n);
    //oDispatcher(str);

    while(!q.empty())
      q.pop(oDispatcher);

    return 0;
}

class X
{
public:
  template<typename T>
  virtual void foo() {}

  template<typename T>
  virtual void bar() {}

  virtual void omg() {}
};

void f(X* px)
{
  x->omg();
}