Iterator pattern: differenze tra le versioni

Versione delle 14:49, 18 dic 2005

Versione attuale delle 18:07, 1 feb 2024

(76 versioni intermedie di 40 utenti non mostrate)

Riga 1:

{{U|Iteratore|Informatica|Febbraio 2020}}

{{da cancellare}}

Nel contesto della [[programmazione orientata agli oggetti]], il termine '''''Iterator''''' (reso in italiano con "'''iteratore'''") denota uno dei più comuni e conosciuti ''[[design pattern]]''.

{{da aiutare mese|motivo=scarsamente contestualizzato, manca un incipit|ottobre 2005}}

L'''Iterator'' risolve diversi problemi connessi all'accesso e alla navigazione attraverso gli elementi, in particolare, di una [[struttura dati]] contenitrice, senza esporre i dettagli dell'[[implementare|implementazione]] e della struttura interna del contenitore.

Nella [[Programmazione_orientata_agli_oggetti|programmazione ad oggetti]], l''''Iterator''' è uno dei [[design pattern|pattern]] fondamentali.

L'[[oggetto (informatica)|oggetto]] principale su cui si basa questo ''design pattern'' è l'[[iteratore]].

== Motivazioni ==

In pratica è una modalità di scrittura di codice che si basa su dettami definiti originariamente dalla [[gang of four]], cioè dai quattro autori di un testo che è alla base della definizione di regole stilistiche per la scrittura di codice ad oggetti.

Una [[Classe (informatica)|classe]] contenitrice dovrebbe consentire l'accesso e la navigazione attraverso l'insieme degli elementi che contiene.

==Struttura==

Il design ''pattern Iterator'' fornisce un punto di accesso sequenziale agli elementi di un oggetto aggregato (ad esempio una ''Collection'' come potrebbe essere un [[array associativo]]) senza mostrare i dettagli interni di implementazione della [[struttura di dati]].

Nella programmazione a oggetti, un'alternativa semplice e preferibile all'uso di indici (come accade ad esempio per gli [[array]]) consiste nell'aggiungere [[Metodo (programmazione)|operazioni]] all'[[interfaccia (informatica)|interfaccia]] del contenitore. Questa soluzione ha il notevole vantaggio che, se l'interfaccia è ben definita, consente di annullare la dipendenza da dettagli interni del contenitore, ma ciò presenta alcuni inconvenienti:

Supporta [[Polimorfismo|iterazioni polimorfiche]] fornendo un'[[interfaccia]] uniforme per le diverse struttura di dati.

;Sovraccarico dell'interfaccia del contenitore: Le operazioni aggiunte sovraccaricano l'interfaccia preesistente della classe contenitore.

;Mancanza di punti di accesso multipli: Le operazioni sono centralizzate nella classe contenitore. Questo non consente di effettuare contemporaneamente più visite indipendenti agli elementi dello stesso contenitore.

;Supporto carente per metodi di navigazione specializzati: Quando i contenitori possiedono una struttura complessa, non di rado vi sono diversi e ugualmente utili modi di attraversarne l'insieme degli elementi contenuti. Un'interfaccia centralizzata si adatta male a questa situazione, perché richiede l'aggiunta di più operazioni specializzate, esacerbando il problema del sovraccarico.

Il ''design pattern'' ''Iterator'', quindi, supera le soluzioni che si possono ottenere con la pura programmazione ad oggetti mediante codice più complesso.

In pratica l'''Iterator'' è un blocco di codice che accede a strutture dati, a volte anche complesse, senza dover utilizzare elementi legati alla particolare struttura, ma, astraendo da quest'ultima, consente l'accesso in maniera uniforme e "decontestualizzata". Ciò permette di riutilizzare lo stesso codice per accedere ai dati, ma di modificare la struttura degli stessi secondo le esigenze.

== Concetti fondamentali ==

==Struttura di un Iterator==

L'idea chiave del ''pattern'' ''Iterator'' consiste nel trasferire la responsabilità dell'accesso e della navigazione attraverso gli elementi a una classe separata dal contenitore: l'iteratore.

* '''Iterator''': definisce un'interfaccia per accedere e attraversare un elemento.

* '''ConcreteIterator''': implementa l'interfaccia Iterator tenendo traccia della posizione corrente nella struttura.

* '''Aggregator''': definisce un'interfaccia per creare un oggetto Iterator.

* '''ConcreteAggregator''': implementa l'interfaccia di crazione dell'Iterator e ritorna un'istanza appropriata do ConcreteIterator.

La classe iteratore consente di visitare ad uno ad uno l'insieme degli elementi di un contenitore come se fossero ordinati in una sequenza finita. A questo scopo, un oggetto iteratore deve tenere traccia dell'ultimo elemento visitato e deve essere in grado di calcolare qual è l'elemento successivo nella sequenza di attraversamento.

==Collegamenti esterni==

* [http://web.cs.wpi.edu/~gpollice/cs509-s04/Patterns/IteratorPattern.html Pattern iterator]

Per permettere di visitare qualunque aggregato di elementi di un tipo concreto, indipendentemente dall'iteratore specifico e dal contenitore ad esso associato, il ''pattern'' ''Iterator'' richiede la definizione di due interfacce:

[[Categoria:Pattern]]

* contenitore (Aggregate),

* iteratore (Iterator).

La prima interfaccia è condivisa da tutte le classi contenitore e definisce un'operazione per ottenere un nuovo iteratore della classe stessa; la seconda definisce l'insieme di operazioni comuni ad ogni tipo di iteratore.

== Struttura ==

[[File:IteratorPattern.png|thumb|upright=1.8|Struttura del pattern Iterator]]

Il ''pattern'' ''iterator'' definisce due gerarchie di classi: una per i contenitori e una per gli iteratori. Le classi contenitore possono essere specializzate per tipo di elemento contenuto o per tipo di struttura in cui gli elementi sono organizzati. Le classi di iteratori sono specializzati per tipo di contenitore (iteratore concreto) e per tipo di navigazione attraverso la sequenza di elementi (iteratori specializzati).

== Partecipanti ==

;Iterator: definisce un'interfaccia per attraversare l'insieme degli elementi di un contenitore e accedere ai singoli elementi.

* ''';ConcreteIterator''': implementa l'interfaccia Iterator tenendo traccia della posizione corrente nel contenitore e calcolando qual è l'elemento successivo nella strutturasequenza di attraversamento.

* '''Iterator''';Aggregate: definisce un'interfaccia per accederecreare eun attraversareoggetto un elementoIterator.

* '''ConcreteAggregator''';ConcreteAggregate: implementa l'interfaccia di crazionecreazione dell'Iterator e ritorna un'istanza appropriata dodi ConcreteIterator.

== Benefici e conseguenze ==

L'adozione del ''pattern'' ''Iterator'' consente di:

# Semplificare l'interfaccia del contenitore, rimuovendo la parte che permette di navigare attraverso gli elementi contenuti.

# Isolare i dettagli di implementazione e la struttura del contenitore, e nasconderli ai programmi che accedono ai dati, che utilizzano soltanto le interfacce del contenitore e dell'iteratore.

# Accedere agli elementi di un contenitore attraverso un'interfaccia uniforme e indipendente dal tipo di contenitore (iterazione polimorfica).

# Attraversare contemporaneamente lo stesso aggregato di elementi con più processi indipendenti. Ciascun processo utilizza un iteratore differente, che tiene traccia della propria posizione nella sequenza.

# Attraversare lo stesso aggregato di elementi con modalità diverse. Più iteratori specializzati, ciascuno eventualmente fornito di interfaccia specifica, possono calcolare in modo diverso l'elemento successivo, e quindi definiscono modi diversi di attraversare l'insieme degli elementi.

== Implementazione ==

Senza [[polimorfismo (informatica)|polimorfismo]], una classe iteratore è strettamente accoppiata al suo tipo di contenitore e di elementi. Per poter cambiare la classe contenitore senza dover cambiare il codice che ne usufruisce e che attraversa gli elementi contenuti, occorre generalizzare il concetto di iteratore e trasformarlo in un'interfaccia.

Sfruttando le capacità polimorfiche di alcuni linguaggi di programmazione è possibile definire un'unica interfaccia uniforme per tutti i tipi di oggetti iteratore. Questo permette di scrivere programmi in cui l'accesso ai dati contenuti da un aggregato è completamente indipendente dalla struttura dell'aggregato stesso, purché esista una concreta implementazione dell'oggetto iteratore per una data.

Per rendere il ''pattern'' ''Iterator'' completamente indipendente dall'implementazione concreta, è necessario virtualizzare il processo di creazione delle istanze di iteratori. Di solito si provvede a questa necessità definendo un'operazione dell'interfaccia contenitore per creare un nuovo iteratore ad ogni invocazione.

== Bibliografia ==

* E.Gamma, R.Helm, R.Johnson, J.Vlissides, ''Design Patterns, Elements of Reusable Object-Oriented Software'', Pearson Education, Milano 2002, ISBN 0-201-63361-2

== Voci correlate ==

* [[Design pattern]]

* [[Visitor]]

* [[Iteratore]]

* Quando la classe contenitore possiede [[struttura dati ricorsiva|struttura ricorsiva]], è possibile utilizzare il ''pattern [[Composite]]'' per definire una classe contenitore concreta.

* Il ''pattern'' ''[[Factory method]]'' è spesso applicato per virtualizzare la creazione di oggetti iteratore da parte delle classi contenitore.

== Altri progetti ==

{{interprogetto|commons=Category:Iterator pattern|preposizione=sull'}}

== Collegamenti esterni ==

* {{cita web | 1 = http://web.cs.wpi.edu/~gpollice/cs509-s04/Patterns/IteratorPattern.html | 2 = Pattern iterator | accesso = 18 dicembre 2005 | urlarchivio = https://web.archive.org/web/20060909134142/http://web.cs.wpi.edu/~gpollice/cs509-s04/Patterns/IteratorPattern.html | dataarchivio = 9 settembre 2006 | urlmorto = sì }}

{{Design pattern}}

[[Categoria:PatternDesign pattern]]