Removing all spaces from a string

Question

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
  string str;
  cin>>str;
  str.erase(remove_if(str.begin(), str.end(), isspace),str.end());
  cout<<str;
  return 0;
}

ERROR MSG:

/home/satish/Desktop/CPP/Remove_Spaces/main.cpp|9|error: no matching function for call to ‘remove_if(std::basic_string::iterator, std::basic_string::iterator, )’|

Answer 1

First off, std::isspace is declared in <cctype> so include that.

Secondly, you need to disambiguate the overload by casting the function to an explicit type:

str.erase(
    remove_if(str.begin(), str.end(), static_cast<int(*)(int)>(isspace)),
    str.end());

Third, as James remarked, this causes undefined behaviour for all characters which aren’t in the ASCII range, and since you cannot generally exclude this, you need to make an effort to ensure that only positive character codes are passed to std::isspace:

bool char_isspace(char c) {
    return std::isspace(static_cast<unsigned char>(c));
}

…

str.erase(
    remove_if(str.begin(), str.end(), char_isspace),
    str.end());

Answer 2

As was denoted in the comments, you are missing the include for std::isspace, namely <cctype>. But even then you won't have success, because isspace is overloaded see here.

The solution to the overload problem would be to explicitly cast the function pointer to the desired function sgnature:

str.erase(remove_if(str.begin(), str.end(), static_cast<int(*)(int)>(&std::isspace)),str.end());

However, as has been noted in the comments, the isspace used here has undefined behavior if it gets non-ASCII characters. In that case it would be preferable to use the templated version taking a locale as second parameter:

C++14:

str.erase(
  remove_if(str.begin(), str.end(), 
    [](auto c){ return isspace(c, cin.getloc());}
  ),
str.end());

C++11: as above, with the lambda taking a char c as parameter (no polymorphic lambdas in C++11).

C++03 with boost: using boost::bind to create the predicate for remove_if

str.erase(
  remove_if(str.begin(), str.end(), 
    boost::bind(&std::isspace<char>, _1, boost::ref(cin.getloc()))
  ),
str.end());

C++03 without boost: defining a handwritten functor as predicate

struct IsSpace {
  bool operator()(char c) {
    return std::isspace(c, cin.getloc());
  }
};

str.erase(
  remove_if(str.begin(), str.end(), 
    IsSpace()
  ),
str.end());

Answer 3

Since all of the answers so far involve undefined behavour...

The "simplest" solution, for a one of use, if you have C++11, is:

str.erase(
    std::remove_if(
        str.begin(),
        str.end(), 
        []( char ch ) { return isspace( static_cast<unsigned char>( ch ) ); } ),
    str.end() );

Without the cast to unsigned char, the input to isspace will fail the (unchecked) preconditions of the function is plain char is signed.

If you don't have C++11, or you're going to need this sort of thing (skipping whitespace, etc.) in other places as well, you can write a separate predicate functional object:

struct IsSpace
{
    bool operator()( char ch ) const
    {
        return isspace( static_cast<unsigned char>( ch ) );
    }
};

You might also want IsNotSpace and corresponding objects for the rest of the is... functions in <ctype.h>.

Alternatively, you can use the locale aware versions of the functions in <locale>:

template <std::ctype_base>::mask mask, bool is>
class Is
{
    std::locale m_toEnsureLifetime;
    std::ctype<char> const* m_ctype;
public:
    Is( std::locale const& l = std::locale() )
        : m_toEnsureLifetime( l )
        , m_ctype( &std::use_facet<std::ctype<char>>( m_toEnsureLifetime ) )
    {
    }
    bool operator()( char ch ) const
    {
        return m_ctype->is( mask, ch ) == is;
    }
};
typedef Is<std::ctype_base::space, true> IsSpace;
typedef Is<std::ctype_base::space, false> IsNotSpace;
//  ...

Although a bit more complex, it is fully locale aware, and actually requires less code (because the mask can be a template argument).

Answer 4

try this way:

#include <iostream>
#include <string>
#include <algorithm>

struct SpaceRemover
{
    bool operator( )( char _ch ) { return std::isspace( _ch ); }
};

int main( )
{
    std::string strSource = "   type    ddd     ";
    std::cout << "[main] Source string :\""<< strSource << "\"" << std::endl;

    std::string::iterator itEnd = std::remove_if( strSource.begin(), 
                                                  strSource.end(), 
                                                  SpaceRemover( ) );
    strSource.resize( std::distance( strSource.begin(), itEnd ) );

    std::cout << "[main] Result string :\""<< strSource << "\"" << std::endl;

    return 0;
}

Answer 5

#include <iostream>

int main() {
    std::string original =  "   type    ddd     ";
    std::string result;
    for(char c: original) {
        if( ! std::isspace(c)) result += c;
    }
    original.swap(result);
    std::cout << "Modified: " << original << std::endl;
    return 0;
}

If the result size can be predicted (or just taking the original size is good enough), a result.reserve() will improve performance.