码迷，mamicode.com
首页 > 编程语言 > 详细

C++001--字符串

时间：2016-04-22 19:00:38      阅读：241      评论：0      收藏：0      [点我收藏+]

标签：


1.字符串的基本用法

1.1 问题

字符串的基本用法主要是指字符串类对象的定义与初始化方法。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符串的实例化

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str;
  7.     std::string str1("Hello World!");
  9.     std::string str2 = std::string();
  10.     std::string str3 = std::string("Hello World!");
  11.     
  12.     std::string *pstr = new std::string;
  13.     std::string *pstr1 = new std::string();
  14.     std::string *pstr2 = new std::string("Hello World!");
  15.     
  16.     return 0;
  17. }

上述代码中，以下代码：

  1.     std::string str;
  2.     std::string str1("Hello World!");

是在栈中隐式实例化字符串类，第一条语句在栈上定义了一个空的字符串对象；第二条语句在栈上定义了一个字符串对象，然后调用构造函数对其进行初始化。

上述代码中，以下代码：

  1.     std::string str2 = std::string();
  2.     std::string str3 = std::string("Hello World!");

是在栈中显式实例化字符串类，第一条语句在栈上定义了一个空的字符串对象，然后将一个空的字符串临时对象初始化给它；第二条语句同样在栈上定义了一个空的字符串对象，然后将一个初始化好的临时字符串对象赋值给它。

上述代码中，以下代码：

  1.     std::string *pstr = new std::string;
  2.     std::string *pstr1 = new std::string();
  3.     std::string *pstr2 = new std::string("Hello World!");

是在堆中实例化字符串类，然后用字符串指针指向它。

步骤二：C++字符串与C字符串关系

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str;
  7.     std::string str1("Hello World!");//栈中隐式初始化
  9.     std::string str2 = std::string();
  10.     std::string str3 = std::string("Hello World!");//栈中显式初始化
  11.     
  12.     std::string *pstr = new std::string;
  13.     std::string *pstr1 = new std::string();
  14.     std::string *pstr2 = new std::string("Hello World!");//堆中初始化，字符串指针指向它
  15.     
  16.     std::string str4 = "Hello World!";
  17.     
  18.     char const *pc = "Hello World!";
  19.     std::string str5 = pc;
  20.     
  21.     char sa[] = "Hello World!";
  22.     std::string str6 = sa;
  23.     
  24.     char const *pc1 = str6.c_str();
  25.     
  26.     return 0;
  27. }

上述代码中，以下代码：

  1.     std::string str4 = "Hello World!";

可以将一个C语言的字符串直接赋值给一个C++的字符串。

上述代码中，以下代码：

  1.     char const *pc = "Hello World!";
  2.     std::string str5 = pc;
  3.     
  4.     char sa[] = "Hello World!";
  5.     std::string str6 = sa;

可以将一个字符指针或一个字符数组赋值给一个C++的字符串。

上述代码中，以下代码：

  1.     char const *pc1 = str6.c_str();

如果希望用字符指针指向C++的字符串，则需要调用字符串类中的c_str()函数，该函数能够返回字符串对象中所存储的字符串数据在内存的地址。

14.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str;
  7.     std::string str1("Hello World!");
  9.     std::string str2 = std::string();
  10.     std::string str3 = std::string("Hello World!");
  11.     
  12.     std::string *pstr = new std::string;
  13.     std::string *pstr1 = new std::string();
  14.     std::string *pstr2 = new std::string("Hello World!");
  15.     
  16.     std::string str4 = "Hello World!";
  17.     
  18.     char const *pc = "Hello World!";
  19.     std::string str5 = pc;
  20.     
  21.     char sa[] = "Hello World!";
  22.     std::string str6 = sa;
  23.     
  24.     char const *pc1 = str6.c_str();
  25.     
  26.     return 0;
  27. }

2 字符串的基本运算

15.1 问题

字符串的基本运算主要包括字符串的拼接、赋值和关系运算。

2.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符串的拼接

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello ";
  7.     std::string str2 = "World!";
  8.     std::string str3 = str1 + str2;
  9.     
  10.     return 0;
  11. }

上述代码中，以下代码：

  1.     std::string str3 = str1 + str2;

是将字符串str2的内容拼接到字符串str1的最后一个字符后面，形成一个更大的字符串，赋值给str3。

步骤二：字符串的赋值

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello ";
  7.     std::string str2 = "World!";
  8.     std::string str3 = str1 + str2;
  9.     
  10.     std::string str4 = "Hello ";
  11.     std::string str5 = "World!";
  12.     std::string str6;
  13.     str6 = str5;
  14.     str4 += str5;
  15.     
  16.     return 0;
  17. }

上述代码中，以下代码：

  1.     str6 = str5;

是实现字符串对象间的相互赋值，将str5赋值给str6。

上述代码中，以下代码：

  1.     str4 += str5;

是实现字符串对象间的复合赋值，本语句实现的是将str4与str5拼接后在赋值给str4。

步骤三：字符串的关系运算

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello ";
  7.     std::string str2 = "World!";
  8.     std::string str3 = str1 + str2;
  9.     
  10.     std::string str4 = "Hello ";
  11.     std::string str5 = "World!";
  12.     std::string str6;
  13.     str6 = str5;
  14.     str4 += str5;
  15.     
  16.     std::string str7 = "zhangfei";
  17.     std::string str8 = "zhaoyun";
  18.     if (str7 == str8)
  19.         std::cout << str7 << "==" << str8 << std::endl;
  20.     else if (str7 < str8)
  21.         std::cout << str7 << "<" << str8 << std::endl;
  22.     else
  23.         std::cout << str7 << ">" << str8 << std::endl;
  24.     
  25.     return 0;
  26. }

上述代码中，以下代码：

  1.     if (str7 == str8)

是判断字符串str7与str8是否相等，其判断的方法是将两个字符串的对应字符进行比较，如果相同则比较下一个对应字符，直到有不同或两个字符串同时结束为止。本例中str7与str8的第一对对应字符是z，第二对对应字符是h，第三对对应字符是a，第四对对应字符是n和o，依次类推。

注意：对应字符进行比较时，是区分大小写的，即a和A是两个不同的字符。

15.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello ";
  7.     std::string str2 = "World!";
  8.     std::string str3 = str1 + str2;
  9.     
  10.     std::string str4 = "Hello ";
  11.     std::string str5 = "World!";
  12.     std::string str6;
  13.     str6 = str5;
  14.     str4 += str5;
  15.     
  16.     std::string str7 = "zhangfei";
  17.     std::string str8 = "zhaoyun";
  18.     if (str7 == str8)
  19.         std::cout << str7 << "==" << str8 << std::endl;
  20.     else if (str7 < str8)
  21.         std::cout << str7 << "<" << str8 << std::endl;
  22.     else
  23.         std::cout << str7 << ">" << str8 << std::endl;
  24.     
  25.     return 0;
  26. }

3 字符串的大小和容量

3.1 问题

字符串的大小或长度是指该字符串实际容纳的字符数，而字符串的容量是该字符串最多容纳的字符数。

3.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符串的大小

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1.size() << std::endl;
  8.     std::cout << str1.length() << std::endl;
  9.     
  10.     str1.resize(20, ‘a‘);
  11.     std::cout << str1 << std::endl;
  12.     
  13.     return 0;
  14. }

上述代码中，以下代码：

  1.     std::cout << str1.size() << std::endl;
  2.     std::cout << str1.length() << std::endl;

中的size()和length()成员函数都能获得字符串实际容纳的字符数，length()函数是较早版本的，size()是为了和容器类保持一致新添加的。

上述代码中，以下代码：

  1.     str1.resize(20, ‘a‘);

是用来更改字符串实际容纳的字符数的，当第一个参数小于原字符串实际容纳的字符数时，字符串将只保留第一个参数指定的前几个字符，当第一个参数大于原字符串实际容纳的字符数时，字符串多出来的空间将有第二个参数填补。

步骤二：字符串的容量

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1.size() << std::endl;
  8.     std::cout << str1.length() << std::endl;
  9.     
  10.     str1.resize(20, ‘a‘);
  11.     std::cout << str1 << std::endl;
  12.     
  13.     std::cout << str1.capacity() << std::endl;
  14.     str1.reserve(50);
  15.     std::cout << str1.capacity() << std::endl;
  16.     
  17.     return 0;
  18. }

上述代码中，以下代码：

  1.     std::cout << str1.capacity() << std::endl;

获取的是字符串最多容纳的字符数。由于字符串可以动态改变，所以在向字符串添加字符时，字符串会变长，但不是添加一个字符就只变长一个字节，而是变长单位长度的字节数，这样做的好处是避免频繁内存操作，提高效率。

上述代码中，以下代码：

  1.     str1.reserve(50);

可以指定字符串的容量。

16.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1.size() << std::endl;
  8.     std::cout << str1.length() << std::endl;
  9.     
  10.     str1.resize(20, ‘a‘);
  11.     std::cout << str1 << std::endl;
  12.     
  13.     std::cout << str1.capacity() << std::endl;
  14.     str1.reserve(50);
  15.     std::cout << str1.capacity() << std::endl;
  16.     
  17.     return 0;
  18. }

4 字符串拼接

4.1 问题

字符串拼接是指将两个字符串连接在一起，形成一个更长的字符串。

4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符串拼接

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello ";
  7.     std::string str2 = "World!";
  8.     str1.append(str2);
  9.     std::cout << str1 << std::endl;
  10.     
  11.     std::string str3 = "Hello ";
  12.     std::string str4 = "Hello World!";
  13.     str3.append(str4, 6, 6);
  14.     std::cout << str3 << std::endl;
  15.     
  16.     std::string str5 = "Hello ";
  17.     str5.append(10, ‘A‘);
  18.     std::cout << str5 << std::endl;
  19.     
  20.     return 0;
  21. }

上述代码中，以下代码：

  1.     str1.append(str2);

将字符串str2拼接到字符串str1的后面。

上述代码中，以下代码：

  1.     str3.append(str4, 6, 6);

将字符串str4的第6字符开始的连续6个字符，拼接到字符串str3的后面。该函数的第二个参数是从第一个参数的第几个字符开始计算，注意从0开始计算；第三个参数是从第二个参数开始的连续几个字符被拼接。

上述代码中，以下代码：

  1.     str5.append(10, ‘A‘);

将10个A拼接到字符串str5的后面。

17.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello ";
  7.     std::string str2 = "World!";
  8.     str1.append(str2);
  9.     std::cout << str1 << std::endl;
  10.     
  11.     std::string str3 = "Hello ";
  12.     std::string str4 = "Hello World!";
  13.     str3.append(str4, 6, 6);
  14.     std::cout << str3 << std::endl;
  15.     
  16.     std::string str5 = "Hello ";
  17.     str5.append(10, ‘A‘);
  18.     std::cout << str5 << std::endl;
  19.     
  20.     return 0;
  21. }

5 在字符串中搜索特定字符

5.1 问题

在字符串中搜索特定字符是指在字符串中寻找是否存在指定的字符或字符集。

5.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：正向查找

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1.find_first_of(‘o‘) << std::endl;
  8.     std::string str2 = "World!";
  9.     std::cout << str1.find_first_of(str2) << std::endl;
  10.     std::cout << str1.find_first_not_of(‘o‘) << std::endl;
  11.     std::cout << str1.find_first_not_of(str2) << std::endl;
  13.     return 0;
  14. }

上述代码中，以下代码：

  1.     std::cout << str1.find_first_of(‘o‘) << std::endl;

是在字符串str1中查找是否存在字符o，如果存在，则返回字符串中第一个o的位置。

上述代码中，以下代码：

  1.     std::cout << str1.find_first_of(str2) << std::endl;

是在字符串str1中查找是否存在字符集str2中的字符，如果存在，则返回字符串中第一个字符集str2中有的字符的位置。

上述代码中，以下代码：

  1.     std::cout << str1.find_first_not_of(‘o‘) << std::endl;

是在字符串str1中查找第一个与字符o不相同的字符的位置。

上述代码中，以下代码：

  1.     std::cout << str1.find_first_not_of(str2) << std::endl;

是在字符串str1中查找第一个与字符集str2中字符不相同的字符的位置。

步骤二：反向查找

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1.find_first_of(‘o‘) << std::endl;
  8.     std::string str2 = "World!";
  9.     std::cout << str1.find_first_of(str2) << std::endl;
  10.     std::cout << str1.find_first_not_of(‘o‘) << std::endl;
  11.     std::cout << str1.find_first_not_of(str2) << std::endl;
  12.     
  13.     std::cout << str1.find_last_of(‘o‘) << std::endl;
  14.     std::cout << str1.find_last_of(str2) << std::endl;
  15.     std::cout << str1.find_last_not_of(‘o‘) << std::endl;
  16.     std::cout << str1.find_last_not_of(str2) << std::endl;
  17.     
  18.     return 0;
  19. }

上述代码中，以下代码：

  1.     std::cout << str1.find_last_of(‘o‘) << std::endl;

是在字符串str1中查找是否存在字符o，如果存在，则返回字符串从后向前查找的第一个o的位置。

上述代码中，以下代码：

  1.     std::cout << str1.find_first_of(str2) << std::endl;

是在字符串str1中查找是否存在字符集str2中的字符，如果存在，则返回字符串中从后向前查找的第一个字符集str2中有的字符的位置。

上述代码中，以下代码：

  1.     std::cout << str1.find_first_not_of(‘o‘) << std::endl;

是在字符串str1中从后向前查找的第一个与字符o不相同的字符的位置。

上述代码中，以下代码：

  1.     std::cout << str1.find_first_not_of(str2) << std::endl;

是在字符串str1中从后向前查找的第一个与字符集str2中字符不相同的字符的位置。

18.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1.find_first_of(‘o‘) << std::endl;
  8.     std::string str2 = "World!";
  9.     std::cout << str1.find_first_of(str2) << std::endl;
  10.     std::cout << str1.find_first_not_of(‘o‘) << std::endl;
  11.     std::cout << str1.find_first_not_of(str2) << std::endl;
  12.     
  13.     std::cout << str1.find_last_of(‘o‘) << std::endl;
  14.     std::cout << str1.find_last_of(str2) << std::endl;
  15.     std::cout << str1.find_last_not_of(‘o‘) << std::endl;
  16.     std::cout << str1.find_last_not_of(str2) << std::endl;
  17.     
  18.     return 0;
  19. }

6 从字符串中提取子字符串

6.1 问题

从字符串中提取子字符串是指将一个字符串中的一部分截取下来形成一个新的字符串。

6.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：截取子串

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::string str2(str1, 0, 6);
  8.     std::cout << str2 << std::endl;
  9.     
  10.     std::string str3 = str1.substr(6, 6);
  11.     std::cout << str3 << std::endl;
  12.    
  13.     return 0;
  14. }

上述代码中，以下代码：

  1.     std::string str2(str1, 0, 6);

定义一个新的字符串str2，其内容被初始化成字符串str1的第0个字符开始的连续6个字符。第二个参数是从第一个参数的第几个字符开始截取，第三个参数是连续截取几个字符。

上述代码中，以下代码：

  1.     std::string str3 = str1.substr(6, 6);

是在字符串str1中截取第6个字符开始的连续6个字符作为一个新的字符串，赋值给str3。第一个参数是从str1的第几个字符开始截取，第二个参数是连续截取几个字符。

19.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::string str2(str1, 0, 6);
  8.     std::cout << str2 << std::endl;
  9.     
  10.     std::string str3 = str1.substr(6, 6);
  11.     std::cout << str3 << std::endl;
  12.    
  13.     return 0;
  14. }

7 访问字符串中的单个字符

7.1 问题

访问字符串中的单个字符是像字符数组那样使用下标访问字符串中的某个元素。

7.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：访问字符串中的单个字符

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1[2] << std::endl;
  8.     std::cout << str1[20] << std::endl;
  9.     
  10.     std::cout << str1.at(6) << std::endl;
  11.     std::cout << str1.at(20) << std::endl;
  12.     
  13.     return 0;
  14. }

上述代码中，以下代码：

  1.     std::cout << str1[2] << std::endl;

是像访问字符数组那样，将字符串中的第2个字符提取出来显示。值得注意的是如果下标越界，如下代码所示：

  1.     std::cout << str1[20] << std::endl;

不会报告错误。

上述代码中，以下代码：

  1.     std::cout << str1.at(6) << std::endl;

是使用成员函数来获得字符串中的第6个字符并显示。值得注意的是如果参数越界，如下代码所示：

  1.     std::cout << str1.at(20) << std::endl;

函数将抛出异常。

7.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1[2] << std::endl;
  8.     std::cout << str1[20] << std::endl;
  9.     
  10.     std::cout << str1.at(6) << std::endl;
  11.     std::cout << str1.at(20) << std::endl;
  12.     
  13.     return 0;
  14. }

8 字符串的查找与替换

8.1 问题

字符串的查找是指查看在字符串中是否有另一个指定的子串。字符串的替换是指将字符串中指定部分替换成指定的内容。

8.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符串的查找

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1.find("o") << std::endl;
  8.     std::cout << str1.find("o", 5) << std::endl;
  9.     std::cout << str1.rfind("o") << std::endl;
  10.     std::cout << str1.rfind("o", 5) << std::endl;
  11.     
  12.     return 0;
  13. }

上述代码中，以下代码：

  1.     std::cout << str1.find("o") << std::endl;

在字符串str1中查看是否有o，如果有则返回字符o在字符串str1中的位置，否则返回npos，即-1。

上述代码中，以下代码：

  1.     std::cout << str1.find("o", 5) << std::endl;

在字符串str1中的第5个位置开始向后查看是否有o，如果有则返回字符o在字符串str1中的位置。

上述代码中，以下代码：

  1.     std::cout << str1.rfind("o") << std::endl;

在字符串str1中从后向前查看是否有o，如果有则返回字符o在字符串str1中的位置。

上述代码中，以下代码：

  1.     std::cout << str1.rfind("o", 5) << std::endl;

在字符串str1中的第5个位置开始向前查看是否有o，如果有则返回字符o在字符串str1中的位置。

步骤二：字符串的替换

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1.find("o") << std::endl;
  8.     std::cout << str1.find("o", 5) << std::endl;
  9.     std::cout << str1.rfind("o") << std::endl;
  10.     std::cout << str1.rfind("o", 5) << std::endl;
  11.     
  12.     std::string str2 = "Tarena";
  13.     str1.replace(6, 5, str2);
  14.     std::cout << str1 << std::endl;
  15.     
  16.     return 0;
  17. }

上述代码中，以下代码：

  1.     str1.replace(6, 5, str2);

是将字符串str1中第6个字符开始的连续5个字符替换成字符串str2的内容。

8.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::cout << str1.find("o") << std::endl;
  8.     std::cout << str1.find("o", 5) << std::endl;
  9.     std::cout << str1.rfind("o") << std::endl;
  10.     std::cout << str1.rfind("o", 5) << std::endl;
  11.     
  12.     std::string str2 = "Tarena";
  13.     str1.replace(6, 5, str2);
  14.     std::cout << str1 << std::endl;
  15.     
  16.     return 0;
  17. }

9 字符串的比较与排序

9.1 问题

字符串的比较是指将两个字符串的对应字符进行比较，如果相同则对比下一对对应字符，知道不同或两个字符串同时结束。

字符串排序是指将字符串数组按指定顺序进行排序。

9.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符串的比较

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello World!";
  7.     std::string str2 = "Hello World!";
  8.     std::cout << str1.compare(str2) << std::endl;
  9.         
  10.     return 0;
  11. }

上述代码中，以下代码：

  1.     std::cout << str1.compare(str2) << std::endl;

是将字符串str1中的第一个字符与字符串str2中的第一个字符进行比较，如果相同，则对比各自的第二个字符，直到两个字符串结束，如果一直相同，则返回0；如果有不同的，则str1中的字符的ASCII码大于str2中的ASCII码，则返回整数；否则返回负数。

步骤二：字符串的排序

代码如下所示：

  1. #include <iostream>
  3. int strCmp (const void* a, const void* b) {
  4.     return (*(std::string const*)a).compare (*(std::string const*)b);
  5. }
  7. int main(int argc, const char * argv[])
  8. {
  9.     
  10.     std::string str1 = "Hello World!";
  11.     std::string str2 = "Hello World!";
  12.     std::cout << str1.compare(str2) << std::endl;
  13.     
  14.     std::string str3[] = {"chongqing", "tianjin", "beijing",_    "shanghai"};
  15.     size_t size = sizeof (str3[0]);
  16.     size_t nmemb = sizeof (str3) / size;
  17.     qsort (str3, nmemb, size, strCmp);
  18.     for (int i = 0; i < nmemb; i++)
  19.         std::cout << str3[i] << std::endl;
  21.     return 0;
  22. }

上述代码中，以下代码：

  1.     size_t size = sizeof (str3[0]);

是求字符数组str3的第一个元素所占的字节数。该值是作为qsort函数的参数使用。

上述代码中，以下代码：

  1.     size_t nmemb = sizeof (str3) / size;

是求字符数组的元素个数。该值也是作为qsort函数的参数使用。

上述代码中，以下代码：

  1.     qsort (str3, nmemb, size, strCmp);

是调用库函数qsort对数组str3进行排序。该函数的第一个参数是要排序的数组名，第二个参数是要排序的数组的元素个数，第三个参数是要排序的数组的每个元素所占的字节数，第四个参数是排序条件，它是一个函数的函数名。该函数如下所示：

  1. int strCmp (const void* a, const void* b) {
  2.     return (*(std::string const*)a).compare (*(std::string const*)b);
  3. }

9.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int strCmp (const void* a, const void* b) {
  4.     return (*(std::string const*)a).compare (*(std::string const*)b);
  5. }
  7. int main(int argc, const char * argv[])
  8. {
  9.     
  10.     std::string str1 = "Hello World!";
  11.     std::string str2 = "Hello World!";
  12.     std::cout << str1.compare(str2) << std::endl;
  13.     
  14.     std::string str3[] = {"chongqing", "tianjin", "beijing", "shanghai"};
  15.     size_t size = sizeof (str3[0]);
  16.     size_t nmemb = sizeof (str3) / size;
  17.     qsort (str3, nmemb, size, strCmp);
  18.     for (int i = 0; i < nmemb; i++)
  19.         std::cout << str3[i] << std::endl;
  21.     return 0;
  22. }

10 字符串的插入与删除

10.1 问题

字符串的插入是指在字符串中指定的位置插入指定的字符串。字符串删除是指在字符串中指定的位置删除指定长度个字符。

10.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符串的插入

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hed!";
  7.     std::string str2 = "llo Worl";
  8.     std::cout << str1.insert(2, str2) << std::endl;
  9.     
  10.     return 0;
  11. }

上述代码中，以下代码：

  1.     std::cout << str1.insert(2, str2) << std::endl;

是在字符串str1的第2个位置插入字符串str2的所有内容。

步骤二：字符串的删除

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hed!";
  7.     std::string str2 = "llo Worl";
  8.     std::cout << str1.insert(2, str2) << std::endl;
  9.     
  10.     std::cout << str1.erase(2, 8) << std::endl;
  11.     
  12.     return 0;
  13. }

上述代码中，以下代码：

  1.     std::cout << str1.erase(2, 8) << std::endl;

是从字符串str1的第2个字符开始，连续删除8个字符。

10.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hed!";
  7.     std::string str2 = "llo Worl";
  8.     std::cout << str1.insert(2, str2) << std::endl;
  9.     
  10.     std::cout << str1.erase(2, 8) << std::endl;
  11.     
  12.     return 0;
  13. }

11 字符串的交换与复制

11.1 问题

字符串的交换是指将两个字符串的内容互相交换。字符串复制是指生成一个新的字符串其内容为原有字符串的内容。

11.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符串的交换

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello ";
  7.     std::string str2 = "World!";
  8.     swap(str1, str2);
  9.     std::cout << str1 << std::endl;
  10.     std::cout << str2 << std::endl;
  11.     
  12.     return 0;
  13. }

上述代码中，以下代码：

  1.     swap(str1, str2);

是将字符串str1的内容与字符串str2的内容进行交换。

步骤二：字符串的复制

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello ";
  7.     std::string str2 = "World!";
  8.     swap(str1, str2);
  9.     std::cout << str1 << std::endl;
  10.     std::cout << str2 << std::endl;
  11.     
  12.     std::string str3 = "Hello World!";
  13.     std::string str4;
  14.     str4.assign(str3);
  15.     std::cout << str4 << std::endl;
  17.     std::string str5;
  18.     str5.assign(str3, 2, 8);
  19.     std::cout << str5 << std::endl;
  20.     
  21.     return 0;
  22. }

上述代码中，以下代码：

  1.     str4.assign(str3);

是将字符串str3中的所有字符复制到字符串str4中。

上述代码中，以下代码：

  1.     str5.assign(str3, 2, 8);

是将字符串str3中的第2个字符开始连续8个字符复制到字符串str5中。

11.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     std::string str1 = "Hello ";
  7.     std::string str2 = "World!";
  8.     swap(str1, str2);
  9.     std::cout << str1 << std::endl;
  10.     std::cout << str2 << std::endl;
  11.     
  12.     std::string str3 = "Hello World!";
  13.     std::string str4;
  14.     str4.assign(str3);
  15.     std::cout << str4 << std::endl;
  17.     std::string str5;
  18.     str5.assign(str3, 2, 8);
  19.     std::cout << str5 << std::endl;
  20.     
  21.     return 0;
  22. }

12 布尔类型

12.1 问题

布尔类型是表示布尔量的数据类型，其值只有真（true）和假（false）两个值，布尔类型的数据占1个字节的存储空间。

12.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：布尔类型

代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     bool b;
  7.     b = true;
  8.     b = false;
  9.     std::cout << std::boolalpha << b << std::endl;
  11.     std::cout << sizeof(bool) << std::endl;
  12.     
  13.     b = 5;
  14.     b = 5.5;
  15.     b = ‘a‘;
  16.     std::cout << std::boolalpha << b << std::endl;
  17.     
  18.     return 0;
  19. }

上述代码中，以下代码：

  1.     bool b;
  2.     b = true;
  3.     b = false;

定义了布尔类型变量b，并将其赋值为true和false。

上述代码中，以下代码：

  1.     std::cout << sizeof(bool) << std::endl;

从运行结果可以看出，布尔类型占1个字节的存储空间。

上述代码中，以下代码：

  1.     b = 5;
  2.     b = 5.5;
  3.     b = ‘a‘;

表示任何基本数据类型的数据均可直接复制给布尔变量b。

12.3 完整代码

本案例中的完整代码如下所示：

  1. #include <iostream>
  3. int main(int argc, const char * argv[])
  4. {
  5.     
  6.     bool b;
  7.     b = true;
  8.     b = false;
  9.     std::cout << std::boolalpha << b << std::endl;
  11.     std::cout << sizeof(bool) << std::endl;
  12.     
  13.     b = 5;
  14.     b = 5.5;
  15.     b = ‘a‘;
  16.     std::cout << std::boolalpha << b << std::endl;
  17.     
  18.     return 0;
  19. }












C++001--字符串

标签：

原文地址：http://blog.csdn.net/opera95/article/details/51217617
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！