#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