通过

编译器支持类型特征（C++ 组件扩展）

  • 项目

编译器支持 类型特征，指示类型的各种特征在编译时。

所有运行时

备注

类型特征编写库的程序员尤其有用。

下表列出了由编译器支持的类型特征。，如果该条件指定名为该类型特征没有匹配项，所有类型特征返回 false 。

(在表的 description 列，代码示例在 C++/CLI只编写。但是，相应的类型特征在 Visual C++ 组件扩展 除非另外声明否则还支持。这个术语， “平台类型”是指 Windows 运行时 类型或公共语言运行时 (clr) 类型。)

键入特征

说明

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

，如果复制赋值运算符具有 null 的异常规范，则返回 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)

，如果默认构造函数具有 null 的异常规范，则返回 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)

，如果复制构造函数具有 null 的异常规范，则返回 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，如果第一个类型为 接口类（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。有关更多信息，请参见委托（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。请参见 C++ 标准，部分 8.5.1/1， 9/4 和 3.9/10 有关 POD 的更多信息。

__is_pod 将返回错误在基础类型。

// 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-cn,VS.110).gif要求

编译器选项: /ZW

公共语言运行时

备注

(如果没有此函数的特定于平台的备注。)

ms177194.collapse_all(zh-cn,VS.110).gif要求

编译器选项: /clr

ms177194.collapse_all(zh-cn,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");
}

Output

请参见

概念

适用于运行时平台的组件扩展