Pętla iteratora vs pętla indeksu [duplikat]

Iteratory sprawiają, że Twój kod jest bardziej ogólny.
Każdy kontener biblioteki standardowej zapewnia iterator, więc jeśli zmienisz klasę kontenera w przyszłości, pętla nie będzie miała wpływu.

Iteratory są pierwszym wyborem nad operator[]. C++11 zapewnia std::begin(), std::end() funkcje.

Ponieważ twój kod używa tylko std::vector, nie mogę powiedzieć, że jest duża różnica w obu kodach, jednak operator [] może nie działać tak, jak zamierzasz. Na przykład, jeśli używasz map, operator[] wstawi element, jeśli nie został znaleziony.

Ponadto, używając iterator twój kod staje się bardziej przenośny między kontenerami. Możesz dowolnie przełączać kontenery z std::vector na std::list lub inny kontener bez większych zmian, jeśli używasz iterator taka reguła nie ma zastosowania do operator[].

Z iteratorami wektorowymi nie dają żadnej rzeczywistej przewagi. Składnia jest brzydsza, dłuższa do pisania i trudniejsza do odczytania.

Iteracja nad wektorem za pomocą iteratorów nie jest szybsza i bezpieczniejsza (w rzeczywistości, jeśli wektor zostanie ewentualnie zmieniony podczas iteracji za pomocą iteratorów, wpakuje cię w duże kłopoty).

Idea posiadania pętli generycznej, która działa, gdy zmienisz później typ kontenera, jest również w większości nonsensowna w rzeczywistych przypadkach. Niestety ciemna strona ściśle język pisany bez poważnego wnioskowania o pisaniu (trochę lepiej teraz z C++11, Jednak) jest to, że trzeba powiedzieć, jaki jest typ wszystkiego na każdym kroku. Jeśli później zmienisz zdanie, nadal będziesz musiał chodzić i zmieniać wszystko. Co więcej, różne kontenery mają bardzo różne kompromisy, a zmiana typu kontenera nie zdarza się tak często.

Jedynym przypadkiem, w którym iteracja powinna być zachowana, jeśli to możliwe, jest pisanie kodu szablonu, ale to (I nadzieja dla Ciebie) nie jest najczęstszym przypadkiem.

Jedynym problemem występującym w Twojej jawnej pętli indeksu jest to, że size Zwraca wartość unsigned (błąd projektowy w C++), a porównanie pomiędzy signed i unsigned jest niebezpieczne i zaskakujące, więc lepiej unikać. Jeśli używasz porządnego kompilatora z włączonymi ostrzeżeniami, powinna być na tym diagnostyka.

Zwróć uwagę, że rozwiązaniem nie jest użycie unsiged jako indeksu, ponieważ arytmetyka między niepodpisanymi wartościami jest również pozornie nielogiczna (jest to arytmetyka modulo i x-1 może być większa niż x). Zamiast tego powinieneś oddać rozmiar do liczby całkowitej przed jej użyciem. Może mieć jakiś sens używać niepodpisanych rozmiarów i indeksów (zwracając dużą uwagę na każde wyrażenie, które piszesz) tylko wtedy, gdy pracujesz nad 16-bitową implementacją C++ (16-bitowy był powodem posiadania niepodpisanych wartości w rozmiarach ).

Jako typowy błąd, który może wprowadzić Rozmiar niepodpisany rozważ:

void drawPolyline(const std::vector<P2d>& points)
{
    for (int i=0; i<points.size()-1; i++)
        drawLine(points[i], points[i+1]);
}

Tutaj błąd jest obecny ponieważ jeśli przekażesz pusty wektor points, wartość points.size()-1 będzie ogromną liczbą dodatnią, co sprawi, że zapętlisz się w segfault. Rozwiązaniem roboczym może być

for (int i=1; i<points.size(); i++)
    drawLine(points[i - 1], points[i]);

Ale ja osobiście wolę zawsze usuwać unsinged - ness z int(v.size()).

Brzydota używania iteratorów w tym przypadku jest pozostawiona jako ćwiczenie dla czytelnika.

To zawsze zależy od tego, czego potrzebujesz.

Powinieneś używać operator[], gdy potrzebujesz bezpośredniego dostępu do elementów w wektorze (gdy musisz indeksować określony element w wektorze). Nie ma nic złego w używaniu go nad iteratorami. Musisz jednak sam zdecydować, który (operator[] lub Iteratory) najlepiej odpowiada twoim potrzebom.

Użycie iteratorów umożliwi Ci przełączenie się na inne typy kontenerów bez większych zmian w kodzie. Innymi słowy, użycie iteratorów sprawi, że Twoje kod bardziej ogólny i nie zależy od określonego typu kontenera.

Pisząc kod klienta w kategoriach iteratorów całkowicie usuniesz kontener.

Rozważ ten kod:

class ExpressionParser // some generic arbitrary expression parser
{
public:
    template<typename It>
    void parse(It begin, const It end)
    {
        using namespace std;
        using namespace std::placeholders;
        for_each(begin, end, 
            bind(&ExpressionParser::process_next, this, _1);
    }
    // process next char in a stream (defined elsewhere)
    void process_next(char c);
};

Kod klienta:

ExpressionParser p;

std::string expression("SUM(A) FOR A in [1, 2, 3, 4]");
p.parse(expression.begin(), expression.end());

std::istringstream file("expression.txt");
p.parse(std::istringstream<char>(file), std::istringstream<char>());

char expr[] = "[12a^2 + 13a - 5] with a=108";
p.parse(std::begin(expr), std::end(expr));

Edit: rozważ oryginalny przykład kodu, zaimplementowany za pomocą:

using namespace std;

vector<int> myIntVector;
// Add some elements to myIntVector
myIntVector.push_back(1);
myIntVector.push_back(4);
myIntVector.push_back(8);

copy(myIntVector.begin(), myIntVector.end(), 
    std::ostream_iterator<int>(cout, " "));

Dobrą rzeczą w iteratorze jest to, że później, jeśli chcesz przełączyć swój wektor na inny kontener STD. Wtedy forloop będzie nadal działać.

To kwestia prędkości. korzystanie z iteratora umożliwia szybszy dostęp do elementów. podobne pytanie padło tutaj:

Co jest szybsze, iteracja wektora STL z vector:: iterator czy z AT ()?

Edytuj: szybkość dostępu różni się w zależności od procesora i kompilatora