// a.h
// Real implementation
template<typename T>
struct ax
{
 void f(T t);
};

// Specializations implementation
struct aint : ax<int>
{
 typedef ax<int> base;
 void f(int t);
};

struct along : ax<long>
{
 typedef ax<long> base;
 void f(long t);
};

// Selector
// Можно через mpl::if_<is_same...>
template<typename T>
struct a_selector;

template<>
struct a_selector<int>
{
 typedef aint type;
};

template<>
struct a_selector<long>
{
 typedef along type;
};

// Class Template
template<typename T>
struct a  : a_selector<T>::type
{
};

// a.cpp
#include <iostream>

// Real implementation
template<typename T>
void ax<T>::f(T t)
{
 std::cout << t << "\n";
}

// Specializations implementation
void aint::f(int t)
{
 base::f(t);
}

void along::f(long t)
{
 base::f(t);
}

// main.cpp
#include "a.h"

int main()
{
 a<int> x;
 x.f(1);

 a<long> y;
 y.f(1L);
}

Нужно писать реализацию методов класса.

Сообственно вопрос состоит в том как недостатки убрать, например с помощью препроцессора

КЛ>>>>>Сообственно вопрос состоит в том зачем это надо?

__>>>>Когда все в заголовочных файлах появляется проблема рекурсивного включения файлов

__>>>>А так ее не будет.

__>>export помог бы, но поддержка компиляторами нужна

КЛ>Опиши проблему, может я невпопад

template<typename T>
struct string_traits;

template<typename T, typename Traits = string_traits<T> >
struct string;

// string_traits.hpp
#include <string.hpp>

template<typename T>
struct string_traits;

// string.hpp
#include <string_traits.hpp>

template<typename T, typename Traits = string_traits<T> >
struct string;

__>>// string_traits.hpp
__>>#include <string.hpp>//это зачем?

__>>template<typename T>
__>>struct string_traits;
__>>

__>>// string.hpp
__>>#include <string_traits.hpp>

__>>template<typename T, typename Traits = string_traits<T> >
__>>struct string;
__>>

__>>Придется использовать указатель или умный указатель, который поддерживает неполные типы.

// string_traits.hpp
template<typename T>
struct string;

//...

>>> Ясно

>>> Как обойти ?

> Посему и вопрос как можно улучшить, допустим через препроцессор, генерацию кода в моем подходе

//a.h

//Класс для контроля типов, с которыми инстанцируется шаблон класса объекта
//Дается только лишь предварительное объявление.
//Полные объявления даются только для разрешенных специализаций
template<typename T> class selector; 

//Шаблон класса объекта
template<typename T> 
struct a : selector<T>
{
  void f(T t);
};

//Разрешенные типы для инстанцирования (можно одеть в макрос)
template<> class selector<int>{};
template<> class selector<long>{};
template<> class selector<double>{};

//a.cpp
#include "a.h"

//основной шаблон
template<typename T>
void a<T>::f(T t)
{
  std::cout << t << std::endl;
};

//специализация для double
void a<double>::f(double t)
{
  std::cout << "double: " << t << std::endl;
}

//Явное инстанцирование классов, порождаемых основным шаблоном
template struct a<int>;
template struct a<long>;

#include "a.h"

int main()
{
  a<int> i;
  a<long> l;
  a<double> d;
  //a<char> c; //Ошибка: 'selector<T>' : base class undefined
  
  i.f(333);
  l.f(555);
  d.f(7.77);
}

333
555
double: 7.77

// a.h
...

// a.cpp

#include "a_t.cpp"

...

// a_t.cpp
#include "a.h"

template<typename T>
void a<T>::f(T t)
{
}

// a_char.h
#include "a.h"

template<> struct selector<char>{};

// a_char.cpp
#include "a.h"
#include "a_t.cpp"

template struct a<char>;

// main.cpp
#include "a.h"
#include "a_char.h"

int main()
{
 a<char> x;
}