Vermeidung von if-Anweisungen innerhalb einer for-Schleife?

Pass in den Körper der Schleife als Funktor. Es wird inlined zur compile-Zeit, keine Leistungseinbußen.

Die Idee der übergabe in dem, was variiert, ist allgegenwärtig in der C++ Standard-Bibliothek. Es heißt Strategie-Muster.

Wenn Sie erlaubt sind zu verwenden, C++11, können Sie etwas wie das hier tun:

#include <iostream>
#include <set>
#include <vector>

template <typename Container, typename Functor, typename Index = std::size_t>
void for_each_indexed(const Container& c, Functor f, Index index = 0) {

    for (const auto& e : c)
        f(index++, e);
}

int main() {

    using namespace std;

    set<char> s{'b', 'a', 'c'};

    //indices starting at 1 instead of 0
    for_each_indexed(s, [](size_t i, char e) { cout<<i<<'\t'<<e<<'\n'; }, 1u);

    cout << "-----" << endl;

    vector<int> v{77, 88, 99};

    //without index
    for_each_indexed(v, [](size_t , int e) { cout<<e<<'\n'; });
}

Dieser code ist nicht perfekt, aber Sie bekommen die Idee.

In alten C++98 sieht es so aus:

#include <iostream>
#include <vector>
using namespace std;

struct with_index {
  void operator()(ostream& out, vector<int>::size_type i, int e) {
    out << i << '\t' << e << '\n';
  }
};

struct without_index {
  void operator()(ostream& out, vector<int>::size_type i, int e) {
    out << e << '\n';
  }
};


template <typename Func>
void writeVector(const vector<int>& v, Func f) {
  for (vector<int>::size_type i=0; i<v.size(); ++i) {
    f(cout, i, v[i]);
  }
}

int main() {

  vector<int> v;
  v.push_back(77);
  v.push_back(88);
  v.push_back(99);

  writeVector(v, with_index());

  cout << "-----" << endl;

  writeVector(v, without_index());

  return 0;
}

Wieder, der code ist bei weitem nicht perfekt, aber es gibt Sie, die Idee.

InformationsquelleAutor der Antwort Ali

Erweitern auf Ali ' s Antwort, die absolut korrekt sind, aber noch Duplikate code (Teil der Schleife, das ist leider kaum vermeidbar, wenn der Strategie-Muster)...

Gewährt in diesem speziellen Fall die code-Duplizierung ist nicht viel, aber es gibt einen Weg, um es zu verringern, noch mehr, die kommt in handliches wenn die Funktion Körper, die größer ist, als nur ein paar Anweisungen.

Der Schlüssel ist die Verwendung der compiler die Leistungsfähigkeit constant folding /dead code elimination. Wir können tun, dass durch die manuelle Zuordnung der Laufzeit-dem Wert des index zu einem compile-Zeit-Wert (einfach zu tun, wenn es gibt nur eine begrenzte Anzahl von Fällen-zwei in diesem Fall) und eine non-type template argument, das ist bekannt, zur compile-Zeit:

template<bool index = true>
//                 ^^^^^^ note: the default value is now part of the template version
//                        see below to understand why
void writeVector(const vector<int>& vec) {
    for (size_t i = 0; i < vec.size(); ++i) {
        if (index) { //compile-time constant: this test will always be eliminated
            cout << i << "\t"; //this will only be kept if "index" is true
        }
        cout << vec[i] << "\n";
    }
}

void writeVector(const vector<int>& vec, bool index)
//                                           ^^^^^ note: no more default value, otherwise
//                                           it would clash with the template overload
{
    if (index) //runtime decision
        writeVector<true>(vec);
        //         ^^^^ map it to a compile-time constant
    else
        writeVector<false>(vec);
}

Diese Weise landen wir mit kompiliertem code, der äquivalent ist zu deinem zweiten code-Beispiel (äußere if /innen for), jedoch ohne Duplizierung der code selbst. Nun können wir die template-version von writeVector so kompliziert, wie wir wollen, es wird immer ein Stück code zu pflegen.

Beachten Sie, wie die version der Vorlage (das dauert ein compile-time-Konstanten in der form einer non-type template argument) und die nicht-template-version (das dauert eine Laufzeit-variable als Funktions-argument) sind überlastet. Dies ermöglicht Ihnen, wählen Sie die entsprechende version je nach Ihren Bedürfnissen, mit einem ziemlich ähnlichen, leicht zu merken-syntax in beiden Fällen:

writeVector<true>(vec);   //you already know at compile-time which version you want
                          //no need to go through the non-template runtime dispatching

writeVector(vec, index);  //you don't know at compile-time what "index" will be
                          //so you have to use the non-template runtime dispatching

writeVector(vec);         //you can even use your previous syntax using a default argument
                          //it will call the template overload directly

InformationsquelleAutor der Antwort syam