Wie gebe ich eine eigene array von einer Funktion?

Ich bin ein Rost Neuling versuchen, herauszufinden, die Sprache durch das spielen mit ihm. Ich getroffen habe einige Probleme, die versuchen, auf Rückgabe eines Arrays aus einer Funktion:

struct Widget {
  thingies: ~[int]
}

impl Widget {
    fn new() -> Widget {
        Widget { thingies: ~[4, 8, 15, 16, 23, 42] }
    }

    fn somethings(&self) -> ~[int] {
        self.thingies
    }
}

fn main() {
   let widget = Widget::new();
   let wotsits = widget.somethings();
}

Diese natürlich fehl Kompilierung mit diesem Fehler:

pointers.rs:11:8: 11:21 error: cannot move out of dereference of & pointer
pointers.rs:11         self.thingies

In diesem Fall-code-Beispiel sieht aus Sorten, alles, was ich versuche zu tun, ist ziehen Sie ein array aus einer implementierten Struktur. Die geliehene Zeiger ist nicht wichtig, es ist nur, wie ich versuche, die Daten zu speichern.

Irgendwelche Tipps, Extrakt mein array richtig?

Btw, ich bin mit Rost 0.8

~ ist ein einmalige Zeiger und es kann nur einer von Ihnen (den gleichen Wert). Sie können nicht kopiert werden (Aliasing), wie Sie in raw-C-Zeigern. Versuchen, erstellen Sie einen anderen Wert (den Rückgabewert) bewegt sich der Wert aus dem ursprünglichen Zeiger, die thingies und ganzen self undefiniert, was natürlich nicht erlaubt. Sie meinte wahrscheinlich die Rückgabe eines geliehenen Zeiger, nicht zum mitnehmen self.thingies.
~[T] heißt ein Vektor, und nicht ein array. Die Unterscheidung der Menschen in der Regel Remis zwischen den beiden ist, dass ein array ist statisch dimensioniert, während ein Vektor kann wachsen oder schrumpfen.

InformationsquelleAutor Greg Malcolm | 2014-01-23

12

Den Grund, warum Ihr code nicht kompilierbar ist, dass ein eindeutiger Zeiger ~ kann nur einen Besitzer haben. Der compiler verhindert, dass Sie vom schreiben fehleranfälliger code. Sie können entweder entscheiden, bringen Sie eine Kopie der Dinger, ein Verweis auf den Dingern, oder ein Stück von Dingern (das ist eine Referenz auf den Vektor-Daten oder ein segment davon).

Kopieren Lösung
```
struct Widget {
  thingies: ~[int]
}

impl Widget {
    fn new() -> Widget {
        Widget { thingies: ~[4, 8, 15, 16, 23, 42] }
    }

    fn somethings(&self) -> ~[int] {
        self.thingies.clone()
    }
}
```
Referenz-Lösung
```
struct Widget {
  thingies: ~[int]
}

impl Widget {
    fn new() -> Widget {
        Widget { thingies: ~[4, 8, 15, 16, 23, 42] }
    }

    fn somethings<'a>(&'a self) -> &'a~[int] {
        &self.thingies
    }
}
```
Slice-Lösung
```
struct Widget {
  thingies: ~[int]
}

impl Widget {
    fn new() -> Widget {
        Widget { thingies: ~[4, 8, 15, 16, 23, 42] }
    }

    fn somethings<'a>(&'a self) -> &'a[int] {
        self.thingies.as_slice()
    }
}
```
Verstehen der Referenz-und slice-Lösungen, die Sie benötigen, um zu verstehen, was 'a bedeutet: es gibt ein Leben lang, und &'a ist ein Weg, zu sagen, der compiler, dass der Verweis muss nie überlebt das Objekt, auf den es verweist, in diesem Fall ist ein Widget.

Diese Lösungen haben auch einige Einschränkungen: Sie können nicht ändern, ein Objekt, dass Sie gerade Referenzierung, da dies eröffnet die Möglichkeit, die Referenzen, die immer ungültig.

Können Sie natürlich ändern Dingern, wenn man wieder eine veränderbare Referenz. Eine veränderbare Referenz mit ein Leben lang hätte geschrieben werden können &'a mut T
```
struct Widget {
  thingies: ~[int]
}

impl Widget {
    fn new() -> Widget {
        Widget { thingies: ~[4, 8, 15, 16, 23, 42] }
    }

    fn somethings<'a>(&'a mut self) -> &'a mut ~[int] {
        &mut self.thingies
    }
}
```
Hinweis ich glaube, dass in Rust 0.8, die Sie schreiben müssen &'self statt &'a weil Lebzeiten mit benutzerdefinierten Namen wurden nicht unterstützt, noch. Ich schrieb auch das in 0.9.

Edit: entfernt redundante Lebensdauer Erklärungen.
- Sie nicht brauchen, um Leben annotation auf eine Struktur, es sei denn, Sie müssen ausgeliehen Zeiger innerhalb der Struktur. Dies ist nicht der Fall. Sie können einfach parametrisieren somethings Methode: fn somethings<'a><(&'a mut self) -> &'a mut ~[int] ....
- Matveev Dank, ich habe aktualisiert die post.
- In Bezug auf die 0,8 Kommentar, fand ich den code arbeitete als ist mit &'ein. Brauchte ich nicht zu ändern, es zu &'selbst.
InformationsquelleAutor A.B.
7

=== BEARBEITEN ===

in Rust 1 stabil ~[T] wurde Vec<T>, aber (syntax abgesehen) das gleiche Problem gilt Vec hat immer noch einen eindeutigen Besitzer. In einer nussschale, somethings nur einen Verweis auf sich selbst und (durch den Verweis) es kann nicht der Besitzer thingies. Spielplatz link zu Rust 1-version hier: https://play.rust-lang.org/?gist=50ec1acdc684e53fd5f9&version=stabil.

Rost Eigentum Modell ist ganz zentral, um die Sprache, also für mehr info würde ich vorschlagen, Blick auf die große offizielle Dokumentation auf Eigentum und Kreditaufnahme

=== ENDE BEARBEITEN ===

In Rust, die . nach self, auto-dereferenziert self, so ist dies der dereference of & pointer dass der Fehler erwähnt.

Nun Eigentum von Dinger ist der Teil, der Sie cannot move out of das dereferenzieren:
```
   let widget = Widget::new(); //widget owns the unique pointer to self
   let wotsits = widget.somethings(); //if this worked, ownership of 
                                      //unique pointer to thingies would be
                                      //moved to wotsits
```
Könnten Sie mir einen Verweis auf thingies statt:
```
fn somethings<'a>(&'a self) -> &'a~[int] {
    &self.thingies
}
```
ausdrücklich oder bringen Sie eine Kopie der Dinger
```
fn somethings(&self) -> ~[int] {
    self.thingies.clone()
}
```
- Hass, ping Sie wieder, aber mehr Menschen werden versuchen, zu aktualisieren pre-1.0 Fragen. Wir haben eine größeren Gruppen-chat.
InformationsquelleAutor Paolo Falabella
2

Können Sie nicht verschieben ausgeliehen Zeiger, wie bereits erläutert, in anderen Antworten. Aber Sie können passieren self durch einen Wert oder Besitz Zeiger, dann werden Sie zurückkehren können, im Besitz Vektor:
```
struct Widget {
    thingies: ~[int]
}

impl Widget {
    fn somethings(self) -> ~[int] {
        self.thingies
    }
}
```
InformationsquelleAutor Vladimir Matveev

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.