C++实现array迭代器

迭代器简述

迭代器是容器类（如数组，链表，队列，栈等）提供的、用于遍历和访问容器内对象的辅助类。在本题中，我们考虑一种简化的迭代器，它为我们自定义的整型数组类提供元素的遍历和访问。

迭代器的功能架构

自定义的整型数组类MyArray和内部类Iterator模板如下：

class MyArray {
    int * arr;
    int size;
public:
    class Iterator{
        ...
    public:
        ...
        bool get(int &value) const;
        bool put(int value);
        ...
    };
public:
    MyArray(int size);
    ~MyArray();
    Iterator begin();
    Iterator end();
}

MyArray类给出两个接口Iterator begin()和Iterator end()来提供两个特殊的迭代器对象。

• Iterator begin()：返回的迭代器对象，指向数组的第一个元素arr[0]
• Iterator end()：返回的迭代器对象，指向数组arr的末尾，但不是任何数组中的元素

//遍历容器中每个元素
for(MyArray::Iterator iter = ma.begin(); iter != ma.end(); iter++){
    int v;
    iter.get(v);
    ...
}
//通过判断迭代器iter是不是迭代到了容器的末尾，让整个遍历可以结束。

每个迭代器对象都提供两个接口bool get(int &value)和bool put(int value)

• bool get(int &value)：获取当前迭代器所指向的元素。如果迭代器位于一个合法的位置：arr[0]~arr[size-1]，则通过value返回对应元素，返回值为true；否则不改变value的值，返回false
• bool put(int value)：向迭代器指向的元素存放值value。如果迭代器位于一个合法的位置：arr[0]~arr[size-1]，则将对应数组元素的值更新为value，返回true；否则不改变任何值，返回false

//下列代码中iter.get(v)获取的应该是ma.arr[0]的值
MyArray ma(10);
MyArray::Iterator iter = ma.begin();
iter.put(20); // true, set ma.arr[0]=20
int v = -1;
iter.get(v); // true, v=20

为了使迭代器更加方便使用，我们需要为其重载一些操作符，它们的含义如下：

• operator++: 将迭代器指向数组中下一个相邻元素(考虑前置和后置)
• operator–: 将迭代器指向数组中上一个相邻元素(考虑前置和后置)
• operator==: 判断两个迭代器是否指向同一个位置（元素）
• operator!=: 与上一个操作符相反的语义
• operator+(int len): 将迭代器移动到当前元素向后的第len个元素
• operator-(int len): 将迭代器移动到当前元素向前的第len个元素

添加相应的构造和析构函数。当MyArray对象析构后，它的迭代器执行put和get函数时返回值为false。

迭代器的功能实现切片

类成员和成员函数

在Iterator的构造函数中传入MyArray的成员，实现了迭代器对MyArray的访问。同时，如果MyArray调用析构函数，则size = 0通过指针传给Iterator，使得迭代器调用put和get函数返回false。

class MyArray{
  int * arr;
  int size;
public:
  class Iterator{
    int* iter;
    int temp_position;
    int* array_size;
  public:
    Iterator(int* arr, int n,int* size);
    int* begin();
    int* end();
    bool get(int & value) const;
    bool put(int value);
    Iterator& operator ++ ();
    const Iterator operator ++(int);
    Iterator& operator --();
    const Iterator operator --(int);
    bool operator ==(const Iterator& iter2) const;
    bool operator != (const Iterator& iter2) const;
    Iterator operator + (int len);
    Iterator operator - (int len);
  };

public:
  MyArray(int sz);
  ~MyArray();
  Iterator begin();
  Iterator end();
};

接口Iterator begin()和Iterator end()

Iterator begin(){
    Iterator it(arr, 0, &size);
    return it;
}
Iterator end(){
    Iterator it(arr, size, &size);
    return it;
}

接口bool get(int &value)和bool put(int value)

bool MyArray::Iterator::get(int& value) const{
  if(temp_position < 0 || temp_position >= *array_size)
    return false;
  value = *iter;
  return true;
}

bool MyArray::Iterator::put(int value){
  if(temp_position < 0 || temp_position >= *array_size)
    return false;
  *iter = value;
  return true;
}

操作符重载

注意到operator++/–前置和后置具有不同语义。

Iterator& operator ++ (){
  iter = iter + 1;
    temp_position ++;
    return *this;
}
const Iterator operator ++(int){
    Iterator temp = *this;
    ++(*this);
    return temp;
}
Iterator& operator --(){
  iter = iter - 1;
  temp_position --;
  return *this;
}
const Iterator operator --(int){
  Iterator temp = *this;
  --(*this);
  return temp;
}
bool operator ==(const Iterator& iter2) const{
  return iter2.iter == iter;
}
bool operator != (const Iterator& iter2) const{
  return iter2.iter != iter;
}
Iterator operator + (int len){
  int* arr = iter-temp_position;
  Iterator new_iter(arr, temp_position+len, array_size);
  return new_iter;
}
Iterator operator - (int len){
  int* arr = iter-temp_position;
  Iterator new_iter(arr, temp_position-len, array_size);
  return new_iter;
}

整体代码实现

#include<iostream>
using namespace std;

class MyArray{
  int * arr;
  int size;
public:
  class Iterator{
    int* iter;
    int temp_position;
    int* array_size;
  public:
    Iterator(int* arr, int n,int* size);
    int* begin();
    int* end();
    bool get(int & value) const;
    bool put(int value);
    Iterator& operator ++ (){
      iter = iter + 1;
      temp_position ++;
      return *this;
    }
    const Iterator operator ++(int){
      Iterator temp = *this;
      ++(*this);
      return temp;
    }
    Iterator& operator --(){
      iter = iter - 1;
      temp_position --;
      return *this;
    }
    const Iterator operator --(int){
      Iterator temp = *this;
      --(*this);
      return temp;
    }
    bool operator ==(const Iterator& iter2) const{
      return iter2.iter == iter;
    }
    bool operator != (const Iterator& iter2) const{
      return iter2.iter != iter;
    }
    Iterator operator + (int len){
      int* arr = iter-temp_position;
      Iterator new_iter(arr, temp_position+len, array_size);
      return new_iter;
    }
    Iterator operator - (int len){
      int* arr = iter-temp_position;
      Iterator new_iter(arr, temp_position-len, array_size);
      return new_iter;
    }
  };

public:
  MyArray(int sz);
  ~MyArray();
  Iterator begin(){
    Iterator it(arr, 0, &size);
    return it;
  };
  Iterator end(){
    Iterator it(arr, size, &size);
    return it;
  };

};

MyArray::MyArray(int sz){
  size = sz;
  arr = new int[sz];
}

MyArray::~MyArray(){
  delete []arr;
  size = 0;
}

MyArray::Iterator::Iterator(int* arr, int n, int* size){
  iter = arr + n;
  temp_position = n;
  array_size = size;
}

bool MyArray::Iterator::get(int& value) const{
  if(temp_position < 0 || temp_position >= *array_size)
    return false;
  value = *iter;
  return true;
}

bool MyArray::Iterator::put(int value){
  if(temp_position < 0 || temp_position >= *array_size)
    return false;
  *iter = value;
  return true;
}
/*测试样例
int main(){
  MyArray ma(10);
  for(MyArray::Iterator iter = ma.begin(); iter != ma.end(); iter ++){
    int v;
    cin >> v;
    iter.put(v);
  }
  for(MyArray::Iterator iter = ma.begin(); iter != ma.end(); iter = iter + 1){
    int v;
    iter.get(v);
    cout << v << " ";
  }
  cout << endl;
  system("pause");
  return 0;
}*/