Re: Deleting items from an std::list , is this code correct?

On Apr 24, 2:43 pm, Chris Uzdavinis <cuz...@[EMAIL PROTECTED]
> wrote:
>
> The only code you have that is really unique to this problem is the
> test for whether the element should be erased or not.  Factor that out
> into its own inlined function object to be a simple predicate:
>
>   struct is_odd
>   {
>     bool operator()(int num) const { return num & 1; }
>   };
>
> Then rewrite delete_odd using standard library function remove_if
> which uses your predicate:
>
>   #include <algorithm>
>
>   void delete_odd(int_list_t & L)
>   {
>     // move the even elements to the front of the list
>     int_list_t::iterator logical_end =
>       std::remove_if(L.begin(), L.end(), is_odd());
>
>     // get rid of odd values that are now at the end of the list.
>     L.erase(logical_end, L.end());
>   }
>
> Note that remove_if doesn't really remove anything, but bubbles the
> keepers up to the front of the sequence, and puts the trash at the
> end, returning the logical end of the sequence.  Therefore, we erase
> the trash at the end from the logical end to the physical end with the
> call to erase on the list.

Calling std::remove_if() on a std::list can invalidate the list's
iterators (meaning that after the call to remove_if() - each iterator
in the list might no longer reference the same value bas it did before
the call). Since the appeal of working with stable iterators is often
one of the primary reasons for storing values in a std::list in the
first place - it would make sense to avoid calling those routines in
<algorithm> that invalidate iterators - and to call the comparable
std::list member functions instead.

So, instead of calling std::remove_if() in this case - and thereby
potentially invalidating the list's iterators - a better idea would be
to call std::list's own remove_if() member function and thereby
preserve the validity of any iterators that remain in the list after
the call:

     void delete_odd(int_list_t& L)
     {
         L.remove_if(isodd);
     }

This revised implementation of delete_odd() also has an advantage in
compactness - being only one-third the size of the original.

Greg



-- 
      [ See http://www.gotw.ca/resources/clcm.htm
for info about ]
      [ comp.lang.c++.moderated.    First time posters: Do this! ]