destructor

I was trying to understand what the rule of zero says by reading this blog . IMO, it says if you declare your own destructor then don't forget to make the move constructor and move assignment as default. Example : class Widget { public: ~Widget(); // temporary destructor ... // no copy or move functions }; "The addition of the destructor has the side effect of disabling generation of the move functions, but because Widget is copyable, all the code that used to generate moves will now generate copies. In other words, adding a destructor to the class has caused presumably-efficient moves to be

Today, I have seen some legacy code. In the destructor there is a statement like " delete this ". I think, this call will be recursive. Why it is working? I made some quick search on Y!, I found that if there is a need to restrict the user to create the stack object, we can make destructor private and provide an interface to delete the instance. In the interface provided, we have to call delete on this pointer. Are there any other situations for using such statements? JaredPar "delete this" is commonly used for ref counted objects. For a ref counted object the decision of when to delete is

Is there a defined order in which local variables are deallocated in C++ (11) ? To be more concise: In which order will side effects of the destructors of two local variables in the same scope become visible? e.g.: struct X{ ~X(){/*do something*/} } int main(){ X x1; X x2; return 0; } Is x1 or x2 destroyed first when main returns or is the order undefined in C++11? James Kanze Within each category of storage classes (except dynamically allocated objects), objects are destructed in the reverse order of construction. I. About local variables Local variables are allocated on the Stack . The Stack

I've not been able to find a conclusive answer to this so far. When is it safe to call this-> from within an object. And in particular from inside the constructor and destructor. And also, when using public inheritance. Is it safe to use up and downcasting on the result of the this call? So for example: class foo { foo(): a(), b(this->a)//case 1 { this-> a = 5; //case 2 } int a; int b; }; class bar: public baz { bar(): baz(this)//case 3 - assuming baz has a valid constructor { } } And finally the most unlikely one foo() { if(static_cast<bar*>(this));//case 4 } Which of the above cases are

Being primarily a C++ developer the absence of RAII (Resource Acquisition Is Initialization) in Java and .NET has always bothered me. The fact that the onus of cleaning up is moved from the class writer to its consumer (by means of try finally or .NET's using construct ) seems to be markedly inferior. I see why in Java there is no support for RAII since all objects are located on the heap and the garbage collector inherently doesn't support deterministic destruction, but in .NET with the introduction of value-types ( struct ) we have the (seemingly) perfect candidate for RAII. A value type