Wie preallocate und füllen eine Scheibe von Zeigern in einem go-idiomatische Weg?

http://play.golang.org/p/j-Y0mQzTdP

package main

import "fmt"

type UselessStruct struct {
    a int
    b int
}

func main() {
    mySlice := make([]*UselessStruct, 5)
    for i := 0; i != 5; i++ {
        mySlice = append(mySlice, &UselessStruct{})
    }

    fmt.Println(mySlice)
}

Ausgänge: [<nil> <nil> <nil> <nil> <nil> 0xc010035160 0xc010035170 0xc010035180 0xc010035190 0xc0100351a0]

Was ich tun möchte, ist preallocate Speicher für 5 UselessStructs, gespeichert als Zeiger. Wenn ich erkläre eine Scheibe struct Werte eq:

mySlice := make([]UselessStruct, 5)

dann dies schafft 5 leere Strukturen - Anhängen nicht, ersetzen Sie den leeren Strukturen, sondern hält Sie auf hinzufügen, um die Scheibe, so dass das Endergebnis mit diesem code:

http://play.golang.org/p/zBYqGVO85h

package main

import "fmt"

type UselessStruct struct {
    a int
    b int
}

func main() {
    mySlice := make([]UselessStruct, 5)
    for i := 0; i != 5; i++ {
        mySlice = append(mySlice, UselessStruct{})
    }

    fmt.Println(mySlice)
}

ist: [{0 0} {0 0} {0 0} {0 0} {0 0} {0 0} {0 0} {0 0} {0 0} {0 0}]

Was ist die der go-idiomatischer Weg um preallocate und füllen in Scheiben?

InformationsquelleAutor Dante | 2013-06-03
  1. 28

    Für dein erstes Beispiel würde ich tun:

    mySlice := make([]*UselessStruct, 5)
for i := range mySlice {
     mySlice[i] = new(UselessStruct)
}

    Das Problem, das Sie konfrontiert sind in beiden Beispielen ist, dass Sie sich Anhängen an eine Scheibe, das ist schon die richtige Länge. Wenn Sie mySlice := make([]*UselessStruct, 5) Sie Fragen, für ein Stück der null-Zeiger von der Länge 5. Wenn Sie fügen einen Zeiger, es hat nun die Länge 6.

    Statt, die Sie verwenden möchten mySlice := make([]*UselessStruct, 0, 5). Dies erzeugt eine slice der Länge 0, jedoch Kapazität 5. Jedes mal, wenn Sie anfügen, wird es hinzufügen, um die Länge, aber es wird nicht umverteilt, bis Sie mehr als die slice-Fähigkeit.

    mySlice := make([]*UselessStruct, 0, 5)
for i := 0; i != 5; i++ {
    mySlice = append(mySlice, &UselessStruct{})
}
//mySlice is [0xc010035160 0xc010035170 0xc010035180 0xc010035190 0xc0100351a0]

    Meine beiden Beispiele funktionieren, wie Sie erwarten, aber ich empfehle die erste, der für rein style-Gründen.

    • Könnten Sie näher erläutern, "aus reinen style-Gründen"? Ich persönlich finde die append Lösung logischer und lesbar, da es vermeidet intermediate Staaten, wo einige der Elemente, die null-Werte. Auch, nicht füllen den Schnitt mit der null-Werte zunächst vergebliche Mühe?
    • Alle Speicher, die zugewiesen wird, in Gehen, ist gelöscht. Es ist also keine vergebliche Mühe.
    InformationsquelleAutor Stephen Weinberg
  2. 8

    Gibt es zwei Möglichkeiten, dies zu tun. Wird man von der vorab-Aufteilung der slots, wie Sie es Tat.
    Aber statt mit append Sie einfach einen index in eine der vorhandenen Steckplätze:

    mySlice[i] = &UselessStruct{}

    Die zweite ist die Verwendung des 'überlastet' verion make. Geben Sie die Länge null, sondern eine Kapazität von 5.

    package main

type T struct {
    A int
    B int
}

func main() {
    mySlice := make([]*T, 0, 5)
    for i := 0; i < 5; i++ {
        mySlice = append(mySlice, &T{1, 2})
    }
}

    mySlice := make([]*T, 0, 5) initialisiert die Scheibe mit einer Länge von null, aber es immer noch pre-reserviert genug Platz für 5 Einträge.

    InformationsquelleAutor jimt
  3. 3

    Sind Sie sicher, dass Sie benötigen Hinweise? Ihre Struktur hat einen null-Wert so:

    mySlice := make([]UselessStruct, 5) # has memory preallocated for 5 UselessStructs.

    Und da Scheiben sind Referenz-Typen, die Sie effektiv haben 5 Zeigern auf die 5 UselessStructs.

    Wenn Sie brauchen, um einen Verweis auf eine einzelne Struktur zu passieren um dann kann man nur so

    myStruct := &mySlice[0]

    Und jetzt haben Sie einen Zeiger auf eine UseLessStruct zu verwenden, wie Sie sehen, passen. Es ist viel weniger code als Sie haben und nutzt Go ' s, den Wert null Funktion.

    InformationsquelleAutor Jeremy Wall
  4. 0

    Gerade abgeschlossen: append arbeitet mit null-Scheibe, so dass Sie nicht brauchen, um das Stück mit zu machen, können Sie einfach die append-element, um es.

    var mySlice []*UselessStruct
for i := 0; i < 5; i++ {
    mySlice = append(mySlice, &UselessStruct{})
}

    Dieser wird das gleiche tun wie vorherigen Beispiel ohne pre-allocation, aber wenn Sie wissen, die Größe, die Sie lieber so etwas wie dieses:

    mySlice := make([]*UselessStruct, 0, 5)
for i := range mySlice {
    mySlice[i] = &UselessStruct{}
}

    Kann dies vermeiden, einige Umverteilung.

    InformationsquelleAutor Marwan Burelle
Schreibe einen Kommentar