一、string类
1、构造函数
string实际上是basic_string
**构造函数** | **描述** |
**string(const char * s)** | **将string对象初始化为s指向的NBTS** |
**string(size_type n, char c)** | **创建一个包含n个元素的string对象,其中每个元素都被初始化为字符c** |
**string(const string & str)** | **将一个string对象初始化为string对象str(复制构造函数)** |
**string()** | **创建一个默认的string对象,长度为0(默认构造函数)** |
**string(const char * s,size_type n)** | **将string对象初始化为s指向的NBTS的前n个字符,即使超过了NBTS结尾** |
**template **string(Iter begin,Iter end)** | **将string对象初始化为区间[begin,end)内的字符,其中begin和end的行为就像指针,用于指定位置,范围包括begin在内,但不包括end** |
**string(const string & str, size_type pos = 0,size_type n = npos)** | **将一个string对象初始化为对象str中从位置pos开始到结尾的字符,或从位置pos开始的n个字符** |
**string(string && str)noexcept** | **这是C++11新增的,他将一个string对象初始化为string对象str,并可能修改str(移动构造函数)** |
**string(initializer_list | **这是C++11新增的,它将一个string对象初始化为初始化列表il中的字符** |
2、string类输入
对于类,需要知道有哪些输入方式可用。对于C风格字符串,有3种方式:
char info[100];
cin >> info;//读取一个词
cin.getline(info,100);//读取一行,遇到\n结束,并丢弃\n
cin.get(info, 100);//读取一行,遇到\n结束,将\n丢弃在输入队列中
对于string对象,有两种方式:
string stuff;
cin >> stuff;//读取一个词
getline(cin,stuff);//读取一行,遇到\n结束并丢弃\n
二、智能指针模板类
智能指针是行为类似于指针的类对象。
auto_ptr是C++98提供的解决方案,C++11已将其摒弃,并提供了另外两种解决方案。然而,虽然auto_ptr被摒弃,但它已经使用了多年;同时,如果编译器不支持其他两种解决方案,auto_ptr将是唯一的解决方案。
2.1、使用智能指针
auto_ptr、unique_ptr和shared_ptr这三个智能指针模板都定义了类似指针的对象,可以将new获得(直接或间接)的地址赋给这种对象。当智能指针过期,其析构函数将使用delete来释放内存。因此,如果将new返回的地址赋给这些对象,将无需记住稍后释放这些内存:在智能指针过期时,这些能存将自动被释放。
要创建智能指针对象,必须包含头文件memory,该文件模板定义。然后使用通常的模板语法来实例化所需类型的指针。例如,模板auto_ptr包含如下构造函数:
template
public:
explicit auto_ptr(X *p = 0) throw();
...};
throw()意味着构造函数不会引发异常;与auto_ptr一样,throw()也被摒弃。因此,请求X类型的auto_ptr将获得一个指向X类型的auto_ptr:
auto_ptr
auto_ptr
new double是new返回的指针,指向新分配的内存块。它是构造函数auto_ptr
unique_ptr
shared_ptr
智能指针模板位于名称空间std中。下面的程序演示了如何使用全部三种智能指针。每个智能指针都放在同一个代码块内,这样离开代码的时候,指针将过期。Report类使用方法报告对象的创建和销毁。
1 #include <iostream>
2 #include <memory>
3
4 class Report{
5 private:
6 std::string str;
7 public:
8 Report(const std::string & s):str(s){
9 std::cout << "创建了对象" << str <<"! \n";
10 }
11 ~Report(){
12 std::cout << "销毁了对象" << str << "! \n";
13 }
14 void comment()const{
15 std::cout << str << "\n";
16 }
17 };
18
19 int main(int argc, char * argv[])
20 {
21 using namespace std;
22 {
23 auto_ptr<Report> ps(new Report("using auto_ptr"));
24 ps->comment();
25 }
26 {
27 shared_ptr<Report> ps(new Report("using shared_ptr"));
28 ps->comment();
29 }
30 {
31 unique_ptr<Report> ps(new Report("using unique_ptr"));
32 ps->comment();
33 }
34 return 0;
35 }
36
37 输出结果:
38 创建了对象using auto_ptr!
39 using auto_ptr
40 销毁了对象using auto_ptr!
41 创建了对象using shared_ptr!
42 using shared_ptr
43 销毁了对象using shared_ptr!
44 创建了对象using unique_ptr!
45 using unique_ptr
46 销毁了对象using unique_ptr!
所有智能指针都有一个explicit构造函数,该构造函数将指针作为参数。因此不需要自动将指针转换为智能指针对象。
由于智能指针模板定义方式,智能指针对象的很多方面都类似于常规指针。
2.2、有关智能指针的注意事项
为何使用三种智能指针呢?实际上有4种,另外一种是weak_ptr,但我们不讨论它。为何摒弃auto_ptr呢?
先来看下面的复制语句:
std::auto_ptr
std::auto_ptr
vocation = ps;
上述赋值语句将完成什么工作呢?如果ps和vocation是常规指针,则两个指针将指向同一个string对象。这是不能接受的,因为程序将视图删除同一个对象两次——一次是ps过期时,另一次是vocation过期时。要避免这种问题,方法有多种。
*定义赋值运算符,使之执行深度复制。这样两个指针将指向不同的对象,其中的一个对象是另一个对象的副本。
*建立所有权(ownership)概念,对于特定的值,只能有一个智能指针可拥有它,这样只有拥有对象的智能指针的析构函数会删除该对象。然后,让赋值操作转让所有权。这就是用于auto_ptr和unique_ptr的策略,但unique_ptr的策略更严格。
*创建智能更高的指针,跟踪引用特定对象的智能指针数。这称为引用计数(reference counting)。例如,赋值时,计数将加1,而指针过期时,计数将减1 。仅当最后一个指针过期时,才调用delete。这是shared_ptr采用的策略。
当然同样的策略也适用于复制构造函数。
每种方法都有用途。下面的程序清单是一个不适合auto_ptr的示例:
#include <iostream>
#include <memory>
#include <string>
int main(int argc, char * argv[])
{
using namespace std;
auto_ptr<string> films[5] = {
auto_ptr<string> (new string("卡卡西")),
auto_ptr<string> (new string("佐助")),
auto_ptr<string> (new string("宇智波鼬")),
auto_ptr<string> (new string("凯")),
auto_ptr<string> (new string("宁次"))
};
auto_ptr<string> pwin;
pwin = films[2];
for (int i = 0; i < 5; i++) {
cout << *films[i] << endl;
}
cout << *pwin << endl;
cin.get();
return 0;
}
输出结果:
卡卡西
佐助
(lldb) //程序崩溃了
程序崩溃的原因在于,下面的语句将所有权从film[2]转让给pwin:
pwin = films[2]; //films[2]丢失所有权
这导致films[2]不再引用该字符串。在auto_ptr放弃对象的所有权后,便可能使用它来反问该对象。当程序打印films[2]指向的字符串时,却发现这是一个空指针。
如果在上面的程序清单中用shared_ptr代替auto_ptr,则程序运行正常:
1 #include <iostream>
2 #include <memory>
3 #include <string>
4
5 int main(int argc, char * argv[])
6 {
7 using namespace std;
8 shared_ptr<string> films[5] = {
9 auto_ptr<string> (new string("卡卡西")),
10 auto_ptr<string> (new string("佐助")),
11 auto_ptr<string> (new string("宇智波鼬")),
12 auto_ptr<string> (new string("凯")),
13 auto_ptr<string> (new string("宁次"))
14 };
15 shared_ptr<string> pwin;
16 pwin = films[2];
17
18 for (int i = 0; i < 5; i++) {
19 cout << *films[i] << endl;
20 }
21 cout << *pwin << endl;
22 cin.get();
23 return 0;
24 }
25
26 输出结果:
27 卡卡西
28 佐助
29 宇智波鼬
30 凯
31 宁次
32 宇智波鼬
这次pwin和films[2]指向同一个对象,而引用计数从1增加到2 。在程序末尾,后声明的pwin首先调用其析构函数,该析构函数将引用计数降低到1 。然后,shared_ptr数组的成员被释放,对films[2]调用析构函数时,将引用计数降低到0,并释放以前分配的空间。
unique_ptr与auto_ptr一样,也采用所有权模型。但使用unique_ptr时,程序不会等到运行阶段崩溃,而在编译阶段出现错误。
2.3 unique_ptr为何优于auto_ptr
先看下面的语句:
auto_ptr
auto_ptr
p2 = p1; // #3
在语句#3中,p2接管了string对象的所有权后,p1的所有权将会被剥夺。这是件好事,可防止p1和p2的析构函数试图删除同一个对象;但如果程序随后试图使用p1,这将是坏事,因为p1不再指向有效的数据。
下面来看使用unique_ptr的情况:
unique_ptr
uniqie_ptr
p4 = p3; // #6
编译器认为语句#6非法,避免了p3不再指向有效数据的问题。因此,unique_ptr比auto_ptr更安全(编译阶段错误比潜在的程序崩溃更安全)。
但有时候,将一个智能指针赋给另一个并不会留下危险的悬挂指针。假设有如下的函数定义:
unique_ptr
unique_ptr
return temp;
}
并假设编写如下的代码:
unique_ptr
ps = demo("Good morning!");
demo()返回一个临时unique_ptr,然后ps接管了原本归返回的unique_ptr所有的对象,而返回的unique_ptr被销毁。这没有问题,因为ps拥有了string对象的所有权。但这里的另一个好处是,demo()返回的临时unique_ptr很快被销毁,没有机会使用它来访问无效的数据。换句话说,没有理由禁止这种赋值。神奇的是,编译器允许这种赋值。
总之,程序试图将一个unique_ptr赋给另一个时,如果源unique_ptr是一个临时右值,编译器允许这样做;如果unique_ptr将存在一段时间,编译器将禁止这样做:
unsing namespace std;
unique_ptr
unique_ptr
pu2 = pu1; //#1 不允许
unique_ptr
pu3 = unique_ptr
语句#1将留下悬挂的unique_ptr(pu1),这可能导致危险。语句#2不会留下悬挂的unique_ptr,因为它调用unique_ptr的构造函数,该构造函数创建的临时对象在其所有权转让给pu3后就会被销毁。这种随情况而异的行为表明,unique_ptr优于允许两种赋值的auto_ptr。这也是禁止(只是一种建议,编译器并不会禁止)在容器对象中使用auto_ptr,但允许使用unique_ptr的原因。如果容器算法试图对包含unique_ptr的容器执行类似于语句#1的操作,将导致编译错误;如果算法试图执行类似于#2的操作,则不会有任何问题。而对于auto_ptr,类似于语句#1的操作可能导致不确定的行为和神秘的崩溃。
当然,可能确实想执行类似语句#1的操作。仅当以非智能的方式使用遗弃的智能指针(如解引用时),这种赋值才不安全。要安全地重用这种指针,可给它赋新值。C++有一个标准库函数std::move(),让您能够将一个unique_ptr赋给另一个。下面是一个使用前面demo()函数的例子,该函数返回一个unique_ptr
unsing namespace std;
unique_ptr
ps1 = demo("Hello world!");
ps2 = move(ps1);
ps1 = demo("Good morning!");
cout << *ps2 << ps1 << endl;
相比于auto_ptr,unique_ptr还有另一个优点。它有一个可用于数组的变体。别忘了,必须将delete和new配对使用,将delete []和new []配对。模板auto_ptr使用delete而不是delete [],因此只能与new一起使用,而不能与new []一起使用。但unique_ptr有使用new []和delete []的版本:
std::unique_ptr
警告:使用new分配内存是,才能使用auto_ptr和shared_ptr,使用new []分配内存时,不能使用它们。不使用new分配内存时,不能使用auto_ptr和shared_ptr;不使用new或new []分配内存时,不能使用unique_ptr。
2.4 选择智能指针
应使用哪种智能指针呢?如果程序要使用多个指向同一个对象的指针,应选择shared_ptr。这种情况包括:有一个指针数组,并使用一些辅助指针来标示特定的元素,如最大的元素和最小的元素;两个对象包含都指向第三个对象的指针;STL容器包含指针。很多STL算法都支持复制和赋值操作,这些操作可用于shared_ptr,但不能用于unique_ptr(编译发出警告)和auto_ptr(行为不确定)。如果编译器没有提供shared_ptr,可使用Boost库提供的shared_ptr。
如果程序不需要多个指向同一个对象的指针,则可使用unique_ptr。如果函数使用new分配内存,并返回指向该内存的指针,将其返回类型声明为unique_ptr是不错的选择。这样,所有权将转让给接受返回值的unique_ptr,而该智能指针负责调用delete。可将unique_ptr存储到STL容器中,只要不调用将一个unique_ptr复制或赋值给另一个方法或算法(如sort())。例如,可在程序中使用类似于下面的代码段,这里假设包含了正确的include和using语句:
unique_ptr
return unique_ptr
}
void show(unique_ptr
cout << *p << '\n';
}
int main(){
...
vector
for(int i = 0; i < vp.size(); i++){
vp[i] = make_int(rand() % 1000);
}
vp.push_back(make_int(rand() % 1000));
for_each(vp.begin(), vp.end(), show);
...
}
其中的push_back()调用没有问题,因为它返回一个临时unique_ptr,该unique_ptr被赋值给vp中的一个unique_ptr。另外,如果按值而不是按引用给show()传递对象,for_each()将非法,因为这将导致使用一个来自vp的非临时unique_ptr初始化pi,而这时不允许的。前面说过,编译器将发现错误使用unique_ptr的企图。
在unique_ptr为右值时,可将其赋给shared_ptr,这与将一个unique_ptr赋给另一个需要满足的条件相同。与前面一样,在下面的代码中,make_int()返回的类型为unique_ptr
unique_ptr
shared_ptr
shared_ptr
模板shared_ptr包含一个显式构造函数,可用于将右值unique_ptr转换为shared_ptr。shared_ptr将接管原来归unique_ptr所有的对象。
在满足unique_ptr要求的条件时,也可使用auto_ptr,但unique_ptr是更好的选择。如果编译器没有提供unique_ptr,可考虑使用BOOST库提供的scoped_ptr,它与unique_ptr类似。
三、标准模板库
STL提供了一组表示容器、迭代器、函数对象和算法的模板。容器是一个与数组类似的单元,可以存储若干个值。STL容器是同质的,即存储的值的类型相同;算法是完成特定任务(如对数组进行排序或在链表中查找特定的值)的处方;迭代器能够用来遍历容器的对象,与能够遍历数组的指针类似,是广义指针;函数对象是类似于函数的对象,可以是类对象或函数指针(包括函数名,因为函数名被用作指针)。STL使得能够构造各种容器(包括数组、队列和链表)和执行各种操作(包括搜索、排序和随机排列)。
STL不是面相对象的编程,而是一种不同的编程模式——范型编程(generic programming)。
3.1 模板类vector
在计算机中,矢量(vector)对应数组,而不是数学矢量(在数学中,可以使用N个分量来表示N维数学矢量,因此从这方面讲,数学矢量类似一个N维数组。然而,数学矢量还有一些计算机矢量不具备的其他特征,如内乘积和外乘积)。计算机矢量存储了一组可随机访问的值,即可以使用索引来直接访问矢量的第10个元素,而不必首先访问前面第9个元素。在头文件vector中定义了vector模板。
要创建vector模板对象,可使用通用的
include
using namespace std;
vector
int n;
cin >> n;
vector
由于运算符[]被重载,因此创建vector对象后,可以使用通用的数组表示法来访问各个元素:
ratings[0] = 9;
for(int i = 0; i < n; n++){
cout << scores[i] << endl;
}
分配器
与string类相似,各种STL容器模板都接受一个可选的模板参数,爱参数指定使用哪个分配器对象来管理内存。例如,vector模板的开头与下面类似:
template
class vector{...};
如果省略该模板参数的值,则容器模板将默认使用allocator
下面的程序是一个要求不高的应用程序,它使用了这个类。该程序创建两个vector对象——一个是int规范,另一个是string规范,它们都包含5个元素。
1 #include <iostream>
2 #include <string>
3 #include <vector>
4 #include <iomanip>
5
6 const int NUM = 5;
7 int main(int argc, char * argv[])
8 {
9 using namespace std;
10 vector<int> scores(NUM);
11 vector<string> students(NUM);
12 cout << "依次输入五个学生的成绩和名字\n";
13 for (int i = 0; i < NUM; i++) {
14 cout << "请输入第"<< i+1 <<"个学生名字:";
15 cin >> students[i];
16 while (cin.get() != '\n');
17 cout << "请输入学生的成绩:";
18 cin >> scores[i];
19 while (cin.get() != '\n');
20 }
21 cout << "\n这是学生的成绩:\n";
22 for (int i = 0; i < NUM; i++) {
23 cout << setw(20) << right << students[i] << ": " << setw(4) << right << scores[i] << endl;
24 }
25 return 0;
26 }
27
28 输出结果:
29 依次输入五个学生的成绩和名字
30 请输入第1个学生名字:xiaohong
31 请输入学生的成绩:100
32 请输入第2个学生名字:xiaoming
33 请输入学生的成绩:98
34 请输入第3个学生名字:xiaoyu
35 请输入学生的成绩:88
36 请输入第4个学生名字:xiaonan
37 请输入学生的成绩:85
38 请输入第5个学生名字:xiaohua
39 请输入学生的成绩:68
40
41 这是学生的成绩:
42 xiaohong: 100
43 xiaoming: 98
44 xiaoyu: 88
45 xiaonan: 85
46 xiaohua: 68
3.2 可对矢量执行的操作
所有的STL容器都提供了一些基本方法,其中包括size()——返回容器中的元素数目、swap()——交换两个容器的内容、begin()——返回一个指向容器第一个元素的迭代器、end()——返回一个表示超过容器尾的迭代器。
迭代器是一个广义指针。事实上,它可以是指针,也可以是一个可对其执行类似指针的操作——如解除引用(如operator*())和递增(如operator++())——的对象。通过将指针广义化为迭代器,让STL能够为各种不同的容器类(包括那些简单指针无法处理的类)提供统一的接口。每个容器都定义了一个合适的迭代器,该迭代器的类型是一个名为iterator的typedef,其作用域为整个类。例如,要为vector的double类型规范声明一个迭代器,可以这样做:
vector
假设scores是一个vector
vector
则可以使用迭代器pd执行这样的操作:
pd = scores.begin();
*pd = 22.3;
++pd;
迭代器的行为就像指针。顺便说一句,还有一个C++11自动类型推断很有用的地方。例如,可以不这样做:
vector
而这样做:
auto pd = scores.begin();
什么是超过结尾(past-the-end)呢?它是一种迭代器,指向容器最后一个元素后面的那个元素。这与C-风格字符串最后一个字符后面的空字符类似,只是空字符是一个值,而“超过结尾”是一个指向元素的指针(迭代器)。end()成员函数标识超过结尾的位置。如果将迭代器设置为容器的第一个元素,并不断递增,则最终它将到达容器的结尾,从而遍历容器的内容。例如,假设students是一个vector
for(auto pd = students.begin(); pd != students.end(); pd++)
cout << *pd << endl;
所有的容器都包含上面讨论的方法。vector模板类也包含一些只有某些STL容器才有的方法。push_back()是一个方便的方法,它将元素添加到矢量末尾。这样做时,它将负责内存管理,增加矢量的长度,使之能够容纳新的成员。这意味着可以这样编写代码:
vector
double temp;
while(cin >> temp && temp >= 0)
scores.push_back(temp);
cout << "You entered " << scores.size() << " scores.\n";
每次循环都给scores对象增加一个元素。在编写或运行程序时,无需了解元素的数目。只要能够取得足够的内存,程序就可以根据需要增加scores的长度。
erase()方法删除矢量中给定区间的元素。它接受两个迭代器参数,这些参数定义了要删除的区间。了解STL如何使用两个迭代器来定义区间至关重要。第一个迭代器指向区间的起始处,第二个迭代器位于区间终止处的后一个位置。例如,下述代码删除第一个和第二个元素,即删除begin()和begin()+1指向的元素(由于vector提供了随机访问功能,因此vector类迭代器定义了诸如begin()+2等操作):
scores.erase(scores.begin(), scores.begin() + 2);
如果it1和it2是迭代器,则STL文档使用[it1, it2)来表示从it1到it2(不包括it2)的区间。因此,区间[begin(), end()]将包括集合的所有内容,而区间[p1, p1)为空。[)表示法并不是C++的组成部分,因此不能在代码中使用,而只能出现在文档中。
insert()方法的功能与erase()相反。它接受三个迭代器参数,第一个参数指定了新元素的插入位置,第二个和第三个迭代器参数定义了被插入区间,该区间通常是另一个容器对象的一部分。例如,下面的代码将矢量new_v中除第一个元素外的所有元素插入到old_v矢量的第一个元素前面:
vecor
vector
...
old_v.insert(old_v.begin(), new_v.begin() + 1, new_v.end());
顺便说一句,拥有超尾元素是非常方便的,因为这使得在矢量尾部附加元素非常简单。下面的代码将新元素插入到old_v.end()前面,即矢量最后一个元素的后面:
old_v.insert(old_v.end(), new_v.begin() + 1, new_v.end());
下面的程序演示了size()、begin()、end()、push_back()、erase()和insert()的用法:
1 #include <iostream>
2 #include <string>
3 #include <vector>
4 struct Review{
5 std::string title;
6 int rating;
7 };
8 bool FillReview(Review & rr);
9 void ShowReview(const Review & rr);
10 int main(int argc, char * argv[])
11 {
12 using namespace std;
13 vector<Review> books;
14 Review temp;
15 while (FillReview(temp)) {
16 books.push_back(temp);
17 }
18 size_t num = books.size();
19 if (num > 0) {
20 cout << "谢谢。下面是你输入的:\n" << "Rating\tBook\n";
21 for (int i = 0; i < num; i++) {
22 ShowReview(books[i]);
23 }
24 cout << "重复:\n" << "Rating\tBook\n";
25 for (auto pd = books.begin(); pd != books.end(); pd++) {
26 ShowReview(*pd);
27 }
28 vector<Review> oldlist(books);
29 if (num > 3) {
30 books.erase(books.begin() + 1, books.begin() + 3);
31 cout << "删除数目后:\n";
32 for (auto ps = books.begin(); ps != books.end(); ps++) {
33 ShowReview(*ps);
34 }
35 }
36
37 books.insert(books.begin(), oldlist.begin() + 1, oldlist.begin() + 2);
38 cout << "插入新数目后:\n";
39 for (auto ps = books.begin(); ps != books.end(); ps++) {
40 ShowReview(*ps);
41 }
42 }
43 else{
44 cout << "什么都没有输入\n";
45 }
46 return 0;
47 }
48
49 bool FillReview(Review & rr){
50 std::cout << "请输入书籍的名字(输入quit退出):";
51 std::getline(std::cin, rr.title);
52 if (rr.title == "quit") {
53 return false;
54 }
55 std::cout << "输入书的价格: ";
56 std::cin >> rr.rating;
57 while (std::cin.get() != '\n') {
58 continue;
59 }
60 return true;
61 }
62
63 void ShowReview(const Review & rr){
64 std::cout << rr.rating << "\t" << rr.title << std::endl;
65 }
66
67 输出结果:
68 请输入书籍的名字(输入quit退出):Juhua
69 输入书的价格: 122
70 请输入书籍的名字(输入quit退出):Meigui
71 输入书的价格: 150
72 请输入书籍的名字(输入quit退出):Lanhua
73 输入书的价格: 199
74 请输入书籍的名字(输入quit退出):Huaishu
75 输入书的价格: 200
76 请输入书籍的名字(输入quit退出):quit
77 谢谢。下面是你输入的:
78 Rating Book
79 122 Juhua
80 150 Meigui
81 199 Lanhua
82 200 Huaishu
83 重复:
84 Rating Book
85 122 Juhua
86 150 Meigui
87 199 Lanhua
88 200 Huaishu
89 删除数目后:
90 122 Juhua
91 200 Huaishu
92 插入新数目后:
93 150 Meigui
94 122 Juhua
95 200 Huaishu
3.3 对矢量可执行的其他操作
STL从更广义的角度定义了非成员函数来执行诸如搜索、排序、随机排序等操作。这种设计理念省却了大量的重复工作。如果每个类都有自己的成员函数,则需要定义80(8*10)个成员函数。但采用STL方式时,只需要定义10个非成员函数即可。在定义新的容器类时,只要遵循正确的指导思想,则它也可以使用已有的10个非成员函数来执行查找、排序等操作。
另一方面,即使有执行相同任务的非成员函数,STL有时也会定义一个成员函数。这是因为对有些操作来说,类特定算法的效率比通用算法高,因此,vector的成员函数swap()的效率比非成员函数swap()高,但非成员函数可用来交换两个类型不同的容器的内容。
下面来看3个具有代表性的STL函数:for_each()、random_shuffle()和sort()。
for_each()函数可用于很多容器类,它接受3个参数。前两个是定义容器中区间的迭代器,最后一个是指向函数的指针(更普遍地说,最后一个参数是一个函数对象)。for_each()函数将被指向的函数应用于容器区间中的各个元素。被指向的函数不能修改容器元素的值。可以用for_each()函数代替for循环。例如,可以将代码:
vector
for(pr = books.begin(); pr != books.end(); ps++)
ShowReview(*pr);
替换为:
for_each(books.begin(), books.end(), ShowReview);
这样可以避免显式地使用迭代器变量。
random_shuffle()函数接受两个指定区间的迭代器参数,并随机排列该区间中的元素。例如,下面的语句随机排列books矢量中所有元素:
random_shuffle(books.begin(), books.end());
与可用于任何容器类的for_each()不同,该函数要求容器类允许随机访问,vector类可以做到这一点。
sort()函数也要求容器支持随机访问。该函数有两个版本,第一个版本接受两个定义区间的迭代器参数,并使用为存储在容器中的类型元素定义的<运算符,对区间中的元素进行操作。例如,下面de1语句按升序对nums的内容进行排序,排序时使用内置的<运算符对值进行比较:
vector
....
sort(nums.begin(), nums.end());
如果容器元素是用户定义的对象,则要使用sort(),必须定义能够处理该类型对象的operator<()函数。
sort()函数的另一个版本接受3个参数,前两个参数也是用来指定区间的迭代器,最后一个参数是指向要使用的函数的指针(函数对象),而不是用比较的operator<()。返回值可转换为bool,false表示两个参数的位置不正确。
3.4 基于范围的for循环(C++11)
基于范围的for循环是为用于STL而设计的。先来看一个例子:
1 int main(int argc, const char * argv[]) {
2 using namespace std;
3 double prices[5] = {12.3, 33.5, 66.8, 22.5, 55.8};
4 for (double var:prices) {
5 cout << var << ", ";
6 }
7 return 0;
8 }
9 输出结果:
10 12.3, 33.5, 66.8, 22.5, 55.8,
在这种for循环中,括号内的代码声明一个类型与容器存储的内容相同的变量,然后指出了容器的名称。接下来,循环体使用指定的变量依次访问容器的每个元素。还可以使用auto进行自动类型推断,例如:
1 int main(int argc, const char * argv[]) {
2 using namespace std;
3 double prices[5] = {12.3, 33.5, 66.8, 22.5, 55.8};
4 for (auto var:prices) {
5 cout << var << ", ";
6 }
7 return 0;
8 }
假设books是一个vector
for_each(books.begin(), books.end(), Show);
替换为:
for(auto x : books) Show(x);
不同于for_each(),基于范围的for循环可以修改容器的内容,诀窍是指定一个引用参数。例如:
1 #include <iostream>
2
3 int main(int argc, const char * argv[]) {
4 using namespace std;
5 int nums[5] = {12, 45, 66, 78, 90};
6 for (auto & var : nums) {
7 cout << var << ", ";
8 }
9 cout << '\n';
10 for (auto & var : nums) {
11 var += 10;
12 }
13 for (auto var : nums) {
14 cout << var << ", ";
15 }
16 return 0;
17 }
18
19 输出结果:
20 12, 45, 66, 78, 90,
21 22, 55, 76, 88, 100,
四、泛型编程
STL是一种泛型编程。面相对象编程关注的是编程的数据方面,而泛型编程关注的是算法。它们之间的共同点是抽象和创建可重用代码,但它们的理念决然不同。
泛型编程旨在编写独立于数据类型的代码。在C++中,完成通用程序的工具是模板。当然,模板使得能够按泛型定义函数或类,而STL通过通用算法更进了一步。模板让这一切成为可能,但必须对元素进行仔细地设计。
4.1 为何使用迭代器
模板使得算法独立于存储的数据类型,而迭代器使算法独立于使用的容器类型。因此,它们都是STL通用方法的重要组成部分。
原文链接: https://www.cnblogs.com/mupiaomiao/p/4725628.html
欢迎关注
微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍
原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/220870
非原创文章文中已经注明原地址,如有侵权,联系删除
关注公众号【高性能架构探索】,第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处!