Übersetzungen überarbeiten

src/ch09-01-unrecoverable-errors-with-panic.md

@@ -15,10 +15,9 @@ aufspüren kannst.
 >
 > Wenn ein Programmabbruch auftritt, beginnt das Programm standardmäßig mit dem
 > *Abwickeln*, was bedeutet, dass Rust den Stapelspeicher wieder nach oben geht
-> und die Daten von jeder Funktion, auf die es trifft, bereinigt. Allerdings
-> ist dieses Zurückgehen und Aufräumen eine Menge Arbeit. Rust bietet dir als
-> Alternative daher an, das Programm sofort *abzubrechen*, wobei das Programm
-> beendet wird, ohne aufzuräumen.
+> und die Daten aller Funktion aufräumt. Allerdings ist dieses Zurückgehen und
+> Aufräumen eine Menge Arbeit. Rust bietet dir als Alternative daher an, das
+> Programm sofort *abzubrechen*, also das Programm ohne Aufräumen zu beenden.
 >
 > Der Speicher, den das Programm benutzt hat, muss dann vom Betriebssystem
 > aufgeräumt werden. Wenn du in deinem Projekt die resultierende Binärdatei so

src/ch15-01-box.md

@@ -252,10 +252,9 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
   |               ++++    +
 ```
 
-In diesem Hinweis bedeutet „indirection“ (Dereferenzierung), dass anstelle
-eines direkten Speicherns des Wertes die Datenstruktur geändert werden soll, um
-den Wert indirekt zu speichern, indem stattdessen ein Zeiger auf den Wert
-gespeichert wird.
+In diesem Hinweis bedeutet „indirection“ (Umweg), dass die Datenstruktur den
+Wert nicht direkt speichern soll, sondern indirekt, indem stattdessen ein
+Zeiger auf den Wert gespeichert wird.
 
 Da eine `Box<T>` ein Zeiger ist, weiß Rust immer, wie viel Platz eine `Box<T>`
 benötigt: Die Größe eines Zeigers ändert sich nicht basierend auf der
@@ -315,7 +314,7 @@ Der Typ `Box<T>` ist ein intelligenter Zeiger, da er das Merkmal `Deref`
 implementiert, mit dem `Box<T>` Werte wie Referenzen behandelt werden können.
 Wenn ein `Box<T>`-Wert den Gültigkeitsbereich verlässt, werden die Daten am
 Haldenspeicher, auf die die Box zeigt, aufgrund der Implementierung des
-Merkmals `Drop` ebenfalls bereinigt. Diese beiden Merkmale sind für die
+Merkmals `Drop` ebenfalls aufgeräumt. Diese beiden Merkmale sind für die
 Funktionalität der anderen intelligenten Zeigertypen, die wir im restlichen
 Kapitel erläutern, noch wichtiger. Lass uns diese beiden Merkmale genauer
 untersuchen.

src/ch15-03-drop.md

@@ -12,16 +12,15 @@ intelligenten Zeigers verwendet wird. Wenn beispielsweise eine `Box<T>`
 aufgeräumt wird, wird der Speicherplatz auf dem Haldenspeicher freigegeben, auf
 den die Box zeigt.
 
-In einigen Programmiersprachen muss der Programmierer bei jeder Verwendung einer
-Instanz eines intelligenten Zeigers Programmcode aufrufen, um Speicher oder
-Ressourcen freizugeben. Beispiele hierfür sind Dateiressurcen, Sockets oder
-Sperren. Wenn sie es vergessen, kann das System überlastet werden und
-abstürzen. In Rust kann man festlegen, dass ein bestimmter Programmcode
-ausgeführt wird, wenn ein Wert seinen Gültigkeitsbereich verlässt, und der
-Compiler fügt diesen Programmcode automatisch ein. Infolgedessen muss man nicht
-vorsichtig sein, wenn man Bereinigungscode überall in einem Programm platziert,
-mit dem eine Instanz eines bestimmten Typs fertig ist, man wird dennoch keine
-Ressourcen verlieren!
+In einigen Programmiersprachen muss der Programmierer für manche Datentypen
+den Speicher oder die Ressourcen manuell freigeben, wenn die jeweiligen
+Instanzen nicht mehr benötigt werden. Beispiele hierfür sind Dateiressourcen,
+Sockets oder Sperren. Wenn er das vergisst, kann das System überlastet werden
+und abstürzen. In Rust kannst du festlegen, dass ein bestimmter Programmcode
+ausgeführt wird, sobald ein Wert seinen Gültigkeitsbereich verlässt. Der
+Compiler fügt dann diesen Programmcode automatisch ein. Infolgedessen muss man
+sich nicht darum kümmern, an allen relevanten Stellen Aufräumcode zu
+platzieren, und verschwendet trotzdem keine Ressourcen!
 
 Du schreibst den Programmcode der ausgeführt wird, wenn ein Wert den
 Gültigkeitsbereich verlässt, durch Implementieren des Merkmals `Drop`. Für das
@@ -91,16 +90,16 @@ Rust hat für uns automatisch `drop` und den von uns angegebenen Programmcode
 aufgerufen, sobald unsere Instanzen den Gültigkeitsbereich verlassen haben. 
 Variablen werden in umgekehrter Reihenfolge ihrer Erstellung aufgeräumt, daher
 wurde `d` vor `c` aufgeräumt. Der Zweck dieses Beispiels ist, dir eine visuelle
-Anleitung zur Funktionsweise der `drop`-Methode zu geben. Normalerweise gibst
-du den Bereinigungscode an, den dein Typ ausführen muss, anstatt einen Text
+Anleitung zur Funktionsweise der `drop`-Methode zu geben. Normalerweise
+schreibst du den Aufräumcode, den dein Typ ausführen muss, anstatt einen Text
 auszugeben.
 
 ### Einen Wert mit `std::mem::drop` frühzeitig aufräumen
 
 Unglücklicherweise ist es nicht einfach, die automatische `drop`-Funktionalität
 zu deaktivieren. Für gewöhnlich ist es auch nicht erforderlich; der wesentliche
 Punkt des `Drop`-Merkmals ist, dass es automatisch erledigt wird. Gelegentlich
-möchte man jedoch möglicherweise einen Wert frühzeitig bereinigen. Ein Beispiel
+möchte man jedoch möglicherweise einen Wert frühzeitig aufräumen. Ein Beispiel
 ist die Verwendung intelligenter Zeiger, die Sperren verwalten: Möglicherweise
 möchtest du die `drop`-Methode dazu zwingen, die Sperre freizugegeben,
 damit anderer Programmcode im selben Gültigkeitsbereich die Sperre erhalten
@@ -137,7 +136,7 @@ fn main() {
 ```
 
 <span class="caption">Codeblock 15-15: Der Versuch, die `drop`-Methode 
-des `Drop`-Merkmals manuell aufzurufen, um frühzeitig zu bereinigen</span>
+des `Drop`-Merkmals manuell aufzurufen, um frühzeitig aufzuräumen</span>
 
 Wenn wir versuchen, diesen Programmcode zu kompilieren, wird folgende
 Fehlermeldung ausgegeben:
@@ -163,7 +162,7 @@ error: could not compile `drop-example` (bin "drop-example") due to 1 previous e
 Diese Fehlermeldung besagt, dass wir `drop` nicht explizit aufrufen dürfen. Die
 Fehlermeldung verwendet den Begriff *Destruktor* (destructor), der der
 allgemeine Programmierbegriff für eine Funktion ist, die eine Instanz
-bereinigt. Ein *Destruktor* ist analog zu einem *Konstruktor* (constructor),
+aufräumt. Ein *Destruktor* ist analog zu einem *Konstruktor* (constructor),
 der eine Instanz erstellt. Die `drop`-Funktion in Rust ist ein bestimmter
 *Destruktor*.
 
@@ -227,14 +226,14 @@ aufgeräumt.` ausgegeben und zeigt, dass der `drop`-Methodencode aufgerufen wird
 um `c` an diesem Punkt aufzuräumen.
 
 Du kannst den Programmcode, der in einer Implementierung des `Drop`-Merkmals
-angegeben ist, auf viele Arten verwenden, um die Bereinigung bequem und sicher
-zu gestalten, du kannst ihn beispielsweise dazu verwnden, um deinen eigenen
-Speicher-Allokator (memory allocator) zu erstellen! Mit dem Merkmal `Drop` und
-dem Eigentümerschaftssystem von Rust musst du nicht daran denken den
-Programmcode zu bereinigen, da Rust dies automatisch tut.
-
-Man muss sich auch keine Sorgen über Probleme machen, die sich aus der
-versehentlichen Bereinigung noch verwendeter Werte ergeben: Das
+angegeben ist, auf viele Arten verwenden, um das Aufräumen bequem und sicher
+zu gestalten. Du kannst ihn beispielsweise dazu verwenden, deine eigene
+Speicherverwaltung (memory allocator) zu erstellen! Mit dem Merkmal `Drop` und
+dem Eigentümerschaftssystem von Rust musst du nicht ans Aufräumen denken, da
+Rust dies automatisch tut.
+
+Man muss sich auch keine Sorgen über Probleme machen, die sich aus dem
+versehentlichen Aufräumen noch verwendeter Werte ergeben: Das
 Eigentümerschaftssystem, das sicherstellt, das Referenzen immer gültig sind,
 stellt auch sicher, dass `drop` nur einmal aufgerufen wird, wenn der Wert nicht
 mehr verwendet wird.

src/ch19-01-unsafe-rust.md

@@ -95,7 +95,7 @@ Rohzeiger sind anders als Referenzen und intelligente Zeiger:
   Stelle haben.
 * Sie zeigen nicht garantiert auf gültigen Speicher.
 * Sie dürfen null sein.
-* Sie implementieren keine automatische Bereinigung.
+* Sie implementieren kein automatisches Aufräumen.
 
 Wenn du dich dagegen entscheidest, diese Garantien von Rust erzwingen zu
 lassen, kannst du auf garantierte Sicherheit verzichten und stattdessen eine