Con trỏ (pointer) hoạt động như thế nào trong Go?

Question

Accepted Answer

Một **con trỏ (pointer)** giữ **địa chỉ bộ nhớ** của một giá trị thay vì chính giá trị đó. Go có con trỏ (như C) nhưng giữ chúng đơn giản và an toàn — không có số học con trỏ, và garbage collector lo việc bộ nhớ. Chúng được dùng để chia sẻ và sửa đổi dữ liệu một cách hiệu quả.

## Hai toán tử: & và *

```go
x := 42
p := &x          // & = "địa chỉ của" → p là một *int (con trỏ tới x)
fmt.Println(p)   // 0xc0000... (địa chỉ)
fmt.Println(*p)  // 42 — * = "dereference" (lấy giá trị tại địa chỉ)

*p = 100         // thay đổi giá trị THÔNG QUA con trỏ
fmt.Println(x)   // 100 — x đã bị sửa đổi qua p
```

`&` lấy địa chỉ của một biến; `*` (trên một con trỏ) truy cập hoặc gán giá trị mà nó trỏ tới.

## Vì sao con trỏ quan trọng: sửa đổi qua hàm

```go
// ❌ tham số giá trị — hàm nhận một BẢN SAO; thay đổi không ảnh hưởng bên gọi
func incrementValue(n int) { n++ }       // biến của bên gọi không đổi

// ✅ tham số con trỏ — hàm có thể sửa đổi biến của bên gọi
func incrementPointer(n *int) { *n++ }

x := 5
incrementValue(x)     // x vẫn là 5
incrementPointer(&x)  // x giờ là 6
```

Vì Go truyền tham số **bằng giá trị** (sao chép), một hàm chỉ có thể sửa đổi dữ liệu của bên gọi nếu nó nhận một **con trỏ** tới dữ liệu đó. Đây là lý do chính để dùng con trỏ.

## Con trỏ với struct (rất phổ biến)

```go
type Counter struct { count int }

// pointer receiver → method có thể sửa đổi struct
func (c *Counter) Increment() { c.count++ }

c := &Counter{}      // một con trỏ tới một Counter
c.Increment()        // sửa đổi nó (Go tự dereference: (*c).count++)
```

Pointer receiver là cách method thay đổi struct của nó, và truyền con trỏ struct tránh việc sao chép các struct lớn.

## Con trỏ nil và giá trị zero

```go
var p *int           // giá trị zero của một con trỏ là nil
fmt.Println(p)       // <nil>
*p = 5               // 💥 PANIC: nil pointer dereference (không có giá trị để trỏ tới)
if p != nil { *p = 5 }   // bảo vệ chống nil
```

Dereference một con trỏ `nil` sẽ panic — một lỗi runtime phổ biến cần đề phòng.

## Những gì con trỏ Go KHÔNG có (an toàn)

```text
✗ KHÔNG có số học con trỏ (không thể p++ để di chuyển qua bộ nhớ như C)
✗ KHÔNG có giải phóng thủ công — garbage collector thu hồi bộ nhớ
→ Con trỏ là về chia sẻ/sửa đổi dữ liệu, không phải thao tác bộ nhớ cấp thấp
```

## Tại sao điều này quan trọng

Con trỏ thiết yếu trong Go cho hai mục đích chính: **sửa đổi** dữ liệu của bên gọi (vì Go truyền bằng giá trị, chỉ có con trỏ mới cho phép một hàm thay đổi bản gốc) và **hiệu quả** (truyền con trỏ tránh sao chép các struct lớn).

Chúng là nền tảng cho method với pointer receiver (cách chuẩn để thay đổi struct) và xuất hiện khắp Go idiomatic.

Hiểu `&`/`*`, ngữ nghĩa value-vs-pointer, panic con trỏ nil, và việc con trỏ Go được thiết kế *an toàn* một cách có chủ đích (không số học, do GC quản lý) — tập trung vào chia sẻ/thay đổi thay vì thao tác bộ nhớ kiểu C — là kiến thức cốt lõi để viết Go đúng đắn, hiệu quả và là một điểm gây nhầm lẫn thường gặp cho người mới và trong phỏng vấn.