Make QScopedPointer comparison operators hidden friends

Reduce overload resolution noise. Fixes: QTBUG-87979 Change-Id: I52f96e016ffaf1b4f2235a05c1175c5af3eebe36 Reviewed-by: Allan Sandfeld Jensen <[email protected]>
lsjoo85612 · Oct 31, 2020 · 04549f6 · 04549f6
1 parent 739e7dd
commit 04549f6
Show file tree

Hide file tree

Showing 2 changed files with 40 additions and 51 deletions.
diff --git a/src/corelib/tools/qscopedpointer.cpp b/src/corelib/tools/qscopedpointer.cpp
@@ -183,21 +183,20 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn template <typename T, typename Cleanup> bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
+    \fn template <typename T, typename Cleanup> bool QScopedPointer<T, Cleanup>::operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
 
-    Returns \c true if \a ptr1 and \a ptr2 refer to the same pointer.
+    Returns \c true if \a lhs and \a rhs refer to the same pointer.
 */
 
 
 /*!
-    \fn template <typename T, typename Cleanup> bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
+    \fn template <typename T, typename Cleanup> bool QScopedPointer<T, Cleanup>::operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
 
     Returns \c true if \a lhs and \a rhs refer to distinct pointers.
 */
 
 /*!
-    \fn template <typename T, typename Cleanup> bool operator==(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t)
-    \relates QScopedPointer
+    \fn template <typename T, typename Cleanup> bool QScopedPointer<T, Cleanup>::operator==(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t)
     \since 5.8
 
     Returns \c true if \a lhs refers to \nullptr.
@@ -206,8 +205,7 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn template <typename T, typename Cleanup> bool operator==(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs)
-    \relates QScopedPointer
+    \fn template <typename T, typename Cleanup> bool QScopedPointer<T, Cleanup>::operator==(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs)
     \since 5.8
 
     Returns \c true if \a rhs refers to \nullptr.
@@ -216,8 +214,7 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn template <typename T, typename Cleanup> bool operator!=(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t)
-    \relates QScopedPointer
+    \fn template <typename T, typename Cleanup> bool QScopedPointer<T, Cleanup>::operator!=(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t)
     \since 5.8
 
     Returns \c true if \a lhs refers to a valid (i.e. non-null) pointer.
@@ -226,8 +223,7 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn template <typename T, typename Cleanup> bool operator!=(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs)
-    \relates QScopedPointer
+    \fn template <typename T, typename Cleanup> bool QScopedPointer<T, Cleanup>::operator!=(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs)
     \since 5.8
 
     Returns \c true if \a rhs refers to a valid (i.e. non-null) pointer.
@@ -268,8 +264,8 @@ QT_BEGIN_NAMESPACE
     \sa isNull()
 */
 
-/*! \fn template <typename T, typename Cleanup> void QScopedPointer<T, Cleanup>::swap(QScopedPointer<T, Cleanup> &other)
-  Swap this pointer with \a other.
+/*! \fn template <typename T, typename Cleanup> void QScopedPointer<T, Cleanup>::swap(QScopedPointer<T, Cleanup> &lhs, QScopedPointer<T, Cleanup> &rhs)
+    Swaps \a lhs with \a rhs.
  */
 
 /*!

diff --git a/src/corelib/tools/qscopedpointer.h b/src/corelib/tools/qscopedpointer.h
@@ -165,52 +165,45 @@ class QScopedPointer
 
     typedef T *pointer;
 
-protected:
-    T *d;
+    friend bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs) noexcept
+    {
+        return lhs.data() == rhs.data();
+    }
 
-private:
-    Q_DISABLE_COPY(QScopedPointer)
-};
+    friend bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs) noexcept
+    {
+        return lhs.data() != rhs.data();
+    }
 
-template <class T, class Cleanup>
-inline bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs) noexcept
-{
-    return lhs.data() == rhs.data();
-}
+    friend bool operator==(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t) noexcept
+    {
+        return lhs.isNull();
+    }
 
-template <class T, class Cleanup>
-inline bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs) noexcept
-{
-    return lhs.data() != rhs.data();
-}
+    friend bool operator==(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs) noexcept
+    {
+        return rhs.isNull();
+    }
 
-template <class T, class Cleanup>
-inline bool operator==(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t) noexcept
-{
-    return lhs.isNull();
-}
+    friend bool operator!=(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t) noexcept
+    {
+        return !lhs.isNull();
+    }
 
-template <class T, class Cleanup>
-inline bool operator==(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs) noexcept
-{
-    return rhs.isNull();
-}
+    friend bool operator!=(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs) noexcept
+    {
+        return !rhs.isNull();
+    }
 
-template <class T, class Cleanup>
-inline bool operator!=(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t) noexcept
-{
-    return !lhs.isNull();
-}
+    friend void swap(QScopedPointer<T, Cleanup> &p1, QScopedPointer<T, Cleanup> &p2) noexcept
+    { p1.swap(p2); }
 
-template <class T, class Cleanup>
-inline bool operator!=(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs) noexcept
-{
-    return !rhs.isNull();
-}
+protected:
+    T *d;
 
-template <class T, class Cleanup>
-inline void swap(QScopedPointer<T, Cleanup> &p1, QScopedPointer<T, Cleanup> &p2) noexcept
-{ p1.swap(p2); }
+private:
+    Q_DISABLE_COPY(QScopedPointer)
+};
 
 template <typename T, typename Cleanup = QScopedPointerArrayDeleter<T> >
 class QScopedArrayPointer : public QScopedPointer<T, Cleanup>