A mutable nonowning collection interface to the bytes in a region of memory.

    @frozen struct UnsafeMutableRawBufferPointer


    You can use an UnsafeMutableRawBufferPointer instance in low-level operations to eliminate uniqueness checks and release mode bounds checks. Bounds checks are always performed in debug mode.

    An UnsafeMutableRawBufferPointer instance is a view of the raw bytes in a region of memory. Each byte in memory is viewed as a UInt8 value independent of the type of values held in that memory. Reading from and writing to memory through a raw buffer are untyped operations. Accessing this collection’s bytes does not bind the underlying memory to UInt8.

    In addition to its collection interface, an UnsafeMutableRawBufferPointer instance also supports the following methods provided by UnsafeMutableRawPointer, including bounds checks in debug mode:

    • load(fromByteOffset:as:)

    • loadUnaligned(fromByteOffset:as:)

    • storeBytes(of:toByteOffset:as:)

    • copyMemory(from:)

    To access the underlying memory through typed operations, the memory must be bound to a trivial type.

    UnsafeMutableRawBufferPointer Semantics

    An UnsafeMutableRawBufferPointer instance is a view into memory and does not own the memory that it references. Copying a variable or constant of type UnsafeMutableRawBufferPointer does not copy the underlying memory. However, initializing another collection with an UnsafeMutableRawBufferPointer instance copies bytes out of the referenced memory and into the new collection.

    The following example uses someBytes, an UnsafeMutableRawBufferPointer instance, to demonstrate the difference between assigning a buffer pointer and using a buffer pointer as the source for another collection’s elements. Here, the assignment to destBytes creates a new, nonowning buffer pointer covering the first n bytes of the memory that someBytes references—nothing is copied:

    var destBytes = someBytes[0..<n]

    Next, the bytes referenced by destBytes are copied into byteArray, a new [UInt8] array, and then the remainder of someBytes is appended to byteArray:

    var byteArray: [UInt8] = Array(destBytes)
    byteArray += someBytes[n..<someBytes.count]

    Assigning into a ranged subscript of an UnsafeMutableRawBufferPointer instance copies bytes into the memory. The next n bytes of the memory that someBytes references are copied in this code:

    destBytes[0..<n] = someBytes[n..<(n + n)]



    • typealias Element

      A type representing the sequence’s elements.

    • typealias Index

      A type that represents a position in the collection.

    • typealias Indices

      A type that represents the indices that are valid for subscripting the collection, in ascending order.

    • typealias Iterator

      A type that provides the sequence’s iteration interface and encapsulates its iteration state.

    • typealias SubSequence

      A collection representing a contiguous subrange of this collection’s elements. The subsequence shares indices with the original collection.


    Instance Subscripts

    Instance Properties

    Type Methods

    Instance Methods


    Removed Members

    Type Methods

    Instance Methods