Bestimmten Bereich/Elemente einer std::list mit delete freigeben

BorisDieKlinge

habe eine liste:

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"?

CStoll

for_each() (du mußt ihr nur dazusagen, was sie mit den betroffenen Elementen machen soll):

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

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

BorisDieKlinge

das problem ist aber das del_elem dann eine member funktion ist , und dann funzt das nich mehr ...

MFK

BorisDieKlinge schrieb:

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.

CStoll

Was hindert dich denn daran, das als globale Funktion zu schreiben? (ja, sowas gibt's auch in C++ :D)

BorisDieKlinge

globale funktionen, zerlagen meine OO design;)

CStoll

BorisDieKlinge schrieb:

globale funktionen, zerlagen meine OO design;)

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

David_pb

Dann nimm ein Funktionsobjekt!

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

Dann hast du wenigstens ein Objekt! ;-P

pumuckl

Dann gibts noch die Moeglichkeit, einen Functor zu uebergeben, da for_each meines Wissens mit Funktionen und Functoren funktioniert (Wortwitz ):

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

pumuckl

Und wenn du auf Erweiterbarkeit ohne Nebeneffekte aus bist, dann kannst du in dem privaten Functor statt delete auf gleich del_elem aufrufen, dann gibts keine boesen Ueberraschungen falls du spaeter sowas wie ne Referenzzaehlung einbaust und die in del_elem mit beruecksichtigst So hat dann del_range auf jeden Fall den selben Effekt wie del_elem fuer jeden einzelnen Eintrag.

BorisDieKlinge

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

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?

David_pb

Du liest auchmal deine eigenen Threads durch?
http://c-plusplus.net/forum/viewtopic-var-t-is-186541.html

echt erstaunlich

finix

BorisDieKlinge schrieb:

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

Aus welchem Grund denn ungern?

BorisDieKlinge

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;)

David_pb

Jaja... Manchmal sind globale Funktionen sehr viel eleganter. Beispielsweise bei Operatorüberladung.

otze

BorisDieKlinge schrieb:

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

Konrad Rudolph

CStoll schrieb:

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.

otze

Konrad Rudolph schrieb:

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.

lolz

Ein schöner Fall für boost::lambda:

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