Supporto del compilatore per caratteristiche di tipo (C++/CLI e C++/CX)

Articolo
06/16/2023

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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, restituisce true 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(type)

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(type)

Restituisce true se type è 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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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(type)

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

Vedi anche

Estensioni componenti per .NET e UWP

Supporto del compilatore per caratteristiche di tipo (C++/CLI e C++/CX)

Tutti i runtime

Osservazioni:

Windows Runtime

Osservazioni:

Requisiti

Common Language Runtime

Osservazioni:

Requisiti

Esempi

Vedi anche

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive