Qual è il modo migliore per tagliare std :: string?

Attualmente sto usando il seguente codice per tagliare tutto a destra std::stringsnei miei programmi:

std::string s;
s.erase(s.find_last_not_of(" \n\r\t")+1);

Funziona bene, ma mi chiedo se ci sono alcuni casi finali in cui potrebbe fallire?

Naturalmente, le risposte con alternative eleganti e anche la soluzione di assetto sinistro sono benvenute.

EDIT Da c ++ 17, alcune parti della libreria standard sono state rimosse. Fortunatamente, a partire da c ++ 11, abbiamo lambda che sono una soluzione superiore.

#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;
}

Grazie a https://stackoverflow.com/a/44973498/524503 per aver proposto la soluzione moderna.

Risposta originale:

Tendo a utilizzare uno di questi 3 per le mie esigenze di taglio:

#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));
}

Sono abbastanza autoesplicativi e funzionano molto bene.

EDIT : A proposito, ho std::ptr_funlì per aiutare a chiarire std::isspaceperché in realtà esiste una seconda definizione che supporta le versioni locali. Questo avrebbe potuto essere un cast lo stesso, ma tendo a piacermi meglio.

EDIT : per rispondere ad alcuni commenti sull'accettazione di un parametro come riferimento, modificandolo e restituendolo. Sono d'accordo. Un'implementazione che preferirei probabilmente sarebbe due serie di funzioni, una per il posto e una che ne fa una copia. Una migliore serie di esempi sarebbe:

#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;
}

Sto mantenendo la risposta originale sopra per il contesto e nell'interesse di mantenere ancora disponibile la risposta votata.

L'uso degli algoritmi di stringa di Boost sarebbe più semplice:

#include <boost/algorithm/string.hpp>

std::string str("hello world! ");
boost::trim_right(str);

strè adesso "hello world!". C'è anche trim_lefte trim, che taglia entrambi i lati.

Se si aggiunge il _copysuffisso a uno dei nomi delle funzioni precedenti, ad es. trim_copy, La funzione restituirà una copia ritagliata della stringa anziché modificarla tramite un riferimento.

Se aggiungi il _ifsuffisso a uno dei nomi delle funzioni precedenti, ad esempio trim_copy_if, puoi tagliare tutti i caratteri che soddisfano il tuo predicato personalizzato, al contrario dei soli spazi bianchi.

Utilizzare il codice seguente per tagliare a destra (finali) spazi e caratteri di tabulazione da 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));
}

E solo per bilanciare le cose, includerò anche il codice trim sinistro ( ideone ):

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

Quello che stai facendo è bello e robusto. Ho usato lo stesso metodo per molto tempo e devo ancora trovare un metodo più veloce:

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);
}

Fornendo i personaggi da tagliare, hai la flessibilità di tagliare i caratteri non bianchi e l'efficienza di tagliare solo i personaggi che vuoi tagliare.

Un po 'tardi alla festa, ma non importa. Ora C ++ 11 è qui, abbiamo lambda e variabili automatiche. Quindi la mia versione, che gestisce anche tutti gli spazi bianchi e stringhe vuote, è:

#include <cctype>
#include <string>
#include <algorithm>

inline std::string trim(const std::string &s)
{
   auto wsfront=std::find_if_not(s.begin(),s.end(),[](int c){return std::isspace(c);});
   auto wsback=std::find_if_not(s.rbegin(),s.rend(),[](int c){return std::isspace(c);}).base();
   return (wsback<=wsfront ? std::string() : std::string(wsfront,wsback));
}

Potremmo creare un iteratore inverso da wsfronte usarlo come condizione di terminazione nel secondo, find_if_notma questo è utile solo nel caso di una stringa per tutti gli spazi bianchi, e gcc 4.8 almeno non è abbastanza intelligente da inferire il tipo di iteratore inverso ( std::string::const_reverse_iterator) con auto. Non so quanto sia costoso costruire un iteratore inverso, quindi YMMV qui. Con questa modifica, il codice è simile al seguente:

inline std::string trim(const std::string &s)
{
   auto  wsfront=std::find_if_not(s.begin(),s.end(),[](int c){return std::isspace(c);});
   return std::string(wsfront,std::find_if_not(s.rbegin(),std::string::const_reverse_iterator(wsfront),[](int c){return std::isspace(c);}).base());
}

Prova questo, funziona per me.

inline std::string trim(std::string& str)
{
    str.erase(0, str.find_first_not_of(' '));       //prefixing spaces
    str.erase(str.find_last_not_of(' ')+1);         //surfixing spaces
    return str;
}

Mi piace la soluzione di Tzaman, l'unico problema è che non taglia una stringa contenente solo spazi.

Per correggere quel 1 difetto, aggiungi uno str.clear () tra le 2 linee del rifinitore

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

http://ideone.com/nFVtEo

std::string trim(const std::string &s)
{
    std::string::const_iterator it = s.begin();
    while (it != s.end() && isspace(*it))
        it++;

    std::string::const_reverse_iterator rit = s.rbegin();
    while (rit.base() != it && isspace(*rit))
        rit++;

    return std::string(it, rit.base());
}

Nel caso di una stringa vuota, il codice presuppone che l'aggiunta di 1 a string::npos0. string::npossia di tipo string::size_type, che è senza segno. Pertanto, fai affidamento sul comportamento di overflow dell'aggiunta.

Violato da Cplusplus.com

std::string choppa(const std::string &t, const std::string &ws)
{
    std::string str = t;
    size_t found;
    found = str.find_last_not_of(ws);
    if (found != std::string::npos)
        str.erase(found+1);
    else
        str.clear();            // str is all whitespace

    return str;
}

Questo funziona anche per il caso null. :-)

Con C ++ 17 puoi usare basic_string_view :: remove_prefix e basic_string_view :: remove_suffix :

std::string_view trim(std::string_view s)
{
    s.remove_prefix(std::min(s.find_first_not_of(" \t\r\v\n"), s.size()));
    s.remove_suffix(std::min(s.size() - s.find_last_not_of(" \t\r\v\n") - 1, s.size()));

    return s;
}

Una bella alternativa:

std::string_view ltrim(std::string_view s)
{
    s.remove_prefix(std::distance(s.cbegin(), std::find_if(s.cbegin(), s.cend(),
         [](int c) {return !std::isspace(c);})));

    return s;
}

std::string_view rtrim(std::string_view s)
{
    s.remove_suffix(std::distance(s.crbegin(), std::find_if(s.crbegin(), s.crend(),
        [](int c) {return !std::isspace(c);})));

    return s;
}

std::string_view trim(std::string_view s)
{
    return ltrim(rtrim(s));
}

La mia soluzione basata sulla risposta di @Bill the Lizard .

Si noti che queste funzioni restituiranno la stringa vuota se la stringa di input non contiene altro che spazi bianchi.

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);
}

La mia risposta è un miglioramento rispetto alla risposta migliore per questo post che taglia i caratteri di controllo e gli spazi (0-32 e 127 nella tabella ASCII ).

std::isgraphdetermina se un personaggio ha una rappresentazione grafica, quindi puoi usarlo per modificare la risposta di Evan per rimuovere qualsiasi personaggio che non ha una rappresentazione grafica da entrambi i lati di una stringa. Il risultato è una soluzione molto più elegante:

#include <algorithm>
#include <functional>
#include <string>

/**
 * @brief Left Trim
 *
 * Trims whitespace from the left end of the provided std::string
 *
 * @param[out] s The std::string to trim
 *
 * @return The modified std::string&
 */
std::string& ltrim(std::string& s) {
  s.erase(s.begin(), std::find_if(s.begin(), s.end(),
    std::ptr_fun<int, int>(std::isgraph)));
  return s;
}

/**
 * @brief Right Trim
 *
 * Trims whitespace from the right end of the provided std::string
 *
 * @param[out] s The std::string to trim
 *
 * @return The modified std::string&
 */
std::string& rtrim(std::string& s) {
  s.erase(std::find_if(s.rbegin(), s.rend(),
    std::ptr_fun<int, int>(std::isgraph)).base(), s.end());
  return s;
}

/**
 * @brief Trim
 *
 * Trims whitespace from both ends of the provided std::string
 *
 * @param[out] s The std::string to trim
 *
 * @return The modified std::string&
 */
std::string& trim(std::string& s) {
  return ltrim(rtrim(s));
}

Nota: in alternativa dovresti essere in grado di utilizzare std::iswgraphse hai bisogno di supporto per caratteri ampi, ma dovrai anche modificare questo codice per abilitare la std::wstringmanipolazione, che è qualcosa che non ho testato (vedi la pagina di riferimento per std::basic_stringesplorare questa opzione) .

Con C ++ 11 è arrivato anche un modulo di espressione regolare , che ovviamente può essere usato per tagliare spazi iniziali o finali.

Forse qualcosa del genere:

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));
}

Questo è quello che uso. Continua a rimuovere lo spazio dalla parte anteriore e, se è rimasto qualcosa, fai lo stesso dalla parte posteriore.

void trim(string& s) {
    while(s.compare(0,1," ")==0)
        s.erase(s.begin()); // remove leading whitespaces
    while(s.size()>0 && s.compare(s.size()-1,1," ")==0)
        s.erase(s.end()-1); // remove trailing whitespaces
}

s.erase(0, s.find_first_not_of(" \n\r\t"));                                                                                               
s.erase(s.find_last_not_of(" \n\r\t")+1);   

Per quello che vale, ecco un'implementazione dell'assetto con un occhio di riguardo per le prestazioni. È molto più veloce di molte altre routine di assetto che ho visto in giro. Invece di usare iteratori e std :: find, usa stringhe c e indici grezzi. Ottimizza i seguenti casi speciali: dimensione 0 stringa (non fare nulla), stringa senza spazi bianchi da tagliare (non fare nulla), stringa con solo spazi vuoti finali da tagliare (basta ridimensionare la stringa), stringa interamente bianca (basta cancellare la stringa) . E infine, nel peggiore dei casi (stringa con spazi bianchi iniziali), fa del suo meglio per eseguire una costruzione di copie efficiente, eseguendo solo 1 copia e spostando quella copia al posto della stringa originale.

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));
    }
}

Un modo elegante di farlo può essere come

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

E le funzioni di supporto sono implementate come:

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;   
}

E una volta che hai messo tutto questo a posto, puoi scrivere anche questo:

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

Implementazione Trim C ++ 11:

static void trim(std::string &s) {
     s.erase(s.begin(), std::find_if_not(s.begin(), s.end(), [](char c){ return std::isspace(c); }));
     s.erase(std::find_if_not(s.rbegin(), s.rend(), [](char c){ return std::isspace(c); }).base(), s.end());
}

Immagino che se inizi a chiedere il "modo migliore" per tagliare una stringa, direi che una buona implementazione sarebbe quella che:

1. Non alloca stringhe temporanee
2. Presenta sovraccarichi per il taglio sul posto e il taglio della copia
3. Può essere facilmente personalizzato per accettare diverse sequenze / logiche di validazione

Ovviamente ci sono troppi modi diversi per affrontarlo e dipende sicuramente da ciò di cui hai effettivamente bisogno. Tuttavia, la libreria standard C ha ancora alcune funzioni molto utili in <string.h>, come memchr. C'è un motivo per cui C è ancora considerato il miglior linguaggio per IO - il suo standard è pura efficienza.

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;
}

Non sono sicuro che il tuo ambiente sia lo stesso, ma nel mio caso la stringa vuota causerà l'interruzione del programma. Vorrei concludere la chiamata con un if (! S.empty ()) o utilizzare Boost come già accennato.

Ecco cosa mi è venuto in mente:

std::stringstream trimmer;
trimmer << str;
trimmer >> str;

L'estrazione del flusso elimina automaticamente gli spazi bianchi, quindi funziona come un fascino.
Abbastanza pulito ed elegante, se lo dico io stesso. ;)

Contribuendo alla mia soluzione al rumore. trimper impostazione predefinita, crea una nuova stringa e restituisce quella modificata mentre trim_in_placemodifica la stringa passata ad essa. La trimfunzione supporta la semantica di spostamento c ++ 11.

#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");  
}

Questo può essere fatto più semplicemente in C ++ 11 grazie all'aggiunta di back()e pop_back().

while ( !s.empty() && isspace(s.back()) ) s.pop_back();

Ecco la mia versione:

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);

I metodi di cui sopra sono fantastici, ma a volte vuoi usare una combinazione di funzioni per quello che la tua routine considera spazi bianchi. In questo caso, usare i funzione per combinare le operazioni può diventare confuso, quindi preferisco un semplice loop che posso modificare per il trim. Ecco una funzione di trim leggermente modificata copiata dalla versione C qui su SO. In questo esempio, sto tagliando caratteri non alfanumerici.

string trim(char const *str)
{
  // Trim leading non-letters
  while(!isalnum(*str)) str++;

  // Trim trailing non-letters
  end = str + strlen(str) - 1;
  while(end > str && !isalnum(*end)) end--;

  return string(str, end+1);
}

Ecco un'implementazione diretta. Per un'operazione così semplice, probabilmente non dovresti usare costrutti speciali. La funzione build-in isspace () si occupa di varie forme di caratteri bianchi, quindi dovremmo approfittarne. Devi anche considerare casi speciali in cui la stringa è vuota o semplicemente un mucchio di spazi. Il trim sinistro o destro potrebbe essere derivato dal seguente codice.

string trimSpace(const string &str) {
   if (str.empty()) return str;
   string::size_type i,j;
   i=0;
   while (i<str.size() && isspace(str[i])) ++i;
   if (i == str.size())
      return string(); // empty string
   j = str.size() - 1;
   //while (j>0 && isspace(str[j])) --j; // the j>0 check is not needed
   while (isspace(str[j])) --j
   return str.substr(i, j-i+1);
}

Ecco una soluzione facile da capire per i principianti che non sono abituati a scrivere std::ovunque e non hanno ancora familiarità con la constcorrettezza, la iterators, la STL algorithm, ecc ...

#include <string>
#include <cctype> // for isspace
using namespace std;


// Left trim the given string ("  hello!  " --> "hello!  ")
string left_trim(string str) {
    int numStartSpaces = 0;
    for (int i = 0; i < str.length(); i++) {
        if (!isspace(str[i])) break;
        numStartSpaces++;
    }
    return str.substr(numStartSpaces);
}

// Right trim the given string ("  hello!  " --> "  hello!")
string right_trim(string str) {
    int numEndSpaces = 0;
    for (int i = str.length() - 1; i >= 0; i--) {
        if (!isspace(str[i])) break;
        numEndSpaces++;
    }
    return str.substr(0, str.length() - numEndSpaces);
}

// Left and right trim the given string ("  hello!  " --> "hello!")
string trim(string str) {
    return right_trim(left_trim(str));
}

Spero che sia d'aiuto...

Questa versione consente di tagliare spazi bianchi interni e non alfanumerici:

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;
}

Ancora un'altra opzione: rimuove uno o più caratteri da entrambe le estremità.

string strip(const string& s, const string& chars=" ") {
    size_t begin = 0;
    size_t end = s.size()-1;
    for(; begin < s.size(); begin++)
        if(chars.find_first_of(s[begin]) == string::npos)
            break;
    for(; end > begin; end--)
        if(chars.find_first_of(s[end]) == string::npos)
            break;
    return s.substr(begin, end-begin+1);
}