作业三(基本要求)

fseq.cpp

#include <fstream>
#include <algorithm>
#include <iterator>

namespace mine
{
    typedef std::fstream* stream_ptr;
    typedef std::size_t pos_type;
    typedef std::ptrdiff_t difference_type;
    typedef char value_type;
    typedef std::size_t size_type;
    const int value_size = sizeof(value_type);

    struct proxy
    {
        stream_ptr fs;
        pos_type pos;

        proxy(stream_ptr fs, pos_type pos) : fs(fs), pos(pos) {}

        operator value_type() const
        {
            fs->seekg(pos);
            value_type val;
            fs->read(&val, value_size);
            return val;
        }

        proxy& operator =(value_type value)
        {
            fs->seekp(pos);
            fs->write(&value, value_size);
            return *this;
        }

        proxy& operator =(proxy other)
        {
            return *this = value_type(other);
        }
    };

    struct iterator
    {
        typedef ::mine::value_type value_type;
        typedef proxy reference;
        typedef void* pointer; // dummy type, can be anything
        typedef ::mine::difference_type difference_type;
        typedef std::random_access_iterator_tag iterator_category;

        stream_ptr fs;
        pos_type pos;

        iterator(stream_ptr fs, pos_type pos) : fs(fs), pos(pos) {}

        reference operator *() const
        {
            return reference(fs, pos);
        }

        iterator& operator ++()
        {
            ++pos;
            return *this;
        }

        // suffix version
        iterator operator ++(int)
        {
            iterator t = *this;
            ++*this;
            return t;
        }

        iterator operator --()
        {
            --pos;
            return *this;
        }

        // suffix version
        iterator operator --(int)
        {
            iterator t = *this;
            --*this;
            return t;
        }

        iterator& operator +=(difference_type offset)
        {
            pos += offset;
            return *this;
        }

        iterator& operator -=(difference_type offset)
        {
            return *this += -offset;
        }

        reference operator [](difference_type offset)
        {
            return *(*this + offset);
        }

        friend iterator operator +(iterator lhs, difference_type offset)
        {
            return lhs += offset;
        }

        friend iterator operator -(iterator lhs, difference_type offset)
        {
            return lhs -= offset;
        }

        friend difference_type operator -(iterator lhs, iterator rhs)
        {
            return lhs.pos - rhs.pos;
        }

        friend bool operator <(iterator lhs, iterator rhs)
        {
            return lhs.pos < rhs.pos;
        }

        friend bool operator !=(iterator lhs, iterator rhs)
        {
            return lhs.pos < rhs.pos || rhs.pos < lhs.pos;
        }

        friend bool operator ==(iterator lhs, iterator rhs)
        {
            return !(lhs != rhs);
        }
    };

    struct fseq
    {
        stream_ptr fs;

        fseq(stream_ptr fs) : fs(fs) {}

        iterator begin()
        {
            return iterator(fs, 0);
        }

        iterator end()
        {
            return begin() + size();
        }

        size_type size() const
        {
            fs->seekg(0, std::ios::end);
            return fs->tellg();
        }
    };
}

namespace std
{
    // some evil hack, just write it
    void swap(mine::proxy &lhs, mine::proxy &rhs)
    {
        mine::value_type t = lhs;
        lhs = rhs;
        rhs = t;
    }
}

int main()
{
    std::fstream fs("in.txt");
    mine::fseq s(&fs);
    std::sort(s.begin(), s.end());
    return 0;
}