Ferrugem - Array

Neste capítulo, aprenderemos sobre um array e os vários recursos associados a ele. Antes de aprendermos sobre arrays, vejamos como um array é diferente de uma variável.

As variáveis têm as seguintes limitações -

As variáveis são escalares por natureza. Em outras palavras, uma declaração de variável pode conter apenas um único valor por vez. Isso significa que, para armazenar n valores em um programa, será necessária a declaração de n variáveis. Portanto, o uso de variáveis não é viável quando se precisa armazenar uma coleção maior de valores.
As variáveis em um programa são alocadas na memória em ordem aleatória, dificultando a recuperação / leitura dos valores na ordem de sua declaração.

Uma matriz é uma coleção homogênea de valores. Simplificando, uma matriz é uma coleção de valores do mesmo tipo de dados.

Características de um Array

Os recursos de uma matriz estão listados abaixo -

Uma declaração de array aloca blocos de memória sequencial.
Matrizes são estáticas. Isso significa que uma matriz, uma vez inicializada, não pode ser redimensionada.
Cada bloco de memória representa um elemento do array.
Os elementos da matriz são identificados por um número inteiro único denominado subscrito / índice do elemento.
O preenchimento dos elementos da matriz é conhecido como inicialização da matriz.
Os valores dos elementos da matriz podem ser atualizados ou modificados, mas não podem ser excluídos.

Declarando e inicializando matrizes

Use a sintaxe fornecida a seguir para declarar e inicializar uma matriz em Rust.

Sintaxe

//Syntax1
let variable_name = [value1,value2,value3];

//Syntax2
let variable_name:[dataType;size] = [value1,value2,value3];

//Syntax3
let variable_name:[dataType;size] = [default_value_for_elements,size];

Na primeira sintaxe, o tipo da matriz é inferido do tipo de dados do primeiro elemento da matriz durante a inicialização.

Ilustração: Array Simples

O exemplo a seguir especifica explicitamente o tamanho e o tipo de dados da matriz. A sintaxe {:?} Da função println! () É usada para imprimir todos os valores na matriz. A função len () é usada para calcular o tamanho do array.

fn main(){
   let arr:[i32;4] = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}

Resultado

array is [10, 20, 30, 40]
array size is :4

Ilustração: Array sem tipo de dados

O programa a seguir declara uma matriz de 4 elementos. O tipo de dados não é especificado explicitamente durante a declaração da variável. Nesse caso, a matriz será do tipo inteiro. A função len () é usada para calcular o tamanho do array.

fn main(){
   let arr = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}

Resultado

array is [10, 20, 30, 40]
array size is :4

Ilustração: valores padrão

O exemplo a seguir cria uma matriz e inicializa todos os seus elementos com um valor padrão de -1 .

fn main() {
   let arr:[i32;4] = [-1;4];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}

Resultado

array is [-1, -1, -1, -1]
array size is :4

Ilustração: Array com for loop

O exemplo a seguir itera por meio de uma matriz e imprime os índices e seus valores correspondentes. O loop recupera valores do índice 0 a 4 (índice do último elemento da matriz).

fn main(){
   let arr:[i32;4] = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());

   for index in 0..4 {
      println!("index is: {} & value is : {}",index,arr[index]);
   }
}

Resultado

array is [10, 20, 30, 40]
array size is :4
index is: 0 & value is : 10
index is: 1 & value is : 20
index is: 2 & value is : 30
index is: 3 & value is : 40

Ilustração: Usando a função iter ()

A função iter () busca valores de todos os elementos em uma matriz.

fn main(){

let arr:[i32;4] = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());

   for val in arr.iter(){
      println!("value is :{}",val);
   }
}

Resultado

array is [10, 20, 30, 40]
array size is :4
value is :10
value is :20
value is :30
value is :40

Ilustração: array mutável

A palavra-chave mut pode ser usada para declarar um array mutável. O exemplo a seguir declara uma matriz mutável e modifica o valor do segundo elemento da matriz.

fn main(){
   let mut arr:[i32;4] = [10,20,30,40];
   arr[1] = 0;
   println!("{:?}",arr);
}

Resultado

[10, 0, 30, 40]

Passando Arrays como Parâmetros para Funções

Uma matriz pode ser passada por valor ou por referência a funções.

Ilustração: Passar por valor

fn main() {
   let arr = [10,20,30];
   update(arr);

   print!("Inside main {:?}",arr);
}
fn update(mut arr:[i32;3]){
   for i in 0..3 {
      arr[i] = 0;
   }
   println!("Inside update {:?}",arr);
}

Resultado

Inside update [0, 0, 0]
Inside main [10, 20, 30]

Ilustração: passagem por referência

fn main() {
   let mut arr = [10,20,30];
   update(&mut arr);
   print!("Inside main {:?}",arr);
}
fn update(arr:&mut [i32;3]){
   for i in 0..3 {
      arr[i] = 0;
   }
   println!("Inside update {:?}",arr);
}

Resultado

Inside update [0, 0, 0]
Inside main [0, 0, 0]

Declaração e constantes de array

Vamos considerar um exemplo fornecido a seguir para entender a declaração e as constantes do array.

fn main() {
   let N: usize = 20;
   let arr = [0; N]; //Error: non-constant used with constant
   print!("{}",arr[10])
}

O compilador resultará em uma exceção. Isso ocorre porque o comprimento de um array deve ser conhecido em tempo de compilação. Aqui, o valor da variável "N" será determinado em tempo de execução. Em outras palavras, as variáveis não podem ser usadas para definir o tamanho de um array.

No entanto, o seguinte programa é válido -

fn main() {
   const N: usize = 20; 
   // pointer sized
   let arr = [0; N];

   print!("{}",arr[10])
}

O valor de um identificador prefixado com a palavra-chave const é definido em tempo de compilação e não pode ser alterado em tempo de execução. usize tem o tamanho de um ponteiro, portanto, seu tamanho real depende da arquitetura para a qual você está compilando seu programa.

↰ Previous page Next page ↱