Obsługa cech typu w kompilatorze (C++/CLI i C++/CX)

Artykuł
10/12/2023

Kompilator języka Microsoft C++ obsługuje cechy typów dla rozszerzeń C++/CLI i C++/CX, które wskazują różne cechy typu w czasie kompilacji.

Wszystkie środowiska wykonawcze

Uwagi

Cechy typów są szczególnie przydatne dla programistów, którzy piszą biblioteki.

Poniższa lista zawiera cechy typów obsługiwane przez kompilator. Wszystkie cechy typu zwracają false , jeśli warunek określony przez nazwę cechy typu nie jest spełniony.

(Na poniższej liście przykłady kodu są napisane tylko w języku C++/interfejsie wiersza polecenia. Jednak odpowiednia cecha typu jest również obsługiwana w języku C++/CX, chyba że określono inaczej. Termin "typ platformy" odnosi się do typów środowisko wykonawcze systemu Windows lub typów środowiska uruchomieniowego języka wspólnego).

__has_assign(type)

Zwraca wartość , jeśli platforma lub typ macierzysty true ma operator przypisania kopiowania.
```
ref struct R {
void operator=(R% r) {}
};

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

Zwraca wartość , jeśli platforma lub typ macierzysty true ma konstruktor kopiujący.
```
ref struct R {
R(R% r) {}
};

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

(Nieobsługiwane w języku C++/CX). Zwraca wartość true , jeśli typ CLR ma finalizator. Aby uzyskać więcej informacji, zobacz Destruktory i finalizatory w temacie How to: Define and consume classes and structs (C++/CLI) (Instrukcje: definiowanie i używanie klas i struktur (C++/CLI).
```
using namespace System;
ref struct R {
~R() {}
protected:
!R() {}
};

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

__has_nothrow_assign(type)

Zwraca wartość true , jeśli operator przypisania kopiowania ma pustą specyfikację wyjątku.

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

Zwraca wartość true , jeśli domyślny konstruktor ma pustą specyfikację wyjątku.

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

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

__has_nothrow_copy(type)

Zwraca wartość true , jeśli konstruktor kopiujący ma pustą specyfikację wyjątku.

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

Zwraca wartość true , jeśli typ ma trywialny, generowany przez kompilator operator przypisania.
```
#include <stdio.h>
struct S {};

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

__has_trivial_constructor(type)

Zwraca wartość true , jeśli typ ma trywialny konstruktor wygenerowany przez kompilator.

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

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

__has_trivial_copy(type)

Zwraca wartość true , jeśli typ ma trywialny, generowany przez kompilator konstruktor kopiowania.
```
#include <stdio.h>
struct S {};

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

__has_trivial_destructor(type)

Zwraca wartość true , jeśli typ ma trywialny, generowany przez kompilator destruktor.

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

Zwraca wartość true , jeśli typ platformy lub natywny ma destruktor zadeklarowany przez użytkownika.

// has_user_destructor.cpp

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

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

__has_virtual_destructor(type)

Zwraca wartość true , jeśli typ ma destruktor wirtualny.

__has_virtual_destructor Działa również na typach platformy, a każdy destruktor zdefiniowany przez użytkownika w typie platformy jest destruktorem wirtualnym.
```
// 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)

Zwraca wartość true , jeśli typ jest typem abstrakcyjnym. Aby uzyskać więcej informacji na temat natywnych typów abstrakcyjnych, zobacz Klasy abstrakcyjne.

__is_abstract działa również w przypadku typów platform. Interfejs z co najmniej jednym elementem członkowskim jest typem abstrakcyjnym, podobnie jak typ odwołania z co najmniej jednym elementem abstrakcyjnym. Aby uzyskać więcej informacji na temat abstrakcyjnych typów platform, zobacz abstrakcja.
```
// 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 )

Zwraca wartość true , jeśli pierwszy typ jest klasą bazową drugiego typu lub jeśli oba typy są takie same.

__is_base_of działa również na typach platform. Na przykład zostanie zwrócony true , jeśli pierwszy typ to klasa interfejsu, a drugi typ implementuje interfejs.
```
// 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)

Zwraca wartość true , jeśli typ jest klasą natywną lub strukturą.

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

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

__is_convertible_to( from , to )

Zwraca wartość true , jeśli pierwszy typ można przekonwertować na drugi typ.

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

Zwraca wartość true , jeśli type jest pełnomocnikiem. Aby uzyskać więcej informacji, zobacz delegate (C++/CLI i C++/CX).
```
delegate void MyDel();
int main() {
System::Console::WriteLine(__is_delegate(MyDel));
}
```

__is_empty(type)

Zwraca wartość true , jeśli typ nie ma żadnych elementów członkowskich danych wystąpienia.

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

Zwraca wartość true , jeśli typ jest wyliczeniem natywnym.

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

Zwraca wartość true w przypadku przekazania interfejsu platformy. Aby uzyskać więcej informacji, zobacz klasa interfejsu.
```
// is_interface_class.cpp

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

Zwraca wartość true , jeśli typ jest klasą lub unią bez konstruktora, prywatnego lub chronionego niestacjonanych składowych, bez klas bazowych i bez funkcji wirtualnych. Aby uzyskać więcej informacji na temat identyfikatorów POD, zobacz standard C++, sekcje 8.5.1/1, 9/4 i 3.9/10.

__is_pod Wartość będzie zwracać wartość false dla typów podstawowych.
```
#include <stdio.h>
struct S {};

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

__is_polymorphic(type)

Zwraca wartość true , jeśli typ natywny ma funkcje wirtualne.

#include <stdio.h>
struct S {
virtual void Test(){}
};

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

__is_ref_array(type)

Zwraca wartość true w przypadku przekazania tablicy platformy. Aby uzyskać więcej informacji, zobacz Tablice.
```
using namespace System;
int main() {
array<int>^ x = gcnew array<int>(10);
Console::WriteLine(__is_ref_array(array<int>));
}
```
__is_ref_class(type)

Zwraca wartość true w przypadku przekazania klasy referencyjnej. Aby uzyskać więcej informacji na temat typów referencyjnych zdefiniowanych przez użytkownika, zobacz Klasy i struktury.
```
using namespace System;
ref class R {};
int main() {
Console::WriteLine(__is_ref_class(Buffer));
Console::WriteLine(__is_ref_class(R));
}
```
__is_sealed(type)

Zwraca wartość true w przypadku przekazania platformy lub typu natywnego oznaczonego jako zapieczętowane. Aby uzyskać więcej informacji, zobacz zapieczętowany.
```
ref class R sealed{};
int main() {
System::Console::WriteLine(__is_sealed(R));
}
```
__is_simple_value_class(type)

Zwraca true wartość, jeśli przekazano typ wartości, który nie zawiera żadnych odwołań do sterta zbieranego przez śmieci. Aby uzyskać więcej informacji na temat typów wartości zdefiniowanych przez użytkownika, zobacz Klasy i struktury.
```
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)

Zwraca wartość true , jeśli typ jest unią.

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

Zwraca wartość true w przypadku przekazania typu wartości. Aby uzyskać więcej informacji na temat typów wartości zdefiniowanych przez użytkownika, zobacz Klasy i struktury.
```
value struct V {};

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

Środowisko wykonawcze systemu Windows

Uwagi

Cecha typu) nie jest obsługiwana__has_finalizer(, ponieważ ta platforma nie obsługuje finalizatorów.

Wymagania

Opcja kompilatora: /ZW

środowiska uruchomieniowe w trakcie wykonania

Uwagi

(Nie ma żadnych uwag specyficznych dla platformy dla tej funkcji).

Wymagania

Opcja kompilatora: /clr

Przykłady

Przykład

W poniższym przykładzie kodu pokazano, jak za pomocą szablonu klasy uwidaczniać cechę typu kompilatora /clr dla kompilacji. Aby uzyskać więcej informacji, zobacz środowisko wykonawcze systemu Windows i szablony zarządzane.

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

Zobacz też

Rozszerzenia składników dla platformy .NET i platformy uniwersalnej systemu Windows

Obsługa cech typu w kompilatorze (C++/CLI i C++/CX)

Wszystkie środowiska wykonawcze

Uwagi

Środowisko wykonawcze systemu Windows

Uwagi

Wymagania

środowiska uruchomieniowe w trakcie wykonania

Uwagi

Wymagania

Przykłady

Zobacz też

Opinia

Opinia

Dodatkowe zasoby