destructor

I have some code that is crashing in a large system. However, the code essentially boils down to the following pseudo-code. I've removed much of the detail, as I have tried to boil this down to the bare bones; I don't think this misses anything crucial though. // in a DLL: #ifdef _DLL #define DLLEXP __declspec(dllexport) #else #define DLLEXP __declspec(dllimport) #endif class DLLEXP MyClass // base class; virtual { public: MyClass() {}; virtual ~MyClass() {}; some_method () = 0; // pure virtual // no member data }; class DLLEXP MyClassImp : public MyClass { public: MyClassImp( some_parameters

I'm writing a multi-threaded C++ program. I plan on killing threads. However, I am also using a ref-counted GC. I'm wondering if stack allocated objects get destructed when a thread gets killed. The stack does not unwind when you 'kill' a thread. Killing threads is not a robust way to operate - resources they have open, such as files, remain open until the process closes. Furthermore, if they hold open any locks at the time you close them, the lock likely remains locked. Remember, you are likely calling a lot of platform code you do not control and you can't always see these things. The

I was reading this which mentions destructors being trivial and non-trivial. A class has a non-trivial destructor if it either has an explicitly defined destructor, or if it has a member object or a base class that has a non-trivial destructor. In example, I have a class, class C { public: ~C(); // not explicitly declared. }; If C::~C() is implicitly defined does it make a trival dtor? Kerrek SB You are getting your words mixed up. Your example does indeed declare an explicit destructor. You just forget to define it, too, so you'll get a linker error. The rule is very straight-forward: Does

I was thinking that when a function returns an object on the stack to the calling function, the calling function gets a copy of the original object but the original object's destructor is called as soon as the stack unwinds. But in the following program, the destructor is getting called only once. I expected it to be called twice. #include <iostream> class MyClass { public: ~MyClass() { std::cout << "destructor of MyClass" << std::endl; } }; MyClass getMyClass() { MyClass obj = MyClass(); return obj; // dtor call for obj here? } int main() { MyClass myobj = getMyClass(); return 0; // Another

I have a resource_manager class which maintains a std::vector<boost::shared_ptr<resource> > internally. resource_manager is a friend class of resource . I want resource s to only be created/deleted by resource_manager , so I made its constructors private (which works ok). However, if I make the destructor private, the code doesn't compile because the destructor is called by boost::shared_ptr , which is not a friend of resource . I am thinking of enforcing the "do not delete by clients" rule by only returning only const resource* from the resource_manager , but somehow I am not satisfied with

im trying to understand php constructor and destructor behaviour. Everything goes as expected with the constructor but i am having trouble getting the destructor to fire implicitly. Ive done all the reading on php.net and related sites, but i cant find an answer to this question. If i have a simple class, something like: class test{ public function __construct(){ print "contructing<br>"; } public function __destruct(){ print "destroying<br>"; } } and i call it with something like: $t = new test; it prints the constructor message. However, i'd expect that when the scripts ends and the page is

I'm very confused about using destructors in Qt4 and hope, you guys can help me. When I have a method like this (with "Des" is a class): void Widget::create() { Des *test = new Des; test->show(); } how can I make sure that this widget is going to be deleted after it was closed? And in class "Des" i have this: Des::Des() { QPushButton *push = new QPushButton("neu"); QHBoxLayout *layout = new QHBoxLayout; layout->addWidget(push); setLayout(layout); } where and how do I have to delete *push and *layout? what should be in the destructor Des::~Des() ? Another option to using deleteLater() , or

Possible Duplicate: Is it okay to inherit implementation from STL containers, rather than delegate? My question is related to Why don't STL containers have virtual destructors? Some people (including author of the former question) are convinced that not having virtual dtor implies that class is not inheritable. I am skeptical about such a strong statement, so I asked for the source or some reasoning but most respondents remain silent. Also nobody responded to my answer So I think it is good idea to question the assumptions made in the former question and clarify this important issue. Are STL