C Academy · Aula

Alocando um vetor

Reserve memória no heap.

Alocando um vetor é uma aula grátis de C Academy no CoddyKit. Esta é a aula 1 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.

Por que usar matrizes dinâmicas?

Uma matriz comum tem um tamanho fixo definido em tempo de compilação. Porém, muitas vezes você só descobre quantos elementos precisa quando o programa é executado.

Matrizes dinâmicas resolvem esse problema: você solicita ao sistema operacional um bloco de memória em tempo de execução usando malloc e decide o tamanho com uma variável.

Conheça malloc

malloc (alocação de memória) está em <stdlib.h>. Você passa a quantidade de bytes, e ele retorna um ponteiro para esse bloco ou NULL se falhar.

A memória vem do heap e permanece disponível até que você a libere.

int *p = malloc(10 * sizeof(int));

Dimensionando com sizeof

Nunca fixe quantidades de bytes no código. Use sizeof para que seu código continue correto em diferentes plataformas.

Para alocar espaço para n inteiros, multiplique n por sizeof(int). Um padrão comum é n * sizeof(*p), que usa o próprio tipo do ponteiro.

int *p = malloc(n * sizeof(*p));

Sempre verifique NULL

Se o sistema ficar sem memória, malloc retornará NULL. Desreferenciar um ponteiro NULL faz o programa travar.

Verifique o resultado antes de usá-lo. Esse simples hábito evita muitas falhas difíceis de depurar.

int *p = malloc(n * sizeof(*p));
if (p == NULL) {
    fprintf(stderr, "out of memory\n");
    return 1;
}

Uma alocação completa

Aqui está um programa completo que aloca espaço para 5 inteiros, preenche-os e os imprime.

Observe a simetria: malloc no início e free no final.

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

int main(void) {
    int n = 5;
    int *a = malloc(n * sizeof(*a));
    if (!a) return 1;
    for (int i = 0; i < n; i++) a[i] = i * i;
    for (int i = 0; i < n; i++) printf("%d\n", a[i]);
    free(a);
    return 0;
}

malloc não zera a memória

A memória obtida com malloc não é inicializada: ela contém qualquer lixo que estivesse ali antes.

Lê-la antes de escrever produz valores imprevisíveis. Sempre atribua um valor a cada elemento antes de lê-lo.

int *a = malloc(3 * sizeof(*a));
/* a[0], a[1], a[2] hold garbage here */
a[0] = 10;

calloc zera a memória para você

calloc(count, size) aloca espaço para count elementos de size bytes e define todos os bytes como zero.

Use-o quando quiser uma matriz limpa e preenchida com zeros. Ele também protege contra estouro na multiplicação.

int *a = calloc(5, sizeof(*a));
/* every element is now 0 */

calloc em ação

Este programa usa calloc e confirma que a matriz começa com zeros antes de alterá-la.

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

int main(void) {
    int n = 4;
    int *a = calloc(n, sizeof(*a));
    if (!a) return 1;
    for (int i = 0; i < n; i++) printf("%d\n", a[i]);
    free(a);
    return 0;
}

Indexando o bloco

Um ponteiro para um bloco do heap se comporta como um nome de matriz. Você pode usar a[i] para ler e escrever qualquer elemento de 0 a n-1.

Internamente, a[i] equivale a *(a + i).

int *a = malloc(3 * sizeof(*a));
a[0] = 1;
*(a + 1) = 2;   /* same as a[1] = 2 */
a[2] = 3;

Fique atento aos limites

Se você alocar n elementos, os índices válidos vão de 0 a n-1. Escrever em a[n] é um comportamento indefinido.

C não verifica os limites por você, portanto um erro de deslocamento de uma posição pode corromper a memória silenciosamente.

int *a = malloc(3 * sizeof(*a));
a[2] = 99;   /* OK, last valid index */
/* a[3] = 0;  BUG: out of bounds */

Lendo o tamanho em tempo de execução

Esse é o verdadeiro poder: o tamanho pode vir de uma entrada, de um arquivo ou de um cálculo. O mesmo código aloca 2 ou 2 milhões de elementos.

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

int main(void) {
    int n = 6;            /* could be scanf'd */
    long *a = malloc(n * sizeof(*a));
    if (!a) return 1;
    long sum = 0;
    for (int i = 0; i < n; i++) { a[i] = i + 1; sum += a[i]; }
    printf("%ld\n", sum);
    free(a);
    return 0;
}

Verificação rápida

Teste seu entendimento sobre alocação.

Recapitulação

Você aloca uma matriz dinâmica com malloc(n * sizeof(*p)) ou uma matriz preenchida com zeros usando calloc(n, sizeof(*p)).

Sempre verifique NULL, lembre-se de que malloc deixa lixo na memória, use índices de 0 a n-1 e associe cada alocação a um free. Em seguida, você aprenderá a redimensionar um bloco mantendo seus dados.

Perguntas Frequentes

A aula “Alocando um vetor” é grátis?

Sim — o texto completo de “Alocando um vetor” é 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 “Alocando um vetor”?

Reserve memória no heap. 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 1 de 4.

Quanto tempo leva a aula “Alocando um vetor”?

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