Con trỏ lưu địa chỉ bộ nhớ, là sức mạnh và cũng là nguồn lỗi lớn của C/C++. Bài này giải thích con trỏ, cấp phát động và cách C++ hiện đại dùng con trỏ thông minh để quản lý bộ nhớ an toàn.
- Địa chỉ, con trỏ, toán tử & và *
- Con trỏ và mảng
- new/delete và rò rỉ bộ nhớ
- unique_ptr, shared_ptr
Cơ sở lý thuyết
Bộ nhớ của chương trình C/C++ chia thành các vùng: code (mã lệnh), dữ liệu tĩnh (biến toàn cục), stack (biến cục bộ, tự giải phóng khi ra khỏi phạm vi) và heap (cấp phát động bằng new/malloc, phải tự giải phóng). Con trỏ là biến lưu địa chỉ của vùng nhớ.
- Các lỗi kinh điển: rò rỉ bộ nhớ (quên delete), con trỏ treo (dùng vùng nhớ đã giải phóng), giải phóng hai lần, con trỏ null. Các lỗi an toàn bộ nhớ chiếm phần lớn lỗ hổng bảo mật nghiêm trọng trong phần mềm viết bằng C/C++.
- RAII (Resource Acquisition Is Initialization): gắn tài nguyên với vòng đời đối tượng – hàm khởi tạo cấp phát, hàm hủy giải phóng, tự động kể cả khi có ngoại lệ.
- unique_ptr: sở hữu duy nhất, không sao chép được, chỉ chuyển quyền sở hữu (std::move). shared_ptr: sở hữu chung bằng đếm tham chiếu; weak_ptr phá vòng tham chiếu.
- Tham chiếu là bí danh của biến có sẵn, không null, không đổi đối tượng được trỏ – an toàn hơn con trỏ khi chỉ cần truy cập.
Con trỏ
int x = 10;
int* p = &x; // p lưu địa chỉ của x
*p = 20; // sửa x qua con trỏ
cout << x << " " << p; // 20 0x7ff...
int a[3] = {1, 2, 3};
int* q = a; // tên mảng là địa chỉ phần tử đầu
cout << *(q + 1); // 2
int* r = nullptr; // con trỏ rỗng (C++11)Bộ nhớ động và con trỏ thông minh
int* mang = new int[100]; // cấp phát thủ công
delete[] mang; // phải tự giải phóng, quên sẽ rò rỉ bộ nhớ
#include <memory>
auto sv = make_unique<SinhVien>("SV01", "Lan", 9); // tự giải phóng khi ra khỏi phạm vi
auto chung = make_shared<SinhVien>("SV02", "Minh", 7);
auto ban2 = chung; // đếm tham chiếuQuy tắc C++ hiện đại: tránh new/delete trực tiếp; dùng vector, string, unique_ptr, shared_ptr.
Ứng dụng thực tế
Bài toán: cây thư mục – mỗi thư mục sở hữu các thư mục con. Dùng unique_ptr để khi xóa thư mục gốc, toàn bộ cây con tự được giải phóng, không rò rỉ bộ nhớ:
#include <memory>
struct ThuMuc {
string ten;
vector<unique_ptr<ThuMuc>> con;
explicit ThuMuc(string t) : ten(std::move(t)) {}
ThuMuc* them(string t) {
con.push_back(make_unique<ThuMuc>(std::move(t)));
return con.back().get(); // con trỏ thô chỉ để truy cập, không sở hữu
}
void in(int muc = 0) const {
cout << string(muc * 2, ' ') << ten << "\n";
for (const auto& c : con) c->in(muc + 1);
}
};
int main() {
auto goc = make_unique<ThuMuc>("Tài liệu");
goc->them("Bài giảng")->them("Web");
goc->them("Đề thi");
goc->in();
} // goc ra khỏi phạm vi → toàn bộ cây tự giải phóngTruy cập con trỏ nullptr hoặc vùng nhớ đã giải phóng gây lỗi chương trình (segmentation fault).
- Viết hàm hoán đổi bằng con trỏ và bằng tham chiếu.
- Duyệt mảng bằng con trỏ.
- Quản lý danh sách đối tượng bằng vector
>.
- & lấy địa chỉ, * truy cập giá trị.
- new/delete dễ gây rò rỉ bộ nhớ.
- Dùng con trỏ thông minh trong C++ hiện đại.

