C Academy · Aula

Acesso inválido

Acesso fora dos limites e não inicializado.

Acesso inválido é uma aula grátis de C Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.

Além dos vazamentos

Vazamentos desperdiçam memória, mas bugs de acesso inválido a corrompem. O memcheck captura vários tipos:

Ler ou escrever além do fim de um buffer
Usar memória depois de free
Ler valores não inicializados
Ler ou escrever por meio de um ponteiro inválido

Eles causam os travamentos mais perigosos e difíceis de reproduzir.

Escrita fora dos limites

Isso aloca espaço para 5 inteiros, mas escreve no índice 5, a sexta posição.

O índice 5 está uma posição além do fim. O memcheck informa uma Invalid write of size 4 nesta linha.

#include <stdlib.h>

int main(void) {
    int *a = malloc(5 * sizeof(int));
    a[5] = 99; /* valid indices are 0..4 */
    free(a);
    return 0;
}

Lendo o erro

O relatório informa a operação, o tamanho e a relação com o bloco:

Invalid write of size 4
Address 0x... is 0 bytes after a block of size 20 alloc'd

“0 bytes after a block of size 20” informa que o acesso ocorreu imediatamente depois de uma alocação de 20 bytes (5 inteiros).

Leitura fora dos limites

As leituras também são detectadas. Aqui, o loop avança uma posição além do necessário.

O memcheck sinaliza uma Invalid read of size 4 na iteração final, mesmo que o programa possa “funcionar” por acaso.

#include <stdlib.h>
#include <stdio.h>

int main(void) {
    int *a = calloc(3, sizeof(int));
    for (int i = 0; i <= 3; i++)   /* should be i < 3 */
        printf("%d\n", a[i]);
    free(a);
    return 0;
}

Valores não inicializados

malloc não zera a memória. Usá-la antes de atribuir um valor produz um valor imprevisível.

O memcheck informa Conditional jump or move depends on uninitialised value(s) quando esse valor afeta o fluxo de controle ou a saída.

#include <stdlib.h>
#include <stdio.h>

int main(void) {
    int *p = malloc(sizeof(int));
    if (*p == 0)              /* *p was never set */
        printf("zero\n");
    free(p);
    return 0;
}

Por que os relatórios de não inicialização demoram

O memcheck não reclama no instante em que você lê memória não inicializada. Ele acompanha se os valores estão “definidos” e só informa o problema quando um valor indefinido realmente importa, por exemplo em um desvio, uma saída ou uma chamada de sistema.

Isso evita falsos alarmes quando você copia bytes não inicializados sem causar danos.

Uso após a liberação

Acessar a memória depois de liberá-la é um comportamento indefinido. O memcheck detecta isso com precisão.

Ele informa Invalid read of size 4 com a observação Address ... is 0 bytes inside a block of size 4 free'd e até mostra onde o free ocorreu.

#include <stdlib.h>
#include <stdio.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 7;
    free(p);
    printf("%d\n", *p);   /* read after free */
    return 0;
}

Liberação dupla

Liberar o mesmo ponteiro duas vezes corrompe os registros internos do alocador.

memcheck relata Invalid free() e mostra tanto a liberação atual quanto a alocação original, tornando o erro evidente.

#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    free(p);
    free(p);   /* freed twice */
    return 0;
}

Rastrear origens

Para erros de valores não inicializados, adicione --track-origins=yes.

Assim, memcheck informa onde o valor incorreto foi created, e não apenas onde foi usado, transformando um aviso vago em uma correção precisa.

valgrind --track-origins=yes ./prog

Pilha e variáveis globais

memcheck é excelente para erros no heap. Para estouros na stack ou em global arrays, sua cobertura é mais limitada.

Nesses casos, AddressSanitizer (gcc -fsanitize=address) costuma ser a melhor escolha. As duas ferramentas se complementam.

Um a mais ou a menos: o terminador nulo

Um estouro frequente no heap ocorre quando o terminador da string é esquecido. strlen retorna 5 para 'hello', mas a string precisa de 6 bytes para armazenar o '\0' final.

memcheck relata uma escrita inválida quando strcpy grava esse último byte além do fim.

#include <stdlib.h>
#include <string.h>

int main(void) {
    char *s = malloc(strlen("hello")); /* needs +1 */
    strcpy(s, "hello");                 /* writes the '\0' past end */
    free(s);
    return 0;
}

Verificação rápida

Identifique o que memcheck relata para o trecho.

Recapitulação

Agora você consegue identificar erros de acesso inválido:

Leituras e escritas fora dos limites aparecem como Invalid read/write, com o deslocamento dentro do bloco
Valores não inicializados são sinalizados quando afetam uma decisão ou uma saída
Uso após liberação e liberação dupla são detectados com os dois pontos de chamada
--track-origins=yes localiza valores indefinidos; combine-o com AddressSanitizer para erros na pilha

Próximo: ler o relatório completo.

Perguntas Frequentes

A aula “Acesso inválido” é grátis?

Sim — o texto completo de “Acesso inválido” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.

O que vou aprender em “Acesso inválido”?

Acesso fora dos limites e não inicializado. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C Academy?

Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Acesso inválido”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C Academy?

Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C Academy