HOWTO · C++
Comment inverser une chaîne de caractères en C++
Cet article présente comment inverser une chaîne de caractères en C++
Sur cette page
Pour inverser une chaîne C++, choisissez si la chaîne d’origine doit être modifiée. Construisez une nouvelle std::string à partir d’itérateurs inverses si vous devez conserver la source, ou appelez std::reverse sur la chaîne si une modification sur place convient. std::copy peut remplir une chaîne de destination ou écrire directement les caractères inversés dans un flux. Une boucle clarifie le traitement élément par élément; la récursion sert surtout d’exercice pédagogique.
Choisir une méthode pour inverser une chaîne
Dans la plupart des cas, utilisez des itérateurs inverses pour créer un résultat distinct, ou std::reverse pour réordonner une chaîne existante. Ces deux approches opèrent sur les éléments de std::string, qui sont des valeurs char. Si le texte est en UTF-8, inverser ses octets peut endommager les caractères multioctets; consultez la dernière section avant d’appliquer ces techniques à du texte destiné à être lu.
Inverser une chaîne avec des itérateurs inverses
Les itérateurs rbegin() et rend() d’une chaîne parcourent ses éléments du dernier au premier. Les transmettre au constructeur de std::string crée une copie inversée sans modifier la source. C’est une solution directe lorsque les deux chaînes doivent rester disponibles.
Exécutez cet exemple :
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#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';
}
Le constructeur reçoit une paire d’itérateurs qui détermine l’ordre des éléments dans la nouvelle chaîne. La chaîne d’origine reste disponible pour un usage ultérieur, tandis que la nouvelle contient la séquence inversée.
Inverser une chaîne sur place avec std::reverse
std::reverse est un algorithme déclaré dans <algorithm>. Il échange les éléments de l’intervalle semi-ouvert allant du premier itérateur jusqu’au second, sans inclure ce dernier. Il modifie l’intervalle fourni et ne renvoie pas de copie inversée. Le programme suivant applique l’algorithme à une copie afin d’afficher les deux versions :
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#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';
}
Pour modifier la chaîne d’origine, appelez plutôt std::reverse(original.begin(), original.end()) sur une chaîne non constante. Cette opération n’a pas besoin d’allouer une deuxième chaîne. Ne comptez pas sur l’algorithme pour signaler un échec d’allocation : il réordonne les éléments de l’intervalle et n’effectue lui-même aucune allocation.
Créer une chaîne inversée avec std::copy
std::copy copie les éléments d’un intervalle source vers un intervalle de destination; il ne redimensionne pas une chaîne de destination. Donnez à la destination une taille suffisante avant la copie. Les itérateurs inverses font parcourir les éléments dans l’ordre inverse. Si vous souhaitez seulement afficher les caractères, un itérateur de sortie permet d’éviter de stocker une autre chaîne.
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#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';
}
Le constructeur de chaîne crée une destination contenant le nombre d’éléments requis : l’intervalle de sortie est donc assez grand pour recevoir la source. std::ostream_iterator écrit chaque caractère copié dans std::cout; <iterator> le déclare. Le préfixe std:: rend explicite l’espace de noms des algorithmes.
Inverser une chaîne avec une boucle
Une boucle peut ajouter les éléments en partant de la fin de la source et en remontant vers le début. Parcourir la chaîne avec std::string::size_type évite de convertir sa longueur en entier signé. La forme avec décrémentation et test ci-dessous s’arrête aussi avant de décrémenter une valeur égale à zéro :
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#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';
}
Réserver de la capacité est une optimisation facultative qui peut éviter des agrandissements répétés lors des ajouts. La boucle aide à comprendre l’opération ou à traiter chaque élément; pour une inversion ordinaire, les solutions de la bibliothèque standard sont plus courtes et plus faciles à reconnaître.
Inverser une chaîne par récursion
La récursion peut exprimer l’inversion en prenant le dernier élément, puis en traitant la sous-chaîne qui le précède. Cette version renvoie une nouvelle chaîne et illustre cette définition :
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#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';
}
Chaque étape récursive crée une sous-chaîne; cette approche peut donc copier beaucoup de données et entraîner de nombreux appels de fonction. Les entrées longues nécessitent aussi une pile d’appels profonde. En production, préférez les itérateurs inverses ou std::reverse, sauf si la récursion est précisément le sujet étudié.
Comprendre les chaînes vides et l’encodage des caractères
Pour une chaîne vide, le constructeur avec des itérateurs inverses crée une autre chaîne vide, et l’intervalle transmis à std::reverse ne contient aucun élément. La boucle n’effectue aucune itération. L’exemple récursif renvoie la valeur au cas de base. Ces approches ne nécessitent donc ni affichage particulier ni logique d’inversion distincte pour une entrée vide.
Un std::string stocke des éléments char, et non des caractères Unicode abstraits. En UTF-8, un caractère visible peut occuper plusieurs octets, et un caractère perçu par l’utilisateur peut réunir plusieurs points de code Unicode. Inverser les octets peut corrompre l’encodage; inverser les points de code peut encore séparer un graphème, par exemple une lettre de son accent combiné. Pour du texte multilingue, décodez-le et utilisez une bibliothèque compatible avec Unicode afin d’inverser les unités requises par l’application, souvent les graphèmes.