Hello Experts!

Assume I have one function that is a template function called add and one
concrete function that also have the name add is it any point to make a
concrete function add in this example?

template <typename T>
T add(T rh, T lh)
{ return rh+lh; }

template <typename T>
int add(int rh, int lh)
{ return rh+lh; }
int main()
{
int i=1, j=2;
cout << "result " << add<int>(i,j) << endl;

return 0;
}

//Many thanks

//Tony

> Hello Experts![color=blue]
>
> Assume I have one function that is a template function called add and one
> concrete function that also have the name add is it any point to make a
> concrete function add in this example?
>
> template <typename T>
> T add(T rh, T lh)
> { return rh+lh; }
>
> template <typename T>
> int add(int rh, int lh)
> { return rh+lh; }
> int main()
> {
> int i=1, j=2;
> cout << "result " << add<int>(i,j) << endl;
> return 0;
>
> }[/color]

In the above example there's no point for the template
specialization(That's the term you'd want to use). In general you'd
want to specialize a function template when you want to have different
behavior for particular types.

Srini

"Srini" <srinivasa.s@gmail.com> wrote in message
news:1124187449.652488.264850@g47g2000cwa.googlegr oups.com...[color=blue][color=green]
>> Hello Experts!
>>
>> Assume I have one function that is a template function called add and one
>> concrete function that also have the name add is it any point to make a
>> concrete function add in this example?
>>
>> template <typename T>
>> T add(T rh, T lh)
>> { return rh+lh; }
>>
>> template <typename T>
>> int add(int rh, int lh)
>> { return rh+lh; }
>> int main()
>> {
>> int i=1, j=2;
>> cout << "result " << add<int>(i,j) << endl;
>> return 0;
>>
>> }[/color]
>
> In the above example there's no point for the template
> specialization(That's the term you'd want to use). In general you'd
> want to specialize a function template when you want to have different
> behavior for particular types.
>
> Srini
>[/color]

The code by Tony didn't look to me like template specialization. A full
specialization of function template add<> would look like:

template <>
int add(int rh, int lh)
{
return rh + lh;
}

> The code by Tony didn't look to me like template specialization. A full[color=blue]
> specialization of function template add<> would look like:
>
> template <>
> int add(int rh, int lh)
> {
> return rh + lh;
> }[/color]

Yeah - even I thought so. But I checked compiling both forms (What OP
has given and what you've given) and both gave same results. I thought
that specialization was what the OP meant in his post.