Clase y objetos
Una clase es un conjunto de variables y funciones que trabajan juntas; donde las variables no tienen valores asignados. Cuando se asignan valores a las variables, la clase se convierte en un objeto. Diferentes valores dados a la misma clase dan como resultado diferentes objetos; es decir, diferentes objetos son de la misma clase con diferentes valores. Se dice que crear un objeto a partir de una clase es instanciar el objeto.
El nombre, cadena, es una clase. Un objeto creado a partir de la clase de cadena tiene un nombre elegido por el programador.
Se necesita una función que pertenezca a la clase para crear una instancia de un objeto de la clase. En C ++, esa función tiene el mismo nombre que el nombre de la clase. Los objetos creados (instanciados) a partir de la clase tienen diferentes nombres que les da el programador.
Crear un objeto a partir de una clase significa construir el objeto; también significa instanciar.
Un programa de C ++ que usa la clase de cadena, comienza con las siguientes líneas en la parte superior del archivo:
#incluir#incluir
usando el espacio de nombres std;
La primera línea es para entrada / salida. La segunda línea es para permitir que el programa use todas las características de la clase de cadena. La tercera línea permite que el programa use los nombres en el espacio de nombres estándar.
Sobrecarga de una función
Cuando dos o más firmas de funciones diferentes tienen el mismo nombre, se dice que ese nombre está sobrecargado. Cuando se llama a una función, el número y tipo de argumentos determinan qué función se ejecuta.
Construcción
cuerda()
La siguiente declaración construye una cadena de longitud cero sin carácter.
Comienza con el nombre de la clase (tipo de objeto), cadena. A esto le sigue el nombre de la cadena del objeto, dado por el programador. El operador de asignación sigue; luego el nombre del constructor con paréntesis vacíos. Aquí, strCol es el objeto instanciado con todos los miembros de datos (propiedades) y funciones miembro (métodos).
cadena (str)
Esto es similar a lo anterior, pero toma un literal de cadena o un identificador como argumento en el constructor. La siguiente declaración ilustra esto:
Construcción con lista de inicializadores
El siguiente código ilustra esto:
cadena strCol=cuerda({'I',' ','los','o','v','Y',' ','y','o','u',' '});La cadena literal es te amo. Tenga en cuenta el carácter nulo al final de la lista de inicializadores.
cadena (str, n)
Esto forma una colección de cadenas de los primeros n caracteres de otra cadena. El siguiente código ilustra esto:
carbonizarsepag[] = 'Te quiero';cadena strCol=cuerda(pag, 6);
costo<<strCol<< ' orte';
El resultado es Me encanta con los primeros 6 personajes de Te amo. Recuerde: el espacio simple es un carácter.
cadena (str, pos, n)
Esto forma una colección de cadenas de n caracteres, comenzando desde la posición indexada de base cero, pos, de otra cadena. El siguiente código ilustra esto:
carbonizarsepag[] = 'Te quiero';cadena strCol=cuerda(pag, 2, 4);
costo<<strCol<< ' orte';
La salida es, amor.
Para los dos casos anteriores, si n es mayor que el tamaño de la cadena, se lanza la excepción out_of_range (ver más adelante).
cadena (n, 'c')
Forma una colección de n caracteres, donde todos los caracteres son iguales. Considerar,
cadena strCol=cuerda(5,'Y');costo<<strCol<< ' orte';
La salida es, eeeee, 5 e's.
Asignar una cadena
Una cadena se puede asignar de la siguiente manera, después de haber declarado ambas cadenas:
cadena strCol1=cuerda('Te quiero');cadena strCol2;
strCol2=strCol1;
costo<<strCol2<< ' orte';
La salida es, te amo.
Construyendo con iterador
Un iterador proporciona una representación genérica del escaneo, a través de los valores de una colección. Una sintaxis para crear una cadena con iterador es:
plantilla<clase InputIterator>cadena_básica(InputIterator comenzar,InputIterator final, constanteAsignador&
a=Asignador());
Esto construye una cadena para el rango [inicio, fin); vea los detalles más adelante.
Destruyendo una cuerda
Para destruir una cuerda, déjela fuera de alcance.
Acceso al elemento de clase de cadena
Un objeto de cadena instanciado puede ser sub-escrito (indexado) como una matriz. El recuento de índices comienza desde cero.
stringName [i]
La operación stringName [i] devuelve una referencia al carácter (elemento) en la ithíndice de la colección de personajes. El siguiente código genera v:
cadena strCol=cuerda('Te quiero');carbonizarsech=strCol[4];
costo<<ch<< ' orte';
stringName [i] const
La operación stringName [i] const se ejecuta en lugar de stringName [i] cuando el objeto string es un objeto constante. Se utiliza en el siguiente código, por ejemplo:
constantecadena strCol=cuerda('Te quiero');carbonizarsech=strCol[4];
costo<<ch<< ' orte';
La expresión devuelve una referencia constante a la ithelemento del objeto de cadena. Ninguno de los elementos de la cadena se puede cambiar.
Asignar un personaje con subíndice
Se puede asignar un carácter a un objeto de cadena no constante, de la siguiente manera:
cadena strCol=cuerda('Yo lo llamo');strCol[2] = 'F';
costo<<strCol<< ' orte';
La salida es que me caigo. 'C' se cambió a 'f'.
stringName.at (i)
stringName.at (i) es similar a stringName [i], pero stringName.at (i) es más confiable. El siguiente código muestra cómo debe usarse:
cadena strCol=cuerda('Te quiero');carbonizarsech=strCol.a(4);
costo<<ch<< ' orte';
at () es en realidad una función miembro de clase de cadena.
stringName.at (i) const
stringName.at (i) const es similar a stringName [i] const, pero stringName.at (i) const es más confiable. stringName.at (i) const se ejecuta en lugar de stringName.at (i) cuando el objeto string es un objeto string constante. Se utiliza en el siguiente código, por ejemplo:
constantecadena strCol=cuerda('Te quiero');carbonizarsech=strCol.a(4);
costo<<ch<< ' orte';
at () const es en realidad una función miembro de clase de cadena.
Asignar un valor con la función at ()
Se puede asignar un valor a un objeto de cadena no constante, con la función at (), de la siguiente manera:
cadena strCol=cuerda('Yo lo llamo');strCol.a(2) = 'F';
costo<<strCol<< ' orte';
La salida es que me caigo.
Problema con el sub-scripting
El problema con las sub-secuencias de comandos (indexación) es que si el índice está fuera de rango, se puede obtener un resultado incorrecto o se puede emitir un error en tiempo de ejecución.
parte delantera()
Esto devuelve una referencia al primer elemento del objeto de cadena, sin eliminar el elemento. La salida del siguiente código es 'I'.
cadena strCol=cuerda('Te quiero');carbonizarsech=strCol.parte delantera();
costo<<ch<< ' orte';
El carácter no se elimina del objeto de cadena.
frente () const
Cuando la construcción del objeto de cadena está precedida por const, se ejecuta la expresión front () const en lugar de front (). Se utiliza en el siguiente código, por ejemplo.
constantecadena strCol=cuerda('Te quiero');carbonizarsech=strCol.parte delantera();
costo<<ch<< ' orte';
Se devuelve una referencia constante. El elemento no se elimina del objeto de cadena. No se puede cambiar ningún carácter para un objeto de cadena constante.
espalda()
Esto devuelve una referencia al último elemento del objeto de cadena, sin eliminar el elemento. La salida del siguiente código es 'u'.
cadena strCol=cuerda('Te quiero');carbonizarsech=strCol.espalda();
costo<<ch<< ' orte';
atrás () const
Cuando la construcción del objeto de cadena está precedida por const, se ejecuta la expresión back () const en lugar de back (). Se utiliza en el siguiente código, por ejemplo.
constantecadena strCol=cuerda('Te quiero');carbonizarsech=strCol.espalda();
costo<<ch<< ' orte';
Se devuelve una referencia constante. El elemento no se elimina del objeto de cadena.
Capacidad de la cadena
size_type capacidad () const noexcepto
Esta función de miembro de capacidad devuelve el número total de caracteres que la cadena puede contener sin necesidad de reasignación. Un segmento de código para esto es:
cadena strCol=cuerda();En ten uno=strCol.capacidad();
costo<<en uno<< ' orte';
La salida es 15 en mi computadora.
reserva (n)
El espacio de memoria no siempre está disponible en la tienda gratuita. Se puede reservar espacio adicional con anticipación. Considere el siguiente segmento de código:
cadena strCol=cuerda('amor');strCol.reserva(6);
costo<<strCol.capacidad() << ' orte';
La salida es 15 en mi computadora.
tamaño () const no excepto
Esto devuelve el número de caracteres de la cadena. El siguiente código ilustra:
cadena strCol=cuerda('Te quiero');En ten uno=strCol.Talla();
costo<<en uno<< ' orte';
La salida es 10, que no incluye el carácter nul, 0.
longitud () const no excepto
-igual que el tamaño().Nota:Talla() <=capacidad().
encoger_para_ajustar ()
Puede reducir la capacidad () al tamaño () provocando una reasignación; no es obligatorio. El siguiente código demuestra esto:
cadena strCol=cuerda('Te quiero');strCol.reserva(12);
strCol.encoger_para_ajustar();
En ts=strCol.Talla();
costo<<s<< ' orte';
La salida es 10 y no 12 o 16. La función devuelve void.
redimensionar (sz), redimensionar (sz, ’c’)
Esto cambia el tamaño de la cuerda. Si el tamaño nuevo es más pequeño que el tamaño anterior, se borran los elementos hacia el final. Si el nuevo tamaño es más largo, se agrega algún carácter predeterminado hacia el final. Para agregar un carácter en particular, use la función resize () con dos argumentos. El siguiente segmento de código ilustra el uso de las dos funciones:
cadena strCol=cuerda('Te quiero');strCol.cambiar el tamaño(6);
costo<< 'Nuevo tamaño de strCol:' <<strCol.Talla() << ' orte';
cadena strCol1=cuerda('Me encanta', 'Y');
strCol1.cambiar el tamaño(12);
costo<< 'Nuevo tamaño de strCol1:' <<strCol1.Talla() << ' orte';
La salida es:
Nuevo tamaño de strCol: 6Nuevo tamaño de strCol1: 12
La función devuelve vacío.
claro () no excepto
Elimina todos los elementos de la cadena, como ilustra el siguiente segmento de código:
cadena strCol=cuerda('Te quiero');strCol.claro();
costo<<strCol.Talla() << ' orte';
La salida es 0. La función devuelve void.
vacío () const no excepto
Esto devuelve 1 para verdadero si no hay ningún carácter en el objeto de cadena, o 0 para falso si el objeto de cadena no está vacío. El siguiente código ilustra esto:
cadena strCol1=cuerda('Te quiero');costo<<strCol1.vacío() << ' orte';
cadena strCol2=cuerda();
costo<<strCol2.vacío() << ' orte';
La salida es:
01
Devolver iteradores y la clase de cadena
Un iterador es como un puntero pero tiene más funcionalidad que el puntero.
comenzar () no excepto
Devuelve un iterador que apunta al primer carácter (elemento) del objeto de cadena, como en el siguiente segmento de código:
cadena strCol=cuerda('Te quiero');cadena_básica<carbonizarse>::iteradoriter=strCol.empezar();
costo<< *iter<< ' orte';
La salida es 'yo'. Tenga en cuenta la forma en que se ha declarado la declaración que recibe el iterador. El iterador se desreferencia en una expresión de retorno para obtener el valor, de la misma manera que se desreferencia un puntero.
begin () const noexcept;
Devuelve un iterador que apunta al primer elemento de la colección de objetos de cadena. Cuando la construcción del objeto está precedida por const, se ejecuta la expresión begin () const en lugar de begin (). Bajo esta condición, el elemento correspondiente en el objeto no se puede modificar. Se utiliza en el siguiente código, por ejemplo.
constantecadena strCol=cuerda('Te quiero');cadena_básica<carbonizarse>::const_iteratoriter=strCol.empezar();
costo<< *iter<< ' orte';
La salida es 'yo'. Tenga en cuenta que esta vez se ha utilizado const_iterator, en lugar de solo iterador, para recibir el iterador devuelto.
fin () no excepto
Devuelve un iterador que apunta inmediatamente más allá del último elemento del objeto de cadena. Considere el siguiente segmento de código:
cadena strCol=cuerda('Te quiero');cadena_básica<carbonizarse>::iteradoriter=strCol.fin();
costo<< *iter<< ' orte';
La salida es nula, que no es nada, ya que no hay ningún elemento concreto más allá del último elemento.
end () const no excepto
Devuelve un iterador que apunta inmediatamente más allá del último elemento del objeto de cadena. Cuando la construcción del objeto de cadena está precedida por const, se ejecuta la expresión end () const en lugar de end (). Considere el siguiente segmento de código:
constantecadena strCol=cuerda('Te quiero');cadena_básica<carbonizarse>::const_iteratoriter=strCol.fin();
costo<< *iter<< ' orte';
La salida es nula. Tenga en cuenta que esta vez se ha utilizado const_iterator, en lugar de solo iterador, para recibir el iterador devuelto.
Iteración inversa
Es posible tener un iterador que itera desde el final real hasta justo antes del primer elemento:
rbegin () no excepto
Devuelve un iterador que apunta al último elemento del objeto instanciado de cadena, como en el siguiente segmento de código:
cadena strCol=cuerda('Te quiero');cadena_básica<carbonizarse>::reverse_iteratoriter=strCol.rbegin();
costo<< *iter<< ' orte';
La salida es 'u'. Tenga en cuenta la forma en que se ha declarado la declaración que recibe el iterador inverso. El iterador se desreferencia en una expresión de retorno para obtener el valor, de la misma manera que se desreferencia un puntero.
rbegin () const noexcept;
Devuelve un iterador que apunta al último elemento del objeto de cadena. Cuando la construcción del objeto está precedida por const, se ejecuta la expresión rbegin () const en lugar de rbegin (). Bajo esta condición, el elemento correspondiente en el objeto no se puede modificar. La función se utiliza en el siguiente código, por ejemplo.
constantecadena strCol=cuerda('Te quiero');cadena_básica<carbonizarse>::const_reverse_iteratoriter=strCol.rbegin();
costo<< *iter<< ' orte';
La salida es 'u'. Tenga en cuenta que esta vez se ha utilizado const_reverse_iterator, en lugar de sólo reverse_iterator, para recibir el iterador devuelto.
render () no excepto
Devuelve un iterador que apunta justo antes del primer elemento del objeto de cadena. Considere el siguiente segmento de código:
cadena strCol=cuerda('Te quiero');cadena_básica<carbonizarse>::reverse_iteratoriter=strCol.marcas();
costo<< *iter<< ' orte';
La salida es nula, que no es nada, ya que no hay ningún elemento concreto justo antes del primer elemento.
render () const no excepto
Devuelve un iterador que apunta justo antes del primer elemento del objeto de cadena. Cuando la construcción del objeto está precedida por const, se ejecuta la expresión rend () const en lugar de rend (). Considere el siguiente segmento de código:
constantecadena strCol=cuerda('Te quiero');cadena_básica<carbonizarse>::const_reverse_iteratoriter=strCol.marcas();
costo<< *iter<< ' orte';
La salida es nula. Tenga en cuenta que esta vez se ha utilizado const_reverse_iterator, en lugar de sólo reverse_iterator, para recibir el iterador devuelto.
Modificadores de cadena
Un modificador que modifica el objeto de cadena, también puede tomar o devolver un iterador.
Anexando
cadena_básica&operador+=(constantecadena_básica&pag)Agrega el objeto de cadena de la derecha al objeto de cadena de la izquierda. Ejemplo:
cadena strCol1=cuerda('Me encanta');cadena strCol2=cuerda(' usted');
strCol1+=strCol2;
costo<<strCol1<< ' orte';
La salida es te amo. No olvide que strCol1 + = strCol2 es lo mismo que strCol1 = strCol1 + strCol2.
cadena_básica & operador + = (const charT * s)
Agrega un literal de cadena a una colección de objetos de cadena. Ejemplo:
cadena strCol=cuerda('Me encanta');strCol+= ' usted';
costo<<strCol<< ' orte';
Salida: te amo.
cadena_básica & operador + = (charT c)
Agrega un solo carácter a una cadena de objeto. Ejemplo:
cadena strCol=cuerda('Te amo');strCol+= 'u';
costo<<strCol<< ' orte';
Salida: te amo.
cadena_básica & operador + = (lista_inicializador)
Añade una lista de inicializadores. Ejemplo:
cadena strCol=cuerda('Me encanta');strCol+= {' ','y','o','u',' '};
costo<<strCol<< ' orte';
Salida: te amo. Siempre es bueno agregar nul, 0 al final de una lista de inicializadores de caracteres.
cadena_básica y añadir (const cadena_básica y str)
Añade el objeto de cadena de argumento al objeto de cadena principal. Ejemplo:
cadena strCol1=cuerda('Me encanta');cadena strCol2=cuerda(' usted');
strCol1.adjuntar(strCol2);
costo<<strCol1<< ' orte';
Salida: te amo.
cadena_básica y anexar (const charT * s)
Agrega un argumento literal de cadena a la cadena principal. Ejemplo
cadena strCol=cuerda('Me encanta');strCol=strCol.adjuntar(' usted');
costo<<strCol<< ' orte';
Salida: te amo.
cadena_básica y anexar (lista_inicializador)
Agrega la lista de inicializadores, que es un argumento, a la cadena principal. Ejemplo:
cadena strCol=cuerda('Me encanta');strCol=strCol.adjuntar({' ','y','o','u',' '});
costo<<strCol<< ' orte';
Salida: te amo. Siempre es bueno agregar el carácter nul, 0 al final de una lista de inicializadores.
cadena_básica y anexar (tipo_tamaño n, charT c)
Agrega n del mismo carácter. Ejemplo:
cadena strCol=cuerda('pestaña');strCol=strCol.adjuntar(2, 'o');
costo<<strCol<< ' orte';
Salida: tabú.
cadena_básica y anexar (const charT * s, size_type n)
Agrega los primeros n elementos de un literal de cadena al objeto de cadena principal. Ejemplo:
cadena strCol=cuerda('Me encanta');strCol=strCol.adjuntar(' tú tan', 4);
costo<<strCol<< ' orte';
El resultado es: te amo. Si n es mayor que la longitud del literal, se lanza una excepción length_error.
cadena_básica & append (const cadena_básica & str, pos_tipo_tamaño, tipo_tamaño n = npos)
Agrega n caracteres del índice, pos a la cadena principal. Ejemplo:
cadena strCol=cuerda('Me encanta');strCol=strCol.adjuntar(eres tan, 2, 4);
costo<<strCol<< ' orte';
Salida: te amo. También se lanzaría una excepción aquí, ver más adelante.
Asignar
cadena_básica&asignar(constantecadena_básica&pag)Asigna el objeto de cadena de argumento a la cadena principal, reemplazando cualquier contenido que estuviera allí.
cadena strCol1=cuerda('Te quiero');cadena strCol2=cuerda('Ella me necesita');
strCol1=strCol1.asignar(strCol2);
costo<<strCol1<< ' orte';
Resultado: Ella me necesita.
cadena_básica&asignar(constantegráfico*s)Asigna un argumento literal de cadena a la cadena principal, reemplazando cualquier contenido que estuviera allí.
cadena strCol=cuerda('Te quiero');strCol=strCol.asignar('Ella me necesita');
costo<<strCol<< ' orte';
Resultado: Ella me necesita.
cadena_básica&asignar(initializer_list<gráfico>)Asigna un argumento de lista de inicializadores a la cadena principal,reemplazando cualquier contenido que estaba allí.
[cc lang='c'escapado='cierto'ancho='780']
cadena strCol=cuerda('Te quiero');
strCol=strCol.asignar({'S','h','Y',' ','norte','Y','Y','D','s',' ','metro','Y',' '});
costo<<strCol<< ' orte';
Resultado: Ella me necesita. Es bueno agregar siempre nul, 0 al final de la lista de caracteres, para formar una cadena literal.
cadena_básica&asignar(constantegráfico*s,size_type n)Asigna los primeros n caracteres de un argumento literal de cadena a la cadena principal, reemplazando cualquier contenido que estuviera allí.
cadena strCol=cuerda('Te quiero');strCol=strCol.asignar('Ella me necesita', 9);
costo<<strCol<< ' orte';
Resultado: Ella necesita.
cadena_básica&asignar(size_type n,charT c)Asigna un argumento de n de los mismos caracteres a la cadena principal, reemplazando cualquier contenido que estuviera allí.
cadena strCol=cuerda('Te quiero');strCol=strCol.asignar(4, 'Y');
costo<<strCol<< ' orte';
Salida: eeee
cadena_básica&asignar(constantecadena_básica&pag,size_type pos,size_type n=npos)
Asigna n caracteres de un argumento de objeto de cadena, comenzando desde pos, a la cadena principal, reemplazando cualquier contenido que estuviera allí.
cadena strCol=cuerda('Te quiero');strCol=strCol.asignar('Ella me necesita', 4, 5);
costo<<strCol<< ' orte';
Salida: necesidades. Lanzaría una excepción - ver más tarde.
Insertar
cadena_básica&insertar(size_type pos, constantecadena_básica&pag)Inserta el argumento del objeto de cadena en la cadena principal, en el índice, pos.
cadena strCol1=cuerda('Te quiero');cadena strCol2=cuerda('odio y');
strCol1=strCol1.insertar(2,strCol2);
costo<<strCol1<< ' orte';
Resultado: Te odio y te amo. Lanzaría una excepción - ver más tarde.
cadena_básica&insertar(size_type pos1, constantecadena_básica&pag,size_type pos2,size_type n=npos)
Inserta una longitud de n caracteres desde pos2 del argumento del objeto de cadena, hasta la cadena principal, en el índice, pos1.
cadena strCol1=cuerda('Te quiero');cadena strCol2=cuerda('odiar, querer y necesitar');
strCol1=strCol1.insertar(2,strCol2, 6, 9);
costo<<strCol1<< ' orte';
Salida: Te quiero y te amo.
inserción de iterador (const_iterator p, charT c)
Inserta un carácter particular, que es un argumento, en la posición apuntada por el iterador. Devuelve un iterador para la posición del carácter recién insertado.
cadena strCol=cuerda('Te quiero');cadena_básica<carbonizarse>::iteradoriter=strCol.empezar();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
cadena_básica<carbonizarse>::iteradorla red=strCol.insertar(iter, 'D');
costo<< *la red<< ' orte';
costo<<strCol<< ' orte';
La salida es:
'D'
yo te amaba
inserción de iterador (const_iterator p, size_type n, charT c)
Inserta n del mismo carácter del argumento, en la posición a la que apunta el iterador. Devuelve un iterador para la posición del comienzo de los mismos caracteres recién insertados.
cadena strCol=cuerda(Pestaña en la tierra.);cadena_básica<carbonizarse>::iteradoriter=strCol.empezar();
++iter; ++iter; ++iter;
cadena_básica<carbonizarse>::iteradorla red=strCol.insertar(iter, 2, 'o');
costo<< *la red<< ' orte';
costo<<strCol<< ' orte';
La salida es:
‘o’
Tabú en la tierra.
cadena_básica&insertar(size_type pos, constantegráfico*s)Inserta un literal de cadena de argumento en el índice, pos en la cadena principal.
cadena strCol=cuerda(Pestaña en la tierra.);strCol=strCol.insertar(3, 'oo');
costo<<strCol<< ' orte';
Resultado: Tabú en la tierra.
cadena_básica&insertar(size_type pos, constantegráfico*s,size_type n)Inserta los primeros n caracteres del literal de la cadena de argumentos, en el índice, pos en la cadena principal.
cadena strCol=cuerda(Pestaña en la tierra.);strCol=strCol.insertar(3, 'oooo', 2);
costo<<strCol<< ' orte';
Resultado: Tabú en la tierra.
Reemplazo
cadena_básica&reemplazar(size_type pos1,size_type n1, constantecadena_básica&pag))Reemplaza n1 caracteres en el objeto de cadena principal del índice, pos1, con el objeto de cadena de argumento.
cadena strCol1=cuerda('Te quiero');cadena strCol2=cuerda('te odio y');
strCol1=strCol1.reemplazar(2, 4,strCol2);
costo<<strCol1<< ' orte';
Resultado: Te odio a ti y a ti. Lanzaría una excepción - ver más tarde.
cadena_básica&reemplazar(size_type pos1,size_type n1, constantecadena_básica&pag,size_type pos2,size_type n2=npos)
Reemplaza n1 caracteres en el objeto de cadena principal del índice, pos1, con n2 caracteres del objeto de cadena de argumentos del índice, pos2.
cadena strCol1=cuerda('Te quiero');cadena strCol2=cuerda('lo odiamos a él y a ella');
strCol1=strCol1.reemplazar(2, 4,strCol2, 3, 12);
costo<<strCol1<< ' orte';
Resultado: Lo odio a él y a ti.
cadena_básica&reemplazar(size_type pos1,size_type n1, constantegráfico*s,size_type n2)
Reemplaza n1 caracteres en el objeto de cadena principal del índice, pos1, con los primeros n2 caracteres del argumento de cadena literal.
cadena strCol1=cuerda('Te quiero');strCol1=strCol1.reemplazar(2, 4, 'odiarlo a él y a ella', 12);
costo<<strCol1<< ' orte';
Resultado: Lo odio a él y a ti.
basic_string & replace (size_type pos, size_type n, const charT * s)
Reemplaza n caracteres en el objeto de cadena principal del índice, pos, con el argumento de cadena literal.
cadena strCol1=cuerda('Te quiero');strCol1=strCol1.reemplazar(2, 4, 'odiarlo y');
costo<<strCol1<< ' orte';
Resultado: Lo odio a él y a ti.
cadena_básica&reemplazar(size_type pos1,size_type n1,size_type n2,charT c)Reemplaza n1 caracteres en el objeto de cadena principal del índice, pos1, con n2 del mismo carácter del argumento.
cadena strCol1=cuerda(Hay una tablilla mala.);strCol1=strCol1.reemplazar(9, 3, 2, 'o');
costo<<strCol1<< ' orte';
Resultado: Hay un mal tabú ...
borrado de iterador (const_iterator p)
Elimina un carácter en la posición señalada por el iterador; luego devuelve la posición del iterador, que ahora está ocupada por el carácter que estaba al lado de este carácter (o end ()). El siguiente código ilustra esto:
cadena strCol=cuerda('a B C D');cadena_básica<carbonizarse>::iteradoriter=strCol.empezar();
++iter; ++iter;
strCol.borrar(iter);
costo<<strCol[0] << ' ' <<strCol[1] << '
' <<strCol[2]<< ' orte';
La salida: a b d
cadena_básica&borrar(size_type pos= 0,size_type n=npos)Elimina n caracteres del índice, pos.
cadena strCol=cuerda('a B C D');strCol.borrar(1, 2);
costo<<strCol[0] << ' ' <<strCol[1] << ' orte';
Salida: a d
anular push_back (charT c)
Para agregar un solo carácter al final de la cadena:
cadena strCol=cuerda('a B C D');strCol.hacer retroceder('5');
costo<<strCol<< ' orte';
Salida: abcd5
void pop_back ()
Elimina el último carácter sin devolverlo. El tamaño de la cuerda se reduce en 1.
cadena strCol=cuerda('a B C D e');strCol.pop_back();
costo<<strCol<< ' orte';
Salida: abcd
intercambio vacío (cadena_básica & s)
Los literales de dos objetos de cadena se pueden intercambiar.
cadena strCol1=cuerda(<ayuda='post-69618 -__ DdeLink__781_3724385525'>a>'a B C D e');cadena strCol2=cuerda('1234567');
strCol1.intercambio(strCol2);
costo<<strCol1<< ' orte';
costo<<strCol2<< ' orte';
La salida es:
'1234567''a B C D e'
Operaciones de cadena
const charT * c_str () const no excepto
Devuelve un puntero al primer elemento de la cadena. El puntero se puede incrementar.
constantecadena strCol=cuerda('a B C D e');constante carbonizarse*pag=strCol.c_str();
costo<< *pag<< ' orte';
++pag;
costo<< *pag<< ' orte';
La salida es:
ab
Debido a la segunda constante en el encabezado, el programa no puede cambiar ningún carácter en la cadena. La construcción está precedida por const.
const charT * data () const noexcepto
Devuelve un puntero al primer elemento de la cadena. El puntero se puede incrementar.
constantecadena strCol=cuerda('a B C D e');constante carbonizarse*pag=strCol.datos();
costo<< *pag<< ' orte';
++pag;
costo<< *pag<< ' orte';
La salida es:
ab
Debido a la segunda constante en el encabezado, el programa no puede cambiar ningún carácter en la cadena. La construcción está precedida por const.
basic_string substr (size_type pos = 0, size_type n = npos) const
Devuelve un objeto de cadena de n caracteres para la subcadena que comienza en el índice, pos.
constantecadena strCol=cuerda('abcdefghij');constantestring retStr=strCol.substr(2, 4);
costo<<retStr<< ' orte';
Salida: cdef
Find () Funciones de miembro
size_type find (const basic_string & str, size_type pos = 0) const noexcept
Busca un objeto de subcadena a partir del índice, pos. Si se encuentra, devuelve el comienzo de la subcadena en la cadena principal.
cadena strCol=cuerda('¡Somos el Mundo!');cadena strCol1=cuerda('los');
En ten uno=strCol.encontrar(strCol1, 2);
costo<<en uno<< ' orte';
Producción:
índice: 7Devuelve -1, cuando no se encuentra.
size_type find (const charT * s, size_type pos = 0) const
Busca un literal de subcadena que comience en el índice, pos. Si se encuentra, devuelve el comienzo de la subcadena en la cadena principal.
cadena strCol=cuerda('¡Somos el Mundo!');En ten uno=strCol.encontrar('están', 0);
costo<<en uno<< ' orte';
Dado que pos = 0 es el valor predeterminado, se podría haber omitido 0 en el argumento.
Salida: 3
Devuelve -1, cuando no se encuentra.
size_type find (const charT * s, size_type pos, size_type n) const
Busca los primeros n caracteres de un literal de subcadena que comienza en el índice, pos. Si se encuentra, devuelve el comienzo de la subcadena en la cadena principal.
cadena strCol=cuerda('El chico más grande');En ten uno=strCol.encontrar('más grande', 1, 3);
costo<<en uno<< ' orte';
Salida: 4
Devuelve -1, cuando no se encuentra.
size_type find (charT c, size_type pos = 0) const
Busca el carácter, c a partir del índice, pos. Si se encuentra, devuelve el comienzo de la subcadena en la cadena principal. Si no se encuentra, devuelve -1.
cadena strCol=cuerda('¡Somos el Mundo!');En ten uno=strCol.encontrar('Con');
costo<<en uno<< ' orte';
Salida: -1
Existen las siguientes funciones miembro de búsqueda inversa ():
size_type rfind(constantecadena_básica&pag,size_type pos=npos) constanteno excepto;size_type rfind(constantegráfico*s,size_type pos=npos) constante;
size_type rfind(constantegráfico*s,size_type pos,size_type n) constante;
size_type rfind(charT c,size_type pos=npos) constante;
Funciones de los miembros de comparación
int compare (const basic_string & str) const noexcept
Compara el objeto de cadena de argumentos con el objeto de cadena principal. Si la cadena principal aparece antes del argumento (en el diccionario), devuelve un número positivo. Si ocurre después de la cadena principal, devuelve un número negativo. Si las dos cadenas son iguales, devuelve cero.
cadena strCol1=cuerda('multitud');cadena strCol2=cuerda('gente');
En ten uno=strCol1.comparar(strCol2);
costo<<en uno<< ' orte';
Salida: -13
int compare (const charT * s) const
Igual que el anterior, pero el argumento es una cadena literal.
cadena strCol1=cuerda('gente');En ten uno=strCol1.comparar('gente');
costo<<en uno<< ' orte';
Salida: 0
Operadores de cadenas
Estos operadores son aplicables a objetos de cadena y no necesariamente a literales de cadena.
+
Concatena dos objetos de cadena y devuelve la concatenación.
cadena strCol1=cuerda('bailando');cadena strCol2=cuerda(' la luna');
cadena strCol=strCol1+strCol2;
costo<<strCol<< ' orte';
Resultado: bailando en la luna.
==
Devuelve 1 para verdadero, si los objetos de cadena son los mismos; y cero para falso, si no lo son.
cadena strCol1=cuerda('bailando');cadena strCol2=cuerda(' en la Luna');
bool bl=strCol1==strCol2;
costo<<licenciado en Derecho<< ' orte';
Salida: 0
!=
Devuelve 1 si los objetos de cadena no son iguales y cero si lo son.
cadena strCol1=cuerda('bailando');cadena strCol2=cuerda(' en la Luna');
bool bl=strCol1!=strCol2;
costo<<licenciado en Derecho<< ' orte';
Salida: 1
<
Devuelve 1, si el operando izquierdo es menor que el operando derecho según el diccionario, o cero si no lo es.
cadena strCol1=cuerda('bailando');cadena strCol2=cuerda(' en la Luna');
bool bl=strCol1<strCol2;
costo<<licenciado en Derecho<< ' orte';
Salida: 0
Para los caracteres ordinarios en C ++, en orden ascendente, los números van antes de las letras mayúsculas, que vienen antes de las minúsculas. El carácter de espacio viene antes de cero y todos ellos.
Tipos de caracteres de cadena principal de C ++
carbonizarse
El tipo char es el tipo C ++ original y normalmente almacenaría un carácter en 8 bits.
char16_t
Esto almacena un carácter en 16 bits.
char32_t
Esto almacena un carácter en 32 bits.
wchar_t
char16_t y char32_t son caracteres anchos. wchar_t es un carácter amplio que es propietario y está definido por la implementación.
Estos tipos se denominan rasgos. Sin embargo, C ++ se refiere técnicamente a ellos como especializaciones de rasgos. Este artículo se ha centrado en el tipo char. El enfoque de los otros tipos es ligeramente diferente, ver más adelante.
Otras funciones de miembro de operación de cadena
Las firmas de otras funciones de operación de cadenas son:
size_type find_first_of(constantecadena_básica&pag,size_type pos= 0) constanteno excepto;size_type find_first_of(constantegráfico*s,size_type pos,size_type n) constante;
size_type find_first_of(constantegráfico*s,size_type pos= 0) constante;
size_type find_first_of(charT c,size_type pos= 0) constante;
size_type find_last_of(constantecadena_básica&pag,size_type pos=npos) constanteno excepto;
size_type find_last_of(constantegráfico*s,size_type pos,size_type n) constante;
size_type find_last_of(constantegráfico*s,size_type pos=npos) constante;
size_type find_last_of(charT c,size_type pos=npos) constante;
size_type find_first_not_of(constantecadena_básica&pag,size_type pos= 0) constanteno excepto;
size_type find_first_not_of(constantegráfico*s,size_type pos,size_type n) constante;
size_type find_first_not_of(constantegráfico*s,size_type pos= 0) constante;
size_type find_first_not_of(charT c,size_type pos= 0) constante;
size_type find_last_not_of(constantecadena_básica&pag,size_type pos=npos) constanteno excepto;
size_type find_last_not_of(constantegráfico*s,size_type pos,size_type n) constante;
size_type find_last_not_of(constantegráfico*s,size_type pos=npos) constante;
size_type find_last_not_of(charT c,size_type pos=npos) constante;
Conclusión
C ++ tiene literales de cadena y objetos de cadena. El objeto de cadena tiene una colección de caracteres en secuencia, similar a una matriz de caracteres en secuencia. La diferencia entre la colección de cadenas y una matriz es que la colección de cadenas puede aumentar o reducir su longitud. Un objeto de cadena se instancia (construye) a partir de una clase de cadena. Un objeto de cadena es una estructura de datos con funciones miembro. Las funciones miembro se pueden clasificar bajo los encabezados de construcción de objetos, acceso a elementos, capacidad de cadena, funciones miembro de cadena con argumentos de iterador y tipos de retorno, y modificadores de cadena. También existen operadores relacionales y de igualdad de cadenas.