Իտերատոր (նախագծման ձևանմուշ)

Վիքիպեդիայից՝ ազատ հանրագիտարանից
Jump to navigation Jump to search
Իտերատոր
Անգլերեն անվանում` Iterator pattern
Տեսակ` Վարքագծային
Նշանակություն` տարանջատում է ալգորիթմը կոնտեյներներից
Նկարագրությունը ԳօՖի
"Design Patterns" գրքում`
Այո

Իտերատոր (անգլ.՝ Iterator pattern), վարքագծային նախագծման ձևանմուշ, որտեղ իտերատորն օգտագործվում է կոնտեյների էլեմենտներով անցնելու և նրանց վրա հասանելիություն ունենալու համար։ Իտերատորն տարանջատում է ալգորիթմը կոնտեյներներից, սակայն որոշ դեպքերում ալգորիթմները կոնտեյներ կողմնորոշված են և հնարավոր չէ այն տարանջատել։

Օրինակ SearchForElement հիպոթետիկ ալգորիթմը կոնկրետ կոնտեյներ սպեցեֆիկ ալգորիթմի փոխարեն իրականացվում է որոշակի տիպի իտերատոր օգտագործելով։ Դա թույլ է տալիս SearchForElement-ն օգտագործել ցանկացած տիպի կոնտեյների համար, եթե իհարկե, այն սպասարվում է տվյալ տիպի իտերատորի կողմից։

Օրինակներ[խմբագրել | խմբագրել կոդը]

C#[խմբագրել | խմբագրել կոդը]

/*
sample code in C#

This structural code demonstrates the Iterator pattern which provides for a way to traverse (iterate) over a collection of items without detailing the underlying structure of the collection.
*/
Hide code

// Iterator pattern -- Structural example

using System;
using System.Collections;
 
namespace DoFactory.GangOfFour.Iterator.Structural
{
 /// <summary>
 /// MainApp startup class for Structural
 /// Iterator Design Pattern.
 /// </summary>
 class MainApp
 {
 /// <summary>
 /// Entry point into console application.
 /// </summary>
 static void Main()
 {
 ConcreteAggregate a = new ConcreteAggregate();
 a[0] = "Item A";
 a[1] = "Item B";
 a[2] = "Item C";
 a[3] = "Item D";
 
 // Create Iterator and provide aggregate
 ConcreteIterator i = new ConcreteIterator(a);
 
 Console.WriteLine("Iterating over collection:");
 
 object item = i.First();
 while (! i.IsDone())
 {
 Console.WriteLine(item);
 item = i.Next();
 }
 
 // Wait for user
 Console.ReadKey();
 }
 }
 
 /// <summary>
 /// The 'Aggregate' abstract class
 /// </summary>
 abstract class Aggregate
 {
 public abstract Iterator CreateIterator();
 public abstract int Count { get; protected set; }
 public abstract object this[int index] { get; set; }
 }

 /// <summary>
 /// The 'ConcreteAggregate' class
 /// </summary>
 class ConcreteAggregate : Aggregate
 {
 private readonly ArrayList _items = new ArrayList();

 public override Iterator CreateIterator()
 {
 return new ConcreteIterator(this);
 }

 // Gets item count
 public override int Count
 {
 get { return _items.Count; }
 protected set { }
 }

 // Indexer
 public override object this[int index]
 {
 get { return _items[index]; }
 set { _items.Insert(index, value); }
 }
 }
 
 /// <summary>
 /// The 'Iterator' abstract class
 /// </summary>
 abstract class Iterator
 {
 public abstract object First();
 public abstract object Next();
 public abstract bool IsDone();
 public abstract object CurrentItem();
 }
 
 /// <summary>
 /// The 'ConcreteIterator' class
 /// </summary>
 class ConcreteIterator : Iterator
 {
 private readonly Aggregate _aggregate;
 private int _current;

 // Constructor
 public ConcreteIterator(Aggregate aggregate)
 {
 this._aggregate = aggregate;
 }
 
 // Gets first iteration item
 public override object First()
 {
 return _aggregate[0];
 }
 
 // Gets next iteration item
 public override object Next()
 {
 object ret = null;

 _current++;

 if (_current < _aggregate.Count)
 {
 ret = _aggregate[_current];
 }
 
 return ret;
 }
 
 // Gets current iteration item
 public override object CurrentItem()
 {
 return _aggregate[_current];
 }
 
 // Gets whether iterations are complete
 public override bool IsDone()
 {
 return _current >= _aggregate.Count;
 }
 }
}

Output
Iterating over collection:
Item A
Item B
Item C
Item D

}}

Ծանոթագրություններ[խմբագրել | խմբագրել կոդը]