Funções, arrays e dois ponteiros

Funções com ponteiros

Vamos experimentar uma função básica para modificar o valor dos nossos dados. Por exemplo, imagine que você precisa de uma função que converte Quilohms em Ohms (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;
}

A nossa tentativa de alterar o valor da variável r não foi bem-sucedida. Isso ocorre porque a função recebe uma cópia da variável r, não o valor real em si.

Para fazer com que nosso programa funcione conforme o planejado, precisamos passar o endereço da variável r para a função. Como resultado, a função Ohm deve aceitar double* em vez de apenas 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;
}

Observe que referenciamos a variável r duas vezes. Após invocar a função Ohm, o valor de r é alterado. Isso ocorre porque a função recebeu o endereço original da variável r, e não uma simples cópia, e então modificou o valor naquele endereço específico.

Além disso, uma função pode retornar um ponteiro para um objeto que ela gerou:

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;
}

Os arrays são apenas ponteiros?

O que você acha que acontecerá se um número for adicionado a um endereço?

Main


              123456789101112
            
#include <stdio.h>

int main()
{
    int x = 100;

    int* pX = &x;

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

    return 0;
}

Quando um número (pX + 1) é adicionado a um endereço, ele resulta no endereço da célula de memória subsequente!

Vamos escrever um loop para navegar na "sequência" da 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;
}

Projecionamos três passos à frente. É evidente a partir dos endereços derivados que há uma clara hierarquia.

Dado que o tipo int ocupa 4 bytes, avançamos 4 bytes a cada passo. Este comportamento é surpreendentemente semelhante ao de um array!

Parece que um array é essencialmente um endereço fixo (representado pelo nome do array) em conjunto com memória alocada. Os índices dos elementos representam o deslocamento a partir do endereço do elemento inicial!

Essa noção pode ser validada com o seguinte 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 observado, nós não percorremos diretamente através do array. Utilizamos apenas o seu endereço, especificamente o endereço do seu elemento inicial.

Tudo estava claro?

Seção 6. Capítulo 5