Safe to use vector.emplace_back( new MyPointer ); Could failure inside vector lead to leaked memory?

Question

Is it safe to use

vector.emplace_back( new MyPointer() );

Or could an exception thrown or some failure inside vector cause memory leak?

Would it be better to do some form of the following, where you put the pointer in a temporary unique_ptr first.

vector.emplace_back( std::unique_ptr<MyPointer>( new MyPointer() ) );

So if a vector failure occurs the temporary unique_ptr will still clean up the memory?

I suggest `std::make_unique` once some C++14 support is available or your own if not. — chris, Oct 16 '13 at 21:35

score 14 · Accepted Answer · edited May 23 '17 at 11:54

14

It is not safe and would create a memory leak if you use the first version. The documentation says that if an exception is thrown, the call to emplace has no effect - which means the plain pointer you passed in is never deleted.

You can use

vector.emplace_back( std::unique_ptr<MyPointer>( new MyPointer() ) );

or with C++14 you can use

vector.emplace_back( std::make_unique<MyPointer>() );

or, if C++14 is not yet available, just roll your own version of make_unique. You can find it here.

edited May 23 '17 at 11:54

Community

1
1

answered Oct 16 '13 at 21:38

Daniel Frey

55,810
13
122
180

3

you also need to change the type of the `vector` with the above. If that is infeasible, you can store the added element outside in a smart pointer, add it, then detech if it worked. – Yakk - Adam Nevraumont Oct 16 '13 at 23:00
You mean 'C++11' instead of 'C++14'? – fnc12 Dec 27 '14 at 16:23
2

@fnc12 No, I meant C++14. [`std::make_unique`](http://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique) was not available/standardized in C++11. – Daniel Frey Dec 27 '14 at 20:33
I did not know it. Thanks – fnc12 Dec 28 '14 at 06:50

marack · Answer 2 · 2013-10-17T02:47:26.900

No, the first scenario is not safe and will leak memory if the vector throws an exception.

The second scenario will not compile, as a std::unique_ptr<T> cannot be implicitly converted to T*. Even if it could, this scenario is arguably worse than the first, because it will add the pointer to your vector, then immediately delete the object being pointed to. You will be left with a vector containing a dangling pointer.

Without changing the type of your std::vector (which I assume is std::vector<MyPointer*>) there are two ways to make this code exception safe.

Using C++11:

auto ptr = std::unique_ptr<MyPointer>(new MyPointer());
vector.emplace_back(ptr.get());
ptr.release();

Or the more verbose C++03 way:

MyPointer* ptr = new MyPointer();
try
{
  vector.push_back(ptr);
}
catch (...)
{
  delete ptr;
  throw;
}

If you are able to change the type of your std::vector<MyPointer*> then the easiest method are those suggested by Daniel Frey above:

std::vector<std::unique_ptr<MyPointer>> vector;
vector.emplace_back(std::unique_ptr<MyPointer>(new MyPointer()));

Or with C++14:

std::vector<std::unique_ptr<MyPointer>> vector;
vector.emplace_back(std::make_unique<MyPointer>());

Safe to use vector.emplace_back( new MyPointer ); Could failure inside vector lead to leaked memory?

2 Answers2

Linked