how to query if(T==int) with template class

Question

When I\'m writing a function in a template class how can I find out what my T is?

e.g.

template 
ostream& operator << (os         


        

Answer 1

Something like this:

template< class T >
struct TypeIsInt
{
    static const bool value = false;
};

template<>
struct TypeIsInt< int >
{
    static const bool value = true;
};

template <typename T>
ostream& operator << (ostream &out,Vector<T>& vec)
{
    if (TypeIsInt< T >::value)
    // ...
}

Answer 2

Since C++11 we have std::is_same:

if (std::is_same<T, int>::value) ...

It's implemented similar to the suggested trait TypeIsInt suggested in the other answers, but with two types to be compared.

Answer 3

Define it explicitly, e.g.:

template <>
ostream& operator << (ostream &out,Vector<int>& vec)
{
}

Answer 4

C++ templates don't work this way. The general idea of templates is express somethings which is common for a lot of different types. And in your case you should use template specialization.

template<class T> ostream& operator<< (ostream& out, const vector<T>& v)
{
    // your general code for all type
}
// specialized template
template<> ostream& operator<< <int>(ostream& out, const vector<int>& vec)
{
    // your specific to iny type code goes here
}

Then C++ compiler will call this function when you use int type and general implementation for any other type

std::vector<int> f(5, 5);
std::cout << f;

Answer 5

The easiest way is to provide a template specialisation:

#include <iostream>
#include <vector>
using namespace std;

template <typename T> struct A {
};

template <typename T > 
ostream & operator <<( ostream & os, A<T> & a  ) {
    return os << "not an int" << endl;
}


template <> 
ostream & operator <<( ostream & os, A<int> & a  ) {
    return os << "an int" << endl;
}

int main() {
    A <double> ad;
    cout << ad;
    A <int> ai;
    cout << ai;
}

Answer 6

Simplest, most general solution: Just write a plain old overload of the function:

ostream& operator << (ostream &out,Vector<int>& vec)
{
// Your int-specific implementation goes here
}

This assumes that the int and non-int versions don't have much code in common, as you have to write two separate implementations.

IF you want to use one common implementation of the function, with just an if statement inside that differs, use Charles Bailey's implementation:

template< class T >
struct TypeIsInt
{
    static const bool value = false;
};

template<>
struct TypeIsInt< int >
{
    static const bool value = true;
};

template <typename T>
ostream& operator << (ostream &out,Vector<T>& vec)
{
    if (TypeIsInt< T >::value) {
      // your int-specific code here
    }
}

In general, don't use typeid if you don't need to.