destructor

I'm coming back to C++ from a heavy C# background and I've inherited some C++ codebase which I think might not have been in line with the best C++ practices. For example, I'm dealing with the following case (simplified): // resource class Resource { HANDLE _resource = NULL; // copying not allowed Resource(const Resource&); Resource& operator=(const Resource& other); public: Resource(std::string name) { _resource = ::GetResource(name); if (NULL == _resource) throw "Error"; } ~Resource() { if (_resource != NULL) { CloseHandle(_resource); _resource = NULL; }; } operator HANDLE() const { return

Given that a class and all its subclasses need no more than the default destructor to release their resources if stored in a variable of the exact type (or pointer to the exact type), can a subclass leak memory if referenced by a base class pointer and then deleted by that pointer? Example: #include <memory> class A { }; class B : public A { public: B () : pInt(new int) {} auto_ptr<int> pInt; // this is what might leak... possibly more will though }; void will_this_leak () { A *pA = new B(); delete pA; } "Leak memory"? Why are you talking about leaking memory specifically? The code you posted

I've been working on an assignment and now I'm stuck with buggy destructors. I have to create a generic binary tree with all the usual member functions and some special operators. There's also a restriction: everything must work iteratively so no nasty recursive hacks this time. There is obviously something very wrong with the destructor of BinTreeNode class because if I delete the node like this: BinTreeNode<int> * node = new BinTreeNode<int>(); delete node; I can still access its data: node->getData(); //should fail miserably so deletion has no effect but I have no usable idea how I should

I am having an issue where static destructors in a DLL are not getting called. The constructor is being called, but the destructor is not. I have a class like this in my DLL struct DLLDestructorTest { int blah; DLLDestructorTest() { blah = 2; } ~DLLDestructorTest() { blah = 0; } }; DLLDestructorTest DLLDestructorTestObj; I can put breakpoints in the constructor and the destructor and I can verify that the constructor breakpoint is hit and the destructor breakpoint is not. If I put an analogous chunk of code in my main.cpp file, I can verify that both the constructor and destructor will be

As per @EvanED in https://stackoverflow.com/a/11311786/890753 I created a gdb command newstr to create a new std::string and put it in a gdb convenience variable: define newstr set ($arg0)=(std::string*)malloc(sizeof(std::string)) call ($arg0)->basic_string() # 'assign' returns *this; casting return to void avoids printing of the struct. call (void)( ($arg0)->assign($arg1) ) end It works great: (gdb) newstr $foo "hello world" (gdb) p $foo->c_str() $57 = 0xb22e388 "hello world" I use newstr in other custom gdb commands, so for tidyness I also created delstr : define delstr call ($arg0)->~basic