files.dif

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

< 	if (*first < *result_first) 
---
> 	if (comp(*first, *result_first))
1957,1958c1806
< 		      Pointer buffer, Distance buffer_size,
< 		      Distance& fill_pointer, T*) {
---
> 		      Pointer buffer, Distance buffer_size, T*) {
1960,1972c1808,1809
< 	BidirectionalIterator i = first;
< 	Pointer j = buffer;
< 	len2 = 0;
< 	while (len2 < len1 && len2 < fill_pointer) {
< 	    *buffer++ = *first++;
< 	    ++len2;
< 	}
< 	raw_storage_iterator<Pointer, T> end_buffer = buffer;
< 	while (len2++ < len1) {
< 	    *end_buffer++ = *first++;
< 	    ++fill_pointer;
< 	}
< 	merge(j, j + len1, middle, last, i);
---
>         Pointer end_buffer = copy(first, middle, buffer);
>         merge(buffer, end_buffer, middle, last, first);
1974,1986c1811,1812
< 	BidirectionalIterator i = middle;
< 	Pointer j = buffer;
< 	len1 = 0;
< 	while (len1 < len2 && len1 < fill_pointer) {
< 	    *buffer++ = *middle++;
< 	    ++len1;
< 	}
< 	raw_storage_iterator<Pointer, T> end_buffer = buffer;
< 	while (len1++ < len2) {
< 	    *end_buffer++ = *middle++;
< 	    ++fill_pointer;
< 	}
< 	__merge_backward(first, i, j, j + len2, last);
---
>         Pointer end_buffer = copy(middle, last, buffer);
>         __merge_backward(first, middle, buffer, end_buffer, last);
2007c1833
< 			 buffer_size, fill_pointer, (T*)0);
---
> 			 buffer_size, (T*)0);
2009,2010c1835
< 			 len2 - len22, buffer, buffer_size, fill_pointer,
< 			 (T*)0);
---
> 			 len2 - len22, buffer, buffer_size, (T*)0);
2019,2020c1844
< 		      Pointer buffer, Distance buffer_size,
< 		      Distance& fill_pointer, T*, Compare comp) {
---
> 		      Pointer buffer, Distance buffer_size, T*, Compare comp) {
2022,2034c1846,1847
< 	BidirectionalIterator i = first;
< 	Pointer j = buffer;
< 	len2 = 0;
< 	while (len2 < len1 && len2 < fill_pointer) {
< 	    *buffer++ = *first++;
< 	    ++len2;
< 	}
< 	raw_storage_iterator<Pointer, T> end_buffer = buffer;
< 	while (len2++ < len1) {
< 	    *end_buffer++ = *first++;
< 	    ++fill_pointer;
< 	}
< 	merge(j, j + len1, middle, last, i, comp);
---
> 	Pointer end_buffer = copy(first, middle, buffer);
> 	merge(buffer, end_buffer, middle, last, first, comp);
2036,2048c1849,1850
< 	BidirectionalIterator i = middle;
< 	Pointer j = buffer;
< 	len1 = 0;
< 	while (len1 < len2 && len1 < fill_pointer) {
< 	    *buffer++ = *middle++;
< 	    ++len1;
< 	}
< 	raw_storage_iterator<Pointer, T> end_buffer = buffer;
< 	while (len1++ < len2) {
< 	    *end_buffer++ = *middle++;
< 	    ++fill_pointer;
< 	}
< 	__merge_backward(first, i, j, j + len2, last, comp);
---
> 	Pointer end_buffer = copy(middle, last, buffer);
> 	__merge_backward(first, middle, buffer, end_buffer, last, comp);
2069c1871
< 			 buffer_size, fill_pointer, (T*)0, comp);
---
> 			 buffer_size, (T*)0, comp);
2071,2072c1873
< 			 len2 - len22, buffer, buffer_size, fill_pointer,
< 			 (T*)0, comp);
---
> 			 len2 - len22, buffer, buffer_size, (T*)0, comp);
2076c1877
< template <class BidirectionalIterator, class Distance, class Pointer>
---
> template <class BidirectionalIterator, class Distance, class Pointer, class T>
2080c1881
< 		     pair<Pointer, Distance> p) {
---
> 		     pair<Pointer, Distance> p, T*) {
2085,2088c1886,1889
<     Distance fill_pointer = 0;
<     __merge_adaptive(first, middle, last, len1, len2, p.first, p.second,
< 		     fill_pointer, value_type(first)); 
<     destroy(p.first, p.first + fill_pointer);
---
>     Distance len = min(p.second, len1 + len2);
>     fill_n(raw_storage_iterator<Pointer, T>(p.first), len, *first);
>     __merge_adaptive(first, middle, last, len1, len2, p.first, p.second, (T*)0);
>     destroy(p.first, p.first + len);
2092c1893
< template <class BidirectionalIterator, class Distance, class Pointer, 
---
> template <class BidirectionalIterator, class Distance, class Pointer, class T,
2097c1898
< 		     pair<Pointer, Distance> p, Compare comp) {
---
> 		     pair<Pointer, Distance> p, T*, Compare comp) {
2102,2105c1903,1907
<     Distance fill_pointer = 0;
<     __merge_adaptive(first, middle, last, len1, len2, p.first, p.second,
< 		     fill_pointer, value_type(first), comp); 
<     destroy(p.first, p.first + fill_pointer);
---
>     Distance len = min(p.second, len1 + len2);
>     fill_n(raw_storage_iterator<Pointer, T>(p.first), len, *first);
>     __merge_adaptive(first, middle, last, len1, len2, p.first, p.second, (T*)0,
> 		     comp); 
>     destroy(p.first, p.first + len);
2109c1911
< template <class BidirectionalIterator, class Distance>
---
> template <class BidirectionalIterator, class T, class Distance>
2112c1914
< 				BidirectionalIterator last, Distance*) {
---
> 				BidirectionalIterator last, T*, Distance*) {
2118c1920
< 		    get_temporary_buffer(len1 + len2, value_type(first)));
---
> 		    get_temporary_buffer(len1 + len2, (T*)0), (T*)0);
2121c1923
< template <class BidirectionalIterator, class Distance, class Compare>
---
> template <class BidirectionalIterator, class T, class Distance, class Compare>
2124c1926
< 				BidirectionalIterator last, Distance*,
---
> 				BidirectionalIterator last, T*, Distance*,
2131c1933
< 		    get_temporary_buffer(len1 + len2, value_type(first)),
---
> 		    get_temporary_buffer(len1 + len2, (T*)0), (T*)0,
2139c1941,1943
<     __inplace_merge_aux(first, middle, last, distance_type(first));
---
>     if (first == middle || middle == last) return;
>     __inplace_merge_aux(first, middle, last, value_type(first),
> 			distance_type(first));
2146c1950,1952
<     __inplace_merge_aux(first, middle, last, distance_type(first), comp);
---
>     if (first == middle || middle == last) return;
>     __inplace_merge_aux(first, middle, last, value_type(first),
> 			distance_type(first), comp);
2313,2314c2119,2120
< template <class InputIterator>
< InputIterator max_element(InputIterator first, InputIterator last) {
---
> template <class ForwardIterator>
> ForwardIterator max_element(ForwardIterator first, ForwardIterator last) {
2316c2122
<     InputIterator result = first;
---
>     ForwardIterator result = first;
2322,2324c2128,2130
< template <class InputIterator, class Compare>
< InputIterator max_element(InputIterator first, InputIterator last,
< 			  Compare comp) {
---
> template <class ForwardIterator, class Compare>
> ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
> 			    Compare comp) {
2326c2132
<     InputIterator result = first;
---
>     ForwardIterator result = first;
2332,2333c2138,2139
< template <class InputIterator>
< InputIterator min_element(InputIterator first, InputIterator last) {
---
> template <class ForwardIterator>
> ForwardIterator min_element(ForwardIterator first, ForwardIterator last) {
2335c2141
<     InputIterator result = first;
---
>     ForwardIterator result = first;
2341,2343c2147,2149
< template <class InputIterator, class Compare>
< InputIterator min_element(InputIterator first, InputIterator last,
< 			  Compare comp) {
---
> template <class ForwardIterator, class Compare>
> ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
> 			    Compare comp) {
2345c2151
<     InputIterator result = first;
---
>     ForwardIterator result = first;

=== diff old/algobase.h new/algobase.h

82c82
<     n = last - first;
---
>     n += last - first;
124c124
< 	destroy(first);
---
> 	destroy(&*first);
126c126
< 	//destroy(first++);
---
> 	//destroy(&*first++);
133c133
<     while (first != last) construct(result++, *first++);
---
>     while (first != last) construct(&*result++, *first++);
140c140
<     while (first != last) construct(first++, x);
---
>     while (first != last) construct(&*first++, x);
146c146
<     while (n--) construct(first++, x);
---
>     while (n--) construct(&*first++, x);

=== diff old/deque.h new/deque.h

264a265
> 	if (end().current == end().last) allocate_at_end();
267,268c268
< 	if (empty() || end().current == end().last)
< 	    allocate_at_end();
---
> 	if (empty()) allocate_at_end();
271a272
> 	if (end().current == end().last) allocate_at_end();
280a282
> 	if (end().current == end().first) deallocate_at_end();
284,285c286
< 	if (empty() || end().current == end().first)
< 	    deallocate_at_end();
---
> 	if (empty()) deallocate_at_end();
410a412,413
> 	if (finish.current == finish.first) 
> 	    data_allocator.deallocate(*start.node);

=== diff old/function.h new/function.h

21,22c21,22
< template <class T>
< inline bool operator!=(const T& x, const T& y) {
---
> template <class T1, class T2>
> inline bool operator!=(const T1& x, const T2& y) {
26,27c26,27
< template <class T>
< inline bool operator>(const T& x, const T& y) {
---
> template <class T1, class T2>
> inline bool operator>(const T1& x, const T2& y) {
31,32c31,32
< template <class T>
< inline bool operator<=(const T& x, const T& y) {
---
> template <class T1, class T2>
> inline bool operator<=(const T1& x, const T2& y) {
36,37c36,37
< template <class T>
< inline bool operator>=(const T& x, const T& y) {
---
> template <class T1, class T2>
> inline bool operator>=(const T1& x, const T2& y) {
244a245
>     pointer_to_unary_function() {}
258a260
>     pointer_to_binary_function() {}

=== diff old/list.h new/list.h

459c459,461
<     while(fill--) merge(counter[fill]);
---
> 
>     for (int i = 1; i < fill; ++i) counter[i].merge(counter[i-1]);
>     swap(counter[fill-1]);

=== diff old/pair.h new/pair.h

24a25
>     pair() {}

=== diff old/random.cpp new/random.cpp

54c54
< __random_generator rd(__SEED);
---
> static __random_generator rd(__SEED);