欧美伦理视频网站,国产视频一区免费看,欧美人体xx

Fri, 21 Apr 2006 08:30:00 GMT

考虑下面的语句：

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

该语句不会执行，因�ؓ没有为vi分配存储�I�间�Q�而copy函数使用复制�q�算�W�将元素从源拯��到目的。STL提供了三�U�可以将元素插入到目的的�q�代器，成�ؓ插入�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�上是重载了operator()的类模版�?/p>

STL提供了许多函数对象，�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
逻辑函数对象:
logical_not	!x
logical_and	x&y
logical_or	x\|y

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

Fri, 21 Apr 2006 07:49:00 GMT

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

0. accumlate�Q?/span>iterator�Ҏ��志的序列中的元素之和�Q�加��C��个由init指定的初始��g��。重载的版本不再做加法，而是传进来的二元操作�W�被应用到元素上�?/span>
adjacent_different�Q�创��Z��个新序列�Q�该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计��相��d��素的差�?/font>
adjacent_find�Q�在iterator�Ҏ��志的元素范围内，查找一对相�ȝ��重复元素�Q�如果找到返回一�?/span>ForwardIterator�Q�指向这对元素的�W�一个元素。否则返�?/span>last。重载版本��用输入的二元操作�W�代替相�{�的判断�?/span>
binary_search�Q�在有序序列中查�?/span>value�Q�如果找到返�?/span>true。重载的版本使用指定的比较函数对象或者函数指针来判断相等�?/span>
copy�Q�复制序列�?/font>
copy_backward�Q�除了元素以相反的顺序被拯��外，别的�?/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�代替了默认的等于操作符�?/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�束搜烦�Q�返回该元素的一�?/span>InputIterator�?/span>
find_if�Q��用输入的函数替代了等于操作符执行�?/span>find�?/span>
find_end�Q�在范围内查�䏀�由输入的另外一�?/span>iterator�Ҏ��志的�W�二个序列”的最后一�ơ出现。重载版本中使用了用戯��入的操作�W�替代等于操作�?/span>
find_first_of�Q�在范围内查�䏀�由输入的另外一�?/span>iterator�Ҏ��志的�W�二个序列”中的�Q意一个元素的�W�一�ơ出现。重载版本中使用了用戯��定义的操作符�?/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��。重载版本��用了用户定义的操作�?/span>
inner_merge�Q�合�q�两个排�q�序的连�l�序列，�l�果序列覆盖了两端范��_��重蝲版本使用输入的操作进行排序�?/font>
iter_swap�Q�交换两�?/span>ForwardIterator的倹{�?/span>
lexicographical_compare�Q�比较两个序列。重载版本��用了用户自定义的比较操作�?/font>
lower_bound�Q�返回一�?/span>iterator�Q�它指向在范围内的有序序列中可以插入指定��D��不破坏容器��序的第一个位�|�。重载函��C��用了自定义的比较操作�?/span>
max�Q�返回两个元素中的较大的一个，重蝲版本使用了自定义的比较操作�?/font>
max_element�Q�返回一�?/span>iterator�Q�指出序列中最大的元素。重载版本��用自定义的比较操作�?/span>
min�Q�两个元素中的较��者。重载版本��用自定义的比较操作�?/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�将光��新排序�ؓ下一个排列。重载版本��用自定义的比较操作�?/font>
nth_element�Q�将范围内的序列重新排序�Q��所有小于第n个元素的元素都出现在它前面，而大于它的都出现在后面，重蝲版本使用了自定义的比较操作�?/span>
partial_sort�Q�对整个序列做部分排序，被排序元素的个数正好可以被放到范围内。重载版本��用自定义的比较操作�?/font>
partial_sort_copy�Q�与partial_sort相同�Q�除了将�l�过排序的序列复制到另外一个容器�?/span>
partial_sum�Q�创��Z��个新的元素序列，其中每个元素的��g��表了范围内该位置之前所有元素之和。重载版本��用了自定义操作替代加法�?/font>
partition�Q�对范围内元素重新排序，使用输入的函敎ͼ�把计��结果�ؓtrue的元素都攑֜��l�果�?/span>false的元素之前�?/span>
prev_permutation�Q�取��围内的序列�ƈ��它重新排序��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�将范围内的所有操作结果�ؓ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��两个范围�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�重载版本��用了自定义的比较操作�?/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�它也不能真正的删除元素。重载版本��用了自定义的操作�?/span>
unique_copy�Q�类��g��unique�Q�不�q�它把结果输出到另外一个容器�?/span>
upper_bound�Q�返回一�?/span>iterator�Q�它指向在范围内的有序序列中插入value而不破坏容器��序的最后一个位�|�，该位�|�标志了一个大�?/span>value的倹{��重载版本��用了输入的比较操作�?/span>
堆算法：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 发表评论

STL数学��法及堆排序��法

Fri, 21 Apr 2006 07:46:00 GMT

数字��法�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> ∑A _i 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=` `∑A_{j (0~i),}把R_i存储到result开始的位置�Q�返回目标区间最后一个元素的下个位置`
`OutIt partial_sum(InIt first,InIt last,OutIt result, Pred pr);`	`R_i=pr(R_i-1,A_i),其中R₀=*first,` `把R_i存储到result开始的位置�Q�返回目标区间最后一个元素的下个位置`

堆排序算法：

`void make_heap(RanIt first, RanIt last); void make_heap(RanIt first, RanIt last, Pred pr);`
	用[first,last)之间的元素生成一个堆�Q�pr是用于比较数值的二元函数
`void sort_heap(RanIt first, RanIt last); void sort_heap(RanIt first, RanIt last, Pred pr);`	`堆排序[first,last)之间的数值序列，pr指定比较数值的二元判定函数`
`void push_heap(RanIt first, RanIt last); void push_heap(RanIt first, RanIt last, Pred pr);`
`void pop_heap(RanIt first, RanIt last); void pop_heap(RanIt first, 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ؓ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ؓ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�）�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

非修改算法：

��法	用法	说明
`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��ؓ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��件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之间的较��者，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)定义了五�U��P代器。下面的图表��d��了这几种�Q?/p>

            input         output
              \            /
                 forward
                     |
                bidirectional
                     |
              random access

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

各个�q�代器的功能如下�Q?/p>

�q�代器类�?/td>	说明
输入	从容器中��d��元素。输入�P代器只能一�ơ读入一个元素向前移动，输入�q�代器只支持一遍算法，同一个输入�P代器不能两遍遍历一个序�?/td>
输出	向容器中写入元素。输��P代器只能一�ơ一个元素向前移动。输��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代器的类别如下：

容器	支持的�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	快速查找，不允讔R��复�?/td>
multiset	快速查找，允许重复�?/td>
map	一对多映射�Q�基于关键字快速查找，不允讔R��复�?/td>
multimap	一对多映射�Q�基于关键字快速查找，允许重复�?/td>
容器适配�?/td>
stack	后进先出
queue	先进先出
priority_queue	最高优先��元素��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>

下表昄��了顺序容器和兌��容器中常用的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��索）

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

欧美伦理视频网站,国产视频一区免费看,欧美人体xx

STL函数对象

STL数学���法及堆排序���法

STL修改���法

STL数学��法及堆排序��法

STL修改��法