Using C++ iterators with arrays

Iterators are designed to provide access to container members, and they can be used in a way similar to pointer manipulation. For example, you can use an iterator to traverse all the elements of a vector. There are several different types of iterators.

Each container class is associated with an iterator type, and each of the STL algorithms uses a specific iterator type.

For example, vectors are associated with random-access iterators, so they can use algorithms that require random access. Since random-access iterators include all the properties of other iterators, vectors can also use algorithms written for other iterators.

The code in the example creates an iterator and uses it in the vector:

    vector<int> the_vector;
    vector<int>::iterator the_iterator;

    for( int i=0; i < 10; i++ ) 
       the_vector.push_back(i);
    int total = 0;
    the_iterator = the_vector.begin();
    while( the_iterator != the_vector.end() ) {
      total += *the_iterator;
      ++the_iterator;
    }

    cout << "Итого=" << total << endl;

You can access the container elements by dereferencing the iterator.

An array is a specific form of data storage. It differs in that we have a numeric index for each element. Moreover, this index is unique. Usually these indexes are integers from some minimum to some maximum with some fixed increment.

int a[100];

for (int i = 0; i < 100; i++)
{
    std::cout<<a[i]; //вывести на экран i-тый элемент массива
}

When the standard array starts to fail, you can make a special class that will overload the [] operator and will look like an array. But at the same time, the internal structure can be, for example, a linked list or something even more tricky. It all depends on the tasks.

Next, no one bothers to overload this operator so that it accepts, for example, a string. This is useful for creating dictionary-type data structures. The presence of numerical indexes is no longer necessary.

But at the same time, in any case, the problem arises of ensuring the possibility of element-by-element iteration of the elements of such an "array". That's where the iterator comes in. This is some kind of thing that knows how iterate through the elements. Again, we, as a user, do not care about the internal implementation. And from the developer's point of view, we can make it optimized for a specific task. There are different types of iterators: passive, active - depending on how they relate to the class for which they are used. This is all well written in Jeff Alger's book " C++.Programmer's Library", ed. Peter.

PS: as an array type in fresh compilers, I would recommend using template type std:: array.

Basically, an iterator is just an extended pointer concept, and all STL algorithms that work with iterators should work with pointers directly as well.:

#include <stdio.h>
#include <algorithm>

void go( int value )
{
    printf("%d\n", value);
}

int main()
{
    int a[5] = { 0, 1, 2, 3, 4 };
    std::for_each( &a[0], &a[5], &go );
    return 0;
}

class MyIterator;
class MyArray{
public:
    MyIterator* Iterate();  // возвращает пассивный итератор, index в 0.
    bool More(MyIterator*); // true если еще есть элементы, иначе - false
    int Next(MyIterator*);  // возвратим текущий элемент массива, index++
    ...
};
class MyIterator
{
     int index;  // здесь мы будем хранить номер текущего элемента
     // для конкретного итератора, т.к. итераторов мы можем завести много.
     ...
}

MyArray* collection = new MyArray(100);// сделаем-ка массив на 100 элементов,
// для этого конструктор коллекции должен принимать кол-во элементов
...
MyIterator* iter = collection->Iterate(); //сделаем итератор
... 
while (collection->More(iter)) // пока еще есть элементы
    std::cout<<collection->Next(iter)<<std::endl; // выведем текущий элемент.

It's crooked, but it sounds like it.

There is a cool book: "C++. Schildt programming techniques". there's about half devoted to iterators