Um die verschiedenen numerischen Datentypen dir zu zeigen, möchte ich zunächst einen kleinen Taschenrechner mit dir programmieren. Mit diesem Beispiel kannst du recht einfach die numerischen Datentypen in Rust kennenlernen und auch die Grenzen von diesen.
Im letzten Beitrag zu Rust Erste Schritte in Rust: 2. Ausgaben auf der Konsole mit println! habe ich dir bereits gezeigt, wie du Ausgaben auf der Konsole erzeugen kannst. Dieses wollen wir hier ebenso nutzen, aber noch zusätzlich eine neue Funktion lernen, wie man Eingaben von der Konsole entgegennimmt.
Inhaltsverzeichnis
- Neues Projekt – Taschenrechner erstellen und laden
- Eingaben vom Benutzer entgegennehmen
- Aufbau von einem kleinen Menü
- Abfragen der Zahlen 1 & 2
- Ausführen der Grundrechenarten, addition, subtraktion, multiplikation und division in Rust
- Gültigkeitsbereiche der numerischen Datentypen in Rust
Neues Projekt – Taschenrechner erstellen und laden
Erstellen wir uns zunächst ein neues Projekt „taschenrechner“ mit dem Befehl:
PS C:\Users\StefanDraeger\Rust> cargo new taschenrechner
Created binary (application) `taschenrechner` package
PS C:\Users\StefanDraeger\Rust>Im nächsten Schritt laden wir uns dieses Projekt über „Explorer“ > „Open Folder“ Wahl des Ordners „taschenrechner“.
Eingaben vom Benutzer entgegennehmen
Schweifen wir zunächst etwas ab und klären, wie man Eingaben vom Benutzer entgegennehmen kann.
Zunächst müssen wir die Bibliothek „io“ aus dem Paket „std“ laden.
use std::io;
In der Funktion main welche beim starten des Programmes ausgeführt wird, legen wir uns zunächst ein Feld vom Typ String an und geben auf der Kommandozeile die Zeichenkette „Eingabe:“ aus.
let mut eingabe = String::new();
println!("Eingabe:");
Im Anschluss können wir dann den Text mit dem nachfolgenden Befehl in das zuvor angelegte Feld speichern. Sollte dabei etwas schiefgehen, dann wird eine Fehlermeldung ausgegeben.
io::stdin().read_line(&mut eingabe).expect("Die Eingabe ist nicht gültig!");
Nun können wir die Eingabe welche sich jetzt im Feld „eingabe“ befindet behandeln, zbsp. mit If-Statements etc. In meinem Fall gebe ich diese einfach wieder auf der Konsole aus.
println!("Sie haben '{}' eingegeben.", eingabe.trim());
Hier jetzt das gesamte kleine Programm zum Lesen von Benutzereingaben von der Konsole. Wenn du weitere Informationen dazu benötigst, dann empfehle ich dir die offizielle englische Dokumentation unter https://doc.rust-lang.org/std/io/struct.Stdin.html#method.read_line.
use std::io;
fn main() {
//Erzeugen eines neuen String Objektes
let mut eingabe = String::new();
//Ausgeben der Zeile "Eingabe:"
println!("Eingabe:");
//Abfragen der Eingabe, die Eingabe wird in die Variable "eingabe" übergeben
//Wenn ein Fehler auftritt wird eine Meldung ausgegeben
io::stdin().read_line(&mut eingabe).expect("Die Eingabe ist nicht gültig!");
//Ausgeben des Inhalts der Variable "eingabe"
println!("Sie haben '{}' eingegeben.", eingabe.trim());
}
Der Code fragt lediglich eine Eingabe ab und übergibt diese Eingabe in die Variable „eingabe“ diese können wir im weiteren Verlauf dann abfragen und je nach Wert eine andere Funktion aufrufen.
In meinem Beispiel gebe ich diese zunächst einfach auf der Konsole wieder aus.
Aufbau von einem kleinen Menü
Unser Taschenrechner soll am Anfang einfach nur zwei Zahlen verarbeiten, dabei möchten wir zunächst die mathematische Funktion auswählen sowie eine Funktion anbieten, das Programm zu verlassen.
let error_msg = "Die Eingabe ist nicht gültig!";
println!("Taschenrechner");
println!("--------------");
println!("[1] - addition (+)");
println!("[2] - subtraktion (-)");
println!("[3] - multiplikation (*)");
println!("[4] - division (:)");
println!("[E] - Ende");
println!("");
println!("Auswahl (1,2,3,4,E):");
let mut eingabe = String::new();
io::stdin().read_line(&mut eingabe).expect(error_msg);
Im nächsten Schritt prüfen wir die Eingabe. Dabei müssen wir den Wert im Feld „eingabe“ auch trimmen, d.h. die Leerzeichen sowie Zeilenumbrüche werden am Anfang und Ende entfernt.
Im ersten If-Statement prüfen wir, ob der Benutzer ein „e“ oder „E“ eingetragen hat, wenn dieses nicht so ist, dann wird geprüft, ob eine der Zahlen 1 bis 4 eingegeben wurde und dann werden die beiden zu behandelnden Zahlen abgefragt.
if !eingabe.trim().to_lowercase().eq("e") {...}
Abfragen der Zahlen 1 & 2
Nun müssen die beiden Zahlen abgefragt werden, diese werden wie zuvor die Menüauswahl in ein String geschrieben welches wir dann auf ein Feld vom Typ Float zuweisen.
let mut zahl1_str = String::new();
let mut zahl2_str = String::new();
println!("Zahl 1 eingeben:");
io::stdin().read_line(&mut zahl1_str).expect(error_msg);
println!("Zahl 2 eingeben:");
io::stdin().read_line(&mut zahl2_str).expect(error_msg);
let a: f32 = zahl1_str.trim().parse().unwrap();
let b: f32 = zahl2_str.trim().parse().unwrap();
let mut ergebniss: f32 = 0.0;
Im unteren Abschnitt „Gültigkeitsbereiche der numerischen Datentypen in Rust“ habe ich dir die numerischen Datentypen mit deren Gültigkeitsbereiche aufgelistet. Da in unserem Fall große Zahlen eingegeben werden sollen und auch mit Komma wählen wir hier den Datentyp f32.
Wenn du jetzt jedoch zweimal die maximale Zahl für f32 eingibst und dieses nutzt, dann erhältst du eine Fehlermeldung.
Compiling taschenrechner v0.1.0 (C:\Users\DraeS\Rust\taschenrechner)
Finished dev [unoptimized + debuginfo] target(s) in 0.64s
Running `target\debug\taschenrechner.exe`
infAusführen der Grundrechenarten, addition, subtraktion, multiplikation und division in Rust
Unser Ergebnis der Grundrechenarten legen wir in einer Variable „ergebniss“ ab, diese ist für alle gültig daher legen wir diese einmalig vor den If-Statements ab und weisen dieser dann lediglich den neuen Wert zu.
Am Ende wird dann das Ergebnis auf der Konsole ausgegeben und das Programm beendet.
let mut ergebniss: f32 = 0.0;
if eingabe.trim().eq("1") {
ergebniss = a + b;
} else if eingabe.trim().eq("2") {
ergebniss = a - b;
} else if eingabe.trim().eq("3") {
ergebniss = a * b;
} else if eingabe.trim().eq("4") {
ergebniss = a / b;
}
println!("Ergebniss: {}", ergebniss);
Nachfolgend nun eine Beispielausgabe vom kleinen Taschenrechner in Rust.
Gültigkeitsbereiche der numerischen Datentypen in Rust
Nachfolgend findest du die Gültigkeitsbereiche der numerischen Datentypen.
Der Code zum Bild:
fn main() {
let space_big = "\t\t\t\t\t\t";
println!("numerische Datentypen");
println!("Datentyp\t|MIN{}|MAX",space_big);
println!("---------------------------------------------------------------------------------------------------------");
println!("u8\t\t|{0}{2}|{1}", std::u8::MIN, std::u8::MAX, space_big);
println!("u16\t\t|{0}{2}|{1}", std::u16::MIN, std::u16::MAX, space_big);
println!("u32\t\t|{0}{2}|{1}", std::u32::MIN, std::u32::MAX, space_big);
println!("u64\t\t|{0}{2}|{1}", std::u64::MIN, std::u64::MAX, space_big);
println!("u128\t\t|{0}{2}|{1}", std::u128::MIN, std::u128::MAX, space_big);
println!("---------------------------------------------------------------------------------------------------------");
println!("i8\t\t|{0}{2}|{1}", std::i8::MIN, std::i8::MAX, space_big);
println!("i16\t\t|{0}{2}|{1}", std::i16::MIN, std::i16::MAX, space_big);
println!("i32\t\t|{0}{2}|{1}", std::i32::MIN, std::i32::MAX, "\t\t\t\t\t");
println!("i64\t\t|{0}{2}|{1}", std::i64::MIN, std::i64::MAX, "\t\t\t\t");
println!("i128\t\t|{0}{2}|{1}", std::i128::MIN, std::i128::MAX, "\t");
println!("---------------------------------------------------------------------------------------------------------");
println!("f32\t\t|{0}{2}|{1}", format!("{:+e}", std::f32::MIN), format!("{:+e}", std::f32::MAX), "\t\t\t\t\t");
println!("f64\t\t|{0}{2}|{1}", format!("{:+e}", std::f64::MIN), format!("{:+e}", std::f64::MAX), "\t\t\t");
}