欧美乱妇高清无乱码,久久久免费精品,久久夜色精品

Fri, 21 Apr 2006 08:30:00 GMT

考虑下面的语句：(x��)

int arr[]={1,2,3,4,5};
vectorvi;
copy(arr,arr+5,vi.begin());

该语句不�?x��)执行，因��?f��)没有为vi分配存储�I�间�Q�而copy函数使用复制�q�算�W�将元素从源拯��到目的。STL提供�?ji��n)三�U�可以将元素插入到目的的�q�代器，成�ؓ(f��)插入�q�代器�?/p>

back_inserter:�q�种�q�代器调用容器的push_back操作替代赋��D��符。该�q�代器的参数是容器本�w��?/p>

front_inserter:该�P代器使用push_front操作替代赋��D��符。参数是容器本��n�?/p>

inserter:该�P代器使用容器的insert操作替代赋��D��符。该�q�代器有两个参数�Q�第一个参数是容器本��n�Q�第二个参数是容器的一个�P代器�Q�用以指定插入位�|��?/p>

芥之�?/a> 2006-04-21 16:30 发表评论

STL函数对象

Fri, 21 Apr 2006 08:18:00 GMT

��Z�ɾc�d��性算法具有灵�z�L��，STL常用函数重蝲机制为算法提供两�U��Ş式，��法的第一�U��Ş式��用的是常规操作来实现目标。在�W�二�U��Ş式中�Q�算法可以根据用��h��定的准则对元素进行处理。这�U�准则是通过函数对象来传递的。函数对象世�U�上是重载了(ji��n)operator()的类模版�?/p>

STL提供�?ji��n)许多函数对象，�q�些对象包含在头文�g中�?/p>

函数对象	说明
��术函数对象�Q?/td>
plus	x+y
minus	x-y
multiplies	x*y
divides	x/y
modulus	x%y
negate	-x
关系函数对象:
equal_to	x==y
not_equal_to	x!=y
grater	x>y
greater_equal	x>=y
less	x
less_equal	x<=y
逻辑函数对象:	(t��ng)
logical_not	!x
logical_and	x&y
logical_or	x\|y

(t��ng)

芥之�?/a> 2006-04-21 16:18 发表评论

Fri, 21 Apr 2006 07:49:00 GMT

泛型函数��?hr align="center" noshade="noshade" size="1" width="100%" />

0. (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) accumlate�Q?/span>iterator�Ҏ(gu��)��志的序列中的元素之和�Q�加��C��个由init指定的初始��g��。重载的版本不再做加法，而是传进来的二元操作�W�被应用到元素上�?/span>
adjacent_different�Q�创��Z��个新序列�Q�该序列的每个新值都代表�?ji��n)当前元素与上一个元素的差。重载版本用指定的二元操作计��相��d��素的差�?/font>
adjacent_find�Q�在iterator�Ҏ(gu��)��志的元素范围内，查找一对相�?c��)��重复元素�Q�如果找到返回一�?/span>ForwardIterator�Q�指向这对元素的�W�一个元素。否则返�?/span>last。重载版本��用输入的二元操作�W�代替相�{�的判断�?/span>
binary_search�Q�在有序序列中查�?/span>value�Q�如果找到返�?/span>true。重载的版本使用指定的比较函数对象或者函数指针来判断相等�?/span>
copy�Q�复制序列�?/font>
copy_backward�Q�除�?ji��n)元素以相反的顺序被拯��外，别的�?/span>copy相同�?/span>
count�Q�利用等于操作符�Q�把标志范围�cȝ��元素与输入的��D��行比较，�q�返回相�{�元素的个数�?/font>
count_if�Q�对于标志范围类的元素，应用输入的操作符�Q��ƈ�q�回�l�果�?/span>true的次数�?/span>
equal�Q�如果两个序列在范围内的元素都相�{�，�?/span>equal�q�回true。重载版本��用输入的操作�W�代替了(ji��n)默认的等于操作符�?/span>
equal_range�Q�返回一�?/span>iterator�Q�第一�?/span>iterator表示�?/span>lower_bound�q�回�?/span>iterator�Q�第二个表示�?/span>upper_bound�q�回�?/span>iterator倹{�?/span>
fill�Q�将输入的值的拯��赋给范围内的每个元素�?/font>
fill_n�Q�将输入的��D��值给first�?/span>frist+n范围内的元素�?/span>
find�Q�利用底层元素的�{�于操作�W�，对范围内的元素与输入的��D��行比较。当匚w��Ӟ��l�束搜烦(ch��)�Q�返回该元素的一�?/span>InputIterator�?/span>
find_if�Q��用输入的函数替代�?ji��n)等于操作符执行�?/span>find�?/span>
find_end�Q�在范围内查�䏀�由输入的另外一�?/span>iterator�Ҏ(gu��)��志的�W�二个序列”的最后一�ơ出现。重载版本中使用�?ji��n)用戯��入的操作�W�替代等于操作�?/span>
find_first_of�Q�在范围内查�䏀�由输入的另外一�?/span>iterator�Ҏ(gu��)��志的�W�二个序列”中的�Q意一个元素的�W�一�ơ出现。重载版本中使用�?ji��n)用戯��定义的操作符�?/span>
for_each�Q�依�ơ对范围内的所有元素执行输入的函数�?/font>
generate�Q�通过对输入的函数gen的连�l�调用来填充指定的范围�?/span>
generate_n�Q�填�?/span>n个元素�?/span>
includes�Q�判�?/span>[first1, last1)的一个元素是否被包含在另外一个序列中。��用底层元素的<=操作�W�，重蝲版本使用用户输入的函数�?/span>
inner_product�Q�对两个序列做内�U?/span>(对应的元素相乘，再求�?/span>)�Q��ƈ��内�U�加��C��个输入的的初始��g��。重载版本��用了(ji��n)用户定义的操作�?/span>
inner_merge�Q�合�q�两个排�q�序的连�l�序列，�l�果序列覆盖�?ji��n)两端范��_(d��)��重蝲版本使用输入的操作进行排序�?/font>
iter_swap�Q�交换两�?/span>ForwardIterator的倹{�?/span>
lexicographical_compare�Q�比较两个序列。重载版本��用了(ji��n)用户自定义的比较操作�?/font>
lower_bound�Q�返回一�?/span>iterator�Q�它指向在范围内的有序序列中可以插入指定��D��不破坏容器��序的第一个位�|�。重载函��C��用了(ji��n)自定义的比较操作�?/span>
max�Q�返回两个元素中的较大的一个，重蝲版本使用�?ji��n)自定义的比较操作�?/font>
max_element�Q�返回一�?/span>iterator�Q�指出序列中最大的元素。重载版本��用自定义的比较操作�?/span>
min�Q�两个元素中的较?y��u)��者。重载版本��用自定义的比较操作�?/font>
min_element�Q�类��g��max_element�Q�不�q�返回最��的元素�?/span>
merge�Q�合�q�两个有序序列，�q�存攑ֈ�另外一个序列中。重载版本��用自定义的比较�?/font>
mismatch�Q��ƈ行的比较两个序列�Q�指出第一个不匚w��的位�|�，它返回一�?/span>iterator�Q�标志第一个不匚w��的元素位�|�。如果都匚w��Q�返回每个容器的last。重载版本��用自定义的比较操作�?/span>
next_permutation�Q�取出当前范围内的排列，�q�将光��新排序�ؓ(f��)下一个排列。重载版本��用自定义的比较操作�?/font>
nth_element�Q�将范围内的序列重新排序�Q��所有小于第n个元素的元素都出现在它前面，而大于它的都出现在后面，重蝲版本使用�?ji��n)自定义的比较操作�?/span>
partial_sort�Q�对整个序列做部分排序，被排序元素的个数正好可以被放到范围内。重载版本��用自定义的比较操作�?/font>
partial_sort_copy�Q�与partial_sort相同�Q�除�?ji��n)将�l�过排序的序列复制到另外一个容器�?/span>
partial_sum�Q�创��Z��个新的元素序列，其中每个元素的��g��表了(ji��n)范围内该位置之前所有元素之和。重载版本��用了(ji��n)自定义操作替代加法�?/font>
partition�Q�对范围内元素重新排序，使用输入的函敎ͼ�把计��结果�ؓ(f��)true的元素都攑֜��l�果�?/span>false的元素之前�?/span>
prev_permutation�Q�取�?gu��)��围内的序列�ƈ��它重新排序��Z��一个序列。如果不存在上一个序列则�q�回false。重载版本��用自定义的比较操作�?/span>
random_shuffle�Q�对范围内的元素随机调整�ơ序。重载版本输入一个随机数产生操作�?/font>
remove�Q�删除在范围内的所有等于指定的元素�Q�注意，该函数�ƈ不真正删除元素。内�|�数�l�不适合使用remove�?/span>remove_if函数�?/span>
remove_copy�Q�将所有不匚w��的元素都复制��C��个指定容器，�q�回�?/span>OutputIterator指向被拷贝的末元素的下一个位�|��?/span>
remove_if�Q�删除所有范围内输入操作�l�果�?/span>true的元素�?/span>
remove_copy_if�Q�将所有不匚w��的元素拷贝到一个指定容器�?/font>
replace�Q�将范围内的所有等�?/span>old_value的元素都�?/span>new_value替代�?/span>
replace_copy�Q�与replace�c�M��Q�不�q�将�l�果写入另外一个容器�?/span>
replace_if�Q�将范围内的所有操作结果�ؓ(f��)true的元素用新值替代�?/span>
replace_copy_if�Q�类��g��replace_if�Q�不�q�将�l�果写入另外一个容器�?/span>
reverse�Q�将范围内元素重新按反序排列�?/font>
reverse_copy�Q�类��g��reverse�Q�不�q�将�l�果写入另外一个容器�?/span>
rotate�Q�将范围内的元素�U�d��容器末尾�Q�由middle指向的元素成为容器第一个元素�?/span>
rotate_copy�Q�类��g��rotate�Q�不�q�将�l�果写入另外一个容器�?/span>
search�Q�给��Z��(ji��n)两个范围�Q�返回一�?/span>iterator�Q�指向在范围内第一�ơ出现子序列的位�|�。重载版本��用自定义的比较操作�?/span>
search_n�Q�在范围内查�?/span>value出现n�ơ的子序列。重载版本��用自定义的比较操作�?/span>
set_difference�Q�构造一个排�q�序的序列，其中的元素出现在�W�一个序列中�Q�但是不包含在第二个序列中。重载版本��用自定义的比较操作�?/font>
set_intersection�Q�构造一个排�q�序的序列，其中的元素在两个序列中都存在。重载版本��用自定义的比较操作�?/font>
set_symmetric_difference�Q�构造一个排�q�序的序列，其中的元素在�W�一个序列中出现�Q�但是不出现在第二个序列中。重载版本��用自定义的比较操作�?/font>
set_union�Q�构造一个排�q�序的序列，它包含两个序列中的所有的不重复元素。重载版本��用自定义的比较操作�?/font>
sort�Q�以升序重新排列范围内的元素�Q�重载版本��用了(ji��n)自定义的比较操作�?/font>
stable_partition�Q�与partition�c�M��Q�不�q�它不保证保留容器中的相寚w��序�?/span>
stable_sort�Q�类��g��sort�Q�不�q�保留相�{�元素之间的��序关系�?/span>
swap�Q�交换存储在两个对象中的倹{�?/font>
swap_range�Q�将在范围内的元素与另外一个序列的元素��D��行交换�?/font>
transform�Q�将输入的操作作用在范围内的每个元素上，�q��生一个新的序列。重载版本将操作作用在一对元素上�Q�另外一个元素来自输入的另外一个序列。结果输出到指定的容器�?/font>
unique�Q�清除序列中重复的元素，�?/span>remove�c�M��Q�它也不能真正的删除元素。重载版本��用了(ji��n)自定义的操作�?/span>
unique_copy�Q�类��g��unique�Q�不�q�它把结果输出到另外一个容器�?/span>
upper_bound�Q�返回一�?/span>iterator�Q�它指向在范围内的有序序列中插入value而不破坏容器��序的最后一个位�|�，该位�|�标志了(ji��n)一个大�?/span>value的倹{��重载版本��用了(ji��n)输入的比较操作�?/span>
堆算法：(x��)C++标准库提供的�?/span>max-heap。一��q��以下4个泛型堆��法�?/span>
make_heap�Q�把范围内的元素生成一个堆。重载版本��用自定义的比较操作�?/font>
pop_heap�Q��ƈ不是真正的把最大元素从堆中弹出�Q�而是重新排序堆。它�?/span>first�?/span>last-1交换�Q�然后重新做成一个堆。可以��用容器的back来访问被“弹出“的元素或者��?/span>pop_back来真正的删除。重载版本��用自定义的比较操作�?/span>
push_heap�Q�假�?/span>first�?/span>last-1是一个有效的堆，要被加入堆的元素在位�|?/span>last-1�Q�重新生成堆。在指向该函数前�Q�必��d��把元素插入容器后。重载版本��用指定的比较�?/span>
sort_heap�Q�对范围内的序列重新排序�Q�它假设该序列是个有序的堆。重载版本��用自定义的比较操作�?/font>

芥之�?/a> 2006-04-21 15:49 发表评论

Fri, 21 Apr 2006 07:46:00 GMT

(t��ng)数字��法�Q?lt;numeric>

��法说明

T accumulate(InIt first,InIt last, T val); �q�回[first,last)所有元素相加后与val的和

T accumulate(InIt first,InIt last, T val, Pred pr); 对[first,last)的元素依�ơ递归调用pr�Q�V_n=pr(V_n-1,A_i),V₀=T;

OutIt adjacent_difference(InIt first,InIt last,OutIt result); 对[first,last)的元素依�ơ执行V_i=A_i+1-A_i�Q�V_i存储在result开始的容器里，�q�回目标区间最后一个元素的下一个位�|?/code>

OutIt adjacent_difference(InIt first,InIt last,OutIt result, Pred pr); 对[first,last)的元素依�ơ执行V_i=pr(A_i+1-A_i)�Q�V_i存储在result开始的容器里，�q�回目标区间最后一个元素的下一个位�|?/code>

T inner_product(InIt1 first1,InIt1 last1,Init2 first2, T val); 对[first1,last1)上的元素A_i�Q�[first2,last2)的元素B_i�Q�递归执行T_i=pr1(T_i-1,pr(A_i,B_i)),其中T-1=val�Q�返回最后T的��|��W�一�U��Ş�? �?/code> B _i

T inner_product(InIt1 first1,InIt1 last1,Init2 first2, T val, Pred1 pr1, Pred2 
pr2);

OutIt partial_sum(InIt first,InIt last,OutIt result); Ri= R_i=pr(R_i-1,A_i),其中R₀=*first,


												void make_heap(RanIt 
		first, RanIt last);

		void make_heap(RanIt first, RanIt last, Pred pr);

st, RanIt last, Pred pr);


												芥之�?/a> 2006-04-21 15:46 发表评论


STL修改���法
Fri, 21 Apr 2006 07:00:00 GMT

		修改���法�Q?/p>
		

				
				
						
								
										���法
								
								用法
								说明
						
						
								
										copy
								
								
										OutIt copy(InIt first,InIt last,OutIt x);
								
								
										���[first�Q�last)之间的元素复制到x指定的位�|?/code>
								
						
						
								
										copy_backward
								
								
										BidIt2 copy_backward(BidIt1 first,BidIt1 
		last,BidIt2 x);
								
								
										���[first�Q�last)之间的元素复制到x指定位置的前�?/code>
								
						
						
								
										fill
								
								
										void fill(FwdIt first,FwdIt last,const T& x);
								
								
										���[first�Q�last)之间的部分用元素x填充
								
						
						
								
										fill_n
								
								
										void fill_n(OutIt first, Size n,const T& x);
								
								
										从first开始向容器中填充n个元素x
								
						
						
								
										generate
								
								
										void generate(FwdIt first,FwdIt last, Gen g);
								
								
										调用函数g()填充[first�Q�last)之间的元�?/code>
								
						
						
								
										generate_n
								
								
										void generate_n(OutIt first,size n, Gen g);
								
								
										调用函数g()填充从first开始的n个元�?/code>
								
						
						
								
										remove
								
								
										FwdIt remove(FwdIt first,FwdIt last,const T& val);
								
								
										从[first�Q�last)中删除元素val�Q�返回新区间中最后一个元素后的位�|?/code>
								
						
						
								
										remove_if
								
								
										FwdIt remove_if(FwdIt first,FwdIt last, Pred pr);
								
								
										从[first�Q�last)中删除所有能使函数pr�q�回true的元素，�q�回新区间最后一个元素后的位�|?/code>
								
						
						
								
										remove_copy
								
								
										OutIt remove_copy(InIt first,InIt last,OutIt x,const T& val);
								
								
										从[first,last)中删除元素val�Q��ƈ把其余的元素复制到x开始的区间中，�q�回被拷贝的最后一个元素的位置
								
						
						
								
										remover_copy_if
								
								
										OutIt remove_copy_if(InIt first,InIt last,OutIt x,Pred pr);
								
								
										从[first�Q�last)中删除所有能使函数pr�q�回true的元素，�q�把其余元素复制到x开始的�I�间�Q�返回被拯���最后一个元素的位置
								
						
						
								
										replace
								
								
										void replace(FwdIt first,FwdIt last,const T& vold,const T& vnew);
								
								
										用vnew替换[first,last)中所有��gؓ(f��)vold的元�?/code>
								
						
						
								
										replace_if
								
								
										void replace_if(FwdIt first,FwdIt last,Pred pr,const T& val);
								
								
										用val替换[first,last)中所有能使函数pr�q�回true的元�?/code>
								
						
						
								
										replace_copy
								
								
										OutIt replace_copy(InIt first,InIt last,OutIt x,const T& vold,const 
T& vnew);
								
								
										把[first,last)中的所有元素复制到以x开始的�I�间中，如果拯���的元素中存在��gؓ(f��)vold的元素，则以vnew替换�Q�返回拷贝到目标容器的最后一个元素的后一个位�|?/code>
								
						
						
								
										replace_copy_if
								
								
										OutIt replace_copy_if(InIt first,InIt last,OutIt x,Pred pr,const T& val);
								
								
										把[first,last)中的所有元素复制到以x开始的�I�间中，如果拯���的元素中存在能够使函数pr�q�回true的元素，则以vnew替换�Q�返回拷贝到目标容器的最后一个元素的后一个位�|?/code>
								
						
						
								
										swap
								
								
										void swap(Container &c1,Container &c2);
								
								
										交换容器c1与c2的元�?/code>
								
						
						
								
										iter_swap
								
								
										void iter_swap(FwdIt1 x,FwdIt2 y);
								
								
										交换�q�代器x�Q�y所指元素的�?/code>
								
						
						
								
										swap_ranges
								
								
										FwdIt2 swap_ranges(FwdIt1 first,FwdIt1 last,FwdIt2 
x);
								
								
										用�v始于x的连�l�元素交换区间[first,last)的所有元素，�q�回�W�二个区间的最后一个元素的下一个位�|?/code>
								
						
						
								
										sort
								
								
										void sort(RanIt first, RanIt last);

void sort(RanIt first, RanIt last, Pred pr);
								
								
										���区间[first,last)中的元素按升序排序，�W�二�U��Ş式pr用于讑֮�比较函数
								
						
						
								
										merge
								
								
										OutIt merge(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt 
x);

OutIt merge(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x, Pred 
pr);
								
								
										合�ƈ两个有序区间[first1,last1)和[first2,last2)�Q��ƈ���合�q�后的元素存储到x开始的容器里，�W�二�U��Ş式pr(elem1,elem2)指定比较规则
								
						
						
								
										inplace_merge
								
								
										void inplace_merge(BidIt first, BidIt middle, BidIt last);

		void inplace_merge(BidIt first, BidIt middle, BidIt last, Pred pr);
								
								
										合�ƈ区间[first,middle)和[middle,last),�q�将合�ƈ后的元素存储到first开始的区间�Q�第二种形式pr(elem1,elem2)指定比较规则
								
						
						
								
										reverse
								
								
										void reverse(BidIt first, BidIt last);
								
								
										���区间[first,last)的元素顺序倒置
								
						
						
								
										reverse_copy
								
								
										OutIt reverse_copy(BidIt first, BidIt last,OutIt x);
								
								
										���区间[first�Q�last)的元素拷贝到x开始的区间�Q�导致拷贝的元素��序�Q�源区间没有被修改，�q�回拯���到目标区间的最后一个元素的下一个位�|?/code>
								
						
						
								
										rotate
								
								
										void rotate(FwdIt first,FwdIt middle,FwdIt last);
								
								
										交换区间[first,middle)和[middle,last)的元素位�|?/code>
								
						
						
								
										rotate_copy
								
								
										OutIt rotate_copy(FwdIt first,FwdIt middle,FwdIt last,OutIt 
x);
								
								
										���区间[first,last)的元素拷贝到x开始的容器中，拯���时交换[first,middle)和[middle,last)的位�|�，源区间不发生修改�Q�返回拷贝到目标区间的最后一个元素的下一�?/code>
								
						
						
								
										random_shuffle
								
								
										void random_shuffle(RanIt first, RanIt last);

void random_shuffle(RanIt first, RanIt last, Fun& f);
								
								
										对区间[first,last)上的元素�q�行随机排序�Q�f用于指定排序函数
								
						
						
								
										transform
								
								
										OutIt transform(InIt first,InIt last,OutIt x, Unop uop);
								
								
										对区间[first,last)上的所有元素执行uop(elem)操作�Q�结果放��C��x开始的区间内，�q�回拯���到目标端的最后一个元素的下一�?/code>
								
						
						
								
										transform
								
								
										OutIt transform(InIt1 first1,InIt1 last1,InIt2 first2,OutIt x, Binop 
bop);
								
								
										对区间[first1,last1)和以first2开始的区间的元素执行二元运���bop(elem1,elem2)�Q�结果放��C��x开始的区间内，�q�回拯���到目标端的最后一个元素的下一�?/code>
								
						
						
								
										set_itersection
								
								
										OutIt set_intersection(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 
last2,OutIt x);

OutIt set_intersection(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x, Pred pr);
								
								
										求两个区间[first1,last1),[first2,last2)的交集，存储到x开始的容器里，源区间元素没有被修改�Q�pr用于指定操作函数�Q�返回拷贝到目标区间的最后一个元素的下一个位�|?/code>
								
						
						
								
										set_union
								
								
										OutIt set_union(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x);

OutIt set_union(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x, 
Pred pr);
								
								
										求两个区间[first1,last1),[first2,last2)的�ƈ集，存储到x开始的容器里，源区间元素没有修改，pr用于指定操作函数�Q�返回拷贝到目标区间的最后一个元素的下一�?/code>
								
						
						
								
										set_difference
								
								
										OutIt set_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 
last2,OutIt x);

OutIt set_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt 
x, Pred pr);
								
								
										求两个集合[first1,last1),[first2,last2)的差集，存储到x开始的容器里，源区间元素没有被修改�Q�pr用于指定操作函数�Q�返回拷贝到目标区间的最后一个元素的下一个位�|?/code>
								
						
						
								
										set_symmetric_
										
												
		difference
										
								
								
										OutIt set_symmetric_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x);

OutIt set_symmetric_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 
last2,OutIt x, Pred pr);
								
								
										求集合[first1,last1),[first2,last2)的对�U�差�Q�即�Q�A-B�Q?�Q�B-A�Q�）(j��)�Q�存储到x开始的容器里，源区间元素没有被修改�Q�pr用于指定操作函数�Q�返回拷贝到目标区间最后一个元素的下一个位�|?/code>
								
						
				
		


芥之�?/a> 2006-04-21 15:00 发表评论


Thu, 20 Apr 2006 15:24:00 GMT

		
				�׃��STL���法都是通过�q�代器间接处理容器，下面定义istream_iteratorInIt,ostream_itreatorOutIt,forward_iteratorFwdIt,bidirectional_iterator BidIt,random_iterator RanIt
		
		非修改算法：(x��)
		
				
						
								
										���法
								
								用法
								说明
						
						
								
										
												adjacent_find
										
								
								
										FwdIt adjacent_find(FwdIt first,FwdIt last);

FwdIt adjacent_find(FwdIt first,FwdIt last,Pred pr);
								
								
										在[first,last)查找相同元素的首�ơ出现或能��pr�Q�elem,nextElem�Q��ؓ(f��)true的元素的位置
		�Q�函数查找成功返回位�|�，��p�|�q�回last
								
						
						
								
										
												binary_search
										
								
								
										bool binary_search(FwdIt first,FwdIt last,const T& val);

bool binary_search(FwdIt first,FwdIt last,const T& val,Pred pr);
								
								
										在区间[first,last)中查扑օ�素val�Q�如果找到返回true�Q�否则返回false�Q�第二种形式pr用于讑֮�查找准则
								
						
						
								
										count
								
								
										size_t count(InIt first,InIt last,const T& val);
								
								
										�q�回区间[first,last)上val出现的次�?/code>
								
						
						
								
										count_if
								
								
										size_t count_if(InIt first,InIt last,Pred pr);
								
								
										�q�回区间[first,last)上满���x(ch��ng)��件pr(elem�Q�的元素个数
								
						
						
								
										equal
								
								
										bool equal(InIt1 first,InIt1 last,InIt2 x);

		bool equal(InIt1 first,InIt1 last,InIt2 x,Pred pr);
								
								
										判断[first,last)与x开始的区间的元素是否相�{�，pr用于指定判断函数
								
						
						
								
										equal
								
								
										pair equal_range(FwdIt first,FwdIt 
		last,const T& val);

		pair equal_range(FwdIt first,FwdIt last,const T& val,Pred 
		pr);
								
								
										�q�回元素val�W�一�ơ出现的位置和最后出现的位置的下一位组成的对，pr指定比较���法
								
						
						
								
										lower_bound
								
								
										FwdIt lower_bound(FwdIt first,FwdIt last,const T& 
		val);

		FwdIt lower_bound(FwdIt first,FwdIt last,const T& val,Pred pr);
								
								
										�q�回已排序序列[first,last)中val首次出现的位�|�，pr指定比较���法
								
						
						
								
										upper_bound
								
								
										FwdIt upper_bound(FwdIt first,FwdIt last,const T& 
		val);

		FwdIt upper_bound(FwdIt first,FwdIt last,const T& val,Pred pr);
								
								
										�q�回已排序序列[first,last)中val最后一�ơ出现的下一个位�|�，pr指定比较���法
								
						
						
								
										find
								
								
										InIt find(InIt first,InIt last,const T& val);
								
								
										在[first,last)之间查找元素val�Q�如果找到返回位�|�，找不到返回last
								
						
						
								
										find_if
								
								
										InIt find_if(InIt first,InIt last, Pred pr);
								
								
										在[first,last)之间查找能��函数pr�q�回true的元素，扑ֈ��q�回位置�Q�否则返回last
								
						
						
								
										find_end
								
								
										FwdIt1 find_end(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 
last2);

FwdIt1 find_end(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2, Pred 
pr);
								
								
										
		在[first1�Q�last1)之间查找[first2�Q�last2)最后出现的位置�Q�如果找到返回位�|�，��p�|�q�回last1�Q�第二个函数的pr函数用于比较两个容器的元素，在两个容器的元素相等时返回true
								
						
						
								
										find_first_of
								
								
										FwdIt1 find_first_of(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 
last2);

FwdIt1 find_first_of(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2, Pred pr);
								
								
										
		在[first1�Q�last1)之间查找�W�一�ơ出现[first2�Q�last2)中元素的位置�Q�找到返回位�|�，��p�|�q�回last1�Q�第二个函数pr用于比较两个容器的元素是否相�{?/code>
								
						
						
								
										for_each
								
								
										Fun for_each(InIt first,InIt last, Fun f);
								
								
										对[first,last)上的所有元素执行函数f(elem),�q�回值常被忽�?/code>
								
						
						
								
										includes
								
								
										bool includes(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2);

bool includes(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2, Pred pr);
								
								
										
		判断已排序序列[first1,last1)中是否包含区间已排序区间[first2,last2)�Q�pr指定元素的顺�?/code>
								
						
						
								
										mismatch
								
								
										pair mismatch(InIt1 first,InIt1 
		last,InIt2 x);

		pair mismatch(InIt1 first,InIt1 last,InIt2 x, Pred pr);
								
								
										�q�回序列[first,last)与x开始的序列�W�一个不匚w��的位�|�的两个�q�代器组成的�?/code>
								
						
						
								
										max
								
								
										const T& max(const T& x,const T& y);

const T& max(const T& x,const T& y, Pred pr);
								
								
										�q�回x�Q�y之间的较大者，pr(elem1,elem2)用于指定比较规则
								
						
						
								
										max_element
								
								
										FwdIt max_element(FwdIt first,FwdIt last);

FwdIt max_element(FwdIt first,FwdIt last, Pred pr);
								
								
										�q�回区间[first,last)上最大值的位置�Q�pr(elem1,elem2)用于指定比较规则
								
						
						
								
										min
								
								
										const T& min(const T& x,const T& y);

const T& min(const T& x,const T& y, Pred pr);
								
								
										�q�回x�Q�y之间的较?y��u)��者，pr(elem1,elem2)用于指定比较规则
								
						
						
								
										min_element
								
								
										FwdIt min_element(FwdIt first,FwdIt last);

FwdIt min_element(FwdIt first,FwdIt last, Pred pr);
								
								
										�q�回区间[first,last)上的最���值的位置�Q�pr(elem1,elem2)用于指定比较规则
								
						
						
								
										search
								
								
										FwdIt1 search(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2);

FwdIt1 search(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2, Pred pr);
								
								
										
		在[first1�Q�last1)中查扑֭�区间[first2,last2),如果扑ֈ��q�回在第一个区间中的位�|�，��p�|�q�回last1�Q�第二种形式pr函数用于讑֮�比较函数
								
						
						
								
										search_n
								
								
										FwdIt search_n(FwdIt first,FwdIt last,Dist n,const T& val);

FwdIt search_n(FwdIt first,FwdIt last,Dist n,const T& val, Pred pr);
								
								
										在[first,last)中查找连�l�n个val�Q�如果找到返回在区间中的位置�Q�失败返回last�Q�第二种形式pr用于讑֮�比较函数
								
						
				
		


芥之�?/a> 2006-04-20 23:24 发表评论


Thu, 20 Apr 2006 10:32:00 GMT

		标准模板�?The Standard Template Library, STL)定义�?ji��n)五�U��P代器。下面的图表��d���?ji��n)这几种�Q?/p>
		
 (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) 
input (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) output

 (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng)\ (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng)/

 (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) forward

 (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng)|

 (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) bidirectional

 (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng)|

 (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng) (t��ng)  (t��ng)random access
		
				
						
								 (t��ng)
						
						
								
										

								
						
				
		
		
要注意，上面�q�图表�ƈ不是表明它们之间的��承关�p�：(x��)而只是描�q�C��(ji��n)�q�代器的�U�类和接口。处于图表下层的�q�代器都是相对于处于图表上层�q�代器的扩张集。例如：(x��)forward�q�代器不但拥有input和output�q�代器的所有功能，�q�拥有更多的功能�?/p>
		
各个�q�代器的功能如下�Q?/p>
		

				
						
								�q�代器类�?/td>
								 说明
						
						
								输入
								
		从容器中��d��元素。输入�P代器只能一�ơ读入一个元素向前移动，输入�q�代器只支持一遍算法，同一个输入�P代器不能两遍遍历一个序�?/td>
						
						
								输出
								
		向容器中写入元素。输�?gu��)��P代器只能一�ơ一个元素向前移动。输�?gu��)��P代器只支持一遍算法，�l�一输出�q�代器不能两�ơ遍历一个序�?/td>
						
						
								正向
								�l�合输入�q�代器和输出�q�代器的功能�Q��ƈ保留在容器中的位�|?/td>
						
						
								双向
								�l�合正向�q�代器和逆向�q�代器的功能�Q�支持多遍算�?/td>
						
						
								随机讉K��
								�l�合双向�q�代器的功能与直接访问容器中��M��元素的功能，卛_��向前向后跌�����L��个元�?/td>
						
				
		
		�q�代器的操作�Q?/p>
		
每种�q�代器均可进行包括表中前一�U��P代器可进行的操作�?/p>
		

				
						
								�q�代器操�?/td>
								 说明
						
						
								所有�P代器
						
						
								p++
								后置自增�q�代�?/td>
						
						
								++p
								前置自增�q�代�?/td>
						
						
								输入�q�代�?/td>
						
						
								*p
								复引用�P代器�Q�作为右�?/td>
						
						
								p=p1
								���一个�P代器赋给另一个�P代器
						
						
								p==p1
								比较�q�代器的相等�?/td>
						
						
								p!=p1
								比较�q�代器的不等�?/td>
						
						
								输出�q�代�?/td>
						
						
								*p
								复引用�P代器�Q�作为左�?/td>
						
						
								p=p1
								���一个�P代器赋给另一个�P代器
						
						
								正向�q�代�?/td>
								 提供输入输出�q�代器的所有功�?/td>
						
						
								双向�q�代�?/td>
						
						
								--p
								前置自减�q�代�?/td>
						
						
								p--
								后置自减�q�代�?/td>
						
						
								随机�q�代�?/td>
						
						
								p+=i
								����P代器递增i�?/td>
						
						
								p-=i
								����P代器递减i�?/td>
						
						
								p+i
								在p位加i位后的�P代器
						
						
								p-i
								在p位减i位后的�P代器
						
						
								p[i]
								�q�回p位元素偏���i位的元素引用
						
						
								p
								 如果�q�代器p的位�|�在p1前，�q�回true�Q�否则返回false
						
						
								p<=p1
								p的位�|�在p1的前面或同一位置时返回true�Q�否则返回false
						
						
								p>p1
								如果�q�代器p的位�|�在p1后，�q�回true�Q�否则返回false
						
						
								p>=p1
								p的位�|�在p1的后面或同一位置时返回true�Q�否则返回false
						
				
		
		只有��序容器和关联容器支持�P代器遍历�Q�各容器支持的�P代器的类别如下：(x��)
		
				
						
								容器
								支持的�P代器�c�d��
						
						
								vector
								随机讉K��
						
						
								deque
								随机讉K��
						
						
								list
								双向
						
						
								set
								双向
						
						
								multiset
								双向
						
						
								map
								双向
						
						
								multimap
								双向
						
						
								stack
								不支�?/td>
						
						
								queue
								不支�?/td>
						
						
								priority_queue
								不支�?/td>
						
				
		


芥之�?/a> 2006-04-20 18:32 发表评论


Thu, 20 Apr 2006 09:49:00 GMT

		
				
						
								标准容器�c?/td>
								 说明
						
						
								��序性容�?/td>
						
						
								vector
								从后面快速的插入与删除，直接讉K����M��元素
						
						
								deque
								从前面或后面快速的插入与删除，直接讉K����M��元素
						
						
								list
								双链表，从�Q何地方快速插入与删除
						
						
								兌���容器
						
						
								set
								快速查找，不允�?d��ng)R��复�?/td>
						
						
								multiset
								快速查找，允许重复�?/td>
						
						
								map
								一对多映射�Q�基于关键字快速查找，不允�?d��ng)R��复�?/td>
						
						
								multimap
								一对多映射�Q�基于关键字快速查找，允许重复�?/td>
						
						
								容器适配�?/td>
						
						
								stack
								后进先出
						
						
								queue
								先进先出
						
						
								priority_queue
								最高�(sh��)��先��元素��L���W�一个出�?/td>
						
				
		
		所有标准库共有函数
		
				
						
								默认构造函�?/td>
								 提供容器默认初始化的构造函数�?/td>
						
						
								复制构造函�?/td>
								 ���容器初始化为现有同�c�d��器副本的构造函�?/td>
						
						
								析构函数
								不再需要容器时�q�行内存整理的析构函�?/td>
						
						
								empty
								容器中没有元素时�q�回true,否则�q�回false
						
						
								max_size
								�q�回容器中最大元素个�?/td>
						
						
								size
								�q�回容器中当前元素个�?/td>
						
						
								operator=
								���一个容器赋�l�另一个容�?/td>
						
						
								operator<
								如果�W�一个容器小于第二个容器�Q�返回true�Q�否则返回false�Q?/td>
						
						
								operator<=
								如果�W�一个容器小于或�{�于�W�二个容器，�q�回true�Q�否则返回false
						
						
								operator>
								如果�W�一个容器大于第二个容器�Q�返回true�Q�否则返回false
						
						
								operator>=
								如果�W�一个容器大于或�{�于�W�二个容器，�q�回true�Q�否则返回false
						
						
								operator==
								如果�W�一个容器等于第二个容器�Q�返回true�Q�否则返回false
						
						
								operator!=
								如果�W�一个容器不�{�于�W�二个容器，�q�回true�Q�否则返回false
						
						
								swap
								交换两个容器的元�?/td>
						
				
		
		其中operator>,operator>=,operator<,operator<=,operator==,operator!=均不适用于priority_queue
		��序容器和关联容器共有函�?/p>
		

				
						
								begin
								该函��C��个版本返回iterator或const_iterator�Q�引用容器第一个元�?/td>
						
						
								end
								该函��C��个版本返回iterator或const_iterator,引用容器最后一个元素后面一�?/td>
						
						
								rbegin
								该函��C��个版本返回reverse_iterator或const_reverse_iterator,引用容器最后一个元�?/td>
						
						
								rend
								该函��C��个版本返回reverse_iterator或const_reverse_iterator�Q�引用容器第一个元素前面一�?/td>
						
						
								erase
								从容器中清除一个或几个元素
						
						
								clear
								清除容器中所有元�?/td>
						
				
		
		下表昄����?ji��n)顺序容器和兌���容器中常用的typedef�Q�这些typedef常用于变量、参数和函数�q�回值的一般性声明�?/p>
		

				
						
								value_type
								容器中存攑օ�素的�c�d��
						
						
								reference
								容器中存攑օ�素类型的引用
						
						
								const_reference
								容器中存攑օ�素类型的帔R��引用�Q�这�U�引用只能读取容器中的元素和�q�行const操作
						
						
								pointer
								容器中存攑օ�素类型的指针
						
						
								iterator
								指向容器中存攑օ�素类型的�q�代�?/td>
						
						
								const_iterator
								指向容器中存攑օ�素类型的帔R���q�代器，只能��d��容器中的元素
						
						
								reverse_iterator
								指向容器中存攑օ�素类型的逆向�q�代器，�q�种�q�代器在容器中逆向�q�代
						
						
								const_reverse_iterator
								指向容器中存攑օ�素类型的逆向�q�代器，只能��d��容器中的元素
						
						
								difference_type
								引用相同容器的两个�P代器相减�l�果的类型（list和关联容器没有定义operator-�Q?/td>
						
						
								size_type
								用于计算容器中项目数和检索顺序容器的�c�d���Q�不能对list���(g��)索）(j��)
						
				
		
		 (t��ng)


芥之�?/a> 2006-04-20 17:49 发表评论

欧美乱妇高清无乱码,久久久免费精品,久久夜色精品

STL函数对象

STL修改���法

STL修改��法