typealias UnsafePointer.Distance
typealias UnsafePointer.Stride
Availability
Technology
@frozen struct UnsafePointer<Pointee>
You use instances of the Unsafe
type to access data of a specific type in memory. The type of data that a pointer can access is the pointer’s Pointee
type. Unsafe
provides no automated memory management or alignment guarantees. You are responsible for handling the life cycle of any memory you work with through unsafe pointers to avoid leaks or undefined behavior.
あなたは、Unsafe
型のインスタンスを使うことで、メモリにおいて特定の型のデータにアクセスします。ポインタがアクセス可能なデータの型は、ポインタのもつPointee
型です。Unsafe
は、自動メモリ管理またはアラインメント保証を提供しません。あなたはリークや未定義挙動を避けるために、あなたが安全でないポインタを通して扱うあらゆるメモリの生涯の処理に責任があります。
Memory that you manually manage can be either untyped or bound to a specific type. You use the Unsafe
type to access and manage memory that has been bound to a specific type.
あなたが手動で管理するメモリは、特定の型に対して型付けされないまたは束縛されるのいずれかが可能です。あなたは、Unsafe
型を使うことで、特定の型に束縛されているメモリへのアクセスおよび管理を行います。
The memory referenced by an Unsafe
instance can be in one of several states. Many pointer operations must only be applied to pointers with memory in a specific state—you must keep track of the state of the memory you are working with and understand the changes to that state that different operations perform. Memory can be untyped and uninitialized, bound to a type and uninitialized, or bound to a type and initialized to a value. Finally, memory that was allocated previously may have been deallocated, leaving existing pointers referencing unallocated memory.
Unsafe
インスタンスによって参照されるメモリは、幾つかの状態のうち1つであるはずです。多くのポインタ演算はある特定の状態のメモリを持つポインタに適用されるだけであるべきです — あなたは、あなたが作業しているメモリの状態を見失わないようにして、異なる演算が実行するその状態の変更を理解していなければなりません。メモリは、型無しで未初期化、ある型に束縛されて未初期化、またはある型に束縛されてある値に初期化される可能性があります。結局、以前にアロケートされたメモリはデアロケートされるかもしれません、アロケートされないメモリを参照している既存のポインタはそのままです。
Memory that has just been allocated through a typed pointer or has been deinitialized is in an uninitialized state. Uninitialized memory must be initialized before it can be accessed for reading. 型付ポインタを通して今しがたアロケートされる、または未初期化状態にデイニシャライズされるメモリ。未初期化メモリは、それが読み出しのためアクセスされる前に初期化される必要があります。
Initialized memory has a value that can be read using a pointer’s pointee
property or through subscript notation. In the following example, ptr
is a pointer to memory initialized with a value of 23
:
初期化済メモリは、pointee
プロパティまたは添え字表記法を使って読み出し可能な値を持ちます。以下の例において、ptr
は23
の値で初期化されるメモリに対するポインタです。
When you access memory through an Unsafe
instance, the Pointee
type must be consistent with the bound type of the memory. If you do need to access memory that is bound to one type as a different type, Swift’s pointer types provide type-safe ways to temporarily or permanently change the bound type of the memory, or to load typed instances directly from raw memory.
あなたがメモリにUnsafe
インスタンスを通してアクセスする時、Pointee
型はそのメモリの束縛される型と一致しなければなりません。あなたがある型に束縛されるメモリに異なる型としてアクセスする必要があるならば、Swiftのポインタ型は型安全な方法を提供することで、一時的にまたは永続的にメモリの束縛される型を変更します、または型付インスタンスを直接に生のメモリからロードします。
An Unsafe
instance allocated with eight bytes of memory, uint8Pointer
, will be used for the examples below.
8バイトのメモリデアロケートされるUnsafe
インスタンス、uint8Pointer
は、下の例で使われます。
When you only need to temporarily access a pointer’s memory as a different type, use the with
method. For example, you can use this method to call an API that expects a pointer to a different type that is layout compatible with your pointer’s Pointee
. The following code temporarily rebinds the memory that uint8Pointer
references from UInt8
to Int8
to call the imported C strlen
function.
あなたがポインタのもつメモリに異なる型として一時的にアクセスする必要があるだけならば、with
メソッドを使ってください。例えば、あなたはこのメソッドを使うことで、異なる型へのポインタを期待するもので、あなたのポインタのもつPointee
と互換のレイアウトである、あるAPIを呼び出すことができます。以下のコードは、一時的にuint8Pointer
が参照するメモリをUInt8
からInt8
へと再束縛することで、インポートされたC strlen
関数を呼び出します。
When you need to permanently rebind memory to a different type, first obtain a raw pointer to the memory and then call the bind
method on the raw pointer. The following example binds the memory referenced by uint8Pointer
to one instance of the UInt64
type:
あなたが永続的にメモリを異なる型へ再束縛する必要があるならば、まずメモリに対する生のポインタを取得して、それからbind
メソッドを生のポインタ上で呼び出してください。以下の例は、uint8Pointer
によって参照されるメモリをUInt64
型のあるインスタンスに束縛します:
After rebinding the memory referenced by uint8Pointer
to UInt64
, accessing that pointer’s referenced memory as a UInt8
instance is undefined.
uint8Pointer
によって参照されるメモリをUInt64
に再束縛する後、そのポインタの参照したメモリにUInt8
インスタンスとしてアクセスすることは未定義です。
Alternatively, you can access the same memory as a different type without rebinding through untyped memory access, so long as the bound type and the destination type are trivial types. Convert your pointer to an Unsafe
instance and then use the raw pointer’s load(from
method to read values.
その代わりに、あなたは同じメモリに異なる型として再束縛することなしにアクセスすることが型なしメモリアクセスを通して可能です、束縛される型と行き先の型が自明型である限りは。あなたのポインタをUnsafe
インスタンスに変換して、それから生のポインタのもつload(from
メソッドを使って値を読みだしてください。
Pointer arithmetic with a typed pointer is counted in strides of the pointer’s Pointee
type. When you add to or subtract from an Unsafe
instance, the result is a new pointer of the same type, offset by that number of instances of the Pointee
type.
型付ポインタでのポインタ算術は、ポインタのもつPointee
型のストライドで勘定されます。あなたがUnsafe
インスタンスに加えたりそれから引いたりする場合、結果は同じ型の新しいポインタです、Pointee
型のインスタンスの数によってオフセットします。
You can also use subscript notation to access the value in memory at a specific offset. あなたはまた、添え字表記法を使ってメモリ中の値に特定のオフセットでアクセスできます。
When calling a function or method with an Unsafe
parameter, you can pass an instance of that specific pointer type, pass an instance of a compatible pointer type, or use Swift’s implicit bridging to pass a compatible pointer.
関数やメソッドをUnsafe
パラメータとともに呼び出すとき、あなたはその特定のポインタ型のインスタンスを渡す、互換ポインタ型のインスタンスを渡す、またはSwiftの暗黙的ブリッジを使って互換ポインタを渡すことが可能です。
For example, the print
function in the following code sample expects an Unsafe
instance as its first parameter:
例えば、print
関数は以下のコード例において、Unsafe
インスタンスをそれの最初のパラメータとして期待します。
As is typical in Swift, you can call the print
function with an Unsafe
instance. This example passes int
, a pointer to an Int
value, to print(address:)
.
Swiftでは普通であるように、あなたはprint
関数をUnsafe
インスタンスとともに呼び出せます。この例はint
、Int
値へのポインタをprint(address:)
に渡します。
Because a mutable typed pointer can be implicitly cast to an immutable pointer with the same Pointee
type when passed as a parameter, you can also call print
with an Unsafe
instance.
可変の型付ポインタは同じPointee
型を持つ不変のポインタに暗黙的にキャストされることがパラメータとして渡される時に可能なことから、あなたはまたprint
をUnsafe
インスタンスとともに呼び出せます。
Alternatively, you can use Swift’s implicit bridging to pass a pointer to an instance or to the elements of an array. The following example passes a pointer to the value
variable by using inout syntax:
あるいはまた、あなたはSwiftの暗黙的ブリッジを使ってポインタをインスタンスへまたは配列の要素へと渡せます。以下の例は、value
変数へのポインタをinout構文を使って渡します:
An immutable pointer to the elements of an array is implicitly created when you pass the array as an argument. This example uses implicit bridging to pass a pointer to the elements of numbers
when calling print
.
配列の要素への不変ポインタは、あなたが配列を引数として渡す時に暗黙的に作成されます。この例は、暗黙的ブリッジを使ってポインタをnumbers
の要素へと、print
を呼び出す時に渡します。
You can also use inout syntax to pass a mutable pointer to the elements of an array. Because print
requires an immutable pointer, although this is syntactically valid, it isn’t necessary.
あなたはまた、インアウト構文を使って、可変ポインタを配列の要素へ渡せます。print
が不変ポインタを要求することから、これは構文的には有効ですが、必要ではありません。
No matter which way you call print
, Swift’s type safety guarantees that you can only pass a pointer to the type required by the function—in this case, a pointer to an Int
.
あなたがprint
を呼び出す方法は問題ではありません、Swiftの型安全は、あなたが関数によって要求される型へのポインタを渡すことだけが可能であるのを保証します — この場合、Int
へのポインタ。
Important 重要
The pointer created through implicit bridging of an instance or of an array’s elements is only valid during the execution of the called function. Escaping the pointer to use after the execution of the function is undefined behavior. In particular, do not use implicit bridging when calling an Unsafe
initializer.
インスタンスのまたは配列の要素の暗黙的ブリッジを通して作成されるポインタは、呼び出された関数の実行の間に有効であるだけです。関数の実行の後に使うためにポインタを脱出させることは、未定義の挙動となります。とりわけ、暗黙的ブリッジをUnsafe
イニシャライザを呼ぶ時に使わないでください。
typealias UnsafePointer.Distance
typealias UnsafePointer.Stride
init?(UnsafePointer<Pointee>?)
init?(OpaquePointer?)
init(OpaquePointer)
init(UnsafePointer<Pointee>)
init?(bitPattern : Int)
init?(bitPattern : UInt)
var customMirror : Mirror
var customPlaygroundQuickLook : PlaygroundQuickLook
var debugDescription : String
var hashValue : Int
var pointee: Pointee
func advanced(by: Int) -> UnsafePointer<Pointee>
func bytes() -> MIDIPacket.ByteCollection
Pointee
is MIDIPacket
.
Pointee
がMIDIPacket
である時に利用可能です。
func deallocate()
func distance(to: UnsafePointer<Pointee>) -> Int
Pointee
type.
このポインタから与えられたポインタまでの隔たりを返します、ポインタのもつPointee
型のインスタンスとして数えられます。
func hash(into: inout Hasher)
func predecessor() -> UnsafePointer<Pointee>
func sequence() -> MIDIPacket.ByteSequence
Pointee
is MIDIPacket
.
Pointee
がMIDIPacket
である時に利用可能です。
func sequence() -> MIDIEventPacket.WordSequence
Pointee
is MIDIEventPacket
.
Pointee
がMIDIEventPacket
である時に利用可能です。
func successor() -> UnsafePointer<Pointee>
func unsafeSequence () -> MIDIPacketList.UnsafeSequence
Pointee
is MIDIPacketList
.
Pointee
がMIDIPacketList
である時に利用可能です。
func unsafeSequence () -> MIDIEventList.UnsafeSequence
Pointee
is MIDIEventList
.
Pointee
がMIDIEventList
である時に利用可能です。
func withMemoryRebound <T, Result>(to: T.Type, capacity: Int, (UnsafePointer<T>) -> Result) -> Result
func words() -> MIDIEventPacket.WordCollection
Pointee
is MIDIEventPacket
.
Pointee
がMIDIEventPacket
である時に利用可能です。
subscript(Int) -> Pointee
static func != (UnsafePointer<Pointee>, UnsafePointer<Pointee>) -> Bool
static func ... (UnsafePointer<Pointee>) -> PartialRangeFrom<UnsafePointer<Pointee>>
static func ... (UnsafePointer<Pointee>) -> PartialRangeThrough<UnsafePointer<Pointee>>
static func ... (UnsafePointer<Pointee>, UnsafePointer<Pointee>) -> ClosedRange<UnsafePointer<Pointee>>
static func ..< (UnsafePointer<Pointee>) -> PartialRangeUpTo<UnsafePointer<Pointee>>
static func ..< (UnsafePointer<Pointee>, UnsafePointer<Pointee>) -> Range<UnsafePointer<Pointee>>
static func < (UnsafePointer<Pointee>, UnsafePointer<Pointee>) -> Bool
static func <= (UnsafePointer<Pointee>, UnsafePointer<Pointee>) -> Bool
static func == (UnsafePointer<Pointee>, UnsafePointer<Pointee>) -> Bool
static func > (UnsafePointer<Pointee>, UnsafePointer<Pointee>) -> Bool
static func >= (UnsafePointer<Pointee>, UnsafePointer<Pointee>) -> Bool
struct UnsafeMutablePointer
struct UnsafeBufferPointer
struct UnsafeMutableBufferPointer