best way to "delete" all objects in a std::vector.

[Daniel Pitts]

I have std::vector<Bas e *bases;

I'd like to do something like:
std::for_each(b ases.begin(), bases.end(), operator delete);

Is it possible without writing an adapter? Is there a better way? Is
there an existing adapter?

Thanks,
Daniel.
--
Daniel Pitts' Tech Blog: <http://virtualinfinity .net/wordpress/>

[acehreli]

On Jun 3, 2:23 pm, Daniel Pitts
<newsgroup.spam fil...@virtuali nfinity.netwrot e:

I have std::vector<Bas e *bases;

I'd like to do something like:
std::for_each(b ases.begin(), bases.end(), operator delete);

Is it possible without writing an adapter? Is there a better way? Is
there an existing adapter?

Keeping plain pointers to dynamic objects is way too much trouble.
Smart pointers is the best way. boost::shared_p tr is suitable:

#include <boost/shared_prt.hpp>
/* ... */
typedef boost::shared_p tr<BaseBasePtr;
std::vector<Bas ePtrbases;

This and other problems magically vanish...

Ali

[jason.cipriani]

On Jun 3, 5:23 pm, Daniel Pitts
<newsgroup.spam fil...@virtuali nfinity.netwrot e:

I have std::vector<Bas e *bases;

I'd like to do something like:
std::for_each(b ases.begin(), bases.end(), operator delete);

Is it possible without writing an adapter? Is there a better way? Is
there an existing adapter?

What's wrong with:

for (std::vector<Ba se *>::iterator i = bases.begin(); i !=
bases.end(); ++ i)
delete *i;

It's only two lines; and it's clear what is happening. I don't think
you'll be able to beat that. If it's something you do frequently you
could write a utility function like:

template <class Tvoid delete_all (T &cont) {
typedef typename T::iterator iter_t;
for (iter_t i(cont.begin()) ; i != cont.end(); ++ i)
delete *i;
cont.clear();
}
Example:

struct A { ... };

void f () {

vector<A *x;
list<A *y;
set<A *z;

x.push_back(new A);
x.push_back(new A);
y.push_back(new A);
y.push_back(new A);
z.insert(new A);
z.insert(new A);

delete_all(x);
delete_all(y);
delete_all(z);

}
Jason

[William Xu]

Daniel Pitts <ne************ ******@virtuali nfinity.netwrit es:

I'd like to do something like:
std::for_each(b ases.begin(), bases.end(), operator delete);

Is it possible without writing an adapter? Is there a better way? Is
there an existing adapter?

Doesn't seem so... You'd better write your own my_delete:

template <class T>
struct my_delete : std::unary_func tion<T, void>
{
void operator()(T* t)
{
delete t;
}
};

This one:

std::for_each(b ases.begin(), bases.end(), std::ptr_fun(op erator delete));

compiles, but doesn't work(dtor is not called)...

--
William

http://williamxu.net9.org

Underdogging:
The tendency to almost invariably side with the underdog in a
given situation. The consumer expression of this trait is the
purchasing of less successful, "sad," or failing products: "I know
these Vienna franks are heart failure on a stick, but they were so sad
looking up against all the other yuppie food items that I just had to
buy them."
-- Douglas Coupland, "Generation X: Tales for an Accelerated
Culture"

[Daniel T.]

Daniel Pitts <ne************ ******@virtuali nfinity.netwrot e:

I have std::vector<Bas e *bases;

I'd like to do something like:
std::for_each(b ases.begin(), bases.end(), operator delete);

Is it possible without writing an adapter? Is there a better way? Is
there an existing adapter?

From Stroustrup's book.

struct Delete_ptr {
template<class TT* operator()(T* p) const { delete p; return 0; }
};

....

transform(s.beg in(),s.end(),s. begin(),Delete_ ptr());

[Jerry Coffin]

In article <48************ **********@news razor.net>,
ne************* *****@virtualin finity.net says...

I have std::vector<Bas e *bases;

I'd like to do something like:
std::for_each(b ases.begin(), bases.end(), operator delete);

Is it possible without writing an adapter? Is there a better way? Is
there an existing adapter?

Boost Pointer Container Library.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[James Kanze]

On Jun 4, 5:43 am, "Daniel T." <danie...@earth link.netwrote:

Daniel Pitts <newsgroup.spam fil...@virtuali nfinity.netwrot e:

I have std::vector<Bas e *bases;

I'd like to do something like:
std::for_each(b ases.begin(), bases.end(), operator delete);

Is it possible without writing an adapter? Is there a better
way? Is there an existing adapter?

From Stroustrup's book.

struct Delete_ptr {
template<class TT* operator()(T* p) const { delete p; return 0; }
};

...

transform(s.beg in(),s.end(),s. begin(),Delete_ ptr());

[To the original poster: ignore this: it is from an
obsessional nitpicker, only for expert nitpickers.]

Note that formally, the above still has undefined behavior,
since it leaves a deleted pointer in the container for a (very)
short time. The correct way of doing this would be:

struct Deleter
{
template< typename T >
void operator()( T*& p ) const
{
T* tmp = NULL ;
std::swap( p, tmp ) ;
delete tmp ;
}
} ;

...

std::for_each( s.begin(), s.end(), Deleter() ) ;

(Note that it even uses swap. Can't get much more in than
that.)

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[jason.cipriani]

On Jun 4, 7:25 am, James Kanze <james.ka...@gm ail.comwrote:

On Jun 4, 5:43 am, "Daniel T." <danie...@earth link.netwrote:

Daniel Pitts <newsgroup.spam fil...@virtuali nfinity.netwrot e:

I have std::vector<Bas e *bases;
I'd like to do something like:
std::for_each(b ases.begin(), bases.end(), operator delete);
Is it possible without writing an adapter? Is there a better
way? Is there an existing adapter?

From Stroustrup's book.
struct Delete_ptr {
template<class TT* operator()(T* p) const { delete p; return 0; }
};
...
transform(s.beg in(),s.end(),s. begin(),Delete_ ptr());

[To the original poster: ignore this: it is from an
obsessional nitpicker, only for expert nitpickers.]

Note that formally, the above still has undefined behavior,
since it leaves a deleted pointer in the container for a (very)
short time. The correct way of doing this would be:

What has undefined behavior? If you are talking about the transform
over all, or the () operator, neither are undefined. It is well-
defined that it leaves an invalid pointer in the container for a very
short time. What's undefined is if something attempts to dereference
that pointer during that time.

[James Kanze]

On Jun 4, 6:08 pm, "jason.cipri... @gmail.com"
<jason.cipri... @gmail.comwrote :

On Jun 4, 7:25 am, James Kanze <james.ka...@gm ail.comwrote:

On Jun 4, 5:43 am, "Daniel T." <danie...@earth link.netwrote:

Daniel Pitts <newsgroup.spam fil...@virtuali nfinity.netwrot e:
I have std::vector<Bas e *bases;
I'd like to do something like:
std::for_each(b ases.begin(), bases.end(), operator delete);
Is it possible without writing an adapter? Is there a better
way? Is there an existing adapter?
From Stroustrup's book.
struct Delete_ptr {
template<class TT* operator()(T* p) const { delete p; return 0; }
};
...
transform(s.beg in(),s.end(),s. begin(),Delete_ ptr());

[To the original poster: ignore this: it is from an
obsessional nitpicker, only for expert nitpickers.]

Note that formally, the above still has undefined behavior,
since it leaves a deleted pointer in the container for a (very)
short time. The correct way of doing this would be:

What has undefined behavior? If you are talking about the
transform over all, or the () operator, neither are undefined.
It is well- defined that it leaves an invalid pointer in the
container for a very short time. What's undefined is if
something attempts to dereference that pointer during that
time.

A pointer, after delete, may not even be read or copied (since
one of the effects of delete could be to render its value
"trapping") . Which means that it is not Copiable, and thus,
you've violated the requirements of the standard containers.

In practice, of course, there are very, very few implementations
where it might actually trap: to do so means 1) that the
hardware can trap on such pointers (Intels IA-32 is the only one
I know of where this might currently be a problem), 2) that the
library actually does free the memory in a way that unmaps it
(none that I know of do---they all keep the memory mapped to the
process for potential future use), 3) that the compiler actually
does the copy in such a way that might trap (I think some Intel
compilers do), and 4) that std::vector actually does try to copy
it. That last point is, of course, the ultimate guarantee;
std::vector will normally only copy anything if you try to
increase the size of the vector.

But the standard still says that all of the elements must be
copiable, even if there's no earthly reason for the vector to
copy.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Jerry Coffin]

In article <da************ *************** *@earthlink.vsr v-
sjc.supernews.n et>, da******@earthl ink.net says...

[ ... ]

The implementation I presented doesn't read or copy any pointers after
the delete. The object is deleted, then the pointer is assigned NULL. If
the code I presented is "technicall y undefined" then so is:

delete p;
p = NULL;

Not so. An item in a container is required to be copyable. _We_ all know
that in a vector, for example, the contents are only ever copied in
reaction to things YOU do, such as a push_back when it's used up all the
memory already reserved. Nonetheless, the standard requires that all
items in a collection _always_ be copyable and assignable, even if you
_don't_ do anything that would force copying of the contents while it's
not copyable. Of course, the same goes for assignment.

In your snippet above, p is (apparently) not in a container, so the
container requirements don't apply.

--
Later,
Jerry.

The universe is a figment of its own imagination.