std::array::at

#include <array>

      reference at ( size_type n );
const_reference at ( size_type n ) const;

Truy cập phần tử tại vị trí chỉ định, nhưng với cơ chế kiểm tra biên an toàn.

Tham số

n

• Vị trí của phần tử cần truy cập.
• Vị trí này phải nằm trong phạm vi hợp lệ của mảng. Nếu không, hàm sẽ ném ra ngoại lệ std::out_of_range.

Giá trị trả về

• Trả về một tham chiếu (reference) tới phần tử tại vị trí n trong mảng.
• Nếu mảng là hằng, nó sẽ trả về một tham chiếu hằng (const_reference).

Đặc điểm

1. Nếu chỉ mục nằm ngoài phạm vi hợp lệ, hàm sẽ ném ngoại lệ std::out_of_range. Điều này giúp phát hiện lỗi truy cập mảng dễ dàng hơn so với việc sử dụng cú pháp chỉ số toán tử [].
2. Truy cập phần tử trong mảng như toán tử [], nhưng có thêm bảo vệ phạm vi.
3. Cung cấp một phiên bản const để sử dụng cho các mảng chỉ đọc (const std::array).
4. Có thể chậm hơn một chút so với toán tử [] do có thêm kiểm tra biên.

Ví dụ

#include <iostream>
#include <array>
#include <stdexcept> // Để xử lý ngoại lệ std::out_of_range

int main() {
    std::array<int, 5> arr = {10, 20, 30, 40, 50};

    try {
        std::cout << "Phần tử tại vị trí 2: " << arr.at(2) << '\n'; // 30
        std::cout << "Phần tử tại vị trí 5: " << arr.at(5) << '\n'; // Ném ngoại lệ
    } catch (const std::out_of_range& e) {
        std::cerr << "Lỗi: " << e.what() << '\n';
    }

    return 0;
}

Truy cập mảng hằng

#include <iostream>
#include <array>

int main() {
    const std::array<int, 3> arr = {1, 2, 3};
    std::cout << "Phần tử đầu tiên: " << arr.at(0) << '\n'; // 1
    return 0;
}

So sánh với toán tử []

#include <iostream>
#include <array>

int main() {
    std::array<int, 3> arr = {10, 20, 30};
    std::cout << "Sử dụng operator[]: " << arr[1] << '\n'; // Không kiểm tra biên
    std::cout << "Sử dụng at(): " << arr.at(1) << '\n';    // Kiểm tra biên an toàn
    return 0;
}

Các hàm liên quan

[]	Truy xuất phần tử tại vị trí chỉ định
front	Truy xuất phần tử tại vị trí đầu tiên
back	Truy xuất phần tử tại vị trí cuối cùng