Swift Academy · Aula

Grafos mistos de valores e referências

Estruturas que contêm classes: entenda a semântica oculta de referências e saiba como lidar com ela.

Grafos mistos de valores e referências é 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.

Boas-vindas

As estruturas podem conter classes como propriedades armazenadas. Nesse caso, a estrutura se comporta como um tipo de valor externamente, mas compartilha internamente a referência da classe — uma armadilha sutil.

Estrutura que Contém uma Classe

```swift class Storage { var data: [Int] = [] } struct Container { var storage = Storage() var label: String = "" } var a = Container() var b = a // copies label, but SHARES storage! a.storage.data.append(1) print(b.storage.data) // [1] — shared! ```

Somente as Propriedades de Valor São Copiadas

Quando uma estrutura é copiada: • As propriedades de tipos de valor (`label: String`) são totalmente copiadas • Nas propriedades de tipos de referência (`storage: Storage`), somente o ponteiro é copiado Isso é chamado de *cópia superficial*.

Criando uma Cópia Profunda

```swift struct Container { var storage: Storage func deepCopy() -> Container { let newStorage = Storage() newStorage.data = storage.data // copy values return Container(storage: newStorage, label: label) } } ```

COW ao Resgate

As próprias coleções do Swift evitam isso usando COW: ```swift struct SafeContainer { private(set) var storage = Storage() mutating func append(_ n: Int) { if !isKnownUniquelyReferenced(&storage) { storage = storage.copy() // copy before mutating } storage.data.append(n) } } ```

Classes que Contêm Estruturas

```swift class ViewModel { var point = CGPoint(x: 0, y: 0) // value type inside reference type } let vm1 = ViewModel() let vm2 = vm1 // same ViewModel! vm1.point.x = 5 print(vm2.point.x) // 5 — shared because ViewModel is a class ```

Identidade vs. Igualdade

```swift class Dog { var name: String = "" } let x = Dog() let y = x print(x === y) // true — same object print(x !== y) // false let z = Dog() print(x === z) // false — different objects ```

Estrutura Recursiva por Meio de uma Classe

As estruturas não podem referenciar a si mesmas, mas podem conter uma classe que referencia a estrutura: ```swift struct Tree { var value: Int var children: [Tree] // OK — Array uses class internally } ```

Detectando Compartilhamento Inesperado

Use `isKnownUniquelyReferenced` em tempo de execução para detectar compartilhamento: ```swift var s = Storage() var r: AnyObject = s print(isKnownUniquelyReferenced(&s)) // true var s2 = s print(isKnownUniquelyReferenced(&s)) // false — shared ```

Diretrizes de Design

Quando uma estrutura precisa conter estado mutável de um tipo de referência: 1. Implemente COW para restaurar a semântica de valor 2. Ou use uma classe imutável: `let` em vez de `var` para a propriedade da classe 3. Ou reformule o design — talvez a estrutura devesse ser uma classe Documente claramente quando o compartilhamento for intencional.

Verificação Rápida

Quando você copia uma estrutura que contém uma propriedade de classe, o que acontece com a classe?

Recapitulação

Principais conclusões: • A cópia de uma estrutura é superficial — as referências de classe são compartilhadas • `isKnownUniquelyReferenced` detecta compartilhamento em tempo de execução • Implemente COW para restaurar a verdadeira semântica de valor • `===` / `!==` testam a identidade de objetos em classes • Estruturas recursivas usam Array (com suporte interno de classe) como filhas A seguir: projetando APIs para a semântica de valor.

Perguntas Frequentes

A aula “Grafos mistos de valores e referências” é grátis?

Sim — o texto completo de “Grafos mistos de valores e referências” é 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 “Grafos mistos de valores e referências”?

Estruturas que contêm classes: entenda a semântica oculta de referências e saiba como lidar com ela. 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 “Grafos mistos de valores e referências”?

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

Pilha e heap: onde os valores vivem
Mutação, compartilhamento e aliasing inesperado
Grafos mistos de valores e referências
Design de APIs para semântica de valores

← Voltar para Swift Academy