3. Container loopen

Container loopen

  • F

    Performancegewinn hat man meist eh bei Algorithmen. Zum Beispiel durch den Verzicht auf sqrt indem man mit den noch quadrierten Werten rechnet. Oder die richtige Reihenfolge bei verschachtelten Schleifen entsprechend der Speicherstruktur etc.

    0
  • B
     

    std::vector<DATA>::iterator vec_end = vec.end();
for(std::vector<DATA>::iterator iter = vec.begin(); iter != vec_end; ++iter)
    *iter;

    Nur als Zusatz, wegen Schreibarbeit und so:

    for(std::vector<DATA>::iterator iter=vec.begin(), end=vec.end(); iter != end; ++iter )
    *iter;
    0
  • B

    http://boost.org/doc/html/foreach.html 🙂 Sollte gleich schnell sein wie die iterator-Variante, ist aber wesentlich weniger Schreibaufwand (und sieht IMO besser aus 🙂 )

    0
  • A

    Warum nicht std::for_each?

    0
  • *

    Also Iterator ist wie hier schon angesprochen so gut wie immer schneller als direkter Zugriff per Index-Operator.

    Dann noch mit Standardalgorithmen kombinieren, und es rockt das haus 😉

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

struct bar
{
    bar()
        : data(0)
    {}

    void foo(const std::size_t value) { std::cout << "data = " << value << " (old: " << data << ");" << std::endl; data = value; }

private:
    std::size_t data;
};

int main()
{
    std::vector<bar> data(10);

    /* operator[] => Indexoperator */
    for (std::size_t i(0); i < data.size(); ++i)
        data.foo(2);

    /* begin(), end() => Iterator */
    const std::vector<bar>::iterator it_end(data.end());
    for (std::vector<bar>::iterator it(data.begin()); it != it_end; ++it)
        it->foo(3);

    /* for_each => Algorithm | Iterator */
    std::for_each(data.begin(), data.end(), std::bind2nd(std::mem_fun_ref(&bar::foo), 2));
}

    ... Letztes gewinnt! ^^ Naja und in manchen Fällen ist es sogar nur per Iterator anständig möglich (std::list) oder einfach viel einfacher (std::ifstream_iterator usw.) ...

    0
  • E

    danke fuer die meinungen

    - wegen dem casten, das wurde hier von jemanden missverstanden, wenn ich
    for(int i...
    mache, muss ich vec.size() nach int casten, darum lass ich das meistens

    - das for_each usw schneller sind, also generell algos zu bevorzugen sind weiss ich, hab cih im start post auch schon geschrieben, mir gehts nur um die faellt wo ein also nicht moeglich ist

    0
  • A

    Na, damit du bei der for-Schleife nicht casten mußt, solltest du dann halt den richtigen Typ nehmen:

    for(std::size_t i=0; i<vec.size(); i++)
    0
  • E

    ich weiss, das mach ich ja auch, nur manchmal brauch ich den index i auch fuer andere zwecke, da ist es dann einfacher size nach int zu casten als das size_t jedesmal nach int casten zu muessen

    ich vermeide das aber so gut wie geht {also casts ueberhaupt}

    0
  • *

    man braucht selten wirklich +/- -Zahlenbereiche ... meist reicht + oder -.

    0
  • T

    Na, damit du bei der for-Schleife nicht casten mußt, solltest du dann halt den richtigen Typ nehmen

    Ähm der richtige wäre:

    typedef std::vector<int> IntArray;
IntArray vec;
for(IntArray::size_type i=0; i<vec.size(); i++)
    0
  • M

    mal so ne Frage nebenbei:
    1. funzt std::mem_fun_ref auch virtuellen methoden?
    2. funzt das mit dem for_each auch bei Pointern?

    class bar{
    bar() {}
    virtual void foo1() = 0;
    virtual void foo2() { std::cout << "bar::foo2"  << std::endl;  }
};

class bar2 : public bar{
    bar2() {}
    void foo1() { std::cout << "bar2::foo1"  << std::endl;  }
    void foo2() { std::cout << "bar2::foo2"  << std::endl;  }
};

class bar3 : public bar{
    bar3() {}
    void foo1() { std::cout << "bar3::foo1"  << std::endl;  }
    void foo2() { std::cout << "bar3::foo2"  << std::endl;  }
};

int main()
{
    std::vector<bar*> data(4);
    data[0] = new bar2;
    data[1] = new bar2;
    data[2] = new bar3;
    data[3] = new bar3;

    /* for_each => Algorithm | Iterator */
   //wie sähe hier der for_each Befehl aus? einmal für foo1 und einmal für foo2    
   std::for_each( ??? )
}
    0
Anmelden zum Antworten