Prev: composition and bad_alloc
Next: Getting address of enclosing object from address of inner object
From: Jiri Palecek on 18 Apr 2008 16:39
Kimon Hoffmann wrote:

> What I'd like to know is whether there is some way to make HalfWorking
> work with fully qualified calls to func() like the one in
> cool_algorithm_2(), besides the obvious solution to move HalfWorking
> together with the function overload into the default_impl namespace.

Fully qualified no, but something similar is possible. It is quite commonly
used:

using default_impl::func;
func(x);

This will call ::func(const HalfWorking&) for arguments of type HalfWorking,
and default_impl::func for anything convertible to DefaultType.

The usual use for this idiom is std::swap, because you want to use std::swap
for anything that doesn't have a swap function, and find the overloads by
ADL where there is one. Also, you should use it for all std functions that
operate on standard types if you want to overload them for your types and
find the overloads by ADL (you obviously cannot move your overloads to
std::) For example, you can create class your_ns::matrix, which would be
eg. a real matrix. Then, you can define a function

your_ns::matrix your_ns::exp(your_ns::matrix);

which would be an exponential of the matrix. In generic code, you would then
do

using std::exp;
T y=exp(2*x); // .. or whatever ..

and that would call std::exp for double, float, long double (also int), and
your_ns::exp for your matrices.

Note that you also need this if a C library leaves its definitions in the ::
scope. For example, abs(0.5) might call ::abs(int) which is really sad :-(

Regards
Jiri Palecek

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

From: Kimon Hoffmann on 19 Apr 2008 09:11
Jiri Palecek wrote:
> Kimon Hoffmann wrote:
>
>> What I'd like to know is whether there is some way to make HalfWorking
>> work with fully qualified calls to func() like the one in
>> cool_algorithm_2(), besides the obvious solution to move HalfWorking
>> together with the function overload into the default_impl namespace.
>
> Fully qualified no, but something similar is possible. It is quite commonly
> used:
>
> using default_impl::func;
> func(x);
>
> This will call ::func(const HalfWorking&) for arguments of type HalfWorking,
> and default_impl::func for anything convertible to DefaultType.

Yes, I am aware of that, but until I stumbled across the problem above I
wasn't fully aware of the implications.

> The usual use for this idiom is std::swap, because you want to use std::swap
> for anything that doesn't have a swap function, and find the overloads by
> ADL where there is one. Also, you should use it for all std functions that
> operate on standard types if you want to overload them for your types and
> find the overloads by ADL (you obviously cannot move your overloads to
> std::) For example, you can create class your_ns::matrix, which would be
> eg. a real matrix. Then, you can define a function

Thanks, this is a keeper :). And now that I learned the lesson the hard
way, I don't believe I'll ever miss this in the future ;).

> Note that you also need this if a C library leaves its definitions in the ::
> scope. For example, abs(0.5) might call ::abs(int) which is really sad :-(

Since the code is intended for a library, the main reasons for why I
wanted to make it work with fully qualified names were:
1. I did not want to force a particular usage pattern on the user (i.e.
not force him to use the idiom you described above).
2. I wanted to avoid matching to unexpected global overloads like
::abs(int). Although for user defined types such mismatching is highly
unlikely to happen in practice.

Best regards,
Kimon



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

First  |  Prev  | 
Pages: 1 2
Prev: composition and bad_alloc
Next: Getting address of enclosing object from address of inner object