Delete pointer and object

Hello and welcome to C++ land! You will love how much you hate it (or something like that). C++, while appearing to be similar to java in untrained eyes might look similar, is actually quite different semantically. Lets see how these semantics play out in c++ in regards to your question. First lets take a class:

class Foo {
public:
    Foo() { std::cout << "In constructor\n"; }
    ~Foo() { std::cout << "In destructor\n"; }
};

Foo here is just a representative of any class you might want to use. Lets see what happens when we create and play with a normal Foo object:

{
    Foo bar;
    do_stuff(bar);
}

If we were to run code that looked like this, we would see:

In constructor
In destructor

This is because, when an object is created, it is constructed using the constructor. When it goes out of scope, the destructor is called (~Foo in our code) which deconstructs (or destroys) the object. This is actually a fairly common and powerful feature in C++ (known as RAII, as opposed to other forms of returning memory to the system, such as Garbage Collection). Armed with this new knowledge, lets see what happens when we play with a pointer to Foo:

{
    Foo *bar = new Foo();
    some_more_stuff(bar);
}

What happens here is we would see:

In constructor

This is because of how pointers are allocated versus how variables are allocated. The way pointers are allocated, they don't actually go out of scope normally, but their contents do. This is known as a dangling pointer. For a better example, take a look at this:

#include <iostream>

int* get_int() {
    int qux = 42;
    int *foo = &qux;
    return foo;
}

int main() {
    int *qazal = get_int();
    std::cout << *qazal;
}

Thanks to modern operating systems, this memory will still be returned when the program finishes, but not during the running of the program. If we were to delete the pointer (in the same scope it was created) via delete, then that memory will actually be returned to the operating system at that time.

When you call delete on a pointer it frees the memory of the thing pointed to. In other words you don't need to free the memory that makes up the pointer variable, just the thing that is pointed to. So your code:

Object *apple;
apple = new Object();

delete apple;

correctly deletes the object and there will be no memory leak.

If you don't call delete and the variable goes out of scope then you'll have a memory leak. These can be difficult to track down, so it's advisable to use a smart pointer class.

Operator delete deletes an object pointed to by the pointer that previously was allocated with operator new.

The pointer itself is not changed and even will have the same value as before the calling the operator. However its value becomes invalid after deleteing the object.

If the pointer itself is a local variable it will be destroyed after the control leaves the declaration region of the pointer.

If the pointer has the static storage duration then it will be destroyed when the program finishes its execution.

Take into account that you can use smart pointers instead of raw pointers.

For example

std::unique_ptr<Object> apple( new Object() );

in this case you need not to call delete It is the smart pointer that will do all the work itself.

Will the code below delete the object?

Yes, it will. But the pointer isn't deleted and accidentally using the pointer after deletion will lead to error.

And what happens if the pointer is not deleted, and gets out of scope?

Memory leak will happen.