Classe i objectes
Una classe és un conjunt de variables i funcions que funcionen juntes; on les variables no tenen assignats valors. Quan s’assignen valors a les variables, la classe es converteix en un objecte. Els diferents valors donats a una mateixa classe donen lloc a objectes diferents; és a dir, diferents objectes són la mateixa classe amb valors diferents. Es diu que la creació d’un objecte a partir d’una classe instancia l’objecte.
El nom, string, és una classe. Un objecte creat a partir de la classe de cadena té un nom triat pel programador.
Es necessita una funció que pertany a la classe per crear un objecte de la classe. A C ++, aquesta funció té el mateix nom que el nom de la classe. Els objectes creats (instanciats) a partir de la classe tenen diferents noms donats pel programador.
Crear un objecte a partir d’una classe significa construir l’objecte; també vol dir instàncies.
Un programa C ++ que utilitza la classe string, comença amb les línies següents a la part superior del fitxer:
#incloure#incloure
utilitzant l'espai de noms std;
La primera línia és per a l'entrada / sortida. La segona línia és permetre al programa utilitzar totes les funcions de la classe de cadena. La tercera línia permet al programa utilitzar els noms a l’espai de noms estàndard.
Sobrecàrrega d'una funció
Quan dues o més signatures de funció diferents tenen el mateix nom, es diu que aquest nom està sobrecarregat. Quan es crida una funció, el nombre i el tipus d'arguments, determineu quina funció s'executa.
Construcció
string ()
La següent instrucció construeix una cadena de longitud zero sense cap caràcter.
Comença amb el nom de la classe (tipus d'objecte), cadena. Tot seguit el nom de la cadena d'objecte, que dóna el programador. Segueix l'operador d'assignació; a continuació, el nom del constructor amb parèntesis buits. Aquí, strCol és l'objecte instantani amb tots els membres de dades (propietats) i funcions de membre (mètodes).
cadena (str)
Això és similar a l'anterior, però pren una cadena literal o un identificador com a argument al constructor. La següent afirmació il·lustra això:
Construcció amb llista d’inicialitzadors
El següent codi ho il·lustra:
string strCol=corda({'Jo','','el','O','v','I','','I','O','tu',' 0'});La cadena literal és I love you. Tingueu en compte el caràcter nul al final de la llista d'inicialitzadors.
cadena (str, n)
Això forma una col·lecció de cadenes, dels primers n caràcters d’una altra cadena. El següent codi ho il·lustra:
charpàg[] = 'T'estimo';string strCol=corda(pàg, 6);
cost<<strCol<< ' n';
La sortida és M’encanta amb els 6 primers personatges de M’estimo. Recordeu: l'espai únic és un personatge.
cadena (str, pos, n)
Això forma una col·lecció de cadenes de n caràcters, que comença des de la posició indexada basada en zero, pos, d'una altra cadena. El següent codi ho il·lustra:
charpàg[] = 'T'estimo';string strCol=corda(pàg, 2, 4);
cost<<strCol<< ' n';
La sortida és, amor.
Per als dos casos anteriors, si n és superior a la mida de la cadena, es llança l'excepció out_of_range (vegeu més endavant).
cadena (n, 'c')
Forma una col·lecció de n caràcters, on tots els personatges són iguals. Penseu en,
string strCol=corda(5,'I');cost<<strCol<< ' n';
La sortida és, eeeee, 5 e’s.
Assignació d'una cadena
Es pot assignar una cadena de la següent manera, després d'haver declarat les dues cadenes:
string strCol1=corda('T'estimo');string strCol2;
strCol2=strCol1;
cost<<strCol2<< ' n';
La sortida és: t'estimo.
Construint amb Iterator
Un iterador proporciona una representació genèrica de l'escaneig a través dels valors d'una col·lecció. Una sintaxi per crear una cadena amb l'iterador és:
plantilla<classe InputIterator>cadena_bàsica(Comença InputIterator,Final InputIterator, constAssignador&
a=Assignador());
Això construeix una cadena per a l'interval [begin, end) - vegeu els detalls més endavant.
Destruint una corda
Per destruir una cadena, deixeu-la fora de l'abast.
Accés a l'element de classe de cadena
Un objecte de cadena instantània es pot subescriure (indexar) com una matriu. El recompte d’índexs comença des de zero.
stringName [i]
L'operació stringName [i] retorna una referència al caràcter (element) de l'ithíndex de la col·lecció de personatges. El codi següent genera v:
string strCol=corda('T'estimo');charcap=strCol[4];
cost<<cap<< ' n';
stringName [i] const
L'operació stringName [i] const s'executa en lloc de stringName [i] quan l'objecte string és un objecte constant. S'utilitza al codi següent, per exemple:
conststring strCol=corda('T'estimo');charcap=strCol[4];
cost<<cap<< ' n';
L’expressió retorna una referència constant a la ithelement de l'objecte string. No es pot canviar cap dels elements de la cadena.
Assignació d'un caràcter amb el subíndex
Es pot assignar un caràcter a un objecte de cadena no constant, de la manera següent:
string strCol=corda('Truco');strCol[2] = 'f';
cost<<strCol<< ' n';
La sortida és Caiguda. 'C' es va canviar per 'f'.
stringName.at (i)
stringName.at (i) és similar a stringName [i], però stringName.at (i) és més fiable. El codi següent mostra com s’ha d’utilitzar:
string strCol=corda('T'estimo');charcap=strCol.a(4);
cost<<cap<< ' n';
at () és en realitat una funció de membre de classe de cadena.
stringName.at (i) const
stringName.at (i) const és similar a stringName [i] const, però stringName.at (i) const és més fiable. stringName.at (i) const s'executa en lloc de stringName.at (i) quan l'objecte string és un objecte constant de cadena. S'utilitza al codi següent, per exemple:
conststring strCol=corda('T'estimo');charcap=strCol.a(4);
cost<<cap<< ' n';
at () const és en realitat una funció membre de classe de cadena.
Assignació d'un valor amb la funció at ()
Es pot assignar un valor a un objecte de cadena no constant, amb la funció at (), de la següent manera:
string strCol=corda('Truco');strCol.a(2) = 'f';
cost<<strCol<< ' n';
La sortida és Caiguda.
Problema amb la subescriptura
El problema amb la subescriptura (indexació) és que si l’índex està fora de rang, es pot obtenir un resultat incorrecte o es pot produir un error en temps d’execució.
front ()
Això retorna una referència al primer element de l'objecte de cadena, sense eliminar-lo. La sortida del codi següent és 'I'.
string strCol=corda('T'estimo');charcap=strCol.frontal();
cost<<cap<< ' n';
El caràcter no s’elimina de l’objecte de cadena.
front () const
Quan la construcció de l'objecte de cadena està precedida per const, l'expressió front () const s'executa en lloc de front (). S'utilitza al codi següent, per exemple.
conststring strCol=corda('T'estimo');charcap=strCol.frontal();
cost<<cap<< ' n';
Es torna una referència constant. L'element no s'elimina de l'objecte de cadena. No es pot canviar cap caràcter per a un objecte de cadena constant.
esquena()
Retorna una referència a l'últim element de l'objecte de cadena, sense eliminar-lo. La sortida del codi següent és 'u'.
string strCol=corda('T'estimo');charcap=strCol.esquena();
cost<<cap<< ' n';
back () const
Quan la construcció de l'objecte de cadena està precedida per const, l'expressió back () const s'executa en lloc de back (). S'utilitza al codi següent, per exemple.
conststring strCol=corda('T'estimo');charcap=strCol.esquena();
cost<<cap<< ' n';
Es torna una referència constant. L'element no s'elimina de l'objecte cadena.
Capacitat de corda
size_type capacity () const no excepte
Aquesta funció membre de la capacitat retorna el nombre total de caràcters que pot contenir la cadena sense necessitat de reassignació. Un segment de codi per a això és:
string strCol=corda();inten un=strCol.capacitat();
cost<<en un<< ' n';
La sortida és 15 al meu ordinador.
reserva (n)
L’espai de memòria no sempre està disponible a la botiga gratuïta. Es pot reservar espai addicional amb antelació. Penseu en el segment de codi següent:
string strCol=corda('amor');strCol.reserva(6);
cost<<strCol.capacitat() << ' n';
La sortida és 15 al meu ordinador.
size () const no excepte
Retorna el nombre de caràcters de la cadena. El següent codi il·lustra:
string strCol=corda('T'estimo');inten un=strCol.mida();
cost<<en un<< ' n';
La sortida és 10, que no inclou el caràcter nul, 0.
length () const no excepte
-igual que la mida().Nota:mida() <=capacitat().
shrink_to_fit ()
Pot reduir la capacitat () a mida () provocant una reassignació; no és obligatori. El codi següent ho demostra:
string strCol=corda('T'estimo');strCol.reserva(12);
strCol.encongir-se per adaptar-se();
ints=strCol.mida();
cost<<s<< ' n';
La sortida és 10 i no 12 o 16. La funció torna nul·la.
canviar la mida (sz), canviar la mida (sz, 'c')
Això canvia la mida de la cadena. Si la mida nova és més petita que la mida anterior, els elements cap al final s’esborren. Si la mida nova és més llarga, s’afegirà algun caràcter per defecte cap al final. Per afegir un caràcter concret, utilitzeu la funció resize () amb dos arguments. El següent segment de codi il·lustra l’ús de les dues funcions:
string strCol=corda('T'estimo');strCol.canviar la mida(6);
cost<< 'Nova mida de strCol:' <<strCol.mida() << ' n';
string strCol1=corda('Estimo', 'I');
strCol1.canviar la mida(12);
cost<< 'Nova mida de strCol1:' <<strCol1.mida() << ' n';
La sortida és:
Nova mida de strCol: 6Nova mida de strCol1: 12
La funció torna nul·la.
clear () sense excepte
Elimina tots els elements de la cadena, tal com il·lustra el segment de codi següent:
string strCol=corda('T'estimo');strCol.clar();
cost<<strCol.mida() << ' n';
La sortida és 0. La funció torna nul·la.
empty () const noexcept
Això retorna 1 per a cert si no hi ha cap caràcter a l'objecte de cadena, o 0 per a fals si l'objecte de cadena no està buit. El següent codi ho il·lustra:
string strCol1=corda('T'estimo');cost<<strCol1.buit() << ' n';
string strCol2=corda();
cost<<strCol2.buit() << ' n';
La sortida és:
01
Iteradors retornats i la classe de corda
Un iterador és com un punter però té més funcionalitats que el punter.
begin () noexcept
Retorna un iterador que apunta al primer caràcter (element) de l'objecte de cadena, com al segment de codi següent:
string strCol=corda('T'estimo');cadena_bàsica<char> ::iteradoriter=strCol.començar();
cost<< *iter<< ' n';
La sortida és ‘jo’. Tingueu en compte la forma en què s'ha declarat la declaració que rep l'iterador. L'iterador es desferencia en una expressió de retorn per obtenir el valor, de la mateixa manera, que es desferencia un punter.
begin () const noexcept;
Retorna un iterador que apunta al primer element de la col·lecció d'objectes de cadena. Quan la construcció de l'objecte va precedida de const, l'expressió begin () const s'executa en lloc de begin (). En aquesta condició, no es pot modificar l'element corresponent de l'objecte. S'utilitza al codi següent, per exemple.
conststring strCol=corda('T'estimo');cadena_bàsica<char> ::const_iteratoriter=strCol.començar();
cost<< *iter<< ' n';
La sortida és ‘jo’. Tingueu en compte que aquesta vegada s’ha utilitzat const_iterator, en lloc de només iterador, per rebre l’iterador retornat.
end () sense excepte
Retorna un iterador que apunta immediatament més enllà de l'últim element de l'objecte de cadena. Penseu en el segment de codi següent:
string strCol=corda('T'estimo');cadena_bàsica<char> ::iteradoriter=strCol.final();
cost<< *iter<< ' n';
La sortida és nul·la, que no és res, ja que no hi ha cap element concret més enllà de l’últim element.
end () const noexcept
Retorna un iterador que apunta immediatament més enllà de l'últim element de l'objecte de cadena. Quan la construcció de l'objecte de cadena està precedida per const, l'expressió end () const s'executa en lloc de end (). Penseu en el segment de codi següent:
conststring strCol=corda('T'estimo');cadena_bàsica<char> ::const_iteratoriter=strCol.final();
cost<< *iter<< ' n';
La sortida és nul·la. Tingueu en compte que aquesta vegada s’ha utilitzat const_iterator, en lloc de només iterador, per rebre l’iterador retornat.
Iteració inversa
És possible tenir un iterador que iteri des del final real fins just abans del primer element:
rbegin () sense excepte
Retorna un iterador que apunta a l'últim element de l'objecte instantani de cadena, tal com es fa al següent segment de codi:
string strCol=corda('T'estimo');cadena_bàsica<char> ::inversor_iteradoriter=strCol.rbegin();
cost<< *iter<< ' n';
La sortida és 'u'. Tingueu en compte la forma en què s'ha declarat la declaració que rep l'iterador invers. L'iterador es desferencia en una expressió de retorn per obtenir el valor, de la mateixa manera, que es desferencia un punter.
rbegin () const noexcept;
Retorna un iterador que apunta a l'últim element de l'objecte de cadena. Quan la construcció de l'objecte va precedida de const, l'execució rbegin () const s'executa en lloc de rbegin (). En aquesta condició, no es pot modificar l'element corresponent de l'objecte. La funció s'utilitza al codi següent, per exemple.
conststring strCol=corda('T'estimo');cadena_bàsica<char> ::const_reverse_iteratoriter=strCol.rbegin();
cost<< *iter<< ' n';
La sortida és 'u'. Tingueu en compte que aquesta vegada s’ha utilitzat const_reverse_iterator, en lloc de només reverse_iterator, per rebre l’iterador retornat.
render () sense excepte
Retorna un iterador que apunta just abans del primer element de l'objecte de cadena. Penseu en el segment de codi següent:
string strCol=corda('T'estimo');cadena_bàsica<char> ::inversor_iteradoriter=strCol.fabrica();
cost<< *iter<< ' n';
La sortida és nul·la, cosa que no és res, ja que no hi ha cap element concret just abans del primer element.
render () const noexcept
Retorna un iterador que apunta just abans del primer element de l'objecte de cadena. Quan la construcció de l'objecte és precedida per const, l'expressió rend () const s'executa en lloc de rend (). Penseu en el segment de codi següent:
conststring strCol=corda('T'estimo');cadena_bàsica<char> ::const_reverse_iteratoriter=strCol.fabrica();
cost<< *iter<< ' n';
La sortida és nul·la. Tingueu en compte que aquesta vegada s’ha utilitzat const_reverse_iterator, en lloc de només reverse_iterator, per rebre l’iterador retornat.
Modificadors de cadena
Un modificador que modifica l'objecte de cadena també pot prendre o retornar un iterador.
Adjunt
cadena_bàsica&operador+ =(constcadena_bàsica&pàg)Afegeix l'objecte de la cadena dreta a l'objecte de la cadena esquerra. Exemple:
string strCol1=corda('Estimo');string strCol2=corda(' vostè');
strCol1+ =strCol2;
cost<<strCol1<< ' n';
La sortida és I love you. No oblideu que strCol1 + = strCol2 és el mateix que strCol1 = strCol1 + strCol2.
basic_string & operator + = (const charT * s)
Afegeix un literal de cadena a una col·lecció d'objectes de cadena. Exemple:
string strCol=corda('Estimo');strCol+ = ' vostè';
cost<<strCol<< ' n';
Sortida: t'estimo.
basic_string & operator + = (gràfic c)
Afegeix un sol caràcter a una cadena d'objecte. Exemple:
string strCol=corda('M'encanta jo');strCol+ = 'tu';
cost<<strCol<< ' n';
Sortida: t'estimo.
basic_string & operator + = (llista_inicialitzador)
Afegeix una llista d'inicialitzadors. Exemple:
string strCol=corda('Estimo');strCol+ = {'','I','O','tu',' 0'};
cost<<strCol<< ' n';
Sortida: t'estimo. Sempre és bo afegir el nul, 0 al final d'una llista d'inicialitzadors de caràcters.
basic_string & append (const basic_string & str)
Afegeix l’objecte de cadena d’argument a l’objecte de cadena principal. Exemple:
string strCol1=corda('Estimo');string strCol2=corda(' vostè');
strCol1.afegir(strCol2);
cost<<strCol1<< ' n';
Sortida: t'estimo.
basic_string & append (const charT * s)
Afegeix un argument literal de cadena a la cadena principal. Exemple
string strCol=corda('Estimo');strCol=strCol.afegir(' vostè');
cost<<strCol<< ' n';
Sortida: t'estimo.
basic_string & append (initializer_list)
Afegeix la llista d'inicialitzadors, que és un argument, a la cadena principal. Exemple:
string strCol=corda('Estimo');strCol=strCol.afegir({'','I','O','tu',' 0'});
cost<<strCol<< ' n';
Sortida: t'estimo. Sempre és bo afegir el caràcter nul, 0 al final d'una llista d'inicialitzadors.
basic_string & append (size_type n, charT c)
Afegeix n del mateix caràcter. Exemple:
string strCol=corda('fitxa');strCol=strCol.afegir(2, 'O');
cost<<strCol<< ' n';
Sortida: tabú.
basic_string & append (const charT * s, size_type n)
Afegeix els primers n elements d'un literal de cadena a l'objecte de cadena principal. Exemple:
string strCol=corda('Estimo');strCol=strCol.afegir('tu tan', 4);
cost<<strCol<< ' n';
La sortida és: t'estimo. Si n és superior a la longitud del literal, es llança una excepció length_error.
basic_string & append (const basic_string & str, size_type pos, size_type n = npos)
Afegeix n caràcters de l'índex, pos a la cadena principal. Exemple:
string strCol=corda('Estimo');strCol=strCol.afegir(ets així, 2, 4);
cost<<strCol<< ' n';
Sortida: t'estimo. Una excepció també es llançaria aquí, vegeu més endavant.
Assignació
cadena_bàsica&assignar(constcadena_bàsica&pàg)Assigna l'objecte de la cadena d'argument a la cadena principal, substituint qualsevol contingut que hi hagués.
string strCol1=corda('T'estimo');string strCol2=corda('Ella em necessita');
strCol1=strCol1.assignar(strCol2);
cost<<strCol1<< ' n';
Sortida: Ella em necessita.
cadena_bàsica&assignar(constgràfic*s)Assigna un argument literal de cadena a la cadena principal, substituint qualsevol contingut que hi hagués.
string strCol=corda('T'estimo');strCol=strCol.assignar('Ella em necessita');
cost<<strCol<< ' n';
Sortida: Ella em necessita.
cadena_bàsica&assignar(llista_inicialitzador<gràfic>)Assigna un argument de llista inicialitzador a la cadena principal,substituint qualsevol contingut que hi hagués.
[cc lang='C'escapat='veritable'amplada='780']
string strCol=corda('T'estimo');
strCol=strCol.assignar({'S','h','I','','n','I','I','d','s','','m','I',' 0'});
cost<<strCol<< ' n';
Sortida: Ella em necessita. És bo afegir sempre el nul, 0 al final de la llista de caràcters, per formar una literal de cadena.
cadena_bàsica&assignar(constgràfic*s,size_type n)Assigna els primers n caràcters d'un argument literal de cadena a la cadena principal, substituint qualsevol contingut que hi hagués.
string strCol=corda('T'estimo');strCol=strCol.assignar('Ella em necessita', 9);
cost<<strCol<< ' n';
Sortida: Necessita.
cadena_bàsica&assignar(size_type n,gràfic c)Assigna un argument de n dels mateixos caràcters a la cadena principal, substituint qualsevol contingut que hi hagués.
string strCol=corda('T'estimo');strCol=strCol.assignar(4, 'I');
cost<<strCol<< ' n';
Sortida: eeee
cadena_bàsica&assignar(constcadena_bàsica&pàg,mida_tip pos,size_type n=npos)
Assigna n caràcters d'un argument d'objecte de cadena, començant des de pos, a la cadena principal, substituint qualsevol contingut que hi hagués.
string strCol=corda('T'estimo');strCol=strCol.assignar('Ella em necessita', 4, 5);
cost<<strCol<< ' n';
Sortida: necessitats. Llançaria una excepció: vegeu-ho més tard.
Inserció
cadena_bàsica&inserir(mida_tip pos, constcadena_bàsica&pàg)Insereix l'argument de l'objecte de cadena a la cadena principal, a index, pos.
string strCol1=corda('T'estimo');string strCol2=corda('odi i');
strCol1=strCol1.inserir(2,strCol2);
cost<<strCol1<< ' n';
Sortida: t’estimo i t’estimo. Llançaria una excepció: vegeu-ho més tard.
cadena_bàsica&inserir(size_type pos1, constcadena_bàsica&pàg,size_type pos2,size_type n=npos)
Insereix una longitud de n caràcters des de pos2 de l’argument de l’objecte de cadena, fins a la cadena principal, a l’índex, pos1.
string strCol1=corda('T'estimo');string strCol2=corda('odiar, voler i necessitar');
strCol1=strCol1.inserir(2,strCol2, 6, 9);
cost<<strCol1<< ' n';
Sortida: et vull i t'estimo.
inserció iteradora (const_iterator p, gràfic c)
Insereix un caràcter concret, que és un argument, a la posició assenyalada per l'iterador. Retorna un iterador per a la posició del caràcter nou inserit.
string strCol=corda('T'estimo');cadena_bàsica<char> ::iteradoriter=strCol.començar();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
cadena_bàsica<char> ::iteradorxarxa=strCol.inserir(iter, 'd');
cost<< *xarxa<< ' n';
cost<<strCol<< ' n';
La sortida és:
'D'
t'estimava
inserció iteradora (const_iterator p, size_type n, charT c)
Insereix n del mateix caràcter de l'argument, a la posició, indicada per l'iterador. Retorna un iterador per a la posició del començament dels mateixos caràcters acabats d'inserir.
string strCol=corda('Pestanya al país'.);cadena_bàsica<char> ::iteradoriter=strCol.començar();
++iter; ++iter; ++iter;
cadena_bàsica<char> ::iteradorxarxa=strCol.inserir(iter, 2, 'O');
cost<< *xarxa<< ' n';
cost<<strCol<< ' n';
La sortida és:
'O'
Tabú a la terra.
cadena_bàsica&inserir(mida_tip pos, constgràfic*s)Insereix una cadena d'argument literal a l'índex, pos a la cadena principal.
string strCol=corda('Pestanya al país'.);strCol=strCol.inserir(3, 'oo');
cost<<strCol<< ' n';
Sortida: tabú a la terra.
cadena_bàsica&inserir(mida_tip pos, constgràfic*s,size_type n)Insereix els primers n caràcters de la cadena d'argument literal, a l'índex, pos a la cadena principal.
string strCol=corda('Pestanya al país'.);strCol=strCol.inserir(3, 'oooo', 2);
cost<<strCol<< ' n';
Sortida: tabú a la terra.
Substitució
cadena_bàsica&substituir(size_type pos1,size_type n1, constcadena_bàsica&pàg))Substitueix n1 caràcters a l'objecte cadena principal de l'índex, pos1, per l'objecte cadena argument.
string strCol1=corda('T'estimo');string strCol2=corda('t'odio i');
strCol1=strCol1.substituir(2, 4,strCol2);
cost<<strCol1<< ' n';
Resultat: t’odio a tu i a tu. Llançaria una excepció: vegeu-ho més tard.
cadena_bàsica&substituir(size_type pos1,size_type n1, constcadena_bàsica&pàg,size_type pos2,size_type n2=npos)
Substitueix n1 caràcters de l'objecte de cadena principal de l'índex, pos1, per n2 caràcters de l'objecte de cadena d'argument de l'índex, pos2.
string strCol1=corda('T'estimo');string strCol2=corda('l'odiem a ell i a ella');
strCol1=strCol1.substituir(2, 4,strCol2, 3, 12);
cost<<strCol1<< ' n';
Sortida: T’odi i ell.
cadena_bàsica&substituir(size_type pos1,size_type n1, constgràfic*s,size_type n2)
Substitueix n1 caràcters a l'objecte de cadena principal de l'índex, pos1, pels primers n2 caràcters de l'argument de cadena literal.
string strCol1=corda('T'estimo');strCol1=strCol1.substituir(2, 4, 'odiem a ell i a ella', 12);
cost<<strCol1<< ' n';
Sortida: T’odi i ell.
basic_string & replace (size_type pos, size_type n, const charT * s)
Substitueix n caràcters a l'objecte de cadena principal de l'índex, pos, amb l'argument de cadena literal.
string strCol1=corda('T'estimo');strCol1=strCol1.substituir(2, 4, 'l'odi i');
cost<<strCol1<< ' n';
Sortida: T’odi i ell.
cadena_bàsica&substituir(size_type pos1,size_type n1,size_type n2,gràfic c)Substitueix n1 caràcters a l'objecte de cadena principal de l'índex, pos1, per n2 del mateix caràcter de l'argument.
string strCol1=corda('Una tauleta dolenta allà'.);strCol1=strCol1.substituir(9, 3, 2, 'O');
cost<<strCol1<< ' n';
Sortida: un mal tabú allà ..
esborrar iterador (const_iterator p)
Elimina un caràcter a la posició assenyalada per l'iterador; després retorna la posició de l'iterador, que ara ocupa el caràcter que hi havia al costat d'aquest (o final ()). El següent codi ho il·lustra:
string strCol=corda('abcd');cadena_bàsica<char> ::iteradoriter=strCol.començar();
++iter; ++iter;
strCol.esborrar(iter);
cost<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
La sortida: a b d
cadena_bàsica&esborrar(mida_tip pos= 0,size_type n=npos)Elimina n caràcters de l'índex, pos.
string strCol=corda('abcd');strCol.esborrar(1, 2);
cost<<strCol[0] << '' <<strCol[1] << ' n';
Sortida: a d
buit push_back (gràfic c)
Per afegir un sol caràcter al final de la cadena:
string strCol=corda('abcd');strCol.fer retrocedir('5');
cost<<strCol<< ' n';
Sortida: abcd5
void pop_back ()
Elimina l'últim caràcter sense tornar-lo. La mida de la corda es redueix en 1.
string strCol=corda('abcde');strCol.pop_back();
cost<<strCol<< ' n';
Sortida: abcd
intercanvi buit (cadena_bàsica & s)
Es poden canviar els literals de dos objectes de cadena.
string strCol1=corda(<una identificació='post-69618 -__ DdeLink__781_3724385525'>a>'abcde');string strCol2=corda('1234567');
strCol1.intercanviar(strCol2);
cost<<strCol1<< ' n';
cost<<strCol2<< ' n';
La sortida és:
'1234567''abcde'
Operacions de cadena
const charT * c_str () const no excepte
Retorna un punter al primer element de la cadena. El punter es pot incrementar.
conststring strCol=corda('abcde');const char*pàg=strCol.c_str();
cost<< *pàg<< ' n';
++pàg;
cost<< *pàg<< ' n';
La sortida és:
ab
A causa de la segona constant de l'encapçalament, el programa no pot canviar cap caràcter de la cadena. La construcció va precedida de const.
const charT * data () const noexcept
Retorna un punter al primer element de la cadena. El punter es pot incrementar.
conststring strCol=corda('abcde');const char*pàg=strCol.dades();
cost<< *pàg<< ' n';
++pàg;
cost<< *pàg<< ' n';
La sortida és:
ab
A causa de la segona constant de l'encapçalament, el programa no pot canviar cap caràcter de la cadena. La construcció va precedida de const.
basic_string substr (size_type pos = 0, size_type n = npos) const
Retorna un objecte de cadena de n caràcters per a la sub-cadena que comença a partir de l'índex, pos.
conststring strCol=corda('abcdefghij');constcadena retStr=strCol.substr(2, 4);
cost<<retStr<< ' n';
Sortida: cdef
find () Funcions del membre
size_type find (const basic_string & str, size_type pos = 0) const no excepte
Cerca un objecte de sub-cadena que comença a l’índex, pos. Si es troba, retorna l'inici de la sub-cadena de la cadena principal.
string strCol=corda('Som el món!');string strCol1=corda('el');
inten un=strCol.trobar(strCol1, 2);
cost<<en un<< ' n';
Sortida:
índex: 7Retorna -1, quan no es troba.
size_type find (const charT * s, size_type pos = 0) const
Cerca una literal de sub-cadena que comença a l’índex, pos. Si es troba, retorna l'inici de la sub-cadena de la cadena principal.
string strCol=corda('Som el món!');inten un=strCol.trobar('són', 0);
cost<<en un<< ' n';
Com que pos = 0 és el valor per defecte, s'hauria pogut ometre 0 a l'argument.
Sortida: 3
Retorna -1, quan no es troba.
size_type find (const charT * s, size_type pos, size_type n) const
Cerca els primers n caràcters d’una literal de sub-cadena a partir de l’índex, pos. Si es troba, retorna l'inici de la sub-cadena de la cadena principal.
string strCol=corda('El noi més gran');inten un=strCol.trobar('més gran', 1, 3);
cost<<en un<< ' n';
Sortida: 4
Retorna -1, quan no es troba.
size_type find (charT c, size_type pos = 0) const
Cerca el caràcter, c començant per l’índex, pos. Si es troba, retorna l'inici de la sub-cadena de la cadena principal. Si no es troba, retorna -1.
string strCol=corda('Som el món!');inten un=strCol.trobar('Amb');
cost<<en un<< ' n';
Sortida: -1
Existeixen les següents funcions d'inversió find ():
size_type rfind(constcadena_bàsica&pàg,mida_tip pos=npos) constexcepte;size_type rfind(constgràfic*s,mida_tip pos=npos) const;
size_type rfind(constgràfic*s,mida_tip pos,size_type n) const;
size_type rfind(gràfic c,mida_tip pos=npos) const;
Funcions de membres de comparació
int compare (const basic_string & str) const noexcept
Compara l’argument objecte de cadena amb l’objecte de cadena principal. Si la cadena principal es produeix abans de l'argument (al diccionari), torna un número positiu. Si es produeix després de la cadena principal, torna un número negatiu. Si les dues cadenes són iguals, torna zero.
string strCol1=corda('multitud');string strCol2=corda('gent');
inten un=strCol1.comparar(strCol2);
cost<<en un<< ' n';
Sortida: -13
int compare (const charT * s) const
Igual que l’anterior, però l’argument és una cadena literal.
string strCol1=corda('gent');inten un=strCol1.comparar('gent');
cost<<en un<< ' n';
Sortida: 0
Operadors de cadena
Aquests operadors són aplicables a objectes de cadena i no necessàriament a literals de cadena.
+
Concatena dos objectes de cadena i retorna la concatenació.
string strCol1=corda('ballant');string strCol2=corda(' la lluna');
string strCol=strCol1+strCol2;
cost<<strCol<< ' n';
Sortida: ballar a la lluna.
==
Retorna 1 per cert, si els objectes de cadena són els mateixos; i zero per a fals, si no ho són.
string strCol1=corda('ballant');string strCol2=corda(' a la lluna');
bool bl=strCol1==strCol2;
cost<<bl<< ' n';
Sortida: 0
! =
Retorna 1 si els objectes de cadena no són els mateixos i zero si ho són.
string strCol1=corda('ballant');string strCol2=corda(' a la lluna');
bool bl=strCol1! =strCol2;
cost<<bl<< ' n';
Sortida: 1
<
Retorna 1, si l'operant esquerre és inferior a l'operant dret segons el diccionari, o zero si no ho és.
string strCol1=corda('ballant');string strCol2=corda(' a la lluna');
bool bl=strCol1<strCol2;
cost<<bl<< ' n';
Sortida: 0
Per als caràcters ordinaris en C ++, en ordre ascendent, els números vénen abans que les majúscules, que vénen abans que les minúscules. El caràcter espacial és anterior a zero i tots ells.
Tipus de caràcters de cadenes principals de C ++
char
El tipus char és el tipus C ++ original i normalment emmagatzema un caràcter en 8 bits.
char16_t
Emmagatzema un caràcter en 16 bits.
char32_t
Emmagatzema un personatge en 32 bits.
wchar_t
char16_t i char32_t són caràcters amplis. wchar_t és un caràcter ampli propietari i definit per la implementació.
Aquests tipus s’anomenen trets. Tanmateix, C ++ es refereix tècnicament a ells com a especialitzacions de trets. Aquest article s'ha centrat en el tipus de caràcter. L’enfocament dels altres tipus és lleugerament diferent (vegeu més endavant).
Altres funcions de membre de l'operació de cadenes
Les signatures d'altres funcions d'operació de cadena són:
size_type find_first_of(constcadena_bàsica&pàg,mida_tip pos= 0) constexcepte;size_type find_first_of(constgràfic*s,mida_tip pos,size_type n) const;
size_type find_first_of(constgràfic*s,mida_tip pos= 0) const;
size_type find_first_of(gràfic c,mida_tip pos= 0) const;
size_type find_last_of(constcadena_bàsica&pàg,mida_tip pos=npos) constexcepte;
size_type find_last_of(constgràfic*s,mida_tip pos,size_type n) const;
size_type find_last_of(constgràfic*s,mida_tip pos=npos) const;
size_type find_last_of(gràfic c,mida_tip pos=npos) const;
size_type find_first_not_of(constcadena_bàsica&pàg,mida_tip pos= 0) constexcepte;
size_type find_first_not_of(constgràfic*s,mida_tip pos,size_type n) const;
size_type find_first_not_of(constgràfic*s,mida_tip pos= 0) const;
size_type find_first_not_of(gràfic c,mida_tip pos= 0) const;
size_type find_last_not_of(constcadena_bàsica&pàg,mida_tip pos=npos) constexcepte;
size_type find_last_not_of(constgràfic*s,mida_tip pos,size_type n) const;
size_type find_last_not_of(constgràfic*s,mida_tip pos=npos) const;
size_type find_last_not_of(gràfic c,mida_tip pos=npos) const;
Conclusió
C ++ té literals de cadena i objectes de cadena. L'objecte de cadena té una col·lecció de caràcters en seqüència, similar a una matriu de caràcters en seqüència. La diferència entre la col·lecció de cadenes i una matriu és que la col·lecció de cadenes pot créixer o reduir-se. Un objecte de cadena s’instancia (construeix) a partir d’una classe de cadena. Un objecte de cadena és una estructura de dades amb funcions de membre. Les funcions de membre es poden classificar sota els encapçalaments de construcció d'objectes, accés a elements, capacitat de cadena, funcions de membre de cadena amb arguments iteradors i tipus de retorn, i modificadors de cadena. La igualtat de cordes i els operadors relacionals també existeixen.