Compartir a través de

Compatibilidad de compilador para type traits (Extensiones de componentes de C++)

  • Artículo

El compilador admite los rasgos de tipo, que indican diversas características de un tipo en tiempo de compilación.

Todos los runtimes

Comentarios

Los rasgos de tipo son especialmente útiles para los programadores que escriben las bibliotecas.

La tabla siguiente se enumeran los rasgos de tipo admitidos por el compilador.Todos los rasgos escritos devuelven false si la condición especificada con el nombre de característica de tipo no se cumple.

(En la columna de la tabla, ejemplos de código se escriben sólo en C++/CLI.Pero el rasgo cuyas corresponde también se admite en Extensiones de componentes de Visual C++ a menos que se indique lo contrario.El término “, plataforma tipo” hace referencia a los tipos de Windows en tiempo de ejecución o tipos de Common Language Runtime).

Rasgo de tipo

Descripción

__has_assign(type)

Devuelve true si el tipo de plataforma o nativo tiene un operador de asignación de copia.

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

__has_copy(type)

Devuelve true si el tipo de plataforma o nativo tiene un constructor de copia.

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

__has_finalizer(type)

(No se admite en Extensiones de componentes de Visual C++.) Devuelve true si el tipo de CLR tiene un finalizador.Para obtener más información, consulte Destructores y Finalizadores en 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)

Devuelve true si un operador de asignación de copia tiene una especificación vacía de la excepción.

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

Devuelve true si el constructor predeterminado tiene una especificación vacía de la excepción.

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

Devuelve true si el constructor de copias tiene una especificación vacía de la excepción.

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

Devuelve true si el tipo tiene un operador de asignación trivial, generado por el 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)

Devuelve true si el tipo tiene un constructor trivial, generado por el 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)

Devuelve true si el tipo tiene un constructor trivial, generados de copia.

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

Devuelve true si el tipo tiene un destructor trivial, generado por el 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)

Devuelve true si el tipo de plataforma o nativas destructor usuario-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)

Devuelve true si el tipo tiene un destructor virtual.

__has_virtual_destructor también funciona en tipos de plataforma, y cualquier un destructor definido por el usuario en un tipo de plataforma es un destructor 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)

Devuelve true si el tipo es un tipo abstracto.Para obtener más información sobre tipos de resumen nativo, vea abstract (Extensiones de componentes de C++).

__is_abstract también funciona con los tipos de la plataforma.Una interfaz con al menos un miembro es un tipo abstracto, así como un tipo de referencia con al menos un miembro abstracto.Para obtener más información sobre tipos abstractos de la plataforma, vea Clases abstractas (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)

Devuelve true si el primer tipo es una clase base del segundo tipo, si ambos tipos son iguales.

__is_base_of también funciona en tipos de la plataforma.Por ejemplo, devolverá true si el primer tipo es interface class (Extensiones de componentes de C++) y el segundo tipo implementa la interfaz.

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

Devuelve true si typ es una clase o struct nativa.

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

Devuelve true si el primer tipo se puede convertir al 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)

Devuelve true si type es un delegado.Para obtener más información, vea delegate (Extensiones de componentes de C++).

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

__is_empty(type)

Devuelve true si el tipo no tiene ningún miembro de datos de la instancia.

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

Devuelve true si typ es una enumeración 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)

Devuelve true si se pasa una interfaz de la plataforma.Para obtener más información, vea interface class (Extensiones de componentes de 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)

Devuelve true si typ es una clase o una unión sin constructor o los miembros no estáticos private o protected, ninguna clase base, ni funciones virtuales.Vea el estándar de C++, las secciones 8.5.1/1, el 9/4, y los 3.9/10 para obtener más información sobre PODs.

__is_pod devolverá false en tipos fundamentales.

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

__is_polymorphic(type)

Devuelve true si un tipo nativo tiene funciones virtuales.

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

Devuelve true si se pasa una matriz de la plataforma.Para obtener más información, vea Matrices (Extensiones de componentes de 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)

Devuelve true si se pasa una clase de referencia.Para obtener más información sobre los tipos de referencia definido por el usuario, vea Clases y structs (Extensiones de componentes de 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)

Devuelve true si se pasa una plataforma o código escribe marcado sealed.Para obtener más información, vea sealed (Extensiones de componentes de C++).

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

__is_simple_value_class(type)

Devuelve true si se pasa un tipo de valor que no contiene ninguna referencia a la pila de recolección de elementos no utilizados.Para obtener más información sobre los tipos de valor definido por el usuario, vea Clases y structs (Extensiones de componentes de 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)

Devuelve true si un tipo es una unión.

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

Devuelve true si se pasa un tipo de valor.Para obtener más información sobre los tipos de valor definido por el usuario, vea Clases y structs (Extensiones de componentes de C++).

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

Windows en tiempo de ejecución

Comentarios

El rasgo de tipo de __has_finalizer(tipo) no se admite porque esta plataforma no admite finalizadores.

ms177194.collapse_all(es-es,VS.110).gifRequisitos

Opción del compilador: /ZW

Common Language Runtime

Comentarios

(No hay notas específicas de la plataforma para esta característica).

ms177194.collapse_all(es-es,VS.110).gifRequisitos

Opción del compilador: /clr

ms177194.collapse_all(es-es,VS.110).gifEjemplos

Ejemplo

El ejemplo de código siguiente muestra cómo utilizar una plantilla de clase para exponer un rasgo de tipo de compilador de una compilación de /clr .Para obtener más información, vea Windows en tiempo de ejecución y plantillas administradas (Extensiones de componentes de 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

Vea también

Conceptos

Extensiones de componentes para plataformas de tiempo de ejecución