Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::experimental::ranges::copy,std::experimental::ranges::copy_if

      From cppreference.com
      <cpp‎ |experimental‎ |ranges
       
       
       
       
      Algorithms library
      Non-modifying sequence operations
                                    
      Modifying sequence operations
      copycopy_if
                                    
      Partitioning operations
      Sorting operations
      Binary search operations
      Set operations (on sorted ranges)
                                    
      Heap operations
      Minimum/maximum operations
      Permutations
       
      template< InputIterator I, Sentinel<I> S, WeaklyIncrementable O>

          requires IndirectlyCopyable<I, O>
      ranges::tagged_pair<tag::in(I),tag::out(O)>

          copy( I first, S last, O result);
      		 (1)(ranges TS)
      template< InputRange R, WeaklyIncrementable O>

          requires IndirectlyCopyable<ranges::iterator_t<R>, O>
      ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>),tag::out(O)>

          copy( R&& r, O result);
      		 (2)(ranges TS)
      template< InputIterator I, Sentinel<I> S, WeaklyIncrementable O,

               class Proj=ranges::identity,
                IndirectUnaryPredicate<projected<I, Proj>> Pred>
          requires IndirectlyCopyable<I, O>
      ranges::tagged_pair<tag::in(I),tag::out(O)>

          copy_if( I first, S last, O result, Pred pred, Proj proj= Proj{});
      		 (3)(ranges TS)
      template< InputRange R, WeaklyIncrementable O,

               class Proj=ranges::identity,
                IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
          requires IndirectlyCopyable<iterator_t<R>, O>
      ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>),tag::out(O)>

          copy_if( R&& r, O result, Pred pred, Proj proj= Proj{});
      		 (4)(ranges TS)

      Copies elements in the source range ([first, last) orr) into the destination range beginning atresult, starting from the first element in the source range and proceeding to the last one.

      1) Copies all elements in the range[first, last). For each non-negative integern < (last - first), performs*(result+ n)=*(first+ n). The behavior is undefined ifresult is within the range[first, last). In this case,ranges::copy_backward may be used instead.
      2) Same as(1), but usesr as the source range, as if byranges::copy(ranges::begin(r),ranges::end(r), result); except thatresult may not be copied.
      3) Only copies the elements for which the predicatepred returnstrue when applied to the element's value as projected by the projectionproj. The order of the elements that are copied is preserved. The behavior is undefined if the source and the destination ranges overlap.
      4) Same as(3), but usesr as the source range, as if byranges::copy_if(ranges::begin(r),ranges::end(r), result, pred, proj); except thatresult,pred andproj may not be copied.

      Notwithstanding the declarations depicted above, the actual number and order of template parameters for algorithm declarations is unspecified. Thus, if explicit template arguments are used when calling an algorithm, the program is probably non-portable.

      Contents

      [edit]Parameters

      first, last - the range of elements to copy
      r - the range of elements to copy
      result - the beginning of the destination range
      pred - predicate to apply to the projected elements
      proj - projection to apply to the elements

      [edit]Return value

      Atagged_pair object containing the following two members:

      • The first member, with the tagtag::in, is the past-the-end iterator of the source range (that is, an iterator of typeI that compares equal to the sentinellast).
      • The second member, with the tagtag::out, is the past-the-end iterator of the result range.

      [edit]Complexity

      1) Exactlyranges::distance(first, last) assignments.
      2) Exactlyranges::distance(r) assignments.
      3) Exactlyranges::distance(first, last) applications of the corresponding projection and predicate.
      4) Exactlyranges::distance(r) applications of the corresponding projection and predicate.

      [edit]Possible implementations

      First version
      template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>    requires IndirectlyCopyable<I, O>()ranges::tagged_pair<tag::in(I),tag::out(O)>    copy(I first, S last, O result){for(; first!= last;++first,(void)++result)*result=*first;return{first, result};}
      Second version
      template<InputRange R, WeaklyIncrementable O>    requires IndirectlyCopyable<ranges::iterator_t<R>, O>()ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>),tag::out(O)>    copy(R&& r, O result){returnranges::copy(ranges::begin(r),ranges::end(r), result);}
      Third version
      template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,class Proj=ranges::identity,         IndirectUnaryPredicate<projected<I, Proj>> Pred>    requires IndirectlyCopyable<I, O>()ranges::tagged_pair<tag::in(I),tag::out(O)>    copy_if(I first, S last, O result, Pred pred, Proj proj= Proj{}){for(; first!= last;++first)if(ranges::invoke(pred,ranges::invoke(proj,*first))){*result=*first;++result;}return{first, result};}
      Fourth version
      template<InputRange R, WeaklyIncrementable O,class Proj=ranges::identity,         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>    requires IndirectlyCopyable<ranges::iterator_t<R>, O>()ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>),tag::out(O)>    copy_if(R&& r, O result, Pred pred, Proj proj= Proj{}){returnranges::copy_if(ranges::begin(r),ranges::end(r), result, pred, proj);}

      [edit]Example

      The following code uses copy to both copy the contents of one vector to another and to display the resulting vector:

      Run this code
      #include <experimental/ranges/algorithm>#include <experimental/ranges/iterator>#include <iostream>#include <numeric>#include <vector> int main(){// see https://en.cppreference.com/w/cpp/language/namespace_aliasnamespace ranges= std::experimental::ranges; std::vector<int> from_vector(10);std::iota(from_vector.begin(), from_vector.end(),0); std::vector<int> to_vector;ranges::copy_if(from_vector.begin(), from_vector.end(),                    ranges::back_inserter(to_vector),[](constauto i){return i%3;});// or, alternatively,//  std::vector<int> to_vector(from_vector.size());//  std::copy(from_vector, to_vector.begin()); std::cout<<"to_vector contains: "; ranges::copy(to_vector, ranges::ostream_iterator<int>(std::cout," "));std::cout<<'\n';}

      Output:

      to_vector contains: 1 2 4 5 7 8

      [edit]See also

      copies a range of elements to a new location
      (function template)[edit]
      copies a range of elements in backwards order
      (function template)[edit]
      creates a copy of a range that is reversed
      (function template)[edit]
      copies a number of elements to a new location
      (function template)[edit]
      assigns a range of elements a certain value
      (function template)[edit]
      copies a range of elements omitting those that satisfy specific criteria
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/experimental/ranges/algorithm/copy&oldid=155239"
      [8]ページ先頭
      ©2009-2025 Movatter.jp