entweder selber coden

#include <cctype>
#include <string>

std::string trimm( std::string txt )
{
    using namespace std;
    while( !txt.empty() && isspace( *txt.begin() ) )
        txt.erase( txt.begin() );
    while( !txt.empty() && isspace( *(txt.end()-1) ) )
        txt.erase( txt.end()-1 );
    return txt;
}

oder besser: gar nicht erst dazu kommen lassen. Wo kommt der String her?

Gruß
Werner

sicher? speicher allozieren kostet bestimmt mehr als die array elemente zu verschieben.

Ja, sicher. Schließlich verschiebt jedes erase() die Elemente wieder neu (und dieses mehrfache Verschieben kostet).

aber vielleicht sollte man es so proggen das nur 1 mal erase für jede seite aufgerufen wird.

Oder so.

Edit:

Konstruktör schrieb:

Bei ganz langen Strings könnte es sich lohnen, anstatt find_if, find_first_not_of und find_last_not_of zu benutzen.

Durchaus möglich - aber dazu müsstest du erstmal einen Teststring zusammenbauen mit allen Whitespaces (in der Hinsicht sind die Algorithmen vielseitiger).

(btw kann man find_if auch mit reverse-Iteratoren verwenden ;))

Konstruktör schrieb:

Bei ganz langen Strings könnte es sich lohnen, anstatt find_if, find_first_not_of und find_last_not_of zu benutzen.

Durchaus möglich - aber dazu müsstest du erstmal einen Teststring zusammenbauen mit allen Whitespaces

Wieso das? 'find_first/last_not_of' funktioniert wunderbar.

std::string trim(std::string str)
{
    std::string::size_type i;

    if ((i = str.find_first_not_of(" \t")) != std::string::npos)
        str.erase(0, i);
    else return "";

    if ((i = str.find_last_not_of(" \t")) != std::string::npos)
        str.erase(i + 1);

    return str;
}

/EDIT: Das 'else' sollte man sich eher sparen. Das macht das ganze nicht wirklich schneller und verhindert RVO.

MSDN schrieb:

isspace returns a non-zero value if c is a white-space character (0x09 – 0x0D or 0x20).

Und was ist mit \n etc?

Hm. Ich finde eigentlich nicht, dass diese durch 'trim' entfernt werden sollen aber ich bin da zugegebenermaßen durch VB vorbelastet.
Wenn man äquivalent zu 'isspace' agieren möchte sollte man das auch benutzen, sprich über 'find_if' gehen.

struct myspace : public std::unary_function<char, bool>
{
    bool operator ()(char c) const { return std::isspace(c); }
};

std::string trim(std::string str)
{
    typedef std::string::iterator SI;
    typedef std::string::reverse_iterator CSI;

    SI i = std::find_if(str.begin(), str.end(), std::not1(myspace()));
    str.erase(str.begin(), i);

    CSI j = std::find_if(str.rbegin(), str.rend(), std::not1(myspace()));
    str.erase(j.base(), str.end());

    return str;
}

Irgendwie stört mich die Adapter-struct aber ohne bekomme ich es nicht hin. Gut, der Typ, der die Vorlesung hält, stört meine Konzentration ein wenig.

...
	return trimWhere<int(*)(int)>(s, std::isspace);
...

Warum ist der Predicatetype int(*)(int) ?
Im Std steht isspace als

template <typename charT> bool (*)(charT, const locale&)

Gruß,

Simon2.

HumeSikkins schrieb:

void trimA(std::string& s) {
	typedef int (*Sig)(int);
	s.erase(s.begin(), std::find_if(s.begin(), s.end(), not1(ptr_fun(static_cast<Sig>(isspace)))));
	s.erase(std::find_if(s.rbegin(), s.rend(), not1(ptr_fun(static_cast<Sig>(isspace)))).base(), s.end());
}

Das ist aber unter Umständen nicht ganz korrekt (siehe char vs. unsigned cahr vs. int Problematik).
Besser also:

struct IsSpace : std::unary_function<char, bool> {
	bool operator()(char c) const {
		return isspace(static_cast<unsigned char>(c)) != 0;
	}
};

void trim(std::string& s) {
	s.erase(s.begin(), std::find_if(s.begin(), s.end(), not1(IsSpace())));
	s.erase(std::find_if(s.rbegin(), s.rend(), not1(IsSpace())).base(), s.end());
}

Grüße,
don_basto.