Wie kann ich verhindern, dass ich "for" - Schleifen mit einer "if" - Bedingung innerhalb mit C++?

Mit fast allen code, den ich Schreibe, bin ich oft Umgang mit set Reduzierung der Probleme, die auf Sammlungen, die letztendlich mit naiven "wenn" - Bedingungen im inneren von Ihnen. Hier ein einfaches Beispiel:

for(int i=0; i<myCollection.size(); i++)
{
     if (myCollection[i] == SOMETHING)
     {
           DoStuff();
     }
}

Mit funktionalen Sprachen, und ich habe das problem lösen können durch die Reduzierung der Sammlung zu einer anderen Sammlung (leicht) und dann alle Vorgänge in meinem reduzierten Satz. In pseudocode:

newCollection <- myCollection where <x=true
map DoStuff newCollection

Und in anderen C-Varianten, wie z.B. C#, könnte ich reduzieren, mit einer where-Klausel wie

foreach (var x in myCollection.Where(c=> c == SOMETHING)) 
{
   DoStuff();
}

Oder besser (zumindest für meine Augen)

myCollection.Where(c=>c == Something).ToList().ForEach(d=> DoStuff(d));

Zugegeben, ich bin dabei eine Menge von Paradigma mischen und subjektive/Meinung basiert Stil, aber ich kann mir nicht helfen, aber das Gefühl, dass mir etwas fehlt wirklich wichtig, könnte mir erlauben, verwenden Sie diese bevorzugte Technik mit C++. Könnte jemand mich aufklären?

Aus der C++ standard-library-Funktionen, können Sie versuchen std::copy_if sein, aber die Auswahl nicht faul
wenn es ok ist für Sie, eine Kopie zu machen, möchten Sie vielleicht werfen Sie einen Blick auf std::copy_if
Sie können daran interessiert sein, Reihe-v3. Sollte es auch dann kommen, um C++ als TS und hoffentlich standardisierte in einer zukünftigen Version.
c++11 hat lambda-Ausdrücke, so dass möglicherweise etwas, das Sie möchten, um zu sehen wie auch.
Ich schlage vor, Sie ändern den Titel, weil beide Antworten verwendet, die Schleifen
Könnte Sie klären, ob Sie interessiert sind, indem Sie die performance-Aspekte, oder allein durch die syntaktischen Aspekte?
Soweit ich weiß, dass C# - code wird nicht kompiliert. : ersetzt werden durch in
Hinzufügen @NullException Kommentar, der andere C# - snippet auch nicht kompilieren, weil es bewusst keine ForEach im IEnumerable
Ich fühle die Notwendigkeit zu betonen, dass der if innerhalb einer for Sie erwähnen, ist nicht nur ziemlich funktional gleichwertig zu den anderen Beispielen würde aber auch wahrscheinlich schneller in eine Menge von Fällen. Auch für jemanden, der behauptet, wie funktionalen Stil, was Sie fördern scheint zu gehen gegen die funktionale Programmierung das Geliebte Konzept von Reinheit, da DoStuff hat eindeutig side effcets.
Wenn Sie das tun, viele, viele Male mit den gleichen filter-Bedingungen, die ich vorschlagen würde, mit so etwas wie Boost multi_index, die pflegen können viele Indizes auf die gleichen Daten. Es ist wie mit Ihrem eigenen DB in der app.
Wenn Sie können, ich denke, man kann Sortieren Sie Ihre Daten zu ersetzen, der für"+", wenn mit nur einer for-Schleife iteriert über die Individuen, die hinsichtlich Ihrer Bedingungen (oder zwei Schleifen im Falle eines anderen, und so weiter)
Ich habe nie wirklich verstanden, warum die Menschen verbinden, die alle Logik auf einer einzigen Zeile macht es sich irgendwie besser oder mehr lesbar. C++ - snippet an der Spitze ist bei weitem die meisten lesbar für mich aus all Ihre Möglichkeiten. Und da der Wirkungsgrad nicht verändert wird, kann ich nicht verstehen, warum Sie lieber nicht zu schreiben, dass, es sei denn, Sie werden bezahlt nach der Anzahl der code-Zeilen, die Sie löschen.
Ich, die zweite. Ich denke, die for-Schleife mit der internen, wenn die mit Abstand am meisten lesbar. Ich bin mir nicht sicher über die Effizienz, mit der Ausnahme, dass es wohl wirklich schließen. Immer eine Untergruppe und dann die Iteration auf die Teilmenge der logisch erfordert zwei traversalen statt, und es ist immer noch der test für jedes element, so dass ich lieber zu durchqueren es einmal und explizit zeigen die Tests, dass das passieren wird sowieso für jedes element. Es ist (gerade noch) effizienter als die Art und Weise, und sehr viel transparenter.
Vereinbart: es ist nur syntaktischer Zucker. Und die Frage, der Titel ist irreführend, denn es ist sehr unterschiedlich zu vermeiden Verzweigung und versteckt es unter Abstraktion.
Heute ist die Effizienz nicht geändert. Morgen - vielleicht. Wenn Sie " Anforderungsfilterung ersten, dann einen Bereich für dann - ich bin, darüber zu spekulieren, hier - filtern könnten parallel ausgeführt werden (je nach Bibliothek) und könnte schneller sein (je nach Architektur). Wissen wir nicht - aber wir wollen nicht ausschließen.
Ein Vorteil in der Verwendung von Dingen wie map/filter zu iterieren über Sammlungen ist, dass Sie wissen, was Sie tun werden. Eine generische Schleife tun können, alle Arten von komplexen Zeug und es ist viel einfacher, auf die Einführung eines bug manuell schreiben der for Schleife als schreiben map doStuff collection. Dies kann auch helfen, den compiler bei der Optimierung. Das gleiche (mehr) wahr schreiben Sie die rekursive Funktion, die per hand oder mit so etwas wie einem fold/reduce statt.
Ich bin überrascht, dass niemand darauf hingewiesen, dass boost bedeutet dies: coliru.stacked-crooked.com/a/f2274ee265d19a1a
Wenn der compiler bekommt ausreichend schlau, dass er die erstaunliche Optimierungen, die Sie sich ausdenken, @lorro, sollte es sicherlich schlau genug, zu erkennen, gemeinsame Muster und transformieren Sie Sie so ausführen kann, dass es die gleichen Optimierungen. Die machen es wichtiger, code zu schreiben, in der normalen, offensichtlichen Weg. Vorausgesetzt natürlich, dass alle diese Optimierungen sind auch möglich, da Sie sehr wahrscheinlich brechen Bestellung von Sicherheiten, die durch die language-Spezifikation.
Ich Rede nicht von dem compiler, ich Rede von der Bibliothek, die filter(). Wir sind auf Vereinbarung, dass Sie nicht-trivial für einen compiler (und es ist nicht trivial, ob das getan werden sollte, in den ersten Platz), jedoch mit std::async() es ist jetzt fast trivial zu schreiben filter() hat, der die Filterung im hintergrund (klar, die Angabe dieser in der Dokumentation). Solange beide Ihren filter und loop-Körper sind ausreichend lang und können parallel ausgeführt werden, könnte dies beschleunigen Sie Ihren code ein wenig Recht.
es ist nicht unbedingt über code-Zeilen, ist es auch egal, ob Sie lieber in Operationen auf einem Bereich, oder lieber eine Schleife über einen Bereich, der explizit die Durchführung der gleichwertige operation auf jedes element. Auch ohne die bedingte, und noch bevor der range-basierte for-Schleifen, einige Leute immer noch nicht std::for_each wenn Sie hatte eine Pistole an Ihren Kopf, auf der Grundlage, dass die Schleife mehr lesbar sind, um Sie in allen Fällen. In der Erwägung, dass anderen Menschen gefallen for_each so viel, dass Sie standardisierte it 😉
Wie der OP sagt, der Wunsch, zu entfernen die explizite if folgt aus einem funktionalen Stil, c.f. degoes.net/articles/destroy-all-ifs
Möglich, Duplikat der Wie kombiniert man eine Funktion und ein Prädikat in for_each?

InformationsquelleAutor Darkenor | 2016-07-15

c++c++11 c++14

98

IMHO ist es mehr straight forward und lesbarer ist die Verwendung einer for-Schleife mit einer if drin. Allerdings, wenn das ist ärgerlich für Sie, könnten Sie ein for_each_if wie folgt:
```
template<typename Iter, typename Pred, typename Op> 
void for_each_if(Iter first, Iter last, Pred p, Op op) {
  while(first != last) {
    if (p(*first)) op(*first);
    ++first;
  }
}
```
Anwendungsfall:
```
std::vector<int> v {10, 2, 10, 3};
for_each_if(v.begin(), v.end(), [](int i){ return i > 5; }, [](int &i){ ++i; });
```
Live Demo
- Das ist sehr clever. Ich werde auch Zustimmen, dass es nicht geradlinig und wahrscheinlich werde ich nur verwenden, wenn die Bedingungen bei der Programmierung von C++, die verbraucht wird, durch andere. Aber genau das ist es, was ich brauche für meinen persönlichen Gebrauch! 🙂
- wäre es möglich, statt nur pass in v und verwenden std::begin und std::end im for_each_if Funktion?
- Vorbei iterator-Paare eher als Container flexibleren und idiomatischer C++.
- oder noch besser, nehmen Sie einen range von Vorlagen geben, die erforderlich ist, um begin() und end() (entweder eigene oder externe) und bieten eine range(Iter first, Iter second) für die Kompatibilität mit Iteratoren.
- es war, bevor Bereiche erstreckt. Nun, die letzteren sind ein wenig sicherer, weil die Grenze Prüfungen sind möglich (d.h., Sie haben weniger chance, zu mischen, bis end()'s von zwei Vektoren).
- would it be possible to instead just pass in v and use std::begin and std::end in the for_each_if function?: Sorry, habe ich falsch interpretiert, die Frage. Nein das ist nicht möglich und, wie andere vorgeschlagen, es wäre nicht flexibel.
- C++ ist definitiv fehlt, reicht - müssen Sie eine neue Vorlage erstellen die Funktion für jedes niesen statt zu grouping bestehende, wie es in funktionalen Sprachen. Und die Tatsache, dass wir bereits viel zu viele algos, dass doppelte Funktionalität Beweise, dass.
- im Allgemeinen reicht nicht reduzieren Sie die Anzahl der algorithmen. Zum Beispiel, Sie müssen noch find_if und find ob Sie arbeiten reicht oder Paare von Iteratoren. (Es gibt ein paar Ausnahmen, wie for_each und for_each_n). Der Weg zu vermeiden, schreiben neue algos für jedes niesen ist die Verwendung von verschiedenen Operationen mit den vorhandenen algos, e.g statt for_each_if einbetten der Bedingung in das callable übergeben for_each z.B. for_each(first, last, [&](auto& x) { if (cond(x)) f(x); });
- vielleicht meinen wir anders, wenn wir sagen es reicht, aber was ich meine ist, wenn Sie kombinieren können, algos, die in der Kette. Dann brauchen Sie nicht find_if verwenden Sie einfach find und Kette es mit filter, das gleiche gilt für alle anderen _if Varianten
- Sie wollen nicht die Verkettung für die, die Sie wollen eine filter erzeugt einen view (also faul wertet einige andere Bereich), und nehmen Sie nur das erste element. Aber das wird off-topic für diese Antwort
- Ich bin gonna haben, um Stimmen mit dem ersten Satz: Der standard für die wenn-Lösung ist sehr besser lesbar und einfacher, mit zu arbeiten. Ich denke, dass die lambda-syntax und die Verwendung einer Vorlage definiert ist woanders einfach zu handhaben, eine einfache Schleife reizen würde oder möglicherweise verwirren die anderen devs. Sie opfern Lokalität und Leistung für... was? Zu schreiben, etwas, das in eine Zeile?
- Räusper @Darkenor, in der Regel "sehr clever" - Programmierung vermeiden, weil es nervt die Scheiße aus jeder andere, einschließlich Ihre Zukunft selbst.
- Das ist eine gute Antwort, aber ich sehe nicht, was sehr klug. Es ist eine Funktion, die eine ähnliche Oberfläche auf die Funktionen in der standard-Bibliothek (z.B. std::copy_if, std::for_each), und die Umsetzung ist unkompliziert.
- Downvoted: dies ist nicht in den Geist dessen, was der OP gefragt. Einen gefilterten Bereich (Boost range-v3) ist mehr idiomatische, einfacher zu erweitern ist, und verringert auch eine mögliche M*N Verbreitung von algorithmen und Auswahl-Modifikatoren (filter, reverse, zip, etc) auf eine überschaubare M+N Wortschatz.
- Stimme mit @ryan hier. Der OP-code ist wesentlich einfacher zu verstehen und zu pflegen, als die cleveren code, der hier vorgeschlagen wird. Ich denke, die OP ' s main Problem ist er will mit dem funktionalen Paradigma in einer Sprache, die nicht mit ihm gemacht im Kopf... wenn die OP machen will, funktionale Programmierung, dann eine funktionale Sprache verwendet werden soll. Sonst muss er anders denken über das problem (z.B. in prozeduralen oder OO-Begriffe).
- Könnten Sie variadic templates zu erweitern, diese Funktion zu nutzen, die eine beliebige Anzahl von Argumenten und jede Funktion Prototyp. Es ist wahrscheinlich besser, um es auf diese Weise, obwohl.
InformationsquelleAutor 101010
48

Boost bietet Bereiche an, die verwendet werden können, w/range-basierte for. Bereiche haben den Vorteil, dass Sie nicht kopieren Sie die zugrunde liegende Datenstruktur, Sie sind nur einen 'Blick' (das ist begin(), end() für den Bereich und operator++(), operator==() für den iterator). Dies könnte Ihr Interesse: http://www.boost.org/libs/range/doc/html/range/reference/adaptors/reference/filtered.html
```
#include <boost/range/adaptor/filtered.hpp>
#include <iostream>
#include <vector>

struct is_even
{
    bool operator()( int x ) const { return x % 2 == 0; }
};

int main(int argc, const char* argv[])
{
    using namespace boost::adaptors;

    std::vector<int> myCollection{1,2,3,4,5,6,7,8,9};

    for( int i: myCollection | filtered( is_even() ) )
    {
        std::cout << i;
    }
}
```
- Darf ich vorschlagen, die Verwendung der OPs-Beispiel statt, d.h. is_even => condition, input=> myCollection etc.
- Dies ist eine ziemlich hervorragende Antwort und definitiv das, was ich Suche zu tun. Ich werde halten sich auf der Annahme, es sei denn, jemand kann kommen mit einer standard-konformen Weg, es zu tun, verwendet lazy/verzögerte Ausführung. Von Ihnen positiv bewertet werden.
- Wenn Boost ist ein problem für Sie (für ex., du bist gebannt, es zu benutzen wegen Gesellschaft, Politik & manager-Weisheit), die ich mit oben kommen kann eine vereinfachte definition der filtered() für Sie - das heißt, es ist besser, verwenden Sie eine unterstützte lib als einige ad-hoc code.
- Völlig mit Ihnen einverstanden. Ich akzeptierte es, weil die standard-konforme Art und Weise, die zuerst kamen, weil die Frage war ausgerichtet auf C++ selbst, nicht die boost-library. Aber diese ist wirklich hervorragend. Auch - ja, ich habe leider gearbeitet, in vielen Plätzen, die gebannt Boost für absurden Gründen...
- Ich will diese zu löschen, aber dumm stackoverflow
- @LeeClagett: ? .
- Ich wollte nicht sehen, den löschen-button für Kommentare
- Ein Hinweis: wenn Sie verwenden boost::adaptors sicher sein, eigenen Bereich (d.h., don ' T pass eine vorübergehende). Dies ist besonders schwierig, wenn Sie möchten mehrere Adapter. Dies bedeutet nicht, dass boost::adaptors ist falsch, es ist nur, dass Sie vorsichtig sein müssen. Finden Sie diese Fehler für weitere Informationen: svn.boost.org/trac/boost/ticket/7630
InformationsquelleAutor lorro
43

Anstatt einen neuen Algorithmus, der die akzeptierte Antwort ist, die Sie verwenden können, einen vorhandenen mit einer Funktion, gilt die Bedingung:
```
std::for_each(first, last, [](auto&& x){ if (cond(x)) { ... } });
```
Oder wenn Sie wirklich wollen, einen neuen Algorithmus, der mindestens Wiederverwendung for_each dort, statt Sie zu duplizieren die iteration Logik:
```
template<typename Iter, typename Pred, typename Op> 
  void
  for_each_if(Iter first, Iter last, Pred p, Op op) {
    std::for_each(first, last, [&](auto& x) { if (p(x)) op(x); });
  }
```
- Viel besser und klarer für die Verwendung der standard-Bibliothek.
- Da std::for-each(first, last, [&](auto& x) {if (p(x)) op(x); }); ist ganz einfacher als for (Iter x = first; x != last; x++) if (p(x)) op(x);}?
- Wiederverwendung der standard-Bibliothek hat andere Vorteile, wie iterator überprüfung der Gültigkeit oder (in C++17) viel leichter zu parallelisieren, indem Sie einfach einen weiteren Grund: std::for_each(std::execution::par, first, last, ...); Wie einfach ist es, diejenigen hinzuzufügen, die die Dinge auf eine handgeschriebene Schleife?
- #pragma omp parallel for
- sorry, einige zufällige Marotte von Ihr Quellcode oder der build-Kette gemacht, die dummerweise fragile parallelen nicht-standard-compiler-Erweiterung generieren keine performance-boost mit keine Diagnose.
- Noch besser unterstützt auf den meisten Compilern als standard C++03 ist auf Microsoft ' s Letzte mal habe ich es 🙂
InformationsquelleAutor Jonathan Wakely
21

Die Idee der Vermeidung von
```
for(...)
    if(...)
```
Konstrukte wie ein antipattern ist zu breit.

Ist es völlig in Ordnung zu verarbeiten mehrerer Gegenstände, die übereinstimmung mit einem bestimmten Ausdruck innerhalb einer Schleife, und den code nicht bekommen, viel klarer als das. Wenn die Verarbeitung wächst zu groß für Bildschirm, ist das ein guter Grund für die Verwendung einer Unterroutine, aber immer noch die bedingte ist am besten platziert, der innerhalb der Schleife, d.h.
```
for(...)
    if(...)
        do_process(...);
```
ist weitaus vorzuziehen
```
for(...)
    maybe_process(...);
```
Wird es ein antipattern, wenn nur einem element übereinstimmen, denn dann wäre es übersichtlicher für das erste Suche nach dem element, und führen Sie die Verarbeitung außerhalb der Schleife.
```
for(int i = 0; i < size; ++i)
    if(i == 5)
```
ist ein extremes und offensichtliches Beispiel HIERFÜR. Subtiler, und damit häufiger, ist ein factory-Muster wie
```
for(creator &c : creators)
    if(c.name == requested_name)
    {
        unique_ptr<object> obj = c.create_object();
        obj.owner = this;
        return std::move(obj);
    }
```
Dies ist schwer zu Lesen, weil es nicht offensichtlich ist, dass der Körper-code ausgeführt werden, sobald nur. In diesem Fall wäre es besser, sich zu trennen-Suche:
```
creator &lookup(string const &requested_name)
{
    for(creator &c : creators)
        if(c.name == requested_name)
            return c;
}

creator &c = lookup(requested_name);
unique_ptr obj = c.create_object();
```
Gibt es noch eine if innerhalb einer for, aber aus dem Kontext wird deutlich, was es bedeutet, es gibt keine Notwendigkeit zur änderung dieses Codes, es sei denn, die lookup-änderungen (z.B. zu einem map), und es ist sofort klar, dass create_object() nur einmal aufgerufen wird, weil es nicht in einer Schleife.
- Ich mag diese, als eine gut durchdachte und ausgewogene übersicht, auch wenn es in einem Sinn, der sich weigert, zu beantworten die Frage. Ich finde, dass die for( range ){ if( condition ){ action } }-Stil macht es leicht zu Lesen, was ein Stück zu einem Zeitpunkt, und verwendet nur Kenntnisse der grundlegenden Sprachkonstrukte.
- die Art der Fragestellung erinnert mich an Raymond Chen ' s Tirade gegen die für-wenn antipattern, wurde die cargo-culted und irgendwie wurde zu einem absoluten. Ich bin völlig einverstanden, dass for(...) if(...) { ... } ist oft die beste Wahl (das ist, warum ich qualifiziert die Empfehlung zur Aufteilung der Handlung in ein Unterprogramm).
- Danke für den link, die Dinge geklärt für mich: der name "wenn" ist irreführend, und sollte so etwas wie "für-alle-wenn-man" oder "lookup-Vermeidung". Es erinnert mich an die Art und Weise Abstraktion inversion beschrieb Wikipedia 2005, als wenn man "erstellt einfache Konstrukte auf der Oberseite der Komplex (sind)" — bis ich schrieb es! Eigentlich würde ich noch nicht einmal rush fix auf den lookup-Prozess-exit-form for(…)if(…)… wenn es der einzige Ort lookup aufgetreten.
InformationsquelleAutor Simon Richter

Hier ist eine schnelle relativ gering filter Funktion.

Dauert es ein Prädikat. Gibt es eine function-Objekt, das nimmt ein durchsuchbar.

Gibt es einen iterierbar, die verwendet werden können in einer for(:) Schleife.

template<class It>
struct range_t {
  It b, e;
  It begin() const { return b; }
  It end() const { return e; }
  bool empty() const { return begin()==end(); }
};
template<class It>
range_t<It> range( It b, It e ) { return {std::move(b), std::move(e)}; }

template<class It, class F>
struct filter_helper:range_t<It> {
  F f;
  void advance() {
    while(true) {
      (range_t<It>&)*this = range( std::next(this->begin()), this->end() );
      if (this->empty())
        return;
      if (f(*this->begin()))
        return;
    }
  }
  filter_helper(range_t<It> r, F fin):
    range_t<It>(r), f(std::move(fin))
  {
      while(true)
      {
          if (this->empty()) return;
          if (f(*this->begin())) return;
          (range_t<It>&)*this = range( std::next(this->begin()), this->end() );
      }
  }
};

template<class It, class F>
struct filter_psuedo_iterator {
  using iterator_category=std::input_iterator_tag;
  filter_helper<It, F>* helper = nullptr;
  bool m_is_end = true;
  bool is_end() const {
    return m_is_end || !helper || helper->empty();
  }

  void operator++() {
    helper->advance();
  }
  typename std::iterator_traits<It>::reference
  operator*() const {
    return *(helper->begin());
  }
  It base() const {
      if (!helper) return {};
      if (is_end()) return helper->end();
      return helper->begin();
  }
  friend bool operator==(filter_psuedo_iterator const& lhs, filter_psuedo_iterator const& rhs) {
    if (lhs.is_end() && rhs.is_end()) return true;
    if (lhs.is_end() || rhs.is_end()) return false;
    return lhs.helper->begin() == rhs.helper->begin();
  }
  friend bool operator!=(filter_psuedo_iterator const& lhs, filter_psuedo_iterator const& rhs) {
    return !(lhs==rhs);
  }
};
template<class It, class F>
struct filter_range:
  private filter_helper<It, F>,
  range_t<filter_psuedo_iterator<It, F>>
{
  using helper=filter_helper<It, F>;
  using range=range_t<filter_psuedo_iterator<It, F>>;

  using range::begin; using range::end; using range::empty;

  filter_range( range_t<It> r, F f ):
    helper{{r}, std::forward<F>(f)},
    range{ {this, false}, {this, true} }
  {}
};

template<class F>
auto filter( F&& f ) {
    return [f=std::forward<F>(f)](auto&& r)
    {
        using std::begin; using std::end;
        using iterator = decltype(begin(r));
        return filter_range<iterator, std::decay_t<decltype(f)>>{
            range(begin(r), end(r)), f
        };
    };
};

Ich nahm kurze Schnitte. Eine echte Bibliothek sollte machen echte Iteratoren, nicht die for(:)-qualifying pseudo-fascades ich.

Am point-of-Nutzung, sieht es wie folgt aus:

int main()
{
  std::vector<int> test = {1,2,3,4,5};
  for( auto i: filter([](auto x){return x%2;})( test ) )
    std::cout << i << '\n';
}

ist ziemlich nett, und druckt

1
3
5

Live-Beispiel.

Es ist ein Vorschlag für die Ergänzung zu C++ namens Rangesv3, die nicht diese Art der Sache und mehr. boost hat auch filter reicht/Iteratoren zur Verfügung. boost hat auch Helfer, die das machen, Schreibe viel kürzer.

InformationsquelleAutor Yakk - Adam Nevraumont

15

Einen Stil, bekommt genug zu erwähnen, aber noch nicht erwähnt wurde noch, ist:
```
for(int i=0; i<myCollection.size(); i++) {
  if (myCollection[i] != SOMETHING)
    continue;

  DoStuff();
}
```
Vorteile:
- Nicht ändern, dass die Einrückung von DoStuff(); wenn Bedingung Komplexität erhöht. Logisch, DoStuff(); sollten auf der obersten Ebene der for Schleife, und es ist.
- Macht sofort deutlich, dass die Schleife iteriert über die SOMETHINGs der Sammlung, ohne dass der Leser, um zu überprüfen, dass es nichts nach dem schließen } des if block.
- Benötigt keine Bibliotheken oder Helfer Makros oder Funktionen.
Nachteile:
- continue wie die anderen flow-control-statements, wird missbraucht in einer Weise, die dazu führen, hard-to-follow-code, so viel, dass manche Menschen im Gegensatz zu alle Verwendung: es gibt einen gültigen Stil von Codierung, dass einige Folgen, die vermeidet, dass continue, vermeidet break anders als in einer switch, vermeidet return andere als am Ende einer Funktion.
- Ich würde argumentieren, dass in einem for - Schleife, die läuft auf vielen Linien, ein zwei-line ", wenn nicht, weiter" ist viel klarer, logischer und lesbarer. Sofort sagen: "überspringen Sie dies, wenn" nach der for Aussage liest sich gut und, wie Sie sagten, nicht Einrücken, die restlichen funktionalen Aspekte der Schleife. Wenn die continue ist weiter unten, jedoch einige Klarheit geopfert wird (d.h. wenn eine operation immer durchgeführt werden, bevor die if - Anweisung).
InformationsquelleAutor
11
```
for(auto const &x: myCollection) if(x == something) doStuff();
```
Sieht ziemlich viel wie ein C++-spezifische for Verständnis für mich. Sie?
- Ich glaube nicht, dass auto-Schlüsselwort vorhanden war, bevor die c++11 also ich würde nicht sagen, dass es sehr klassischen c++. Wenn ich Fragen darf hier eine Frage in den Kommentar, würde "das auto const" teilt dem compiler mit, dass Sie neu anordnen alle Elemente, wie es will? Vielleicht wird es einfacher für den compiler zu planen, um zu vermeiden, Verzweigung, wenn das der Fall ist.
- Je früher die Leute aufhören, sich sorgen über "klassische" c++", desto besser. C++11 wurde eine macroevolutionary Ereignis für die Sprache & 5 Jahre alt: es sollte die mindestens wir erstreben. Anyway, der OP-tagged-und C++14 (noch besser!). Nein, auto const hat keinerlei Einfluss auf iteration um. Wenn Sie nach oben schauen, reichte-basierte for Sie werden sehen, dass es im Grunde genommen ein standard-loop aus begin() zu end() mit impliziten Dereferenzierung. Es gibt keine Möglichkeit, es zu brechen könnte die Bestellung von Sicherheiten (falls vorhanden) des Containers iteriert über; es wäre schon gelacht Antlitz der Erde
- tatsächlich war es, er hatte gerade ganz andere Bedeutung. Was nicht vorhanden war, ist die Bereich-für... und andere verschiedene C++11-feature. Was ich meinte war, dass die range-fors, std::futures std::functions, auch diejenigen, anonyme Verschlüsse sind sehr gut C++ - ish, die in der syntax; jede Sprache hat Ihre eigene Ausdrucksweise, und wenn incorporatin neuen features, die es versucht zu machen, imitieren die alten bekannten syntax.
- ein compiler ist erlaubt ausführen beliebigen Transformationen zur Verfügung gestellt, die wie-wenn Regel befolgt, ist es nicht?
- Gut, ja, aber einen container mit den vorgegebenen Reihenfolge zu Durchlaufen als-ob es ist erhalten, die in den meisten Fällen bedeutet es wird nur Durchlaufen werden-in dieser Reihenfolge. Sie werden etwas zu tun mit den spielen, und der compiler annehmen muss, die Sie wählten, ein container mit definierten Reihenfolge (oder Mangel an), weil Sie wollen, dass "etwas" geschehen, sagte um. Eh, meine Antwort war eine Reaktion auf die Idee, dass die range-for änderungen Verhalten im Vergleich zu OP ist indiziert Schleife, die ist sehr unwahrscheinlich: wenn ein compiler aus dieser byzantinischen transformation für range -for ist, wäre es ebenso frei, dies zu tun für eine indizierte Schleife.
- Wenn jemand zeigen kann, ein Beispiel für beide eine Optimierung der Begründung und eine erhaltene compiler, die Umwandlung einer Loop-Schleife über eine geordnete container mit dem als-ob - Regel zu bewerten Elemente in einer anderen Reihenfolge, aber Versand Seite-Effekte in der richtigen vorgegebenen Reihenfolge, dann machen mein Monat.
- wenn man nur sitzt an einem Flussufer, um lange genug starrte auf das Wasser...
- Was meinst du mit "eine C++-spezifische for Verständnis", insbesondere "Verständnis"?
- Hmmm, und das, was möglicherweise damit gemeint?
InformationsquelleAutor bipll
7

Wenn DoStuff() würde davon abhängig sein, ob ich irgendwie in die Zukunft dann würde ich vorschlagen, dies garantiert Zweig-gratis-bit-Maskierung Variante.
```
unsigned int times = 0;
const int kSize = sizeof(unsigned int)*8;
for(int i = 0; i < myCollection.size()/kSize; i++){
  unsigned int mask = 0;
  for (int j = 0; j<kSize; j++){
    mask |= (myCollection[i*kSize+j]==SOMETHING) << j;
  }
  times+=popcount(mask);
}

for(int i=0;i<times;i++)
   DoStuff();
```
Wo popcount ist keine Funktion dabei, eine population count ( Anzahl der bits = 1 ). Es wird eine gewisse Freiheit zu setzen, die mehr fortgeschrittene Einschränkungen mit ich und Ihre Nachbarn. Wenn das nicht erforderlich sein, können wir Streifen die innere Schleife und ein remake der äußeren Schleife
```
for(int i = 0; i < myCollection.size(); i++)
  times += (myCollection[i]==SOMETHING);
```
gefolgt von einem
```
for(int i=0;i<times;i++)
   DoStuff();
```
InformationsquelleAutor mathreadler

Auch, wenn Sie nicht kümmern, die Neuordnung der Sammlung, std::partition ist Billig.

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

void DoStuff(int i)
{
    std::cout << i << '\n';
}

int main()
{
    using namespace std::placeholders;

    std::vector<int> v {1, 2, 5, 0, 9, 5, 5};
    const int SOMETHING = 5;

    std::for_each(v.begin(),
                  std::partition(v.begin(), v.end(),
                                 std::bind(std::equal_to<int> {}, _1, SOMETHING)), //some condition
                  DoStuff); //action
}

Aber std::partition verschiebt den container.
ja, ist geklärt..

InformationsquelleAutor Loreto

5

Ich bin in Ehrfurcht vor der Komplexität der oben genannten Lösungen. Ich wollte vorschlagen eine einfache #define foreach(a,b,c,d) for(a; b; c)if(d) aber es hat einige offensichtliche Defizite, zum Beispiel, müssen Sie daran denken, Kommata statt Semikolons in der Schleife, und Sie können nicht den Komma-operator in a oder c.
```
#include <list>
#include <iostream>

using namespace std; 

#define foreach(a,b,c,d) for(a; b; c)if(d)

int main(){
  list<int> a;

  for(int i=0; i<10; i++)
    a.push_back(i);

  for(auto i=a.begin(); i!=a.end(); i++)
    if((*i)&1)
      cout << *i << ' ';
  cout << endl;

  foreach(auto i=a.begin(), i!=a.end(), i++, (*i)&1)
    cout << *i << ' ';
  cout << endl;

  return 0;
}
```
- Die Komplexität einiger Antworten ist nur hoch, weil Sie zum ersten zeigen eine wiederverwendbare generische Methode (was Sie tun würde, nur einmal), und dann verwenden Sie es. Nicht wirksam, wenn Sie one - Schleife mit einer if-Bedingung in der gesamten Anwendung, aber sehr wirksam, wenn es passiert tausend mal.
- Wie die meisten Vorschläge, diese machen es schwieriger, nicht einfacher, zu erkennen, das Sortiment und die Auswahl-Bedingung. Und die Verwendung von Makros erhöht die Unsicherheit darüber, Wann (und wie oft) Ausdrücke ausgewertet werden, auch wenn es keine überraschungen hier.
InformationsquelleAutor Ian Parberry
2

Andere Lösung bei der ich:s wichtig sind. Diese baut man eine Liste, die füllt die Indizes, von denen zu nennen doStuff() an. Wieder einmal der wichtigste Punkt ist zu vermeiden, die Verzweigung und den Handel für pipelineable arithmetische Kosten.
```
int buffer[someSafeSize];
int cnt = 0; //counter to keep track where we are in list.
for( int i = 0; i < container.size(); i++ ){
   int lDecision = (container[i] == SOMETHING);
   buffer[cnt] = lDecision*i + (1-lDecision)*buffer[cnt];
   cnt += lDecision;
}

for( int i=0; i<cnt; i++ )
   doStuff(buffer[i]); //now we could pass the index or a pointer as an argument.
```
Den "magischen" Zeile den Puffer laden Zeile, überträgt sich rein rechnerisch ermittelt, ob zu halten, den Wert und bleiben in der position oder count-up-position und Wert hinzufügen. So handeln wir entfernt eine potenzielle Niederlassung für einige Logik-und Arithmetik-und vielleicht einige cache-hits. Ein typisches Szenario, wenn dies hilfreich wäre ist, wenn doStuff() wird eine kleine Menge von pipelineable Berechnungen und in jeder Filiale zwischen Anrufe unterbrechen könnten diese pipelines.

Dann einfach Schleife über den Puffer und führen Sie doStuff (), bis wir zu cnt. Dieses mal werden wir den Strom i im Puffer gespeichert, so können wir es verwenden im Aufruf von doStuff (), wenn wir müssten.

InformationsquelleAutor mathreadler

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.