Bibliothèque standard C++<type_traits>

<type_traits>Est un fichier d'en-tête très utile de la bibliothèque standard C++, contenant un ensemble d'outils pour vérifier les traits de type au moment de la compilation. Ces outils peuvent aider les développeurs à déterminer les caractéristiques des types au moment de la compilation, permettant ainsi un code plus sûr et plus flexible.

<type_traits>Le fichier d'en-tête définit un ensemble de modèles qui peuvent être utilisés pour interroger et manipuler les traits de type. Ces traits incluent, sans s'y limiter :

  • S'il s'agit d'un type entier
  • S'il s'agit d'un type à virgule flottante
  • S'il s'agit d'un type pointeur
  • S'il s'agit d'un type référence
  • s'il est appelable (fonction ou pointeur de fonction)

Syntaxe

<type_traits>Les modèles qu'il contient utilisent généralementstd::le préfixe, par ex.std::is_integral<T>::valueUtilisé pour vérifier des typesTs'il s'agit d'un type entier. Icivalueest une constante statique dont la valeur esttrueoufalse。

Voici quelquestype_traitsfonctions couramment utilisées :

Détermination du type de base:

  • std::is_void<T>: Détermine le typeTs'il s'agit devoid。
  • std::is_integral<T>: Détermine le typeTS'il s'agit d'un type entier.
  • std::is_floating_point<T>: Détermine le typeTS'il s'agit d'un type à virgule flottante.
  • std::is_array<T>: Détermine le typeTs'il s'agit d'un type tableau.
  • std::is_pointer<T>: Détermine le typeTs'il s'agit d'un type pointeur.
  • std::is_reference<T>: Détermine le typeTs'il s'agit d'un type référence.
  • std::is_const<T>: Détermine le typeTs'il s'agit deconstqualifié.

Modificateurs de type:

  • std::remove_const<T>: Supprimer le typeTdeconstqualifié.
  • std::remove_volatile<T>: Supprimer le typeTdevolatilequalifié.
  • std::remove_cv<T>: supprimer aussi le typeTdeconstetvolatilequalifié.
  • std::remove_reference<T>: Supprimer le typeT.
  • std::remove_pointer<T>: Supprimer le typeT.

Conversion de type:

  • std::add_const<T>: au typeTajoutezconstqualifié.
  • std::add_volatile<T>: au typeTajoutezvolatilequalifié.
  • std::add_cv<T>: Aussi, pour le typeTajoutezconstetvolatilequalifié.
  • std::add_pointer<T>: au typeTajouter un qualificateur de pointeur.
  • std::add_lvalue_reference<T>: au typeTajouter un qualificateur de référence lvalue.
  • std::add_rvalue_reference<T>: au typeTajouter un qualificateur de référence rvalue.

Détection de trait de type:

  • std::is_same<T, U>: Détermine le typeTetUs'ils sont identiques.
  • std::is_base_of<Base, Derived>: Détermine le typeBases'il s'agit du typeDerived.
  • std::is_convertible<From, To>: Détermine le typeFroms'il peut être converti en typeTo。

Type conditionnel:

  • std::conditional<Condition, T, F>: siConditionesttrue, alors le type estT, sinon il estF。
  • std::enable_if<Condition, T>: siConditionesttrue, alors le type estT, sinon ce modèle ne participe pas à la résolution de surcharge.

Exemple

Voici quelques<type_traits>exemples d'utilisation, et leurs résultats de sortie.

vérifie s'il s'agit d'un type entier

Exemple

#include <iostream>
#include <type_traits>

int main() {
    std::cout << "int est un entier : " << std::is_integral<int>::value << std::endl;
    std::cout << "float est intégral : " << std::is_integral<float>::value << std::endl;
    std::cout << "char est intégral : " << std::is_integral<char>::value << std::endl;
    return 0;
}

Sortie :

int is integral: 1
float is integral: 0
char is integral: 1

vérifier s'il s'agit d'un type à virgule flottante

Exemple

#include <iostream>
#include <type_traits>

int main() {
    std::cout << "int est floating_point : " << std::is_floating_point<int>::value << std::endl;
    std::cout << "float est floating_point : " << std::is_floating_point<float>::value << std::endl;
    std::cout << "double est floating_point : " << std::is_floating_point<double>::value << std::endl;
    return 0;
}

Sortie :

int is floating_point: 0
float is floating_point: 1
double is floating_point: 1

vérifier s'il s'agit d'un type pointeur

Exemple

#include <iostream>
#include <type_traits>

int main() {
    int a = 10;
    int* p = &a;
    std::cout << "int* est un pointeur : " << std::is_pointer<int*>::value << std::endl;
    std::cout << "int est un pointeur : " << std::is_pointer<int>::value << std::endl;
    return 0;
}

Sortie :

int* is a pointer: 1
int is a pointer: 0

vérifie s'il s'agit d'un type de référence

Exemple

#include <iostream>
#include <type_traits>

int main() {
    int a = 10;
    int& ref = a;
    std::cout << "int& est une référence : " << std::is_reference<int&>::value << std::endl;
    std::cout << "int est une référence : " << std::is_reference<int>::value << std::endl;
    return 0;
}

Sortie :

int& is a reference: 1
int is a reference: 0

vérifie si c'est appelable

Exemple

#include <iostream>
#include <type_traits>
#include <functional>

void func() {}

int main() {
    std::cout << "int est appelable : " << std::is_callable<int>::value << std::endl;
    std::cout << "void() est appelable : " << std::is_callable<void()>::value << std::endl;
    std::cout << "func est appelable : " << std::is_callable<decltype(func)>::value << std::endl;
    return 0;
}

Sortie :

int is callable: 0
void() is callable: 1
func is callable: 1

<type_traits>est un outil très utile en C++ qui permet aux développeurs de vérifier et de manipuler les traits de type au moment de la compilation. Cela améliore non seulement la sécurité du code, mais rend aussi le code plus flexible et réutilisable.

autres extensions