Why is it so that for creating function template specialization we don’t need to have template<> keyword
Like you have explained in previous tutorial :

void Storage<double>::Print()
{
std::cout << std::scientific << m_tValue << std::endl;
}

But for class template specialization we need the template <> keyword

template <>
class Storage8<bool>
{ ...};

Few questions…
1. Can I specialize a class template’s member function? For example, let’s say I have a class template like this:

template<class A, class B, class C> MyClass;

For B=int, some member functions need to have special implementations. Can I define

template<class A, class B, class C> void MyClass<A,B,C>::func() {...}

and then just define a special implementation like this:

template<class A, class C> void MyClass<A,int,C>::func() {...}

It it possible?

2. MyClass’s functions have few different implementations. And the interface is different too. One method is defining each version as a different class, but what if I’d like to use a template instead? in template, impl is the implementation’s number. Can I define a general class definition:

template<class A, class B, int impl> class MyClass { ... };

And then define a specialization for impl=1 like this:

template<class A, class B> class MyClass<A,B,1> { ... };

Is it possible?

3. If yes, let’s say MyClass is a template like this:

template<class A, class B, class C> class MyClass { ... };

For A=int, I’d like to specialize this class template:

template<class B, class C> class MyClass<int,B,C> { ... };

For A=int and C=double, I’d like to have another specialization: (but for A=int and C!=double I’d like the compiler to use the first specialization)

template<class B> class MyClass<int,B,double> { ... };

And I’d also like to have a full specialization like this:

template<> class MyClass<int,char*,double> { ... };

Do compilers ready to handle such sets of specializations?

template MyClass;

For B=int, some member functions need to have special implementations. Can I define
template void MyClass::func() {…}

template void MyClass::func() {…}

template class MyClass { … };

Do compilers ready to handle such sets of specializations?

Similarly, ob[i] will work if operator[] has been overridden for class A.

..while C++ gives us free reign to add, remove, or change functions of Storage8<bool&gt as we see fit, keeping a consistent..

[ Fixed. Thanks for noticing. -Alex ]