Óxido - Matriz

En este capítulo, aprenderemos sobre una matriz y las diversas características asociadas a ella. Antes de aprender sobre las matrices, veamos en qué se diferencia una matriz de una variable.

Las variables tienen las siguientes limitaciones:

Las variables son de naturaleza escalar. En otras palabras, una declaración de variable solo puede contener un valor a la vez. Esto significa que para almacenar n valores en un programa se necesitará una declaración de n variables. Por tanto, el uso de variables no es factible cuando se necesita almacenar una colección mayor de valores.
A las variables de un programa se les asigna memoria en orden aleatorio, lo que dificulta la recuperación / lectura de los valores en el orden de su declaración.

Una matriz es una colección homogénea de valores. En pocas palabras, una matriz es una colección de valores del mismo tipo de datos.

Características de una matriz

Las características de una matriz se enumeran a continuación:

Una declaración de matriz asigna bloques de memoria secuenciales.
Las matrices son estáticas. Esto significa que no se puede cambiar el tamaño de una matriz una vez inicializada.
Cada bloque de memoria representa un elemento de matriz.
Los elementos de la matriz se identifican mediante un número entero único llamado subíndice / índice del elemento.
Completar los elementos de la matriz se conoce como inicialización de la matriz.
Los valores de los elementos de la matriz se pueden actualizar o modificar, pero no se pueden eliminar.

Declarar e inicializar matrices

Utilice la sintaxis que se proporciona a continuación para declarar e inicializar una matriz en Rust.

Sintaxis

//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];

En la primera sintaxis, el tipo de la matriz se infiere del tipo de datos del primer elemento de la matriz durante la inicialización.

Ilustración: Matriz simple

El siguiente ejemplo especifica explícitamente el tamaño y el tipo de datos de la matriz. La sintaxis {:?} De la función println! () Se usa para imprimir todos los valores en la matriz. La función len () se usa para calcular el tamaño de la matriz.

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

Salida

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

Ilustración: matriz sin tipo de datos

El siguiente programa declara una matriz de 4 elementos. El tipo de datos no se especifica explícitamente durante la declaración de la variable. En este caso, la matriz será de tipo integer. La función len () se usa para calcular el tamaño de la matriz.

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

Salida

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

Ilustración: valores predeterminados

El siguiente ejemplo crea una matriz e inicializa todos sus elementos con un valor predeterminado de -1 .

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

Salida

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

Ilustración: Matriz con bucle for

El siguiente ejemplo recorre en iteración una matriz e imprime los índices y sus valores correspondientes. El ciclo recupera valores del índice 0 al 4 (índice del último elemento de la 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]);
   }
}

Salida

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

Ilustración: Uso de la función iter ()

La función iter () obtiene los valores de todos los elementos de una 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);
   }
}

Salida

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

Ilustración: Matriz mutable

La palabra clave mut se puede utilizar para declarar una matriz mutable. El siguiente ejemplo declara una matriz mutable y modifica el valor del segundo elemento de la matriz.

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

Salida

[10, 0, 30, 40]

Pasar matrices como parámetros a funciones

Una matriz se puede pasar por valor o por referencia a funciones.

Ilustración: Pase 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);
}

Salida

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

Ilustración: Pasar por referencia

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);
}

Salida

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

Constantes y declaración de matriz

Consideremos un ejemplo que se da a continuación para comprender la declaración de matrices y las constantes.

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

El compilador dará como resultado una excepción. Esto se debe a que la longitud de una matriz debe conocerse en tiempo de compilación. Aquí, el valor de la variable "N" se determinará en tiempo de ejecución. En otras palabras, las variables no se pueden utilizar para definir el tamaño de una matriz.

Sin embargo, el siguiente programa es válido:

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

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

El valor de un identificador prefijado con la palabra clave const se define en tiempo de compilación y no se puede cambiar en tiempo de ejecución. usize tiene el tamaño de un puntero, por lo que su tamaño real depende de la arquitectura para la que está compilando su programa.

↰ Previous page Next page ↱