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

[Mateusz �oskot]

Joseph Turian wrote:

How can I determine the type of some particular typename?

typeid(T)

Cheers
--
Mateusz �oskot
http://mateusz.loskot.net

[Howard Hinnant]

In article <11************ **********@z14g 2000cwz.googleg roups.com>,
"Joseph Turian" <tu****@gmail.c om> 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";
}
};

Here's one possibility:

template <typename T>
class foo {
public:
foo() {
}
};

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

Here's another:

template <typename T>
class foo {
public:
foo();
};

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

template <>
foo<int>::foo()
{
cerr << "int\n";
}

And here's another:

#include <tr1/type_traits>
#include <iostream>
using std::cerr;

template <typename T>
class foo {
public:
foo()
{
foo_imp(std::tr 1::is_same<T, int>());
}
private:
void foo_imp(std::tr 1::true_type)
{ cerr << "int\n"; }
void foo_imp(std::tr 1::false_type)
{ }
};

-Howard

[Joseph Turian]

Mateusz Loskot wrote:

How can I determine the type of some particular typename? typeid(T)

I'll see if I can figure out the syntax to use 'typeid'
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?
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?

Thanks

Joseph

[puzzlecracker]

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?

Thanks

Joseph

it is not supported by most compilers and won't be until next
standardization
n

[Luke Meyers]

puzzlecracker wrote:

it is not supported by most compilers and won't be until next
standardization

I think that's a slightly pessimistic characterizatio n. gcc, for one,
handles partial template specialization pretty well. I don't know the
status of other compilers (I use gcc, why not?), but given the rise in
popularity and practice of things such as template metaprogramming , I
think it's safe to say that an appreciable number of people have found
compilers that to the job for them just fine.

Luke

[puzzlecracker]

Luke Meyers wrote:

puzzlecracker wrote:

it is not supported by most compilers and won't be until next
standardization

I think that's a slightly pessimistic characterizatio n. gcc, for one,
handles partial template specialization pretty well. I don't know the
status of other compilers (I use gcc, why not?), but given the rise in
popularity and practice of things such as template metaprogramming , I
think it's safe to say that an appreciable number of people have found
compilers that to the job for them just fine.

Luke

I was refering to foo_imp(std::tr 1::is_same<T, int>());....

[Victor Bazarov]

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";
}
};

Thanks!

This is covered in the FAQ.

[benben]

>

I was refering to foo_imp(std::tr 1::is_same<T, int>());....

Why wait for the standardization ?

Things like tr1::is_same are extremely easy to write so just take a
minute to write some of them.

Or just use the boost library.

Ben

[Gianni Mariani]

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 ?