c++ local variable memory management

If your intent is for the instance to only exist within the scope of this function, then you don't need to use dynamic allocation...

void someFunction() {
  .......
  myClass obj; 

  ........

}

... in which case the obj constructor is called when it is declared at myClass obj and the destructor is called when the function returns. Otherwise, if it must be dynamic, then this...

void someFunction() {
  .......
  myClass* obj = new myClass(); 

  ........

  delete obj;
}

... in which case the constructor is called when you call new myClass() and the destructor is called when you call delete obj -- but, in this case, you need to declare obj to be a pointer to a myClass object so that there's a place to store the return value from the new.

In your example I don't think you can re-claim the memory.

obj is a copy of the anonymous class you create with *(new myClass()). "obj" is allocated on the stack... it is not allocated on the heap (which is where new allocates from).

When you try to delete &obj you are trying to delete the stack memory for the copy that you created.

Try something like

myClass *obj = new myClass(); // memory is allocated from the heap and a pointer returned
myClass copyOfObj = *obj; // memory is allocated on the stack. a *shallow* copy of obj is made

delete obj.

myClass obj= *(new myClass());

That line:

1. Creates an instance of myClass with automatic storage duration.
2. Dynamically allocates an instance of myClass.
3. Dereferences the returned pointer and copies the object to obj. The pointer to the dynamically allocated object is discarded, resulting in a memory leak.
4. Call delete on a pointer to a local variable with automatic storage duration, which results in undefined behavior. This object was not allocated with new or any variant of new.

Your code should be:

myClass *p = new myClass();
// use p
delete p;

You probably don't need dynamic memory allocation at all, so...

myClass obj;  // that's it!

Next, read up on smart pointers.

std::unique_ptr<myClass> p(new myClass());
// no delete!  unique_ptr handles it for you when it goes 
// out of scope and has the benefit of being exception safe.

Your obj variable has to hold a reference to the dereferenced pointer, so that it later can (rather oddly) delete it:

myClass& obj;
//     ^

But you need not define it this way, you can define a pointer to the memory instead:

myClass* obj = new myClass();

and delete it this way:

delete obj;

Or, better yet, you can use memory management tools like std::unique_ptr:

std::unique_ptr<myClass> obj(new myClass);

But there really is no use here for dynamic memory as far as I can see, just intantiate it as a normal variable:

myClass obj;

myClass obj= *(new myClass());

This first creates a myClass object with automatic storage duration named obj. This object is initialised by the expression *(new myClass()). This expression dynamically allocates a myClass object and then dereferences the pointer to that object. So what you end up doing here, is dynamically allocating an object and then copying that into obj.

You've now lost track of the dynamically allocated object. That's not good. Doing delete &obj; will only take the address of the automatic object and attempt to destroy that, but you must only use delete with dynamically allocated objects.

You could change obj to be a reference and it would work:

myClass& obj = *(new myClass());

This makes sure the dynamically allocated object isn't copied. However, this isn't a good idea. It masks the fact that obj refers to an object that must be deleted. Instead, you're better off storing the pointer itself:

myClass* obj = new myClass();
// ...
delete obj;

Or even better, use a smart pointer like std::unique_ptr<myClass>.

Or even betterer, don't even both dynamically allocating it. Just use an automatic object:

myClass obj;
// No need to allocate or delete anything