also wie gesagt remove_if soll aus einer liste ein objekt entfernen wenn das listen element den selben namen(string) trägt wie das der funktion übergebenen klassen element... und iwie bekomme ich kein prädikat hin welches funktioniert !?

bool name(SingleWS const &ws1, SingleWS &ws2) {
    return ws1.GetName() == ws2.GetName();
}

void WS::Remove(SingleWS const & ws) {
    remove_if(mWeSt.begin(), mWeSt.end(), bind2nd(name, ws)) 
}

wäre nett wenn jemand rat weis

struct Compare
{
    explicit Compare(SingleWS const &ws1) : ws1(ws1) { }

    bool operator() (SingleWS const &ws2) const
    {
        return (ws1.GetName() == ws2.GetName());
    }

private:
    SingleWS const &ws1;
};

void WS::Remove(SingleWS const & ws)
{ 
    std::remove_if(mWeSt.begin(), mWeSt.end(), Compare(ws)) ;
}

EDIT: Mit C++11 sind natürlich lambdas die beste Methode.

std::bind2nd() ist übrigens deprecated. Wenn du C++11 hast, verwende stattdessen std::bind() . Auch möglich ist ein Lambda-Ausdruck als Prädikat.

also das ich das richtig verstehe wofür brauch ich das explicit ? und sonst is es einfach ein standard c-tor und die operator funktion überlädt den () operator um operationen auf die klasse auszuführen ... aber wozu brauch ich noch die ws1 als member ?

aber wozu brauch ich noch die ws1 als member ?

Schau die doch den Code an. Mit was willst du denn vergleichen wenn du ws1 nicht hast?

also das ich das richtig verstehe wofür brauch ich das explicit ?

Ein expliziter Konstruktor lässt sich auch nur explizit aufrufen. Er lässt sich also nicht implizit aufrufen.

Beispiel:

struct A
{
     A(int){}
};

struct B
{
     explicit B(int){}
};

void foo1(A);
void foo2(B);

// ...

foo1(0); // Alles gut - der sog. Konvertierungskonstruktor von A wird aufgerufen.
foo2(0); // Fehler: Du musst den Konstruktor explizit aufrufen.
foo2( B(0) ); // Gut!

Hier ein Beispiel aus dem Standard:

struct Z 
{
    explicit Z();
    explicit Z(int);
};
Z a; // OK: default-initialization performed
Z a1 = 1; // error: no implicit conversion
Z a3 = Z(1); // OK: direct initialization syntax used
Z a2(1); // OK: direct initialization syntax used
Z* p = new Z(1); // OK: direct initialization syntax used
Z a4 = (Z)1; // OK: explicit cast used
Z a5 = static_cast<Z>(1); // OK: explicit cast used

Explizite Konstruktoren machen da Sinn, wo ein Konstruktor mit einem Parameter aufgerufen werden kann, und es keinen Sinn macht, diesen implizit in den entsprechenden Klassentypen konvertierbar zu machen.

Wie würde das aussehen:

foo( vector<int> );

foo(2); // Wenn std::vectors entsprechender Konstruktor (der, der die Größe nimmt), nicht explizit wäre, würde das gehen
        // .. und das sieht echt voll Blöd aus. Macht keinen Sinn, oder!?

Und das kann dann theoretisch auch zu Überladungszwecken genutzt werden.

naja ich dachte bei der operator funktion könnt ich einfach zwei paramter angeben und die find_if liefert an den ersten paramter jeweils ein element der liste und das zweite is gebunden an ws

Du übergibst mit dem Funktor aber ein Objekt und keine Funktion. Da gibt es nichts zum Binden.