Back to General and Gameplay Programming

Deconstructor not firing...

sirSolarius · 2004-06-09T12:06:15

I''m having a problem where an object''s deconstructor never fires, and that means that a member variable never gets deconstructed either. I''m not sure why this is happening. I have a base memory-managed object called MemObj, a smart pointer to it called MemPtr and then the derived object is an InputKeymap. When an object has nothing pointing to it, it adds itself to the MemoryManager''s list of objects to be deleted. In this example, the keymap _is_ deleted by the MemoryManager, but the destructor is never called for some reason (I set a breakpoint at InputKeymap::~InputKeymap() and it''s never fired). This leaves a reference to the escape Functor, and so that never deletes. Please help! This is the base memory-managed object: #ifndef _ERIK_MEMOBJ_H_DEFINED #define _ERIK_MEMOBJ_H_DEFINED #include <assert.h> #include <list> #include "MemoryManager.h" // include the memory management class ///////////////////////////////////////////////////////////////////////////// // MEMOBJ.H ///////////////////////////////////////////////////////////////////////////// // // AUTHOR: ERIK GOLDMAN // DATE: 6-3-04 // DESC: The base memory-managed object class // NOTES: // TOFIX: ///////////////////////////////////////////////////////////////////////////// class MemObj { protected: int m_refs; public: MemObj() :m_refs(0) { } virtual ~MemObj() { } void attach() { ++m_refs; } void release() { --m_refs; if(m_refs==0) // nothing points to the object { MemoryManager::getInstance()->markForDeletion(this); } } }; ///////////////////////////////////////////////////////////////////////////// // MEMPTR ///////////////////////////////////////////////////////////////////////////// // // AUTHOR: ERIK GOLDMAN // DATE: 6-3-04 // DESC: A smart pointer to a memory-managed object // NOTES: // TOFIX: ///////////////////////////////////////////////////////////////////////////// template <class T> class MemPtr { protected: T *obj; public: MemPtr() :obj(0) { } MemPtr(const MemPtr<T> &p) :obj(p.obj) { if(obj) obj->attach(); } MemPtr(T *p) :obj(p) { if(obj) obj->attach(); } ~MemPtr() { if(obj) obj->release(); obj=0; } inline MemPtr &operator=(T *p) { if(p != obj) // prevent against self-assignment { if(obj) obj->release(); obj=p; if(obj) obj->attach(); } return *this; } inline MemPtr &operator=(const MemPtr &p) { if(p.obj != obj) // prevent against self-assignment { if(obj) obj->release(); obj=p.obj; if(obj) obj->attach(); } return *this; } inline T& operator*() const { assert(obj!=0); return *obj; } inline T *operator->() const { assert(obj!=0); return obj; } inline bool operator==(const MemPtr<T> &p) { return(p.obj == obj); } inline bool operator ==(const T *p) { return(obj == p); } inline bool operator !() { return (obj == 0); } inline bool isValid() { return (obj != 0); } }; #endif And then the class itself: // InputKeymap.cpp: implementation of the InputKeymap class. // ////////////////////////////////////////////////////////////////////// #include "InputKeymap.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// InputKeymap::InputKeymap() { } InputKeymap::~InputKeymap() { Erase(); } ////////////////////////////////////////////////////////////////////////////////////////// // Name: Assign // Desc: Maps a key to a function // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// void InputKeymap::Assign(int key, MemPtr<Functor> &f) { m_keymap[key]=f; } ////////////////////////////////////////////////////////////////////////////////////////// // Name: Unassign // Desc: Unmaps a key completely // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// void InputKeymap::Unassign(int key) { m_keymap[key]=0; m_keymap.erase(key); } ////////////////////////////////////////////////////////////////////////////////////////// // Name: Erase // Desc: Erases the keymap and deletes its functors // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// void InputKeymap::Erase() { std::map<int, MemPtr<Functor> >::iterator iter=m_keymap.begin(), e=m_keymap.end(); while(iter != e) { Unassign(iter->first); // set the functor to 0 for memory management ++iter; } } ////////////////////////////////////////////////////////////////////////////////////////// // Name: Update // Desc: Checks the input manager for pressed keys, and activates functions if pressed // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// void InputKeymap::Update() { InputManager *p=InputManager::getInstance(); std::map<int, MemPtr<Functor> >::iterator iter=m_keymap.begin(), e=m_keymap.end(); while(iter != e) { if(p->keyDown(iter->first)) // if key is pressed (*(iter->second))(); // activate the function ++iter; // then advance to the next key } } The memory manager: // MemoryManager.cpp: implementation of the MemoryManager class. // ////////////////////////////////////////////////////////////////////// #include "MemoryManager.h" MemoryManager *MemoryManager::instance; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// MemoryManager::MemoryManager() :m_deadObjects() { } MemoryManager::~MemoryManager() { } ////////////////////////////////////////////////////////////////////////////////////////// // Name: getInstance // Desc: Gets an instance of the singleton // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// MemoryManager *MemoryManager::getInstance() { if(!instance) instance=new MemoryManager(); return instance; } ////////////////////////////////////////////////////////////////////////////////////////// // Name: CheckMemory // Desc: Iterates through the list of dead objects and deletes them // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// void MemoryManager::checkMemory() { if(!m_deadObjects.empty()) { m_iter=m_deadObjects.begin(); while(m_iter != m_deadObjects.end()) { delete *m_iter; m_tempIter=m_iter; ++m_tempIter; m_deadObjects.erase(m_iter); m_iter=m_tempIter; } } } ////////////////////////////////////////////////////////////////////////////////////////// // Name: markForDeletion // Desc: Adds the MemObj to the deletion queue when nothing points to it // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// void MemoryManager::markForDeletion(MemObj *m) { m_deadObjects.push_back(m); } ////////////////////////////////////////////////////////////////////////////////////////// // Name: Destroy // Desc: Cleans up the memory created by, ironically, the memory manager // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// void MemoryManager::Destroy() { while(!m_deadObjects.empty()) // because deleted stuff frees other things { checkMemory(); } delete instance; instance=0; } And finally, the main loop: ////////////////////////////////////////////////////////////////////////////////////////// // Name: MainLoop // Desc: The main loop of the engine... implemented for memory management reasons // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// void MainLoop() { MemoryManager *memManage=MemoryManager::getInstance(); MemPtr<InputKeymap> keymap=new InputKeymap(); MemPtr<Functor> escape=new Functor(&ExitProgram); keymap->Assign(DIK_ESCAPE, escape); g_state=RUNNING; InputManager *mainInput=InputManager::getInstance(); MSG msg; // Message for recieving Windows messages while(g_state == RUNNING) { if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage(&msg;; DispatchMessage(&msg;; } mainInput->Update(); memManage->checkMemory(); keymap->Update(); if(g_state==PAUSED) g_state=RUNNING; } } ////////////////////////////////////////////////////////////////////////////////////////// // Name: WinMain // Desc: the entry function for the entire engine. // Notes: // ToFix: ////////////////////////////////////////////////////////////////////////////////////////// int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { //_CrtSetBreakAlloc(48); ////////////////// Enable memory leak detection /////////// #ifdef _DEBUG _CrtDumpMemoryLeaks(); _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); #endif ////////////////////////////////////////////////////////// // Start by creating my class and window WindowManager *wnd=WindowManager::getInstance(); wnd->CreateClass("Kutatas", WindowsMsgHandler, hInstance); wnd->SpawnWindow("Kutatas Engine", 1024, 768); wnd->SetAsGLWindow(); wnd->setFullScreen(true); MainLoop(); // destroy everything WindowManager::getInstance()->Destroy(); LogManager::getInstance()->Destroy(); InputManager::getInstance()->Destroy(); MemoryManager::getInstance()->Destroy(); return 1; }

General and Gameplay Programming Programming

Started by sirSolarius June 07, 2004 10:04 AM

20 comments, last by sirSolarius 19 years, 10 months ago

Aprosenf

372

June 09, 2004 11:40 AM

Yes, I think the AP is right - if the compiler has a forward declaration of a class but not the whole definition and you try to delete a pointer to that class, it doesn't call the destructor. I tried a quick example of this and fortunately, MSVC gave me a warning about this, warning C4150. Make sure that MemoryManager.cpp includes MemObj.h into it so that it knows about MemObj's destructor.

[Edit] Oh yeah, and make sure to keep your warning level high. I got this warning on levels 2 and above, but not on level 1 (and obviously not on the None setting either). You wouldn't have had to bang your head on the wall for days waiting for the above AP's brilliance if you'd just had your warning level high enough. [/Edit]

[edited by - aprosenf on June 9, 2004 12:43:44 PM]

quorn

145

June 09, 2004 12:06 PM

virtual destructors?

Deconstructor not firing...

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Deconstructor not firing...

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Reticulating splines