型の特徴のコンパイラ サポート (C++/CLI および C++/CX)Compiler Support for Type Traits (C++/CLI and C++/CX)

Microsoft C++ コンパイラでは、C++/CLI と C++/CX の拡張機能に対して、コンパイル時に型のさまざまな特性を示す "型の特徴" をサポートしています。The Microsoft C++ compiler supports type traits for C++/CLI and C++/CX extensions, which indicate various characteristics of a type at compile time.

すべてのランタイムAll Runtimes

解説Remarks

型の特徴は、ライブラリを記述するプログラマにとって特に便利です。Type traits are especially useful to programmers who write libraries.

次の一覧に、コンパイラによってサポートされる型の特徴が含まれています。The following list contains the type traits that are supported by the compiler. false の特徴の名前で指定された条件が満たされない場合は、すべての型の特徴が返されます。All type traits return false if the condition specified by the name of the type trait is not met.

(次の一覧のコード例は、C++/CLI のみで記述されています。(In the following list, code examples are written only in C++/CLI. ただし、特に明記されていない限り、対応する型の特徴は C++/CX でもサポートされています。But the corresponding type trait is also supported in C++/CX unless stated otherwise. "プラットフォーム型" という用語は、Windows Runtime の型または共通言語ランタイムの型を示します。)The term, "platform type" refers to either Windows Runtime types or common language runtime types.)

  • __has_assign( type )__has_assign( type )

    true プラットフォームまたはネイティブ型にコピー代入演算子がある場合は、を返します。Returns true if the platform or native type has a copy assignment operator.

    ref struct R {
    void operator=(R% r) {}
    };
    
    int main() {
    System::Console::WriteLine(__has_assign(R));
    }
    
  • __has_copy( type )__has_copy( type )

    true プラットフォームまたはネイティブ型にコピーコンストラクターがある場合は、を返します。Returns true if the platform or native type has a copy constructor.

    ref struct R {
    R(R% r) {}
    };
    
    int main() {
    System::Console::WriteLine(__has_copy(R));
    }
    
  • __has_finalizer( type )__has_finalizer( type )

    (C++/CX ではサポートされていません)。true CLR 型にファイナライザーがある場合は、を返します。(Not supported in C++/CX.) Returns true if the CLR type has a finalizer. 詳細については、「方法: クラスと構造体を定義および使用する (C++/cli)」の「デストラクターとファイナライザー 」を参照してください。See Destructors and finalizers in How to: Define and consume classes and structs (C++/CLI) for more information.

    using namespace System;
    ref struct R {
    ~R() {}
    protected:
    !R() {}
    };
    
    int main() {
    Console::WriteLine(__has_finalizer(R));
    }
    
  • __has_nothrow_assign( type )__has_nothrow_assign( type )

    true コピー代入演算子に空の例外指定がある場合は、を返します。Returns true if a copy assignment operator has an empty exception specification.

    #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 )__has_nothrow_constructor( type )

    true 既定のコンストラクターに空の例外指定がある場合は、を返します。Returns true if the default constructor has an empty exception specification.

    #include <stdio.h>
    struct S {
    S() throw() {}
    };
    
    int main() {
    __has_nothrow_constructor(S) == true ?
    printf("true\n") : printf("false\n");
    }
    
  • __has_nothrow_copy( type )__has_nothrow_copy( type )

    true コピーコンストラクターに空の例外指定がある場合は、を返します。Returns true if the copy constructor has an empty exception specification.

    #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 )__has_trivial_assign( type )

    true 型に自明なコンパイラで生成された代入演算子がある場合は、を返します。Returns true if the type has a trivial, compiler-generated assignment operator.

    #include <stdio.h>
    struct S {};
    
    int main() {
    __has_trivial_assign(S) == true ?
    printf("true\n") : printf("false\n");
    }
    
  • __has_trivial_constructor( type )__has_trivial_constructor( type )

    true 型に自明なコンパイラで生成されたコンストラクターがある場合は、を返します。Returns true if the type has a trivial, compiler-generated constructor.

    #include <stdio.h>
    struct S {};
    
    int main() {
    __has_trivial_constructor(S) == true ?
    printf("true\n") : printf("false\n");
    }
    
  • __has_trivial_copy( type )__has_trivial_copy( type )

    true 型に自明なコンパイラで生成されたコピーコンストラクターがある場合は、を返します。Returns true if the type has a trivial, compiler-generated copy constructor.

    #include <stdio.h>
    struct S {};
    
    int main() {
    __has_trivial_copy(S) == true ?
    printf("true\n") : printf("false\n");
    }
    
  • __has_trivial_destructor( type )__has_trivial_destructor( type )

    true 型に自明なコンパイラで生成されたデストラクターがある場合は、を返します。Returns true if the type has a trivial, compiler-generated destructor.

    // 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 )__has_user_destructor( type )

    true プラットフォームまたはネイティブ型にユーザーが宣言したデストラクターがある場合は、を返します。Returns true if the platform or native type has a user-declared destructor.

    // has_user_destructor.cpp
    
    using namespace System;
    ref class R {
    ~R() {}
    };
    
    int main() {
    Console::WriteLine(__has_user_destructor(R));
    }
    
  • __has_virtual_destructor( type )__has_virtual_destructor( type )

    true 型に仮想デストラクターがある場合は、を返します。Returns true if the type has a virtual destructor.

    __has_virtual_destructor はプラットフォーム型でも機能します。また、プラットフォーム型のユーザー定義のデストラクターは仮想デストラクターです。__has_virtual_destructor also works on platform types, and any user-defined destructor in a platform type is a 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 )__is_abstract( type )

    true 型が抽象型である場合はを返します。Returns true if the type is an abstract type. ネイティブ抽象型の詳細については、「抽象クラス」を参照してください。For more information on native abstract types, see Abstract Classes.

    __is_abstract はプラットフォーム型でも機能します。__is_abstract also works for platform types. 1 つ以上の抽象メンバーを持つ参照型と同様に、1 つ以上のメンバーを持つインターフェイスは抽象型です。An interface with at least one member is an abstract type, as is a reference type with at least one abstract member. 抽象プラットフォーム型の詳細については、「abstract」を参照してください。For more information on abstract platform types, see abstract.

    // 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 )__is_base_of( base , derived )

    true 最初の型が2番目の型の基本クラスであり、両方の型が同じである場合は、を返します。Returns true if the first type is a base class of the second type, of if both types are the same.

    __is_base_of はプラットフォーム型でも機能します。__is_base_of also works on platform types. たとえば、 true 最初の型がインターフェイスクラスで、2番目の型がインターフェイスを実装している場合は、が返されます。For example, it will return true if the first type is an interface class and the second type implements the interface.

    // 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 )__is_class( type )

    true 型がネイティブクラスまたは構造体である場合は、を返します。Returns true if the type is a native class or struct.

    #include <stdio.h>
    struct S {};
    
    int main() {
    __is_class(S) == true ?
    printf("true\n") : printf("false\n");
    }
    
  • __is_convertible_to( from , to )__is_convertible_to( from , to )

    true 最初の型を2番目の型に変換できる場合はを返します。Returns true if the first type can be converted to the second type.

    #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 )__is_delegate( type )

    true がデリゲートである場合は、を返し type ます。Returns true if type is a delegate. デリゲートの詳細については、「delegate (C++/CLI and C++/CX)」を参照してください。For more information, see delegate (C++/CLI and C++/CX).

    delegate void MyDel();
    int main() {
    System::Console::WriteLine(__is_delegate(MyDel));
    }
    
  • __is_empty( type )__is_empty( type )

    true 型にインスタンスデータメンバーがない場合は、を返します。Returns true if the type has no instance data members.

    #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 )__is_enum( type )

    true 型がネイティブ列挙型である場合はを返します。Returns true if the type is a native enum.

    // 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 )__is_interface_class( type )

    true プラットフォームインターフェイスが渡された場合は、を返します。Returns true if passed a platform interface. 詳細については、「インターフェイス クラス」を参照してください。For more information, see interface class.

    // is_interface_class.cpp
    
    using namespace System;
    interface class I {};
    int main() {
    Console::WriteLine(__is_interface_class(I));
    }
    
  • __is_pod( type )__is_pod( type )

    true 型がコンストラクターのないクラスまたは共用体、プライベートまたは保護された非静的メンバー、基底クラス、および仮想関数がない場合は、を返します。Returns true if the type is a class or union with no constructor or private or protected non-static members, no base classes, and no virtual functions. POD 型の詳細については、C++ 標準のセクション 8.5.1/1、9/4、3.9/10 を参照してください。See the C++ standard, sections 8.5.1/1, 9/4, and 3.9/10 for more information on PODs.

    __is_pod は基本型の場合に false を返します。__is_pod will return false on fundamental types.

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

    true ネイティブ型に仮想関数がある場合は、を返します。Returns true if a native type has virtual functions.

    #include <stdio.h>
    struct S {
    virtual void Test(){}
    };
    
    int main() {
    __is_polymorphic(S) == true ?
    printf("true\n") : printf("false\n");
    }
    
  • __is_ref_array( type )__is_ref_array( type )

    true プラットフォーム配列が渡された場合は、を返します。Returns true if passed a platform array. 詳細については、「配列」を参照してください。For more information, see Arrays.

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

    true 参照クラスが渡された場合は、を返します。Returns true if passed a reference class. ユーザー定義の参照型の詳細については、クラスと構造体に関する記事を参照してください。For more information on user-defined reference types, see Classes and Structs.

    using namespace System;
    ref class R {};
    int main() {
    Console::WriteLine(__is_ref_class(Buffer));
    Console::WriteLine(__is_ref_class(R));
    }
    
  • __is_sealed( type )__is_sealed( type )

    true Sealed とマークされたプラットフォームまたはネイティブ型が渡された場合は、を返します。Returns true if passed a platform or native type marked sealed. 詳細については、「sealed」を参照してください。For more information, see sealed.

    ref class R sealed{};
    int main() {
    System::Console::WriteLine(__is_sealed(R));
    }
    
  • __is_simple_value_class( type )__is_simple_value_class( type )

    true ガベージコレクションヒープへの参照を含まない値型が渡された場合は、を返します。Returns true if passed a value type that contains no references to the garbage-collected heap. ユーザー定義の値型の詳細については、クラスと構造体に関する記事を参照してください。For more information on user-defined value types, see Classes and Structs.

    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 )__is_union( type )

    true 型が共用体の場合はを返します。Returns true if a type is a 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( type )__is_value_class( type )

    true 値型が渡された場合はを返します。Returns true if passed a value type. ユーザー定義の値型の詳細については、クラスと構造体に関する記事を参照してください。For more information on user-defined value types, see Classes and Structs.

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

Windows ランタイムWindows Runtime

解説Remarks

__has_finalizer() 特徴はサポートされていません。このプラットフォームではファイナライザーがサポートされていません。The __has_finalizer(type) type trait is not supported because this platform does not support finalizers.

必要条件Requirements

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

共通言語ランタイムCommon Language Runtime

解説Remarks

(この機能のプラットフォーム固有の解説はありません。)(There are no platform-specific remarks for this feature.)

必要条件Requirements

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

Examples

Example

次のコード例は /clr コンパイルのコンパイラ型の特徴を公開するときは、クラス テンプレートを使用する方法を示します。The following code example shows how to use a class template to expose a compiler type trait for a /clr compilation. 詳細については、「Windows ランタイムおよびマネージド テンプレート (C++/CLI および C++/CX)」を参照してください。For more information, see Windows Runtime and Managed Templates.

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

関連項目See also

.NET および UWP 用のコンポーネントの拡張機能Component Extensions for .NET and UWP