Speichern einer Referenz auf Array in swift

Question

Ich möchte ein Array an ein Objekt übergeben und einen Verweis auf dieses Array speichern. Ich möchte in der Lage sein, dieses Array innerhalb dieses Objekts zu ändern und sicherzustellen, dass es überall anders geändert wird.

Hier ist, was ich zu tun versuchen, (wie der Code funktioniert nicht)

class Foo { 
    var foo : Array<Int> 

    init(foo: Array<Int>) { 
     self.foo = foo 
    } 

    func modify() { 
     foo.append(5) 
    } 
} 

var a = [1,2,3,4] 
let bar = Foo(a) 
bar.modify() 
print(a) // My goal is that it will print 1,2,3,4,5 

Meine bisherigen Ergebnisse

A) Das Array (Standardeinstellung) sind seltsame Weise übergeben. Es ist eine Referenz, bis Sie eine Array-Länge ändern. Sobald Sie eine Länge ändern, wird diese kopiert und geändert. Als Ergebnis, wenn ich irgendetwas davon in das Objekt anhänge oder lösche, wird es außerhalb nicht gesehen

B) Ich kann inout auf einem Funktionsparameter verwenden. Dies erlaubt mir, es innerhalb dieser Funktion zu modifizieren. Sobald ich jedoch versuche, es einem Objekt zuzuweisen, fällt mir wieder ein: A)

C) Ich kann ein Array in eine Container-Klasse einbinden. Dies ist wahrscheinlich der sauberste Weg. Diese Objekte serialisiere/deserialisiere ich jedoch, und ich würde es lieber nicht in Container einfügen (weil ich einige Dinge für die Serialisierung und Deserialisierung umgehen und sie an den Server senden muss).

Gibt es noch etwas? Vermisse ich ein Swift-Konstrukt, das mir erlaubt, das zu tun?

Answer 1

Von the Swift Programming Language,

Structures are always copied when they are passed around in your code, and do not use reference counting.

Wenn Sie den Inhalt der Array-Variablen zu untersuchen, werden Sie, dass in der Tat die append sehen funktioniert:

 
class Foo { 
    var foo : Array 

    init(_ foo: Array) { 
    self.foo = foo 
    } 

    func modify() { 
    foo.append(5) 
    } 

    func printFoo() { 
    print("self.foo: \(foo)") 
    } 
} 

let a = [1,2,3,4] 
let bar = Foo(a) 
bar.modify() 
bar.printFoo() 
print("a: \(a)") 

produziert

 
self.foo: [1, 2, 3, 4, 5] 
a: [1, 2, 3, 4] 

Sie haben eine c genommen Opy of a, kein Verweis auf eine.

Answer 2

Sie müssen hierfür ein NSArray oder NSMutableArray verwenden, da Swift-Arrays Werttypen sind, sodass bei jeder Zuweisung eine Kopie erstellt wird.

Answer 3

wird eine Konstante deklariert und kann daher nicht geändert werden. Wenn Sie planen, den Inhalt von a zu ändern, deklarieren Sie es als Variable. das heißt

var a = [1,2,3,4] 

Answer 4

Sie könnten die Verwendung von Swifts (sehr un-swifty) UnsafeMutablePointer machen.

Da (aus Ihrem Post) das Verhalten Referenzen auf Arrays kann nicht wirklich zu trauen scheint, anstatt eine UnsafeMutablePointer Begleiter auf die innere Array Klasse halten foo sowie alle „externen“ Arrays, die Sie foo binded werden möchten in dem Sinne, dass sie beide nur Zeiger auf die gleiche Adresse im Speicher sind.

class Foo { 
    var foo : [Int] 
    var pInner: UnsafeMutablePointer<Int> 

    init(foo: [Int]) { 
     pInner = UnsafeMutablePointer(foo) 
     self.foo = Array(UnsafeBufferPointer(start: pInner, count: foo.count)) 
    } 

    func modify(inout pOuter: UnsafeMutablePointer<Int>) { 
     foo.append(5) // <-- foo gets new memory adress 
     pInner = UnsafeMutablePointer(foo) 
     pOuter = pInner 
    } 
} 

var a = [1,2,3,4] // first alloc in memory 
var pOuter: UnsafeMutablePointer<Int> = UnsafeMutablePointer(a) 
var bar = Foo(foo: a) // 'bar.foo' now at same address as 'a' 
print(bar.foo) // [1,2,3,4] 
bar.modify(&pOuter) // -> [1,2,3,4,5] 
a = Array(UnsafeBufferPointer(start: pOuter, count: bar.foo.count)) 

/* Same pointer adress, OK! */ 
print(bar.pInner) 
print(pOuter) 

/* Naturally same value (same address in memory) */ 
print(bar.foo) 
print(a) 

Pointers kann gefährlich sein, wenn (daher der Einpasstyps Name), und wiederum sehr un-swifty. Sowieso...

/* When you're done: clear pointers. Usually when using 
    pointers like these you should take care to .destroy 
    and .dealloc, but here your pointers are just companions 
    to an Array property (which has a pointer an reference 
    counter itself), and the latter will take care of the 
    objects in memory when it goes out of scope.   */ 
bar.pInner = nil 
pOuter = nil 

Nun, was passiert, wenn entweder a oder foo den Gültigkeitsbereich verlässt, wird die Variable brechen, die nicht aus dem Rahmen sind, oder hat Swift einige clevere Referenzzählung enthalten, die eine Speicheradresse ist noch in Gebrauch realisiert ? Ich habe das nicht untersucht, aber fühlen Sie sich frei, sich darin zu verwöhnen.