Vòng lặp for dạng range C++: cú pháp, auto và tham chiếu

"Với mỗi phần tử, làm việc này"

Vòng lặp for đếm kiểu truyền thống rất hợp khi bạn cần một chỉ số để điều khiển. Nhưng phần lớn thời gian bạn không thật sự quan tâm đến chỉ số, bạn chỉ muốn xử lý từng phần tử của một container. Viết for (int i = 0; i < v.size(); i++) cho việc đó vừa rườm rà, vừa khiến i chỉ cách một lỗi lệch một đơn vị là đọc ra ngoài phạm vi.

C++11 thêm vòng lặp for dạng range (range-based for loop) cho đúng mục đích này. Bạn đặt tên một biến, chỉ ra container, và vòng lặp tự đi qua từng phần tử:

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

int main() {
    vector<int> scores = {90, 75, 100, 60};

    for (int s : scores) {
        cout << s << "\n";
    }
}

Không chỉ số, không .size(), không giới hạn nào để viết sai. Hãy đọc nó là "với mỗi s trong scores". Nó dùng được với mảng thô, std::vector, std::string, std::map và mọi thứ có begin() và end().

Để auto chọn kiểu

Viết rõ kiểu phần tử vẫn chạy, nhưng dễ vỡ: đổi kiểu của container là phải sửa mọi vòng lặp. Kết hợp for dạng range với auto, trình biên dịch sẽ tự suy ra kiểu phần tử cho bạn:

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

int main() {
    vector<string> names = {"Ada", "Linus", "Grace"};

    for (auto name : names) {
        cout << "Hello, " << name << "!\n";
    }
}

Tuy nhiên ở đây có một chi phí ẩn. auto name thông thường suy ra string và sao chép từng phần tử vào name ở mỗi lần lặp. Với int thì không tốn gì; với string hay một struct lớn thì mỗi lần lặp lại tốn một lần cấp phát vô ích. Cách khắc phục là tham chiếu, và đó là điều tiếp theo cần hiểu.

Sửa trực tiếp với auto&

Nếu viết auto x, bạn nhận được một bản sao, nên gán vào x chỉ thay đổi bản sao chứ không phải container. Xem cái bẫy này:

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

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto n : nums) {   // copy! changes are thrown away
        n *= 10;
    }

    for (int n : nums) cout << n << " ";   // still 1 2 3
}

Phép nhân âm thầm chẳng có tác dụng gì vì n chỉ là một bản sao dùng xong bỏ. Muốn thật sự sửa các phần tử, hãy lấy chúng theo tham chiếu với auto&:

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

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto& n : nums) {   // reference - edits the real element
        n *= 10;
    }

    for (int n : nums) cout << n << " ";   // 10 20 30
}

Chỉ một dấu & là toàn bộ khác biệt giữa "chỉ xem không sửa" và "sửa trực tiếp". Nếu bạn từng thắc mắc vì sao thay đổi của mình biến mất, gần như chắc chắn đây là lý do.

Đọc mà không sao chép: const auto&

Khi bạn chỉ cần đọc phần tử nhưng chúng tốn kém để sao chép, hãy dùng const auto&. Tham chiếu giúp tránh sao chép, còn const thể hiện (và bắt buộc) rằng bạn sẽ không sửa gì:

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

int main() {
    vector<string> words = {"refactor", "compile", "deploy"};

    size_t total = 0;
    for (const auto& w : words) {   // no copy, can't accidentally change w
        total += w.size();
    }

    cout << "Total characters: " << total << "\n";
}

Một quy tắc dễ nhớ:

for (auto x : c)         // copy   - cheap types (int, char, pointers)
for (auto& x : c)        // edit   - you want to change the elements
for (const auto& x : c)  // read   - heavy types you only inspect

Mặc định dùng const auto& khi đọc và auto& khi ghi. Chỉ dùng auto thông thường cho những kiểu thật sự nhỏ, rẻ để sao chép.

Duyệt map và pair

Vòng lặp for dạng range trên một std::map trả về một std::pair cho mỗi phần tử, với .first (khóa) và .second (giá trị). Từ C++17, structured binding cho phép bạn tách pair đó thành hai biến có tên ngay trong phần đầu vòng lặp:

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
    map<string, int> ages = {{"Ada", 36}, {"Grace", 85}};

    for (const auto& [name, age] : ages) {
        cout << name << " is " << age << "\n";
    }
}

[name, age] rõ ràng hơn nhiều so với việc lặp lại entry.first và entry.second ở khắp nơi. Ở đây cũng nên giữ const auto&: khóa của một phần tử map là string, nên sao chép từng pair sẽ rất lãng phí.

Cái bẫy: đừng đổi kích thước khi đang lặp

Cái bẫy lớn nhất là thay đổi kích thước container trong khi vòng lặp for dạng range đang duyệt nó. Gọi push_back, erase, insert hay clear có thể cấp phát lại vùng nhớ bên dưới và làm các iterator bên trong vòng lặp mất hiệu lực. Kết quả là hành vi không xác định, nghĩa là crash hoặc dữ liệu rác, chứ không phải một thông báo lỗi dễ hiểu:

vector<int> v = {1, 2, 3};
for (int x : v) {
    v.push_back(x);   // UNDEFINED BEHAVIOR - reallocation invalidates the range
}

Nếu cần thêm hay xóa phần tử trong lúc xử lý, hãy chuyển sang vòng lặp for theo chỉ số hoặc theo iterator và tự quản lý giới hạn, hoặc tạo một container kết quả riêng rồi hoán đổi vào sau. Hai cái bẫy nhỏ hơn cùng họ: đừng bao giờ gắn vòng lặp for dạng range vào một đối tượng tạm bị hủy ngay lập tức (for (auto x : makeVector()) thì ổn, nhưng for (auto& x : someObj.getTempVector()) có thể bị treo), và nhớ rằng for (auto& c : myString) cho phép bạn sửa trực tiếp từng ký tự.

Tiếp theo: hàm

Vòng lặp for dạng range giúp việc duyệt gọn gàng hơn, và các lựa chọn auto / auto& / const auto& bạn vừa học sẽ áp dụng thẳng vào một trong những công cụ quan trọng nhất của C++. Tiếp theo, chúng ta sẽ đóng gói logic vào các hàm có thể dùng lại: đặt cho code một cái tên, tham số và giá trị trả về để bạn gọi nó từ bất cứ đâu thay vì lặp lại chính mình.