Überschreiben der Pop()-Methode

Der PHP-Editor Banana stellt Ihnen heute vor, wie Sie die Pop()-Methode neu schreiben. In der Programmierung wird die Methode Pop() verwendet, um das letzte Element eines Arrays zu entfernen und zurückzugeben. Manchmal müssen wir jedoch die Pop()-Methode anpassen, um bestimmte Anforderungen zu erfüllen. Durch Überschreiben der Pop()-Methode können wir zusätzliche Logik hinzufügen oder die zurückgegebenen Elemente ändern, damit sie besser zu unserem Code passen. In diesem Artikel wird detailliert beschrieben, wie die Pop()-Methode überschrieben wird, und es werden einige Beispiele zum besseren Verständnis gegeben. Lasst uns beginnen!

Frageninhalt

Unter der Installation von go gibt es ein Beispiel für eine Prioritätswarteschlange in container/heap/example_pq_test.go Ich füge den Inhalt der gesamten Datei ein, damit ich die Methode pop() fragen kann.

// copyright 2012 the go authors. all rights reserved.
// use of this source code is governed by a bsd-style
// license that can be found in the license file.

// this example demonstrates a priority queue built using the heap interface.
package heap_test

import (
    "container/heap"
    "fmt"
)

// an item is something we manage in a priority queue.
type item struct {
    value    string // the value of the item; arbitrary.
    priority int    // the priority of the item in the queue.
    // the index is needed by update and is maintained by the heap.interface methods.
    index int // the index of the item in the heap.
}

// a priorityqueue implements heap.interface and holds items.
type priorityqueue []*item

func (pq priorityqueue) len() int { return len(pq) }

func (pq priorityqueue) less(i, j int) bool {
    // we want pop to give us the highest, not lowest, priority so we use greater than here.
    return pq[i].priority > pq[j].priority
}

func (pq priorityqueue) swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
    pq[i].index = i
    pq[j].index = j
}

func (pq *priorityqueue) push(x any) {
    n := len(*pq)
    item := x.(*item)
    item.index = n
    *pq = append(*pq, item)
}

func (pq *priorityqueue) pop() any {
    old := *pq
    n := len(old)
    item := old[n-1]
    old[n-1] = nil  // avoid memory leak
    item.index = -1 // for safety
    *pq = old[0 : n-1]
    return item
}

// update modifies the priority and value of an item in the queue.
func (pq *priorityqueue) update(item *item, value string, priority int) {
    item.value = value
    item.priority = priority
    heap.fix(pq, item.index)
}

// this example creates a priorityqueue with some items, adds and manipulates an item,
// and then removes the items in priority order.
func example_priorityqueue() {
    // some items and their priorities.
    items := map[string]int{
        "banana": 3, "apple": 2, "pear": 4,
    }

    // create a priority queue, put the items in it, and
    // establish the priority queue (heap) invariants.
    pq := make(priorityqueue, len(items))
    i := 0
    for value, priority := range items {
        pq[i] = &item{
            value:    value,
            priority: priority,
            index:    i,
        }
        i++
    }
    heap.init(&pq)

    // insert a new item and then modify its priority.
    item := &item{
        value:    "orange",
        priority: 1,
    }
    heap.push(&pq, item)
    pq.update(item, item.value, 5)

    // take the items out; they arrive in decreasing priority order.
    for pq.len() > 0 {
        item := heap.pop(&pq).(*item)
        fmt.printf("%.2d:%s ", item.priority, item.value)
    }
    // output:
    // 05:orange 04:pear 03:banana 02:apple
}

Wenn ich eine pop()-Methode wie unten habe (ohne eine tiefe Kopie des Original-Slice zu erstellen), welchen Schaden könnte das anrichten oder liegt da ein Trugschluss vor?

func (pq *PriorityQueue) Pop2() any {
    n := len(*pq)
    item := (*pq)[n-1]
    (*pq)[n-1] = nil  // avoid memory leak
    item.index = -1 // for safety
    *pq = (*pq)[: n-1]
    return item
}

Ich glaube, dass die ursprüngliche pop()-Methode, die old := *pq schneidet, eine tiefe Kopie erstellt (ein neues zugrunde liegendes Array zuweist). ist das echt?

pop() 方法，这一行为切片 old := *pq 创建一个深层副本（分配一个新的底层数组）。这是真的吗？

解决方法

make函数创建的对象，这里是map和sliceLösung

Die von der Funktion make erstellten Objekte, hier map und slice, sind eher Zeiger auf Datenspeicherorte als die Daten selbst. So old := *pq verhält sich eher wie ein

Alias🎜 als wie das Kopieren von Daten. 🎜

Das obige ist der detaillierte Inhalt vonÜberschreiben der Pop()-Methode. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!