Question

std::vector具有成员函数at()作为operator[]的安全替代，因此应用绑定检查并且不会创建悬空引用：

void foo(std::vector<int> const&x)
{
  const auto&a=x[0];     // What if x.empty()? Undefined behavior!
  const auto&a=x.at(0);  // Throws exception if x.empty().
}

但是，std::unique_ptr缺少相应的功能：

void foo(std::unique_ptr<int> const&x)
{
  const auto&a=*x;       // What if bool(x)==false? Undefined behavior!
}

如果std::unique_ptr有这样一个安全的选择，那么会很好，比如成员ref()（和cref()）永远不会返回悬空引用，而是抛出异常。可能的实施：

template<typename T>
typename add_lvalue_reference<T>::type
unique_ptr<T>::ref() const noexcept(false)
{
  if(bool(*this)==false)
    throw run_time_error("trying to de-refrence null unique_ptr");
  return this->operator*();
}

为什么标准没有提供这种东西有充分的理由吗？

Answer 1

unique_ptr专门设计为具有空状态检测的轻量级指针类（例如optional中的A proposal to add a utility class to represent optional objects (Revision 3)中所述）

也就是说，自operator*文档说明以来，您所要求的功能已经就位：

// may throw, e.g. if pointer defines a throwing operator*
typename std::add_lvalue_reference<T>::type operator*() const;

pointer类型is defined as

std::remove_reference<Deleter>::type::pointer if that type exists, otherwise T*

因此，通过自定义删除器，您可以执行任何即时操作，包括空指针检查和异常抛出

#include <iostream>
#include <memory>

struct Foo { // object to manage
    Foo() { std::cout << "Foo ctor\n"; }
    Foo(const Foo&) { std::cout << "Foo copy ctor\n"; }
    Foo(Foo&&) { std::cout << "Foo move ctor\n"; }
    ~Foo() { std::cout << "~Foo dtor\n"; }
};

struct Exception {};

struct InternalPtr {
    Foo *ptr = nullptr;
    InternalPtr(Foo *p) : ptr(p) {}
    InternalPtr() = default;

    Foo& operator*() const {
        std::cout << "Checking for a null pointer.." << std::endl;
        if(ptr == nullptr)
            throw Exception();
        return *ptr;
    }

    bool operator != (Foo *p) {
        if(p != ptr)
            return false;
        else
            return true;
    }
    void cleanup() {
      if(ptr != nullptr)
        delete ptr;
    }
};

struct D { // deleter
    using pointer = InternalPtr;
    D() {};
    D(const D&) { std::cout << "D copy ctor\n"; }
    D(D&) { std::cout << "D non-const copy ctor\n";}
    D(D&&) { std::cout << "D move ctor \n"; }
    void operator()(InternalPtr& p) const {
        std::cout << "D is deleting a Foo\n";
        p.cleanup();
    };
};

int main()
{
    std::unique_ptr<Foo, D> up(nullptr, D()); // deleter is moved

    try {
      auto& e = *up;      
    } catch(Exception&) {
        std::cout << "null pointer exception detected" << std::endl;
    }

}

Live Example

为了完整起见，我将发布两个额外的替代方案/解决方法：

通过unique_ptr

检查operator bool的指针

#include <iostream>
#include <memory>

int main()
{
    std::unique_ptr<int> ptr(new int(42));

    if (ptr) std::cout << "before reset, ptr is: " << *ptr << '\n';
    ptr.reset();
    if (ptr) std::cout << "after reset, ptr is: " << *ptr << '\n';
}

（这可能是解决问题的最直接方式）

另一种解决方案，虽然更加混乱，但is to use a wrapper type which takes care of the exception handling

Answer 2

我怀疑真正的答案很简单，而且很多“为什么不是这样的C ++？”问题：

没有人提出它。

std::vector和std::unique_ptr不是由同一个人同时设计的，并且没有以相同的方式使用，因此不一定遵循相同的设计原则。

Answer 3

我不能说，为什么委员会决定不添加安全的退税方法 - 答案可能是＆＃34;因为它没有被提议＆＃34; 或＆＃34;因为原始指针不是＆＃34; 。但是自己编写一个自由函数模板是很简单的，它将任何指针作为参数，将它与nullptr进行比较，然后抛出异常或返回对指向对象的引用。

如果你不通过指向基类的指针删除它，甚至可以从unique_ptr公开派生，只需添加这样的成员函数。

请记住，在任何地方使用这种经过检查的方法都可能会导致严重的性能损失（与at相同）。通常，您希望最多验证一次参数，开头的单个if语句更适合。

还有一所学校说你不应该因为编程错误而抛出异常。也许负责设计unique_ptr的peopke属于这所学校，而设计矢量（更老的人）的人并不是。

Answer 4

智能指针API设计的主要目标之一是成为替代品，具有附加价值，没有陷阱或副作用，并且接近零开销。 if (ptr) ptr->...通常是如何安全地访问裸指针，相同的语法与智能指针很好地配合，因此当一个被另一个替换时不需要更改代码。

对指针放置的有效性的额外检查（例如，抛出异常）会干扰分支预测器，因此可能会对性能产生连锁效应，这可能不会被视为零成本直接替换了。

Answer 5

你有

operator bool()

示例来自： cplusplusreference

// example of unique_ptr::operator bool
#include <iostream>
#include <memory>


int main () {
  std::unique_ptr<int> foo;
  std::unique_ptr<int> bar (new int(12));

  if (foo) std::cout << "foo points to " << *foo << '\n';
  else std::cout << "foo is empty\n";

  if (bar) std::cout << "bar points to " << *bar << '\n';
  else std::cout << "bar is empty\n";

  return 0;
}

unique_ptr是原始指针的简单包装器，当您只需轻松检查布尔条件时，无需抛出异常。

编辑：显然operator*可以投掷。

例外 1）可以投掷，例如如果指针定义了抛出运算符*

也许有人可以在热点上熄灯以定义投掷操作员*

Answer 6

根据MikeMB的建议，这里有一个免费函数的实现，用于解除引用指针和unique_ptr的相似内容。

template<typename T>
inline T& dereference(T* ptr) noexcept(false)
{
  if(!ptr) throw std::runtime_error("attempt to dereference a nullptr");
  return *ptr;
}

template<typename T>
inline T& dereference(std::unique_ptr<T> const& ptr) noexcept(false)
{
  if(!ptr) throw std::runtime_error("attempt to dereference an empty unique_ptr)");
  return *ptr;
}

为什么unique_ptr :: operator *（）没有安全的替代方案？

6 个答案: