Tham chiếu và con trỏ trong C++: khi nào dùng cái nào

Hai cách để trỏ tới một thứ

Bạn đã biết con trỏ: những biến lưu một địa chỉ và cho phép bạn truy cập đối tượng nằm ở đó. Tham chiếu (reference) là công cụ còn lại mà C++ cung cấp để làm việc gián tiếp với một đối tượng đã có. Hai thứ này giống nhau đến mức người mới thường không biết nên chọn cái nào, nên trang này sẽ đặt chúng cạnh nhau.

Nói ngắn gọn: tham chiếu là một tên khác. Khi int& r = x; chạy xong, r chính là x: cùng một đối tượng, khác tên. Con trỏ là một đối tượng riêng tình cờ chứa địa chỉ của một đối tượng khác. Chỉ một khác biệt đó quyết định mọi thứ còn lại.

Tham chiếu là một tên khác

Tham chiếu phải được gắn với một đối tượng ngay lúc được tạo, và từ đó mọi lần dùng tham chiếu đều tác động lên đối tượng gốc.

#include <iostream>
using namespace std;

int main() {
    int score = 10;
    int& alias = score;   // alias and score are now the same object

    alias = 42;           // writes through to score
    cout << score << endl; // 42

    score = 7;
    cout << alias << endl; // 7 - they move together
    return 0;
}

Để ý rằng không có * để giải tham chiếu và không có & để "lấy địa chỉ" lúc sử dụng: bạn đọc và ghi alias y như một int bình thường. Dấu & trong int& alias là một phần của kiểu, không phải toán tử lấy địa chỉ.

Chúng khác nhau ở đâu

Những hành vi dưới đây chính là lý do cả hai công cụ cùng tồn tại. Đây là bảng nên ghi nhớ.

//                      reference            pointer
// must be initialized? yes                  no (but should be)
// can be null?         no                   yes (nullptr)
// can be reseated?     no                   yes
// pointer arithmetic?  no                   yes
// syntax to use it     just the name        *p  or  p->member
// taking address       &ref == &original    &p is the pointer's own address

Có hai điểm khiến nhiều người vấp nhất. Thứ nhất, tham chiếu không bao giờ gắn lại được: gán vào nó là sao chép một giá trị vào đối tượng được tham chiếu, chứ không làm tham chiếu trỏ sang thứ khác.

#include <iostream>
using namespace std;

int main() {
    int a = 1, b = 2;
    int& r = a;

    r = b;   // does NOT make r refer to b - it copies b's value INTO a
    cout << a << endl; // 2  (a was changed)
    cout << b << endl; // 2

    b = 99;
    cout << r << endl; // 2  (r still aliases a, not b)
    return 0;
}

Ngược lại, con trỏ có thể trỏ sang chỗ khác bất cứ lúc nào:

#include <iostream>
using namespace std;

int main() {
    int a = 1, b = 2;
    int* p = &a;

    p = &b;   // reseats: p now points at b
    *p = 99;  // writes to b
    cout << a << endl; // 1
    cout << b << endl; // 99
    return 0;
}

Thứ hai, tham chiếu không bao giờ được phép null một cách hợp lệ, còn con trỏ thì có thể. Nhờ vậy "không có giá trị" biểu diễn được bằng con trỏ nhưng không bằng tham chiếu, một tính chất bạn sẽ dựa vào thường xuyên.

Chọn cho tham số của hàm

Đây là nơi lựa chọn này xuất hiện nhiều nhất. Khi một hàm cần đọc hoặc sửa đối tượng của nơi gọi, cả hai đều được, nhưng chúng thể hiện ý định khác nhau.

#include <iostream>
using namespace std;

// reference: the argument ALWAYS exists; cleaner call site
void addTax(double& price) {
    price *= 1.2;
}

// pointer: the argument is OPTIONAL; nullptr means "skip"
void applyDiscount(double* price) {
    if (price == nullptr) return;   // caller can opt out
    *price *= 0.9;
}

int main() {
    double cart = 100.0;

    addTax(cart);              // no &, reads like a normal call
    cout << cart << endl;      // 120

    applyDiscount(&cart);      // explicit & flags "this may be modified"
    cout << cart << endl;      // 108

    applyDiscount(nullptr);    // legal: nothing happens
    return 0;
}

Phiên bản tham chiếu (addTax(cart)) không thể gọi với "không có gì", nên bên trong hàm bạn không bao giờ phải kiểm tra null: đối tượng chắc chắn tồn tại. Phiên bản con trỏ (applyDiscount(&cart)) cho thấy ngay tại chỗ gọi, qua dấu &, rằng đối số có thể bị thay đổi, và cho phép nơi gọi truyền nullptr để nói "không áp dụng". Hãy chọn cái có cam kết khớp với hàm của bạn.

Với tham số chỉ đọc có kiểu lớn, lựa chọn chuẩn là const T&: nó tránh sao chép và cam kết không sửa đổi. Xem bài tham số của hàm để hiểu thêm về truyền tham trị và truyền tham chiếu.

Một quy tắc đơn giản

Khi không chắc, hãy mặc định dùng tham chiếu và chỉ chuyển sang con trỏ khi bạn cần một khả năng mà tham chiếu không có:

• Dùng tham chiếu khi đối tượng luôn tồn tại và danh tính của nó không bao giờ đổi: trường hợp phổ biến với tham số hàm và tên gọi khác.
• Dùng con trỏ khi có bất kỳ điều nào sau đây:
  • "Không có gì" là một trạng thái hợp lệ (đối số tùy chọn, một lần tìm kiếm có thể không thấy kết quả): con trỏ có thể là nullptr.
  • Bạn cần trỏ tới các đối tượng khác nhau theo thời gian: con trỏ có thể gắn lại.
  • Bạn đang quản lý vùng nhớ heap sẽ phải delete (hoặc tốt hơn là một smart pointer), hoặc duyệt một mảng bằng số học con trỏ.

Nếu không điều nào ở trên đúng, tham chiếu là lựa chọn gọn và an toàn hơn, vì trình biên dịch tự đảm bảo "luôn hợp lệ, không bao giờ gắn lại" cho bạn.

Những lỗi thường gặp cần tránh

• Tưởng ref = other sẽ gắn lại. Thực ra nó gán một giá trị vào đối tượng được tham chiếu. Tham chiếu gắn cố định suốt đời; nếu cần gắn lại, hãy dùng con trỏ.
• Trả về tham chiếu (hoặc con trỏ) tới biến cục bộ. int& f() { int x = 5; return x; } trả về một tham chiếu treo: x bị hủy khi f trả về, và dùng kết quả đó là hành vi không xác định. Con trỏ cũng dính cùng cái bẫy (return &x;).
• Tạo ra một "tham chiếu null". Viết int& r = *p; khi p là nullptr là hành vi không xác định ngay lúc giải tham chiếu, chứ không phải một tham chiếu "rỗng" an toàn. Hãy diễn đạt tính tùy chọn bằng con trỏ hoặc std::optional.
• Dùng con trỏ theo thói quen. Nếu đối số luôn tồn tại và bạn không bao giờ gắn lại, tham chiếu loại bỏ cả một nhóm phép kiểm tra null và crash. Đừng trả giá cho những khả năng bạn không dùng.

Tiếp theo: bộ nhớ động

Cho đến giờ, mọi đối tượng bạn tham chiếu hay trỏ tới đều được tạo tự động trên stack. Trang tiếp theo, bộ nhớ động, nói về new và delete: xin hệ điều hành cấp bộ nhớ lúc chạy, vì sao con trỏ (chứ không phải tham chiếu) sở hữu vùng nhớ đó, và việc quên giải phóng gây rò rỉ bộ nhớ như thế nào.