Podpora kompilátoru pro typové vlastnosti (C++/CLI a C++/CX)

Článek
10/12/2023

Kompilátor Microsoft C++ podporuje vlastnosti typů pro rozšíření C++/CLI a C++/CX, které označují různé charakteristiky typu v době kompilace.

Všechny moduly runtime

Poznámky

Vlastnosti typu jsou zvláště užitečné pro programátory, kteří píší knihovny.

Následující seznam obsahuje vlastnosti typu, které kompilátor podporuje. Všechny vlastnosti typu se vrátí false , pokud není splněna podmínka zadaná názvem vlastnosti typu.

(V následujícím seznamu jsou příklady kódu napsané pouze v jazyce C++/CLI. Odpovídající vlastnost typu je však podporována také v jazyce C++/CX, pokud není uvedeno jinak. Termín "typ platformy" odkazuje buď na typy prostředí Windows Runtime, nebo typy modulu CLR (Common Language Runtime).)

__has_assign(type)

Vrátí true , pokud má platforma nebo nativní typ operátor přiřazení kopírování.
```
ref struct R {
void operator=(R% r) {}
};

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

Vrátí true , pokud platforma nebo nativní typ má konstruktor kopírování.
```
ref struct R {
R(R% r) {}
};

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

(Nepodporuje se v C++/CX.) Vrátí true , pokud typ CLR má finalizátor. Další informace najdete v tématu Destruktory a finalizátory v tématu Postupy: Definování a využívání tříd a struktur (C++/CLI).
```
using namespace System;
ref struct R {
~R() {}
protected:
!R() {}
};

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

__has_nothrow_assign(type)

Vrátí true , pokud má operátor přiřazení kopírování prázdnou specifikaci výjimky.

#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í true , pokud výchozí konstruktor má prázdnou specifikaci výjimky.

#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í true , pokud konstruktor kopírování má prázdnou specifikaci výjimky.

#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 typ má triviální operátor přiřazení vygenerovaný kompilátorem.

#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 typ má triviální konstruktor vygenerovaný kompilátorem.

#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 typ má triviální konstruktor kopírování vygenerovaný kompilátorem.

#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 triviální destruktor vygenerovaný 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í true , pokud má platforma nebo nativní typ destruktor deklarovaný uživatelem.

// has_user_destructor.cpp

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

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

__has_virtual_destructor(type)

Vrátí true , pokud typ má virtuální destruktor.

__has_virtual_destructor funguje také na typech platformy a jakýkoli uživatelem definovaný destruktor v typu platformy je virtuální 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)

Vrátí true , pokud je typ abstraktním typem. Další informace o nativních abstraktních typech naleznete v tématu Abstraktní třídy.

__is_abstract také funguje pro typy platforem. Rozhraní s alespoň jedním členem je abstraktní typ, stejně jako odkazový typ s alespoň jedním abstraktním členem. Další informace o abstraktních typech platforem najdete v abstrakci.
```
// 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í true , pokud je první typ základní třídou druhého typu, nebo pokud jsou oba typy stejné.

__is_base_of funguje také na typech platforem. Vrátí se true například, pokud první typ je třída rozhraní 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)

Vrátí true , pokud je typ nativní třídou nebo strukturou.

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

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

__is_convertible_to( from , to )

Vrátí true , pokud lze první typ převést na druhý 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)

Vrátí true , pokud type je delegát. Další informace najdete v tématu delegát (C++/CLI a C++/CX).
```
delegate void MyDel();
int main() {
System::Console::WriteLine(__is_delegate(MyDel));
}
```

__is_empty(type)

Vrátí true , pokud typ nemá žádné datové členy instance.

#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í true , pokud je typ nativní výčtem.

// 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í true , pokud bylo předáno rozhraní platformy. Další informace naleznete v tématu třída rozhraní.
```
// is_interface_class.cpp

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

Vrátí true , pokud typ je třída nebo sjednocení bez konstruktoru nebo privátních nebo chráněných nestatických členů, žádné základní třídy a žádné virtuální funkce. Další informace o podech najdete ve standardních částech C++, 8.5.1/1, 9/4 a 3.9/10.

__is_pod vrátí hodnotu false u základních typů.
```
#include <stdio.h>
struct S {};

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

__is_polymorphic(type)

Vrátí true , pokud má nativní typ virtuální funkce.

#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í true , pokud bylo předáno pole platformy. Další informace naleznete v tématu Pole.

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í true , pokud byla předána referenční třída. Další informace o uživatelem definovaných referenčních typech naleznete v tématu Třídy a struktury.
```
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í true , pokud byla předána platforma nebo nativní typ označený jako zapečetěný. Další informace naleznete v zapečetěných.
```
ref class R sealed{};
int main() {
System::Console::WriteLine(__is_sealed(R));
}
```
__is_simple_value_class(type)

Vrátí true , pokud byl předán typ hodnoty, který neobsahuje žádné odkazy na haldu shromážděnou z paměti. Další informace o uživatelem definovaných typech hodnot naleznete v tématu Třídy a 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)

Vrátí true , pokud je typ sjednocením.

#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í true , pokud byl předán typ hodnoty. Další informace o uživatelem definovaných typech hodnot naleznete v tématu Třídy a struktury.
```
value struct V {};

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

prostředí Windows Runtime

Poznámky

Vlastnost __has_finalizer(typu) není podporována, protože tato platforma nepodporuje finalizátory.

Požadavky

Možnost kompilátoru: /ZW

CLR (Common Language Runtime)

Poznámky

(Pro tuto funkci nejsou žádné poznámky specifické pro platformu.)

Požadavky

Možnost kompilátoru: /clr

Příklady

Příklad

Následující příklad kódu ukazuje, jak použít šablonu třídy k zveřejnění vlastnosti typu kompilátoru /clr pro kompilaci. Další informace najdete v tématu prostředí Windows Runtime a spravované šablony.

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

Viz také

Přípony komponent pro .NET a UPW

Share via

Podpora kompilátoru pro typové vlastnosti (C++/CLI a C++/CX)

Všechny moduly runtime

Poznámky

prostředí Windows Runtime

Poznámky

Požadavky

CLR (Common Language Runtime)

Poznámky

Požadavky

Příklady

Viz také

Váš názor

Váš názor

Další materiály