HOWTO · C++
Como reverter uma string em C++
Este artigo introduz como reverter uma string em C++
Nesta página
Para inverter uma string em C++, decida se o original deve ser alterado. Construa um novo std::string com iteradores reversos quando precisar preservar a origem, ou chame std::reverse na string quando for apropriado modificá-la no próprio local. std::copy pode preencher uma string de destino ou escrever os caracteres invertidos diretamente em um fluxo. Um laço deixa claro o processo elemento por elemento; a recursão é útil principalmente como exercício de aprendizado.
Escolha uma abordagem para inverter uma string
Na maioria dos programas, use iteradores reversos para criar um resultado separado ou std::reverse para reordenar uma string existente. Ambos operam nos elementos de std::string, que são valores char. Se o texto contiver UTF-8, inverter esses bytes pode danificar caracteres multibyte; consulte a última seção antes de usar essas técnicas em textos de idiomas naturais.
Inverta uma string com iteradores reversos
Os iteradores rbegin() e rend() de uma string percorrem seus elementos do último ao primeiro. Passá-los ao construtor de std::string cria uma cópia invertida e mantém a origem inalterada. Essa é uma opção direta quando as duas strings precisam continuar disponíveis.
Execute este exemplo:
O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.
#include <iostream>
#include <string>
int main() {
const std::string original = "Hello, C++!";
const std::string reversed(original.rbegin(), original.rend());
std::cout << "Original: " << original << '\n';
std::cout << "Reversed: " << reversed << '\n';
}
O construtor recebe um par de iteradores que define a ordem dos elementos na nova string. A original continua disponível para uso posterior, enquanto a nova string contém sua própria sequência invertida.
Inverta uma string no próprio local com std::reverse
std::reverse é um algoritmo declarado em <algorithm>. Ele troca os elementos no intervalo semiaberto que começa no primeiro iterador e vai até, mas não inclui, o segundo. Modifica o intervalo fornecido e não retorna uma cópia invertida. O programa a seguir aplica o algoritmo a uma cópia para poder imprimir as duas versões:
O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.
#include <algorithm>
#include <iostream>
#include <string>
int main() {
const std::string original = "Hello, C++!";
std::string changed = original;
std::reverse(changed.begin(), changed.end());
std::cout << "Original: " << original << '\n';
std::cout << "Changed: " << changed << '\n';
}
Se a própria string original deve ser alterada, chame std::reverse(original.begin(), original.end()) em uma string não constante. Essa operação não precisa alocar uma segunda string. Não conte com o algoritmo para informar uma falha de alocação: ele reorganiza os elementos do intervalo e não tem uma etapa própria de alocação.
Crie uma string invertida com std::copy
std::copy copia elementos de um intervalo de entrada para um intervalo de destino; não redimensiona a string de destino. Antes de copiar, dê ao destino espaço para elementos suficientes. Os iteradores reversos fazem com que a ordem dos elementos copiados fique invertida. Quando você só precisa exibir os caracteres, um iterador de saída permite evitar o armazenamento de outra string.
O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.
#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>
int main() {
const std::string original = "Hello, C++!";
std::string reversed(original.size(), '\0');
std::copy(original.rbegin(), original.rend(), reversed.begin());
std::cout << "Copy: " << reversed << '\n';
std::cout << "Stream: ";
std::copy(original.rbegin(), original.rend(),
std::ostream_iterator<char>(std::cout));
std::cout << '\n';
}
O construtor da string cria um destino com a quantidade necessária de elementos, de modo que o intervalo de saída seja grande o bastante para a origem. std::ostream_iterator escreve cada caractere copiado em std::cout; <iterator> o declara. Qualificar os nomes dos algoritmos com std:: explicita o namespace.
Inverta uma string com um laço
Um laço pode acrescentar elementos do fim da origem em direção ao começo. Iterar com std::string::size_type evita converter o tamanho da string para um inteiro com sinal. A forma abaixo, que decrementa e verifica o valor, também para antes de subtrair de zero:
O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.
#include <iostream>
#include <string>
int main() {
const std::string original = "Hello, C++!";
std::string reversed;
reversed.reserve(original.size());
for (std::string::size_type i = original.size(); i > 0; --i) {
reversed.push_back(original[i - 1]);
}
std::cout << reversed << '\n';
}
Reservar capacidade é uma otimização opcional que pode evitar crescimentos repetidos durante os acréscimos. O laço é útil para entender a operação ou adicionar lógica para cada elemento; para uma inversão comum, as abordagens da biblioteca padrão são mais curtas e fáceis de reconhecer.
Inverta uma string recursivamente
A recursão pode expressar a inversão retirando o último elemento e, em seguida, processando a substring anterior. Esta versão retorna uma nova string e ilustra essa definição:
O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.
#include <iostream>
#include <string>
std::string reverseString(const std::string& value) {
if (value.size() < 2) {
return value;
}
return value.back() + reverseString(value.substr(0, value.size() - 1));
}
int main() {
const std::string original = "Hello, C++!";
std::cout << reverseString(original) << '\n';
}
Cada etapa recursiva cria uma substring; por isso, essa abordagem pode copiar muitos dados e fazer várias chamadas de função. Entradas longas também exigem pilhas de chamadas profundas. Em código de produção, prefira iteradores reversos ou std::reverse, a menos que o objetivo seja ensinar recursão.
Entenda strings vazias e a codificação de caracteres
Para uma string vazia, o construtor com iteradores reversos cria outra string vazia, e o intervalo passado para std::reverse não contém elementos. O laço não executa nenhuma iteração. O exemplo recursivo retorna no caso-base. Portanto, essas abordagens não precisam de saída especial nem de uma lógica de inversão separada para entradas vazias.
Um std::string armazena elementos char, e não caracteres Unicode abstratos. Em texto UTF-8, um caractere visível pode ocupar vários bytes, e um caractere percebido pelo usuário pode consistir em vários pontos de código Unicode. Inverter os bytes pode corromper a codificação, enquanto inverter pontos de código ainda pode separar um grafema, como uma letra combinada com um acento. Para textos multilíngues, decodifique-os e use uma biblioteca compatível com Unicode para inverter as unidades exigidas pela aplicação, geralmente grupos de grafemas.