enumMemoryLayout<T>
| Import |
|
|---|
Static Variables
The default memory alignment of T, in bytes.
Use the alignment property for a type when allocating memory using an
unsafe pointer. This value is always positive.
Declaration
staticvaralignment:Int{get}
The contiguous memory footprint of T, in bytes.
A type's size does not include any dynamically allocated or out of line
storage. In particular, MemoryLayout<T>.size, when T is a class
type, is the same regardless of how many stored properties T has.
When allocating memory for multiple instances of T using an unsafe
pointer, use a multiple of the type's stride instead of its size.
See Also: stride
Declaration
staticvarsize:Int{get}
The number of bytes from the start of one instance of T to the start of
the next when stored in contiguous memory or in an Array<T>.
This is the same as the number of bytes moved when an UnsafePointer<T>
instance is incremented. T may have a lower minimal alignment that
trades runtime performance for space efficiency. This value is always
positive.
Declaration
staticvarstride:Int{get}
Static Methods
Returns the default memory alignment of T.
Use a type's alignment when allocating memory using an unsafe pointer.
When you have a type instead of an instance, use the
MemoryLayout<T>.stride static property instead.
letx:Int=100// Finding the alignment of a value's typelets=MemoryLayout.alignment(ofValue:x)// s == 8// Finding the alignment of a type directlylett=MemoryLayout<Int>.alignment// t == 8
value: A value representative of the type to describe.
Returns: The default memory alignment, in bytes, of the given value's
type. This value is always positive.
See Also: MemoryLayout.alignment
Declaration
staticfuncalignment(ofValuevalue:T) ->Int
Returns the contiguous memory footprint of the given instance.
The result does not include any dynamically allocated or out of line storage. In particular, pointers and class instances all have the same contiguous memory footprint, regardless of the size of the referenced data.
When you have a type instead of an instance, use the
MemoryLayout<T>.size static property instead.
letx:Int=100// Finding the size of a value's typelets=MemoryLayout.size(ofValue:x)// s == 8// Finding the size of a type directlylett=MemoryLayout<Int>.size// t == 8
value: A value representative of the type to describe.
Returns: The size, in bytes, of the given value's type.
See Also: MemoryLayout.size
Declaration
staticfuncsize(ofValuevalue:T) ->Int
Returns the number of bytes from the start of one instance of T to the
start of the next when stored in contiguous memory or in an Array<T>.
This is the same as the number of bytes moved when an UnsafePointer<T>
instance is incremented. T may have a lower minimal alignment that
trades runtime performance for space efficiency. The result is always
positive.
When you have a type instead of an instance, use the
MemoryLayout<T>.stride static property instead.
letx:Int=100// Finding the stride of a value's typelets=MemoryLayout.stride(ofValue:x)// s == 8// Finding the stride of a type directlylett=MemoryLayout<Int>.stride// t == 8
value: A value representative of the type to describe.
Returns: The stride, in bytes, of the given value's type.
See Also: MemoryLayout.stride
Declaration
staticfuncstride(ofValuevalue:T) ->Int
The memory layout of a type, describing its size, stride, and alignment.
You can use
MemoryLayoutas a source of information about a type when allocating or binding memory using unsafe pointers. The following example declares aPointtype withxandycoordinates and a BooleanisFilledproperty.The size, stride, and alignment of the
Pointtype are accessible as static properties ofMemoryLayout<Point>.Always use a multiple of a type's
strideinstead of itssizewhen allocating memory or accounting for the distance between instances in memory. This example allocates untyped, uninitialized memory with space for four instances ofPoint.