Este artículo trata sobre la aritmética de punteros en C++. El puntero es una variable en la dirección de memoria donde se almacenan los datos. La aritmética de punteros es un ícono poderoso en el mundo del lenguaje de programación C++, que nos permite manejar diferentes operaciones aritméticas, entre las cuales la suma, multiplicación, división, incremento, decremento y resta involucran punteros para desarrollar nuevas direcciones de memoria en el buffer de memoria. La aritmética de indicadores facilita el establecimiento de una asignación de memoria dinámica. En este artículo de C++, aprenderemos cómo usar punteros para manipular direcciones de memoria de diferentes maneras y brindaremos pautas y ejemplos apropiados.
Tabla de Contenidos
Escenario 1: el puntero realiza operaciones de autoincremento y autodecremento
Aquí aprenderemos operaciones de puntero para generar diferentes direcciones de memoria para diferentes propósitos. Los indicadores incrementales y decrementales también se aprovechan de la aritmética de indicadores, duplicando o restando direcciones una vez el tamaño del tipo de datos al que apuntan. El fragmento de código relacionado con este escenario se adjunta a continuación:
#incluir
Utilice el espacio de nombres estándar;
constante int Arr_Max = 5;
maestro de enteros () {
variable entera[Arr_Max] = {20, 150, 270};
entero *puntero; //declarar puntero
ptr = var;
para (entero yo = ; I < alcanzar el máximo;i++) {
std::cout < «La dirección de memoria del elemento es: [« << i << «] =»;
std::cout < puntero < Finalizar;
kut < «El valor relativo a la dirección es [« << i << «] =»;
kut < *puntero < Finalizar;
std::cout<«Incremento del puntero exitoso»<Finalizar;
ptr++;
}
std::cout<«Dirección del indicador antes de la disminución»<puntero<Finalizar;
ptr–;
std::cout<«Dirección de índice decreciente»<puntero<Finalizar;
devolver ;
}
Aquí, definimos una biblioteca requerida en el código inicial: «
Pasamos el array al puntero para acceder a la dirección. Como todos sabemos, las matrices siempre contienen varios elementos ubicados en diferentes ubicaciones. Por lo tanto, necesitamos un bucle con un puntero de «ayuda» para acceder a cada elemento de la matriz. Cada vez que se ejecuta el bucle, obtenemos la dirección de memoria y el valor de esa dirección con la ayuda del operador de incremento aritmético de puntero «ptr++», que mueve la dirección de memoria a la siguiente dirección en la memoria. El período de ejecución del bucle depende del tamaño de la matriz. Fuera del bucle, solo queremos usar «ptr–» para disminuir el puntero para devolverlo a la dirección de memoria anterior.
Ejecute este código haciendo clic en la opción «Ejecutar» > «Compilar y ejecutar» y obtendrá el siguiente resultado:
Esperemos que este resultado sea fácil de entender. Las direcciones y valores de la memoria cambian. El puntero solo se puede mover desde una posición mediante aritmética de puntero incremental en C++.
Escenario 2: Restar dos indicadores en C++
En este caso, aprenderemos cómo restar dos o más indicadores en C++. Todas las operaciones aritméticas que implican resta son procedimientos cruciales, ya que podemos restar dos indicadores al mismo tiempo si y sólo si tienen el mismo tipo de datos.
Otras operaciones (como suma, multiplicación y división) no son posibles en punteros porque no tienen significado en el direccionamiento de memoria. El fragmento de código se adjunta a continuación:
maestro de enteros() {
Alá[] = {veintitrés, 36, 42, 51, 62,77,89,96,100};
entero *ptrr1 = &Alá[3]; // puntero al tercer elemento (42)
entero *ptrr2 = &Alá[6]; // puntero al sexto elemento (89)
ptrdiff_t resta de puntero= ptrr2 – ptrr1;
std::cout < «La diferencia entre estas direcciones es:» < resta de puntero < «elemento» < std::endl;
devolver ;
}
La operación de resta en C++ es encontrar la diferencia entre direcciones de memoria. En la función principal, tomamos una matriz que contiene diferentes valores en diferentes índices. En una matriz, cada índice tiene una ubicación de memoria diferente. Sólo podemos encontrar la diferencia entre dos indicadores con la ayuda de la aritmética de indicadores. Aquí usamos el tipo de indicador especial «ptrdiff_t», que debe usarse para encontrar diferencias entre dos o más indicadores en C++.
El resultado de este código se adjunta a continuación:
La diferencia entre estas direcciones se calcula en unidades de elementos, que es 3.
Escenario 3: comparar dos o más punteros en C++
En este caso, aprenderemos cómo comparar diferentes punteros en C++ usando diferentes operadores relacionales como «==», «<=”, “>=»,»<”, ”>«. Podemos compararlos sólo si los punteros apuntan a la misma dirección del elemento de la matriz. Tenga en cuenta que comparar dos tipos diferentes de métricas puede generar un comportamiento indefinido. El fragmento de código relacionado con la comparación de indicadores es el siguiente:
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros()
{
entero arr1[10]={4,7,9,11,14,dieciséis,18,20,Veintidós,25};
entero *puntero1=&Llegada 1[3];
entero *Puntero 2=&Llegada 1[6];
entero *Puntero 3=&Llegada 1[8];
entero *ptr4=&Llegada 1[9];
si(puntero1==ptr2)
{
std::cout<«Los punteros son iguales»<Finalizar;
}
Otros si(Puntero 3<=ptr4)
{
std::cout<«ptr3 es menor o igual que ptr4»<endel;;
}
Otros
{
std::cout<«Los punteros no se comparan en ningún momento»<Finalizar;
}
devolver ;
}
Aquí tomamos una matriz de 10 elementos. Declaramos cuatro punteros que apuntan a diferentes índices de la matriz. Después de eso, comparamos estos cuatro punteros en diferentes condiciones como se muestra en el código proporcionado. En la condición «si», verifique si el puntero «ptr1» es igual al puntero «ptr2» y luego imprima «los punteros son iguales». Cuando tenemos múltiples condiciones, usamos la condición «si no» para verificar si el indicador «ptr3» es menor o igual que el indicador «ptr4». Cuando hayas terminado, haz clic Ejecutar > Compilar y ejecutar opciones.
El resultado de este código se adjunta a continuación:
Muestra condiciones válidas en la pantalla de la consola y sale de la compilación. El indicador «ptr3» contiene un valor menor o igual al valor señalado por el indicador «ptr4».
Escenario 4: uso de aritmética de punteros para mostrar números impares
Aquí veremos cómo asignar memoria dinámicamente para una matriz de números enteros. El fragmento de código relevante para este ejemplo es el siguiente:
#incluir
maestro de enteros() {
entero[] = {1, 12, 33, veinticuatro, 15, Capítulo 776, 71, 18, 29, 50};
entero *ptrr = número;
std::cout < «Números impares en una matriz:»;
para (entero yo = ; I < 10++yo) {
si (*PTRR % 2 != ) {
std::cout < *PTRR < » «;
}
ptrr++;
}
std::cout < std::endl;
devolver ;
}
En la función principal, tomamos una matriz de 10 elementos. Necesitamos un puntero a todos los elementos de la matriz para comprobar si hay números impares en la matriz. En un bucle «for», busque números impares dividiendo el elemento actual de la matriz. Después de verificar un elemento de la matriz, se incrementa el contador del indicador.
Después de ejecutar el código, el resultado se mostrará en la pantalla de la consola como se muestra a continuación:
De esta manera, podemos utilizar operaciones con indicadores para mostrar números impares en la pantalla de la consola.
en conclusión
Lo que concluimos aquí es que la aritmética de indicadores es la herramienta más eficiente para realizar diferentes operaciones en C++. Asegúrese de que el indicador incremente o disminuya el valor de una matriz con el mismo tipo de datos. Podemos utilizar la aritmética de punteros en el lenguaje de programación C++ para comparar los valores de las matrices según sus direcciones de memoria. Con la ayuda de las operaciones del indicador, podemos recorrer fácilmente la matriz y administrar la memoria.
