Allow scoped_ptr variables to be used in boolean expressions

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 the
 // 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):
@@ skipping 185 matching lines @@
   C& operator*() const {
     assert(ptr_ != NULL);
     return *ptr_;
   }
   C* operator->() const  {
     assert(ptr_ != NULL);
     return ptr_;
   }
   C* get() const { return ptr_; }
 
+  // Allow scoped_ptr<C> to be used in boolean expressions, but not
+  // implicitly convertible to a real bool (which is dangerous).
+  typedef C* scoped_ptr::*Testable;
+  operator Testable() const { return ptr_ ? &scoped_ptr::ptr_ : NULL; }
+
   // Comparison operators.
   // These return whether two scoped_ptr refer to the same object, not just to
   // two different but equal objects.
   bool operator==(C* p) const { return ptr_ == p; }
   bool operator!=(C* p) const { return ptr_ != p; }
 
   // Swap two scoped pointers.
   void swap(scoped_ptr& p2) {
     C* tmp = ptr_;
     ptr_ = p2.ptr_;
@@ skipping 105 matching lines @@
     assert(array_ != NULL);
     return array_[i];
   }
 
   // Get a pointer to the zeroth element of the current object.
   // If there is no current object, return NULL.
   C* get() const {
     return array_;
   }
 
+  // Allow scoped_array<C> to be used in boolean expressions, but not
+  // implicitly convertible to a real bool (which is dangerous).
+  typedef C* scoped_array::*Testable;
+  operator Testable() const { return array_ ? &scoped_array::array_ : NULL; }
+
   // Comparison operators.
   // These return whether two scoped_array refer to the same object, not just to
   // two different but equal objects.
   bool operator==(C* p) const { return array_ == p; }
   bool operator!=(C* p) const { return array_ != p; }
 
   // Swap two scoped arrays.
   void swap(scoped_array& p2) {
     C* tmp = array_;
     array_ = p2.array_;
@@ skipping 103 matching lines @@
 
   C* operator->() const {
     assert(ptr_ != NULL);
     return ptr_;
   }
 
   C* get() const {
     return ptr_;
   }
 
+  // Allow scoped_ptr_malloc<C> to be used in boolean expressions, but not
+  // implicitly convertible to a real bool (which is dangerous).
+  typedef C* scoped_ptr_malloc::*Testable;
+  operator Testable() const { return ptr_ ? &scoped_ptr_malloc::ptr_ : NULL; }
+
   // Comparison operators.
   // These return whether a scoped_ptr_malloc and a plain pointer refer
   // to the same object, not just to two different but equal objects.
   // For compatibility with the boost-derived implementation, these
   // take non-const arguments.
   bool operator==(C* p) const {
     return ptr_ == p;
   }
 
   bool operator!=(C* p) const {
@@ skipping 45 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_