Access Specifier C++: public, private, protected

Siapa yang Boleh Menyentuh Datamu

Saat menulis class pertamamu, kemungkinan besar kamu membuka semua member ke dunia luar. Itu memang jalan, tetapi kamu membuang salah satu alasan utama class ada: enkapsulasi, yaitu menyembunyikan keadaan internal sebuah class sehingga bagian program lainnya hanya bisa berinteraksi dengannya lewat antarmuka yang terkendali. Access specifier adalah cara kamu menarik batas itu.

Jumlahnya tepat tiga: public, private, dan protected. Masing-masing memberi label pada member yang ada sesudahnya, dan label itu menentukan kode mana yang boleh membaca atau mengubahnya. Kalau benar, class-mu menjaga aturannya sendiri. Kalau salah, bug di mana saja bisa merusak keadaan objekmu.

Tiga Access Specifier

Access specifier adalah kata kunci yang diikuti titik dua. Setiap member yang dideklarasikan sesudahnya, sampai access specifier berikutnya, masuk ke level akses tersebut.

#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;
}

Hapus tanda komentar di baris terakhir, dan compiler menolak membangun program: balance bersifat private, jadi main tidak bisa mengutak-atiknya secara langsung. Justru itu intinya. Satu-satunya cara mengubah saldo adalah lewat deposit, artinya nanti kamu bisa menambahkan validasi (tidak boleh setoran negatif, pencatatan log, batasan) di satu tempat dan yakin validasi itu selalu berlaku.

Berikut rinciannya:

//             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 vs struct: Default-nya

Kamu boleh menulis blok access specifier sebanyak apa pun, dalam urutan apa pun. Akses member sebelum kamu menulis access specifier pertama bergantung pada apakah kamu memakai class atau struct:

• Di sebuah class, member bersifat private secara default.
• Di sebuah struct, member bersifat public secara default.

Default itu adalah satu-satunya perbedaan antara kedua kata kunci tersebut di level bahasa. Sebuah struct bisa punya method, constructor, dan bagian private persis seperti 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;
}

Konvensinya, struct dipakai untuk kumpulan data public yang sederhana dan class dipakai saat kamu menginginkan perilaku dan keadaan tersembunyi. Namun compiler tidak memaksakan hal itu, yang berbeda hanya default-nya.

Enkapsulasi dengan Getter dan Setter

Pola sehari-harinya begini: data masuk ke bagian private, dan method public memberi akses yang terkendali. Getter yang hanya membaca mengembalikan nilainya; setter memvalidasi dulu sebelum mengisi nilai. Di sinilah private terasa manfaatnya.

#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;
}

Karena celsius bersifat private, tidak ada cara menyelipkan nilai yang tidak valid. Setiap penulisan harus lewat setCelsius, yang menjaga aturan tersebut. Perhatikan bahwa getter-nya ditandai const: getter itu berjanji tidak mengubah objek, jadi kamu juga bisa memanggilnya pada objek const Temperature.

protected dan Pewarisan

protected baru berarti saat pewarisan (inheritance) ikut berperan. Bagi kode di luar, ia berperilaku seperti private, tetapi class turunan bisa mengaksesnya. Pakai untuk member yang memang dibutuhkan subclass, tetapi tetap tidak boleh diakses publik.

#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;
}

Kesalahan umum pemula adalah memakai protected untuk setiap member data "siapa tahu nanti subclass butuh". Itu diam-diam memperluas kontrak class-mu: sekarang setiap subclass bisa bergantung pada field tersebut, dan kamu tidak bisa lagi mengubahnya dengan bebas. Utamakan private, dan naikkan ke protected hanya saat class turunan benar-benar butuh aksesnya.

Jalan Pintas friend

Kadang satu fungsi atau class dari luar memang perlu melihat bagian dalam class-mu. Contoh klasiknya adalah operator overloading untuk <<, yang tidak bisa kamu jadikan member. Kata kunci friend memberi akses ke member private dan protected milikmu kepada satu entitas yang disebut namanya itu, dan tidak kepada yang lain.

#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 adalah pengecualian yang disengaja dan sangat terarah: class itu sendiri menyebutkan dengan tepat siapa yang ia percaya, jadi tidak ada yang bisa memberi dirinya akses dari luar. Pakailah seperlunya. Kalau kamu mendapati dirimu menambahkan banyak friend, mungkin member tersebut memang tidak seharusnya private, atau desainmu perlu dipikirkan ulang.

Kesalahan Umum yang Perlu Dihindari

• Membuat semua member public. Terasa mudah, tetapi kamu kehilangan semua validasi dan aturan yang diberikan enkapsulasi. Jadikan data private dengan method public sebagai pilihan awal.
• Lupa default dari class. class Foo { int x; }; membuat x bersifat private, jadi foo.x = 5 tidak akan bisa dikompilasi. Kalau yang kamu maksud adalah kumpulan data sederhana, pakai struct atau tambahkan label public:.
• Terlalu sering memakai protected. Batasnya lebih lemah daripada private dan hanya relevan dalam pewarisan. Memakainya di mana-mana membuat subclass terikat pada field yang mungkin ingin kamu ubah.
• Menganggap private sebagai fitur keamanan. Ini aturan saat kompilasi yang mencegah akses tidak sengaja, bukan enkripsi. Byte-nya tetap ada di memori; private adalah soal desain yang rapi, bukan kerahasiaan.

Berikutnya: Struct

Sekarang kamu tahu bahwa struct sebenarnya hanyalah class yang member-nya public secara default. Halaman berikutnya, struct, membahas kapan default public itu justru yang kamu inginkan, yaitu kumpulan ringan untuk mengelompokkan nilai yang saling terkait, dan bagaimana struct dipakai dalam C++ yang idiomatis bersama class yang lengkap.