दिलचस्प पोस्ट
अजगर फ़ाइल मोड द्वारा भ्रमित "w +" "~" (टिल्ड / स्क्विगल / ट्विडल) सीएसएस चयनकर्ता का मतलब क्या है? अमेज़ॅन ईसी 2, आईएसएडीबी: एमएमएपी (एक्स बाइट्स) असफल; आईएसडीबी प्रारंभिक रूप से शुरू हो रहा है; गलत 12 टेम्पलेट का उपयोग करते समय मुझे "अनसुलझे बाहरी प्रतीक" त्रुटियां क्यों मिलती हैं? उदात्त पाठ 3 में डिफ़ॉल्ट कोड स्निपेट कैसे बदलेंगे? मैं लिनक्स पर जीसीसी के लिए एक साधारण मेसेफ़ाइल कैसे बनाऊं? मुझे थ्रेड-सेफ़ संग्रह संग्रह कहां मिल रहा है? कैलोरी (कैलरीबीट) को आवधिक कार्यों को गतिशील रूप से कैसे जोड़ता / निकालना एक निरंतरता और कॉलबैक के बीच क्या अंतर है? एक्लिप्स में लाइब्रेरी v7 AppCompat को जोड़ने पर "कोई संसाधन नहीं मिला जो दिए गए नाम से मेल खाता है" त्रुटि को कैसे हल करें? XmlDocument से लाइन ब्रेक के साथ इंडेंडेड एक्सएमएल प्राप्त करने का सबसे आसान तरीका क्या है? कोको में XML को पार्स करना ब्राउज़रों को ऐसा क्यों लगता है कि <div /> टैग तुरंत समाप्त नहीं होता है? मर्ज किए गए कवरेज रिपोर्ट देने के लिए मल्टी-मॉड्यूल मैवेन + सोनार + जाकोओ को कैसे कॉन्फ़िगर करें? जेपीए "जेनटेबल" एनोटेशन

स्विफ्ट 2 – असुरक्षित पॉइंटर <शून्य> ऑब्जेक्ट के लिए

अगर मेरे पास एक विधि है:

func someMethod(contextPtr: UnsafeMutablePointer<Void>) 

मैं संदर्भ से वस्तु कैसे प्राप्त contextPtr ?

 func someMethod(contextPtr: UnsafeMutablePointer<Void>){ let object:MyObject = contextPtr.memory } 

देता है:

'शून्य' 'MyObject' के लिए परिवर्तनीय नहीं है

गुप्त सॉस क्या है


ज्यादा जानकारी:

मैं वास्तव में यहाँ क्या कर रहा हूँ SCNetworkReachability लिए एक वैश्विक कॉलबैक फ़ंक्शन स्थापित कर रहा है:

 func callback(reachability:SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutablePointer<Void>) { let r:Reachability = info.memory } 

और फिर कॉलबैक को निम्नानुसार जोड़ रहा है:

 var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil) var s = self withUnsafeMutablePointer(&s) { context.info = UnsafeMutablePointer($0) } SCNetworkReachabilitySetCallback(reachability, callback, &context) 

वेब के समाधान से एकत्रित समाधान "स्विफ्ट 2 – असुरक्षित पॉइंटर <शून्य> ऑब्जेक्ट के लिए"

इसे काम करना चाहिए: ऑब्जेक्ट पॉइंटर को कॉलबैक पर अपारदर्शी अप्रबंधित पॉइंटर के रूप में पास करें:

 context.info = UnsafeMutablePointer(Unmanaged.passUnretained(myObject).toOpaque()) SCNetworkReachabilitySetCallback(reachability, callback, &context) 

और कॉलबैक के माध्यम से पुनः प्राप्त करें:

 func callback(reachability:SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutablePointer<Void>) { let myObject = Unmanaged<MyObject>.fromOpaque(COpaquePointer(info)).takeUnretainedValue() } 

बेशक यह मानता है कि जब तक कॉलबैक स्थापित होता है तब तक ऑब्जेक्ट का कुछ मजबूत संदर्भ मौजूद होता है, ताकि ऑब्जेक्ट डिलोकेटेड न हो।

अपडेट करें: ध्यान दें कि ऑब्जेक्ट पॉइंटर से रिक्त पॉइंटर और बैक से दोनों रूपांतरण सरल किए जा सकते हैं यदि आप "असुरक्षित" फ़ंक्शन का उपयोग करने के लिए तैयार हैं:

 context.info = unsafeAddressOf(myObject) // ... myObject = unsafeBitCast(info, MyObject.self) 

उत्पन्न असेंबली कोड है – जहां तक ​​मैं देख सकता हूँ – समान।

अपडेट 2: यह भी देखें कि "ब्रिजिंग" और कुछ सहायक फ़ंक्शन के बारे में अधिक जानकारी के लिए स्वयं को कैसे अस्वाभाविक रूप से निकालना है।


स्विफ्ट 3 अपडेट (Xcode 8 बीटा 6):

 var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil) context.info = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque()) // ... func callback(reachability:SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutableRawPointer?) { if let info = info { let myObject = Unmanaged<MyObject>.fromOpaque(info).takeUnretainedValue() // ... } } 
 struct S { var i: Int = 10 } var first = S() func foo(contextPtr: UnsafeMutablePointer<Void>){ let pS = UnsafeMutablePointer<S>(contextPtr) pS.memory.i = 100 } print(first.i) // 10 foo(&first) print(first.i) // 100 

अगर हमें असंसक फ़ंक्शन के लिए असुरक्षितपॉइंटर स्वयं के रूप में पास की आवश्यकता होती है

 import XCPlayground XCPlaygroundPage.currentPage.needsIndefiniteExecution = true import Foundation // can be struct, class ... class C { let queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT) var s: String = "" func foo() { var c = self dispatch_async(queue) { () -> Void in f(&c) } } } func f(pV: UnsafeMutablePointer<Void>) { let pC = UnsafeMutablePointer<C>(pV) sleep(1) print(pC.memory.s) } var c1: C? = C() c1!.s = "C1" c1!.foo() // C1 var c2: C? = C() c2!.s = "C2" c2!.foo() // C2 c1 = nil c2 = nil print("test")