Releasing memory in a function - c++

Question

I was about to ask a rather simple beginner question the other day about a c++ function I was working on when I realized I hadn't released the memory for my function. That never seems to end well around here.
It seems like this would be a common question but I wasn't able to find anything at my level of understanding in c++
How would I properly free memory in this code
#include <iostream>
class thing{
public:
int a;
};
thing makeThing(){
thing *t = new thing;
t -> a = 5;
return *t;
}
int main(){
thing thing1 = makeThing();
std::cout << "a: " << thing1.a << std::endl;
return 0;
}
As far as I know I'm not able to free it after the function terminates.
I tried this:
delete &thing1;
but based on the core dump, I assume that’s not the way to do it.

Answer 1

Since you return by value, that means you return a copy of the object. The original object, created by new things, can't be reached after the function returns (not reliably anyway).
You can return a pointer:
thing* makeThing(){
thing *t = new thing;
t -> a = 5;
return t;
}
And delete that.
But you should really just return an object, and not even allocate anything with new in this case.

Answer 2

Sometimes the simplest way to free memory is to not have allocated it to begin with:
thing makeThing(){
thing t;
t.a = 5;
return t;
}
The reason what you're trying to do doesn't work is that when you have:
delete &thing1;
that's the address of your local object... that's not the address of what you actually allocated. That one got copied into yours, and now you have no way to access it.
If you wanted to allocate your thing, you would need to return the pointer directly. Preferably, wrapped somehow:
std::unique_ptr<thing> makeThing() {
std::unique_ptr<thing> t(new thing);
t->a = 5;
return t;
}

Answer 3

thing makeThing(){
thing *t = new thing;
t -> a = 5;
return *t;
}
Leads to an immediate memory leak. The t variable will go out of scope after makeThing() returns, and the allocated memory will never be released or accessible for release with an appropriate delete statement.
There's a copy of the newly created t returned.
To fix it just create a local variable and retun a copy:
thing makeThing(){
thing t;
t.a = 5;
return t;
}

Answer 4

If you really want to use new this is the right way to do it. This code is C++11, so you may need to turn on some option if that is not already the default in the compiler you are using. I habitually use C++11, since the improvements in that version of the language are really worthwhile.
#include <iostream>
#include <memory>
#include <ostream>
class thing {
public:
int a;
};
std::ostream& operator<<(std::ostream& os, const thing& t) {
os << t.a;
return os;
}
std::unique_ptr<thing> makeThing() {
std::unique_ptr<thing> t(new thing);
t->a = 5;
return std::move(t);
}
int main() {
auto thing1 = makeThing();
std::cout << "a: " << *thing1 << std::endl;
return 0;
}
But really if all you want to do is create an object there is no need to allocate it on the heap. You can just do it like the code below. Notice that the object is created without the use of new. The object is copied when it is returned from makeThing(), and the compiler uses the default copy constructor for class thing (which I did not replace) when doing that.
#include <iostream>
#include <ostream>
thing makeThing() {
thing t;
t.a = 5;
return t;
}
int main() {
auto thing1 = makeThing();
std::cout << "a: " << thing1 << std::endl;
return 0;
}
The ostream inserter does not need to change, so I omitted it. Same for the class definition.