delete foo;
foo = nullptr;

int foo = 13;

int test(void)
{
    int bar = 42:
    MyClass *obj = new MyClass();

    printf("Pointer to the global (statically allocated) variable 'foo': %p\n", &foo);
    printf("Pointer to the local (stack allocated) variable 'bar': %p\n", &bar);
    printf("Pointer to the MyClass object allocated on the heap space: %p\n", obj);
    printf("Pointer to an arbitrary and probably invalid memory location: %p\n", (void*)666);
}

void test(void)
{
    /* Allocate an instance (object) of class MyClass on the stack (will be destroyed when it goes out of scope) */
    MyClass obj;

    /* Allocate an instance of class MyClass on the heap space, and store the pointer returned by the "new" operator in pointer variable 'ptr' */
    MyClass *ptr = new MyClass();

    /* Print the addresses of (i.e. "pointer to") the two objects */
    printf("Pointer to the first (stack-allocated) instance: %p\n", &obj);
    printf("Pointer to the second (heap-allocated) instance: %p\n", ptr);

    /* Actually access the two objects */
    obj.do_something();
    ptr->do_something();

    /* Destory the object that was allocated on the heap */
    delete ptr;

    /* The variable 'ptr' still contains the exactly same pointer (memory address) as before, even though the object at that address has been destroyed */
    printf("Pointer to the location where the now-destroyed object used to reside: %p\n", ptr);

    /* The following line is a dangerous "use after free" vulnerability */
    /* At this point, the memory region that the memory address in 'ptr' is pointing to may have been un-mapped or re-used for something entirely different !!! */
    ptr->do_something();
}

void test2(void)
{
    /* The following is a "memory leak", because the new heap-allocated object is never delete'd, but it's still perfectly possible to do that */
    /* Note: We *never* store the pointer to the object in a variable, but still we access the object via that pointer ;-) */
    (new MyClass())->do_something();
}

void test(void)
{
    Foo foo;
    printf("Pointer to local object 'foo': %p", &foo);
    printf("Pointer to new heap-allocated object: %p", new Foo());
    printf("Pointer to heap-allocated memory block: %p", malloc(666));
}

void test(void)
{
    (new Foo())->do_something(); // <-- note: this is a memory leak, but still possible
}

void test(void)
{
    Foo *foo = new Foo();
    Foo *bar = foo;
    
    printf("foo: %p\n",   foo);
    printf("bar: %p\n\n", bar);

    delete foo;

    printf("foo: %p\n",   foo);
    printf("bar: %p\n\n", bar);

    bar->do_something(); // <-- whooops !!!
}

void test2(void)
{
    Foo* foo = new Foo();
    printf("foo: %p\n", foo);
    delete (foo + 0);
    printf("foo: %p\n", foo);
    foo->do_something(); // <-- whooops !!!
}