How do I externalise the conversion operator? - c++

Question

How do I make it so the following code is externalised outside the class:
template<typename TemplateItem>
class TestA
{
operator const int (){return 10;}
};
So it appears like:
template<typename TemplateItem>
class TestA
{
operator const int ();
};
template<>
TestA<int>::operator const int()
{
//etc etc
}
So I can specialise the function for different templated types?

Answer 1

Write this:
template <typename T> class TestA
{
operator const int();
};
template <typename T> TestA<T>::operator const int()
{
return 10;
}
The standard antonym of "inline" is usually "out of line", by the way. Also, I'd probably make the function const, as one usually does with conversion operators (to allow conversions from constant objects).
You can either specialize the entire class, or just the member function. For the member function only, write this:
template <> TestA<int>::operator const int() { /* ... */ }
For the entire class specialization, the syntax is this:
template <> class TestA<int>
{
operator const int();
};
TestA<int>::operator const int() { /*...*/ }

Answer 2

I don't think you can specialize a non-template function of a template class without specializing the whole class. Which means you have to cheat. Simplist way is to move most of the implementation to a "Base" class, (everything that the two share), and have TestA inherit from that base class, and only define the functions that need specializing.
//general base
template<typename TemplateItem>
class TestABase
{
protected:
TemplateItem data;
};
//non specialized members
template<typename TemplateItem>
class TestA: public TestABase<TemplateItem>
{
public:
operator const int ();
};
//specialized members
template<>
class TestA<int> : public TestABase<TemplateItem>
{
public:
operator const int ();
};
//implementations
template<typename TemplateItem>
TestA<TemplateItem>::operator const int()
{
return data;
}
template<>
TestA<int>::operator const int()
{
return data;
}

Answer 3

First off, declare and define the primary templates as follows:
template<typename T>
class TestA
{
public:
operator int() const;
};
template<typename T>
TestA<T>::operator int() const
{
return -1;
}
Regarding specialization, the C++03 standard §14.5.1.1/1 tells us that non-template member functions (and constructors!) of a class template are themselves considered function templates:
A member function of a class template may be defined outside of the class template definition in which it is declared. [Example:
template<class T> class Array {
T* v;
int sz;
public:
explicit Array(int);
T& operator[](int);
T& elem(int i) { return v[i]; }
// ...
};
declares three function templates. The subscript function might be defined like this:
template<class T> T& Array<T>::operator[](int i)
{
if (i<0 || sz<=i) error("Array: range error");
return v[i];
}
—end example]
Consequently, they can be specialized without also specializing the rest of the primary class template (unlike if you were to specialize, explicitly or partially, the class template itself):
template<>
TestA<int>::operator int() const
{
return 5;
}
template<>
TestA<double>::operator int() const
{
return 3;
}
Full demo