/ generate and generate_n
//將仿函式gen的處理結果填充在[first, last)區間內所有元素上，所謂填寫
//就是用迭代器所指元素的assignment操作
//注意：對於使用者自定義型別要提供operator =() 

template <class _ForwardIter, class _Generator>
void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) {
  __STL_REQUIRES(_ForwardIter, _ForwardIterator);
  __STL_GENERATOR_CHECK(_Generator, 
          typename iterator_traits<_ForwardIter>::value_type);
  for ( ; __first != __last; ++__first)//遍歷整個序列
    *__first = __gen();
}
//將仿函式gen的處理結果填充在first開始的n個元素上，所謂填寫
//就是用迭代器所指元素的assignment操作
template <class _OutputIter, class _Size, class _Generator>
_OutputIter generate_n(_OutputIter __first, _Size __n, _Generator __gen) {
  __STL_REQUIRES(_OutputIter, _OutputIterator);
  for ( ; __n > 0; --__n, ++__first)//只限於n個元素
    *__first = __gen();
  return __first;
}
 

/*
下面是計算set集合的相關演算法，分別是並集set_union，差集set_difference，交集set_intersection
和對稱差集set_symmetric_difference，這是個函式都提供了兩個版本的函式原型
第一個版本是採用預設的排序比較方式 operator<
第二個版本是使用者通過comp自行指定排序方式
注意：這四個演算法接受的輸入區間都是有序的，輸出也是有序的
*/

// Set algorithms: includes, set_union, set_intersection, set_difference,
// set_symmetric_difference.  All of these algorithms have the precondition
// that their input ranges are sorted and the postcondition that their output
// ranges are sorted.

// 判斷[first1, last1)是否包含[first2, last2),  
// 注意: 兩個區間要保證有序,預設排序方式是operator<，若要自行定義排序方式，則呼叫第二版本;
template <class _InputIter1, class _InputIter2>
bool includes(_InputIter1 __first1, _InputIter1 __last1,
              _InputIter2 __first2, _InputIter2 __last2) {
  __STL_REQUIRES(_InputIter1, _InputIterator);
  __STL_REQUIRES(_InputIter2, _InputIterator);
  __STL_REQUIRES_SAME_TYPE(
       typename iterator_traits<_InputIter1>::value_type,
       typename iterator_traits<_InputIter2>::value_type);
  __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type,
                 _LessThanComparable);
  while (__first1 != __last1 && __first2 != __last2)//遍歷兩個區間
    if (*__first2 < *__first1)//first2小於first1表示不包含
      return false;//返回FALSE
    else if(*__first1 < *__first2)//若first1小於first2 
      ++__first1;//尋找第一個區間下一個位置
    else
      ++__first1, ++__first2;//若first2等於first1,遍歷兩區間的下一位置

  return __first2 == __last2;//若第二個區間先到達尾端，則返回TRUE
}

//版本二：使用者通過comp自行指定排序方式
template <class _InputIter1, class _InputIter2, class _Compare>
bool includes(_InputIter1 __first1, _InputIter1 __last1,
              _InputIter2 __first2, _InputIter2 __last2, _Compare __comp) {
  __STL_REQUIRES(_InputIter1, _InputIterator);
  __STL_REQUIRES(_InputIter2, _InputIterator);
  __STL_REQUIRES_SAME_TYPE(
       typename iterator_traits<_InputIter1>::value_type,
       typename iterator_traits<_InputIter2>::value_type);
  __STL_BINARY_FUNCTION_CHECK(_Compare, bool,
       typename iterator_traits<_InputIter1>::value_type,
       typename iterator_traits<_InputIter2>::value_type);
  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first2, *__first1))
      return false;
    else if(__comp(*__first1, *__first2)) 
      ++__first1;
    else
      ++__first1, ++__first2;

  return __first2 == __last2;
}
 

// partition, stable_partition, and their auxiliary functions
//若迭代器的型別為forward_iterator_tag，則呼叫此函式
template <class _ForwardIter, class _Predicate>
_ForwardIter __partition(_ForwardIter __first,
		         _ForwardIter __last,
			 _Predicate   __pred,
			 forward_iterator_tag) {
  if (__first == __last) return __first;//若為空，直接退出

  while (__pred(*__first))//若pred出first的值為true
    if (++__first == __last) return __first;//先移動迭代器first，在判斷是否到達尾端last

  _ForwardIter __next = __first;//繼續判斷

  while (++__next != __last)//若下一個位置依然不是尾端
    if (__pred(*__next)) {//繼續pred出next的值，若為true
      swap(*__first, *__next);//交換值
      ++__first;//繼續下一位置
    }

  return __first;
}
//若迭代器的型別為bidirectional_iterator_tag，則呼叫此函式
template <class _BidirectionalIter, class _Predicate>
_BidirectionalIter __partition(_BidirectionalIter __first,
                               _BidirectionalIter __last,
			       _Predicate __pred,
			       bidirectional_iterator_tag) {
  while (true) {
    while (true)
      if (__first == __last)//若為空
        return __first;//直接退出
      else if (__pred(*__first))//first的值符合不移動條件，則不移動該值
        ++__first;//只移動迭代器
      else//若頭指標符合移動
        break;//跳出迴圈
    --__last;//尾指標回溯
    while (true)
      if (__first == __last)//頭指標等於尾指標
        return __first;//操作結束
      else if (!__pred(*__last))//尾指標的元素符合不移動操作
        --__last;//至移動迭代器，並不移動具體元素
      else//尾指標的元素符合移動操作
        break;//跳出迴圈
    iter_swap(__first, __last);//頭尾指標交換元素
    ++__first;//準備下一次迴圈
  }
}
//將區間[first,last)的元素進行排序，被pred判斷為true的放在區間的前段，判定為false的放在區間後段
//該算算可能會使元素的元素位置放生改變.
/*
演算法功能：Rearranges the elements from the range [first,last), in such a way that all the elements
for which pred returns true precede all those for which it returns false. 
The iterator returned points to the first element of the second group.

演算法原型：
	template <class BidirectionalIterator, class UnaryPredicate>
	BidirectionalIterator partition (BidirectionalIterator first,
                                   BidirectionalIterator last, UnaryPredicate pred);
*/
template <class _ForwardIter, class _Predicate>
inline _ForwardIter partition(_ForwardIter __first,
   			      _ForwardIter __last,
			      _Predicate   __pred) {
  __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator);
  __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, 
        typename iterator_traits<_ForwardIter>::value_type);
  //首先萃取出迭代器first的型別，根據迭代器的型別呼叫不同的函式
  return __partition(__first, __last, __pred, __ITERATOR_CATEGORY(__first));
}