[1] string基础
[1.1] string 的构造
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 #include <iostream> 2 #include <string> 3 4 int main() 5 { 6 using namespace std; 7 8 cout << "1 --- string(const char* s):将string对象初始化为s指向的C风格字符串" << endl; 9 string one("benxintuzi_1"); 10 cout << "one = " << one << endl; // 重载了 << 11 12 cout << "2 --- string(size_type n, char c):以字符c初始化包含n个字符的string对象" << endl; 13 string two(20, '$'); 14 cout << "two = " << two << endl; 15 16 cout << "3 --- string(const string& str):复制构造函数初始化" << endl; 17 string three(one); 18 cout << "three = " << three << endl; 19 20 cout << "4 --- string():默认构造函数" << endl; 21 string four; 22 four += one; // 重载了 += 23 four = two + three; // 重载了 + 24 cout << "four = " << four << endl; 25 26 cout << "5 --- string(const char* s, size_type n):用s指向的C风格字符串的前n个字符初始化string对象" << endl; 27 char s[] = "benxintuzi"; 28 string five(s, 5); 29 cout << "five = " << five << endl; 30 31 cout << "6 --- string(Iter begin, Iter end):用[begin, end)区间内的字符初始化string对象" << endl; 32 string six(s + 2, s + 5); 33 cout << "six = " << six << endl; 34 35 cout << "7 --- string(const string& str, string size_type pos = 0, size_type n = npos):将string对象初始化为str中从pos开始的n个字符" << endl; 36 string seven(four, 5, 2); 37 cout << "seven = " << seven << endl; 38 39 /* 40 cout << "8 --- string(string&& str) noexcept:将string对象初始化为str,并可能修改str,移动构造函数[C++11新特性]" << endl; 41 42 cout << "9 --- string(initializer_list<char>il:将string对象初始化为初始化列表il中的字符[C++11新特性]" << endl; 43 string nine = {'t', 'u', 'z', 'i'}; // or string nine{'t', 'u', 'z', 'i'}; 44 cout << "nine = " << nine << endl; 45 */ 46 }
[1.2] string 的输入
对于 C 风格字符串,有3种输入方式 |
char info[100]; cin >> info; // 从流中读一个单词存放到info中 cin.getline(info, 100); // 从流中读入一行存放到info,删除流中的 cin.get(info, 100); // 从流中读入一行存放到info,保留流中的 |
对于 string 对象,有2种输入方式 |
string stuff; cin >> stuff; // 从流中读取一个单词 getline(cin, stuff); // 从流中读取一行,删除流中的 |
getline可以指定用于分割单词的分隔符,将其放到第三个参数中,如:
cin.getline(info, 100, ‘:’); // C 风格字符串使用这种形式
getline(stuff, ‘:’); // string 类使用这种形式
string与传统 C 风格字符串的比较:
使用string类输入时,不需要具体指定输入的字符个数,其可以自动匹配字符串大小,使用C风格字符串必须显示指定,因为C风格字符串使用的是istream类的方法,而string版本使用的是独立的函数,因此形式上有所区别,这种区别在其他运算符上也有体现,如>>操作符:
C 风格字符串使用:cin.operator>>(fname),而string风格为:operator(cin, fname);
说明:
string版本的getline()在如下三种情况下结束读取:
1 到达文件末尾:此时输入流中的eofbit置位;
2 遇到分割符:默认为 ,此时,删除流中的 ;
3 读取的字符个数达到最大值[min(string::npos, 空闲内存)],此时将输入流的failbit置位。
在输入流中有一个统计系统,用于跟踪流的状态:
1 检测到文件末尾,设置eofbit寄存器;
2 检测到错误,设置failbit寄存器;
3 检测到无法识别的故障,设置badbit寄存器;
4 检测到一切顺利,设置goodbit寄存器。
string 类对全部 6 个关系运算符进行了重载,对于每个关系运算符,又进行了3种重载,分别是:
string 对象与 string 对象;
string 对象 C 风格字符串;
C 风格字符串与 string 对象。
[2] 智能指针(smart pointer)
智能指针是行为类似于指针,但却是类。其可以帮助管理动态分配的内存,有三种可选:分别为auto_ptrunique_ptrshared_ptr。auto_ptr是C++ 98提供的,C++ 11已经抛弃了(虽然已经被抛弃,但是仍然被大量使用)。
小知识: 为何新标准要放弃auto_ptr?理由如下: 假设如下赋值: auto_ptr<string> ps1(new string(“benxintuzi”)); auto_ptr<string> ps2; ps2 = ps1; 如果ps2和ps1是普通指针,那么他们将同时指向一块堆内存,那么auto_ptr类型的指针若同时指向一块堆内存,那么就会调用两次delete,这个太可怕了,因此,auto_ptr采用的策略是如果发生赋值,那么就会令ps1为0,同样unique_ptr也是采用这种策略,但是更加严格。 如下,当ps2 = ps1,即ps1置空时,如果发生调用*ps1,那么相当于调用了一个空指针指向的对象,在auto_ptr情况下,可以编译通过,在运行时会出错;但在unique_ptr情况下,不会让你通过编译的。 结论就是unique_ptr比auto_ptr更安全一些。
shared_ptr对于每个堆对象,其维护一个指向同一对象的引用计数,只有当引用计数为0时才调用delete,因此可以很好地支持智能指针赋值操作。 |
要创建智能指针,必须包含头文件memory,然后使用模板语法实例化所需类型的指针,例如auto_ptr包含如下构造函数:
template<class X> class auto_ptr
{
public:
// throw()意味着不引发异常【C++ 11也将throw()抛弃了】
explicit auto_ptr(X* p = 0) throw();
...
}
因此,智能指针的使用非常简单,只需要用特定类型的指针初始化即可,如:
auto_ptr<double> pd(new double);
说明:
智能指针都放在名称空间std中(注意shared_ptr和unique_ptr都是C++ 11新增的,旧时的编译器可能不支持)。
1 #include <iostream> 2 #include <string> 3 #include <memory> 4 5 class Report 6 { 7 public: 8 Report(const std::string s) : str(s) 9 { 10 std::cout << "Object created!" << std::endl; 11 } 12 ~Report() 13 { 14 std::cout << "Object deleted!" << std::endl; 15 } 16 void comment() const 17 { 18 std::cout << "str = " << str << std::endl; 19 } 20 21 private: 22 std::string str; 23 }; 24 25 int main() 26 { 27 std::auto_ptr<Report> pa(new Report("using auto_ptr")); 28 pa->comment(); 29 30 std::shared_ptr<Report> ps(new Report("using shared_ptr")); 31 ps->comment(); 32 33 std::unique_ptr<Report> pu(new Report("using unique_ptr")); 34 pu->comment(); 35 36 return 0; 37 } 38 39 /** output */ 40 Object created! 41 str = using auto_ptr 42 Object created! 43 str = using shared_ptr 44 Object created! 45 str = using unique_ptr 46 Object deleted! 47 Object deleted! 48 Object deleted!
注意:
绝对不要将非堆内存指针赋予智能指针,否则虽然可以通过编译,但是情况并非总是乐观的,这就相当于delete了非堆内存,容易引发难以发现的问题。
关于如何选择合适的智能指针,如下给出参考建议:
如果需要多个指向同一堆对象的有效指针,那么选择使用shared_ptr。这种情况包括:
1 有一个指针数组,并且使用一些辅助指针标识特殊元素,如标识最值元素;
2 两个对象中都包含指向第三个对象的指针;
3 STL容器中的指针等,很多STL算法都支持复制和赋值操作。
如果程序不需要多个有效指针同时指向同一堆对象,那么使用unique_ptr。如果需要将unique_ptr作为右值时,可将其赋值给shared_ptr;在满足unique_ptr条件时,也可使用auto_ptr,但unique_ptr似乎是更好的选择(如果编译器不提供unique_ptr,可以使用boost库提供的scoped_ptr,其功能与unique_ptr类似)。
[3] 迭代器
[3.1] 迭代器基础
迭代器就是广义的指针,可对其进行递增操作和解引用操作等的对象。每个容器类都定义了一个与之相关的迭代器,该迭代器是一个名为iterator的typedef定义,作用域为整个类。模板使算法独立于数据类型,而迭代器使算法独立于容器类型。
迭代器主要用于遍历容器中的元素,其应该具有如下基本功能:
1 支持解引用操作
2 赋值操作
3 比较操作,如 ==、!=
4 自增操作
具备以上能力就差不多了。其实STL按照迭代器功能强弱定义了多种级别(5种)的迭代器,说明如下:
迭代器类型 |
说明 |
输入迭代器 |
【读容器】可来读取容器中的元素,但可能不会修改容器中的元素。输入迭代器必须可以访问容器中的所有元素,因此,支持++操作。 |
输出迭代器 |
【写容器】程序可以修改容器中的元素值,但不能读取容器中的元素。 |
正向迭代器 |
【读或者写容器】单向读写。 |
双向迭代器 |
【双向读或者写容器】双向读写。支持自减运算符。 |
随机访问迭代器 |
【双向读或者写容器】提供了附加的“跳步”访问能力。 |
迭代器支持的操作含义:
表达式 |
说明 |
a + n、n + a |
指向a所指元素后的第n个元素 |
a - n |
指向a所指元素前的第n个元素 |
r += n、r -= n |
r = r + n、r = r – n |
a[n] |
*(a + n) |
b - a |
a ~ b区间的元素个数 |
a < b、a > b、a >= b、a <= b |
逻辑判断 |
STL迭代器功能汇总:
总结:
迭代器支持的通常操作为解引用读或者写;所有类型的迭代器都支持自增操作;自减操作只有双向迭代器和随机访问迭代器支持;随机访问迭代器为“跳步”访问提供了可能。因此迭代器能力大小可以表示如下:
随机访问迭代器 > 双向迭代器 > 正向迭代器 > 输入迭代器 == 输出迭代器
[3.2] 迭代器进阶
迭代器是广义的指针,而指针满足所有迭代器的要求。因此STL算法可以使用指针来对基于指针的非STL容器进行操作。例如,可将STL算法用于数组:
如果要将一个double Receipts[100]进行排序,可以使用STL的算法sort,但传入的确是指针,如:
sort(Receipts, Receipts + 100);
STL提供了一些预定义的迭代器:copy()、ostream_iterator、istream_iterator。
假设有如下定义:
int casts[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
vector<int> dice(10);
copy(casts, casts + 10, dice.begin()); // 将[casts, casts + 10)范围内的数据复制到dice.begin()开始的目标空间中
输出流迭代器:
假设现在需要将数据复制到显示器上,那么需要一个表示输出流的迭代器,STL为我们提供了ostream_iterator模板。该迭代器是一个适配器,可将所有的接口转换为STL使用的接口。我们使用时必须包含头文件iterator,并且做出如下声明来创建该迭代器:
#include <iterator>
...
ostream_iterator<int, char> out_iter(cout, “ ”);
说明:
int: 表示发送到输出流中的数据类型;
char: 表示输出流使用的字符类型;
构造函数中,cout: 表示要使用的输出流;“ ”:表示所发送数据的分隔符;
可以这样使用迭代器:
*out_iter++ = 15; // 等价于cout << 15 << “ ”;
这条语句表明将”15 ”赋予指针指向的位置,然后指针向前移动一个单位。
实现如上的copy动作为:
copy(dice.begin(), dice.end(), out_iter)即可将dice容器的整个区间复制到显示器中显示。
当然也可以创建匿名的迭代器,如下:
copy(dice.begin(), dice.end(), ostream_iterator<int, char>(cout, “ ”));
输入流迭代器:
对于的输入流迭代器为istream_iter模板:
copy(istream_iterator<int, char>(cin), istream_iterator<int, char>(), ostream_iterator<int, char>(cout, “ ”));
说明:
int:要读取的数据类型;
char:输入流使用的数据类型;
构造函数中,第一个参数cin表示读取由cin管理的输入流;省略构造函数意味着输入失败,因此上述代码从输入流中读取int型数据,直到文件末尾、类型不匹配或者出现其他输入故障为止才输出到屏幕上。
1 #include <iostream> 2 #include <iterator> 3 using namespace std; 4 5 int main() 6 { 7 copy(istream_iterator<int, char>(cin), istream_iterator<int, char>(), 8 ostream_iterator<int, char>(cout, " ")); 9 return 0; 10 } 11 12 /** output */ 13 1 2 3 4 5 14 1 2 3 4 5 __
除了istream_iterator和ostream_iterator外,头文件iterator中还提供了一些专用的迭代器,如:reverse_iterator、back_insert_iterator、front_insert_iterator和insert_iterator。
reverse_iterator执行递增时,指针实际上发生递减操作。例如:vector类中的rbegin()和rend()分别返回指向最后一个元素下一位置的指针、指向第一个元素的指针。
强调:
虽然rbegin()和end()返回的指针虽然指向同一个位置,但是类型不同,前者类型是reverse_iterator,后者类型是iterator。
同样要注意的是:对于反向迭代的解引用的具体实现实则是先递减,再解引用。否则会出错。试想一下,如果一个rp是rbegin()返回的,直接解引用将导致操作一个空指针。
1 #include <iostream> 2 #include <iterator> 3 #include <vector> 4 using namespace std; 5 6 /* 7 int main() 8 { 9 copy(istream_iterator<int, char>(cin), istream_iterator<int, char>(), 10 ostream_iterator<int, char>(cout, " ")); 11 return 0; 12 } 13 */ 14 15 int main() 16 { 17 int casts[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 18 vector<int> dice(10); 19 copy(casts, casts + 5, dice.begin()); // 将casts的前5个数据复制到dice中 20 21 ostream_iterator<int, char> out_iter(cout, " "); // 创建输出流迭代器 22 copy(dice.begin(), dice.end(), out_iter); // 将dice中的全部元素复制到屏幕上输出 23 24 cout << endl; 25 26 /* 隐式使用reverse_iterator */ 27 copy(dice.rbegin(), dice.rend(), out_iter); // 将dice中的全部元素反向输出到屏幕上 28 29 cout << endl; 30 31 /* 显式使用reverse_iterator */ 32 vector<int>::reverse_iterator ri; 33 for(ri = dice.rbegin(); ri != dice.rend(); ++ri) 34 cout << *ri << " : "; 35 cout << endl; 36 37 return 0; 38 } 39 40 /** output */ 41 1 2 3 4 5 0 0 0 0 0 42 0 0 0 0 0 5 4 3 2 1 43 0 : 0 : 0 : 0 : 0 : 5 : 4 : 3 : 2 : 1 :
在形式上,STL中的很多算法都和copy函数类似,如下为三种插入迭代器操作:
back_insert_iterator将元素插入容器尾部;
front_insert_iterator将元素插入容器头部;
insert_iterator将元素插入指定位置。
插入操作相比于copy操作而言,可以自动增加空间,而copy确是静态分配好的空间,即使不够了也不会向操作系统去申请,默认情况下会截断后边的数据,只复制容量允许的数据。使用插入迭代器时,使用容器类型作为模板参数,使用容器变量作为构造参数,如下所述:
back_insert_iterator<vector<int>> back_iter(dice);
对于insert_iterator,还需要一个指定插入位置的构造参数:
insert_iterator<vector<int>> insert_iter(dice, dice.begin());
[4]容器类
容器用于存储对象,其要求所存储的对象必须具有相同的类型,而且该类型必须是可复制构造和可赋值的。一般基本类型和类类型都满足要求(当然除非你把这两种函数声明为私有或保护类型的)。C++ 11中又添加了可复制插入和可移动插入要求。
容器类型是用于创建具体容器的模板。之前共有11个容器类型:deque/list/queue/priority_queue/stack/vector/map/multimap/set/multiset/biset,C++ 11新增了5个:forward_list/unordered_map/unordered_multimap/unordered_set/unordered_multiset。
何为序列?
序列保证了元素将按特定的顺序排列,不会在两次迭代之间发生变化。序列还要求其元素严格按线性顺序排列,即存在第一个/第二个/.../等。比如数组和链表都是序列,但分支结构就不是序列。
由于序列中的元素具有特定的顺序,因此可以执行像插入元素到特定位置、删除特定区间等操作。如下容器都为序列容器:
vector |
vector是数组的一种类的表示,它提供了自动管理内存的功能,可以动态改变vector的长度,增大或减小。vector是可以反转的,主要是通过rbegin()和rend()实现的,并且其返回的迭代器类型都是reverse_iterator。 |
deque |
双端队列。其实现类似于vector,支持随机访问。主要区别在于可以从deque中开头和结尾处插入和删除元素,而且其时间复杂度固定。 |
list |
双向链表。与vector类似,list也可以反转。主要区别是:list不支持随机访问。除此之外,list模板类还包括了链表专用的成员函数,如下所示: void merge(list<T, Alloc>& x): 将链表x与调用链表合并,并且已然有序。合并后的链表保存在调用链表中,x为空。 void remove(const T& val): 从链表中删除val的所有实例。 void sort(): 使用<运算符对链表进行排序,时间复杂度为nlgn。 void splice(iterator pos, list<T, Alloc>x): 将链表x的内容插入到pos前边,插入后x为空。 void unique(): 将链表中连续的相同元素压缩为单个元素。 说明: insert()和splice()之间的主要区别在于:insert是插入原始区间的副本到目标地址,而splice是将原始区间转移到目标地址。 C++ 11新增了容器类forward_list,实现了单链表,与之关联的迭代器是正向迭代器而非双向迭代器。 |
queue |
queue模板类是一个适配器类,如前所述,ostream_iterator模板也是一个适配器,可以让输出流使用迭代器接口,同样,queue模板类让底层类(默认为deque)展示出队列接口。 queue模板的限制比deque更多。他不仅不允许随机访问,而且不允许遍历操作。其把使用限制在队列基本操作上,如入队、出队、取队首、判队空等,具体如下: bool empty() const: 如果队列为空则返回true;否则返回false。 size_type size() const: 返回队列中元素的数目。 T& front(): 返回指向队首元素的引用。 T& back(): 返回指向队尾元素的引用。 void push(const T& x): 在队尾插入x。 void pop(): 删除队首元素。 说明: priority_queue与queue的主要区别在于:最大元素被移到队首。其内部实现为vector,可以指定内部元素排序规则。 |
stack |
适配器类,使用vector实现,支持操作如下: bool empty() const: 如果栈为空则返回true;否则返回false。 size_type size() const: 返回栈中元素的数目。 T& top(): 返回指向栈顶元素的引用。 void push(const T& x): 在栈顶插入x。 void pop(): 删除栈顶元素。 |
array(C++ 11 新增) |
模板类array并非STL容器,因为其长度是固定的。因此不能使用动态调整容器大小的函数如push_back()和insert()等,但是其定义了很有用的成员函数,如operator[]()和at(),正如之前所述,许多标准的STL算法也可用于array对象,如:copy()和for_each()。 |
操作示例:
1 #include <iostream> 2 #include <list> 3 #include <iterator> 4 #include <algorithm> 5 using namespace std; 6 7 void PrintList(int n){ cout << n << " "; } 8 9 int main() 10 { 11 list<int> one(5, 2); // 5个2 12 cout << "list one: "; 13 for_each(one.begin(), one.end(), PrintList); 14 cout << endl; 15 16 list<int> two; 17 int stuff[3] = {2, 5, 9}; 18 two.insert(two.begin(), stuff, stuff + 3); 19 cout << "list two: "; 20 for_each(two.begin(), two.end(), PrintList); 21 cout << endl; 22 23 list<int> three(two); 24 three.insert(three.end(), one.begin(), one.end()); 25 cout << "list three: "; 26 for_each(three.begin(), three.end(), PrintList); 27 cout << endl; 28 29 cout << "merge one and three: "; 30 three.splice(three.begin(), one); 31 for_each(three.begin(), three.end(), PrintList); 32 cout << endl; 33 34 cout << "delete the duplicate elements: "; 35 three.unique(); 36 for_each(three.begin(), three.end(), PrintList); 37 cout << endl; 38 39 cout << "merge with another: four = "; 40 list<int> four(3, 8); 41 four.merge(three); 42 for_each(four.begin(), four.end(), PrintList); 43 cout << endl; 44 45 cout << "remove the value 8 in four: "; 46 four.remove(8); 47 for_each(four.begin(), four.end(), PrintList); 48 cout << endl; 49 50 return 0; 51 } 52 53 /** output */ 54 list one: 2 2 2 2 2 55 list two: 2 5 9 56 list three: 2 5 9 2 2 2 2 2 57 merge one and three: 2 2 2 2 2 2 5 9 2 2 2 2 2 58 delete the duplicate elements: 2 5 9 2 59 merge with another: four = 2 5 8 8 8 9 2 60 remove the value 8 in four: 2 5 9 2