Template<> confusion

[SoilMan]

Consider the following:

class xyz
{
public:
template <typename T>
void foo(T x)
{
cout << "foo<T> " << x << endl;
}

template <> // remove this line or not?
void foo(int x)
{
cout << "foo<int> " << x << endl;
}
};

This code compiles on MS VS C++ 2003 and Intel C++ 9 but not on Dev-C++
4.9.9.2. However, if I comment out the line "template<>", it compiles
fine on all 3 compilers.

Can someone please explain what is the standard C++ on this matter?
Thank you.

Chris

 

[Sumit Rajan]

Consider the following:

class xyz
{
public:
template <typename T>
void foo(T x)
{
cout << "foo<T> " << x << endl;
}

Move the following out of this scope:

template <> // remove this line or not?
void foo(int x)
{
cout << "foo<int> " << x << endl;
}
};

and place it here:

template <>
void xyz::foo(int x)
{
cout << "foo<int> " << x << endl;
}

Regards,
Sumit.

 

[dc]

There is no need to place template <> when u defining a specific
implementation.

 

[Maxim Yegorushkin]

Consider the following:

class xyz
{
public:
template <typename T>
void foo(T x)
{
cout << "foo<T> " << x << endl;
}

template <> // remove this line or not?
void foo(int x)
{
cout << "foo<int> " << x << endl;
}
};

This code compiles on MS VS C++ 2003 and Intel C++ 9 but not on Dev-C++
4.9.9.2. However, if I comment out the line "template<>", it compiles
fine on all 3 compilers.

Can someone please explain what is the standard C++ on this matter?

A specialization of member template can only be declared out of the
class definition.

Anyway, you don't need specialization here, function overloading would
suffice.

 

[Rolf Magnus]

There is no need to place template <> when u defining a specific
implementation.

It depends on what you want. If you don't place the template<>, you get an
overload instead of a specialization.

 

[red floyd]

Move the following out of this scope:

and place it here:

template <>
void xyz::foo(int x)
{
cout << "foo<int> " << x << endl;
}

Just out of curiosity, shouldn't it be:

template<>
void xyz::foo<int>(int x)
{
cout << "foo<int> " << x << endl;
}

 

[Sumit Rajan]

Sumit Rajan wrote:

Just out of curiosity, shouldn't it be:

template<>
void xyz::foo<int>(int x)
{
cout << "foo<int> " << x << endl;
}

IIRC, it is not necessary.

Regards,
Sumit.

 

[dc]

Can someone explain when u need overloaded version / specialization of
a template. And
how does it differs...

 

[Marcelo Pinto]

Rolf Magnus escreveu:

It depends on what you want. If you don't place the template<>, you get an
overload instead of a specialization.

IIRC, in either case you get an overload, for there is no such thing as
function template specialization.

Please advise me if I got it wrong.

TIA,

Marcelo Pinto.

 

[dc]

Ya , for function it doesnot matter. If both implemented , overload
will be preferred over
specialization.
But for class template, only specialization is the solution.

 

[Marcelo Pinto]

dc wrote:

Please, do cote what you are replying to.

Ya , for function it doesnot matter. If both implemented , overload
will be preferred over
specialization.

IIRC, there is *no* such thing as function template specialization,
just function template overloading. Please, advise me if I am wrong.

But for class template, only specialization is the solution.

Agreed, for there is no "overloaded class".

Regards,

Marcelo Pinto

 

[dc]

IIRC, there is *no* such thing as function template specialization,
just function template overloading. Please, advise me if I am wrong.

No body prevents u from implementing the function template
specialization.
template <class T>
void func(T i){
}

//Here is function template specialization
template <>
void func(int i){
cout << "func spec" <<endl;
}

void func(int i){
cout << "func overload" <<endl;
}

 

[Marcelo Pinto]

dc escreveu:

No body prevents u from implementing the function template
specialization.
template <class T>
void func(T i){
}

//Here is function template specialization
template <>
void func(int i){
cout << "func spec" <<endl;
}

void func(int i){
cout << "func overload" <<endl;
}

I am sory, I recalled it incorrectly. You can't partial specialize a
function template, but you *can* full specialize a function template.

Sory,

Marcelo Pinto

 

[Rolf Magnus]

Can someone explain when u need overloaded version / specialization of
a template. And
how does it differs...

I'd prefer specialization to avoid confusion. Consider this:

#include<iostream>

template <typename T>
void test(T value)
{
std::cout << "not a short\n";
}

void test(short value)
{
std::cout << "a short with value " << value << '\n';
}

int main()
{
test<short>(2);
}

If the template argument cannot be deduced from the function arguments, you
can't even use the overload version.

 

[Marcus Kwok]

I'd prefer specialization to avoid confusion. Consider this:

#include<iostream>

template <typename T>
void test(T value)
{
std::cout << "not a short\n";
}

void test(short value)
{
std::cout << "a short with value " << value << '\n';
}

int main()
{
test<short>(2);
}

If the template argument cannot be deduced from the function arguments, you
can't even use the overload version.

However, you can still call the overload version by explicitly
indicating the type of the argument by using

test(static_cast<short>(2));