Swift高性能数组内存复制：从指定范围复制到目标数组偏移位置

嘿，作为Swift新手碰到内存访问的坑太正常了！我完全懂你想绕开那些繁琐又不确定性能的API，直接搞底层内存操作的心情😉

答案是完全可以！Swift提供了安全的底层内存访问接口，让你能直接调用C标准库的memcpy或memmove来实现高性能的数组元素拷贝，避免replaceSubrange可能带来的额外开销或不确定的内存操作次数。

核心思路 #

Swift的Array默认是连续内存存储的，我们可以通过withUnsafeBufferPointer和withUnsafeMutableBufferPointer安全地获取数组的内存指针，然后直接调用底层内存拷贝函数。这里需要注意两个关键点：

• 必须做严格的边界检查，避免越界访问导致崩溃或内存损坏
• 根据源和目标内存是否重叠，选择memcpy（无重叠，速度更快）或memmove（有重叠，安全可靠）

完整实现代码 #

下面是一个泛型函数，支持任意可存储的Swift类型（值类型、结构体甚至类都可以）：

func copyMemory<T>(from source: [T], sourceRange: Range<Int>, to target: inout [T], targetOffset: Int) {
    let sourceElementCount = sourceRange.count
    
    // 第一步：严格的边界检查，防止越界
    precondition(sourceRange.lowerBound >= 0 && sourceRange.upperBound <= source.count, 
                 "源数组范围超出有效边界")
    precondition(targetOffset >= 0 && targetOffset + sourceElementCount <= target.count, 
                 "目标位置+拷贝元素数量超出目标数组边界")
    
    // 第二步：安全获取内存指针并执行拷贝
    source.withUnsafeBufferPointer { sourceBuffer in
        target.withUnsafeMutableBufferPointer { targetBuffer in
            guard let sourceBasePtr = sourceBuffer.baseAddress, 
                  let targetBasePtr = targetBuffer.baseAddress else {
                return // 空数组无需拷贝
            }
            
            let sourceStartPtr = sourceBasePtr.advanced(by: sourceRange.lowerBound)
            let targetStartPtr = targetBasePtr.advanced(by: targetOffset)
            
            // 提前判断内存是否重叠，选择合适的拷贝函数
            let sourceEndPtr = sourceStartPtr.advanced(by: sourceElementCount)
            let isMemoryOverlapping = (targetStartPtr >= sourceStartPtr && targetStartPtr < sourceEndPtr) ||
                                      (sourceStartPtr >= targetStartPtr && sourceStartPtr < targetStartPtr.advanced(by: sourceElementCount))
            
            if isMemoryOverlapping {
                // 内存重叠时用memmove，避免数据覆盖
                memmove(targetStartPtr, sourceStartPtr, sourceElementCount * MemoryLayout<T>.stride)
            } else {
                // 内存无重叠时用memcpy，性能更优
                memcpy(targetStartPtr, sourceStartPtr, sourceElementCount * MemoryLayout<T>.stride)
            }
        }
    }
}

代码说明 #

• 泛型支持：<T>让函数能处理任意类型的数组，只要该类型的内存布局是确定的（Swift绝大多数类型都满足）
• 边界检查：用precondition做断言，调试阶段会直接崩溃并给出明确错误信息，线上环境可以根据需求替换为更温和的错误处理
• 内存指针操作：advanced(by:)用来移动指针到指定位置，MemoryLayout<T>.stride获取每个元素占用的内存字节数，计算总拷贝字节数
• 重叠判断：如果是同一个数组内的元素移动（比如把数组前3个元素移到索引2的位置），内存会重叠，这时候必须用memmove，否则memcpy会导致数据被覆盖而错误

使用示例 #

// 测试用例：源数组和目标数组是不同数组
var sourceArray = [10, 20, 30, 40, 50]
var targetArray = [0, 0, 0, 0, 0, 0, 0]

// 复制sourceArray中索引1到4的元素（20,30,40）到targetArray的索引2位置
copyMemory(from: sourceArray, sourceRange: 1..<4, to: &targetArray, targetOffset: 2)
print(targetArray) // 输出：[0, 0, 20, 30, 40, 0, 0]

// 测试用例：同一个数组内移动元素
var sameArray = [1,2,3,4,5,6]
// 把索引0到3的元素（1,2,3,4）移到索引2的位置
copyMemory(from: sameArray, sourceRange: 0..<4, to: &sameArray, targetOffset: 2)
print(sameArray) // 输出：[1,2,1,2,3,4]

和replaceSubrange的对比 #

replaceSubrange确实会生成较多的底层代码，并且会处理数组扩容、元素的构造/析构（如果是类类型）等额外逻辑。对于性能敏感的场景，直接内存拷贝能避免这些额外开销，尤其是当你已经确认数组边界安全、元素是值类型（无需析构）的时候，性能提升会更明显。

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