std :: string을 자르는 가장 좋은 방법은 무엇입니까?

현재 다음 코드를 사용하여 std::strings프로그램의 모든 항목을 오른쪽으로 자릅니다 .

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

잘 작동하지만 실패 할 수있는 최종 사례가 있는지 궁금합니다.

물론, 우아한 대안과 왼쪽 손질 솔루션으로 답변을 환영합니다.

편집 c ++ 17 이후 표준 라이브러리의 일부가 제거되었습니다. 다행스럽게도 c ++ 11부터는 우수한 솔루션 인 람다가 있습니다.

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

최신 솔루션을 제공하는 https://stackoverflow.com/a/44973498/524503 에 감사합니다 .

원래 답변 :

트리밍 요구에 다음 3 가지 중 하나를 사용하는 경향이 있습니다.

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

그들은 상당히 자명하고 잘 작동합니다.

편집 : BTW, 실제로 로케일을 지원하는 두 번째 정의가 있기 때문에 std::ptr_fun명확성을 돕기 위해 거기에 std::isspace있습니다. 이것은 똑같은 캐스트 일 수 있었지만 나는 이것을 더 좋아하는 경향이 있습니다.

편집 : 매개 변수를 참조하여 수락하고 수정하고 반환하는 것에 대한 의견을 제시합니다. 동의한다. 내가 선호하는 구현은 두 가지 기능 세트, 하나는 제자리에 있고 다른 하나는 사본을 만듭니다. 더 나은 예는 다음과 같습니다.

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

나는 문맥 상으로 그리고 높은 투표 응답을 계속 사용할 수 있도록 위의 원래 답변을 유지하고 있습니다.

사용 부스트의 문자열 알고리즘은 쉬운 것입니다 :

#include <boost/algorithm/string.hpp>

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

str지금 "hello world!"입니다. 이이기도 trim_left하고 trim양쪽 트림한다.

_copy위의 함수 이름 에 접미사를 추가하면 ( 예 : 참조 trim_copy) 함수는 문자열을 참조를 통해 수정하지 않고 잘린 사본을 반환합니다.

_if예를 들어 위의 함수 이름 에 접미사를 추가 trim_copy_if하면 공백이 아닌 사용자 지정 술어를 만족시키는 모든 문자를자를 수 있습니다.

다음 코드를 사용하여 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));
}

그리고 균형을 맞추기 위해 왼쪽 트림 코드도 포함합니다 ( ideone ).

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

당신이하고있는 일은 훌륭하고 강력합니다. 나는 같은 방법을 오랫동안 사용했지만 아직 더 빠른 방법을 찾지 못했습니다.

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

트리밍 할 문자를 제공하면 공백이 아닌 문자를 트리밍 할 수있는 유연성과 트리밍하려는 문자 만 트리밍 할 수있는 효율성이 있습니다.

파티에 늦었지만 걱정하지 마십시오. 이제 C ++ 11이 있습니다. 람다와 자동 변수가 있습니다. 따라서 모든 공백과 빈 문자열을 처리하는 내 버전은 다음과 같습니다.

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

우리는 역 반복자를 만들 수 있습니다. wsfront 두 번째 터미네이션 조건으로 사용할 수 find_if_not있지만 공백 공백 문자열의 경우에만 유용하며 gcc 4.8 이상은 리버스 이터레이터의 유형을 유추하기에 충분하지 않습니다 ( std::string::const_reverse_iterator)와 auto. 역 이터레이터를 구성하는 데 비용이 많이 들지 않으므로 YMMV입니다. 이 변경으로 코드는 다음과 같습니다.

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

이것을 시도하십시오, 그것은 나를 위해 작동합니다.

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

나는 tzaman의 솔루션을 좋아하는데, 유일한 문제는 공백 만 포함하는 문자열을 자르지 않는다는 것입니다.

1 개의 결함을 수정하려면 2 개의 트리머 라인 사이에 str.clear ()를 추가하십시오.

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

빈 문자열의 경우 코드에서 1을 추가하여 string::npos0 을 제공 하는 것은 부호없는 string::npos유형 string::size_type인 것으로 가정합니다 . 따라서 오버플로 추가 동작에 의존하고 있습니다.

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

이것은 null 경우에도 작동합니다. :-)

C ++ 17에서는 basic_string_view :: remove_prefix 및 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;
}

좋은 대안 :

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

@Bill the Lizard 의 답변을 기반으로 한 내 솔루션 .

입력 문자열에 공백 만 있으면이 함수는 빈 문자열을 반환합니다.

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

내 대답은 제어 문자와 공백 ( ASCII 테이블 의 0-32 및 127)을 자르는이 게시물 의 최상위 답변 을 개선 한 것 입니다 .

std::isgraph문자에 그래픽 표현이 있는지 여부를 결정하므로이를 사용하여 문자열의 양쪽에서 그래픽 표현이없는 문자를 제거하도록 Evan의 답변을 변경할 수 있습니다. 결과는 훨씬 더 우아한 솔루션입니다.

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

참고 : 또는 std::iswgraph넓은 문자를 지원해야하는 경우 사용할 수도 있지만 std::wstring테스트하지 않은 조작 을 사용하려면이 코드를 편집해야합니다 ( std::basic_string이 옵션을 탐색 하려면 참조 페이지 참조 ). .

C ++ 11에서도 정규 표현식 이 나왔습니다. 모듈도 제공되어 물론 선행 또는 후행 공백을 자르는 데 사용할 수 있습니다.

아마도 이런 식으로 뭔가 :

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

이것이 내가 사용하는 것입니다. 앞면에서 공간을 계속 제거한 다음 남은 것이 있으면 뒷면에서도 동일하게하십시오.

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

가치있는 것을 위해, 성능을 향한 트림 구현이 있습니다. 내가 본 다른 많은 트림 루틴보다 훨씬 빠릅니다. 반복자와 std :: finds를 사용하는 대신 원시 c 문자열과 인덱스를 사용합니다. 크기 0 문자열 (아무것도하지 않음), 잘라낼 공백이없는 문자열 (아무것도 없음), 끝 마무리 공백이있는 문자열 (자르기 만하면 됨), 완전히 공백 인 문자열 (문자열 지우기) . 마지막으로 최악의 경우 (공백이있는 문자열) 효율적인 복사 구성을 수행하고 1 개의 사본 만 수행 한 다음 해당 사본을 원래 문자열 대신 이동하는 것이 가장 좋습니다.

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

그것을하는 우아한 방법은 같을 수 있습니다

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

그리고 지원 기능은 다음과 같이 구현됩니다.

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

그리고 일단이 모든 것을 제자리에 놓으면 다음과 같이 쓸 수도 있습니다.

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

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

문자열을 자르는 "최상의 방법"을 요구하기 시작하면 좋은 구현이 다음과 같습니다.

1. 임시 문자열을 할당하지 않습니다
2. 전체 트리밍 및 복사 트리밍을위한 과부하가 있음
3. 다양한 검증 시퀀스 / 논리를 수용하도록 쉽게 사용자 정의 가능

분명히 이것에 접근하는 방법이 너무 많으며 실제로 필요한 것에 달려 있습니다. 그러나 C 표준 라이브러리에는 여전히 memchr과 같은 <string.h>에 매우 유용한 기능이 있습니다. C가 여전히 IO에 가장 적합한 언어로 여겨지는 이유가 있습니다. stdlib는 순수한 효율성입니다.

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

환경이 같은지 확실하지 않지만 빈 문자열 케이스로 인해 프로그램이 중단됩니다. if (! s.empty ())로 지우기 호출을 래핑하거나 이미 언급 한 것처럼 Boost를 사용합니다.

내가 생각해 낸 것은 다음과 같습니다.

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

스트림 추출은 공백을 자동으로 제거하므로 매력처럼 작동합니다.
내가 직접 말하면 꽤 깨끗하고 우아합니다. ;)

내 솔루션을 소음에 기여합니다. trim기본적으로 새 문자열을 만들고 trim_in_place전달 된 문자열 을 수정하는 동안 수정 된 문자열을 반환 합니다. 이 trim함수는 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");  
}

이것은 back()and 의 추가로 인해 C ++ 11에서 더 간단하게 수행 할 수 있습니다 pop_back().

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

내 버전은 다음과 같습니다.

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

위의 방법은 훌륭하지만 때로는 일상에서 공백으로 간주하는 기능을 조합하여 사용하려고합니다. 이 경우 펑터를 사용하여 작업을 결합하면 지저분해질 수 있으므로 트림에 대해 수정할 수있는 간단한 루프를 선호합니다. 여기 SO 버전의 C 버전에서 복사 된 약간 수정 된 트림 기능이 있습니다. 이 예에서는 영숫자가 아닌 문자를 자릅니다.

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

다음은 간단한 구현입니다. 이러한 간단한 작업을 위해서는 특별한 구성을 사용하지 않아야합니다. 내장 된 isspace () 함수는 다양한 형태의 흰색 문자를 처리하므로이를 활용해야합니다. 또한 문자열이 비어 있거나 단순히 여러 개의 공백이있는 특수한 경우를 고려해야합니다. 왼쪽 또는 오른쪽 트림은 다음 코드에서 파생 될 수 있습니다.

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

여기에 글을 쓰는 데 std::익숙하지 않고- const정확도, iterators, STL algorithm등에 익숙하지 않은 초보자가 이해하기 쉬운 솔루션이 있습니다 .

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

그것이 도움이되기를 바랍니다 ...

이 버전은 내부 공백과 영숫자가 아닌 문자를 자릅니다.

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

또 다른 옵션-양쪽 끝에서 하나 이상의 문자를 제거합니다.

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