留双龙 發表於 2022-9-23 15:05:42

Swift 指针底层探索分析

<div id="navCategory"><h5 class="catalogue">目录</h5><ul class="first_class_ul"><li>概要</li><li>1. 指针的认识</li><ul class="second_class_ul"><li>1.1 指定类型指针</li><li>1.2 未指定类型指针</li><li>1.3 访问结构体实例对象</li></ul><li>2. 指针的常见绑定</li><ul class="second_class_ul"><li>2.1 指针与内存空间的绑定（指向）（bindMemory)</li><li>2.2 元组指针类型转换(假定内存绑定assumingMemoryBound)</li><li>2.3 通过 withMemoryRebound 临时绑定内存类型</li></ul><li>3、总结</li><ul class="second_class_ul"></ul></ul></div><p class="maodian"></p><h2>概要</h2>
<p>主要内容：</p>
<p>指针的认识</p>
<p>指针的常见绑定</p>
<p class="maodian"></p><h2>1. 指针的认识</h2>
<p>指针分为两类，指定数据类型和未指定数据类型</p>
<p><strong>区别：</strong></p>
<p style="text-align:center"><img alt="" src="https://img.jbzj.com/file_images/article/202209/20220923092525033.jpg" /></p>
<p class="maodian"></p><h3>1.1 指定类型指针</h3>
<p><strong>代码：</strong></p>
<p style="text-align:center"><img alt="" src="https://img.jbzj.com/file_images/article/202209/20220923092525034.jpg" /></p>
<p><strong>运行结果：</strong></p>
<p style="text-align:center"><img alt="" src="https://img.jbzj.com/file_images/article/202209/20220923092525035.jpg" /></p>
<p><strong>说明：</strong></p>
<ul><li>指针的内存需要自己管理，需要手动开辟空间和释放空间</li><li>存储数据时，需要移动一定的字节大小</li><li>移动通过advanced实现</li><li>存储数据通过storeBytes实现</li><li>取出数据通过load实现</li></ul>
<p class="maodian"></p><h3>1.2 未指定类型指针</h3>
<p><strong>代码：</strong></p>
<div class="jb51code"><pre class="brush:cpp;">&lt;!--定义--&gt;
@inlinable public func withUnsafePointer&lt;T, Result&gt;(to value: inout T, _ body: (UnsafePointer&lt;T&gt;) throws -&gt; Result) rethrows -&gt; Result
&lt;!--使用1--&gt;
var age = 10
let p = withUnsafePointer(to: &amp;age) { $0 }
print(p)
&lt;!--使用2--&gt;
withUnsafePointer(to: &amp;age){print($0)}
&lt;!--使用3--&gt;
//其中p1的类型是 UnsafePointer&lt;Int&gt;
let p1 = withUnsafePointer(to: &amp;age) { ptr in
    return ptr
}
</pre></div>
<p><strong>说明：</strong></p>
<ul><li>对于withUnsafePointer的定义，我们可以看到闭包中返回的结果就是这个函数返回的结果</li><li>因此我们在使用这个指针时，就可以通过闭包返回数据来决定拿到的结果</li><li>所以可以看到我们可以有两种方式，1）直接返回指针；2）返回具体的数据</li></ul>
<p><strong>访问属性：</strong></p>
<p><strong>直接修改：</strong></p>
<p>直接在闭包中计算后将结果返回给属性</p>
<div class="jb51code"><pre class="brush:cpp;">var age = 10
age = withUnsafePointer(to: &amp;age) { ptr in
    //返回Int整型值
    return ptr.pointee + 12
}
print(age)
</pre></div>
<p><strong>间接修改：</strong></p>
<div class="jb51code"><pre class="brush:cpp;">var age = 10
//分配容量大小，为8字节
let ptr = UnsafeMutablePointer&lt;Int&gt;.allocate(capacity: 1)
//初始化
ptr.initialize(to: age)
ptr.deinitialize(count: 1)
ptr.pointee += 12
print(ptr.pointee)
//释放
ptr.deallocate()
</pre></div>
<p><strong>说明：</strong></p>
<ul><li>返回指针，指针拿到pointee来进行修改</li></ul>
<p class="maodian"></p><h3>1.3 访问结构体实例对象</h3>
<p><strong>结构体：</strong></p>
<div class="jb51code"><pre class="brush:cpp;">struct CJLTeacher {
    var age = 10
    var height = 1.85
}
var t = CJLTeacher()
</pre></div>
<p><strong>指针处理：</strong></p>
<div class="jb51code"><pre class="brush:cpp;">//分配两个CJLTeacher大小的空间
let ptr = UnsafeMutablePointer&lt;CJLTeacher&gt;.allocate(capacity: 2)
//初始化第一个空间
ptr.initialize(to: CJLTeacher())
//移动，初始化第2个空间
ptr.successor().initialize(to: CJLTeacher(age: 20, height: 1.75))
//访问方式一
print(ptr)
print(ptr)
//访问方式二
print(ptr.pointee)
print((ptr+1).pointee)
//访问方式三
print(ptr.pointee)
//successor 往前移动
print(ptr.successor().pointee)
//必须和分配是一致的
ptr.deinitialize(count: 2)
//释放
ptr.deallocate()
</pre></div>
<p><strong>说明：</strong></p>
<ul><li>直接通过下标来获取</li><li>通过指针偏移来获取</li><li>通过successor()偏移一步来获取，它可以通用在指定指针类型和未指定指针类型</li></ul>
<p class="maodian"></p><h2>2. 指针的常见绑定</h2>
<p class="maodian"></p><h3>2.1 指针与内存空间的绑定（指向）（bindMemory)</h3>
<p>将指针指向某个内存空间，也就是绑定到这个内存空间上</p>
<p><strong>定义：</strong></p>
<div class="jb51code"><pre class="brush:cpp;">struct HeapObject {
    var kind: Int
    var strongRef: UInt32
    var unownedRef: UInt32
}
class CJLTeacher{
    var age = 18
}
var t = CJLTeacher()
</pre></div>
<p><strong>绑定：</strong></p>
<div class="jb51code"><pre class="brush:cpp;">//将t绑定到结构体内存中
//1、获取实例变量的内存地址，声明成了非托管对象
/*
通过Unmanaged指定内存管理，类似于OC与CF的交互方式（所有权的转换 __bridge）
- passUnretained 不增加引用计数，即不需要获取所有权
- passRetained 增加引用计数，即需要获取所有权
- toOpaque 不透明的指针
*/
let ptr = Unmanaged.passUnretained(t as AnyObject).toOpaque()
//2、绑定到结构体内存,返回值是UnsafeMutablePointer&lt;T&gt;
/*
- bindMemory 更改当前 UnsafeMutableRawPointer 的指针类型，绑定到具体的类型值
    - 如果没有绑定，则绑定
    - 如果已经绑定，则重定向到 HeapObject类型上
*/
let heapObject = ptr.bindMemory(to: HeapObject.self, capacity: 1)
//3、访问成员变量
print(heapObject.pointee.kind)
print(heapObject.pointee.strongRef)
print(heapObject.pointee.unownedRef)
</pre></div>
<p><strong>说明：</strong></p>
<ul><li>首先创建一个指针，指针指向CJLTeacher</li><li>通过bindMemeory将指针绑定到结构体HeapObject中</li><li>接下来就可以通过这个指针来访问内存数据了</li></ul>
<p class="maodian"></p><h3>2.2 元组指针类型转换(假定内存绑定assumingMemoryBound)</h3>
<p>元组和指针指向内存的数据类型不一样，就需要使用假定内存绑定</p>
<p><strong>代码：</strong></p>
<div class="jb51code"><pre class="brush:cpp;">var tul = (10, 20)
//UnsafePointer&lt;T&gt;
func testPointer(_ p : UnsafePointer&lt;Int&gt;){
    print(p)
}
withUnsafePointer(to: &amp;tul) { (tulPtr: UnsafePointer&lt;(Int, Int)&gt;) in
    //不能使用bindMemory，因为已经绑定到具体的内存中了
    //使用assumingMemoryBound，假定内存绑定，目的是告诉编译器ptr已经绑定过Int类型了，不需要再检查memory绑定
    testPointer(UnsafeRawPointer(tulPtr).assumingMemoryBound(to: Int.self))
}
</pre></div>
<p><strong>说明：</strong></p>
<ul><li>testPointe需要传入的是一个泛型为Int的指针</li><li>我们此时想要传入一个元组，元组类型为（Int, Int)，与Int类型不一样</li><li>因此无法通过memoryBind来直接指向Int内存</li><li>所以就需要通过assumingMemoryBound(to: Int.self)来指向</li><li>这是因为假定内存绑定是假绑定，不需要进行严格的类型检查</li></ul>
<p><strong>举例：获取结构体的属性的指针</strong></p>
<div class="jb51code"><pre class="brush:cpp;">struct HeapObject {
    var strongRef: UInt32 = 10
    var unownedRef: UInt32 = 20
}
func testPointer(_ p: UnsafePointer&lt;Int&gt;){
   print(p)
}
//实例化
vart = HeapObject()
//获取结构体属性的指针传入函数
withUnsafePointer(to: &amp;t) { (ptr: UnsafePointer&lt;HeapObject&gt;) in
    //1. 获取变量
    let strongRef = UnsafeRawPointer(ptr) + MemoryLayout&lt;HeapObject&gt;.offset(of: \HeapObject.strongRef)!
    //2. 传递strongRef属性的值
    testPointer(strongRef.assumingMemoryBound(to: Int.self))
}
</pre></div>
<p><strong>说明：</strong></p>
<ul><li>通过地址偏移拿到结构体中的strngRef变量</li><li>之后也是通过假定绑定将其转换为一个指针（从Uint32到Int）</li></ul>
<p class="maodian"></p><h3>2.3 通过 withMemoryRebound 临时绑定内存类型</h3>
<p><strong>问题：</strong></p>
<p style="text-align:center"><img alt="" src="https://img.jbzj.com/file_images/article/202209/20220923092525036.jpg" /></p>
<p><strong>代码实现：</strong></p>
<div class="jb51code"><pre class="brush:cpp;">var age = 10
func testPointer(_ p: UnsafePointer&lt;Int64&gt;){
   print(p)
}
let ptr = withUnsafePointer(to: &amp;age) {$0}
ptr.withMemoryRebound(to: Int64.self, capacity: 1) { (ptr: UnsafePointer&lt;Int64&gt;)in
    testPointer(ptr)
}
</pre></div>
<p><strong>说明：</strong></p>
<ul><li>此处可以看到ptr的指针泛型为Int，而testPointer的参数指针泛型为Int64，所以并不能直接传递</li><li>而这个指针我们只是作为参数传递，所以就可以临时绑定一下</li><li>实现方式就是ptr.withMemoryRebound(to: Int64.self, capacity: 1)</li><li>在出了这个作用域后，ptr仍然是Int类型</li></ul>
<p class="maodian"></p><h2>3、总结</h2>
<ul><li>指针类型分两种</li><li>typed pointer 指定数据类型指针，即 UnsafePointer&lt; T &gt; + unsafeMutablePointer</li><li>raw pointer 未指定数据类型的指针（原生指针） ，即UnsafeRawPointer + unsafeMutableRawPointer</li></ul>
<p>指针的内存管理需要手动管理</p>
<p>假定内存绑定和内存绑定的区别</p>
<p>需要注意对于指针类型指针，可以通过指针偏移来偏移内存大小，而对于未指定类型的指针，只能通过内存偏移来偏移内存大小</p>
<p>将一个指针绑定到内存中，其实就是指向到这个内存空间</p>
<p>三种绑定的区别</p>
<ul><li>绑定：bindMemory(to: Capacity:): 更改内存绑定的类型，如果之前没有绑定，那么就是首次绑定，如果绑定过了，会被重新绑定为该类型</li><li>假定绑定：assumingMemoryBound假定内存绑定，这里就是告诉编译器：我的类型就是这个，你不要检查我了,其实际类型还是原来的类型</li><li>临时绑定：withMemoryRebound: 临时更改内存绑定类型</li></ul>
<p>以上就是Swift 指针底层探索分析的详细内容，更多关于Swift 指针底层的资料请关注琼殿技术社区其它相关文章！</p>
                           
                            <div class="art_xg">
                              <b>您可能感兴趣的文章:</b><ul><li>详解Swift的内存管理</li><li>深入探究Swift枚举关联值的内存</li><li>Swift超详细讲解指针</li><li>swift指针及内存管理内存绑定实例详解</li></ul>
                            </div>

                        </div>
                        <!--endmain-->
頁: [1]
查看完整版本: Swift 指针底层探索分析