CODEWITHSUNDEEP
c++
Anshul
Anshul

Reputation: 101

Calling delete on automatic objects

Consider the following c++ code:

class test
{
public:
    int val;

    test():val(0){}
    ~test()
    {
        cout << "Destructor called\n";
    }
};

int main()
{
    test obj;
    test *ptr = &obj;
    delete ptr;

    cout << obj.val << endl;

    return 0;
}

I know delete should be called only on dynamically allocated objects but what would happen to obj now ?

Ok I get that we are not supposed to do such a thing, now if i am writing the following implementation of a smart pointer, how can i make sure that such a thing does't happen.

class smart_ptr
{
public:
    int *ref;
    int *cnt;

    smart_ptr(int *ptr)
    {
        ref = ptr;
        cnt = new int(1);
    }

    smart_ptr& operator=(smart_ptr &smptr)
    {
        if(this != &smptr)
        {
            //  House keeping
            (*cnt)--;
            if(*cnt == 0)
            {
                delete ref;
                delete cnt;
                ref = 0;
                cnt = 0;
            }

            //  Now update    
            ref = smptr.ref;
            cnt = smptr.cnt;
            (*cnt)++;
        }
        return *this;
    }

    ~smart_ptr()
    {
        (*cnt)--;
        if(*cnt == 0)
        {
            delete ref;
            delete cnt;
            ref = 0;
            cnt = 0;
        }
    }
};

Upvotes: 2

Views: 169

Answers (5)

Robᵩ
Robᵩ

Reputation: 168646

You've asked two distinct questions in your post. I'll answer them separately.

but what would happen to obj now ?

The behavior of your program is undefined. The C++ standard makes no comment on what happens to obj now. In fact, the standard makes no comment what your program does before the error, either. It simply is not defined.

Perhaps your compiler vendor makes a commitment to what happens, perhaps you can examine the assembly and predict what will happen, but C++, per se, does not define what happens.

Practially speaking1, you will likely get a warning message from your standard library, or you will get a seg fault, or both.

1: Assuming that you are running in either Windows or a UNIX-like system with an MMU. Other rules apply to other compilers and OSes.

how can i make sure that [deleteing a stack variable] doesn't happen.

Never initialize smart_ptr with the address of a stack variable. One way to do that is to document the interface to smart_ptr. Another way is to redefine the interface so that the user never passes a pointer to smart_ptr; make smart_ptr responsible for invoking new.

Upvotes: 3

SomeWittyUsername
SomeWittyUsername

Reputation: 18358

It's not just undefined behavior, like stated in other answers. This will almost certainly crash.

The first issue is with attempting to free a stack variable.

The second issue will occur upon program termination, when test destructor will be called for obj.

Upvotes: 0

Jakub Kuszneruk
Jakub Kuszneruk

Reputation: 1240

Delete's trying to get access to obj space in memory, but opperation system don't allow to do this and throws (core dumped) exception.

Upvotes: 1

john
john

Reputation: 8027

Your code has undefined behaviour because you used delete on a pointer that was not allocated with new. This means anything could happen and it's impossible to say what would happen to obj.

I would guess that on most platforms your code would crash.

Upvotes: 1

Mark B
Mark B

Reputation: 96271

It's undefined what will happen so you can't say much. The best you can do is speculate for particular implementations/compilers.

Upvotes: 0

Related Questions