//arrayList.h
 #include<iostream>
#include<sstream>
#include<string>
#include<algorithm>
#include<iterator>

using namespace std;

template<class T>
class arrayList{
public:
    // constructor, copy constructor and destructor
    arrayList(int initialCapacity = 10);
    arrayList(const arrayList<T>&);
    ~arrayList() {
        delete[] element;
    }

    // ADT methods
    bool empty() const {
        return listSize == 0;
    }
    int size() const {
        return listSize;
    }
    T& get(int theIndex) const;
    int indexOf(const T& theElement) const;
    void erase(int theIndex);
    void insert(int theIndex, const T& theElement);
    void output(ostream& out) const;

    // additional method
    int capacity() const {
        return arrayLength;
    }
    void reverse(); // new defined

    // iterators to start and end of list
    class iterator;
    class seamlessPointer;
    seamlessPointer begin() {
        return seamlessPointer(element);
    }
    seamlessPointer end() {
        return seamlessPointer(element + listSize);
    }
    // iterator for arrayList
    class iterator {
    public:
        // typedefs required by C++ for a bidirectional iterator
        typedef bidirectional_iterator_tag iterator_category;
        typedef T value_type;
        typedef ptrdiff_t difference_type;
        typedef T* pointer;
        typedef T& reference;

        // constructor
        iterator(T* thePosition = 0) {
            position = thePosition;
        }

        // dereferencing operators
        T& operator*() const {
            return *position;
        }
        T* operator->() const {
            return position;
        }

        // increment
        iterator& operator++() // preincrement
        {
            ++position;
            return *this;
        }
        iterator operator++(int) // postincrement
        {
            iterator old = *this;
            ++position;
            return old;
        }

        // decrement
        iterator& operator--() // predecrement
        {
            --position;
            return *this;
        }
        iterator operator--(int) // postdecrement
        {
            iterator old = *this;
            --position;
            return old;
        }

        // equality testing
        bool operator!=(const iterator right) const {
            return position != right.position;
        }
        bool operator==(const iterator right) const {
            return position == right.position;
        }
    protected:
        T* position;
    }; // end of iterator class

    class seamlessPointer: public arrayList<T>::iterator {

        // constructor
        seamlessPointer(T *thePosition) { iterator::position = thePosition;
        }
        //arithmetic operators
        seamlessPointer & operator+(int n) {
            arrayList<T>::iterator::position += n;
            return *this;
        }
        seamlessPointer & operator+=(int n) {
            arrayList<T>::iterator::position += n;
            return *this;
        }

        seamlessPointer & operator-(int n) {
            arrayList<T>::iterator::position -= n;
            return *this;
        }
        seamlessPointer & operator-=(int n) {
            arrayList<T>::iterator::position -= n;
            return *this;
        }
        T& operator[](int n) {
            return arrayList<T>::iterator::position[n];
        }
        bool operator<(seamlessPointer &rhs) {
            if(int(arrayList<T>::iterator::position - rhs.position) < 0)
                return true;
            return false;

        }
        bool operator<=(seamlessPointer & rhs) {
            if (int(arrayList<T>::iterator::position - rhs.position) <= 0)
                return true;
            return false;
        }
        bool operator >(seamlessPointer & rhs) {
            if (int(arrayList<T>::iterator::position - rhs.position) > 0)
                return true;
            return false;
        }
        bool operator >=(seamlessPointer &rhs) {
            if (int(arrayList<T>::iterator::position - rhs.position) >= 0)
                return true;
            return false;
        }
    };

protected:
    // additional members of arrayList
    void checkIndex(int theIndex) const;
    // throw illegalIndex if theIndex invalid
    T* element; // 1D array to hold list elements
    int arrayLength; // capacity of the 1D array
    int listSize; // number of elements in list
};

#endif

//main.cpp

#include<iostream>
#include"arrayList.h"
#include<fstream>
#include<algorithm>
#include<string>

using namespace std;


bool compare_nocase (string first, string second)
{
  unsigned int i=0;
  while ( (i<first.length()) && (i<second.length()) )
  {
    if (tolower(first[i])<tolower(second[i])) return true;
    else if (tolower(first[i])>tolower(second[i])) return false;
    ++i;
  }
  if (first.length()<second.length()) return true;
  else return false;
}

int main() {
    ifstream fin;
    ofstream fout;
    string str;
    arrayList<string> dict;

    fin.open("dictionary");
    if (!fin.good()) {
        cout << "Unable to open file" << endl;
        return 1;
    }
    int k=0;
    while(getline(fin,str))
    {
        dict.insert(k,str);
//      cout<<dict.get(k)<<endl;
        k++;
    }
    //sort the array

    sort(dict.begin, dict.end(),compare_nocase);

    fout.open("sortedDictionary");

    if (!fout.good()) {
        cout << "Cannot create file" << endl;
        return 1;
    }

    dict.output(fout);
    fin.close();


    return 0;
}

Two errors are:

..\src\test.cpp: In function 'int main()':
..\src\test.cpp:50:44: error: no matching function for call to 'sort(<unresolved overloaded function type>, arrayList<std::basic_string<char> >::seamlessPointer, bool (&)(std::string, std::string))'

..\src\/arrayList.h: In member function 'arrayList<T>::seamlessPointer arrayList<T>::end() [with T = std::basic_string<char>]':
..\src\test.cpp:50:28:   instantiated from here
..\src\/arrayList.h:114:3: error: 'arrayList<T>::seamlessPointer::seamlessPointer(T*) [with T = std::basic_string<char>]' is private
..\src\/arrayList.h:49:44: error: within this context

Why do I get these errors?

Update I add public: in the seamlessPointer class and change begin to begin() Then I got the following errors:

..\hw3prob2.cpp:50:46:   instantiated from here
c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_algo.h:5250:4: error: no match for 'operator-' in '__last - __first'
..\/arrayList.h:129:21: note: candidate is: arrayList<T>::seamlessPointer& arrayList<T>::seamlessPointer::operator-(int) [with T = std::basic_string<char>, arrayList<T>::seamlessPointer = arrayList<std::basic_string<char> >::seamlessPointer]

c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_algo.h:5252:4:   instantiated from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = arrayList<std::basic_string<char> >::seamlessPointer, _Compare = bool (*)(std::basic_string<char>, std::basic_string<char>)]'
..\hw3prob2.cpp:50:46:   instantiated from here
c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_algo.h:2190:7: error: no match for 'operator-' in '__last - __first'
..\/arrayList.h:129:21: note: candidate is: arrayList<T>::seamlessPointer& arrayList<T>::seamlessPointer::operator-(int) [with T = std::basic_string<char>, arrayList<T>::seamlessPointer = arrayList<std::basic_string<char> >::seamlessPointer]

Then I add operator -() in the seamlessPointer class

ptrdiff_t operator -(seamlessPointer &rhs) {

        return (arrayList<T>::iterator::position - rhs.position);
    }

Then I compile successfully. But when I run it, I found memeory can not read error. I debug and step into and found the error happens in stl function

template<typename _RandomAccessIterator, typename _Distance,
       typename _Tp, typename _Compare>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
          _Distance __len, _Tp __value, _Compare __comp)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
    {
      __secondChild = 2 * (__secondChild + 1);
      if (__comp(*(__first + __secondChild),
             *(__first + (__secondChild - 1))))  
        __secondChild--;
      *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild)); ////// stop here
      __holeIndex = __secondChild;
    }

Of course, there must be something wrong with the customized operators of iterator. Does anyone know the possible reason? Thank you.