Partilhar via

Suporte para Compilador de Traços de Tipo (Extensões de Componentes C++)

  • Artigo

O oferece suporte do compilador digitar os características, que indicam várias características de um tipo em tempo de compilação.

Todos os Tempos de Execução

Comentários

As características do tipo são especialmente úteis para os programadores que gravam bibliotecas.

A tabela a seguir lista as características do tipo com suporte pelo compilador. Todos os características do tipo retornam false se a condição especificada pelo nome de característica de tipo não é atendida.

(Na coluna de descrição da tabela, os exemplos de código são gravados apenas em C++/CLI. Mas o traço correspondente do tipo também tem suporte em Extensões de componentes Visual C++ salvo indicação em contrário. O termo, “tipo plataforma” refere-se tipos de Tempo de Execução do Windows ou tipos de Common Language Runtime).

Traço do tipo

Descrição

__has_assign(type)

Retornará true se a plataforma ou tipo nativo têm um operador de atribuição de cópia.

// has_assign.cpp
// compile with: /clr
ref struct R {
   void operator=(R% r) {}
};
int main() {
   System::Console::WriteLine(__has_assign(R));
}

__has_copy(type)

Retornará true se a plataforma ou tipo nativo têm um construtor de cópia.

// has_copy.cpp
// compile with: /clr
ref struct R {
   R(R% r) {}
};
int main() {
   System::Console::WriteLine(__has_copy(R));
}

__has_finalizer(type)

(Não tem suporte em Extensões de componentes Visual C++.) Retornará true se o tipo CLR tem um finalizador. Consulte Destruidores e finalizadores no Visual C++ para maiores informações.

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

Retornará true se um operador de atribuição de cópia tem uma especificação vazia da exceção.

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

Retornará true se o construtor padrão possui uma especificação vazia da exceção.

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

Retornará true se o construtor de cópia tem uma especificação vazia da exceção.

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

Retornará true se o tipo tem um operador de atribuição trivial, completo gerado.

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

Retornará true se o tipo tem um construtor trivial, completo gerado.

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

Retornará true se o tipo tem um construtor trivial, completo gerado pela cópia.

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

Retornará true se o tipo tem um destruidor trivial, completo gerado.

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

Retornará true se a plataforma ou tipo nativo têm um usuário destruidor declarado.

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

Retornará true se o tipo tem um destruidor virtual.

__has_virtual_destructor também funciona em tipos de plataforma, e qualquer destruidor definida pelo usuário em um tipo de plataforma é um destruidor virtual.

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

Retornará true se o tipo é abstrato. Para obter mais informações sobre os tipos de sumário nativos, consulte abstrata (Extensões de Componentes C++).

__is_abstract também funciona para tipos de preparo. Uma interface com pelo menos um membro é abstrato, como é um tipo de referência com pelo menos um membro abstrato. Para obter mais informações sobre os tipos abstratos de plataforma, consulte Classes abstratas (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)

Retornará true se o primeiro tipo é uma classe base do tipo, dependendo de se ambos os tipos são os mesmos.

__is_base_of também funciona em tipos de preparo. Por exemplo, retornará true se o primeiro tipo é classe de interface (Extensões de Componentes C++) e o segundo tipo implementa a 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)

Retornará true se o tipo for uma classe ou uma estrutura nativo.

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

Retornará true se o primeiro tipo pode ser convertido no segundo tipo.

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

Retornará true se type é um representante. Para obter mais informações, consulte delegado (Extensões de Componentes C++).

// is_delegate.cpp
// compile with: /clr
delegate void MyDel();
int main() {
   System::Console::WriteLine(__is_delegate(MyDel));
}

__is_empty(type)

Retornará true se o tipo não tem nenhum membro de dados da instância.

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

Retornará true se o tipo for uma enum nativo.

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

Retornará true se passado uma interface de preparo. Para obter mais informações, consulte classe de interface (Extensões de Componentes 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)

Retornará true se o tipo for uma classe ou uma união sem o construtor ou membros privados ou protegidos de não estático, nenhuma classes base, e nenhuma função virtuais. Consulte o padrão do C++, as seções 8.5.1/1, o 9/4, e os 3.9/10 para obter mais informações sobre as vagens.

__is_pod retornará false em tipos básicos.

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

__is_polymorphic(type)

Retornará true se um tipo nativo tem funções virtuais.

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

Retornará true se passado uma matriz de preparo. Para obter mais informações, consulte Matrizes (Extensões de Componentes 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)

Retornará true se passado uma classe de referência. Para obter mais informações sobre tipos definidos pelo usuário de referência, consulte Classes e Estruturas (Extensões de Componentes 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)

Retornará true se passado uma plataforma ou um tipo nativo selado marcada. Para obter mais informações, consulte autenticada (Extensões de Componentes C++).

// is_sealed.cpp
// compile with: /clr
ref class R sealed{};
int main() {
   System::Console::WriteLine(__is_sealed(R));
}

__is_simple_value_class(type)

Retornará true se transmitido para um tipo de valor que não contém nenhuma referência ao heap com coletados. Para obter mais informações sobre tipos de valor definido pelo usuário, consulte Classes e Estruturas (Extensões de Componentes 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)

Retornará true se um tipo é uma união.

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

Retornará true se transmitido para um tipo de valor. Para obter mais informações sobre tipos de valor definido pelo usuário, consulte Classes e Estruturas (Extensões de Componentes C++).

// is_value_class.cpp
// compile with: /clr
value struct V {};
int main() {
   System::Console::WriteLine(__is_value_class(V));
}

Tempo de Execução do Windows

Comentários

O sublinhado do tipo de __has_finalizer(type) não tem suporte porque esta plataforma não oferece suporte a finalizers.

Requisitos

Opção do compilador: /ZW

Common Language Runtime

Comentários

(Não há nenhum comentário específico de plataforma para este recurso.)

Requisitos

Opção do compilador: /clr

Exemplos

Exemplo

O exemplo de código mostra como usar um modelo da classe para expor um traço do tipo do compilador para uma compilação de /clr . Para obter mais informações, consulte Tempo de Execução do Windows e Modelos Gerenciados (Extensões de Componentes 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");
}

Saída

Consulte também

Conceitos

Extensões de componente para plataformas de tempo de execução