How can I trim a std::string?

For C++11

#include <algorithm> #include <cctype> #include <locale> // Trim from the start (in place) inline void ltrim(std::string &s) { s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) { return !std::isspace(ch); })); } // Trim from the end (in place) inline void rtrim(std::string &s) { s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) { return !std::isspace(ch); }).base(), s.end()); } 

Thanks to std::ptr_fun replacement for c++17 for bringing up the modern solution.

Convenience functions

// Trim from both ends (in place) inline void trim(std::string &s) { rtrim(s); ltrim(s); } // Trim from the start (copying) inline std::string ltrim_copy(std::string s) { ltrim(s); return s; } // Trim from the end (copying) inline std::string rtrim_copy(std::string s) { rtrim(s); return s; } // Trim from both ends (copying) inline std::string trim_copy(std::string s) { trim(s); return s; } 

For C++03

To address some comments about accepting a parameter by reference, modifying and returning it. I agree. An implementation that I would likely prefer would be two sets of functions, one for in place and one which makes a copy. A better set of examples would be:

#include <algorithm> #include <functional> #include <cctype> #include <locale> // Trim from the start (in place) 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 the end (in place) 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()); } // The remaining functions (trim() et al.) are identical to the new C++11 version 

std::ptr_fun is needed to disambiguate std::isspace because there is a second definition which supports locales. This could have been a cast just the same, but I tend to like this better.

Another answer for C++03

#include <algorithm> #include <functional> #include <cctype> #include <locale> // Trim from start 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 the end 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 inline std::string &trim(std::string &s) { return ltrim(rtrim(s)); } 

Using Boost's string algorithms would be easiest:

#include <boost/algorithm/string.hpp> std::string str("Hello, World! "); boost::trim_right(str); 

str is now "Hello, World!". There's also trim_left and trim, which trims both sides.

If you add _copy suffix to any of above function names e.g. trim_copy, the function will return a trimmed copy of the string instead of modifying it through a reference.

If you add _if suffix to any of above function names e.g. trim_copy_if, you can trim all characters satisfying your custom predicate, as opposed to just whitespaces.

What you are doing is fine and robust. I have used the same method for a long time and I have yet to find a faster method:

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

By supplying the characters to be trimmed you have the flexibility to trim non-whitespace characters and the efficiency to trim only the characters you want trimmed.

Try this. It works for me.

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

Use the following code to right trim (trailing) spaces and tab characters from 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)); } 

And just to balance things out, I'll include the left trim code too (ideone):

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

Now C++11 is here, we have lambdas and auto variables. So my version, which also handles all-whitespace and empty strings, is:

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

We could make a reverse iterator from wsfront and use that as the termination condition in the second find_if_not, but that's only useful in the case of an all-whitespace string, and gcc 4.8 at least isn't smart enough to infer the type of the reverse iterator (std::string::const_reverse_iterator) with auto. I don't know how expensive constructing a reverse iterator is, so YMMV here. With this alteration, the code looks like this:

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

With C++17 you can use basic_string_view::remove_prefix and 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; } 

A nice alternative:

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

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

I like tzaman's solution. The only problem with it is that it doesn't trim a string containing only spaces.

To correct that one flaw, add a str.clear() in between the two trimmer lines:

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

In the case of an empty string, your code assumes that adding 1 to string::npos gives 0. string::npos is of type string::size_type, which is unsigned. Thus, you are relying on the overflow behaviour of addition.

str.erase(0, str.find_first_not_of("\t\n\v\f\r ")); // left trim str.erase(str.find_last_not_of("\t\n\v\f\r ") + 1); // right trim 

Try it online!

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

Hacked off of 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; } 

This works for the null case as well. :-)

Here is a solution for trim with regex

#include <string> #include <regex> string trim(string str){ return regex_replace(str, regex("(^[ ]+)|([ ]+$)"),""); } 

My solution based on the answer by @Bill the Lizard.

Note that these functions will return the empty string if the input string contains nothing but whitespace.

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

With C++11 also came a regular expression module, which of course can be used to trim leading or trailing spaces.

Maybe something like this:

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

My answer is an improvement upon the top answer for this post that trims control characters as well as spaces (0-32 and 127 on the ASCII table).

std::isgraph determines if a character has a graphical representation, so you can use this to alter Evan's answer to remove any character that doesn't have a graphical representation from either side of a string. The result is a much more elegant solution:

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

Note: Alternatively you should be able to use std::iswgraph if you need support for wide characters, but you will also have to edit this code to enable std::wstring manipulation, which is something that I haven't tested (see the reference page for std::basic_string to explore this option).

This is what I use. Just keep removing space from the front, and then, if there's anything left, do the same from the back.

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 } 

An elegant way of doing it can be like

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

And the supportive functions are implemented as:

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

And once you've all these in place, you can write this as well:

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

I guess if you start asking for the "best way" to trim a string, I'd say a good implementation would be one that:

1. Doesn't allocate temporary strings
2. Has overloads for in-place trim and copy trim
3. Can be easily customized to accept different validation sequences / logic

Obviously there are too many different ways to approach this and it definitely depends on what you actually need. However, the C standard library still has some very useful functions in <string.h>, like memchr. There's a reason why C is still regarded as the best language for IO - its stdlib is pure efficiency.

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

Trim C++11 implementation:

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

This can be done more simply in C++11 due to the addition of back() and pop_back().

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

For what it's worth, here is a trim implementation with an eye towards performance. It's much quicker than many other trim routines I've seen around. Instead of using iterators and std::finds, it uses raw C strings and indices.

It optimizes the following special cases: size 0 string (do nothing), string with no whitespace to trim (do nothing), string with only trailing whitespace to trim (just resize the string), string that's entirely whitespace (just clear the string).

And finally, in the worst case (string with leading whitespace), it does its best to perform an efficient copy construction, performing only one copy and then moving that copy in place of the original string.

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

trim defaults to creating a new string and returning the modified one while trim_in_place modifies the string passed to it. The trim function supports C++11 move semantics.

#include <string> // Modifies the input string, and returns the 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"); } 

Here's what I came up with:

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

Stream extraction eliminates whitespace automatically, so this works like a charm.
It is pretty clean and elegant too, if I do say so myself. ;)

Here is my 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); 

Here's a solution easy to understand for beginners not used to write std:: everywhere and not yet familiar with const-correctness, iterators, STL algorithms, etc...

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

Hope it helps...

I'm not sure if your environment is the same, but in mine, the empty string case will cause the program to abort. I would either wrap that erase call with an if(!s.empty()) or use Boost as already mentioned.

The above methods are great, but sometimes you want to use a combination of functions for what your routine considers to be whitespace. In this case, using functors to combine operations can get messy, so I prefer a simple loop I can modify for the trim. Here is a slightly modified trim function copied from the C version here on Stack Overflow. In this example, I am trimming non alphanumeric characters.

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

What about this...?

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