Implementing DequeIterator<>

template <typename T>
DequeIterator<T>::DequeIterator () : dequePtr_(0), indexBase_(0)
{}

template <typename T>
DequeIterator<T>::DequeIterator (const Deque<T>& Q)
 : dequePtr_(&Q), indexBase_(0)
{}

template <typename T>
DequeIterator<T>::DequeIterator (const DequeIterator<T>& i)
  :  dequePtr_(i.dequePtr_), indexBase_(i.indexBase_)
{}

template <typename T>
void  DequeIterator<T>::Initialize (const Deque<T>& Q)
{
  dequePtr_ = &Q;
  indexBase_ = 0;
}

template <typename T>
bool DequeIterator<T>::Valid () const
{
  if (0 == dequePtr_)
    return 0;
  if (indexBase_ >= dequePtr_->Size())
    return 0;
  return 1;
}

template <typename T>
bool DequeIterator<T>::operator == (const Iterator& i2) const
{
  if (dequePtr_ != i2.dequePtr_)
    return 0;
  if (indexBase_ != i2.indexBase_)
    return 0;
  return 1;
}

template <typename T>
T&  DequeIterator<T>::operator *  () const
{
  if (0 == dequePtr_)
    ... error handling
  if (dequePtr_->Size() == 0)
    std::cerr << "** DequeIterator error: invalid dereference\n";
  return dequePtr_->operator[](indexBase_);
}

template <typename T>
T&  DequeIterator<T>::operator [] (size_t index) const
{
  if (!dequePtr_)
    ... error handling
  return dequePtr_->operator[](indexBase_ + index);
}

template <typename T>
DequeIterator<T>& DequeIterator<T>::operator = (const Iterator & i)
{
  if (this != &i)
  {
    dequePtr_ = i.dequePtr_;
    indexBase_ = i.indexBase_;
  }
  return *this;
}

template <typename T>
DequeIterator<T>& DequeIterator<T>::operator ++ ()
{
  ++indexBase_;
  return *this;
}

template <typename T>
DequeIterator<T>  DequeIterator<T>::operator ++ (int)
{
  Iterator i(*this);
  operator ++();
  return i;
}

template <typename T>
long DequeIterator<T>::operator -  (const Iterator & i2) const
{
  return indexBase_ -  i2.indexBase_;
}

// these are the new template pointer arithmetic operator implementations

template <typename T>
template <typename N>
DequeIterator<T>& DequeIterator<T>::operator += (N n)
{
  indexBase_ += n;
  return *this;
}

template <typename T>
template <typename N>
DequeIterator<T>  DequeIterator<T>::operator +  (N n) const
{
  Iterator i(*this);
  return i += n;
}

Complete details in Narrative