The destructor is not being called because terminate() for the unhandled exception is called before the stack gets unwound. The specific details of what the C++ spec says is outside of my knowledge, but a debug trace with gdb and g++ seems to bear this out. According to the draft standard section 15.3 bullet 9: … Read more
Yes, it is possible to implement shared_ptr that way. Boost does and the C++11 standard also requires this behaviour. As an added flexibility shared_ptr manages more than just a reference counter. A so-called deleter is usually put into the same memory block that also contains the reference counters. But the fun part is that the … Read more
But it is not true, why? ยง5.2.4/1: The only effect is the evaluation of the postfix-expression before the dot or arrow. Where the postfix-expression is the expression of the object for which the call takes place. Thus a pseudo destructor call, as a call to a trivial destructor, does not end the lifetime of the … Read more
It sounds like you have two questions here: How can I wait until my thread completes? Answer: This is directly supported by pthreads — make your thread-to-be-stopped JOINABLE (when it is first started), and use pthread_join() to block your current thread until the thread-to-be-stopped is no longer running. How can I tell if my thread … Read more
Both do different things. The first creates an object with automatic storage duration. It is created, used, and then goes out of scope when the current block ({ … }) ends. It’s the simplest way to create an object, and is just the same as when you write int x = 0; The second creates … Read more
Objects with finalizers cannot be collected within a single garbage collection procedure. Such objects are moved to f-reachable queue, and remain there until finalizers are called. Only after that they can be garbage-collected. Following code is better, but you should not rely on it anyway: GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); Also, throwing exceptions in finalizer seems too … Read more
I’m not convinced by the previous answers here. Firstly note that the example given does not prevent __del__ methods being called during exit. In fact, the current CPythons will call the __del__ method given, twice in the case of Python 2.7 and once in the case of Python 3.4. So this can’t be the “killer … Read more
To combine several answers and add my own, without a class definition the calling code doesn’t know: whether the class has a declared destructor, or if the default destructor is to be used, and if so whether the default destructor is trivial, whether the destructor is accessible to the calling code, what base classes exist … Read more
@edgerunner’s solution almost worked. Basically, you cannot create a closure in place of the define_finalizer call since that captures the binding of the current self. In Ruby 1.8, it seems that you cannot use any proc object converted (using to_proc) from a method that is bound to self either. To make it work, you need … Read more
The simplest solution is to put a named struct instance as a member in the unnamed one, and put all of the functionality into the named instance. This is probably the only way that is compatible with C++98. #include <iostream> #include <cmath> int main() { struct { struct S { double a; int b; S() … Read more