Was ist der beste Weg, um trim std::string?

BEARBEITEN, Da c++17, einige Teile der standard-Bibliothek entfernt wurden. Zum Glück, beginnend mit c++11 haben wir Lambda-Ausdrücke, die eine überlegene Lösung.

#include <algorithm> 
#include <cctype>
#include <locale>

//trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

//trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

//trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

//trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

//trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

//trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Dank https://stackoverflow.com/a/44973498/524503 für die moderne Lösung.

Original Antwort:

Ich Neige dazu, verwenden Sie eine dieser 3 für meine trimmen muss:

#include <algorithm> 
#include <functional> 
#include <cctype>
#include <locale>

//trim from start
static inline std::string &ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
            std::not1(std::ptr_fun<int, int>(std::isspace))));
    return s;
}

//trim from end
static inline std::string &rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(),
            std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
    return s;
}

//trim from both ends
static inline std::string &trim(std::string &s) {
    return ltrim(rtrim(s));
}

Sind Sie ziemlich selbsterklärend und funktioniert sehr gut.

BEARBEITEN: BTW, ich habe std::ptr_fun dort zu helfen, keine Verwechslungen std::isspace denn es gibt tatsächlich eine zweite definition, die unterstützt Gebietsschemas. Dies hätte eine Besetzung genau das gleiche, aber ich Neige dazu, dies besser.

BEARBEITEN: einige Bemerkungen über die Annahme von parameter-Referenz, änderung und Rückgabe. Ich Bin Damit Einverstanden. Eine Umsetzung, die würde ich wahrscheinlich bevorzugen würde, werden zwei Gruppen von Funktionen, eine für die im Ort und man macht eine Kopie. Bessere Beispiele wären:

#include <algorithm> 
#include <functional> 
#include <cctype>
#include <locale>

//trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
            std::not1(std::ptr_fun<int, int>(std::isspace))));
}

//trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(),
            std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
}

//trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

//trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

//trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

//trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Bin ich unter Beibehaltung der ursprünglichen Antwort oben aber für den Zusammenhang und im Interesse, dass die hohe stimmten die Antwort noch verfügbar.

InformationsquelleAutor Evan Teran

Verwenden Sie den folgenden code nach rechts trim (trailing) Leerzeichen und Tabulator-Zeichen von std::strings (ideone):

//trim trailing spaces
size_t endpos = str.find_last_not_of(" \t");
size_t startpos = str.find_first_not_of(" \t");
if( std::string::npos != endpos )
{
    str = str.substr( 0, endpos+1 );
    str = str.substr( startpos );
}
else {
    str.erase(std::remove(std::begin(str), std::end(str), ' '), std::end(str));
}

Und nur um die Dinge auszugleichen, werde ich die Links kürzen-code zu (ideone):

//trim leading spaces
size_t startpos = str.find_first_not_of(" \t");
if( string::npos != startpos )
{
    str = str.substr( startpos );
}

InformationsquelleAutor Bill the Lizard

Was du tust ist gut und robust. Ich habe die gleiche Methode, die für eine lange Zeit und ich habe noch zu finden, eine schnellere Methode:

const char* ws = " \t\n\r\f\v";

//trim from end of string (right)
inline std::string& rtrim(std::string& s, const char* t = ws)
{
    s.erase(s.find_last_not_of(t) + 1);
    return s;
}

//trim from beginning of string (left)
inline std::string& ltrim(std::string& s, const char* t = ws)
{
    s.erase(0, s.find_first_not_of(t));
    return s;
}

//trim from both ends of string (right then left)
inline std::string& trim(std::string& s, const char* t = ws)
{
    return ltrim(rtrim(s, t), t);
}

Durch Angabe der Zeichen, die abgeschnitten werden, haben Sie die Flexibilität zu trimmen, nicht-whitespace-Zeichen und die Effizienz zu trimmen, nur die Zeichen, die Sie getrimmt.

InformationsquelleAutor Galik

Ich mag tzaman Lösung, das einzige problem dabei ist, dass Sie nicht schneiden Sie ein string der nur aus Leerzeichen besteht.

Korrigieren, dass 1 Fehler, hinzufügen str.clear () - zwischen den 2 trimmer-Linien

std::stringstream trimmer;
trimmer << str;
str.clear();
trimmer >> str;

InformationsquelleAutor Michaël Schoonbrood

In dem Fall ein leerer string ist, wird Ihr code wird davon ausgegangen, dass das hinzufügen von 1 bis string::npos gibt 0. string::npos ist der Typ string::size_type, die nicht signiert ist. Also, Sie verlassen sich auf das overflow-Verhalten hinaus.

InformationsquelleAutor Greg Hewgill

Meine Lösung basiert auf der Antwort von @Bill, die Eidechse.

Beachten Sie, dass diese Funktionen wird ein leerer string zurückgegeben, wenn die Eingabe-Zeichenfolge enthält nichts außer whitespace-Zeichen.

const std::string StringUtils::WHITESPACE = " \n\r\t";

std::string StringUtils::Trim(const std::string& s)
{
    return TrimRight(TrimLeft(s));
}

std::string StringUtils::TrimLeft(const std::string& s)
{
    size_t startpos = s.find_first_not_of(StringUtils::WHITESPACE);
    return (startpos == std::string::npos) ? "" : s.substr(startpos);
}

std::string StringUtils::TrimRight(const std::string& s)
{
    size_t endpos = s.find_last_not_of(StringUtils::WHITESPACE);
    return (endpos == std::string::npos) ? "" : s.substr(0, endpos+1);
}

InformationsquelleAutor DavidRR

Mit C++11 kamen auch ein regulärer Ausdruck Modul, das kann verwendet werden, zu trimmen führende oder nachfolgende Leerzeichen.

Vielleicht so etwas wie dieses:

std::string ltrim(const std::string& s)
{
    static const std::regex lws{"^[[:space:]]*", std::regex_constants::extended};
    return std::regex_replace(s, lws, "");
}

std::string rtrim(const std::string& s)
{
    static const std::regex tws{"[[:space:]]*$", std::regex_constants::extended};
    return std::regex_replace(s, tws, "");
}

std::string trim(const std::string& s)
{
    return ltrim(rtrim(s));
}

InformationsquelleAutor Some programmer dude

Für was es Wert ist, hier ist eine trim-Implementierung mit einem Auge in Richtung performance. Es ist viel schneller als viele andere trim-Routinen, die ich gesehen habe um. Anstelle der Verwendung von Iteratoren und std::findet, verwendet es roh c-strings und-Indizes. Es optimiert den folgenden besonderen Fällen: Größe 0-Zeichenfolge (nichts tun), string ohne Leerzeichen, trim (nichts tun), string mit nur Leerzeichen zu trimmen (nur die Größe der Zeichenfolge) Zeichenfolge, die ganz whitespace-Zeichen (löschen Sie einfach die Zeichenfolge). Und schließlich, im schlimmsten Fall (Zeichenkette mit führenden Leerzeichen), es tut sein bestes geben, um eine effiziente kopieren Konstruktion, Durchführung nur 1 kopieren und dann verschieben, kopieren, an die Stelle der ursprünglichen Zeichenfolge.

void TrimString(std::string & str)
{ 
    if(str.empty())
        return;

    const auto pStr = str.c_str();

    size_t front = 0;
    while(front < str.length() && std::isspace(int(pStr[front]))) {++front;}

    size_t back = str.length();
    while(back > front && std::isspace(int(pStr[back-1]))) { --back;}

    if(0 == front)
    {
        if(back < str.length())
        {
            str.resize(back - front);
        }
    }
    else if(back <= front)
    {
        str.clear();
    }
    else
    {
        str = std::move(std::string(str.begin()+front, str.begin()+back));
    }
}

InformationsquelleAutor mbgda

Einen eleganten Weg, es zu tun sein kann, wie

std::string & trim(std::string & str)
{
   return ltrim(rtrim(str));
}

Sowie die unterstützenden Funktionen sind implementiert:

std::string & ltrim(std::string & str)
{
  auto it =  std::find_if( str.begin() , str.end() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
  str.erase( str.begin() , it);
  return str;   
}

std::string & rtrim(std::string & str)
{
  auto it =  std::find_if( str.rbegin() , str.rend() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
  str.erase( it.base() , str.end() );
  return str;   
}

Und sobald Sie haben alle diese, können Sie schreiben so gut:

std::string trim_copy(std::string const & str)
{
   auto s = str;
   return ltrim(rtrim(s));
}

InformationsquelleAutor gjha

Ich denke, wenn Sie anfangen zu Fragen, für den "besten Weg" zu trimmen ist eine Zeichenfolge, würde ich sagen, eine gute Umsetzung wäre ein:

1. Nicht zuordnen temporäre strings
2. Hat überladungen für in-place-trimmen und kopieren trim
3. Können leicht angepasst werden, um zu akzeptieren, unterschiedliche Validierungs-Sequenzen /Logik

Offensichtlich gibt es zu viele verschiedene Möglichkeiten, dies zu nähern und es auf jeden Fall, hängt davon ab, was Sie eigentlich brauchen. Aber der C-standard-Bibliothek hat noch einige sehr nützliche Funktionen in <string.h>, wie memchr. Es gibt einen Grund, warum C gilt immer noch als die beste Sprache für IO - seine stdlib ist pure Effizienz.

inline const char* trim_start(const char* str)
{
    while (memchr(" \t\n\r", *str, 4))  ++str;
    return str;
}
inline const char* trim_end(const char* end)
{
    while (memchr(" \t\n\r", end[-1], 4)) --end;
    return end;
}
inline std::string trim(const char* buffer, int len) //trim a buffer (input?)
{
    return std::string(trim_start(buffer), trim_end(buffer + len));
}
inline void trim_inplace(std::string& str)
{
    str.assign(trim_start(str.c_str()),
        trim_end(str.c_str() + str.length()));
}

int main()
{
    char str [] = "\t \nhello\r \t \n";

    string trimmed = trim(str, strlen(str));
    cout << "'" << trimmed << "'" << endl;

    system("pause");
    return 0;
}

InformationsquelleAutor Jorma Rebane

Ich bin mir nicht sicher, ob Ihre Umgebung ist die gleiche, aber in mir, die leere Zeichenfolge Fall dazu, dass das Programm abgebrochen wird. Ich würde entweder wickeln, löschen, rufen Sie mit einer if(!s.empty()) oder die Verwendung von Boost wie bereits erwähnt.

InformationsquelleAutor Steve

Beitrag meine Lösung für den Lärm. trim standardmäßig erstellen Sie einen neuen string-und die Rückkehr der veränderten, während trim_in_place ändert den übergebenen string. Die trim - Funktion unterstützt c++11 move-Semantik.

#include <string>

//modifies input string, returns input

std::string& trim_left_in_place(std::string& str) {
    size_t i = 0;
    while(i < str.size() && isspace(str[i])) { ++i; };
    return str.erase(0, i);
}

std::string& trim_right_in_place(std::string& str) {
    size_t i = str.size();
    while(i > 0 && isspace(str[i - 1])) { --i; };
    return str.erase(i, str.size());
}

std::string& trim_in_place(std::string& str) {
    return trim_left_in_place(trim_right_in_place(str));
}

//returns newly created strings

std::string trim_right(std::string str) {
    return trim_right_in_place(str);
}

std::string trim_left(std::string str) {
    return trim_left_in_place(str);
}

std::string trim(std::string str) {
    return trim_left_in_place(trim_right_in_place(str));
}

#include <cassert>

int main() {

    std::string s1(" \t\r\n  ");
    std::string s2("  \r\nc");
    std::string s3("c \t");
    std::string s4("  \rc ");

    assert(trim(s1) == "");
    assert(trim(s2) == "c");
    assert(trim(s3) == "c");
    assert(trim(s4) == "c");

    assert(s1 == " \t\r\n  ");
    assert(s2 == "  \r\nc");
    assert(s3 == "c \t");
    assert(s4 == "  \rc ");

    assert(trim_in_place(s1) == "");
    assert(trim_in_place(s2) == "c");
    assert(trim_in_place(s3) == "c");
    assert(trim_in_place(s4) == "c");

    assert(s1 == "");
    assert(s2 == "c");
    assert(s3 == "c");
    assert(s4 == "c");  
}

InformationsquelleAutor vmrob

Hier ist meine version:

size_t beg = s.find_first_not_of(" \r\n");
return (beg == string::npos) ? "" : in.substr(beg, s.find_last_not_of(" \r\n") - beg);

InformationsquelleAutor nulleight

Diese version trimmt die interne Leerzeichen und nicht-alphanumerische Zeichen:

static inline std::string &trimAll(std::string &s)
{   
    if(s.size() == 0)
    {
        return s;
    }

    int val = 0;
    for (int cur = 0; cur < s.size(); cur++)
    {
        if(s[cur] != ' ' && std::isalnum(s[cur]))
        {
            s[val] = s[cur];
            val++;
        }
    }
    s.resize(val);
    return s;
}

InformationsquelleAutor Brian

Was ist das...?

#include <iostream>
#include <string>
#include <regex>

std::string ltrim( std::string str ) {
    return std::regex_replace( str, std::regex("^\\s+"), std::string("") );
}

std::string rtrim( std::string str ) {
    return std::regex_replace( str, std::regex("\\s+$"), std::string("") );
}

std::string trim( std::string str ) {
    return ltrim( rtrim( str ) );
}

int main() {

    std::string str = "   \t  this is a test string  \n   ";
    std::cout << "-" << trim( str ) << "-\n";
    return 0;

}

Hinweis: ich bin noch relativ neu in C++, also bitte verzeihen Sie mir, wenn ich bin off base hier.

InformationsquelleAutor Duncan