Sdílet prostřednictvím

Podpora kompilátoru pro typové vlastnosti (C++ Component Extensions)

  • Článek

Kompilátor podporuje typu vlastnosti, které označují různé charakteristiky typu v čase kompilace.

Všechny knihovny runtime

Poznámky

Typ vlastnosti jsou užitečné zejména pro programátory, kteří psát knihoven.

Následující tabulka uvádí znaky typu podporované kompilátoru.Všechny textové znaky návrat false Pokud není splněna podmínka určená názvem typu znak.

(Ve sloupci Popis v tabulce jsou příklady kódu zapsány pouze v C++/CLI.Ale odpovídající typ znak je podporováno také v rozšíření komponent v jazyce Visual C++ Pokud není uvedeno jinak.Pojem, "typ platformy" označuje buď Windows Runtime typy nebo typy společného jazykového modulu runtime.)

Znak typu

Description

__has_assign(type)

Vrátí hodnotu PRAVDA platformu nebo nativní typ má operátor přiřazení kopie.

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

__has_copy(type)

Vrátí hodnotu PRAVDA platformu nebo nativní typ má kopírovat konstruktor.

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

__has_finalizer(type)

(Není podporováno v rozšíření komponent v jazyce Visual C++.) Vrátí hodnotu true, pokud má typ CLR finalizačních metod.Další informace naleznete v tématu Destruktory a finalizačních metod jazyka 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)

Pokud má operátor přiřazení kopie specifikaci výjimky prázdné vrátí hodnotu true.

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

Vrátí hodnotu PRAVDA specifikaci prázdné výjimka má výchozí konstruktor.

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

Vrátí hodnotu true Pokud specifikaci výjimky prázdný konstruktor kopie.

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

Vrátí true, pokud má typ trivial, generovaných kompilátorem operátoru.

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

Vrátí true, pokud má typ konstruktor trivial, generovaných kompilátorem.

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

Vrátí true, pokud má typ trivial, generovaných kompilátorem Kopírovat konstruktor.

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

Vrátí true, pokud má typ destruktoru trivial, generovaných kompilátorem.

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

Vrátí hodnotu PRAVDA platformu nebo nativní typ má destruktor prohlášena za uživatele.

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

Vrátí hodnotu PRAVDA, pokud má typ virtuálního destruktoru.

__has_virtual_destructortaké je prací na typů platformy a jakékoli destruktoru uživatelem definovaný typ platformy v virtuálního destruktoru.

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

Vrátí hodnotu PRAVDA, pokud typ je abstraktní typ.Další informace o typech nativní abstraktní, viz abstract (rozšíření komponent C++).

__is_abstractfunguje také pro typy platformy.Rozhraní s alespoň jeden člen je abstraktní typ jako je typ odkazu s alespoň jedním členem abstraktní.Další informace o typech abstraktní platforma vizAbstraktní třídy (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)

Vrátí hodnotu PRAVDA, pokud první typ je základní třída druhý typ, pokud jsou oba typy stejné.

__is_base_oftaké pracuje na typů platformy.Například vrátí hodnotu true, pokud je prvním typem interface class (rozšíření komponent C++) a druhý typ implementuje rozhraní.

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

Vrací true, pokud je typem nativní třídy nebo struct.

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

Vrátí hodnotu PRAVDA, pokud první typ lze převést na druhý typ.

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

Vrátí hodnotu true v případě type je delegát.Další informace naleznete v tématu delegate (rozšíření komponent C++).

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

__is_empty(type)

Pokud typ nemá žádné členy instance dat vrátí hodnotu true.

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

Vrátí hodnotu true pokud nativní výčtového typu.

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

Vrátí hodnotu PRAVDA, pokud předaný platformě rozhraní.Další informace naleznete v tématu interface class (rozšíření komponent 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)

Pokud je typem třídy nebo unie žádný konstruktor nebo soukromé nebo chráněné nestatický členů, žádný základní třídy a žádné virtuální funkce vrátí hodnotu true.C++ standardní, oddíly 8.5.1/1, 9/4 a 3.9/10 Další informace naleznete na lusky.

__is_podVrátí hodnotu false základních typů.

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

__is_polymorphic(type)

Nativní typ má virtuální funkce vrátí hodnotu true.

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

Vrátí hodnotu true Pokud předaný platformě array.Další informace naleznete v tématu Pole (rozšíření komponent 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)

Vrátí hodnotu true Pokud předán odkaz třídy.Další informace o referenční uživatelem definované typy, viz Třídy a struktury (rozšíření komponent 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)

Vrátí hodnotu PRAVDA, pokud předaný platformě nebo nativní typ označeny uzavřených.Další informace naleznete v tématu sealed (rozšíření komponent C++).

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

__is_simple_value_class(type)

Vrátí hodnotu PRAVDA, pokud je předán typ hodnoty, který obsahuje žádné odkazy na něho uvolněna haldy.Další informace o typech hodnota definovaná uživatelem, viz Třídy a struktury (rozšíření komponent 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)

Pokud je typ unie vrátí hodnotu true.

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

Vrátí hodnotu true Pokud Předaný typ hodnoty.Další informace o typech hodnota definovaná uživatelem, viz Třídy a struktury (rozšíření komponent C++).

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

Windows Runtime

Poznámky

__has_finalizer(Typu) znak typ není podporován, protože tuto platformu nepodporuje finalizačních metod.

ms177194.collapse_all(cs-cz,VS.110).gifPožadavky

Volba kompilátoru:/ZW

Common Language Runtime

Poznámky

(Nejsou žádné poznámky platformu pro tuto funkci.)

ms177194.collapse_all(cs-cz,VS.110).gifPožadavky

Volba kompilátoru:/clr

ms177194.collapse_all(cs-cz,VS.110).gifPříklady

Příklad

Následující příklad kódu ukazuje, jak použít šablonu třídy vystavit typ znak kompilátoru pro /clr kompilace.Další informace naleznete v tématu Windows Runtime a spravované šablony (rozšíření komponent 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");
}

Výsledek

Viz také

Koncepty

Součást rozšíření pro Runtime platformy