vector<Object*> objects;
// deleting
for_each(objects.begin(), objects.end(), boost::checked_deleter<Object>());
objects.clear();
template<class K, class V>
struct checked_deleter_pair
{
void operator()(std::pair<K, V*> x) const
{
boost::checked_delete(x.second);
}
};
Quote:Original post by SiCrane
Just use a smart pointer. Then the cleanup becomes just using the container's destructor. Can't get very much more general than that.
Quote:Original post by LizardCPP
Yeah I should probably just do that. I was just thinking that I could forward declare the pointer type, which I can't if I use shared_ptr.
Quote:Original post by SneftelQuote:Original post by LizardCPP
Yeah I should probably just do that. I was just thinking that I could forward declare the pointer type, which I can't if I use shared_ptr.
Sure you can. On any modern compiler, anyway.
map<int, shared_ptr<Object> > objects;Quote:Original post by LizardCPP
I was just thinking that I could forward declare the pointer type, which I can't if I use shared_ptr.
#ifndef ENTITYPTR_HPP#define ENTITYPTR_HPP// C++ standard library includes:// Boost includes:#include <boost/shared_ptr.hpp>// 3rd-party includes:// Project includes:typedef boost::shared_ptr<class Entity> EntityPtr;#endif // #ifndef ENTITYPTR_HPP#include <newton.h>class NewtonBodyDeleter{public: NewtonBodyDeleter(shared_ptr<const NewtonWorld> const& world) : m_world(world) { } void operator()(NewtonBody * body) { NewtonDeleteBody(m_world.get(), body); } shared_ptr<const NewtonWorld> m_world;};shared_ptr<NewtonBody> MakeNewtonBody(shared_ptr<const NewtonWorld> const& world, shared_ptr<const NewtonCollision> const& collision){ NewtonBody * body = NewtonCreateBody(world.get(), collision.get()); return shared_ptr(body, NewtonBodyDeleter(world));}Quote:Original post by Sneftel
Bingo: the NewtonBody will delete itself at the appropriate time, and will keep the World alive while it exists. Neat, huh?
