Reflexionen über die Programmiersprache Rust 7

*Komplexe Datentypen: Das Array

Grundkonfiguration eines Arrays

*speichert ausschließlich den gleichen Datentyp
*Größe des Arrays fix

Syntax

let my_array =[1,3,19,27,4];

Zugriff auf ein Array

Entweder wir speichern den gewollten Index wieder in einer neuen Variable, oder geben diesen direkt per println! aus.

    let x = my_array[0]; //Zugriff auf Index 0 via einer Variable
    println!("{x}"); //Ausgabe von x (Index 0 von my_array)
    //oder direkt per println!
    println!("{}", my_array[0]); 

Ändern eines Arrayelements

Vielleicht kann sich nun der eine oder andere von euch eine wichtige Voraussetzung schon vorstellen. Ja? Das Array muss mut sein, sonst funktioniert es nicht. Der Rest ergibt sich praktisch von selbst. Das Element wird per eckigen Klammern ausgewählt und einfach per Gleichheitszeichen umgestellt.

let mut my_array2=[1,2,3,4,5]; //mutables Array wird erstellt
my_array2[4]=7; //Element 4, Ziffer 5 wird auf 7 geändert.
println!("my_array2{:?}",my_array2);

Ausgabe

...

Zugriff auf Array-Slices

Zuerst muss natürlich mal geklärt werden, was denn überhaupt ein Slice ist.
Slice bedeutet einen Bereich auszuwählen. Also zB. von Index 0 bis 2. Dieser muss aber mit einer sogenannten Referenz ausgewählt werden. Die funktioniert mit dem kaufmännischen UND (&), im englischen Ampersand.

Im Beispiel angeführt sind 2 Arten, wie man auf die Indizes zugreift:

let slice1=&my_array[0..2];
println!("Slice1 = {:?}",slice1);
let slice1=&my_array[0..=2];
println!("Slice1 = {:?}",slice1);

Ausgabe:

[0..2] beschreibt eigentlich die Indizes 0 bis 1. Also der linke Index ist inklusiv, der rechte (warum auch immer) muss ein Index höher gewählt werden.
Eine andere Schreibweise, die den rechten Index inklusiv macht, ist vorher noch ein Gleichheitszeichen zu setzen. Also [0..=2]. Dann sind alle 3 Elemente von 0 bis 2 dabei.

Zum Thema Referenzierung und Dergleichen, kommt zu einem späteren Zeitpunkt noch etwas mehr. Vorweg, einfach zu merken:

*primitive Datentypen, wie i32, f64 usw brauchen keine Referenzierung.
*komplexe Datentypen schon.

Genauere Deklaration

Manchmal ist es vielleicht nötig, im Vorfeld genauere Angaben zu machen, was das Array enthalten soll. Dabei hilft die bereits früher erwähnte Annotation.

let my_array3:[u8;5]=[1,2,3,4,6];

Das hier bewirkt, dass 5 Elemente des Datentyps u8 (unsigned integer, Integer die nur höher als 0 sein können) erwartet werden.

Andersrum kann man auch eine kleine Abkürzung nehmen und zB. 50 3er ausgeben lassen (wozu auch immer).

let my_array4 = [3;50];

Ich hatte Schwierigkeiten mir die Reihenfolge zu merken. Aber es half mir dann "Was? Wie oft?"

Zugriff auf Elemente außerhalb des Arrays

Manchmal leistet man sich einen Fehlgriff; nicht so schlimm in Rust.
Nachdem Rust in verschiedene RAM-Typen speichert (wie andere Programmiersprachen auch), könnte man (das kann in C/C++ passieren) in einen Speicherbereich schreiben, den zB ein anderes Programm ausführt. Vielleicht kann sich noch jemand an die Fehlerbezeichnung "Schwere Zugriffsverletzung" erinnern? Solche Fehler wären das.

Wie sieht so etwas aus (das in Rust durch Sicherheitskonzepte nicht funktioniert)?

my_array2[6]=17; 

Zur Erinnerung: my_array2 hatte nur Indizes von 0..4. Index 6 kann es also nicht geben. Das zeigt sich auch, wenn das Programm ausgeführt wird.

Zum Schluss noch die Zusammenfassung und die Ausgabe
(Das kann man kopieren, dann braucht man nicht alles schreiben)

fn main(){
   let my_array =[1,3,19,27,4]; //Array erzeugen
   let x = my_array[0]; //Ausgabe von x (Index 0 von my_array)
   println!("x={x}"); //Ausgabe von x
 //oder direkt per println!
   println!("my_array0={}", my_array[0]);

   let mut my_array2=[1,2,3,4,5]; //mutables Array wird erstellt
   my_array2[4]=7; //Element 4, Ziffer 5 wird auf 7 geändert.
   println!("my_array2{:?}",my_array2);

   //Slices
   let slice1=&my_array[0..2];
   println!("Slice1 = 0..2={:?}",slice1);
   let slice1=&my_array[0..=2];
   println!("Slice1 0..=2={:?}",slice1);

   //Genauere Deklaration
   let my_array3:[u8;5]=[1,2,3,4,6];
   println!("Genaue Deklaration:[u8;5]={:?}", my_array3);


  let my_array4 = [3;50];
  println!("50x3er={:?}", my_array4);

  //Zugriff auf ein Element, dass es im Array nicht gibt erzeugt einen Fehler!
  //my_array2[6]=17;

}

und die Ausgabe aus der Konsole

Das wars fürs Erste mit den Arrays.