Use std::destroy_at/std::destroy/std::destroy_n (#66)

Author: Morwenn

include/cpp-sort/detail/fixed_size_list.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2022 Morwenn
+ * Copyright (c) 2020-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #ifndef CPPSORT_DETAIL_FIXED_SIZE_LIST_H_
@@ -92,7 +92,7 @@ namespace detail
     auto destroy_node_contents(NodeType* node)
         -> void
     {
-        detail::destroy_at(&(node->*Ptr));
+        std::destroy_at(&(node->*Ptr));
     }
 
     ////////////////////////////////////////////////////////////
@@ -170,10 +170,7 @@ namespace detail
             ~fixed_size_list_node_pool()
             {
                 // Destroy the nodes
-                node_type* ptr = buffer_.get();
-                for (std::ptrdiff_t n = 0 ; n < capacity_ ; ++n, ++ptr) {
-                    detail::destroy_at(ptr);
-                }
+                std::destroy_n(buffer_.get(), capacity_);
             }
 
             ////////////////////////////////////////////////////////////

include/cpp-sort/detail/immovable_vector.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2022 Morwenn
+ * Copyright (c) 2021-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #ifndef CPPSORT_DETAIL_IMMOVABLE_VECTOR_H_
@@ -9,11 +9,11 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <cstddef>
+#include <memory>
 #include <new>
 #include <utility>
 #include <cpp-sort/utility/iter_move.h>
 #include "config.h"
-#include "memory.h"
 
 namespace cppsort
 {
@@ -59,7 +59,7 @@ namespace detail
             ~immovable_vector()
             {
                 // Destroy the constructed elements
-                detail::destroy(memory_, end_);
+                std::destroy(memory_, end_);
 
                 // Free the allocated memory
 #ifdef __cpp_sized_deallocation
@@ -115,7 +115,7 @@ namespace detail
                 -> void
             {
                 // Destroy the constructed elements
-                detail::destroy(memory_, end_);
+                std::destroy(memory_, end_);
 
                 // Ensure the new size is zero
                 end_ = memory_;
@@ -143,7 +143,7 @@ namespace detail
                     }
                 } catch (...) {
                     // Cleanup
-                    detail::destroy(end_, writer);
+                    std::destroy(end_, writer);
                     throw;
                 }
                 end_ = writer;

include/cpp-sort/detail/memory.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2022 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 
@@ -29,37 +29,6 @@ namespace cppsort
 {
 namespace detail
 {
-    ////////////////////////////////////////////////////////////
-    // C++17 std::destroy and friends
-
-    template<typename T>
-    auto destroy_at(T* ptr)
-        -> void
-    {
-        // TODO: implement if needed
-        static_assert(not std::is_array<T>::value, "destroy_at() does no handle arrays");
-        ptr->~T();
-    }
-
-    template<typename ForwardIterator>
-    auto destroy(ForwardIterator first, ForwardIterator last)
-        -> void
-    {
-        for (; first != last; ++first) {
-            detail::destroy_at(std::addressof(*first));
-        }
-    }
-
-    template<typename ForwardIterator, typename Size>
-    auto destroy_n(ForwardIterator first, Size n)
-        -> void
-    {
-        for (; n > 0; --n) {
-            detail::destroy_at(std::addressof(*first));
-            ++first;
-        }
-    }
-
     ////////////////////////////////////////////////////////////
     // Deleter for ::operator new(std::size_t)
 
@@ -122,7 +91,7 @@ namespace detail
         constexpr auto operator()(T* pointer) noexcept
             -> void
         {
-            detail::destroy_n(pointer, size);
+            std::destroy_n(pointer, size);
         }
 
         // Number of allocated objects to destroy

include/cpp-sort/detail/slabsort.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2022 Morwenn
+ * Copyright (c) 2021-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #ifndef CPPSORT_DETAIL_SLABSORT_H_
@@ -9,6 +9,7 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <iterator>
+#include <memory>
 #include <utility>
 #include <vector>
 #include <cpp-sort/comparators/flip.h>
@@ -24,7 +25,6 @@
 #include "iterator_traits.h"
 #include "lower_bound.h"
 #include "melsort.h"
-#include "memory.h"
 #include "stable_partition.h"
 #include "nth_element.h"
 
@@ -203,7 +203,7 @@ namespace detail
             for (auto it = list.begin(), end = list.end() ; it != end ; ++it) {
                 auto node = it.base();
                 auto value_it = node->it;
-                detail::destroy_at(&node->it);
+                std::destroy_at(&node->it);
                 ::new(&node->value) rvalue_type(iter_move(value_it));
             }
             list.set_node_destructor(destroy_node_contents<rvalue_type, node_type, &node_type::value>);

tests/testing-tools/test_vector.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Morwenn
+ * Copyright (c) 2021-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #ifndef CPPSORT_TESTSUITE_TEST_VECTOR_H_
@@ -10,10 +10,10 @@
 ////////////////////////////////////////////////////////////
 #include <cstddef>
 #include <iterator>
+#include <memory>
 #include <new>
 #include <stdexcept>
 #include <utility>
-#include <cpp-sort/detail/memory.h>
 
 ////////////////////////////////////////////////////////////
 // Vector with a tiny size
@@ -273,7 +273,7 @@ class test_vector
         ~test_vector()
         {
             // Destroy the constructed elements
-            cppsort::detail::destroy(memory_, end_);
+            std::destroy(memory_, end_);
             // Free the allocated memory
             ::operator delete(memory_);
         }
@@ -330,7 +330,7 @@ class test_vector
             -> void
         {
             // Destroy the constructed elements
-            cppsort::detail::destroy(memory_, end_);
+            std::destroy(memory_, end_);
             // Ensure the new size is zero
             end_ = memory_;
         }