Quiz 4 — Ponteiros e Memória

1. Qual é a saída?

#include <stdio.h>
int main() {
    int x = 7;
    int *p = &x;
    *p = 20;
    printf("%d", x);
}

• 7
• 20
• Endereço de x
• Comportamento indefinido

2. Em sistemas 64-bit, qual é o tamanho em bytes de um double *?

• 8 bytes — mesmo que double
• 4 bytes — metade de double
• 8 bytes — independente do tipo apontado, todo ponteiro tem 8 bytes em 64-bit
• 16 bytes — o dobro de um ponteiro int *

3. O que acontece ao tentar usar um ponteiro que não foi inicializado?

• O compilador recusa compilar com erro
• O ponteiro automaticamente aponta para NULL
• Comportamento indefinido — contém endereço aleatório; usá-lo pode corromper dados ou causar segfault
• O programa imprime 0 e continua normalmente

4. Qual a diferença entre *p++ e (*p)++?

• São equivalentes — o compilador trata os dois da mesma forma
• *p++ incrementa o ponteiro (avança para o próximo endereço); (*p)++ incrementa o valor apontado
• *p++ incrementa o valor; (*p)++ incrementa o ponteiro
• Ambos causam erro de compilação por ambiguidade

5. Por que é boa prática escrever p = NULL logo após free(p)?

• Para que a memória liberada seja imediatamente reutilizada pelo SO
• Porque free não libera a memória sem esse comando adicional
• Para evitar que o ponteiro seja usado acidentalmente após a liberação — um dangling pointer que aponta para memória já devolvida
• Para reinicializar o bloco de memória com zeros

6. Se p é um int * apontando para 0x1000, qual é o endereço de p + 3?

• 0x1003 — soma 3 bytes
• 0x100C — soma 3 × 4 = 12 bytes
• 0x1006 — soma 3 × 2 = 6 bytes
• 0x1018 — soma 3 × 8 = 24 bytes

7. Qual é a saída?

int v[] = {10, 20, 30, 40, 50};
int *p = v + 2;
printf("%d %d", *p, *(p + 1));

• 10 20
• 20 30
• 30 40
• 30 50

8. As expressões v[i] e *(v + i) para um array int v[] são:

• Diferentes — v[i] faz verificação de limite; *(v+i) não
• Idênticas — o compilador gera exatamente o mesmo código para ambas
• Similares, mas *(v+i) é mais lenta por envolver aritmética adicional
• Diferentes — v[i] copia o elemento; *(v+i) retorna referência

9. Dado int v[6] com int *p = &v[1] e int *q = &v[5], qual é o valor de q - p?

• 16 (distância em bytes)
• 6 (tamanho do array)
• 4 (distância em elementos)
• 5 (índice de q)

10. A função abaixo conta o comprimento de uma string. O que ela retorna para "hello"?

int len(const char *s) {
    const char *p = s;
    while (*p) p++;
    return p - s;
}

• 4
• 5
• 6 (inclui o '\0')
• Endereço do último caractere

11. Qual é a diferença fundamental entre malloc e calloc?

• malloc aloca na stack; calloc aloca no heap
• malloc não inicializa o bloco (pode conter lixo); calloc inicializa todos os bytes com zero
• malloc é para tipos primitivos; calloc é para structs
• Não há diferença funcional — são aliases um do outro

12. Qual é o erro no código abaixo?

int *p = (int *) malloc(10 * sizeof(int));
p = realloc(p, 20 * sizeof(int));

• realloc não pode ser usado com ponteiros obtidos de malloc
• Se realloc falhar e retornar NULL, o bloco original é perdido (memory leak) pois p foi sobrescrito com NULL
• O novo tamanho deve ser obrigatoriamente menor que o original
• Não há nenhum erro — o código está correto

13. Qual das afirmações sobre free é verdadeira?

• free(NULL) causa segmentation fault
• Após free(p), chamar free(p) novamente é seguro se p != NULL
• free(NULL) é seguro e não faz nada; chamar free duas vezes no mesmo ponteiro não nulo é comportamento indefinido
• free zera automaticamente o bloco liberado

14. Qual é a fórmula correta para acessar o elemento na linha i, coluna j de uma matriz alocada como array único com C colunas?

• matriz[i + j]
• matriz[i * C + j]
• matriz[j * C + i]
• matriz[i][j] (funciona igual)

15. Por que a estratégia de dobrar a capacidade no realloc é preferível a aumentar 1 elemento por vez?

• Porque usa menos memória total no final
• O custo amortizado de cada inserção permanece O(1) — o número de realocações cresce apenas logaritmicamente com o total de elementos
• Evita completamente a necessidade de usar realloc
• Permite usar calloc em vez de realloc

16. Qual é a saída?

#include <stdio.h>
void f(int x) { x = 99; }
int main() {
    int a = 5;
    f(a);
    printf("%d", a);
}

• 99
• 5
• 0
• Comportamento indefinido

17. Qual é a saída?

#include <stdio.h>
void trocar(int *a, int *b) {
    int t = *a; *a = *b; *b = t;
}
int main() {
    int x = 10, y = 20;
    trocar(&x, &y);
    printf("%d %d", x, y);
}

• 10 20
• 20 10
• 0 0
• Comportamento indefinido

18. O que o parâmetro const float *v garante dentro de uma função?

• O array é copiado antes de ser passado à função
• Os valores apontados por v não podem ser modificados — o compilador emite erro se a função tentar escrever em v[i]
• O ponteiro v não pode ser reatribuído dentro da função
• A função é marcada como somente leitura pelo compilador

19. Por que a função abaixo está errada?

int *calcular() {
    int resultado = 42;
    return &resultado;
}

• Funções não podem retornar ponteiros em C
• Retorna o endereço de uma variável local que é destruída ao retornar — o ponteiro fica dangling (pendurado), apontando para memória inválida
• O tipo de retorno deveria ser int, não int *
• Variáveis locais não têm endereço em C

20. Uma função recebe int **pp e executa *pp = malloc(10 * sizeof(int)). O que isso faz no chamador?

• Aloca memória acessível apenas dentro da função
• Modifica o ponteiro original no chamador, fazendo-o apontar para o bloco recém-alocado no heap
• Cria uma cópia do ponteiro que nunca pode ser liberada
• Causa erro de compilação — não é possível atribuir a *pp