Pointer in a class

Question

I have the following below code snippet

class test{
    private:
        int *ptr;
    public:
        test(int *myptr){
            ptr = myptr;
        }
        ~test(){
            delete ptr;
        }
};

int main(){
    int* myptr = new int;
    *myptr = 10;
    test obj(myptr);
    delete myptr;
}

Is there a memory leak happening in this program, if I dont do a new to pointer in the class will space be allocated for that pointer?

Answer 1

Rule of thumb for dealing with allocating member: every new/new[] should be paired with exactly one delete/delete[]. If you are missing the delete, then you have a memory leak (you have allocated memory that you never clean up). If you are delete-ing multiples times, as you are doing in this code example, you will have memory corruption issues.

How are you delete-ing multiple times? In main(), you allocate a pointer:

int* myptr = new int;

You give a copy of that pointer to your test object, obj. Then, at the end of the scope we have:

{
    // ...
    delete myptr;
    ~test(); // implicit, which also does delete myptr
}

Only one of those two places should be responsible for delete-ing the pointer. Which one is based on the semantics of your code. Does test own the pointer? In which case, it should delete it but main() should not. Does it simply observe the pointer? In which case, it should not delete it. With C++11, we have new smart pointers to express this idea better.

I'd encourage you to browse the definitive C++ book list as concepts like this are very crucial to understanding C++ but also very difficult to explain properly in a short Q&A format.

Answer 2

You should only delte a pointer once in ~test() or delete directly

*** Error in `./a.out': double free or corruption (fasttop): 0x08d13a10 ***

Answer 3

Consider using std::shared_ptr<int> or std::unique_ptr<int>, since direct memory management is discouraged in modern C++ unless you've a reason to do so. You can read about semantics differences of smart pointers here, and the reference for them is here.

Answer 4

What will happen in your instance is that the pointer will be given to delete in main(), then the same pointer value will be given a second time to delete in the destructor of obj. This is undefined behaviour, so it might work, or it might not, in any case, it isn't guaranteed to work, and therefore such a construct should not be used.

Ordinarily you would establish ownership rules, e.g. whether the constructor “takes ownership” (and is therefore responsible for freeing resources) is up to you, but typically, and especially in modern C++, ownership semantics can be clearly achieved by using std::unique_ptr and std::shared_ptr.

Most importantly, whichever method you use to determine ownership, make sure you are consistent! Avoid complicated ownership semantics, as it will make it much more difficult to detect memory-related issues (or more generally, resource-related issues).

Answer 5

It will crash when exit main function, a allocated in heap memory can't be release two times

Answer 6

Contrary to what other people have said: you do not delete pointers in C++, but objects.

What's the difference?

Let's simplify your code a bit:

int *myptr = new int; // 1
int *ptr = myptr; // 2
delete myptr; // 3
delete ptr; // 4

As far as the usage of new and delete is concerned, this is the same code - I've just removed the class, since it's not relevant to the point here.

This code does the following:

1. new int allocates an int, and returns its address. The address is then stored in myptr.

2. The address is copied to ptr. Both ptr and myptr contain the address of the int that was just allocated.

3. The int is deallocated.

4. The int is deallocated... but it was already deallocated? Oops!

   If you're lucky, your program will crash at this point.

delete myptr; has nothing to do with the variable myptr, except that myptr holds the address of the thing to delete.

It doesn't even have to be a variable - you could do delete new int; (although it wouldn't be very useful) or delete someFunctionThatReturnsAnAddress();, or int *p = 1 + new int[2]; delete [] (p - 1);.

Answer 7

Your class has only a reference of the allocated integer. Consider to declare it int const* ptr, then you cant delete it inside the class. You should remove delete ptr from the destructor.

Usually the scope which is allocating something is responsible for freeing it. In your case the main routine is allocating and has to free.

Answer 8

For your question "Is there a memory leak happening in this program", the answer is No, but an exception is rasing.

Your code logic is not good, you should delete the pointer at where it was created. In this example, you shouldn't delete ptr in destructor function.