在 Swift 中将两个字节的 UInt8 数组转换为 UInt16

Question

使用 Swift 我想将字节从 uint8_t 数组转换为整数。

“C”示例：

char bytes[2] = {0x01, 0x02};
NSData *data = [NSData dataWithBytes:bytes length:2];
NSLog(@"data: %@", data); // data: <0102>

uint16_t value2 = *(uint16_t *)data.bytes;
NSLog(@"value2: %i", value2); // value2: 513

快速尝试：

let bytes:[UInt8] = [0x01, 0x02]
println("bytes: \(bytes)") // bytes: [1, 2]
let data = NSData(bytes: bytes, length: 2)
println("data: \(data)") // data: <0102>

let integer1 = *data.bytes // This fails
let integer2 = *data.bytes as UInt16 // This fails

let dataBytePointer = UnsafePointer<UInt16>(data.bytes)
let integer3 = dataBytePointer as UInt16 // This fails
let integer4 = *dataBytePointer as UInt16 // This fails
let integer5 = *dataBytePointer // This fails

在 Swift 中从 UInt8 数组创建 UInt16 值的正确语法或代码是什么？

我对 NSData 版本感兴趣，正在寻找不使用临时数组的解决方案。

Answer 1

如果你想通过NSData ，那么它会像这样工作：

let bytes:[UInt8] = [0x01, 0x02]
println("bytes: \(bytes)") // bytes: [1, 2]
let data = NSData(bytes: bytes, length: 2)
print("data: \(data)") // data: <0102>

var u16 : UInt16 = 0 ; data.getBytes(&u16)
// Or:
let u16 = UnsafePointer<UInt16>(data.bytes).memory

println("u16: \(u16)") // u16: 513

或者：

let bytes:[UInt8] = [0x01, 0x02]
let u16 = UnsafePointer<UInt16>(bytes).memory
print("u16: \(u16)") // u16: 513

两种变体都假定字节按主机字节顺序排列。

Swift 3 (Xcode 8) 更新：

let bytes: [UInt8] = [0x01, 0x02]
let u16 = UnsafePointer(bytes).withMemoryRebound(to: UInt16.self, capacity: 1) {
    $0.pointee
}
print("u16: \(u16)") // u16: 513

Answer 2

在 Swift 5 或更高版本中，您可以使用 withUnsafeBytes { $0.load(as: UInt16.self) } 将字节 [UInt8] 转换为 UInt16 值

let bytes: [UInt8] = [1, 2]

加载为UInt16

let uint16 = bytes.withUnsafeBytes { $0.load(as: UInt16.self) }    // 513 

---

为了摆脱冗长，我们可以创建一个扩展 ContiguousBytes 的泛型方法：

extension ContiguousBytes {
    func object<T>() -> T {
        withUnsafeBytes { $0.load(as: T.self) }
    }
}

---

用法：

let bytes: [UInt8] = [1, 2]
let uint16: UInt16 = bytes.object()    // 513

---

并访问集合中任何位置的字节：

extension Data {
    func subdata<R: RangeExpression>(in range: R) -> Self where R.Bound == Index {
        subdata(in: range.relative(to: self) )
    }
    func object<T>(at offset: Int) -> T {
        subdata(in: offset...).object()
    }
}

---

extension Sequence where Element == UInt8  {
    var data: Data { .init(self) }
}

---

extension Collection where Element == UInt8, Index == Int {
    func object<T>(at offset: Int = 0) -> T {
        data.object(at: offset)
    }
}

---

用法：

let bytes: [UInt8] = [255, 255, 1, 2]
let uintMax: UInt16 = bytes.object()      // 65535 at offset zero
let uint16: UInt16 = bytes.object(at: 2)  // 513   at offset two

Answer 3

怎么样

let bytes:[UInt8] = [0x01, 0x02]
let result = (UInt16(bytes[1]) << 8) + UInt16(bytes[0])

使用循环，这很容易推广到更大的字节数组，并且可以包装在函数中以提高可读性：

let bytes:[UInt8] = [0x01, 0x02, 0x03, 0x04]

func bytesToUInt(byteArray: [UInt8]) -> UInt {
  assert(byteArray.count <= 4)
  var result: UInt = 0
  for idx in 0..<(byteArray.count) {
    let shiftAmount = UInt((byteArray.count) - idx - 1) * 8
    result += UInt(byteArray[idx]) << shiftAmount
  }
  return result
}

println(bytesToUInt(bytes))    // result is 16909060

Answer 4

我不知道 swift 的语法，但是像这样的东西呢：

let a:UInt16 = UInt16(bytes[0]) * 256 + UInt16(bytes[1])

Answer 5

如果字节在NSData 对象中，您可以这样做（假设data:NSData）：

var number: UInt16 = 0
data.getBytes(&number, length: sizeof(UInt16))

getBytes 方法在number 的内存位置最多写入两个字节（类似于C 的memcpy。 如果data 没有足够的字节，这不会使您的应用程序崩溃。

（编辑：如果从缓冲区的开头开始，则无需使用范围）

Answer 6

Martin R 的回答非常棒，并且针对 beta 6 进行了很好的更新。 但是，如果您需要获取不在缓冲区开头的字节，则建议的 withMemoryRebound 方法不提供重新绑定的范围。 我对此的解决方案，例如。从数组中挑选出第二个 UInt16 是：

var val: UInt16 = 0
let buf = UnsafeMutableBufferPointer(start: &val, count: 1)
_ = dat.copyBytes(to: buf, from: Range(2...3))

Answer 7

假设小端编码。

要从 [UInt8] 转换为 UInt16，您可以执行类似的操作

var x: [UInt8] = [0x01, 0x02]
var y: UInt16 = 0
y += UInt16(x[1]) << 0o10
y += UInt16(x[0]) << 0o00

为了转换为 UInt32，此模式扩展到

var x: [UInt8] = [0x01, 0x02, 0x03, 0x04]
var y: UInt32 = 0
y += UInt32(x[3]) << 0o30
y += UInt32(x[2]) << 0o20
y += UInt32(x[1]) << 0o10
y += UInt32(x[0]) << 0o00

移位量的八进制表示可以很好地指示移位了多少完整字节（8 变为 0o10，16 变为 0o20 等）。

对于 UInt16，这可以简化为以下内容：

var x: [UInt8] = [0x01, 0x02]
let y: UInt16 = reverse(x).reduce(UInt16(0)) {
    $0 << 0o10 + UInt16($1)
}

以及 UInt32 的以下内容：

var x: [UInt8] = [0x01, 0x02, 0x03, 0x04]
let y: UInt32 = reverse(x).reduce(UInt32(0)) {
    $0 << 0o10 + UInt32($1)
}

精简版也适用于 UInt64，并且还可以处理字节编码不使用所有字节的值，例如 [0x01, 0x02, 0x03]