---
title: "withMemoryRebound(to:capacity:_:)"
framework: swift
role: symbol
role_heading: Instance Method
path: "swift/unsafemutablepointer/withmemoryrebound(to:capacity:_:)"
---

# withMemoryRebound(to:capacity:_:)

Executes the given closure while temporarily binding memory to the specified number of instances of the given type.

## Declaration

```swift
func withMemoryRebound<T, E, Result>(to type: T.Type, capacity count: Int, _ body: (UnsafeMutablePointer<T>) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable
```

## Parameters

- `type`: The type to temporarily bind the memory referenced by this pointer. The type T must be layout compatible with the pointer’s Pointee type.
- `count`: The number of instances of T in the re-bound region.
- `body`: A closure that takes a mutable typed pointer to the same memory as this pointer, only bound to type T. The closure’s pointer argument is valid only for the duration of the closure’s execution. If body has a return value, that value is also used as the return value for the withMemoryRebound(to:capacity:_:) method.

## Return Value

Return Value The return value, if any, of the body closure parameter.

## Discussion

Discussion Use this method when you have a pointer to memory bound to one type and you need to access that memory as instances of another type. Accessing memory as a type T requires that the memory be bound to that type. A memory location may only be bound to one type at a time, so accessing the same memory as an unrelated type without first rebinding the memory is undefined. The region of memory that starts at this pointer and covers count strides of T instances must be bound to Pointee. Any instance of T within the re-bound region may be initialized or uninitialized. Every instance of Pointee overlapping with a given instance of T should have the same initialization state (i.e. initialized or uninitialized.) Accessing a T whose underlying Pointee storage is in a mixed initialization state shall be undefined behaviour. The following example temporarily rebinds the memory of a UInt64 pointer to Int64, then modifies the signed integer. let uint64Pointer: UnsafeMutablePointer<UInt64> = fetchValue() uint64Pointer.withMemoryRebound(to: Int64.self, capacity: 1) {     $0.pointee.negate() } Because this pointer’s memory is no longer bound to its Pointee type while the body closure executes, do not access memory using the original pointer from within body. Instead, use the body closure’s pointer argument to access the values in memory as instances of type T. After executing body, this method rebinds memory back to the original Pointee type. note: Only use this method to rebind the pointer’s memory to a type that is layout compatible with the Pointee type. The stride of the temporary type (T) may be an integer multiple or a whole fraction of Pointee’s stride, for example to point to one element of an aggregate. To bind a region of memory to a type that does not match these requirements, convert the pointer to a raw pointer and use the bindMemory(to:) method. If T and Pointee have different alignments, this pointer must be aligned with the larger of the two alignments.