c++ - STL algoritmer i member funktioner - Udvikleren.dk

Tags: c++

<< < 1 2 > >>

Bruger #8249 @ 16.03.10 14:22

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:

Kode


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:

Kode

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:

Kode


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!

Indlæg senest redigeret d. 16.03.2010 14:25 af Bruger #8249

18 svar postet i denne tråd vises herunder
2 indlæg har modtaget i alt 2 karma

Sorter efter stemmer Sorter efter dato

Bruger #14479 @ 18.03.10 09:27

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

Bruger #5620 @ 18.03.10 11:59

1.500

Ellers kan man bruge macro til at spare tid:

Kode

#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

Bruger #5620 @ 16.03.10 17:01

1.500

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

Bruger #8249 @ 17.03.10 07:52

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.

Indlæg senest redigeret d. 17.03.2010 07:52 af Bruger #8249

Bruger #4996 @ 18.03.10 00:19

196

Man kan kaste sig ud i noget i stil med:

Kode

#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

Bruger #8249 @ 18.03.10 11:46

>> 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:

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!

Bruger #14479 @ 18.03.10 14:27

Jeg ville passe paa med macros...

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

Bruger #4996 @ 18.03.10 18:15

196

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...

Bruger #8249 @ 18.03.10 19:02

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)

Bruger #4996 @ 18.03.10 19:21

196

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)

<< < 1 2 > >>

STL algoritmer i member funktioner

Karma barometer (30 dage)

Modtaget

Givet

Favorit hos
Forum tråde
Artikler