Implement iterator

[afedorov]

I read somewhere that it is possible to implement an `iterator` through defining begin/end methods, so object can be used in the for loop:

for(const auto &item:myCoolObject){
//do something
}

could somebody share example?

[mbozzi]

constexpr int sz = 3;

class my_array 
{
  int data[sz] { 1, 2, 3 }; 

public:
  int const* begin() const { return data; } 
  int const* end() const { return begin() + sz; }
} array;

#include <iostream>

int main()
{
  for (auto const& elt: array) 
    std::cout << elt << '\n';   
}

There are various other ways to define the meaning of range-based for loops over a particular object. See https://en.cppreference.com/w/cpp/language/range-for

[afedorov]

Nice, thank you

[afedorov]

one more question.
If I have array of pointers will it be the same? For example int **data

[mbozzi]

If I have array of pointers will it be the same? For example int **data

You'll need to adjust begin and end to return a type which works as an iterator. Which could be int* const* or int** for const and non-const my_array values respectively.

#include <utility>
#include <iostream>

class my_array 
{
  int **data = nullptr, size = 0;
  
public:
  ~my_array() { delete[] data; }
  
  my_array& operator=(my_array const&) = delete;
  my_array(my_array const&) = delete;
  
  my_array& operator=(my_array&& other) noexcept
  {
    size = std::exchange(other.size, 0);
    data = std::exchange(other.data, nullptr);
    return *this;
  }
  my_array(my_array&& other) noexcept
  {
    *this = std::move(other);
  }
  
  explicit my_array(int s)
    : data{new int*[s] {}}, size(s)
  {}

  int* const* begin() const { return data; } 
  int* const* end()   const { return begin() + size; }
  int**       begin()       { return data; }
  int**       end()         { return begin() + size; }
};

int main()
{
  for (auto const& elt: my_array(3)) 
    std::cout << elt << '\n';   
}

[CodingKnight11]

I've seen some pretty weird ways of iteration in C++, as someone coming from Python.

Like the one from w3schools.

string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};
for(int i = 0; i < 4; i++) {
  cout << i << ": " << cars[i] << "\n";
}

It's a correct way obviously but they don't teach how iterate over something properly unlike this site (https://coderslegacy.com/c/c-strings/), which does.

int main() { 
     string str = "Hello";
     for(char& c : str) {
         cout << c << endl;
     }
}

[jonnin]

https://www.geeksforgeeks.org/introduction-iterators-c/

I like that site, it explains things in fairly simple and easy to understand ways, without a lot of nonsense.

[seeplus]

Note that there is a problem with the element deletion example.

// Deleting a element using iterators 
    for (i = v.begin(); i != v.end(); ++i) { 
        if (i == v.begin() + 1) { 
            i = v.erase(i); 
            // i now points to the element after the 
            // deleted element 
        } 
    } 

As the comment correctly states, after the .erase() i points to the element after the deleted element - which is what is needed to be compared with .end() for correct termination. But i is incremented in the for loop so now points one element past the element following the deletion. It 'works' in this example as there are following entries. But if the deleted element was the last element then i will be one past .end() so the for comparison test will never succeed to give an infinite loop.

A 'better' solution could be:

// Deleting an element using iterators 
    for (auto i = v.begin(); i != v.end(); )
        if (i == v.begin() + 1)    // test for deletion of element
            i = v.erase(i);        // i now points to the element after the deleted element
        else
            ++i;

where i is only incremented if the deletion test fails.

[ne555]

v.erase(v.begin()+1);
your code would remove all elements except the first (not just an element), would be similar to v.erase(v.begin()+1, v.end()); provided that the vector does hold enough elements.

the examples are awful, it's quite idiotic to use a loop there.

[seeplus]

True. I didn't study the original example carefully enough! I just saw that i was incremented after the .erase() which is usually not what is required - as the deletion test is usually on a value not a position. Ouch!!!

My suggestion would have been better for say removing all elements that had the value 2

// Deleting an element using iterators 
    for (auto i = v.begin(); i != v.end(); )
        if (*i == 2)                // test for deletion of element
            i = v.erase(i);         // i now points to the element after the deleted element
        else
            ++i;

I agree that the examples are awful and possibly hinder understanding rather than helping.

[mbozzi]

for (auto i = v.begin(); i != v.end(); )
        if (*i == 2)                // test for deletion of element
            i = v.erase(i);         // i now points to the element after the deleted element
        else
            ++i;

This code requires quadratic time and therefore represents a serious performance bug.

Instead, use
v.erase(std::remove(std::begin(v), std::end(v), 2), std::end(v));
Which requires linear time.