Ich iteriere innerhalb meiner Klassenmethoden mehrfach über die gleichen Vektoren, was meiner Meinung nach ganz schön nach Redundanz stinkt.

ich habe also des öfteren das Konstrukt:

for(vector<Klasse>::iterator foo = vektor1.begin(); foo < vektor1.end(); foo++ )
{
    for(vector<int>::iterator bar = vektor2.begin(); bar < vektor2.end(); bar++ )
    {
    // Sachen machen...
    }
}

Bei den Sachen mache ich aber unterschiedliche Sachen, nur um es einmal klarzustellen.

Jemand eine Idee, wie ich da mal die Redundanz vermeiden kann?

Besten Dank

for(vector1...)
{
 for(vector2...)
 {
   // Mache Sachen A 
 }
}
for(vector1...)
{
 for(vector2...)
 {
   // Mache Sachen B 
 }
}
for(vector1...)
{
 for(vector2...)
 {
   // Mache Sachen C 
 }
}

Dann mach daraus

for(vector1...)
{
 for(vector2...)
 {
   // Mache Sachen A, B und C
 }
}

Konkretere Antworten kannst du bekommen, wenn du den konkreten Fall beschreibst.

Ich iteriere innerhalb meiner Klassenmethoden mehrfach über die gleichen Vektoren

Warum hast du dann in deinem Beispiel verschiedene Vektoren?

HackerNeo schrieb:

Bei den Sachen mache ich aber unterschiedliche Sachen, nur um es einmal klarzustellen.

Kannst du etwas konkreter werden?

Wo genau ist die Redundanz? Bitte beschreibe dein Problem genauer.

Sagen wir mal, ich habe 4 Methoden und in allen 4 Methoden iteriere ich so, wie ich es geschrieben habe und führe in diesen Schleifen unterschiedliche Operationen auf den Daten aus.

Ist das genau genug?

void X::foreach(std::function<void(int&)> fn)
{
    for (MyClass& c : vec1) // vec1 ist std::vector<MyClass>
    {
        for (int& i : c.ints) // c.ints ist std::vector<int>
        {
            fn(i);
        }
    }
}

Du kannst auch ein Template verwenden:

template <typename Function>
void X::foreach(Function fn)
{
    ... // wie gehabt
}

Aufrufen kannst du das mit Funktionszeigern, Funktoren oder Lambda-Ausdrücken:

void function(int& i);

struct Functor
{
    void operator() (int& i);
};

auto lambda = [] (int& i) { ... };

// Aufrufe
foreach(&function);
foreach(Functor());
foreach(lambda);

Gibt es auch eine Möglichkeit ohne C++11?