Pregunta ¿Cuál es la mejor manera de recortar std :: string?


Actualmente estoy usando el siguiente código para recortar todos los std::strings en mis programas:

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

Funciona bien, pero me pregunto si hay algunos casos finales en los que podría fallar.

Por supuesto, las respuestas con alternativas elegantes y también la solución de ajuste izquierdo son bienvenidas.


647
2017-10-19 19:23


origen


Respuestas:


EDITAR Desde c ++ 17, algunas partes de la biblioteca estándar fueron eliminadas. Afortunadamente, comenzando con c ++ 11, tenemos lambdas que son una solución superior.

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

Gracias a https://stackoverflow.com/a/44973498/524503 para traer a colación la solución moderna.

Respuesta original:

Tiendo a usar uno de estos 3 para mis necesidades de recorte:

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

Son bastante auto explicativos y funcionan muy bien.

EDITAR: Por cierto, tengo std::ptr_fun allí para ayudar a desambiguar std::isspace porque en realidad hay una segunda definición que admite configuraciones regionales. Esto podría haber sido un yeso de la misma manera, pero tiendo a gustarme esto mejor.

EDITAR: Para abordar algunos comentarios sobre la aceptación de un parámetro por referencia, modificarlo y devolverlo. Estoy de acuerdo. Una implementación que preferiría sería dos conjuntos de funciones, una para el lugar y otra para hacer una copia. Un mejor conjunto de ejemplos sería:

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

Sin embargo, mantengo la respuesta original más arriba para el contexto y en interés de mantener disponible la respuesta más votados.


525
2017-10-20 05:46



Utilizando Algoritmos de cadena de Boost sería más fácil:

#include <boost/algorithm/string.hpp>

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

str es ahora "hello world!". También hay trim_left y trim, que recorta ambos lados.


Si agrega _copy sufijo a cualquiera de los nombres de funciones anteriores, p. trim_copy, la función devolverá una copia recortada de la cadena en lugar de modificarla a través de una referencia.

Si agrega _if sufijo a cualquiera de los nombres de funciones anteriores, p. trim_copy_if, puede recortar todos los caracteres que satisfagan su predicado personalizado, en lugar de solo espacios en blanco.


376
2017-10-19 19:55



Utilice el siguiente código para recortar espacios y caracteres de tabulación correctos desde 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));
}

Y solo para equilibrar las cosas, incluiré también el código de ajuste izquierdo (ideone)

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

55
2017-12-07 19:45



Un poco tarde para la fiesta, pero no importa. Ahora C ++ 11 está aquí, tenemos lambdas y variables automáticas. Por lo tanto, mi versión, que también maneja cadenas totalmente vacías y espacios en blanco, es:

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

Podríamos hacer un iterador inverso de wsfront y usar eso como la condición de terminación en el segundo find_if_not pero eso solo es útil en el caso de una cadena de espacios en blanco, y gcc 4.8 al menos no es lo suficientemente inteligente como para inferir el tipo del iterador inverso (std::string::const_reverse_iterator) con auto. No sé qué tan costoso es construir un iterador inverso, entonces YMMV aquí. Con esta alteración, el código se ve así:

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

49
2017-07-31 17:03



Lo que estás haciendo es bueno y robusto. He usado el mismo método durante mucho tiempo y todavía no he encontrado un método más rápido:

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 (left & right)
inline std::string& trim(std::string& s, const char* t = ws)
{
    return ltrim(rtrim(s, t), t);
}

Al suministrar los caracteres que se van a recortar, tiene la flexibilidad de recortar caracteres que no son de espacios en blanco y la eficiencia para recortar solo los caracteres que desea recortar.


33
2017-08-19 14:16



Prueba esto, funciona para mí.

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

30
2018-06-28 00:47



Me gusta la solución de tzaman, el único problema es que no recorta una cadena que contiene solo espacios.

Para corregir ese 1 defecto, agregue un str.clear () entre las 2 líneas de recorte

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

25
2017-07-05 06:37