C++ de los fundamentos al dominio — Lección 5

Los artículos escritos en este blog fueron creados con el objetivo de enseñar. Además, la información del artículo puede ser incorrecta, así que tenga cuidado.

Aprendamos sobre los tipos de datos de las variables. Se puede dividir en términos generales en cuatro categorías.

Tipo de datos básicos. Estos son los tipos más básicos que se asignan directamente a la memoria.

1-A. Propósito especial

vacío: no tiene tamaño. No ocupa memoria directamente y es de tipo incompleto.

std::nullptr_t: Tipo de literal de puntero nulo nullptr.

void DoSomething() {} //Función sin valor de retorno
void* ptr = nullptr;  //puntero sin tipo
std::nullptr_t null_val = nullptr;

1-B. Tipo aritmético

1-B-1. Entero char, char firmado, char sin firmar: almacenar caracteres. También existe wchar_t para Unicode. short, int, long, long long: almacena enteros con signo. sin signo corto, sin signo int, sin signo largo, sin signo largo largo: almacena números enteros sin signo. Debido a que no almacena números negativos, el espacio de almacenamiento para números positivos es el doble del espacio con signo. bool: almacena verdadero o falso. Utiliza 1 byte, no 1 bit.

char c = 'A';
int count = -10;
unsigned int u_count = 20;
bool is_valid = true;

Tipo de punto flotante 1-B-2

Tipos que siguen IEEE 754, Básicamente hay flotantes, dobles y dobles largos. También hay std::float16t, std::float32t, std::float64t, std::float128t y std::bfloat16_t. (extensión C++23)

float f_val = 3.14f;
double d_val = 3.1415926535;

2. Tipo de datos complejos Este es un tipo que define una estructura en la memoria combinando tipos básicos u otros tipos complejos.

Puntero (T): Apunta a una dirección de memoria de otro tipo T. Puntero a miembro (T::): un puntero especial que apunta al desplazamiento de memoria de una variable miembro específica o función dentro de una clase.

Referencia: Referencia de valor L (T&): alias de un objeto (valor L) que tiene un nombre y una sustancia en la memoria. Referencia de Rvalue (T&&, C++11): se vincula a objetos temporales y es un tipo central de Move Semantics y Perfect Forwarding.

Matriz (Array, T[N] / T[]): asigna datos del mismo tipo a bloques de memoria consecutivos. Función: la firma en sí, que consta de un tipo de retorno y una lista de parámetros, también es un tipo único. (por ejemplo, int(doble, char))

Enumeración: enumeración: una enumeración básica sin alcance especificado (permite la conversión de enteros implícita).

clase enum (C++11): una enumeración con alcance estricto (verificación de tipos sólida y garantías de alcance). Tipo definido por el usuario (Clase / Estructura / Unión): un tipo que implementa estructuras de datos y orientadas a objetos mediante el control del relleno de memoria y las reglas de alineación.

int value = 10;
int* ptr = &value; //puntero
int& ref = value;  //referencia de valor l
int&& r_ref = 20;  //Referencia de valor R


struct MyStruct { int x; };
int MyStruct::* member_ptr = &MyStruct::x; //puntero de miembro


int arr[5] = {1, 2, 3, 4, 5}; //acuerdo
int(*func_ptr)(int, int);     //puntero de función


enum class Color { Red, Green, Blue }; //enumeración estricta

3. Alias ​​específico de la arquitectura del sistema Estos son tipos de alias principales cuyos tamaños se determinan dinámicamente según el compilador y la arquitectura del sistema operativo (32 bits/64 bits). (encabezado <cstddef>)

std::sizet: tipo de retorno del operador sizeof. Es un entero sin signo que puede expresar el tamaño de bytes del objeto más grande que se puede crear en el sistema. (unidad estándar de indexación de contenedores y asignación de memoria) std::ptrdifft: un entero con signo que representa la distancia cuando se restan dos punteros. Se utiliza al calcular la diferencia entre direcciones de memoria.

#include <cstddef>

int arr[10];
std::size_t arr_size = sizeof(arr); //Tamaño máximo garantizado según la arquitectura del sistema.
std::ptrdiff_t diff = &arr[5] - &arr[0]; //Calcular la distancia entre punteros (5)

4. CV-Clasificatorios En el sistema de tipos de C++, si se agregan calificadores a todos los tipos de datos anteriores, se tratan como tipos completamente diferentes desde la perspectiva del compilador y se sobrecargan. (por ejemplo, int y const int son tipos diferentes)

const: evita la escritura en el área de memoria correspondiente y garantiza la inmutabilidad. volátil: impide con fuerza la optimización de lectura/escritura de la memoria del compilador. Al controlar registros de hardware o comunicarse con MMIO (E/S asignadas en memoria), se utiliza esencialmente para informar al compilador que los valores de los registros pueden ser cambiados por una fuente externa.

const int MAX_VALUE = 100; //Sólo lectura, no se puede modificar
//MAX_VALUE = 200; //Se produjo un error de compilación

volatile int hardware_register; //Evite la optimización del compilador
//El hardware externo puede cambiar el valor, por lo que cada vez se lee directamente desde la memoria en lugar del caché.