Iterator Pattern
Example using the NBA
Iterator (Iterator.h)
#ifndef ITERATOR_H_
#define ITERATOR_H_
template <class Item>
class Iterator {
public:
virtual void First() = 0;
virtual void Next() = 0;
virtual bool IsDone() const = 0;
virtual Item CurrentItem() const = 0;
};
#endif
- Template Class
- All pure virtual functions and will be overridden
List (List.h)
#ifndef LIST_H_
#define LIST_H_
#include "Iterator.h"
template <class Item>
class List {
public:
virtual Iterator<Item> * CreateIterator() const = 0; // Iterator
virtual unsigned int Count() const = 0; // Return number of items in the list
virtual void Append(Item item) = 0; // Add item (element to the List)
};
#endif
Lets look at the iterators for Vector and Array
Vector List Iterator (Vector_List_Iterator)
#ifndef VECTOR_LIST_ITERATOR_H_
#define VECTOR_LIST_ITERATOR_H_
#include "Iterator.h"
template <class Item>
class VectorList;
template <class Item>
class VectorListIterator : public Iterator<Item> {
private:
const VectorList<Item> * vector_List;
unsigned int vector_index; // Assigned to 0 in constructor
public:
VectorListIterator(const VectorList<Item> * list): vector_List(list),vector_index(0){} // Constructor
virtual ~VectorListIterator(){} // Deconstructor
virtual void First(){
// Return first index
vector_index = 0;
}
virtual void Next()
{
vector_index++;
}
virtual bool IsDone() const
{
return (vector_List->Count() <= vector_index);
}
virtual Item CurrentItem() const
{
if(IsDone())
{
//throw IteratorOutOfBounds;
}
return vector_List->Get(vector_index);
}
};
#endif
Vector List (Vector_list.h)
#ifndef VECTOR_LIST_H_
#define VECTOR_LIST_H_
#include "List.h"
#include "Vector_List_Iterator.h"
#include <algorithm>
#include <vector>
template <class Item>
class Iterator;
template <class Item>
class VectorList : public List<Item> {
private:
std::vector<Item> m_vector; // Vector
public:
VectorList(){} // Constructor
virtual ~VectorList(){} // Deconstructor
virtual Iterator<Item> * CreateIterator() const {
return new VectorListIterator<Item>(this);
}
virtual unsigned int Count() const {
return m_vector.size();
}
virtual void Append(Item item) {
// Add Item/element to the list (push_back is a Vector Method)
m_vector.push_back(item);
}
virtual const Item& Get(unsigned int index) const
{
return m_vector.at(index);
}
};
#endif
Array List Iterator (Array_List_Iterator.h)
#ifndef ARRAY_LIST_ITERATOR_H_
#define ARRAY_LIST_ITERATOR_H_
#include "Iterator.h"
template <class Item>
class ArrayList;
template <class Item>
class ArrayListIterator : public Iterator<Item> {
private:
const ArrayList<Item> * Array_List;
unsigned int Array_index;
public:
ArrayListIterator(const ArrayList<Item> * list) : Array_List(list), Array_index(0){}
virtual ~ArrayListIterator(){}
virtual void First()
{
Array_index = 0;
}
virtual void Next()
{
Array_index++;
}
virtual bool IsDone() const
{
return (Array_List->Count() <= Array_index);
}
virtual Item CurrentItem() const
{
if(IsDone())
{
return Item();
}
return Array_List->Get(Array_index);
}
};
#endif
Array List (ArrayList.h)
#ifndef ARRAY_LIST_H_
#define ARRAY_LIST_H_
#include "List.h"
#include "Array_List_Iterator.h"
const unsigned int MAXSIZEARRAY = 200;
template <class Item>
class Iterator;
template <class Item>
class ArrayList : public List<Item> {
private:
Item m_array[MAXSIZEARRAY];
unsigned int current_Size;
public:
ArrayList(): current_Size(0){} // Constructor (set size of the Array)
virtual ~ArrayList(){} // Deconstructor
virtual Iterator<Item> * CreateIterator() const {
return new ArrayListIterator<Item>(this);
}
virtual unsigned int Count() const {
// Count number of elements in the Array
return current_Size;
}
virtual void Append(Item item) {
if(current_Size < MAXSIZEARRAY)
{
// Add Element to the array
m_array[current_Size] = item;
current_Size++;
}
}
virtual const Item& Get(unsigned int index) const
{
return m_array[index];
}
};
#endif
Basketball File Header (NBA_Payer.h)
#ifndef NBA_PLAYER_H_
#define NBA_PLAYER_H_
#include <string>
#include <iostream>
class NBA_Player {
private:
std::string m_name;
std::string m_position;
char m_ShootingHand;
public:
NBA_Player(std::string name, std::string position, char ShootingHand); // Constructor
NBA_Player();
virtual ~NBA_Player(); // Deconstructor
std::string GetName() const { return m_name; } // Setters
std::string GetPosition() const { return m_position; } // Setters
char GetShootingHandType() const { return m_ShootingHand; } // Setters
};
std::ostream& operator<<(std::ostream& outc,const NBA_Player & player);
#endif
Basketball File (NBA_Payer.cpp)
#include "NBA_Player.h"
NBA_Player::NBA_Player (std::string name, std::string position, char ShootingHand)
: m_name(name),
m_position(position),
m_ShootingHand(ShootingHand)
{}
NBA_Player::NBA_Player(): m_ShootingHand('\0') {} // another constructor
NBA_Player::~NBA_Player() {} // Deconstructor
std::ostream& operator<<(std::ostream& outc, const NBA_Player & player)
{
// Pretty Print
std::string tabsAfterName =
(player.GetName().size() >= 16) ?
std::string("\t") : std::string("\t\t");;
outc << player.GetPosition() << "\t"
<< player.GetName() << tabsAfterName
<< player.GetShootingHandType();
return outc;
}
Main File (main.cpp)
#include "Array_List.h"
#include "Vector_List.h"
#include "Iterator.h"
#include "NBA_Player.h"
#include <iostream>
#include <string>
List<NBA_Player> * MakeDetroitPistonsLineup()
{
// Using this Example as a Vector List
List<NBA_Player> * DetroitPistonsLineup = new VectorList<NBA_Player>();
// Append to our VectorList
DetroitPistonsLineup->Append(NBA_Player(std::string("Saddiq Bey"), std::string("F"), 'L'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Tyler Cook"), std::string("F"), 'R'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Hamidou Diallo"), std::string("G"), 'R'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Sekou Doumbouya"), std::string("F"), 'L'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Wayne Ellington"), std::string("G"), 'R'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Jerami Grant"), std::string("F"), 'L'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Killian Hayes"), std::string("G"), 'R'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Frank Jackson"), std::string("G"), 'R'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Josh Jackson"), std::string("G/F"),'L'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Cory Joseph"), std::string("G"), 'L'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Dennis Smith Jr."), std::string("G"), 'L'));
DetroitPistonsLineup->Append(NBA_Player(std::string("Isaiah Stewart"), std::string("C"), 'R'));
return DetroitPistonsLineup;
}
List<NBA_Player> * MakeLosAngelesLakersLineup()
{
// Using this Example as a Array List
List<NBA_Player> * LosAngelesLakersLineup = new ArrayList<NBA_Player>();
LosAngelesLakersLineup->Append(NBA_Player(std::string("Kostas Antetokounmpo"), std::string("F"), 'L'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Devontae Cook"), std::string("F"), 'R'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Kentavious Caldwell"), std::string("G"), 'L'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Alex Caruso"), std::string("G"), 'L'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Anthony Davis"), std::string("C"), 'L'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Andre Drummond"), std::string("C"), 'R'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Jared Dudley"), std::string("G"), 'R'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Marc Gasol"), std::string("C/F"), 'R'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Montrezl Harrell"), std::string("F"), 'R'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Talen Horton-Tucker"), std::string("G/F"), 'R'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Lebron James"), std::string("F/F"), 'R'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Kyle Kuzma "), std::string("F"), 'R'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Dennis Schroder"), std::string("G"), 'R'));
LosAngelesLakersLineup->Append(NBA_Player(std::string("Markieff Morris"), std::string("G/F"), 'R'));
return LosAngelesLakersLineup;
}
void PrintLineup(std::string lineupName, Iterator<NBA_Player> * iterator)
{
// Pretty Print Function
// Pass in LineupName
// Can "iterate" through both the Array_List and Vector_List using First(), Next()
std::cout << lineupName << "\n";
unsigned int lineupPosition = 1;
for(iterator->First(); !iterator->IsDone(); iterator->Next())
{ // Loop through the iterator
std::cout << lineupPosition++ << ". " << iterator->CurrentItem() << " \n";
}
std::cout << "\n";
}
int main()
{
List<NBA_Player> * DetroitPistonsLineup = MakeDetroitPistonsLineup();
Iterator<NBA_Player> * DetroitPistonsLineupIterator = DetroitPistonsLineup->CreateIterator(); // Custom iterator to "iterate thru"
PrintLineup(std::string("Detroit Pistons Lineup"), DetroitPistonsLineupIterator);
delete DetroitPistonsLineupIterator;
delete DetroitPistonsLineup;
List<NBA_Player> * LosAngelesLakersLineup = MakeLosAngelesLakersLineup();
Iterator<NBA_Player> * LosAngelesLakersLineupIterator = LosAngelesLakersLineup->CreateIterator();
PrintLineup(std::string("Los Angeles Lakers Lineup"), LosAngelesLakersLineupIterator);
delete LosAngelesLakersLineupIterator;
delete LosAngelesLakersLineup;
}
Output:
Detroit Pistons Lineup
1. F Saddiq Bey L
2. F Tyler Cook R
3. G Hamidou Diallo R
4. F Sekou Doumbouya L
5. G Wayne Ellington R
6. F Jerami Grant L
7. G Killian Hayes R
8. G Frank Jackson R
9. G/F Josh Jackson L
10. G Cory Joseph L
11. G Dennis Smith Jr. L
12. C Isaiah Stewart R
Los Angeles Lakers Lineup
1. F Kostas Antetokounmpo L
2. F Devontae Cook R
3. G Kentavious Caldwell L
4. G Alex Caruso L
5. C Anthony Davis L
6. C Andre Drummond R
7. G Jared Dudley R
8. C/F Marc Gasol R
9. F Montrezl Harrell R
10. G/F Talen Horton-Tucker R
11. F/F Lebron James R
12. F Kyle Kuzma R
13. G Dennis Schroder R
14. G/F Markieff Morris R