C++Talk.NET

Marco Jez · Guest

Let's suppose I have a class template with parameter T. I want instances of
this template to be able to determine at compile time whether type T has a
function member which matches a certain signature or not, and then take
different actions in case such function exists. Something like this:

template<typename T>
struct Dummy
{
// should return true if T::method() exists, false otherwise
bool detect() const {....}
};

Is that possible?

Cheers,
Marco

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

sandor · Guest

Hi Marco,

I am attempting the same: checking for the existence of the clone
method with this code. But compilation fails in gcc 3.4.2. I was hoping
to use the "substitution failure is not an error" [SFINAE] rule, to
force the compiler to chose the second hasClone method if substituting
into the first one fails. But it is not working. Any help is
appreciated!

#include <iostream>
using namespace std;

template <size_t ignored>
struct IntSink
{
};

template <typename T>
struct CloneAsserter
{
enum { r = sizeof( &T::clone ) };
};

typedef char True;
struct False
{
char s[2];
};

template <typename C> True hasClone( IntSink< CloneAsserter *
);
template <typename C> False hasClone( ... );

template <typename T>
struct HasClone
{
enum { r = sizeof(hasClone<T>(0)) == sizeof(True) };
};

struct Tester1
{
int clone;
};

struct Tester2
{
int clone() { return 1; }
};

struct Tester3
{
};

#define PRINT(r) cout << #r " = " << r << endl;

int main()
{
PRINT( HasClone PRINT( HasClone<Tester2>::r );
PRINT( HasClone<Tester3>::r );
PRINT( HasClone<int>::r );
return 0;
}

cheers,
Sandor

Marco Jez wrote:

Victor Bazarov · Guest

Marco Jez wrote:

sandor · Guest

Hi,

I did solve it. Compiles on gcc 3.4.2.

--------------8<-----------------------------

#include using namespace std;

template <size_t ignored>
struct IntSink
{
};

template <typename T2, T2 p>
struct Assert
{
enum { r = sizeof( p ) };
};

typedef char True;
struct False
{
char s[2];
};

#define CHEKCER_CLASS_DEF(name)
template <typename T>
struct name
{
enum { r = sizeof(func##name<T>(0)) == sizeof(True) };
};

#define HAS_MEMBER_CHECKER(memberType, memberName, checkerName)
template <typename C> True func##checkerName( IntSink<
Assert * );
template <typename C> False func##checkerName( ... );
CHEKCER_CLASS_DEF(checkerName);

#define HAS_NONSTATIC_FIELD_CHECKER(fieldType, fieldName)
HAS_MEMBER_CHECKER(fieldType (C::*), fieldName,
Has_##fieldName##_nonstatic_field)

#define HAS_STATIC_FIELD_CHECKER(fieldType, fieldName)
HAS_MEMBER_CHECKER(fieldType *, fieldName,
Has_##fieldName##_static_field)

#define HAS_METHOD_CHECKER(retType, methodName, params)
HAS_MEMBER_CHECKER(retType(C::*)params, methodName,
Has_##methodName##_method)

#define HAS_SUBTYPE_CHECKER(SUBTYPE)
template <typename C> True funcHas_##SUBTYPE##_subtype( typename
C::SUBTYPE * );
template <typename C> False funcHas_##SUBTYPE##_subtype( ... );
CHEKCER_CLASS_DEF(Has_##SUBTYPE##_subtype);

HAS_NONSTATIC_FIELD_CHECKER(int, f)
HAS_STATIC_FIELD_CHECKER(int, f)
HAS_METHOD_CHECKER(C*, clone, ())
HAS_SUBTYPE_CHECKER(TestType)

struct Tester1
{
int f;
};

struct Tester2
{
Tester2 * clone() { return 0; }
};

struct Tester3
{
typedef int TestType;
static int f;
};

#define PRINT(r) cout << #r " = " << r << endl;

int main()
{
PRINT( Has_clone_method PRINT( Has_clone_method<Tester2>::r );
PRINT( Has_clone_method<Tester3>::r );
PRINT( Has_clone_method<int>::r );

PRINT( Has_f_nonstatic_field<Tester1>::r );
PRINT( Has_f_nonstatic_field<Tester2>::r );
PRINT( Has_f_nonstatic_field<Tester3>::r );
PRINT( Has_f_nonstatic_field<int>::r );

PRINT( Has_TestType_subtype<Tester1>::r );
PRINT( Has_TestType_subtype<Tester2>::r );
PRINT( Has_TestType_subtype<Tester3>::r );
PRINT( Has_TestType_subtype<int>::r );

PRINT( Has_f_static_field<Tester1>::r );
PRINT( Has_f_static_field<Tester2>::r );
PRINT( Has_f_static_field<Tester3>::r );
PRINT( Has_f_static_field<int>::r );

return 0;
}

--------------8<-----------------------------
It prints:

Has_clone_method Has_clone_method<Tester2>::r = 1
Has_clone_method<Tester3>::r = 0
Has_clone_method<int>::r = 0

Has_f_nonstatic_field<Tester1>::r = 1
Has_f_nonstatic_field<Tester2>::r = 0
Has_f_nonstatic_field<Tester3>::r = 0
Has_f_nonstatic_field<int>::r = 0

Has_TestType_subtype<Tester1>::r = 0
Has_TestType_subtype<Tester2>::r = 0
Has_TestType_subtype<Tester3>::r = 1
Has_TestType_subtype<int>::r = 0

Has_f_static_field<Tester1>::r = 0
Has_f_static_field<Tester2>::r = 0
Has_f_static_field<Tester3>::r = 1
Has_f_static_field<int>::r = 0

best regards,
Sandor

Marco Jez wrote:

Mike Jolley · Guest

"Marco Jez" <guess (AT) none (DOT) it> wrote

Marco Jez · Guest

Marco Jez · Guest

sandor · Guest

Hi Marco,

I worked out the solution to the checking of the existence of the
global operator==, but unfortunately it crashes the gcc 3.4.2 compiler
itself: I get a segfault during the compilation. So this should be the
correct code to my best knowledge, but I am unable to test it. If I
change the names of the operator== methods to a simple "equals", the
code compiles and works.

#include <iostream>
using namespace std;

template <typename T2, T2 p>
struct Assert
{
};

typedef char True;
struct False
{
char s[2];
};

struct Tester1
{
int f;
};

struct Tester2
{
Tester2 * clone() { return 0; }
bool operator==(const Tester2 &) { return true; }
};

struct Tester3
{
typedef int TestType;
static int f;
};

bool operator==(const Tester3 &, const Tester3 &)
{ return true; }

template <typename T, bool (*equality)(const T &, const T &)>
struct EqualAssert
{
};

template <typename T> True funcHas_global_equality( EqualAssert<T,
operator==> * );
template <typename T> False funcHas_global_equality( ... );
template <typename T>
struct Has_global_equality
{
enum { r = sizeof(funcHas_global_equality<T>(0)) == sizeof(True) };
};

template <typename T> True funcHas_member_equality(
Assert<bool(T::*)(const T&), &T::operator==> * );
template <typename T> False funcHas_member_equality( ... );
template <typename T>
struct Has_member_equality
{
enum { r = sizeof(funcHas_member_equality<T>(0)) == sizeof(True) };
};

template <typename T>
struct Has_any_equality
{
enum { r = Has_global_equality<T>::r || Has_member_equality<T>::r };
};

#define PRINT(r) cout << #r " = " << r << endl;

int main()
{
PRINT( Has_global_equality PRINT( Has_global_equality<Tester2>::r );
PRINT( Has_global_equality<Tester3>::r );
PRINT( Has_global_equality<int>::r );

PRINT( Has_member_equality<Tester1>::r );
PRINT( Has_member_equality<Tester2>::r );
PRINT( Has_member_equality<Tester3>::r );
PRINT( Has_member_equality<int>::r );

PRINT( Has_any_equality<Tester1>::r );
PRINT( Has_any_equality<Tester2>::r );
PRINT( Has_any_equality<Tester3>::r );
PRINT( Has_any_equality<int>::r );

return 0;
}

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

Vladimir Marko · Guest

Marco Jez wrote:

Marco Jez · Guest

Marco Jez · Guest

Hi Sandor,

Vladimir Marko · Guest

Marco Jez wrote: