Re: [RFA] handling of 'operator' in cp_find_first_component

[Daniel Jacobowitz <drow@mvista.com>]

On Tue, Apr 22, 2003 at 10:33:05AM -0400, Daniel Berlin wrote:
> 
> On Monday, April 21, 2003, at 11:21  PM, Daniel Jacobowitz wrote:
> 
> >
> >i.e. you can't have a program with
> >  int foo<int> (int)
> >and
> >  long foo<int> (int)
> >in it!
> 
> 
> Stop right here.
> 
> This is not quite right, since the second example is invalid.
> You can, however,  have (geez i haven't written C++ templates in a 
> while. it took me a few compiles to get this right):

I don't think it's invalid on its own.  I think I'm just not being
clear.  It's something like:

template <typename T> int foo(T);
template <typename T> long foo(T);
template <> int foo (int) { return 1;}
template <> long foo (int) { return 2;}

Not that that's valid, but one of them would be "int foo<int> (int)"
and the other would be "long foo<int> (int)".

> template <class blah> blah foo (int a)
> {
>         return a;
> }
> int main(void)
> {
>         int q = foo<int>(5);
>         long r = foo<long>(5);
> }
> 
> Note the only real difference here is in return type.
> It also definitely generates two functions:
> root@dberlin root]# nm -C a.o
>          U __gxx_personality_v0
> 00000000 T main
> 00000000 W int foo<int>(int)
> 00000000 W long foo<long>(int)
> [root@dberlin root]#
> 
> There is no way to write exactly what you want in valid C++ (IIRC), so 
> i'm not sure if this program demonstrates what you think can't be done 
> or not.
> 
> To answer whether you need the return type, let's add two 
> specializations here and make it worse:
> template <> long foo (int a)
> {
> 	return 9;
> }
> template <> int foo (int a)
> {
> 	return 10;
> }
> 
> Now, without the return type in the template, you would *never* know 
> which function to call from a debugger if someone does p foo(5) 
> (However, i'll note the only case you will know is when someone does 
> something like p a=foo(5), where "a" is a program variable of type int 
> or long).
> With the return type,  you could at least present a useful list to the 
> user and ask.
> Unless you want the list to have to re-demangle names so it can get the 
> return type out again, or something ugly like that.

Sure we can.  We look through our list of functions whose name is foo. 
We find that there's a foo<int>(int) returning int and a foo<long>(int)
returning long.  Note that they have unique names because one's
foo<int>(int) and the other's foo<long>(int).  We then ask the user
which one he wanted.

That's what I'm suggesting; I'm just not sure if there's a valid way to
get both "int foo<int>(int)" and "long foo<int>(int)" into the same
program.

In the light of the morning, maybe it's not such a good idea after all.
-- 
Daniel Jacobowitz
MontaVista Software                         Debian GNU/Linux Developer