Поддержка характеристик типов компилятором (расширения компонентов C++)

  • Статья

Компилятор поддерживает характеристики типов, которые отображают различные характеристики типа во время компиляции.

Все среды выполнения

Примечания

Характеристики типов особенно полезны программистам, которые создают библиотеки.

В следующей таблице описаны характеристики типов, поддерживаемые компилятором. Все характеристики типов возвращают false, если условие, заданное по имени характеристики типов, не выполняется.

(В столбце описания таблицы примеры кода записываются только в 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++). Возвращает true, если тип CLR имеет метод завершения. Дополнительные сведения см. в разделе Деструкторы и методов завершения в 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, если тип является классом или объединением без конструктора или закрытых или защищенных нестатических членов, базовых классов, виртуальных функций. Дополнительные сведения о POD см. в разделе 8.5.1/1, 9/4 и 3.9/10 стандарта C++.

__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(type) не поддерживается, потому что эта среда не поддерживает методы завершения.

Требования

Параметр компилятора: /ZW

Среда CLR

Примечания

(Отсутствуют комментарии для данной функции в рамках этой платформы).

Требования

Параметр компилятора: /clr

Примеры

Пример

В следующем примере показано, как использовать шаблон класса для предоставления характеристики типа компилятора для компиляции /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

См. также

Основные понятия

Расширения компонентов для платформ среды выполнения