Determine type of typename T?

[Joseph Turian]

How can I determine the type of some particular typename?

I am writing a template, and it needs special case handling for some
particular types:

template <typename T>
class foo {
public:
foo() {
if (T == int) cerr << "int\n";
}
};

Thanks!

Joseph

[Howard Hinnant]

In article <ZL************ ********@speake asy.net>,
Gianni Mariani <gi*******@mari ani.ws> wrote:

Joseph Turian wrote:

How can I determine the type of some particular typename?

I am writing a template, and it needs special case handling for some
particular types:

template <typename T>
class foo {
public:
foo() {
if (T == int) cerr << "int\n";
}
};

What about different types of int ?

const int
unsigned int
volatile int
int &

or any combination of those ?

Using std::tr1::type_ traits (or boost::type_tra its) it is relatively
easy to perform arbitrarily complex compile-time tests and dispatch (at
compile time) based on the test results:

template <typename T>
class foo {
public:
foo()
{
foo_imp(std::tr 1::integral_con stant<bool, test<T>::value> ());
}

private:
template <class U>
struct test
{
private:
typedef typename std::tr1::remov e_cv<U>::type cv_removed;
typedef typename
std::tr1::remov e_reference<U>: :type reference_remov ed;
static const bool is_int =
std::tr1::is_sa me<cv_removed, int>::value;
static const bool is_uint =
std::tr1::is_sa me<U, unsigned>::valu e;
static const bool is_int_ref =
std::tr1::is_sa me<reference_re moved, int>::value;
public:
static const bool value = is_int || is_uint || is_int_ref;
};

void foo_imp(std::tr 1::true_type)
{ cerr << "int\n"; }
void foo_imp(std::tr 1::false_type)
{ }
};

-Howard

[Gianni Mariani]

Howard Hinnant wrote:
....

Using std::tr1::type_ traits (or boost::type_tra its) it is relatively
easy to perform arbitrarily complex compile-time tests and dispatch (at
compile time) based on the test results:

Sure.

The point I was trying to make is that it may be insufficient to test
for int alone.

[Howard Hinnant]

In article <11************ **********@f14g 2000cwb.googleg roups.com>,
"Joseph Turian" <tu****@gmail.c om> wrote:

template <typename T>
foo<T>::foo()
{
}

template <>
foo<int>::foo()
{
cerr << "int\n";
}
So foo<T>::foo is used unless it is overloaded (by foo<int>::foo, in
this circumstance).
If I switched the order in which the constructors were declared, would
foo<T> always be used, or would it be identical?

I believe the order of definition is irrelevant.

foo_imp(std::tr 1::is_same<T, int>());

This is weird, I'll have to google tr1.
Does it only work for primitive types, or will it also work for
user-defined classes?

As someone else mentioned, you can sub in boost::type_tra its if you
don't have tr1 yet (www.boost.org).

Here is the latest documentation for tr1:

http://www.open-std.org/jtc1/sc22/wg...2005/n1836.pdf

And here's a link to the freely available boost library which inspired
this part of tr1:

http://www.boost.org/doc/html/boost_typetraits.html

is_same<T, U> will work for arbitrary types. It is both clever and
simple:

template <class T, class U> struct is_same
: public integral_consta nt<bool, false> {};
template <class T> struct is_same<T, T>
: public integral_consta nt<bool, true> {};

where integral_consta nt is just a helper class:

template <class T, T v>
struct integral_consta nt
{
static const T value = v;
typedef T value_type;
typedef integral_consta nt<T, v> type;
};

typedef integral_consta nt<bool, true> true_type;
typedef integral_consta nt<bool, false> false_type;

Be aware that const T and T are two different types according to
is_same. But the same type_traits package can strip cv-qualifiers.

The type_traits lib is invaluable for making compile-time
decisions/computations on template parameters. If it helps, here's a
jpeg representation of the type hierarchy which type_traits implements.

http://home.twcny.rr.com/hinnant/cpp...eHiearchy.jpeg

This also roughly follows the classification laid out in section 3.9 of
the standard (modulo those parts the jpeg marks as "proposed" which are
also absent in the boost and tr1 libs).

-Howard

[baibaichen]

which item? thanks

[Victor Bazarov]

baibaichen wrote:

which item? thanks

Somewhere in http://www.parashift.com/c++-faq-lite/