In Which Situations To Delete A Pointer

Question

My following question is on memory management. I have for example an int variable not allocated dynamically in a class, let's say invar1. And I'm passing the memory address of this int to another classes constructor. That class does this:

class ex1{
    ex1(int* p_intvar1)
    {
       ptoint = p_intvar1;
    }

    int* ptoint;
};

Should I delete ptoint? Because it has the address of an undynamically allocated int, I thought I don't need to delete it.

And again I declare an object to a class with new operator:

objtoclass = new ex1();

And I pass this to another class:

class ex2{
    ex2(ex1* p_obj)
    {
       obj = p_obj;
    }

    ex1* obj;
};

Should I delete obj when I'm already deleting objtoclass?

Thanks!

Answer 1

Because it has the address of an undynamically allocated int I thought I don't need to delete it.

Correct.

Should I delete obj when I'm already deleting objtoclass?

No.

Recall that you're not actually deleting pointers; you're using pointers to delete the thing they point to. As such, if you wrote both delete obj and delete objtoclass, because both pointers point to the same object, you'd be deleting that object twice.

I would caution you that this is a very easy mistake to make with your ex2 class, in which the ownership semantics of that pointed-to object are not entirely clear. You might consider using a smart pointer implementation to remove risk.

Answer 2

just an appendix to the other answers

You can get rid of raw pointers and forget about memory management with the help of smart pointers (shared_ptr, unique_ptr).

The smart pointer is responsible for releasing the memory when it goes out of scope.

Here is an example:

#include <iostream>
#include <memory>

class ex1{
public:
    ex1(std::shared_ptr<int> p_intvar1)
    {
        ptoint = p_intvar1;
        std::cout << __func__ << std::endl;
    }
    
    ~ex1()
    {
        std::cout << __func__ << std::endl;
    }
private:
    std::shared_ptr<int> ptoint;
};

int main()
{
    std::shared_ptr<int> pi(new int(42));
    std::shared_ptr<ex1> objtoclass(new ex1(pi));

    /* 
     * when the main function returns, these smart pointers will go
     * go out of scope and delete the dynamically allocated memory
     */ 

    return 0;
}

Output:

ex1
~ex1