Comment couper std::string en C++ : 5 méthodes pratiques pour débutants et experts

Introduction : pourquoi la découpe de chaînes est un casse-tête pour chaque développeur C++

Si vous avez déjà écrit un analyseur de logs, lu une saisie utilisateur ou traité des fichiers CSV en C++, vous avez sûrement rencontré le problème : les chaînes arrivent avec des espaces « superflus », des tabulations ou des retours à la ligne. En Python, il y a strip() intégré, en Java — trim(), mais en C++, la bibliothèque standard ne fournit pas de fonction prête à l'emploi pour découper les chaînes. C'est l'une des questions les plus populaires sur Stack Overflow (plus de 350 000 vues), et aujourd'hui nous allons enfin comprendre comment résoudre ce problème de manière élégante.

Dans cet article, vous apprendrez :

\n
• Pourquoi C++ n'a pas de trim intégré et comment contourner cela
\n
• 5 méthodes éprouvées pour découper std::string
\n
• Comment écrire votre propre fonction trim universelle
\n
• Quand utiliser Boost, et quand utiliser du C++11/17 pur
\n

Qu'est-ce que le trim et pourquoi en a-t-on besoin ?

Trim (découpe de chaîne) — c'est la suppression des caractères d'espacement (espace, tabulation, retour à la ligne, retour chariot) au début, à la fin ou des deux côtés de la chaîne. En C++, sous le capot, cela revient à rechercher le premier et le dernier caractère non-espacement et à créer une sous-chaîne entre eux.

Scénarios typiques où la découpe de chaînes en C++ est cruciale :

\n
• Validation de formulaires — l'utilisateur a accidentellement mis un espace avant l'email
\n
• Analyse de fichiers de configuration — chaînes comme "key = value "
\n
• Travail avec des protocoles réseau — les caractères superflus cassent les en-têtes
\n
• Analyse de logs — les espaces gênent la recherche et la comparaison
\n

Méthode 1 : Trim manuel classique (C++98/03)

La méthode la plus ancienne et la plus compréhensible — utiliser find_first_not_of et find_last_not_of. Ces méthodes recherchent le premier/dernier caractère qui NE fait PAS partie d'un ensemble donné (par défaut — les espaces).

#include <string>\n#include <cctype>\n\nstd::string trim(const std::string& str) {\n    const std::string whitespace = " \\t\\n\\r\\f\\v";\n    size_t start = str.find_first_not_of(whitespace);\n    if (start == std::string::npos)\n        return ""; // la chaîne ne contient que des espaces\n    size_t end = str.find_last_not_of(whitespace);\n    return str.substr(start, end - start + 1);\n}

Avantages : fonctionne sur n'importe quel standard C++, aucune dépendance. Inconvénients : crée une nouvelle chaîne (copie). Pour la plupart des tâches, ce n'est pas un problème, mais si vous découpez des millions de chaînes — pensez aux performances.

Méthode 2 : Modification sur place (in-place trim, C++11)

Si vous voulez modifier la chaîne d'origine sans copie, utilisez erase et les itérateurs. Cette méthode est particulièrement utile pour travailler avec de grands tampons.

#include <string>\n#include <algorithm>\n\nstd::string& trim_in_place(std::string& str) {\n    const std::string whitespace = " \\t\\n\\r\\f\\v";\n    // Suppression au début\n    str.erase(0, str.find_first_not_of(whitespace));\n    // Suppression à la fin\n    size_t end = str.find_last_not_of(whitespace);\n    if (end != std::string::npos)\n        str.erase(end + 1);\n    return str;\n}

Notez : après erase au début, la chaîne est décalée, ce qui peut être coûteux pour des chaînes très longues. Mais pour les cas typiques (jusqu'à 10K caractères) — c'est parfait.

Méthode 3 : Utilisation de <algorithm> et lambdas (C++17)

Le C++ moderne permet d'écrire un code plus déclaratif. Utilisons std::find_if_not pour trouver le premier caractère non-espacement.

#include <string>\n#include <algorithm>\n#include <cctype>\n\nstd::string trim_modern(const std::string& str) {\n    auto is_space = [](unsigned char ch) { return std::isspace(ch); };\n    \n    auto start = std::find_if_not(str.begin(), str.end(), is_sp