为什么 std：：unique_ptr 不隐式转换为 T* 和 const T*？

Why doesn't std::unique_ptr implicitly convert to T* and const T*?

本文关键字：const 转换 unique std ptr 为什么      更新时间：2023-10-16

如果我自己写，我想我会做这样的事情：

template<typename T, typename Dtor = std::default_delete<T> >
class Uptr : private Dtor {
  T* vl_;
public:
  explicit Uptr(T* vl = nullptr) noexcept : vl_(vl) {}
  ~Uptr() noexcept { Dtor::operator()(vl_); }
  Uptr& swap(Uptr& o) noexcept { T* tmp; tmp = vl_; vl_=o.vl_; o.vl_ = tmp; }
  Uptr& operator=(Uptr&& o) noexcept { o.swap(*this); }
  Uptr& operator=(nullptr_t) noexcept { vl_=nullptr; return *this; } 
  Uptr(Uptr&& o) noexcept : Uptr(nullptr) { *this = std::move(o); } 
  Uptr(const Uptr& o) = delete;
  Uptr& operator=(const Uptr& o) = delete;

  operator T*() noexcept { return vl_; } 
  operator const T*() const noexcept { return vl_; } 
  T* release() noexcept { T* ret = vl_; vl_=nullptr; return ret; }    
  const Dtor& deleter() const noexcept { return *(static_cast<Dtor*>(this)); }
  Dtor& deleter() noexcept { return *(static_cast<Dtor*>(this)); }
};

并且不必定义get()和运算符*、->和[]。

在这种情况下进行隐式转换有什么问题？

我不认为你的问题特定于unique_ptr，而是询问一般的智能指针。

赫伯·萨特(Herb Sutter(很久以前就写过这个问题。显然，它将允许您编写逻辑错误的代码，例如：

unique_ptr<something> p;
...
delete p; // p is a smart pointer - probably not what you want.

和其他类似的代码。

正如其他人指出的那样，可能会发生一些烦人的错误，例如 

T* f() { unique_ptr p{...}; return p; } // oops
unique_ptr p{...}; delete p; // oops

和

unique_ptr get_up();
shared_ptr sp{get_up()}; // cool, this works: promote UP to SP
// does it work the other way around?
shared_ptr get_sp();
unique_ptr p{get_sp()}; // compiles, then yes! eh, wait.. BOOM!

等等。考虑到该语言是为人类设计的，在这种情况下，通过明确所有内容来避免这些陷阱会更安全。

我没有正式的答案，但我知道为什么这没有多大意义。unique_ptr的整个思想是一种强类型(即编译器强制(的方式来承载对象的唯一所有权。因此，移动语义。

在这种情况下，让unique_ptr要求你显式请求其原始指针是有意义的，因为一旦你有了原始值，你就可以很容易地破坏所有内容：你可以delete它，你可以把它传递给另一个智能指针(反过来会在某个时候删除它(，或者做指针算术并意外地处理结果(可能不指向分配的内存(或类似的东西那。其中一些可能会立即导致编译器错误，而另一些则可能导致未定义的行为。对于像unique_ptr这样的高级类，这是不可取的，至少不是隐含的。当然，您可以使用 .get() 执行相同的操作，但在这种情况下，您知道您正在使用原始指针值，并且不得释放它。

Ami发布的链接也非常相关，但我认为最好引用另一个例子：

unique_ptr p( new widget );
...
use( p + 42 ); // error (maybe he meant "*p + 42"?)
    // but if implicit conversion to * were allowed, would silently compile -- urk

C++哲学是，可以在给定类型上运行的公共函数属于该类型的接口。控制和限制隐式转换为指针的类型的接口几乎是不可能的。智能指针的故意限制性质将被完全解构，导致容易出错的代码。

相关文章：