Tipos de C ++
La memoria de una computadora es una serie de celdas. Cada celda tiene el tamaño de un byte, normalmente es el espacio ocupado por un carácter de Europa occidental. El tamaño de un objeto se da en bytes. Este artículo ofrece un resumen de los tipos de C ++. Ya debería tener conocimiento básico de C ++, para comprender este artículo.
Contenido del artículo
- Tipos fundamentales
- Formas de construir tipos de compuestos
- Matrices
- Enumeración
- Clase
- Unión
- Referencias
- Funciones
- Otros tipos de compuestos
- Conclusión
Tipos fundamentales
Los tipos fundamentales son tipos escalar.
bool
Un tipo booleano o tipo bool tiene un valor de verdadero o falso para 1 o 0. Verdadero o falso ocupa un byte.
Char, un unsigned char, y firmado Char
Un carbón es típicamente para un personaje de Europa occidental. Normalmente ocupa un byte. También hay un char sin firmar y firmado, que es cada uno un entero de ocho bits. Los caracteres sin firmar no involucran valores negativos, mientras que los caracteres firmados involucran valores negativos. El tipo de valor que tiene un char depende del compilador y puede ser un char sin firmar. Estos tres tipos de caracteres se llaman tipos de caracteres estrechos, y cada uno ocupa un byte.
Entero
Hay cinco tipos enteros estándar sin firmar y cinco tipos de enteros estándar firmados. Los cinco tipos de enteros sin firmar son: "Char sin firmar", "Unsigned Short Int", "Unsigned int", "Unsigned Long int" y "Unsigned Long Long int". Los cinco tipos de enteros firmados correspondientes son: "Char firmado", "Short Int", "Int", "Long Int" y "Long Long int".
"Unsigned Char" es del mismo tipo que los tipos de caracteres estrechos (ver arriba). "Firmado Char" es el otro tipo de tipos de caracteres estrechos (ver arriba).
Con el compilador G ++, "un sin signo de char" o "char" firmado "ocupa un byte; "Unsigned Short Int" o "Short Int" ocupa dos bytes; "Unsigned int" o "int" ocupa cuatro bytes; "Unsigned Long Int" o "Long int" ocupa 8 bytes; "Unsigned Long Long int" o "Long Long int" todavía ocupa 8 bytes (a partir de ahora).
char16_t, char32_t, wchar_t
Al tratar con los personajes de Europa occidental, el tipo de char es suficiente en muchas situaciones. Sin embargo, cuando se trata de idiomas chinos y otros idiomas orientales, se necesita char16_t o char32_t o wchar_t. Con el compilador G ++, Char16_T ocupa dos bytes; Char32_t ocupa cuatro bytes y wchar_t también ocupa cuatro bytes.
El bool, el char, el char16_t, el char32_t, el warchar_t, el tipos de enteros firmados y los tipos sin firmar, forman otro conjunto, llamado integral (entero) tipos.
En este punto del artículo, se han mencionado dos tipos colectivos: tipos de caracteres estrechos y tipos integrales.
Tipos de puntos flotantes
Suponga que los números 457,000 y 457,230 son la misma lectura, medidas por dos instrumentos de medición diferentes. 457,230 es más preciso que 457,000 porque el valor es más detallado (involucra lugares más pequeños: + 200 más 30). Un número de punto flotante es un número con una parte fraccional (decimal). Aunque los números en la computadora son una secuencia de bits, algunos números de punto flotante son más precisos que los otros.
Algunos instrumentos de medición toman medidas en pasos mínimos, digamos 10 unidades. Tal instrumento tendría las siguientes lecturas: 10, 20, 30, 40, ... 100, 110, 130, 140, ... 200, 210, 220, 230, 240, y así sucesivamente. Aunque los números en la computadora son una secuencia de bits, los números de punto flotante varían en algunos pasos mínimos (mucho más pequeños que 10 unidades).
C ++ tiene tres tipos de puntos flotantes, que son: flotación, doble y largo. Para cualquier compilador, el doble debe tener la precisión que es más alta que la de Float o al menos la de Float; El doble largo debe tener la precisión que es mayor que la de doble o al menos la de doble.
Hay un tercer nombre colectivo: tipo aritmético. Este es el nombre de los tipos integrales y de punto flotante. Tenga en cuenta que este es también el nombre de todos los tipos escalares, como se explica hasta ahora.
Con el compilador G ++, el número de bytes para un flotador es cuatro; El número de bytes para un doble es ocho; El número de bytes para un doble largo es dieciséis.
tipo vacío
Con el compilador G ++, el tamaño del tipo vacío es un byte. El byte oficialmente no tiene bits, lo que significa que su ubicación tiene contenido vacío.
Formas de construir tipos de compuestos
Los tipos de compuestos son tipos no fundamentales. Esto significa que los tipos de compuestos no son tipos no escala. Esta sección explica los conceptos básicos de los tipos de compuestos.
Matrices
El siguiente segmento de código muestra una matriz de INTS y una matriz de caracteres:
int Arrint [] = 1, 2, 3, 4, 5;Char Arrcha [] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <
Enumeración
Una enumeración es un tipo, con constantes con nombre. Considere el siguiente segmento de código:
enum a = 3, b, c;cout << b <<'\n';
La salida es: 4. La primera línea del segmento de código es una enumeración, y A, B o C es un enumerador.
Clase
Una clase es una unidad generalizada a partir de la cual se pueden crear muchos objetos de la misma unidad generalizada (instanciada). El siguiente programa muestra una clase y dos objetos, instanciados de él. Tal objeto es diferente de un objeto escalar.
#incluirusando el espacio de nombres STD;
Clase THECLA
público:
int num = 5;
int fn ()
num de devolución;
;
int main ()
Thecla obj1;
Thecla obj2;
cout << obj1.num << " << obj2.num <<'\n';
regresar 0;
La salida es: 5 5. El nombre de la clase es thecla, y los nombres de los dos objetos son obj1 y obj2. Tenga en cuenta el punto y coma justo después de la descripción (definición) de la clase. Observe cómo se instanciaron los dos objetos en la función Main ().
NOTA: NUM es un miembro de datos y FN es una función miembro.
Unión
estructura
Una estructura es como una matriz, pero en lugar de tener pares de índice/valor, tiene pares de nombre/valor. Los nombres pueden escribirse en cualquier orden. El siguiente programa muestra una estructura y su uso:
#incluirusando el espacio de nombres STD;
estructurar thecla
int num = 5;
flotante flt = 2.3;
char ch = 'a';
obj1, obj2;
int main ()
cout << obj2.num <<", "<< obj2.flt <<
","<< obj2.ch <<'\n';
regresar 0;
La salida es:
5, 2.3, AEl nombre de la estructura es thecla. obj1 y obj2 son dos objetos diferentes de la estructura.
Unión
El siguiente programa muestra un sindicato y su uso:
#incluirusando el espacio de nombres STD;
Unión THECLA
int num;
flotante flt = 2.3;
Char Ch;
obj1, obj2;
int main ()
cout << obj2.flt <<'\n';
regresar 0;
La salida es: 2.3. La unión es similar a una estructura. La principal diferencia entre una estructura y una unión es que, para una estructura, solo un miembro puede tener un valor (inicializado) en cualquier momento. En el programa anterior, el miembro, FLT tiene un valor de 2.3. Cada uno de los otros miembros, NUM o CH, solo puede tener un valor siguiente si el valor para FLT está abandonado.
Referencias
Una referencia es sinónimo de un identificador. El siguiente segmento de código muestra cómo obtener una referencia a un identificador:
int id = 5;int & ref1 = id;
int & ref2 = id;
cout << id << " << ref1 <<
" << ref2 <<'\n';
La salida es: 5 5 5. Ref1 y Ref2 son sinónimos de identificación.
referencia de lvalue y referencia de rValue
Las referencias anteriores son referencias de Lvalue. El siguiente código muestra referencia de rValue:
int && ref = 5;cout << ref <<'\n';
La salida es: 5. Esta referencia se crea sin identificar ninguna ubicación en la memoria. Para lograr esto, doble y es necesario, yo.mi., &&.
Puntero
Un puntero no es realmente una entidad C ++. Sin embargo, proporciona un mejor esquema para tratar con referencias. El siguiente código muestra cómo se puede crear un puntero:
int ptdid = 5;int ptdid = 5;
int *ptrid;
ptrid = &ptdId;
cout << *ptrId <<'\n';
La salida es: 5. Tenga en cuenta la diferencia de nombre entre ptdid y ptdid. Ptdid es el objeto puntiagudo y Ptrid es el objeto puntero. & ptdid devuelve la dirección del objeto puntiagudo que se asigna a Ptrid. Para devolver el valor del objeto puntiagudo, use *ptrid.
Funciones
Función básica y su llamada
El siguiente código muestra una definición de función básica y su llamada:
#incluirusando el espacio de nombres STD;
int fn (int num)
cout<<"seen"<<'\n';
num de devolución;
int main ()
int ret = fn (5);
cout << ret <<'\n';
regresar 0;
La salida es
visto5
La llamada de función es fn (5). El nombre de la función es FN.
Referencia y puntero a una función
& fn devuelve la dirección en memoria de la función cuyo nombre es FN. La siguiente declaración declara un puntero a una función:
int (*func) ();Aquí, FUNC es el nombre del puntero a la función. El primer par de paréntesis diferencia este puntero de la función de un puntero de objeto escalar. Se puede hacer FUNC para mantener la dirección de una función identificada por FN, como sigue:
func = &fn;El siguiente programa pone la referencia de la función y el puntero en acción:
#incluirusando el espacio de nombres STD;
int fn (int num)
/ * Algunas declaraciones */
num de devolución;
int main ()
int (*func) (int);
func = &fn;
int ret = func (5);
cout << ret <<'\n';
regresar 0;
La salida es: 5. Tenga en cuenta que tanto FN como Func tienen el parámetro int en la declaración.
Otros tipos de compuestos
Los tipos de compuestos básicos anteriores son compuestos en sí mismos. También se utilizan para construir tipos de compuestos elaborados.
typeedef
La palabra reservada typedef se usa para reemplazar una secuencia de tipos con un nombre (para la secuencia). El siguiente segmento de código ilustra esto:
typedef unsigned long int iduil;Iduil myInt = 5555555555555555555;
cout << myInt <<'\n';
La salida es 5555555555555555555. En el código, Iduil se ha convertido en un tipo que representa "sin firmar larga int".
Unión estructurada
La unión estructurada es una característica que hace posible que los nombres se dan a los subobjetos. El siguiente código ilustra esto para la matriz:
int arr [3] = 1, 2, 3;auto [x, y, z] (arr);
cout << x <<"<< y <<"<< z <<'\n';
La salida es 1 2 3. Entonces, los valores: 1, 2, 3 han recibido los nombres, x, y, z. Tenga en cuenta el uso y la posición de la palabra reservada, automática. Además, tenga en cuenta el uso de los soportes cuadrados.
Campo de bits
La memoria es una secuencia de células. Cada celda toma un byte. Además, cada byte consta de ocho bits. Un grupo de bits, no necesariamente ocho bits, se puede configurar y cambiar. Tal grupo se llama un campo de bits. Estos grupos se mentirían uno al lado del otro. Si los grupos no inventan un tipo, digamos 16 bits para un intento corto, se agregan bits de acolchado. El siguiente código ilustra esto con la estructura:
Fecha de estructuraUnsigned Short Wkday: 3; // 3 bits
Unsigned Short Lunes: 6; // 6 bits
Unsigned Short Mon: 5; // 5 bits
Unsigned Short Yr: 8; // 8 bits para un año de 2 dígitos
dte;
dte.wkday = 1; dte.Lunes = 2; dte.mon = 2; dte.YR = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
La salida es: 2/2/21. El número total de bits para wkday, lunes y lunes es 3 + 6 + 5 = 14. Por lo tanto, se agregarían dos bits de relleno para compensar 16 bits para el entero corto de 2 bytes (16 bits). Los siguientes 8 bits comienzan el siguiente intento corto, que luego se llena con 8 bits de relleno.
Nota: Evite usar campos de bits; Úselo solo para la investigación.
Espacio de nombres
Un espacio de nombres es un conjunto de nombres, que no deberían entrar en conflicto con los mismos nombres de otros conjuntos de nombres. El siguiente programa ilustra el uso de los mismos nombres de dos espacios de nombres diferentes, aplicado en el espacio de nombres de la función Main ():
#incluirusando el espacio de nombres STD;
espacio de nombres NS1
int myint = 8;
flotante flt;
espacio de nombres NS2
int myint = 9;
flotante flt;
int main ()
cout << NS1::myInt << '\n';
cout << NS2::myInt << '\n';
NS1 :: FLT = 2.5;
NS2 :: FLT = 4.8;
cout << NS1::flt << '\n';
cout << NS2::flt << '\n';
regresar 0;
La salida es:
98
2.5
4.8
Hay dos mismos nombres de intenciones en conflicto y dos nombres de flotación en conflicto en el código.
Especialización de plantilla y plantilla
El esquema de plantilla permite el uso de un marcador de posición para diferentes tipos de escalar posibles. La especialización es elegir un tipo escalar particular. El siguiente código ilustra esto para una función:
#incluirusando el espacio de nombres STD;
plantilla
vacío func (t cha, u no)
cout << "I need bread for " << cha << no << '.' << '\n';
int main ()
func ('$', 3);
regresar 0;
La salida es:
Necesito pan por $ 3.Paquete de parámetros de plantilla
Los compiladores aún deben implementar completamente esta función; ver más tarde.
Conclusión
Los tipos de C ++ existen en dos categorías: tipos fundamentales y tipos de compuestos. Los tipos fundamentales son tipos escalar. Los tipos de compuestos básicos son matrices, enumeraciones, clases, sindicatos, referencias, punteros y funciones. Estos tipos de compuestos básicos se utilizan para construir tipos de compuestos elaborados, que son typedef, enlaces estructurados, campos de bits, espacio de nombres y características de plantilla.