Partager via

Prise en charge du compilateur pour les Type Traits (extensions du composant C++)

  • Article

Prend en charge de compilateur entrez les caractéristiques, qui indiquent différentes caractéristiques d'un type au moment de la compilation.

Tous les runtimes

Remarques

Les caractéristiques de type sont particulièrement utiles aux programmeurs qui écrivent des bibliothèques.

Le tableau suivant répertorie les caractéristiques de type qui sont prises en charge par le compilateur.Toutes les caractéristiques de type retournent false si la condition spécifiée en regard de le nom de la fonctionnalité de type n'est pas remplie.

(Dans la colonne description de la table, des exemples de code sont écrits uniquement dans C++/CLI.Mais la fonctionnalité correspondante de type est également prise en charge dans Extensions de composant Visual C++ sauf indication contraire.Le terme, « type de plateforme » fait référence aux types d' Windows Runtime ou à des types du common langage runtime.)

Trait de type

Description

__has_assign(type)

Retourne la valeur true si la plateforme ou le type natif a un opérateur d'assignation de copie.

// has_assign.cpp
// compile with: /clr
ref struct R {
   void operator=(R% r) {}
};
int main() {
   System::Console::WriteLine(__has_assign(R));
}

__has_copy(type)

Retourne la valeur true si la plateforme ou le type natif a un constructeur de copie.

// has_copy.cpp
// compile with: /clr
ref struct R {
   R(R% r) {}
};
int main() {
   System::Console::WriteLine(__has_copy(R));
}

__has_finalizer(type)

(Non pris en charge dans Extensions de composant Visual C++.) Retourne la valeur true si le type CLR a un finaliseur.Consultez Destructeurs et les finaliseurs dans Visual C++ pour plus d'informations.

// has_finalizer.cpp
// compile with: /clr
using namespace System;
ref struct R {
   ~R() {}
protected:
   !R() {}
};
int main() {
   Console::WriteLine(__has_finalizer(R));
}

__has_nothrow_assign(type)

Retourne la valeur true si un opérateur d'assignation de copie a une spécification vide d'exception.

// has_nothrow_assign.cpp
#include <stdio.h>
struct S { 
   void operator=(S& r) throw() {}
};
int main() {
   __has_nothrow_assign(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_nothrow_constructor(type)

Retourne la valeur true si le constructeur par défaut a une spécification vide d'exception.

// has_nothrow_constructor.cpp
#include <stdio.h>
struct S { 
   S() throw() {}
};
int main() {
   __has_nothrow_constructor(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_nothrow_copy(type)

Retourne la valeur true si le constructeur de copie a une spécification vide d'exception.

// has_nothrow_copy.cpp
#include <stdio.h>
struct S { 
   S(S& r) throw() {}
};
int main() {
   __has_nothrow_copy(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_trivial_assign(type)

Retourne la valeur true si le type possède un opérateur d'assignation simple et généré par le compilateur.

// has_trivial_assign.cpp
#include <stdio.h>
struct S {};
int main() {
   __has_trivial_assign(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_trivial_constructor(type)

Retourne la valeur true si le type possède un constructeur trivial et généré par le compilateur.

// has_trivial_constructor.cpp
#include <stdio.h>
struct S {};
int main() {
   __has_trivial_constructor(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_trivial_copy(type)

Retourne la valeur true si le type possède un constructeur de copie simple et généré par le compilateur.

// has_trivial_copy.cpp
#include <stdio.h>
struct S {};
int main() {
   __has_trivial_copy(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_trivial_destructor(type)

Retourne la valeur true si le type a un destructeur simple et généré par le compilateur.

// has_trivial_destructor.cpp
#include <stdio.h>
struct S {};
int main() {
   __has_trivial_destructor(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_user_destructor(type)

Retourne la valeur true si la plateforme ou le type natif a un destructeur utilisateur-déclaré.

// has_user_destructor.cpp
// compile with: /clr
using namespace System;
ref class R {
   ~R() {}
};
int main() {
   Console::WriteLine(__has_user_destructor(R));
}

__has_virtual_destructor(type)

Retourne la valeur true si le type a un destructeur virtuel.

__has_virtual_destructor fonctionne également sur les types de plateforme, et tout destructeur défini par l'utilisateur dans un type de plateforme est un destructeur virtuel.

// has_virtual_destructor.cpp
#include <stdio.h>
struct S {
   virtual ~S() {}
};
int main() {
   __has_virtual_destructor(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_abstract(type)

Retourne la valeur true si le type est un type abstrait.Pour plus d'informations sur les types abstract natif, consultez l' abstract (extensions du composant C++).

__is_abstract fonctionne également pour les types de plateforme.Une interface avec au moins un membre est un type abstrait, ainsi qu'un type référence avec au moins un membre abstrait.Pour plus d'informations sur les types abstraits de plateforme, consultez l' Classes abstraites (C++)

// is_abstract.cpp
#include <stdio.h>
struct S {
   virtual void Test() = 0;
};
int main() {
   __is_abstract(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_base_of(base,derived)

Retourne la valeur true si le premier type est une classe de base du deuxième type, de si les deux types sont identiques.

__is_base_of fonctionne également sur les types de plateforme.Par exemple, il retourne la valeur true si le premier type est classe d'interface (extensions du composant C++) et le second type implémente l'interface.

// is_base_of.cpp
#include <stdio.h>
struct S {};
struct T : public S {};
int main() {
   __is_base_of(S, T) == true ? 
      printf("true\n") : printf("false\n");
   __is_base_of(S, S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_class(type)

Retourne la valeur true si le type est une classe ou une structure native.

// is_class.cpp
#include <stdio.h>
struct S {};
int main() {
   __is_class(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_convertible_to(from, to)

Retourne la valeur true si le premier type peut être converti au second type.

// is_convertible_to.cpp
#include <stdio.h>
struct S {};
struct T : public S {};
int main() {
   S * s = new S;
   T * t = new T;
   s = t;
   __is_convertible_to(T, S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_delegate(type)

Retourne la valeur true si type est un délégué.Pour plus d'informations, consultez déléguer (extensions du composant C++).

// is_delegate.cpp
// compile with: /clr
delegate void MyDel();
int main() {
   System::Console::WriteLine(__is_delegate(MyDel));
}

__is_empty(type)

Retourne la valeur true si le type n'a aucune donnée membre d'instance.

// is_empty.cpp
#include <stdio.h>
struct S {
   int Test() {}
   static int i;
};
int main() {
   __is_empty(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_enum(type)

Retourne la valeur true si le type est un enum natif.

// is_enum.cpp
#include <stdio.h>
enum E { a, b };
struct S {
   enum E2 { c, d };   
};
int main() {
   __is_enum(E) == true ? 
      printf("true\n") : printf("false\n");
   __is_enum(S::E2) == true ? 
      printf("true\n") : printf("false\n");
}

__is_interface_class(type)

Retourne la valeur true si passé une interface de plateforme.Pour plus d'informations, consultez classe d'interface (extensions du composant C++).

// is_interface_class.cpp
// compile with: /clr
using namespace System;
interface class I {};
int main() {
   Console::WriteLine(__is_interface_class(I));
}

__is_pod(type)

Retourne la valeur true si le type est une classe ou une union sans le constructeur ou les membres non statiques privés ou protégés, aucune classes de base, et les fonctions virtuelles.Consultez la norme C++, les sections 8.5.1/1, le 9/4, et les 3.9/10 pour plus d'informations sur les cosses.

__is_pod retourne la valeur false sur les types fondamentaux.

// is_pod.cpp
#include <stdio.h>
struct S {};
int main() {
   __is_pod(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_polymorphic(type)

Retourne la valeur true si un type natif a des fonctions virtuelles.

// is_polymorphic.cpp
#include <stdio.h>
struct S {
   virtual void Test(){}
};
int main() {
   __is_polymorphic(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_ref_array(type)

Retourne la valeur true si passé un tableau de plateforme.Pour plus d'informations, consultez Tableaux (extensions du composant C++).

// is_ref_array.cpp
// compile with: /clr
using namespace System;
int main() {
   array<int>^ x = gcnew array<int>(10);
   Console::WriteLine(__is_ref_array(array<int>));
}

__is_ref_class(type)

Retourne la valeur true si passe une classe de référence.Pour plus d'informations sur les types définis par l'utilisateur, consultez Classes et structs (extensions du composant C++).

// is_ref_class.cpp
// compile with: /clr
using namespace System;
ref class R {};
int main() {
   Console::WriteLine(__is_ref_class(Buffer));
   Console::WriteLine(__is_ref_class(R));
}

__is_sealed(type)

Retourne la valeur true si passé une plateforme ou un type natif marqué sealed.Pour plus d'informations, consultez sealed (extensions du composant C++).

// is_sealed.cpp
// compile with: /clr
ref class R sealed{};
int main() {
   System::Console::WriteLine(__is_sealed(R));
}

__is_simple_value_class(type)

Retourne la valeur true si passé un type valeur qui ne contient aucune référence vers le tas récupéré par le garbage collector.Pour plus d'informations sur les types valeur définis par l'utilisateur, consultez Classes et structs (extensions du composant C++).

// is_simple_value_class.cpp
// compile with: /clr
using namespace System;
ref class R {};
value struct V {};
value struct V2 {
   R ^ r;   // not a simnple value type
};
int main() {
   Console::WriteLine(__is_simple_value_class(V));
   Console::WriteLine(__is_simple_value_class(V2));
}

__is_union(type)

Retourne la valeur true si un type est une union.

// is_union.cpp
#include <stdio.h>
union A {
   int i;
   float f;
};
int main() {
   __is_union(A) == true ? 
      printf("true\n") : printf("false\n");
}

__is_value_class(type)

Retourne la valeur true si passé un type valeur.Pour plus d'informations sur les types valeur définis par l'utilisateur, consultez Classes et structs (extensions du composant C++).

// is_value_class.cpp
// compile with: /clr
value struct V {};
int main() {
   System::Console::WriteLine(__is_value_class(V));
}

Windows Runtime

Remarques

La fonctionnalité de type d' __has_finalizer(type) n'est pas prise en charge car cette plateforme ne prend pas en charge les finaliseurs.

ms177194.collapse_all(fr-fr,VS.110).gifConfiguration requise

Option du compilateur : /ZW

Common Language Runtime

Remarques

(Il n'y a aucune note en plateforme spécifique pour cette fonctionnalité.)

ms177194.collapse_all(fr-fr,VS.110).gifConfiguration requise

Option du compilateur : /clr

ms177194.collapse_all(fr-fr,VS.110).gifExemples

Exemple

L'exemple de code suivant montre comment utiliser un modèle de classe pour exposer un trait de type de compilateur pour une compilation d' /clr .Pour plus d'informations, consultez Windows Runtime et modèles gérés (extensions du composant C++).

// compiler_type_traits.cpp
// compile with: /clr
using namespace System;

template <class T>
ref struct is_class {
   literal bool value = __is_ref_class(T);
};

ref class R {};

int main () {
   if (is_class<R>::value)
      Console::WriteLine("R is a ref class");
   else
      Console::WriteLine("R is not a ref class");
}

Sortie

Voir aussi

Concepts

Extensions de composant pour les plateformes Runtime