Re: [Boost-users] [mpl] how to find out whether a function is implemented

From: David Abrahams (dave_at_[hidden])
Date: 2005-08-05 13:05:50

Zeljko Vrba <zvrba_at_[hidden]> writes:

> David Abrahams wrote:
>>
>> However, reliably taking the address of an overloaded function
>> involves knowing the exact types in its signature.  I'm not sure how
>> you can do that.
>>
> I have googled a bit and found the following example in the Microsoft
> C++ reference: http://tinyurl.com/cljnn
>
> int Func( int i, int j );
> int Func( long l );
>
> ...
>
> int (*pFunc) ( int, int ) = Func;
>
> Do you see any problems with this?

Not at all.  As I said, you need to know the exact signature.  The
problem is detecting that the function (or operator<) whose existence
you detect has the exact signature you care about.  

Maybe it could be tested by passing a convertible-to-T POD struct
through the function:

   // UNTESTED

   template <class T>
   struct convertible_to { operator T() const; };

   namespace tester
   {
     typedef char (&yes) [1];
     typedef char (&no) [2];

     struct not_found {};

     no is_found(not_found);
     yes i_found(...);

     not_found operator<(...);

     template <class A1, class A2>
     struct has_less1
     {
         static bool const value
           = sizeof(
               is_found(
                  convertible_to<A1>() < convertible_to<A2>()
               )
             ) == yes;
     };

     template <class T> T make();

     template <class T, class U>
     no is(T&,U&);

     template <class T>
     yes is(T&,T&);

     template <class R, class A1, class A2, bool = has_less1<A1,A2>::value>
     struct has_less
     {
         static bool const value
           = sizeof( is(make<R>(), make<A1>() < make<A2>()) ) == yes;
     };

     template <class R, class A1, class A2>
     struct has_less<R,A1,A2,false>
     {
         static bool const value = false;
     };
   }

The problem with this is that you still can't tell whether the
operator< you found takes its arguments by reference or by value, and
without that information, you can't do the cast you want reliably.

> I guess it should be possible to take an address of an operator by
> replacing 'Func' with e.g. 'operator<'. I'll try it and report the
> result.

I don't think this problem can be solved.

-- 
Dave Abrahams
Boost Consulting
www.boost-consulting.com