C++Talk.NET

Matt Young · Guest

If I have a template function with one template parameter, is there a
way to specialize or overload it to handle the case where that
parameter is a std::pair?

For example, suppose I have the following function:

template<typename Entry>
void WriteEntry(Entry const & entry) {
std::cout << "[" << entry << "]";
}

I would like to write a version that takes a std::pair as its
parameter. (The caller is itself a templated function that iterates
over a std::set or a std::map to write out all its entries in a
specified number of columns.) However, if I naively write:

template void WriteEntry(std::pair<Left, Right> const & entry) {
std::cout << "[" << entry.first << ", " << entry.second << "]";
}

then the compiler complains that neither of the two overloads has the
best conversion.

Is there a way to get this to work, or should I be taking a different
approach altogether? (I can think of a few run-time ways of solving
the problem, but it would be more elegant to deduce which output
function to call at compile time.)

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Antoun Kanawati · Guest

Matt Young wrote:

Kodt · Guest

This is an overload, not specialization. One cannot specialize function
templates, this is prohibited by the Holy Standard :)

I examined following code:
#include <iostream>
#include <utility>
#include <typeinfo>

template<class T> char* foo(const T& t)
{
std::cout << "generic foo of " << typeid(t).name() << "n";
return "x";
}
template {
std::cout << "specific foo of " << typeid(t).name() << "n";
return 0;
}
int main()
{
char *x = foo(123); // generic
int y = foo(std::make_pair(1,2)); // specific
}

Comeau 4.3.3 online ( www.comeaucomputing.com/tryitout |
www.nixie.narod.ru/comeau ) compiled this,
while VC 6 sp6 failed, reporting "ambiguous call, none of overloads,
etc."

So, this is a problem of the compiler you use.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Kodt · Guest

If you are allowed to change a signature of your template, here is a
way to solve it:

template<class T>
void foo(T t, char dummy) // a prototype uses 'char'
{
cout << "base: " << typeid(t).name();
}

template void foo(pair<T,U> t, int dummy) // all quazy-specializations shall use
'int'
{
cout << "pair: " << typeid(t).name();
}

template void foo(T t)
{
foo(t,0); // specialization is preferred because it doesn't require
additional type conversion (int->char)
}

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Thomas Maeder · Guest

"Matt Young" <palaso (AT) gmail (DOT) com> writes:

Ben Hutchings · Guest

Matt Young <palaso (AT) gmail (DOT) com> wrote:

Kodt · Guest

VC6 (I believe Matt Young uses it) doesn't support partial
specialization.
Good compilers have no problems with both overloading of function
templates and partial specialization of class templates.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]