使用shared_ptr将原始指针传递给函数

Question

When I have a function:

void foo(std::shared_ptr<T> a, std::shared_ptr<T> b);

is there a chance of memory leak when calling it like this:

foo(new T(), new T());

Answer 1

That won't compile since the conversion to shared_ptr is explicit. If I were to naively fix that:

foo(std::shared_ptr<T>(new T()), std::shared_ptr<T>(new T()));  // don't do this

then there is indeed a chance of a memory leak. One allowed order of evaluation is:

T * p1 = new T();
T * p2 = new T();
std::shared_ptr<T> s1(p1);
std::shared_ptr<T> s2(p2);
foo(s1,s2);

If the second new throws an exception, then the first object would be leaked. To fix this, make sure the first shared pointer is initialised before attempting the second allocation, either with a temporary variable:

std::shared_ptr<T> a(new T());
std::shared_ptr<T> b(new T());
foo(a,b);

or calling a function to initialise each

foo(std::make_shared<T>(), std::make_shared<T>());

Answer 2

As @Mike said, your source won't compile. You need an explicit construction of shared_ptr , such as:

foo(std::shared_ptr<T>(new T()), std::shared_ptr<T>(new T()));

It's still unsafe. In c++ expressions used as function arguments may generally be evaluated in any order, including interleaved, except as otherwise restricted by the other rules.

For one example, the order may be:

1. allocate memory for the first T
2. construct the first T
3. allocate memory for the second T
4. construct the second T
5. construct the shared_ptr
6. construct the shared_ptr

And if step(3) or (4) failed (by throwing), The object constructed at step(2) will not be destructed, and memory allocated at step(1) will leak.