Từ khóa auto trong C++: suy luận kiểu qua ví dụ

Để trình biên dịch chọn kiểu

Ở trang trước, bạn đã thấy mọi biến C++ đều có một kiểu cố định: int, double, std::string, v.v. Tự tay ghi kiểu thì ổn với int count = 0;, nhưng sẽ rườm rà khi tên kiểu dài ra. Từ khóa (keyword) auto (từ C++11 trở đi) cho phép trình biên dịch suy ra kiểu từ giá trị bạn gán, nên bạn chỉ cần viết giá trị một lần và để trình biên dịch lo phần còn lại.

#include <iostream>
using namespace std;

int main() {
    auto count = 0;        // int
    auto price = 3.99;     // double
    auto letter = 'A';     // char
    auto greeting = "hi";  // const char*

    cout << count << " " << price << " " << letter << " " << greeting << "\n";
    return 0;
}

Ý chính: auto không phải kiểu động. Mỗi biến vẫn có đúng một kiểu cụ thể, được chốt lúc biên dịch. auto chỉ giúp bạn khỏi phải ghi kiểu ra.

Vì sao auto đáng dùng

Với những kiểu ngắn và hiển nhiên, auto count = 0; và int count = 0; dễ đọc như nhau. auto thật sự phát huy tác dụng với những tên kiểu dài và lặp đi lặp lại, loại bạn gặp ở các container và iterator của thư viện chuẩn.

So sánh phiên bản dài dòng với phiên bản dùng auto:

// Without auto - the type is written twice, in effect
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// With auto - the compiler already knows the type
auto it = scores.begin();

Cả hai khai báo đúng cùng một kiểu iterator. Cách thứ hai dễ đọc hơn và không bị lệch nếu sau này bạn đổi scores sang một container khác.

Đây là ví dụ trong một chương trình hoàn chỉnh:

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

int main() {
    vector<pair<string, int>> scores = {{"Ada", 90}, {"Boris", 85}};

    for (auto it = scores.begin(); it != scores.end(); ++it) {
        cout << it->first << ": " << it->second << "\n";
    }
    return 0;
}

auto trong vòng lặp for dạng range

Chỗ bạn gặp auto nhiều nhất là vòng lặp for dạng range. Gần như bạn không bao giờ muốn tự ghi kiểu phần tử, và cách bạn viết auto quyết định bạn nhận được bản sao hay tham chiếu.

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

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

    // const auto& - read-only, no copy. The usual default for reading.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Ba biến thể bạn sẽ gặp, và ý nghĩa của từng cái:

• for (auto x : v): x là bản sao của từng phần tử. Rẻ với int, lãng phí với đối tượng lớn.
• for (auto& x : v): x là tham chiếu; bạn có thể sửa các phần tử ngay tại chỗ.
• for (const auto& x : v): x là tham chiếu chỉ đọc. Dùng khi bạn chỉ cần đọc.

Chương trình tiếp theo sửa đổi container qua auto&:

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

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

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

    for (const auto& n : nums) {
        cout << n << " ";   // 10 20 30
    }
    cout << "\n";
    return 0;
}

Cái bẫy: viết for (auto n : nums) (không có &) trong vòng lặp đó thì n *= 10 chỉ âm thầm thay đổi bản sao, còn nums vẫn nguyên. Trình biên dịch không cảnh báo gì cả, vòng lặp chỉ đơn giản là không làm được gì có ích.

Những gì auto lược bỏ

auto thường suy ra kiểu giống như cách một tham số hàm truyền theo giá trị: nó bỏ đi const ở mức ngoài cùng, tham chiếu và volatile. Nghĩa là auto luôn cho bạn một bản sao mới, sửa được, trừ khi bạn yêu cầu khác.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // type is int, NOT const int
    copy = 100;             // perfectly legal - the const was stripped

    cout << original << " " << copy << "\n";  // 42 100
    return 0;
}

Nếu muốn giữ const hoặc tránh sao chép, bạn tự thêm các từ bổ nghĩa. Khuôn mẫu là trang trí auto giống như cách bạn trang trí bất kỳ kiểu nào:

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

int main() {
    string name = "Ada";

    const auto& ref = name;   // const std::string& - no copy, read-only
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // error: ref is const
    return 0;
}

Vậy auto suy ra kiểu cơ sở; &, const và * là những nút điều chỉnh bạn thêm vào. auto là kiểu, const auto& là tham chiếu chỉ đọc tới kiểu đó.

Lỗi thường gặp và cái bẫy

auto giảm công gõ phím, chứ không giảm nhu cầu hiểu về kiểu. Vài cái bẫy hay bắt người mới:

Bắt buộc phải khởi tạo. auto không có gì để suy ra từ một khai báo trống, nên đây là lỗi biên dịch:

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // fine

Số nguyên literal là int, không phải double. auto half = 1 / 2; suy ra int và lưu 0, vì 1 / 2 là phép chia nguyên được tính trước khi auto kịp thấy nó. Kiểu đi theo giá trị:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // int division -> 0
    auto right = 1.0 / 2;    // double -> 0.5

    cout << wrong << " " << right << "\n";  // 0 0.5
    return 0;
}

auto bỏ đi tham chiếu, hãy cẩn thận với những bản sao bất ngờ. Nếu một hàm trả về tham chiếu mà bạn nhận nó bằng auto thường, bạn sẽ có một bản sao, đôi khi là một bug hiệu năng thật sự trong vòng lặp chạy nhiều (sao chép sâu một đối tượng lớn ở mỗi lần lặp). Hãy dùng const auto& khi ý bạn là "chỉ xem, không lấy".

Đừng giấu kiểu khi kiểu quan trọng. auto result = compute(); ổn khi kiểu trả về của compute hiển nhiên từ ngữ cảnh, nhưng nếu người đọc phải đi tìm xem result thật ra là gì, ghi rõ kiểu có thể là lựa chọn thân thiện hơn. auto dùng để bớt rườm rà, không phải để che giấu ý định.

Tiếp theo: hằng số và const

Bạn đã thấy auto cố ý bỏ const trừ khi bạn yêu cầu giữ lại, và điều đó dẫn tới câu hỏi hiển nhiên: const thật sự đảm bảo điều gì, và khi nào bạn nên đánh dấu một giá trị là không thể thay đổi? Trang tiếp theo đi sâu vào const, biểu thức hằng, và vì sao "mặc định dùng const" là một trong những thói quen hữu ích nhất trong C++.