C Aritmética de punteros

C 指针Punteros en C

Un puntero en C es una dirección representada por un valor numérico. Por lo tanto, puede realizar operaciones aritméticas sobre punteros. Se pueden realizar cuatro operaciones aritméticas con punteros: ++, --, +, -.

Supongamosptres un puntero a entero que apunta a la dirección 1000, es un entero de 32 bits. Realicemos las siguientes operaciones aritméticas sobre este puntero:

ptr++

Después de realizar las operaciones anteriores,ptrapuntará a la posición 1004, porque cada vez que ptr se incrementa, apuntará a la siguiente posición entera, es decir, se desplazará 4 bytes desde la posición actual. Esta operación moverá el puntero a la siguiente posición de memoria sin afectar el valor real en la ubicación de memoria. Siptrapunta a un carácter en la dirección 1000, la operación anterior hará que el puntero apunte a la posición 1001, porque la siguiente posición de carácter está en 1001.

Resumamos:

  • Cada incremento de un puntero hace que apunte a la celda de memoria del siguiente elemento.
  • Cada decremento de un puntero hace que apunte a la celda de memoria del elemento anterior.
  • La cantidad de bytes que salta un puntero al incrementarse o decrementarse depende de la longitud del tipo de dato de la variable a la que apunta; por ejemplo, un int son 4 bytes.

Incrementar un puntero

Incrementar un puntero significa hacer que el puntero apunte a la siguiente posición de memoria.

La operación de incremento de un puntero realiza un desplazamiento de memoria apropiado según el tipo de dato al que apunta.

Nos gusta usar punteros en lugar de arrays en los programas, porque un puntero variable se puede incrementar, mientras que un array no se puede incrementar; un array puede considerarse como una constante de puntero. El siguiente programa incrementa un puntero variable para acceder secuencialmente a cada elemento del array:

, con valor 40

#include <stdio.h> const int MAX = 3; int main () { // Define un array de enteros int var[] = {10, 100, 200}; // Define una variable entera i y un puntero a entero ptr int i, *ptr; // Apunta el puntero ptr a la dirección inicial del array var ptr = var; // Recorre el array en un bucle for ( i = 0; i < MAX; i++) { // Imprime la dirección a la que apunta actualmente el puntero ptr printf("Dirección almacenada: var[%d] = %p\n", i, ptr ); // Imprime el valor de la dirección a la que apunta actualmente el puntero ptr printf("Valor almacenado: var[%d] = %d\n", i, *ptr ); // Mueve el puntero ptr a la posición del siguiente elemento del array ptr++; } return 0; }

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

存储地址：var[0] = e4a298cc
存储值：var[0] = 10
存储地址：var[1] = e4a298d0
存储值：var[1] = 100
存储地址：var[2] = e4a298d4
存储值：var[2] = 200

Incrementar un puntero a carácter:

Ejemplo

#include <stdio.h>

int main() {
    char str[] = "Hello";
    char *ptr = str;  // El puntero apunta al primer carácter de la cadena

    printf("Carácter inicial: %c\n", *ptr);  // Imprime H

    ptr++;  // Incrementa el puntero para que apunte al siguiente carácter
    printf("Carácter tras incrementar: %c\n", *ptr);  // Imprime e

    return 0;
}

En este ejemplo, ptr++ hace que el puntero pase de str

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

初始字符: H
递增后字符: e

Incrementar un puntero a estructura:

Ejemplo

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main() {
    struct Point points[] = {{1, 2}, {3, 4}, {5, 6}};
    struct Point *ptr = points;  // El puntero apunta al primer elemento del array de estructuras

    printf("Punto inicial: (%d, %d)\n", ptr->x, ptr->y);  // Imprime (1, 2)

    ptr++;  // Incrementa el puntero para que apunte a la siguiente estructura
    printf("Punto tras incrementar: (%d, %d)\n", ptr->x, ptr->y);  // Imprime (3, 4)

    return 0;
}

En este ejemplo, ptr++ hace que el puntero pase de points

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

初始点: (1, 2)
递增后点: (3, 4)

Decrementar un puntero

Decrementar un puntero significa hacer que el puntero apunte a la posición de memoria anterior. De manera similar al incremento, la operación de decremento de un puntero también realiza un desplazamiento de memoria apropiado según el tipo de dato al que apunta.

Realizar una operación de decremento sobre un puntero, es decir, restar la cantidad de bytes de su tipo de dato, como se muestra a continuación:

Ejemplo

#include <stdio.h> int main() { int arr[] = {10, 20, 30, 40, 50}; int *ptr = &arr[4]; // El puntero apunta al último elemento del array printf("Valor inicial: %d\n", *ptr); // Imprime 50 ptr--; // Decrementa el puntero para que apunte al elemento entero anterior printf("Valor tras decrementar: %d\n", *ptr); // Imprime 40 ptr--; // Decrementa el puntero nuevamente printf("Valor tras decrementar nuevamente: %d\n", *ptr); // Imprime 30 return 0; }

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

初始值: 50
递减后值: 40
再次递减后值: 30

Decrementar un puntero a carácter:

Ejemplo

#include <stdio.h>

int main() {
    char str[] = "Hello";
    char *ptr = &str[4];  // El puntero apunta al último carácter de la cadena, 'o'

    printf("Carácter inicial: %c\n", *ptr);  // Imprime o

    ptr--;  // Decrementa el puntero para que apunte al carácter anterior
    printf("Carácter tras decrementar: %c\n", *ptr);  // Imprime l

    ptr--;  // Decrementa el puntero nuevamente
    printf("Carácter tras decrementar nuevamente: %c\n", *ptr);  // Imprime l

    return 0;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

初始字符: o
递减后字符: l
再次递减后字符: l

Decrementar un puntero a estructura:

Ejemplo

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main() {
    struct Point points[] = {{1, 2}, {3, 4}, {5, 6}};
    struct Point *ptr = &points[2];  // El puntero apunta al último elemento del array de estructuras

    printf("Punto inicial: (%d, %d)\n", ptr->x, ptr->y);  // Imprime (5, 6)

    ptr--;  // Decrementa el puntero para que apunte a la estructura anterior
    printf("Punto tras decrementar: (%d, %d)\n", ptr->x, ptr->y);  // Imprime (3, 4)

    ptr--;  // Decrementa el puntero nuevamente
    printf("Punto tras decrementar nuevamente: (%d, %d)\n", ptr->x, ptr->y);  // Imprime (1, 2)

    return 0;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

初始点: (5, 6)
递减后点: (3, 4)
再次递减后点: (1, 2)

Comparación de punteros

En C, se pueden comparar punteros para determinar su relación. La comparación de punteros se utiliza principalmente para determinar si dos punteros apuntan a la misma posición de memoria o si un puntero está antes o después de otro.

Los punteros se pueden comparar con operadores relacionales, como==、!=、<、>、<=y>=. Si p1 y p2 apuntan a dos variables relacionadas, como diferentes elementos del mismo array, entonces se pueden comparar p1 y p2.

A continuación se muestran algunos ejemplos de código que demuestran cómo comparar punteros y mostrar los resultados.

Comparación de igualdad de punteros:

Ejemplo

#include <stdio.h> int main() { int a = 5; int b = 10; int *ptr1 = &a; int *ptr2 = &a; int *ptr3 = &b; if (ptr1 == ptr2) { printf("ptr1 y ptr2 apuntan a la misma dirección de memoria\n"); // Esta línea se imprimirá } else { printf("ptr1 y ptr2 apuntan a direcciones de memoria diferentes\n"); } if (ptr1 != ptr3) { printf("ptr1 y ptr3 apuntan a direcciones de memoria diferentes\n"); // Esta línea se imprimirá } else { printf("ptr1 y ptr3 apuntan a la misma dirección de memoria\n"); } return 0; }

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

ptr1 和 ptr2 指向相同的内存地址
ptr1 和 ptr3 指向不同的内存地址

Comparación de tamaño de punteros:

Ejemplo

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr1 = &arr[1];  // Apunta a arr
    int *ptr2 = &arr[3];  // Apunta a arr

    if (ptr1 < ptr2) {
        printf("ptr1 está antes que ptr2\n");  // Esta línea se imprimirá
    } else {
        printf("ptr1 está después de ptr2 o en la misma posición\n");
    }

    if (ptr1 > ptr2) {
        printf("ptr1 está después de ptr2\n");
    } else {
        printf("ptr1 está antes de ptr2 o en la misma posición\n");  // Esta línea se imprimirá
    }

    return 0;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

ptr1 在 ptr2 之前
ptr1 在 ptr2 之前或相同位置

Recorrer un array y comparar punteros:

Ejemplo

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *start = arr;           // Apunta al primer elemento del array
    int *end = &arr[4];         // Apunta al último elemento del array
    int *ptr;

    for (ptr = start; ptr <= end; ptr++) {
        printf("Valor al que apunta actualmente el puntero: %d\n", *ptr);
    }

    return 0;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

当前指针指向的值: 10
当前指针指向的值: 20
当前指针指向的值: 30
当前指针指向的值: 40
当前指针指向的值: 50

Resumen

  • Comparación de igualdad (==y!=): se utiliza para determinar si dos punteros apuntan a la misma posición de memoria.
  • Comparación de tamaño (<, >, <=, >=): normalmente se utiliza al recorrer arrays o bloques de memoria con punteros, para determinar si un puntero está antes o después de otro.
Es importante tener en cuenta que la comparación de punteros solo tiene sentido cuando apuntan al mismo array o al mismo bloque de memoria; de lo contrario, el comportamiento no está definido.

C 指针Punteros en C

Otras extensiones