此文来自于👉 C++ / typeinfo — DevDocs ，并整理

判断数据是哪种数据类型

头文件<typeinfo>

std::type_info::name()

例子：

#include <iostream>
#include <typeinfo>
 
struct Base { virtual ~Base() = default; };
struct Derived : Base {};
 
int main() {
    Base b1;
    Derived d1;

    const Base *pb = &b1;
    std::cout << typeid(*pb).name() << '\n';
    pb = &d1;
    std::cout << typeid(*pb).name() << '\n';

    int i;
    int * pi;
    std::cout << "int is: " << typeid(int).name() << '\n';
    std::cout << "  i is: " << typeid(i).name() << '\n';
    std::cout << " pi is: " << typeid(pi).name() << '\n';
    std::cout << "*pi is: " << typeid(*pi).name() << '\n';

    return 0;
}

结果：

4Base
7Derived

int is: int
  i is: int
 pi is: int *
*pi is: int

判断数据是否是对应的数据类型

头文件<type_traits>

主要类型类别 Primary type categories

• is_array

  Is array (class template )

  // is_array example
  #include <iostream>
  #include <array>
  #include <string>
  #include <type_traits>
  
  int main() {
      std::cout << std::boolalpha;
      std::cout << "is_array:" << std::endl;
      std::cout << "int: " << std::is_array<int>::value << std::endl;
      std::cout << "int[3]: " << std::is_array<int[3]>::value << std::endl;
      std::cout << "array<int,3>: " << std::is_array<std::array<int,3>>::value << std::endl;
      std::cout << "string: " << std::is_array<std::string>::value << std::endl;
      std::cout << "string[3]: " << std::is_array<std::string[3]>::value << std::endl;
      return 0;
  }
  

  结果：

  is_array:
  int: false
  int[3]: true
  array<int,3>: false
  string: false
  string[3]: true
  

• is_class

  Is non-union class (class template )

• is_enum

  Is enum (class template )

• is_floating_point

  Is floating point (class template )

• is_function

  Is function (class template )

• is_integral

  Is integral (class template )

• is_lvalue_reference

  Is lvalue reference (class template )

• is_member_function_pointer

  Is member function pointer (class template )

• is_member_object_pointer

  Is member object pointer (class template )

• is_pointer

  Is pointer (class template )

• is_rvalue_reference

  Is rvalue reference (class template )

• is_union

  Is union (class template )

• is_void

  Is void (class template )

复合类型范畴 Composite type categories

• is_arithmetic

  Is arithmetic type (class template )

  // is_arithmetic example
  #include <iostream>
  #include <type_traits>
  #include <complex>
  
  int main() {
      std::cout << std::boolalpha;
      std::cout << "is_arithmetic:" << std::endl;
      std::cout << "char: " << std::is_arithmetic<char>::value << std::endl;
      std::cout << "float: " << std::is_arithmetic<float>::value << std::endl;
      std::cout << "float*: " << std::is_arithmetic<float*>::value << std::endl;
      std::cout << "complex<double>: " << std::is_arithmetic<std::complex<double>>::value << std::endl;
      return 0;
  }
  

Output: bash is_arithmetic: char: true float: true float*: false complex<double>: false

• is_compound

  Is compound type (class template )

• is_fundamental

  Is fundamental type (class template )

• is_member_pointer

  Is member pointer type (class template )

• is_object

  Is object type (class template )

• is_reference

  Is reference type (class template )

• is_scalar

  Is scalar type (class template )

类型属性 Type properties

• is_abstract

  Is abstract class (class template )

  // is_abstract example
  #include <iostream>
  #include <type_traits>
  
  struct A { };
  struct B {
    	virtual void fn() = 0;  // pure virtual function
  };
  struct C : B { };
  struct D : C { virtual void fn(){} };
  
  int main() {
      std::cout << std::boolalpha;
      std::cout << "is_abstract:" << std::endl;
      std::cout << "A: " << std::is_abstract<A>::value << std::endl;
      std::cout << "B: " << std::is_abstract<B>::value << std::endl;
      std::cout << "C: " << std::is_abstract<C>::value << std::endl;
      std::cout << "D: " << std::is_abstract<D>::value << std::endl;
      return 0;
  }
  

结果：

is_abstract:
A: false
B: true
C: true
D: false

• is_const

  Is const-qualified (class template )

• is_empty

  Is empty class (class template )

• is_literal_type

  Is literal type (class template )

• is_pod

  Is POD type (class template )

• is_polymorphic

  Is polymorphic (class template )

• is_signed

  Is signed type (class template )

• is_standard_layout

  Is standard-layout type (class template )

• is_trivial

  Is trivial type (class template )

• is_trivially_copyable

  Is trivially copyable (class template )

• is_unsigned

  Is unsigned type (class template )

• is_volatile

  Is volatile-qualified (class template )

类型特征 Type features

• has_virtual_destructor

  Has virtual destructor (class template )

  // has_virtual_destructor example
  #include <iostream>
  #include <type_traits>
  
  struct A { };
  struct B { virtual ~B(){} };
  struct C : B { };
  
  int main() {
      std::cout << std::boolalpha;
      std::cout << "has_virtual_destructor:" << std::endl;
      std::cout << "int: " << std::has_virtual_destructor<int>::value << std::endl;
      std::cout << "A: " << std::has_virtual_destructor<A>::value << std::endl;
      std::cout << "B: " << std::has_virtual_destructor<B>::value << std::endl;
      std::cout << "C: " << std::has_virtual_destructor<C>::value << std::endl;
      return 0;
  }
  

Output:

has_virtual_destructor:
int: false
A: false
B: true
C: true

• is_assignable

  Is assignable (class template )

• is_constructible

  Is constructible (class template )

• is_copy_assignable

  Is copy assignable (class template )

• is_copy_constructible

  Is copy constructible (class template )

• is_destructible

  Is destructible (class template )

• is_default_constructible

  Is default constructible (class template )

• is_move_assignable

  Is move assignable (class template )

• is_move_constructible

  Is move constructible (class template )

• is_trivially_assignable

  Is trivially assignable (class template )

• is_trivially_constructible

  Is trivially constructible (class template )

• is_trivially_copy_assignable

  Is trivially copy assignable (class template )

• is_trivially_copy_constructible

  Is trivially copy constructible (class template )

• is_trivially_destructible

  Is trivially destructible (class template )

• is_trivially_default_constructible

  Is trivially default constructible (class template )

• is_trivially_move_assignable

  Is trivially move assignable (class template )

• is_trivially_move_constructible

  Is trivially move constructible (class template )

• is_nothrow_assignable

  Is assignable throwing no exceptions (class template )

• is_nothrow_constructible

  Is constructible throwing no exceptions (class template )

• is_nothrow_copy_assignable

  Is copy assignable throwing no exceptions (class template )

• is_nothrow_copy_constructible

  Is copy constructible throwing no exceptions (class template )

• is_nothrow_destructible

  Is nothrow destructible (class template )

• is_nothrow_default_constructible

  Is default constructible throwing no exceptions (class template )

• is_nothrow_move_assignable

  Is move assignable throwing no exception (class template )

• is_nothrow_move_constructible

  Is move constructible throwing no exceptions (class template )

类型关系 Type relationships

• is_base_of

  Is base class of (class template )

  // is_base_of example
  #include <iostream>
  #include <type_traits>
  
  struct A {};
  struct B : A {};
  
  int main() {
      std::cout << std::boolalpha;
      std::cout << "is_base_of:" << std::endl;
      std::cout << "int, int: " << std::is_base_of<int,int>::value << std::endl;
      std::cout << "A, A: " << std::is_base_of<A,A>::value << std::endl;
      std::cout << "A, B: " << std::is_base_of<A,B>::value << std::endl;
      std::cout << "A, const B: " << std::is_base_of<A,const B>::value << std::endl;
      std::cout << "A&, B&: " << std::is_base_of<A&,B&>::value << std::endl;
      std::cout << "B, A: " << std::is_base_of<B,A>::value << std::endl;
      return 0;
  }
  

Output:

is_base_of:
int, int: false
A, A: true
A, B: true
A, const B: true
A&, B&: false
B, A: false

• is_convertible

  Is convertible (class template )

• is_same

  Is same type (class template )