AUTOSAR C++14 Rule A8-4-12

If you expect the function to take ownership of the managed object, pass the smart pointer by value. For instance, the std::unique_ptr argument of the caller in this code is moved-from and ownership of the int object is transferred to an implicitly constructed std::unique_ptr smart pointer, which is then passed to the function func().

void func(std::unique_ptr<int>) {}
void otherFunc()
{
    auto smartPtr = make_unique<int>(1);
    func(std::move(smartPtr)); //caller
}

If you expect the function to replace the object that the smart pointer manages, pass the smart pointer as an lvalue reference. For instance, you might replace the managed object by calling the assignment operator or the reset() smart pointer member function. For example, uniquePtr is reset inside func() and no longer manages the int object in this code.

void func(std::unique_ptr<int>& smartPtr)
{
    smartPtr.reset();
}
void otherFunc
{
    auto uniquePtr = make_unique<int>(1);
    func(std::move(uniquePtr); //caller
}

The parameter is used as the destination of a move assignment.

The parameter is moved-from through a call to std::move.

The parameter is used as the argument of std::unique_ptr member functions reset(), swap(), or release().

The parameter is used as the argument of any function that takes a non-const qualified lvalue reference to an std::unique_ptr smart pointer, regardless of the implementation of the callee.

The pointer is used as a parameter of a template function. The parameter type of template functions depends on the instantiation of the function and a fix is not always possible at the template design level. For instance, Polyspace does not report the use of unique pointer ptr as parameter in this code.

#include <iostream>
#include <memory>
#include <cassert>

template <typename T>
double XtimesY(T& ptr) // Use of ptr not flagged
{
  return (ptr->x) * (ptr->y);
  // ...
}
struct S
{
  double x;
  double y;
  S(double x0, double y0) : x{x0}, y{y0} {}
};
void func()
{
  auto a = std::make_unique<S>{100.0, 200.0};
  auto b = new S(100.0, 200.0);
  assert(XtimesY(a) == XtimesY(b));
}

The smart pointer parameter is captured by a lambda function inside the function body. For instance, Polyspace does not report a violation when you use an lvalue reference to unique pointer ptr as a parameter of func() because it is captured by a lambda function inside the body of func(). Polyspace reports the use of lambda function parameter up1 because its lifetime is not modified inside the lambda function.

#include <memory>

struct S
{
  double x;
  double y;
  S(double x0, double y0) : x{x0}, y{y0} {}
};

void func(std::unique_ptr<S>& ptr)
{ // no defect is detected on 'ptr'
  auto lambdaF =
      [&ptr0 = ptr]            // 'ptr' is captured (by reference)
      (std::unique_ptr<S> up1) // Non-compliant
  {                            // lifetime of 'up1' not affected
    // ...
  };
  auto b = std::make_unique<S>(100.0, 200.0);
  lambdaF(std::move(b));
}