Some basic template problems in C++ - c++

Question

I meet with 3 questions when coding C++ with templates. It seems that VS2013 can compile the code below.
Code here:
//template_test.h
#include <iostream>
using namespace std;
template<class T>
class mytest
{
public:
void method(T input);
void common();
};
template <>
class mytest<char>
{
public:
void method(char input);
void common();
};
template<class T>
void mytest<T>::method(T input)
{
cout << input << endl;
}
template<class T>
void mytest<T>::common()
{
cout << "common" << endl;
}
//template_test.cpp
#include "template_test.h"
void mytest<char>::method(char input)
{
cout << "char:" << input << endl;
}
void mytest<char>::common()
{
cout << "common" << endl;
}
//main.cpp
#include "template_test.h"
using namespace std;
int main()
{
mytest<char> test_char;
test_char.method('1');
test_char.common();
mytest<int> test_int;
test_int.method(1);
test_int.common();
system("pause");
return 0;
}
1.In the implementation of mytest::method
template<class T>
void mytest<T>::method(T input)
{
cout << input << endl;
}
Can I erase the second T for short expression? I try the following code instead of original cpp in VS2013,and fail to compile.
template<class T>
void mytest::method(T input)
{
cout << input << endl;
}
It seems so strange that I need to use it in such a complicated form with so many template parameters.
2.In .h file,I delclare the Class 'mytest' using Template Specialization with
template <>
class mytest<char>
{
public:
void method(char input);
void common();
};
and the implementation of each function is in
//template_test.cpp
#include "template_test.h"
void mytest<char>::method(char input)
{
cout << "char:" << input << endl;
}
void mytest<char>::common()
{
cout << "common" << endl;
}
My question is , when I put the implementation in .h file other than in .cpp file together with the implementation of non-specialization template class, VS2013 will also report the error code.
I know the the declaration and implementation of non-specialization template class should be in the same header, for the reason c++ should not permit the expicit of non-specialization template class in other file. But why the declaration and implementation of specialization template class should be in the different code files ?
3.In the header file
template<class T>
class mytest
{
public:
void method(T input);
void common();
};
template <>
class mytest<char>
{
public:
void method(char input);
void common();
};
It is obvious that the function 'common' are the common part of the specialization and non-specialization template class. However, the specialization will specialize the whole class. I just want to reserve the common function ,so there is no need to write the same function in the specialization version. I have no idea how to get it.
I am a newbie in the field of programming with c++ template, and the 3 questions above are basic and easy. I search some questions in Google but still have no idea. So I post my questions here.

Answer 1

Can <T> be omitted from template <typename T> void mytest<T>::method(T input)?
No. Although it seems redundant in simple cases, it becomes necessary in more complex case, e.g., when there are multiple partial specializations are around. Keeping the syntax consistent is also helpful.
When putting the definition of a member function of a fully specialized class template into the header, there is "the" error (I assume you get multiply declared symbols).
The member functions of a fully specialized class template are treated like member functions of a non-class template: there is only one version and the compiler will never need to implicitly instantiate it. Thus, the function is not implicitly inline like it is the case for anything which is a function template and may need to be instantiated by the compiler. If you want to put the definition into the header, you'll need to explicitly declared it as inline.
How can I share a function between a class template and its specialization?
Except for the syntax a class template and any of its specializations have nothing in common. They are entirely separate class. There are two approach to share common functionality between different specializations:
Put the common functionality into a common base class and implement the logic there. If the functionality needs to access members of the actual template, you can use the curiously recurring template pattern to give the base class access to the specialization.
Don't make the common functionality a member function but make it a function template accepting any of the specializations.
Depending on what your common functionality needs to do one or the other approach works better.

Answer 2

A small addition to Dietmar Kühl's answer to 1. Feel the difference:
Implementation of the method of the non-specialized class template template <class T> class mytest:
template <class T>
void mytest<T>::method(T input)
{
// ...
// use of input
}
Implementation of the method of the partial class template specialization template <class T> class mytest<T*> for pointers to objects:
template <class T>
void mytest<T*>::method(T* input)
{
// ...
// use of *input
}
Implementation of the method of the partial class template specialization template <class U, class V> class mytest<U V::*> for pointers to another class data members:
template <class U, class V>
void mytest<U V::*>::method(V& object, U V::* input)
{
// ...
// use of object.*input
}
Implementation of the method of the full class template specialization template <> class mytest<char>:
void mytest<char>::method(char input)
{
// ...
// use of input
}
Implementation of the fully specialized method of the non-specialized class template template <class T> class mytest<T>:
template <>
void mytest<int>::method(int input)
{
// ...
// use of input
}