Re: Template-Meta: Finding out whether a template-definition exists

From:

Barry <dhb2000@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Mon, 03 Sep 2007 23:30:02 +0800

Message-ID:

<fbh9av$32v$1@aioe.org>

xtrigger303@gmail.com wrote:

On Sep 3, 2:13 pm, "Hendrik Schober" <SpamT...@gmx.de> wrote:

Hi,

suppose we have

  template< typename T >
  struct X;

and some specializations:

  template<>
  struct X<A> {};

  template<>
  struct X<B> {};

  template<>
  struct X<B> {};

Given a type 'U', is there a way to find out whether the
definition 'X<U>' exists? (The result should be a compile-
time constant, so that it can be used for specializing
other templates.)

Schobi

--
SpamT...@gmx.de is never read
I'm HSchober at gmx dot de
"A patched buffer overflow doesn't mean that there's one less way attackers
can get into your system; it means that your design process was so lousy
that it permitted buffer overflows, and there are probably thousands more
lurking in your code."
Bruce Schneier

IMHO

template< typename T >
struct X
{
enum { kIsSpecialized = false };
};

template<>
struct X< A >
{
enum { kIsSpecialized = true };
};

if you cannot touch the structs you might keep a manually updated
typelist ( a la Alexandrescu ) of the specialized types anche check if
a type is in the typelist...

I can't think of any other way ( so probably there are a thousands
more ... )

I think of another way (in your "thousand more" :-) ) to do compile-time

#include <boost/static_assert.hpp>

template <class T>
struct X;

template <>
struct X<int>
{
};

template <>
struct X<float>
{
};

struct true_type
{
     char dummy[256];
};

struct false_type
{
     char dummy[1];
};

template <class U>
struct Traiter
{
     static true_type test(X<int>);
     static true_type test(X<float>);
     static false_type test(...);

     static X<U> make_xt();

     enum { value = (sizeof(test(make_xt())) == sizeof(true_type)) };
};

int main()
{
     using namespace std;
     BOOST_STATIC_ASSERT(Traiter<int>::value);
     BOOST_STATIC_ASSERT(Traiter<float>::value);
     BOOST_STATIC_ASSERT(!Traiter<bool>::value);;
}

--
Thanks
Barry