//header.h
template<typename T>
class C {
public:
    void memberFunction();

    template <typename S>
    void templateMemberFunction();
};

//main.cpp
#include<header.h>

...
    C<int> c;
    c.memberFunction();
    c.templateMemberFunction<double>();

//class_implementation.cpp
#include<header.h>

template<>
void C<int>::memberFunction() {
}

template <>
template <>
void C<int>::templateMemberFunction<double>() {
}

//class_implementation.cpp
void this_function_is_not_used_anywhere() {
    C<int> c;
    c.memberFunction();
    c.templateMemberFunction<double>();
}

//class_implementation.cpp
template void C<int>::memberFunction();

//class_implementation.cpp
template class C<int>;

//class_implementation.cpp
template void C<int>::templateMemberFunction<double>();

E>//class_implementation.cpp
E>template class C<int>;
E>

E>//class_implementation.cpp
E>template void C<int>::templateMemberFunction<double>();
E>

template class C<int>;
template void C<int>::templateMemberFunction<double>();

E>//class_implementation.cpp
E>#include<header.h>

E>template<>
E>void C<int>::memberFunction() {
E>}

E>template <>
E>template <>
E>void C<int>::templateMemberFunction<double>() {
E>}
E>

template<>
void C<int>::memberFunction();

template <>
template <>
void C<int>::templateMemberFunction<double>();

• если тело функции размещается в cpp-файле, то для возможности использования функции в других единицах трансляции, необходимо объявить ее в заголовочном файле;
  
• если тело функции размещается в заголовочном файле, то необходимо использовать ключевое слово inline.

E>//class_implementation.cpp
E>template void C<int>::templateMemberFunction<double>();
E>

extern template void C<int>::templateMemberFunction<double>();

6 If a template, a member template or a member of a class template is explicitly specialized then that
specialization shall be declared before the first use of that specialization that would cause an implicit
instantiation to take place, in every translation unit in which such a use occurs; no diagnostic is required. If
the program does not provide a definition for an explicit specialization and either the specialization is used in
a way that would cause an implicit instantiation to take place or the member is a virtual member function,
the program is ill-formed, no diagnostic required. An implicit instantiation is never generated for an explicit
specialization that is declared but not defined. [ Example:

class String { };
template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v) { /* ... */ }
void f(Array<String>& v) {
  sort(v); // use primary template sort(Array<T>&), T is String
}
template<> void sort<String>(Array<String>& v); // error: specialization after use of primary template
template<> void sort<>(Array<char*>& v); // OK: sort<char*> not yet used
template<class T> struct A {
  enum E : T;
  enum class S : T;
};
template<> enum A<int>::E : int { eint }; // OK
template<> enum class A<int>::S : int { sint }; // OK
template<class T> enum A<T>::E : T { eT };
template<class T> enum class A<T>::S : T { sT };
template<> enum A<char>::E : char { echar }; // ill-formed, A<char>::E was instantiated
// when A<char> was instantiated
template<> enum class A<char>::S : char { schar }; // OK

— end example ]
7 The placement of explicit specialization declarations for function templates, class templates, variable templates,
member functions of class templates, static data members of class templates, member classes of class templates,
member enumerations of class templates, member class templates of class templates, member function
templates of class templates, static data member templates of class templates, member functions of member
templates of class templates, member functions of member templates of non-template classes, static data
member templates of non-template classes, member function templates of member classes of class templates,
etc., and the placement of partial specialization declarations of class templates, variable templates, member
class templates of non-template classes, static data member templates of non-template classes, member class
templates of class templates, etc., can affect whether a program is well-formed according to the relative
positioning of the explicit specialization declarations and their points of instantiation in the translation unit
as specified above and below. When writing a specialization, be careful about its location; or to make it
compile will be such a trial as to kindle its self-immolation.

E>Подробности, конечно, присутствуют. Там и не void возвращается, а другой темплейтный класс. И не всегда возвращается, т.к. метод существует не всегда, а только когда условие в enable_if выполняется, а выполняется это не для каждого типа. И типы далеко не int и double . Но эти подробности я убрал, причем не только в данном искусственном примере, но и в своем коде ради эксперимента.

//header.h
template<typename T>
class C {
public:
    inline void memberFunction();

    template <typename S>
    inline void templateMemberFunction();
};

//header.h
template<typename T>
class C {
public:
    void memberFunction();

    template <typename S>
    void templateMemberFunction();
};

template<>
void C<int>::memberFunction() {
}

template <>
template <>
void C<int>::templateMemberFunction<double>() {
}

//header.h
template<typename T>
class C {
public:
    inline void memberFunction();

    template <typename S>
    inline void templateMemberFunction();
};

template<>
void C<int>::memberFunction() {
}

template <>
template <>
void C<int>::templateMemberFunction<double>() {
}