How do I call the class's destructor?

Question

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?

Answer 1

A lot of the answers include " you never do that" but I have a counter example. I haven't performance tested this, indeed there is garbage code left in, but it did run for hours although the overall app bombed eventually with optimization level 3 on g++, so there may be bugs, bit you get the idea here.

mjm_object_pool.h

where a fixed array is created but only some objects are used. You can see explicit destructor calls. These compile and appear to run although I'm still working on best approach. Laugh if you want but it does run and may optimize better. fwiw. In response to the comment below, the relevant code is below. A pointer to a memory block is m_ptr and the objects are typedeffed to "ObjectTy". m_bits is a boolean array for those that were allocated. You can see the details in the code but you can call the dtor without releasing the memory.

void Free()
{
MM_ILOOP(i,m_sz)
{
    if (m_bits[i]) m_ptr[i].~ObjectTy();
}
m_bits.clear();
} // Free 

2nd edit, to answer the OP's question you can call the dtor explicitly if you want to execute it but that is independent of releasing the memory in which the object resides. You could for example do this

Foo foo;
foo.~Foo();
new(&foo)Foo;

or what I finally did,

Foo * p = (Foo*) char[sizeof(Foo)];
new(p)Foo;
p->~Foo();
delete[] p;

how's that? lol

Answer 2

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 destructor will get called here, after which it's memory is freed
}

When you create your object on the heap, you kinda need to delete your class before its destructor is called and memory is freed:

int main()
{
  date* ob2 = new date(12);
  // ob2->day holds 12
  delete ob2; // ob2's destructor will get called here, after which it's memory is freed
  return 0;   // ob2 is invalid at this point.
}

(Failing to call delete on this last example will result in memory loss.)

Both ways have their advantages and disadvantages. The stack way is VERY fast with allocating the memory the object will occupy and you do not need to explicitly delete it, but the stack has limited space and you cannot move those objects around easily, fast and cleanly.

The heap is the preferred way of doing it, but when it comes to performance it is slow to allocate and you have to deal with pointers. But you have much more flexibility with what you do with your object, it's way faster to work with pointers further and you have more control over the object's lifetime.

Answer 3

You may be confused by undefined behavior here. The C++ standard has no rules as to what happens if you use an object after its destructor has been run, as that's undefined behavior, and therefore the implementation can do anything it likes. Typically, compiler designers don't do anything special for undefined behavior, and so what happens is an artifact of what other design decisions were made. (This can cause really weird results sometimes.)

Therefore, once you've run the destructor, the compiler has no further obligation regarding that object. If you don't refer to it again, it doesn't matter. If you do refer to it, that's undefined behavior, and from the Standard's point of view the behavior doesn't matter, and since the Standard says nothing most compiler designers will not worry about what the program does.

In this case, the easiest thing to do is to leave the object untouched, since it isn't holding on to resources, and its storage was allocated as part of starting up the function and will not be reclaimed until the function exits. Therefore, the value of the data member will remain the same. The natural thing for the compiler to do when it reads ob2.day is to access the memory location.

Like any other example of undefined behavior, the results could change under any change in circumstances, but in this case they probably won't. It would be nice if compilers would catch more cases of undefined behavior and issue diagnostics, but it isn't possible for compilers to detect all undefined behavior (some occurs at runtime) and often they don't check for behavior they don't think likely.

Answer 4

Even though the destructor seems like something you need to call to get rid of or "destroy" your object when you are done using it, you aren't supposed to use it that way.

The destructor is something that is automatically called when your object goes out of scope, that is, when the computer leaves the "curly braces" that you instantiated your object in. In this case, when you leave main(). You don't want to call it yourself.

Answer 5

In this case your destructor does not need to delete the day variable.

You only need to call delete on memory that you have allocated with new.

Here's how your code would look if you were using new and delete to trigger invoking the destructor

class date {

  public: int* day; 
  date(int m) { 
      day = new int;
      *day = m; 
  }

  ~date(){ 
      delete day;
      cout << "now the destructor get's called explicitly";
  } 
};

int main() { 
  date *ob2 = new date(12); 
  delete ob2;
  return 0; 
}

Answer 6

Only in very specific circumstances you need to call the destructor directly. By default the destructor will be called by the system when you create a variable of automatic storage and it falls out of scope or when a an object dynamically allocated with new is destroyed with delete.

struct test {
   test( int value ) : value( value ) {}
   ~test() { std::cout << "~test: " << value << std::endl; }
   int value;
};
int main()
{
   test t(1);
   test *d = new t(2);
   delete d;           // prints: ~test: 2
}                      // prints: ~test: 1 (t falls out of scope)

For completeness, (this should not be used in general) the syntax to call the destructor is similar to a method. After the destructor is run, the memory is no longer an object of that type (should be handled as raw memory):

int main()
{
   test t( 1 );
   t.~test();            // prints: ~test: 1
                         // after this instruction 't' is no longer a 'test' object
   new (&t) test(2);     // recreate a new test object in place
}                        // test falls out of scope, prints: ~test: 2

Note: after calling the destructor on t, that memory location is no longer a test, that is the reason for recreation of the object by means of the placement new.

Answer 7

Rarely do you ever need to call the destructor explicitly. Instead, the destructor is called when an object is destroyed.

For an object like ob2 that is a local variable, it is destroyed when it goes out of scope:

int main() 
{ 
    date ob2(12); 

} // ob2.~date() is called here, automatically!

If you dynamically allocate an object using new, its destructor is called when the object is destroyed using delete. If you have a static object, its destructor is called when the program terminates (if the program terminates normally).

Unless you create something dynamically using new, you don't need to do anything explicit to clean it up (so, for example, when ob2 is destroyed, all of its member variables, including day, are destroyed). If you create something dynamically, you need to ensure it gets destroyed when you are done with it; the best practice is to use what is called a "smart pointer" to ensure this cleanup is handled automatically.

Answer 8

You do not need to call the destructor explicitly. This is done automatically at the end of the scope of the object ob2, i.e. at the end of the main function.

Furthermore, since the object has automatic storage, its storage doesn’t have to be deleted. This, too, is done automatically at the end of the function.

Calling destructors manually is almost never needed (only in low-level library code) and deleting memory manually is only needed (and only a valid operation) when the memory was previously acquired using new (when you’re working with pointers).

Since manual memory management is prone to leaks, modern C++ code tries not to use new and delete explicitly at all. When it’s really necessary to use new, then a so-called “smart pointer” is used instead of a regular pointer.