A question about std::lists

[JustSomeGuy]

I have a method which traverses a list and then clears it.
I was optimizing it and broke it.

series *Ser;
series::iterator im_it;

for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
img = *im_it;
...
}
Ser->clear();

vs. (Which dies a horrible death on the last element.)

for (im_it=Ser->begin(); im_it != Ser->end(); Ser->pop_front())
{
img = *im_it;
...
}

[Ben Pope]

JustSomeGuy wrote:

I have a method which traverses a list and then clears it.
I was optimizing it and broke it.

series *Ser;
series::iterator im_it;

for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
img = *im_it;
...
}
Ser->clear();

vs. (Which dies a horrible death on the last element.)

for (im_it=Ser->begin(); im_it != Ser->end(); Ser->pop_front())
{
img = *im_it;
...
}

I can't see how thats an optimisation.

Presumably you still have to increment your iterator somewhere.

Perhaps you should use the dereferenced iterator, rather than copying it when you do:

img = *im_it;

I fail to see why you would copy it, but then, I fail to see most of your code, also.

Ben
--
I'm not just a number. To many, I'm known as a String...

[Victor Bazarov]

JustSomeGuy wrote:

I have a method which traverses a list and then clears it.
I was optimizing it and broke it.

series *Ser;
series::iterator im_it;

for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
img = *im_it;
...
}
Ser->clear();

vs. (Which dies a horrible death on the last element.)

for (im_it=Ser->begin(); im_it != Ser->end(); Ser->pop_front())
{
img = *im_it;
Shouldn't this be

img = *im_it++;

?
...
}

Since you posted a mock-up instead of the actual code, there is
no way to tell what the reason for undefined behaviour was.

V

[Andre Kostur]

"JustSomeGuy" <bo*******@yahoo.com> wrote in
news:11**********************@g49g2000cwa.googlegr oups.com:

I have a method which traverses a list and then clears it.
I was optimizing it and broke it.

series *Ser;
series::iterator im_it;

for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
img = *im_it;
...
}
Ser->clear();

vs. (Which dies a horrible death on the last element.)

for (im_it=Ser->begin(); im_it != Ser->end(); Ser->pop_front())
{
img = *im_it;
...
}

I'm somewhat surprised that it didn't blow up on the first element.
You've invoked undefined behaviour by destroying the object that the
iterator refers to. Let's rewrite your for loop to its equivalent while
loop:

im_it=Ser->begin();

while (im_it != Ser->end())
{
img = *im_it;
...
Ser->pop_front();
}
So, before pop_front is called, im_it is an iterator to the first element
in the list. After calling pop_front, that iterator is now invalidated.
Attempting to use it for anything is undefined behaviour.

Probably a better optimization would be:

while (!Ser->emtpy())
{
img = Ser->front();
...
Ser->pop_front();
}

[JustSomeGuy]

I wanted to free up the memory as soon as possible...

[Greg]

Andre Kostur wrote:

"JustSomeGuy" <bo*******@yahoo.com> wrote in
news:11**********************@g49g2000cwa.googlegr oups.com:

I have a method which traverses a list and then clears it.
I was optimizing it and broke it.

series *Ser;
series::iterator im_it;

for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
img = *im_it;
...
}
Ser->clear();

vs. (Which dies a horrible death on the last element.)

for (im_it=Ser->begin(); im_it != Ser->end(); Ser->pop_front())
{
img = *im_it;
...
}

I'm somewhat surprised that it didn't blow up on the first element.
You've invoked undefined behaviour by destroying the object that the
iterator refers to. Let's rewrite your for loop to its equivalent while
loop:

im_it=Ser->begin();

while (im_it != Ser->end())
{
img = *im_it;
...
Ser->pop_front();
}
So, before pop_front is called, im_it is an iterator to the first element
in the list. After calling pop_front, that iterator is now invalidated.
Attempting to use it for anything is undefined behaviour.

Probably a better optimization would be:

while (!Ser->emtpy())
{
img = Ser->front();
...
Ser->pop_front();
}

I think calling Ser->clear() in the first place and forgetting about
the loop would be an even better optimization.

What exactly is the contribution that this loop is making to the
program?

Greg

[Andre Kostur]

"Greg" <gr****@pacbell.net> wrote in
news:11*********************@o13g2000cwo.googlegro ups.com:

Andre Kostur wrote:

"JustSomeGuy" <bo*******@yahoo.com> wrote in
news:11**********************@g49g2000cwa.googlegr oups.com:

> I have a method which traverses a list and then clears it.
> I was optimizing it and broke it.
>
> series *Ser;
> series::iterator im_it;
>
> for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
> {
> img = *im_it;
> ...
> }
> Ser->clear();
>
> vs. (Which dies a horrible death on the last element.)
>
> for (im_it=Ser->begin(); im_it != Ser->end(); Ser->pop_front())
> {
> img = *im_it;
> ...
> }

I'm somewhat surprised that it didn't blow up on the first element.
You've invoked undefined behaviour by destroying the object that the
iterator refers to. Let's rewrite your for loop to its equivalent
while loop:

im_it=Ser->begin();

while (im_it != Ser->end())
{
img = *im_it;
...
Ser->pop_front();
}
So, before pop_front is called, im_it is an iterator to the first
element in the list. After calling pop_front, that iterator is now
invalidated. Attempting to use it for anything is undefined
behaviour.

Probably a better optimization would be:

while (!Ser->emtpy())
{
img = Ser->front();
...
Ser->pop_front();
}

I think calling Ser->clear() in the first place and forgetting about
the loop would be an even better optimization.

What exactly is the contribution that this loop is making to the
program?

Beats me. However, I think correcting the misusage of the iterator was
worth correcting. (I probably should have quoted the word "optimization")