Rust - Das umfassende, deutschsprachige Handbuch zur performanten und sicheren Programmierung. Zum Lernen und Nachschlagen, mit Codebeispielen und Tipps

Werden Sie Rust-Profi und entwickeln Sie moderne, sichere Software!
Rust ist für sein cleveres Speichermanagement, hervorrangende Sicherheit und viele beliebte Features bekannt. Nutzen Sie das hervorrangende Design dieser Sprache, um moderne und robuste Software auf professionellem Niveau zu entwickeln! Dieses Handbuch begleitet Sie beim Einstieg und stellt Rust dann detailliert vor - sowohl für systemnahe Prorammierung als auch für Enterprise- und Cloud-Anwendungen. Mit vielen gut kommentierten Codebeispielen, Best Practices und einer durchgehenden Demo-Anwendung. Zugleich lassen sich alle Kapitel gut einzeln lesen und zum Nachschlagen verwenden. Der ideale Weg zu fundierten und umfassenden Kenntnissen!

Aus dem Inhalt:

• Rust installieren, Toolchain aufsetzen


• Fundierter Einstieg


• Speichermanagement


• Traits und Closures


• Collections und Iteratoren


• Asynchrone Programmierung


• Multithreading


• Arbeiten mit Text


• Dokumentation und Test automatisieren


• Schnittstellen zu anderen Sprachen

  Materialien zum Buch ... 18


  1.  Über dieses Buch ... 19


       1.1 ... Was Sie in diesem Buch lernen werden ... 20

       1.2 ... Was dieses Buch Ihnen zeigen möchte ... 21

       1.3 ... Noch mehr Informationen und Guides ... 22

       1.4 ... Danksagung ... 24



  2.  Die Installation, die IDE und 'Hallo Rust' ... 25


       2.1 ... Wie Sie Rust installieren ... 25

       2.2 ... Eine Entwicklungsumgebung wählen ... 28

       2.3 ... Das erste Programm ... 30

       2.4 ... Wie es weitergeht ... 33



  3.  Variablen und Datentypen ... 35


       3.1 ... Prelude: Die Standardimporte ... 35

       3.2 ... Variablen ... 36

       3.3 ... Konstanten ... 56

       3.4 ... Skalare Datentypen ... 60

       3.5 ... Wie Rust mit 'Option
       3.6 ... Zusammenfassung ... 84



  4.  Speichernutzung und Referenzen ... 87


       4.1 ... Wichtige Speicherbereiche ... 87

       4.2 ... Eigentumsverhältnisse im Speicher ... 89

       4.3 ... Referenzen und der leihweise Zugriff ... 98

       4.4 ... Mit Box Objekte im Heap ablegen ... 111

       4.5 ... Zusammenfassung ... 121



  5.  Strings ... 123


       5.1 ... Der String-Slice ... 123

       5.2 ... Der String ... 134

       5.3 ... Wie Sie Strings formatieren ... 147

       5.4 ... Zusammenfassung ... 154



  6.  Collections ... 157


       6.1 ... Tupel ... 157

       6.2 ... Arrays ... 166

       6.3 ... Elementbereiche ... 173

       6.4 ... Vektoren ... 182

       6.5 ... Slices ... 214

       6.6 ... HashMap und BTreeMap ... 231

       6.7 ... Hashes ... 245

       6.8 ... Mengen verwalten ... 248

       6.9 ... Die Entry API ... 251

       6.10 ... Elemente verschiedener Datentypen in eine Collection einfügen ... 257

       6.11 ... Zusammenfassung ... 260



  7.  Funktionen ... 263


       7.1 ... Der Aufbau einer Funktion ... 264

       7.2 ... Funktionszeiger ... 268

       7.3 ... Referenzen und Lebenszeiten in Funktionen ... 271

       7.4 ... Konstante Funktionen ... 280

       7.5 ... Anonyme Funktionen und Closures ... 285

       7.6 ... Funktions-Traits ... 302

       7.7 ... Zusammenfassung ... 311



  8.  Anweisungen, Ausdrücke und Muster ... 313


       8.1 ... Von der Anweisung zum Ausdruck und Muster ... 313

       8.2 ... Die Zuweisung im Detail ... 316

       8.3 ... Speicherausdrücke ... 319

       8.4 ... Operatoren ... 325

       8.5 ... Konditionale Ausdrücke ... 330

       8.6 ... Schleifen ... 342

       8.7 ... Muster ... 350

       8.8 ... Zusammenfassung ... 364



  9.  Fehlerbehandlung ... 367


       9.1 ... Fehler, von denen sich das Programm nicht erholen kann ... 367

       9.2 ... Erwartbare Fehler behandeln ... 381

       9.3 ... Zusammenfassung ... 418



10.  Strukturen ... 421


       10.1 ... Daten zusammenhängend ablegen ... 422

       10.2 ... Records: Der Struktur-Urtyp ... 423

       10.3 ... Strukturen und Instanzen ... 426

       10.4 ... Lebenszeiten: Wenn Felder Referenzen enthalten ... 441

       10.5 ... Wie Sie dem Compiler mit PhantomData wichtige Typinformationen übergeben ... 449

       10.6 ... Eine Datenstruktur ohne feste Größe ... 460

       10.7 ... Die drei Strukturen ... 462

       10.8 ... Muster ... 466

       10.9 ... Daten und Verhalten sind getrennt ... 468

       10.10 ... Strukturen in der Praxis: Das Bestellsystem überarbeiten ... 475

       10.11 ... Assoziierte Funktionen und die new-Konvention ... 480

       10.12 ... Methoden ... 486

       10.13 ... Referenzen in assoziierten Funktionen und Methoden ... 501

       10.14 ... Praxisbeispiel: Simulationsfähigkeiten im Restaurant-System ... 503

       10.15 ... Rekursion in Strukturen ... 507

       10.16 ... Typ-Aliasse ... 510

       10.17 ... Zusammenfassung ... 512



11.  Traits ... 515


       11.1 ... Marker-Traits ... 516

       11.2 ... Trait-Implementierungsblöcke ... 517

       11.3 ... Sie können ein Trait jeweils für T und &T implementieren ... 541

       11.4 ... Super-Traits ... 546

       11.5 ... Trait-Objekte ... 549

       11.6 ... Beispielprojekt: Trait-Objekte von 'Form' ... 564

       11.7 ... Undurchsichtige Datentypen zurückgeben ... 574

       11.8 ... Traits in der Praxis ... 578

       11.9 ... Zusammenfassung ... 627



12.  Enumerationen ... 631


       12.1 ... Die Eigenschaften einer Enumeration ... 632

       12.2 ... Verschiedene Variant-Typen ... 644

       12.3 ... Enumerationen und Muster ... 656

       12.4 ... Implementierungsblöcke und Verhalten ... 660

       12.5 ... Zusammenfassung ... 667



13.  Module, Pfade und Crates ... 669


       13.1 ... Das Modul ... 669

       13.2 ... Pfade ... 697

       13.3 ... Vom Crate zum Paket, vom Paket zum Workspace ... 721

       13.4 ... Zusammenfassung ... 777



14.  Generische Programmierung ... 781


       14.1 ... Von der Vorlage zur Konkretisierung: Monomorphisierung ... 781

       14.2 ... Typparameter, generische Konstanten und Lebenszeiten ... 783

       14.3 ... Syntaktische Elemente, die generisch sein können ... 785

       14.4 ... Mehr zu Trait-Grenzen ... 789

       14.5 ... Zusammenfassung ... 794



15.  Iteratoren ... 797


       15.1 ... Wie Sie einen Iterator beziehen ... 798

       15.2 ... Iterator-Adapter ... 805

       15.3 ... Einen Iterator konsumieren ... 816

       15.4 ... Zusammenfassung ... 822



16.  Nebenläufige und asynchrone Programmierung ... 823


       16.1 ... Nebenläufige Programmierung ... 824

       16.2 ... Smart Pointer ... 876

       16.3 ... Asynchrone Programmierung ... 893

       16.4 ... Zusammenfassung ... 915



17.  Makros ... 917


       17.1 ... Deklarative Makros ... 917

       17.2 ... Prozedurale Makros ... 939

       17.3 ... Zusammenfassung ... 950



18.  Automatische Tests und Dokumentation ... 953


       18.1 ... Tests ... 954

       18.2 ... Rust-Projekte dokumentieren ... 966

       18.3 ... Zusammenfassung ... 979



19.  Unsafe Rust und das Foreign Function Interface ... 981


       19.1 ... Unsafe Rust ... 981

       19.2 ... Primitive Zeiger ... 987

       19.3 ... Union ... 998

       19.4 ... Foreign Function Interface ... 1001

       19.5 ... Zusammenfassung ... 1005



  Index ... 1007