Переключить переданный тип из шаблона

Question

Возможно ли в C ++ проверить тип, переданный в функцию шаблона? Например:

template <typename T>
void Foo()
{
   if (typeof(SomeClass) == T)
      ...;
   else if (typeof(SomeClass2) == T)
      ...;
}

Answer 1

Да, это так ... но, вероятно, это не сработает так, как вы ожидаете.

template < typename T >
void foo()
{
  if (is_same<T,SomeClass>::value) ...;
  else if (is_same<T,SomeClass2>::value) ...;
}

Вы можете получить is_same из std:: или boost:: в зависимости от вашего желания / компилятора. Первый только в C ++ 0x.

Проблема в том, что в .... Если вы ожидаете, что сможете выполнить какой-либо вызов функции, специфичный для этих типов в foo, вы сильно ошибаетесь. Ошибка компилятора, даже если эта часть кода никогда не запускается, когда вы передаете что-то, что не соответствует ожидаемому интерфейсу.

Чтобы решить эту проблему, вам нужно сделать что-то немного другое. Я бы порекомендовал диспетчеризацию тегов:

struct v1_tag {};
struct v2_tag {};

template < typename T > struct someclass_version_tag;
template < > struct someclass_version_tag<SomeClass> { typedef v1_tag type; };
template < > struct someclass_version_tag<SomeClass2> { typedef v2_tag type; };

void foo(v1_tag) { ... }
void foo(v2_tag) { ... }
template < typename T > void foo()
{
  typedef typename someclass_version_tag<T>::type tag;
  foo(tag());
}

Обратите внимание, что здесь вы не будете испытывать никаких издержек во время исполнения-полиморфизма, и при включенной оптимизации это должно привести к тому же или даже меньшему размеру кода И скорости (хотя вам все равно не следует беспокоиться об этом, пока вы не запустите профиль).

Answer 2

Если вы хотите сделать что-то конкретное в зависимости от типа, специализируйте шаблон:

template <typename T>
void Foo() { }

template <>
void Foo<SomeClass>() { }

template <> 
void Foo<SomeClass2>() { }

// etc.

(Вы на самом деле не хотите специализировать шаблон функции, хотя; это только для экспозиции. Вы можете либо перегружать шаблон, если можете, либо делегировать специализированный шаблон класса. Подробнее о причинах и как избежать специализации шаблонов функций, прочитайте Херба Саттера, почему бы не специализировать шаблоны функций? )

Answer 3

Нет, но вы можете использовать частичную специализацию:

template<typename T>
struct Bar { static void foo(); };
template<typename T>
template<> inline void Bar<T>::foo() {
//generic
}
template<> inline void Bar<int>::foo() {
//stuff for int
}
template<> inline void Bar<QString>::foo() {
//QString
}

Редактировать Да, с чертами типа, но в действительности это не нужно. Редактировать пример 2 type_traits.

#include <type_traits>
template<typename T> void foo() {
    using std::is_same;
    if<is_same<T, T2>::value || is_same<T, T1>::value) { 
        /* stuff */
    }
}

Answer 4

Да.Вам придется использовать черты типа .Например:

#include <boost/type_traits/is_same.hpp>

template <typename T>
void Foo ()
{
   if ((boost::is_same<T, SomeClass>::value))
      ...;
   else if ((boost::is_same<T, SomeClass2>::value))
      ...;
}

В зависимости от того, что вы пытаетесь достичь, использование специализация шаблона может быть гораздо лучшим выбором.

Также вы можете использовать enable_if / disable_if для условного включения / отключения определенных функций / методов.Комбинирование этого с признаками типа позволит, например, использовать одну функцию для одного набора типов и другую функцию для другого набора типов.