CODEWITHSUNDEEP
c++for-loopforeachiterator
gator
gator

Reputation: 3523

Foreach loops and arrow/dot operator difference?

I have a class Point which has a member method to get position:

class Point {
    private:
        int x; int y;
    public:
        Point(int a, int b) {
            x = a; y = b;
        }
        int getX() { return x; }
        int getY() { return y; }
};

These are stored in a list<Point> named listPoints. I have a function which checks whether a position matches any of the points in the list:

bool checkMatch(int x, int y) {
    for (Point p : listPoints) {
        if (p.getX() == x && p.getY() == y) {
            return true;
        }
    }
    return false;
}

Note the . is used to access member methods of Point, but there's another way:

bool checkMatch(int x, int y) {
    list<Point>::iterator p = listPoints.begin();
    for (; p != listPoints.end(); ++p) {
        if (p->getX() == x && p->getY() == y) {
            return true;
        }
    }
    return false;
}

What is this function doing differently to the one before, specifically why does . no longer work and I need to use -> instead to access member methods of Point? Are these foreach loops fundamentally different?

Upvotes: 0

Views: 288

Answers (2)

R Sahu
R Sahu

Reputation: 206607

Are these foreach loops fundamentally different?

They are not fundmentally different. They are subtly different.

It's analogous to:

int a;
int* ptr = &a;

a = 10;
*ptr = 10;

The last two lines are not fundmentally different. An iterator is kinda like a pointer. Its operator* is overloaded such that using *p acts as though you are dereferencing a pointer -- you get a reference to an item in the container.

The second block of code can be changed a bit to resemble the first one.

list<Point>::iterator iter = listPoints.begin();
for (; iter != listPoints.end(); ++iter) {
    Point& p = *iter;
    if (p.getX() == x && p.getY() == y) {
        return true;
    }
}

Under the covers, the first block is exactly that.

See the documentation on the range-for loop in the standard for the details.

Upvotes: 1

Tas
Tas

Reputation: 7111

They're not different no, with some very minor exceptions. In the second loop, you're using an iterator, which is more-or-less a pointer to the object itself. It can be dereferenced to get the actual object.

You'd use iterators if you wanted to remove some elements. So say instead of checking for matches, you were removing anything that matched, you'd want to iterate with iterators.

Since you are just iterating over the entire range, it's far clearer to use your for-ranged loop. It's easier to write and clearer.

specifically why does . no longer work and I need to use -> instead to access member methods of Point?

Because the iterator is an object, which basically points to the actual object. You cannot override the dot operator, so instead operator-> is overridden to retrieve the object. One could also dereference the iterator like *p, which allows you to use the dot operator (*p).getX()

Upvotes: 1

Related Questions