Цикл итератора против цикла индекса [дубликат]

итераторы делают ваш код более универсальным.
Каждый стандартный контейнер библиотеки предоставляет итератор, следовательно, если вы измените свой класс контейнера в будущем, цикл не будет затронут.

итераторы являются первым выбором за operator[]. C++11 поддерживает std::begin(),std::end() функции.

как ваш код использует только std::vector, Я не могу сказать, что есть большая разница в обоих кодексов, однако, operator [] может работать не так, как вы намереваетесь. Например, если вы используете карту, operator[] вставить элемент, если не нашли.

кроме того, с помощью iterator ваш код становится более переносимым между контейнерами. Вы можете переключать контейнеры из std::vector до std::list или другой контейнер свободно, не меняя многого, если вы используете итератор, такое правило не применяется к operator[].

с векторными итераторами не предлагают никакого реального преимущества. Синтаксис страшнее, дольше и труднее читать.

итерация по вектору с использованием итераторов не быстрее и не безопаснее (на самом деле, если вектор может быть изменен во время итерации с использованием итераторов поставит вас в большие проблемы).

идея иметь общий цикл, который работает, когда вы позже измените тип контейнера, также в основном бессмысленна в реальных случаях. К сожалению темнота сторона строго типизированного языка без серьезного вывода типа (немного лучше теперь с C++11, однако) заключается в том, что вам нужно сказать, какой тип всего на каждом шаге. Если вы передумаете позже, вам все равно нужно будет пойти и изменить все. Кроме того, разные контейнеры имеют очень разные компромиссы, и изменение типа контейнера-это не то, что происходит так часто.

единственный случай, в котором итерация должна быть сохранена, если это возможно, общий при написании шаблонный код, но это (я надеюсь на вас) не самый частый случай.

единственная проблема, присутствующая в вашем явном цикле индекса, заключается в том, что size возвращает беззнаковое значение (ошибка проектирования C++) и сравнение между подписанным и беззнаковым опасно и удивительно, поэтому лучше избегать. Если вы используете приличный компилятор с включенными предупреждениями, на нем должна быть диагностика.

обратите внимание, что решение не использовать unsiged в качестве индекса, потому что арифметика между беззнаковые значения также, по-видимому, нелогичны (это арифметика по модулю и x-1 может быть больше, чем x). Вместо этого вы должны привести размер к целому числу перед его использованием. Это мая имеет смысл использовать неподписанные размеры и индексы (уделяя большое внимание каждому написанному выражению) только в том случае, если вы работаете над 16-битной реализацией C++ (16 бит был причиной наличия беззнаковых значений в размерах).

как типичная ошибка, что без знака размер может ввести рассмотрим:

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

здесь ошибка присутствует, потому что если вы передаете пустой points векторная величина points.size()-1 будет огромное положительное число, что делает вас цикл в segfault. Рабочее решение может быть

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

но я лично предпочитаю всегда удалить unsinged-Несс с int(v.size()).

уродство использования итераторов в этом случае остается в качестве упражнения для читателя.

это всегда зависит от того, что вам нужно.

вы должны использовать operator[] когда вы нужно прямой доступ к элементам в векторе (когда необходимо индексировать определенный элемент в векторе). Нет ничего плохого в использовании его над итераторами. Тем не менее, вы должны решить для себя, какие (operator[] или итераторы) лучше всего подходит для ваших нужд.

использование итераторов позволит вам переключаться на другие типы контейнеров без особых изменений в коде. Другими словами, используя итераторы сделают ваш код более универсальным и не зависят от конкретного типа контейнера.

написав свой клиентский код в терминах итераторов, вы полностью абстрагируете контейнер.

рассмотрим этот код:

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

клиентский код:

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: рассмотрим ваш исходный пример кода, реализованный с помощью:

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

хорошая вещь об итераторе заключается в том, что позже, если вы хотите переключить свой вектор на другой контейнер STD. Тогда forloop все равно будет работать.

Это вопрос скорости. использование итератора обеспечивает более быстрый доступ к элементам. на аналогичный вопрос был дан ответ здесь:

что быстрее, повторяя вектор STL с vector:: iterator или с at()?

изменить: скорость доступа зависит от процессора и компилятора