स्विफ्ट

Question

में सरणी के संदर्भ को संग्रहीत करना मैं किसी ऑब्जेक्ट को एक सरणी पास करना चाहता हूं और इस सरणी का संदर्भ संग्रहीत करना चाहता हूं। मैं इस वस्तु के भीतर इस सरणी को संशोधित करने में सक्षम होना चाहता हूं और यह सुनिश्चित कर सकता हूं कि यह हर जगह संशोधित हो।

यहाँ है कि मैं क्या पूरा करने के लिए (कैसे कोड काम नहीं करता है)

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 

मेरे निष्कर्ष अब तक

ए) सरणी (डिफ़ॉल्ट रूप से) अजीब तरीके से पारित कर रहे हैं कोशिश कर रहा हूँ है। यह एक संदर्भ है जब तक आप एक सरणी लंबाई संशोधित नहीं करते हैं। जैसे ही आप एक लंबाई संशोधित करेंगे, इसकी प्रतिलिपि बनाई जाएगी और संशोधित की जाएगी। परिणाम के रूप में, अगर मैं संलग्न या वस्तु यह बाहर

बी नहीं देखा जाएगा में यह से कुछ भी हटाना) मैं एक समारोह पैरामीटर पर inout उपयोग कर सकते हैं। यह मुझे इस फ़ंक्शन के भीतर संशोधित करने की अनुमति देगा। हालांकि, जैसे ही मैं इसे किसी ऑब्जेक्ट सदस्य को असाइन करने का प्रयास करूंगा, मुझे फिर से ए)

सी) मैं कुछ कंटेनर क्लास में एक सरणी लपेट सकता हूं। यह शायद सबसे साफ तरीका है। हालांकि, मैं क्रमानुसार/इन वस्तुओं deserialize और मैं नहीं बल्कि कंटेनर में रख नहीं होगा (क्योंकि मैं सर्वर से क्रमबद्धता और अक्रमांकन और उसे भेजने के लिए कुछ बातें चारों ओर काम करना होगा)।

क्या कुछ और है? क्या मुझे कुछ स्विफ्ट निर्माण याद आ रहा है जो मुझे ऐसा करने की अनुमति देता है?

Answer 1

the Swift Programming Language से,

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

आप सरणी चर की सामग्री की जांच करते हैं, तो आपको लगता है कि वास्तव में संलग्न देखेंगे काम करता है:

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

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

का उत्पादन आपने सी लिया है का विकल्प, के संदर्भ में नहीं।

Answer 2

आप इस के लिए एक NSArray या NSMutableArray का उपयोग करें ताकि कोई भी काम एक प्रतिलिपि बनाने जाएगा, क्योंकि स्विफ्ट सरणी मूल्य प्रकार के होते हैं होगा।

Answer 3

एक इसलिए एक निरंतर घोषित किया जाता है बदला नहीं जा सकता। यदि आप किसी की सामग्री को संशोधित करने की योजना बना रहे हैं, तो इसे एक चर के रूप में घोषित करें। i.e.,

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

Answer 4

आप स्विफ्ट्स (बहुत गैर-स्विफ्ट) UnsafeMutablePointer का उपयोग कर सकते हैं।

के बाद से (अपने पद से) व्यवहार सरणियों के लिए संदर्भ वास्तव में लग भरोसा नहीं किया जा सकता है, बजाय वर्ग भीतरी सरणी foo के लिए एक UnsafeMutablePointer साथी के साथ-साथ किसी भी "बाहरी" सरणियों कि आप foo से आबद्ध किया जाना चाहते हैं रखने के , इस अर्थ में कि वे दोनों सिर्फ स्मृति में एक ही पते पर संकेत दिए गए हैं में।

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) 

पॉइंटर्स हालांकि खतरनाक हो सकते हैं (इसलिए फिटिंग प्रकार का नाम), और फिर, बहुत ही तेज़। वैसे भी ...

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

अब, क्या होता है जब या तो a या foo क्षेत्र से बाहर चला जाता है, यह चर कि क्षेत्र से बाहर नहीं हैं टूट जाएगा, या स्विफ्ट कुछ चालाक संदर्भ गिनती है कि एक स्मृति पते का एहसास में क्या है भी उपयोग में है ? मैंने इसकी जांच नहीं की है, लेकिन उसमें खुद को शामिल करने के लिए स्वतंत्र महसूस करें।