Um vetor é um tipo de dado derivado de outros tipos de dados primitivos ou do usuário em que seus elementos são armazenados de forma justaposta.

Nesta parte, vamos aprender a declarar um vetor, como acessar e alterar elementos, como percorrer o conteúdo do vetor e outras operações básicas aplicadas a vetores.

Algumas características:

1. Elementos sequenciais
2. Estático
3. Elemento identificado por índice
4. Elemento pode ser atualizado
5. Não pode ser redimensionado
6. Elementos homogêneos

Em uma das formas de declaração, utilizamos a inferência de tipo de dados padrão da linguagem Rust. Nessa forma, é necessário iniciar o vetor com valores.

Sintaxe:

let [mut] variavel = [valor1, valor2, valor3, valorN];

Exemplo 1

fn main() 
{
  let array = [1,2,3,4,5];
  println!("{:?}",array);
}

Saída

[1, 2, 3, 4, 5]

Uma segunda forma para declaração de array é que informamos o tipo de dado a qual queremos que seus elemento sejam e também a quantidade de elementos que o array terá.

Sintaxe:

let [mut] variavel:[tipo_dado;num_elems] = [valor1, valor2, valor3, valorN];

Exemplo 2

fn main() 
{
  let array:[i8;5] = [1,2,3,4,5];
  println!("{:?}",array);
}

Saída

[1, 2, 3, 4, 5]

E uma terceira forma básica é reservado espaço para os elementos do vetor para posterior preechimento como pode ser visto na sintaxe e exemplo logo abaixo:

Sintaxe:

let [mut] variavel:[tipo_dado;num_elems];

Onde:

tipo_dado : tipo de dado do elemento
num_elems: número de elementos do vetor

Exemplo 3

fn main() 
{
  let mut vetor:[i8;5];
}

Saída

-

O acesso a um array é semelhante a todas outras linguagens de programação. Utilizamos o índice associado a um elemento para acessar e atualizar o valor desse elemento.

Sintaxe:

variavel_vetor[indice]

Exemplo 4

fn main() {
 
    let mut palavras:[&str;5]=["Rust!";5];
    
    println!("Antes {:?}",palavras);
    
    //indice/posição 0
    palavras[0] = "Olá,";
    palavras[1] = "Bem vindo ao";
    palavras[2] = "mundo dos";
    palavras[3] = "array em";
    println!("Depois {:?}",palavras);
}

Saída

Antes ["Rust!", "Rust!", "Rust!", "Rust!", "Rust!"]
Depois ["Olá,", "Bem vindo ao", "mundo dos", "array em", "Rust!"]

Para percorrer um vetor em Rust, podemos utilizar o comando de repetição for, por exemplo, como mostrado na sintaxe e exemplo a seguir:

Sintaxe:

for elemento in <variavel_vetor> {
    //omitido
}

Exemplo 5

fn main() {
 
    let palavras:[&str;5]=["Rust!";5];
    let mut indice = 0;
    
    for valor in palavras{
        println!("indice:{} valor:{}",indice,valor);
        indice+=1;
    }
}

Saída

indice:0 valor:Rust!
indice:1 valor:Rust!
indice:2 valor:Rust!
indice:3 valor:Rust!
indice:4 valor:Rust!

Os comandos de repetição loop e while podem ser utilizados como substitutos do comando for utilizado no exemplo acima.

Caso não em algum momento haja a necessidade da informação sobre o número de elementos contidos em um vetor, podemos utilizar a função len:

Sintaxe:

variavel_vetor.len() 

Retorno:

Inteiro contendo o número de elementos de variavel_vetor

Exemplo 6

fn main() 
{
    let valores: [i32; 10] = [3; 10];
    println!("{:?}", valores.len());    
}

Saída

10

O uso de vetor como parâmetro é feito declarando um parâmetro com apenas o tipo de dado do vetor como mostrado na sintaxe abaixo:

Sintaxe: parâmetro

fn nome_funcao(nome_param: &[tipo_dado]) //imutável
fn nome_funcao(nome_param: &mut &[tipo_dado]) //mutável

Sintaxe: argumento

nome_funcao(&mut variavel_vetor); //mutável
nome_funcao(&variavel_vetor); //imutável

Exemplo 7

//mutável
fn funcao1(vet: &mut [i32]) {
    //alteração
}

//imutável
fn funcao2(vet: &[i32]) {
    //uso sem alteração
}

fn main() {
    let mut vet1:[i32;3] = [1, 2, 3];
    let vet2:[i32;3] = [4,5,6];
    
    funcao1(&mut vet);
    funcao2(&vet2);
}

Saída

-

Para retornar um vetor em Rust, é necessário informar o número de elementos contido no vetor de retorno na declaração do retorno da função. Duas formas básicas são mostradas abaixo:

Sintaxe: declaração retorno

fn nome_funcao() -> [i32, QTD]                   //dimensão fixa
fn nome_funcao<const QTD: usize>() -> [i32, QTD] //dimensão variável

Sintaxe: uso função

nome_funcao::<QTD>(); //dimensão variável
nome_funcao(); //dimensão fixa

Onde:

QTD : número de elementos do vetor

Exemplo 8

//uso de generics
fn funcao1<const QTD: usize>() -> [i32; QTD] {
    let vet:[i32;QTD] = [-1;QTD]; //mut se sofre mudança
    //preechimento de elementos
    return vet;
}

fn funcao2() -> [i32;3]{
    let vet:[i32;3] = [0;3]; //mut se sofre mudança
    //preechimento de elementos
    return vet;
}

fn main() {
    let vet:[i32;3] = funcao1::<3>();
    println!("{:?}",vet);
    
    let vet2:[i32;3] = funcao2();
    println!("{:?}",vet2);
}

Saída

[-1, -1, -1]
[0, 0, 0]

Para retorno vetor dinâmico, o tipo de dado Vector deve ser utilizado. Esse tipo de dado será visto em Rust: EDD > Vector com mais informações.

O que foi discutido nesse tópico também é valido para o uso de vetor como parâmetro, argumento e retorno de métodos. Esse assunto pode ser visto em Rust POO > Método como mais informações.

1. 16/08/2026 - versão inicial: declaração, acesso, iteração, número de elementos e 'função e vetor'