# withUnsafeTemporaryAllocation(byteCount:alignment:_:) Provides scoped access to a raw buffer pointer with the specified byte count and alignment. ``` func withUnsafeTemporaryAllocation(byteCount: Int, alignment: Int, _ body: (UnsafeMutableRawBufferPointer) throws(E) -> R) throws(E) -> R where E : Error, R : ~Copyable ``` ## Parameters `byteCount` The number of bytes to temporarily allocate. `byteCount` must not be negative. `alignment` The alignment of the new, temporary region of allocated memory, in bytes. `alignment` must be a whole power of 2. `body` A closure to invoke and to which the allocated buffer pointer should be passed. ## Return Value Whatever is returned by `body`. ## Discussion> Throws: Whatever is thrown by `body`. This function is useful for cheaply allocating raw storage for a brief duration. Storage may be allocated on the heap or on the stack, depending on the required size and alignment. When `body` is called, the contents of the buffer pointer passed to it are in an unspecified, uninitialized state. `body` is responsible for initializing the buffer pointer before it is used *and* for deinitializing it before returning, but deallocation is automatic. The buffer pointer passed to `body` (as well as any pointers to elements in the buffer) must not escape. It will be deallocated when `body` returns and cannot be used afterward. --- Copyright © 2026 Apple Inc. All rights reserved. | [Terms of Use](https://www.apple.com/legal/internet-services/terms/site.html) | [Privacy Policy](https://www.apple.com/privacy/privacy-policy)