Tutorial de Programação em C no Linux Parte 20 - Aritmética de Endereço de Ponteiro

No nosso tutorial anterior nesta série contínua de Programação em C, discutimos ponteiros em um pouco mais de detalhe. Estendendo essa discussão, aqui estamos com alguns conceitos dignos de discussão relacionados a ponteiros. Então, sem mais delongas, vamos começar.

Aritmética de endereço de ponteiro em C

Primeiramente, vamos nos concentrar na aritmética de endereço ao lidar com ponteiros. Como discutimos em nosso tutorial anterior, se você tem um ponteiro apontando para um array (digamos o início dele), é muito fácil acessar os elementos desse array. Aqui está um exemplo:

#include   
  
int main()  
{  
    char arr[]={'a','b','c','d'};  
    int a[]={1,2,3,4};  
   
    char *ptr = arr;  
    int *p = a;  
   
    for(int i=0; i

Então, neste código, temos dois arrays - ‘arr’ e ‘a’. Enquanto o primeiro é um array de caracteres, o segundo é um array de inteiros. Então temos dois ponteiros apontando para esses arrays - ‘ptr’ e ‘p’, respectivamente. Depois, há alguns loops ‘for’ onde imprimimos o endereço atual para o qual o ponteiro está apontando e o valor contido nesse endereço.

Aqui está a saída deste código na minha máquina:

 Ponteiro de caractere apontando para 726409312, com valor a   
 Ponteiro de caractere apontando para 726409313, com valor b   
 Ponteiro de caractere apontando para 726409314, com valor c   
 Ponteiro de caractere apontando para 726409315, com valor d   
 Ponteiro inteiro apontando para 726409296, com valor 1   
 Ponteiro inteiro apontando para 726409300, com valor 2   
 Ponteiro inteiro apontando para 726409304, com valor 3   
 Ponteiro inteiro apontando para 726409308, com valor 4

Agora, o que é notável aqui são os endereços impressos na saída. Para o array de caracteres, adicionar ‘1’ ao ponteiro o incrementou para o próximo endereço, mas para um array de inteiros, adicionar ‘1’ ao ponteiro fez com que ele pulasse 4 endereços à frente. Por que isso acontece?

Bem, tudo depende do tipo de ponteiro. Um ponteiro de caractere sempre pula o número de bytes que um caractere ocupa, que geralmente é 1. Da mesma forma, um ponteiro para um inteiro geralmente pula 4 bytes quando incrementado em 1. Portanto, isso deve explicar a diferença nos saltos de ponteiros de caracteres e inteiros na saída acima.

Seguindo com a aritmética de ponteiros, os ponteiros podem ser usados em expressões de comparação em casos selecionados. Por exemplo, se você quiser confirmar se um ponteiro ‘ptr’ aponta para um elemento de um array ‘arr’ (tamanho ‘size’), então você pode fazer a comparação da seguinte maneira:

if((ptr >= arr) && (ptr < (arr + size))) 

Assim, efetivamente, a expressão acima verifica se o endereço mantido pelo ponteiro é de um de seus elementos.

Além disso, se houver múltiplos ponteiros apontando para elementos do mesmo array, você pode usar os seguintes operadores de comparação ==, !=, <, e >=. Na verdade, você também pode realizar a subtração de ponteiros nesses casos. Aqui está um exemplo:

#include   
  
int main()  
{  
    char arr[]= "Bem-vindo ao HowtoForge";  
   
    char *ptr = arr;  
    char *p = arr;  
   
    while(*p != '\0')  
   {  
      p++;  
   }  
   
   printf("\n O comprimento da string é %d", (p - ptr));  
   
   return 0;  
}

Assim, neste programa, garantimos que um ponteiro aponta para o primeiro elemento do array, enquanto o segundo ponteiro é continuamente incrementado até que aponte para o último elemento (que é ‘\0’ em strings constantes).

Então, dado o fato de que estamos lidando com caracteres aqui (que ocupam um byte cada), ao subtrair o endereço apontado pelo primeiro ponteiro do que é apontado pelo segundo ponteiro, conseguimos encontrar o número de caracteres, que se você observar é o comprimento exato da string.

NOTA: Tenha em mente que operações como adição, multiplicação, divisão e mais são inválidas quando se trata de ponteiros. Além disso, o tipo de operações aceitáveis que listamos até agora também é válido apenas quando os ponteiros são do mesmo tipo e estão apontando para elementos do mesmo array.

Conclusão

Após discutir conceitos básicos de ponteiros no tutorial anterior, ampliamos o conceito de ponteiros discutindo a aritmética de endereço de ponteiro aqui. Sugerimos que você pratique tudo o que discutimos aqui em sua máquina na forma de programas. E caso tenha alguma dúvida ou pergunta, não hesite em deixar um comentário abaixo.