class CFoo
{
public:
    template<class TYPE>
    CFoo(void)
        {
        };

    virtual ~CFoo(void){};
};

template<class T> struct type2type {};

class Foo
{
public:
  template<class T> explicit Foo(type2type<T> dummy) {.....}
  // или так
  template<class T> explicit Foo(T* dummy) {.....}
};

void f(Foo);

.....

Foo obj( (type2type<int>()) ); // обратите внимание на лишние скобки. Без них эта конструкция будет трактоваться как объявление функции.
Foo* ptr = new Foo(type2type<int>());
f(Foo(type2type<int>()));
// или так
Foo obj((int*)NULL);
Foo* ptr = new Foo((int*)NULL);
f(Foo((int*)NULL));

// а если убрать explicit, то, соответственно,
Foo obj = type2type<int>(); // здесь незримо присутствует ещё и конструктор копирования
f(type2type<int>());
// или
Foo obj = (int*)NULL;
f((int*)NULL);

//В *.h файле

template<int val>
class CFoo
{
public:
    CFoo(void);
    void init();
};

//В *.cpp файле
template<int val>
CFoo<val>::CFoo(void)
{
}

template<int val>
void CFoo<val>::init()
{
    cout<<0<<endl;
}

//Как перегрузить для val == 2 ???
//пробую так - ошибка 
template<int val>
void CFoo<2>::init()
{

}

А>//В *.h файле

А>template<int val>
А>class CFoo
А>{
А>public:
А>    CFoo(void);
А>    void init();
А>};

А>//В *.cpp файле
А>template<int val>
А>CFoo<val>::CFoo(void)
А>{
А>}

А>template<int val>
А>void CFoo<val>::init()
А>{
А>    cout<<0<<endl;
А>}

А>//Как перегрузить для val == 2 ???
А>//пробую так - ошибка 
А>template<int val>
А>void CFoo<2>::init()
А>{

А>}
А>

template <>
class CFoo<2>
{};

#include <iostream>

template<class T, class U>
struct A
{
    void fn()
    {
        std::cout << "primary\n";
    }
};

template<>
void A<short, float>::fn()
{
    std::cout << "specialization\n";
}

int main()
{
    A<int, float> a;
    A<short, float> b;
    a.fn(); // primary
    b.fn(); // specialization
}

class A
{
public:

  template <typename T, typename U>
  void f();
};

template <typename T>
void A::f<T, int>(){}

template<calss ItemClass, class BaseEnumClass>
class C1 : public BaseEnumClass
{
...
//отличия только в этих фукнциях шаблона в зависимости от класса
    HRESULT CloneItem(ItemClass &dest, const ItemClass &source);
    void DestroyItem(ItemClass item);
....
};
......
//реализация для конкретных классов вот такая 
template<>
HRESULT Enumeration<T1, Class1>::CloneItem(T1 &dest, const T1 &source)
{
.....
    return S_OK;
}

template<>
void Enumeration<T1, Class1>::DestroyItem(T1 item)
{
...
}