The code below is a toy example of something I'm trying to do that might be misguided. I believe this is leaking memory since I'm using new but not deleting. Is that correct, and if so, is there any way to delete the leaking stuff within the main method? Or is it inaccessible at that point?
#include <iostream>
using namespace std;
int* f(){
int* x = new int;
*x = 4;
return x;
};
int main(){
cout << *f();
return 0;
}
The trick would be to capture the returned pointer-value into a variable, so that you can refer to it more than once inside main(). Like this:
int main(){
int * ptr = f();
cout << *ptr;
delete ptr;
return 0;
}
(Side note: it's preferred to return an int by-value instead, but in cases where you are required to dynamically allocate the object you are returning (e.g. when you want to use run-time polymorphism), you should return the allocated object via a smart-pointer rather than a raw/C-style pointer. That way you won't have to remember to delete the returned object, and therefore you can't forget to do so and cause a memory leak)
We have to store the return variable into a integer-type pointer so that it can be accessed into the main.
int main()
{
int * ptr = f();
cout << *ptr;
delete ptr;
return 0;
}
You can do even better: smart pointers!
#include <iostream>
#include <memory>
int* f(){
int* x = new int;
*x = 4;
return x;
};
int main(){
std::cout << *std::unique_ptr<int>(f());
return 0;
} // No memory leak!
Really, you should try to not use new/delete in your own code unless you have to.
