0Pricing
Swift Academy · Aula

Ponteiros de Buffer Inseguros

Processe memória contígua com eficiência.

Ponteiros de Buffer Inseguros é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O que é um ponteiro de buffer

Um ponteiro tipado individual endereça um elemento por vez. Um UnsafeBufferPointer<T> envolve um ponteiro inicial e uma contagem, oferecendo uma visão limitada de um bloco contíguo de memória que está em conformidade com Collection.

Isso significa que você pode iterar, acessar por subscrito, mapear e reduzir — todas as APIs conhecidas de coleções sobre memória bruta.

// A buffer pointer = base address + element count
// UnsafeBufferPointer<Int>(start: ptr, count: 5)

Buffers somente para leitura e mutáveis

Assim como os ponteiros individuais, os buffers vêm em duas formas: UnsafeBufferPointer<T> para iteração somente de leitura e UnsafeMutableBufferPointer<T> quando você também precisa atribuir valores aos elementos.

let p = UnsafeMutablePointer<Int>.allocate(capacity: 4)
p.initialize(repeating: 0, count: 4)
let buf = UnsafeMutableBufferPointer(start: p, count: 4)
buf[0] = 11
print(buf[0]) // 11

Iterando como uma coleção

Como um ponteiro de buffer é uma Collection, um laço for percorre todos os elementos em ordem. Não há cálculo manual de índices nem risco de erro de índice no próprio laço — embora os limites que você forneceu continuem sendo de sua responsabilidade.

let buf = UnsafeMutableBufferPointer<Int>.allocate(capacity: 3)
_ = buf.initialize(from: [10, 20, 30])
for value in buf { print(value) } // 10, 20, 30

Algoritmos de coleção sem custo adicional

map, filter, reduce, enumerated e indices funcionam em ponteiros de buffer. Isso permite processar memória bruta com código de alto nível, sem fazer alocações.

let buf = UnsafeMutableBufferPointer<Int>.allocate(capacity: 4)
_ = buf.initialize(from: [1, 2, 3, 4])
let total = buf.reduce(0, +)   // 10
let evens = buf.filter { $0 % 2 == 0 } // [2, 4]
print(total, evens)

Alocando um buffer mutável

UnsafeMutableBufferPointer<T>.allocate(capacity:) reserva o bloco e retorna um buffer em uma única etapa. Ainda é necessário executar initialize antes de ler e deallocate quando terminar.

let buf = UnsafeMutableBufferPointer<Int>.allocate(capacity: 5)
buf.initialize(repeating: 0)
defer {
    buf.deinitialize()
    buf.deallocate()
}

Os limites não são verificados na extremidade

Usar subscritos dentro de 0..<count é seguro. No entanto, o buffer não pode saber se a contagem que você forneceu está correta. Se você criar um buffer com uma contagem maior que a alocação real, as leituras ultrapassarão o fim e acessarão memória indefinida.

Sempre derive a contagem da mesma alocação que você criou.

let p = UnsafeMutablePointer<Int>.allocate(capacity: 3)
p.initialize(repeating: 0, count: 3)
// CORRECT: count matches capacity
let good = UnsafeBufferPointer(start: p, count: 3)
// WRONG: count: 10 would read past the block
print(good.count)

Buffers vazios

Um buffer com count: 0 é válido e pode ter um endereço base nil. Sempre verifique isEmpty ou confie no fato de que o laço simplesmente não será executado, em vez de forçar o desempacotamento de baseAddress.

let empty = UnsafeBufferPointer<Int>(start: nil, count: 0)
print(empty.isEmpty)       // true
print(empty.count)         // 0
for _ in empty { print("never runs") }

withUnsafeBufferPointer em Arrays

A maneira mais segura de obter um buffer é a partir de um Array existente, usando withUnsafeBufferPointer. O Swift garante que o armazenamento seja contíguo e válido durante a execução do bloco, evitando completamente a alocação manual.

let numbers = [4, 8, 15, 16, 23]
let maxValue = numbers.withUnsafeBufferPointer { buf -> Int in
    var m = buf[0]
    for v in buf where v > m { m = v }
    return m
}
print(maxValue) // 23

Modificando o armazenamento de um Array

withUnsafeMutableBufferPointer permite gravar diretamente no armazenamento de um array. Isso é usado ocasionalmente em transformações no próprio armazenamento que exigem alto desempenho, quando o ARC e as verificações de limites acrescentariam sobrecarga.

var data = [1, 2, 3, 4]
data.withUnsafeMutableBufferPointer { buf in
    for i in buf.indices { buf[i] *= 10 }
}
print(data) // [10, 20, 30, 40]

baseAddress para APIs de C

Ao chamar uma função de C que espera um ponteiro e um comprimento, passe buffer.baseAddress e buffer.count. O endereço base é nil somente para buffers vazios; portanto, trate esse caso.

let bytes: [UInt8] = [0xDE, 0xAD, 0xBE, 0xEF]
bytes.withUnsafeBufferPointer { buf in
    if let base = buf.baseAddress {
        // c_function(base, buf.count)
        print("start:", base, "len:", buf.count)
    }
}

Quando usar ponteiros de buffer

Use ponteiros de buffer quando precisar de acesso contíguo, seguro quanto ao tipo e no estilo de coleções a uma região de memória: fazendo a ponte com arrays de C, analisando formatos binários ou eliminando sobrecarga em laços críticos. Sempre que possível, prefira as formas de bloco with... à alocação manual.

// Counting set bits across a byte buffer
let data: [UInt8] = [0b1011, 0b0110, 0b1111]
let bits = data.withUnsafeBufferPointer { buf in
    buf.reduce(0) { $0 + $1.nonzeroBitCount }
}
print(bits) // 3 + 2 + 4 = 9

Verificação rápida

Lembre-se do que um ponteiro de buffer acrescenta em relação a um ponteiro individual.

Recapitulação

Os ponteiros de buffer envolvem uma região contígua como uma coleção limitada:

  • UnsafeBufferPointer / UnsafeMutableBufferPointer = endereço base + contagem.
  • Você obtém map, filter, reduce e iteração com for sobre memória bruta.
  • Prefira withUnsafeBufferPointer em arrays para que o Swift gerencie a validade e o lifetime.
  • A contagem fornecida é considerada correta — derive-a da alocação real.

Perguntas Frequentes

A aula “Ponteiros de Buffer Inseguros” é grátis?

Sim — o texto completo de “Ponteiros de Buffer Inseguros” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Ponteiros de Buffer Inseguros”?

Processe memória contígua com eficiência. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Ponteiros de Buffer Inseguros”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. MemoryLayout e Alinhamento
  2. UnsafePointer e UnsafeMutablePointer
  3. Ponteiros de Buffer Inseguros
  4. withUnsafeBytes e Interoperabilidade com C
← Voltar para Swift Academy