Supporto del compilatore per caratteristiche di tipo (C++/CLI e C++/CX)
Il compilatore Microsoft C++ supporta le caratteristiche di tipo per estensioni C++/CLI e C++/CX, che indicano diverse caratteristiche di un tipo in fase di compilazione.
Tutti i runtime
Osservazioni:
Tratti di tipo sono particolarmente utili per i programmatori che scrivono librerie.
L'elenco seguente contiene le caratteristiche di tipo supportate dal compilatore. Tutti i tratti di tipo restituiscono false
se la condizione specificata dal nome del tratto di tipo non viene soddisfatta.
Nell'elenco seguente gli esempi di codice vengono scritti solo in C++/CLI. Ma il tratto di tipo corrispondente è supportato anche in C++/CX, se non diversamente specificato. Il termine "tipo di piattaforma" si riferisce ai tipi di Windows Runtime o ai tipi Common Language Runtime.
__has_assign(
digitare)
Restituisce
true
se la piattaforma o il tipo nativo dispone di un operatore di assegnazione di copia.ref struct R { void operator=(R% r) {} }; int main() { System::Console::WriteLine(__has_assign(R)); }
__has_copy(
digitare)
Restituisce
true
se la piattaforma o il tipo nativo ha un costruttore di copia.ref struct R { R(R% r) {} }; int main() { System::Console::WriteLine(__has_copy(R)); }
__has_finalizer(
digitare)
Non supportato in C++/CX. Restituisce
true
se il tipo CLR dispone di un finalizzatore. Per altre informazioni, vedere Distruttori e finalizzatori in Procedura: Definire e utilizzare classi e struct (C++/CLI).using namespace System; ref struct R { ~R() {} protected: !R() {} }; int main() { Console::WriteLine(__has_finalizer(R)); }
__has_nothrow_assign(
digitare)
Restituisce
true
se un operatore di assegnazione di copia ha una specifica di eccezione vuota.#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(
digitare)
Restituisce
true
se il costruttore predefinito ha una specifica di eccezione vuota.#include <stdio.h> struct S { S() throw() {} }; int main() { __has_nothrow_constructor(S) == true ? printf("true\n") : printf("false\n"); }
__has_nothrow_copy(
digitare)
Restituisce
true
se il costruttore di copia ha una specifica di eccezione vuota.#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(
digitare)
Restituisce
true
se il tipo ha un operatore di assegnazione semplice generato dal compilatore.#include <stdio.h> struct S {}; int main() { __has_trivial_assign(S) == true ? printf("true\n") : printf("false\n"); }
__has_trivial_constructor(
digitare)
Restituisce
true
se il tipo ha un costruttore semplice generato dal compilatore.#include <stdio.h> struct S {}; int main() { __has_trivial_constructor(S) == true ? printf("true\n") : printf("false\n"); }
__has_trivial_copy(
digitare)
Restituisce
true
se il tipo ha un costruttore di copia semplice generato dal compilatore.#include <stdio.h> struct S {}; int main() { __has_trivial_copy(S) == true ? printf("true\n") : printf("false\n"); }
__has_trivial_destructor(
digitare)
Restituisce
true
se il tipo ha un distruttore semplice generato dal compilatore.// 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(
digitare)
Restituisce
true
se la piattaforma o il tipo nativo dispone di un distruttore dichiarato dall'utente.// has_user_destructor.cpp using namespace System; ref class R { ~R() {} }; int main() { Console::WriteLine(__has_user_destructor(R)); }
__has_virtual_destructor(
digitare)
Restituisce
true
se il tipo dispone di un distruttore virtuale.__has_virtual_destructor
funziona anche su tipi di piattaforma e gli eventuali distruttori definiti dall'utente in un tipo di piattaforma sono distruttori virtuali.// 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(
digitare)
Restituisce
true
se il tipo è un tipo astratto. Per altre informazioni sui tipi astratti nativi, vedere Classi astratte.__is_abstract
funziona anche per i tipi di piattaforma. Un'interfaccia con almeno un membro è un tipo astratto perché è un tipo riferimento con almeno un membro astratto. Per altre informazioni sui tipi piattaforma astratti, vedere abstract.// 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
)
Restituisce
true
se il primo tipo è una classe base del secondo tipo o se entrambi i tipi sono uguali.__is_base_of
funziona anche sui tipi di piattaforma. Ad esempio, restituiscetrue
se il primo tipo è una classe di interfaccia e il secondo tipo implementa l'interfaccia.// 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(
digitare)
Restituisce
true
se il tipo è una classe o uno struct nativo.#include <stdio.h> struct S {}; int main() { __is_class(S) == true ? printf("true\n") : printf("false\n"); }
__is_convertible_to(
from
,
to
)
Restituisce
true
se il primo tipo può essere convertito nel secondo tipo.#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(
digitare)
Restituisce
true
setype
è un delegato. Per altre informazioni, vedere delegate (C++/CLI e C++/CX).delegate void MyDel(); int main() { System::Console::WriteLine(__is_delegate(MyDel)); }
__is_empty(
digitare)
Restituisce
true
se il tipo non dispone di membri dati dell'istanza.#include <stdio.h> struct S { int Test() {} static int i; }; int main() { __is_empty(S) == true ? printf("true\n") : printf("false\n"); }
__is_enum(
digitare)
Restituisce
true
se il tipo è un'enumerazione nativa.// 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(
digitare)
Restituisce
true
se è stata passata un'interfaccia della piattaforma. Per altre informazioni, vedere interface class.// is_interface_class.cpp using namespace System; interface class I {}; int main() { Console::WriteLine(__is_interface_class(I)); }
__is_pod(
digitare)
Restituisce
true
se il tipo è una classe o un'unione senza membri non statici o privati o protetti, senza classi di base e senza funzioni virtuali. Per altre informazioni sui POD, vedere lo standard C++, sezioni 8.5.1/1, 9/4 e 3.9/10.__is_pod
restituisce false per i tipi fondamentali.#include <stdio.h> struct S {}; int main() { __is_pod(S) == true ? printf("true\n") : printf("false\n"); }
__is_polymorphic(
digitare)
Restituisce
true
se un tipo nativo dispone di funzioni virtuali.#include <stdio.h> struct S { virtual void Test(){} }; int main() { __is_polymorphic(S) == true ? printf("true\n") : printf("false\n"); }
__is_ref_array(
digitare)
Restituisce
true
se è stata passata una matrice di piattaforma. Per altre informazioni, vedere Matrici.using namespace System; int main() { array<int>^ x = gcnew array<int>(10); Console::WriteLine(__is_ref_array(array<int>)); }
__is_ref_class(
digitare)
Restituisce
true
se è stata passata una classe di riferimento. Per altre informazioni sui tipi riferimento definiti dall'utente, vedere Classi e struct.using namespace System; ref class R {}; int main() { Console::WriteLine(__is_ref_class(Buffer)); Console::WriteLine(__is_ref_class(R)); }
__is_sealed(
digitare)
Restituisce
true
se è stato passato un tipo nativo o una piattaforma contrassegnata come sealed. Per altre informazioni, vedere sealed.ref class R sealed{}; int main() { System::Console::WriteLine(__is_sealed(R)); }
__is_simple_value_class(
digitare)
Restituisce
true
se è stato passato un tipo valore che non contiene riferimenti all'heap sottoposto a Garbage Collection. Per altre informazioni sui tipi valore definiti dall'utente, vedere Classi e struct.using namespace System; ref class R {}; value struct V {}; value struct V2 { R ^ r; // not a simple value type }; int main() { Console::WriteLine(__is_simple_value_class(V)); Console::WriteLine(__is_simple_value_class(V2)); }
__is_union(
digitare)
Restituisce
true
se un tipo è un'unione.#include <stdio.h> union A { int i; float f; }; int main() { __is_union(A) == true ? printf("true\n") : printf("false\n"); }
__is_value_class(
digitare)
Restituisce
true
se è stato passato un tipo di valore. Per altre informazioni sui tipi valore definiti dall'utente, vedere Classi e struct.value struct V {}; int main() { System::Console::WriteLine(__is_value_class(V)); }
Windows Runtime
Osservazioni:
La caratteristica di tipo __has_finalizer(
tipo)
non è supportata, perché questa piattaforma non supporta i finalizzatori.
Requisiti
Opzione del compilatore: /ZW
Common Language Runtime
Osservazioni:
Non esistono commenti specifici della piattaforma per questa funzionalità.
Requisiti
Opzione del compilatore: /clr
Esempi
Esempio
Nell'esempio di codice seguente viene illustrato come usare un modello di classe per esporre un tratto di tipo del compilatore per una compilazione /clr
. Per altre informazioni, vedere Windows Runtime e modelli gestiti.
// 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");
}
R is a ref class