Я новичок в языке C ++. Я начал использовать векторы и заметил, что во всем коде, который я вижу, для итерации по вектору через индексы, первый параметр forцикла всегда основан на векторе. В Java я мог бы сделать что-то вроде этого с ArrayList:

for(int i=0; i < vector.size(); i++){
   vector[i].doSomething();
}

Есть ли причина, по которой я не вижу этого в C ++? Это плохая практика?

Есть ли причина, по которой я не вижу этого в C ++? Это плохая практика?

Нет. Это неплохая практика, но следующий подход придает вашему коду определенную гибкость .

Обычно в пре-C ++ 11 коде для перебора элементов контейнера используются итераторы, что-то вроде:

std::vector<int>::iterator it = vector.begin();

Это потому, что это делает код более гибким.

Все стандартные контейнеры библиотеки поддерживают и предоставляют итераторы. Если на более позднем этапе разработки вам нужно переключиться на другой контейнер, то этот код не нужно менять.

Примечание. Написание кода, который работает со всеми возможными контейнерами стандартной библиотеки, не так прост, как может показаться.

Причина, по которой вы не видите такой практики, весьма субъективна и не может дать однозначного ответа, потому что я видел много кода, который использует упомянутый вами способ, а не iteratorкод стиля.

Ниже приведены причины, по которым люди не рассматривают vector.size()способ зацикливания:

1. Быть параноиком в отношении вызова size()каждый раз в состоянии цикла. Однако либо это не проблема, либо ее можно исправить тривиально
2. Предпочитая std::for_each() над самой forпетлей
3. Позже меняя контейнер с std::vectorдругого (например map,list ) также потребует изменения механизма зацикливания, поскольку не все контейнеры поддерживают size()стиль зацикливания.

C ++ 11 предоставляет хорошие возможности для перемещения по контейнерам. Это называется «диапазон для цикла» (или «расширенный для цикла» в Java).

С небольшим кодом вы можете пройти через полное (обязательно!) std::vector:

vector<int> vi;
...
for(int i : vi) 
  cout << "i = " << i << endl;

Самый чистый способ перебора вектора - через итераторы:

for (auto it = begin (vector); it != end (vector); ++it) {
    it->doSomething ();
}

или (эквивалент вышеупомянутого)

for (auto & element : vector) {
    element.doSomething ();
}

До C ++ 0x вы должны заменить auto на тип итератора и использовать функции-члены вместо глобальных функций начала и конца.

Это, наверное, то, что вы видели. По сравнению с упомянутым вами подходом преимущество заключается в том, что вы не сильно зависите от типа vector. Если вы переключитесь vectorна другой класс типа коллекции, ваш код, вероятно, все еще будет работать. Однако вы можете сделать нечто подобное и в Java. Концептуально нет большой разницы; C ++, однако, использует шаблоны для реализации этого (по сравнению с обобщениями в Java); следовательно, подход будет работать для всех типов, для которых beginи endфункций определены, даже для не относящихся к классу типов, таких как статические массивы. Смотрите здесь: Как работает диапазон на основе для простых массивов?

Правильный способ сделать это:

for(std::vector<T>::iterator it = v.begin(); it != v.end(); ++it) {
    it->doSomething();
 }

Где T - тип класса внутри вектора. Например, если класс был CActivity, просто напишите CActivity вместо T.

Этот тип метода будет работать на каждом STL (не только на векторах, что немного лучше).

Если вы все еще хотите использовать индексы, способ:

for(std::vector<T>::size_type i = 0; i != v.size(); i++) {
    v[i].doSomething();
}

Есть несколько веских причин использовать итераторы, некоторые из которых упомянуты здесь:

Переключение контейнеров позже не делает ваш код недействительным.

то есть, если вы переходите от std :: vector к std :: list или std :: set, вы не можете использовать числовые индексы, чтобы получить значение, которое вы содержите. Использование итератора все еще действует.

Время отлова неверной итерации

Если вы измените свой контейнер в середине цикла, в следующий раз, когда вы будете использовать итератор, он выдаст недопустимое исключение итератора.

Я был удивлен, что никто не упомянул, что итерация массива с целочисленным индексом облегчает вам написание ошибочного кода, подписывая массив с неправильным индексом. Например, если у вас есть вложенные циклы, используяi и в jкачестве индексов, вы можете неправильно индексировать массив с , jа неi и, таким образом, вносить ошибку в программу.

Напротив, другие формы, перечисленные здесь, а именно forцикл на основе диапазона и итераторы, намного менее подвержены ошибкам. Семантика языка и механизм проверки типов компилятора предотвратят случайный доступ к массиву с использованием неверного индекса.

В STL программисты используют iteratorsдля обхода контейнеров, поскольку итератор является абстрактной концепцией, реализованной во всех стандартных контейнерах. Например, std::listне имеет operator []вообще.

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

Итерация вектора с использованием auto и for loop

vector<int> vec = {1,2,3,4,5}

for(auto itr : vec)
    cout << itr << " ";

Вывод:

1 2 3 4 5

Вы также можете использовать этот метод для итерации наборов и списков. Использование auto автоматически определяет тип данных, используемый в шаблоне, и позволяет использовать его. Таким образом, даже если мы имели vectorиз stringили charтот же синтаксис будет работать нормально

Правильный способ итерации цикла и печати его значений следующие:

#include<vector>

//declare the vector of type int
vector<int> v;

//insert the 5 element in the vector
for ( unsigned int i = 0; i < 5; i++){
    v.push_back(i);
}

//print those element
for (auto it = 0; it < v.end(); i++){
    std::cout << *it << std::endl;
}

Вот более простой способ итерации и печати значений в векторе.

for(int x: A) // for integer x in vector A
    cout<< x <<" "; 

 //different declaration type
    vector<int>v;  
    vector<int>v2(5,30); //size is 5 and fill up with 30
    vector<int>v3={10,20,30};
    
    //From C++11 and onwards
    for(auto itr:v2)
        cout<<"\n"<<itr;
     
     //(pre c++11)   
    for(auto itr=v3.begin(); itr !=v3.end(); itr++)
        cout<<"\n"<<*itr;