C++标准库中的string类的函数

C++标准库中的string类包含了一系列的成员函数，用于处理和操作字符串。具体如下：

初始化：可以通过直接赋值或使用构造函数来初始化一个string对象。
获取长度：使用length()或size()成员函数可以获取字符串的长度。
插入：insert()函数可以在指定位置插入字符或另一个字符串。
替换：replace()函数可以替换字符串中的一部分内容。
添加：append()函数可以在字符串的末尾添加字符或另一个字符串。
赋值：可以使用=运算符或assign()函数来给string对象赋值。
删除：erase()函数可以删除字符串中的一段字符。
剪切：substr()函数可以从字符串中提取子串。
比较：可以使用compare()函数来比较两个字符串。
交换：swap()函数可以交换两个string对象的内容。
反转：reverse()函数可以反转字符串中的字符顺序。
数值转化：可以将字符串转换为数值类型，如stoi()（字符串转整数）。
查找：find()函数可以查找子串在字符串中的位置。
迭代器：string类支持使用迭代器来访问和修改字符串中的字符。

需包含头文件<string>.

length:

1:length用于获取字符串的长度

在C++中，length()函数通常用于获取字符串或数组的长度。对于字符串，可以使用std::string类的length()成员函数；

对于字符串，使用std::string类的length()成员函数：

#include <iostream>
#include <string>

int main() {
	std::string str = "Hello, World!";
	std::cout << "字符串长度为： " << str.length() << std::endl;
	return 0;
}

对于数组，使用sizeof()运算符：

#include <iostream>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    std::cout << "数组长度为： " << sizeof(arr) / sizeof(arr[0]) << std::endl;
    return 0;
}

insret:

2.insert()函数可以在指定位置插入字符或另一个字符串。

在C++中，insert函数用于向容器（如vector、set、map等）插入元素。其基本语法为：

iterator insert(iterator position, const T& value);
iterator insert(iterator position, size_type count, const T& value);
iterator insert(iterator position, InputIterator first, InputIterator last);

其中，position表示要插入元素的位置，value表示要插入的元素值，count表示要插入的元素个数，first,last表示要插入的元素范围。

append ：

append()函数可以在字符串的末尾添加字符或另一个字符串。

对于字符串，append函数可以追加字符或字符串。例如：

std::string s1 = "hello";
std::string s2 = "the";
s1.append(s2); // 结果为 "hellothe"

在这个例子中，字符串s2被添加到了字符串s1的末尾。此外，还可以使用append函数来添加C风格的字符串（C-string）到字符串的末尾。

对于列表，如std::list，append函数用于向列表的末尾添加一个新元素。例如：

std::list<std::string> name_list = {"zhangsan", "lisi", "wangwu"};
name_list.append("zhaoliu"); // 结果为 ["zhangsan", "lisi", "wangwu", "zhaoliu"]

在这个例子中，字符串"zhaoliu"被添加到了name_list列表的末尾。

assign：

assign()函数来给对象赋值。

区间赋值：void assign(const_iterator first, const_iterator last) 这种形式的assign函数会将指定迭代器区间[first, last)内的元素复制到当前容器中。这意味着，原容器中的所有元素将被清除，并替换为新指定的元素。例如下面代码中的v2：

 int main(int argc, char* argv[])
 {
	  vector<int> v1{ 1,2,3 };
	 v1.assign(4, 5);
	 std::cout << "vectorV1" << endl;
	 for (int val :v1)
	 {
		 std::cout << val << endl;
	 }
	 vector<int> v2;
	 std::cout << "vectorV2" << endl;
	 v2.assign(v1.begin(), v1.end());
	 for (int val : v2)
	 {
		 std::cout << val << endl;
	 }
     return 0；
}

数量赋值：void assign(size_type n, const T& x = T()) 这种形式的assign函数会将n个具有值x的元素添加到当前容器中。同样，原容器中的内容会被清除，然后添加新的元素。如上图代码中的v1。

在C++标准库的容器如std::vector、std::list等中，assign函数通常用于重新设置容器的内容。例如，如果你想清空一个vector并将其设置为包含5个值为0的元素，你可以使用vec.assign(5, 0);

需要注意的是，assign函数与拷贝构造函数不同，它不会保留原容器中的元素，而是完全替换为新的元素。此外，assign函数的效率通常较高，因为它可能会直接在内存中进行操作，而不需要逐个元素的拷贝。

erase：

erase()函数可以删除字符串中的一段字符。

erase()函数是C++标准库中的算法，用于删除容器中的元素。它有两种重载形式：

1、erase(iterator position)：删除指定位置的元素，并返回指向下一个元素的迭代器。

例如：

  #include <iostream>
  #include <vector>
  
  int main() {
  std::vector<int> vec = {1, 2, 3, 4, 5};
  
  // 删除指定位置的元素
  vec.erase(vec.begin() + 2);
  
  // 输出删除后的向量
  for (int num : vec) {
  std::cout << num << " ";
  }
  std::cout << std::endl;
  }//输出是1 2 4 5

2、erase(iterator first, iterator last)：删除指定范围内的元素，并返回指向最后一个被删除元素的下一个元素的迭代器。例如：

#include <iostream>
#include <vector>
int main(){
	std::vector<int> vec = {1, 2, 3, 4, 5};
// 删除指定范围内的元素
vec.erase(vec.begin() + 1, vec.begin() + 3);

// 输出删除后的向量
for (int num : vec) {
	std::cout << num << " ";
}
std::cout << std::endl;

return 0;
}

substr ：

substr()函数可以从字符串中提取子串。代码如下：

#include <iostream> // 引入输入输出流库
#include <string>   // 引入字符串处理库

int main() {
    std::string str = "Hello, World!"; // 定义一个字符串变量str，赋值为"Hello, World!"
    std::string sub_str = str.substr(7, 5); // 使用substr函数从str中提取子字符串，起始位置为7（从0开始计数），长度为5个字符
    std::cout << "Substring: " << sub_str << std::endl; // 输出提取到的子字符串
    return 0; // 程序正常结束，返回0
}

这段代码首先包含了两个头文件，分别是<iostream>和<string>。<iostream>头文件提供了输入输出流的功能，而<string>头文件提供了字符串处理的功能。

在main函数中，首先定义了一个名为str的字符串变量，并将其初始化为"Hello, World!"。然后使用substr函数从str中提取子字符串，起始位置为7，长度为5个字符，将提取到的子字符串赋值给sub_str变量。最后，使用std::cout输出提取到的子字符串。程序正常结束后，返回0。

compare ：

可以使用compare()函数来比较两个字符串。

在C++中，compare函数通常用于比较两个对象的大小。它通常与STL中的sort函数一起使用，以便对容器中的元素进行排序。compare函数需要两个参数，分别是要比较的两个对象。如果第一个对象小于第二个对象，则返回负数；如果两个对象相等，则返回0；如果第一个对象大于第二个对象，则返回正数。

以下是一个简单的示例，展示了如何使用compare函数对一个整数数组进行排序：

#include <iostream>
#include <algorithm>

bool compare(int a, int b) {
    return a < b;
}

int main() {
    int arr[] = {5, 3, 1, 4, 2};
    int n = sizeof(arr) / sizeof(arr[0]);

    std::sort(arr, arr + n, compare);

    for (int i = 0; i < n; i++) {
        std::cout << arr[i] << " ";
    }

    return 0;
}

在这个示例中，我们定义了一个名为compare的函数，该函数接受两个整数参数a和b，并返回它们之间的比较结果。然后，我们使用std::sort函数对整数数组arr进行排序，并将compare函数作为第三个参数传递给它。最后，我们遍历排序后的数组并输出其元素。

swap：

在C++中，swap函数用于交换两个变量的值。它需要两个参数，分别是要交换的两个变量。

以下是一个简单的示例，展示了如何使用swap函数交换两个整数变量的值：

#include <iostream>
#include <algorithm>

int main() {
    int a = 5;
    int b = 10;

    std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;

    std::swap(a, b);

    std::cout << "After swap: a = " << a << ", b = " << b << std::endl;

    return 0;
}

reverse：

C++中的reverse函数用于反转容器中的元素顺序。它需要两个迭代器作为参数，分别表示要反转的容器的起始和结束位置。reverse函数会将这两个迭代器之间的元素顺序反转。用法示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用reverse函数反转vec中的元素顺序
    std::reverse(vec.begin(), vec.end());

    // 输出反转后的vec
    for (int num : vec) {
        std::cout << num << " ";
    }

    return 0;
}

 stio：

C++中的stoi函数用于将字符串转换为整数。它需要两个参数，第一个参数是要转换的字符串，第二个参数是可选的基数（默认为10）。如果需要其他进制，也可以是2，8，16：代码如下：

#include <iostream>
#include <string>

int main() {
    std::string binaryStr = "1010"; // 二进制表示的10
    std::string octalStr = "10";   // 八进制表示的8
    std::string hexStr = "A";      // 十六进制表示的10

    int binaryNum = std::stoi(binaryStr, nullptr, 2);
    int octalNum = std::stoi(octalStr, nullptr, 8);
    int hexNum = std::stoi(hexStr, nullptr, 16);

    std::cout << "Binary: " << binaryNum << std::endl;
    std::cout << "Octal: " << octalNum << std::endl;
    std::cout << "Hexadecimal: " << hexNum << std::endl;

    return 0;
}

输出是：

Binary: 10
Octal: 8
Hexadecimal: 10

find：

C++中的find函数用于在容器（如vector、list、set等）中查找指定元素。find函数返回一个迭代器，指向找到的元素。如果未找到该元素，则返回容器的end()迭代器。

以下是find函数的基本用法：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int target = 3;

    // 使用find函数查找目标元素
    std::vector<int>::iterator it = std::find(vec.begin(), vec.end(), target);

    if (it != vec.end()) {
        std::cout << "找到元素： " << *it << std::endl;
    } else {
        std::cout << "未找到元素" << std::endl;
    }

    return 0;
}

在这个例子中，我们使用find函数在vector容器中查找值为3的元素。如果找到了，就输出找到的元素；如果没有找到，就输出"未找到元素"。

 //迭代器和指针什么区别

迭代器和指针在C++中是两个不同的概念，它们的主要区别在于本质、使用范围以及生命周期上。

其次，在使用范围上，指针可以指向任何类型的数据，包括函数和普通变量，而迭代器只能用于遍历容器的元素。迭代器的设计目的是为了泛化数据结构的操作，使得同一套算法能够适用于不同类型的容器，这是指针所不具备的。

最后，关于生命周期，迭代器在使用后可能会失效，需要重新获取才能再次使用，而指针则没有这样的。

综上所述，虽然迭代器在某些方面类似于指针，但它们在本质和使用上有着明显的区别。迭代器提供了一种更加抽象和安全的方式来遍历容器，而指针则提供了更直接的内存访问方式。