Aracılığıyla paylaş

Tür Özellikleri için Derleyici Desteği (C++ Bileşen Uzantıları)

  • Makale

Derleyici destekler türü nitelikler, doldurmak istediğiniz türde çeşitli özellikleri derleme zamanında.

Tüm çalışma zamanlarının

Notlar

Tür nitelikler kitaplıkları yazma programcılar için özellikle yararlıdır.

Derleyici tarafından desteklenen türü nitelikleri aşağıdaki tabloda listelenmektedir.Tüm nitelikler return yazın false türü ayırdedici Nitelik adı tarafından belirtilen koşul karşılanmazsa.

(Tablo Açıklama sütununda yalnızca kod örnekleri yazılı C++/CLI.Ancak karşılık gelen türü ayırdedici nitelik de desteklenir Visual C++ bileşen uzantıları aksi belirtilmedikçe.Ya da "platform türü" terimi başvuran Windows Çalışma Zamanı türleri veya ortak dil çalışma zamanı türleri.)

Tür ayırdedici nitelik

Description

__has_assign(type)

Platform veya yerel türü bir kopyasını atama işleci varsa true deðerini verir.

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

__has_copy(type)

Platform veya yerel türü bir kopya kurucu varsa true deðerini verir.

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

__has_finalizer(type)

(Desteklenen değil Visual C++ bileşen uzantıları.) clr türü bir sınıfları sonlandırıcıyı varsa true deðerini verir.Daha fazla bilgi için bkz. Yıkıcı ve Visual C++ Finalizers.

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

Bir kopyayı atama işleci boş durum belirtimi varsa true deðerini verir.

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

Varsayılan kurucu boş durum belirtimi varsa true deðerini verir.

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

Boş bir özel durum belirtimi kopya kurucu varsa true deðerini verir.

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

Önemsiz, derleyici tarafından oluşturulmuş atama işleci türündeyse true deðerini verir.

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

Önemsiz, derleyici tarafından oluşturulan kurucu türündeyse true deðerini verir.

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

Önemsiz, derleyici tarafından oluşturulan kopyası yapıcı türündeyse true deðerini verir.

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

Önemsiz, derleyici tarafından oluşturulmuş bir yıkıcı türündeyse true deðerini verir.

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

Kullanıcı bildirilen yıkıcı platform veya yerel türü varsa true deðerini verir.

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

Sanal yıkıcı türündeyse true deðerini verir.

__has_virtual_destructorAyrıca platform türleri ve platform türü kullanıcı tanımlı yıkıcıya works sanal yıkıcı olur.

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

Soyut bir tür türündeyse true deðerini verir.Yerel soyut türleri hakkında daha fazla bilgi için bkz: soyut (C++ Bileşen Uzantıları).

__is_abstractAyrıca platform türleri için geçerlidir.Soyut en az bir üye ile bir başvuru türü olarak en az bir üye ile soyut bir tür arabirimdir.Soyut platform türleri hakkında daha fazla bilgi için bkz.Soyut sınıflar (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)

Her iki tür aynıysa ilk tür ikinci türden bir temel sınıf ise true deðerini verir.

__is_base_ofplatform türleri üzerinde de çalışır.Örneğin, onu ilk türü ise doğru döndürür bir arabirim sınıfı (C++ Bileşen Uzantıları) ve ikinci tür arabirimini uygular.

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

Yerel sınıf ya da yapı türündeyse true deðerini verir.

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

İlk tür, ikinci tür dönüştürülmesi, true deðerini verir.

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

Döndürür true if type bir temsilcidir.Daha fazla bilgi için bkz. temsilci (C++ Bileşen Uzantıları).

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

__is_empty(type)

Hiçbir örnek veri üyeleri türündeyse true deðerini verir.

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

Yerel bir enum türü ise true deðerini verir.

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

Platform arabirimi aktarılırsa doğru değerini döndürür.Daha fazla bilgi için bkz. arabirim sınıfı (C++ Bileşen Uzantıları).

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

__is_pod(type)

Bir sınıf veya hiç yapıcı veya özel veya korumalı olmayan statik üyeleri, temel bir sınıf ve sanal bir işlev birleşim türü ise true deðerini verir.PODs üzerinde C++ standart, Bölüm 8.5.1/1, 9/4 ve 3.9/10 daha fazla bilgi için bkz.

__is_podtemel türlerinde false döndürür.

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

__is_polymorphic(type)

Yerel tür sanal işlevler varsa true deðerini verir.

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

Platform dizi aktarılırsa doğru değerini döndürür.Daha fazla bilgi için bkz. Dizeler (C++ Bileşen Uzantıları).

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

Başvuru sınıf aktarılırsa doğru değerini döndürür.Kullanıcı tanımlı bir baþvuru türleri hakkında daha fazla bilgi için bkz: Sınıflar ve Yapılar (C++ Bileşen Uzantıları).

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

Platform veya yerel türü aktarılırsa döndürür true sealed olarak işaretlenmiş.Daha fazla bilgi için bkz. mühürlü (C++ Bileşen Uzantıları).

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

__is_simple_value_class(type)

Atık olarak toplanmış öbek hiçbir başvuru içeren bir değer türü aktarılırsa doğru değerini döndürür.Kullanıcı tanımlı değer türleri hakkında daha fazla bilgi için bkz: Sınıflar ve Yapılar (C++ Bileşen Uzantıları).

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

Bir UNION türündeyse true deðerini verir.

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

Bir değer türü aktarılırsa doğru değerini döndürür.Kullanıcı tanımlı değer türleri hakkında daha fazla bilgi için bkz: Sınıflar ve Yapılar (C++ Bileşen Uzantıları).

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

Windows Çalışma Zamanı

Notlar

__has_finalizer(Türü) finalizers bu platform desteklemediğinden türü ayırdedici nitelik desteklenmez.

ms177194.collapse_all(tr-tr,VS.110).gifGereksinimler

Derleyici seçeneği:/ZW

Ortak Dil Çalışma Zamanı

Notlar

(Bu özelliğin hiçbir platforma özgü açıklamalar vardır.)

ms177194.collapse_all(tr-tr,VS.110).gifGereksinimler

Derleyici seçeneği:/clr

ms177194.collapse_all(tr-tr,VS.110).gifÖrnekler

Örnek

Aşağıdaki kod örneği sınıf şablonu için derleyici tür ayırdedici nitelik göstermek için nasıl kullanılacağını gösteren bir /clr derleme.Daha fazla bilgi için bkz. Windows Çalışma Zamanı ve Yönetilen Şablonlar (C++ Bileşen Uzantıları).

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

Çıktı

Ayrıca bkz.

Kavramlar

Çalışma platformları için bileşen uzantıları