STL algoritmer i member funktioner

Hej udviklere,
en ting der er tilbagevendende i min kode er at bruge iteratorer til at gå gennem en STL container og gøre noget. Et eksempel:

void RangeSimulation::step()
{
 //...

for (std::list<Species *>::iterator iter = community.begin(); iter != community.end(); ++iter)
{
    if (goExtinct(*iter)) makeExtinct(*iter);  
    else
    {
        if (selectSpecies(*iter)) speciate(*iter);         
        else next_community.push_back(*iter);              
    }

//...
}

Jeg kan forstå at det i virkeligheden er den slags man har STL algoritmerne til. Jeg ville gerne lære at bruge en fornuftig syntax med STL algoritmer i stedet for altid at skulle bruge de tunge iteratorer, så det kunne ligne noget a la:

void RangeSimulation::extinctAndSpeciate(Species * spec)
{
    if (goExtinct(spec)) makeExtinct(spec);  
    else
    {
        if (selectSpecies(spec)) speciate(spec);         
        else next_community.push_back(spec);              
    }
}

void RangeSimulation::step()
{
//...

    for_each(community.begin(), community.end(), extinctAndSpeciate);

//...
}

Hvor jeg prøver at bruge en funktionspointer til en memberfunktion (af RangeSimulation, ikke Species). Problemet er at min compiler (TDM GCC for Windows) ikke vil acceptere denne syntax.
Jeg kunne tænke mig at løse det med et funktionsobjekt:

void RangeSimulation::extinctAndSpeciate::operator()(Species * spec)
{
    if (goExtinct(spec)) makeExtinct(spec);  
    else
    {
        if (selectSpecies(spec)) speciate(spec);         
        else next_community.push_back(spec);              
    }
}

void RangeSimulation::step()
{
//...

    for_each(community.begin(), community.end(), extinctAndSpeciate());

//...
}

Problemet er at functoren nu ikke har adgang til mit RangeSimulation objekt, så det compiler heller ikke. Og hvis jeg lægger functoren ud i namespacet ryger min indkapsling af RangeSimulation klassen også.
Spørgsmålet er, helt generelt: hvordan bruger jeg STL algoritmer med callback (for_each, transform etc.) i memberfunktioner? Der er formentlig en etableret syntaks, jeg blot ikke kender, da dette må være særdeles almindeligt.
På forhånd mange tak!

Har aldrig brugt for_each, men muligvis er det her svaret:
http://www.java2s.com/Code/Cpp/Vector/Callmemberfunctionforeachelementinvector.htm

Webpage:http://donp.the-hive.dk/

Nej, mem_fun_ref ville have været svaret hvis det var en memberfunktion af 'Species' jeg ville kalde (Species er den klasse som listen indeholder).
Det jeg er interesseret i er at bruge for_each i en klasses (RangeSimulation) memberfunktioner. Og her er det uklart hvordan jeg skal definere det function object/pointer jeg skal passere til for_each.

Man kan kaste sig ud i noget i stil med:

#include <iostream>
#include <list>
#include <algorithm>
#include <functional>
using namespace std;
class Species
{
public:
   Species(bool _is, int _num) : is(_is), num(_num) {}
   bool is;
   int num;
};

class RangeSimulation
{
public:
   RangeSimulation()
   {
      toPrint = false;
      for(int n = 0; n < 10; n++)
      {
         myList.push_back(new Species(n & 1, n));
      }
   }
   ~RangeSimulation()
   {
      for(list<Species* >::iterator it = myList.begin(); it != myList.end(); ++it)
         delete *it;
      myList.clear();
   }
   void Do()
   {
      for_each(myList.begin(), myList.end(), ExtinctAndSpeciate(this));
   }
   void extinctAndSpeciate(Species* x)
   {
      if(x->is == toPrint)
         std::cout << x->num << std::endl;
   }
private:
   bool toPrint;
   list<Species* > myList;
   class ExtinctAndSpeciate : public unary_function<class RangeSimulation*, void>
   {
   public:
      ExtinctAndSpeciate(class RangeSimulation* _sim) : sim(_sim) {}
      void operator() (Species* x)
      {
         sim->extinctAndSpeciate(x);
      }
      class RangeSimulation* sim;
   };
};

int main()
{
   RangeSimulation range;
   range.Do();
}

Her bruges en mellem class der arver fra unary_function til at kalde funktionen i classen.

Eksemplet bygger på koden herfra:
http://www.sgi.com/tech/stl/for_each.html

42657274656C204272616E646572

Hej michael du siger:

" Jeg ville gerne lære at bruge en fornuftig syntax med STL algoritmer i stedet for altid at skulle bruge de tunge iteratorer"

Jeg vil mene at det som du proever paa er ligepræcist det omvendte... Det er meget nemere at bruge iteratorer. Naar du siger "de tunge iteratorer" er det saa fordi du synes det er for svært eller besværligt?

iteratorer er ioevrigt en meget fornuftig STL syntax

>> Bertel: Tak, det virker. Men er det virkelig den smarteste måde at gøre den slags på?
Måske har Ossi ret, når han siger at det er fin stil at bruge iteratorer. Sagen er den, at jeg må konstatere at jeg aldrig bruger STL's algoritmer, og det undrer mig når nu de er der. Derfor tænkte jeg at jeg burde refactorere min kode til at kunne bruge algoritmer og funktionsobjekter.
Jeg synes dog den resulterende kode:

class RangeSimulation
{
//...
        void extinctAndSpeciate(Species * spec);
        struct ExtinctAndSpeciate
        {
            RangeSimulation * sim;
            ExtinctAndSpeciate(RangeSimulation * _sim): sim(_sim){}
            void operator()(Species * spec){sim->extinctAndSpeciate(spec);}
        };
};

// plus

void RangeSimulation::extinctAndSpeciate(Species * spec)
{
    if (goExtinct(spec)) makeExtinct(spec);  
    else
    {
        if (selectSpecies(spec)) speciate(spec);         
        else next_community.push_back(spec);              
    }
}

void RangeSimulation::step()
{
   //...

    for_each(community.begin(), community.end(), ExtinctAndSpeciate(this));

   //...
}

er næsten sværere at læse end den oprindelige kode der bare brugte en iterator.

Stadig, mange tak Bertel for at have taget dig tid til at vise mig hvordan jeg kan få det til at fungere!

Ellers kan man bruge macro til at spare tid:

#include<iostream>
#include<vector>
#define foreach(type,name,cont)\
  for(type::iterator name=cont.begin();name!=cont.end();name++)
int main(){
  std::vector<int> tal;
  tal.push_back(1);
  tal.push_back(2);
  tal.push_back(3);
  tal.push_back(4);
  tal.push_back(5);
  tal.push_back(6);

  foreach(std::vector<int>,it,tal){
    std::cout<<*it;
  }  
}

Boost udgave af en foreach lavet anderledes og sikkert bedre end det jeg skrev.
http://www.boost.org/doc/libs/1_35_0/doc/html/foreach.html

Webpage:http://donp.the-hive.dk/

Jeg ville passe paa med macros...

se evt. her:
http://www2.research.att.com/~bs/bs_faq2.html#macro

Jeg ved ikke om det er den smarteste måde at gøre det på. Man burde kunne udvide ExtinctAndSpeciate så den kan bruges til at kalde enhver funktion i enhver class (så bør den have et andet navn).

Derved burde du kunne lave en syntax som:
for_each(community.begin(), community.end(), CallFun(this, extinctAndSpeciate));

Jeg prøver at kikke på det senere.

Jeg har programmeret i C++ i mange år, men har aldrig brugt for_each...

42657274656C204272616E646572

Tak
Bertel, er du så bare gået uden om for_each, compare, transform etc...? Hvis du har kunnet klare dig uden er alm iteration også godt nok til mig
(jeg venter lidt med at lukke tråden fordi jeg stadig er nysgerrig)

Ja, jeg er blot gået udenom, delvist fordi syntax'en er noget sær. Jeg synes heller ikke at jeg ser det brugt ret meget andre steder. Jeg tvivler f.eks. på at der er ret mange C++ programmører der kan forklare dig hvad bind2nd gør og give dig et eksempel på brugen.

Noget andet er så at det i mine øjne er mere logisk at skrive:
for(hver x i whatever)
gør noget med x

end at skrive:
funktionen(x)
gør noget med x

for(hver x i whatever)
kald funktion med x

Selv om den anden form er kortere hvis du skal gøre det samme mange gange. Men så foretrækker jeg:
Funktion()
gør noget med alle x i whatever

Men det kunne være rart om man kunne skrive dette lidt enklere:
for(std::vector<std::string >::iterator i = container.begin(); i != container.end(); ++i)

42657274656C204272616E646572