C++ class nested into template class - c++

Question

So I have some problems with my template class.
<!-- language: lang-c++ -->
template<class T>
class List {
class Counter
{
T real;
T imaginary;
Counter *next;
//....
public:
Counter(T a=0,T b=0);
virtual ~Counter();
friend ostream& operator<<(ostream&,Counter&);
friend ostream& operator<<(ostream&,List&);
};
Counter* first;
Counter* last;
//....
};
But I have some problems with methods. If i write function as
template<class T> Counter operator/(Counter &one,...)
When I look at Counter in VC++10 it says something like
<error_type>&one
for example. Should I use template<class T> for my Counter class everywhere in the code?
//Methods
//Counter. For example some methods
Counter operator/(Counter& one,Counter& two){}
ostream& operator<<(ostream&os,Counter&x){}
istream& operator>>(istream&is,Counter&x){}
//List
template<class T>void List<T>::add(Counter *T,int i,bool c){}

Answer 1

It depends on whether you define the operators (regardless of whether they are member functions or global operators) inside the class definition or outside of it.
If you do it inside the class definition, there is no need for template<T>, nor for List<T>:
template <typename T>
class List
{
public:
class Counter
{
/* This is a global operator* defined inside the class, and
as friend. */
friend Counter operator*(const Counter &c1, const Counter &c2)
{
return Counter();
}
};
};
(Note that my definition of operator* isn't actually useful because it always returns an empty Counter object. This is just to demonstrate the syntax.)
But if you define the operator outside the class (and therefore outside the template definition for List as well), you have to use the full syntax of a function template definition:
template <typename T>
typename List<T>::Counter operator/(const typename List<T>::Counter &c1, const typename List<T>::Counter &c2)
{
return List<T>::Counter();
}
As you can see, this involves three steps:
Put template <....>, with the names of all template parameters enclosed in <...> before the definition.
Use List<T>::Counter to indicate that Counter is a nested typename
Use typename List<T>::Counter because Counter is nested into a dependent type (i.e. a type that depends on a template argument).