Condividi tramite

Supporto del compilatore per tratti di tipo (Estensioni del componente C++)

  • Articolo

Il compilatore supporta tratti di tipo, che indicano le varie caratteristiche di un tipo in fase di compilazione.

Tutti i runtime

Osservazioni

Tratti di tipo sono particolarmente utili per i programmatori che scrivono librerie.

La tabella seguente elenca i tratti di tipo supportati dal compilatore. Tutti i tratti di tipo restituiscono false se la condizione specificata dal nome del tratto di tipo non viene soddisfatta.

(Nella colonna descrizione della tabella, esempi di codice vengono scritti solo in C++/CLI. Ma il tratto di tipo corrispondente è supportato anche in Estensioni componenti Visual C++ a meno di una diversa dichiarazione. Il termine, "tipo di piattaforma" fa riferimento ai tipi di Windows Runtime o ai tipi di Common Language Runtime).

Tratto di Tipo

Descrizione

__has_assign(type)

Restituisce true se la piattaforma o il tipo nativo ha un operatore di assegnazione di copia.

// has_assign.cpp
// compile with: /clr
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.

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

__has_finalizer(type)

(Non supportata in Estensioni componenti Visual C++.) Restituisce true se il tipo CLR dispone di un finalizzatore. Per ulteriori informazioni, vedere distruttori e finalizzatori in 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)

Restituisce true se un operatore di assegnazione di copia ha una specifica di eccezione vuota.

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

Restituisce true se il costruttore predefinito include una specifica di eccezione vuota.

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

Restituisce true se il costruttore di copia include una specifica di eccezione vuota.

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

Restituisce true se il tipo presenta un operatore semplice e generato dal compilatore.

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

Restituisce true se il tipo presenta un costruttore semplice e generato dal compilatore.

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

Restituisce true se il tipo presenta un costruttore di copia semplice e generato dal compilatore.

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

Restituisce true se il tipo presenta un distruttore semplice e 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 presenta un distruttore dichiarato dall'utente.

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

Restituisce true se il tipo presenta un distruttore virtuale.

__has_virtual_destructor funziona anche sui tipi di piattaforma e ogni distruttore definito dall'utente in un tipo di piattaforma è un distruttore virtuale.

// 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 ulteriori informazioni sui tipi astratti nativi, vedere abstract (Estensioni del componente C++).

__is_abstract funziona anche per i tipi di piattaforma. Un'interfaccia con almeno un membro è un tipo astratto, come è un tipo di riferimento con almeno un membro astratto. Per ulteriori informazioni sui tipi di piattaforma astratti, vedere Classi astratte (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)

Restituisce true se il primo tipo è una classe base del secondo di tipo o se entrambi i tipi sono uguali.

__is_base_of è applicabile anche ai tipi di piattaforma. Ad esempio, restituirà true se il primo tipo è classe di interfaccia (Estensioni del componente C++) 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 una struttura nativa.

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

Restituisce true se il primo tipo può essere convertito nel secondo tipo.

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

Restituisce true se type è un delegato. Per ulteriori informazioni, vedere delegato (Estensioni del componente C++).

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

__is_empty(type)

Restituisce true se il tipo non dispone di membri dati di istanza.

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

Restituisce true se il tipo è un enum nativo.

// 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 passata un'interfaccia della piattaforma. Per ulteriori informazioni, vedere classe di interfaccia (Estensioni del componente 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)

Restituisce true se il tipo è una classe o un'unione senza un costruttore o membri non statici privati o protected, non è una classe base e non sono funzioni virtuali. Vedere lo standard di C++, sezioni 8.5.1/1, 9/4, e 3.9/10 per ulteriori informazioni sui POD.

__is_pod restituirà false sui tipi fondamentali.

// is_pod.cpp
#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.

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

Restituisce true se passato un'array della piattaforma. Per ulteriori informazioni, vedere Matrici (Estensioni del componente 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)

Restituisce true se passata una classe di riferimento. Per ulteriori informazioni sui tipi di riferimento definiti dall'utente, vedere Classi e struct (Estensioni del componente 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)

Restituisce true se passata una piattaforma o un tipo nativo segnato chiuso. Per ulteriori informazioni, vedere sealed (Estensioni del componente C++).

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

__is_simple_value_class(type)

Restituisce true se passato un tipo di valore che non contiene riferimenti all'heap del garbage collection. Per ulteriori informazioni sui tipi di valore definiti dall'utente, vedere Classi e struct (Estensioni del componente 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)

Restituisce true se un tipo è un'unione.

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

Restituisce true se passato un tipo di valore. Per ulteriori informazioni sui tipi di valore definiti dall'utente, vedere Classi e struct (Estensioni del componente C++).

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

Windows Runtime

Osservazioni

Il tratto di tipo di __has_finalizer(type) non è supportato 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

L'esempio di codice seguente mostra come utilizzare un modello di classe per esporre un tratto di tipo del compilatore per una compilazione di /clr. Per ulteriori informazioni, vedere Windows Runtime e modelli gestiti (Estensioni del componente 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");
}

Output

Vedere anche

Concetti

Estensioni componenti per le piattaforme runtime