【C++ Primer每日刷】之三 标准库 string 类型

标准库 string 类型

string 类型支持长度可变的字符串。C++ 标准库将负责管理与存储字符相关的内存，以及提供各种实用的操作。标准库string 类型的目的就是满足对字符串的一般应用。

与其它的标准库类型一样，用户程序要使用 string 类型对象。必须包括相关头文件。假设提供了合适的 using 声明，那么编写出来的程序将会变得简短些：

#include <string>

using std::string;

1.1 string 对象的定义和初始化

string 标准库支持几个构造函数。

构造函数是一个特殊成员函数。定义怎样初始化该类型的对象。表中列出了几个 string 类型经常使用的构造函数。当没有明白指定对象初始化式时。系统将使用默认构造函数。

几种初始化string 对象的方式：

string s1; 默认构造函数s1 为空串

string s2(s1); 将 s2初始化为 s1 的一个副本

string s3("value"); 将 s3 初始化为一个字符串字面值副本

string s4(n, 'c'); 将 s4 初始化为字符 'c' 的 n 个副本

1.2 string 对象的读写

我们已在前面学习了用 iostream 标准库来读写内置类型的值。如 int double 等。相同地，也能够用 iostream 和 string 标准库，使用标准输入输出操作符来读写 string 对象：

// Note: #include and using declarationsmust be added to compile this code

int main()

{

string s; // empty string

cin >> s; // readwhitespace-separated string into s

cout << s << endl; // write sto the output

return 0;

}

以上程序首先定义命名为 s 的string 第二行代码：

cin >> s; // readwhitespace-separated string into s

从标准输入读取 string 并将读入的串存储在 s 中。string 类型的输入操

作符：

• 读取并忽略开头全部的空白字符（如空格，换行符，制表符）。

• 读取字符直至再次遇到空白字符，读取终止。

假设给定和上一个程序相同的输入。则输出的结果是"HelloWorld!"（注意到开头和结尾的空格），则屏幕上将输出"Hello"。而不含不论什么空格。输入和输出操作的行为与内置类型操作符基本类似。

尤其是，这些操作符返回左操作数作为运算结果。因此，我们能够把多个读操作或多个写操作放在一起：

string s1, s2;

cin >> s1 >> s2; // read firstinput into s1, second into s2

cout << s1 << s2 << endl;// write both strings

假设给定和上一个程序相同的输入。则输出的结果将是：

HelloWorld!

对于上例，编译时必须加上 #include 来标示 iostream 和 string 标准库。以及给出用到的全部标准库中的名字（如 string。cin。cout，endl）的 using 声明。

读入未知数目的string 对象

和内置类型的输入操作一样，string 的输入操作符也会返回所读的数据流。因此，能够把输入操作作为推断条件。这与我们在 1.4.4 节读取整型数据的程序做法是一样的。以下的程序将从标准输入读取一组string 对象。然后在标准输出上逐行输出：

int main()

{

string word;

// read until end-of-file, writing eachword to a new line

while (cin >> word)

上例中。用输入操作符来读取 string 对象。

该操作符返回所读的 istream 对象，并在读取结束后，作为 while 的推断条件。假设输入流是有效的，即还未到达文件尾且未遇到无效输入，则运行 while 循环体。并将读取到的字符串输出到标准输出。假设到达了文件尾。则跳出while 循环。

使用getline 读取整行文本

另外另一个实用的 string IO 操作：getline。

这个函数接受两个參数：

一个输入流对象和一个 string 对象。

getline 函数从输入流的下一行读取，并保存读取的内容到不包含换行符。

和输入操作符不一样的是，getline 并不忽略行开头的换行符。

仅仅要 getline 遇到换行符。即便它是输入的第一个字符，getline 也将停止读入并返回。假设第一个字符就是换行符，则 string 參数将被置为空 string。

getline 函数将 istream參数作为返回值。和输入操作符一样也把它用作推断条件。比如，重写前面那段程序，把每行输出一个单词改为每次输出一行文本：

int main()

{

string line;

// read line at time until end-of-file

while (getline(cin, line))

cout << line << endl;

return 0;

}

因为 line 不含换行符，若要逐行输出须要自行加入。

照常，我们用 endl 来输出一个换行符并刷新输出缓冲区。

因为 getline 函数返回时丢弃换行符。换行符将不会存储

在 string 对象中。

1.3 string 对象的操作

s.empty() 假设 s 为空串，则返回 true。否则返回 false。

s.size() 返回 s 中字符的个数

s[n] 返回 s 中位置为 n 的字符，位置从 0 開始计数

s1 + s2 把 s1 和s2 连接成一个新字符串。返回新生成的字符串

s1 = s2 把 s1 内容替换为 s2 的副本

v1 == v2 比較 v1 与 v2 的内容，相等则返回 true，否则返回 false

!=, <, <=, >, and >= 保持这些操作符惯有的含义

string 的 size 和 empty 操作

string 对象的长度指的是string 对象中字符的个数，能够通过 size 操

作获取：

int main()

{

string st("The expense ofspirit\n");

cout << "The size of "<< st << "is " << st.size()

<< " characters, including thenewline" << endl;

return 0;

}

编译并执行这个程序，得到的结果为：

The size of The expense of spirit

is 22 characters, including the newline

了解 string 对象是否空是实用的。一种方法是将 size 与 0 进行比較：

if (st.size() == 0)

// ok: empty

本例中，程序猿并不须要知道 string 对象中有多少个字符，仅仅想知道 size 是否为 0。用 string的成员函数 empty() 能够更直接地回答这个问题：

if (st.empty())

// ok: empty

empty() 成员函数将返回bool（2.1 节），假设 string 对象为空则返

回 true 否则返回 false。

string::size_type 类型

从逻辑上来讲。size() 成员函数似乎应该返回整形数值。或如 2.2 节“建议”中所述的无符号整数。

但其实。size 操作返回的是 string::size_type 类型的值。

我们须要对这样的类型做一些解释。

string 类类型和更多库类型都定义了一些配套类型（companion type）。通过这些配套类型，库类型的使用就能与机器无关（machine-independent）。size_type 就是这些配套类型中的一种。它定义为与 unsigned 型（unsigned int 或 unsigned long）具有同样的含义，并且可以保证足够大可以存储随意 string 对象的长度。为了使用由 string 类型定义的
size_type 类型是由 string 类定义。

尽管我们不知道 string::size_type 的确切类型，但能够知道它是 unsigned 型（2.1.1 节）。对于随意一种给定的数据类型，它的 unsigned 型所能表示的最大正数值比相应的 signed 型要大。这个事实表明 size_type 存储的 string 长度是 int 所能存储的两倍。

使用 int 变量的还有一个问题是，有些机器上 int 变量的表示范围太小。甚至无法存储实际并不长的 string 对象。如在有 16 位 int 型的机器上。int 类型变量最大仅仅能表示 32767 个字符的 string 个字符的 string 对象。而能容纳一个文件内容的 string 对象轻易就会超过这个数字。因此。为了避免溢出。保存一个 stirng 对象 size 的最安全的方法就是使用标准库类型 string::size_type。

string 关系操作符

string 类定义了几种关系操作符用来比較两个 string 值的大小。

这些操作符实际上是比較每一个 string 。

string对象比較操作是区分大写和小写的。即同一个字符的大写和小写形式被觉得是两个不同的字符。在多数计算机上，大写的字母位于小写之前：不论什么一个大写之母都小于随意的小写字母。

== 操作符比較两个 string 对象，假设它们相等，则返回 true。两个 string 对象相等是指它们的长度同样，且含有同样的字符。标准库还定义了 != 操作符来測试两个 string 对象是否不等。关系操作符 <。<=，>，>= 分别用于測试一个 string 对象是否小于、小于或等于、大于、大于或等于还有一个 string 对象：

string big = "big", small ="small";

string s1 = big; // s1 is a copy of big

if (big == small) // false

// ...

if (big <= s1) // true, they're equal,so big is less than or

equal to s1

// ...

关系操作符比較两个 string 对象时採用了和（大写和小写敏感的）字典排序同样的策略：

• 假设两个 string 对象长度不同，且短的 string 对象与长的 string 对

象的前面部分相匹配。则短的 string 对象小于长的 string 对象。

• 假设 string 对象的字符不同，则比較第一个不匹配的字符。string

举例来说，给定 string 对象；

string substr = "Hello";

string phrase = "Hello World";

string slang = "Hiya";

则 substr 小于 phrase，而 slang 则大于 substr 或phrase

string 对象的赋值

整体上说。标准库类型尽量设计得和基本数据类型一样方便易用。因此。大多数库类型支持赋值操作。对 string 对象来说。能够把一个 string 对象赋值给还有一个 string 对象；

// st1 is an empty string, st2 is a copy ofthe literal

string st1, st2 = "The expense ofspirit";

st1 = st2; // replace st1 by a copy of st2

赋值操作后，st1 就包括了 st2 串全部字符的一个副本。

大多数 string 库类型的赋值等操作的实现都会遇到一些效率上的问题。但

值得注意的是。从概念上讲，赋值操作确实须要做一些工作。它必须先把 st1 占

用的相关内存释放掉。然后再分配给 st2 足够存放 st2 副本的内存空间。最后

把 st2 中的全部字符拷贝到新分配的内存空间。

两个string 对象相加

多个）string 对象能够通过使用加操作符 + 或者复合赋值操作符 +=

（1.4.1 节）连接起来。

给定两个string 对象：

string s1("hello, ");

string s2("world\n");

以下把两个 string 对象连接起来产生第三个 string 对象：

string s3 = s1 + s2; // s3 is hello,world\n

假设要把 s2 直接追加到 s1 的末尾，能够使用 += 操作符：

s1 += s2; // equivalent to s1 = s1 + s2

和字符串字面值的连接

上面的字符串对象 s1 和 s2 直接包括了标点符号。

也能够通过

将 string 对象和字符串字面值混合连接得到相同的结果：

string s1("hello");

string s2("world");

string s3 = s1 + ", " + s2 +"\n";

当进行 string 对象和字符串字面值混合连接操作时，+ 操作符的左右操作

数必须至少有一个是 string 类型的：

string s1 = "hello"; // nopunctuation

string s2 = "world";

string s3 = s1 + ", "; // ok:adding a string and a literal

string s4 = "hello" + ","; // error: no string operand

string s5 = s1 + ", " +"world"; // ok: each + has string operand

string s6 = "hello" + "," + s2; // error: can't add string literals

s3 和 s4 的初始化仅仅用了一个单独的操作。在这些样例中，非常easy推断 s3 的初始化是合法的：把一个 string 对象和一个字符串字面值连接起来。而 s4 的初始化试图将两个字符串字面值相加，因此是非法的。

s5 的初始化方法显得有点不可思议，但这样的使用方法和标准输入输出的串联效果是一样的（1.2 节）。本例中，string 标准库定义加操作返回一个 string 对象。这样，在对 s5 进行初始化时。子表达式 s1 + ", " 将返回一个新 string 对象，后者再和字面值 "world\n"连接。整个初始化过程能够改写为：

string tmp = s1 + ", "; // ok: +has a string operand

s5 = tmp + "world"; // ok: + hasa string operand

而 s6 的初始化是非法的。依次来看每一个子表达式。则第一个子表达式试图

把两个字符串字面值连接起来。

这是不同意的，因此这个语句是错误的。

从string 对象获取字符

string 类型通过下标操作符（[]）来訪问 string 对象中的单个字符。下

标操作符须要取一个 size_type 类型的值，来标明要訪问字符的位置。这个下

标中的值通常被称为“下标”或“索引”（index）

string 对象的下标从 0 開始。假设 s 是一个 string 对象且 s 不空。则s[0] 就是字符串的第一个字符， s[1] 就表示第二个字符（假设有的话），而 s[s.size() - 1] 则表示 s 的最后一个字符。

引用下标时假设超出下标作用范围就会引起溢出错误。可用下标操作符分别取出string 对象的每一个字符，分行输出：

string str("some string");

for (string::size_type ix = 0; ix != str.size(); ++ix)

cout << str[ix] << endl;

每次通过循环，就从 str 对象中读取下一个字符，输出该字符并换行。

下标操作可用作左值

前面说过，变量是左值，且赋值操作的左操作的必须是左值。

和变量一样，string 对象的下标操作返回值也是左值。因此，下标操作能够放

于赋值操作符的左边或右边。通过以下循环把 str 对象的每个字符置

为 ‘*’：

for (string::size_type ix = 0; ix !=str.size(); ++ix)

str[ix] = '*';

计算下标值

不论什么可产生整型值的表达式可用作下标操作符的索引。比如。如果 someval 和 someotherval 是两个整形对象。能够这样写：

str[someotherval * someval] = someval;

尽管不论什么整型数值都可作为索引，但索引的实际数据类型却是类型 unsigned 类型

string::size_type。

前面讲过。应该用 string::size_type 类型的变量接受 size 函数的返回值。在定义用作索引的变量时。出于相同的道理。string 对象的索引变量最好也用 string::size_type 类型。

在使用下标索引 string 对象时。必须保证索引值“在上下界范围内”。“在上下界范围内”就是指索引值是一个赋值为 size_type 类型的值。其取值范围在 0 到 string 对象长度减 1 之间。使用 string::size_type 类型或其它 unsigned 类型，就仅仅须要检測它是否小于 string 对象的长度。标准库不要求检查索引值，所用索引的下标越界是未定义的。这样往往会导致严重的执行时错误。

 

1.4 string 对象中字符的处理

我们常常要对 string 对象中的单个字符进行处理，比如。通常须要知道某个特殊字符是否为空白字符、字母或数字。表 3.3 列出了各种字符操作函数，适用于 string 对象的字符（或其它不论什么 char 值）。

这些函数都在 cctype 头文件里定义。

isalnum(c) 假设 c 是字母或数字。则为 True。

isalpha(c) 假设 c 是字母，则为 true。

iscntrl(c) 假设 c 是控制字符，则为 true

isdigit(c) 假设 c 是数字。则为 true。

isgraph(c) 假设 c 不是空格，但可打印。则为 true。

islower(c) 假设 c 是小写字母，则为 true。

isprint(c) 假设 c 是可打印的字符，则为 true。

ispunct(c) 假设 c 是标点符号，则 true。

isspace(c) 假设 c 是空白字符。则为 true。

isupper(c) 假设 c 是大写字母。则 true。

isxdigit(c) 假设是 c 十六进制数，则为 true。

tolower(c) 假设 c 大写字母，返回其小写字母形式，否则直接返回 c。

toupper(c) 假设 c 是小写字母，则返回其大写字母形式，否则直接返回 c。

表中的大部分函数是測试一个给定的字符是否符合条件，并返回一个 int 作为真值。假设測试失败，则该函数返回 0 ，否则返回一个（无意义的）非 0 ，表示被測字符符合条件。

表中的这些函数，可打印的字符是指那些能够表示的字符，空白字符则是空格、制表符、垂直制表符、回车符、换行符和进纸符中的随意一种；标点符号则是除了数字、字母或（可打印的）空白字符（如空格）以外的其它可打印字符。

这里给出一个样例。运用这些函数输出一给定 string 对象中标点符号的个数：

string s("Hello World!!!");

string::size_type punct_cnt = 0;

// count number of punctuation charactersin s

for (string::size_type index = 0; index !=s.size(); ++index)

if (ispunct(s[index]))

++punct_cnt;

cout << punct_cnt

<< " punctuation characters in" << s << endl;

这个程序的输出结果是：

3 punctuation characters in Hello World!!!

和返回真值的函数不同的是，tolower 和 toupper 函数返回的是字符，返

回实參字符本身或返回该字符对应的大写和小写字符。我们能够用 tolower 函数

把 string 对象 s 中的字母改为小写字母，程序例如以下：

// convert s to lowercase

for (string::size_type index = 0; index !=s.size(); ++index)

s[index] = tolower(s[index]);

cout << s << endl;

得到的结果为：

hello world!!!

建议：採用 C 标准库头文件的 C++ 版本号

C++ 标准库除了定义了一些选定于C++ 的设施外。还包含 C 标准库。C++ 中的头文件 cctype 事实上就是利用了 C 标准库函数，这些库函数就定义在 C 标准库的 ctype.h 头文件里。

C 标准库头文件命名形式为 name 而C++ 版本号则命名为 cname ，少了后缀，.h 而在头文件名称前加了 c 表示这个头文件源自 C 标准库。

因此。cctype 与 ctype.h 文件的内容是一样的，仅仅是採用了更适合
C++程序的形式。

特别地。cname 头文件里定义的名字都定义在命名空间 std 内。而 .h 版本号中的名字却不是这样。

通常，C++ 程序中应採用 cname这样的头文件的版本号。而不採用 name.h 版本号，这样，标准库中的名字在命名空间 std 中保持一致。

使用 .h 版本号会给程序猿带来负担，由于他们必须记得哪些标准库名字是从 C 继承来的，而哪些是 C++ 所特有的。