Pfthb

Is there any way to determine at runtime the type of method's argument in C++03? I am thinking about such way:

#include <cstdio>

template<class T, class U>
struct is_same 
 static const bool result = false;
;

template<class T>
struct is_same<T, T> 
 static const bool result = true;
;

template<class ToFind, class Ret, class T, class Arg>
bool hasArg1(ToFind, Ret (T::*)(Arg))return is_same<ToFind, Arg>::result;

template<class ToFind, class Ret, class T, class Arg1, class Arg2>
bool hasArg1(ToFind, Ret (T::*)(Arg1, Arg2))return is_same<ToFind, Arg1>::result;

struct A

 int fun1(int a)return a+1;
;

int main() 
 std::printf("int arg1: %sn", hasArg1(1, &A::fun1) ? "yes" : "no");

but I want something like this:

hasArg1<int>(&A::fun1)

instead of

hasArg1(1, &A::fun1)

Just remove the first function argument:

template<class ToFind, class Ret, class T, class Arg>
bool hasArg1(Ret (T::*)(Arg))return is_same<ToFind, Arg>::result;

template<class ToFind, class Ret, class T, class Arg1, class Arg2>
bool hasArg1(Ret (T::*)(Arg1, Arg2))return is_same<ToFind, Arg1>::result;

Now hasArg1<int>(&A::fun1) works as you want it to.

See it Live

But bear in mind that this approach won't work if A::fun1 is overloaded.

Now, as was noted under your question. Runtime checking of such things is less useful. Usually you want that information at compile time, to affect code generation and possibly optimize based upon. c++03 is limited in its compile time capabilities compared to later revisions, but it's not impossible to make this check at compile time. Here is how you'd modify your code to do it:

template<bool C, typename T = void>
struct enable_if;

template<typename T>
struct enable_if<true, T> typedef T type; ;

template<int s> struct tag char _[s]; ;

template<class ToFind>
tag<1> hasArg1(...);

template<class ToFind, class Ret, class T, class Arg>
tag<2> hasArg1(Ret (T::*)(Arg), enable_if<is_same<ToFind, Arg>::result, void>* = 0);

// Add hasArg1 overloads to support members with more arguments

#define HAS_ARG1(ToFind, member) (sizeof(hasArg1<ToFind>(member)) != sizeof(tag<1>))

First we add a "fallback" overload that returns a type with an expected size. Then we add another overload, modified from your own. The check is relegated to another function argument. When the checks fails during overload resolution, the argument is ill-formed and substitution fails, leaving us only with the fallback, because SFINAE is awesome!

If the check passes, the second overload is well-formed and a better match, because ellipsis have the lowest priority among conversion sequences in overload resolution.

The macro is added for syntactic sugar, since the subsequent details are tedious to type over and over. We do overload resolution inside the sizeof operator. The overload chosen, via its return type, will be reflected in what sizeof(hasArg1<ToFind>(member)) reports. So we can check it against sizeof(tag<1>) (the fallback). And since sizeof is a compile time operator, we have a compile time constant that tells us if the first argument of member is ToFind.

And to prove that it is a compile time constant, we can instantiate

tag<HAS_ARG1(int, &A::fun1)> test_compile_time;

Like we do here, in GCC 4.1.2 in C++98 mode.