Compilerunterstützung für Typmerkmale (C++/CLI und C++/CX)

  • Artikel

Der Microsoft C++-Compiler unterstützt Typmerkmale für C++/CLI- und C++/CX-Erweiterungen, die verschiedene Merkmale eines Typs zur Kompilierzeit angeben.

Alle Laufzeiten

Hinweise

Typeigenschaften sind besonders nützlich für Programmierer, die Bibliotheken schreiben.

Die folgende Liste enthält die Typmerkmale, die vom Compiler unterstützt werden. Alle Typeigenschaften werden zurückgegeben false , wenn die durch den Namen des Typs angegebene Bedingung nicht erfüllt ist.

(In der folgenden Liste werden Codebeispiele nur in C++/CLI geschrieben. Die entsprechende Typeigenschaft wird jedoch auch in C++/CX unterstützt, sofern nicht anders angegeben. Der Begriff "Plattformtyp" bezieht sich entweder auf Windows-Runtime Typen oder Common Language Runtime-Typen.)

  • __has_assign(type)

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

    ref struct R {
void operator=(R% r) {}
};

int main() {
System::Console::WriteLine(__has_assign(R));
}

  • __has_copy(type)

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

    ref struct R {
R(R% r) {}
};

int main() {
System::Console::WriteLine(__has_copy(R));
}

  • __has_finalizer(type)

    (In C++/CX nicht unterstützt.) Gibt zurück true , wenn der CLR-Typ über einen Finalizer verfügt. Weitere Informationen finden Sie unter Destruktoren und Finalizer in How to: Define and consume classes and structs (C++/CLI).

    using namespace System;
ref struct R {
~R() {}
protected:
!R() {}
};

int main() {
Console::WriteLine(__has_finalizer(R));
}

  • __has_nothrow_assign(type)

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

    #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 zurück true , wenn der Standardkonstruktor eine leere Ausnahmespezifikation aufweist.

    #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 zurück true , wenn der Kopierkonstruktor eine leere Ausnahmespezifikation aufweist.

    #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 zurück true , wenn der Typ über einen trivialen, compilergenerierten Zuordnungsoperator verfügt.

    #include <stdio.h>
struct S {};

int main() {
__has_trivial_assign(S) == true ?
printf("true\n") : printf("false\n");
}

  • __has_trivial_constructor(type)

    Gibt zurück true , wenn der Typ einen trivialen, compilergenerierten Konstruktor aufweist.

    #include <stdio.h>
struct S {};

int main() {
__has_trivial_constructor(S) == true ?
printf("true\n") : printf("false\n");
}

  • __has_trivial_copy(type)

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

    #include <stdio.h>
struct S {};

int main() {
__has_trivial_copy(S) == true ?
printf("true\n") : printf("false\n");
}

  • __has_trivial_destructor(type)

    Gibt zurück true , wenn der Typ einen trivialen, compilergenerierten Destruktor aufweist.

    // 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 zurück true , wenn der Plattform- oder systemeigene Typ einen vom Benutzer deklarierten Destruktor aufweist.

    // has_user_destructor.cpp

using namespace System;
ref class R {
~R() {}
};

int main() {
Console::WriteLine(__has_user_destructor(R));
}

  • __has_virtual_destructor(type)

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

    __has_virtual_destructor funktioniert auch für Plattformtypen, und jeder 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 zurück true , wenn der Typ ein abstrakter Typ ist. Weitere Informationen zu nativen abstrakten Typen finden Sie unter Abstrakte Klassen.

    __is_abstract funktioniert auch für die Plattformtypen. Eine Schnittstelle mit mindestens einem Member ist ein abstrakter Typ, genauso wie ein Verweistyp mit mindestens einem abstrakten Member. Weitere Informationen zu abstrakten Plattformtypen finden Sie unter 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 )

    Gibt zurück true , wenn der erste Typ eine Basisklasse des zweiten Typs ist oder beide Typen identisch sind.

    __is_base_of funktioniert auch für Plattformtypen. Beispielsweise wird zurückgegeben true , wenn der erste Typ eine Schnittstellenklasse 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 zurück true , wenn der Typ eine systemeigene Klasse oder Struktur ist.

    #include <stdio.h>
struct S {};

int main() {
__is_class(S) == true ?
printf("true\n") : printf("false\n");
}

  • __is_convertible_to( from , to )

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

    #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 zurück true , wenn type es sich um eine Stellvertretung handelt. Weitere Informationen finden Sie unter delegate (C++/CLI und C++/CX).

    delegate void MyDel();
int main() {
System::Console::WriteLine(__is_delegate(MyDel));
}

  • __is_empty(type)

    Gibt zurück true , wenn der Typ keine Instanzdatenmber enthält.

    #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 zurück true , 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 zurück true , wenn eine Plattformschnittstelle übergeben wurde. Weitere Informationen finden Sie unter Schnittstellenklasse.

    // is_interface_class.cpp

using namespace System;
interface class I {};
int main() {
Console::WriteLine(__is_interface_class(I));
}

  • __is_pod(type)

    Gibt zurück true , wenn der Typ eine Klasse oder Vereinigung ohne Konstruktor oder private oder geschützte nicht statische Member, keine Basisklassen und keine virtuellen Funktionen ist. Weitere Informationen zu PODs finden Sie im C++-Standard in den Abschnitten 8.5.1/1, 9/4 und 3.9/10.

    __is_pod gibt „false“ für grundlegende Typen zurück.

    #include <stdio.h>
struct S {};

int main() {
__is_pod(S) == true ?
printf("true\n") : printf("false\n");
}

  • __is_polymorphic(type)

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

    #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 zurück true , wenn ein Plattformarray übergeben wurde. Weitere Informationen finden Sie unter Arrays.

    using namespace System;
int main() {
array<int>^ x = gcnew array<int>(10);
Console::WriteLine(__is_ref_array(array<int>));
}

  • __is_ref_class(type)

    Gibt zurück true , wenn eine Referenzklasse übergeben wurde. Weitere Informationen zu benutzerdefinierten Verweistypen finden Sie unter Klassen und Strukturen.

    using namespace System;
ref class R {};
int main() {
Console::WriteLine(__is_ref_class(Buffer));
Console::WriteLine(__is_ref_class(R));
}

  • __is_sealed(type)

    Gibt zurück true , wenn eine Plattform oder ein systemeigener Typ als versiegelt markiert wurde. Weitere Informationen finden Sie unter sealed.

    ref class R sealed{};
int main() {
System::Console::WriteLine(__is_sealed(R));
}

  • __is_simple_value_class(type)

    Gibt true zurück, wenn ein Werttyp übergeben wird, der keine Verweise auf den garbage-collection-Heap enthält. Weitere Informationen zu benutzerdefinierten Werttypen finden Sie unter Klassen und Strukturen.

    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)

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

    #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 zurück true , wenn ein Werttyp übergeben wurde. Weitere Informationen zu benutzerdefinierten Werttypen finden Sie unter Klassen und Strukturen.

    value struct V {};

int main() {
System::Console::WriteLine(__is_value_class(V));
}

Windows-Runtime

Hinweise

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

Anforderungen

Compileroption: /ZW

Übersicht: Common Language Runtime (CLR)

Hinweise

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

Anforderungen

Compileroption: /clr

Beispiele

Beispiel

Im folgenden Codebeispiel wird veranschaulicht, wie Sie mit einer Klassenvorlage eine Compiler-Typeigenschaft für eine /clr-Kompilierung verfügbar machen. Weitere Informationen finden Sie unter Windows-Runtime und verwaltete Vorlagen.

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

Siehe auch

Komponentenerweiterungen für .NET und UWP