Las variables de puntero también se conocen como tipos de datos de dirección porque se utilizan para almacenar la dirección de otra variable. La dirección es la ubicación de memoria que se asigna a la variable. No almacena ningún valor.
Por lo tanto, solo hay unas pocas operaciones que se permiten realizar en punteros en lenguaje C. Las operaciones son ligeramente diferentes de las que generalmente usamos para cálculos matemáticos. Las operaciones son:
- Incremento/Decremento de un puntero
- Adición de entero a un puntero
- Resta de entero a un puntero
- Restar dos punteros del mismo tipo
- Comparación de punteros del mismo tipo.
Incremento/Decremento de un puntero
Incremento: Es una condición que también entra en la suma. Cuando se incrementa un puntero, en realidad se incrementa en un número igual al tamaño del tipo de datos para el que es un puntero.
Por ejemplo:
si se incrementa un puntero de número entero que almacena la dirección 1000 , se incrementará en 2 ( tamaño de un int ) y la nueva dirección apuntará a 1002 . Mientras que si se incrementa un puntero de tipo flotante, se incrementará en 4 ( tamaño de un flotante ) y la nueva dirección será 1004 .
Decremento: Es una condición que también entra en la sustracción. Cuando se reduce un puntero, en realidad se reduce en un número igual al tamaño del tipo de datos para el que es un puntero.
Por ejemplo: si se reduce
un puntero de número entero que almacena la dirección 1000 , se reducirá en 2 ( tamaño de un int ) y la nueva dirección apuntará a 998 . Mientras que si se reduce un puntero de tipo flotante, disminuirá en 4 ( tamaño de un flotante ) y la nueva dirección será 996 .
A continuación se muestra el programa para ilustrar el incremento/decremento del puntero:
C
// C program to illustrate
// pointer increment/decrement
#include <stdio.h>
// Driver Code
int main()
{
// Integer variable
int N = 4;
// Pointer to an integer
int *ptr1, *ptr2;
// Pointer stores
// the address of N
ptr1 = &N;
ptr2 = &N;
printf("Pointer ptr1 "
"before Increment: ");
printf("%p \n", ptr1);
// Incrementing pointer ptr1;
ptr1++;
printf("Pointer ptr1 after"
" Increment: ");
printf("%p \n\n", ptr1);
printf("Pointer ptr1 before"
" Decrement: ");
printf("%p \n", ptr1);
// Decrementing pointer ptr1;
ptr1--;
printf("Pointer ptr1 after"
" Decrement: ");
printf("%p \n\n", ptr1);
return 0;
}
Pointer ptr1 before Increment: 0x7ffefa9c5704 Pointer ptr1 after Increment: 0x7ffefa9c5708 Pointer ptr1 before Decrement: 0x7ffefa9c5708 Pointer ptr1 after Decrement: 0x7ffefa9c5704
Suma
Cuando se agrega un puntero con un valor, el valor primero se multiplica por el tamaño del tipo de datos y luego se agrega al puntero.
C
// C program to illustrate pointer Addition
#include <stdio.h>
// Driver Code
int main()
{
// Integer variable
int N = 4;
// Pointer to an integer
int *ptr1, *ptr2;
// Pointer stores the address of N
ptr1 = &N;
ptr2 = &N;
printf("Pointer ptr2 before Addition: ");
printf("%p \n", ptr2);
// Addition of 3 to ptr2
ptr2 = ptr2 + 3;
printf("Pointer ptr2 after Addition: ");
printf("%p \n", ptr2);
return 0;
}
Pointer ptr2 before Addition: 0x7fffc22348a4 Pointer ptr2 after Addition: 0x7fffc22348b0
Sustracción
Cuando se resta un puntero con un valor, el valor primero se multiplica por el tamaño del tipo de datos y luego se resta del puntero.
A continuación se muestra el programa para ilustrar la resta de puntero:
C
// C program to illustrate pointer Subtraction
#include <stdio.h>
// Driver Code
int main()
{
// Integer variable
int N = 4;
// Pointer to an integer
int *ptr1, *ptr2;
// Pointer stores the address of N
ptr1 = &N;
ptr2 = &N;
printf("Pointer ptr2 before Subtraction: ");
printf("%p \n", ptr2);
// Subtraction of 3 to ptr2
ptr2 = ptr2 - 3;
printf("Pointer ptr2 after Subtraction: ");
printf("%p \n", ptr2);
return 0;
}
Pointer ptr2 before Subtraction: 0x7ffcbed44ee4 Pointer ptr2 after Subtraction: 0x7ffcbed44ed8
Resta de dos punteros
La resta de dos punteros solo es posible cuando tienen el mismo tipo de datos. El resultado se genera calculando la diferencia entre las direcciones de los dos punteros y calculando cuántos bits de datos hay según el tipo de datos del puntero. La resta de dos punteros da los incrementos entre los dos punteros.
Por ejemplo:
se restan dos punteros enteros que dicen ptr1 (dirección: 1000) y ptr2 (dirección: 1016) . La diferencia entre direcciones es de 16 bytes. Dado que el tamaño de int es de 2 bytes, el incremento entre ptr1 y ptr2 viene dado por (16/2) = 8 .
A continuación se muestra la implementación para ilustrar la resta de dos punteros:
C
// C program to illustrate Subtraction
// of two pointers
#include <stdio.h>
// Driver Code
int main()
{
int x;
// Integer variable
int N = 4;
// Pointer to an integer
int *ptr1, *ptr2;
// Pointer stores the address of N
ptr1 = &N;
ptr2 = &N;
// Incrementing ptr2 by 3
ptr2 = ptr2 + 3;
// Subtraction of ptr2 and ptr1
x = ptr2 - ptr1;
// Print x to get the Increment
// between ptr1 and ptr2
printf("Subtraction of ptr1 "
"& ptr2 is %d\n",
x);
return 0;
}
Subtraction of ptr1 & ptr2 is 3
Aritmética de punteros en arrays: los
punteros contienen direcciones. Agregar dos direcciones no tiene sentido porque no hay idea de a qué apuntaría. Restar dos direcciones le permite calcular el desplazamiento entre las dos direcciones. Un nombre de array actúa como una constante de puntero. El valor de esta constante de puntero es la dirección del primer elemento. Por ejemplo: si una array se llama arr, arr y &arr[0] se pueden usar para hacer referencia a la array como un puntero.
A continuación se muestra el programa para ilustrar la aritmética de punteros en arrays:
Programa 1:
C
// C program to illustrate the array
// traversal using pointers
#include <stdio.h>
// Driver Code
int main()
{
int N = 5;
// An array
int arr[] = { 1, 2, 3, 4, 5 };
// Declare pointer variable
int* ptr;
// Point the pointer to first
// element in array arr[]
ptr = arr;
// Traverse array using ptr
for (int i = 0; i < N; i++) {
// Print element at which
// ptr points
printf("%d ", ptr[0]);
ptr++;
}
}
1 2 3 4 5
Programa 2:
C
// C program to illustrate the array
// traversal using pointers in 2D array
#include <stdio.h>
// Function to traverse 2D array
// using pointers
void traverseArr(int* arr,
int N, int M)
{
int i, j;
// Traverse rows of 2D matrix
for (i = 0; i < N; i++) {
// Traverse columns of 2D matrix
for (j = 0; j < M; j++) {
// Print the element
printf("%d ", *((arr + i * M) + j));
}
printf("\n");
}
}
// Driver Code
int main()
{
int N = 3, M = 2;
// A 2D array
int arr[][2] = { { 1, 2 },
{ 3, 4 },
{ 5, 6 } };
// Function Call
traverseArr((int*)arr, N, M);
return 0;
}
1 2 3 4 5 6
Comparación de punteros del mismo tipo:
Podemos comparar los dos punteros usando los operadores de comparación en C. Podemos implementar esto usando todos los operadores en C >, >=, <, <=, ==, !=. Devuelve verdadero para la condición válida y devuelve falso para la condición insatisfecha.
Paso 1: inicialice los valores enteros y apunte estos valores enteros al puntero.
Paso 2: ahora, verifique la condición usando operadores de comparación o relacionales en variables de puntero.
Paso 3: Mostrar la salida.
C
#include <stdio.h>
int main() {
// code
int num1=5,num2=6,num3=5; //integer input
int *p1=&num1;// addressing the integer input to pointer
int *p2=&num2;
int *p3=&num3;
//comparing the pointer variables.
if(*p1<*p2)
{
printf("\n%d less than %d",*p1,*p2);
}
if(*p2>*p1)
{
printf("\n%d greater than %d",*p2,*p1);
}
if(*p3==*p1)
{
printf("\nBoth the values are equal");
}
if(*p3!=*p2)
{
printf("\nBoth the values are not equal");
}
return 0;
}
5 less than 6 6 greater than 5 Both the values are equal Both the values are not equal
Operadores de comparación en punteros usando array:
En el siguiente enfoque, resulta el conteo de números pares e impares en una array. Vamos a implementar esto usando un puntero.
Paso 1: Primero, declare la longitud de una array y los elementos de la array.
Paso 2: Declare la variable puntero y apúntela al primer elemento de una array.
Paso 3:Inicialice count_even y count_odd. Itere el ciclo for y verifique las condiciones para el número de elementos impares y elementos pares en una array,
Paso 4: Incremente la ubicación del puntero ptr++ al siguiente elemento en una array para una mayor iteración.
Paso 5: Imprime el resultado.
C
#include <stdio.h>
int main()
{
int n = 10; // length of an array
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int* ptr; // Declaration of pointer variable
ptr = arr; // Pointer points the first (0th index)
// element in an array
int count_even = 0;
int count_odd = 0;
for (int i = 0; i < n; i++) {
if (*ptr % 2 == 0) {
count_even++;
}
if (*ptr % 2 != 0) {
count_odd++;
}
ptr++; // Pointing to the next element in an array
}
printf("\n No of even elements in an array is : %d",
count_even);
printf("\n No of odd elements in an array is : %d",
count_odd);
}
No of even elements in an array is : 5 No of odd elements in an array is : 5
Publicación traducida automáticamente
Artículo escrito por vishalraina y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA