I solved the problem.
I created a pointer for newPoly instead.
I would just like to understand why this is so? the pointer is not deleted by the destructor?
OK blackx, firstly this is a multinational you may well not get an answer for up to 24 hours as the expet answering your question may not be in the same time zone as you.
As to your question and solution, your solution is not a solution. It is adding another bug on top of already buggy code.
Starting with you original operator* and original question, the reason that the delete operator is called when the function returns is that the function returns Polynomial, this means that a temporary object is created on the heap to hold this return value and as soon as it goes out of scope (at the end of the calling statement) the compiler deletes it.
The reason that you get garbage in p3 is a little more involved and I am going to have to make some guesses. I guess that Polynomial::head is a pointer and that you allocate data for it (call new) in the constructor (and possibly in other places) and you delete it in the destructor.
Now your copy constructor (and assignment operator??) just copies the value of head from one object to another, so both objects end up pointing at the same block of allocated memory. This is the root your problem, if you create a Polynomial, newPoly in operator*, and then construct another Polynomial from it , as happens when operator* returns to create the temporary variable then both of the 2 instances of Polynomial have the head pointing at the same piece of allocated data. If one of those 2 instances then gets deleted, as happens to newPoly when operator* returns, then the that memory that head points to is deleted and the other instance of Polynomial ends up with an invalid head pointer.
What your "solution" does is rather than create newPoly on the stack and have the compiler automatically delete it you have created it on the heap using new. When you do this it is your responsibility to delete it (or put in place a mechanism that does it for you like smart pointers). However you never delete it, because it doesn't get deleted you have a memory leak. You get the answer you want because there is no temporary object created (or the object is a pointer rather than a Polynomial) so no object referring to that particular head is deleted, newPoly is not deleted and a temporary Polynomial is not created and deleted. Therefore the memory that head points to in p3 is not deleted at any time so it is valid and p3 apparently has the correct answer.
But you do have a memory leak which will ultimately bring your program crashing down.
The correct solution to your problem is in the copy constructor and assignment operator (if you need one your normally need the other), when copying a Polynomial from 1 object to another rather than copying head (a flat copy) what you should be doing is allocating new data for the destination polynomial and copying the data that head points to. Then when an Polynomial object is deleted and head is deleted it will not effect any other objects as they each have their own memory.