Phạm vi truy cập trong C++: public, private, protected

Ai được phép chạm vào dữ liệu của bạn

Khi viết lớp đầu tiên, có lẽ bạn đã để lộ mọi thành viên ra bên ngoài. Cách đó vẫn chạy, nhưng nó bỏ đi một trong những lý do chính khiến lớp tồn tại: tính đóng gói (encapsulation), tức che giấu trạng thái bên trong của lớp để phần còn lại của chương trình chỉ tương tác với nó qua một bề mặt được kiểm soát. Access specifier (phạm vi truy cập) là cách bạn vạch ra ranh giới đó.

Có đúng ba loại: public, private và protected. Mỗi loại gắn nhãn cho các thành viên đứng sau nó, và nhãn đó quyết định đoạn code nào được phép đọc hoặc ghi chúng. Làm đúng thì lớp của bạn tự bảo vệ các quy tắc của nó; làm sai thì một bug ở bất cứ đâu cũng có thể làm hỏng trạng thái của đối tượng.

Ba access specifier

Một specifier là một từ khóa theo sau là dấu hai chấm. Mọi thành viên khai báo sau nó, cho tới specifier tiếp theo, đều thuộc mức truy cập đó.

#include <iostream>
using namespace std;

class Account {
public:
    void deposit(double amount) { balance += amount; }  // anyone can call
    double getBalance() const { return balance; }       // anyone can read

private:
    double balance = 0.0;   // only Account's own code can touch this
};

int main() {
    Account a;
    a.deposit(100.0);
    cout << a.getBalance() << endl; // 100
    // a.balance = 999999;          // ERROR: balance is private
    return 0;
}

Bỏ chú thích ở dòng cuối và trình biên dịch sẽ từ chối build: balance là private, nên main không thể động trực tiếp vào nó. Đó chính là mục đích: cách duy nhất để thay đổi số dư là qua deposit, nghĩa là sau này bạn có thể thêm bước kiểm tra (không cho nạp số âm, ghi log, giới hạn) ở một chỗ duy nhất và tin chắc nó luôn được áp dụng.

Đây là bảng tổng hợp đầy đủ:

//             reachable from...
// public      anywhere (any code that has the object)
// private     only the same class's own members (+ friends)
// protected   the same class's members AND derived classes (+ friends)

class và struct: mặc định khác nhau

Bạn có thể viết bao nhiêu khối specifier tùy thích, theo thứ tự bất kỳ. Các thành viên đứng trước specifier đầu tiên có mức truy cập nào thì tùy vào việc bạn dùng class hay struct:

• Trong class, thành viên mặc định là private.
• Trong struct, thành viên mặc định là public.

Mặc định đó là khác biệt duy nhất ở mức ngôn ngữ giữa hai từ khóa. Một struct cũng có thể có phương thức, hàm khởi tạo và phần private giống hệt class.

#include <iostream>
using namespace std;

class Locked {
    int secret = 42;   // private by default - no specifier needed
};

struct Open {
    int value = 7;     // public by default
};

int main() {
    Open o;
    o.value = 99;           // fine: public
    cout << o.value << endl; // 99

    // Locked l;
    // l.secret = 1;         // ERROR: secret is private
    return 0;
}

Quy ước thường là dùng struct cho những gói dữ liệu public đơn giản và class khi bạn muốn có hành vi và trạng thái ẩn, nhưng trình biên dịch không bắt buộc điều đó, chỉ có mặc định là khác nhau.

Đóng gói với getter và setter

Khuôn mẫu hằng ngày là: dữ liệu nằm trong phần private, và một phương thức public cung cấp quyền truy cập có kiểm soát. Getter chỉ đọc sẽ trả về giá trị; setter kiểm tra trước khi gán. Đây là lúc private phát huy tác dụng.

#include <iostream>
using namespace std;

class Temperature {
public:
    void setCelsius(double c) {
        if (c < -273.15) {          // physics says you can't go lower
            cout << "Ignoring impossible temperature\n";
            return;
        }
        celsius = c;
    }
    double getCelsius() const { return celsius; }
    double getFahrenheit() const { return celsius * 9.0 / 5.0 + 32.0; }

private:
    double celsius = 0.0;
};

int main() {
    Temperature t;
    t.setCelsius(25);
    cout << t.getCelsius() << " C = " << t.getFahrenheit() << " F\n";

    t.setCelsius(-500);             // rejected, state stays valid
    cout << t.getCelsius() << " C\n"; // still 25
    return 0;
}

Vì celsius là private, không có cách nào lén đưa một giá trị không hợp lệ vào: mọi lần ghi đều phải đi qua setCelsius, hàm bảo vệ bất biến của lớp. Để ý các getter được đánh dấu const: chúng hứa không sửa đổi đối tượng, nên bạn gọi được chúng cả trên các đối tượng const Temperature.

protected và kế thừa

protected chỉ có ý nghĩa khi có kế thừa. Với code bên ngoài, nó hoạt động như private, nhưng lớp dẫn xuất có thể truy cập nó. Dùng nó cho những thành viên mà lớp con thật sự cần nhưng bên ngoài vẫn không nên chạm vào.

#include <iostream>
#include <string>
using namespace std;

class Animal {
protected:
    string name = "unknown";   // subclasses may use this...

public:
    void setName(const string& n) { name = n; }
};

class Dog : public Animal {
public:
    void speak() const {
        // 'name' is protected, so Dog can read it directly
        cout << name << " says Woof!\n";
    }
};

int main() {
    Dog d;
    d.setName("Rex");
    d.speak();            // Rex says Woof!
    // cout << d.name;    // ERROR: protected is off-limits to outside code
    return 0;
}

Một lỗi phổ biến của người mới là dùng protected cho mọi thành viên dữ liệu "phòng khi lớp con cần". Điều đó âm thầm nới rộng hợp đồng của lớp: giờ lớp con nào cũng có thể phụ thuộc vào trường đó, và bạn không còn tự do thay đổi nó. Hãy ưu tiên private và chỉ nâng lên protected khi lớp dẫn xuất thật sự cần quyền truy cập.

Lối thoát friend

Đôi khi một hàm hoặc một lớp bên ngoài thật sự cần nhìn vào bên trong lớp của bạn. Trường hợp kinh điển là nạp chồng toán tử <<, thứ không thể làm thành phương thức thành viên. Từ khóa friend cấp cho đúng thực thể được nêu tên đó quyền truy cập vào các thành viên private và protected của bạn, và không ai khác.

#include <iostream>
using namespace std;

class Point {
public:
    Point(int x, int y) : x(x), y(y) {}

    // grant this specific function access to private members
    friend ostream& operator<<(ostream& os, const Point& p);

private:
    int x, y;
};

ostream& operator<<(ostream& os, const Point& p) {
    return os << "(" << p.x << ", " << p.y << ")"; // can read private x, y
}

int main() {
    Point p(3, 4);
    cout << p << endl; // (3, 4)
    return 0;
}

friend là một ngoại lệ có chủ ý và rất chính xác: chính lớp nêu đích danh ai được tin tưởng, nên không ai có thể tự cấp quyền cho mình từ bên ngoài. Hãy dùng nó một cách tiết kiệm; nếu thấy mình thêm quá nhiều friend, có lẽ các thành viên đó ngay từ đầu không nên là private, hoặc thiết kế của bạn cần được xem lại.

Lỗi thường gặp cần tránh

• Để mọi thành viên là public. Nghe thì dễ, nhưng bạn mất hết khả năng kiểm tra và các bất biến mà tính đóng gói mang lại. Mặc định hãy để dữ liệu private cùng các phương thức public.
• Quên mặc định của class. class Foo { int x; }; khiến x là private, nên foo.x = 5 sẽ không biên dịch được. Nếu bạn muốn một gói dữ liệu đơn giản, hãy dùng struct hoặc thêm nhãn public:.
• Lạm dụng protected. Đây là ranh giới yếu hơn private và chỉ liên quan khi có kế thừa. Dùng nó khắp nơi sẽ gắn chặt lớp con với những trường mà bạn có thể muốn thay đổi.
• Coi private là tính năng bảo mật. Đó là quy tắc lúc biên dịch nhằm ngăn truy cập nhầm lẫn, không phải mã hóa. Các byte vẫn nằm trong bộ nhớ; private là để thiết kế gọn gàng, không phải để giữ bí mật.

Tiếp theo: struct

Giờ bạn đã thấy struct thực chất chỉ là một class có thành viên mặc định là public. Trang tiếp theo, struct, đi sâu vào khi nào mặc định public đó chính là thứ bạn cần, tức những cấu trúc gọn nhẹ để gom các giá trị liên quan, và cách struct được dùng trong C++ chuẩn mực bên cạnh các lớp đầy đủ tính năng.