Programmiersprachen unterscheiden sich darin, wie sie mit Speicher umgehen und Speicherverwaltungsregeln erzwingen. Go und Python verwenden Garbage Collectors, sodass sich Entwickler auf das Schreiben von Code konzentrieren können. C und C++ geben Programmierern die Verantwortung für die Speicherverwaltung auf einer niedrigeren Ebene.
Rust behandelt die Speicherverwaltung anders und verwendet Konzepte, die es Eigentum und Ausleihen nennt. Es verwendet einen „Borrow Checker“, um die Speichersicherheit effizient durchzusetzen.
Was ist Eigentum?
Ownership ist eine Funktion und Konvention von Rust, die dabei hilft, die Speichersicherheit von Programmen ohne Garbage Collector sicherzustellen. Es ist eine andere Art, es anzugehen das Problem der Speicherlecks in deinem Code.
Der Rust-Compiler prüft zur Kompilierzeit, ob ein Programm die Besitzregeln einhält. Wenn das Programm diese Regeln befolgt, kann es ausgeführt werden. Wenn dies nicht der Fall ist, weigert sich der Compiler, eine ausführbare Datei zu erstellen.
Rust verifiziert die Eigentumsregeln mit der Prüfer ausleihen. Der Borrow-Checker verifiziert das Eigentumsmodell und entscheidet, ob ein Wert im Speicher (Stapel oder Haufen) außerhalb des Gültigkeitsbereichs liegt oder nicht. Wenn ein Wert außerhalb seines Gültigkeitsbereichs liegt, ist er für andere Teile des Programms nicht zugänglich, es sei denn, er wird ausgeliehen.
Die Eigentumsregeln
In Rust besitzt jede Variable den Wert, mit dem sie initialisiert wurde, und es kann nur einen Besitzer geben. Sobald der Eigentümer außerhalb des Bereichs liegt, wird der Wert gelöscht. Es ist wichtig, die Details der Eigentumsregeln zu verstehen.
Die erste Besitzregel besagt, dass jede Variable ihren initialisierten Wert besitzt.
Lassen Eigentümer = Schnur::von einem");
Das Eigentümer obige Variable besitzt die Zeichenfolge eines und im Gegensatz zu Sprachen wie Python und Go wird dieser Wert bei der Neuzuweisung von Variablen gelöscht.
Die zweite Besitzregel besagt, dass zwei Variablen nicht auf denselben Speicherort zeigen können; Jeder Wert kann nur einen Besitzer haben.
Lassen new_owner = Besitzer;
Das neuer Besitzer Variable besitzt jetzt den Wert, der am Speicherplatz der gespeichert ist Eigentümer Variable. Wenn Sie versuchen, die zu verwenden Eigentümer -Variable, gerät der Compiler in Panik und weigert sich, eine ausführbare Datei zu generieren.
In den meisten Sprachen, die Garbage Collectors verwenden, können zwei Variablen auf denselben Speicherort zeigen. Hier ist ein Beispiel für einen entsprechenden JavaScript-Code:
Lassen Besitzer = "Eigentümer";
Lassen new_owner = Besitzer;
Konsole.log (neuer_Eigentümer);
Das Ausführen des obigen JavaScript-Codes funktioniert fehlerfrei, und wenn Sie dasselbe in Go oder Python tun, funktioniert Ihr Programm auch fehlerfrei.
Die dritte Eigentumsregel besagt, dass sobald eine Variable den deklarierten Gültigkeitsbereich verlässt, der Wert gelöscht und der Speicher freigegeben wird.
// eine Variable in einem separaten Geltungsbereich
{
Lassen Beispiel = Schnur::from("Hier ist ein neuer Geltungsbereich");
}
drucken!("{}", Beispiel)
Sie können nicht auf die zugreifen Beispiel Variable außerhalb ihres Gültigkeitsbereichs; Wenn Sie dies versuchen, gerät der Compiler in Panik.
Eigentum an Funktionen
Wenn Sie einer Funktion einen Wert als Argument übergeben, kann die Funktion auf diese Variable zugreifen, obwohl sie nicht in ihrem Gültigkeitsbereich deklariert wurde:
fnDrucker(Wert: Schnur) -> Schnur {
Rückkehr Wert
}fnhauptsächlich() {
Lassen x= Schnur::from("Druckt einen Wert"); // x besitzt den String-Wert
// Der Besitz wird hier auf die Druckerfunktion verschoben
drucken!("{} Das Ergebnis von Printing X ist, dass es -:", Drucker (x));
}
Die Funktion kann auf diese Variable zugreifen, da Rust den Besitz davon zur Kompilierzeit auf die Funktion überträgt.
Sie könnten denken, dass es immer noch möglich ist, die Variable später in ihrem ursprünglichen Gültigkeitsbereich zu verwenden:
fnDrucker(Wert: Schnur) -> Schnur {
Rückkehr Wert
}fnhauptsächlich() {
Lassen x= Schnur::from("Druckt einen Wert");
drucken!("{} Das Ergebnis von Drucken x ist, dass es -:", Drucker (x));
// Versuch, die Variable zu verwenden, nachdem der Besitz ihres Wertes übertragen wurde
drucken!("{} sollte nicht zugänglich sein", x)
}
Aber wenn Sie dies versuchen, gerät der Compiler in Panik und weigert sich, eine ausführbare Datei zu erstellen:
Rust priorisiert die Wiederverwendbarkeit von Code
Die Wiederverwendbarkeit von Code ist eine wesentliche Praxis, aber um die Wiederverwendbarkeit von Code zu üben, müssen Sie die Eigentumsregeln von Rust verstehen.
Rust ist eine sehr flexible Programmiersprache. Es bietet Konzepte wie Ausleihen, Verschieben, Kopieren und Klonen des Eigentums für variable Wiederverwendbarkeit.
