//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.
