自己写一个类支持迭代器功能

template<typename T, int n>		//带"非类型"的模板参数
class Array
{
private:
    T* arr;
    int capcity;	//容量: 数组中可容纳的最大的元素个数
    int size;		//数组中实际的元素个数

public:
    //构造函数 
    Array() : arr(nullptr), capcity(n), size(0)
    {
        if (capcity > 0)
        {
            arr = new T[capcity];
        }
    }

    //拷贝构造函数 
    Array(const Array<T, n>& a) : arr(nullptr), capcity(a.capcity), size(a.size)
    {
        if (capcity > 0)
        {
            //先分配空间 
            arr = new T[capcity];

            //再 拷贝 
            int i;
            for (i = 0; i < size; i++)
            {
                (*this)[i] = a[i];
            }
        }
    }

    //析构函数 
    ~Array()
    {
        if (arr)
        {
            delete[] arr;
        }
    }

    // []下标运算符重载 
    T& operator[](const int& i)
    {
        if (i >= 0 && i < size)
        {
            return arr[i];
        }
    }

    const T& operator[](const int& i) const
    {
        if (i >= 0 && i < size)
        {
            return arr[i];
        }
    }

    //往数组的末尾插入一个元素
    bool insert(const T& d)
    {
        if (size >= capcity)
        {
            return false;
        }

        arr[size++] = d;

        return true;
    }

    //返回数组实际的元素个数
    int length(void) const
    {
        return size;
    }


    // << 输出运算符重载 
    template<typename T1, int n1>
    friend ostream& operator<<(ostream& o, const Array<T1, n1>& a);


    //数组Array的 "迭代器的类", 该类的对象 用来遍历Array数组的元素
    class ArrayIterator
    {
    private:
        T* _arr;		//执行"遍历范围"的首元素/首地址
        int _size;		//遍历的范围内的元素个数 
        // 遍历范围 [arr, arr+_size)
        int index;		//指定遍历范围内 当前元素的下标
    public:
        ArrayIterator(T* _start, int _s) : _arr(_start), _size(_s), index(0)
        {}

        //begin
        void begin(void)
        {
            index = 0;
        }

        //返回当前元素(指向元素)的引用
        T& operator*(void)
        {
            return _arr[index];
        }

        // ++ 
        ArrayIterator& operator++()
        {
            index++;
            return *this;
        }

        // is_end 
        bool is_end(void)
        {
            return index == _size;
        }

    };

    // 用来获取 Array这个类对象的 迭代器
    ArrayIterator get_Iterator(void)
    {
        ArrayIterator it(arr, size);
        return it;
    }

    // 用来获取 Array这个类对象的 迭代器
    ArrayIterator get_Iterator(const int& first, const int& num)
    {
        ArrayIterator it(arr + first, num);
        return it;
    }


};

// << 输出运算符重载 
template<typename T, int n>
ostream& operator<<(ostream& o, const Array<T, n>& a)
{
    int i;
    for (i = 0; i < a.length(); i++)
    {
        o << a[i] << "  ";
    }
    o << endl;

    return o;
}

int main()
{
    Array<int, 10> a;       // int a[5];

    a.insert(1);
    a.insert(3);
    a.insert(5);
    a.insert(7);
    a.insert(9);
    a.insert(11);
    a.insert(13);

    cout << a << endl;
    cout << "--------------------" << endl;

    //使用迭代器来遍历 
    //Array<int, 10>::ArrayIterator it = a.get_Iterator();
    auto it = a.get_Iterator();

    //对象it 就是数组a 的迭代器对象
    // 通过it这个迭代器对象,用来遍历数组a 的元素
        // ++it  // 让it"指向"写一个元素
        // *it   // 返回当前元素的引用(it当前指向的那个元素)

    for (it.begin(); !it.is_end(); ++it)
    {
        cout << *it << "  ";
    }
    cout << endl;
	//1 3 5 7 9 11 13
	
	Array<int, 10>::ArrayIterator itr = a.get_Iterator(1,6);
	for (itr.begin(); !itr.is_end(); ++itr)
	{
	    cout << *itr << "  ";
	}
	cout << endl;
	3 5 7 9 11 13
}

这个程序实现了一个泛型动态数组类`Array`，其中包含一个嵌套的迭代器类`ArrayIterator`，
用于遍历数组元素。这个类模板有两个参数：`T`表示数组元素的类型，而`n`是一个非类型的模板
参数，代表数组的最大容量。下面是对主要部分的详细解释：

Array类

• 构造函数：初始化数组，根据给定的最大容量n分配内存，并设置size为0，因为此时数组为空。

• 拷贝构造函数：当创建一个新数组作为已有数组的副本时，会重新分配内存并复制所有元素。

• 析构函数：释放由数组管理的动态内存，防止内存泄漏。

• 下标运算符重载：提供了读取和修改数组元素的能力，同时检查索引是否越界。

• insert方法：尝试在数组末尾添加一个元素，如果数组未满则成功插入并返回true，否则返回false。

• length方法：返回数组的实际元素数量。

• 输出运算符重载友元函数：以格式化的形式输出数组的所有元素。

• ArrayIterator嵌套类：定义了一个迭代器类，用于遍历Array中的元素。

  • _arr：指向当前迭代范围起始位置的指针。
  • _size：当前迭代范围内的元素数量。
  • index：当前迭代位置的索引。

  这个迭代器提供了：

  • begin方法：重置迭代器到范围的开始。
  • operator*：返回当前迭代位置元素的引用。
  • operator++：向前移动迭代器到下一个元素。
  • is_end：检查是否已经到达迭代范围的末尾。

• get_Iterator方法：提供两种方式获取迭代器，一种是从头开始遍历整个数组，另一种是指定范围内的遍历。

主函数中的示例用法

在main函数中，首先创建了一个最大容量为10的整数数组Array<int, 10> a，然后插入一些元素，并通过标准输出操作符打印数组内容。接着，通过调用get_Iterator方法获取迭代器，并利用这个迭代器遍历数组元素，展示如何使用迭代器进行数组遍历。

这个设计展示了泛型编程、资源管理（动态内存分配与释放）、操作符重载以及迭代器模式在C++中的应用，既灵活又高效，同时也遵循了RAII（Resource Acquisition Is Initialization）原则来管理资源。