为什么我要在这种情况下使用智能指针？

Question

我从来没有使用过任何类型的智能指针，但是当主题是指针时，我几乎到处都在阅读它们。我确实理解在某些情况下，智能指针比原始指针更好用，因为在某种程度上它们管理指针的所有权。但是，我仍然不知道，“我不需要智能指针”和“这是智能指针的情况”之间的界限在哪里。

比方说，我有以下情况：

class A {
public:
    double get1(){return 1;}
    double get2(){return 2;}
};
class SomeUtilityClass {
public:
    SomeUtilityClass(A* a) : a(a) {}
    double getResult(){return a->get1() + a->get2();}
    void setA(A* a){a = a;}
private:
    A* a;
};
int main(int argc, char** argv) {
    A a;
    SomeUtilityClass u(&a);
    std::cout << u.getResult() << std::endl;
    A a2;
    u.setA(&a2);
    std::cout << u.getResult() << std::endl;
    return 0;
}

这当然是一个过于简单的例子。我的意思是SomeUtilityClass 不应该“拥有”A 的实例（因为它只是一个实用程序类），因此它只包含一个指针。

关于指针，我知道的唯一可能出错的是：

• SomeUtilityClass 可以用空指针实例化
• 指向的对象可能被删除/超出范围，SomeUtilityClass 没有注意到它

智能指针如何帮助避免这个问题？在这种情况下使用智能指针还能获得哪些其他好处？

PS：我知道有几个关于智能指针的问题（例如this one）。但是，如果您能告诉我对这个特定示例的影响，我将不胜感激。

Answer 1

这取决于参数的创建和存储方式。如果您不拥有内存并且它可以是静态或动态分配的，那么原始指针是一个非常合理的解决方案 - 特别是如果您需要支持数据交换，如您的示例中所示。另一种选择是使用std::reference_wrapper，这将消除您的nullptr 问题，同时保持相同的语义。

如果您持有指向某个共享资源的指针（即存储在某处的std::shared_ptr）并希望能够检查它是否已被删除，您可以持有std::weak_ptr。

Answer 2

出于此答案的目的，我将 setA 重新定义为：

void setA(A* new_a){a = new_a;}

考虑：

// Using your SomeUtilityClass

int main() {
  A a;
  SomeUtilityClass u(&a);
  // We define a new scope, just because:
  {
    A b;
    u.setA(&b);
  }
  std::cout << u.getResult() << '\n';
  return 0;
}

作用域结束后，SomeUtilityClass 有一个悬空指针，getResult() 调用未定义行为。请注意，这不能通过参考来解决：您仍然会得到一个悬空的。

现在考虑使用智能指针的版本：

class SomeUtilityClass {
public:
    SomeUtilityClass(std::shared_ptr<A>& a) : a{a} {}
    double getResult(){return a->get1() + a->get2();}
    void setA(std::shared_ptr<A>& new_a){a = new_a;}
private:
    std::shared_ptr<A> a;
};

int main() {
  std::shared_ptr<A> a{new A};
  SomeUtilityClass u{a};
  // We define a new scope, just because:
  {
    std::shared_ptr<A> b{new A};
    u.setA(b);
  }
  std::cout << u.getResult() << '\n';
  return 0;
}

因为您拥有共享所有权，所以无法获得悬空指针。 b 指向的内存将照常删除，但只有在u 被销毁（或其指针改变）之后。

恕我直言，在大多数情况下，您应该使用智能指针（即使起初它似乎没有多大意义）。它使维护变得更加容易。仅在实际需要它们的特定代码中使用原始指针，并尽可能封装/隔离此代码。

Answer 3

如果SomeUtilityClass 不拥有成员变量a，则智能指针没有意义。

你可以考虑一个引用成员，它会消除空指针的问题。

Answer 4

在 C++ 中表示非拥有指针的默认方式是weak_ptr。要使用weak_ptr，您需要使用shared_ptr 作为所有权，因此在您的示例中，您将使用

shared_ptr<A> owner(...)

而不是

A a

然后作为 SomeUtilityClass 的私有指针成员，您使用弱指针：

weak_ptr<A> w;

并用shared_ptr初始化它：

SomeUtilityClass(shared_ptr<A> o) : w(o) {}

但是，您不能直接使用weak_ptr，因为shared_ptr 可能超出范围并且您的弱指针不能再指向任何东西。使用前需要锁定：

shared_ptr<A> locked = w.lock();

如果拥有的指针不再管理一个对象，locked 指针将为空，例如它超出了范围。如果它不为空，你可以使用它，然后它会超出范围自动释放对象的锁定。

shared_ptr 和 weak_ptr 在 C++11 的标准库和旧编译器的 Boost 中都可用。

Answer 5

有不同类型的智能指针。在您的情况下，很明显智能指针并不是真正需要的，但它仍然可以提供一些好处。

SomeUtilityClass 可以用空指针实例化

这个问题可能最好通过检查构造函数来解决，在你得到一个 NULL 指针作为参数的情况下，抛出异常或以其他方式指示错误。我很难想象智能指针会有什么帮助，除非您使用不接受 NULL 的特定智能指针类，因此它已经为您进行了检查。

指向的对象可能被删除/超出范围，没有 SomeUtilityClass 注意到它

这实际上可以用一种特殊类型的智能指针来解决，但是需要被指向的对象以某种方式支持销毁通知。一个这样的例子是Qt库中的QPointer类，它只能指向QObject实例，当被删除时通知它，所以当对象被删除时智能指针自动变为NULL。但是，这种方法存在一些问题：

1. 每次通过智能指针访问对象时都需要检查 NULL。
2. 如果智能指针指向一个类的实例，比如MyClass，扩展执行删除通知的类（在 Qt 案例中为QObject），你会得到奇怪的结果：它通知智能指针的 QObject 的析构函数，因此当MyClass 析构函数已经开始其脏工作时，您可能访问它，因此对象被部分破坏，但指针还不是NULL，因为破坏仍在进展。