c – 使用shared_ptr作为输出参数

typedef std::shared_ptr<Object> ObjectPtr;

class APIClass
{
    ErrorCode SetSomething(int i);
    ErrorCode IsSomethingSet(bool* ask);
    ErrorCode DoSomething();
    ErrorCode GetSomething(ObjectPtr* outObj);
}

ErrorCode res;
ObjectPtr obj;
res = myApiClass->GetSomething(&obj);

ErrorCode APIClass::GetSomething(ObjectPtr* outObj)
{
   ObjectPtr temp(new Object(),CleanUpFunction<Object>);

   // Do something with object temp.
   ...

   *outObj= temp;

   return OK;
}

这很好,但我会问在这种情况下是否真的需要共享指针.主要是因为你无法以任何理智的方式从shared_ptr释放指针……这可能会在以后导致问题.而shared_ptr实际上意味着底层资源的未指定或共享所有权.

我通常记录函数并使用类似的东西：

// Caller must delete the outObj once done.
ErrorCode APIClass::GetSomething( Object* & outObj )
{
  // I use auto_ptr so I can release it later...
  // Mostly I hate auto_ptr,but for this its invaluable.

  auto_ptr<Object> obj( new Object );
  ...
  outObj = obj.release();
  return OK;
}

这样,客户端需要将指针存储到其中,并且很明显对象的所有权传递给调用者.

然后,客户端代码可以使用适当的容器.

Object * obj_raw;
ErrorCode ec = apiClass.GetSomething( obj_raw )
if( ec!=OK ) { .. do something with ec .. }
shared_ptr<Object> obj( obj_raw );

要么

auto_ptr<Object> obj( obj_raw );

要么

scoped_ptr<Object> obj( obj_raw);

等等

请注意,如果将函数定义更改为：

// Caller must delete the return value.
// On error,NULL is returned and e filled in appropriately.
Object* APIClass::GetSomething( ErrorCode & e )
{
   auto_ptr<Object> obj( new Object );
   ..
   e = OK;
   return obj.release();
}

//Now using it looks like this:
ErrorCode ec;
shared_ptr<Object> obj( apiObject.GetSomething(ec) ); 
if(!obj)
{
   .. do something with ec ..
}