📊 Declarando Arrays
"Um array (vetor) é uma coleção sequencial de elementos do mesmo tipo, armazenados contiguamente na memória e acessados por um índice numérico."
Arrays são estruturas de dados fundamentais que permitem armazenar múltiplos valores do mesmo tipo sob um único nome. Em vez de declarar dezenas de variáveis individuais, você declara um array e acessa cada elemento por sua posição (índice).
📝 Declaração Básica
A sintaxe para declarar um array é: tipo nome[tamanho];
// Declaração de arrays de diferentes tipos
int numeros[10]; // Array de 10 inteiros
float precos[5]; // Array de 5 floats
char nome[50]; // Array de 50 caracteres (string)
double medidas[100]; // Array de 100 doubles
// Usando constante para o tamanho (recomendado)
const int MAX_ALUNOS = 30;
float notas[MAX_ALUNOS];
⚠️ Importante: Em C/C++, o tamanho do array deve ser uma constante conhecida em tempo de compilação (para arrays alocados na pilha). Para tamanhos dinâmicos, use new/delete ou std::vector.
🔢 Acesso aos Elementos
Os elementos são acessados usando o operador [] com um índice. O primeiro elemento está no índice 0, e o último no índice tamanho - 1.
int valores[5] = {10, 20, 30, 40, 50};
valores[0] = 100; // Modifica o primeiro elemento
cout << valores[2]; // Acessa o terceiro elemento (30)
cout << valores[4]; // Acessa o último elemento (50)
// Índices podem ser variáveis
int i = 3;
valores[i] = 999; // Modifica o elemento no índice 3
🎯 Inicialização de Arrays
Existem várias formas de inicializar um array no momento da declaração.
// Inicialização completa
int a[5] = {1, 2, 3, 4, 5};
// Inicialização parcial (o resto é zerado)
int b[5] = {1, 2}; // {1, 2, 0, 0, 0}
// Tamanho inferido pelo compilador
int c[] = {10, 20, 30, 40}; // Array de 4 elementos
// Inicializar todos com zero
int d[100] = {0}; // Todos os 100 elementos são 0
// Inicialização uniforme (C++11)
int e[]{1, 2, 3, 4, 5}; // Tamanho inferido
🔄 Percorrendo Arrays com Laços
Arrays são frequentemente processados usando estruturas de repetição.
For Tradicional
int numeros[] = {2, 4, 6, 8, 10};
int tamanho = sizeof(numeros) / sizeof(numeros[0]);
for (int i = 0; i < tamanho; i++) {
cout << "Elemento " << i << ": " << numeros[i] << endl;
}
Range-based For (C++11)
int numeros[] = {2, 4, 6, 8, 10};
for (int n : numeros) {
cout << n << " ";
}
// Com referência para modificar os elementos
for (int &n : numeros) {
n *= 2; // Dobra cada elemento
}
🧮 Arrays Multidimensionais (Matrizes)
Arrays podem ter mais de uma dimensão, formando matrizes (2D), cubos (3D) ou estruturas de maior dimensionalidade.
// Declaração de uma matriz 3x3
int matriz[3][3];
// Inicialização de uma matriz 2x3
int tabela[2][3] = {
{1, 2, 3},
{4, 5, 6}
};
// Acesso a elementos
matriz[1][2] = 42; // Linha 1, coluna 2
cout << tabela[0][1]; // 2
// Percorrendo uma matriz com laços aninhados
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
cout << tabela[i][j] << " ";
}
cout << endl;
}
📏 Obtendo o Tamanho de um Array
Em C/C++, arrays não armazenam seu próprio tamanho. Para arrays alocados na pilha, use o operador sizeof.
int arr[] = {10, 20, 30, 40, 50};
// Calcula o número de elementos
int tamanho = sizeof(arr) / sizeof(arr[0]);
cout << "Tamanho: " << tamanho << endl; // 5
// Em C++17, pode-se usar std::size()
#include <iterator>
cout << std::size(arr) << endl; // 5
⚠️ Cuidado: Quando um array é passado para uma função, ele "decai" para um ponteiro, e sizeof retornará o tamanho do ponteiro, não do array original. Passe o tamanho como parâmetro adicional.
📊 Arrays vs. std::array e std::vector
| Característica | Array C-style | std::array (C++11) | std::vector |
|---|
| Tamanho | Fixo, conhecido em compilação | Fixo, conhecido em compilação | Dinâmico, pode crescer |
| Conhece o próprio tamanho? | Não | Sim (método size()) | Sim (método size()) |
| Verificação de limites | Não | at() verifica | at() verifica |
| Alocação | Pilha (stack) | Pilha (stack) | Heap (memória dinâmica) |
🔗 Conclusão
Arrays são a base para muitas estruturas de dados e algoritmos. Compreender sua declaração, inicialização e manipulação é essencial para qualquer programador C/C++. Lembre-se sempre dos limites do array para evitar acessos inválidos que podem causar comportamentos imprevisíveis ou falhas de segurança (buffer overflow). Em C++ moderno, prefira std::array ou std::vector para maior segurança e funcionalidade.
⏭️ Próximo: Definindo novos tipos...
0 Comentários