如何根据 c++ 模板中的类型类型执行 if else ？ [复制]

Question

// template specialization
#include <iostream>
using namespace std;

// class template:
template <class T>
class mycontainer {
    T element;
  public:
    mycontainer (T arg) {element=arg;}
    T increase () {

    //if(T.type==int)//how to do this or something similar?
    //do this if an int
    return ++element;

    //if(T.type==char)
     //if ((element>='a')&&(element<='z'))
      //element+='A'-'a';
      //return element;

    }
};

我知道如何编写模板特化并为 char 类型做一个单独的整个类定义。

但是，如果我想在一个代码块中处理所有事情呢？

如何检查 T 是 int 还是 char？

Answer 1

你可以使用typeid:

if (typeid(T) == typeid(int))

或者你可以使用std::is_same 类型特征：

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

Answer 2

您想要的可能类似于compile-time if。 不幸的是，C++11 没有对这种语言结构的原生支持。

但是，如果您只想检查两个类型是否相同，std::is_same<> 类型特征应该可以帮助您：

#include <type_traits> // <== INCLUDE THIS STANDARD HEADER

// class template:
template <class T>
class mycontainer 
{
    T element;
public:
    mycontainer (T arg) {element=arg;}
    T increase () 
    {
        if (std::is_same<T, int>::value)   // <== THIS IS HOW YOU WOULD USE IT
            return ++element;

        if (std::is_same<T, char>::value)  // <== THIS IS HOW YOU WOULD USE IT
        {
            if ((element>='a') && (element<='z'))
                element+='A'-'a';
        }

        return element;
    }
};

但是，请记住条件是在运行时评估的，即使is_same<T, int>::value 的值在编译时是已知的。这意味着bothtrue 和if 语句的false 分支必须编译！

例如，以下内容是不合法的：

if (std::is_same<T, int>::value)
{
    cout << element;
}
else if (std::is_same<T, my_class>::value)
{
    element->print();  // Would not compile when T is int!
}

此外，正如 Xeo 在 cmets 中正确指出的那样，编译器可能会发出警告，因为您的条件将始终评估为 true 或 false，因此两个分支之一将包含无法访问的代码。

Answer 3

您可以使用显式模板特化

#include <iostream>
using namespace std;

// class template:
template <class T>
class mycontainer {
    T element;
  public:
    mycontainer (T arg) {element=arg;}
    T increase();
};


template<>
int mycontainer<int>::increase(){
    return ++element;
}

template<>
char mycontainer<char>::increase(){
    if ((element>='a')&&(element<='z'))
       element+='A'-'a';
    return element;
}

int main(){
        mycontainer<int> A(10);
        mycontainer<char> B('x');

        cout << A.increase() <<endl;
        cout << B.increase() <<endl;
        return 0;
}

Answer 4

简单的重载怎么样？

// in the private section
static int& do_increase(int& i){ return ++i; }
static char& do_increase(char& c){
  if(c >= 'a' && c <= 'z')
    c += 'A' - 'a';
  return c;
}
template<class U>
static U& do_increase(U& arg){
  // some default implementation?
  return arg;
}

（请注意，该标准不保证char 的数值的字母顺序。）

然后只需在increase 中将其称为return do_increase(element);。

Answer 5

这里通常的解决方案是转发到一个重载的函数 有一个额外的论点。比如：

template <typename T>
class MyContainer
{
    T increase( int const* ) { /* special treatment for int */ }
    T increase( ... )        { /* default treatment         */ }
public:
    T increase()
    {
        return increase( (T const*)0 );
    }
};

只要有一点想象力，你就可以想出各种各样的 区别。如果你使用额外的目标函数 参数模板，您甚至可以利用 SFINAE：设计 虚拟参数，以便模板类型替换失败，并且 该函数将不被考虑在重载集中。和 由于所有函数都是内联的，因此很可能存在 只要您进行优化，就不会产生额外的开销。

Answer 6

这与 Andy Prowls 的回答类似，但都是在编译时使用具有专业化功能的最小辅助类完成的。

在这种情况下，您有一个实际执行特化的助手，但您也可以让助手类只接受一个布尔值，然后使用 std::is_same<T, int>::value 之类的东西将该值作为模板参数传递。

template <typename T>
struct myContainerHelper;
{
    // General Case
    static inline T increase(T element)
    {
        return ++element;
    }
};

template <>
struct myContainerHelper<char>
{
    // Specific case
    static inline char increase(char element)
    {
        if ((element>='a')&&(element<='z')) element+='A'-'a';
        return element;
    }
};

template <class T>
class mycontainer 
{
    T element;
public:
    mycontainer (T arg) {element=arg;}
    T increase () 
    {
        return myContainerHelper<T>::increase(element);
    }
};

这允许您只专门化单个函数而不是整个类。我正在使用带有静态的模板类，因为我已经习惯了 VS2012 对函数模板的部分专业化限制。