// Trim begin/end spaces
                if(tempStr.find_first_of(' ')==0)
                    tempStr.replace(0, tempStr.find_first_not_of(' '), "");
                if (!tempStr.empty() && (tempStr.find_last_of(' ')+1)==tempStr.size())
                    tempStr.replace(tempStr.find_last_not_of(' '), std::string::npos, "");

#include <functional>
#include <algorithm>
#include <locale>

template <typename CharType>
struct compress_spaces_comparator
    : std::binary_function<CharType,CharType,bool> {

    bool operator()(const CharType& a, const CharType& b) const
    {
        return std::isspace(a) && std::isspace(b);
    }

};

template <typename StringType>
void compress_spaces(StringType& str)
{
    typename StringType::iterator end = str.end();
    compress_spaces_comparator<typename StringType::value_type> comparator;
    str.erase(std::unique(str.begin(), end, comparator), end);
}

std::string test = ",    Саша    +   Маша         =";
compress_spaces(test);

template <typename CharType>
struct compress_spaces_comparator
    : std::binary_function<CharType,CharType,bool> {
    std::locale loc;
    compress_spaces_comparator(std::locale const &loc = std::locale()) : loc(loc) {}
    bool operator()(const CharType& a, const CharType& b) const
    {
        return std::isspace(a, loc) && std::isspace(b, loc);
    }
};

gok>А если пробелы в середине?

std::string str(" 1 2 ");
str.erase(std::remove(str.begin(), str.end(), ' '), str.end());

string s;
copy(istream_iterator(cin), istream_iterator(), back_inserter(s))

«Саша    +     Маша     =» ->  «Саша + Маша =»

while ( currentString.Replace("  ", " ") > 0 ){}

void eat_some_whitespaces (string & s)
{
    istringstream i(s);
    ostringstream o;
    copy(istream_iterator<string>(i), istream_iterator<string>(), ostream_iterator<string>(o, " "));
    s.swap (o.str());
    if (!s.empty()) s.resize(s.size() - 1);   
}

s.swap (o.str());

o.str().swap(s);

bool isMySpace( char ch )
{
    return ch == ' ';    //    это соответсвует твоему примеру.

//    а это чуть гибче, и более соответсвует тому, что просишь :)
    return isspace( ch ) || ch == '\n' /*|| что хочешь ещё.*/;

//    как варинат можно и так:
    const char* spaces = " \t\r\n";
    return strchar( spaces, ch ) != 0;    //    :)
}


void removeExtraSpaces( CString& str )
{
    int length = str.GetLength();
    int insPos = 0;
    int curPos = 0;
    char* ptr = str.GetBuffer( length );
    while( curPos < Length ) {
        if( !isMySpace( ptr[curPos] ) ) {
            ptr[insPOs++] = ptr[curPos++];
            continue;
        }
        ptr[insPos] = ' ';
        curPos++;
        while( curPos < length && isMySpace( ptr[curPOs] ) )
            curPos++;
    }
    ptr[insPos] = 0;
    str.ReleaseBuffer( insPos );
}

E>bool isMySpace( char ch )
E>{
E>    return ch == ' ';    //    это соответсвует твоему примеру.

E>//    а это чуть гибче, и более соответсвует тому, что просишь :)
E>    return isspace( ch ) || ch == '\n' /*|| что хочешь ещё.*/;

E>//    как варинат можно и так:
E>    const char* spaces = " \t\r\n";
E>    return strchar( spaces, ch ) != 0;    //    :)
E>}
E>

bool isMySpace(char ch)
{
    return isspace(ch); // Вернет true для ' ', '\t', '\n', '\r'.
}

void eat_some_whitespaces2 (string & s)
{
    string temp(s.size(), 0);

    string::iterator curr = s.begin(),
        end  = s.end(),
        out  = temp.begin();

    locale loc;

    while (curr != end)
    {
        if (isspace(*curr, loc)) 
        {
            *out = ' ';
            ++out;
            ++curr;
            while (curr != end)
            {
                if (isspace(*curr, loc)) ++curr;
                else 
                {
                    *out = *curr;
                    ++out;
                    ++curr;
                    break;
                }
            }
        }
        else
        {
            *out = *curr;
            ++out;
            ++curr;
        }
    }
    temp.resize(out - temp.begin());
    s.swap(temp);
}

void eat_some_whitespaces3 (string & s)
{
    string temp(s.size(), 0);

    string::iterator curr = s.begin(),
        end  = s.end(),
        out  = temp.begin();

    locale loc;

    bool write = true;

    while (curr != end)
    {
        if (isspace(*curr, loc)) 
        {
            if (write)
            {
                *out = ' ';
                ++out;
                write = false;
            }
            ++curr;
        }
        else
        {
            *out = *curr;
            ++out;
            ++curr;
            write = true;
        }
    }
    temp.resize(out - temp.begin());
    s.swap(temp);
}

char *space_deleter( char *s )
{
      char *b=s,*p=s;
      for(;*p;p++) if (*p==' ') *b++ = *p;
      *b=0; return s; 
}

char *trim_str( char *s , int l)
{
      char *b=s,*p=s,*p2=s+l-1;
      for(;*p;p++) if (*p==' ') *b++ = *p; else break;
      for(;*p2==' ';p2--)*p2=0;
      for(;*p;p++,b++) *b=*p;
      *b=0; return s; 
}