Qual é a maneira correta de iterar sobre um vetor em C ++?

Considere estes dois fragmentos de código, este funciona bem:

for (unsigned i=0; i < polygon.size(); i++) {
    sum += polygon[i];
}

e este:

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

que gera warning: comparison between signed and unsigned integer expressions.

Eu sou novo no mundo do C ++, então a unsignedvariável me parece um pouco assustadora e sei que as unsignedvariáveis ​​podem ser perigosas se não forem usadas corretamente, então - isso está correto?

Para iterar para trás, veja esta resposta .

Iterar para frente é quase idêntico. Apenas altere o decremento de iteradores / swap por incremento. Você deve preferir iteradores. Algumas pessoas dizem para você usar std::size_tcomo o tipo de variável de índice. No entanto, isso não é portátil. Sempre use o size_typetypedef do contêiner (Embora você possa se livrar apenas de uma conversão no caso de iteração direta, ele pode realmente dar errado todo o caminho no caso de iteração reversa ao usar std::size_t, caso std::size_tseja maior do que o typedef de size_type) :

Usando std :: vector

Usando iteradores

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

Importante é sempre usar o formulário de incremento de prefixo para iteradores cujas definições você não conhece. Isso garantirá que seu código seja executado o mais genérico possível.

Usando o intervalo C ++ 11

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

Usando índices

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

Usando matrizes

Usando iteradores

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

Usando o intervalo C ++ 11

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

Usando índices

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

Leia na resposta de iteração reversa para qual problema a sizeofabordagem pode render.

Quatro anos se passaram, o Google me deu essa resposta. Com o C ++ 11 padrão (também conhecido como C ++ 0x ), há realmente uma nova maneira agradável de fazer isso (ao preço de quebrar a compatibilidade com versões anteriores): a nova autopalavra-chave. Isso evita a necessidade de especificar explicitamente o tipo de iterador a ser usado (repetindo o tipo de vetor novamente), quando é óbvio (para o compilador), qual tipo usar. Com vsendo o seu vector, você pode fazer algo como isto:

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

O C ++ 11 vai ainda mais longe e fornece uma sintaxe especial para iterar sobre coleções como vetores. Remove a necessidade de escrever coisas que são sempre as mesmas:

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

Para vê-lo em um programa de trabalho, crie um arquivo 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;
}

Ao escrever isso, quando você o compila com o g ++ , normalmente é necessário configurá-lo para funcionar com o novo padrão, dando um sinalizador extra:

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

Agora você pode executar o exemplo:

$ ./auto
17
12
23
42

Observe que as instruções de compilação e execução são específicas para o compilador gnu c ++ no Linux , o programa deve ser independente da plataforma (e compilador).

No caso específico do seu exemplo, eu usaria os algoritmos STL para fazer isso.

#include <numeric> 

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

Para um caso mais geral, mas ainda bastante simples, eu diria:

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

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

Em relação à resposta de Johannes Schaub:

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

Isso pode funcionar com alguns compiladores, mas não com o gcc. O problema aqui é a questão se std :: vector :: iterator é um tipo, uma variável (membro) ou uma função (método). O seguinte erro ocorre com o 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

A solução está usando a palavra-chave 'typename', conforme informado:

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

Uma chamada para vector<T>::size()retorna um valor do tipo std::vector<T>::size_type, não int, int não assinado ou não.

Também geralmente a iteração sobre um contêiner em C ++ é feita usando iteradores , como este.

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

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

Onde T é o tipo de dados que você armazena no vetor.

Ou utilizando os diferentes algoritmos de iteração ( std::transform, std::copy, std::fill, std::for_eachet cetera).

Use size_t:

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

Citando a Wikipedia :

Os arquivos de cabeçalho stdlib.he stddef.h definem um tipo de dados chamado size_tque é usado para representar o tamanho de um objeto. As funções de biblioteca que aceitam tamanhos esperam que sejam do tipo size_te o operador sizeof avalia size_t.

O tipo real de size_tdepende da plataforma; um erro comum é assumir que size_té o mesmo que int não assinado, o que pode levar a erros de programação, principalmente quando as arquiteturas de 64 bits se tornam mais prevalentes.

Um pouco de história:

Para representar se um número é negativo ou não, use um bit de 'sinal'. inté um tipo de dados assinado, o que significa que pode conter valores positivos e negativos (cerca de -2 bilhões a 2 bilhões). Unsignedsó pode armazenar números positivos (e, como não desperdiça um pouco de metadados, pode armazenar mais: 0 a cerca de 4 bilhões).

std::vector::size()retorna um unsigned, pois como um vetor pode ter comprimento negativo?

O aviso está dizendo que o operando direito da sua declaração de desigualdade pode conter mais dados do que o esquerdo.

Essencialmente, se você tiver um vetor com mais de 2 bilhões de entradas e usar um número inteiro para indexar, terá problemas de estouro (o int retornará para 2 bilhões negativos).

Eu costumo usar BOOST_FOREACH:

#include <boost/foreach.hpp>

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

Funciona em contêineres STL, matrizes, cadeias de estilo C, etc.

Para ser concluída, a sintaxe do C ++ 11 permite apenas uma outra versão para os iteradores ( ref ):

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

O que também é confortável para iteração reversa

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

Em C ++ 11

Eu usaria algoritmos gerais for_eachpara evitar procurar o tipo certo de iterador e expressão lambda para evitar funções / objetos extra nomeados.

O pequeno exemplo "bonito" para o seu caso particular (assumindo que o polígono é um vetor de números inteiros):

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

testado em: http://ideone.com/i6Ethd

Não se esqueça de incluir: algoritmo e, é claro, vetor :)

A Microsoft também tem um bom exemplo disso:
fonte: 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;
}

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

O primeiro é o tipo correto, e correto em algum sentido estrito. (Se você pensa que é, o tamanho nunca pode ser menor que zero.) Esse aviso me parece um dos bons candidatos a ser ignorado.

Considere se você precisa iterar

O <algorithm>cabeçalho padrão fornece facilidades para isso:

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

Outras funções na biblioteca de algoritmos realizam tarefas comuns - verifique se você sabe o que está disponível se quiser economizar seu esforço.

Detalhes obscuros mas importantes: se você disser "for (auto it)" da seguinte maneira, obterá uma cópia do objeto, não do elemento real:

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]

Para modificar os elementos do vetor, você precisa definir o iterador como uma referência:

for(auto &it : v)

Se o seu compilador suportar, você pode usar um intervalo baseado em para acessar os elementos do vetor:

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

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

Impressões: 1 2 3. Observe que você não pode usar esta técnica para alterar os elementos do vetor.

Os dois segmentos de código funcionam da mesma maneira. No entanto, a rota unsigned int "está correta. O uso de tipos int não assinados funcionará melhor com o vetor na instância em que você o usou. Chamar a função de membro size () em um vetor retorna um valor inteiro não assinado, portanto, você deseja comparar a variável "i" para um valor de seu próprio tipo.

Além disso, se você ainda estiver um pouco desconfortável com a aparência de "unsigned int" em seu código, tente "uint". Esta é basicamente uma versão abreviada de "unsigned int" e funciona exatamente da mesma maneira. Você também não precisa incluir outros cabeçalhos para usá-lo.

Adicionando isso como não consegui encontrá-lo mencionado em nenhuma resposta: para iteração baseada em índice, podemos usar o decltype(vec_name.size())que seria avaliado comostd::vector<T>::size_type

Exemplo

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