Klingt verdammt kompliziert, hier ein kleines Beispiel zur Verdeutlichung:

class Elem
{
    int member;

    public:
        int GetMember () { return member; }
};

...

std::vector<Elem> vec;

...

// Lösche alle Elemente aus vec die für GetMember() nicht x liefern

Da mein Operator != ist verwende ich std::not_equal_to als Prädikat. x als Parameter daran zu binden ist mittels bind2nd auch kein Problem, würde so aussehen:

std::bind2nd<std::not_equal_to<TRMode>,int>(std::not_equal_to<TRMode>(),x)

Doch da taucht ein Problem auf TRMode hat natürlich keinen op!= für int überladen. Wie kann ich nun not_equal_to sagen, dass es nicht elem != x sondern elem.GetMember() != x ausführen soll?

Den op!= zu überladen geht nicht, ich habe mehrere int-Member für die das alles auf dem selben Weg funktionieren muss.

Ich habe von std::mem_fun_ref gelesen, weiß jetzt aber nicht ob und wenn ja wie ich das hier anwenden kann. Ich hoffe mir kann jemand helfen

BTW: Eigene Prädikate zu schreiben ist zwar eine sehr einfache Idee aber ich will jetzt eigentlich nicht für 10 verschiedene Member Prädikate schreiben...

MfG SideWinder

MfG SideWinder

Ich möchte mittels std::remove_if alle Elemente aus einem Container löschen die bei elem.GetMember() einen Wert != einen von mir bestimmten Wert liefern.

...
Ich habe von std::mem_fun_ref gelesen, weiß jetzt aber nicht ob und wenn ja wie ich das hier anwenden kann. Ich hoffe mir kann jemand helfen

Hallo SideWinder,
mit Standard-Mitteln allein wirst Du das nicht schaffen. Mit boost ist es relativ einfach:

vector< Elem >::iterator i = std::remove_if( vec.begin(), vec.end(), 
        boost::bind( &Elem::GetMember, _1 ) != bestimmterWert  ); // ab boost V1.33

SideWinder schrieb:

BTW: Eigene Prädikate zu schreiben ist zwar eine sehr einfache Idee aber ich will jetzt eigentlich nicht für 10 verschiedene Member Prädikate schreiben...

Falls Du Dir boost nicht antun möchtest (es sei aber wärmstens empfohlen) kannst Du Dir genau ein Prädikat schreiben, welches die aktuell gewünschte Member-Funktion als Parameter hält.

template< typename T > // T ist der Type des jeweiligen ReturnWerts, bzw. von 'bestimmterWert'
struct NotEqualMem
{
    typedef T (Elem::*memFun_type)() const; // Get-Methoden sollten const sein
    NotEqualMem( memFun_type mf, const T& x )
        : m_mf( mf )
        , m_x( x )
    {}

    bool operator()( const Elem& e ) const
    {
        return (e.*m_mf)() != m_x;
    }

private:
    memFun_type m_mf;
    T m_x;
};

// Aufruf geht dann so
    vector< Elem >::iterator i = std::remove_if( vec.begin(), vec.end(), 
        NotEqualMem< int >( &Elem::GetMember, bestimmterWert )  );

Bedenke bitte, dass der Algorithmus keine Elemente aus dem Container std::vector< Elem > löscht - bzw. löschen kann. Er schiebt die zu löschenden Elemente nach hinten und liefert Dir einen Iterator ab dem ersten zu löschenden Element zurück. Also zum Entfernen fehlt dann noch:

vec.erase( i, vec.end() );

Gruß
Werner

mit Standard-Mitteln allein wirst Du das nicht schaffen

Ich habs befürchtet

Mit boost ist es relativ einfach

Merk ich mir für zu Hause, hilft mir jetzt leider aber auch nichts

kannst Du Dir genau ein Prädikat schreiben, welches die aktuell gewünschte Member-Funktion als Parameter hält.

Das werd ich dann wohl nehmen, danke, hätt ich wohl nie daran gedacht

BTW: Sehr ausführliche und aufschlussreiche Antwort

MfG SideWinder

// Pred:
template <class T>
struct not_equal_to_member
{
	// Typen
	typedef T (TRMode::*MethodPointer) () const;

	// Aufzurufende Vergleichsmethode
	PRIVATE MethodPointer mMethod;
	// Vergleichswert
	PRIVATE T mValue;

	// Konstruktoren
	PUBLIC not_equal_to_member (MethodPointer method, T value)
		:
	mMethod(method),
	mValue(value)
	{
	}

	// Operatoren
	PUBLIC bool operator() (T elem) const
	{
		return mValue != (elem.*mMethod)();
	}
};

// Aufruf (TRModeList : public std::list)
// viel switch jeweils mit anderer methode
eraseFrom = std::remove_if(begin(),end(),not_equal_to_member<int32>(&TRMode::GetHeight,value));

erase(eraseFrom,end());

Zuerst hab ich geglaubt, die Methoden dürfen ganz einfach nicht inline sein, aber das scheint auch nicht der Fall zu sein. Der MSVC liefert mir folgenden Compiler-Fehler für jeden Aufruf von remove_if:

'not_equal_to_member<TEXT>::__ctor': Durch keine der 2 Überladungen kann Parameter 1 vom Typ 'int32 (__thiscall TRMode::* )(void) const' konvertiert werden
        with
        [
            TEXT=int32
        ]
        and
        [
            TEXT=int32
        ]

kann 'not_equal_to_member<TEXT>::not_equal_to_member(not_equal_to_member<TEXT>::MethodPointer (__cdecl *),TEXT)' sein
        with
        [
            TEXT=int32
        ]
        bei Anpassung der Argumentliste '(int32 (__thiscall TRMode::* )(void) const, int32)'

Was mach ich falsch?

MfG SideWinder

Gruß
Werner

class TRMode
{
	PUBLIC_FOR_ENUMERATOR; // nicht mehr als ne friend-dekl, der darf TRMode als einziges erstellen

	PRIVATE int32 mHeight;
      PRIVATE int32 mWidth; // und noch viel mehr nach dem muster, aber für die hier funktionierts schon nicht.

	// Konstruktoren
	INTERN TRMode () {}; // INTERN = private:

	// Methoden - Getter
      PUBLIC INLINE int32 GetHeight () const { return mHeight; }
      PUBLIC INLINE int32 GetWidth () const { return mWidth; } // dito, noch ein paar nach dem muster
};

MfG SideWinder

MfG SideWinder

Mach doch:

template <class T, class X>
struct not_equal_to_member
{
    // Typen
    typedef T (X::*MethodPointer) () const;

    // Aufzurufende Vergleichsmethode
    private:
      MethodPointer mMethod;
    // Vergleichswert
       T mValue;

    // Konstruktoren
    public:
    not_equal_to_member (MethodPointer method, T value)
        :
    mMethod(method),
    mValue(value)
    {
    }

    // Operatoren
    bool operator() (X elem) const  // hier darf nicht T stehen
    {
        return mValue != (elem.*mMethod)();
    }
};

Damit kannst Du das Prädikat dann auch für andere Typen als TRMode einsetzen.

/Edit: Hab hier mal einstweilen Boost installiert, mit Boost ists kein Problem. Bloß verstehe ich die Implementierung von denen nicht und direkt einsetzen kann ichs auhc nicht.

MfG SideWinder

#include <iostream>
#include <vector>
using namespace std;

class Elem
{
    int member;

    public:
        Elem( int y) : member( y) {};
        int GetMember () const { return member; }
};

template <class T, class X>
struct not_equal_to_member
{
    // Typen
    typedef T (X::*MethodPointer) () const;

    // Aufzurufende Vergleichsmethode
    private:
      MethodPointer mMethod;
    // Vergleichswert
       T mValue;

    // Konstruktoren
    public:
    not_equal_to_member (MethodPointer method, T value)
        :
    mMethod(method),
    mValue(value)
    {
    }

    // Operatoren
    bool operator() (X elem) const
    {
        return mValue != (elem.*mMethod)();
    }
};

int main()
{
   vector<Elem> x;
   x.push_back( Elem( 1));
   x.push_back( Elem( 0));
   x.push_back( Elem( 2));
   x.push_back( Elem( 0));
   x.push_back( Elem( 3));
   for( int i = 0; i < 10; ++i) { x.push_back( Elem( i)); }

   int value = 0;

   vector<Elem>::iterator eraseFrom = 
     std::remove_if(x.begin(),x.end(),
                    not_equal_to_member<int, Elem>(&Elem::GetMember,value));

   x.erase(eraseFrom,x.end());

   for( vector<Elem>::const_iterator it = x.begin(); it != x.end(); ++it) {
   	cout << it->GetMember() << " ";
   }
   cout << endl;
}

Compiler ist irgendeine neuere GCC Version für Windows.

Weil den Kerlen das TEXT()-Macro für hardcoded Unicode-Externalisierungen zu lang war haben die:

#define T TEXT

eingeführt. Ich mein wie kann man den Standard-Template-Parametr fast aller Template-Klassen im Umlauf nur umdefinieren? Ich sitz verdammte 11 Stunden vor dem PC und jetzt erst wundert mich in der Template-Fehlermeldung dieses TEXT als Paramter, das wird doch sonst nie gemacht. Und dann bimmelts, ich will heulen

MfG SideWinder

#define PRIVATE private
#define PUBLIC public

MfG SideWinder