Efficient way to check if std::string has only spaces

I was just talking with a friend about what would be the most efficient way to check if a std::string has only spaces. He needs to do this on an embedded project he is working on and apparently this kind of optimization matters to him.

I've came up with the following code, it uses strtok().

bool has_only_spaces(std::string& str)
{
    char* token = strtok(const_cast<char*>(str.c_str()), " ");

    while (token != NULL)
    {   
        if开发者_JS百科 (*token != ' ')
        {   
            return true;
        }   
    }   
    return false;
}

I'm looking for feedback on this code and more efficient ways to perform this task are also welcome.

if(str.find_first_not_of(' ') != std::string::npos)
{
    // There's a non-space.
}

In C++11, the all_of algorithm can be employed:

// Check if s consists only of whitespaces
bool whiteSpacesOnly = std::all_of(s.begin(),s.end(),isspace);

Why so much work, so much typing?

bool has_only_spaces(const std::string& str) {
   return str.find_first_not_of (' ') == str.npos;
}

Wouldn't it be easier to do:

bool has_only_spaces(const std::string &str)
{
    for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
    {
        if (*it != ' ') return false;
    }
    return true;
}

This has the advantage of returning early as soon as a non-space character is found, so it will be marginally more efficient than solutions that examine the whole string.

To check if string has only whitespace in c++11:

bool is_whitespace(const std::string& s) {
  return std::all_of(s.begin(), s.end(), isspace);
}

in pre-c++11:

bool is_whitespace(const std::string& s) {
  for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) {
    if (!isspace(*it)) {
      return false;
    }
  }
  return true;
}

Here's one that only uses STL (Requires C++11)

inline bool isBlank(const std::string& s)
{
    return std::all_of(s.cbegin(),s.cend(),[](char c) { return std::isspace(c); });
}

It relies on fact that if string is empty (begin = end) std::all_of also returns true

Here is a small test program: http://cpp.sh/2tx6

Using strtok like that is bad style! strtok modifies the buffer it tokenizes (it replaces the delimiter chars with \0).

Here's a non modifying version.

const char* p = str.c_str();
while(*p == ' ') ++p;
return *p != 0;

It can be optimized even further, if you iterate through it in machine word chunks. To be portable, you would also have to take alignment into consideration.

I do not approve of you const_casting above and using strtok.

A std::string can contain embedded nulls but let's assume it will be all ASCII 32 characters before you hit the NULL terminator.

One way you can approach this is with a simple loop, and I will assume const char *.

bool all_spaces( const char * v )
{
   for ( ; *v; ++v )
   {
      if( *v != ' ' )
          return false;
   }
   return true;
}

For larger strings, you can check word-at-a-time until you reach the last word, and then assume the 32-bit word (say) will be 0x20202020 which may be faster.

Something like:

return std::find_if(
            str.begin(), str.end(),
            std::bind2nd( std::not_equal_to<char>(), ' ' ) )
    == str.end();

If you're interested in white space, and not just the space character, then the best thing to do is to define a predicate, and use it:

struct IsNotSpace
{
    bool operator()( char ch ) const
    {
        return ! ::is_space( static_cast<unsigned char>( ch ) );
    }
};

If you're doing any text processing at all, a collection of such simple predicates will be invaluable (and they're easy to generate automatically from the list of functions in <ctype.h>).

it's highly unlikely you'll beat a compiler optimized naive algorithm for this, e.g.

string::iterator it(str.begin()), end(str.end())    
for(; it != end && *it == ' '; ++it);
return it == end;

EDIT: Actually - there is a quicker way (depending on size of string and memory available)..

std::string ns(str.size(), ' '); 
return ns == str;

EDIT: actually above is not quick.. it's daft... stick with the naive implementation, the optimizer will be all over that...

EDIT AGAIN: dammit, I guess it's better to look at the functions in std::string

return str.find_first_not_of(' ') == string::npos;

I had a similar problem in a programming assignment, and here is one other solution I came up with after reviewing others. here I simply create a new sentence without the new spaces. If there are double spaces I simply overlook them.

string sentence; string newsent; //reconstruct new sentence string dbl = " ";

getline(cin, sentence);

int len = sentence.length();

for(int i = 0; i < len; i++){

//if there are multiple whitespaces, this loop will iterate until there are none, then go back one.
    if (isspace(sentence[i]) && isspace(sentence[i+1])) {do{ 
        i++;
    }while (isspace(sentence[i])); i--;} //here, you have to dial back one to maintain at least one space.  
    
    
    newsent +=sentence[i];
}       

cout << newsent << "\n";

Hm...I'd do this:

for (auto i = str.begin(); i != str.end() ++i)
    if (!isspace(i))
       return false;

Pseudo-code, isspace is located in cctype for C++.

Edit: Thanks to James for pointing out that isspace has undefined behavior on signed chars.

If you are using CString, you can do

CString myString = "    "; // All whitespace
if(myString.Trim().IsEmpty())
{
    // string is all whitespace
}

This has the benefit of trimming all newline, space and tab characters.