This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: [RFA] handling of 'operator' in cp_find_first_component
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 at 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 at 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