énumérations et structures indirectes
Pour commencer, je tiens à dire que je suis conscient qu'il y a beaucoup articles et questions dans SO qui font référence au mot clé indirect dans Swift .
L'explication la plus courante pour l'utilisation de indirect est de permettre des énumérations récursives.
Plutôt que de simplement savoir ce que indirect nous permet de faire, je voudrais savoir comment cela nous permet d'utiliser des énumérations récursives.
Des questions:
Est-ce parce que les énumérations sont des types de valeur et que les types de valeur ne sont pas bien mis à l'échelle s'ils sont construits dans une structure récursive? Pourquoi?
indirect modifie-t-il le comportement du type de valeur pour se comporter davantage comme un type de référence?
Les deux exemples suivants se compilent très bien. Quelle est la différence?
indirect enum BinaryTree<T> {
case node(BinaryTree<T>, T, BinaryTree<T>)
case empty
}
enum BinaryTree<T> {
indirect case node(BinaryTree<T>, T, BinaryTree<T>)
case empty
}
Le mot clé indirect introduit une couche d'indirection en arrière-plan.
Vous indiquez qu'un cas d'énumération est récursif en écrivant indirect avant lui, qui indique au compilateur d'insérer la couche d'indirection nécessaire .
De ici
La partie importante des structures et des énumérations est qu'elles sont de taille constante. Autoriser directement des structures ou des énumérations récursives violerait cela, car il y aurait un nombre indéterminable de récursions, rendant ainsi la taille non constante et imprévisible. indirect utilise une référence de taille constante pour faire référence à une structure de taille constante.
Il y a une différence entre les deux extraits de code que vous montrez.
Le premier morceau de code fait
BinaryTree<T>stocké par une référence partout où il est utilisé.Le deuxième morceau de code fait
BinaryTree<T>stocké par référence uniquement dans le cas denode. C'est à dire.BinaryTree<T>a généralement sa valeur stockée directement, sauf dans ce cas expliciteindirectnode.