Intercambio de números con punteros

Introducción

En la programación en C, los punteros son características poderosas que nos permiten manipular datos accediendo y modificando directamente las ubicaciones de memoria. Una aplicación común de los punteros es intercambiar valores entre dos variables sin utilizar una tercera variable.

En este laboratorio (lab), aprenderemos cómo crear un programa en C que intercambia dos números utilizando punteros. Esta técnica es fundamental en diversos escenarios de programación y demuestra el uso práctico de los punteros para la manipulación de memoria.

El laboratorio te guiará a través de la creación de un programa desde cero, su compilación y ejecución para ver el intercambio en acción.

Skills Graph

Comprender los punteros en C

Antes de comenzar a codificar, entendamos qué son los punteros y cómo funcionan en C.

¿Qué es un puntero?

Un puntero es una variable que almacena la dirección de memoria de otra variable. Los punteros son esenciales en C porque permiten el acceso directo a la memoria y facilitan una manipulación más eficiente de los datos.

Sintaxis de los punteros

En C, los punteros se declaran utilizando el asterisco (*) como símbolo:

int *ptr;    // Declares a pointer to an integer

Cuando se trabaja con punteros, se utilizan dos operadores importantes:

• El operador de dirección (&) - obtiene la dirección de memoria de una variable
• El operador de desreferenciación (*) - accede al valor almacenado en la dirección que contiene un puntero

Creando nuestro primer archivo

Comencemos creando nuestro archivo principal de C en el directorio del proyecto. Abra el IDE y cree un nuevo archivo llamado main.c:

1. En el panel del explorador de archivos (lado izquierdo), navegue hasta /home/labex/project
2. Haga clic derecho y seleccione "Nuevo archivo"
3. Nombre el archivo main.c
4. Agregue la siguiente estructura básica al archivo:

#include <stdio.h>

int main() {
    // We will add our code here

    return 0;
}

Esto crea un simple programa en C con la biblioteca estándar de entrada/salida incluida y una función principal que devuelve 0 cuando el programa se completa con éxito.

Creando la estructura del programa de intercambio

Ahora que entendemos los punteros, construyamos nuestro programa de intercambio paso a paso.

Declarando variables y punteros

Necesitamos declarar:

1. Dos variables enteras (a y b) para almacenar los valores que queremos intercambiar
2. Dos punteros enteros (ptra y ptrb) para almacenar las direcciones de a y b
3. Una variable temporal (temp) para ayudar con la operación de intercambio

Actualice su archivo main.c con el siguiente código:

#include <stdio.h>

int main() {
    // Declare variables
    int a, b;
    int *ptra, *ptrb;
    int temp;

    // Get input from user
    printf("Enter value for a: ");
    scanf("%d", &a);

    printf("Enter value for b: ");
    scanf("%d", &b);

    // Display original values
    printf("\nOriginal values:\n");
    printf("a = %d\n", a);
    printf("b = %d\n", b);

    // We will add more code here in the next step

    return 0;
}

Comprendiendo el código

Analicemos lo que hemos hecho hasta ahora:

1. Declaramos dos enteros a y b que almacenarán los valores que queremos intercambiar
2. Declaramos dos punteros enteros ptra y ptrb que almacenarán las direcciones de memoria de a y b
3. Declaramos un entero temporal temp que nos ayudará con la operación de intercambio
4. Añadimos código para solicitar al usuario que ingrese valores para a y b
5. Añadimos código para mostrar los valores originales de a y b

Note que en la función scanf, usamos el operador de dirección (&) para indicar a la función dónde almacenar los valores de entrada en memoria.

Implementando la lógica de intercambio

Ahora implementemos la lógica real de intercambio utilizando punteros.

Asignando direcciones a punteros

Primero, necesitamos hacer que nuestros punteros apunten a nuestras variables asignando las direcciones de a y b a ptra y ptrb respectivamente:

// Assign addresses to pointers
ptra = &a;
ptrb = &b;

El algoritmo de intercambio utilizando punteros

La clave para intercambiar valores con punteros es manipular los valores en las ubicaciones de memoria, no solo los punteros en sí. Así es como lo haremos:

1. Almacenar el valor de a (accedido a través de *ptra) en la variable temporal temp
2. Asignar el valor de b (accedido a través de *ptrb) a a (utilizando *ptra)
3. Asignar el valor temporal (valor original de a) a b (utilizando *ptrb)

Actualice su archivo main.c agregando el siguiente código donde se indicó en el paso anterior:

#include <stdio.h>

int main() {
    // Declare variables
    int a, b;
    int *ptra, *ptrb;
    int temp;

    // Get input from user
    printf("Enter value for a: ");
    scanf("%d", &a);

    printf("Enter value for b: ");
    scanf("%d", &b);

    // Display original values
    printf("\nOriginal values:\n");
    printf("a = %d\n", a);
    printf("b = %d\n", b);

    // Assign addresses to pointers
    ptra = &a;
    ptrb = &b;

    // Display memory addresses (optional but helpful for understanding)
    printf("\nMemory addresses:\n");
    printf("Address of a: %p\n", ptra);
    printf("Address of b: %p\n", ptrb);

    // Swap the values using pointers
    temp = *ptra;    // Store value of a in temp
    *ptra = *ptrb;   // Assign value of b to a
    *ptrb = temp;    // Assign original value of a to b

    // Display swapped values
    printf("\nAfter swapping:\n");
    printf("a = %d\n", a);
    printf("b = %d\n", b);

    return 0;
}

Comprendiendo la lógica de intercambio

Comprendamos exactamente cómo funciona el intercambio:

1. temp = *ptra; - El operador * desreferencia el puntero, accediendo al valor en la ubicación de memoria. Esta línea almacena el valor de a en temp.
2. *ptra = *ptrb; - Esto asigna el valor de b a la ubicación de memoria de a, cambiando efectivamente el valor de a.
3. *ptrb = temp; - Esto asigna el valor original de a (almacenado en temp) a la ubicación de memoria de b, completando el intercambio.

Después de estas operaciones, las variables a y b han intercambiado valores sin modificarlas directamente; solo modificamos los valores en sus ubicaciones de memoria.

Compilando y probando el programa de intercambio

Ahora que hemos completado nuestro programa, compilémoslo y ejecutémoslo para ver los resultados.

Compilando el programa

Para compilar el programa, usaremos el compilador GNU C (gcc). Abra una terminal en el WebIDE y ejecute el siguiente comando:

cd ~/project
gcc main.c -o swap_program

Este comando compila nuestro archivo main.c y crea un ejecutable llamado swap_program.

Ejecutando el programa

Ahora ejecutemos nuestro programa para ver si intercambia correctamente los valores:

./swap_program

Se le pedirá que ingrese valores para a y b. Por ejemplo, ingresemos:

• a = 5
• b = 10

El programa debe mostrar:

• Los valores originales: a = 5, b = 10
• Las direcciones de memoria de a y b
• Los valores intercambiados: a = 10, b = 5

Comprendiendo la salida

Cuando ejecute el programa, verá varias secciones de salida:

1. Valores originales - Muestra los valores antes del intercambio
2. Direcciones de memoria - Muestra dónde se almacenan las variables en memoria (serán diferentes cada vez que ejecute el programa)
3. Después del intercambio - Muestra los valores después de la operación de intercambio

Intente ejecutar el programa varias veces con diferentes valores de entrada para confirmar que el intercambio funciona de manera consistente.

¿Cómo funciona detrás de escena?

Visualicemos lo que sucede en memoria:

1. Inicialmente, si a = 5 y b = 10, cada una tiene su propia ubicación de memoria
2. ptra apunta a la ubicación de memoria de a
3. ptrb apunta a la ubicación de memoria de b
4. Durante el intercambio:
   • temp obtiene el valor en ptra (que es 5)
   • El valor en ptra se cambia al valor en ptrb (que es 10)
   • El valor en ptrb se cambia a temp (que es 5)
5. Después del intercambio, a = 10 y b = 5, intercambiando efectivamente sus valores

Esto demuestra el poder de los punteros: nos permiten modificar indirectamente valores manipulando directamente las ubicaciones de memoria.

Resumen

En este laboratorio, aprendimos cómo usar punteros en C para intercambiar los valores de dos variables. Los conceptos clave cubiertos incluyen:

1. Punteros: Variables que almacenan las direcciones de memoria de otras variables
2. Direcciones de memoria: Ubicaciones únicas en la memoria de la computadora donde se almacenan los datos
3. Operaciones con punteros:
   • El operador de dirección (&) para obtener la dirección de memoria de una variable
   • El operador de desreferenciación (*) para acceder al valor en una dirección de memoria
4. Algoritmo de intercambio: Utilizar una variable temporal y punteros para intercambiar valores

Esta técnica es un concepto fundamental en la programación en C y demuestra el poder de los punteros para la manipulación de memoria. Puede aplicarse en diversos escenarios de programación, como algoritmos de ordenamiento, operaciones de estructuras de datos e implementaciones de funciones.

Al entender cómo manipular datos a través de direcciones de memoria, has dado un paso importante en el dominio de la programación en C y de los conceptos de memoria de computadora.