Aula 24a - Arrays (Vetores) em C

1. O que é um Array?

Um array (ou vetor) é uma sequência de elementos do mesmo tipo, armazenados em posições contíguas na memória. O acesso a qualquer elemento é feito pelo seu índice (posição), que em C começa sempre em zero.

Imagine que você precisa guardar as notas de 5 alunos. Sem array, seria:

float nota0, nota1, nota2, nota3, nota4;  // 5 variáveis separadas — impraticável para 100 alunos

Com array:

float notas[5];  // 5 floats em sequência na memória, acessíveis por índice

Visualização na memória

Índice	0	1	2	3	4
Variável	`notas[0]`	`notas[1]`	`notas[2]`	`notas[3]`	`notas[4]`
Endereço (exemplo)	1000	1004	1008	1012	1016

Cada float ocupa 4 bytes, então os endereços avançam de 4 em 4. Os elementos ficam lado a lado na memória — isso é o que torna o acesso por índice tão rápido.

2. Declaração e Inicialização

Sintaxe de declaração

tipo nome[tamanho];

O tamanho deve ser uma constante inteira positiva conhecida em tempo de compilação (C89/C90). Em C99 em diante, pode ser uma variável (VLA — Variable Length Array), mas isso é assunto avançado.

Formas de inicialização

// Forma 1 — inicialização na declaração com lista
int idades[5] = {20, 25, 30, 35, 40};

// Forma 2 — tamanho deduzido pelo compilador (conta os elementos)
int idades[] = {20, 25, 30, 35, 40};   // compilador define tamanho = 5

// Forma 3 — inicialização parcial (restante recebe 0)
int idades[5] = {20, 25};              // idades = {20, 25, 0, 0, 0}

// Forma 4 — zerar todo o array (idioma C clássico)
int idades[5] = {0};                   // idades = {0, 0, 0, 0, 0}

// Forma 5 — declaração sem inicialização (contém lixo de memória!)
int idades[5];                         // PERIGO: valores imprevisíveis

Lixo de memória: Em C, declarar um array sem inicializar não zera os valores — cada posição contém o que estiver na memória naquele momento ("lixo"). Diferente do Java, onde campos de instância são zerados automaticamente. Sempre inicialize antes de usar!

O idioma = {0} é a forma mais compacta de zerar um array inteiro. Funciona porque C garante que elementos não especificados na lista de inicialização recebem zero. Assim, especificar apenas o primeiro como zero faz os demais seguirem a mesma regra.

3. Acessando e Percorrendo Elementos

Leitura e escrita por índice

#include <stdio.h>

int main() {
    int notas[5] = {7, 8, 6, 9, 5};

    notas[2] = 10;                        // modifica o 3º elemento (índice 2)
    printf("Nota 3: %d\n", notas[2]);     // lê o 3º elemento
    return 0;
}

Nota 3: 10

Percorrendo com for

#include <stdio.h>

int main() {
    float notas[] = {7.5, 8.0, 6.5, 9.0, 5.5};
    int n = 5;
    float soma = 0;

    for (int i = 0; i < n; i++) {
        soma += notas[i];
        printf("notas[%d] = %.1f\n", i, notas[i]);
    }

    printf("Média: %.2f\n", soma / n);
    return 0;
}

notas[0] = 7.5
notas[1] = 8.0
notas[2] = 6.5
notas[3] = 9.0
notas[4] = 5.5
Média: 7.30

Preenchendo com scanf

#include <stdio.h>
#define N 5

int main() {
    int v[N];
    printf("Digite %d inteiros:\n", N);
    for (int i = 0; i < N; i++) {
        printf("v[%d]: ", i);
        scanf("%d", &v[i]);         // &v[i] = endereço do elemento i
    }

    printf("Você digitou: ");
    for (int i = 0; i < N; i++)
        printf("%d ", v[i]);
    printf("\n");
    return 0;
}

4. ⚠️ Sem Verificação de Limites — A Diferença Mais Perigosa em Relação ao Java

Em Java, acessar um índice fora do array lança imediatamente uma ArrayIndexOutOfBoundsException, interrompendo o programa de forma controlada. Em C, não existe nenhuma verificação automática de limites. Acessar além do fim do array é comportamento indefinido (Undefined Behavior — UB).

O que acontece em Java vs C

Java — erro detectado e reportado:

int[] v = new int[5];
v[10] = 42;  // lança exceção

Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException:
Index 10 out of bounds for length 5

✅ Programa para, erro identificado.

C — comportamento indefinido, silencioso:

int v[5];
v[10] = 42;  // UB — sem aviso!
printf("%d\n", v[10]);

Possíveis resultados:
• Imprime algum valor lixo (42, -1073741824, ...)
• Corrompe outra variável na memória
• Segmentation fault (crash)
• Parece funcionar — mas o dano já foi feito

❌ Pode parecer OK e ainda assim ser catastrófico.

Por que isso é tão grave?

Quando você escreve em v[10] num array de tamanho 5, você está escrevendo em memória que pertence a outra variável, ao sistema operacional, ou a código do programa. Os efeitos são imprevisíveis:

Cenário	O que pode acontecer
Leitura fora do array	Retorna "lixo" — valor de outra variável ou área de memória não inicializada
Escrita fora do array	Corrompe silenciosamente outra variável; o bug pode se manifestar muito depois, em ponto diferente do código
Acesso a área do SO	Segmentation fault — programa termina abruptamente
Buffer overflow	Vulnerabilidade de segurança clássica — pode ser explorada por hackers para executar código arbitrário

Regra de ouro: Em C, você é responsável por não ultrapassar os limites. O compilador não vai avisá-lo. O programa pode não travar imediatamente. O erro pode aparecer longe do ponto onde foi cometido. Por isso, sempre use a variável de controle do loop (i < n) e nunca i <= n.

Exemplo do erro mais comum

int v[5] = {1, 2, 3, 4, 5};

// ERRADO — acessa v[5] que não existe!
for (int i = 0; i <= 5; i++)       // ← i <= 5 (deveria ser i < 5)
    printf("%d ", v[i]);

// CORRETO
for (int i = 0; i < 5; i++)        // ← i < 5
    printf("%d ", v[i]);

A diferença entre < e <= na condição do loop é responsável por inúmeros bugs em C. Um array de tamanho n tem índices de 0 a n-1. O índice n já está fora.

Aula 24a — Arrays (Vetores) Parte 1 de 2