#include <iostream>
#include <string>
using namespace std;

template <typename T, const int size = 7> class Iterator; // Forward declaration

template <typename T, const int size = 7>
class Container
{
    T array[size];
public:
    friend class Iterator<T, size>;
};

template <typename T, const int size>
class Iterator
{
    Container<T,size>& ref;
    int index;
public:
    Iterator(Container<T,size>& cr)
        : ref(cr), index(0)
    {}

    void reset()
    {
        index = 0;
    }

    // prefix increment operator
    Iterator<T,size>& operator++()
    {
        if(index < size - 1)
            index++;
        else
            index = size;
        return *this;   // indicates end of list
    }

    // dereferencing operator
    T& operator*()
    {
        return ref.array[index];
    }

    // conversion operator
    operator bool() const
    {
        return index < size;
    }
};

class X
{
    int i;
public:
    X(int I = 0) : i(I) {}
    X& operator=(const int& I)
    {
        i = I;
        return *this;
    }

    friend ostream& operator<<(ostream& out, const X& object)
    {
        out << object.i;
        return out;
    }
};
class Fraction
{
    int numer, denom;
public:
    Fraction(int n = 0, int d = 1) : numer(n),denom(d) {}
    Fraction& operator=(const Fraction& f)
    {
        numer = f.numer;
        denom = f.denom;
        return *this;
    }
    friend ostream& operator<<(ostream& out, const Fraction& object)
    {
        out << object.numer << '/' << object.denom;
        return out;
    }
};


class Card
{
private:
    int pips, suit;
    static const string SuitName[4];
    static const string PipsName[13];
public:
    Card(int n = 0) : pips(n%13), suit(n/13) {}
    Card& operator=(const Card& c)
    {
        pips = c.pips;
        suit = c.suit;
        return *this;
    }
    friend ostream& operator<<(ostream& out, const Card& object)
    {
        out <<PipsName[object.pips] << " of " << SuitName[object.suit];
        return out;
    }
};

const string Card::SuitName[4] = {"clubs","diamonds","hearts","spades"};
const string Card::PipsName[13] = {"two","three","four","five","six","seven",
                        "eight","nine","ten","jack","queen","king","ace"};

int main()
{
    Container<X> xC;
    Iterator<X> iX(xC);
    for(auto i = 0; i < 7; i++)
    {
        *iX = i;
        ++iX;
    }
    iX.reset();
    do cout << *iX << endl;
    while(++iX);

    Container<Fraction,3> fractionContainer;
    Iterator<Fraction,3> fractionIterator(fractionContainer);
    for(auto i = 0; i < 3; i++)
    {
        *fractionIterator = Fraction(i+1,i+2);
        ++fractionIterator;
    }
    fractionIterator.reset();
    do cout << *fractionIterator << endl;
    while(++fractionIterator);

    Container<Card,5> CardC;
    Iterator<Card,5> itCard(CardC);
    for(auto i = 0; i < 5; i++)
    {
        *itCard = Card(3*i+5);
        ++itCard;
    }
    itCard.reset();
    do cout << *itCard << endl;
    while(++itCard);
}