Cách lặp chính xác của một vectơ trong C ++ là gì?

Hãy xem xét hai đoạn mã này, đoạn này hoạt động tốt:

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

và cái này nữa:

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

mà tạo ra warning: comparison between signed and unsigned integer expressions.

Tôi là người mới trong thế giới của C ++, vì vậy unsignedbiến này có vẻ hơi đáng sợ đối với tôi và tôi biết unsignedcác biến có thể nguy hiểm nếu không được sử dụng đúng cách, vậy - điều này có đúng không?

Đối với lặp đi lặp lại xem câu trả lời này .

Lặp đi lặp lại gần như giống hệt nhau. Chỉ cần thay đổi các lần lặp / giảm trao đổi theo gia số. Bạn nên thích lặp đi lặp lại. Một số người bảo bạn sử dụng std::size_tlàm kiểu biến chỉ số. Tuy nhiên, đó không phải là di động. Luôn luôn sử dụng size_typetypedef của container (Mặc dù bạn có thể thoát khỏi chỉ với một chuyển đổi trong trường hợp lặp lại phía trước, nhưng nó thực sự có thể sai hoàn toàn trong trường hợp lặp lại khi sử dụng std::size_t, trong trường hợp std::size_trộng hơn so với typedef của size_type) :

Sử dụng std :: vector

Sử dụng các vòng lặp

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

Quan trọng là, luôn luôn sử dụng biểu mẫu tăng tiền tố cho các trình vòng lặp có định nghĩa mà bạn không biết. Điều đó sẽ đảm bảo mã của bạn chạy chung chung nhất có thể.

Sử dụng Phạm vi C ++ 11

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

Sử dụng chỉ số

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

Sử dụng mảng

Sử dụng các vòng lặp

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

Sử dụng Phạm vi C ++ 11

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

Sử dụng chỉ số

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

Đọc trong câu trả lời lặp đi lặp lại những gì vấn đề mà sizeofphương pháp có thể mang lại, mặc dù.

Bốn năm trôi qua, Google đã cho tôi câu trả lời này. Với C ++ 11 tiêu chuẩn (còn gọi là C ++ 0x ) thực sự có một cách dễ chịu mới để làm điều này (với mức giá phá vỡ tính tương thích ngược): autotừ khóa mới . Nó giúp bạn bớt đau đớn khi phải chỉ định rõ ràng loại trình lặp sẽ sử dụng (lặp lại loại vectơ), khi nó rõ ràng (với trình biên dịch), loại nào sẽ sử dụng. Với vviệc là của bạn vector, bạn có thể làm một cái gì đó như thế này:

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

C ++ 11 thậm chí còn đi xa hơn và cung cấp cho bạn một cú pháp đặc biệt để lặp qua các bộ sưu tập như vectơ. Nó loại bỏ sự cần thiết phải viết những thứ luôn giống nhau:

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

Để xem nó trong một chương trình làm việc, hãy tạo một tệp 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;
}

Khi viết bài này, khi bạn biên dịch nó với g ++ , thông thường bạn cần phải thiết lập nó để hoạt động với tiêu chuẩn mới bằng cách đưa ra một cờ bổ sung:

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

Bây giờ bạn có thể chạy ví dụ:

$ ./auto
17
12
23
42

Xin lưu ý rằng các hướng dẫn về biên dịch và chạy là dành riêng cho trình biên dịch gnu c ++ trên Linux , chương trình phải độc lập với nền tảng (và trình biên dịch).

Trong trường hợp cụ thể trong ví dụ của bạn, tôi sẽ sử dụng các thuật toán STL để thực hiện điều này.

#include <numeric> 

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

Đối với một trường hợp tổng quát hơn, nhưng vẫn khá đơn giản, tôi sẽ đi với:

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

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

Về câu trả lời của Julian Schaub:

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

Điều đó có thể làm việc với một số trình biên dịch nhưng không phải với gcc. Vấn đề ở đây là câu hỏi nếu std :: vector :: iterator là một kiểu, một biến (thành viên) hoặc một hàm (phương thức). Chúng tôi nhận được lỗi sau với 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

Giải pháp là sử dụng từ khóa 'typename' như đã nói:

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

Một cuộc gọi để vector<T>::size()trả về một giá trị của loại std::vector<T>::size_type, không phải int, unsign int hoặc cách khác.

Ngoài ra, việc lặp lại thông thường trên một container trong C ++ được thực hiện bằng cách sử dụng các trình vòng lặp , như thế này.

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

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

Trong đó T là loại dữ liệu bạn lưu trữ trong vector.

Hoặc sử dụng các thuật toán lặp khác nhau ( std::transform, std::copy, std::fill, std::for_eachvân vân).

Sử dụng size_t:

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

Trích dẫn Wikipedia :

Các tệp tiêu đề stdlib.h và stddef.h xác định một kiểu dữ liệu được gọi size_tlà được sử dụng để thể hiện kích thước của một đối tượng. Các hàm thư viện có kích thước mong đợi chúng có kiểu size_tvà toán tử sizeof ước tính size_t.

Loại thực tế size_tlà phụ thuộc vào nền tảng; một lỗi phổ biến là giả sử size_tgiống như int unsign, điều này có thể dẫn đến lỗi lập trình, đặc biệt khi kiến ​​trúc 64 bit trở nên phổ biến hơn.

Một chút về lịch sử:

Để thể hiện một số có âm hay không, máy tính sử dụng bit 'dấu'. intlà một kiểu dữ liệu đã ký có nghĩa là nó có thể giữ các giá trị dương và âm (khoảng -2 tỷ đến 2 tỷ). Unsignedchỉ có thể lưu trữ các số dương (và vì nó không lãng phí một chút vào siêu dữ liệu nên nó có thể lưu trữ nhiều hơn: 0 đến khoảng 4 tỷ).

std::vector::size()trả về một unsigned, làm thế nào một vectơ có thể có chiều dài âm?

Cảnh báo cho bạn biết rằng toán hạng bên phải của câu lệnh bất đẳng thức của bạn có thể chứa nhiều dữ liệu hơn bên trái.

Về cơ bản, nếu bạn có một vectơ có hơn 2 tỷ mục nhập và bạn sử dụng một số nguyên để lập chỉ mục cho các vấn đề tràn (int sẽ quay trở lại âm 2 tỷ).

Tôi thường sử dụng BOOST_FOREACH:

#include <boost/foreach.hpp>

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

Nó hoạt động trên các thùng chứa STL, mảng, chuỗi kiểu C, v.v.

Để hoàn thành, cú pháp C ++ 11 chỉ cho phép một phiên bản khác cho iterators ( ref ):

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

Điều này cũng thoải mái cho việc lặp lại

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

Trong C ++ 11

Tôi sẽ sử dụng các thuật toán chung như for_eachđể tránh tìm kiếm đúng loại biểu thức lặp và lambda để tránh các hàm / đối tượng được đặt tên thêm.

Ví dụ "khá" ngắn cho trường hợp cụ thể của bạn (giả sử đa giác là một vectơ số nguyên):

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

đã thử nghiệm trên: http://ideone.com/i6Ethd

Đừng quên bao gồm: thuật toán và, tất nhiên, vector :)

Microsoft thực sự cũng có một ví dụ hay về điều này:
nguồn: http://msdn.microsoft.com/en-us/l 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; 

Đầu tiên là loại chính xác, và chính xác trong một số ý nghĩa nghiêm ngặt. (Nếu bạn nghĩ là, kích thước không bao giờ có thể nhỏ hơn 0.) Cảnh báo đó đánh tôi là một trong những ứng cử viên tốt để bị bỏ qua, mặc dù.

Xem xét liệu bạn có cần lặp đi lặp lại không

Các <algorithm>tiêu đề tiêu chuẩn cung cấp cho chúng với cơ sở vật chất cho việc này:

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

Các chức năng khác trong thư viện thuật toán thực hiện các tác vụ phổ biến - đảm bảo bạn biết những gì có sẵn nếu bạn muốn tiết kiệm công sức cho mình.

Ít chi tiết nhưng quan trọng: nếu bạn nói "for (auto it)" như sau, bạn sẽ có được một bản sao của đối tượng, không phải là phần tử thực tế:

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]

Để sửa đổi các phần tử của vectơ, bạn cần xác định iterator làm tham chiếu:

for(auto &it : v)

Nếu trình biên dịch của bạn hỗ trợ nó, bạn có thể sử dụng một phạm vi dựa trên để truy cập các phần tử vectơ:

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

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

In: 1 2 3. Lưu ý, bạn không thể sử dụng kỹ thuật này để thay đổi các yếu tố của vectơ.

Hai đoạn mã làm việc như nhau. Tuy nhiên, tuyến int "không dấu là đúng. Sử dụng kiểu int không dấu sẽ hoạt động tốt hơn với vectơ trong trường hợp bạn đã sử dụng. Gọi hàm thành viên size () trên vectơ trả về giá trị nguyên không dấu, vì vậy bạn muốn so sánh biến "i" với một giá trị của loại riêng của nó.

Ngoài ra, nếu bạn vẫn còn một chút lo lắng về việc "unsign int" trông như thế nào trong mã của bạn, hãy thử "uint". Về cơ bản, đây là phiên bản rút gọn của "unsign int" và nó hoạt động giống hệt nhau. Bạn cũng không cần bao gồm các tiêu đề khác để sử dụng nó.

Thêm điều này khi tôi không thể tìm thấy nó được đề cập trong bất kỳ câu trả lời nào: đối với phép lặp dựa trên chỉ mục, chúng ta có thể sử dụng decltype(vec_name.size())để đánh giástd::vector<T>::size_type

Thí dụ

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