Determining if types alias to the same underlying type in C++

I'd like to write a templated function which changes its behavior depending on template class types passed in. To do this, I'd like to determine the type passed in. For example, something like this:

template <class T>
void foo() {
  if (T == int) {开发者_运维知识库 // Sadly, this sort of comparison doesn't work
    printf("Template parameter was int\n");
  } else if (T == char) {
    printf("Template parameter was char\n");
  }
}

Is this possible?

---

This is the purpose of template specialization, a search for that term gives tons of examples.

#include <iostream>

template <typename T>
void foo() 
{ 
    std::cout << "Unknown type " << typeid(T).name() << "\n";
}

template<typename T>
void fooT(T const& x) { foo<T>(); }

template<>
void foo<int>()
{    printf("Template parameter was int\n");
}

template<>
void foo<char>()
{    printf("Template parameter was char\n");
}

int main()
{
    fooT(std::cout);
    fooT(5);
    fooT('a');
    fooT("Look Here");
}

---

By using the power of partial specialization, this can be done at compile time:

template<class T, class U>
struct is_same_type
{
    static const bool value = false;
};
template<class T>
struct is_same_type<T, T>
{
    static const bool value = true;
};

template <class T>
void foo() 
{
    if (is_same_type<T, int>::value) 
    {
        printf("Template parameter was int\n");
    }
    else if (is_same_type<T, char>::value) 
    {
        printf("Template parameter was char\n");
    }
}

Compiled in my head, but should work nonetheless.

---

Using template specialization or typeid would probably work for you, although you might prefer template specialization as it won't incur the runtime cost of typeid. For example:

#include <iostream>
#include <typeinfo>

template <typename T>
void foo(T arg) {
  if (typeid(arg) == typeid(int)) std::cout << "foo<T> where T is int\n";
  else if (typeid(arg) == typeid(double)) std::cout << "foo<T> where T is double\n";
  else if (typeid(arg) == typeid(char)) std::cout << "foo<T> where T is char\n";
}

template <>
void foo<int>(int arg) {
  std::cout << "foo<int>\n";
}

int main() {
  foo(3);   // foo<int>
  foo(3.0); // foo<T> where T is double
  foo('c'); // foo<T> where T is char
}

---

Use type_info directly, or better still typeid operator to do that.

#include <typeinfo>
template < typename T > 
T max( T arg1, T arg2 ) {
   cout << typeid( T ).name() << "s compared." << endl;
   return ( arg1 > arg2 ? arg1 : arg2 );
}