14.11.2024

Lição: 29: Operadores Avançados (Overflow, Bitwise)

Nesta aula, vamos explorar operadores avançados em Swift, focando especificamente nos operadores de overflow e nos operadores bitwise. Compreender esses operadores melhorará sua capacidade de manipular dados em um nível baixo e realizar cálculos eficientes.

Operadores de Overflow

Os operadores de overflow em Swift permitem que operações aritméticas excedam os limites de seus tipos de dados. Quando ocorre um overflow, o valor se "enrola" em vez de causar um erro em tempo de execução. Swift oferece três operadores de overflow: &+ para adição, &- para subtração e &* para multiplicação.

Exemplo: Adição com Overflow

import Foundation

let maxUInt8: UInt8 = 255
let valorComOverflow = maxUInt8 &+ 1

print("Máximo UInt8: \(maxUInt8)") // Saída: 255
print("Valor com Overflow: \(valorComOverflow)") // Saída: 0

Neste exemplo, adicionamos 1 a 255 (o valor máximo para UInt8). Em vez de causar um erro de overflow, o valor se "enrola" para 0.

Exemplo: Subtração com Overflow

let minUInt8: UInt8 = 0
let valorComUnderflow = minUInt8 &- 1

print("Mínimo UInt8: \(minUInt8)") // Saída: 0
print("Valor com Underflow: \(valorComUnderflow)") // Saída: 255

Aqui, subtrair 1 de 0 resulta em um underflow, fazendo o valor voltar para 255, que é o valor máximo para UInt8.

Exemplo: Multiplicação com Overflow

let valorGrande: UInt8 = 20
let valorMultiplicado = valorGrande &* 13

print("Valor Grande: \(valorGrande)") // Saída: 20
print("Valor Multiplicado: \(valorMultiplicado)") // Saída: 60

Neste caso de multiplicação, 20 * 13 cabe dentro dos limites de UInt8 (o valor máximo ainda é 255), e o resultado é computado normalmente.

Operadores Bitwise

Os operadores bitwise operam nas representações binárias de inteiros. Esses operadores permitem que você manipule bits específicos dentro de um tipo inteiro. Os operadores bitwise mais comuns são:

• E bitwise (&)
• OU bitwise (|)
• OU exclusivo bitwise (^)
• NÃO bitwise (~)
• Deslocamento à esquerda (<<)
• Deslocamento à direita (>>)

Exemplo: E Bitwise

let a: UInt8 = 0b10101010
let b: UInt8 = 0b11001100
let resultado = a & b // Resultado: 0b10001000

print("E Bitwise: \(String(resultado, radix: 2))") // Saída: 10001000

O operador E bitwise compara cada bit de a e b. Um 1 é retornado apenas se ambos os bits correspondentes forem 1.

Exemplo: OU Bitwise

let resultadoOu = a | b // Resultado: 0b11101110

print("OU Bitwise: \(String(resultadoOu, radix: 2))") // Saída: 11101110

O operador OU bitwise retorna 1 se pelo menos um dos bits correspondentes for 1.

Exemplo: OU Exclusivo Bitwise

let resultadoXor = a ^ b // Resultado: 0b01100110

print("OU Exclusivo Bitwise: \(String(resultadoXor, radix: 2))") // Saída: 1100110

O operador OU exclusivo bitwise retorna 1 se os bits correspondentes forem diferentes.

Exemplo: NÃO Bitwise

let resultadoNot = ~a // Resultado: 0b01010101

print("NÃO Bitwise: \(String(resultadoNot, radix: 2))") // Saída: 1010101

O operador NÃO bitwise inverte todos os bits.

Exemplo: Deslocamento à Esquerda

let valorDeslocadoEsquerda = a << 2 // Resultado: 0b101010000

print("Deslocado à Esquerda: \(String(valorDeslocadoEsquerda, radix: 2))") // Saída: 101010000

Um deslocamento à esquerda move todos os bits para a esquerda, preenchendo com zeros.

Exemplo: Deslocamento à Direita

let valorDeslocadoDireita = a >> 2 // Resultado: 0b00101010

print("Deslocado à Direita: \(String(valorDeslocadoDireita, radix: 2))") // Saída: 101010

Um deslocamento à direita move todos os bits para a direita.

Conclusão

Dominar os operadores de overflow e bitwise em Swift permite que você realize manipulações de dados em baixo nível de forma eficiente. Você achará esses operadores inestimáveis ao lidar com aplicações críticas em termos de desempenho ou ao desenvolver para sistemas com restrições rigorosas de memória. Lembre-se de usar esses operadores de maneira apropriada para aproveitar ao máximo seu potencial!

Video

Navigation