• Aritmética de ponteiros em C refere-se às operações matemáticas que podem ser realizadas em ponteiros para acessar diferentes posições de memória. Essas operações são particularmente úteis quando se trabalha com arrays, estruturas de dados e alocação dinâmica de memória. No entanto, a aritmética de ponteiros requer cuidado para evitar acessos indevidos à memória e comportamento indefinido.

• A aritmética de ponteiros depende do tipo base do ponteiro sendo possível apenas a utilização de adição e subtração, sem multiplicações e divisões.

• Cada vez que um ponteiro é incrementado, ele aponta para a posição de memória do próximo elemento do seu tipo base e cada vez que for decrementado, aponta para a posição anterior:

  ++p; //Pré-incrementa o valor do ponteiro;
  
  --p; //Pré-decrementa o valor do ponteiro;
  
  p++; //Pós-incrementa o valor do ponteiro;
  
  p--; //Pós-decrementa o valor do ponteiro;
  
  p+i; //Soma de um ponteiro com um inteiro;
  
  p-i; //Subtração de um inteiro sobre o ponteiro;
  

• Em C, as operações básicas de aritmética de ponteiros são:

  1. Incremento e Decremento:

     1. Você pode incrementar e decrementar um ponteiro para mover-se para posições de memória adjacentes. Isso é útil, por exemplo, para percorrer arrays ou estruturas de dados.

     int array[5] = {10, 20, 30, 40, 50};
     int *ponteiro = array;
     
     ponteiro++;  // move para o próximo elemento do array
     

  2. Adição e Subtração:

     1. Você pode adicionar ou subtrair um valor inteiro a um ponteiro para mover-se por múltiplos elementos do mesmo tipo.

     int *ponteiro = &array[2];
     ponteiro = ponteiro + 2;  // move dois elementos à frente
     

  3. Diferença entre Ponteiros:

     1. A diferença entre dois ponteiros que apontam para elementos de um mesmo array ou bloco de memória é um valor inteiro que indica quantos elementos separam os ponteiros.

     int *ponteiro1 = &array[1];
     int *ponteiro2 = &array[4];
     int diferenca = ponteiro2 - ponteiro1;  // diferença é 3 posições
     

  4. Acesso a Elementos de Arrays:

     1. Ponteiros também podem ser usados para acessar elementos de arrays diretamente usando a notação de aritmética de ponteiros.

     int *ponteiro = array;
     int valor = *(ponteiro + 3);  // acessa o quarto elemento (40)
     

• É importante ter em mente algumas considerações ao usar a aritmética de ponteiros:

  • Não é possível realizar todas as operações aritméticas em todos os tipos de ponteiros. As operações são permitidas somente com tipos que têm tamanho fixo, como inteiros ou ponteiros para elementos de um array;
  • Aritmética de ponteiros fora dos limites válidos de um array pode resultar em comportamento indefinido, o que pode levar a falhas no programa;
  • O valor resultante de uma operação de aritmética de ponteiros ainda é um ponteiro que aponta para uma localização de memória válida;
  • Aritmética de ponteiros não deve ser usada para acessar memória que não tenha sido alocada explicitamente para o seu programa;
  • Há uma única exceção ao uso legal de aritmética de ponteiros: quando um ponteiro é definido para o tipo void. Neste caso, a variável ponteiro contém um endereço genérico, sobre um tipo que não pode ser determinado. Portanto, operações aritméticas sobre este tipo de ponteiro não são permitidas;

• Exemplificação visual

• Exemplo 01

• Exemplo 02

• Exemplo 03

• Em C, as operações lógicas aplicadas diretamente a ponteiros são limitadas. Os ponteiros são geralmente usados para lidar com endereços de memória e para realizar operações lógicas envolvendo ponteiros, você deve considerar principalmente comparações de igualdade ou diferença. Aqui estão algumas das operações lógicas de ponteiros mais comuns:

  1. Comparação de Igualdade (==):

     1. Você pode comparar dois ponteiros para ver se eles apontam para a mesma localização de memória. Dois ponteiros são considerados iguais se eles apontam para a mesma posição na memória.

     int *ponteiro1, *ponteiro2;
     if (ponteiro1 == ponteiro2) {
         // Ponteiros apontam para a mesma posição de memória
     }
     

  2. Comparação de Diferença (!=):

     1. Você pode verificar se dois ponteiros são diferentes, ou seja, se eles não apontam para a mesma posição na memória.

     int *ponteiro1, *ponteiro2;
     if (ponteiro1 != ponteiro2) {
         // Ponteiros apontam para posições diferentes de memória
     }
     

• Lembre-se de que as operações lógicas em ponteiros não fazem comparações sobre os valores armazenados nas posições de memória para as quais os ponteiros apontam. Eles comparam apenas os endereços de memória.

• Além das operações lógicas diretas, é importante ter em mente que ponteiros podem ser usados com condicionais e loops, onde suas comparações e operações lógicas podem ser aplicadas para controlar o fluxo do programa ou para avaliar determinadas condições.

• Exemplo 04

• Exemplo 05

int strlen_pointers(char *str) { char *s = str; while( *s != '\0' ) s++; return ( s - str ); }

int strlen_arrays( char s[] ) { int i = 0; while( s[i] != '\0' ) i++; return ( i ); }