Prise en charge du compilateur des caractéristiques de type

__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_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_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_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_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_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_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_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_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_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_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_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_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_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));
}