CKTIS / C++
std::is_same et std::is_same_v — identité de type
std::is_same et std::is_same_v de <type_traits> vérifient à la compilation si deux types sont exactement le même type. Ils tiennent compte de const, volatile et des références ; ils ne vérifient ni l’égalité des valeurs ni la possibilité de conversion.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <type_traits>
std::is_same<T, U>::value
std::is_same_v<T, U>std::is_same<T, U> de <type_traits> est un modèle de classe qui vérifie l’identité des types à la compilation. Il dérive de std::true_type lorsque T et U désignent exactement le même type avec les mêmes qualifications const et volatile ; sinon, il dérive de std::false_type.
std::is_same<T, U>::value expose le résultat sous la forme d’une constante booléenne. std::is_same_v<T, U> est un modèle de variable qui fournit une écriture plus courte du même résultat ; ce n’est ni un type ni un appel de fonction. Les deux écritures peuvent être utilisées dans static_assert pour imposer une exigence de type à la compilation.
La comparaison ne supprime ni les qualifications ni les références : int, const int, volatile int, int& et int&& sont des types différents. Un alias tel que using Count = int; ne crée pas un nouveau type ; comparer Count à int donne donc true.
Ne confondez pas l’identité des types avec l’égalité des valeurs ou la possibilité de conversion : comparer int à double donne false. L’exemple vérifie ces distinctions à l’aide de static_assert ; son main vide n’affiche aucun texte.
Exemples
#include <type_traits>
using Count = int;
static_assert(std::is_same<Count, int>::value);
static_assert(std::is_same_v<Count, int>);
static_assert(!std::is_same_v<int, const int>);
static_assert(!std::is_same_v<int, volatile int>);
static_assert(!std::is_same_v<int, int&>);
static_assert(!std::is_same_v<int&, int&&>);
static_assert(!std::is_same_v<int, double>);
int main() {}
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.