Tipo

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Lenguaje C++

 

Conceptos básicos

Palabras clave

Fases de traducción

Comentarios

La función main()

Nombres e identificadores

Tipos

Tipos fundamentales

Objetos

Ámbito

Tiempo de vida de objetos

Duración de almacenamiento y enlace

Definiciones y regla de una definición

Búsqueda de nombres

Búsqueda de nombre calificado

Búsqueda de nombre no calificado

Regla como-si

Comportamiento no definido

Modelo de memoria

 

Los objetos, referencias, funciones (incluyendo las funciones de plantilla especializadas), y las expresiones tienen una propiedad denominada “tipo”, que restringe las operaciones permitidas para esas entidades y proporciona un significado semántico a las secuencias de bits que de otro modo serían genéricas.

Clasificación de tipos

El sistema de tipos en C++ consiste en los siguientes tipos:

• los tipos fundamentales (véase también std::is_fundamental):

• el tipo void (véase también std::is_void);
• el tipo std::nullptr_t (desde C++11) (véase también std::is_null_pointer);
• los tipos aritméticos (véase también std::is_arithmetic):

• los tipos de punto flotante (float, double, long double y sus versiones calificadas-cv) (véase también std::is_floating_point);
• los tipos enteros (incluyendo las versiones calificadas-cv, véase también std::is_integral):

• el tipo bool;
• los tipos carácter:

• los tipos carácter estrechos:

• los tipos carácter ordinarios (char, signed char, unsigned char)
• el tipo char8_t (desde C++20)

• los tipos carácter anchos (char16_t (desde C++11), char32_t (desde C++11), wchar_t);

• los tipos enteros con signo (short int, int, long int, long long int);
• los tipos enteros sin signo (unsigned short int, unsigned int, unsigned long int, unsigned long long int);

• los tipos compuestos (véase también std::is_compound):

• los tipos referencia (véase también std::is_reference):

• los tipos referencia a l-valor (véase también std::is_lvalue_reference):

• los tipos referencia a l-valor a tipos objeto;
• los tipos referencia a l-valor a tipos función;

• los tipos referencia a r-valor (véase también std::is_rvalue_reference):

• los tipos referencia a r-valor a tipos objeto;
• los tipos referencia a r-valor a tipos función;

• los tipos puntero (véase también std::is_pointer):

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

• los tipos puntero a miembro ( véase también std::is_member_pointer):

• los tipos puntero a dato miembro (véase también std::is_member_object_pointer);
• los tipos puntero a función miembro (véase también std::is_member_function_pointer);

• los tipos array (véase también std::is_array);
• los tipos función (véase también std::is_function);
• los tipos enumeración (véase también std::is_enum);
• los tipos clase:

• los tipos no-unión (véase también std::is_class);
• los tipos unión (véase también std::is_union).

Para cada tipo aparte de una referencia o función, el sistema de tipos admite además tres versiones calificadas-cv de dicho tipo: (const, volatile y const volatile).

Los tipos se agrupan en varias categorías según sus propiedades:

• los tipos objeto son tipos (posiblemente calificados-cv) que no son ni tipos función, ni tipos referencia, ni el tipo void (véase también std::is_object);
• los tipos escalares son tipos objeto ((posiblemente calificados-cv) que no son ni tipos array, ni tipos clase (véase también std::is_scalar);
• los tipos triviales (véase también std::is_trivial), tipos POD (compatible con lenguaje C) (véase también std::is_pod), tipos literal (véase también std::is_literal_type), y otras categorías referidas en la biblioteca de rasgos de tipo o como requerimientos denominados de tipo .

Denominación de tipos

Un nombre puede declararse para referirse a un tipo mediante:

• la declaración de una clase;
• la declaración de una unión;
• la declaración de una enumeración;
• la declaración una definición de tipo typedef;
• la declaración de un alias de tipo.

A menudo se necesita usar tipos que no tienen nombre en programas de C++; la sintaxis para esto se conoce como id-de-tipo. La sintaxis del id-de-tipo que nombra al tipo T es exactamente la sintaxis de una declaración de variable o función de tipo T, omitiendo el identificador, excepto que la secuencia-de-declaración-de-especificadores de la gramática de declaración está restringida a una secuencia-de-especificadores-de-tipo, y que los nuevos tipos pueden definirse solo si el id-de-tipo aparece en el lado derecho de una declaración de un alias que no sea de plantilla.

int* p;               // declaración de un puntero a entero
static_cast<int*>(p); // el id-de-tipo es "int*"

int a[3];   // declaración de un array de 3 enteros
new int[3]; // id-de-tipo es "int[3]" (denominado nuevo-id-de-tipo)

int (*(*x[2])())[3];      // declaración de un array de 2 punteros a función
                          // que devuelven un puntero a un array de 3 enteros
new (int (*(*[2])())[3]); // id-de-tipo es "int (*(*[2])())[3]"

void f(