Khái niệm con trỏ trong lập trình

Con trỏ là một thành phần cốt lõi trong các ngôn ngữ như C, C++, Java và Go. Về bản chất, nó mang hai ý nghĩa chính:

1. Một kiểu dữ liệu biểu thị địa chỉ bộ nhớ (ví dụ: con trỏ int, con trỏ đến con trỏ).
2. Một biến lưu trữ địa chỉ của một đối tượng trong bộ nhớ.

Giữa hai khái niệm này có mối liên hệ chặt chẽ: khi một biến được khai báo dưới dạng con trỏ, nó có thể trỏ đến một vùng nhớ cụ thể, từ đó cho phép truy cập vào giá trị tại vị trí đó. Kiểu của con trỏ cũng xác định cách thức dịch chuyển trong bộ nhớ — độ lệch phải khớp với kích thước bộ nhớ của kiểu dữ liệu tương ứng.

Nếu không có kiểu (như void*), con trỏ chỉ lưu địa chỉ nhưng không biết cách di chuyển qua các phần tử kế tiếp, dẫn đến việc không thể giải tham chiếu. Ngược lại, nếu con trỏ trỏ đến nullptr, nó không thể truy cập bất kỳ dữ liệu nào.

Lợi ích chính của con trỏ

• Tạo ra bộ nhớ động thông qua các hàm như malloc, new, hoặc allocator.
• Cho phép truyền tham số theo kiểu con trỏ, giúp tránh sao chép giá trị tốn kém.
• Cho phép thay đổi giá trị của biến từ bên ngoài phạm vi chức năng.
• Hỗ trợ tối ưu hóa các thao tác như hoán đổi, cấu tạo di chuyển, gán di chuyển bằng cách thao tác trực tiếp trên con trỏ thay vì toàn bộ dữ liệu.

Tham chiếu trong C++

C++ cung cấp hai loại tham chiếu: tham chiếu trái giá trị (lvalue reference) và tham chiếu phải giá trị (rvalue reference).

Tham chiếu trái giá trị

Được khởi tạo bằng một giá trị có thể tham chiếu (lvalue) và không thể bị gán lại sau đó. Nó hoạt động gần giống như biến gốc, ngoại trừ một điểm nhỏ: khi dùng decltype, nó không còn giữ nguyên kiểu ban đầu.

int value = 10;
int& ref = value;

ref++; // Thay đổi giá trị gốc
decltype(ref) temp = 5; // Lỗi: không thể khai báo kiểu như vậy

Tham chiếu trái giá trị thường dùng để truyền tham số theo tham chiếu, ví dụ trong hàm hoán đổi:

void swap(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

Python và hành vi "giống con trỏ"

Python không có khái niệm tham chiếu thực sự như C++. Tuy nhiên, hành vi của các biến trong Python lại rất giống với một dạng con trỏ bị hạn chế.

Không tồn tại tham chiếu trong Python

Do Python không phân biệt giữa trái giá trị và phải giá trị, nên không có khái niệm tham chiếu trái hay phải như trong C++. Mọi tham chiếu đều là động và không thể ràng buộc vĩnh viễn.

Biến Python hoạt động như con trỏ

Trong Python, mọi thao tác gán, truyền tham số đều không tạo bản sao dữ liệu mà chỉ tăng đếm tham chiếu. Điều này khiến biến Python giống như một con trỏ trỏ đến một đối tượng, chứ không phải một bản sao giá trị.

1. Hàm khởi tạo trả về con trỏ

Khi một đối tượng được tạo trong Python (ví dụ: obj = MyClass()), thực tế là một đối tượng được sinh ra trong bộ nhớ, và biến obj chỉ đơn giản là một con trỏ trỏ đến nó.

Ví dụ:

num = 5

Không giống như C++:

int num = 5;

Mà tương đương với:

int* num = new int(5);
// Hoặc:
std::shared_ptr<int> num = std::make_shared<int>(5);

2. Hành vi giải tham chiếu ngầm trong __setitem__

Python thực hiện giải tham chiếu ngầm khi sử dụng phương thức __setitem__. Các thao tác như gán giá trị qua chỉ mục hoặc thuộc tính đều làm thay đổi đối tượng gốc — giống như thao tác qua con trỏ.

Ví dụ:

data_list = [0] * 10
data_list[0] = 1  # Giải tham chiếu: thay đổi giá trị gốc
data_list = [0] * 5  # Chỉ gán lại con trỏ, không thay đổi giá trị cũ

Trong trường hợp này, việc gán lại data_list là tái định nghĩa con trỏ, còn việc thay đổi phần tử là thao tác giải tham chiếu.

3. Thao tác thuộc tính và chỉ mục đều giống giải tham chiếu

Mọi thao tác như obj.attr = value hay list[index] = value đều đi qua cơ chế __setattr__ hoặc __setitem__, tức là thao tác thay đổi nội dung đối tượng gốc — tương tự như ptr->field = value trong C++.

Ví dụ:

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

def main():
    p = Point(1, 2)
    p.x += 1
    p.y += 1
    print(p)  # (2, 3)

if __name__ == '__main__':
    main()

Tương đương với:

struct Point {
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
};

std::ostream& operator<<(std::ostream& os, const Point& p) {
    return os << '(' << p.x << ',' << p.y << ')';
}

int main() {
    Point* p = new Point(1, 2);
    p->x++;
    p->y++;
    std::cout << *p << '\n';
    delete p;
    return 0;
}

Kết luận

Python không sở hữu khái niệm tham chiếu như C++. Thay vào đó, các biến trong Python hành xử giống như những con trỏ bị giới hạn — chúng luôn trỏ đến đối tượng, và mọi thay đổi thông qua chỉ mục hoặc thuộc tính đều ảnh hưởng trực tiếp đến đối tượng gốc. Điều này cho thấy rằng, mặc dù Python giấu đi sự hiện diện của con trỏ, nhưng bản chất của nó vẫn nằm sâu trong cơ chế quản lý bộ nhớ.