Phenquestions
La memoria de una computadora es una serie de células. 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 debe tener conocimientos básicos de C ++ para poder 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 escalares.
bool
Un tipo booleano o un tipo bool tiene un valor de verdadero o falso para 1 o 0. Verdadero o falso ocupa un byte.
char, char sin firmar y char firmado
Un char es típicamente para un carácter de Europa occidental. Normalmente ocupa un byte. También hay un carácter sin firmar y firmado, que es cada uno un entero de ocho bits. Los caracteres sin firmar no implican valores negativos, mientras que los caracteres firmados implican valores negativos. El tipo de valor que tiene un char depende del compilador y puede ser simplemente un char sin firmar. Estos tres tipos de caracteres se denominan tipos de caracteres limitados y cada uno ocupa un byte.
Entero
Hay cinco tipos de enteros estándar sin signo y cinco tipos de enteros estándar con signo. Los cinco tipos de enteros sin signo son: "unsigned char", "unsigned short int", "unsigned int", "unsigned long int" y "unsigned long long int". Los cinco tipos de enteros con signo correspondientes son: "signo de caracteres", "short int", "int", "long int" y "long long int".
"Unsigned char" es del mismo tipo que los tipos de caracteres limitados (ver más arriba). "Carácter firmado" es el otro tipo de los tipos de caracteres limitados (ver más arriba).
Con el compilador g ++, "unsigned char" o "firmado char" 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
Cuando se trata de personajes de Europa occidental, el tipo char es suficiente en muchas situaciones. Sin embargo, cuando se trata de chino y otros idiomas orientales, se necesita char16_t, 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.
Los tipos de enteros bool, char, char16_t, char32_t, wchar_t, con signo y sin signo forman otro conjunto, llamado tipos integrales (enteros).
En este punto del artículo, se han mencionado dos tipos colectivos: tipos de caracteres estrechos y tipos integrales.
Tipos de punto flotante
Suponga que los números 457,000 y 457,230 son la misma lectura, medida con 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 fraccionaria (decimal). Aunque los números en la computadora son una secuencia de bits, algunos números de punto flotante son más precisos que otros.
Algunos instrumentos de medición toman medidas en pasos mínimos, digamos 10 unidades. Dicho instrumento tendría las siguientes lecturas: 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240, etc. 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 punto flotante, que son: float, double y long double. Para cualquier compilador, double debe tener una precisión superior a la de float o al menos a la de float; long double debe tener una precisión superior a la de double o al menos a la de double.
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 explicó hasta ahora.
Con el compilador g ++, el número de bytes de un flotante 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 void 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 compuestos son tipos no fundamentales. Esto significa que los tipos compuestos son tipos no escalares. Esta sección explica los conceptos básicos de los tipos compuestos.
Matrices
El siguiente segmento de código muestra una matriz de entradas 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 nombradas. 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 (instanciar) muchos objetos de la misma unidad generalizada. El siguiente programa muestra una clase y dos objetos, instanciados a partir de ella. Un objeto así es diferente de un objeto escalar.
#incluirusando el espacio de nombres std;
clase TheCla
público:
int num = 5;
int fn ()
return num;
;
int main ()
TheCla obj1;
TheCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
return 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 crearon instancias de 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;
estructura TheCla
int num = 5;
flotador flt = 2.3;
char ch = 'a';
obj1, obj2;
int main ()
cout << obj2.num <<", "<< obj2.flt <<", "<< obj2.ch <<'\n';
return 0;
La salida es:
5, 2.3, a
El nombre de la estructura es TheCla. obj1 y obj2 son dos objetos diferentes de la estructura.
Unión
El siguiente programa muestra una unión y su uso:
#incluirusando el espacio de nombres std;
unión TheCla
int num;
flotador flt = 2.3;
char ch;
obj1, obj2;
int main ()
cout << obj2.flt <<'\n';
return 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 se abandona el valor de flt.
Referencias
Una referencia es un 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 id.
Referencia de lvalue y referencia de rvalue
Las referencias anteriores son referencias de valor. El siguiente código muestra la 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, se necesita doble &, i.mi., &&.
Puntero
Un puntero no es realmente una entidad de C ++. Sin embargo, proporciona un mejor esquema para tratar las 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 llamado
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';
return num;
int main ()
int ret = fn (5);
cout << ret <<'\n';
return 0;
La salida es
definición de función
5
La llamada a la 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 la 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 función de un puntero de objeto escalar. func se puede hacer para contener la dirección de una función identificada por fn, de la siguiente manera:
func = &fn;El siguiente programa pone en acción la referencia de función y el puntero:
#incluirusando el espacio de nombres std;
int fn (int num)
/ * algunas declaraciones * /
return num;
int main ()
int (* func) (int);
func = &fn;
int ret = func (5);
cout << ret <<'\n';
return 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 están compuestos en sí mismos. También se utilizan para construir tipos de compuestos elaborados.
typedef
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 = 555555555555555555;cout << myInt <<'\n';
La salida es 555555555555555555. En el código, IduIL se ha convertido en un tipo que significa "unsigned long int".
Encuadernación estructurada
El enlace estructurado es una característica que hace posible que se asignen nombres 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, a los valores: 1, 2, 3 se les han dado los nombres, x, y, z. Tenga en cuenta el uso y la posición de la palabra reservada, auto. Además, tenga en cuenta el uso de los corchetes.
Campo de bits
La memoria es una secuencia de células. Cada celda toma un byte. Además, cada byte consta de ocho bits. Se puede configurar y cambiar un grupo de bits, no necesariamente ocho bits. Tal grupo se llama campo de bits. Estos grupos se acostarían uno al lado del otro. Si los grupos no forman un tipo, digamos 16 bits para un int corto, se agregan bits de relleno. El siguiente código ilustra esto con la estructura:
estructura Fechasemana corta sin firmar: 3; // 3 bits
monDay corto sin firmar: 6; // 6 bits
mon corto sin firmar: 5; // 5 bits
año corto sin firmar: 8; // 8 bits para año de 2 dígitos
dte;
dte.wkDay = 1; dte.monDay = 2; dte.mon = 2; dte.año = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
La salida es: 2/2/21. El número total de bits para wkDay, MonDay y mon es 3 + 6 + 5 = 14. Por lo tanto, se agregarían dos bits de relleno para formar 16 bits para el entero corto de 2 bytes (16 bits). Los siguientes 8 bits comienzan el siguiente int corto, que luego se llena con 8 bits de relleno.
Nota: Evite el uso de campos de bits; Úselo solo para la investigación.
Espacio de nombres
Un espacio de nombres es un conjunto de nombres, que no debe 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, aplicados en el espacio de nombres de la función main ():
#incluirusando el espacio de nombres std;
espacio de nombres NS1
int myInt = 8;
flotador flt;
espacio de nombres NS2
int myInt = 9;
flotador 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';
return 0;
La salida es:
9
8
2.5
4.8
Hay dos mismos nombres int en conflicto y dos mismos nombres flotantes en conflicto en el código.
Especialización en plantillas y plantillas
El esquema de plantilla permite el uso de un marcador de posición para diferentes tipos escalares 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 void func (T cha, U no)
cout << "I need bread for " << cha << no << '.' << '\n';
int main ()
func ('$', 3);
return 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 adelante.
Conclusión
Los tipos de C ++ existen en dos categorías: tipos fundamentales y tipos compuestos. Los tipos fundamentales son tipos escalares. Los tipos compuestos básicos son matrices, enumeraciones, clases, uniones, 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.
Chrys
