std::list<ELEM*> LIST;

std::list<ELEM*::Iterator A=...,B=...;

LIST.erase(A,B);

gibts es ne funktion welche genau für den beriech "delete ausführt"?

void del_elem(ELEM* ptr)
{ delete ptr; }

...
for_each(A,B,del_elem);
LIST.erase(A,B);

das problem ist aber das del_elem dann eine member funktion ist

Nur wenn du eine daraus machst. Dazu zwingt dich ja niemand.

und dann funzt das nich mehr ...

Doch, z.B. mit boost::bind.

globale funktionen, zerlagen meine OO design;)

Man kann's auch übertreiben mit der OO-Fixierung

struct del_elem
{
  void operator()( ELEM*& elem ) const
  { 
    delete elem;
    elem = 0; 
  }
};

Dann hast du wenigstens ein Objekt! ;-P

class BorisKlasse 
{
private:
 struct ElemDeletor
 {
  void operator() (ElEM* ptr) const
  { delete ptr; }
 };

 std::list<ELEM*> LIST;

public:
  void del_elem(ELEM* ptr)  // wenn sie denn ubedingt Memberfunktion
  { delete ptr; }           // sein muss und du sie anderweitig brauchst

  void del_range()
  {
   // std::list<ELEM*>::Iterator A=...,B=...; usw.
   for_each(A, B, ElemDeletor() );
   LIST.erase(A,B);
  }
};

edit: war wieder einer schneller

Nochmal was:

void operation(ELEM *ptr){

}

ELEM::func(){

 std::list<ELEM*::Iterator A=...,B=...;

  count_if(A,B,operation);

}

wie ereich das , das ich in der opeation funktion noch den this-zeiger aus func() übergenbe kann? damit ich in operatioen das this -Objekt mit Objekt der liste vergleichen kann?

hmm.. ich mach vorerst mal die funktionen global.. ungern aber egal jetzt:)

Aus welchem Grund denn ungern?

naja habe gelernt, man sollte keine golbalen variablen funktionen anlegen, auser es ist überhaupt nich anders machbar... da war ich 16;) 10 jahre lange routine ist nich so einfach umzubiegen;)

nein, keine globalen variablen. funktionen sind ein anderes thema

BorisDieKlinge schrieb:

globale funktionen, zerlagen meine OO design;)

Man kann's auch übertreiben mit der OO-Fixierung

Sicher, kann man. Aber nicht mit Kapselung. Hierfür eine Funktion global auslagern zu müssen, ist inakzeptabel.

Aber es gibt doch für sowas 'std::mem_fun' und AFAIR in Boost auch noch eins drauf.

Sicher, kann man. Aber nicht mit Kapselung. Hierfür eine Funktion global auslagern zu müssen, ist inakzeptabel.

Ich denke nicht dass es die Kapselung bricht, wenn man einen functor/eine freie funktion bastelt, die ein element löscht. wenn die funktion nicht im header sondern nur in der dazugehörigen cpp datei steht, dann kann man ja nichtmal einfach so drauf zugreifen.

for_each( A, B, bind( delete_ptr(), _1 ) );