Freigeben über

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

  • Artikel

Die Compilerunterstützung gibt Merkmalen ein, die unterschiedliche Eigenschaften eines Typs zur Kompilierzeit angeben.

Alle Laufzeiten

Hinweise

Programmierer Typmerkmale sind besonders nützlich, die Bibliotheken schreiben.

Die folgende Tabelle zeigt die Typmerkmale auf, die vom Compiler unterstützt werden. Alle Typmerkmale geben false zurück, wenn die Bedingung, die mit dem Namen des Typmerkmal angegeben ist, nicht erfüllt ist.

(In der Spalte der Tabelle, Codebeispiele werden nur in C++/CLI geschrieben. Wenn das entsprechende Typmerkmal wird auch in Komponentenerweiterungen für Visual C++ falls nicht anders angegeben unterstützt. Der Begriff, "Plattformtyp" verweist entweder Typen oder Windows-Runtime Common Language Runtime verwendet werden.) an

Typ-Merkmal

Beschreibung

__has_assign(type)

Gibt true zurück, wenn die Plattform oder der systemeigene Typ ein Kopierzuweisungsoperator hat.

// 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 systemeigenen Typ einen Kopierkonstruktor ist.

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

__has_finalizer(type)

(Nicht unterstützt 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 hat.

// 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 hat.

// 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 hat.

// 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 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 einen trivialen, vom Compiler generierten Konstruktor 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 einen trivialen, vom Compiler generierten Kopierkonstruktor ist.

// 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 einen trivialen, vom Compiler generierten Destruktor enthält.

// 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 Benutzer-deklarierten Typ einen Destruktor enthält.

// 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 einen virtuellen Destruktor verfügt.

__has_virtual_destructor kann auch an Plattformtypen, und jede benutzerdefinierte Destruktor in einem Plattformtyp 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 vom Typ abstract ist. Weitere Informationen zu systemeigenen abstrakte Typen, finden Sie unter abstract (Komponentenerweiterungen für C++).

__is_abstract kann auch für Plattformtypen. Eine Schnittstelle mit mindestens einköpfigem ist ein abstrakter Typ, z ein Referenztyp mit mindestens einen abstrakten Member. Weitere Informationen zu abstrakten Plattformtypen, finden Sie unter Abstrakte Klassen (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)

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

__is_base_of kann auch an Plattformtypen. Beispielsweise wird true zurück, wenn der erste Typ interface class (Komponentenerweiterungen für C++) handelt 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 eine systemeigene Klasse oder Struktur handelt.

// 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 auf 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 Instanzdatenmember hat.

// 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 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 Plattformschnittstelle übergeben wird. 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 Union ohne Konstruktor oder private oder geschützte nicht statische 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 weitere Informationen zu Hülsen.

__is_pod Gibt false über grundlegende Typen 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 ein Plattformarray übergeben wird. 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 wird. Weitere Informationen zu benutzerdefinierten Verweistypen, 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 wird, die diese versiegelt 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 einem Werttyp übergeben wird, der keine Verweise auf dem Heap der Garbage Collection enthält. Weitere Informationen zu benutzerdefinierten Werttypen, finden Sie unter 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 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 einem Werttyp übergeben wird. Weitere Informationen zu benutzerdefinierten Werttypen, finden Sie unter 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 Typmerkmal __has_finalizer(type) wird nicht unterstützt, da diese Plattform Finalizer nicht unterstützt.

Voraussetzungen

Compileroption: /ZW

Common Language Runtime

Hinweise

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

Voraussetzungen

Compileroption: /clr

Beispiele

Beispiel

Das folgende Codebeispiel zeigt, wie eine Klassenvorlage verwendet, um ein für eine /clr Compilertypmerkmal 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");
}

Ausgabe

Siehe auch

Konzepte

Komponentenerweiterungen für Laufzeitplattformen