Указатели в Swift: Небезопасные, буферные, необработанные и управляемые указатели

let obj = MyClass()
let unmanaged = Unmanaged.passRetained(obj) // увеличивает счетчик ссылок
let ptr = unmanaged.toOpaque() // получаем указатель
 
// Работаем с указателем...
 
// Когда работа завершена, уменьшаем счетчик ссылок
unmanaged.release()

func sumArrayFast(_ array: [Int]) -> Int {
    var result = 0
    array.withUnsafeBufferPointer { buffer in
        for i in 0..<buffer.count {
            result += buffer[i]
        }
    }
    return result
}

func processData(_ data: UnsafePointer<Float>) {
    // Можно только читать значения
    let value = data.pointee
    print("Текущее значение: \(value)")
}

func modifyData(_ data: UnsafeMutablePointer<Float>) {
    // Можно читать и изменять
    data.pointee *= 2.0
}

let numbers = [1, 2, 3, 4, 5]
var sum = 0
 
numbers.withUnsafeBufferPointer { buffer in
    // Работаем с buffer как с коллекцией
    for element in buffer {
        sum += element
    }
    
    // Также доступен индексный доступ
    let firstElement = buffer[0]
    let lastElement = buffer[buffer.count - 1]
}

var array = [10, 20, 30]
array.withUnsafeMutableBufferPointer { buffer in
    for i in 0..<buffer.count {
        buffer[i] *= 2
    }
}
// array теперь [20, 40, 60]

let rawData = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 8)
// Привязка к типу Int
let intPtr = rawData.bindMemory(to: Int.self, capacity: 2)
intPtr[0] = 42
intPtr[1] = 314
 
// Переинтерпретация как массив байтов
let bytesPtr = UnsafeRawBufferPointer(start: rawData, count: 16)
for byte in bytesPtr {
    print(byte, terminator: " ")
}

class MyBufferStorage<T>: ManagedBuffer<Int, T> {
  static func create(capacity: Int) -> MyBufferStorage<T> {
    let buffer = self.create(minimumCapacity: capacity) { buffer in
      return capacity // Инициализируем заголовок количеством элементов
    }
    return unsafeDowncast(buffer, to: MyBufferStorage<T>.self)
  }
}

let obj = MyClass()
let unmanaged = Unmanaged.passRetained(obj)
let opaquePtr = unmanaged.toOpaque()
 
// Обратное преобразование
let recoveredUnmanaged = Unmanaged<MyClass>.fromOpaque(opaquePtr)
let recoveredObj = recoveredUnmanaged.takeRetainedValue()

// 1. Выделение памяти
let pointer = UnsafeMutablePointer<Int>.allocate(capacity: 1)
 
// 2. Инициализация памяти значением
pointer.initialize(to: 42)
 
// 3. Использование указателя
let value = pointer.pointee
print(value) // 42
pointer.pointee = 100
 
// 4. Деинициализация - освобождает ресурсы, связанные с объектом
pointer.deinitialize(count: 1)
 
// 5. Освобождение памяти
pointer.deallocate()

var value = 42
withUnsafeMutablePointer(to: &value) { pointer in
    pointer.pointee *= 2
}
// Память автоматически управляется после выхода из блока

// Выделение памяти с выравниванием 8 байт
let rawPtr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 8)

let rawPtr = UnsafeMutableRawPointer.allocate(
    byteCount: 100,
    alignment: MemoryLayout<Double>.alignment
)
let doublePtr = rawPtr.bindMemory(to: Double.self, capacity: 12)

let intAlignment = MemoryLayout<Int>.alignment
let doubleStride = MemoryLayout<Double>.stride

let address = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 8)
let addressValue = Int(bitPattern: address) // Получаем числовое значение адреса
 
// Проверка выравнивания адреса (кратность 8)
let isAligned = (addressValue & 0x7) == 0
 
// Округление адреса вниз до ближайшего выровненного значения
let alignedDown = UnsafeMutableRawPointer(bitPattern: addressValue & ~0x7)
 
// Округление адреса вверх до ближайшего выровненного значения
let alignedUp = UnsafeMutableRawPointer(bitPattern: (addressValue + 0x7) & ~0x7)

let intPointer = UnsafePointer<Int>(...)
let rawPointer = UnsafeRawPointer(intPointer)

let rawPointer = UnsafeRawPointer(...)
let intPointer = rawPointer.assumingMemoryBound(to: Int.self)

let nonmutable = UnsafePointer<Int>(...)
let raw = UnsafeRawPointer(nonmutable)
let mutable = UnsafeMutablePointer<Int>(mutating: nonmutable) // Это разрешено

var cgPoint = CGPoint(x: 10, y: 20)
let result = withUnsafePointer(to: &cgPoint) { ptr in
    CGPointFunction(ptr)
}

let swiftString = "Hello, C!"
swiftString.withCString { cString in
    // cString имеет тип UnsafePointer<Int8>
    printf("%s\n", cString)
}

let handle = dlopen(nil, RTLD_NOW)
if let symbol = dlsym(handle, "function_name") {
    let function = unsafeBitCast(symbol, to: (@convention(c) () -> Void).self)
    function()
}

func calculateSum(_ numbers: [Double]) -> Double {
    return numbers.withUnsafeBufferPointer { buffer -> Double in
        var sum = 0.0
        for i in 0..<buffer.count {
            sum += buffer[i]
        }
        return sum
    }
}

class DataProcessor {
    private let array: [Float]
    private var cachedPointer: UnsafeBufferPointer<Float>?
    
    init(array: [Float]) {
        self.array = array
        self.array.withUnsafeBufferPointer { ptr in
            self.cachedPointer = ptr
        }
    }
    
    func process() -> Float {
        guard let ptr = cachedPointer else { return 0 }
        // Быстрая обработка через указатель
    }
}

let image = UIImage(named: "sample")!
let cgImage = image.cgImage!
 
let width = cgImage.width
let height = cgImage.height
let bytesPerRow = width * 4
let bitmapInfo = CGImageAlphaInfo.premultipliedLast.rawValue
 
let context = CGContext(
    data: nil,
    width: width,
    height: height,
    bitsPerComponent: 8,
    bytesPerRow: bytesPerRow,
    space: CGColorSpaceCreateDeviceRGB(),
    bitmapInfo: bitmapInfo
)!
 
context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
 
if let pixelData = context.data {
    let buffer = pixelData.bindMemory(to: UInt8.self, capacity: width * height * 4)
    
    // Инвертирование цветов изображения
    for y in 0..<height {
        for x in 0..<width {
            let pixelIndex = (y * width + x) * 4
            buffer[pixelIndex] = 255 - buffer[pixelIndex]     // R
            buffer[pixelIndex + 1] = 255 - buffer[pixelIndex + 1] // G
            buffer[pixelIndex + 2] = 255 - buffer[pixelIndex + 2] // B
        }
    }
}

audioBuffer.withUnsafeMutableBufferPointer { buffer in
    for i in 0..<buffer.count {
        // Применение эффекта или фильтра к аудиоданным
        buffer[i] *= 0.8 // Простое уменьшение громкости
    }
}

var vertices = [Vector3D](repeating: .zero, count: 1000)
vertices.withUnsafeMutableBufferPointer { buffer in
    // Трансформация всех вершин
    for i in 0..<buffer.count {
        buffer[i] = transformMatrix.multiply(buffer[i])
    }
}

class ObjectPool<T> {
    private let pool: UnsafeMutableBufferPointer<T?>
    private let semaphore = DispatchSemaphore(value: 1)
    
    init(capacity: Int, factory: () -> T) {
        pool = UnsafeMutableBufferPointer.allocate(capacity: capacity)
        for i in 0..<capacity {
            pool[i] = factory()
        }
    }
    
    func obtain() -> T? {
        semaphore.wait()
        defer { semaphore.signal() }
        
        for i in 0..<pool.count {
            if let obj = pool[i] {
                pool[i] = nil
                return obj
            }
        }
        return nil
    }
    
    func recycle(_ object: T) {
        semaphore.wait()
        defer { semaphore.signal() }
        
        for i in 0..<pool.count {
            if pool[i] == nil {
                pool[i] = object
                return
            }
        }
    }
    
    deinit {
        for i in 0..<pool.count {
            pool[i] = nil
        }
        pool.deallocate()
    }
}

// Типичная проблема: использование указателя после освобождения
let pointer = UnsafeMutablePointer<Int>.allocate(capacity: 1)
pointer.initialize(to: 42)
pointer.deallocate()
print(pointer.pointee) // Обращение к освобождённой памяти

func debugAllocate<T>(capacity: Int, file: String = #file, line: Int = #line) -> UnsafeMutablePointer<T> {
    print("Аллокация \(T.self) в \(file):\(line)")
    return UnsafeMutablePointer<T>.allocate(capacity: capacity)
}

let sharedBuffer = UnsafeMutablePointer<Int>.allocate(capacity: 100)
sharedBuffer.initialize(repeating: 0, count: 100)
 
// Опасный код: параллельный доступ без синхронизации
DispatchQueue.concurrentPerform(iterations: 1000) { i in
    let index = i % 100
    sharedBuffer[index] += 1 // Возможно повреждение данных
}

class ThreadConfinedBuffer {
    private let buffer: UnsafeMutableBufferPointer<Int>
    private let queue = DispatchQueue(label: "buffer.queue")
    
    init(size: Int) {
        buffer = UnsafeMutableBufferPointer.allocate(capacity: size)
        buffer.initialize(repeating: 0)
    }
    
    func modify(_ block: @escaping (UnsafeMutableBufferPointer<Int>) -> Void) {
        queue.async {
            block(self.buffer)
        }
    }
    
    deinit {
        buffer.deallocate()
    }
}

import Darwin
 
let counter = UnsafeMutablePointer<Int32>.allocate(capacity: 1)
counter.initialize(to: 0)
 
DispatchQueue.concurrentPerform(iterations: 1000) { _ in
    OSAtomicIncrement32(counter)
}
 
print("Итоговое значение: \(counter.pointee)")
counter.deallocate()

let lock = NSLock()
let sharedPointer = UnsafeMutablePointer<Int>.allocate(capacity: 1)
sharedPointer.initialize(to: 0)
 
DispatchQueue.concurrentPerform(iterations: 100) { _ in
    lock.lock()
    defer { lock.unlock() }
    sharedPointer.pointee += 1
}
 
print("Результат: \(sharedPointer.pointee)")
sharedPointer.deallocate()

class PoolAllocator {
    private let chunkSize: Int
    private let alignment: Int
    private var currentChunk: UnsafeMutableRawPointer?
    private var offset: Int = 0
    private var chunks: [UnsafeMutableRawPointer] = []
    
    init(chunkSize: Int, alignment: Int = MemoryLayout<Int>.alignment) {
        self.chunkSize = chunkSize
        self.alignment = alignment
        allocateNewChunk()
    }
    
    private func allocateNewChunk() {
        currentChunk = UnsafeMutableRawPointer.allocate(
            byteCount: chunkSize,
            alignment: alignment
        )
        chunks.append(currentChunk!)
        offset = 0
    }
    
    func allocate<T>(type: T.Type) -> UnsafeMutablePointer<T> {
        let size = MemoryLayout<T>.size
        let align = MemoryLayout<T>.alignment
        
        // Выравнивание адреса
        let alignedOffset = (offset + align - 1) & ~(align - 1)
        
        // Проверка наличия свободного места
        if alignedOffset + size > chunkSize {
            allocateNewChunk()
            return allocate(type: type)
        }
        
        // Выделение памяти из текущего чанка
        let pointer = currentChunk!.advanced(by: alignedOffset)
            .bindMemory(to: type, capacity: 1)
        offset = alignedOffset + size
        
        return pointer
    }
    
    func reset() {
        offset = 0
    }
    
    deinit {
        for chunk in chunks {
            chunk.deallocate()
        }
    }
}

let allocator = PoolAllocator(chunkSize: 4096)
 
// Создание множества объектов
for _ in 0..<1000 {
    let ptr = allocator.allocate(type: MyStruct.self)
    ptr.initialize(to: MyStruct())
    
    // Использование объекта...
    
    // Не нужно вызывать deallocate() для каждого указателя!
}
 
// Освобождение всей памяти сразу
allocator.reset()

// Создание буфера вершин
let vertexCount = 1000
let vertexSize = MemoryLayout<Vertex>.stride
let vertexBuffer = device.makeBuffer(length: vertexCount * vertexSize, options: .storageModeShared)!
 
// Заполнение буфера данными
if let vertexPtr = vertexBuffer.contents().bindMemory(to: Vertex.self, capacity: vertexCount) {
    for i in 0..<vertexCount {
        vertexPtr[i] = generateVertex(i)
    }
}

func updateBufferContent(buffer: MTLBuffer, frame: Int) {
    let dataPtr = buffer.contents().bindMemory(to: Float.self, capacity: buffer.length / MemoryLayout<Float>.stride)
    
    // Обновление данных для текущего кадра
    for i in 0..<dataPtr.count {
        dataPtr[i] = calculateData(i, frame: frame)
    }
}

let region = MTLRegionMake2D(0, 0, texture.width, texture.height)
let bytesPerRow = texture.width * 4
            
texture.replace(region: region, 
                mipmapLevel: 0, 
                withBytes: pixelData.baseAddress!, 
                bytesPerRow: bytesPerRow)

let pointer = UnsafeMutablePointer<Int>.allocate(capacity: 1)
pointer.initialize(to: 42)
pointer.deallocate()
let value = pointer.pointee // Критическая ошибка: обращение к освобождённой памяти

let pointer = UnsafeMutablePointer<Int>.allocate(capacity: 1)
pointer.deallocate()
pointer.deallocate() // Двойное освобождение приводит к непредсказуемому поведению

let pointer = UnsafeMutablePointer<Int>.allocate(capacity: 3)
pointer.initialize(repeating: 0, count: 3)
let value = pointer[5] // Доступ за пределами выделенной памяти

let pointer = UnsafeMutablePointer<Int>.allocate(capacity: 1)
// Отсутствует вызов initialize
let value = pointer.pointee // Чтение неинициализированных данных

func leakyFunction() {
  let pointer = UnsafeMutablePointer<Int>.allocate(capacity: 1000)
  pointer.initialize(to: 0) 
  // Отсутствует deallocate — утечка памяти
}

array.withUnsafeBufferPointer { buffer in
    // Безопасное использование buffer внутри замыкания
    // При выходе из блока указатель автоматически становится недействительным
}

func processData(_ data: [Int]) -> [Int] {
    // Внутри используем указатели
    var result = [Int](repeating: 0, count: data.count)
    data.withUnsafeBufferPointer { source in
        result.withUnsafeMutableBufferPointer { destination in
            // Работа с указателями
            for i in 0..<source.count {
                destination[i] = source[i] * 2
            }
        }
    }
    return result // Возвращаем безопасный тип
}

let pointer = UnsafeMutablePointer<Int>.allocate(capacity: 10)
defer { pointer.deallocate() }
 
pointer.initialize(repeating: 0, count: 10)
defer { pointer.deinitialize(count: 10) }
 
// Безопасное использование pointer...

// Безопасная реализация
func safeSum(_ array: [Int]) -> Int {
    var sum = 0
    for element in array {
        sum += element
    }
    return sum
}
 
// Небезопасная реализация с указателями
func unsafeSum(_ array: [Int]) -> Int {
    var sum = 0
    array.withUnsafeBufferPointer { buffer in
        for i in 0..<buffer.count {
            sum += buffer[i]
        }
    }
    return sum
}

// Безопасное копирование
func safeCopy(from source: [Int], to destination: inout [Int]) {
    guard destination.count >= source.count else { return }
    for i in 0..<source.count {
        destination[i] = source[i]
    }
}
 
// Небезопасное копирование
func unsafeCopy(from source: [Int], to destination: inout [Int]) {
    guard destination.count >= source.count else { return }
    source.withUnsafeBufferPointer { srcBuffer in
        destination.withUnsafeMutableBufferPointer { dstBuffer in
            for i in 0..<srcBuffer.count {
                dstBuffer[i] = srcBuffer[i]
            }
        }
    }
}

var array1 = [1, 2, 3, 4, 5]
var array2 = array1 // На этом этапе реального копирования не происходит
 
// Копирование выполняется только при модификации одной из копий
array2.append(6) // Теперь array2 получает собственную копию данных

let contiguousArray = ContiguousArray(repeating: 0, count: 10000)
// Элементы расположены в памяти последовательно, что улучшает локальность кэша

func processInPlace(values: inout [Int]) {
    for i in 0..<values.count {
        values[i] *= 2
    }
}
 
var numbers = [1, 2, 3]
processInPlace(values: &numbers) // Передача по ссылке без копирования

var data = Data(capacity: 1024 * 1024) // Предварительное выделение 1MB
data.append(contentsOf: [0, 1, 2, 3])

if let inputStream = InputStream(fileAtPath: filePath) {
    inputStream.open()
    
    let bufferSize = 1024
    var buffer = [UInt8](repeating: 0, count: bufferSize)
    
    while inputStream.hasBytesAvailable {
        let read = inputStream.read(&buffer, maxLength: bufferSize)
        if read < 0 {
            // Ошибка чтения
            break
        }
        // Обработка прочитанных данных...
    }
    
    inputStream.close()
}

import simd
 
let vector1 = SIMD4<Float>(1, 2, 3, 4)
let vector2 = SIMD4<Float>(5, 6, 7, 8)
let result = vector1 + vector2 // Векторное сложение [6, 8, 10, 12]

// В общем коде (Kotlin)
expect class NativePointer
 
// В iOS-коде (Kotlin)
actual typealias NativePointer = COpaquePointer
 
// Использование в Swift
func processNativePointer(_ pointer: UnsafeRawPointer) {
    // Преобразование Swift указателя для использования в общем коде
    val kotlinPointer = createKotlinPointer(pointer)
}

struct SafeBuffer<Element> {
    private var buffer: UnsafeMutableBufferPointer<Element>
    
    init(count: Int) {
        buffer = UnsafeMutableBufferPointer.allocate(capacity: count)
        buffer.initialize(repeating: Element())
    }
    
    subscript(index: Int) -> Element {
        get {
            precondition(index >= 0 && index < buffer.count, "Индекс вне допустимого диапазона")
            return buffer[index]
        }
        set {
            precondition(index >= 0 && index < buffer.count, "Индекс вне допустимого диапазона")
            buffer[index] = newValue
        }
    }
    
    deinit {
        buffer.deallocate()
    }
}

func withUnsafeResource<T, Result>(_ resource: T, perform: (T) -> Result) -> Result {
    // Подготовка ресурса
    let result = perform(resource)
    // Очистка ресурса
    return result
}

class OwnedResource<T> {
    private let resource: T
    private let cleanup: (T) -> Void
    
    init(resource: T, cleanup: @escaping (T) -> Void) {
        self.resource = resource
        self.cleanup = cleanup
    }
    
    func access<Result>(_ block: (T) -> Result) -> Result {
        return block(resource)
    }
    
    deinit {
        cleanup(resource)
    }
}