Overloading vs. specialization of function templates

[Govindan]

Hello all,

I'm trying to get a grasp of the difference between specializing a function
template and overloading it. The example below has a primary template, a
specialization and an overload. Note that the overload is identical to the
specialization except, of course, for the missing "template <>".

I don't know if my questions will be a bit too broad or not, but I thought
I'd give it shot... When is overloading preferable to specialization? When
is specialization preferable to overloading? What is the intended
conceptual difference between the two? Any other guidance on other things I
need to know but don't know enough yet to even ask?

Thanks everyone - this group has been an invaluable resource to me and I
sure appreciate the time of those who have so generously assisted me!

Thanks,
Dave


#include <iostream>

using namespace std;

struct foo
{
int data;

bool operator<(const foo &rhs) const
{
return data < rhs.data;
}
};

template <typename T>
const T &my_max(const T &a, const T &b)
{
cout << "Point 1" << endl;
return (a < b) ? b : a;
}

template <>
const foo &my_max(const foo &a, const foo &b)
{
cout << "Point 2" << endl;
return (a < b) ? b : a;
}

const foo &my_max(const foo &a, const foo &b)
{
cout << "Point 3" << endl;
return (a < b) ? b : a;
}

int main()
{
foo a = {5};
foo b = {10};

// Yields "Point 3" as non-templates are
// preferred.
cout << my_max(a, b).data << endl;

return 0;
}

I am not so clear about your question but here goes. I am using simple
examples
to explain the concepts.

Use composition ( has-a relationship,embedded objects ) over inheritance
(i.e specialisation of a base class).
If there are many related classes differing in the parameters only by the
type, then use templates.
Use operator or function overloading as a last resort.
As an example the sign plus can mean binary addition eg 4 + 7 or string
concatenation or adding
two graphic figures together depending on your program or class.
Thus in this case the plus sign token is an overloaded operator.

As an example for function overloading, lets say for a function
AverageOf3Numbers(param1, param2, param3 ,...)
where average can mean mean or median.
The AverageOf3Numbers( totalof3Numbers) function divides the param1 by 3 to
get the average, as in mean case;
in the other case,the median interpretation of average, all 3 numbers are
passed into the function as in,
AverageOf3Numbers(3 , 5, 8) function does a integer comparison and gives 5
as the median(average).

That is in your class definition, there are two AverageOf3Numbers( ) methods
declared.

However, if you just want to have one interpreation of the meaning of
average , as mean, but the types of the parameters differ,
use a template.
AverageOf3Numbers(integer1, integer2, integer3) ; AverageOf3Numbers(float1,
float2, float3) etc
Use a template class.
As an example of operator-loading, You can write your own complex nos. class
to add , subtract, divide and multiply
complex nos. In this class, all "+", "-", "*" and "/" will be overloaded ,
the methods will be written by you.

First check with a C++ standard book and a STL library book before writing
your own classes. The STL is template-based
and already has many useful methods , functions,functors you can use etc

Regards,
Govin

 

[Dave Theese]

Hello all,

I'm trying to get a grasp of the difference between specializing a function
template and overloading it. The example below has a primary template, a
specialization and an overload. Note that the overload is identical to the
specialization except, of course, for the missing "template <>".

I don't know if my questions will be a bit too broad or not, but I thought
I'd give it shot... When is overloading preferable to specialization? When
is specialization preferable to overloading? What is the intended
conceptual difference between the two? Any other guidance on other things I
need to know but don't know enough yet to even ask?

Thanks everyone - this group has been an invaluable resource to me and I
sure appreciate the time of those who have so generously assisted me!

Thanks,
Dave


#include <iostream>

using namespace std;

struct foo
{
int data;

bool operator<(const foo &rhs) const
{
return data < rhs.data;
}
};

template <typename T>
const T &my_max(const T &a, const T &b)
{
cout << "Point 1" << endl;
return (a < b) ? b : a;
}

template <>
const foo &my_max(const foo &a, const foo &b)
{
cout << "Point 2" << endl;
return (a < b) ? b : a;
}

const foo &my_max(const foo &a, const foo &b)
{
cout << "Point 3" << endl;
return (a < b) ? b : a;
}

int main()
{
foo a = {5};
foo b = {10};

// Yields "Point 3" as non-templates are
// preferred.
cout << my_max(a, b).data << endl;

return 0;
}

 

[Mike Wahler]

I had the same question sometime back and this is the reply from Bjarne
Stroustrup....

"For functions, you don't have to. Overloading will do. For classes, you don't
have an alternative. Note that when you specialize the specialzation doesn't
affect overload resolution rules, when you overload with a non-specialization,
overload resolution will prefer the non-specialization."

Vandevoordes & Josuttis' recent book "C++ Templates"
imo covers this and other template issues quite well.

I must admit it will take me at least a few passes through this
great book to absorb everything therein.

http://www.josuttis.com/tmplbook/index.html

-Mike

 

[tom_usenet]

Hello all,

I'm trying to get a grasp of the difference between specializing a function
template and overloading it. The example below has a primary template, a
specialization and an overload. Note that the overload is identical to the
specialization except, of course, for the missing "template <>".

I don't know if my questions will be a bit too broad or not, but I thought
I'd give it shot... When is overloading preferable to specialization?

Non-template overloads can be useful if you want the function to be
chosen in the face of conversions and non-exact parameter matches.

Also, because partial specialization doesn't exist for function
templates, you have to use overloading when you need a special
implementation for a subset of cases of a template.

When

is specialization preferable to overloading?

When you just want to provide a special implementation for a
particular type, but don't want to effect overload resolution.

What is the intended

conceptual difference between the two?

An overload adds a new function, a specialization just specializes an
implementation of a function you already have.

Any other guidance on other things I

need to know but don't know enough yet to even ask?

There's a bit more information here:
http://www.gotw.ca/gotw/049.htm

and a ludicrous amount of information about all sorts of C++ things
here:
http://www.gotw.ca/gotw/

Tom

 

[Senthilvel Samatharman]

Hello all,

I'm trying to get a grasp of the difference between specializing a function
template and overloading it. The example below has a primary template, a
specialization and an overload. Note that the overload is identical to the
specialization except, of course, for the missing "template <>".

I don't know if my questions will be a bit too broad or not, but I thought
I'd give it shot... When is overloading preferable to specialization? When
is specialization preferable to overloading? What is the intended
conceptual difference between the two? Any other guidance on other things I
need to know but don't know enough yet to even ask?

I had the same question sometime back and this is the reply from Bjarne
Stroustrup....

"For functions, you don't have to. Overloading will do. For classes, you don't
have an alternative. Note that when you specialize the specialzation doesn't
affect overload resolution rules, when you overload with a non-specialization,
overload resolution will prefer the non-specialization."