Compartilhar via

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

  • Artigo

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

Todos os tempos de execução

Comentários

Características do tipo são especialmente úteis para os programadores que escrevem bibliotecas.

A tabela a seguir lista as características do tipo que são suportadas pelo compilador.Todos tipo de retorno de características false se a condição especificada pelo nome da característica de tipo não for atendida.

(Na coluna Descrição da tabela, exemplos de código são escritos em C++/CLI.Mas a característica de tipo correspondente também é suportada no Extensões de componentes Visual C++ salvo indicação em contrário.O termo "tipo de plataforma" refere-se a um Tempo de Execução do Windows tipos ou tipos common language runtime.)

Característica do tipo

Descrição

__has_assign(type)

Retorna true se o tipo nativo ou plataforma tiver um operador de atribuição 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)

Retorna true se a plataforma ou tipo nativo tem 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 suportada no Extensões de componentes Visual C++.) Retorna 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)

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

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

Retorna true se o construtor padrão tem uma especificação de exceção vazia.

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

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

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

Retorna true se o tipo tiver um operador de atribuição trivial, gerado pelo compilador.

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

Retorna true se o tipo tem um construtor trivial, gerado pelo compilador.

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

Retorna true se o tipo tem um construtor de copiar trivial, gerado pelo compilador.

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

Retorna true se o tipo tiver um destruidor trivial, gerado pelo compilador.

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

Retorna true se a plataforma ou tipo nativo tem um destruidor declarada de usuário.

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

Retorna true se o tipo tiver um destruidor virtual.

__has_virtual_destructortambém funciona em tipos de plataforma e qualquer destruidor definido 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)

Retorna true se o tipo é um tipo abstrato.Para obter mais informações sobre tipos abstratos nativos, consulte abstrata (Extensões de Componentes C++).

__is_abstracttambém funciona para tipos de plataforma.Uma interface com pelo menos um membro é um tipo abstrato como um tipo de referência pelo menos um membro abstract.Para obter mais informações sobre tipos abstratos de plataforma, consulteClasses 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)

Retorna true se o primeiro tipo é uma classe base do segundo tipo de se ambos os tipos são iguais.

__is_base_oftambém funciona em tipos de plataforma.Por exemplo, ele retornará true se o primeiro tipo é um 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)

Retorna true se o tipo é nativo class ou struct.

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

Retorna true se o primeiro tipo pode ser convertido para o 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)

Retorna VERDADEIRO se type é um delegado.Para 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)

Retorna true se o tipo não possui instância dados membros.

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

Retorna true se o tipo for um 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)

Retorna true se o passado de uma interface de plataforma.Para 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)

Retorna true se o tipo é uma classe ou união com nenhum construtor ou membros não-estático privados ou protegidos, não há classes base e não funções virtuais.Consulte o C++ padrão, as seções 8.5.1/1, 9/4 e 3.9/10 para obter mais informações sobre os PODs.

__is_podretornará false em tipos fundamentais.

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

__is_polymorphic(type)

Retorna true se um tipo nativo possui 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)

Retorna true se o passado de uma matriz de plataforma.Para 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)

Retorna true se o passado de uma classe de referência.Para obter mais informações sobre tipos de referência definidos pelo usuário, 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)

Retorna VERDADEIRO se o passado de uma plataforma ou tipo nativo marcado como sealed.Para 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)

Retorna true se passado um tipo de valor que não contém nenhuma referência a pilha de coletor.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)

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

Retorna true se passado 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 __has_finalizer(tipo) característica de tipo não é suportada porque esta plataforma não suporta os finalizadores.

ms177194.collapse_all(pt-br,VS.110).gifRequisitos

Opção de compilador:/ZW

Common Language Runtime

Comentários

(Não há nenhum comentários específicos da plataforma para esse recurso.)

ms177194.collapse_all(pt-br,VS.110).gifRequisitos

Opção de compilador:/clr

ms177194.collapse_all(pt-br,VS.110).gifExemplos

Exemplo

O exemplo de código a seguir mostra como usar um modelo de classe para expor uma característica do tipo de compilador para um /clr compilação.Para 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