Difference between revisions of "cpp/memory/ranges/uninitialized move"

Latest revision as of 15:22, 7 December 2023

Defined in header `<memory>`
Call signature
template< std::input_iterator I, std::sentinel_for<I> S1, no-throw-forward-iterator O, no-throw-sentinel-for<O> S2 > requires std::constructible_from<std::iter_value_t<O>, std::iter_rvalue_reference_t<I>> uninitialized_move_result<I, O> uninitialized_move( I ifirst, S1 ilast, O ofirst, S2 olast );	(1)	(since C++20)
template< ranges::input_range IR, no-throw-forward-range OR > requires std::constructible_from<ranges::range_value_t<OR>, ranges::range_rvalue_reference_t<IR>> uninitialized_move_result<ranges::borrowed_iterator_t<IR>, ranges::borrowed_iterator_t<OR>> uninitialized_move( IR&& in_range, OR&& out_range );	(2)	(since C++20)
Helper types
template< class I, class O > using uninitialized_move_result = ranges::in_out_result<I, O>;	(3)	(since C++20)

1) Moves N elements from the input range [ifirst, ilast) to the output range [ofirst, olast) (that is an uninitialized memory area), where N is min(ranges::distance(ifirst, ilast), ranges::distance(ofirst, olast)).

The effect is equivalent to:

for (; ifirst != ilast && ofirst != olast; ++ofirst, ++ifirst)
    ::new (static_cast<void*>(std::addressof(*ofirst)))
        std::remove_reference_t<std::iter_reference_t<O>>(ranges::iter_move(ifirst));

If an exception is thrown during the initialization then the objects that already constructed in [ofirst, olast) are destroyed in an unspecified order. Also, the objects in [ifirst, ilast) that were already moved, are left in a valid but unspecified state.

2) Same as (1), but uses in_range as the first range and out_range as the second range, as if using ranges::begin(in_range) as ifirst, ranges::end(in_range) as ilast, ranges::begin(out_range) as ofirst, and ranges::end(out_range) as olast.

The function-like entities described on this page are niebloids, that is:

Explicit template argument lists cannot be specified when calling any of them.
None of them are visible to argument-dependent lookup.
When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.

In practice, they may be implemented as function objects, or with special compiler extensions.

struct uninitialized_move_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S1,
             no-throw-forward-iterator O, no-throw-sentinel-for<O> S2>
    requires std::constructible_from<std::iter_value_t<O>,
             std::iter_rvalue_reference_t<I>>
    ranges::uninitialized_move_result<I, O>
    operator()(I ifirst, S1 ilast, O ofirst, S2 olast) const
    {
        O current{ofirst};
        try
        {
            for (; !(ifirst == ilast or current == olast); ++ifirst, ++current)
                ::new (const_cast<void*>(static_cast<const volatile void*>
                    (std::addressof(*current)))) std::remove_reference_t<
                        std::iter_reference_t<O>>(ranges::iter_move(ifirst));
            return {std::move(ifirst), std::move(current)};
        }
        catch (...) // rollback: destroy constructed elements
        {
            for (; ofirst != current; ++ofirst)
                ranges::destroy_at(std::addressof(*ofirst));
            throw;
        }
    }
 
    template<ranges::input_range IR, no-throw-forward-range OR>
    requires std::constructible_from<ranges::range_value_t<OR>,
             ranges::range_rvalue_reference_t<IR>>
    ranges::uninitialized_move_result<ranges::borrowed_iterator_t<IR>,
                                      ranges::borrowed_iterator_t<OR>>
    operator()(IR&& in_range, OR&& out_range) const
    {
        return (*this)(ranges::begin(in_range), ranges::end(in_range),
                       ranges::begin(out_range), ranges::end(out_range));
    }
};
 
inline constexpr uninitialized_move_fn uninitialized_move{};

[edit] Example

Run this code

#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
 
void print(auto rem, auto first, auto last)
{
    for (std::cout << rem; first != last; ++first)
        std::cout << std::quoted(*first) << ' ';
    std::cout << '\n';
}
 
int main()
{
    std::string in[]{"Home", "World"};
    print("initially, in: ", std::begin(in), std::end(in));
 
    if (constexpr auto sz = std::size(in);
        void* out = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz))
    {
        try
        {
            auto first{static_cast<std::string*>(out)};
            auto last{first + sz};
            std::ranges::uninitialized_move(std::begin(in), std::end(in), first, last);
 
            print("after move, in: ", std::begin(in), std::end(in));
            print("after move, out: ", first, last);
 
            std::ranges::destroy(first, last);
        }
        catch (...)
        {
            std::cout << "Exception!\n";
        }
        std::free(out);
    }
}

Possible output:

initially, in: "Home" "World"
after move, in: "" ""
after move, out: "Home" "World"

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 3870	C++20	this algorithm might create objects on a const storage	kept disallowed

[edit] See also

ranges::uninitialized_move_n (C++20)	moves a number of objects to an uninitialized area of memory (niebloid)[edit]
uninitialized_move (C++17)	moves a range of objects to an uninitialized area of memory (function template) [edit]

@@ Line 2: / Line 2: @@
 {{cpp/memory/navbar}}
 {{dcl begin}}
-{{dcl header | memory}}
+{{dcl header|memory}}
-{{dcl h | Call signature}}
+{{dcl h|Call signature}}
-{{dcl | num=1 | since=c++20 |1=
+{{dcl|num=1|since=c++20|1=
 template< std::input_iterator I, std::sentinel_for<I> S1,
            no-throw-forward-iterator O, no-throw-sentinel-for<O> S2 >
@@ Line 12: / Line 12: @@
 uninitialized_move( I ifirst, S1 ilast, O ofirst, S2 olast );
 }}
-{{dcl | num=2 | since=c++20 |1=
+{{dcl|num=2|since=c++20|1=
 template< ranges::input_range IR, no-throw-forward-range OR >
 requires std::constructible_from<ranges::range_value_t<OR>,
@@ Line 20: / Line 20: @@
 uninitialized_move( IR&& in_range, OR&& out_range );
 }}
-{{dcl h | Helper types}}
+{{dcl h|Helper types}}
-{{dcl | num=3 | since=c++20 |1=
+{{dcl|num=3|since=c++20|1=
-template<class I, class O>
+template< class I, class O >
 using uninitialized_move_result = ranges::in_out_result<I, O>;
 }}
 {{dcl end}}
-@1@ Moves {{c|N}} elements from the input range {{tt|[ifirst, ilast)}} to the output range {{tt|[ofirst, olast)}} (that is an uninitialized memory area), where {{c|N}} is {{c|min(ranges::distance(ifirst, ilast), ranges::distance(ofirst, olast))}}.
+@1@ Moves {{c|N}} elements from the input range {{range|ifirst|ilast}} to the output range {{range|ofirst|olast}} (that is an uninitialized memory area), where {{c|N}} is {{c|min(ranges::distance(ifirst, ilast), ranges::distance(ofirst, olast))}}.
 @@ The effect is equivalent to:
 {{source|1=
 for (; ifirst != ilast && ofirst != olast; ++ofirst, ++ifirst)
-     ::new (const_cast<void*>(static_cast<const volatile void*>(std::addressof(*first))))
+     ::new (static_cast<void*>(std::addressof(*ofirst)))
          std::remove_reference_t<std::iter_reference_t<O>>(ranges::iter_move(ifirst));
 }}
-@@ If an exception is thrown during the initialization then the objects that already constructed in {{tt|[ofirst, olast)}} are destroyed in an unspecified order. Also, the objects in {{tt|[ifirst, ilast)}} that were already moved, are left in a valid but unspecified state.
+@@ If an exception is thrown during the initialization then the objects that already constructed in {{range|ofirst|olast}} are destroyed in an unspecified order. Also, the objects in {{range|ifirst|ilast}} that were already moved, are left in a valid but unspecified state.
-@2@ Same as {{v|1}}, but uses {{tt|in_range}} as the first range and {{tt|out_range}} as the second range, as if using {{c|ranges::begin(in_range)}} as {{tt|ifirst}}, {{c|ranges::end(in_range)}} as {{tt|ilast}}, {{c|ranges::begin(out_range)}} as {{tt|ofirst}}, and {{c|ranges::end(out_range)}} as {{tt|olast}}.
+@2@ Same as {{v|1}}, but uses {{tt|in_range}} as the first range and {{tt|out_range}} as the second range, as if using {{c|ranges::begin(in_range)}} as {{c|ifirst}}, {{c|ranges::end(in_range)}} as {{c|ilast}}, {{c|ranges::begin(out_range)}} as {{c|ofirst}}, and {{c|ranges::end(out_range)}} as {{c|olast}}.
 {{cpp/ranges/niebloid}}
@@ Line 43: / Line 43: @@
 ===Parameters===
 {{par begin}}
-{{par | ifirst, ilast | the input range of elements to move from}}
+{{par|ifirst, ilast|iterator-sentinel pair denoting the input range of elements to move from}}
-{{par | ofirst, olast | the output range to initialize}}
+{{par|in_range|the input range of elements to move from}}
-{{par | in_range | the input range of elements to move from}}
+{{par|ofirst, olast|iterator-sentinel pair denoting the output range to initialize}}
-{{par | out_range | the output range to initialize}}
+{{par|out_range|the output range to initialize}}
 {{par end}}
 ===Return value===
-{{c|{ifirst + N, ofirst + N} }}.
+{{c|{ifirst + N, ofirst + N}<!---->}}
 ===Complexity===
-Linear in the {{c|N}}.
+Linear in {{c|N}}.
 ===Exceptions===
@@ Line 59: / Line 59: @@
 ===Notes===
-An implementation may improve the efficiency of the {{c|ranges::uninitialized_move}} by using {{c|ranges::copy_n}} if the value type of the output range is {{named req|TrivialType}}.
+An implementation may improve the efficiency of the {{tt|ranges::uninitialized_move}}, e.g. by using {{lc|ranges::copy_n}}, if the value type of the output range is {{named req|TrivialType}}.
 ===Possible implementation===
-{{eq fun | 1=
+{{eq fun|1=
-struct uninitialized_move_fn {
+struct uninitialized_move_fn
-     template <std::input_iterator I, std::sentinel_for<I> S1,
+{
+     template<std::input_iterator I, std::sentinel_for<I> S1,
               no-throw-forward-iterator O, no-throw-sentinel-for<O> S2>
      requires std::constructible_from<std::iter_value_t<O>,
               std::iter_rvalue_reference_t<I>>
      ranges::uninitialized_move_result<I, O>
-     operator()( I ifirst, S1 ilast, O ofirst, S2 olast ) const {
+     operator()(I ifirst, S1 ilast, O ofirst, S2 olast) const
-         O current {ofirst};
+    {
-         try {
+         O current{ofirst};
+         try
+        {
              for (; !(ifirst == ilast or current == olast); ++ifirst, ++current)
                  ::new (const_cast<void*>(static_cast<const volatile void*>
@@ Line 77: / Line 80: @@
                          std::iter_reference_t<O>>(ranges::iter_move(ifirst));
              return {std::move(ifirst), std::move(current)};
-         } catch (...) { // rollback: destroy constructed elements
+         }
+        catch (...) // rollback: destroy constructed elements
+        {
              for (; ofirst != current; ++ofirst)
                  ranges::destroy_at(std::addressof(*ofirst));
@@ Line 84: / Line 89: @@
      }
-     template <ranges::input_range IR, no-throw-forward-range OR>
+     template<ranges::input_range IR, no-throw-forward-range OR>
      requires std::constructible_from<ranges::range_value_t<OR>,
               ranges::range_rvalue_reference_t<IR>>
      ranges::uninitialized_move_result<ranges::borrowed_iterator_t<IR>,
-             ranges::borrowed_iterator_t<OR>>
+                                      ranges::borrowed_iterator_t<OR>>
-     operator()( IR&& in_range, OR&& out_range ) const {
+     operator()(IR&& in_range, OR&& out_range) const
+    {
          return (*this)(ranges::begin(in_range), ranges::end(in_range),
                         ranges::begin(out_range), ranges::end(out_range));
@@ Line 107: / Line 113: @@
 #include <string>
-void print(auto rem, auto first, auto last) {
+void print(auto rem, auto first, auto last)
+{
      for (std::cout << rem; first != last; ++first)
          std::cout << std::quoted(*first) << ' ';
@@ Line 113: / Line 120: @@
 }
-int main() {
+int main()
-     std::string in[] { "Home", "World" };
+{
+     std::string in[]{"Home", "World"};
      print("initially, in: ", std::begin(in), std::end(in));
-     if (
+     if (constexpr auto sz = std::size(in);
-        constexpr auto sz = std::size(in);
+         void* out = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz))
-         void* out = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz)
+     {
-     ) {
+         try
-         try {
+        {
-             auto first {static_cast<std::string*>(out)};
+             auto first{static_cast<std::string*>(out)};
-             auto last {first + sz};
+             auto last{first + sz};
              std::ranges::uninitialized_move(std::begin(in), std::end(in), first, last);
@@ Line 131: / Line 139: @@
              std::ranges::destroy(first, last);
          }
-         catch (...) {
+         catch (...)
+        {
              std::cout << "Exception!\n";
          }
@@ Line 137: / Line 146: @@
      }
 }
-| p=true <!-- move results are indeterminate -->
+|p=true<!--move results are indeterminate-->
-| output=
+|output=
 initially, in: "Home" "World"
 after move, in: "" ""
 after move, out: "Home" "World"
 }}
+===Defect reports===
+{{dr list begin}}
+{{dr list item|wg=lwg|dr=3870|std=C++20|before=this algorithm might create objects on a {{c/core|const}} storage|after=kept disallowed}}
+{{dr list end}}
 ===See also===
 {{dsc begin}}
-{{dsc inc | cpp/memory/ranges/dsc uninitialized_move_n}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_move_n}}
-{{dsc inc | cpp/memory/dsc uninitialized_move}}
+{{dsc inc|cpp/memory/dsc uninitialized_move}}
 {{dsc end}}
 {{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/memory/ranges/uninitialized move"

Latest revision as of 15:22, 7 December 2023

Contents

[edit] Parameters

[edit] Return value

[edit] Complexity

[edit] Exceptions

[edit] Notes

[edit] Possible implementation

[edit] Example

[edit] Defect reports

[edit] See also

Navigation

Toolbox

ifirst, ilast	-	iterator-sentinel pair denoting the input range of elements to move from
in_range	-	the input range of elements to move from
ofirst, olast	-	iterator-sentinel pair denoting the output range to initialize
out_range	-	the output range to initialize