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 addres

Answer 1

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

That is correct. Simply do not delete it.

The second part of your question was about dynamically allocated memory. Here you have to think a little more and make some decisions.

Lets say that your class called ex1 receives a raw pointer in its constructor for a memory that was dynamically allocated outside the class.

You, as the designer of the class, have to decide if this constructor "takes the ownership" of this pointer or not. If it does, then ex1 is responsible for deleting its memory and you should do it probably on the class destructor:

class ex1 {
public:
    /**
     * Warning: This constructor takes the ownership of p_intvar1,
     * which means you must not delete it somewhere else.
     */
    ex1(int* p_intvar1)
    {
        ptoint = p_intvar1;
    }

    ~ex1()
    {
        delete ptoint;
    }

    int* ptoint;
};

However, this is generally a bad design decision. You have to root for the user of this class read the commentary on the constructor and remember to not delete the memory allocated somewhere outside class ex1.

A method (or a constructor) that receives a pointer and takes its ownership is called "sink".

Someone would use this class like:

int* myInteger = new int(1);
ex1 obj(myInteger); // sink: obj takes the ownership of myInteger
// never delete myInteger outside ex1

Another approach is to say your class ex1 does not take the ownership, and whoever allocates memory for that pointer is the responsible for deleting it. Class ex1 must not delete anything on its destructor, and it should be used like this:

int* myInteger = new int(1);
ex1 obj(myInteger);
// use obj here
delete myInteger; // remeber to delete myInteger

Again, the user of your class must read some documentation in order to know that he is the responsible for deleting the stuff.

You have to choose between these two design decisions if you do not use modern C++.

In modern C++ (C++ 11 and 14) you can make things explicit in the code (i.e., do not have to rely only on code documentation).

First, in modern C++ you avoid using raw pointers. You have to choose between two kinds of "smart pointers": unique_ptr or shared_ptr. The difference between them is about ownership.

As their names say, an unique pointer is owned by only one guy, while a shared pointer can be owned by one or more (the ownership is shared).

An unique pointer (std::unique_ptr) cannot be copied, only "moved" from one place to another. If a class has an unique pointer as attribute, it is explicit that this class has the ownership of that pointer. If a method receives an unique pointer as copy, it is explicit that it is a "sink" method (takes the ownership of the pointer).

Your class ex1 could be written like this:

class ex1 {
public:
    ex1(std::unique_ptr p_intvar1)
    {
        ptoint = std::move(p_intvar1);
    }

    std::unique_ptr ptoint;
};

The user of this class should use it like:

auto myInteger = std::make_unique(1);
ex1 obj(std::move(myInteger)); // sink
// here, myInteger is nullptr (it was moved to ex1 constructor)

If you forget to do "std::move" in the code above, the compiler will generate an error telling you that unique_ptr is not copyable.

Also note that you never have to delete memory explicitly. Smart pointers handle that for you.