Partager via

Prise en charge du compilateur des caractéristiques de type

  • Article

Le compilateur prend en charge tapez les caractéristiques, qui montrent différentes caractéristiques d'un type au moment de la compilation.

Tous les runtimes

Remarques

Les spécifications de type sont particulièrement utiles pour les programmeurs qui écrivent des bibliothèques.

Le tableau suivant fait la liste des accessibilités de type prises en charge par le compilateur. Toutes les spécifications de type renvoient false si la condition spécifiée par le nom de la fonctionnalité de type n'est pas remplie.

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

Spécifications de types

Description

__has_assign(type)

Renvoie true si la plate-forme ou le type natif est 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)

Renvoie true si la plate-forme ou le type natif a un opérateur de construction 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++). Renvoie true si le type CLR a un finaliseur. Pour plus d'informations, consultez Destructeurs et les finaliseurs dans Visual C++.

// 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)

Renvoie true si un opérateur d'assignation de la 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)

Renvoie 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)

Renvoie 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)

Renvoie true si le type possède un opérateur d'assignation trivial 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)

Renvoie 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)

Renvoie true si le type possède un constructeur de copie trivial 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)

Renvoie true si le type possède un destructeur trivial 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)

Renvoie true si la plate-forme ou le type natif a un destructeur déclaré par l'utilisateur.

// 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)

Renvoie true si le type possède un destructeur virtuel.

__has_virtual_destructor fonctionne aussi sur les types de données, et tout destructeur défini par l'utilisateur dans un type de données 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)

Renvoie true si le type est un type abstrait. Pour plus d'informations sur les types abstraits natifs, consultez résumé (Visual C++).

__is_abstract fonctionne également pour les types de données. Une interface avec au moins un membre est un type abstrait, de même qu'un type référence à au moins un membre abstrait. Pour plus d'informations sur les plateformes abstraites, consultez 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)

Renvoie true si le premier type est une classe de base du second type, de si les deux types sont identiques.

__is_base_of fonctionne aussi sur les types de données. Par exemple, elle renvoie true si le premier type est classe d'interface et si 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)

Renvoie 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)

Renvoie true si le premier type puisse ê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)

Renvoie true si type est un délégué. Pour plus d'informations, consultez delegate.

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

__is_empty(type)

Renvoie true si le type n'a aucun membre de données de l'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)

Renvoie true si le type est une énumération 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)

Renvoie true si transmis une interface de plateforme. Pour plus d'informations, consultez classe d'interface.

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

__is_pod(type)

Renvoie true si le type est une classe ou une union sans le constructeur ou non les membres statiques privés ou protégés, aucune classes de base, et les fonctions virtuels. Consultez les sections 8.5.1/1, 9/4, et 3.9/10 de C++ stantdard pour plus d'information sur les PODs.

__is_pod renvoie 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)

Renvoie true si un type natif contient des fonctions virtuels.

// 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)

Renvoie true si transmis un tableau de plateforme. Pour plus d'informations, consultez tableau (Visual 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)

Renvoie true si transmis a une classe de référence. Pour plus d'informations sur les types de references définis par l'utilisateur, consultez Classes et structures (géré).

// 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)

Renvoie true si transmis a une plate-forme ou un type natif comme scellé. 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)

Renvoie true si transmis un type de valeur qui ne contient pas de références au segment récupérés par le garbage collector. Pour plus d'informations sur les types de valeurs définis par l'utilisateur, consultez Classes et structures (géré).

// 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)

Renvoie true si le 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)

Renvoie true si transmis un type de valeur. Pour plus d'informations sur les types de valeurs définis par l'utilisateur, consultez Classes et structures (géré).

// 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 __has_finalizer(type) n'est pas prise en charge car cette plateforme ne prend pas en charge les finaliseurs.

Conditions requises

Option du compilateur : /ZW

Common Language Runtime

Remarques

(Il n'existe aucune note spécifique à la plateforme pour cette fonctionnalité.)

Conditions requises

Option du compilateur : /clr

Exemples

Exemple

L'exemple de code suivant montre comment utiliser un modèle de la classe pour exposer une caractéristique de type du compilateur pour une compilation /clr. Pour plus d'informations, consultez modèles managés.

// 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

Fonctionnalités de langage pour cibler le CLR