Udostępnij za pośrednictwem

Obsługa cech typu w kompilatorze (C++ Component Extensions)

  • Artykuł

Obsługuje kompilatora typu cech, które wskazują różne cechy typu w czasie kompilacji.

Wszystkich modułów wykonawczych.

Uwagi

Cechy typu są szczególnie użyteczne dla programistów piszących bibliotek.

Poniższa tabela zawiera listę cech typu, które są obsługiwane przez kompilator.Wpisz wszystkie cechy return false , jeśli nie jest spełniony warunek określony przez nazwę cechy typu.

(W kolumnie Opis w tabeli przykłady kodu są zapisywane tylko w C++/CLI.Jednak odpowiednie cechy typu jest również obsługiwany w Rozszerzenia składników dla programu Visual C++ , chyba że stwierdzono inaczej.Termin "typ" odnosi się do albo Środowisko wykonawcze systemu Windows typów lub wspólne language runtime.)

Cechy typu

Opis

__has_assign(type)

Zwraca wartość true, jeśli operator przypisania kopii platformy lub typu macierzystego.

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

__has_copy(type)

Zwraca wartość true, jeśli platformy lub typ macierzysty ma konstruktora kopii.

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

__has_finalizer(type)

(Nie obsługiwane w Rozszerzenia składników dla programu Visual C++.) Zwraca wartość true, jeśli typ CLR finalizatorów.Zobacz Destruktory i finalizatory w języku Visual C++ Aby uzyskać więcej informacji.

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

Zwraca wartość true, jeśli operator przypisania kopia ma specyfikacja pusty wyjątek.

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

Zwraca wartość true, jeśli Specyfikacja wyjątku pustego konstruktora domyślnego.

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

Zwraca wartość true, jeśli Konstruktor kopia ma specyfikacja pusty wyjątek.

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

Zwraca wartość true, jeśli typ jest operatorem przypisania trivial, generowanych przez kompilator.

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

Zwraca wartość true, jeśli typ jest trywialny, generowanych przez kompilator konstruktora.

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

Zwraca wartość true, jeśli typ jest trywialny, generowanych przez kompilator kopiujący.

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

Zwraca wartość true, jeśli typ jest trywialny, generowanych 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 platformy lub typ macierzysty ma destruktora zgłoszone przez użytkowników.

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

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

__has_virtual_destructorworks na typy platformy i wszelkie destruktora zdefiniowane przez użytkownika w polu Typ platformy jest również wirtualnego 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)

Zwraca wartość true, jeśli typ jest abstrakcyjny typ.Aby uzyskać więcej informacji na typy abstrakcyjne macierzystych, zobacz abstract (C++ Component Extensions).

__is_abstractdziała również dla platformy typy.Interfejs z co najmniej jeden członek jest typu abstract, podobnie jak typ odwołania z co najmniej jednego członka abstrakcyjny.Aby uzyskać więcej informacji na typy abstrakcyjne platformy zobaczKlasy abstrakcyjne (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)

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

__is_base_ofdziała również w typach platformy.Na przykład, zostanie zwrócona wartość true, jeśli pierwszy typ jest interface class (C++ Component Extensions) i 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 typem jest macierzystym klasy lub struktury.

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

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

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

Zwraca wartość PRAWDA, jeśli type jest pełnomocnika.Aby uzyskać więcej informacji, zobacz delegate (C++ Component Extensions).

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

__is_empty(type)

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

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

Zwraca wartość true, jeśli typem jest macierzystym enum.

// 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, jeśli przekazany interfejs platformy.Aby uzyskać więcej informacji, zobacz interface class (C++ Component Extensions).

// is_interface_class.cpp
// compile with: /clr
using namespace System;
interface class I {};
int main() {
   Console::WriteLine(__is_interface_class(I));
}

__is_pod(type)

Zwraca wartość true, jeśli typem jest klasa lub Unii nie konstruktora lub członków-statycznej prywatnym ani chronionym nie klas podstawowych i nie funkcje wirtualnych.Zobacz strączki C++ standardowych, sekcje 8.5.1/1, 9 i 4 oraz 3.9/10, aby uzyskać więcej informacji.

__is_podZwraca wartość false w typach podstawowych.

// is_pod.cpp
#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 macierzysty ma funkcje wirtualnych.

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

Zwraca wartość true, jeśli przekazany tablicy platformy.Aby uzyskać więcej informacji, zobacz Tablice (C++ Component Extensions).

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

Zwraca wartość true, jeśli przekazany klasy odniesienia.Aby uzyskać więcej informacji na temat typów zdefiniowanych przez użytkownika odwołania zobacz Klasy i struktury (C++ Component Extensions).

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

Zwraca wartość true, jeśli przekazany platformy lub typ macierzysty oznaczony zamkniętych.Aby uzyskać więcej informacji, zobacz sealed (rozszerzenia składnika C++).

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

__is_simple_value_class(type)

Zwraca wartość true, jeśli przekazany typ wartości zawiera nie odwołań do sterty zebrane garbage.Aby uzyskać więcej informacji na temat typów zdefiniowanych przez użytkownika wartości, zobacz Klasy i struktury (C++ Component Extensions).

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

Zwraca wartość true, jeśli typ jest Unii.

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

Zwraca wartość true, jeśli przekazany typ wartości.Aby uzyskać więcej informacji na temat typów zdefiniowanych przez użytkownika wartości, zobacz Klasy i struktury (C++ Component Extensions).

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

Środowisko wykonawcze systemu Windows

Uwagi

__has_finalizer(Typu) cechy typu nie jest obsługiwany, ponieważ ta platforma nie obsługuje finalizatorów.

Wymagania

Opcja kompilatora:/ZW

Środowisko uruchomieniowe języka wspólnego

Uwagi

(Nie są żadne uwagi platformy dla tej funkcji).

Wymagania

Opcja kompilatora:/clr

Przykłady

Przykład

Poniższy przykład kodu pokazuje, jak używać szablonu klasy narazić cechy typu kompilatora dla /clr kompilacji.Aby uzyskać więcej informacji, zobacz Środowisko wykonawcze systemu Windows i zarządzane szablony (C++ Component Extensions).

// 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");
}

Dane wyjściowe

Zobacz też

Koncepcje

Component Extensions dla platform środowiska uruchomieniowego