Brauchen ganzheitliche Erklärung über Rost Zelle und Referenz-Arten gezählt

Gibt es verschiedene wrapper-Typen im Rost standard-Bibliothek:

Wie ich es verstehe, diese sind Wrapper, die weitere Möglichkeiten als eine einfache Referenz. Ich verstehe zwar einige Grundlagen, ich kann nicht das ganze Bild zu sehen.

Was tun Sie eigentlich genau? Werden Zellen und Referenz-gezählten Familien stellen orthogonale oder ähnliche features?

  • Bitte beschreiben Sie, was Sie nicht verstehen. Die Dokumentation, die du verlinkt hast, hat hatte Hunderte (oder Tausende) von Menschen Lesen es, und wahrscheinlich zig bis Hunderte Leute dazu beitragen. Was können wir vielleicht sagen, das wäre anders aus, was bereits gesagt ist, vor allem, wenn du uns nicht sagst was du nicht verstehst?
  • Die Erklärungen in der Dokumentation sprechen über innere Wandlungsfähigkeit. Dieses Konzept ist unklar für mich. Vielleicht war meine Frage unklar zu.
  • Eine schnelle Suche im internet gefunden ein Kapitel in dem Buch über das innere Veränderlichkeit, eine blog post und SO Frage. Vielleicht ist jetzt, dass Sie wissen, was Sie unklar, können Sie einige der Forschung und aktualisieren Sie Ihre Frage.
InformationsquelleAutor French Boiethios | 2017-08-14
  1. 124

    Gibt es zwei wesentliche Konzepte, die in Rust:

    • Eigentum,
    • Veränderbarkeit.

    Die verschiedenen Zeiger-Typen (Box, Rc, Arc) befassen sich mit Eigentum: Sie erlauben die Steuerung, ob es eine einzige oder mehrere Eigentümer für ein einzelnes Objekt.

    Auf der anderen Seite, die verschiedenen Zellen (Cell, RefCell, Mutex, RwLock, AtomicXXX) betroffen sind mit Veränderlichkeit.

    Der Gründung die Regel der Rost die Sicherheit Aliasing XOR Veränderlichkeit. Das heißt, ein Objekt kann nur sicher mutiert, wenn es keine herausragende Referenz in seinem inneren.

    Diese Regel ist in der Regel erzwungen, die zur compile-Zeit durch den borrow checker:

    • wenn Sie eine &T Sie können auch eine &mut T auf das gleiche Objekt im Rahmen,
    • wenn Sie eine &mut T Sie können auch eine beliebige Referenz auf das gleiche Objekt im scope.

    Manchmal jedoch, dies ist nicht flexibel genug. Manchmal Sie TUN müssen (oder wollen) die Möglichkeit, mehrere Referenzen auf das gleiche Objekt und dennoch mutieren Sie. Geben Sie die Zellen.

    Die Idee Cell und RefCell zu ermöglichen, ist Veränderlichkeit in der Gegenwart von aliasing - in einer kontrollierten Art und Weise:

    • Cell verhindert die Bildung von Referenz in seinem inneren, die Vermeidung von dangling references,
    • RefCell Schichten, die Durchsetzung der Aliasing XOR Veränderlichkeit von der Kompilierung zur Laufzeit.

    Diese Funktionalität wird manchmal beschrieben, wie die Bereitstellung von innere Veränderlichkeit, das ist, wo ein Objekt, das sonst aussieht unveränderbar von außen (&T) kann tatsächlich mutiert.

    Wenn diese Veränderlichkeit erstreckt sich über mehrere threads, die Sie stattdessen verwenden Mutex, RwLock oder AtomicXXX; Sie bieten die gleiche Funktionalität:

    • AtomicXXX sind nur Cell: keine Referenz auf das innere, nur das verschieben in/out,
    • RwLock ist nur RefCell: erhalten Verweise auf den Innenraum durch Wachen,
    • Mutex ist eine vereinfachte version des RwLock die nicht unterscheiden zwischen einem nur-lese-guard und schreiben Sie guard; so konzeptionell ähnlich wie ein RefCell mit nur einem borrow_mut Methode.

    Wenn Sie kommen aus einem C++ - hintergrund:

    • Box ist unique_ptr,
    • Arc ist shared_ptr,
    • Rc ist eine nicht thread-sichere version von shared_ptr.

    Und die Zellen bieten eine ähnliche Funktionalität wie mutable nur mit zusätzlichen Garantien zur Vermeidung von aliasing-Probleme; denken Cell als std::atomic und RefCell als eine nicht thread-sichere version von std::shared_mutex (die wirft statt blockieren, wenn die Sperre).

    • Danke, dass du so viel, Antworten Sie genau auf alle meine Ratlosigkeit über die "komplizierten" Arten in Rust. Der Vergleich mit C++ ist perfekt, auch.
    • Der Begriff aliasing, obwohl, der mich schlägt. Ich verstehe es als "multiple Referenz auf ein Daten", ist es das?
    • Ja, das ist genau das. Jeder Verweis/Zeiger ist ein "alias" mit den realen Daten (ein anderer name für die gleiche "person" ist das, was ein alias ist, nachdem alle), und durch die Erweiterung in der software reden wir über aliasing, wenn es mehrere Aliase zu einem bestimmten Zeitpunkt.
    • Die erste Ausgabe des Buches hatte ein Kapitel über dieses. Es ist einer von denen, die verloren war in der Fassung, die ich denke, ist bedauerlich-vielleicht in einem Anhang oder sowas
    • Wenn Aliasing XOR Veränderlichkeit ist die Regel für die Sicherheit, das bedeutet, dass (kein Aliasing) UND (nicht Veränderlichkeit) ist unsicher? Aber sicher, wenn es kein aliasing UND kein Veränderlichkeit dann ist das ganz sicher? Ich denke, Sie wollen etwas anderes als XOR gibt.
    • way out => nur unter Berufung auf core-Entwickler " - Folie, werde ich halten mit Ihrem slogan 😉
    • Vielleicht ist der slogan verwenden sollten, NAND statt XOR 😛
    • Was bedeutet "verhindert die Bildung von Referenz, um seine inneren" noch bedeuten? Dies ist, was ich hasse über die Dokumentation, die ist es. Ich weiß eigentlich schon, was Cell tut, aber diese Art von Erklärung ist unnötig. Es muss nicht erklärt werden, wie eine Akademische Beweis.

    InformationsquelleAutor Matthieu M.
  2. 9

    Dank Matthieu ist gute Antwort, ist hier ein Diagramm, um zu helfen Leute zu finden die wrapper, die Sie benötigen:

    +-----------+
| Ownership |
+--+--------+                              +================+
   |                         +-Static----->| T              |(1)
   |                         |             +================+
   |                         |
   |                         |             +================+
   |          +-----------+  | Local    Val| Cell<T>        |(1)
   +-Unique-->| Borrowing +--+-Dynamic---->|----------------|
   |          +-----------+  |          Ref| RefCell<T>     |(1)
   |                         |             +================+
   |                         |
   |                         |             +================+
   |                         | Threaded    | AtomicT        |(2)
   |                         +-Dynamic---->|----------------|
   |                                       | Mutex<T>       |(1)
   |                                       | RwLock<T>      |(1)
   |                                       +================+
   |
   |
   |                                       +================+
   |                         +-No--------->| Rc<T>          |
   |                         |             +================+
   | Locally  +-----------+  |
   +-Shared-->| Mutable?  +--+             +================+
   |          +-----------+  |          Val| Rc<Cell<T>>    |
   |                         +-Yes-------->|----------------|
   |                                    Ref| Rc<RefCell<T>> |
   |                                       +================+
   |
   |
   |                                       +================+
   |                         +-No--------->| Arc<T>         |
   |                         |             +================+
   | Shared   +-----------+  |
   +-Between->| Mutable?  +--+             +================+
     Threads  +-----------+  |             | Arc<AtomicT>   |(2)
                             +-Yes-------->|----------------|
                                           | Arc<Mutex<T>>  |
                                           | Arc<RwLock<T>> |
                                           +================+
    1. In diesen Fällen T ersetzt werden kann, mit Box<T>
    2. Verwenden AtomicT wenn T ist ein bool oder eine Reihe

    Wissen, ob Sie verwenden sollten Mutex oder RwLock finden Sie in diesem Zusammenhang Frage.

    InformationsquelleAutor French Boiethios
Schreibe einen Kommentar