Итераторы (пример использования итератора для шаблона, к примеру списка)

for (container_t::iterator it = Con.begin(); it != Con.end(); ++it)
{
    // ...
}

#include <iostream>
#include <list>
 
int main()
{
    std::list<int> List;
 
    List.push_back(123);
    List.push_back(456);
    List.push_back(789);
 
    for (std::list<int>::iterator it = List.begin(); it != List.end(); ++it)
    {
        std::cout << *it << std::endl;
    }
 
    return 0;
}

#include <assert.h>
#include <iostream>
#include <string>
#include <stdexcept>
#include <list>
 
using namespace std;
 
template<class Item>
class Iterator {
public:
    virtual ~Iterator();
    virtual void First() = 0;
    virtual void Next() = 0;
    virtual bool IsDone() const = 0;
    virtual Item * CurrentItem() const = 0;
protected:
    Iterator();
};
 
template<class Item>
Iterator<Item>::Iterator() {
}
 
template<class Item>
Iterator<Item>::~Iterator() {
}
//------------------------------------------------------------------------------
 
struct A {
    A(string mark) :
            mMark(mark) {
    }
    string mMark;
};
 
//------------------------------------------------------------------------------
 
template<class T>
class IteratorList: public Iterator<T> {
    typename list<T>::iterator curr;
    typename list<T>::iterator first;
    typename list<T>::iterator last;
public:
    virtual ~IteratorList() {}
    IteratorList(typename list<T>::iterator c, typename list<T>::iterator f,
            typename list<T>::iterator l) :
                curr(c), first(f), last(l) {
    }
        
// Функция костыль: по сули дублирует код конструктора, но без нее не получатся связать итератор с контейнером внутри коллекции.   
    void  Init(typename list<T>::iterator c, typename list<T>::iterator f, typename list<T>::iterator l ) {
        curr = c;
        first = f;
        last = l;
    }
 
    // By GoF
    virtual void First();
    virtual void Next();
    virtual bool IsDone() const;
    virtual T* CurrentItem() const;
 
    // Стратуструп
    T& operator*() {
        return *curr;
    }
    const T& operator*() const {
        return *curr;
    }
    T* operator->() {
        return &(*curr);
    }
 
 
    IteratorList& operator++();
    IteratorList& operator--();
};
 
template<typename T>
class ContainerList {
public:
    ContainerList() {
    }
    void PushBack(T car) {
        Cares.push_back(car);
    }
 
    typename list<T>::iterator Begin() {
        return Cares.begin();
    }
 
    typename list<T>::iterator End() {
        return Cares.end();
    }
private:
    list<T> Cares;
};
 
template<typename T>
class CollectionList {
public:
    CollectionList() :
        containList(), itList(containList.Begin(), containList.Begin(), containList.End()) { // my пустой itList тоже инит. копиями пустых итераторов
        // идея связать containList и itList на этапе создания коллекции (заранее)
    }
    void Add(T item) {
        containList.PushBack(item);
    }
    T* Get() {
        return itList.CurrentItem();
    }
 
    void First() {
        itList.Init(containList.Begin(), containList.Begin(), containList.End()); // хотелось бы без этой строки 
        itList.First();
    }
 
    void Next() {
        itList.Next();
    }
 
    bool IsDone() {
        return itList.IsDone();
    }
 
private:
    ContainerList<T> containList;
    IteratorList<T> itList;
};
 
//------------------------------------------------------------------------------
 
int main() {
    try {
 
        A* a1 = new A("bmw");
        A* a2 = new A("honda");
        A* a3 = new A("mazda");
 
        CollectionList<A*> coll;
        coll.Add(a1);
        coll.Add(a2);
        coll.Add(a3);
 
        cout  << " collection : \n";
 
        for(coll.First(); !coll.IsDone(); coll.Next()){
            A *a = *coll.Get();
            cout << a->mMark << "\n";
        }
//       coll.Next(); //  assert error
 
    }
 
    catch (exception& e) {
        cerr << "exception: " << e.what() << endl;
    }
    catch (...) {
        cerr << "exception\n";
    }
}
 
//------------------------------------------------------------------------------
 
template<class T>
IteratorList<T>& IteratorList<T>::operator++() {
    ++curr;
    if (curr == last)
        assert(!"iterator past end of list");
    return *this;
}
 
template<class T>
IteratorList<T>& IteratorList<T>::operator--() {
    if (curr == first)
        assert(!"iterator before begin of list");
    --curr;
    return *this;
}
 
//------------------------------------------------------------------------------
 
template<class T>
void IteratorList<T>::First() {
    curr = first;
}
 
template<class T>
void IteratorList<T>::Next() {
 
    if (curr != last)
        ++curr;
    else
        assert(!"iterator past end of list");
}
 
template<class T>
bool IteratorList<T>::IsDone() const {
    return curr == last;
}
 
template<class T>
T* IteratorList<T>::CurrentItem() const {
    return &(*curr);
}

    void CollectionList::First() {
        itList.Init(containList.Begin(), containList.Begin(), containList.End());
        itList.First();
    }

       IteratorList::IteratorList(typename list<T>::iterator & c, typename list<T>::iterator & f,
            typename list<T>::iterator & l) :
                curr(c), first(f), last(l) {
    }

template<class T>
void IteratorList<T>::Next() {
    assert(curr != container.End() && "iterator past end of list");
    ++curr;
}

template<typename TData, template< typename _Tp, typename _Alloc = std::allocator<_Tp> > class TContain >
class IContainer {
public:
    virtual ~IContainer(){}
    typedef typename TContain<TData>::iterator iterator;
 
    virtual void PushBack(TData item)=0;
    virtual iterator Begin()=0;
    virtual iterator End()=0;
 
    IContainer(){}  // TODO не получается сделать приватным приватным, не понял почему?
private:
};

template<typename TData, template< typename _Tp, typename _Alloc = std::allocator<_Tp> > class TContain >

template<typename,  typename> class TContain

// Компилируется 
 
#include <cstddef>
#include <iostream>
#include <list>
#include <vector>
//-#include <map>
//-#include <queue>
#include <stack>
 
using namespace std;
 
template< typename TData, template<typename, typename Alloc = allocator<TData> > class Contain >  //
class Container {
public:
    typedef typename Contain<TData>::iterator iterator;
    Container() :
        contain(), curr(begin()) {
    }
 
    void Append(const TData& t) {
        contain.push_back(t);
    }
 
    void First() {
        curr = begin();
    }
 
    void Next() {
        ++curr;
    }
 
    bool IsDone() {
        return curr == end();
    }
 
    TData * CurrentItem() {
        return &(*curr);
    }
 
private:
    iterator begin() {
        return contain.begin();
    }
    iterator end() {
        return contain.end();
    }
 
private:
    Contain<TData> contain;
    iterator  curr;
};
 
int main() {
    Container<int, list  > container;
 
    container.Append(9);
    container.Append(5);
 
 
    for(container.First(); !container.IsDone(); container.Next() ) {
        cout << *container.CurrentItem() << "\n";
    }
}

// Не компилируется. Не заня как добрать до значения параметра шаблона Tp
#include <cstddef>
#include <iostream>
#include <list>
#include <vector>
//-#include <map>
//-#include <queue>
#include <stack>
 
using namespace std;
 
 
template< template<typename Tp, typename Alloc = allocator<Tp> >    class Contain >  
class Container {
public:
    typedef typename Contain<Tp>::iterator iterator;
    Container() :
        contain(), curr(begin()) {
    }
 
    void Append(const Tp& t) {
        contain.push_back(t);
    }
 
    void First() {
        curr = begin();
    }
 
    void Next() {
        ++curr;
    }
 
    bool IsDone() {
        return curr == end();
    }
 
    Tp * CurrentItem() {
        return &(*curr);
    }
 
private:
    iterator begin() {
        return contain.begin();
    }
    iterator end() {
        return contain.end();
    }
 
private:
    Contain<Tp> contain;
    iterator  curr;
};
 
int main() {
    Container< list<int>  > container;
 
    container.Append(9);
    container.Append(10);
 
    for(container.First(); !container.IsDone(); container.Next() ) {
        cout << *container.CurrentItem() << "\n";
    }
}

// Не компилируется. Даже не представлю как реализовать функции добавления и возврата данных
#include <cstddef>
#include <iostream>
#include <list>
#include <vector>
//-#include <map>
//-#include <queue>
#include <stack>
 
using namespace std;
 
 
 
template< template<typename, typename>  class Contain >  
class Container {
public:
    typedef typename Contain::iterator iterator;
    Container() :
        contain(), curr(begin()) {
    }
 
//  void Append(const Tp& t) {
//      contain.push_back(t);
//  }
 
    void First() {
        curr = begin();
    }
 
    void Next() {
        ++curr;
    }
 
    bool IsDone() {
        return curr == end();
    }
 
//  Tp * CurrentItem() {
//      return &(*curr);
//  }
 
private:
    iterator begin() {
        return contain.begin();
    }
    iterator end() {
        return contain.end();
    }
 
private:
    Contain contain;
    iterator  curr;
};
 
int main() {
    Container< list<int>  > container;
 
//  container.Append(9);
//  container.Append(10);
 
    for(container.First(); !container.IsDone(); container.Next() ) {
//      cout << *container.CurrentItem() << "\n";
    }
}