Используйте size_t:

for (size_t i=0; i < polygon.size(); i++)

Цитата Википедия:

The stdlib.h and stddef.h header files define a datatype called size_t which is used to represent the size of an object. Library functions that take sizes expect them to be of type size_t, and the sizeof operator evaluates to size_t.

The actual type of size_t is platform-dependent; a common mistake is to assume size_t is the same as unsigned int, which can lead to programming errors, particularly as 64-bit architectures become more prevalent.

Вызов vector<T>::size() возвращает значение типа std::vector<T>::size_type, а не int, unsigned int или иное.

Также обычно итерация по контейнеру в C++ выполняется с использованием итераторы, как это.

std::vector<T>::iterator i = polygon.begin();
std::vector<T>::iterator end = polygon.end();

for(; i != end; i++){
    sum += *i;
}

Где T - это тип данных, которые вы храните в векторе.

Или с использованием различных итерационных алгоритмов (std::transform, std::copy, std::fill, std::for_each и так далее).

for (vector<int>::iterator it = polygon.begin(); it != polygon.end(); it++)
    sum += *it; 

Немного истории:

Чтобы указать, является ли число отрицательным или нет, компьютер использует «знаковый» бит. int - это тип данных со знаком, что означает, что он может содержать положительные и отрицательные значения (от -2 до 2 миллиардов). Unsigned может хранить только положительные числа (и, поскольку он не тратит немного времени на метаданные, он может хранить больше: от 0 до примерно 4 миллиардов).

std::vector::size() возвращает unsigned, почему вектор может иметь отрицательную длину?

Предупреждение говорит вам, что правый операнд вашего оператора неравенства может содержать больше данных, чем левый.

По сути, если у вас есть вектор с более чем 2 миллиардами записей и вы используете целое число для индексации, вы столкнетесь с проблемами переполнения (int вернется к отрицательным 2 миллиардам).

Первый - это правильный тип и правильный в некотором строгом смысле слова. (Если задуматься, размер никогда не может быть меньше нуля.) Однако это предупреждение кажется мне одним из хороших кандидатов на игнорирование.

Для итерации в обратном направлении см. этот ответ.

Итерация вперед практически идентична. Просто измените итераторы / декремент свопа на инкремент. Вам следует предпочесть итераторы. Некоторые люди советуют использовать std::size_t в качестве типа индексной переменной. Однако это непереносимо. Всегда используйте size_type typedef контейнера (хотя вы можете обойтись только преобразованием в случае прямой итерации, на самом деле она может пойти не так, как в случае обратной итерации при использовании std::size_t, в случае, если std::size_t шире, чем то, что typedef size_type):

Использование std :: vector

Использование итераторов

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

Важно всегда использовать форму приращения префикса для итераторов, определения которых вам неизвестны. Это гарантирует, что ваш код будет работать как можно более универсальным.

Использование Range C++ 11

for(auto const& value: a) {
     /* std::cout << value; ... */

Использование индексов

for(std::vector<int>::size_type i = 0; i != v.size(); i++) {
    /* std::cout << v[i]; ... */
}

Использование массивов

Использование итераторов

for(element_type* it = a; it != (a + (sizeof a / sizeof *a)); it++) {
    /* std::cout << *it; ... */
}

Использование Range C++ 11

for(auto const& value: a) {
     /* std::cout << value; ... */

Использование индексов

for(std::size_t i = 0; i != (sizeof a / sizeof *a); i++) {
    /* std::cout << a[i]; ... */
}

Прочтите в ответе на обратную итерацию, какую проблему может решить подход sizeof.

Обычно я использую BOOST_FOREACH:

#include <boost/foreach.hpp>

BOOST_FOREACH( vector_type::value_type& value, v ) {
    // do something with 'value'
}

Он работает с контейнерами STL, массивами, строками в стиле C и т. д.

В конкретном случае в вашем примере я бы использовал алгоритмы STL для этого.

#include <numeric> 

sum = std::accumulate( polygon.begin(), polygon.end(), 0 );

Для более общего, но все же довольно простого случая я бы выбрал:

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;
std::for_each( polygon.begin(), polygon.end(), sum += _1 );

Что касается ответа Йоханнеса Шауба:

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

Это может работать с некоторыми компиляторами, но не с gcc. Проблема здесь в том, является ли std :: vector :: iterator типом, переменной (членом) или функцией (методом). Мы получаем следующую ошибку с gcc:

In member function ‘void MyClass<T>::myMethod()’:
error: expected `;' before ‘it’
error: ‘it’ was not declared in this scope
In member function ‘void MyClass<T>::sort() [with T = MyClass]’:
instantiated from ‘void MyClass<T>::run() [with T = MyClass]’
instantiated from here
dependent-name ‘std::vector<T*,std::allocator<T*> >::iterator’ is parsed as a non-type, but instantiation yields a type
note: say ‘typename std::vector<T*,std::allocator<T*> >::iterator’ if a type is meant

Решение использует ключевое слово typename, как сказано:

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

Прошло четыре года, и Google дал мне такой ответ. С стандартный C++ 11 (он же C++ 0x) есть новый приятный способ сделать это (ценой нарушения обратной совместимости): новое ключевое слово auto. Это избавляет вас от необходимости явно указывать тип используемого итератора (повторяя векторный тип снова), когда очевидно (для компилятора), какой тип использовать. Если v является вашим vector, вы можете сделать что-то вроде этого:

for ( auto i = v.begin(); i != v.end(); i++ ) {
    std::cout << *i << std::endl;
}

C++ 11 идет еще дальше и дает вам специальный синтаксис для итерации по коллекциям, таким как векторы. Это устраняет необходимость писать всегда одно и то же:

for ( auto &i : v ) {
    std::cout << i << std::endl;
}

Чтобы увидеть это в работающей программе, соберите файл auto.cpp:

#include <vector>
#include <iostream>

int main(void) {
    std::vector<int> v = std::vector<int>();
    v.push_back(17);
    v.push_back(12);
    v.push_back(23);
    v.push_back(42);
    for ( auto &i : v ) {
        std::cout << i << std::endl;
    }
    return 0;
}

На момент написания этого, когда вы компилируете это с помощью g ++, вам обычно нужно настроить его для работы с новым стандартом, указав дополнительный флаг:

g++ -std=c++0x -o auto auto.cpp

Теперь вы можете запустить пример:

$ ./auto
17
12
23
42

Пожалуйста, обрати внимание, что инструкции по компиляции и запуску относятся к компилятору GNU C++ на Linux, программа должна быть независимой от платформы (и компилятора).

Чтобы быть полным, синтаксис C++ 11 позволяет использовать только одну другую версию для итераторов (ссылка):

for(auto it=std::begin(polygon); it!=std::end(polygon); ++it) {
  // do something with *it
}

Что также удобно для обратной итерации

for(auto it=std::end(polygon)-1; it!=std::begin(polygon)-1; --it) {
  // do something with *it
}

В C++ 11

Я бы использовал общие алгоритмы, такие как for_each, чтобы избежать поиска правильного типа итератора и лямбда-выражения, чтобы избежать дополнительных именованных функций / объектов.

Короткий "красивый" пример для вашего конкретного случая (при условии, что многоугольник является вектором целых чисел):

for_each(polygon.begin(), polygon.end(), [&sum](int i){ sum += i; });

проверено на: http://ideone.com/i6Ethd

Не забудьте про алгоритм включать: и, конечно же, вектор :)

У Microsoft есть хороший пример по этому поводу:
источник: http://msdn.microsoft.com/en-us/library/dd293608.aspx

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main() 
{
   // Create a vector object that contains 10 elements.
   vector<int> v;
   for (int i = 1; i < 10; ++i) {
      v.push_back(i);
   }

   // Count the number of even numbers in the vector by 
   // using the for_each function and a lambda.
   int evenCount = 0;
   for_each(v.begin(), v.end(), [&evenCount] (int n) {
      cout << n;
      if (n % 2 == 0) {
         cout << " is even " << endl;
         ++evenCount;
      } else {
         cout << " is odd " << endl;
      }
   });

   // Print the count of even numbers to the console.
   cout << "There are " << evenCount 
        << " even numbers in the vector." << endl;
}

Подумайте, нужно ли вам вообще повторять

Стандартный заголовок <algorithm> предоставляет нам возможности для этого:

using std::begin;  // allows argument-dependent lookup even
using std::end;    // if the container type is unknown here
auto sum = std::accumulate(begin(polygon), end(polygon), 0);

Другие функции библиотеки алгоритмов выполняют общие задачи - убедитесь, что вы знаете, что доступно, если хотите сэкономить силы.

Непонятная, но важная деталь: если вы скажете «for (auto it)» следующим образом, вы получите копию объекта, а не фактический элемент:

struct Xs{int i} x;
x.i = 0;
vector <Xs> v;
v.push_back(x);
for(auto it : v)
    it.i = 1;         // doesn't change the element v[0]

Чтобы изменить элементы вектора, вам нужно определить итератор как ссылку:

for(auto &it : v)

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

vector<float> vertices{ 1.0, 2.0, 3.0 };

for(float vertex: vertices){
    std::cout << vertex << " ";
}

Отпечатки: 1 2 3. Обратите внимание, что вы не можете использовать эту технику для изменения элементов вектора.

Два сегмента кода работают одинаково. Однако маршрут unsigned int "правильный. Использование типов int без знака будет лучше работать с вектором в том экземпляре, который вы его использовали. Вызов функции-члена size () для вектора возвращает целочисленное значение без знака, поэтому вы хотите сравнить переменную "i" к значению собственного типа.

Кроме того, если вас все еще немного беспокоит, как "unsigned int" выглядит в вашем коде, попробуйте "uint". По сути, это сокращенная версия unsigned int, работающая точно так же. Вам также не нужно включать другие заголовки, чтобы использовать его.

Добавляя это, поскольку я не мог найти его ни в одном ответе: для итерации на основе индекса мы можем использовать decltype(vec_name.size()), который будет оценивать std::vector<T>::size_type

Пример

for(decltype(v.size()) i{ 0 }; i < v.size(); i++) {
    /* std::cout << v[i]; ... */
}