Iteration über Vectoren



  • Hallo, ich habe folgendes Problem:

    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 🙂


  • Mod

    Ich frage nochmal nach, da ich nicht sicher bin, alles verstanden zu haben. Du du hast folgendes?

    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.



  • HackerNeo schrieb:

    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.



  • Ok. Also ich habe unterschiedliche Methoden, die alle unterschiedliche Sachen machen. Vektor1 stellt hier bei eine Klasse dar, der wiederum einen weiteren Vektor enthält (Vektor2).

    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? 🙂



  • Du könntest dir Funktionsobjekte anschauen. In C++11 kannst du dafür die Klasse std::function benutzen. Übrigens könntest du, falls dein Compiler das unterstützt, auch gleich die neue Schleife (Range Based For) einsetzen:

    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);
    


  • Danke für den Beitrag 🙂

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



  • Ja, Code 2 und 3 kannst du bis auf Lambda-Ausdrücke auch in C++98 verwenden.


Log in to reply