C++Talk.NET

õá · Guest

//Well,this one is,just like the title sais,about Template Metaprogramming.
// I am sorry,if it lready exists, but I had this idea today and tried it.
// Just follow the comments to understand.

typedef char Small;
typedef struct {char unused[2];} Big;
// or just whatever you like

// the first template parameter is the type to check,
// the second the supposed type of the member.
// Just like with checking for a nested class, just using
// the default parameter for SFINAE.Note that if there wasn't
// this second template parameter in the second function,
// then this function would always be chosen.
#define DEFINE_HAS_MEMBER_WITH_TYPE(name)
template <typename T,typename U>
struct has_member_##name##_with_type
{
private:
/* Note that in order to disambiguate the calls I need
the first dummy parameter.
*/
template <typename U,typename V>
static ::Small has_##name(int,V U::* = &U::name);

template <typename U,typename V>
static ::Big has_##name(...);

public:
enum{value=sizeof(has_member_##name##_with_type::template
has_##name<T,U>(0)
)==sizeof(::Small)};
}
// No comma intended,just like in the following class.
// You can add one if that's your wish.

// A little bit trickier,because of the conversion.
// Now it will even say that there is a member function foo,
// even if it is the member data.On the other hand, you don't need
// to specify the type.
#define DEFINE_HAS_MEMBER(name)
template <typename T>
struct has_member_##name
{
private:
template <typename U>
static ::Small has_##name(int,int U::* = reinterpret_cast<int
U::*>(&U::name));

template <typename U>
static ::Big has_##name(...);

public:
enum{value=sizeof(has_member_##name::template has_##name<T>(0))
==sizeof(::Small)};
}

// I would like to hear the people's opinion.
//I wouldalso like to note, that English isn't my native language,
// so sorry if I did any mistake.

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

David Abrahams · Guest

"õá" <efim.slobodov233432 (AT) arcor (DOT) de> writes:

Vladimir Marko · Guest

õá wrote:
[snip]

õá · Guest

"õá" <efim.slobodov233432 (AT) arcor (DOT) de> ÓÏÏÂÝÉÌ/ÓÏÏÂÝÉÌÁ × ÎÏ×ÏÓÔÑÈ ÓÌÅÄÕÀÝÅÅ:
news:4250433e$0$11461$9b4e6d93 (AT) newsread2 (DOT) arcor-online.net...

õá · Guest

"David Abrahams" <dave (AT) boost-consulting (DOT) com> ÓÏÏÂÝÉÌ/ÓÏÏÂÝÉÌÁ × ÎÏ×ÏÓÔÑÈ
ÓÌÅÄÕÀÝÅÅ: news:uwtrj2sq7.fsf (AT) boost-consulting (DOT) com...

Pete Becker · Guest

õá wrote:

õá · Guest

So,now I got it.Halleluia!Sorry that I forgot to include the
Selector class in my last message, but I thought that it's
pretty obvious.
Try this one and see if it works. :-)

template <int> Selector;
____________________________
#define DEFINE_HAS_MEMBER(name)
template <typename T>
struct has_member_##name
{
private:

template <typename U>
static ::Small test(Selecter<sizeof(&U::name)>*);

template <typename U>
static ::Big test(...);

public:
enum{value=sizeof(test<T>(0))==sizeof(::Small)};
}
____________________________
It can be no simpler and it really works.
The only problem is that there is still
acompilation error if the member is
inaccessible(i.e. nonpublic).But otherwise
value is just either 0 or 1.

I tried it with the following types:

struct HasClone
{
void clone(){}
};

struct NoClone
{};

and of course the ol' good int.
DEFINE_HAS_MEMBER(clone);

has_member_clone<HasClone>::value==1;
has_member_clone<NoClone>::value==0;
has_member_clone<int>::value==0;

All of those of course true!!!!
It still would be easier and safer if
the language would support it
without the need to write overly complicated
templates.I hope C++0x will do this and much more
(justa joke).

What remains is checking for a member of a certain type.
P.S.: I hope my compiler is standard-comforming enough.
Thanks for replies!

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

Alberto Barbati · Guest

Pete Becker wrote:

õá · Guest

Well, I have still found only two possible
implementations for the "DEFINE_HAS_MEMBER_WITH_TYPE"
thing.Neither are truly good.

1)IMHO it shouldn't be considered ,because the information
would only be availible at run-time.But there would be still
almost no performance penalty(it isn't typeid Razz

).

The idea is using this functions:

template <typename T,typename U>
bool isSame(U& x)
{
return is_same<T,U>::value;
}

#define DEFINE_HAS_MEMBER_WITH_TYPE(name)
template <typename T,typename U>
struct name##_checker
{
static bool value=isSame<U>(&T::name);
};

template <typename T,typename U>
struct has_member_##name##_with_type
{
public:
enum{value=has_member_##name<T>::value
&& name##_checker<T,U>::value};
}

Just as I said,pretty much useless.

2)

#define DEFINE_HAS_MEMBER_WITH_TYPE(name)

template <typename T,typename U>
struct name##_checker
{
enum{value=is_same<typeof(&T::name),U>::value};
};

template <typename T,typename U>
struct has_member_##name##_with_type
{
public:
enum{value=if_<has_member_##name name##_checker<T,U>,int_<0> >::type::value};
}

value is now a compile-time constant,but the cost...
The cost is the portability.Bill Gibbons idea for typeof
is very good, but it could be that some user-defined
type X wasn't registered.So I have to rely on some
future extension.

Another note:both require that has_member_##name is defined.
One can duplicate the code to eliminate dependencies.I hope
s.o. can find a better solution.

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

Pete Becker · Guest

Alberto Barbati wrote:

Gabriel Dos Reis · Guest

Alberto Barbati <AlbertoBarbati (AT) libero (DOT) it> writes:

Vladimir Marko · Guest

õá wrote:

ZMS · Guest

1. The source from 'õá' or "Vladimir Marko"
does not compile in MSVC7.1 (MSC1301)
resulting 'INTERNAL COMPILER ERROR".
Is there any workaround in that compiler
( except using __if_exists and __if_not_exists ) ?

2. Testing of a template member function like following,
template< typename Stream >
void Output( Stream& stream );
causes compilation error in both sources.
But __if_exists implementaion in MSVC like following,
template< typename T >
struct has_foo {
__if_exists( T::foo ) { static const bool value = true; }
__if_not_exists( T::foo ) { static const bool value = false; }
};
works fine.
Is there any workaround on this case in other compilers ?

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

David Abrahams · Guest

Gabriel Dos Reis <gdr (AT) integrable-solutions (DOT) net> writes:

Vladimir Marko · Guest

ZMS wrote: