Standard Template Library(STL)主要由两种组件构成:一是容器(container),,包括vector、list、set、map等类;另一种组件是用以操作这些容器的所谓泛型算法(generic algorithm),包括find(),sort(),replace(),merge()等。
vector和list这两个容器是所谓的顺序性容器(sequential container)。顺序性容器会一次维护第一个、第二个...直到最后一个元素。我们在顺序性容器身上主要进行迭代操作(iterate)。map和set这两个容器属于关联容器。关联容器可以让我们快速查找容器中的元素值。
泛型算法提供了许多可作用于容器类及数组类型上的操作。这些算法之所以被称为泛型(generic),是因为它们和它们想要操作的元素类型无关。
泛型算法系通过function template技术,达到“与操作对象的类型相互独立”的目的。而实现“与容器无关”的诀窍,就是不要直接在容器身上进行操作。而是借由一对iterator(first和last),标示我们要进行迭代的元素范围。如果first等于last,算法只作用域first所指元素。如果first不等于last,算法便会首先作用于first所指元素身上,并将first递增,指向下一个元素,然后在比较first与last是否相等,如此持续进行,知道first等于last为止。
3.1 指针的算数运算
假设我们要查找vector中是否存在一个整形数值。
int* find(const vector<int>& vec, int value)
{
for (int ix = 0; ix < vec.size(); ++ix)
if (vec[ix] == value)
return &vec[ix];
return 0;
}
接下来我们又获得一个新任务:想办法让这个函数可以处理任何类型数据,而不仅限于整形。前提是该类型定义的equality运算符。
template <typename elemType>
elemType* find(const vector<elemType>& vec, elemType value)
{
for (int ix = 0; ix < vec.size(); ++ix)
if (vec[ix] == value)
return &vec[ix];
return 0;
}
下一个任务,便是让这个函数同时可以处理vector和array内的任意元素类型。首先引入脑海的想法便是将此函数重载(overload),一份用来处理vector,一份用来处理array。但是不建议使用重载方式解决。
有一种存在已久的难题对策,就是将问题分割为数个较小、相对而言较简单的子问题。本例中我们的大问题可切割为:(1) 将array的元素传入find,而非指明该array,(2)将vector的元素传入find(),而不指明该vector。
我们想起当数组传给函数,或是由函数中返回,仅有第一个元素地址会被传递。指向array开头的指针找到了,使得我们得以开始对array进行读取操作,但在何处应该停止对array的读取呢?解法之一是:增加一个参数,用来表示array的大小。解法之二:传入另一个地址,指示array读取操作的终点。
第一种方法代码如下:
template <typename elemType>
elemType* find(const elemType* array, const int size, const elemType& value)
{
if (!array || size < 1)
return 0;
for (int ix = 0; ix < size; ++ix)
if (array[ix] == value)
return &array[ix];
return 0;
}
事实上所谓的下标操作就是将array的起始地址加上索引值,产生出某个元素的地址,然后该地址再被解应用以返回值。
array[2] 相当于*(array + 2)。
在指针的算术运算中,会把“指针所指的类型”的大小考虑进去。
第二种方法实现的find()代码如下:
template <typename elemType>
elemType* find(const elemType* first, const elemType last, const elemType& value)
{
if (!first || !last)
return 0;
for (; first != last; ++first)
if (*first == value)
return first;
return 0;
}
传入的第二个地址,标示出数组最后一个元素的下一个地址。这合法嘛? 是的,不过倘若我们企图对此地址进行读取或写入,那就不合法。如果仅仅是将该地址和其他元素的地址进行比较,那就完全不会有任何问题。
如何完成第二个子任务呢?该任务表明,不论vector内的元素类型是什么,都能一一访问vector内的每个元素。切记,vector可以为空,array则不然。那么,如果对空vector取第一个元素位置,则会报错。
比较保险的方法是对vector确定不为空。增加一个判断,
if (!vec.empty())
虽然这样比较安全,但对用户来说过于累赘了。于是我们将“取用第一个元素的地址”的操作包装成函数,像下面:
template <typename elemType>
inline
elemType* begin(const vector<elemType>& vec)
{
return vec.empty()? 0 : &vec[0];
}
find(begin(vec), last(vec), value);
到目前位置,find()函数已经应用于vector和array上了。
但如何继续扩展find()函数,让其也能支持其他容器,比如list?
list也是一个容器。不同的是,list的元素以一组指针相互连接,前向指针指向下一个元素,后向指针指向上一个元素。
因此,指针的算术运算并不适用于list,因为指针的算术运算必须首先假设所有元素都存储在连续空间里,然后才能根据当前指针,加上元素大小之后,指向下一个元素。这一假设对于list容器并不成立。
解决方法是,在底层指针行为上提供一层抽象,取代程序原本的“指针直接操作”方式。我们把底层指针的处理通通放在此抽象层中,让用户无需直接面对指针操作。
3.2 了解Iterator(泛型指针)
我们要设计一组iterator class,让我们得以使用“和指针相同的语法”来继续程序编写。
while (first != last)
{
cout << *first << ' ';
++first;
}
这好像把first和last当作指针一样。唯一差别在于解引用运算符、不等运算符、递增运算符乃是由iterator class内相关的inline函数提供。对于list iterator而言,其递增函数会沿着list的指针前进到下一个元素,对于vector iterator而言,其递增函数前进至下一个元素的方式,是将目前的地址加上一个元素的大小。
如何取得iterator勒? 每个标准容器都提供一个名为begin()的操作函数,可返回一个iterator,指向第一个元素。另一个end()函数会返回一个iterator,指向最后一个元素的下一个位置。
在我们定义iterator之前,让我们思考一下,那些信息是由这份定义应该提供的:(1)迭代对象(某个容器)的类型,这可用来决定如何访问下一个元素;(2)迭代器所指的元素类型,这决定iterator解应用的返回值。
iterator的一个可能的定义形式是,便是将上述两个类型作为参数,传给iterator class:
iterator <vector, string> iter;
以下便是display()函数重新实现后的面容。其中以iterator取代了原来的下标运算符。
template <typename elemType>
void display(const vector<elemType>& vec, ostream& os)
{
vector<elemType>::const_iterator iter = vec.begin();
vector<elemType>::const_iterator end_it = vec.end();
// 如果vec是空,iter便等于end_it
// 于是for循环不会被执行
for (; iter != end_it; iter++)
os << *iter << ' ';
os << end;
}
现在我们用iterator类来重新实现find()函数。
template <typename IteratorType, typename elemType>
IteratorType
find(IteratorType first, IteratorType last, const elemType& val)
{
for (; first != last; ++first)
if (value == *first)
return first;
return last;
}
目前find()函数已经有了更大的通用性,但故事尚未结束。find()的实现使用了底部元素所属类型的equality运算符。如果底层元素所属类型并未提供这个运算符,或希望用户赋予equality运算符不同的意义,这个find()函数还需加强。
解法之一便是传入一个函数指针,取代原来固定的equality运算符。第二种便是使用function object。
3.3 所有容器的共通操作
下列为所有容器类(包含string类)的共同操作:
equality和inequality运算符,返回true或false。
assignment运算符,将某个容器复制给另一个容器。
empty()会在容器无任何元素时返回true,否则返回flase。
size()返回容器内目前持有的元素类型。
clear()删除所有元素。
每个容器都提供了begin()和end()两个函数,分别返回指向容器的第一个元素和最后一个元素的下一个位置的iterator。
通常,我们在容器身上进行的迭代操作都是始于begin()而终于end()。所有容器都提供insert()用以插入单一或某个范围元素,以及erase()用以删除单一或某一范围元素。
insert()和erase()的行为试容器本身为顺序性或关联容器而有所不同。
3.4 使用顺序性容器
vector和list是两个最主要的顺序性容器。vector以一块连续内存来存放元素。对vector进行随机访问(random access)颇有效率。vector内每个元素都存储在距离起始点的固定偏移位置上。如果将元素插入任意位置,而此位置不是vector的末端,那么效率将很低,因此插入位置的右端的每个元素,都必须被复制一份,依次向后移动。同样道理,删除vector内最后一个元素以外的任意元素,同样缺乏效率。
list系以双向连接(double-linked)而非连续内存来存储内容,因此可以执行前进或后退操作。list中的每个元素都包含三个字段:value,back指针(指向前一个元素),front指针(指向后一个元素)。在list的任意位置进行元素的插入和删除操作,都颇具效率。因为list本身只需要适当设定back指针和front指针即可。但是如果要对list进行随机访问,则效率不彰。
vector比较适合数列。因为我们会有很多随机访问的机会。
如果我们需要增删操作较多时,适合使用list。
第三种顺序容器时deque。deque的行为和vector颇为相似--都以连续内存储存元素。和vector不同的是,deque对于最前端元素的插入和删除操作,效率更高;末端元素亦同。如果我们需要在容器最前端插入元素,并执行末端删除操作,那么deque便很理想。
要使用顺序性容器,首先必须包含相关的头文件。
#include <vector>
#include <list>
#include <deque>
定义顺序性容器对象的方式有五种。
// 1 产生空的容器
list<string> slist;
vector<int> ivec;
// 2 产生特定大小的容器。每个元素都以其默认值作为初值
list<int> ilist(1024);
vector<string> svec(32);
// 3 产生特定大小的容器,并为每个元素指定初值
vector<int> ivect(10, -1);
list<string> slist(16, "unassigned");
// 4 通过一对iterator产生容器。这对iterator用来标示一整组作为初值的元素的范围
int ia[8] = {1, 2, 2, 34, 5, 5, 3, 1};
vector<int> fib(ia, ia + 8);
// 5 根据某个容器产生新的容器。复制原容器内的元素,作为新容器的初值
list<string> slist;
//填充slist
...
list<string> slist2(slist);
有两个特别的操作函数,允许我们在容器末尾进行插入和删除操作:push_back()和pop_back()。
list和deque还包括push_front()和pop_front()。
如果要读取最前端元素的值,应该采用front()。如果要读取末端元素的值,应该采用back()。
push_back()和push_front()都属于特殊化的插入操作。每个insert()还支持四种变体。
1. 指定位置插
2. 指定位置插入n个相同值
3. 指定位置之前插入另外一段范围的值
4. 插入默认值
3.5 使用泛型算法
想使用泛型算法,首先包含对应的头文件:
#include <algorithm>
1. find()用于搜索无序集合中是否存在某值。
2. binary_search()用于有序集合的搜索。
3. count()返回数值相符的元素数目。
4. search()对比某个容器内是否存在某个子序列。
3.6 如何设计一个泛型算法
一个新任务是,用户给予一个整数vector,我们必须返回一个新的vector,其中内含原vector之中小于10的所有数值。一个快速但缺乏弹性的解法是:
vector<int> less_than_10(const vector<int>& vect)
{
vector<int> nvec;
for (int ix = 0; ix < vec.size(); ++ix)
if (vec[ix] < 10)
nvec.push(vec[ix]);
return nvec;
}
如果用户想找到小于11的元素,那么需要将这个函数改造一下,让用户只当某个上限值。如下;
vector<int> less_than_10(const vector<int>& vect, int less_than_val);
下一个任务是允许用户指定不同的比操作,像是大于、小于,等等。如何才能将“比较操作”参数化呢?
有一个解法,以函数调用来替代less-than运算符。需要加入第三个参数,用它来指定一个函数指针,其参数列表中有两个整数,返回值为bool。至此,less_than()名称不合适了,让我们改名为filter()吧。
vector<int> filter(const vector<int>& vect, int less_than_val, bool (*pred)(int, int));
为方便起见,我们同时定义了许多可以传递给filter()的关系比较函数:
bool less_than(int v1, int v2)
{
return v1 < v2 ? true : false;
}
bool greater_than(int v1, int v2)
{
return v1 > v2 ? true : false;
}
调用filter()时,用户以可传入上述函数,或其他自定义的关系比较函数。唯一一个限制是,必须返回bool,而且参数列表只接受两个参数。
以下则是实现filter()函数:
vector<int> filter_ver1(const vector<int>& vec, int filter_value, bool (*pred)(int, int))
{
vector<int> nvec;
for (int ix = 0; ix < vec.size(); ++ix)
if (pred(vec[ix], filter_value))
nvec.push_back(vec[ix]);
return nvec;
}
function object
标准库预先定义好的许多function object。所谓function object,是某种class的实例对象,这类class对function call运算符做了重载操作,如此一来可使function object被当作一般函数来使用。
欲使用function object,得先包含头文件。
#inclulde <functional>
function object实现了我们原本可以以独立函数加以定义的事物。但又何必如此呢? 主要是为了效率。我们可以令call运算符成为inlilne,从而消除“通过函数指针调用函数”时需要付出的额外代价。
标准库事先定义了一组function object,分为算术运算(arithmetic)、关系运算(relational)和逻辑运算(logic)三大类。
6个算术运算:plus<type>, minus<type>, negate<type>, multiplies<type>, divides<type>, modules<type>。
6个关系运算:less<type>, less_equal<type>, greater<type>, greater_equal<type>, equal_to<type>, not_equal_to<type>。
3个逻辑运算,logic_and<type>, logic_or<type>, logic_not<type>。
function object adapter
上述的function object并不那么恰好符合find_if()的要求,举个例子,function object less<type>期望外界传入两个值,如果第一个值小于第二个值,就返回true。在find_if()中,每个元素都必须和用户指定的数值进行比较。理想情况下,我们需要将less<type>转化为一元运算符。这可以通过”将其第二个参数绑定(bind)至用户指定的值“完成。标准库提供标准的adapter便因此而生。
function object adapter会对function object进行修改操作。所谓bind adapter(绑定适配器)会将function object的参数绑定至特定值,使二元function object转化为一元function object。
vector<int> filter(const vector<int>& vec, int filter_value, less<int>& lt)
{
vector<int> nvec;
vector<int>::const_iterator iter = vec.begin();
// bind2nd(less<int>, val);
// 会把val绑定与less<int>的第二个参数上
// 于是,less<int>会将每个元素拿来和val比较
while ((iter = find_if(iter, vec.end(), bind2nd(lt, val))) != vec.end())
{
nvec.push_back(*iter);
iter++;
}
return nvec;
}
接下来消除filter()与vector元素类型依赖性。将filter()改为function template,并将元素类型加入template声明中。为了消除它与容器的依赖性,我们传入一对iterator[first, last),并在参数列表中加入另一个iterator,用以指定从何处开始复制元素。新的实现内容如下:
template <typename InputIterator, typename OutputIterator,
typename Elemtype, typename Comp>
OutputIterator filter(InputIterator first,InputIterator last,
OutputIterator at, const ElemType& val, Comp pred)
{
while ((first = find_if(first, last, bind2nd(pred, val))) != last)
{
cout << "found value: " << *first << endl;
*at++ = *first++;
}
return at;
}
另一种adapter是negator,它会对function object的真伪取反。not1可对unary function object的真伪值取反,not2可对binary function object的真伪值取反。比如,要找出不小于10的元素,我们可以将less<int>()运算结果取反。
while (iter = (find_if(iter, vec.end(), not1(bind2nd(less<int>, 10))) != vec.end())
对本节内容做一个梳理:
一开始写一个函数,可以找出vector内小于10的函数。然而函数过于死板,没有弹性。
然后,为函数加上一个数值参数,让用户指定得以指定某个数值,以此和vector中元素做比较。
接着,加上一个函数指针,让用户得以指定比较方式。
然后引入function object概念,使我们得以将某组行为传给函数,此法比函数指针的做法效率更高。
最后,将函数以function template的方式重现实现。为了支持多种容器,传入了一对iterator,标示出一组元素范围;为了支持多种元素类型,将元素类型模板参数化,也将应用在元素上的比较操作参数化,以便同时支持函数指针和function object方式。
现在,我们的函数与元素类型无关,与比较操作无关,与容器类型无关。也就是当前函数已经是泛型算法了。
3.7 使用Map
map被定义为一对pair数值,其中key通常是字符串,扮演索引的角色,另一个数值是value。
要使用map,也得先包含他的头文件。
#include <map>
#include <string>
map<string, int> words;
// key value
word["veshuih"] = 1;
欲查询map内是否存在key。有三种方法。最直接的方式把key当作索引使用,该写法缺点是,如果用来索引的key并不存在map内,这个key会被自动加入map中,而且value值会被设置为所属类型的默认值。
第二种方法是利用map的find()函数。我们将key传入find(),并调用。如果key已经放入其中,find()会返回一个iterator,指向key/value形成的一个pair。反之则返回end()。
words.find("vermeer");
第三种方法是是利用map的count()函数。count()会返回某特定项在map内的个数。
words.count("vermeer");
任何一个key值在map最多只有一份,如果我们需要多份相同的key值,请使用multimap。
3.8 使用Set
set是一群key组合而成。如果我们想知道某值是否存在某个集合内,就可以使用set。例如,在图形遍历算法中,我们可以使用set存储在每个遍历过的节点node。在移至下一个节点前,我们可以先查询set,判断该节点是否已经遍历过。
#include <set>
#include <string>
set<string> word_exclusion;
word_exclusion.count();
默认情况下,set元素皆依据所属类型的less-than运算符进行排序。
3.9 如何使用Iterator Inserter
回顾3.6节中filter()的实现,我们将源端容器内每一个符合条件的元素一一赋值至目的端容器。
while ((first = find_if(first, last, bind2nd(pred, val))) != last)
{
*at++ = *first++;
}
一个问题是filter()函数无法知道每次对at递增之后,at是否仍然指向一个有效的容器位置。如果设置目的端容器大小等于源端容器大小,这有些浪费内存空间了。另一种解法是先定义一个空容器,而后每当有元素插入进来,在加以扩展。
标准库提供了三个所谓的Insertion adapter,这些adapter能让我们避免使用容器的assignment运算符。
back_inserter()会以容器的push_back()取代assignment运算符。
inserter()会以容器的insert()函数取代assignment运算符。
front_inserter()会容器的push_front()取代assignment运算符。这个inserter只适用于list和deque。
欲使用上述三种inserter,必须包含iterator头文件。
#include <iterator>
3.10 使用iostream iterator
标准库提供输入输出的iostream iterator类。称为istream_iterator和ostream_iterator,分别支持单一类型的元素读取和写入。得先包含头文件iterator。
#include <iterator>
我们提供了一个first iterator,它将is定义为一个“绑定标准输入设备”。对于标准输入设备而言,end-of-file即代表一个last。只要在定义istream_iterator时不为它指定istream对象,它便代表了end-of-file。例如:
istream_iterator<string> is(cin);
istream_iterator<string> eof;