Swift中如何将多个UnsafeMutablePointer合并为一个？

在Swift中，合并数组是很直观的操作，但UnsafeMutablePointer本质只是一块原始内存的地址，它本身不携带长度信息，所以要实现“追加”或“合并”，核心是手动管理内存分配、拷贝和释放——毕竟系统不知道你的指针指向了多少元素，得靠你自己跟踪这些信息。

核心前提：必须知道每个指针的元素数量 #

不管你要合并几个指针，都得明确每个指针指向的元素个数，否则根本没办法安全地拷贝内存（会直接导致越界访问崩溃）。

实现方案1：泛型追加函数（针对UnsafeMutablePointer） #

下面是一个通用的函数，能把一个指针的内容追加到另一个指针末尾。注意这里我们需要同时跟踪目标指针的当前元素数量，并且要确保目标指针的内存是你手动分配的（这样才能安全释放旧内存）：

func appendPointer<T>(_ source: UnsafeMutablePointer<T>, sourceCount: Int, to destination: inout UnsafeMutablePointer<T>, destinationCount: inout Int) {
    // 计算合并后的总元素数
    let totalCount = destinationCount + sourceCount
    
    // 分配足够容纳所有元素的新内存
    let newPointer = UnsafeMutablePointer<T>.allocate(capacity: totalCount)
    
    // 拷贝原目标指针的内容到新内存的前半段
    newPointer.initialize(from: destination, count: destinationCount)
    // 拷贝源指针的内容到新内存的后半段
    newPointer.advanced(by: destinationCount).initialize(from: source, count: sourceCount)
    
    // 释放旧的目标内存（仅当旧内存是你手动allocate的才可以这么做！）
    destination.deallocate()
    
    // 更新目标指针和计数
    destination = newPointer
    destinationCount = totalCount
}

用法示例

假设我们要合并两个Int类型的指针：

// 创建第一个指针，包含3个元素
var destCount = 3
var destPointer = UnsafeMutablePointer<Int>.allocate(capacity: destCount)
destPointer.initialize(from: [1, 2, 3], count: destCount)

// 创建第二个指针，包含2个元素
let sourceCount = 2
let sourcePointer = UnsafeMutablePointer<Int>.allocate(capacity: sourceCount)
sourcePointer.initialize(from: [4, 5], count: sourceCount)

// 执行追加操作
appendPointer(sourcePointer, sourceCount: sourceCount, to: &destPointer, destinationCount: &destCount)

// 验证结果
for i in 0..<destCount {
    print(destPointer[i]) // 输出：1, 2, 3, 4, 5
}

// 最后一定要释放内存！
destPointer.deallocate()
sourcePointer.deallocate()

更安全的方案：用UnsafeMutableBufferPointer #

UnsafeMutableBufferPointer比裸指针更安全，因为它自带了指针和长度信息，不容易出错。下面是基于它的合并函数：

func appendBuffer<T>(_ source: UnsafeMutableBufferPointer<T>, to destination: inout UnsafeMutableBufferPointer<T>) {
    let totalCount = destination.count + source.count
    // 分配新的buffer
    let newBuffer = UnsafeMutableBufferPointer<T>.allocate(capacity: totalCount)
    
    // 拷贝两段内容到新buffer
    newBuffer[0..<destination.count].copyBytes(from: destination)
    newBuffer[destination.count..<totalCount].copyBytes(from: source)
    
    // 释放旧buffer内存
    destination.deallocate()
    
    // 更新目标buffer
    destination = newBuffer
}

关键注意事项 #

• 内存所有权：只有当你确定指针的内存是通过allocate(capacity:)手动分配的，才能调用deallocate()。如果指针来自其他API（比如C函数返回的指针），绝对不能随意释放，否则会导致内存崩溃。
• 类型安全性：确保所有指针的类型一致，否则拷贝会导致内存错乱。如果你的自定义结构体是值类型，直接用上面的泛型函数即可；如果是引用类型，要额外注意引用计数的管理。
• 初始化与销毁：如果你的类型有自定义的初始化/析构逻辑（比如包含deinit的结构体），要记得在分配内存后调用initialize(from:count:)初始化，在释放前调用deinitialize(count:)销毁对象。

内容的提问来源于stack exchange，提问作者AlexBerd