Apa cara yang benar untuk mengulangi vektor dalam C ++?

Pertimbangkan dua fragmen kode ini, ini berfungsi dengan baik:

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

dan yang satu ini:

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

yang menghasilkan warning: comparison between signed and unsigned integer expressions.

Saya baru di dunia C ++, jadi unsignedvariabelnya terlihat sedikit menakutkan bagi saya dan saya tahu unsignedvariabel bisa berbahaya jika tidak digunakan dengan benar, jadi - apakah ini benar?

Untuk iterasi mundur lihat jawaban ini .

Iterasi ke depan hampir identik. Cukup ganti iterators / swap decrement demi increment. Anda harus memilih iterators. Beberapa orang memberi tahu Anda untuk menggunakan std::size_tsebagai tipe variabel indeks. Namun, itu tidak portabel. Selalu gunakan size_typetypedef wadah (Meskipun Anda bisa pergi hanya dengan konversi dalam kasus iterasi maju, itu bisa benar-benar salah sepanjang jalan dalam kasus iterasi berulang ketika menggunakan std::size_t, dalam kasus std::size_tlebih luas dari apa yang diketikkan dari size_type) :

Menggunakan std :: vector

Menggunakan iterators

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

Yang penting adalah, selalu gunakan formulir kenaikan awalan untuk iterator yang definisinya tidak Anda ketahui. Itu akan memastikan kode Anda berjalan generik mungkin.

Menggunakan Range C ++ 11

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

Menggunakan indeks

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

Menggunakan array

Menggunakan iterators

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

Menggunakan Range C ++ 11

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

Menggunakan indeks

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

Baca di jawaban iterasi mundur apa masalahnya sizeof bisa dihasilkan pendekatan ini.

Empat tahun berlalu, Google memberi saya jawaban ini. Dengan standar C ++ 11 (alias C ++ 0x ) sebenarnya ada cara baru yang menyenangkan untuk melakukan ini (dengan harga melanggar kompatibilitas mundur): autokata kunci baru . Ini menghemat rasa sakit karena harus secara eksplisit menentukan jenis iterator untuk digunakan (mengulangi jenis vektor lagi), ketika jelas (ke kompiler), jenis mana yang digunakan. Dengan vmenjadi milik Anda vector, Anda dapat melakukan sesuatu seperti ini:

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

C ++ 11 melangkah lebih jauh dan memberi Anda sintaks khusus untuk mengulangi koleksi seperti vektor. Ini menghilangkan keharusan menulis hal-hal yang selalu sama:

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

Untuk melihatnya di program kerja, buat file 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;
}

Saat menulis ini, saat Anda mengompilasi ini dengan g ++ , Anda biasanya perlu mengaturnya agar bekerja dengan standar baru dengan memberikan tanda tambahan:

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

Sekarang Anda dapat menjalankan contoh:

$ ./auto
17
12
23
42

Harap dicatat bahwa instruksi tentang kompilasi dan menjalankan adalah khusus untuk kompiler gnu c ++ di Linux , program harus platform (dan kompiler) independen.

Dalam kasus khusus dalam contoh Anda, saya akan menggunakan algoritma STL untuk mencapai ini.

#include <numeric> 

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

Untuk kasus yang lebih umum, tetapi masih cukup sederhana, saya akan membahas:

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

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

Mengenai jawaban Johannes Schaub:

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

Itu mungkin bekerja dengan beberapa kompiler tetapi tidak dengan gcc. Masalahnya di sini adalah pertanyaan apakah std :: vector :: iterator adalah tipe, variabel (anggota) atau fungsi (metode). Kami mendapatkan kesalahan berikut dengan 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

Solusinya menggunakan kata kunci 'typename' seperti yang diceritakan:

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

Panggilan untuk vector<T>::size()mengembalikan nilai tipe std::vector<T>::size_type, bukan int, int tidak bertanda tangan atau sebaliknya.

Juga umumnya iterasi di atas wadah dalam C ++ dilakukan menggunakan iterator , seperti ini.

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

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

Di mana T adalah tipe data yang Anda simpan dalam vektor.

Atau menggunakan algoritma iterasi yang berbeda ( std::transform, std::copy, std::fill, std::for_eachdan sebagainya).

Gunakan size_t:

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

Mengutip Wikipedia :

File header stdlib.h dan stddef.h menentukan tipe data yang disebut size_tyang digunakan untuk mewakili ukuran objek. Fungsi pustaka yang mengambil ukuran mengharapkannya bertipe size_t, dan ukurannya dievaluasi oleh operator size_t.

Jenis aktualnya size_tadalah platform-dependent; kesalahan umum adalah menganggap size_tsama dengan unsigned int, yang dapat menyebabkan kesalahan pemrograman, terutama karena arsitektur 64-bit menjadi lebih umum.

Sedikit sejarah:

Untuk menyatakan apakah suatu angka negatif atau tidak, komputer menggunakan bit 'tanda'. intadalah tipe data yang ditandatangani artinya dapat memiliki nilai positif dan negatif (sekitar -2billion hingga 2billion). Unsignedhanya dapat menyimpan angka positif (dan karena tidak membuang sedikit pun pada metadata, ia dapat menyimpan lebih banyak: 0 hingga sekitar 4 miliar).

std::vector::size()mengembalikan sebuah unsigned, karena bagaimana mungkin vektor memiliki panjang negatif?

Peringatan itu memberi tahu Anda bahwa operan kanan pernyataan ketidaksetaraan Anda dapat menyimpan lebih banyak data daripada yang kiri.

Pada dasarnya jika Anda memiliki vektor dengan lebih dari 2 miliar entri dan Anda menggunakan integer untuk mengindeks ke dalam Anda akan mendapatkan masalah overflow (int akan membungkus kembali sekitar negatif 2 miliar).

Saya biasanya menggunakan BOOST_FOREACH:

#include <boost/foreach.hpp>

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

Ini bekerja pada wadah STL, array, string gaya-C, dll.

Agar lengkap, sintaksis C ++ 11 hanya memungkinkan satu versi lain untuk iterator ( ref ):

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

Yang juga nyaman untuk iterasi terbalik

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

Dalam C ++ 11

Saya akan menggunakan algoritma umum for_eachuntuk menghindari mencari jenis iterator dan ekspresi lambda yang tepat untuk menghindari fungsi / objek bernama ekstra.

Contoh "cantik" pendek untuk kasus khusus Anda (dengan asumsi poligon adalah vektor bilangan bulat):

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

diuji pada: http://ideone.com/i6Ethd

Jangan lupa sertakan: algoritma dan, tentu saja, vektor :)

Microsoft sebenarnya juga merupakan contoh yang bagus untuk ini:
sumber: 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; 

Yang pertama adalah jenis yang benar, dan benar dalam beberapa hal. (Jika Anda berpikir tentang itu, ukuran tidak pernah bisa kurang dari nol.) Namun, peringatan itu mengejutkan saya sebagai salah satu kandidat yang baik untuk diabaikan.

Pertimbangkan apakah Anda perlu mengulangi sama sekali

The <algorithm>standar header memberikan kita dengan fasilitas untuk ini:

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

Fungsi lain di pustaka algoritma melakukan tugas-tugas umum - pastikan Anda tahu apa yang tersedia jika Anda ingin menghemat usaha.

Detail yang tidak jelas tetapi penting: jika Anda mengatakan "untuk (otomatis)" sebagai berikut, Anda mendapatkan salinan objek, bukan elemen sebenarnya:

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]

Untuk memodifikasi elemen-elemen vektor, Anda perlu mendefinisikan iterator sebagai referensi:

for(auto &it : v)

Jika kompiler Anda mendukungnya, Anda bisa menggunakan rentang berbasis untuk untuk mengakses elemen vektor:

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

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

Cetakan: 1 2 3. Catatan, Anda tidak dapat menggunakan teknik ini untuk mengubah elemen-elemen vektor.

Dua segmen kode bekerja sama. Namun, rute unsigned int "benar. Menggunakan tipe int unsigned akan bekerja lebih baik dengan vektor pada saat Anda menggunakannya. Memanggil fungsi size () anggota pada vektor mengembalikan nilai integer yang tidak ditandai, jadi Anda ingin membandingkan variabel "i" dengan nilai tipe sendiri.

Juga, jika Anda masih sedikit gelisah tentang bagaimana "unsigned int" terlihat dalam kode Anda, coba "uint". Ini pada dasarnya adalah versi singkat dari "unsigned int" dan berfungsi persis sama. Anda juga tidak perlu menyertakan header lain untuk menggunakannya.

Menambahkan ini karena saya tidak dapat menemukannya disebutkan dalam jawaban apa pun: untuk iterasi berbasis indeks, kita dapat menggunakan decltype(vec_name.size())yang akan dievaluasistd::vector<T>::size_type

Contoh

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