Destructor

[raj1986]

I have got some doubt on destructor call.
When the object is deleted then the destructor is called.

When the object is deleted?
stack object when goest out of scope and heap object when we call a delete.

Please find the below code where object is allocated using new.

#include<iostream>
#include<vector>
using namespace std;

struct st{
        st(int v):val(v){cout<<"st constructed  for "<<val<<endl;}
        ~st(){cout<<"st desctructed  for "<<val<<endl;}
        int val;
};


int main()
{
        {
        st *p = new st(1000);
        st dd = *(p);
        }

        cout<<"Before Program ends"<<endl;
}

Here i am not calling delete but assigned to a stack object and when i run the program i see the output as

st constructed for 1000
st desctructed for 1000
Before Program ends

so is the memory got de-allocated? Though i do not call delete.

[laserlight]

It might be helpful if you printed the addresses of the objects as well, and implemented the copy constructor see it being invoked:

#include<iostream>

using namespace std;

struct st {
    st(int v) : val(v) {
        cout << "st constructed @ " << this << " for " << val << endl;
    }
    st(const st& other) : val(other.val) {
        cout << "st copy constructed @ " << this << " from " << &other << " for " << val << endl;
    }
    ~st() {
        cout << "st @ " << this << " destroyed for " << val << endl;
    }
    int val;
};

int main()
{
    {
        st *p = new st(1000);
        st dd = *(p);
    }

    cout << "Before Program ends" << endl;
}

Now I get:

st constructed @ 0x1486c20 for 1000
st copy constructed @ 0x7ffc5f0f4ae0 from 0x1486c20 for 1000
st @ 0x7ffc5f0f4ae0 destroyed for 1000
Before Program ends

so you can see that you constructed two st objects, one at 0x1486c20 and the other at 0x7ffc5f0f4ae0, but only the object at 0x7ffc5f0f4ae0 had the destructor invoked for it.

[raj1986]

Thanks a lot. It is clear now

[wolle]

When the object is deleted?
stack object when goest out of scope and heap object when we call a delete.

There's a third option. As of C++ 11 a so called (reference counting) smart pointer became part of the standard. It's called std::shared_ptr.

This smart pointer is used like an ordinary pointer but is "smart" in the sense that it knows when the object it points to on the heap may be safely deleted. This happens when all copies of the smart pointer has gone out of scope so the heap object is no longer referenced from anywhere. Then the smart pointer deletes the object.

[2kaud]

There's a third option. As of C++ 11 a so called (reference counting) smart pointer became part of the standard. It's called std::shared_ptr.

This smart pointer is used like an ordinary pointer but is "smart" in the sense that it knows when the object it points to on the heap may be safely deleted. This happens when all copies of the smart pointer has gone out of scope so the heap object is no longer referenced from anywhere. Then the smart pointer deletes the object.

Or if the ownership of the memory doesn't need to be shared, then std::unique_ptr would be used. See http://www.cplusplus.com/reference/memory/unique_ptr/