destructor

I have a simple C++ code, but I don't know how to use the destructor: class date { public: int day; date(int m) { day =m; } ~date(){ cout << "I wish you have entered the year \n" << day; } }; int main() { date ob2(12); ob2.~date(); cout << ob2.day; return 0; } The question that I have is, what should I write in my destructor code, that after calling the destructor, it will delete the day variable ? Marius You should not call your destructor explicitly. When you create your object on the stack (like you did) all you need is: int main() { date ob2(12); // ob2.day holds 12 return 0; // ob2's

Suppose I have the following snipplet: Foo foo; .... return bar(); Now, does the C++ standard guarantees me that bar() will be called before foo::~Foo() ? Or is this the compiler/implementation's choice? Thanks! It is guaranteed behaviour. The actual execution is unrolled as follows: 0: enter block (scope) 1: Foo::Foo() 2. evaluation of bar(); as expression in return statement 3. save result of the expression as value returned from function 4. finalize return statement to leave function to its caller (request exit from current scope) 5: exit block (scope) with call to Foo::~Foo() Here are some

I think virtual alone is generally sufficient. Is there another reason to make it pure virtual than to force derived classes to implement their own destructor? I mean if you allocate something in your class' constructor you should impement your own destructor - if your class is derived or not. Doesn't count as answer as I already know: If you want your class abstract and it has no pure virtual functions - leave it to the destructor. Some more uses? If you want your class abstract and it has no pure virtual functions - leave it to the destructor. Actually, I don't think there's more. All the

Consider the following: In X.h: class X { X(); virtual ~X(); }; X.cpp: #include "X.h" X::X() {} Try to build this (I'm using a .dll target to avoid an error on the missing main, and I'm using Visual Studio 2010): Error 1 error LNK2001: unresolved external symbol "private: virtual __thiscall X::~X(void)" (??1X@@EAE@XZ) Small modifications result in a successful build, however: X.h: class X { inline X(); // Now inlined, and everything builds virtual ~X(); }; or X.h: class X { X(); ~X(); // No longer virtual, and everything builds }; What causes the unresolved external in the linker when the

What is the advantage in de-allocating memory in reverse order to variables? Consider this example: Type1 Object1; Type2 Object2(Object1); Suppose that Object2 uses some internal resources of Object1 and is valid as long as Object1 is valid. For example, Object2 s destructor accesses Object1 's internal resource. If it weren't for the guarantee of reverse order of destruction, this would lead to problems. It's not just about deallocating memory, it's about symmetry in a broader sense. Each time you create an object you are creating a new context to work in. You "push" into these contexts as

The article Are destructors overloadable? talks about overloading the destructor. This raised a question: Can a destructor have parameters? I've never used or seen a destructor with parameters. I could not come up with an example of a reason to use parameters to the destructor. Mat Section §12.4 of C++0x draft n3290 has this to say about destructors: Destructors A special declarator syntax using an optional function-specifier (7.1.2) followed by ˜ followed by the destructor’s class name followed by an empty parameter list is used to declare the destructor in a class definition. (emphasis added)