Lưu trữ một tham chiếu đến mảng trong swift

Question

Tôi muốn chuyển một mảng tới một đối tượng và lưu trữ một tham chiếu đến mảng này. Tôi muốn có thể sửa đổi mảng này trong đối tượng này và đảm bảo rằng nó được sửa đổi ở mọi nơi khác.

Đây là những gì tôi đang cố gắng để thực hiện (cách mã không hoạt động)

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 

phát hiện của tôi cho đến nay

A) Mảng (theo mặc định) được thông qua cách kỳ lạ. Đó là một tham chiếu cho đến khi bạn sửa đổi độ dài mảng. Ngay sau khi bạn sửa đổi độ dài, nó sẽ được sao chép và sửa đổi. Do đó, nếu tôi nối hoặc xóa bất kỳ thứ gì từ nó trong đối tượng, nó sẽ không được nhìn thấy bên ngoài

B) Tôi có thể sử dụng inout trên tham số chức năng. Điều này sẽ cho phép tôi sửa đổi nó trong hàm này. Tuy nhiên, ngay sau khi tôi sẽ cố gắng gán nó cho một số thành viên đối tượng, tôi lại bị ấn tượng bởi A)

C) Tôi có thể bọc một mảng trong một số lớp Container. Đây có lẽ là cách sạch nhất. Tuy nhiên, tôi tuần tự hóa/deserialize các đối tượng này và tôi không muốn đặt nó trong Container (vì tôi sẽ phải làm việc xung quanh một số thứ cho serialization và deserialization và gửi nó đến máy chủ).

Còn gì khác không? Tôi có thiếu một số cấu trúc Swift cho phép tôi làm điều đó không?

Answer 1

Từ the Swift Programming Language,

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

Nếu bạn kiểm tra các nội dung của biến mảng, bạn sẽ thấy rằng thực sự là append hoạt động:

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

sản xuất

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

Bạn đã chụp c opy của số, không phải là số tham chiếu đến.

Answer 2

Bạn sẽ phải sử dụng NSArray hoặc NSMutableArray cho điều này vì Swift Arrays là các loại giá trị nên bất kỳ nhiệm vụ nào cũng sẽ tạo một bản sao.

Answer 3

a được khai báo là hằng số do đó không thể sửa đổi được. Nếu bạn đang có kế hoạch sửa đổi nội dung của một, khai báo nó như là một biến. ví dụ:

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

Answer 4

Bạn có thể tận dụng Yến (rất un-Swifty) UnsafeMutablePointer.

Vì (từ bài đăng của bạn), tham chiếu hành vi đối với mảng không thực sự đáng tin cậy, thay vào đó hãy giữ UnsafeMutablePointer đồng hành với mảng bên trong lớp foo cũng như bất kỳ mảng "bên ngoài" nào bạn muốn được gắn với foo , theo nghĩa là cả hai chỉ là con trỏ đến cùng một địa chỉ trong bộ nhớ.

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) 

Con trỏ có thể gây nguy hiểm (do đó loại tên phù hợp) và, một lần nữa, rất không khéo léo. Dù sao...

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

Bây giờ, những gì xảy ra khi một trong hai a hoặc foo đi ra khỏi phạm vi, nó sẽ phá vỡ các biến mà không phải là ra khỏi phạm vi, hoặc không Swift chứa một số tính tham khảo thông minh mà nhận ra một địa chỉ bộ nhớ vẫn còn trong sử dụng ? Tôi đã không điều tra điều này, nhưng cảm thấy tự do để thưởng thức chính mình trong đó.