Funciones, Arrays y Dos Punteros

Funciones con Punteros

Experimentemos con una función básica para modificar el valor de nuestros datos. Por ejemplo, imaginemos que necesitamos una función que convierta kilo-Ohmios a Ohmios (1 kOhm = 1000 Ohm).

Main


              12345678910111213141516171819
            
#include <stdio.h>

void Ohm(double R)
{
    R = R * 1000;
}

int main()
{
    double r = 1.5; // kOhm
  
    printf("The value of resistance before using function: %f\n", r);

    Ohm(r);

    printf("The value of resistance after using function: %f", r);

    return 0;
}

Nuestro intento de cambiar el valor de la variable r no tuvo éxito. Esto se debe a que la función recibe una copia de la variable r, no el valor real.

Para que nuestro programa funcione como es debido, necesitamos pasar la dirección de la variable r a la función. Como resultado, la función Ohm debería aceptar double* en lugar de sólo double.

Main


              1234567891011121314151617181920
            
#include <stdio.h>

void Ohm(double* R)
{
    // dereferencing the entered address and changing the object it points to
    *R = *R * 1000;
}

int main()
{
    double r = 1.5; // kOhm

    printf("The value of resistance before using function: %f\n", r);

    Ohm(&r);

    printf("The value of resistance after using function: %f\n", r);

    return 0;
}

Observa que hacemos referencia a la variable r dos veces. Después de invocar la función Ohm, el valor de r es alterado. Esto se debe a que la función recibió la dirección original de la variable r, no una mera copia, y luego modificó el valor en esa dirección en particular.

Además, una función puede devolver un puntero a un objeto que ha generado:

Main


              1234567891011121314151617181920
            
#include <stdio.h>
#include <stdlib.h>

int* func()
{
    int* x = (int*)malloc(sizeof(int));

    printf("Address into function: %p\n", x);

    return x;
}

int main()
{
    int* pointerToFunc = func();

    printf("Address after using function: %p\n", pointerToFunc);
   
    return 0;
}

¿Son las Arrays Meros Punteros?

¿Qué crees que ocurrirá si se añade un número a una dirección?

Main


              123456789101112
            
#include <stdio.h>

int main()
{
    int x = 100;

    int* pX = &x;

    printf("Address: %p | Adress + 1: %p", pX, pX + 1);

    return 0;
}

Cuando se añade un número (pX + 1) a una dirección, se obtiene la dirección de la celda de memoria siguiente.

Guionicemos un loop para navegar por la "secuencia" de RAM:

Main


              1234567891011
            
#include <stdio.h>

int main()
{
    int* pX = NULL; // pointer to `int` type (4 bites)

    for (int i = 0; i < 3; i++)
        printf("Address: %p\n", pX + i);

    return 0;
}

Hemos proyectado tres pasos adelante. De las direcciones derivadas se desprende que hay una jerarquía clara.

Dado que el tipo int ocupa 4 bytes, avanzamos 4 bytes en cada paso ¡Este comportamiento recuerda mucho al de una array!

Parece que un array es esencialmente una dirección fija (representada por el nombre del array) unida a una memoria asignada. ¡Los índices de los elementos representan su desplazamiento desde la dirección del elemento inicial!

Esta noción se puede validar con el siguiente programa:

Main


              12345678910111213
            
#include <stdio.h>

int main()
{
    int array[] = {1,2,3,4,5};

    printf("Address of array: %p\n", array);

    for(int i = 0; i < 5; i++)
        printf("Value: %d | Address of element with index %d: %p\n", *(array + i), i , &array[i]);

    return 0;
}

Como se ha observado, no recorremos directamente el array. Únicamente utilizamos su dirección, concretamente la dirección de su elemento inicial.

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 6. Capítulo 5