﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>C++博客-洗尘斋-随笔分类-STL</title><link>http://www.cppblog.com/lmlf001/category/1511.html</link><description>三悬明镜垂鸿韵，九撩清泉洗尘心
</description><language>zh-cn</language><lastBuildDate>Wed, 21 May 2008 06:09:22 GMT</lastBuildDate><pubDate>Wed, 21 May 2008 06:09:22 GMT</pubDate><ttl>60</ttl><item><title>STL插入迭代器</title><link>http://www.cppblog.com/lmlf001/archive/2006/04/21/6035.html</link><dc:creator>芥之舟</dc:creator><author>芥之舟</author><pubDate>Fri, 21 Apr 2006 08:30:00 GMT</pubDate><guid>http://www.cppblog.com/lmlf001/archive/2006/04/21/6035.html</guid><wfw:comment>http://www.cppblog.com/lmlf001/comments/6035.html</wfw:comment><comments>http://www.cppblog.com/lmlf001/archive/2006/04/21/6035.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/lmlf001/comments/commentRss/6035.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/lmlf001/services/trackbacks/6035.html</trackback:ping><description><![CDATA[
		<p>考虑下面的语句：</p>
		<p>int arr[]={1,2,3,4,5};<br />
vector&lt;int&gt;vi;<br />
copy(arr,arr+5,vi.begin());</p>
		<p>该语句不会执行，因为没有为vi分配存储空间，而copy函数使用复制运算符将元素从源拷贝到目的。STL提供了三种可以将元素插入到目的的迭代器，成为插入迭代器。</p>
		<p>back_inserter:这种迭代器调用容器的push_back操作替代赋值运算符。该迭代器的参数是容器本身。</p>
		<p>front_inserter:该迭代器使用push_front操作替代赋值运算符。参数是容器本身。</p>
		<p>
inserter:该迭代器使用容器的insert操作替代赋值运算符。该迭代器有两个参数：第一个参数是容器本身，第二个参数是容器的一个迭代器，用以指定插入位置。</p>
<img src ="http://www.cppblog.com/lmlf001/aggbug/6035.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/lmlf001/" target="_blank">芥之舟</a> 2006-04-21 16:30 <a href="http://www.cppblog.com/lmlf001/archive/2006/04/21/6035.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>STL函数对象</title><link>http://www.cppblog.com/lmlf001/archive/2006/04/21/6034.html</link><dc:creator>芥之舟</dc:creator><author>芥之舟</author><pubDate>Fri, 21 Apr 2006 08:18:00 GMT</pubDate><guid>http://www.cppblog.com/lmlf001/archive/2006/04/21/6034.html</guid><wfw:comment>http://www.cppblog.com/lmlf001/comments/6034.html</wfw:comment><comments>http://www.cppblog.com/lmlf001/archive/2006/04/21/6034.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/lmlf001/comments/commentRss/6034.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/lmlf001/services/trackbacks/6034.html</trackback:ping><description><![CDATA[
		<p>
为使类属性算法具有灵活性，STL常用函数重载机制为算法提供两种形式，算法的第一种形式使用的是常规操作来实现目标。在第二种形式中，算法可以根据用户指定的准则对元素进行处理。这种准则是通过函数对象来传递的。函数对象世纪上是重载了operator()的类模版。</p>
		<p>STL提供了许多函数对象，这些对象包含在头文件&lt;functional&gt;中。</p>
		<table id="table1" border="1" width="100%">
				<tbody>
						<tr>
								<td width="50%">函数对象</td>
								<td height="70%">说明</td>
						</tr>
						<tr>
								<td colspan="2">算术函数对象：</td>
						</tr>
						<tr>
								<td width="50%">plus&lt;T&gt;</td>
								<td height="70%">x+y</td>
						</tr>
						<tr>
								<td width="50%">minus&lt;T&gt;</td>
								<td height="70%">x-y</td>
						</tr>
						<tr>
								<td width="50%">multiplies&lt;T&gt;</td>
								<td height="70%">x*y</td>
						</tr>
						<tr>
								<td width="50%">divides&lt;T&gt;</td>
								<td height="70%">x/y</td>
						</tr>
						<tr>
								<td width="50%">modulus&lt;T&gt;</td>
								<td height="70%">x%y</td>
						</tr>
						<tr>
								<td width="50%">negate&lt;T&gt;</td>
								<td height="70%">-x</td>
						</tr>
						<tr>
								<td colspan="2">关系函数对象:</td>
						</tr>
						<tr>
								<td width="50%">equal_to&lt;T&gt;</td>
								<td height="70%">x==y</td>
						</tr>
						<tr>
								<td width="50%">not_equal_to&lt;T&gt;</td>
								<td height="70%">x!=y</td>
						</tr>
						<tr>
								<td width="50%">grater&lt;T&gt;</td>
								<td height="70%">x&gt;y</td>
						</tr>
						<tr>
								<td width="50%">greater_equal&lt;T&gt;</td>
								<td height="70%">x&gt;=y</td>
						</tr>
						<tr>
								<td width="50%">less&lt;T&gt;</td>
								<td height="70%">x&lt;y</td>
						</tr>
						<tr>
								<td width="50%">less_equal&lt;T&gt;</td>
								<td height="70%">x&lt;=y</td>
						</tr>
						<tr>
								<td width="50%">逻辑函数对象:</td>
								<td height="70%"> </td>
						</tr>
						<tr>
								<td width="50%">logical_not&lt;T&gt;</td>
								<td height="70%">!x</td>
						</tr>
						<tr>
								<td width="50%">logical_and&lt;T&gt;</td>
								<td height="70%">x&amp;y</td>
						</tr>
						<tr>
								<td width="50%">logical_or&lt;T&gt;</td>
								<td height="70%">x|y</td>
						</tr>
				</tbody>
		</table>
		<p> </p>
<img src ="http://www.cppblog.com/lmlf001/aggbug/6034.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/lmlf001/" target="_blank">芥之舟</a> 2006-04-21 16:18 <a href="http://www.cppblog.com/lmlf001/archive/2006/04/21/6034.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>泛型函数简表（ZZ）</title><link>http://www.cppblog.com/lmlf001/archive/2006/04/21/6032.html</link><dc:creator>芥之舟</dc:creator><author>芥之舟</author><pubDate>Fri, 21 Apr 2006 07:49:00 GMT</pubDate><guid>http://www.cppblog.com/lmlf001/archive/2006/04/21/6032.html</guid><wfw:comment>http://www.cppblog.com/lmlf001/comments/6032.html</wfw:comment><comments>http://www.cppblog.com/lmlf001/archive/2006/04/21/6032.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/lmlf001/comments/commentRss/6032.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/lmlf001/services/trackbacks/6032.html</trackback:ping><description><![CDATA[泛型函数简表<hr align="center" noshade="noshade" size="1" width="100%" /><br /><table style="table-layout: fixed;" align="center" border="0" cellpadding="0" cellspacing="0" width="98%"></table><p></p><p class="MsoNormal" style="margin: 0cm 0cm 0pt 18pt; text-indent: -18pt;"><font face="Tahoma"><font size="2"><span style="" lang="EN-US"><span style="">0.<span style="font-family: &quot;Times New Roman&quot;; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">       </span></span></span><b style=""><span lang="EN-US">accumlate</span></b><span style="font-family: 宋体;">：</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">对标志的序列中的元素之和，加到一个由</span><span lang="EN-US">init</span><span style="font-family: 宋体;">指定的初始值上。重载的版本不再做加法，而是传进来的二元操作符被应用到元素上。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">adjacent_different</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：创建一个新序列，该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计算相邻元素的差。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">adjacent_find</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：在</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">对标志的元素范围内，查找一对相邻的重复元素，如果找到返回一个</span><span lang="EN-US">ForwardIterator</span><span style="font-family: 宋体;">，指向这对元素的第一个元素。否则返回</span><span lang="EN-US">last</span><span style="font-family: 宋体;">。重载版本使用输入的二元操作符代替相等的判断。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">binary_search</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：在有序序列中查找</span><span lang="EN-US">value</span><span style="font-family: 宋体;">，如果找到返回</span><span lang="EN-US">true</span><span style="font-family: 宋体;">。重载的版本使用指定的比较函数对象或者函数指针来判断相等。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">copy</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：复制序列。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">copy_backward</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：除了元素以相反的顺序被拷贝外，别的和</span><span lang="EN-US">copy</span><span style="font-family: 宋体;">相同。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">count</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：利用等于操作符，把标志范围类的元素与输入的值进行比较，并返回相等元素的个数。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">count_if</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：对于标志范围类的元素，应用输入的操作符，并返回结果为</span><span lang="EN-US">true</span><span style="font-family: 宋体;">的次数。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">equal</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：如果两个序列在范围内的元素都相等，则</span><span lang="EN-US">equal</span><span style="font-family: 宋体;">返回</span><span lang="EN-US">true</span><span style="font-family: 宋体;">。重载版本使用输入的操作符代替了默认的等于操作符。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">equal_range</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：返回一对</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">，第一个</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">表示由</span><span lang="EN-US">lower_bound</span><span style="font-family: 宋体;">返回的</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">，第二个表示由</span><span lang="EN-US">upper_bound</span><span style="font-family: 宋体;">返回的</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">值。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">fill</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：将输入的值的拷贝赋给范围内的每个元素。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">fill_n</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：将输入的值赋值给</span><span lang="EN-US">first</span><span style="font-family: 宋体;">到</span><span lang="EN-US">frist+n</span><span style="font-family: 宋体;">范围内的元素。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">find</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：利用底层元素的等于操作符，对范围内的元素与输入的值进行比较。当匹配时，结束搜索，返回该元素的一个</span><span lang="EN-US">InputIterator</span><span style="font-family: 宋体;">。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">find_if</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：使用输入的函数替代了等于操作符执行了</span><span lang="EN-US">find</span><span style="font-family: 宋体;">。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">find_end</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：在范围内查找“由输入的另外一个</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">对标志的第二个序列”的最后一次出现。重载版本中使用了用户输入的操作符替代等于操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">find_first_of</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：在范围内查找“由输入的另外一个</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">对标志的第二个序列”中的任意一个元素的第一次出现。重载版本中使用了用户自定义的操作符。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">for_each</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：依次对范围内的所有元素执行输入的函数。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">generate</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：通过对输入的函数</span><span lang="EN-US">gen</span><span style="font-family: 宋体;">的连续调用来填充指定的范围。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">generate_n</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：填充</span><span lang="EN-US">n</span><span style="font-family: 宋体;">个元素。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">includes</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：判断</span><span lang="EN-US">[first1, last1)</span><span style="font-family: 宋体;">的一个元素是否被包含在另外一个序列中。使用底层元素的</span><span lang="EN-US">&lt;=</span><span style="font-family: 宋体;">操作符，重载版本使用用户输入的函数。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">inner_product</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：对两个序列做内积</span><span lang="EN-US">(</span><span style="font-family: 宋体;">对应的元素相乘，再求和</span><span lang="EN-US">)</span><span style="font-family: 宋体;">，并将内积加到一个输入的的初始值上。重载版本使用了用户定义的操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">inner_merge</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：合并两个排过序的连续序列，结果序列覆盖了两端范围，重载版本使用输入的操作进行排序。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">iter_swap</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：交换两个</span><span lang="EN-US">ForwardIterator</span><span style="font-family: 宋体;">的值。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">lexicographical_compare</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：比较两个序列。重载版本使用了用户自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">lower_bound</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：返回一个</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">，它指向在范围内的有序序列中可以插入指定值而不破坏容器顺序的第一个位置。重载函数使用了自定义的比较操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">max</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：返回两个元素中的较大的一个，重载版本使用了自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">max_element</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：返回一个</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">，指出序列中最大的元素。重载版本使用自定义的比较操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">min</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：两个元素中的较小者。重载版本使用自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">min_element</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：类似与</span><span lang="EN-US">max_element</span><span style="font-family: 宋体;">，不过返回最小的元素。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">merge</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：合并两个有序序列，并存放到另外一个序列中。重载版本使用自定义的比较。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">mismatch</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：并行的比较两个序列，指出第一个不匹配的位置，它返回一对</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">，标志第一个不匹配的元素位置。如果都匹配，返回每个容器的</span><span lang="EN-US">last</span><span style="font-family: 宋体;">。重载版本使用自定义的比较操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">next_permutation</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：取出当前范围内的排列，并将其重新排序为下一个排列。重载版本使用自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">nth_element</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：将范围内的序列重新排序，使所有小于第</span><span lang="EN-US">n</span><span style="font-family: 宋体;">个元素的元素都出现在它前面，而大于它的都出现在后面，重载版本使用了自定义的比较操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">partial_sort</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：对整个序列做部分排序，被排序元素的个数正好可以被放到范围内。重载版本使用自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">partial_sort_copy</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：与</span><span lang="EN-US">partial_sort</span><span style="font-family: 宋体;">相同，除了将经过排序的序列复制到另外一个容器。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">partial_sum</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：创建一个新的元素序列，其中每个元素的值代表了范围内该位置之前所有元素之和。重载版本使用了自定义操作替代加法。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">partition</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：对范围内元素重新排序，使用输入的函数，把计算结果为</span><span lang="EN-US">true</span><span style="font-family: 宋体;">的元素都放在结果为</span><span lang="EN-US">false</span><span style="font-family: 宋体;">的元素之前。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">prev_permutation</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：取出范围内的序列并将它重新排序为上一个序列。如果不存在上一个序列则返回</span><span lang="EN-US">false</span><span style="font-family: 宋体;">。重载版本使用自定义的比较操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">random_shuffle</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：对范围内的元素随机调整次序。重载版本输入一个随机数产生操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">remove</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：删除在范围内的所有等于指定的元素，注意，该函数并不真正删除元素。内置数组不适合使用</span><span lang="EN-US">remove</span><span style="font-family: 宋体;">和</span><span lang="EN-US">remove_if</span><span style="font-family: 宋体;">函数。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">remove_copy</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：将所有不匹配的元素都复制到一个指定容器，返回的</span><span lang="EN-US">OutputIterator</span><span style="font-family: 宋体;">指向被拷贝的末元素的下一个位置。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">remove_if</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：删除所有范围内输入操作结果为</span><span lang="EN-US">true</span><span style="font-family: 宋体;">的元素。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">remove_copy_if</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：将所有不匹配的元素拷贝到一个指定容器。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">replace</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：将范围内的所有等于</span><span lang="EN-US">old_value</span><span style="font-family: 宋体;">的元素都用</span><span lang="EN-US">new_value</span><span style="font-family: 宋体;">替代。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">replace_copy</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：与</span><span lang="EN-US">replace</span><span style="font-family: 宋体;">类似，不过将结果写入另外一个容器。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">replace_if</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：将范围内的所有操作结果为</span><span lang="EN-US">true</span><span style="font-family: 宋体;">的元素用新值替代。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">replace_copy_if</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：类似与</span><span lang="EN-US">replace_if</span><span style="font-family: 宋体;">，不过将结果写入另外一个容器。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">reverse</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：将范围内元素重新按反序排列。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">reverse_copy</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：类似与</span><span lang="EN-US">reverse</span><span style="font-family: 宋体;">，不过将结果写入另外一个容器。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">rotate</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：将范围内的元素移到容器末尾，由</span><span lang="EN-US">middle</span><span style="font-family: 宋体;">指向的元素成为容器第一个元素。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">rotate_copy</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：类似与</span><span lang="EN-US">rotate</span><span style="font-family: 宋体;">，不过将结果写入另外一个容器。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">search</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：给出了两个范围，返回一个</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">，指向在范围内第一次出现子序列的位置。重载版本使用自定义的比较操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">search_n</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：在范围内查找</span><span lang="EN-US">value</span><span style="font-family: 宋体;">出现</span><span lang="EN-US">n</span><span style="font-family: 宋体;">次的子序列。重载版本使用自定义的比较操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">set_difference</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：构造一个排过序的序列，其中的元素出现在第一个序列中，但是不包含在第二个序列中。重载版本使用自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">set_intersection</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：构造一个排过序的序列，其中的元素在两个序列中都存在。重载版本使用自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">set_symmetric_difference</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：构造一个排过序的序列，其中的元素在第一个序列中出现，但是不出现在第二个序列中。重载版本使用自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">set_union</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：构造一个排过序的序列，它包含两个序列中的所有的不重复元素。重载版本使用自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">sort</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：以升序重新排列范围内的元素，重载版本使用了自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">stable_partition</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：与</span><span lang="EN-US">partition</span><span style="font-family: 宋体;">类似，不过它不保证保留容器中的相对顺序。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">stable_sort</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：类似与</span><span lang="EN-US">sort</span><span style="font-family: 宋体;">，不过保留相等元素之间的顺序关系。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">swap</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：交换存储在两个对象中的值。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">swap_range</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：将在范围内的元素与另外一个序列的元素值进行交换。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">transform</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：将输入的操作作用在范围内的每个元素上，并产生一个新的序列。重载版本将操作作用在一对元素上，另外一个元素来自输入的另外一个序列。结果输出到指定的容器。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">unique</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：清除序列中重复的元素，和</span><span lang="EN-US">remove</span><span style="font-family: 宋体;">类似，它也不能真正的删除元素。重载版本使用了自定义的操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">unique_copy</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：类似与</span><span lang="EN-US">unique</span><span style="font-family: 宋体;">，不过它把结果输出到另外一个容器。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">upper_bound</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：返回一个</span><span lang="EN-US">iterator</span><span style="font-family: 宋体;">，它指向在范围内的有序序列中插入</span><span lang="EN-US">value</span><span style="font-family: 宋体;">而不破坏容器顺序的最后一个位置，该位置标志了一个大于</span><span lang="EN-US">value</span><span style="font-family: 宋体;">的值。重载版本使用了输入的比较操作。</span></font></font><span lang="EN-US"><br /></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">堆算法：</span><span lang="EN-US">C++</span><span style="font-family: 宋体;">标准库提供的是</span><span lang="EN-US">max-heap</span><span style="font-family: 宋体;">。一共由以下</span><span lang="EN-US">4</span><span style="font-family: 宋体;">个泛型堆算法。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">make_heap</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：把范围内的元素生成一个堆。重载版本使用自定义的比较操作。</font></span><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">pop_heap</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：并不是真正的把最大元素从堆中弹出，而是重新排序堆。它把</span><span lang="EN-US">first</span><span style="font-family: 宋体;">和</span><span lang="EN-US">last-1</span><span style="font-family: 宋体;">交换，然后重新做成一个堆。可以使用容器的</span><span lang="EN-US">back</span><span style="font-family: 宋体;">来访问被“弹出“的元素或者使用</span><span lang="EN-US">pop_back</span><span style="font-family: 宋体;">来真正的删除。重载版本使用自定义的比较操作。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">push_heap</font></b></span><font face="Tahoma"><font size="2"><span style="font-family: 宋体;">：假设</span><span lang="EN-US">first</span><span style="font-family: 宋体;">到</span><span lang="EN-US">last-1</span><span style="font-family: 宋体;">是一个有效的堆，要被加入堆的元素在位置</span><span lang="EN-US">last-1</span><span style="font-family: 宋体;">，重新生成堆。在指向该函数前，必须先把元素插入容器后。重载版本使用指定的比较。</span></font></font><span lang="EN-US"><br /><b style=""><font face="Tahoma" size="2">sort_heap</font></b></span><span style="font-family: 宋体;"><font face="Tahoma" size="2">：对范围内的序列重新排序，它假设该序列是个有序的堆。重载版本使用自定义的比较操作。</font></span></p><img src ="http://www.cppblog.com/lmlf001/aggbug/6032.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/lmlf001/" target="_blank">芥之舟</a> 2006-04-21 15:49 <a href="http://www.cppblog.com/lmlf001/archive/2006/04/21/6032.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>STL数学算法及堆排序算法</title><link>http://www.cppblog.com/lmlf001/archive/2006/04/21/6031.html</link><dc:creator>芥之舟</dc:creator><author>芥之舟</author><pubDate>Fri, 21 Apr 2006 07:46:00 GMT</pubDate><guid>http://www.cppblog.com/lmlf001/archive/2006/04/21/6031.html</guid><wfw:comment>http://www.cppblog.com/lmlf001/comments/6031.html</wfw:comment><comments>http://www.cppblog.com/lmlf001/archive/2006/04/21/6031.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/lmlf001/comments/commentRss/6031.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/lmlf001/services/trackbacks/6031.html</trackback:ping><description><![CDATA[
		<p> 数字算法：&lt;numeric&gt;</p>
		<table id="table3" border="1" width="100%">
				<tbody>
						<tr>
								<td>算法</td>
								<td width="530">说明</td>
						</tr>
						<tr>
								<td>
										<code>T accumulate(InIt first,InIt last, T val);</code>
								</td>
								<td width="530">
										<code>返回[first,last)所有元素相加后与val的和</code>
								</td>
						</tr>
						<tr>
								<td>
										<code>T accumulate(InIt first,InIt last, T val, Pred pr);</code>
								</td>
								<td width="530">
										<code>对[first,last)的元素依次递归调用pr，V<sub>n</sub>=pr(V<sub>n-1</sub>,A<sub>i</sub>),V<sub>0</sub>=T;</code>
								</td>
						</tr>
						<tr>
								<td>
										<code>OutIt adjacent_difference(InIt first,InIt last,OutIt result);</code>
								</td>
								<td width="530">
										<code>对[first,last)的元素依次执行V<sub>i</sub>=A<sub>i+1</sub>-A<sub>i</sub>，V<sub>i</sub>存储在result开始的容器里，返回目标区间最后一个元素的下一个位置</code>
								</td>
						</tr>
						<tr>
								<td>
										<code>OutIt adjacent_difference(InIt first,InIt last,OutIt result, Pred 
pr);</code>
								</td>
								<td width="530">
										<code>对[first,last)的元素依次执行V<sub>i</sub>=pr(A<sub>i+1</sub>-A<sub>i</sub>)，V<sub>i</sub>存储在result开始的容器里，返回目标区间最后一个元素的下一个位置</code>
								</td>
						</tr>
						<tr>
								<td>
										<code>T inner_product(InIt1 first1,InIt1 last1,Init2 first2, T val);</code>
								</td>
								<td rowspan="2" width="530">
										<code>对[first1,last1)上的元素A<sub>i</sub>，[first2,last2)的元素B<sub>i</sub>，递归执行T<sub>i</sub>=pr1(T<sub>i-1</sub>,pr(A<sub>i</sub>,B<sub>i</sub>)),其中T-1=val，返回最后T的值，第一种形式
		为</code>
										<font face="宋体">
												<code>∑A</code>
										</font>
										<sub>
												<code>i</code>
										</sub>
										<font face="宋体">
												<code>B</code>
										</font>
										<sub>
												<code>i</code>
										</sub>
								</td>
						</tr>
						<tr>
								<td>
										<code>T inner_product(InIt1 first1,InIt1 last1,Init2 first2, T val, Pred1 pr1, Pred2 
pr2);</code>
								</td>
						</tr>
						<tr>
								<td>
										<code>OutIt partial_sum(InIt first,InIt last,OutIt result);</code>
								</td>
								<td width="530">
										<code>Ri=</code>
										<font face="宋体">
												<code>∑A<sub>j (0~i),</sub>把R<sub>i</sub>存储到result开始的位置，返回目标区间最后一个元素的下个位置</code>
										</font>
								</td>
						</tr>
						<tr>
								<td>
										<code>OutIt partial_sum(InIt first,InIt last,OutIt result, Pred pr);</code>
								</td>
								<td width="530">
										<code>R<sub>i</sub>=pr(R<sub>i-1,</sub>A<sub>i</sub>),其中R<sub>0</sub>=*first,</code>
										<font face="宋体">
												<code>把R<sub>i</sub>存储到result开始的位置，返回目标区间最后一个元素的下个位置</code>
										</font>
								</td>
						</tr>
				</tbody>
		</table>
		<p>
				<code>
						<br />
				</code>堆排序算法：</p>
		<table id="table4" border="1" width="100%">
				<tbody>
						<tr>
								<td rowspan="2">
										<code>
												<font face="宋体" size="3">void <b>make_heap</b>(RanIt 
		first, RanIt last);<br />
		void <b>make_heap</b>(RanIt first, RanIt last, Pred pr);</font>
										</code>
								</td>
						</tr>
						<tr>
								<td>
										<font face="宋体">用[first,last)之间的元素生成一个堆，pr是用于比</font>较数值的二元函数</td>
						</tr>
						<tr>
								<td>
										<code>void <b>sort_heap</b>(RanIt first, RanIt last);<br />
		void <b>sort_heap</b>(RanIt fir<font face="宋体">st, RanIt last, Pred pr);</font></code>
								</td>
								<td>
										<code>
												<font face="宋体">堆排序[first,last)之间的数值序列，pr指定比较数值的二元判定函数</font>
										</code>
								</td>
						</tr>
						<tr>
								<td>
										<code>void <b>push_heap</b>(RanIt first, RanIt last);<br />
		void <b>push_heap</b>(RanIt first, RanIt last, Pred pr);</code>
								</td>
								<td> </td>
						</tr>
						<tr>
								<td>
										<code>void <b>pop_heap</b>(RanIt first, RanIt last);<br />
		void <b>pop_heap</b>(RanIt first, RanIt last, Pred pr);</code>
								</td>
								<td> </td>
						</tr>
				</tbody>
		</table>
<img src ="http://www.cppblog.com/lmlf001/aggbug/6031.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/lmlf001/" target="_blank">芥之舟</a> 2006-04-21 15:46 <a href="http://www.cppblog.com/lmlf001/archive/2006/04/21/6031.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>STL修改算法</title><link>http://www.cppblog.com/lmlf001/archive/2006/04/21/6025.html</link><dc:creator>芥之舟</dc:creator><author>芥之舟</author><pubDate>Fri, 21 Apr 2006 07:00:00 GMT</pubDate><guid>http://www.cppblog.com/lmlf001/archive/2006/04/21/6025.html</guid><wfw:comment>http://www.cppblog.com/lmlf001/comments/6025.html</wfw:comment><comments>http://www.cppblog.com/lmlf001/archive/2006/04/21/6025.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/lmlf001/comments/commentRss/6025.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/lmlf001/services/trackbacks/6025.html</trackback:ping><description><![CDATA[
		<p>修改算法：</p>
		<table id="table2" border="1" width="100%">
				<!-- MSTableType="nolayout" -->
				<tbody>
						<tr>
								<td width="10%">
										<font size="2">算法</font>
								</td>
								<td width="45%">用法</td>
								<td width="45%">说明</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">copy</font>
								</td>
								<td width="45%">
										<code>OutIt copy(InIt first,InIt last,OutIt x);</code>
								</td>
								<td width="45%">
										<code>将[first，last)之间的元素复制到x指定的位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">copy_backward</font>
								</td>
								<td width="45%">
										<code>BidIt2 copy_backward(BidIt1 first,BidIt1 
		last,BidIt2 x);</code>
								</td>
								<td width="45%">
										<code>将[first，last)之间的元素复制到x指定位置的前面</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">fill</font>
								</td>
								<td width="45%">
										<code>void fill(FwdIt first,FwdIt last,const T&amp; x);</code>
								</td>
								<td width="45%">
										<code>将[first，last)之间的部分用元素x填充</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">fill_n</font>
								</td>
								<td width="45%">
										<code>void fill_n(OutIt first, Size n,const T&amp; x);</code>
								</td>
								<td width="45%">
										<code>从first开始向容器中填充n个元素x</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">generate</font>
								</td>
								<td width="45%">
										<code>void generate(FwdIt first,FwdIt last, Gen g);</code>
								</td>
								<td width="45%">
										<code>调用函数g()填充[first，last)之间的元素</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">generate_n</font>
								</td>
								<td width="45%">
										<code>void generate_n(OutIt first,size n, Gen g);</code>
								</td>
								<td width="45%">
										<code>调用函数g()填充从first开始的n个元素</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">remove</font>
								</td>
								<td width="45%">
										<code>FwdIt remove(FwdIt first,FwdIt last,const T&amp; val);</code>
								</td>
								<td width="45%">
										<code>从[first，last)中删除元素val，返回新区间中最后一个元素后的位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">remove_if</font>
								</td>
								<td width="45%">
										<code>FwdIt remove_if(FwdIt first,FwdIt last, Pred pr);</code>
								</td>
								<td width="45%">
										<code>从[first，last)中删除所有能使函数pr返回true的元素，返回新区间最后一个元素后的位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">remove_copy</font>
								</td>
								<td width="45%">
										<code>OutIt remove_copy(InIt first,InIt last,OutIt x,const T&amp; val);</code>
								</td>
								<td width="45%">
										<code>从[first,last)中删除元素val，并把其余的元素复制到x开始的区间中，返回被拷贝的最后一个元素的位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">remover_copy_if</font>
								</td>
								<td width="45%">
										<code>OutIt remove_copy_if(InIt first,InIt last,OutIt x,Pred pr);</code>
								</td>
								<td width="45%">
										<code>从[first，last)中删除所有能使函数pr返回true的元素，并把其余元素复制到x开始的空间，返回被拷贝最后一个元素的位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">replace</font>
								</td>
								<td width="45%">
										<code>void replace(FwdIt first,FwdIt last,const T&amp; vold,const T&amp; vnew);</code>
								</td>
								<td width="45%">
										<code>用vnew替换[first,last)中所有值为vold的元素</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">replace_if</font>
								</td>
								<td width="45%">
										<code>void replace_if(FwdIt first,FwdIt last,Pred pr,const T&amp; val);</code>
								</td>
								<td width="45%">
										<code>用val替换[first,last)中所有能使函数pr返回true的元素</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">replace_copy</font>
								</td>
								<td width="45%">
										<code>OutIt replace_copy(InIt first,InIt last,OutIt x,const T&amp; vold,const 
T&amp; vnew);</code>
								</td>
								<td width="45%">
										<code>把[first,last)中的所有元素复制到以x开始的空间中，如果拷贝的元素中存在值为vold的元素，则以vnew替换，返回拷贝到目标容器的最后一个元素的后一个位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">replace_copy_if</font>
								</td>
								<td width="45%">
										<code>OutIt replace_copy_if(InIt first,InIt last,OutIt x,Pred pr,const T&amp; val);</code>
								</td>
								<td width="45%">
										<code>把[first,last)中的所有元素复制到以x开始的空间中，如果拷贝的元素中存在能够使函数pr返回true的元素，则以vnew替换，返回拷贝到目标容器的最后一个元素的后一个位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">swap</font>
								</td>
								<td width="45%">
										<code>void swap(Container &amp;c1,Container &amp;c2);</code>
								</td>
								<td width="45%">
										<code>交换容器c1与c2的元素</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">iter_swap</font>
								</td>
								<td width="45%">
										<code>void iter_swap(FwdIt1 x,FwdIt2 y);</code>
								</td>
								<td width="45%">
										<code>交换迭代器x，y所指元素的值</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">swap_ranges</font>
								</td>
								<td width="45%">
										<code>FwdIt2 swap_ranges(FwdIt1 first,FwdIt1 last,FwdIt2 
x);</code>
								</td>
								<td width="45%">
										<code>用起始于x的连续元素交换区间[first,last)的所有元素，返回第二个区间的最后一个元素的下一个位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">sort</font>
								</td>
								<td width="45%">
										<code>void sort(RanIt first, RanIt last);<br />
void sort(RanIt first, RanIt last, Pred pr);</code>
								</td>
								<td width="45%">
										<code>将区间[first,last)中的元素按升序排序，第二种形式pr用于设定比较函数</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">merge</font>
								</td>
								<td width="45%">
										<code>OutIt merge(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt 
x);<br />
OutIt merge(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x, Pred 
pr);</code>
								</td>
								<td width="45%">
										<code>合并两个有序区间[first1,last1)和[first2,last2)，并将合并后的元素存储到x开始的容器里，第二种形式pr(elem1,elem2)指定比较规则</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">inplace_merge</font>
								</td>
								<td width="45%">
										<code>void inplace_merge(BidIt first, BidIt middle, BidIt last);<br />
		void inplace_merge(BidIt first, BidIt middle, BidIt last, Pred pr);</code>
								</td>
								<td width="45%">
										<code>合并区间[first,middle)和[middle,last),并将合并后的元素存储到first开始的区间，第二种形式pr(elem1,elem2)指定比较规则</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">reverse</font>
								</td>
								<td width="45%">
										<code>void reverse(BidIt first, BidIt last);</code>
								</td>
								<td width="45%">
										<code>将区间[first,last)的元素顺序倒置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">reverse_copy</font>
								</td>
								<td width="45%">
										<code>OutIt reverse_copy(BidIt first, BidIt last,OutIt x);</code>
								</td>
								<td width="45%">
										<code>将区间[first，last)的元素拷贝到x开始的区间，导致拷贝的元素顺序，源区间没有被修改，返回拷贝到目标区间的最后一个元素的下一个位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">rotate</font>
								</td>
								<td width="45%">
										<code>void rotate(FwdIt first,FwdIt middle,FwdIt last);</code>
								</td>
								<td width="45%">
										<code>交换区间[first,middle)和[middle,last)的元素位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">rotate_copy</font>
								</td>
								<td width="45%">
										<code>OutIt rotate_copy(FwdIt first,FwdIt middle,FwdIt last,OutIt 
x);</code>
								</td>
								<td width="45%">
										<code>将区间[first,last)的元素拷贝到x开始的容器中，拷贝时交换[first,middle)和[middle,last)的位置，源区间不发生修改，返回拷贝到目标区间的最后一个元素的下一位</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">random_shuffle</font>
								</td>
								<td width="45%">
										<code>void random_shuffle(RanIt first, RanIt last);<br />
void random_shuffle(RanIt first, RanIt last, Fun&amp; f);</code>
								</td>
								<td width="45%">
										<code>对区间[first,last)上的元素进行随机排序，f用于指定排序函数</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">transform</font>
								</td>
								<td width="45%">
										<code>OutIt transform(InIt first,InIt last,OutIt x, Unop uop);</code>
								</td>
								<td width="45%">
										<code>对区间[first,last)上的所有元素执行uop(elem)操作，结果放到以x开始的区间内，返回拷贝到目标端的最后一个元素的下一位</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">transform</font>
								</td>
								<td width="45%">
										<code>OutIt transform(InIt1 first1,InIt1 last1,InIt2 first2,OutIt x, Binop 
bop);</code>
								</td>
								<td width="45%">
										<code>对区间[first1,last1)和以first2开始的区间的元素执行二元运算bop(elem1,elem2)，结果放到以x开始的区间内，返回拷贝到目标端的最后一个元素的下一位</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">set_itersection</font>
								</td>
								<td width="45%">
										<code>OutIt set_intersection(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 
last2,OutIt x);<br />
OutIt set_intersection(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x, Pred pr);</code>
								</td>
								<td width="45%">
										<code>求两个区间[first1,last1),[first2,last2)的交集，存储到x开始的容器里，源区间元素没有被修改，pr用于指定操作函数，返回拷贝到目标区间的最后一个元素的下一个位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">set_union</font>
								</td>
								<td width="45%">
										<code>OutIt set_union(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x);<br />
OutIt set_union(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x, 
Pred pr);</code>
								</td>
								<td width="45%">
										<code>求两个区间[first1,last1),[first2,last2)的并集，存储到x开始的容器里，源区间元素没有修改，pr用于指定操作函数，返回拷贝到目标区间的最后一个元素的下一位</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">set_difference</font>
								</td>
								<td width="45%">
										<code>OutIt set_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 
last2,OutIt x);<br />
OutIt set_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt 
x, Pred pr);</code>
								</td>
								<td width="45%">
										<code>求两个集合[first1,last1),[first2,last2)的差集，存储到x开始的容器里，源区间元素没有被修改，pr用于指定操作函数，返回拷贝到目标区间的最后一个元素的下一个位置</code>
								</td>
						</tr>
						<tr>
								<td width="10%">
										<font size="2">set_symmetric_</font>
										<p>
												<font size="2">
		difference</font>
										</p>
								</td>
								<td width="45%">
										<code>OutIt set_symmetric_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x);<br />
OutIt set_symmetric_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 
last2,OutIt x, Pred pr);</code>
								</td>
								<td width="45%">
										<code>求集合[first1,last1),[first2,last2)的对称差（即（A-B）+（B-A）），存储到x开始的容器里，源区间元素没有被修改，pr用于指定操作函数，返回拷贝到目标区间最后一个元素的下一个位置</code>
								</td>
						</tr>
				</tbody>
		</table>
<img src ="http://www.cppblog.com/lmlf001/aggbug/6025.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/lmlf001/" target="_blank">芥之舟</a> 2006-04-21 15:00 <a href="http://www.cppblog.com/lmlf001/archive/2006/04/21/6025.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>STL非修改算法</title><link>http://www.cppblog.com/lmlf001/archive/2006/04/20/5986.html</link><dc:creator>芥之舟</dc:creator><author>芥之舟</author><pubDate>Thu, 20 Apr 2006 15:24:00 GMT</pubDate><guid>http://www.cppblog.com/lmlf001/archive/2006/04/20/5986.html</guid><wfw:comment>http://www.cppblog.com/lmlf001/comments/5986.html</wfw:comment><comments>http://www.cppblog.com/lmlf001/archive/2006/04/20/5986.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/lmlf001/comments/commentRss/5986.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/lmlf001/services/trackbacks/5986.html</trackback:ping><description><![CDATA[
		<p>
				<code>由于STL算法都是通过迭代器间接处理容器，下面定义istream_iteratorInIt,ostream_itreatorOutIt,forward_iteratorFwdIt,bidirectional_iterator BidIt,random_iterator RanIt</code>
		</p>
		<p>非修改算法：</p>
		<table id="table1" border="1" width="100%">
				<tbody>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">算法</font>
								</td>
								<td width="45%">用法</td>
								<td width="384">说明</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<code>
												<font face="宋体" size="2">adjacent_find</font>
										</code>
								</td>
								<td width="45%">
										<code>FwdIt adjacent_find(FwdIt first,FwdIt last);<br />
FwdIt adjacent_find(FwdIt first,FwdIt last,Pred pr);</code>
								</td>
								<td width="384">
										<code>在[first,last)查找相同元素的首次出现或能使pr（elem,nextElem）为true的元素的位置
		，函数查找成功返回位置，失败返回last</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<code>
												<font face="宋体" size="2">binary_search</font>
										</code>
								</td>
								<td width="45%">
										<code>bool binary_search(FwdIt first,FwdIt last,const T&amp; val);<br />
bool binary_search(FwdIt first,FwdIt last,const T&amp; val,Pred pr);</code>
								</td>
								<td width="384">
										<code>在区间[first,last)中查找元素val，如果找到返回true，否则返回false，第二种形式pr用于设定查找准则</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">count</font>
								</td>
								<td width="45%">
										<code>size_t count(InIt first,InIt last,const T&amp; val);</code>
								</td>
								<td width="384">
										<code>返回区间[first,last)上val出现的次数</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">count_if</font>
								</td>
								<td width="45%">
										<code>size_t count_if(InIt first,InIt last,Pred pr);</code>
								</td>
								<td width="384">
										<code>返回区间[first,last)上满足条件pr(elem）的元素个数</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">equal</font>
								</td>
								<td width="45%">
										<code>bool equal(InIt1 first,InIt1 last,InIt2 x);<br />
		bool equal(InIt1 first,InIt1 last,InIt2 x,Pred pr);</code>
								</td>
								<td width="384">
										<code>判断[first,last)与x开始的区间的元素是否相等，pr用于指定判断函数</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">equal</font>
								</td>
								<td width="45%">
										<code>pair&lt;FwdIt,FwdIt&gt; equal_range(FwdIt first,FwdIt 
		last,const T&amp; val);<br />
		pair&lt;FwdIt,FwdIt&gt; equal_range(FwdIt first,FwdIt last,const T&amp; val,Pred 
		pr);</code>
								</td>
								<td width="384">
										<code>返回元素val第一次出现的位置和最后出现的位置的下一位组成的对，pr指定比较算法</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">lower_bound</font>
								</td>
								<td width="45%">
										<code>FwdIt lower_bound(FwdIt first,FwdIt last,const T&amp; 
		val);<br />
		FwdIt lower_bound(FwdIt first,FwdIt last,const T&amp; val,Pred pr);</code>
								</td>
								<td width="384">
										<code>返回已排序序列[first,last)中val首次出现的位置，pr指定比较算法</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">upper_bound</font>
								</td>
								<td width="45%">
										<code>FwdIt upper_bound(FwdIt first,FwdIt last,const T&amp; 
		val);<br />
		FwdIt upper_bound(FwdIt first,FwdIt last,const T&amp; val,Pred pr);</code>
								</td>
								<td width="384">
										<code>返回已排序序列[first,last)中val最后一次出现的下一个位置，pr指定比较算法</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">find</font>
								</td>
								<td width="45%">
										<code>InIt find(InIt first,InIt last,const T&amp; val);</code>
								</td>
								<td width="384">
										<code>在[first,last)之间查找元素val，如果找到返回位置，找不到返回last</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">find_if</font>
								</td>
								<td width="45%">
										<code>InIt find_if(InIt first,InIt last, Pred pr);</code>
								</td>
								<td width="384">
										<code>在[first,last)之间查找能使函数pr返回true的元素，找到返回位置，否则返回last</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">find_end</font>
								</td>
								<td width="45%">
										<code>FwdIt1 find_end(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 
last2);<br />
FwdIt1 find_end(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2, Pred 
pr);</code>
								</td>
								<td width="384">
										<code>
		在[first1，last1)之间查找[first2，last2)最后出现的位置，如果找到返回位置，失败返回last1，第二个函数的pr函数用于比较两个容器的元素，在两个容器的元素相等时返回true</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">find_first_of</font>
								</td>
								<td width="45%">
										<code>FwdIt1 find_first_of(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 
last2);<br />
FwdIt1 find_first_of(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2, Pred pr);</code>
								</td>
								<td width="384">
										<code>
		在[first1，last1)之间查找第一次出现[first2，last2)中元素的位置，找到返回位置，失败返回last1，第二个函数pr用于比较两个容器的元素是否相等</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">for_each</font>
								</td>
								<td width="45%">
										<code>Fun for_each(InIt first,InIt last, Fun f);</code>
								</td>
								<td width="384">
										<code>对[first,last)上的所有元素执行函数f(elem),返回值常被忽略</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">includes</font>
								</td>
								<td width="45%">
										<code>bool includes(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2);<br />
bool includes(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2, Pred pr);</code>
								</td>
								<td width="384">
										<code>
		判断已排序序列[first1,last1)中是否包含区间已排序区间[first2,last2)，pr指定元素的顺序</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">mismatch</font>
								</td>
								<td width="45%">
										<code>pair&lt;InIt1,InIt2&gt; mismatch(InIt1 first,InIt1 
		last,InIt2 x);<br />
		pair&lt;InIt1,InIt2&gt; mismatch(InIt1 first,InIt1 last,InIt2 x, Pred pr);</code>
								</td>
								<td width="384">
										<code>返回序列[first,last)与x开始的序列第一个不匹配的位置的两个迭代器组成的对</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">max</font>
								</td>
								<td width="45%">
										<code>const T&amp; max(const T&amp; x,const T&amp; y);<br />
const T&amp; max(const T&amp; x,const T&amp; y, Pred pr);</code>
								</td>
								<td width="384">
										<code>返回x，y之间的较大者，pr(elem1,elem2)用于指定比较规则</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">max_element</font>
								</td>
								<td width="45%">
										<code>FwdIt max_element(FwdIt first,FwdIt last);<br />
FwdIt max_element(FwdIt first,FwdIt last, Pred pr);</code>
								</td>
								<td width="384">
										<code>返回区间[first,last)上最大值的位置，pr(elem1,elem2)用于指定比较规则</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">min</font>
								</td>
								<td width="45%">
										<code>const T&amp; min(const T&amp; x,const T&amp; y);<br />
const T&amp; min(const T&amp; x,const T&amp; y, Pred pr);</code>
								</td>
								<td width="384">
										<code>返回x，y之间的较小者，pr(elem1,elem2)用于指定比较规则</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">min_element</font>
								</td>
								<td width="45%">
										<code>FwdIt min_element(FwdIt first,FwdIt last);<br />
FwdIt min_element(FwdIt first,FwdIt last, Pred pr);</code>
								</td>
								<td width="384">
										<code>返回区间[first,last)上的最小值的位置，pr(elem1,elem2)用于指定比较规则</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">search</font>
								</td>
								<td width="45%">
										<code>FwdIt1 search(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2);<br />
FwdIt1 search(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2, Pred pr);</code>
								</td>
								<td width="384">
										<code>
		在[first1，last1)中查找子区间[first2,last2),如果找到返回在第一个区间中的位置，失败返回last1，第二种形式pr函数用于设定比较函数</code>
								</td>
						</tr>
						<tr>
								<td align="left" width="10">
										<font face="宋体" size="2">search_n</font>
								</td>
								<td width="45%">
										<code>FwdIt search_n(FwdIt first,FwdIt last,Dist n,const T&amp; val);<br />
FwdIt search_n(FwdIt first,FwdIt last,Dist n,const T&amp; val, Pred pr);</code>
								</td>
								<td width="384">
										<code>在[first,last)中查找连续n个val，如果找到返回在区间中的位置，失败返回last，第二种形式pr用于设定比较函数</code>
								</td>
						</tr>
				</tbody>
		</table>
<img src ="http://www.cppblog.com/lmlf001/aggbug/5986.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/lmlf001/" target="_blank">芥之舟</a> 2006-04-20 23:24 <a href="http://www.cppblog.com/lmlf001/archive/2006/04/20/5986.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>STL迭代器简介</title><link>http://www.cppblog.com/lmlf001/archive/2006/04/20/5971.html</link><dc:creator>芥之舟</dc:creator><author>芥之舟</author><pubDate>Thu, 20 Apr 2006 10:32:00 GMT</pubDate><guid>http://www.cppblog.com/lmlf001/archive/2006/04/20/5971.html</guid><wfw:comment>http://www.cppblog.com/lmlf001/comments/5971.html</wfw:comment><comments>http://www.cppblog.com/lmlf001/archive/2006/04/20/5971.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/lmlf001/comments/commentRss/5971.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/lmlf001/services/trackbacks/5971.html</trackback:ping><description><![CDATA[
		<p>标准模板库(The Standard Template Library, STL)定义了五种迭代器。下面的图表画出了这几种：</p>
		<p align="left">            
input         output<br />
              \            /<br />
                 forward<br />
                     |<br />
                bidirectional<br />
                     |<br />
               random access</p>
		<table id="table1" align="right" border="0" cellpadding="0" cellspacing="0" width="0">
				<tbody>
						<tr>
								<td align="center"> </td>
						</tr>
						<tr>
								<td>
										<br />
								</td>
						</tr>
				</tbody>
		</table>
		<p>
要注意，上面这图表并不是表明它们之间的继承关系：而只是描述了迭代器的种类和接口。处于图表下层的迭代器都是相对于处于图表上层迭代器的扩张集。例如：forward迭代器不但拥有input和output迭代器的所有功能，还拥有更多的功能。</p>
		<p>各个迭代器的功能如下：</p>
		<table id="table2" border="1" width="100%">
				<tbody>
						<tr>
								<td>迭代器类别</td>
								<td width="558">说明</td>
						</tr>
						<tr>
								<td>输入</td>
								<td width="558">
		从容器中读取元素。输入迭代器只能一次读入一个元素向前移动，输入迭代器只支持一遍算法，同一个输入迭代器不能两遍遍历一个序列</td>
						</tr>
						<tr>
								<td>输出</td>
								<td width="558">
		向容器中写入元素。输出迭代器只能一次一个元素向前移动。输出迭代器只支持一遍算法，统一输出迭代器不能两次遍历一个序列</td>
						</tr>
						<tr>
								<td>正向</td>
								<td width="558">组合输入迭代器和输出迭代器的功能，并保留在容器中的位置</td>
						</tr>
						<tr>
								<td>双向</td>
								<td width="558">组合正向迭代器和逆向迭代器的功能，支持多遍算法</td>
						</tr>
						<tr>
								<td>随机访问</td>
								<td width="558">组合双向迭代器的功能与直接访问容器中任何元素的功能，即可向前向后跳过任意个元素</td>
						</tr>
				</tbody>
		</table>
		<p>迭代器的操作：</p>
		<p>每种迭代器均可进行包括表中前一种迭代器可进行的操作。</p>
		<table id="table4" border="1" width="100%">
				<tbody>
						<tr>
								<td>迭代器操作</td>
								<td>说明</td>
						</tr>
						<tr>
								<td colspan="2">所有迭代器</td>
						</tr>
						<tr>
								<td>p++</td>
								<td>后置自增迭代器</td>
						</tr>
						<tr>
								<td>++p</td>
								<td>前置自增迭代器</td>
						</tr>
						<tr>
								<td colspan="2">输入迭代器</td>
						</tr>
						<tr>
								<td>*p</td>
								<td>复引用迭代器，作为右值</td>
						</tr>
						<tr>
								<td>p=p1</td>
								<td>将一个迭代器赋给另一个迭代器</td>
						</tr>
						<tr>
								<td>p==p1</td>
								<td>比较迭代器的相等性</td>
						</tr>
						<tr>
								<td>p!=p1</td>
								<td>比较迭代器的不等性</td>
						</tr>
						<tr>
								<td colspan="2">输出迭代器</td>
						</tr>
						<tr>
								<td>*p</td>
								<td>复引用迭代器，作为左值</td>
						</tr>
						<tr>
								<td>p=p1</td>
								<td>将一个迭代器赋给另一个迭代器</td>
						</tr>
						<tr>
								<td>正向迭代器</td>
								<td>提供输入输出迭代器的所有功能</td>
						</tr>
						<tr>
								<td colspan="2">双向迭代器</td>
						</tr>
						<tr>
								<td>--p</td>
								<td>前置自减迭代器</td>
						</tr>
						<tr>
								<td>p--</td>
								<td>后置自减迭代器</td>
						</tr>
						<tr>
								<td colspan="2">随机迭代器</td>
						</tr>
						<tr>
								<td>p+=i</td>
								<td>将迭代器递增i位</td>
						</tr>
						<tr>
								<td>p-=i</td>
								<td>将迭代器递减i位</td>
						</tr>
						<tr>
								<td>p+i</td>
								<td>在p位加i位后的迭代器</td>
						</tr>
						<tr>
								<td>p-i</td>
								<td>在p位减i位后的迭代器</td>
						</tr>
						<tr>
								<td>p[i]</td>
								<td>返回p位元素偏离i位的元素引用</td>
						</tr>
						<tr>
								<td>p&lt;p1</td>
								<td>如果迭代器p的位置在p1前，返回true，否则返回false</td>
						</tr>
						<tr>
								<td>p&lt;=p1</td>
								<td>p的位置在p1的前面或同一位置时返回true，否则返回false</td>
						</tr>
						<tr>
								<td>p&gt;p1</td>
								<td>如果迭代器p的位置在p1后，返回true，否则返回false</td>
						</tr>
						<tr>
								<td>p&gt;=p1</td>
								<td>p的位置在p1的后面或同一位置时返回true，否则返回false</td>
						</tr>
				</tbody>
		</table>
		<p>只有顺序容器和关联容器支持迭代器遍历，各容器支持的迭代器的类别如下：</p>
		<table id="table3" border="1" width="100%">
				<tbody>
						<tr>
								<td>容器</td>
								<td>支持的迭代器类别</td>
						</tr>
						<tr>
								<td>vector</td>
								<td>随机访问</td>
						</tr>
						<tr>
								<td>deque</td>
								<td>随机访问</td>
						</tr>
						<tr>
								<td>list</td>
								<td>双向</td>
						</tr>
						<tr>
								<td>set</td>
								<td>双向</td>
						</tr>
						<tr>
								<td>multiset</td>
								<td>双向</td>
						</tr>
						<tr>
								<td>map</td>
								<td>双向</td>
						</tr>
						<tr>
								<td>multimap</td>
								<td>双向</td>
						</tr>
						<tr>
								<td>stack</td>
								<td>不支持</td>
						</tr>
						<tr>
								<td>queue</td>
								<td>不支持</td>
						</tr>
						<tr>
								<td>priority_queue</td>
								<td>不支持</td>
						</tr>
				</tbody>
		</table>
<img src ="http://www.cppblog.com/lmlf001/aggbug/5971.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/lmlf001/" target="_blank">芥之舟</a> 2006-04-20 18:32 <a href="http://www.cppblog.com/lmlf001/archive/2006/04/20/5971.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>STL标准容器类简介</title><link>http://www.cppblog.com/lmlf001/archive/2006/04/20/5967.html</link><dc:creator>芥之舟</dc:creator><author>芥之舟</author><pubDate>Thu, 20 Apr 2006 09:49:00 GMT</pubDate><guid>http://www.cppblog.com/lmlf001/archive/2006/04/20/5967.html</guid><wfw:comment>http://www.cppblog.com/lmlf001/comments/5967.html</wfw:comment><comments>http://www.cppblog.com/lmlf001/archive/2006/04/20/5967.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/lmlf001/comments/commentRss/5967.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/lmlf001/services/trackbacks/5967.html</trackback:ping><description><![CDATA[
		<table id="table1" border="1" width="100%">
				<tbody>
						<tr>
								<td>标准容器类</td>
								<td>说明</td>
						</tr>
						<tr>
								<td colspan="2">顺序性容器</td>
						</tr>
						<tr>
								<td>vector</td>
								<td>从后面快速的插入与删除，直接访问任何元素</td>
						</tr>
						<tr>
								<td>deque</td>
								<td>从前面或后面快速的插入与删除，直接访问任何元素</td>
						</tr>
						<tr>
								<td>list</td>
								<td>双链表，从任何地方快速插入与删除</td>
						</tr>
						<tr>
								<td colspan="2">关联容器</td>
						</tr>
						<tr>
								<td>set</td>
								<td>快速查找，不允许重复值</td>
						</tr>
						<tr>
								<td>multiset</td>
								<td>快速查找，允许重复值</td>
						</tr>
						<tr>
								<td>map</td>
								<td>一对多映射，基于关键字快速查找，不允许重复值</td>
						</tr>
						<tr>
								<td>multimap</td>
								<td>一对多映射，基于关键字快速查找，允许重复值</td>
						</tr>
						<tr>
								<td colspan="2">容器适配器</td>
						</tr>
						<tr>
								<td>stack</td>
								<td>后进先出</td>
						</tr>
						<tr>
								<td>queue</td>
								<td>先进先出</td>
						</tr>
						<tr>
								<td>priority_queue</td>
								<td>最高优先级元素总是第一个出列</td>
						</tr>
				</tbody>
		</table>
		<p>所有标准库共有函数</p>
		<table id="table2" border="1" width="100%">
				<tbody>
						<tr>
								<td>默认构造函数</td>
								<td width="75%">提供容器默认初始化的构造函数。</td>
						</tr>
						<tr>
								<td>复制构造函数</td>
								<td width="75%">将容器初始化为现有同类容器副本的构造函数</td>
						</tr>
						<tr>
								<td>析构函数</td>
								<td width="75%">不再需要容器时进行内存整理的析构函数</td>
						</tr>
						<tr>
								<td>empty</td>
								<td width="75%">容器中没有元素时返回true,否则返回false</td>
						</tr>
						<tr>
								<td>max_size</td>
								<td width="75%">返回容器中最大元素个数</td>
						</tr>
						<tr>
								<td>size</td>
								<td width="75%">返回容器中当前元素个数</td>
						</tr>
						<tr>
								<td>operator=</td>
								<td width="75%">将一个容器赋给另一个容器</td>
						</tr>
						<tr>
								<td width="11%">operator&lt;</td>
								<td width="75%">如果第一个容器小于第二个容器，返回true，否则返回false，</td>
						</tr>
						<tr>
								<td width="11%">operator&lt;=</td>
								<td width="75%">如果第一个容器小于或等于第二个容器，返回true，否则返回false</td>
						</tr>
						<tr>
								<td width="11%">operator&gt;</td>
								<td width="75%">如果第一个容器大于第二个容器，返回true，否则返回false</td>
						</tr>
						<tr>
								<td width="11%">operator&gt;=</td>
								<td width="75%">如果第一个容器大于或等于第二个容器，返回true，否则返回false</td>
						</tr>
						<tr>
								<td width="11%">operator==</td>
								<td width="75%">如果第一个容器等于第二个容器，返回true，否则返回false</td>
						</tr>
						<tr>
								<td width="11%">operator!=</td>
								<td width="75%">如果第一个容器不等于第二个容器，返回true，否则返回false</td>
						</tr>
						<tr>
								<td width="21%">swap</td>
								<td width="75%">交换两个容器的元素</td>
						</tr>
				</tbody>
		</table>
		<p>其中operator&gt;,operator&gt;=,operator&lt;,operator&lt;=,operator==,operator!=均不适用于priority_queue</p>
		<p>顺序容器和关联容器共有函数</p>
		<table id="table3" border="1" width="100%">
				<tbody>
						<tr>
								<td>begin</td>
								<td>该函数两个版本返回iterator或const_iterator，引用容器第一个元素</td>
						</tr>
						<tr>
								<td>end</td>
								<td>该函数两个版本返回iterator或const_iterator,引用容器最后一个元素后面一位</td>
						</tr>
						<tr>
								<td>rbegin</td>
								<td>该函数两个版本返回reverse_iterator或const_reverse_iterator,引用容器最后一个元素</td>
						</tr>
						<tr>
								<td>rend</td>
								<td>该函数两个版本返回reverse_iterator或const_reverse_iterator，引用容器第一个元素前面一位</td>
						</tr>
						<tr>
								<td>erase</td>
								<td>从容器中清除一个或几个元素</td>
						</tr>
						<tr>
								<td>clear</td>
								<td>清除容器中所有元素</td>
						</tr>
				</tbody>
		</table>
		<p>下表显示了顺序容器和关联容器中常用的typedef，这些typedef常用于变量、参数和函数返回值的一般性声明。</p>
		<table id="table4" border="1" width="100%">
				<tbody>
						<tr>
								<td>value_type</td>
								<td>容器中存放元素的类型</td>
						</tr>
						<tr>
								<td>reference</td>
								<td>容器中存放元素类型的引用</td>
						</tr>
						<tr>
								<td>const_reference</td>
								<td>容器中存放元素类型的常量引用，这种引用只能读取容器中的元素和进行const操作</td>
						</tr>
						<tr>
								<td>pointer</td>
								<td>容器中存放元素类型的指针</td>
						</tr>
						<tr>
								<td>iterator</td>
								<td>指向容器中存放元素类型的迭代器</td>
						</tr>
						<tr>
								<td>const_iterator</td>
								<td>指向容器中存放元素类型的常量迭代器，只能读取容器中的元素</td>
						</tr>
						<tr>
								<td>reverse_iterator</td>
								<td>指向容器中存放元素类型的逆向迭代器，这种迭代器在容器中逆向迭代</td>
						</tr>
						<tr>
								<td>const_reverse_iterator</td>
								<td>指向容器中存放元素类型的逆向迭代器，只能读取容器中的元素</td>
						</tr>
						<tr>
								<td>difference_type</td>
								<td>引用相同容器的两个迭代器相减结果的类型（list和关联容器没有定义operator-）</td>
						</tr>
						<tr>
								<td>size_type</td>
								<td>用于计算容器中项目数和检索顺序容器的类型（不能对list检索）</td>
						</tr>
				</tbody>
		</table>
		<p> </p>
<img src ="http://www.cppblog.com/lmlf001/aggbug/5967.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/lmlf001/" target="_blank">芥之舟</a> 2006-04-20 17:49 <a href="http://www.cppblog.com/lmlf001/archive/2006/04/20/5967.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>