STL源码剖析（二十）基本算法之copy

最新推荐文章于 2021-12-12 19:35:12 发布
最新推荐文章于 2021-12-12 19:35:12 发布
阅读量378 收藏 1
点赞数 1
分类专栏： STL源码剖析 文章标签： c++ STL copy 算法 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mei_true/article/details/120892523
版权

copy进行复制操作，复制操作不外乎运用assignment operator或copy constructor，有些元素类型拥有trivial assignment operator可以使用内存复制如memmove或memcpy可节省大量时间。
copy算法使用的assignment operator，算法中使用函数重载、类型特性type traits、偏特性等特性技巧，目的加强效率。
copy算法完整脉络如下：

请添加图片描述

copy_barward实现技巧与copy类似，将[first, last)区间内元素以逆行方向复制到result-1为起点，方向逆行的区间上，执行的赋值操作*(result-1) = *(last -1), *(result-2) = *(last-2), …返回迭代器result-(last-first)。
copy_backward接受的迭代器必须是BidirectionalIterator。

namespace std _GLIBCXX_VISIBILITY(default)
{

  template<bool, bool, typename> //模板类__copy_move<bool, bool, typename>
    struct __copy_move
    {
      template<typename _II, typename _OI>
	static _OI //静态成员函数
	__copy_m(_II __first, _II __last, _OI __result) //拷贝迭代器[first, last)内容至result
	{
	  for (; __first != __last; ++__result, (void)++__first) //执行[first, last)循环，result前向+1
	    *__result = *__first; //result赋值为[first, last)内容
	  return __result; //返回迭代器result
	}
    };

  template<typename _Category> //模板类__copy_move<typename _Category>
    struct __copy_move<true, false, _Category>
    {
      template<typename _II, typename _OI>
	static _OI
	__copy_m(_II __first, _II __last, _OI __result) //移动迭代器[first, last)内容至result
	{
	  for (; __first != __last; ++__result, (void)++__first)
	    *__result = std::move(*__first); //将迭代器first中内容移动至result
	  return __result; //返回result，移动完成后[first, last)中内容为空
	}
    };

  template<> //模板类特例化版本__copy_move<false, false, random_access_iterator_tag>
    struct __copy_move<false, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI> //迭代器类型为随机访问迭代器
	static _OI
	__copy_m(_II __first, _II __last, _OI __result) //拷贝迭代器[first, last)内容至result
	{
	  typedef typename iterator_traits<_II>::difference_type _Distance; //表迭代器之间距离的类型
	  for(_Distance __n = __last - __first; __n > 0; --__n) //执行距离循环
	    {
	      *__result = *__first;
	      ++__first;
	      ++__result;
	    }
	  return __result;
	}
    };

  template<> //模板类特例化版本__copy_move<true, false, random_access_iterator_tag>
    struct __copy_move<true, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI> //随机访问迭代器
	static _OI
	__copy_m(_II __first, _II __last, _OI __result) //移动迭代器[first, last)内容至result
	{
	  typedef typename iterator_traits<_II>::difference_type _Distance; //表迭代器之间距离的类型
	  for(_Distance __n = __last - __first; __n > 0; --__n) //执行距离循环
	    {
	      *__result = std::move(*__first); //将迭代器first中内容移动至result
	      ++__first;
	      ++__result;
	    }
	  return __result; //返回result，移动完成后[first, last)中内容为空
	}
    };

  template<bool _IsMove> //模板类__copy_move<bool _IsMove>
    struct __copy_move<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>
	static _Tp*
	__copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) //拷贝指针范围[first, last)内容至result
	{
	  using __assignable = conditional<_IsMove,
					   is_move_assignable<_Tp>,
					   is_copy_assignable<_Tp>>;
	  static_assert( __assignable::type::value, "type is not assignable" );
	  const ptrdiff_t _Num = __last - __first; //表指针之间的距离
	  if (_Num)
	    __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); //使用内建memmove函数实现拷贝
	  return __result + _Num;
	}
    };

  template<bool _IsMove, typename _II, typename _OI> //模板类__copy_move_a<bool, typename, typename>
    inline _OI
    __copy_move_a(_II __first, _II __last, _OI __result)
    {
      typedef typename iterator_traits<_II>::value_type _ValueTypeI; //迭代器_II所指内容类型I
      typedef typename iterator_traits<_OI>::value_type _ValueTypeO; //迭代器_OI所指内容类型O
      typedef typename iterator_traits<_II>::iterator_category _Category; //迭代器_II类型
      const bool __simple = (__is_trivial(_ValueTypeI) //__is_trivial判断类型I是否存在默认构造函数、拷贝构造函数、赋值操作、析构函数
			     && __is_pointer<_II>::__value //判断类型I是否为指针
			     && __is_pointer<_OI>::__value //判断类型O是否为指针
			     && __are_same<_ValueTypeI, _ValueTypeO>::__value); //判断类型I和O是否为同一类型
      //__simple为true时使用内建memmove函数完成拷贝操作，为false时执行循环根据_IsMove决定拷贝副本或移动元素
      return std::__copy_move<_IsMove, __simple,
			      _Category>::__copy_m(__first, __last, __result);
    }
  //以下为辅助流迭代器内容，包括输入流和输出流
  template<typename _CharT>
    struct char_traits;
  //写入流迭代器
  template<typename _CharT, typename _Traits>
    class istreambuf_iterator;
  //输出流迭代器
  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator;
  //输出流迭代器拷贝
  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
	     ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(_CharT*, _CharT*,
		   ostreambuf_iterator<_CharT, char_traits<_CharT> >);
  //输出流迭代器const拷贝
  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
	     ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(const _CharT*, const _CharT*,
		   ostreambuf_iterator<_CharT, char_traits<_CharT> >);
  //写入流迭代器拷贝
  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
				    _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
		   istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);

  template<bool _IsMove, typename _II, typename _OI> //模板函数__copy_move_a2<bool, typename, typename>
    inline _OI
    __copy_move_a2(_II __first, _II __last, _OI __result)
    {
      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first), //根据_IsMove决定调用__copy_move_a2<true>或<false>版本完成拷贝
					     std::__niter_base(__last), //__niter_base移除__normal_iterator包装器
					     std::__niter_base(__result))); //__niter_base返回指针类型时需调用相应指针类型版本
    }

  template<typename _II, typename _OI> //模板函数copy，拷贝序列元素到另一序列
    inline _OI
    copy(_II __first, _II __last, _OI __result)
    {
      __glibcxx_function_requires(_InputIteratorConcept<_II>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OI,
	    typename iterator_traits<_II>::value_type>) //迭代器_II所指内容类型
      __glibcxx_requires_valid_range(__first, __last);
      
      return (std::__copy_move_a2<__is_move_iterator<_II>::__value> //__is_move_iterator判断迭代器是否为移动迭代器
	      (std::__miter_base(__first), std::__miter_base(__last), //__miter_base移除move_iterator包装器
	       __result)); 
	       //调用__copy_move_a2<true>或<false>版本完成拷贝，模板参数赋值_IsMove
	       //__copy_move_a2包括流迭代器，根据传入模板参数true或false调用__copy_move_a<_IsMove>
	       //__copy_move_a中根据__simple决定使用内建memmove函数或循环赋值方式完成拷贝操作
	       //_IsMove决定拷贝操作是拷贝副本还是移动元素
	       //首先移除移动迭代器包装，再移除正常迭代器包装，__copy_move定义了指针类型和自定义数据类型版本
    }

  template<typename _II, typename _OI> //模板函数move，移动序列元素到另一序列
    inline _OI
    move(_II __first, _II __last, _OI __result)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_II>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OI,
	    typename iterator_traits<_II>::value_type>) //迭代器_II所指内容类型
      __glibcxx_requires_valid_range(__first, __last);
      //直接调用__copy_move_a2<true>完成移动操作
      return std::__copy_move_a2<true>(std::__miter_base(__first), //移除move_iterator包装器
				       std::__miter_base(__last), __result);
    }

#define _GLIBCXX_MOVE3(_Tp, _Up, _Vp) std::move(_Tp, _Up, _Vp)

  template<bool, bool, typename> //模板类__copy_move_backward<bool, bool, typename>
    struct __copy_move_backward //拷贝序列元素至另一序列，拷贝方式为反向前进
    {
      template<typename _BI1, typename _BI2>
	static _BI2
	__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
	{
	  while (__first != __last)
	    *--__result = *--__last; //迭代器反向-1
	  return __result;
	}
    };

  template<typename _Category> //模板类__copy_move_backward<_Category>
    struct __copy_move_backward<true, false, _Category> //移动序列元素至另一序列，反向前进移动
    {
      template<typename _BI1, typename _BI2>
	static _BI2
	__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
	{
	  while (__first != __last)
	    *--__result = std::move(*--__last); //反向-1移动元素
	  return __result;
	}
    };

  template<> //模板类特例化版本__copy_move_backward<false, false, random_access_iterator_tag>
    struct __copy_move_backward<false, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>
	static _BI2
	__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
	{
	  typename iterator_traits<_BI1>::difference_type __n; //表迭代器之间距离的类型
	  for (__n = __last - __first; __n > 0; --__n)
	    *--__result = *--__last; //拷贝元素副本
	  return __result;
	}
    };

  template<> //模板类特例化版本__copy_move_backward<true, false, random_access_iterator_tag>
    struct __copy_move_backward<true, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>
	static _BI2
	__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
	{
	  typename iterator_traits<_BI1>::difference_type __n; //表迭代器之间距离的类型
	  for (__n = __last - __first; __n > 0; --__n)
	    *--__result = std::move(*--__last); //移动元素
	  return __result;
	}
    };

  template<bool _IsMove> //模板类__copy_move_backward<bool _IsMove>
    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>
	static _Tp*
	__copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
	{
	  using __assignable = conditional<_IsMove,
					   is_move_assignable<_Tp>,
					   is_copy_assignable<_Tp>>;
	  static_assert( __assignable::type::value, "type is not assignable" );
	  const ptrdiff_t _Num = __last - __first;
	  if (_Num)
	    __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); //使用内建memmove移动元素
	  return __result - _Num;
	}
    };

  template<bool _IsMove, typename _BI1, typename _BI2> //模板函数__copy_move_backward_a
    inline _BI2
    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
      typedef typename iterator_traits<_BI1>::iterator_category _Category;
      const bool __simple = (__is_trivial(_ValueType1)
			     && __is_pointer<_BI1>::__value
			     && __is_pointer<_BI2>::__value
			     && __are_same<_ValueType1, _ValueType2>::__value);
      //__simple为true时使用内建memmove函数拷贝元素，为false时执行循环根据_IsMove决定拷贝副本或移动元素
      return std::__copy_move_backward<_IsMove, __simple,
				       _Category>::__copy_move_b(__first,
								 __last,
								 __result);
    }

  template<bool _IsMove, typename _BI1, typename _BI2> //模板函数__copy_move_backward_a2
    inline _BI2
    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      return _BI2(std::__copy_move_backward_a<_IsMove>
		  (std::__niter_base(__first), std::__niter_base(__last),
		   std::__niter_base(__result)));
    }

  template<typename _BI1, typename _BI2> //模板函数copy_backward，调用与copy相似
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      // concept requirements
      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>)
      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>)
      __glibcxx_function_requires(_ConvertibleConcept<
	    typename iterator_traits<_BI1>::value_type,
	    typename iterator_traits<_BI2>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);

      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
	      (std::__miter_base(__first), std::__miter_base(__last),
	       __result));
    }

  template<typename _BI1, typename _BI2> //模板函数move_backward，调用与move相似
    inline _BI2
    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      // concept requirements
      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>)
      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>)
      __glibcxx_function_requires(_ConvertibleConcept<
	    typename iterator_traits<_BI1>::value_type,
	    typename iterator_traits<_BI2>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);

      return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
						std::__miter_base(__last),
						__result);
    }

#define _GLIBCXX_MOVE_BACKWARD3(_Tp, _Up, _Vp) std::move_backward(_Tp, _Up, _Vp)

} // namespace std
花花...
关注
专栏目录
STL源码分析之copy算法
啦啦啦
12-08 823
前言 在前面分析顺序容器和关联容器时, 总会遇到copy这个函数, 当时并没有去分析这个函数, 毕竟都能知道他是什么功能, 本节就来揭开它面纱. copy分析 copy函数源码在stl_algobase.h中, 该结构中还有很多其他的算法实现, 我只是从中挑选出了copy, 有兴趣可以自己看看里面的其他算法. copy同traits编程, 都对性能做了最优的优化, 能使用的memmove函数就使用...
STL算法之copy
系统 运维
04-15 207
STL算法之copy copy 使用必须包含头文件&lt;algorithm&gt; 由于copy进行的是复制操作，而复制操作不外乎assignment operator和copy constructor(copy算法用的是前者)，但是某些元素型别用于的是trivial assginment operator，因此，如果能够使用内存直接复制行为(例如C标准函数memmove或memcpy)，...
stl 之 copy copy_backward
chivalry
02-23 2233
http://blog.csdn.net/jerryjbiao/article/details/7381498 元素复制算法copy 该算法主要用于容器之间元素的拷贝，即将迭代器区间[first，last)的元素复制到由复制目标result给定的区间[result，result+(last-first))中。下面我们来看看它的函数原型： 函数原形:
【STL】算法 — copy
Nestle的专栏
05-14 1811
为了效率，copy算法可谓无所不用其极，通过分析copy算法能够体会STL的精妙。 首先是三个对外接口： template // 泛化版本 inline OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result) {
STL算法_copy
xixihaha331的博客
05-24 389
STL标准模板库中的copy算法，整体设计比较复杂，使用起来也比较麻烦，因为copy函数为了强化效率可以说是无所不用其极。用到的编程技巧有函数重载，型别特化， 偏特化等技巧。所以STL库中的copy函数体现了泛化的思想       copy函数的整体架构：     （一）泛化的copy        inline OutputIterator copy(InputIterator first
STL源码剖析---copy
仰望星空
10-30 198
一、 泛型copy template&lt;typename SrcIt, typename DesIt&gt; void mcopy(SrcIt first, SrcIt last, DesIt desit) { while (first != last) { *desit = *first; first++; } } 二、 测试 从调用copy函数的时候，我们可以看到...
STL源码剖析！无水印！
03-04
STL源码剖析！无水印！ STL（ Standard Template Library）是C++标准模板库，提供了大量通用容器、算法和迭代器，以满足大多数编程需求。STL源码剖析是深入了解C++语言和STL库的内部实现机制的重要步骤。 一、STL...
STL源码剖析--侯捷_繁体和简体版集合
06-15
《STL源码剖析》是侯捷先生的经典之作，它深入解析了标准模板库（Standard Template Library，简称STL）的内部实现机制，为读者揭示了C++编程中这一重要工具的奥秘。STL是C++编程中的核心组件，包含了一系列高效的...
STL源码剖析
04-04
其次，"侯捷STL源码剖析pdf(繁体版)"是由知名C++专家侯捷编写的关于STL源码分析的书籍。这本书深入浅出地解析了SGI STL的实现细节，从基础概念到高级技巧，涵盖了STL的各个方面。侯捷的讲解风格独特，他将理论与实践...
STL源码剖析_C++STL_stl源码c++_
09-29
在《STL源码剖析》这本书中，作者深入解析了STL的实现细节，帮助开发者更好地理解和利用这个强大的工具。 首先，我们来了解一下STL中的主要容器。容器是STL的基础，它们可以存储和管理数据。常见的容器有向量...
侯捷Boolan STL源码剖析视频集
01-15
根据提供的文件信息，我们可以深入探讨侯捷Boolan STL源码剖析视频集中涉及的关键知识点。这里主要聚焦于标准模板库（Standard Template Library，简称STL）的相关概念与实践应用。 ### 标题：“侯捷Boolan STL源码...
copy算法
weixin_33782386的博客
07-27 137
 copy------强化效率无所不用其极 copy(first,last,result)算法可将输入区间[first,last)内的元素拷贝到输出区间[result,result+(last-first))内。也就是说，它会运行赋值操作*result =*first,*(result+1) =*(first+1), …一次类推。返回一个迭代器：result+(l...
STL源码剖析 数值算法 copy 算法
CHYabc123456hh的博客
11-29 654
copy复制操作，其操作通过使用assignment operator 。针对使用trivial assignment operator的元素型别可以直接使用内存直接复制行为(使用C函数 memove或者memcpy)节约时间。 还可以通过函数重载(function overloading)、型别特性(type traits)、偏特化(partial specialization)等技巧进一步强化效率。 copy函数将[first,last) 内的元素复制到区间[result,result+(last
stl copy
萧海的博客
12-12 535
int nums[] = {100, 200, 300, 400, 500, 600}; vector<int> vec; vector<int>::iterator it; //方法一 // vec.resize(6); // 为容器myvector分配空间 // copy (nums, nums+7, vec.begin()); //方法二 copy (nums, nums+6, std::back_inserter(vec)
STL中copy算法
w512的专栏
11-17 2544
STL中通过使用copy函数以提供一种方便的方式来输出容器中的元素。函数copy作为泛型算法的一部分，任何容器类型都可以使用。由于我们需要频繁的初始容器的元素，因此在继续讨论容器之前，先学习一下copy函数的用法。 copy函数不只是输出容器的元素。通常，它允许我们复制元素从一个地方到另一个地方。例如输出vector的元素或复制vector的元素到另一个vector，我们可以使用copy
STL源码剖析——copy函数
Johnsonjjj的博客
08-02 1241
前言 最近在看《STL 源码剖析》，恰好看到copy函数这里。书上写的这个函数比较复杂，因为涉及到比较多提高效率的方法。因此我这篇博客就当做个简单的记录吧。 copy函数的原型如下： template<class InputIterator, class OutputIterator> inline OutputIterator copy( InputIterator first, InputIterator last, OutputIte
SGI STL源码剖析：内存管理与算法解析
"SGI STL源码剖析，内存管理和算法细节" 在深入理解内存管理和STL容器的实现细节方面，SGI STL源码提供了一个宝贵的参考。SGI STL(Stanford Graphics Group's Standard Template Library)是一个著名的C++标准模板库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值