C++ 何时使用unique_ptr而不是本地对象？

我想知道什么时候我们应该使用

unique\u ptr

（或者

boost:：scope\u ptr

）而不是本地对象

我可以想到两种可能的情况：

对象太大，超过了线程的堆栈大小。但在这种情况下，您总是可以增加线程的大小

多态性。e、 g.

unique\u ptr p；如果。。。p、 重置（新C1）；其他p.重置（新C2）。但我不确定我们到底什么时候需要这个。如果这个
p
是函数的一个参数，我们可以简单地说：
如果。。。foo（新C1）；else-foo（新指挥控制）

是否还有其他情况需要使用

unique\u ptr

而不是本地对象？

多态性是一个常见的原因。一个典型的例子是，您的对象是由一个返回

唯一\u ptr

的工厂创建的：

std::unique_ptr<C> factoryFunction(int arg) {
  switch (arg) {
    case 1:
      return std::make_unique<C1>();
    case 2:
      return std::make_unique<C2>();
    default:
      return nullptr; 
  }
}

void someFunction(int arg) {
  auto c = factoryFunction(arg);
  if (c) {
    // do something with c...
  }
}

unique_ptr

比

shared_ptr

的开销更小，而且所有权更清晰。如果需要共享所有权，我只会使用

shared\u ptr

将

unique\u ptr

传递到函数中意味着将所有权转移到函数中（“接收器”）。例如，构造函数：

class Foo {
 private:
  std::unique_ptr<BigArray> array_;
 public:
  Foo(std::unique_ptr<BigArray> array) : array_(std::move(array)) {}
};

void someFunction() {
    auto big = getBig();
    auto foo = Foo(std::move(big));
    // do something with foo...
}

class-Foo{
私人：
std：：唯一的ptr数组；
公众：
Foo（std:：unique_ptr数组）：数组（std:：move（array））{
};
void函数（）{
auto big=getBig（）；
自动foo=foo（标准：：移动（大））；
//用foo做点什么。。。
}

unique\u ptr

不会创建全新的存储持续时间类型。所以，您的问题实际上是关于使用堆栈还是使用堆。这应该会有所帮助。在我看来，第一个原因相当深奥。表示如此大量数据的对象很可能会在堆内部分配它（例如，

std:：vector

或

std:：string

）。更改堆栈大小总是有黑客攻击的味道。YMMV@Pradhan如果我需要一个比它声明的作用域更长的变量，我将使用heap，与您提供的链接的答案相同。但在这种情况下，我更喜欢

shared\u ptr

。我仍然看不到最适合

独特的\u ptr

。

class Foo {
 private:
  std::unique_ptr<BigArray> array_;
 public:
  Foo(std::unique_ptr<BigArray> array) : array_(std::move(array)) {}
};

void someFunction() {
    auto big = getBig();
    auto foo = Foo(std::move(big));
    // do something with foo...
}