struct — o que é, conceitos-chave e sintaxe em Swift

O que é struct em Swift?

Struct (estrutura) é um tipo de dado composto em Swift que agrupa propriedades e métodos relacionados em uma única entidade. Ao contrário das classes, as estruturas são value types: ao serem passadas para uma função ou atribuídas a uma nova variável, uma cópia independente da estrutura é criada, não uma referência ao objeto original.

Swift usa estruturas para todos os tipos primitivos: Int, Double, String, Bool, Array, Dictionary e Set. Isso significa que até mesmo um Int básico se comporta como uma estrutura — uma cópia é criada na atribuição. O desenvolvedor pode definir sua própria estrutura com qualquer conjunto de propriedades e métodos.

De acordo com o Swift Evolution (SE-0143), a decisão de implementar tipos padrão como estruturas é motivada por desempenho e previsibilidade. Value types não criam ciclos de referência, não exigem contagem de referências ARC e garantem que modificar uma cópia não afetará o original — isso é criticamente importante para a imutabilidade de dados em cenários multithread.

Struct como value type

A semântica de value type é a diferença chave entre struct e class. Quando você atribui uma estrutura a uma nova variável ou a passa para uma função, Swift cria uma cópia independente de todos os dados. Quaisquer alterações na cópia não afetam o original, eliminando os efeitos colaterais típicos dos tipos de referência.

// Exemplo de semântica de value type
struct Point {
    var x: Double
    var y: Double
}

var p1 = Point(x: 10, y: 20)
var p2 = p1        // p2 é uma cópia independente de p1
p2.x = 99            // Apenas p2 muda
print(p1.x)         // 10 — p1 inalterado
print(p2.x)         // 99

Otimização Copy-on-Write

Swift usa Copy-on-Write (COW) para otimizar a cópia. Se múltiplas variáveis referenciam a mesma estrutura mas nenhuma delas modifica os dados, nenhuma cópia real ocorre. Swift compartilha memória entre as variáveis até a primeira mutação — então uma cópia real é criada. Isso previne operações de alocação excessivas e acelera o trabalho com coleções.

Mutabilidade e métodos mutating

Por padrão, os métodos de uma estrutura não podem modificar suas propriedades — Swift exige a palavra-chave mutating explícita para métodos que fazem alterações. Essa restrição protege contra mutação acidental e torna o código previsível: se um método não está marcado como mutating, você tem a garantia de não alterar a estrutura.

Mutating em ação

Quando você adiciona a palavra-chave mutating antes de um método, Swift ganha a capacidade de escrever novos valores nas propriedades da estrutura. Na verdade, o método pode até substituir completamente a instância da estrutura por uma nova via self =. Este mecanismo é usado, por exemplo, nos tipos Option e Result.

// Struct com método mutating
struct Counter {
    private var value: Int = 0

    // Método mutating — pode modificar propriedades
    mutating func increment() {
        value += 1
    }

    // Método mutating pode substituir self completamente
    mutating func reset() {
        self = Counter()
    }

    // Método não mutating — somente leitura
    func currentValue() -> Int {
        return value
    }
}

var counter = Counter()
counter.increment()
print(counter.currentValue())  // 1
counter.reset()
print(counter.currentValue())  // 0

Regras para mutating: a estrutura deve ser declarada com var, não com let — uma estrutura constante não pode chamar um método mutating. O compilador verifica isso em tempo de compilação: tentar chamar um método mutating em uma constante let resultará em um erro de compilação.

Struct vs Class: comparação

A escolha entre struct e class é uma das decisões fundamentais em Swift. Ambos os tipos podem conter propriedades, métodos, inicializadores e implementar protocolos, mas têm diferenças fundamentais na semântica de memória, herança e gerenciamento de ciclo de vida.

Estruturas são preferíveis quando os dados não requerem herança, não devem ter identidade compartilhada (por exemplo, coordenadas, tamanhos, configuração) e são passados entre módulos. Classes são escolhidas para componentes de UI (UIView, UIViewController), singletons e objetos com identidade compartilhada.

Quando escolher struct

A Apple recomenda usar struct como tipo padrão para modelagem de dados em Swift. Estruturas são adequadas para a maioria dos cenários devido à semântica de cópia previsível e à ausência de sobrecarga de contagem de referências. Vamos ver os casos típicos onde struct é a escolha ideal.

Modelos de dados sem herança

Se uma entidade contém dados sem necessidade de herança (Product, User, Order, Point), use struct. O compilador gera automaticamente um memberwise initializer — você não precisa escrever init manualmente. Equatable e Hashable também são implementados automaticamente para estruturas cujas propriedades estão em conformidade com esses protocolos.

Dados imutáveis

Para configurações, ajustes e flags que não mudam após a criação, struct é preferível a class. Uma estrutura constante (let) garante a imutabilidade de todos os campos aninhados — em uma class isso se aplica apenas à referência, não ao conteúdo do objeto.

Código multithread

Estruturas são seguras em ambientes multithread devido à semântica de valor. Cada thread obtém uma cópia independente dos dados e não afeta outras threads. Condições de corrida entre threads são impossíveis para value types, tornando struct a escolha preferida para modelos em SwiftUI (ObservableObject requer class, mas @State usa struct).

// Exemplo de uso de struct para modelo de dados
struct User: Codable, Identifiable {
    let id: UUID
    var name: String
    var email: String
    var isPremium: Bool

    // Propriedade computada — não mutating
    var displayName: String {
        isPremium ? "\(name) ⭐️" : name
    }
}

// Inicializador memberwise automático
let user = User(
    id: UUID(),
    name: "Alice",
    email: "alice@example.com",
    isPremium: true
)

// Cópia é segura para multithreading
var userCopy = user
userCopy.isPremium = false
// user.isPremium permanece true

Use class quando precisar de herança (componentes UIKit/AppKit), identidade compartilhada (delegate, observer) ou ciclo de vida controlado do objeto (deinit). Para todo o resto — use struct.