Listing 3: <iterator>, part 7

        // TEMPLATE CLASS back_insert_iterator
template<class Cont>
    class back_insert_iterator : public output_iterator {
public:
    explicit back_insert_iterator(Cont& x)
        : container(x) {}
    back_insert_iterator<Cont>& operator=(
        const Cont::value_type& val)
        {container.push_back(val);
        return (*this); }
    back_insert_iterator<Cont>& operator*()
        {return (*this); }
    back_insert_iterator<Cont>& operator++()
        {return (*this); }
    back_insert_iterator<Cont> operator++(int)
        {return (*this); }
protected:
    Cont& container;
    };

        // TEMPLATE FUNCTION back_inserter
template<class Cont> inline
    back_insert_iterator<Cont> back_inserter(Cont& x)
    {return (back_insert_iterator<Cont>(x)); }

        // TEMPLATE CLASS front_insert_iterator
template<class Cont>
    class front_insert_iterator : public output_iterator {
public:
    explicit front_insert_iterator(Cont& x)
        : container(x) {}
    front_insert_iterator<Cont>& operator=(
        const Cont::value_type& val)
        {container.push_front(val);
        return (*this); }
    front_insert_iterator<Cont>& operator*()
        {return (*this); }
    front_insert_iterator<Cont>& operator++()
        {return (*this); }
    front_insert_iterator<Cont> operator++(int)
        {return (*this); }
protected:
    Cont& container;
    };

        // TEMPLATE FUNCTION front_inserter
template<class Cont> inline
    front_insert_iterator<Cont> front_inserter(Cont& x)
    {return (front_insert_iterator<Cont>(x)); }

        // TEMPLATE CLASS insert_iterator
template<class Cont>
    class insert_iterator : public output_iterator {
public:
    insert_iterator(Cont& x, Cont::iterator p)
        : container(x), iter(p) {}
    insert_iterator<Cont>& operator=(
        const Cont::value_type& val)
        {iter = container.insert(iter, val);
        ++iter;
        return (*this); }
    insert_iterator<Cont>& operator*()
        {return (*this); }
    insert_iterator<Cont>& operator++()
        {return (*this); }
    insert_iterator<Cont>& operator++(int)
        {return (*this); }
protected:
    Cont& container;
    Cont::iterator iter;
    };

        // TEMPLATE FUNCTION inserter
template<class Cont, class Iter> inline
    insert_iterator<Cont> inserter(Cont& x, Iter p)
    {return (insert_iterator<Cont>(x, Cont::iterator(p))); }
/* End of File */