Uma string pode ser criada de duas maneiras principais em C++. Uma string pode ser criada como um ponteiro constante para uma sequência de caracteres. Uma string também pode ser criada instanciando um objeto string da classe string. Este artigo lida com objetos string instanciados da classe string. Isso significa que a biblioteca de strings deve ser incluída para executar os exemplos de código neste artigo.
Um objeto string é uma estrutura de dados onde a string literal é uma lista. Cada caractere é de um elemento na lista. E assim, uma string literal pode ser tratada como uma matriz de elementos.
Este artigo explica a solução alternativa clássica para inverter uma string em C++. Isso essencialmente itera a string literal de trás para frente. Ter um conhecimento resumido da iteração direta permite que o leitor entenda melhor a iteração reversa. Este artigo lida com objetos string instanciados da classe string.
Todo o código de string para este tutorial é escrito na função C++ main(), a menos que indicado de outra forma.
Conteúdo do Artigo
- Iteração de Encaminhamento de String
- Iteração reversa da string
- Iteração Reversa Constante de String
- Conclusão
Iteração Avançada
Um iterador é uma classe de ponteiro a partir da qual objetos iteradores podem ser instanciados. Um objeto iterador pode ser usado para varrer elementos de string desde o início da lista de strings até o final da lista de strings. A função de membro de string, begin(), retorna um iterador que aponta para o primeiro elemento da string literal. Pode ser incrementado até atingir, logo após o último elemento da string. A função de membro de string, end(), retorna um iterador que aponta logo após o último elemento da string literal. Pode ser decrementado até atingir, o último elemento da string. Esses dois iteradores são considerados como iteradores avançados, embora o segundo itere para trás.
Para um objeto string com o nome da variável, str, a seguinte instrução retornará um iterador inicial:
corda :: iterador p = estr. começar ( ) ;Aqui, p é um iterador inicial. Um iterador final pode ser retornado pela seguinte instrução:
corda :: iterador q = estr. fim ( ) ;
Aqui, q é um iterador final. p e q acima são do mesmo tipo e podem até ser trocados.
O código a seguir imprime todos os caracteres da string, do início ao fim:
string string = { 'no' , 'no' , 'x' , 'Y' , 'Com' , ' \0 ' } ;para ( corda :: iterador p = estr. começar ( ) ; p ! = estr. fim ( ) ; p ++ ) {
cout << * p << '' ;
}
cout << fim ;
A saída é:
V W x y Z'\0' não deve ser impresso. Deve estar lá para marcar o fim da string literal. Observe como o iterador inicial foi obtido. A iteração varre a lista de strings do começo ao fim, comparando o iterador de cada elemento com aquele retornado por str.begin(); após incrementar. Quando o iterador retornado é aquele logo após o último elemento, a iteração para. Um iterador é incrementado ou decrementado da mesma forma que um índice. A expressão, *p retorna o valor apontado, pelo iterador, p.
O código a seguir imprime os valores na string, do último ao primeiro caractere, usando o iterador final:
string string = 'V W x y Z' ;corda :: iterador q = estr. fim ( ) ;
para ( q = -- q ; q >= estr. começar ( ) ; q -- ) {
cout << * q << '' ;
}
cout << fim ;
A saída é:
z y x w vEsta é uma reversão indireta de uma string. O iterador final aponta logo após o final da string literal e tal ponto não é um elemento. Para que ele aponte para o último elemento, ele deve ser decrementado. A partir daí, a iteração pode retroceder.
Por causa disso, o iterador final foi declarado fora do loop for. O valor inicial do iterador no loop for é um único decremento. O iterador é decrementado em passos até atingir o primeiro elemento conforme indicado por “str.begin()”. Esta é uma maneira informal de iterar para trás. Ou seja, essa é uma forma informal de inverter um vetor (indiretamente).
Alterando o caráter de um elemento
O objeto string é uma estrutura de dados, onde a string literal é uma lista. A lista consiste em elementos. Cada elemento tem um caractere, e esse caractere é o valor do elemento. Os caracteres também são valores da string. A string literal completa é o valor do objeto string.
Quando a declaração do objeto string não é precedida por const (para constante), o valor de qualquer elemento da string pode ser alterado. Ilustração:
string string = 'V W x y Z' ;corda :: iterador q = estr. fim ( ) ;
q -- ; q -- ; q -- ;
* q = 'uma' ;
corda :: iterador B = estr. fim ( ) ;
para ( B = -- B ; B >= estr. começar ( ) ; B -- ) {
cout << * B << '' ;
}
cout << fim ;
A saída é:
z y a w v“ q–; q–; q–; ” diminuiu o iterador final 3 vezes para apontar para ‘C’.
Quando a declaração do objeto string é precedida por const, os caracteres são somente leitura. Para tal código, o iterador retornado deve ser const_iterator. Nesse caso, o código não compila. O código a seguir emitirá uma mensagem de erro:
const string string = 'V W x y Z' ;fragmento :: const_iterator q = estr. fim ( ) ;
q -- ; q -- ; q -- ;
* q = 'uma' ;
Iteração reversa
O iterador usado com a iteração reversa é reverse_iterator. Outra função de membro da classe string é rend(), que retorna um iterador que aponta logo na frente do primeiro elemento do objeto string. Ainda assim, outra função membro da classe string é rbegin(), que retorna um iterador que aponta para o último elemento do objeto string. O código a seguir ilustra o uso do reverse_iterator retornado, lendo na direção direta, do primeiro ao último elemento:
string string = 'V W x y Z' ;fragmento :: reverse_iterator p = estr. faz ( ) ;
para ( p = -- p ; p >= estr. começar ( ) ; p -- ) {
cout << * p << '' ;
}
cout << fim ;
A saída é:
V W x y ZObserve que com o reverse_iterator, ++ é — e <= é >= , na condição while.
O código a seguir itera para trás, usando o iterador de rbegin():
string string = 'V W x y Z' ;para ( fragmento :: reverse_iterator q = estr. começar ( ) ; q <= estr. faz ( ) ; q ++ ) {
cout << * q << '' ;
}
cout << fim ;
A saída é:
z y x w vNovamente, ++ é usado em vez de — e <= é usado em vez de >= .
Alterando o caráter de um elemento
Quando a declaração do objeto string não é precedida por const (para constante), o valor de qualquer elemento da string pode ser alterado. Ilustração:
string string = 'V W x y Z' ;fragmento :: reverse_iterator q = estr. começar ( ) ;
q ++ ; q ++ ;
* q = 'uma' ;
para ( fragmento :: reverse_iterator B = estr. começar ( ) ; B <= estr. faz ( ) ; B ++ ) {
cout << * B << '' ;
}
cout << fim ;
A saída é:
z y a w vO iterador rbegin(), q, é decrementado duas vezes com “q++; q++;” para apontar para ‘C’, já que aponta inicialmente para o último elemento.
Se um objeto string for precedido por const, nenhum dos caracteres poderá ser alterado com qualquer tipo de iterador. O compilador emitirá uma mensagem de erro para o seguinte código porque o código tenta modificar o valor de 'C':
const string string = 'V W x y Z' ;fragmento :: const_reverse_iterator q = estr. começar ( ) ;
q ++ ; q ++ ;
* q = 'uma' ;
Iteração Reversa Constante de String
Um const_reverse_iterator é retornado pela função de membro, crbegin(). crbegin() é como rbegin(), mas o valor apontado por seu iterador não pode ser alterado. Um const_reverse_iterator também é retornado por outra função de membro, crend(). crend() é como rend(), mas o valor apontado por seu iterador não pode ser alterado.
O código a seguir exibe todos os valores do objeto string, usando const_reverse_iterator, começando pelo último elemento:
const string string = 'V W x y Z' ;para ( fragmento :: const_reverse_iterator q = estr. crbegin ( ) ; q <= estr. acreditam ( ) ; q ++ ) {
cout << * q << '' ;
}
cout << fim ;
A saída é:
z y x w vEmbora a declaração do objeto string não seja precedida por const, o código a seguir não será compilado. Isso ocorre devido ao uso de const_reverse_iterator. Mesmo que a declaração fosse precedida por const, ela ainda não compilaria pelo mesmo motivo. O código é:
const string string = 'V W x y Z' ;fragmento :: const_reverse_iterator q = estr. crbegin ( ) ;
q ++ ; q ++ ;
* q = 'uma' ;
Conclusão
A classe string não tem uma função de membro para reverter uma string. No entanto, uma string pode ser invertida indiretamente iterando de trás para frente. As funções de membro envolvidas são end(), begin(), rend(), rbegin(), crend() e crbegin(). Os iteradores envolvidos são iterator, reverse_iterator e const_reverse_iterator. Esses recursos são combinados para produzir uma reversão indireta, mas ainda efetiva, do literal de um objeto string.