Rost - Array
In diesem Kapitel lernen wir ein Array und die verschiedenen damit verbundenen Funktionen kennen. Bevor wir uns mit Arrays befassen, wollen wir sehen, wie sich ein Array von einer Variablen unterscheidet.
Variablen haben die folgenden Einschränkungen:
Variablen sind skalarer Natur. Mit anderen Worten, eine Variablendeklaration kann jeweils nur einen Wert enthalten. Dies bedeutet, dass zum Speichern von n Werten in einem Programm n eine Variablendeklaration erforderlich ist. Daher ist die Verwendung von Variablen nicht möglich, wenn eine größere Sammlung von Werten gespeichert werden muss.
Variablen in einem Programm wird Speicher in zufälliger Reihenfolge zugewiesen, wodurch es schwierig wird, die Werte in der Reihenfolge ihrer Deklaration abzurufen / zu lesen.
Ein Array ist eine homogene Sammlung von Werten. Einfach ausgedrückt ist ein Array eine Sammlung von Werten desselben Datentyps.
Merkmale eines Arrays
Die Funktionen eines Arrays sind wie folgt aufgeführt:
Eine Array-Deklaration weist sequentielle Speicherblöcke zu.
Arrays sind statisch. Dies bedeutet, dass die Größe eines einmal initialisierten Arrays nicht geändert werden kann.
Jeder Speicherblock repräsentiert ein Array-Element.
Array-Elemente werden durch eine eindeutige Ganzzahl identifiziert, die als Index / Index des Elements bezeichnet wird.
Das Auffüllen der Array-Elemente wird als Array-Initialisierung bezeichnet.
Array-Elementwerte können aktualisiert oder geändert, aber nicht gelöscht werden.
Arrays deklarieren und initialisieren
Verwenden Sie die unten angegebene Syntax, um ein Array in Rust zu deklarieren und zu initialisieren.
Syntax
//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];In der ersten Syntax wird der Typ des Arrays während der Initialisierung aus dem Datentyp des ersten Elements des Arrays abgeleitet.
Abbildung: Einfaches Array
Das folgende Beispiel gibt explizit die Größe und den Datentyp des Arrays an. Die {:?} Syntax der Funktion println! () Wird verwendet, um alle Werte im Array zu drucken. Die Funktion len () wird verwendet, um die Größe des Arrays zu berechnen.
fn main(){
let arr:[i32;4] = [10,20,30,40];
println!("array is {:?}",arr);
println!("array size is :{}",arr.len());
}Ausgabe
array is [10, 20, 30, 40]
array size is :4Abbildung: Array ohne Datentyp
Das folgende Programm deklariert ein Array von 4 Elementen. Der Datentyp wird in der Variablendeklaration nicht explizit angegeben. In diesem Fall ist das Array vom Typ Integer. Die Funktion len () wird verwendet, um die Größe des Arrays zu berechnen.
fn main(){
let arr = [10,20,30,40];
println!("array is {:?}",arr);
println!("array size is :{}",arr.len());
}Ausgabe
array is [10, 20, 30, 40]
array size is :4Abbildung: Standardwerte
Im folgenden Beispiel wird ein Array erstellt und alle seine Elemente mit dem Standardwert -1 initialisiert .
fn main() {
let arr:[i32;4] = [-1;4];
println!("array is {:?}",arr);
println!("array size is :{}",arr.len());
}Ausgabe
array is [-1, -1, -1, -1]
array size is :4Abbildung: Array mit for-Schleife
Das folgende Beispiel durchläuft ein Array und druckt die Indizes und ihre entsprechenden Werte. Die Schleife ruft Werte vom Index 0 bis 4 (Index des letzten Array-Elements) ab.
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]);
}
}Ausgabe
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 : 40Abbildung: Verwenden der Funktion iter ()
Die Funktion iter () ruft Werte aller Elemente in einem Array ab.
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);
}
}Ausgabe
array is [10, 20, 30, 40]
array size is :4
value is :10
value is :20
value is :30
value is :40Abbildung: Veränderbares Array
Mit dem Schlüsselwort mut kann ein veränderbares Array deklariert werden. Das folgende Beispiel deklariert ein veränderbares Array und ändert den Wert des zweiten Array-Elements.
fn main(){
let mut arr:[i32;4] = [10,20,30,40];
arr[1] = 0;
println!("{:?}",arr);
}Ausgabe
[10, 0, 30, 40]Übergeben von Arrays als Parameter an Funktionen
Ein Array kann als Wert oder als Verweis auf Funktionen übergeben werden.
Abbildung: Wert übergeben
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);
}Ausgabe
Inside update [0, 0, 0]
Inside main [10, 20, 30]Abbildung: Als Referenz übergeben
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);
}Ausgabe
Inside update [0, 0, 0]
Inside main [0, 0, 0]Array-Deklaration und Konstanten
Betrachten wir ein Beispiel unten, um die Array-Deklaration und -Konstanten zu verstehen.
fn main() {
let N: usize = 20;
let arr = [0; N]; //Error: non-constant used with constant
print!("{}",arr[10])
}Der Compiler führt zu einer Ausnahme. Dies liegt daran, dass die Länge eines Arrays zur Kompilierungszeit bekannt sein muss. Hier wird zur Laufzeit der Wert der Variablen "N" ermittelt. Mit anderen Worten, Variablen können nicht zum Definieren der Größe eines Arrays verwendet werden.
Das folgende Programm ist jedoch gültig -
fn main() {
const N: usize = 20;
// pointer sized
let arr = [0; N];
print!("{}",arr[10])
}Der Wert eines Bezeichners mit dem Schlüsselwort const wird zur Kompilierungszeit definiert und kann zur Laufzeit nicht geändert werden. usize hat eine Zeigergröße, daher hängt seine tatsächliche Größe von der Architektur ab, für die Sie Ihr Programm kompilieren.