【C++】string类的使用①（默认成员函数 || 迭代器接口begin，end，rbegin和rend）

🔥个人主页： Forcible Bug Maker
🔥专栏： STL || C++

目录

• 前言
• 🌈关于string类
• 🌈string类的成员函数
• • 🔥默认成员函数
  • • ==string类对象的构造(constructor)==
    • ==string类对象的析构==
    • ==string类对象的赋值运算符重载==
  • 🔥迭代器接口（iterators）
  • • ==begin==
    • ==end==
    • ==rbegin==
    • ==rend==
    • ==cbgin，cend，erbegin和crend==
• 结语

前言

本篇博客主要内容：STL库中string类的默认成员函数和各种迭代器接口的介绍和使用。

在开始我们string类使用接口的讲解之前，想先讲讲为什么我们要学习string类。在C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

简单说，string就是C++STL标准库中便于维护和操作字符串的一个类。

学习STL过程中，我们主要参考这个网站中的文档：https://cplusplus.com，虽然里面的内容是全英的，但是不用担心，我会带着大家一一去翻译并讲解其中的接口。

🌈关于string类

字符串是表示字符序列的类。

标准的字符串提供了此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。

string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数(关于模板更多的信息，请参考basic_string)。

请注意，这个类独立于所使用的编码来处理字节：如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

对以上文字做一个总结：

1. string是表示字符串的类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string类再底层实际是：basic_string模板类的别名，typedef basic_string<char,char_traits,alloctor> string;
4. 不能操作多字节或变长字节的序列。
   在使用string类时，必须包含相应头文件#include<string>以及using namespace std;

🌈string类的成员函数

C++STL库的string类中重载的成员函数非常之多，但并不是每个接口都有着其必要性。string类是C++中最先被开发和实验的类，由于向前兼容等各种原因，其实其中也不免存在一些函数的冗余，在上百个重载的接口中，真正常用的也就是那十几二十个。对于一些相同道理的重载，我会做简单解释而不会展开讲，避免文章内容的冗余。

🔥默认成员函数

string类对象的构造(constructor)

string类提供了七种方式的重载用于构造string类对象。
（1）无参构造（默认构造）
string();

构造出一个空的string，里面存储0个字符元素。
（2）拷贝构造
string(const string& str);

构造出一个和str对象内容相同的拷贝对象。
（3）字串构造
string (const string& str, size_t pos, size_t len = npos);

拷贝str从pos位置开始跨越len个长度的元素到新创建的对象中（如果字符串太短 或未提供第三个参数 ，直接从pos位置拷贝到字符串的末尾 ）。
（4）通过字符串构造
string (const char* s);

通过s指向的以 空字符('\0') 结尾的字符串创建新的string类型的对象。
（5）通过部分字符串构造
string (const char* s, size_t n);

从s指向的字符串中拷贝前n个字符创建新的string类型的对象。
（6）字符填充构造
string (size_t n, char c);

用连续的n个c构成的串创建string类型的对象。
（7）迭代器区间构造
template <class InputIterator>
string (InputIterator first, InputIterator last);

通过迭代器区间 [first,last) 之间的元素，创建顺序相同的新string对象。

你现在可能不知道迭代器是什么，不过你可以先将它理解成是一种指针，指向string中的元素，可以通过++或--来改变这种指针的指向。

使用样例：

// string类的构造
#include <iostream>
#include <string>
// 由于下面使用了std::，所以此处不用命名空间展开
int main()
{
	std::string s0("Initial string");

	// constructors used in the same order as described above:
	std::string s1;
	std::string s2(s0);
	std::string s3(s0, 8, 3);
	std::string s4("A character sequence");
	std::string s5("Another character sequence", 12);
	std::string s6a(10, 'x');
	std::string s6b(10, 42);      // 42是字符'*'的ASCII码值
	std::string s7(s0.begin(), s0.begin() + 7);
	
	// 打印构造出来的字符串内容，这里重载了流插入>>和流提取<<运算符。
	std::cout << "s1: " << s1 << "\ns2: " << s2 << "\ns3: " << s3;
	std::cout << "\ns4: " << s4 << "\ns5: " << s5 << "\ns6a: " << s6a;
	std::cout << "\ns6b: " << s6b << "\ns7: " << s7 << '\n';
	return 0;
}

string类对象的析构

如你所见，析构只有一种，之前在类和对象篇已经讲过了，析构函数是不能重载的。

析构函数编译器会自动调用，释放资源，所以就不需要你操心了。

string类对象的赋值运算符重载

string类提供了三种赋值运算符重载，用于给已经创建好的对象赋值。
（1）string对象赋值
string& operator=(const string& str);

将str的内容拷贝到被赋值的对象中。

返回值：被赋值对象（*this）的引用。
（2）字符串赋值
string& operator=(const char* s);

通过一个已有的字符串给string赋值，其实不重载此函数也可以达到效果（隐式类型转换），但是考虑到隐式类型转换是有效率损耗的，故标准库中还是重载了此成员函数。

返回值：被赋值对象（*this）的引用。
（3）字符赋值
string& operator=(char c);

将字符直接赋值给串。

返回值：被赋值对象（*this）的引用。

使用样例：

#include <iostream>
#include <string>
using namespace std;
int main()
{
	std::string str1, str2, str3;
	str1 = "Test string. ";   // c-string
	str2 = str1; //string
	str3 = 'x'; //char

	cout << str1 << endl;
	cout << str2 << endl;
	cout << str3 << endl;
	return 0;
}

🔥迭代器接口（iterators）

什么是迭代器接口，就是成员函数返回迭代器的接口，也就是获取迭代器的方法。

我们可以先将迭代器想象成指向容器元素的指针，而这些成员函数的作用就是让我们获取这些指针。同时我们可以通过+，-，++或--等运算符调整这种指针的指向。

begin

iterator begin();
const_iterator begin() const;

这两个成员函数都返回一个指向string串中第一个元素的正向迭代器。

end

iterator end();
const_iterator end() const;

这两个成员函数都返回一个指向string串中最后一个元素下一位的正向迭代器。

使用样例：

// string::begin/end
#include <iostream>
#include <string>
using namespace std;
int main()
{
    std::string str("Test string");
    string::iterator it = str.begin();
    for (; it != str.end(); ++it)
        cout << *it;
    cout << endl;

    return 0;
}

string的迭代器（iterator）是一个定义在string类内部的一个类型，它能指向string对象的元素，而迭代器的对象可以通过string提供的成员函数获取。上述代码案例中的迭代器it被我们称为正向迭代器，++使其向后移动指向下一元素，--使其向前移动指向上一元素 。

而接下来我们要讲的rbegin和rend，是获取反向迭代器的两个接口函数。

rbegin

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

这两个成员函数都返回一个指向string串中最后一个元素的反向迭代器。

rend

reverse_iterator rend();
const_reverse_iterator rend() const;

这两个成员函数都返回一个指向string串中第一个元素上一位的反向迭代器。

使用样例：

// string::rbegin/rend
#include <iostream>
#include <string>
using namespace std;
int main()
{
    string str("now step live...");
    string::reverse_iterator rit = str.rbegin();
    for (; rit != str.rend(); ++rit)
        cout << *rit;
    cout << endl;

    return 0;
}

同理，string的反向迭代器（reverse_iterator）是一个定义在string类内部的一个类型，它能指向string对象的元素，而反向迭代器的对象可以通过string提供的成员函数获取。反向迭代器，++使其向前移动指向上一元素，--使其后前移动指向下一元素。

cbgin，cend，erbegin和crend

这几个作为C++11新增语法，专门提供了获取const类型的四种迭代器接口，使迭代器可以读，但不能通过迭代器解引用更改串中的内容。这里就不多做赘述。

结语

本篇博客讲了关于string类构造的七种重载，赋值运算符的三种重载，以及各种string迭代器接口的使用。后面博主会继续分享关于string类的使用以及STL更多的内容，感谢大家的支持。♥