Aprenda Funções, Arrays e Dois Ponteiros

Funções com Ponteiros

Vamos experimentar com uma função básica para modificar o valor dos nossos dados. Por exemplo, imagine que você precisa de uma função que converta kilo-Ohms em Ohms (1 kOhm = 1000 Ohm).

Main.c


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

Uma 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, e não o valor real em si.

Para que nosso programa funcione conforme o esperado, é necessário 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.c


              1234567891011121314151617
            
#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 a variável r é referenciada duas vezes. Após a chamada da função Ohm, o valor de r é modificado. Isso ocorre porque a função recebeu o endereço original da variável r, e não apenas uma cópia, e então alterou o valor nesse endereço específico.

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

Main.c


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

Quando um número (pX + 1) é adicionado a um endereço, ele resulta no endereço da próxima célula de memória! Vamos criar um loop para navegar pela "sequência" da RAM:

Main.c


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

Você projetou três passos à frente. É evidente, a partir dos endereços derivados, que existe uma hierarquia clara.

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

Essa noção pode ser validada com o seguinte programa:

Main.c


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

Você não percorre diretamente o array. Utiliza-se apenas o endereço dele, especificamente o endereço do seu elemento inicial.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 6. Capítulo 5

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Suggested prompts:

Can you explain how passing by address differs from passing by value in functions?

Could you show an example of how to use pointers to modify an array in a function?

What happens if I try to access memory outside the bounds of an array using pointers?

Deslize para mostrar o menu

Funções com Ponteiros

Vamos experimentar com uma função básica para modificar o valor dos nossos dados. Por exemplo, imagine que você precisa de uma função que converta kilo-Ohms em Ohms (1 kOhm = 1000 Ohm).

Main.c


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

Uma 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, e não o valor real em si.

Main.c


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

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

Main.c


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

Quando um número (pX + 1) é adicionado a um endereço, ele resulta no endereço da próxima célula de memória! Vamos criar um loop para navegar pela "sequência" da RAM:

Main.c


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

Você projetou três passos à frente. É evidente, a partir dos endereços derivados, que existe uma hierarquia clara.

Essa noção pode ser validada com o seguinte programa:

Main.c


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

Você não percorre diretamente o array. Utiliza-se apenas o endereço dele, especificamente o endereço do seu elemento inicial.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 6. Capítulo 5