Паттерн Iterator

Помечено: , , ,

В этой теме 0 ответов, 1 участник, последнее обновление  Васильев Владимир Сергеевич 7 мес., 2 нед. назад.

  • Автор
    Сообщения
  • #3622

    Итератор — это класс, объект которого имеет частичную семантику указателя. Итераторы делятся по способу доступа на итераторы последовательного доступа и итераторы произвольного доступа. Итераторы последовательного доступа бывают однонаправленными и двунаправленными. Цель данного паттерна — предоставить пользователю возможность работать с элементами какого-либо множества без непосредственного доступа к самому множеству, не вынуждая пользователя работать с небезопасными указателями и не завязывая пользователя на структуре этого множества.

    Я постарался продемонстрировать минимальную реализацию итератора. Конечно, представленный вариант далек от совершенства, однако я ставил перед собой иные цели — показать общую идею в минимальном количестве кода. Мой итератор не является STL-совместимым, его задача заключается в простой демонстрации идеи паттерна.

    #include <iostream>
    
    template <class node, class T>
    class iterator
    {
    public:
    
        iterator(node* n)
        : node_ptr(n)
        {
        }
    
        T* operator * ()
        {
            return node_ptr->get();
        }
    
        T* operator -> ()
        {
            return node_ptr->get();
        }
    
        void operator ++ ()
        {
            node_ptr = node_ptr->next();
        }
    
        iterator operator ++ (int)
        {
            iterator iter(*this);
            ++(*this);
            return iter;
        }
    
        bool operator == (iterator const& i)
        {
            return node_ptr == i.node_ptr;
        }
    
        bool operator != (iterator const& i)
        {
            return !(*this == i);
        }
    
    private:
    
        node* node_ptr;
    };
    
    template <class T>
    class list_node
    {
    public:
    
        list_node(T const& t)
        : object(t)
        , next_node(0)
        {
            
        }
    
        ~list_node()
        {
            delete next_node;
        }
    
        void push_back(T const& t)
        {
            if(next_node)
            {
                next_node->push_back(t);
            }
            else
            {
                next_node = new list_node(t);
            }
        }
    
        list_node* next()
        {
            return next_node;
        }
    
        T* get()
        {
            return &object;
        }
    
    private:
    
        T object;
        list_node* next_node;
    };
    
    template <class T>
    class list
    {
    public:
    
        typedef list_node<T> node;
    
        typedef iterator<node, T> iterator;
    
        list()
        : root(0)
        {
        }
    
        ~list()
        {
            delete root;
        }
    
        void push_back(T const& t)
        {
            if(root)
            {
                root->push_back(t);
            }
            else
            {
                root = new node(t);
            }
        }
    
        iterator begin()
        {
            return iterator(root);
        }
    
        iterator end()
        {
            return iterator(0);
        }
    
    private:
    
        node* root;
    };
    
    int main()
    {
        typedef list<std::string> string_container;
        string_container orders;
    
        orders.push_back("First");
        orders.push_back("Second");
        orders.push_back("Third");
        orders.push_back("Fourth");
    
        for(string_container::iterator it = orders.begin(); it != orders.end(); ++it)
        {
            std::cout << it->c_str() << std::endl;
        }
    
        return 0;
    }

    Итератор — хороший паттерн. Он позволяет полностью разделить реализацию инфраструктуры контейнерноподобных типов данных и алгоритмы по их обработке. Помимо всего прочего, итераторы являются наиболее естественным с точки зрения языка инструментом для последовательной или произвольной работы с элементами множества.

Для ответа в этой теме необходимо авторизоваться.