C++ Primer 学习笔记_29_STL实践与分析（3） --操作步骤集装箱(下一个)STL实践与分析

STL实践与分析

--顺序容器的操作(下)

六、訪问元素

    假设容器非空，那么容器类型的front和back成员将返回容器的第一个和最后一个元素的引用。

【与begin和end的对照：】

    1）begin和end返回容器类型的迭代器，而不是引用；

    2）end返回容器最后一个元素的下一个位置的迭代器，而back返回容器的最后一个元素的引用！

	/*
*必须保证该list容器非空！
*假设容器为空，则if语句内的全部操作都是没有定义的！

*/ if (!iList.empty()) { list<int>::reference bVal1 = *iList.begin(); list<int>::reference bVal2 = iList.front(); list<int>::reference eVal1 = *--iList.end(); list<int>::reference eVal2 = iList.back(); cout << "Begin:" << endl; cout << bVal1 << endl; cout << bVal2 << endl; cout << endl << "End:" << endl; cout << eVal1 << endl; cout << eVal2 << endl; }

訪问顺序容器内元素的操作
c.back()	返回容器c的最后一个元素的引用。假设c为空，则该操作没有定义
c.front()	返回容器c的第一个元素的引用。假设c为空，则该操作没有定义
c[n]	返回下标n的元素的引用，假设n<0或n>=c.size()，则该操作没有定义 仅仅适用于vector和deque容器
c.at(n)	返回下标为n的元素的引用，假设下标越界。则该操作没有定义 仅仅适用于vector和deque容器

    使用下标运算的一个可选方案是使用at成员函数，尽管这个函数的行为和下标运算相似。可是假设程序给出的下标无效，at函数会抛出out_of_range异常。

vector<string> strVec;
cout << strVec[0] << endl;
//run-time error
cout << strVec.at(0) << endl;	//throw out_of_range

//P280 习题9.24
int main()
{
vector<string> strVec;
strVec.push_back("o(∩∩)o...");
if (!strVec.empty())
{
cout << strVec.front() << endl;
cout << *strVec.begin() << endl;
string tmp = strVec.at(0);
cout << tmp << endl;
tmp = strVec[0];
cout << tmp << endl;
}
}

七、删除元素

删除顺序容器内元素的操作
c.erase(p)	删除迭代器p所指向的元素 返回一个迭代器,它指向被删除元素后面的元素。 假设p指向容器内的最后一个元素,则返回的迭代器指向容器的超出末端的下一位置。假设p本身就是指向超出末端的下一位置的迭代器,则该函数没有定义
c.erase(b,e)	删除迭代器b和e所标记的范围内全部的元素 返回一个迭代器,它指向被删除元素段后面的元素。假设e本身就是指向超出末端的下一位置的迭代器,则返回的迭代器也指向容器的超出末端的下一位置
c.clear()	删除容器c内的全部元素。返回void
c.pop_back()	删除容器c的最后一个元素。返回void。 假设c为空容器, 则该函数没有定义
c.pop_front()	删除容器c的第一个元素。返回void。假设c为空容器,则该函数没有定义 仅仅适用于list或deque容器

1、删除第一个/最后一个元素

    pop_front操作通常与front操作配套使用。实现以栈的方式处理容器：

	while (!iDeq.empty())
{
proccess(iDeq.front());
iDeq.pop_front();
}

【注意：】

    pop_front和 pop_back函数的返回值并非删除的元素值,而是void。

要获取删除的元素值,则必须在删除元素之前调用front或 back函数。

2、删除容器内的一个/一段元素

    erase的两种形式都返回一个迭代器,它指向被删除元素或元素段后面的元素。

也就是说,假设元素j恰好紧跟在元素i后面,则将元素i从容器中删除后,删除操作返回指向j的迭代器。

    如同其它操作一样,erase操作也不会检查它的參数。程序猿必须确保用作參数的迭代器或迭代器范围是有效的。因此。在删除元素之前。必须确保迭代器不是end迭代器，假设恰巧是end迭代器，则erase的操作没有定义。

void printVec(const vector<string> &strVec)
{
for (vector<string>::const_iterator iter = strVec.begin(); iter != strVec.end(); ++iter)
{
cout << *iter << endl;
}
}
int main()
{
//	freopen("input","r",stdin);
vector<string> strVec;
string val;
while (cin >> val)
{
strVec.push_back(val);
}
printVec(strVec);
string searchVal("Quasimodo");
vector<string>::iterator iter = find(strVec.begin(),strVec.end(),searchVal);
if (iter != strVec.end())
{
strVec.erase(iter);
}
printVec(strVec);
}

3、删除容器内的全部元素

	strVec.clear();
strVec.erase(strVec.begin(),strVec.end());

    同一时候，erase函数的迭代器版本号也提供了删除部分元素的功能：

	string searchVal("Quasimodo");
vector<string>::iterator iter = find(strVec.begin(),strVec.end(),searchVal);
strVec.erase(strVec.begin(),iter);	//不会包括iter指向的元素
printVec(strVec);

    假设删除时，两个迭代器指向的元素是同一个元素。则不会删除不论什么元素。假设两个迭代器指向的元素有一个或两个不存在。则会发生执行时错误：

strVec.erase(strVec.begin(),strVec.begin());
printVec(strVec);
strVec.erase(strVec.begin(),strVec.end()+1);
printVec(strVec);

【小心地雷o(∩∩)o...，P282】

    erase、pop_front和 pop_back函数使指向被删除元素的全部迭代器失效。对于vector容器,指向删除点后面的元素的迭代器通常也会失效。而对于deque容器,假设删除时不包括第一个元素或最后一个元素,那么该deque容器相关的全部迭代器都会失效。

//P282 习题9.26
void printVecInt(const vector<int> &strVec)
{
for (vector<int>::const_iterator iter = strVec.begin(); iter != strVec.end(); ++iter)
{
cout << *iter << 't';
}
cout << endl;
}
void printlistInt(const list<int> &strVec)
{
for (list<int>::const_iterator iter = strVec.begin(); iter != strVec.end(); ++iter)
{
cout << *iter << 't';
}
cout << endl;
}
int main()
{
int ia[] = {0,1,1,2,3,5,8,13,21,55,89};
vector<int> iVec(ia,ia+sizeof(ia)/sizeof(*ia));
list<int> iList(ia,ia+sizeof(ia)/sizeof(*ia));
//
printlistInt(iList);
//
printVecInt(iVec);
for (vector<int>::iterator iter = iVec.begin(); iter != iVec.end(); ++iter)
{
if (!(*iter % 2))
{
iter =
iVec.erase(iter);
-- iter;
}
}
printVecInt(iVec);
for (list<int>::iterator iter = iList.begin(); iter != iList.end(); ++iter)
{
if (*iter % 2)
{
iter = iList.erase(iter);
-- iter;
}
}
printlistInt(iList);
}

//习题9.27
int main()
{
//	freopen("input","r",stdin);
list<string> strList;
string val;
while (cin >> val)
{
strList.push_back(val);
}
string searchVal("dream");
for (list<string>::iterator iter = strList.begin(); iter != strList.end(); ++iter)
{
if (*iter == searchVal)
{
strList.erase(iter);
--iter;
}
}
for (list<string>::iterator iter = strList.begin(); iter != strList.end(); ++iter)
{
cout << *iter << 't';
}
cout << endl;
}

八、赋值与swap

顺序容器的赋值与swap操作
c1= c2	删除容器c1的全部元素,然后将c2的元素复制给c1。 c1和c2的类型(包含容器类型和元素类型)必须同样
c.assign(b,e)	又一次设置c的元素:将迭代器b和e标记的范围内全部的元素拷贝到c中。 b和e必须不是指向c中元素的迭代器
c.assign(n,t)	将容器c又一次设置为存储n个值为t的元素
c1.swap(c2)	交换内容:调用完该函数后,c1中存放的是c2原来的元素,c2中存放的则是c1原来的元素。 c1和c2的类型必须同样。 该函数的运行速度通常要比将c2拷贝到c1的操作快

    与赋值相关的操作符都作用于整个容器。除了swap外，其它操作都能够通过erase和insert来替代。

赋值操作符首先删除其左操作数容器的全部元素，然后将右操作数容器的全部元素插入到左边容器中：

	vec1 = vec2;
//等效于
vec1.erase(vec1.begin(),vec1.end());
vec1.insert(vec1.begin(),vec2.begin(),vec2.end());

    虽然赋值前两个容器的长度可能不相等。可是赋值后两个容器的长度都等于右边容器的长度！

【小心地雷：】

    赋值和assign操作使左操作容器的全部迭代器失效，swap操作则不会使迭代器失效。完毕swap操作后,虽然被交换的元素已经存放在还有一容器中,但迭代器仍然指向同样的元素。

1、使用assign

    1）带有一对迭代器參数的assign操作同意我们将一个容器的元素赋给还有一个不同类型的容器。

可是两种容器类型与元素类型必须相互兼容！

	sList.assign(sVec.begin(),sVec.end());

    2）assign运算的第二个版本号须要一个整型数值和一个元素值做參数,它将容器重置为存储指定数量的元素,而且每一个元素的值都为指定值: 

	sList.assign(10,"o(∩∩)o...");

2、使用swap操作以节省删除元素的成本

    swap操作实现交换两个容器内全部元素的功能。要交换的容器的类型必须匹配:操作数必须是同样类型的容器,并且所存储的元素类型也必须同样。

调用了swap函数后,右操作数原来存储的元素被存放在左操作数中,反之亦然。

void printListStr(const list<string> &sList)
{
for (list<string>::const_iterator iter = sList.begin(); iter != sList.end(); ++iter)
{
cout << *iter << endl;
}
}
int main()
{
list<string> sList1(3,"o(∩∩)o...");
list<string> sList2(4,"(*^__^*)");
cout << "sList1:" << endl;
printListStr(sList1);
cout << "sList2:" << endl;
printListStr(sList2);
sList1.swap(sList2);
cout << "sList1:" << endl;
printListStr(sList1);
cout << "sList2:" << endl;
printListStr(sList2);
}

    关于swap的一个重要问题在于:该操作不会删除或插入不论什么元素,并且保证在常量时间内实现交换。

因为容器内没有移动不论什么元素,因此迭代器不会失效。

    没有移动元素这个事实意味着迭代器不会失效。它们指向同一元素,就像没作swap运算之前一样。尽管,在swap运算后,这些元素已经被存储在不同的容器之中了。比如,在做 swap运算之前,有一个迭代器iter指向 svec1[3]字符串;实现swap运算后,该迭代器则指向svec2[3]字符串(这是同一个字符串,仅仅是存储在不同的容器之中而已)。

vector<string> sVec1(4,"o(∩∩)o...");
vector<string> sVec2(3,"(*^__^*)");
vector<string>::iterator iter = sVec1.end() - 1;
cout << *iter << endl;
sVec1.swap(sVec2);
cout << *iter << endl;

//P284 习题9.28
void printListStr(const list<string> &sList)
{
for (list<string>::const_iterator iter = sList.begin(); iter != sList.end(); ++iter)
{
cout << *iter << endl;
}
}

版权声明：本文博主原创文章，博客，未经同意不得转载。