Add nullptr support to scoped_ptr.

base/memory/scoped_ptr.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Scopers help you manage ownership of a pointer, helping you easily manage a
 // pointer within a scope, and automatically destroying the pointer at the end
 // of a scope.  There are two main classes you will use, which correspond to the
 // operators new/delete and new[]/delete[].
 //
 // Example usage (scoped_ptr<T>):
@@ skipping 171 matching lines @@
         !base::is_convertible<T*, base::subtle::RefCountedThreadSafeBase*>::
             value
   };
 };
 
 // Minimal implementation of the core logic of scoped_ptr, suitable for
 // reuse in both scoped_ptr and its specializations.
 template <class T, class D>
 class scoped_ptr_impl {
  public:
-  explicit scoped_ptr_impl(T* p) : data_(p) { }
+  explicit scoped_ptr_impl(T* p) : data_(p) {}
 
   // Initializer for deleters that have data parameters.
   scoped_ptr_impl(T* p, const D& d) : data_(p, d) {}
 
   // Templated constructor that destructively takes the value from another
   // scoped_ptr_impl.
   template <typename U, typename V>
   scoped_ptr_impl(scoped_ptr_impl<U, V>* other)
       : data_(other->release(), other->get_deleter()) {
     // We do not support move-only deleters.  We could modify our move
@@ skipping 109 matching lines @@
 
   COMPILE_ASSERT(base::internal::IsNotRefCounted<T>::value,
                  T_is_refcounted_type_and_needs_scoped_refptr);
 
  public:
   // The element and deleter types.
   typedef T element_type;
   typedef D deleter_type;
 
   // Constructor.  Defaults to initializing with NULL.
-  scoped_ptr() : impl_(NULL) { }
+  scoped_ptr() : impl_(NULL) {}

[jamesr, 2014/09/25 05:58:08]

nit: impl_(nullptr) ?

 
   // Constructor.  Takes ownership of p.
-  explicit scoped_ptr(element_type* p) : impl_(p) { }
+  explicit scoped_ptr(element_type* p) : impl_(p) {}
 
   // Constructor.  Allows initialization of a stateful deleter.
-  scoped_ptr(element_type* p, const D& d) : impl_(p, d) { }
+  scoped_ptr(element_type* p, const D& d) : impl_(p, d) {}
+
+  // Constructor.  Allows construction from a nullptr.
+  scoped_ptr(decltype(nullptr)) : impl_(NULL) {}
 
   // Constructor.  Allows construction from a scoped_ptr rvalue for a
   // convertible type and deleter.
   //
   // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this constructor distinct

[jamesr, 2014/09/25 05:58:08]

does this note still apply?

[danakj, 2014/09/25 14:47:52]

I think so. unique_ptr has 2 constructors:
unique_ptr(unique_ptr&&)
template <U,E> unique_ptr(unique_ptr<T,E>&&)

Where as scoped_ptr just has the latter. I believe that's what this comment is
about.

[danakj, 2014/09/25 14:50:19]

Rather,

unique_ptr(unique_ptr&&)
template <U,E> unique_ptr(unique_ptr<U,E>&&)

   // from the normal move constructor. By C++11 20.7.1.2.1.21, this constructor
   // has different post-conditions if D is a reference type. Since this
   // implementation does not support deleters with reference type,
   // we do not need a separate move constructor allowing us to avoid one
   // use of SFINAE. You only need to care about this if you modify the
   // implementation of scoped_ptr.
   template <typename U, typename V>
-  scoped_ptr(scoped_ptr<U, V> other) : impl_(&other.impl_) {
+  scoped_ptr(scoped_ptr<U, V>&& other)
+      : impl_(&other.impl_) {
     COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
   }
 
   // Constructor.  Move constructor for C++03 move emulation of this type.
-  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { }
+  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) {}
 
   // operator=.  Allows assignment from a scoped_ptr rvalue for a convertible
   // type and deleter.
   //
   // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this operator= distinct from
   // the normal move assignment operator. By C++11 20.7.1.2.3.4, this templated
   // form has different requirements on for move-only Deleters. Since this
   // implementation does not support move-only Deleters, we do not need a
   // separate move assignment operator allowing us to avoid one use of SFINAE.
   // You only need to care about this if you modify the implementation of
   // scoped_ptr.
   template <typename U, typename V>
-  scoped_ptr& operator=(scoped_ptr<U, V> rhs) {
+  scoped_ptr& operator=(scoped_ptr<U, V>&& rhs) {
     COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
     impl_.TakeState(&rhs.impl_);
     return *this;
   }
 
+  // operator=.  Allows assignment from a nullptr. Deletes the currently owned
+  // object, if any.
+  scoped_ptr& operator=(decltype(nullptr)) {
+    reset();
+    return *this;
+  }
+
   // Reset.  Deletes the currently owned object, if any.
   // Then takes ownership of a new object, if given.
   void reset(element_type* p = NULL) { impl_.reset(p); }
 
   // Accessors to get the owned object.
   // operator* and operator-> will assert() if there is no current object.
   element_type& operator*() const {
     assert(impl_.get() != NULL);
     return *impl_.get();
   }
@@ skipping 71 matching lines @@
 template <class T, class D>
 class scoped_ptr<T[], D> {
   MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
 
  public:
   // The element and deleter types.
   typedef T element_type;
   typedef D deleter_type;
 
   // Constructor.  Defaults to initializing with NULL.
-  scoped_ptr() : impl_(NULL) { }
+  scoped_ptr() : impl_(NULL) {}

[jamesr, 2014/09/25 05:58:08]

s/NULL/nullptr/, same for the rest of file

 
   // Constructor. Stores the given array. Note that the argument's type
   // must exactly match T*. In particular:
   // - it cannot be a pointer to a type derived from T, because it is
   //   inherently unsafe in the general case to access an array through a
   //   pointer whose dynamic type does not match its static type (eg., if
   //   T and the derived types had different sizes access would be
   //   incorrectly calculated). Deletion is also always undefined
   //   (C++98 [expr.delete]p3). If you're doing this, fix your code.
   // - it cannot be NULL, because NULL is an integral expression, not a

[jamesr, 2014/09/25 05:58:08]

update this part of the comment plz

   //   pointer to T. Use the no-argument version instead of explicitly
   //   passing NULL.
   // - it cannot be const-qualified differently from T per unique_ptr spec
   //   (http://cplusplus.github.com/LWG/lwg-active.html#2118). Users wanting
   //   to work around this may use implicit_cast<const T*>().
   //   However, because of the first bullet in this comment, users MUST
   //   NOT use implicit_cast<Base*>() to upcast the static type of the array.
-  explicit scoped_ptr(element_type* array) : impl_(array) { }
+  explicit scoped_ptr(element_type* array) : impl_(array) {}
+
+  // Constructor.  Allows construction from a nullptr.
+  scoped_ptr(decltype(nullptr)) : impl_(NULL) {}
+
+  // Constructor.  Allows construction from a scoped_ptr rvalue.
+  scoped_ptr(scoped_ptr&& other) : impl_(&other.impl_) {}
 
   // Constructor.  Move constructor for C++03 move emulation of this type.
-  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { }
+  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) {}
+
+  // operator=.  Allows assignment from a scoped_ptr rvalue.
+  scoped_ptr& operator=(scoped_ptr&& rhs) {
+    impl_.TakeState(&rhs.impl_);
+    return *this;
+  }
 
   // operator=.  Move operator= for C++03 move emulation of this type.
   scoped_ptr& operator=(RValue rhs) {
     impl_.TakeState(&rhs.object->impl_);
     return *this;
   }
 
+  // operator=.  Allows assignment from a nullptr. Deletes the currently owned
+  // array, if any.
+  scoped_ptr& operator=(decltype(nullptr)) {
+    reset();
+    return *this;
+  }
+
   // Reset.  Deletes the currently owned array, if any.
   // Then takes ownership of a new object, if given.
   void reset(element_type* array = NULL) { impl_.reset(array); }
 
   // Accessors to get the owned array.
   element_type& operator[](size_t i) const {
     assert(impl_.get() != NULL);
     return impl_.get()[i];
   }
   element_type* get() const { return impl_.get(); }
@@ skipping 77 matching lines @@
 
 // A function to convert T* into scoped_ptr<T>
 // Doing e.g. make_scoped_ptr(new FooBarBaz<type>(arg)) is a shorter notation
 // for scoped_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
 template <typename T>
 scoped_ptr<T> make_scoped_ptr(T* ptr) {
   return scoped_ptr<T>(ptr);
 }
 
 #endif  // BASE_MEMORY_SCOPED_PTR_H_