Dukungan Pengkompilasi untuk Jenis Sifat (C++/CLI dan C++/CX)

Artikel
10/12/2023

Pengkompilasi Microsoft C++ mendukung sifat jenis untuk ekstensi C++/CLI dan C++/CX, yang menunjukkan berbagai karakteristik jenis pada waktu kompilasi.

Semua Runtime

Keterangan

Sifat jenis sangat berguna bagi pemrogram yang menulis pustaka.

Daftar berikut berisi sifat jenis yang didukung oleh pengkompilasi. Semua sifat jenis mengembalikan false jika kondisi yang ditentukan oleh nama sifat jenis tidak terpenuhi.

(Dalam daftar berikut, contoh kode hanya ditulis dalam C++/CLI. Tetapi sifat jenis yang sesuai juga didukung dalam C++/CX kecuali dinyatakan sebaliknya. Istilah, "jenis platform" mengacu pada jenis Windows Runtime atau jenis runtime bahasa umum.)

__has_assign(jenis)

Mengembalikan true jika platform atau jenis asli memiliki operator penugasan salinan.

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

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

__has_copy(jenis)

Mengembalikan true jika platform atau jenis asli memiliki konstruktor salinan.
```
ref struct R {
R(R% r) {}
};

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

(Tidak didukung di C++/CX.) Mengembalikan true jika jenis CLR memiliki finalizer. Lihat Destruktor dan finalizer dalam Cara: Menentukan dan menggunakan kelas dan struktur (C++/CLI) untuk informasi selengkapnya.
```
using namespace System;
ref struct R {
~R() {}
protected:
!R() {}
};

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

__has_nothrow_assign(jenis)

Mengembalikan true jika operator penugasan salinan memiliki spesifikasi pengecualian kosong.

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

Mengembalikan true jika konstruktor default memiliki spesifikasi pengecualian kosong.

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

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

__has_nothrow_copy(jenis)

Mengembalikan true jika konstruktor salinan memiliki spesifikasi pengecualian kosong.

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

Mengembalikan true jika jenis memiliki operator penugasan yang dihasilkan kompilator yang sepele.
```
#include <stdio.h>
struct S {};

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

__has_trivial_constructor(jenis)

Mengembalikan true jika jenis memiliki konstruktor yang dihasilkan kompilator yang sepele.

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

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

__has_trivial_copy(jenis)

Mengembalikan true jika jenis memiliki konstruktor salinan yang dihasilkan kompilator yang sepele.
```
#include <stdio.h>
struct S {};

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

__has_trivial_destructor(jenis)

Mengembalikan true jika jenis memiliki destruktor yang dihasilkan kompilator yang sepele.

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

Mengembalikan true jika platform atau jenis asli memiliki destruktor yang dideklarasikan pengguna.

// has_user_destructor.cpp

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

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

__has_virtual_destructor(jenis)

Mengembalikan true jika jenis memiliki destruktor virtual.

__has_virtual_destructor juga berfungsi pada jenis platform, dan setiap destruktor yang ditentukan pengguna dalam jenis platform adalah destruktor virtual.
```
// 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(jenis)

Mengembalikan true jika jenisnya adalah jenis abstrak. Untuk informasi selengkapnya tentang jenis abstrak asli, lihat Kelas Abstrak.

__is_abstract juga berfungsi untuk jenis platform. Antarmuka dengan setidaknya satu anggota adalah jenis abstrak, seperti jenis referensi dengan setidaknya satu anggota abstrak. Untuk informasi selengkapnya tentang jenis platform abstrak, lihat abstrak.
```
// 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 )

Mengembalikan true jika jenis pertama adalah kelas dasar dari jenis kedua, atau jika kedua jenis sama.

__is_base_of juga berfungsi pada jenis platform. Misalnya, ini akan mengembalikan true jika jenis pertama adalah kelas antarmuka dan jenis kedua mengimplementasikan antarmuka.
```
// 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(jenis)

Mengembalikan true jika jenisnya adalah kelas atau struktur asli.

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

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

__is_convertible_to( from , to )

Mengembalikan true jika jenis pertama dapat dikonversi ke jenis kedua.

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

Mengembalikan true jika type adalah delegasi. Untuk informasi selengkapnya, lihat delegasi (C++/CLI dan C++/CX).
```
delegate void MyDel();
int main() {
System::Console::WriteLine(__is_delegate(MyDel));
}
```

__is_empty(jenis)

Mengembalikan true jika jenis tidak memiliki anggota data instans.

#include <stdio.h>
struct S {
int Test() {}
static int i;
};
int main() {
__is_empty(S) == true ?
printf("true\n") : printf("false\n");
}

__is_enum(jenis)

Mengembalikan true jika jenisnya adalah enum asli.

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

Mengembalikan true jika melewati antarmuka platform. Untuk informasi selengkapnya, lihat kelas antarmuka.

// is_interface_class.cpp

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

__is_pod(jenis)

Mengembalikan true jika jenisnya adalah kelas atau gabungan tanpa konstruktor atau anggota non-statis privat atau terlindungi, tidak ada kelas dasar, dan tidak ada fungsi virtual. Lihat standar C++, bagian 8.5.1/1, 9/4, dan 3.9/10 untuk informasi selengkapnya tentang DAK.

__is_pod akan mengembalikan false pada jenis dasar.
```
#include <stdio.h>
struct S {};

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

__is_polymorphic(jenis)

Mengembalikan true jika jenis asli memiliki fungsi virtual.

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

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

__is_ref_array(jenis)

Mengembalikan true jika lulus array platform. Untuk informasi selengkapnya, lihat Array.

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

__is_ref_class(jenis)

Mengembalikan true jika lulus kelas referensi. Untuk informasi selengkapnya tentang jenis referensi yang ditentukan pengguna, lihat Kelas dan Struktur.
```
using namespace System;
ref class R {};
int main() {
Console::WriteLine(__is_ref_class(Buffer));
Console::WriteLine(__is_ref_class(R));
}
```
__is_sealed(jenis)

Mengembalikan true jika melewati platform atau jenis asli yang ditandai disegel. Untuk informasi selengkapnya, lihat disegel.
```
ref class R sealed{};
int main() {
System::Console::WriteLine(__is_sealed(R));
}
```
__is_simple_value_class(jenis)

Mengembalikan true jika melewati jenis nilai yang tidak berisi referensi ke tumpukan yang dikumpulkan sampah. Untuk informasi selengkapnya tentang jenis nilai yang ditentukan pengguna, lihat Kelas dan Struktur.
```
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(jenis)

Mengembalikan true jika jenis adalah union.

#include <stdio.h>
union A {
int i;
float f;
};

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

__is_value_class(jenis)

Mengembalikan true jika melewati jenis nilai. Untuk informasi selengkapnya tentang jenis nilai yang ditentukan pengguna, lihat Kelas dan Struktur.
```
value struct V {};

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

Windows Runtime

Keterangan

) Sifat __has_finalizer(jenis tidak didukung karena platform ini tidak mendukung finalizer.

Persyaratan

Opsi pengkompilasi: /ZW

Runtime Bahasa Umum

Keterangan

(Tidak ada sambutan khusus platform untuk fitur ini.)

Persyaratan

Opsi pengkompilasi: /clr

Contoh

Contoh

Contoh kode berikut menunjukkan cara menggunakan templat kelas untuk mengekspos sifat jenis kompilator untuk /clr kompilasi. Untuk informasi selengkapnya, lihat Windows Runtime dan Templat Terkelola.

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

Bagikan melalui

Dukungan Pengkompilasi untuk Jenis Sifat (C++/CLI dan C++/CX)

Semua Runtime

Keterangan

Windows Runtime

Keterangan

Persyaratan

Runtime Bahasa Umum

Keterangan

Persyaratan

Contoh

Baca juga

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan: