स्विफ्ट

Question

में एक फ्लोट के कच्चे बाइट प्राप्त करें मैं स्विफ्ट में Float या Double के कच्चे बाइट कैसे पढ़ सकता हूं?

उदाहरण:

let x = Float(1.5) 
let bytes1: UInt32 = getRawBytes(x) 
let bytes2: UInt32 = 0b00111111110000000000000000000000 

मैं bytes1 और bytes2 चाहते हैं, एक ही मूल्य को नियंत्रित करने के बाद से इस द्विआधारी संख्या 1.5 की फ्लोट प्रतिनिधित्व है।

मुझे & और >> (इन्हें फ्लोट पर परिभाषित नहीं किया गया है) जैसे बिट-वार ऑपरेशंस करने की आवश्यकता है। स्विफ्ट 3 के लिए

Answer 1

अद्यतन: स्विफ्ट 3, सभी चल बिन्दु प्रकार bitPattern संपत्ति जो के साथ एक ही स्मृति प्रतिनिधित्व एक अहस्ताक्षरित पूर्णांक रिटर्न है के रूप में, और विपरीत रूपांतरण के लिए एक इसी init(bitPattern:) निर्माता।

उदाहरण:FloatUInt32 रहे हैं:

let x = Float(1.5) 
let bytes1 = x.bitPattern 
print(String(format: "%#08x", bytes1)) // 0x3fc00000 

उदाहरण:UInt32Float रहे हैं:

let bytes2 = UInt32(0x3fc00000) 
let y = Float(bitPattern: bytes2) 
print(y) // 1.5 

उसी तरह आप Double और UInt64, या CGFloat के बीच के बीच परिवर्तित कर सकते हैं ए nd UInt।

---

पुराना जवाब के लिए स्विफ्ट 1.2 और स्विफ्ट 2:

let x = Float(1.5) 
let bytes1 = x._toBitPattern() 
print(String(format: "%#08x", bytes1)) // 0x3fc00000 

let bytes2: UInt32 = 0b00111111110000000000000000000000 
print(String(format: "%#08x", bytes2)) // 0x3fc00000 

print(bytes1 == bytes2) // true 

इस विधि जो करने के लिए FloatingPointType प्रोटोकॉल का हिस्सा है: स्विफ्ट चल बिन्दु प्रकार एक _toBitPattern() विधि है Float, Double और CGFloat अनुरूप:

/// A set of common requirements for Swift's floating point types. 
protocol FloatingPointType : Strideable { 
    typealias _BitsType 
    static func _fromBitPattern(bits: _BitsType) -> Self 
    func _toBitPattern() -> _BitsType 

    // ... 
} 

(स्विफ्ट 2 के रूप में, ये परिभाषा अब एपीआई दस्तावेज में दिखाई नहीं दे रही है, लेकिन वे अभी भी मौजूद हैं और पहले की तरह काम करते हैं।)

_BitsType की वास्तविक परिभाषा एपीआई दस्तावेज में दिखाई नहीं देता है, लेकिन यह Double के लिए Float के लिए UInt32, UInt64, और IntCGFloat के लिए है:

print(Float(1.0)._toBitPattern().dynamicType) 
// Swift.UInt32 

print(Double(1.0)._toBitPattern().dynamicType) 
// Swift.UInt64 

print(CGFloat(1.0)._toBitPattern().dynamicType) 
// Swift.UInt 

_fromBitPattern() रूपांतरण के लिए इस्तेमाल किया जा सकता अन्य दिशा में:

let y = Float._fromBitPattern(0x3fc00000) 
print(y) // 1.5 

Answer 2

आप इस तरह unsafeBitCast उपयोग कर सकते हैं,:

let x = Float(1.5) 
let bytes1: UInt32 = unsafeBitCast(x, UInt32.self) 
let bytes2: UInt32 = 0b00111111110000000000000000000000 
if (bytes1 == bytes2) { 
    println ("Success") 
} 

ऊपर प्रिंट "Success" जब आप इसे चलाते हैं।

Answer 3

यह काम करने के लिए मिल नहीं सका:

let x = Float(1.5) 
let bytes1 = x.bitPattern 
print(String(format: "%#08x", bytes1)) // 0x3fc00000 

या इस:

let bytes1: UInt32 = unsafeBitCast(x, UInt32.self) 

तो मैं इस के लिए चला गया:

print(String(x.bitPattern, radix: 2))