New and delete mix ups - c++

Question

I have a small problem with using the new and delete operators. I read in a bunch of places that every new operator has to correspond to a delete, and as I understand it, variables created with new will persist until they are hit with that delete. If you would please look at the following code, it's longish but straightforward:
#include <iostream>
using namespace std;
int* testFunction1();
int* testFunction2();
int main(){
int* ptr1 = testFunction1();
int* ptr2 = testFunction2();
cout << *ptr1 << endl; // outputs 5
cout << *(ptr1 - 1) << endl; // outputs random int
cout << *ptr2 << endl; // outputs random int
cout << ptr1 << endl; //prints address of b from testFunction1()
cout << ptr1 - 1 << endl; // prints address of a and c from testFunction1()
cout << ptr2 << endl; // prints address of a and c from testFunction1()
cout << endl;
// delete ptr1; won't work
return 0;
}
int* testFunction1(){
int a = 5, b = 10;
int* pointerToInt1 = new int;
pointerToInt1 = &a;
pointerToInt1 = &b;
cout << &a << endl;
cout << &b << endl;
return pointerToInt1;
}
int* testFunction2(){
int c = 5;
int* pointerToInt2 = &c;
cout << &c << endl;
return pointerToInt2;
}
I have two questions:
I figured that, with testFunction1(), I am returning the pointer by value. But I don't know how to fix that, to return a reference to the pointer, so that I can free the memory in the main method (or for that matter, any other method).
Why did I get 5 as an output when I dereferenced *ptr1? I mean, from the address output, it's clear that the value assigned to c in testFunction2() was stored there, but why did that happen?

Answer 1

Let's don't put your questions aside and explain your code first.
You declare and defined a function named testFunction1 which returns int poitner
int* testFunction1(){
int a = 5, b = 10; // define local variables with initial values. a,b have different memory addresses
int* pointerToInt1 = new int; // dynamic allocate pointer(new address) to int
pointerToInt1 = &a; // set pointerToInt1 to point to address of a
pointerToInt1 = &b; // set pointerToInt1 to point to address of b
cout << &a << endl;
cout << &b << endl;
return pointerToInt1; // return pointerToInt1 pointer which currently points to address of b
}
a,b are local variables inside function testFunction1, they have automatic duration, when function finishes they are release, so pointerToInt1 actually is dangling pointer and access it is undefined behavior.
Also a typical memory leak is introduce in testFunction1, original memory block allocated by new is lost.
int* pointerToInt1 = new int;
pointerToInt1 = &a;
Now, let's "fix" function testFunction1, yup, I mean fix with double quotes.
int* testFunction1(){
int a = 5, b = 10;
int* pointerToInt1 = new int;
*pointerToInt1 = a; // copy a to memory pointerToInt1
*pointerToInt1 = b; // copy b to memory pointerToInt1
cout << &a << endl;
cout << &b << endl;
return pointerToInt1; // return pointerToInt1 pointer
}
After you call function testFunction1, you still need to delete the dynamically allocated memory block.
int *p = testFunction1();
delete p;
Now if you go back and review your two questions, do you get the answer?

Answer 2

You are setting the pointer to a variable allocated on stack:
int a = 5, b = 10;
int* pointerToInt1 = new int; // allocates an int on heap
pointerToInt1 = &a; // overwrite pointer with a local variable
What happens is that the pointer you return points to a value that has automatic allocation on stack so the pinter becomes invalid when the function exits its scope.
In addition, since you lose any reference to the object you allocated dynamically on heap, you can't delete it anymore so it's leaked memory.
Finally the delete tries to delete a pointer which points to an address that was on stack during the call to testFunction1 so it's not a valid pointer anymore, hence delete doesn't work.