Przechowywanie odwołania do tablicy w trybie szybkim

Question

Chcę przekazać tablicę do obiektu i zapisać referencję do tej tablicy. Chcę móc modyfikować tę tablicę w tym obiekcie i upewnić się, że jest ona modyfikowana wszędzie indziej.

Oto co próbuję wykonać (jak kod nie działa)

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 

moich ustaleń dotychczas

a) array (domyślnie) są przekazywane dziwny sposób. Jest to odniesienie, dopóki nie zmodyfikujesz długości tablicy. Po zmodyfikowaniu długości zostanie ona skopiowana i zmodyfikowana. W rezultacie, jeśli dodaję lub usuwam z niego cokolwiek w obiekcie, nie będzie można go zobaczyć poza BN2. Mogę użyć parametru inout dla parametru funkcji. To pozwoli mi modyfikować go w ramach tej funkcji. Jednak, gdy tylko spróbuję przypisać go do jakiegoś elementu obiektu, znowu uderzy mnie A)

C) Mogę owinąć tablicę w jakiejś klasie Container. To prawdopodobnie jest najczystszy sposób. Jednakże serializuję/deserializuję te obiekty i wolałbym nie umieszczać ich w Container (ponieważ będę musiał obejść pewne rzeczy dla serializacji i deserializacji i wysłania ich na serwer).

Czy jest coś jeszcze? Czy brakuje mi konstrukcji Swift, która pozwala mi to zrobić?

Answer 1

Od the Swift Programming Language,

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

Jeśli przeanalizować zawartość zmiennej tablicy, widać, że rzeczywiście append działa:

 
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)") 

produkuje

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

Zrobiłeś c opy o numerze, a nie o odniesienie do.

Answer 2

Będziesz musiał użyć NSArray lub NSMutableArray, ponieważ Swift Arrays są typami wartości, więc każde zadanie utworzy kopię.

Answer 3

a jest deklarowana jako stała, dlatego nie można jej modyfikować. Jeśli planujesz zmodyfikować zawartość a, zadeklaruj ją jako zmienną. tj.,

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

Answer 4

Możesz użyć jerzyków (bardzo nie-śmigających) UnsafeMutablePointer.

Ponieważ (z Twojego postu) zachowanie odniesienia do tablic mogą naprawdę nie wydają się ufać, zamiast zachować UnsafeMutablePointer towarzysza do klasy wewnętrznej tablicy foo jak również żadnych „zewnętrznych” tablice, które mają być zbindowanych do foo , w tym sensie, że oba są po prostu wskaźnikami do tego samego adresu w pamięci.

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) 

Wskaźniki mogą być niebezpieczne, choć (stąd nazwa typu okucia) oraz, ponownie, bardzo un-swifty. Tak czy inaczej...

/* 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 

Teraz, co się dzieje, gdy obaj a lub foo wykracza poza zakres, będzie przerwa zmiennej, które nie znajdują się poza zakresem, czy też Swift zawierać jakiś sprytny liczenia odniesienia, który realizuje adres pamięci jest nadal w użyciu ? Nie zbadałem tego, ale nie krępuj się.