共用方式為

型別特性的編譯器支援 (C++ 元件擴充功能)

  • 發行項

編譯器支援型別特性，表示在編譯時期型別的各種特性。

所有的執行階段

備註

型別特性是程式設計人員撰寫程式庫的交換作業。

下表列出所支援的編譯器型別特性。 所有輸入特性復false如果不符合型別特性的名稱所指定的條件。

(表格的 [描述] 欄中的程式碼範例僅在撰寫C++/CLI。 但對應的型別特性也支援在Visual C++ 元件擴充功能除非否則另有說明。 來看，「 平台型別 」 參考以下任一Windows 執行階段型別或通用語言執行階段型別。)

型別特性

描述

__has_assign(type)

如果平台或原生型別有複製指派運算子，則傳回 true。

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

__has_copy(type)

如果平台或原生型別有複製建構函式，則傳回 true。

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

__has_finalizer(type)

(不支援此Visual C++ 元件擴充功能。)如果 CLR 型別完成項，則傳回 true。 如需詳細資訊，請參閱 解構函式和在 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)

如果複製指派運算子具有空的例外狀況規格，則傳回 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)

如果預設的建構函式具有一種規格，空白的例外狀況，則傳回 true。

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

如果複製建構函式具有一種規格，空白的例外狀況，則傳回 true。

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

如果型別是小事一樁、 編譯器所產生的工作分派運算子，則傳回 true。

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

如果型別小事一樁、 編譯器所產生的建構函式，則傳回 true。

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

如果型別小事一樁、 編譯器所產生的複製建構函式，則傳回 true。

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

如果型別小事一樁、 編譯器所產生的解構函式，則傳回 true。

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

如果平台或原生型別有使用者宣告解構函式，則傳回 true。

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

如果該型別具有虛擬解構函式，則傳回 true。

__has_virtual_destructor同樣的平台型別和任何使用者定義的解構函式的平台型別中的工作方式是虛擬的解構函式。

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

如果型別是抽象型別，則傳回 true。 如需有關原生的抽象型別的詳細資訊，請參閱abstract (C++ 元件擴充功能)。

__is_abstract也適用於平台類型。 含有至少一個成員的介面與至少一個抽象的成員是參考型別是抽象型別。 如需有關抽象的平台類型的詳細資訊，請參閱抽象類別 (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)

如果第一種類型的是基底類別的第二個類型而定，兩種類型皆相同，則傳回 true。

__is_base_of也可以在平台的型別。 比方說，它會傳回值為 true 的第一個型別是interface class (C++ 元件擴充功能)和第二個型別所實作的介面。

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

如果原生類別或結構的型別，則傳回 true。

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

如果第一個型別可以轉換成第二個型別，則傳回 true。

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

傳回 true type的委派。 如需詳細資訊，請參閱 delegate (C++ 元件擴充功能)。

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

__is_empty(type)

如果型別沒有執行個體資料成員，則傳回 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)

如果原生列舉的型別，則傳回 true。

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

如果傳遞的平台介面，則傳回 true。 如需詳細資訊，請參閱 interface class (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)

如果類別或等位沒有建構函式或私用或保護的非靜態成員、 與沒有基底類別中，沒有虛擬函式的型別，則傳回 true。 C + + 標準，各節 8.5.1/1，9/4 和 3.9/10，如需詳細資訊，請參閱 PODs。

__is_pod會傳回 false 主要資料型別上。

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

__is_polymorphic(type)

如果原生型別有虛擬函式，則傳回 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)

如果傳遞的平台的陣列，則傳回 true。 如需詳細資訊，請參閱 陣列 (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)

如果傳遞參考類別，則傳回 true。 使用者定義的參考型別上的相關資訊，請參閱類別和結構 (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)

如果傳遞的平台 」 或 「 原生型別就會傳回 true 標示為密封。 如需詳細資訊，請參閱 sealed (C++ 元件擴充功能)。

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

__is_simple_value_class(type)

如果傳遞未包含參考記憶體回收的堆積實值型別，則傳回 true。 如需有關使用者定義的實值型別的詳細資訊，請參閱類別和結構 (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)

如果型別等位，則傳回 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)

如果傳遞實值型別，則傳回 true。 如需有關使用者定義的實值型別的詳細資訊，請參閱類別和結構 (C++ 元件擴充功能)。

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

Windows 執行階段

備註

__has_finalizer(型別)因為這個平台不支援的完成項不支援的型別特性。

ms177194.collapse_all(zh-tw,VS.110).gif需求

編譯器選項：/ZW

Common Language Runtime

備註

(還有沒有這項功能的平台專屬註解)。

ms177194.collapse_all(zh-tw,VS.110).gif需求

編譯器選項：/clr

ms177194.collapse_all(zh-tw,VS.110).gif範例

範例

下列程式碼範例示範如何使用類別樣板來公開 (expose) 的編譯器型別特性**/clr**編譯。 如需詳細資訊，請參閱 Windows 執行階段和 Managed 樣板 (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");
}

Output

請參閱

概念

執行階段平台的元件擴充功能