C++001--字符串

最新推荐文章于 2023-01-15 22:46:38 发布
最新推荐文章于 2023-01-15 22:46:38 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： C++ 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/opera95/article/details/51217617
版权


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. }












opera92
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++001
zzzzzzcb的专栏
03-16 716
2015/3/15   Class与object 的对比： 类是一个抽象的概念，而对象做到了实体化，比如学生类，我可以定义一个对象就是student  A；表示A学生，那么这个A就具备所有学生的所有特征。这些特征就是你在student 这个类里面定义的一些属性和方法。只有定义了对象，你才能调用类里面的方法。用我们老师的话说，类是图纸，对象才是建筑。调用方法，肯定是要用对象调的 对象是具体的
C++代码 - 通过异或字符加密字符串.zip
最新发布
06-29
字符串加密
C++-001-基本知识
生于忧患，死于安乐
03-02 1482
C/C+±001-基本知识-2020-3-2 标准数据类型 数据类型 取值范围 [signed]short -32768~32767 [signed] int -2147483648~2147483647 [signed] long -2147483648~2147483647 [signed]long long -(2x1063-1)~2x1063-1 [unsi...
001——C++
驿书达的博客
04-05 519
01 关于setw（） 制定输出所占的列数可以使用控制符setw（）进行设置，for examole setw（5）的作用是为其后面的一个输出项保留5列的空间，如果输出数据不足5列，则数据向右对齐，else 按照实际长度输出。 //输入语句 cout<<"a="<<set(6)<<a<<endl<<"b="<<set(6)&l...
7.整数反转
qq_38023332的博客
03-17 159
思路 这道题就是很简单的数字问题，难点在于对于越界数值的处理。所以此处用long来定义res，就不用担心越界啦。最后把越界的输出为0就可以了。 代码 int reverse(int x) { long res=0; while(x!=0){ res=res*10+x%10; x=x/10; } ...
c++
老王001的博客
05-22 177
@[TOC]qqqqqqq #include #include #include using namespace std; int main() { std::cout << “Hello World!\n”; vector<int> coll; // vector container for integer elements // append elements with values 1 to 6 for (int i = 1; i <= 6; ++i) {
c++ 字符串字符转16进制
01-17
在C++编程中，将字符串中的每个字符转换成16进制值并输出是一项常见的任务。这涉及到对字符串的处理和数字的进制转换。在本文中，我们将深入探讨如何实现这一目标，以及相关的C++语言特性。 首先，我们要了解字符串...
c++常量字符串编译期加密
08-17
源实现参考网络资源；基于源实现解决了其重入问题。 语言环境：c++14 测试环境：在VS2019、ubuntu（wsl） g++(理论上支持c++14的都可以)
C++ 中字符串操作--宽窄字符转换的实例详解
08-29
C++ 字符串操作--宽窄字符转换的实例详解 C++ 中字符串操作--宽窄字符转换是指在 C++ 编程语言中，将字符串从一种编码格式转换到另一种编码格式的过程。在这种操作中，需要使用到相关的函数来实现宽窄字符的转换。...
c++字符串分割的方法
12-17
在C++编程中，字符串处理是一项基础且重要的任务。字符串分割是其中常见的操作，它将一个字符串分解成多个子字符串，通常根据特定的分隔符进行。本文将详细讲解两种C++中对字符串进行分割的方法：一是使用单个分隔符...
C++实现的字符串加一操作
09-08
C++实现的字符串加一功能，csdn中有类似的资源，只是用C#实现的，这个是自己写的c++版本。除浮点数和负数外，支持任意夹带数字和字母的字符串。
初学c++ （001） 随机数字生成
oldwhitefat的博客
01-14 519
使用 timer进行随机种子生成，用rand基于RAND_MAX样本空间进行随机数字生成主，除以最大值 ，就能生成0-1的随机浮点数字。 #include <iostream> #include <cstdlib> #include <iomanip> #include <time.h> int main() { time_t t; srand((unsigned)time(&t)); cout << " Random
C++ 001：C++ 基础语法
Copcin的小站
01-15 786
由于某次偶然的机会，我看见了一张 C++ 竞赛的学习路线表（这里由于表格内容太多就不贴出来），里面的东西是真的多：不仅仅有 C++ 本身，还有各种算法，数据结构，数论等等等等。但是学习路线旁边，还贴了一个学完之后参加比赛能够拿到的名次，我一秒也没犹豫，直接开了这个坑~ 但是由于这些内容实在太多了，所以学习路线肯定是要有的。下面浅浅的~~贴出来~~画个大饼~
C++基础知识001
一个金牛座 的程序员
05-09 256
1、C++简介 C++是在C语言的基础上进一步优化而来的，它既可以进行C语 言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。 2、命名空间：用来避免标识符命名污染与命名重复的。 命名空间的定义及使用 // 命名空间：用来避免C语言中的命名冲突 // :: 作用域限定符 // 命名空间的定义 // 命名空间的使用： // N::a...
C/C++-001-字符串与string类
生于忧患，死于安乐
03-05 1520
字符串与string类-2020-3-5 C++语言对于字符串的操作提供了许多字符串处理函数，我们将介绍一些常用的字符串函数，需要注意的是，使用这些字符串处理函数，需要在文件头加上#include<string.h>这一句。 一、字符串转换小写字符strlwr(char *s1) 该函数将字符串s1中的所有字符转小写。 如下： //字符串转换小写字符 #include<iostr...
【c++】输出 0000,0001,0002,0003,0004...这样的字符串
weixin_34206899的博客
06-14 1161
#include <iostream> #include <iomanip> int frameCount = 0; while(1){ stringstream buf; buf <<setfill('0') << setw(4)<< frameCount; ...
C++学习笔记#001字符串转数字 stringstream
littzhi的博客
11-30 463
string数据类型转换为数字，先将其转换为stringstream 类型，然后可以使用流运算符进行转换即可。
C++_001【重载赋值运算符】
DamonDT
03-27 122
【要点】 把返回值类型声明为该类型的引用，并在函数结束前返回实例自身的引用（*this） 把传入的参数类型声明为常量引用，并加上 const 表明不会改变传入的实例的状态 在分配新内存之前释放自身已有内存，否则会导致内存泄漏 在释放自身内存之前，需要进行判断传入的参数和当前的实例（*this）是不是同一个实例，若是同一个实例，则直接返回 【1】主体代码 #include<iostream...
学习C++ -> string类字符串
weixin_34409703的博客
01-21 101
学习C++ -&gt; string类字符串 一、string类字符串的介绍    在程序设计中, 字符串的使用十分频繁, C语言类型字符串(简称C-串)在使用与字符串的处理上较为复杂, C++为了在程序设计中更加方便的使用字符串特新增了一种string类型的字符串。 　　string类字符串为STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型,...
c++ utf-8字符串判断
04-21
在C语言中，可以使用strcmp函数进行字符串比较，也可以使用strstr函数判断一个字符串是否包含另一个子字符串。另外，使用strlen函数可以获取字符串的长度。需要注意的是，UTF-8字符串中，一个中文字符可能由多个字节...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值