Velocity Reviews

Velocity Reviews (http://www.velocityreviews.com/forums/index.php)
-   C++ (http://www.velocityreviews.com/forums/f39-c.html)
-   -   vector.swap and heap / stack (http://www.velocityreviews.com/forums/t276928-vector-swap-and-heap-stack.html)

Steve Hill 08-20-2003 02:31 PM

vector.swap and heap / stack
 
Hi,
suppose I have a vector allocated on the heap. Can I use a temporary
(stack based vector) and swap to clear it, or is this unsafe. e.g.

vector<int> *v;
vector<int> tmp;
v->swap(tmp); // is this an unsafe transfer between heap and stack
// or does the allocator handle it safely?


regards,
steve

Ivan Vecerina 08-20-2003 03:00 PM

Re: vector.swap and heap / stack
 
"Steve Hill" <stephen.hill@motorola.com> wrote in message
news:c230c758.0308200631.1c19b673@posting.google.c om...
| suppose I have a vector allocated on the heap. Can I use a temporary
| (stack based vector) and swap to clear it, or is this unsafe. e.g.
|
| vector<int> *v;
| vector<int> tmp;
| v->swap(tmp); // is this an unsafe transfer between heap and stack
| // or does the allocator handle it safely?

It is safe.
You could write:
void clearV(vector<int>& c)
{ vector<int>().swap(c); }

And call it with various instances:

auto_ptr<vector<int> > p = new vector<int>(4,5);
clearV( *p );

vector<int> l(4,5);
clearV( l );

static vector<int> s(4,5);
clearV( s );

All is safe and sound...

hth
--
http://www.post1.com/~ivec



Ivan Vecerina 08-20-2003 10:33 PM

Re: vector.swap and heap / stack
 
"Mike Wahler" <mkwahler@mkwahler.net> wrote in message
news:WIQ0b.1262$lw4.1040@newsread3.news.pas.earthl ink.net...
> Yes, this is safe. But note that you needn't define
> 'tmp', you could use a temporary expression:
>
> v->swap(std::vector<int>());


This line is actually illegal in standard C++, unlike:
std::vector<int>().swap(*v); // this is ok

A temporary can only be bound to a *const* reference,
while the parameter of swap is a non-const reference.
(MSVC typically supports the line you posted as an
extension of the language, but it is non-standard).

> BTW, why not just use the 'clear()' member function:
>
> v->clear();


Because clear does not free the memory allocated by *v,
while using the swap trick typically will (although
the standard does not formally guarantee this).


Regards,
Ivan
--
http://www.post1.com/~ivec



Ivan Vecerina 08-20-2003 11:37 PM

Re: vector.swap and heap / stack
 
"Mike Wahler" <mkwahler@mkwahler.net> wrote in message
news:Y2T0b.1396$lw4.833@newsread3.news.pas.earthli nk.net...
> > > v->swap(std::vector<int>());

> >
> > This line is actually illegal in standard C++, unlike:
> > std::vector<int>().swap(*v); // this is ok

>
> Actually, I didn't mean either one.
>
> I meant:
>
> std::swap(*v, std::vector<int>());


Note that this illegal, for the same reason as the
first example ( v->swap(std::vector<int>()) ).
std::vector<int>() is a temporary, and both of the swap
calls you suggested expect a non-const reference as a
first parameter.
This is unlike the valid option:
std::vector<int>().swap(*v); // this is ok
Here swap is invoked as a member function of the
temporary, which is legal ISO C++.

> > > BTW, why not just use the 'clear()' member function:
> > >
> > > v->clear();

> >
> > Because clear does not free the memory allocated by *v,

>
> AFAIK, it *will* free the memory occupied by
> its elements (assuming of course that if the
> elements are UDT's which manage memory, they do so
> correctly).


The standard mandates that v.clear() is equivalent to
calling v.erase( v.begin(), v.end() ) -- in 23.1.1.
The erase function does not cause the vector's memory
to be reallocated (or freed). Its effect is to (23.2.4.3)
invalidate "all the iterators and references *after* the
point of the erase". Which means that the iterator
returned by v.begin() shall not be invalidated by the
call to v.clear().
Basically, clear() will set the *size* of a vector to 0,
but will leave the *capacity* of the vector unchanged.
The memory block that std::vector has allocated to
store its contents will not be freed.

> > while using the swap trick typically will (although
> > the standard does not formally guarantee this).

>
> Can you elaborate, please?


v1.swap(v2) will exchange the memory blocks that are
associated with the two vectors. This is typically done
by swapping the pointers stored within each vector.

When using: std::vector<int>().swap(*v);
std::vector<int>() typically does not allocate any
memory (its capacity is zero). After the memory blocks
are exchanged, v will receive the block of capacity 0,
and the temporary owns the memory previously associated
with v -- which will be released by the temporary's
destructor.

Well, I hope this is not too confused... it's getting
late here.

Sincerely,
Ivan
--
http://www.post1.com/~ivec



Ivan Vecerina 08-22-2003 03:53 PM

Re: vector.swap and heap / stack
 
"tom_usenet" <tom_usenet@hotmail.com> wrote in message
news:3f44ae5d.9544609@news.easynet.co.uk...
| On Thu, 21 Aug 2003 01:37:01 +0200, "Ivan Vecerina"
| <ivecATmyrealboxDOTcom> wrote:
|
| >The standard mandates that v.clear() is equivalent to
| >calling v.erase( v.begin(), v.end() ) -- in 23.1.1.
| >The erase function does not cause the vector's memory
| >to be reallocated (or freed). Its effect is to (23.2.4.3)
| >invalidate "all the iterators and references *after* the
| >point of the erase". Which means that the iterator
| >returned by v.begin() shall not be invalidated by the
| >call to v.clear().
|
| It certainly shall! erase invalidates iterators to erased elements, as
| well as iterators to elements after the erase.

From my reading of the standard (see the *after* above),
I believe that the following is legal code:

void deleteOddValues(std::vector<int>& v)
{
std::vector<int>::iterator scan = v.begin();
while( scan != v.end() )
if( *s % 2 ) v.erase(scan);
else ++scan;
}

The iterator from which the erasing starts remains valid
(although it must not be dereferenced if it now equals end()).

By extension, the following should also be ok:
std::vector<int>::iterator b = v.begin();
v.clear();
assert( b == v.end() && b == v.begin() );

Therefore, v.clear() cannot free the memory occupied by
the vector (the allocator's interface doesn't support
in-place shrinking of allocated memory).
And the std::vector<int>().swap(v) trick has its place...


Kind regards,
Ivan
--
http://www.post1.com/~ivec





tom_usenet 08-22-2003 04:51 PM

Re: vector.swap and heap / stack
 
On Fri, 22 Aug 2003 17:53:44 +0200, "Ivan Vecerina"
<ivec@myrealbox.com> wrote:

>| It certainly shall! erase invalidates iterators to erased elements, as
>| well as iterators to elements after the erase.
>
>From my reading of the standard (see the *after* above),
>I believe that the following is legal code:
>
> void deleteOddValues(std::vector<int>& v)
> {
> std::vector<int>::iterator scan = v.begin();
> while( scan != v.end() )
> if( *s % 2 ) v.erase(scan);
> else ++scan;
> }
>
>The iterator from which the erasing starts remains valid
>(although it must not be dereferenced if it now equals end()).
>
>By extension, the following should also be ok:
> std::vector<int>::iterator b = v.begin();
> v.clear();
> assert( b == v.end() && b == v.begin() );
>
>Therefore, v.clear() cannot free the memory occupied by
>the vector (the allocator's interface doesn't support
>in-place shrinking of allocated memory).
>And the std::vector<int>().swap(v) trick has its place...


Apologies, you're correct according to the standard, if not according
to my expectations (although they have now been updated).

Tom


All times are GMT. The time now is 07:23 PM.

Powered by vBulletin®. Copyright ©2000 - 2014, vBulletin Solutions, Inc.
SEO by vBSEO ©2010, Crawlability, Inc.