如何比较 C++ 中的类型？

Question

有没有办法比较 C++ 中的变量类型？例如，我想要这样的东西：（使用伪语言）

template <class T> void checkType(T variable) {
    if(type_of(T) == int) cout << "The variable is of type int.\n";
}

编辑 1：我尝试使用 is_same，但它在 Xcode 中不起作用...但是当我尝试在 Atom 中使用 Script 包的以下简单代码中使用它时，它会运行。

#include <iostream>

using namespace std;

template <class T> void print(T value) {
  if(is_same<T, char> :: value) cout << "char\n";
  if(is_same<T, int> :: value) cout << "int\n";
  if(is_same<T, string> :: value) cout << "string\n";
}

int main() {
  string var1;
  int var2;
  char var3;

  print(var1);
  print(var2);
  print(var3);

  return 0;
}

编辑 2：我将不起作用的代码放在这里。现在我尝试评论有关字符串的部分，代码适用于 int 和 char。

template <class keytype, class attrtype>
void LinkedList <keytype, attrtype> :: insert(keytype k, attrtype a) {
    LinkedList <keytype, attrtype> :: position iter = l.head();
    
    if(is_same<keytype, int> :: value) {
        while(iter != NULL and k > iter -> key) {
            iter = l.next(iter);
        }
        
        l.insert(iter, k, a);
    }
    
    else if(is_same<keytype, char> :: value) {
        while(iter != NULL and tolower(k) > tolower(iter -> key)) {
            iter = l.next(iter);
        }
        
        l.insert(iter, k, a);
    }
     //Whatever type I pass by the template in 'keytype' enters this if statement
    else if(is_same<keytype, string> :: value) {
        bool node_filled = false;
        
        if(iter == NULL) {
            l.insert(iter, k, a);
            node_filled = true;
        }
        else {
            unsigned long rif = 0;
            int i = 0;
            
            while(!node_filled and iter != NULL) {
                if(tolower(iter -> key.at(0)) > tolower(k.at(0))) {
                    l.insert(iter, k, a);
                    node_filled = true;
                }
                else if(tolower(iter -> key.at(0)) < tolower(k.at(0))) {
                    iter = l.next(iter);
                }
                else if(tolower(iter -> key.at(0)) == tolower(k.at(0))) {
                    if(k.size() > iter -> key.size())
                        rif = iter -> key.size();
                    else
                        rif = k.size();
                    
                    while((i < rif - 1) and (k.at(i) == iter -> key.at(i))) {
                        i ++;
                    }
                    
                    if(tolower(iter -> key.at(i)) > tolower(k.at(i))) {
                        l.insert(iter, k, a);
                        node_filled = true;
                    }
                    
                    else if(tolower(iter -> key.at(i)) == tolower(k.at(i))) {
                        if(k.size() < iter -> key.size()) {
                            l.insert(iter, k, a);
                            node_filled = true;
                        }
                        else {
                            iter = l.next(iter);
                        }
                    }
                    
                    else if(tolower(iter -> key.at(i)) < tolower(k.at(i))) {
                        iter = l.next(iter);
                    }
                }
            }
            
            if(!node_filled) {
                l.insert(NULL, k, a);
            }
        }
    }
}

Answer 1

查看 EDIT 2 中的代码，您可能希望使用 if constexpr 代替（假设 C++17 兼容编译器）。这里的问题是，通常编译器需要对 if 语句的所有分支的代码进行语法检查，即使从逻辑上讲，对于给定的模板实例化可能只采用一个分支。

if constexpr 放宽了这一要求：未采用的分支被“丢弃”，这意味着如果未采用该分支，则取决于模板参数的值不会被实例化。这意味着它永远不会尝试做，例如，当keytype 是int 时，k.at(0)，因为在这种情况下我们不会进入那个分支。

假设您的编译器支持 C++17（并且启用了该标准！），将代码中的所有 if 替换为 if constexpr 应该可以解决此特定问题。

Answer 2

这对我有用。

#include <iostream>
#include <string>
#include <type_traits>

using namespace std;

template <class T>
void print(T value) {
  if (is_same<T, char>::value) cout << "char\n";
  if (is_same<T, int>::value) cout << "int\n";
  if (is_same<T, string>::value) cout << "string\n";
}

int main() {
  string var1;
  int var2;
  char var3;

  print(var1);
  print(var2);
  print(var3);

  return 0;
}

Live Demo

在C++17中，可以使用if constexpr让编译器生成更优化的codegen：

#include <iostream>
#include <string>
#include <type_traits>

using namespace std;

template <class T>
void print(T value) {
  if constexpr (is_same_v<T, char>) cout << "char\n";
  if constexpr (is_same_v<T, int>) cout << "int\n";
  if constexpr (is_same_v<T, string>) cout << "string\n";
}

int main() {
  string var1;
  int var2;
  char var3;

  print(var1);
  print(var2);
  print(var3);

  return 0;
}

Live Demo

Answer 3

在 C++ 中有 typeid() 运算符，它返回一个 std::type_info，这可以通过多种方式使用。

你像这样使用std::type_info::hash_code()：

template<typename T>
void print()
{
    if (typeid(T).hash_code() == typeid(char).hash_code())
        std::cout << "char\n"
    else if (typeid(T).hash_code() == typeid(int).hash_code())
        std::cout << "int\n"
    else if (typeid(T).hash_code() == typeid(std::string).hash_code())
        std::cout << "std::string\n"
}

或者，您可以像这样使用std::type_info::name()：

template<typename T>
void print()
{
    std::cout << typeid(T) << '\n';
}

请注意后者，如果您输入std::string 之类的内容，您最终会得到类似class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > 的输出内容。这只是因为 std::string 是 using 为 class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > 定义的。

编辑：我忘了说，你需要一个#include <typeinfo> 才能使用std::type_info。

Answer 4

你可以试试这个：

template <class T> void checkType(T variable) {
    switch(sizeof(T)){
    case sizeof(int) :
        cout << "The variable is of type int.\n";
        break;
    case sizeof(char):
        cout << "The variable is of type char.\n";
        break;
    }
}

观察：如果你有一个向量，你必须给它一个特殊的处理，例如将它的 sizeof int switch 参数除以向量的分配数。