共用方式為

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

  • 發行項

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

所有執行階段

備註

型別特性對撰寫物件程式庫的程式設計人員特別有用。

下表列出編譯器所支援的型別特性。 如果條件指定由型別特性不符合，所有型別特性傳回 false 。

(在資料表的關聯中，程式碼範例只會在 C++/CLI寫入。 但是，這個對應型別特性在 Visual C++ 元件擴充功能 支援，除非陳述。否則也支援。 這個詞彙「平台類型」是指 Windows 執行階段 型別或 Common Language Runtime 型別)。

型別特性

說明

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

如果 type 為委派，則傳回 true。 如需詳細資訊，請參閱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。 如需 PODs 的詳細資訊，請參閱 C++ 標準中的 8.5.1/1、9/4 和 3.9/10 一節。

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

如果透過平台或原生型別標記為 Sealed ，傳回 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(type) 型別中不支援。

需求

編譯器選項：/ZW

Common Language Runtime

備註

(沒有這項功能的平台特定備註。)

需求

編譯器選項：/clr

範例

範例

下列程式碼範例示範如何使用類別樣板公開 /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

請參閱

概念

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