[Solved] Clean memory allocation

// generic object base classclass CRefObject{public:  virtual ~CRefObject ();  virtual void update ();};// holds a reference to the pointers of all objects (all are the same type, CRefObject)class CPointerContainer{  // list of pointers is dynamically allocated, so it can have unlimited items  CRefObject ** pointer; // ** because array of pointers  int nPointers;public:  ~CPointerContainer ()  { // destroy all    for (int i; i<nPointers; ++i) delete pointer[];  }  add (CRefObject * ptr);  // won't bother adding insides of this function, basically it adds the given pointer to the container  remove (CRefObject * ptr); // again, won't include insides of this function.    							//It searches for the pointer in the list, and then deletes that pointer, setting it to null  clean (); // cleans up the container, slides upper pointers in the list down over null pointers  updateAll ()  { // this would be called in a main loop    for (int i; i<nPointers; ++i)    {      if (pointer != NULL) pointer->updt (); // a null pointer is null because it has been deleted    }  }} container;virtual void CRefObject:: update (){  // default update action when not specified} // allows derived classes to be cleaned, when the base class is destroyedvirtual CRefObject:: ~CRefObject (){  container.remove (this);}// a couple of derived devicesclass CDeviceA : public CRefObject{public:  ~CDeviceA () {};  void update () {/* do the update stuff for this device */};};class CDeviceB : public CRefObject{public:  ~CDeviceB () {};  void update () {/* do the update stuff for this device */};};// when I want to create a device I would call this function, which returns a pointer to that deviceCDeviceA * CreateDeviceA (){  CDeviceA * d;  d = new CDeviceA;  container.add (d);  return d;}CDeviceB * CreateDeviceB (){  CDeviceB * d;  d = new CDeviceB;  container.add (d);  return d;}// so in the main loop I can now do thisvoid run (){  CDeviceA * device;  device = CreateDeviceA ();  container.updateAll ();  delete device;}

std::vector<CRefObject *> updateList;updateList.push_back( new CDeviceA (/* device A params */) );//...while(running()){   std::for_each( updateList.begin(), updateList.end(), std::mem_fun(&CRefObject::update) );  //...  std::vector<CRefObject *>::iterator i = std::remove_if(updateList.begin(), updateList.end(), std::mem_fun(&CRefObject::dead);  std::for_each(i, updateList.end(), std::mem_fun(&CRefObject::deleteMe);  updateList.erase( i, updateList.end() );}std::for_each(updateList.being(), updateList.end(), std::mem_fun(&CRefObject::deleteMe);updateList.clear();

#include <vector>#include <algorithm>#include <functional>//----------------------------------------------------------------------------// Your device interfaceclass DeviceBase{	public:		DeviceBase(){};		virtual ~DeviceBase(){};		virtual void update () = 0; // << pure virtual means you HAVE to implement this (helps prevent typos like "Update()" from working)		virtual bool isDead() = 0;		void deleteMe() { delete this; }};//----------------------------------------------------------------------------static std::vector<DeviceBase *> updateList;static std::vector<DeviceBase *> removeList;//----------------------------------------------------------------------------// Adds it to the update listvoid AddForUpdate( DeviceBase *pDevice ){	updateList.push_back( pDevice );}//----------------------------------------------------------------------------// Flag it for later removal.// Don't outright remove it, incase this is called durring updatevoid FlagForRemove( DeviceBase *pDevice ){	removeList.push_back( pDevice );}//----------------------------------------------------------------------------// Check if it is in the remove listbool WasRemoved( const DeviceBase *pDevice ){	return std::find( removeList.begin(), removeList.end(), pDevice ) != removeList.end();}void RemoveDeleted( ){	std::vector<DeviceBase *>::iterator i;									// Iterator	i = std::remove_if(updateList.begin(), updateList.end(), WasRemoved );	// quickly moves all items that "WereRemoved" to the end of the list	updateList.erase( i, updateList.end() );								// quickly pops all items past i	removeList.clear();														// clear our "deleted already" list}//----------------------------------------------------------------------------// Clear out the listvoid ClearDevices(){	//_______________	// first kill all the stuff that was already deleted	RemoveDeleted();	//_______________	// now kill everything else	std::for_each(updateList.begin(), updateList.end(), std::mem_fun(&DeviceBase::deleteMe));	// destroy the objects	updateList.clear();	removeList.clear();}//----------------------------------------------------------------------------// Update loopvoid UpdateLoop( ){	//_______________	// first kill all the deleted stuff	RemoveDeleted();	//_______________	// Check for things that died	std::vector<DeviceBase *>::iterator i;									// Iterator	i = std::remove_if(updateList.begin(), updateList.end(), std::mem_fun(&DeviceBase::isDead));	std::for_each(i, updateList.end(), std::mem_fun(&DeviceBase::deleteMe));	updateList.erase( i, updateList.end() );	//_______________	// Now update	std::for_each( updateList.begin(), updateList.end(), std::mem_fun(&DeviceBase::update) );}//----------------------------------------------------------------------------// Inherited deviceclass DeviceA : public DeviceBase{	public:		DeviceA() : _dead( false )		{			AddForUpdate( this ); // add for update		}		virtual ~DeviceA()		{			FlagForRemove( this ); // add for remove		}		// virtual update function, so we don't have to know what type of device in the update loop		// but the right code gets called		virtual void update()		{			std::cout << "Device A Updating" << std::endl;		}		virtual bool isDead()		{			return _dead;		}	private:		bool _dead;};class DeviceB : public DeviceBase{	public:		DeviceB() : _dead( false )		{			AddForUpdate( this ); // add for update		}		virtual ~DeviceB()		{			FlagForRemove( this ); // add for remove		}		// virtual update function, so we don't have to know what type of device in the update loop		// but the right code gets called		virtual void update()		{			std::cout << "Device B Updating" << std::endl;		}		virtual bool isDead()		{			return _dead;		}	private:		bool _dead;};//--------------------------------------------------------------// Begin Test Func//--------------------------------------------------------------int main ( u32 argc, char *argv[] ){	//----------------------------------------------------------------------------	// create some devices	DeviceBase *newDevice1 = new DeviceA;	DeviceBase *newDevice2 = new DeviceA;	DeviceBase *newDevice3 = new DeviceB;	// Test the update loop	UpdateLoop();	// Delete one	delete newDevice1;	// Test again	UpdateLoop();	// Clear out everything	ClearDevices();	//----------------------------------------------------------------------------	return 0;}

#include <iostream>#include <vector>#include <algorithm>#include <functional>//----------------------------------------------------------------------------// BaseClass//----------------------------------------------------------------------------class BaseClass{	bool is_dead;public:	BaseClass ()		{ is_dead = false; }	virtual ~BaseClass () {};	virtual void Update () = 0;	bool IsDead () { return is_dead; }	void SetIsDead (bool d) { is_dead = d; }	void DeleteMe () { delete this; }};//----------------------------------------------------------------------------// MemManager//----------------------------------------------------------------------------class MemManager // memory manager{	typedef std::vector<BaseClass *> ClassContainer; // pointer array	ClassContainer updateList, // items that will be updated								 removeList; // items that are to be removedpublic:	MemManager () {}	~MemManager ()		{ ClearAll (); }	void AddForUpdate ( DeviceBase * p_device );	void FlagForRemove ( DeviceBase * p_device );	bool WasRemoved ( const DeviceBase *p_device );	void RemoveDeleted ();	void ClearAll();	void UpdateLoop ()} memManager;//----------------------------------------------------------------------------// Add to update listvoid MemManager:: AddForUpdate ( DeviceBase * p_device ){	updateList.push_back( p_device );}//----------------------------------------------------------------------------// Flag for later removal.// Don't outright remove it, incase this is called during updatevoid MemManager:: FlagForRemove ( DeviceBase * p_device ){	p_device->SetIsDead (true);	removeList.push_back( p_device );}//----------------------------------------------------------------------------// Check if it is in the remove listbool MemManager:: WasRemoved ( const DeviceBase *p_device ){	return std::find( removeList.begin(), removeList.end(), p_device ) != removeList.end();}//----------------------------------------------------------------------------void MemManager:: RemoveDeleted (){	std::vector<BaseClass *>::iterator i; // Iterator	i = std::remove_if (updateList.begin(), updateList.end(), &MemManager::WasRemoved );	// quickly moves all items that "WereRemoved" to the end of the list	updateList.erase( i, updateList.end() ); // quickly pops all items past i	removeList.clear(); // clear our "deleted already" list}//----------------------------------------------------------------------------// Clear out the listvoid MemManager:: ClearAll(){	//_______________	// first kill all the stuff that was already deleted	RemoveDeleted();	//_______________	// now kill everything else	std::for_each(updateList.begin(), updateList.end(), std::mem_fun(&BaseClass::DeleteMe));	// destroy the objects	updateList.clear();	removeList.clear();}//----------------------------------------------------------------------------// Update loopvoid MemManager:: UpdateLoop (){	//_______________	// first kill all the deleted stuff	RemoveDeleted();	//_______________	// Check for things that died	std::vector<BaseClass *>::iterator i; // Iterator	i = std::remove_if(updateList.begin(), updateList.end(), std::mem_fun(&BaseClass::IsDead));	std::for_each(i, updateList.end(), std::mem_fun(&BaseClass::DeleteMe));	updateList.erase( i, updateList.end() );	//_______________	// Now update	std::for_each( updateList.begin(), updateList.end(), std::mem_fun(&BaseClass::update) );}//----------------------------------------------------------------------------// ClassA//----------------------------------------------------------------------------// derived classclass ClassA : public BaseClass{public:	ClassA()	{ AddForUpdate( this ); } // add for update	virtual ~ClassA() { FlagForRemove( this ); } // add for remove		virtual void Update();};//----------------------------------------------------------------------------virtual void ClassA:: Update (){	std::cout << "Class A Updating" << std::endl;}//----------------------------------------------------------------------------// ClassB//----------------------------------------------------------------------------// derived classclass ClassB : public BaseClass{public:	ClassB()	{ AddForUpdate( this ); } // add for update	virtual ~ClassB() { FlagForRemove( this ); } // add for remove		virtual void Update();};//----------------------------------------------------------------------------virtual void ClassB:: Update (){	std::cout << "Class B Updating" << std::endl;}//----------------------------------------------------------------------------// Some global functions//----------------------------------------------------------------------------ClassA * void CreateClassA (){	ClassA * c;	c = new ClassA;	return c;}//----------------------------------------------------------------------------ClassB * void CreateClassB (){	ClassB * c;	c = new ClassB;	return c;}//----------------------------------------------------------------------------// Begin Test Funcvoid runMainLoop (){	ClassA * class1 = CreateClassA ();	ClassA * class2 = CreateClassA ();	ClassB * class3 = CreateClassB ();		// Test the update loop	memManager.UpdateLoop();		// Delete one	delete class1;		// Test again	memManager.UpdateLoop();	return;}

class Device{  // Implement your device here, as a plain old C++ class   // with constructors and destructor.};typedef std::list<Device> Devices;typedef Devices::iterator DeviceHandle;// The devices. You may make this list global if you wish.Devices devices;// Create a new device, add it to the list of devices, get a // handle to itdevices.push_front(Device(/* constructor arguments */));DeviceHandle handle = devices.begin();// Have some fun with the devicehandle -> frobnicate();// Remove it from the listdevices.erase(handle);// Let's traverse all devices and do something to them...for(DeviceHandle handle = devices.begin(); handle != devices.end(); ++handle){  handle -> update();}// Now let's remove all dead devices from the list of devicesdevices.remove_if(std::mem_fun_ref(&Device::isDead));

template<class T>class Proxy{  boost::shared_ptr<T> inner;public:  Proxy(const boost::shared_ptr<T> &used) : inner(used) { assert(used); }  operator T& () { return *inner; }  operator const T&() const { return *inner; }};class DeviceBase { /* Base class Members */ };class DeviceFoo : public DeviceBase { /* Foo overrides */ };class DeviceBar : public DeviceBase { /* Bar overrides */ };typedef Proxy<DeviceBase> Device;// Create a foo devicedevices.push_back(Device(new DeviceFoo(/* Arguments */)));// Everything else happens as above[/quote]The proxy automatically cleans up behind you any memory you've allocated once it's not used anymore.

#include <iostream>#include <vector> // needed for the list#include <algorithm> // needed for the find functionusing namespace std;// number of Example classes createdstatic unsigned int n_Example = 0;//Base for all auto-updted classesclass BaseUpdate{public:	BaseUpdate () {}	virtual ~BaseUpdate ();	virtual void Update () = 0; // must define this function in derived classes	void DeleteMe () { delete this; } // used internally, to delete the class use  delete Class;  instead};//Example classclass Example : public BaseUpdate{	int number; // just for demo purposespublic:	Example (int num)   { ++n_Example; number = num; } // all these are inline, but they don't have to be	~Example ()         { --n_Example; }	void Update ()      {cout << ": Updating Example" << endl; number++; }	int GetNumber ()    { return number; }};//List of auto-updted classestypedef vector <BaseUpdate *> List;List UpdateList;//Function for creating example classExample * CreateExample (int number){	cout << " An example has been created!" << endl;	Example * b = new Example (number);	UpdateList.push_back (b); // add to list	return b;}Example * CreateExample () // no params{	cout << " An example has been created!" << endl;	Example * b = new Example (0);	UpdateList.push_back (b);	return b;}//When the class is destroyedBaseUpdate:: ~BaseUpdate (){	cout << "An example has been deleted!" << endl;	List:: iterator i;	i = find (UpdateList.begin (), UpdateList.end (), this); // find the current class in the list	if (i != UpdateList.end ()) UpdateList.erase (i);}//Function for auto-uptding the classesvoid Run (){	//Update the classes	List:: iterator i; // think of this as if it were int i;  but you can get the value from the list by *(i)	for (i=UpdateList.begin (); i!=UpdateList.end (); i++)	{		BaseUpdate * b = *(i);		b->Update ();	}}//Function for clearing the update listvoid ClearAll (){	UpdateList.clear();}int main (){	Example *example1, *example2;	// Create a couple of thingys	example1 = CreateExample (5); // the number is an example of using a parameter	example2 = CreateExample (3);	// Record their numbers	cout << " example1 has this number value: " << example1->GetNumber () << endl;	cout << " example2 has this number value: " << example2->GetNumber () << endl;	// Automatically update (number++) all created Example classes	Run (); //This would normally be done in the main loop, but we don't have a main loop in this example	delete example1; //It's simple to delete stuff	example1 = CreateExample ();		// what are the new values	cout << " example1 has this number value: " << example1->GetNumber () << endl;	cout << " example2 has this number value: " << example2->GetNumber () << endl;		system ("PAUSE");		ClearAll ();	return 0;}