C++ Taglio di caratteri all'inizio / fine


Esempio

Questo esempio richiede le intestazioni <algorithm> , <locale> e <utility> .

C ++ 11

Tagliare una sequenza o una stringa significa rimuovere tutti gli elementi iniziali e finali (o caratteri) che corrispondono a un determinato predicato. Per prima cosa tagliamo gli elementi finali, perché non implica lo spostamento di alcun elemento e quindi taglia gli elementi principali. Si noti che le generalizzazioni di seguito funzionano per tutti i tipi di std::basic_string (ad es. std::string e std::wstring ), e accidentalmente anche per contenitori di sequenze (ad es. std::vector e std::list ).

template <typename Sequence, // any basic_string, vector, list etc.
          typename Pred>     // a predicate on the element (character) type
Sequence& trim(Sequence& seq, Pred pred) {
    return trim_start(trim_end(seq, pred), pred);
}

Ritagliare gli elementi finali significa trovare l' ultimo elemento che non corrisponde al predicato e cancellare da lì in poi:

template <typename Sequence, typename Pred>
Sequence& trim_end(Sequence& seq, Pred pred) {
    auto last = std::find_if_not(seq.rbegin(),
                                 seq.rend(),
                                 pred);
    seq.erase(last.base(), seq.end());
    return seq;
}

Il taglio degli elementi principali comporta la ricerca del primo elemento che non corrisponde al predicato e che cancella fino a lì:

template <typename Sequence, typename Pred>
Sequence& trim_start(Sequence& seq, Pred pred) {
    auto first = std::find_if_not(seq.begin(),
                                  seq.end(),
                                  pred);
    seq.erase(seq.begin(), first);
    return seq;
}

Per specializzare quanto sopra per il taglio degli spazi bianchi in una std::string possiamo usare la funzione std::isspace() come predicato:

std::string& trim(std::string& str, const std::locale& loc = std::locale()) {
    return trim(str, [&loc](const char c){ return std::isspace(c, loc); });
}

std::string& trim_start(std::string& str, const std::locale& loc = std::locale()) {
    return trim_start(str, [&loc](const char c){ return std::isspace(c, loc); });
}

std::string& trim_end(std::string& str, const std::locale& loc = std::locale()) {
    return trim_end(str, [&loc](const char c){ return std::isspace(c, loc); });
}

Allo stesso modo, possiamo usare la funzione std::iswspace() per std::wstring ecc.

Se desideri creare una nuova sequenza che è una copia tagliata, puoi utilizzare una funzione separata:

template <typename Sequence, typename Pred>
Sequence trim_copy(Sequence seq, Pred pred) { // NOTE: passing seq by value
    trim(seq, pred);
    return seq;
}