Не найдена соответствующая функция "begin"

#include <iostream>
 
struct Point {
    int x, y;
};
 
struct Rect {
    int x1, y1, x2, y2;
};
 
void process_point(Point pt) {
    // для отладки -- самый удобный вариант "обработки точки"
    std::cout << "(" << pt.x << "," << pt.y << ") ";
};
 
 
Rect get_work_rect()
{
    return { 2, 2, 6, 4 };
};
 
void Foo() {
    Rect r = get_work_rect();
 
    for (int y = r.y1; y < r.y2; ++y)
        for (int x = r.x1; x < r.x2; ++x) {
            process_point(Point{ x, y });
        }
 
    for (auto p : r) {
        process_point(p);
    }
}
 
int main() 
{
    Foo();
    return 0;
}

 
struct Rect {
    Point a, b, c, d;
};

struct Rect {
    Point a, b, c, d;
};
   for (auto & p : {r.a, r.b, r.c, r.d}) {
        process_point(p);
    }

struct Rect {
    Point a, b, c, d;
    operator std::array<Point,4>() const { return {a, b, c, d};}
};

    Rect r;
 
// .........
 
 for (auto p : static_cast<std::array<Point,4>>(r)) {
        process_point(p);
    }

struct Point { 
int x, y; 
};
 
struct Rect { 
int x1, y1, x2, y2; 
};

void process_point( Point pt )
{
  std::cout << "(" << pt.x << "," << pt.y << ") ";
}

for ( int y = r.y1; y < r.y2; ++y )
for ( int x = r.x1; x < r.x2; ++x )
{
    process_point( Point{x,y} );
}

Rect r = get_work_rect();
 
for ( auto p : r )
{
    process_point( p );
}

Rect get_work_rect()
{
    return { 2,2,6,4 };
}

#include <iostream>
 
struct Point
{
    int x{}, y{};
 
    friend bool operator==(const Point& l, const Point& r)
    {
        return l.x==r.x && l.y==r.y;
    }
    friend bool operator!=(const Point& l, const Point& r)
    {
        return !(l==r);
    }
    
    friend std::ostream& operator<<(std::ostream& os, const Point& p)
    {
        os<<"x="<<p.x<<", y="<<p.y<<'\n';
        return os;
    }
};
 
struct Rect
{
    Point lt, rb;
    
    struct iterator
    {
        Rect* parent;
        Point p;
        
        friend bool operator!=(const iterator& l, const iterator& r)
        {
            return l.p!=r.p;
        }
        
        iterator& operator++()
        {
            if(p.x!=parent->rb.x)
            {
                p.x++;
            }
            else
            {
                p.x=parent->lt.x;
                if(p.y!=parent->rb.y)
                {
                    p.y++;
                }
                else
                {
                    *this=parent->end();
                }
            }
            return *this;
        }
        
        Point& operator*()
        {
            return p;
        }
    };
 
    iterator begin()
    {
        return iterator{this,lt.x,lt.y};
    }
    iterator end()
    {
        return iterator{this,rb.x+1,rb.y+1};
    }
};
 
int main() 
{
    Rect r{{0,0},{4,5}};
    
    for (auto& p : r)
    {
        std::cout<<p;
    }
    
    return 0;
}