次の方法で共有

型の特徴のコンパイラ サポート (C++ コンポーネント拡張)

  • [アーティクル]

コンパイラ サポートはコンパイル時に型のさまざまな特性を示す 特徴を入力します。

すべてのランタイム

解説

型の特徴は、ライブラリを記述するプログラミングに特に便利です。

次の表は、コンパイラによってサポートされる型の特徴を示します。すべての型の特徴は、型の特徴の名前によって指定された条件が満たされない場合 false を返します。

（テーブルの説明の列で、コード例は C++/CLIでのみ書き込まれます。ただし、対応する型の特徴は、 Visual C++ コンポーネント拡張 の他に表示されていないサポートされます。用語は、プラットフォーム 「型」の Windows ランタイム の型に共通言語ランタイム型を示します）。

型の特徴

Description

__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 は、プラットフォームの型で機能します。少なくとも 1 人のメンバーを持つインターフェイスは、少なくとも 1 の抽象メンバーを持つ参照型と同様に、抽象型です。抽象プラットフォームの種類の詳細については、 抽象クラス (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)

型が同じ場合、一つ目の型が 2 番目の型の基本クラスでの、 true を返します。

__is_base_of は、プラットフォームの型で実行されます。たとえば、最初の型が インターフェイス クラス (C++ コンポーネント拡張) であり、 2 番目の型がインターフェイスを実装する場合、 true を返します。

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

最初の型が 2 番目の型に変換できる場合、 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 を返します。詳細については、「インターフェイス クラス (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 を返します。POD の詳細については、 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)

渡られたらプラットフォーム 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(ja-jp,VS.110).gif要件

コンパイラ オプション: /ZW

共通言語ランタイム

解説

この機能のプラットフォーム固有の解説はありません）。

ms177194.collapse_all(ja-jp,VS.110).gif要件

コンパイラ オプション: /clr

ms177194.collapse_all(ja-jp,VS.110).gif例

例

次のコード例は /clr コンパイルのコンパイラ型の特徴を公開するには、クラス テンプレートを使用する方法を示します。詳細については、「Windows ランタイムおよびマネージ テンプレート (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");
}

出力

参照

概念

ランタイム プラットフォームのコンポーネントの拡張機能