Directorio de artículos
- Descripciones de interfaz de uso común de la clase de cadena (solo se explican las interfaces más utilizadas)
- Primero, la estructura común de los objetos de clase de cadena
- 2. Operaciones de acceso y recorrido de objetos de clase de cadena
- 3. Operación de capacidad de objetos de cadena
- Cuarto, la operación de modificación del objeto de clase de cadena.
- Cinco, funciones no miembro de clase de cadena
Descripciones de interfaz de uso común de la clase de cadena (solo se explican las interfaces más utilizadas)
Primero, la estructura común de los objetos de clase de cadena
La clase de cadena implementa la sobrecarga de múltiples constructores, y los constructores de uso común son los siguientes:
| nombre de la función | Función descriptiva |
|---|---|
| cadena() | construye una cadena vacía |
| cadena (const char * s) | Usar cadenas para construir objetos de cadena |
| cadena (const cadena y cadena) | copiar constructor |
| cadena (tamaño_t n, carácter c) | Use n caracteres c para construir un objeto de cadena |
| cadena (const char * s, size_t n) | Copia los primeros n caracteres de la matriz de caracteres a la que apunta s |
| string(const string& str, size_t pos, size_t len = npos) | Copie la parte de str que comienza en la posición de carácter pos y abarca los caracteres len |
Ejemplo de uso:
string s1; //构造空字符串
string s2("hello string"); //用"hello string"字符串来构造string对象
string s3(s2); //拷贝构造
string s4 = "hello string" //也是拷贝构造 --- string支持赋值运算符重载
string s5(10, 's'); //生成10个's'字符的字符串
string s6("hello string", 3); //复制"hello string"的前3个字符给s5
string s7(s2, 0, 4); //复制s2中从字符位置0开始并跨越4个字符的部分
2. Operaciones de acceso y recorrido de objetos de clase de cadena
| nombre de la función | Función descriptiva |
|---|---|
| operador[ ] (énfasis) | Devuelve el carácter en la posición pos |
| Reenviar iterador: comienzo + fin (énfasis) | begin obtiene un iterador para un carácter + end obtiene un iterador para la siguiente posición del último carácter |
| Iterador inverso: rbegin + rend | begin obtiene un iterador para un carácter + end obtiene un iterador para la siguiente posición del último carácter |
| rango para (énfasis) | C ++ 11 admite un nuevo método transversal para un rango más conciso para |
Ejemplo de uso:
1. operador[ ]: sobrecarga del operador [ ]
void test_string1()
{
string s1("1234");
// 遍历
// 1、下标 []
for (size_t i = 0; i < s1.size(); ++i)
{
s1[i]++;
}
cout << s1 << endl;
}
2. Gama para:
void test_string2()
{
string s1("1234");
// 2、范围for
for (auto& ch : s1)
{
ch++;//每个字符加加
}
for (auto e : s1)
{
cout << e ;//遍历打印
}
cout << endl;
//cout << s1 << endl;//也可以直接打印，
}
Recorrido de bucle ordinario:
void test_string2()
{
string s1("1234");
// 反转一下
size_t begin = 0, end = s1.size() - 1;//size()计算字符串有效字符个数
while (begin < end)
{
swap(s1[begin++], s1[end--]);
}
cout << s1 << endl;
}
3. Iteradores:
1. La función relacionada con la
función de inicio del iterador hacia adelante: devuelve un iterador que apunta al primer carácter de la cadena.
Prototipo de función:
iterador begin();
const_iterator begin() const;
función final: Devuelve un iterador que apunta al carácter final de la cadena, es decir, '\0'.
Prototipo de función:
iterador end();
const_iterator end() const;
Ejemplo de uso:
void test_string3()
{
string s1("1234");
//正向迭代器 --- 关键字：iterator
string::iterator it1 = s1.begin();
while (it1 != s1.end())
{
//每个字符加1
*it1 += 1;
++it1;
}
it1 = s1.begin();
while (it1 != s1.end())
{
//遍历打印
cout << *it1 << " ";
++it1;
}
//2 3 4 5
cout << endl;
}
Nota: ¡ bigin() y end() para los iteradores directos deben aparecer juntos!
2. La función relacionada con la
función rbegin del iterador inverso: devuelve el iterador inverso que apunta al último carácter de la cadena.
Prototipo de función:
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
función rend: Devuelve un iterador inverso que apunta al elemento teórico que precede al primer carácter de la cadena.
Prototipo de función:
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
Ejemplo de uso:
void test_string3()
{
string s1("1234");
string::iterator it = s1.begin();
while (it != s1.end())
{
//每个字符加1
cout << *it << " ";
++it;
}
cout << endl;
//反向迭代器 --- 关键字：reverse_iterator
string::reverse_iterator rit = s1.rbegin();
//若觉得类型过长，书写麻烦，我们可以使用auto自动推导类型
//auto rit = s1.rbegin();可自动推到类型
while (rit != s1.rend())
{
//反向遍历
cout << *rit << " ";
++rit;
}
//5 4 3 2
cout << endl;
}
Nota: ¡ rbigin() y rend() para los iteradores inversos deben aparecer juntos!
iterador const:
la demostración anterior es solo un iterador no const, podemos leer y escribir cadenas, y el iterador const solo nos permite leer.
Para resumir, podemos hacer un resumen de la tabla de iteradores:
| Iteradores (ambos se pueden deducir con auto) | no constante | constante |
|---|---|---|
| Adelante | (adelante) legible y escribible (iterador) comenzar (), finalizar () | (adelante) legible pero no escribible (const_iterator)begin(),end() |
| contrarrestar | (reversa) legible y escribible (reverse_iterator) rbegin(), rend() | (inversa) legible y escribible (const_reverse_iterator) rbegin(), rend() |
4. Usar at para acceder a los elementos del objeto
Debido a que la función at también se usa para devolver la referencia, también podemos modificar el elemento en la posición correspondiente a través de la función at.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("CSDN");
for (size_t i = 0; i < s.size(); i++)
{
//at(pos)访问pos位置的元素
cout << s.at(i);
}
cout << endl;
for (size_t i = 0; i < s.size(); i++)
{
//at(pos)访问pos位置的元素，并对其进行修改
s.at(i) = 'x';
}
cout << s << endl; //xxxx
return 0;
}
3. Operación de capacidad de objetos de cadena
1. Utilice la función de tamaño o la función de longitud para obtener el número de caracteres actualmente válidos
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("CSDN");
cout << s.size() << endl; //4
cout << s.length() << endl; //4
return 0;
}
2. Use la función de capacidad para obtener el tamaño del espacio de almacenamiento asignado por el objeto actual
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("CSDN");
cout << s.capacity() << endl; //15
return 0;
}
3. Use la función max_size para obtener la cantidad máxima de caracteres que puede contener un objeto de cadena
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("CSDN");
cout << s.max_size() << endl; //4294967294
return 0;
}
4. Use clear para borrar el contenido del objeto, y el objeto se convierte en una cadena vacía después de la eliminación
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("CSDN");
//clear()删除对象的内容，该对象将变为空字符串
s.clear();
cout << s << endl; //空字符串
return 0;
}
5. Use vacío para juzgar si el objeto está vacío,
devuelva verdadero si está vacío y devuelva falso si no está vacío
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("CSDN");
cout << s.empty() << endl; //0
//clear()删除对象的内容，该对象将变为空字符串
s.clear();
cout << s.empty() << endl; //1
return 0;
}
6. Función de cambio de tamaño
regla:
| redimensionar(n) | |
|---|---|
| n<tamaño | Si n es menor que la longitud actual de la cadena, el valor actual se acorta al carácter n, los caracteres más allá del carácter n se eliminan. |
| tamaño<n<capacidad | Si n es mayor que el tamaño y menor que la capacidad, no habrá expansión y el espacio será mayor que el tamaño. Si se proporciona el carácter c especificado, se completará con c. Si no se proporciona c, se establecerá por defecto a '\0'. |
| n>capacidad | Para la expansión de cadenas, si el n dado es mayor que la capacidad actual del objeto, la capacidad también se expandirá de acuerdo con sus propias reglas de crecimiento. |
7. Usa la reserva para cambiar la capacidad del objeto actual
Reglas de reserva:
1. Cuando n es mayor que la capacidad actual del objeto, expanda la capacidad a n o mayor que n.
2. Cuando n es menor que la capacidad actual del objeto, no haga nada.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("CSDN");
cout << s << endl; //CSDN
cout << s.size() << endl; //4
cout << s.capacity() << endl; //15
//reverse(n)当n大于对象当前的capacity时，将当前对象的capacity扩大为n或大于n
s.reserve(20);
cout << s << endl; //CDSN
cout << s.size() << endl; //4
cout << s.capacity() << endl; //31
//reverse(n)当n小于对象当前的capacity时，什么也不做
s.reserve(2);
cout << s << endl; //CDSN
cout << s.size() << endl; //4
cout << s.capacity() << endl; //31
return 0;
}
Nota: esta función no tiene efecto sobre el tamaño de la cadena y su contenido no se puede cambiar.
8. Función de encoger_para_ajustar
Cuarto, la operación de modificación del objeto de clase de cadena.
1. push_back:
inserta un carácter al final
void test_string()
{
string s1("hello world");
s1.push_back(' ');
s1.push_back('!');
cout << s1 << endl;//hello world !
}
2. agregar:
agregue una cadena después de la cadena
Métodos de transferencia de parámetros comúnmente utilizados:
cadena& anexar (const cadena& str);
cadena& anexar (const char* s);
cadena& anexar (tamaño_t n, char c);
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1("I");
string s2(" like");
//append(string)完成两个string对象的拼接
s1.append(s2); //I like
//append(str)完成string对象和字符串str的拼接
s1.append(" C++"); //I like C++
//append(n, char)将n个字符char拼接到string对象后面
s1.append(3, '!'); //I like C++!!!
cout << s1 << endl; //I like C++!!!
return 0;
}
3. operador+= (énfasis): el
operador += está sobrecargado en la clase de cadena, y el operador += sobrecargado admite la asignación compuesta de la clase de cadena, la asignación compuesta de cadenas y la asignación compuesta de caracteres
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1;
string s2("hello");
//支持string类的复合赋值
s1 += s2;
cout << s1 << endl; //hello
//支持字符串的复合赋值
s1 += " CSDN";
cout << s1 << endl; //hello CSDN
//支持字符的复合赋值
s1 += '!';
cout << s1 << endl; //hello CSDN!
return 0;
}
4. insertar: inserte el método de paso de parámetros comunes
en la posición pos :
cadena& insertar (tamaño_t pos, const cadena& str);
cadena e inserción (tamaño_t pos, const char* s);
inserción de iterador (iterador p, char c);
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("C"); //C
//insert(pos, str)在pos位置插入字符串str
s.insert(1, "S"); //CS
//insert(pos, string)在pos位置插入string对象
string t("D");
s.insert(2, t); //CSD
//insert(pos, char)在pos位置插入字符char
s.insert(s.end(), 'N'); //CSDN
cout << s << endl; //CSDN
return 0;
}
5. borrar: elimine el método de paso de parámetros comunes
en la posición de pos :
string& erase (size_t pos = 0, size_t len = npos);//Elimine los caracteres len de la posición pos, si no se pasa len, todos los caracteres en la posición pos y posteriores se eliminarán por iterador borrado predeterminado (iterador p); borrado de iterador
(
iterador primero, último iterador);
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("I like C++!!!");
//erase(pos, n)删除pos位置开始的n个字符
s.erase(8, 5); //I like C
cout << s << endl; //I like C
//erase(pos)删除pos位置的字符
s.erase(s.end() - 1); //I like
cout << s << endl; //I like
//erase(pos1, pos2)删除[pos1pos2)上所有字符
s.erase(s.begin() + 1, s.end()); //I
cout << s << endl; //I
return 0;
}
6. asignar:
asignar puede entenderse como borrar el objeto de carácter original y volver a realizar la operación de asignación.
Métodos de paso de parámetros de uso común:
cadena& asignar (const cadena& str);
cadena& asignar (const char* s);
cadena& asignar (const char* s, size_t n);
cadena& asignar (tamaño_t n, char c);
void test_string()
{
string s1("hello world hello world");
string s2("CSDN");
//将s1清空，替换指定string对象
s1.assign(s2);
cout << s1 << endl;//CSDN
//将s1清空，替换指定字符串
s1.assign("hello C++");
cout << s1 << endl;//hello C++
//将s1清空，替换指定字符串的一部分
s1.assign("hello C++", 5);
cout << s1 << endl;//hello
//将s1清空，替换n个指定的字符
s1.assign(5, '!');
cout << s1 << endl;//！！！！！
}
7. replace:
replace es un reemplazo parcial de objetos de carácter.
Métodos de paso de parámetros de uso común:
string& replace (size_t pos, size_t len, const string& str);
string& replace (size_t pos, size_t len, const char* s);
void test_string()
{
string s1("hello world hello world");
string s2("CSDN");
//从第六个下标位置开始，将五个字符替换成s2对象
s1.replace(6, 5, s2);
cout << s1 << endl;//hello CSDN hello world
//从第六个下标位置开始，将五个字符替换成指定字符串
s1.replace(6, 5, "C++");
cout << s1 << endl;//hello C++hello world
}
8. buscar:
use la función de búsqueda para buscar hacia adelante el primer elemento coincidente.Métodos
de paso de parámetros comúnmente utilizados:
size_t find (const string& str, size_t pos = 0) const;
size_t find (const char* s, size_t pos = 0) const;
size_t find (char c, size_t pos = 0) const;
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1("http://www.cplusplus.com/reference/string/string/find/");
//find(string)正向搜索与string对象所匹配的第一个位置
string s2("www");
size_t pos1 = s1.find(s2);
cout << pos1 << endl; //7
//find(str)正向搜索与字符串str所匹配的第一个位置
char str[] = "cplusplus.com";
size_t pos2 = s1.find(str);
cout << pos2 << endl; //11
//find(char)正向搜索与字符char所匹配的第一个位置
size_t pos3 = s1.find(':');
cout << pos3 << endl; //4
return 0;
}
9. rfind:
use la función rfind para buscar en reversa la primera coincidencia.Métodos
de paso de parámetros comúnmente utilizados:
size_t rfind (const string& str, size_t pos = npos) const;
size_t rfind (const char* s, size_t pos = npos) const;
size_t rfind (char c, size_t pos = npos) const;
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1("http://www.cplusplus.com/reference/string/string/find/");
//rfind(string)反向搜索与string对象所匹配的第一个位置
string s2("string");
size_t pos1 = s1.rfind(s2);
cout << pos1 << endl; //42
//rfind(str)反向搜索与字符串str所匹配的第一个位置
char str[] = "reference";
size_t pos2 = s1.rfind(str);
cout << pos2 << endl; //25
//rfind(char)反向搜索与字符char所匹配的第一个位置
size_t pos3 = s1.rfind('/');
cout << pos3 << endl; //53
return 0;
}
10. substr
Use la función substr para extraer la subcadena en la cadena
string substr (size_t pos = 0, size_t len = npos) const;//Extraiga la secuencia de caracteres len comenzando desde la posición pos como valor de retorno
Extraiga el sufijo del archivo.
void test_string()
{
// "Test.cpp"
// "Test.cpp.tar"
string file;
cin >> file;
// 要求取后缀
//应该使用rfind，因为有些文件名可能有两个点
size_t pos = file.rfind('.');
if (pos != string::npos)
{
//string suffix = file.substr(pos, file.size() - pos);
string suffix = file.substr(pos);//提取pos位置开始的len个字符序列作为返回值
cout << suffix << endl;
}
}
11.c_str
obtiene la primera dirección de la matriz de caracteres y la atraviesa en forma de cadena C
const char* c_str() const;
void TestString()
{
//获取字符数组首地址，用C字符串的形式遍历
string s1("hello world");
const char* str = s1.c_str();
while (*str)
{
cout << *str << " ";
str++;
}
cout << endl;
s1 += '\0';
s1 += " hello";
cout << s1 << endl; //调用的string重载operator<< 将对象数组中所有字符都输出
cout << s1.c_str() << endl; //直接输出const char* 遇到\0结束
}
Cinco, funciones no miembro de clase de cadena
1. operator+
El operador + está sobrecargado en la clase de cadena, y el operador + sobrecargado admite los siguientes tipos de operaciones:
clase de cadena + clase de cadena clase de cadena
+
cadena cadena + clase de
cadena clase de cadena + carácter carácter
+ clase de cadena
Todos devuelven un objeto de clase de cadena después de ser agregado.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s;
string s1("hello");
string s2("world");
char str[] = "wyt";
char ch = '!';
//string类 + string类
s = s1 + s2;
cout << s << endl; //helloworld
//string类 + 字符串
s = s1 + str;
cout << s << endl; //hellowyt
//字符串 + string类
s = str + s1;
cout << s << endl; //wythello
//string类 + 字符
s = s1 + ch;
cout << s << endl; //hello!
//字符 + string类
s = ch + s1;
cout << s << endl; //!hello
return 0;
}
2. operador>> y operador<<
La clase de cadena también sobrecarga los operadores >> y <<, por lo que podemos usar directamente >> y << para ingresar y generar la clase de cadena.
operador istream&>> (istream& is, string& str);
operador ostream&<< (ostream& os, const string& str);
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s;
cin >> s; //输入
cout << s << endl; //输出
return 0;
}
3.
Una serie de operadores relacionales también están sobrecargados en la clase de cadena de operadores relacionales, que son ==, !=, <, <=, >, >=. Los operadores relacionales sobrecargados admiten la comparación relacional entre la clase de cadena y la clase de cadena, la comparación relacional entre la clase de cadena y la cadena, y la comparación relacional entre la cadena y la clase de cadena.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1("abcd");
string s2("abde");
cout << (s1 > s2) << endl; //0
cout << (s1 < s2) << endl; //1
cout << (s1 == s2) << endl; //0
return 0;
}
Nota: Estos operadores de comparación relacional sobrecargados comparan los valores de código ASCII de los caracteres correspondientes.
4. Getline
Sabemos que cuando usamos >> para operaciones de entrada, cuando >> lee un espacio, dejará de leer. En base a esto, no podremos usar >> para leer una cadena de cadenas que contengan espacios en la cadena. objeto
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s;
cin >> s; //输入：hello CSDN
cout << s << endl; //输出：hello
return 0;
}
En este momento, necesitamos usar la función getline para completar la operación de lectura de una cadena de cadenas que contienen espacios.
Uso uno:
istream& getline (istream& es, cadena& str);
La función getline almacena los caracteres extraídos de is en str hasta que se lee el carácter de nueva línea '\n'
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s;
getline(cin, s); //输入：hello CSDN
cout << s << endl; //输出：hello CSDN
return 0;
}
Uso dos:
istream& getline (istream& is, string& str, char delim);
La función getline almacena los caracteres extraídos de is en str hasta que se lee el delimitador delim o el carácter de nueva línea '\n'.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s;
getline(cin, s, 'D'); //输入：hello CSDN
cout << s << endl; //输出：hello CS
return 0;
}