Wie std :: foreach mit Parametern / Änderung verwenden,

Question

Ich habe festgestellt, mich zu schreiben

for(int i=0;i<myvec.size();i++)
   myvec[i]->DoWhatever(param);

viel, und ich möchte diese in eine foreach Aussage komprimieren, aber ich bin nicht sicher, wie param ohne dabei super-verbose in dorthin zu gelangen. Ich habe auch Dinge wie

for(int i=0;i<myvec.size();i++)
   if(myvec[i]->IsOK())
      myvec[i]->DoWhatever(param);

, und ich möchte auch, dass Guy neu zu schreiben. Irgendwelche Gedanken?

Oh, auch aus verschiedenen Gründen, ich will nicht Boost verwenden.

Answer 1

#include <vector>
#include <algorithm>
#include <functional>

class X
{
    public:
        void doWhat(int x) {}
        bool IsOK() const {return true;}
};
class CallWhatIfOk
{
    public:
        CallWhatIfOk(int p): param(p) {}

        void operator()(X& x) const
        {   if (x.IsOK())    {x.doWhat(param);}}
    private:
        int param;
};

int main()
{
    std::vector<X>      myVec;

    std::for_each(  myVec.begin(),
                    myVec.end(),
                    std::bind2nd(std::mem_fun_ref(&X::doWhat),4)
                 );


    std::for_each(  myVec.begin(),
                    myVec.end(),
                    CallWhatIfOk(4)
                 );
}

Answer 2

  

Oh, auch aus verschiedenen Gründen, ich will nicht Boost verwenden.

Gültige Entscheidung, aber wahrscheinlich die falsche. Steigern Sie als Erweiterung Betrachten an die STL. C ++ ist eine Bibliothek gesteuerte Sprache. Wenn Sie dies nicht berücksichtigen, wird Ihr Code qualitativ minderwertig sein.

Während std::for_each hier verwendet werden kann, macht das Fehlen von Lambda-Ausdrücke in C ++ bis C ++ 0x diesen mühsamen. Ich plädiere dafür, mit Boost.ForEach ! Es macht das viel einfacher:

foreach (yourtype x, yourvec)
    if (x.IsOK())
        x.Whatever();

Answer 3

Meine bevorzugte Lösung ist in der Regel einen Funktor zu schreiben zu tun, was ich brauche:

struct doWhatever {
  doWhatever(const Param& p) p(p) {}
  void operator(MyVec v&, Param p) {
    v.DoWhatever(param);
  }

private:
  Param p;
};

Und dann die Schleife:

std::for_each(myvec.begin(), myvec.end(), doWhatever(param));

Je nachdem, wie viele Variationen dieses Sie haben, könnte dies ein wenig zu ausführlich sein. Es gibt viele Möglichkeiten für sie inline obwohl tun. boost :: Lambda würden Sie die Funktion, die Sie bei der Call-Website benötigen konstruieren. boost :: bind (oder die Standardbibliothek binden Funktionen) können Sie die Parameter param auf die Funktion lassen würde binden, so dass Sie jedes Mal, als Argument nicht angeben müssen.

boost :: Lambda ist wahrscheinlich der knappste und flexiblen Ansatz. Normalerweise verwende ich die Ebene Funktor Ansatz, weil die Syntax leichter zu merken ist. ;)

Answer 4

gut, wenn wir Compiler, die C ++ 0x Lambda expresions unterstützen, wird dies einfach und minimal-invasive:

std::for_each(myvec.begin(),myvec.end(),[&](X& item){
     item->DoWhatever(param);
});

und das zweite Beispiel wie folgt aussehen:

std::for_each(myvec.begin(),myvec.end(),[&](X& item){   
   if(item->IsOK())      
      myvec[i]->DoWhatever(param);
});

Answer 5

#include <vector>
#include <algorithm>
#include <boost/bind.hpp>
#include <boost/lambda/if.hpp>
#include <boost/lambda/bind.hpp>


struct A
{
  bool IsOK () { return true; }
  void DoWhatever (int param) {}
};

struct B
{
  bool IsOk (A * a) { return true; }
  void DoWhatever (A * a, int param) {}
};

typedef std::vector<A *> Myvec;

void main()
{
  Myvec myvec;
  int param = 1;
  B b;

  // first challenge using boost::bind (fnct in the same class)
  std::for_each (myvec.begin(), myvec.end(),
    boost::bind (&A::DoWhatever, _1, param));

  // first challenge using boost::bind (fnct in an external class)
  std::for_each (myvec.begin(), myvec.end(),
    boost::bind (&B::DoWhatever, &b, _1, param));

  // second challange using boost::lambda (fnct in the same class)
  std::for_each (myvec.begin(), myvec.end(),
    boost::lambda::if_then(
      boost::lambda::bind (&A::IsOK, boost::lambda::_1), 
      boost::lambda::bind (&A::DoWhatever, boost::lambda::_1, param)
    )
  );

  // second challange using boost::lambda (fnct in an external class)
  std::for_each (myvec.begin(), myvec.end(),
    boost::lambda::if_then(
      boost::lambda::bind (&B::IsOK, &b, boost::lambda::_1), 
      boost::lambda::bind (&B::DoWhatever, &b, boost::lambda::_1, param)
    )
  );

}

Sie können es vereinfachen, indem Verwendung von Namespaces ...

Answer 6

Wenn Sie GCC verwenden Sie so etwas wie definieren:

#define foreach(element, array) \
    for(typeof((array).begin()) element = (array).begin(), __end_##element = (array).end();\
        element != __end_##element;\
        ++element)

und verwenden Sie es nach wie folgt aus:

foreach(element, array){
    element->DoSomething(); //or (*element)->DoSomething() if type is already a pointer
}

Ich benutze diese auf einem benutzerdefinierten Array, aber es funktioniert gut mit std :: vector auch.