Pointer Deallocation and Heap memory, c++

Question

I have a member function that I call, from there I get a pointer to a private member which is of class BankAccount, I am unsure what happens with the pointers when I deallocate them. I create a new pointer and heap memory address but then assign the pointer to something else. What does "delete" end up deleting?

I read that if you delete a pointer

Here is the code

void Employee::raise(){

    BankAccount* tempBank = new BankAccount(); //set pointer to new heap place

    double amt;

    tempBank = get_bank(); // set pointer to existing heap implicitly
    amt = tempBank->get_amount();
    amt = (amt + (amt/12));
    tempBank->set_amount(amt);


    delete tempBank; //does this delete new heap created or does it add a new block of
                     //memory to heap since it is trying to delete a pointer assigned 
                     //by memory address
    tempBank = NULL;
}

I realized I could just do the code below to avoid this situation, but now I am curious as to what happens in the above situation with the memory

BankAccount* tempBank = get_bank();

So what exactly happens when delete is called in my original situation?

Answer 1

When you use delete ptr; the object pointed to by ptr is destroyed and the corresponding memory is returned to the memory management system. The variable ptr and any copy thereof hold a bit pattern referring to now inaccessible memory (the system may still allow you to actually access this memory and it may even still contain the original data but that's undefined behavior and you shall not rely on it).

Put differently, the memory deallocation does not affect the pointer but it does affected the pointed to entity. In your case, the BankAccount, i.e., the result of *tempBank gets destroyed while the pointer tempBank remains unchanged by the delete operation. Obviously, setting tempBank to NULL does change this specific pointer but none of the other copies (if any), giving you false sense of security: I'd not set deleted pointers to NULL unless I keep them around for whatever reason...

Answer 2

Pointers are essentially just the address of the first byte in memory that belongs to the data structure they point to. So in your case:

BankAccount* tempBank = new BankAccount(); // this creates a new object of type BankAccount
                                           // the pointer tempBank points to the first byte of that object in memory

tempBank = get_bank();  // now tempBank points to the first byte of whatever is returned from get_bank()
                        // that means that you no longer know the address of the object you created above (tempBank now points to something different)
                        // C++ has no garbage collection, so you just leaked that memory

delete tempBank; // you delete the object that was returned from get_bank
                 // so that memory is now marked as free and can be reused by whatever needs it

tempBank = NULL;  // this is good style, you should always do it, but it does nothing to any allocated memory

BTW: using plain new and delete and owning raw pointers is considered bad style in modern C++. YOu might want to consider using std::shared_ptr or std::unique_ptr (or their boost equivalents if you cannot use C++11 yet)

Answer 3

I found this information that may be useful to you:

ordinary delete Deallocates the memory block pointed by ptr (if not null), releasing the storage space previously allocated to it by a call to operator new and rendering that pointer location invalid.

You can find more information in the original url: http://www.cplusplus.com/reference/new/operator%20delete/

Answer 4

delete tempBank;

when delete is called on pointer , it releases memory pointed by that variable[tempBank].

There are two notions of delete in C++: One is the operator, declared as ::operator delete(void*), which basically only frees up the memory and isn't usually thought about by most programmers. The other is the delete expression, delete p;, where p is a T*. The expression invokes the destructor of the object pointed to by p (and then frees the memory), which is a crucial language feature of C++ that has no analogue in C.

Answer 5

Well first of all, you are allocating from heap with your first exp which is

BankAccount* tempBank = new BankAccount();

and you lose the address of it with assigning another object address to tempBank pointer by

tempBank = get_bank();

so actually when you delete tempBank; you actually deleting the object that you allocated in the function get_bank(). Also because you have lost the address of object that you allocated with new BankAccount(), there is no more way to delete it, because you do not know the address of this object.

Answer 6

In your question, Are you sure that get_bank() indeed returns pointer to object allocated on heap (and not address of just plain object on stack). You have not mentioned it clearly hence it's worth to confirm it again. Now, coming back to question, if get_bank() returned pointer to private member which let's say was not on heap - in that case doing doing tempBank will result in undefined behavior because you can only invoke delete on an object which was created using new. But if get_bank() returned pointer to object allocated on heap then it will free memory of that object and then accessing that object from any other member function could become a nightmare!

You can check below link for some more related information,

Calling delete on variable allocated on the stack