Compilerunterstützung für Typmerkmale (Komponentenerweiterungen für C++)

  • Artikel

Der Compiler unterstützt Typmerkmale, die verschiedene Eigenschaften eines Typs zur Kompilierungszeit angeben.

Alle Laufzeiten

Hinweise

Typmerkmale sind Programmierer hilfreich, die Bibliotheken schreiben.

In der folgenden Tabelle werden die Typmerkmale aufgeführt, die vom Compiler unterstützt werden.Alle Typmerkmale geben false zurück, wenn die Bedingung, die durch den Namen des Typmerkmal angegeben ist, nicht erfüllt wird.

(In der Spalte Beschreibung der Tabelle werden nur Codebeispiele in C++/CLI geschrieben.Das entsprechende Typmerkmal wird auch in Komponentenerweiterungen für Visual C++ sofern nicht anders angegeben.Der Begriff "Typ" Plattform entweder auf Typen oder Windows-Runtime Common Language Runtime) an.

Typ-Merkmal

Beschreibung

__has_assign(type)

Gibt true zurück, wenn die Plattform oder der systemeigene Typ einen Kopierzuweisungsoperator verfügt.

// has_assign.cpp
// compile with: /clr
ref struct R {
   void operator=(R% r) {}
};
int main() {
   System::Console::WriteLine(__has_assign(R));
}

__has_copy(type)

Gibt true zurück, wenn die Plattform oder der systemeigene Typ über einen Kopierkonstruktor verfügt.

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

__has_finalizer(type)

(Wird nicht in Komponentenerweiterungen für Visual C++). Gibt true zurück, wenn der CLR-Typ einen Finalizer hat.Weitere Informationen finden Sie unter Destruktoren und Finalizer 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)

Gibt true zurück, wenn ein Kopierzuweisungsoperator eine leere Ausnahmespezifikation ist.

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

Gibt true zurück, wenn der Standardkonstruktor eine leere Ausnahmespezifikation ist.

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

Gibt true zurück, wenn der Kopierkonstruktor eine leere Ausnahmespezifikation ist.

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

Gibt true zurück, wenn der Typ über einen trivialen, vom Compiler generierten Zuweisungsoperator verfügt.

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

Gibt true zurück, wenn der Typ über einen trivialen, vom Compiler generierten Standardkonstruktor verfügt.

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

Gibt true zurück, wenn der Typ über einen trivialen, vom Compiler generierten Kopierkonstruktor verfügt.

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

Gibt true zurück, wenn der Typ über einen trivialen Destruktor vom Compiler generiert hat.

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

Gibt true zurück, wenn die Plattform oder der systemeigene Typ USER-deklarierten einen Destruktor verfügt.

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

Gibt true zurück, wenn der Typ über einen virtuellen Destruktor verfügt.

__has_virtual_destructor funktioniert auch auf Plattform, und jeder benutzerdefinierte Typen in einem Destruktor Typ von Plattform ist ein virtueller Destruktor.

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

Gibt true zurück, wenn der Typ ein abstrakter Typ ist.Weitere Informationen zu systemeigenen abstrakte Typen finden Sie unter abstract (Komponentenerweiterungen für C++).

__is_abstract funktioniert auch für Plattform Typen.Eine Schnittstelle mit mindestens einköpfigem ist ein abstrakter Typ, z. B. ein Verweistyp mit mindestens einem abstrakten Member.Weitere Informationen zu abstrakten Typen finden Sie unter Abstrakte Klassen (C++) Plattform

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

Gibt true zurück, wenn der erste Typ eine Basisklasse zweite Typ ist, der zurück, wenn beide Typen gleich sind.

__is_base_of funktioniert auch Plattform Typen.Beispielsweise gibt er true zurück, wenn der erste Typ interface class (Komponentenerweiterungen für C++) ist und der zweite Typ die Schnittstelle implementiert.

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

Gibt true zurück, wenn der Typ einer systemeigenen Klasse oder eine Struktur ist.

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

Gibt true zurück, wenn der erste Typ für den zweiten Typ konvertiert werden kann.

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

Gibt true zurück, wenn type ein Delegat ist.Weitere Informationen finden Sie unter delegate (Komponentenerweiterungen für C++).

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

__is_empty(type)

Gibt true zurück, wenn der Typ keine Instanzdaten Member verfügt.

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

Gibt true zurück, wenn der Typ eine systemeigene Enumeration vorhanden ist.

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

Gibt true zurück, wenn Sie einer Plattform Oberfläche übergeben werden.Weitere Informationen finden Sie unter interface class (Komponentenerweiterungen für 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)

Gibt true zurück, wenn der Typ eine Klasse oder eine Union ohne Konstruktor oder private oder geschützte nicht statischen Member keine Basisklassen und keine virtuellen Funktionen ist.Siehe den C++-Standard, die Abschnitte 8.5.1/1, das 9/4 und die 3.9/10 Informationen zu Hülsen.

__is_pod auf einfachen Typen gibt false zurück.

// is_pod.cpp
#include <stdio.h>
struct S {};
int main() {
   __is_pod(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_polymorphic(type)

Gibt true zurück, wenn ein systemeigener Typ virtuelle Funktionen verfügt.

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

Gibt true zurück, wenn Sie ein Zeichenfolgenarray Plattform übergeben werden.Weitere Informationen finden Sie unter Arrays (Komponentenerweiterungen für 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)

Gibt true zurück, wenn Sie einer Verweisklasse übergeben werden.Weitere Informationen zu benutzerdefinierten Referenztypen finden Sie unter Klassen und Strukturen (Komponentenerweiterungen für 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)

Gibt true zurück, wenn Sie einer Plattform oder einem systemeigenen Typ übergeben werden, die sealed gekennzeichnet ist.Weitere Informationen finden Sie unter sealed (Komponentenerweiterungen für C++).

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

__is_simple_value_class(type)

Gibt true zurück, wenn Sie einen Werttyp übergeben werden, der keine Verweise auf den Heap der Garbage Collection enthält.Weitere Informationen zu benutzerdefinierten Werttypen finden Sie Klassen und Strukturen (Komponentenerweiterungen für 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)

Gibt true zurück, wenn ein Typ eine Union ist.

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

Gibt true zurück, wenn Sie einen Werttyp übergeben werden.Weitere Informationen zu benutzerdefinierten Werttypen finden Sie Klassen und Strukturen (Komponentenerweiterungen für C++).

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

Windows-Runtime

Hinweise

Das __has_finalizer(-Typ )-Typmerkmal wird nicht unterstützt, da diese Plattform Finalizer nicht unterstützt.

ms177194.collapse_all(de-de,VS.110).gifAnforderungen

Compileroption: /ZW

Common Language Runtime

Hinweise

(Es gibt keine plattformspezifische Hinweise für diese Funktion.)

ms177194.collapse_all(de-de,VS.110).gifAnforderungen

Compileroption: /clr

ms177194.collapse_all(de-de,VS.110).gifBeispiele

Beispiel

Im folgenden Codebeispiel wird veranschaulicht, wie eine Klassenvorlage verwendet, um ein Compilertyp merkmal für eine /clr Kompilierung verfügbar zu machen.Weitere Informationen finden Sie unter Windows-Laufzeit und verwaltete Vorlagen (Komponentenerweiterungen für 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

Siehe auch

Konzepte

Komponentenerweiterungen für Laufzeitplattformen