Quiz de Ponteiros em C | Operador de Endereço, NULL, swap

Questão 1 — O operador &

int a = 42;
int *p = &a;
printf("%d\n", *p);

O que isso imprime?

Um endereço

Erro de compilação

Explicação: p guarda o endereço de a. *p desreferencia o ponteiro para ler o valor naquele endereço — o valor de a, que é 42.

Questão 2 — Modificando através de um ponteiro

int a = 10;
int *p = &a;
*p = 20;
printf("a = %d\n", a);

O que isso imprime?

a = 10

a = 20

a = 0

Erro de compilação

Explicação: *p = 20 escreve 20 no local para o qual p aponta (que é a). O valor de a muda, então obtemos a = 20.
Ponteiros permitem modificar uma variável indiretamente.

Questão 3 — Ponteiro NULL

int *p = NULL;
printf("%d\n", *p);

O que acontece?

NULL

Erro em tempo de execução (Segmentation Fault)

Erro de compilação

Explicação: Desreferenciar um ponteiro NULL (*p) é comportamento indefinido.
Na maioria dos sistemas isso dispara um segmentation fault. Sempre verifique se é NULL antes de desreferenciar um ponteiro.

Questão 4 — Função swap

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
int main(void) {
    int x = 3, y = 7;
    swap(&x, &y);
    printf("x=%d, y=%d\n", x, y);
    return 0;
}

O que isso imprime?

x=3, y=7

x=7, y=3

x=7, y=7

Erro de compilação

Explicação: Os dois valores são trocados através de ponteiros. Como *a = x e *b = y: tmp=3, *a=7, *b=3.
Resultado: x=7, y=3. Esse é o uso clássico de ponteiros como argumentos de função.

Questão 5 — Ponteiros e vetores

int a[3] = {10, 20, 30};
int *p = a;
printf("%d\n", p[1]);

O que isso imprime?

Erro de compilação

Explicação: Dentro de uma expressão, o nome do vetor a é tratado como um ponteiro para o primeiro elemento.

p = a faz p apontar para a[0]
p[1] significa a mesma coisa que *(p + 1), que é igual a a[1] = 20

O fato de o operador de subscrito [] também funcionar com ponteiros mostra o quão próximos são ponteiros e vetores.

Questão 6 — Aritmética de ponteiros

int a[4] = {1, 2, 3, 4};
int *p = a;
p++;
printf("%d\n", *p);

O que isso imprime?

Um valor de endereço

Explicação: Aplicar ++ a um ponteiro avança o endereço por o tamanho do tipo apontado.

Inicialmente, p aponta para a[0] (=1)
Depois de p++, p aponta para a[1] (avança sizeof(int) = 4 bytes)
*p = a[1] = 2

Um int* avança por sizeof(int); um char* avança 1 byte. Essa é a técnica fundamental para percorrer um vetor com ponteiros.

Questão 7 — Verificação de NULL

void safe_print(int *p) {
    if (p != NULL) {
        printf("%d\n", *p);
    } else {
        printf("NULL\n");
    }
}
int main(void) {
    safe_print(NULL);
    return 0;
}

O que isso imprime?

NULL

Segmentation fault

Erro de compilação

Explicação: Em qualquer função que recebe um ponteiro, uma verificação de NULL importa.

Mesmo quando p é NULL, a guarda if (p != NULL) impede que *p execute
O fluxo cai no ramo else e "NULL" é impresso

Desreferenciar *p sem verificar NULL causaria segfault. Proteger com um if é um hábito essencial para escrever código C seguro.

Questão 8 — Ponteiro solto

int *danger(void) {
    int x = 42;
    return &x;  // retorna o endereço de uma variável local
}
int main(void) {
    int *p = danger();
    printf("%d\n", *p);
    return 0;
}

Qual é o problema aqui?

Sempre imprime 42

Comportamento indefinido (a variável local é invalidada quando a função retorna)

Erro de compilação

Sem problema

Explicação: A variável local x é liberada da pilha no momento em que a função retorna.

Mesmo que você retorne seu endereço, a vida útil de x já acabou quando o chamador o usa
Acessar *p desreferencia um ponteiro solto — comportamento indefinido
Você pode acabar vendo 42, mas isso não é garantido

Correções: marcar x como static, alocar dinamicamente com malloc, ou aceitar um buffer do chamador como argumento.

Questão 9 — Atribuição entre ponteiros

int x = 1, y = 2;
int *p = &x;
int *q = &y;
p = q;
*p = 99;
printf("x=%d, y=%d\n", x, y);

O que isso imprime?

x=99, y=2

x=1, y=99

x=99, y=99

x=1, y=2

Explicação: p = q faz p apontar para o mesmo endereço que q (copia o ponteiro, não o valor apontado).

Depois de p = q, p aponta para y (não mais para x)
*p = 99 escreve 99 em y
x não é alterado e permanece 1

Observe a diferença entre p = q (atribuição de ponteiros) e *p = *q (cópia do valor apontado) — fazem coisas muito diferentes.