Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C

Aritmética de ponteiros em C

Desloca ponteiros por elementos, usa a posição logo após o último elemento do vetor e calcula diferenças representáveis em `ptrdiff_t`.

Versão: ISO C23; implementation support may vary

Sintaxe

ISO C23 (implementation support may vary):
T *p;                     // T is a complete object type
p + n;  n + p;  p - n;    // n has integer type; result has p's type
p += n; p -= n;           // update a modifiable pointer variable
p - q;                    // compatible complete pointed-to types, possibly differently qualified; result: ptrdiff_t

Em C, a aritmética de ponteiros desloca um ponteiro p para um tipo de objeto completo em unidades de elementos, não de bytes. p + n e n + p deslocam-no n posições, sendo n inteiro; p - n desloca-o no sentido oposto. O resultado mantém o tipo de p; p += n guarda a nova posição em p. Não se podem somar dois ponteiros. A aritmética com void * ou ponteiros para funções é uma extensão de GNU C, não uma regra de ISO C23.

O ponteiro inicial e o resultado têm de apontar, cada um, para um elemento do mesmo vetor durante o seu tempo de vida ou para a posição logo após o último elemento. Essa posição pode servir de marcador de fim e permite recuar, mas não pode ser desreferenciada. Só calcular uma posição anterior ao primeiro elemento ou posterior a essa posição limite já tem comportamento indefinido. Para estes operadores, um objeto que não é elemento de um vetor comporta-se como um vetor de um só elemento.

p - q exige ponteiros para tipos de objeto completos compatíveis, cujos qualificadores podem ser diferentes. Ambos têm de pertencer ao mesmo vetor no sentido acima. O resultado é a diferença dos índices em elementos, com sinal e de tipo ptrdiff_t, definido em <stddef.h>. Se não for representável, o comportamento é indefinido. Usa %td em printf. Já com dois operandos aritméticos, + e - efetuam operações numéricas com as conversões aritméticas habituais; o - unário calcula o simétrico de um número, não de um ponteiro.

Antes de cur += lf ou w += seg, trata qualquer erro indicado por NULL e verifica o deslocamento face ao intervalo restante do vetor. Um ponteiro não nulo não garante validade nem respeito pelos limites. Para calcular um tamanho em bytes, verifica count <= SIZE_MAX / sizeof *p antes de multiplicar, com count do tipo size_t e SIZE_MAX definido em <stdint.h>. Este teste não verifica nem os limites do vetor nem se cur - r é representável em ptrdiff_t.

Exemplos

#include <stddef.h>
#include <stdio.h>

int main(void)
{
    int a[] = {10, 20, 30, 40};
    int *r = a;
    int *cur = r;
    size_t lf = 2;
    cur += lf;

    int *w = cur;
    size_t seg = 2;
    w += seg;

    printf("%d %td %td %td %d\n", *cur, cur - r, w - r, r - w, *(w - 1));
    return 0;
}

Resultado

30 2 4 -4 40

`cur` aponta para `30` e `w` fica logo após o vetor. `cur - r`, `w - r` e `r - w` dão, respetivamente, `2`, `4` e `-4`. `*(w - 1)` lê `40` sem desreferenciar `w`.

Lições relacionadas

  • C · Lição 81 · Avançado · Versão: 3

Fontes