Type

Objetos , referencias , funciones incluyendo especializaciones de plantillas de función , y expresiones tienen una propiedad llamada tipo , que tanto restringe las operaciones permitidas para esas entidades como proporciona significado semántico a las secuencias de bits que de otro modo serían genéricas.

Clasificación de tipos

El sistema de tipos de C++ consta de los siguientes tipos:

• tipos fundamentales (ver también std::is_fundamental ):

• el tipo void (ver también std::is_void );

• tipos aritméticos (ver también std::is_arithmetic ):

• tipos integrales (incluyendo versiones calificadas cv , ver también std::is_integral , un sinónimo para tipo integral es tipo entero):

• el tipo bool ;
• tipos de caracteres:

• tipos de caracteres estrechos:

• tipos de caracteres ordinarios: char , signed char , unsigned char ^[1]

• tipos de caracteres anchos: char16_t , char32_t , (desde C++11) wchar_t ;

• tipos enteros con signo:

• tipos enteros con signo estándar: signed char , short , int , long , long long ;

• tipos de enteros sin signo:

• tipos de enteros sin signo estándar: unsigned char , unsigned short , unsigned , unsigned long , unsigned long long ;

• tipos de punto flotante (ver también std::is_floating_point ):

• tipos estándar de punto flotante: float , double , long double y sus versiones calificadas cv ;

• tipos compuestos (consulte también std::is_compound ):

• tipos de referencia (ver también std::is_reference ):

• tipos de referencia lvalue (ver también std::is_lvalue_reference ):

• referencia lvalue a tipos de objeto;
• referencia lvalue a tipos de función;

• tipos de puntero (ver también std::is_pointer ):

• tipos puntero-a-objeto ;
• tipos puntero-a-función ;

• tipos puntero-a-miembro (ver también std::is_member_pointer ):

• tipos puntero-a-dato-miembro (ver también std::is_member_object_pointer );
• tipos puntero-a-función-miembro (ver también std::is_member_function_pointer );

• tipos de arreglo (ver también std::is_array );
• tipos de función (ver también std::is_function );
• tipos de enumeración (ver también std::is_enum );

• tipos de enumeración no acotada ;

• class types :

• tipos no unión (ver también std::is_class );
• union types (ver también std::is_union ).

1. ↑ signed char y unsigned char son tipos de caracteres estrechos, pero no son tipos de caracteres. En otras palabras, el conjunto de tipos de caracteres estrechos no es un subconjunto del conjunto de tipos de caracteres.

Para cada tipo no calificado-cv que no sea referencia y función, el sistema de tipos admite tres versiones adicionales calificadas-cv de ese tipo ( const , volatile , y const volatile ).

Otras categorías

Un tipo de objeto (ver también std::is_object ) es un tipo (posiblemente calificado con cv) que no es un tipo función, no es un tipo referencia, y no es void (posiblemente calificado con cv).

Los siguientes tipos se denominan colectivamente tipos escalares (ver también std::is_scalar ):

• tipos aritméticos
• tipos de enumeración
• tipos de puntero
• tipos de puntero-a-miembro

• versiones calificadas cv de estos tipos

Los siguientes tipos se denominan colectivamente tipos de duración implícita :

• tipos escalares
• tipos de clase de duración implícita
• tipos de arreglo
• versiones calificadas cv de estos tipos

Categorías obsoletas

Tipo definido por el programa

Una especialización definida por el programa es una especialización explícita o una especialización parcial que no forma parte de la biblioteca estándar de C++ y no está definida por la implementación.

Un tipo definido por el programa es uno de los siguientes tipos:

• Un tipo que no es closure (desde C++11) tipo clase o tipo enumeración que no forma parte de la biblioteca estándar de C++ y no está definido por la implementación.

• Una instanciación de una especialización definida por el programa.

Nomenclatura de tipos

Un name puede declararse para referirse a un tipo mediante:

• class declaración;
• union declaración;
• enum declaración;
• typedef declaración;
• type alias declaración.

Los tipos que no tienen nombres a menudo necesitan ser referenciados en programas de C++; la sintaxis para eso se conoce como type-id . La sintaxis del type-id que nombra al tipo T es exactamente la sintaxis de una declaración de una variable o función de tipo T , omitiendo el identificador, excepto que el decl-specifier-seq de la gramática de declaración está restringido a type-specifier-seq , y que nuevos tipos pueden definirse solo si el type-id aparece en el lado derecho de una declaración de alias de tipo no plantilla.

int* p;               // declaración de un puntero a int
static_cast<int*>(p); // type-id es "int*"
int a[3];   // declaración de un array de 3 int
new int[3]; // type-id es "int[3]" (llamado new-type-id)
int (*(*x[2])())[3];      // declaración de un array de 2 punteros a funciones
                          // que retornan puntero a array de 3 int
new (int (*(*[2])())[3]); // type-id es "int (*(*[2])())[3]"
void f(int);                    // declaración de una función que toma int y retorna void
std::function<void(int)> x = f; // parámetro de plantilla de tipo es un type-id "void(int)"
std::function<auto(int) -> void> y = f; // mismo
std::vector<int> v;       // declaración de un vector de int
sizeof(std::vector<int>); // type-id es "std::vector<int>"
struct { int x; } b;         // crea un nuevo tipo y declara un objeto b de ese tipo
sizeof(struct { int x; });   // error: no se pueden definir nuevos tipos en una expresión sizeof
using t = struct { int x; }; // crea un nuevo tipo y declara t como un alias de ese tipo
sizeof(static int); // error: especificadores de clase de almacenamiento no son parte de type-specifier-seq
std::function<inline void(int)> f; // error: tampoco los especificadores de función

La parte declarator de la gramática de declaración con el nombre eliminado se denomina abstract-declarator .

Type-id puede ser utilizado en las siguientes situaciones:

• para especificar el tipo destino en expresiones de conversión ;
• como argumentos de sizeof , alignof , alignas , new , y typeid ;
• en el lado derecho de una declaración de alias de tipo ;
• como el tipo de retorno final de una declaración de función ;
• como el argumento predeterminado de un parámetro de plantilla de tipo ;
• como el argumento de plantilla para un parámetro de plantilla de tipo ;

El type-id puede utilizarse con algunas modificaciones en las siguientes situaciones:

• en la lista de parámetros de una función (cuando se omite el nombre del parámetro), type-id utiliza decl-specifier-seq en lugar de type-specifier-seq (en particular, se permiten algunos especificadores de clase de almacenamiento);
• en el nombre de una función de conversión definida por el usuario , el declarador abstracto no puede incluir operadores de función o array.

Especificador de tipo elaborado

Los especificadores de tipo elaborados pueden utilizarse para referirse a un nombre de clase previamente declarado (class, struct o union) o a un nombre de enumeración previamente declarado incluso si el nombre estaba oculto por una declaración de no-tipo . También pueden utilizarse para declarar nuevos nombres de clase.

Consulte elaborated type specifier para más detalles.

Tipo estático

El tipo de una expresión que resulta del análisis en tiempo de compilación del programa se conoce como el static type de la expresión. El static type no cambia mientras el programa se está ejecutando.

Tipo dinámico

Si alguna expresión glvalue se refiere a un objeto polimórfico , el tipo de su objeto más derivado se conoce como el tipo dinámico.

// dado
struct B { virtual ~B() {} }; // tipo polimórfico
struct D : B {};               // tipo polimórfico
D d; // objeto más derivado
B* ptr = &d;
// el tipo estático de (*ptr) es B
// el tipo dinámico de (*ptr) es D

Para las expresiones prvalue, el tipo dinámico siempre es el mismo que el tipo estático.

Tipo incompleto

Los siguientes tipos son tipos incompletos :

• el tipo void (posiblemente cv -calificado);
• tipos de objeto incompletamente definidos :
  • tipo de clase que ha sido declarado (ej. por declaración anticipada ) pero no definido;
  • arreglo de límite desconocido ;
  • arreglo de elementos de tipo incompleto;
  • tipo de enumeración desde el punto de declaración hasta que su tipo subyacente es determinado.

Todos los demás tipos están completos.

Cualquiera de los siguientes contextos requiere que el tipo T esté completo:

• definición o llamada a una función con tipo de retorno T o tipo de argumento T ;
• definición de un objeto de tipo T ;
• declaración de un miembro de datos no estático de clase de tipo T ;
• new expresión para un objeto de tipo T o un array cuyo tipo de elemento es T ;
• conversión de lvalue a rvalue aplicada a un glvalue de tipo T ;
• una conversión implícita o explícita al tipo T ;
• una conversión estándar , dynamic_cast , o static_cast al tipo T * o T & , excepto cuando se convierte desde la constante de puntero nulo o desde un puntero a void posiblemente calificado con cv ;
• operador de acceso a miembro de clase aplicado a una expresión de tipo T ;
• typeid , sizeof , o alignof aplicado al tipo T ;
• operador aritmético aplicado a un puntero a T ;
• definición de una clase con clase base T ;
• asignación a un lvalue de tipo T ;
• un manejador de tipo T , T & , o T * .

(En general, cuando el tamaño y diseño de T deben conocerse.)

Si cualquiera de estas situaciones ocurre en una unidad de traducción, la definición del tipo debe aparecer en la misma unidad de traducción. De lo contrario, no es requerida.

Un tipo de objeto incompletamente definido puede ser completado:

• Un tipo de clase (como class X ) puede considerarse incompleto en un punto de una unidad de traducción y considerarse completo más adelante; el tipo class X es el mismo tipo en ambos puntos:

struct X;            // declaración de X, aún no se proporciona la definición
extern X* xp;        // xp es un puntero a un tipo incompleto:
                     // la definición de X no es accesible
void foo()
{
    xp++;            // incorrecto: X está incompleto
}
struct X { int i; }; // definición de X
X x;                 // OK: la definición de X es accesible
void bar()
{
    xp = &x;         // OK: el tipo es "puntero a X"
    xp++;            // OK: X está completo
}

• El tipo declarado de un objeto array podría ser un array de tipo de clase incompleto y por lo tanto incompleto; si el tipo de clase se completa posteriormente en la unidad de traducción, el tipo array se vuelve completo; el tipo array en esos dos puntos es el mismo tipo.
• El tipo declarado de un objeto array podría ser un array de límite desconocido y por lo tanto ser incompleto en un punto de una unidad de traducción y completo posteriormente; los tipos array en esos dos puntos ("array de límite desconocido de T " y "array de N T ") son tipos diferentes.

El tipo de un puntero o referencia a un array de límite desconocido apunta permanentemente o se refiere a un tipo incompleto. Un array de límite desconocido nombrado por una typedef declaración se refiere permanentemente a un tipo incompleto. En cualquier caso, el tipo array no puede ser completado:

extern int arr[];   // el tipo de arr es incompleto
typedef int UNKA[]; // UNKA es un tipo incompleto
UNKA* arrp;         // arrp es un puntero a un tipo incompleto
UNKA** arrpp;
void foo()
{
    arrp++;         // error: UNKA es un tipo incompleto
    arrpp++;        // OK: sizeof UNKA* es conocido
}
int arr[10];        // ahora el tipo de arr es completo
void bar()
{
    arrp = &arr;    // OK: conversión de calificación (desde C++20)
    arrp++;         // error: UNKA no puede ser completado
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Referencias

Véase también

Enlaces externos