Ponteiros e endereços de memória em C

A memória pode ser visualizada como uma sequência de bytes numerados. Cada número é um endereço. Um objeto como um int ocupa bytes consecutivos, e seu endereço identifica seu primeiro byte. O nome usado no código-fonte permite que o compilador encontre esse objeto; a linguagem não exige que uma etiqueta com o nome seja armazenada ao lado de seu valor.

Meça o armazenamento com sizeof

sizeof informa o tamanho em bytes e produz um valor size_t. Use %zu para imprimi-lo:

int scores[4] = {12, 18, 15, 21};
printf("%zu %zu\n", sizeof scores, sizeof scores[0]);

Com valores int de 4 bytes, isso imprime 16 4. O primeiro resultado mede os quatro elementos; o segundo mede um. sizeof(char) é sempre 1. Uma disposição comum em computadores de mesa de 64 bits usa valores int de 4 bytes, valores double de 8 bytes e ponteiros para objetos de 8 bytes. Outros sistemas podem ser diferentes. Mesmo entre sistemas de 64 bits, long costuma ocupar 8 bytes no Linux e no macOS, mas 4 no Windows.

Tamanho de armazenamento e comprimento de texto respondem a perguntas diferentes. Para char word[20] = "hi";, sizeof word é 20, enquanto strlen(word) é 2. O arranjo ainda contém 20 elementos, embora sua cadeia use apenas duas letras e um terminador. Exceto para arranjos de tamanho variável, esses tamanhos de objetos são fixados em tempo de compilação.

Acompanhe os endereços de um arranjo

Endereços hexadecimais usam os dígitos de 0 a 9 e depois de a a f. O prefixo 0x indica a base 16. Para um arranjo ilustrativo que começa em 0x1000, quatro elementos de 4 bytes começam em:

0x100C é 4.108 em decimal, doze bytes depois de 0x1000. Os elementos de um arranjo não têm espaços entre si. Variáveis declaradas separadamente não têm ordem nem distância garantidas; endereços reais impressos também podem mudar entre execuções. Um compilador pode manter um valor em um registrador do processador quando não é necessário um local de armazenamento endereçável.

Alinhamento e ordem dos bytes

O alinhamento restringe onde os objetos de um tipo podem começar. Uma disposição comum coloca valores int de 4 bytes em múltiplos de 4 e valores double de 8 bytes em múltiplos de 8. O compilador fornece alinhamento adequado para objetos declarados.

A ordem dos bytes é a ordem dos bytes dentro de um valor com vários bytes. Para um unsigned int de 4 bytes contendo 0x12345678, o armazenamento com o byte menos significativo primeiro apresenta os bytes 78 56 34 12 dos endereços menores aos maiores; com o byte mais significativo primeiro, apresenta 12 34 56 78. Um unsigned char * pode examinar a representação de um objeto byte por byte. A ordem dos bytes não altera a ordem dos índices do arranjo.

Mantenha o objeto existente

Uma variável local comum tem duração de armazenamento automática: seu tempo de vida dura enquanto seu bloco está em execução. Implementações típicas mantêm esses objetos no registro de ativação de uma chamada e reutilizam esse armazenamento posteriormente. Variáveis globais, variáveis static e literais de cadeia de caracteres duram durante toda a execução do programa. Salvar um endereço não prolonga o tempo de vida de seu objeto.

Um ponteiro armazena um endereço e tem um tipo que descreve o objeto que ele pode acessar. Declarar um int * fornece armazenamento para um ponteiro; isso não cria um int para esse ponteiro usar. Dê ao ponteiro um valor conhecido ao declará-lo.

Obtenha o endereço de um objeto

int count = 42;
int *p = &count;

O operador de endereço unário & obtém o endereço de count. Se count começa no endereço ilustrativo 0x1000, p contém 0x1000, enquanto count contém 42. O ponteiro também é um objeto: &p é o endereço do armazenamento separado que contém esse ponteiro.

Você pode obter o endereço de um elemento de arranjo, como &scores[2]. Uma constante numérica ou o resultado de um cálculo não é um objeto armazenado cujo endereço você possa obter dessa maneira: &42 e &(count + 1) são inválidos. A expressão binária a & b usa o mesmo símbolo para AND bit a bit; o número de operandos indica qual operação está presente.

Leia cada declarador

Os espaços em branco não alteram nenhum desses tipos. int* p e int *p são equivalentes. Declarar um ponteiro por linha torna seu asterisco mais fácil de perceber. Em computadores de mesa comuns de 64 bits, um ponteiro para objeto ocupa 8 bytes, mas seu próprio tamanho não informa o tamanho do objeto para o qual aponta.

O tipo apontado importa. Para double price = 9.5;, use double *r = &price;. Inicializar um int * com &price produz um diagnóstico de ponteiros incompatíveis. Uma conversão explícita que oculta o diagnóstico não torna válido um acesso como int a esse double: o tipo controla como os bytes armazenados são acessados.

Redirecione um ponteiro

int a = 5, b = 8;
int *p = &a;
p = &b;

A última atribuição substitui o endereço em p. Ela não move nenhum dos inteiros nem copia o valor de um inteiro para o outro. Agora p aponta para b; a continua sendo 5 e b continua sendo 8. Várias variáveis ponteiro também podem armazenar o mesmo endereço.

Use um estado vazio conhecido

Um ponteiro local não inicializado tem um valor indeterminado e às vezes é chamado de ponteiro não inicializado. Não o examine nem o desreferencie. Inicialize-o com o endereço de um objeto válido ou com NULL, disponível em cabeçalhos como <stddef.h> e <stdio.h>:

int *pending = NULL;
if (pending == NULL) {
    pending = &count;
}

Um ponteiro nulo não designa nenhum objeto. !pending é outro teste de nulidade. Esses testes só fazem sentido para ponteiros inicializados; eles não validam um endereço arbitrário nem um ponteiro cujo objeto deixou de existir.

Imprima um ponteiro para objeto

printf("%p\n", (void *)p);

%p espera um void *, então forneça a conversão explícita ao usar um ponteiro para objeto de tipo específico. Sua representação impressa é escolhida pela implementação e costuma ser hexadecimal. %d e %x esperam argumentos inteiros de tipos específicos e não podem substituir %p.

O operador de desreferenciação unário * segue um ponteiro até seu objeto. Se p aponta para x, *p designa o próprio x. Ler *p lê esse objeto; atribuir um valor a *p o altera.

Rastreie uma escrita por meio de um endereço

int x = 10;
int *p = &x;
*p = *p + 5;
int y = *p * 2;
printf("%d %d %d\n", x, *p, y);

Primeiro, p armazena o endereço de x. No lado direito da atribuição, *p lê 10. Somar 5 resulta em 15, e o *p do lado esquerdo armazena 15 em x. A linha seguinte multiplica o valor atualizado por 2, então y passa a ser 30. A saída é 15 15 30.

O contexto distingue os asteriscos: int *p declara um ponteiro, o *p unário acessa um objeto e *p * 2 também contém uma multiplicação binária. Para um objeto válido x, *&x designa x; para um ponteiro para um objeto válido, &*p devolve o valor do ponteiro.

Separe endereços de conteúdos

Comece cada rastreamento com duas linhas de informação: o endereço contido em cada ponteiro e o valor contido em cada inteiro. Suponha que p aponte para a, que contém 3, e q aponte para b, que contém 8.

Um diagrama de memória usa uma caixa para cada objeto. Identifique uma caixa com seu nome e endereço, coloque seu valor atual dentro dela e desenhe uma seta de um ponteiro até seu destino. Uma atribuição de endereço move uma seta; uma atribuição ao objeto apontado altera o conteúdo da caixa de destino.

Após p = q, os ponteiros são referências alternativas a b. Se você executar *p = 20; em seguida, ler *q ou b resultará em 20. Copiar um endereço cria outro caminho para o mesmo objeto, não outro inteiro.

Verifique se uma desreferenciação é válida

Um ponteiro usado para acesso deve designar um objeto existente de tipo adequado, e a escrita também exige um objeto modificável. Ponteiros nulos não designam nenhum objeto. Ponteiros não inicializados não têm um destino conhecido utilizável. Um ponteiro fica pendente quando o tempo de vida de seu objeto termina.

Acessar por meio de um ponteiro inválido é comportamento indefinido: C não impõe requisitos ao resultado. O programa pode parar com uma falha de segmentação, corromper dados ou parecer executar normalmente. Uma execução aparentemente bem-sucedida não pode estabelecer que o acesso era válido.

Para um ponteiro que pode legitimamente ser nulo, teste-o antes de acessá-lo:

if (p != NULL) {
    *p = 0;
}

Atribuir NULL a um ponteiro de que você não precisa mais pode evitar o uso acidental posterior dessa variável. Isso não redefine outras referências alternativas. Acompanhe separadamente o tempo de vida do objeto.

Use parênteses em torno do valor desejado

O ++ pós-fixado tem precedência maior que o * unário. Assim, *p++ significa *(p++): usa o valor anterior do ponteiro para acessar um valor e avança o ponteiro. (*p)++ incrementa o valor apontado e deixa o ponteiro no lugar. *p + 1 lê o valor e soma 1 sem armazenar o resultado. Essas são três ações diferentes.

C passa todo argumento por valor. Um parâmetro é uma variável local inicializada a partir do argumento. Passar um endereço não altera essa regra: a função recebe uma cópia do endereço, e essa cópia pode acessar o objeto da função chamadora.

Compare duas funções de redefinição

void reset_copy(int n) {
    n = 0;
}

void reset(int *n) {
    *n = 0;
}

Para int score = 12;, reset_copy(score) altera apenas seu n local. score continua sendo 12. A chamada reset(&score) copia o endereço de score para o parâmetro ponteiro n; atribuir um valor a *n altera score para 0. Essa técnica costuma ser chamada de passagem por referência, embora a passagem efetiva de argumentos da linguagem continue sendo por valor.

O endereço na chamada e a desreferenciação no corpo realizam tarefas diferentes. &score informa à função onde está o objeto. *n = 0 informa o que armazenar nele. Chamar reset(score) fornece um inteiro onde é exigido um ponteiro e gera um diagnóstico do compilador.

Acompanhe uma troca

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

/* Inside a calling function: */
int x = 3, y = 8;
swap(&x, &y);

1. a aponta para x e b aponta para y.
2. t guarda o valor original de x, que é 3.
3. *a = *b escreve 8 em x.
4. *b = t escreve o 3 guardado em y.

As duas variáveis da função chamadora mudam. Uma versão que recebe int a, int b troca apenas cópias. Uma versão com ponteiros que executa int *t = a; a = b; b = t; também não troca os inteiros: ela redireciona apenas os parâmetros ponteiro locais.

Forneça mais de um resultado

Uma instrução de retorno fornece um valor, mas parâmetros ponteiro podem fornecer saídas adicionais:

void divide(int total, int size, int *q, int *r) {
    *q = total / size;
    *r = total % size;
}

/* size must be positive for these example inputs. */
int q, r;
divide(17, 5, &q, &r);

A divisão inteira resulta em q igual a 3 e r igual a 2. A função chamadora fornece dois objetos distintos nos quais é possível escrever. Outra interface útil retorna um status de sucesso e escreve uma saída apenas em caso de sucesso; as funções chamadoras verificam esse status antes de usar a saída.

Reconheça o mesmo padrão em chamadas de biblioteca

scanf("%d", &age) precisa do endereço de age porque armazena nele um inteiro extraído da entrada. Passar age fornece um valor em vez do int * exigido, produzindo comportamento indefinido. Verifique se scanf retorna 1 antes de usar o valor recém-lido.

Para texto, char name[20]; scanf("%19s", name); passa um ponteiro para o primeiro caractere do arranjo. A largura permite no máximo 19 caracteres de entrada, deixando espaço para '\0'. A expressão do arranjo já fornece o ponteiro para caractere exigido.

Um parâmetro de arranjo também recebe um endereço, não um bloco copiado de elementos. Em void zero(int *a, size_t n), atribuições a a[i] afetam o arranjo da função chamadora. Passar o endereço copia apenas um ponteiro, o que também permite que funções somente de leitura examinem arranjos grandes sem copiar cada elemento.

Uma interface com ponteiro deve deixar duas coisas claras: se a função pode escrever por meio dele e por quanto tempo o armazenamento apontado permanece válido. const responde à primeira pergunta. O tempo de vida do objeto responde à segunda.

Identifique a restrição de const

Um ponteiro para dados constantes restringe esse caminho de acesso. Se x foi definida como em int x = 5;, sem const, x = 6; ainda é permitido mesmo enquanto um const int * aponta para ela. Se o próprio objeto foi definido com const, tentar modificá-lo por meio de qualquer ponteiro é comportamento indefinido.

Um ponteiro constante mantém um único endereço. Ele deve ser inicializado, e o endereço não pode ser substituído posteriormente. O objeto nesse endereço ainda pode mudar quando seu tipo permite. Leia a partir do nome em direção às partes externas: int *const p torna p constante; const int *p protege o int acessado por meio de p.

Use um parâmetro somente de leitura como const char *s quando uma função apenas examinar uma cadeia de caracteres. Um char * comum pode ser passado para esse parâmetro sem conversão explícita. A função pode avançar seu s local, mas uma atribuição por meio de *s é rejeitada. Converter de volta para um tipo que permita escrita exige mais que eliminar um aviso do compilador: o objeto subjacente deve de fato ser modificável.

Retorne uma posição no armazenamento da função chamadora

int *find(int *a, size_t n, int target) {
    for (size_t i = 0; i < n; i++) {
        if (a[i] == target) return &a[i];
    }
    return NULL;
}

Para int v[] = {4, 9, 2, 9};, find(v, 4, 9) retorna &v[1]. A função termina, mas v pertence à função chamadora e continua existindo nela. Após verificar se o resultado é diferente de NULL, a função chamadora pode calcular found - v para obter o índice 1 ou executar *found = 0 para atualizar o elemento. Uma busca por 7 retorna NULL, que não deve ser desreferenciado. strchr e strstr usam a mesma convenção de retornar nulo quando não encontram o resultado.

Rejeite endereços de variáveis locais que deixaram de existir

int *bad(void) {
    int result = 42;
    return &result;
}

result tem duração de armazenamento automática. Seu tempo de vida termina quando a chamada retorna, deixando a função chamadora com um ponteiro pendente. O compilador pode emitir um aviso, e qualquer acesso posterior por meio desse ponteiro tem comportamento indefinido. Os bytes antigos estarem visíveis em uma execução não mantém o objeto existente.

O mesmo problema pode ocorrer na chave de fechamento de um bloco interno. Um ponteiro externo não pode prolongar o tempo de vida de uma variável interna cujo endereço ele salvou.

Escolha armazenamento que dure o suficiente

Retorne um valor int quando a função chamadora precisar apenas de um resultado inteiro. Para vários resultados, permita que a função chamadora forneça o armazenamento a ser preenchido. Um ponteiro retornado também pode se referir ao arranjo da função chamadora, a um literal de cadeia de caracteres exposto por meio de const char * ou a um objeto static.

Uma variável local estática é inicializada uma vez e dura durante todo o programa, mas todas as chamadas a compartilham. Se uma chamada posterior armazenar um novo valor nela, todo ponteiro retornado anteriormente verá essa alteração. O armazenamento estático resolve o problema de tempo de vida sem fornecer a cada chamada seu próprio objeto de resultado independente.

Somar um inteiro a um ponteiro o move por elementos do tipo apontado. Se p aponta para o elemento i de um arranjo, p + n aponta para o elemento i + n, desde que a posição resultante esteja dentro do arranjo ou imediatamente após seu último elemento.

Aplique a escala ao endereço uma vez

No endereço ilustrativo 0x1000, somar 3 fornece estes resultados:

O compilador aplica a escala. Escrever p + 3 * sizeof *p aplica a escala duas vezes e geralmente chega ao elemento errado. Use unsigned char * quando o passo desejado for realmente um byte da representação de um objeto.

Para int a[6] = {10, 20, 30, 40, 50, 60}; e int *p = &a[1];, *(p + 2) lê a[3], que é 40. A atribuição p += 3; move o próprio ponteiro para a[4], que contém 50. A partir daí, *(p - 1) lê 40. p++, p--, p += n e p -= n usam passos por elementos.

Subtraia posições para contar elementos

&a[5] - &a[1] é 4, e inverter os operandos resulta em -4. O resultado já conta elementos; não o divida por sizeof(int). Seu tipo com sinal é ptrdiff_t, declarado em <stddef.h>, e %td o imprime.

Subtraia apenas ponteiros para posições no mesmo arranjo, incluindo a posição imediatamente após seu último elemento, com um resultado representável em ptrdiff_t. Essa operação descreve posições dentro desse arranjo. Subtrair endereços de variáveis não relacionadas é comportamento indefinido, mesmo que os números impressos por acaso estejam próximos.

Use a posição após o último elemento como limite

Para seis elementos, a + 6 é um ponteiro para a posição imediatamente após o último elemento válido. Ele pode servir como limite e participar de uma subtração válida dentro do mesmo arranjo, mas não pode ser desreferenciado. a + 7 e a - 1 já são comportamento indefinido quando formados; evitar uma desreferenciação posterior não os corrige.

for (int *p = a; p < a + 6; p++) {
    printf("%d\n", *p);
}

O corpo é executado para os índices de 0 a 5. Após o último incremento, p é igual a a + 6, e o teste seguinte interrompe o laço. Usar <= permitiria que o corpo acessasse essa posição que não é um elemento.

Para as regras de aritmética, um objeto isolado funciona como um arranjo de um elemento. Você pode formar &x + 1; não pode usá-lo para ler uma suposta variável seguinte.

Compare apenas posições que façam sentido

Operadores de ordem como < comparam posições dentro de um arranjo. Não ordene ponteiros para objetos não relacionados. Igualdade e desigualdade podem comparar tipos de ponteiro compatíveis e testar se um ponteiro é nulo.

Você não pode somar dois ponteiros, multiplicar ponteiros nem fazer aritmética do C padrão com um void * ou um ponteiro para função. Para encontrar o ponto médio de um intervalo no mesmo arranjo [p, q), use p + (q - p) / 2: subtraia as posições para obter uma contagem, divida essa contagem e avance a partir de p.

Um arranjo é um bloco de elementos. Um ponteiro é um objeto separado que contém um endereço. A relação próxima entre eles vem de uma conversão automática que ocorre na maioria das expressões, e não de serem o mesmo tipo de objeto.

Converta uma expressão de arranjo

int a[5] = {3, 1, 4, 1, 5};
int *p = a;

Aqui, a é convertido em um ponteiro para a[0]. Essa conversão de arranjo em ponteiro torna o inicializador equivalente a &a[0]. Tanto *p quanto a[0] leem 3.

C define a indexação por meio de aritmética: a[i] significa *(a + i). Portanto, p[3] também funciona e lê 1. &a[i] e a + i identificam o mesmo elemento. Até 3[a] tem o mesmo significado definido que a[3], embora a forma usual seja muito mais clara.

Saiba quando o arranjo inteiro continua sendo um arranjo

A conversão não ocorre para operandos de sizeof ou do & unário. Ela também não ocorre para typeof e typeof_unqual de C23, nem quando um literal de cadeia de caracteres inicializa um arranjo de caracteres.

Você não pode atribuir um novo endereço a um arranjo nem incrementar seu nome: a = p; e a++; são inválidos. Você pode redirecionar p, por exemplo, com p = a + 2;. Copie o conteúdo de um arranjo com um laço sobre os elementos ou uma chamada adequada a memcpy.

Acompanhe o tipo de parâmetro ajustado

int sum(const int *values, size_t n) {
    int total = 0;
    for (size_t i = 0; i < n; i++) total += values[i];
    return total;
}

A função chamadora fornece um endereço e uma contagem. Para o arranjo acima, sum(a + 2, 3) visita os índices originais 2, 3 e 4, somando 4, 1 e 5 para retornar 10. Dentro da função, o índice 0 é relativo ao ponteiro inicial fornecido.

Em uma lista de parâmetros de função, int a[], int a[10] e int *a declaram um parâmetro ponteiro. A forma simples [10] não fornece um limite verificado nem transfere um comprimento. Dentro dessa função, sizeof a mede um ponteiro. A expressão sizeof a / sizeof a[0] resultaria em 2 em um sistema com ponteiros de 8 bytes e valores int de 4 bytes, independentemente do comprimento real do arranjo da função chamadora.

Diferencie um ponteiro para elemento de um ponteiro para arranjo

a é convertido em int *, enquanto &a tem tipo int (*)[5], um ponteiro para o arranjo inteiro de cinco elementos. Ambos identificam o início do mesmo armazenamento, mas a aritmética segue seus tipos diferentes. a + 1 avança um int, ou 4 bytes nessa disposição. &a + 1 avança um arranjo inteiro, ou 20 bytes, até a posição imediatamente após seu último elemento.

Um endereço inicial impresso não revela essa diferença de tipo. Leia a declaração e mantenha o tipo apontado junto ao ponteiro ao rastrear uma expressão.

Um laço com ponteiro precisa de uma posição atual e de uma regra de parada. Um arranjo com quantidade conhecida usa um ponteiro para o fim; uma cadeia de caracteres usa seu '\0' de terminação. Escolha a forma que torne os elementos visitados mais fáceis de visualizar.

Percorra um intervalo com quantidade conhecida

int a[] = {3, 1, 4, 1, 5};
int total = 0;
for (const int *p = a; p < a + 5; p++) {
    total += *p;
}

Os totais acumulados são 3, 4, 8, 9 e 14. Um laço com índice que soma a[i] para índices menores que 5 fornece o mesmo resultado. Compiladores modernos com otimização costumam gerar código semelhante para essas formas; a sintaxe com ponteiros, por si só, não garante vantagem de velocidade.

Leia antes ou depois de mover

Com p no 3 de {3, 1, 4}, int v = *p++; define v como 3 e deixa p no 1. O incremento pós-fixado fornece o valor anterior do ponteiro a * e atualiza o ponteiro. *++p primeiro move para o próximo elemento e depois o lê. (*p)++ altera o elemento atual e não move o ponteiro.

Pare no terminador de uma cadeia de caracteres

size_t my_strlen(const char *s) {
    const char *p = s;
    while (*p != '\0') p++;
    return (size_t)(p - s);
}

Para "pointer", p para no terminador, sete posições a partir do início. O resultado exclui esse terminador. Uma contagem de caracteres usa o mesmo percurso: examinar "mississippi" e incrementar um contador sempre que *p == 's' conta quatro ocorrências entre onze letras.

Um ponteiro para o meio de uma cadeia de caracteres dá acesso a seu sufixo. Com const char *msg = "hello world";, puts(msg + 6) imprime "world". Os caracteres anteriores permanecem onde estavam.

Copie também o terminador

char destination[4];
const char *src = "cat";
char *dst = destination;
while ((*dst++ = *src++) != '\0') {
}

Cada iteração atribui um caractere, testa o valor atribuído e avança ambos os ponteiros. A última iteração copia '\0', então o destino é uma cadeia de caracteres completa. Ambos os ponteiros ficam imediatamente após seus terminadores. O armazenamento precisa do comprimento do texto mais um byte; omitir esse byte extra causa um estouro de buffer. Esse padrão de cópia também exige que as regiões de origem e destino não se sobreponham.

Inverta a partir das duas extremidades

Para uma cadeia de caracteres modificável, obtenha primeiro seu comprimento. Se o comprimento for zero, pare antes de formar um ponteiro para o último caractere. Caso contrário, defina left = s e right = s + length - 1. Enquanto left < right, troque os caracteres, incremente left e decremente right. Para "stressed", quatro trocas produzem "desserts"; o terminador permanece no fim original.

A verificação de cadeia vazia importa porque subtrair 1 de seu ponteiro inicial formaria um ponteiro para antes do arranjo.

Escolha armazenamento modificável para caracteres

char word[] = "hello"; cria um arranjo modificável de seis bytes, incluindo o terminador. const char *word = "hello"; aponta para um literal de cadeia de caracteres com duração de armazenamento estática. Modificar um literal de cadeia de caracteres é comportamento indefinido, mesmo que uma declaração use char * sem const. Use const char * para que escritas acidentais sejam um erro de compilação.

Um laço sobre um arranjo deve parar antes da posição imediatamente após seu último elemento, e um percurso de cadeia de caracteres deve realmente encontrar um terminador dentro do armazenamento acessível. Um ponteiro não carrega um comprimento nem uma garantia de que os bytes formam uma cadeia de caracteres.

Um ponteiro é um objeto armazenado, então tem um endereço que outro ponteiro pode conter. Um ponteiro para ponteiro acrescenta mais um passo entre a expressão e os dados finais.

Siga as setas uma de cada vez

int x = 7;
int *p = &x;
int **pp = &p;

Use endereços ilustrativos: x em 0x2000 contém 7; p em 0x3000 contém 0x2000; pp em 0x4000 contém 0x3000. Avaliar *pp alcança p, cujo valor tem tipo int *. Avaliar **pp segue esse ponteiro até x, um int.

&p tem um nível de ponteiro a mais que p; cada desreferenciação remove um nível. Inicializar int **pp com &x é incompatível porque &x tem tipo int *.

Escolha o nível da atribuição

Com outro inteiro existente y, **pp = 9; altera x. A atribuição *pp = &y; altera o ponteiro p, então usos futuros de **pp alcançam y. Ela deixa x com seu valor atual. Se q for outro int *, pp = &q; altera apenas o ponteiro externo, fazendo sua primeira seta alcançar q em vez de p.

Não conte os asteriscos sem verificar também o objeto em cada nível. Antes de avaliar **pp, tanto o caminho até o objeto ponteiro quanto o caminho desse objeto até o inteiro devem ser válidos.

Mova um ponteiro para cadeia da função chamadora

void skip_spaces(const char **s) {
    while (**s == ' ') {
        (*s)++;
    }
}

/* In the caller: */
const char *text = "   hi";
skip_spaces(&text);
puts(text);

A função chamadora passa o endereço de sua variável ponteiro. Portanto, *s designa text; **s lê o caractere atual. Cada (*s)++ avança text em um caractere. Após três iterações, ele aponta para 'h', e puts imprime "hi". A função exige um ponteiro válido para um ponteiro que aponta para uma cadeia terminada em nulo.

Uma versão que recebe const char *s e incrementa s altera apenas uma cópia local. Os parênteses em (*s)++ também são essenciais: *s++ incrementa o ponteiro local externo em vez do ponteiro para caractere da função chamadora. Em const char **s, os caracteres são somente de leitura por esse caminho de acesso, mas o ponteiro da função chamadora pode se mover.

Leia um ponteiro de saída de uma função de biblioteca

strtol de <stdlib.h> usa um parâmetro de saída do tipo char **:

char *end;
long number = strtol("42abc", &end, 10);

Ela retorna 42 e armazena em end um ponteiro para o primeiro caractere não usado, que agora alcança "abc". Se o ponteiro de fim for igual ao ponteiro inicial, nenhum dígito foi convertido. Um analisador numérico com verificação completa também trata erros de faixa; aqui, a função do ponteiro é informar a posição de parada.

Um arranjo pode armazenar ponteiros como elementos. Uma matriz bidimensional, por sua vez, armazena linhas completas como elementos. Ambos aceitam dois índices, mas seu armazenamento e os tipos dos ponteiros resultantes da conversão diferem.

Armazene endereços de cadeias separadas

const char *days[] = {"Mon", "Tue", "Wed"};

days contém três ponteiros para caracteres. Cada um aponta para um literal de cadeia de caracteres separado. days[1] é o ponteiro para "Tue", e days[1][0] lê 'T'. Com ponteiros para objetos de 8 bytes, sizeof days é 24, independentemente dos comprimentos das cadeias. As próprias cadeias ocupam armazenamento em outro lugar.

Os comprimentos podem ser diferentes, formando uma coleção irregular. Reordenar a lista pode trocar elementos ponteiro sem copiar o texto. Atribuir days[0] = "Thursday"; é permitido: o elemento ponteiro pode mudar, embora os caracteres acessados por ele sejam somente de leitura.

Na maioria das expressões, days é convertido em um ponteiro para seu primeiro elemento. Como um elemento é um const char *, o tipo convertido é const char **:

for (const char **d = days; d < days + 3; d++) {
    puts(*d);
}

O laço avança um elemento ponteiro por iteração. *d recupera o ponteiro para caractere de que puts precisa.

Leia cadeias da linha de comando

int main(int argc, char *argv[]) recebe o mesmo tipo de parâmetro que char **argv. argc não é negativo e conta as cadeias disponíveis. Quando é positivo, argv[0] representa o nome do programa ou uma cadeia vazia se esse nome não estiver disponível. Os argumentos do usuário ocupam os índices de 1 até argc - 1, e argv[argc] é um ponteiro nulo.

Para uma chamada típica ./greet Ada 42, argc é 3, argv[1] aponta para "Ada" e argv[2] aponta para "42". O último argumento é texto até que uma conversão como strtol o leia. argv[1][0] é 'A'. Verifique argc > 2 antes de usar argv[2].

Um laço que imprime os argumentos do usuário pode usar for (int i = 1; i < argc; i++) puts(argv[i]);. Para percorrer a partir de argv + 1 até um ponteiro nulo, verifique primeiro argc > 0; se argc for zero, não há um intervalo de argumentos do usuário que possa ser percorrido dessa maneira. As cadeias de caracteres dos argumentos são modificáveis, ao contrário dos literais de cadeia.

Percorra linhas completas

int grid[3][4] contém doze inteiros armazenados por linhas: toda a linha 0, depois a linha 1 e depois a linha 2. Com valores int de 4 bytes, cada linha ocupa 16 bytes. grid[2][1] fica 36 bytes após grid[0][0]: duas linhas completas contribuem com 32 bytes e a coluna contribui com 4.

grid + 1 avança uma linha. Uma função que o recebe pode usar int g[][4] ou int (*g)[4], com uma contagem de linhas separada. Ela não pode usar int **: a matriz não tem ponteiros para linhas armazenados para desreferenciar. Uma conversão explícita não pode criar esses ponteiros ausentes.

Da mesma forma, char names[3][6] contém dezoito posições para caracteres em linhas de tamanho fixo. const char *names[3] contém três posições para ponteiros que podem se referir a cadeias de comprimentos diferentes.

Um ponteiro para função armazena uma referência a uma função que pode ser chamada posteriormente. Seu tipo inclui o tipo de retorno e os tipos dos parâmetros. Esses tipos devem corresponder à função usada por meio do ponteiro.

Coloque parênteses em torno do nome do ponteiro

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

int (*op)(int, int) = add;

Leia a partir de op: ele é um ponteiro, o elemento apontado é uma função que recebe dois valores int, e essa função retorna um int. Sem os parênteses, int *op(int, int); declara uma função que retorna um ponteiro para inteiro. Os parênteses mudam o significado da declaração.

O nome de uma função é convertido em ponteiro para função nesse inicializador. op = &add; é equivalente a op = add;. Tanto op(6, 3) quanto (*op)(6, 3) chamam add e retornam 9. Atribuir op = sub; faz a mesma chamada retornar 3. Nada na expressão de chamada mudou, exceto a função armazenada no ponteiro.

Mantenha a assinatura compatível

Um ponteiro do tipo int (*)(int, int) não pode chamar com segurança uma função que recebe e retorna double. Por exemplo, atribuir sqrt a ele produz um diagnóstico de tipo incompatível. Converter explicitamente o ponteiro para função para silenciar um diagnóstico não torna válida uma chamada incompatível; o comportamento é indefinido.

O C padrão trata separadamente ponteiros para objetos e ponteiros para funções. void * é o tipo de ponteiro genérico para objeto, não um recipiente portável para um ponteiro para função. Ponteiros para funções permitem testes de igualdade e desigualdade, mas não aritmética de ponteiros.

Um ponteiro para função nulo significa que não há função que possa ser chamada. Quando uma interface permite esse estado, verifique-o:

if (op != NULL) {
    int result = op(6, 3);
    printf("%d\n", result);
}

Chamar uma função por meio de um ponteiro para função nulo é comportamento indefinido.

Nomeie o tipo uma vez

typedef int (*binop)(int, int);
binop ops[] = {add, sub, mul};

O typedef nomeia um tipo de ponteiro. binop selected = mul; declara um ponteiro; binop pick(char symbol); declara uma função que retorna um ponteiro desse tipo. Sem o typedef, essa declaração de retorno seria int (*pick(char symbol))(int, int);.

Um arranjo de ponteiros para funções é uma tabela de despacho. ops[2](6, 3) seleciona mul e retorna 18. Para um índice de seleção com sinal i, verifique i >= 0 && i < 3 antes de avaliar ops[i]. Acessar um índice fora da tabela é inválido, mesmo que todas as funções armazenadas possam ser chamadas.

Leia declarações maiores a partir do nome

Comece pelo nome e resolva os parênteses e as partes pós-fixadas antes de avançar para as partes externas. Em int (*table[3])(int, int), table[3] cria um arranjo de três elementos, * torna cada elemento um ponteiro e (int, int) torna seu destino uma função que retorna int.

Em char *(*f)(const char *), f é um ponteiro para uma função que recebe um const char *; essa função retorna um char *. Mantenha os requisitos de tempo de vida do ponteiro retornado separados dos requisitos de chamada compatível do ponteiro para função.

Uma função de retorno de chamada é uma função fornecida a outra função, que a chama como parte de seu trabalho. Isso separa a operação geral de percurso ou ordenação da ação ou ordem específica que você escolhe.

Passe uma operação sem chamá-la

void twice(int *x) { *x *= 2; }

void for_each(int *a, size_t n, void (*fn)(int *)) {
    for (size_t i = 0; i < n; i++) fn(&a[i]);
}

Para int v[] = {1, 2, 3};, for_each(v, 3, twice); produz {2, 4, 6}. O nome da função fornece um ponteiro. Escrever twice() tentaria chamá-la imediatamente, sem o argumento exigido, em vez de fornecer uma operação para chamadas posteriores.

Recupere um tipo a partir de um ponteiro genérico para objeto

Um void * pode conter um ponteiro para objeto e ser convertido de volta ao tipo original. Ele não pode ser desreferenciado nem usado em aritmética de ponteiros do C padrão porque não fornece um tipo de elemento. Preserve os qualificadores: dados somente de leitura passam por const void * e depois por um ponteiro adequado para dados constantes.

qsort de <stdlib.h> recebe um endereço base, uma contagem de elementos, um tamanho de elemento em bytes e uma função de comparação. A função de retorno de chamada tem tipo int (*)(const void *, const void *). Cada argumento aponta para um elemento do arranjo, e o sinal retornado indica onde o primeiro elemento deve ficar:

Ordene inteiros sem estouro

int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

/* In the caller: */
int v[] = {42, -7, 19, 0, 3};
qsort(v, 5, sizeof v[0], cmp_int);

O arranjo torna-se {-7, 0, 3, 19, 42}. As comparações produzem 0 ou 1, então a expressão de retorno produz apenas -1, 0 ou 1. Inverter a expressão de ordenação para (y > x) - (y < x) ordena em ordem decrescente.

Não use return x - y; para inteiros com sinal arbitrários. Para int de 32 bits, subtrair -2.000.000.000 de 2.000.000.000 ultrapassa INT_MAX. O estouro de inteiro com sinal tem comportamento indefinido, então não há garantia de um resultado com redução modular nem de um sinal de comparação confiável.

Ordene ponteiros para cadeias de caracteres

int cmp_str(const void *a, const void *b) {
    return strcmp(*(const char *const *)a,
                  *(const char *const *)b);
}

const char *names[] = {"Lin", "Ada", "Grace"};
qsort(names, 3, sizeof names[0], cmp_str);

Inclua <string.h> para strcmp. Um elemento do arranjo aqui é, ele próprio, um ponteiro. A função de retorno de chamada recebe um endereço desse elemento ponteiro, então desreferenciar uma vez recupera o endereço da cadeia. O const interno acrescentado impede a alteração do elemento por esse caminho de acesso. Após a ordenação, a ordem é "Ada", "Grace", "Lin".

strcmp(a, b) leria os bytes das posições dos ponteiros como texto. Use também sizeof names[0], o tamanho de um elemento ponteiro, não sizeof(char) nem o comprimento de um nome.

As funções de comparação devem deixar os elementos inalterados e responder de modo consistente, incluindo uma ordenação transitiva. qsort não promete preservar a ordem dos elementos considerados iguais na comparação. bsearch aceita o mesmo formato de função de comparação para buscar em um arranjo já ordenado segundo essa ordem.