Revisão da ETAPA 6 — Ponteiros, estruturas, malloc e arquivos

Revise as aulas 34 a 42 com uma folha de consulta, seis questões de leitura de código e uma lista de erros frequentes.

① Folha de consulta

Revise os conceitos essenciais da ETAPA 6nas tabelas a seguir.

📍 Fundamentos de ponteiros

int x = 5;
int *p = &x;     // p guarda o endereço de x
printf("%d\n", *p); // 5 (lê o conteúdo)
*p = 100;          // x também passa a 100!
  • &x: endereço de x
  • *p: conteúdo apontado por p (desreferência)
  • Em int *p, * faz parte da declaração do ponteiro. Em *p = 5, * desreferencia o ponteiro.

🏢 Estruturas (struct)

struct Point {
    int x, y;
};

struct Point p = { 3, 4 };
printf("%d %d\n", p.x, p.y); // 3 4

struct Point *pp = &p;
printf("%d\n", pp->x);  // 3 (-> equivale a (*pp).x)
  • Dados relacionados são agrupadosem um tipo
  • Acesso a membros: com um objeto, use .; com um ponteiro, use ->

💾 malloc / free (memória dinâmica)

#include <stdlib.h>

int *a = malloc(sizeof(int) * 10);
if (a == NULL) { /* Falha */ }

a[0] = 42;
free(a);             // Libere a memória!
a = NULL;            // Evita liberar novamente por este ponteiro
  • Aloque apenas o necessário durante a execução (o comprimento também pode ser decidido em execução)
  • Após o uso, chame free(não liberar causa vazamento de memória)
  • Em caso de falha, NULL é retornado

📁 Entrada e saída de arquivos

FILE *fp = fopen("data.txt", "r");
if (fp == NULL) { /* Não foi possível abrir */ }

int n;
fscanf(fp, "%d", &n);
fclose(fp);          // Feche o arquivo!
  • modo: "r"(leitura) / "w"(escrita, substitui) / "a"(acréscimo)
  • Após fopen, sempre faça a verificação de NULL; ao terminar, fclose

⚡ Operações de bits

SímboloSignificadoExemplo
&AND5 & 3 → 1
|OR5 | 3 → 7
^XOR5 ^ 3 → 6
~Inversão~5 → -6
<<Deslocamento à esquerda1 << 3 → 8
>>Deslocamento à direita8 >> 2 → 2
  • Teste de paridade: (n & 1) == 0
  • Multiplicar / dividir por 2: n << 1 / n >> 1
  • Operadores lógicos && e operadores de bits & têm funções diferentes

② Seis questões de leitura de código

Execute mentalmente antes de clicar em uma alternativa. Se errar, leia a explicação.

Q1. Alterar um valor por ponteiro

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

Qual é a saída?

10
99
Endereço (valor indeterminado)
Erro de compilação
Explicação: p = &x faz p apontar para x. *p = 99 grava 99 no objeto apontado, que é x. Portanto, x passa a 99. Ponteiros permitem modificar variáveis de quem chama a função, o que exige cuidado.

Q2. swap com ponteiros

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

Qual é a saída?

3 7 (sem alteração)
7 3
Indefinido
Erro de compilação
Explicação: Os ponteiros permitem alterar x e y originais: primeiro, t = *a guarda 3; depois, *a = *b coloca 7 em x; por fim, *b = t coloca 3 em y. A saída é 7 3. Trocar somente cópias locais não alteraria as variáveis originais.

Q3. Acesso -> por ponteiro de estrutura

struct Point { int x, y; };

struct Point p = {10, 20};
struct Point *pp = &p;
pp->x = 99;
printf("%d %d\n", p.x, p.y);

Qual é a saída?

10 20 (sem alteração)
99 20
99 99
Erro de compilação
Explicação: pp->x equivale a (*pp).x e acessa o membro x da estrutura p. Portanto, pp->x = 99 modifica p.x. O membro y permanece 20, e a saída é 99 20. O operador -> acessa membros de uma estrutura por meio de um ponteiro.

Q4. malloc + free

#include <stdlib.h>

int *a = malloc(sizeof(int) * 3);
a[0] = 10; a[1] = 20; a[2] = 30;
int sum = a[0] + a[1] + a[2];
free(a);
printf("%d\n", sum);

Qual é a saída?

60
Indefinido (porque houve free)
0
Erro de compilação
Explicação: sum já foi calculado antes de free. Liberar o bloco alocado não apaga sum, que é uma variável local independente. A saída é 60. Se o programa tentasse ler a[0] depois de free, haveria comportamento indefinido: use-after-free.

Q5. AND de bits (teste de paridade)

for (int n = 1; n <= 5; n++) {
    if ((n & 1) == 0) printf("%d ", n);
}

Qual é a saída?

1 3 5
2 4
1 2 3 4 5
Nada
Explicação: n & 1 extrai o bit menos significativo: zero para pares e um para ímpares. Logo, (n & 1) == 0 é verdadeiro para pares. Entre 1 e 5, isso ocorre com 2 e 4, produzindo 2 4. O teste n % 2 == 0 expressa a mesma ideia; o desempenho depende das otimizações.

Q6. Cópia de estruturas

struct P { int x, y; };

struct P a = {1, 2};
struct P b = a;       // Cópia
b.x = 99;
printf("%d %d %d %d\n", a.x, a.y, b.x, b.y);

Qual é a saída?

1 2 99 2
99 2 99 2
99 99 99 99
Erro de compilação
Explicação: struct P b = a faz uma cópia por valor da estrutura inteira. a e b são objetos independentes, então alterar b.x não altera a.x. A saída é 1 2 99 2. Estruturas que contêm ponteiros exigem atenção à cópia superficial; neste exemplo, os membros são int.

③ Lista de erros e dificuldades frequentes

Se reconhecer um erro que já cometeu, volte à página correspondente para revisar.
  1. 1
    Usar um ponteiro não inicializado
    int *p; *p = 5; usa um endereço indeterminado → comportamento indefinido. Inicialize com NULL ou com um endereço válido.
  2. 2
    Esquecer free depois de malloc
    Vazamentos de memória podem esgotar recursos, especialmente em programas de longa duração. Libere os blocos alocados quando não forem mais necessários.
  3. 3
    Acessar memória depois de free (use-after-free)
    Acessar o bloco liberado causa comportamento indefinido. Atribuir p = NULL após free ajuda a evitar reutilizar esse ponteiro.
  4. 4
    Usar o resultado de fopen sem verificar NULL
    Se a abertura falhar, fopen retorna NULL. Passá-lo a fscanf pode causar falha de memória. Sempre verifique com if(fp == NULL) .
  5. 5
    Esquecer fclose
    Dados de saída podem permanecer no buffer e ser perdidos. Feche o arquivo ao terminar.
  6. 6
    Confundir . e -> no acesso à estrutura
    Com o objeto, use p.x; com um ponteiro, use pp->x. Escrever pp.x quando pp é um ponteiro causa erro de compilação.
  7. 7
    Operadores lógicos && e operadores de bits & por engano
    (a == 1) & (b == 2) combina bits dos resultados das comparações, mas não faz curto-circuito, podendo mudar os efeitos colaterais. Para condições, use &&.

④ Páginas para revisar — retome os pontos difíceis

Use os links para voltar diretamente à explicação correspondente.
Aula 36: Noções de Ponteiro& e * Para revisar o significado Quiz (Ponteiros)Pratique com questões semelhantes Structs (struct)Para revisar o acesso a membros (. e ->) Aula 40: Uniões (union)Para revisar o compartilhamento de memória Aula 41: Entrada/Saída de arquivosPara revisar fopen, fclose e modos de abertura Aula 42: Memória dinâmicaPara revisar malloc, free e verificação de NULL Operadores Bit a BitPara revisar deslocamentos, AND, OR e XOR Folha de consulta rápidaRevise ponteiros, estruturas e malloc em uma página