web-dev-qa-db-fra.com

Comment obtenir des octets d'un UnsafeMutableRawPointer?

Comment accéder aux octets (ou aux Int16, aux flottants, etc.) hors de la mémoire pointée par un UnsafeMutableRawPointer (nouveau dans Swift 3) transmis à une fonction Swift par une API C (Core Audio, etc.)

swiftunsafe-pointers
19
hotpaw2

load<T> lit les octets bruts de la mémoire et construit une valeur de type T:

let ptr = ... // Unsafe[Mutable]RawPointer
let i16 = ptr.load(as: UInt16.self)

éventuellement avec un décalage d'octet:

let i16 = ptr.load(fromByteOffset: 4, as: UInt16.self)

Il existe également assumingMemoryBound() qui convertit un Unsafe[Mutable]RawPointer en un Unsafe[Mutable]Pointer<T>, en supposant que la mémoire pointée vers contient une valeur de type T:

let i16 = ptr.assumingMemoryBound(to: UInt16.self).pointee

Pour un tableau de valeurs, vous pouvez créer un "pointeur de mémoire tampon":

let i16bufptr = UnsafeBufferPointer(start: ptr.assumingMemoryBound(to: UInt16.self), count: count)

Un pointeur de mémoire tampon peut déjà suffire à votre tâche, il est susceptible d’être énuméré de la même manière qu’un tableau . Si nécessaire, créez un tableau à partir de ce pointeur:

let i16array = Array(i16bufptr)

Comme @Hamish a dit, plus d'informations et de détails peuvent être trouvés à

38
Martin R

Créer Données objet.

init(bytesNoCopy bytes: UnsafeMutableRawPointer, count: Int, deallocator: Data.Deallocator)

Un moyen important qui manque dans les autres réponses ici est l'initialisation d'un objet Data avec UnsafeMutableRawPointer. L'objet de données peut ensuite être utilisé pour d'autres calculs.

public func base64(quality: Int32 = 67) -> String? {
    var size: Int32 = 0
    if let image = gdImageJpegPtr(internalImage, &size, quality) {
        // gdImageJpegPtr returns an UnsafeMutableRawPointer that is converted to a Data object
        let d = Data(bytesNoCopy: image, count: Int(size), deallocator: .none)
        return d.base64EncodedString()
    }
    return nil
}
3
Hannes Sverrisson

Voici la documentation api de la conversion Unsafe [Mutable] RawPointer en T/Unsafe [MutablePointer]:

/// Binds the allocated memory to type `T` and returns an
/// `UnsafePointer<T>` to the bound memory at `self`.
///
/// - Precondition: The memory is uninitialized.
/// - Postcondition: The memory is bound to 'T' starting at `self` continuing
///   through `self` + `count` * `MemoryLayout<T>.stride`
/// - Warning: Binding memory to a type is potentially undefined if the
///   memory is ever accessed as an unrelated type.
public func bindMemory<T>(to type: T.Type, capacity count: Int) -> UnsafePointer<T>

/// Converts from an `UnsafeRawPointer` to UnsafePointer<T> given that
/// the region of memory starting at `self` is already bound to type `T`.
///
/// - Precondition: The memory is bound to 'T' starting at `self` for some
///   unspecified capacity.
///
/// - Warning: Accessing memory via the returned pointer is undefined if the
///   if the memory has not been bound to `T`.
public func assumingMemoryBound<T>(to: T.Type) -> UnsafePointer<T>

/// Reads raw bytes from memory at `self + offset` and constructs a
/// value of type `T`.
///
/// - Precondition: The underlying pointer plus `offset` is properly
///   aligned for accessing `T`.
///
/// - Precondition: The memory is initialized to a value of some type, `U`,
///   such that `T` is layout compatible with `U`.
public func load<T>(fromByteOffset offset: Int = default, as type: T.Type) -> T

et puis de Unsafe[MutablePointer]<T> àT peut être converti avec pointee et move apis

/// Accesses the `Pointee` instance referenced by `self`.
///
/// - Precondition: the pointee has been initialized with an instance of
///   type `Pointee`.
public var pointee: Pointee { get }

/// Retrieves the `pointee`, returning the referenced memory to an
/// uninitialized state.
///
/// Equivalent to `{ defer { deinitialize() }; return pointee }()`, but
/// more efficient.
///
/// - Precondition: The pointee is initialized.
///
/// - Postcondition: The memory is uninitialized.
public func move() -> Pointee
1
Ankit Thakur

Voici un exemple Swift 4 de conversion d'un tableau UInt8 littéral en un UnsafeMutableRawPointer, puis d'un tableau en UInt32

static func unsafePointerTest() {
    //let a : [UInt8] = [0,0,0,4,0,0,0,8,0,0,0,12]
    let a : [UInt8] = [0x04, 0x00, 0x00, 0x00,
                       0x08, 0x00, 0x00, 0x00,
                       0x0C, 0x00, 0x00, 0x00] //little endian
    //0xFF, 0xF0, 0xF0, 0x12]  //317780223 = 12F0F0FF
    let b:UnsafeMutableRawPointer = UnsafeMutableRawPointer(mutating:a)
    let bTypedPtr = b.bindMemory(to: UInt32.self, capacity: a.count/4)
    let UInt32Buffer = UnsafeBufferPointer(start: bTypedPtr, count: a.count/4)
    let output = Array(UInt32Buffer)
    print(output)
}
1
Mike Lee