files.dif

C++标准库源代码_C++ STL Source Code 请不要修改任何文件

=== diff old/algo.h new/algo.h

80,81c80,81
< template <class InputIterator>
< InputIterator adjacent_find(InputIterator first, InputIterator last) {
---
> template <class ForwardIterator>
> ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last) {
83c83
<     InputIterator next = first;
---
>     ForwardIterator next = first;
91,93c91,93
< template <class InputIterator, class BinaryPredicate>
< InputIterator adjacent_find(InputIterator first, InputIterator last,
< 			    BinaryPredicate binary_pred) {
---
> template <class ForwardIterator, class BinaryPredicate>
> ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last,
> 			      BinaryPredicate binary_pred) {
95c95
<     InputIterator next = first;
---
>     ForwardIterator next = first;
901,1043d900
< 	  class RandomAccessIterator3, class Distance, class T>
< RandomAccessIterator3 __merge_aux(RandomAccessIterator1 first1,
< 				  RandomAccessIterator1 last1,
< 				  RandomAccessIterator2 first2,
< 				  RandomAccessIterator2 last2,
< 				  RandomAccessIterator3 result,
< 				  Distance& fill_pointer, T*){
<     Distance len = 0;
<     while (first1 != last1 && first2 != last2 && len < fill_pointer) {
< 	++len;
< 	if (*first2 < *first1)
< 	    *result++ = *first2++;
< 	else
< 	    *result++ = *first1++;
<     }
<     if (fill_pointer == len) {
< 	raw_storage_iterator<RandomAccessIterator3, T> p = result;
< 	result += (last1 - first1) + (last2 - first2);
< 	fill_pointer += (last1 - first1) + (last2 - first2);
< 	while (first1 != last1 && first2 != last2)
< 	    if (*first2 < *first1)
< 		*p++ = *first2++;
< 	    else
< 		*p++ = *first1++;
< 	copy(first2, last2, copy(first1, last1, p));
<     } else if (first2 == last2) {
< 	while (first1 != last1 && len < fill_pointer) { 
< 	    ++len;
< 	    *result++ = *first1++;
< 	}
< 	if (fill_pointer == len) {
< 	    raw_storage_iterator<RandomAccessIterator3, T> p = result;  
< 	    result += last1 - first1;
< 	    fill_pointer += last1 - first1;
< 	    while (first1 != last1) *p++ = *first1++;
< 	}
<     } else {
< 	while (first2 != last2 && len < fill_pointer) { 
< 	    ++len;
< 	    *result++ = *first2++;
< 	}
< 	if (fill_pointer == len) {
< 	    raw_storage_iterator<RandomAccessIterator3, T> p = result;  
< 	    result += last2 - first2;
< 	    fill_pointer += last2 - first2;
< 	    while (first2 != last2) *p++ = *first2++;
< 	}
<     }
<     return result;
< }       
< 
< template <class RandomAccessIterator1, class RandomAccessIterator2,
< 	  class RandomAccessIterator3, class Distance, class T, class Compare>
< RandomAccessIterator3 __merge_aux(RandomAccessIterator1 first1,
< 				  RandomAccessIterator1 last1,
< 				  RandomAccessIterator2 first2,
< 				  RandomAccessIterator2 last2,
< 				  RandomAccessIterator3 result,
< 				  Distance& fill_pointer, T*, Compare comp){
<     Distance len = 0;
<     while (first1 != last1 && first2 != last2 && len < fill_pointer) {
< 	++len;
< 	if (comp(*first2, *first1))
< 	    *result++ = *first2++;
< 	else
< 	    *result++ = *first1++;
<     }
<     if (fill_pointer <= len) {
< 	raw_storage_iterator<RandomAccessIterator3, T> p = result;
< 	result += (last1 - first1) + (last2 - first2);
< 	fill_pointer += (last1 - first1) + (last2 - first2);
< 	while (first1 != last1 && first2 != last2)
< 	    if (comp(*first2, *first1))
< 		*p++ = *first2++;
< 	    else
< 		*p++ = *first1++;
< 	copy(first2, last2, copy(first1, last1, p));
<     } else if (first2 == last2) {
< 	while (first1 != last1 && len < fill_pointer) { 
< 	    ++len;
< 	    *result++ = *first1++;
< 	}
< 	if (fill_pointer == len) {
< 	    raw_storage_iterator<RandomAccessIterator3, T> p = result;  
< 	    result += last1 - first1;
< 	    fill_pointer += last1 - first1;
< 	    while (first1 != last1) *p++ = *first1++;
< 	}
<     } else {
< 	while (first2 != last2 && len < fill_pointer) { 
< 	    ++len;
< 	    *result++ = *first2++;
< 	}
< 	if (fill_pointer == len) {
< 	    raw_storage_iterator<RandomAccessIterator3, T> p = result;  
< 	    result += last2 - first2;
< 	    fill_pointer += last2 - first2;
< 	    while (first2 != last2) *p++ = *first2++;
< 	}
<     }
<     return result;
< }       
< 
< template <class RandomAccessIterator1, class RandomAccessIterator2,
< 	  class Distance, class T>
< void __merge_sort_loop_aux(RandomAccessIterator1 first,
< 			   RandomAccessIterator1 last, 
< 			   RandomAccessIterator2 result, Distance step_size,
< 			   Distance& fill_pointer, T*) {
<     Distance two_step = 2 * step_size;
< 
<     while (last - first >= two_step) {
< 	result = __merge_aux(first, first + step_size, first + step_size,
< 			     first + two_step, result, fill_pointer, (T*)0);
< 	first += two_step;
<     }
<     step_size = min(Distance(last - first), step_size);
< 
<     __merge_aux(first, first + step_size, first + step_size, last, result,
< 		fill_pointer, (T*)0);
< }
< 
< template <class RandomAccessIterator1, class RandomAccessIterator2,
< 	  class Distance, class T, class Compare>
< void __merge_sort_loop_aux(RandomAccessIterator1 first,
< 		       RandomAccessIterator1 last, 
< 		       RandomAccessIterator2 result, Distance step_size,
< 		       Distance& fill_pointer, T*, Compare comp) {
<     Distance two_step = 2 * step_size;
< 
<     while (last - first >= two_step) {
< 	result = __merge_aux(first, first + step_size, first + step_size, 
< 			     first + two_step, result, fill_pointer, (T*)0,
< 			     comp);
< 	first += two_step;
<     }
<     step_size = min(Distance(last - first), step_size);
< 
<     __merge_aux(first, first + step_size, first + step_size, last, result, 
< 		fill_pointer, (T*)0, comp);
< }
< 
< template <class RandomAccessIterator1, class RandomAccessIterator2,
1103,1104c960,961
< 			       RandomAccessIterator last,
< 			       Pointer buffer, Distance& fill_pointer, T*) {
---
> 			      RandomAccessIterator last,
> 			      Pointer buffer, Distance*, T*) {
1109a967
> 
1111,1112c969
< 	__merge_sort_loop_aux(first, last, buffer, step_size, fill_pointer,
< 			      (T*)0);
---
> 	__merge_sort_loop(first, last, buffer, step_size);
1122,1124c979,980
< 			      RandomAccessIterator last,
< 			      Pointer buffer, Distance& fill_pointer,
< 			      T*, Compare comp) {
---
> 			      RandomAccessIterator last, Pointer buffer,
> 			      Distance*, T*, Compare comp) {
1132,1133c988
< 	__merge_sort_loop_aux(first, last, buffer, step_size, fill_pointer,
< 			      (T*)0, comp);
---
> 	__merge_sort_loop(first, last, buffer, step_size, comp);
1143c998
< 			    Distance buffer_size, Distance& fill_pointer, T*) {
---
> 			    Distance buffer_size, T*) {
1147,1150c1002,1003
< 	__stable_sort_adaptive(first, middle, buffer, buffer_size,
< 			       fill_pointer, (T*)0);
< 	__stable_sort_adaptive(middle, last, buffer, buffer_size,
< 			       fill_pointer, (T*)0);
---
> 	__stable_sort_adaptive(first, middle, buffer, buffer_size, (T*)0);
> 	__stable_sort_adaptive(middle, last, buffer, buffer_size, (T*)0);
1152,1153c1005,1006
< 	__merge_sort_with_buffer(first, middle, buffer, fill_pointer, (T*)0);
< 	__merge_sort_with_buffer(middle, last, buffer, fill_pointer, (T*)0);
---
> 	__merge_sort_with_buffer(first, middle, buffer, (Distance*)0, (T*)0);
> 	__merge_sort_with_buffer(middle, last, buffer, (Distance*)0, (T*)0);
1156,1157c1009
< 		     Distance(last - middle), buffer, buffer_size,
< 		     fill_pointer, (T*)0);
---
> 		     Distance(last - middle), buffer, buffer_size, (T*)0);
1164,1165c1016
< 			    Distance buffer_size, Distance& fill_pointer, 
< 			    T*, Compare comp) {
---
> 			    Distance buffer_size, T*, Compare comp) {
1169,1172c1020,1021
< 	__stable_sort_adaptive(first, middle, buffer, buffer_size,
< 			       fill_pointer, (T*)0, comp);
< 	__stable_sort_adaptive(middle, last, buffer, buffer_size,
< 			       fill_pointer, (T*)0, comp);
---
> 	__stable_sort_adaptive(first, middle, buffer, buffer_size, (T*)0, comp);
> 	__stable_sort_adaptive(middle, last, buffer, buffer_size, (T*)0, comp);
1174,1177c1023,1026
< 	__merge_sort_with_buffer(first, middle, buffer, fill_pointer,
< 				 (T*)0, comp);
< 	__merge_sort_with_buffer(middle, last, buffer, fill_pointer,
< 				 (T*)0, comp);
---
> 	__merge_sort_with_buffer(first, middle, buffer, (Distance*)0, (T*)0,
> 				 comp);
> 	__merge_sort_with_buffer(middle, last, buffer, (Distance*)0, (T*)0,
> 				 comp);
1180,1181c1029
< 		     Distance(last - middle), buffer, buffer_size,
< 		     fill_pointer, (T*)0, comp);
---
> 		     Distance(last - middle), buffer, buffer_size, (T*)0, comp);
1184c1032
< template <class RandomAccessIterator, class Pointer, class Distance>
---
> template <class RandomAccessIterator, class Pointer, class Distance, class T>
1187c1035
< 			  pair<Pointer, Distance> p) {
---
> 			  pair<Pointer, Distance> p, T*) {
1192,1195c1040,1043
<     Distance fill_pointer = 0;
<     __stable_sort_adaptive(first, last, p.first, p.second, fill_pointer,
< 			   value_type(first));
<     destroy(p.first, p.first + fill_pointer);
---
>     Distance len = min(p.second, last - first);
>     copy(first, first + len, raw_storage_iterator<Pointer, T>(p.first));
>     __stable_sort_adaptive(first, last, p.first, p.second, (T*)0);
>     destroy(p.first, p.first + len);
1199c1047
< template <class RandomAccessIterator, class Pointer, class Distance,
---
> template <class RandomAccessIterator, class Pointer, class Distance, class T,
1203c1051
< 			  pair<Pointer, Distance> p, Compare comp) {
---
> 			  pair<Pointer, Distance> p, T*, Compare comp) {
1208,1211c1056,1059
<     Distance fill_pointer = 0;
<     __stable_sort_adaptive(first, last, p.first, p.second, fill_pointer,
< 			   value_type(first), comp);
<     destroy(p.first, p.first + fill_pointer);
---
>     Distance len = min(p.second, last - first);
>     copy(first, first + len, raw_storage_iterator<Pointer, T>(p.first));
>     __stable_sort_adaptive(first, last, p.first, p.second, (T*)0, comp);
>     destroy(p.first, p.first + len);
1215c1063
< template <class RandomAccessIterator, class Distance>
---
> template <class RandomAccessIterator, class T, class Distance>
1217c1065
< 			      RandomAccessIterator last, Distance*) {
---
> 			      RandomAccessIterator last, T*, Distance*) {
1219c1067
< 						    value_type(first)));
---
> 						    (T*)0), (T*)0);
1222c1070
< template <class RandomAccessIterator, class Distance, class Compare>
---
> template <class RandomAccessIterator, class T, class Distance, class Compare>
1224c1072
< 			      RandomAccessIterator last, Distance*,
---
> 			      RandomAccessIterator last, T*, Distance*,
1227c1075
< 						    value_type(first)), comp);
---
> 						    (T*)0), (T*)0, comp);
1233c1081
<     __stable_sort_aux(first, last, distance_type(first));
---
>     __stable_sort_aux(first, last, value_type(first), distance_type(first));
1239c1087,1088
<     __stable_sort_aux(first, last, distance_type(first), comp);
---
>     __stable_sort_aux(first, last, value_type(first), distance_type(first), 
> 		      comp);
1264c1113
< 	if (*i < *first) 
---
> 	if (comp(*i, *first))
1320c1169