C++ Erişim Belirleyicileri: public, private, protec…

Q: C++'ta public, private ve protected arasındaki fark nedir?

public üyelere her yerden erişilebilir. private üyelere yalnızca aynı sınıfın içinden (ve onun friend'lerinden) erişilebilir. protected da private gibidir, ancak türetilmiş sınıfların da üyeye erişmesine izin verir. Geleneksel olarak verileri private tutar ve davranışı public metotlar aracılığıyla dışarı açarsınız.

Q: C++'ta üyeler varsayılan olarak private midir?

Bir class içinde evet - bir erişim belirleyici yazana kadar her şey private'dır. Bir struct içinde ise varsayılan public'tir. Bu tek varsayılan, C++'ta class ile struct arasındaki gerçek tek farktır; her ikisi de metotlara, kuruculara ve erişim belirleyicilerine sahip olabilir.

Q: C++'ta friend anahtar sözcüğü ne işe yarar?

friend, belirli bir işleve veya sınıfa private ve protected üyelerinize erişim verir. Kapsüllemeye bilinçli ve dar bir istisnadır - sınıf tam olarak kime güvendiğini açıkça belirtir, böylece erişim hiçbir zaman örtük olarak verilmez.

Verinize Kim Dokunabilir

İlk sınıfınızı yazdığınızda muhtemelen her üyeyi dış dünyaya açtınız. Bu işe yarar, ama sınıfların var olma sebeplerinden birini çöpe atar: kapsülleme - bir sınıfın iç durumunu gizleyerek programın geri kalanının onunla yalnızca denetimli bir yüzey üzerinden etkileşmesini sağlamak. Erişim belirleyicileri, bu sınırı çizme şeklinizdir.

Tam olarak üç tane vardır: public, private ve protected. Her biri kendisinden sonra gelen üyeleri etiketler ve etiket, hangi kodun onları okuyabileceğine veya yazabileceğine karar verir. Bunu doğru yaparsanız sınıfınız kendi kurallarını uygular; yanlış yaparsanız herhangi bir yerdeki herhangi bir hata nesnenizin durumunu bozabilir.

Üç Belirleyici

Bir belirleyici, iki nokta üst üste ile takip edilen bir anahtar sözcüktür. Ondan sonra bildirilen her üye - bir sonraki belirleyiciye kadar - o erişim düzeyine girer.

#include <iostream>
using namespace std;

class Account {
public:
    void deposit(double amount) { balance += amount; }  // herkes çağırabilir
    double getBalance() const { return balance; }       // herkes okuyabilir

private:
    double balance = 0.0;   // buna yalnızca Account'un kendi kodu dokunabilir
};

int main() {
    Account a;
    a.deposit(100.0);
    cout << a.getBalance() << endl; // 100
    // a.balance = 999999;          // HATA: balance private'tır
    return 0;
}

Son satırın yorumunu kaldırın, derleyici derlemeyi reddeder: balance private'tır, bu yüzden main ona doğrudan dokunamaz. İşte amaç bu - bakiyeyi değiştirmenin tek yolu deposit'tir, bu da ileride doğrulamayı (negatif yatırım yok, kayıt, limitler) tek bir yerde ekleyip her zaman uygulandığına güvenebileceğiniz anlamına gelir.

İşte tam dökümü:

//             şuradan erişilebilir...
// public      her yerden (nesneye sahip herhangi bir kod)
// private     yalnızca sınıfın kendi üyeleri (+ friend'ler)
// protected   sınıfın kendi üyeleri VE türetilmiş sınıflar (+ friend'ler)

class ve struct: Varsayılan

İstediğiniz kadar belirleyici bloğunu istediğiniz sırada yazabilirsiniz. İlkini yazmadan önce üyelerin ne aldığı, class mı yoksa struct mı kullandığınıza bağlıdır:

Bir class içinde üyeler varsayılan olarak private'tır.
Bir struct içinde üyeler varsayılan olarak public'tir.

Bu varsayılan, iki anahtar sözcük arasındaki tek dil düzeyindeki farktır. Bir struct da tıpkı bir class gibi metotlara, kuruculara ve private bölümlere sahip olabilir.

#include <iostream>
using namespace std;

class Locked {
    int secret = 42;   // varsayılan olarak private - belirleyici gerekmez
};

struct Open {
    int value = 7;     // varsayılan olarak public
};

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

    // Locked l;
    // l.secret = 1;         // HATA: secret private'tır
    return 0;
}

Gelenek, salt genel verilerin oluşturduğu paketler için struct, davranış ve gizli durum istediğinizde ise class kullanmaktır - ancak derleyici bunu zorunlu kılmaz, yalnızca varsayılan farklıdır.

Getter ve Setter ile Kapsülleme

Günlük desen şudur: veriler bir private bölüme girer ve bir public metot denetimli erişim verir. Salt okunur bir getter değeri döndürür; bir setter atamadan önce doğrular. private'in işe yaradığı yer burasıdır.

#include <iostream>
using namespace std;

class Temperature {
public:
    void setCelsius(double c) {
        if (c < -273.15) {          // fizik der ki daha aşağı inemezsin
            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);             // reddedildi, durum geçerli kalır
    cout << t.getCelsius() << " C\n"; // hâlâ 25
    return 0;
}

celsius private olduğu için geçersiz bir değeri içeri sokmanın yolu yoktur - her yazma işleminin, değişmezi koruyan setCelsius'tan geçmesi gerekir. Getter'ların const ile işaretlendiğine dikkat edin: nesneyi değiştirmeyeceklerine söz verirler, böylece onları const Temperature nesneleri üzerinde de çağırabilirsiniz.

protected ve Kalıtım

protected, yalnızca kalıtım devreye girdiğinde önem kazanır. Dış kod için private gibi davranır, ancak bir türetilmiş sınıf ona erişebilir. Bir alt sınıfın meşru olarak ihtiyaç duyduğu ancak dışarıdakilerin hâlâ erişmemesi gereken üyeler için kullanın.

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

class Animal {
protected:
    string name = "unknown";   // alt sınıflar bunu kullanabilir...

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

class Dog : public Animal {
public:
    void speak() const {
        // 'name' protected'tır, bu yüzden Dog onu doğrudan okuyabilir
        cout << name << " says Woof!\n";
    }
};

int main() {
    Dog d;
    d.setName("Rex");
    d.speak();            // Rex says Woof!
    // cout << d.name;    // HATA: protected dış koda kapalıdır
    return 0;
}

Yaygın bir acemi hatası, "belki bir alt sınıf ihtiyaç duyar diye" her veri üyesi için protected'a sarılmaktır. Bu, sınıfınızın sözleşmesini sessizce genişletir - artık her alt sınıf o alana bağımlı olabilir ve onu serbestçe değiştiremezsiniz. private'i tercih edin ve yalnızca türetilmiş bir sınıfın gerçekten erişime ihtiyacı olduğunda protected'a yükseltin.

friend Kaçış Kapısı

Bazen tek bir dış işlev veya sınıfın iç yapınızı meşru olarak görmesi gerekir - klasik bir örnek, üye yapamayacağınız << gibi bir operatördür. friend anahtar sözcüğü, o tek adlandırılmış varlığa private ve protected üyelerinize erişim verir, başka hiçbir şeye değil.

#include <iostream>
using namespace std;

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

    // bu belirli işleve private üyelere erişim ver
    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 << ")"; // private x, y okuyabilir
}

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

friend, bilinçli ve cerrahi bir istisnadır - sınıfın kendisi tam olarak kime güvendiğini adlandırır, böylece kimse kendisine dışarıdan erişim veremez. Onu idareli kullanın; eğer çok sayıda friend eklediğinizi fark ediyorsanız, muhtemelen üyeleriniz en baştan private olmamalıydı ya da tasarımınızın yeniden düşünülmesi gerekiyor.

Kaçınılması Gereken Yaygın Hatalar

Her üyeyi public yapmak. Kolay gibi görünür, ama kapsüllemenin sağladığı tüm doğrulamayı ve değişmezleri kaybedersiniz. Varsayılan olarak private veriler ve public metotlar kullanın.
class varsayılanını unutmak. class Foo { int x; }; x'i private yapar, bu yüzden foo.x = 5 derlenmez. Eğer salt veri paketi kastettiyseniz, struct kullanın veya bir public: etiketi ekleyin.
protected'i aşırı kullanmak. private'ten daha zayıf bir sınırdır ve yalnızca kalıtımla ilgilidir. Her yerde ona sarılmak, alt sınıfları değiştirmek isteyebileceğiniz alanlara bağlar.
private'in bir güvenlik özelliği olmasını beklemek. Bu, kazara erişimi önleyen bir derleme zamanı kuralıdır, şifreleme değil. Baytlar hâlâ bellektedir; private temiz tasarımla ilgilidir, gizlilikle değil.

Sırada: Struct'lar

Artık bir struct'ın aslında yalnızca üyeleri varsayılan olarak public olan bir class olduğunu gördünüz. Sonraki sayfa, struct'lar, bu varsayılan-public davranışının tam olarak ne zaman istediğiniz şey olduğunu - ilişkili değerleri gruplamak için hafif kümeler - ve struct'ın deyimsel C++'ta tam donanımlı sınıfların yanında nasıl kullanıldığını derinlemesine inceler.

Sıkça Sorulan Sorular

C++'ta public, private ve protected arasındaki fark nedir?

public üyelere her yerden erişilebilir. private üyelere yalnızca aynı sınıfın içinden (ve onun friend'lerinden) erişilebilir. protected da private gibidir, ancak türetilmiş sınıfların da üyeye erişmesine izin verir. Geleneksel olarak verileri private tutar ve davranışı public metotlar aracılığıyla dışarı açarsınız.

C++'ta üyeler varsayılan olarak private midir?

Bir class içinde evet - bir erişim belirleyici yazana kadar her şey private'dır. Bir struct içinde ise varsayılan public'tir. Bu tek varsayılan, C++'ta class ile struct arasındaki gerçek tek farktır; her ikisi de metotlara, kuruculara ve erişim belirleyicilerine sahip olabilir.

C++'ta friend anahtar sözcüğü ne işe yarar?

friend, belirli bir işleve veya sınıfa private ve protected üyelerinize erişim verir. Kapsüllemeye bilinçli ve dar bir istisnadır - sınıf tam olarak kime güvendiğini açıkça belirtir, böylece erişim hiçbir zaman örtük olarak verilmez.

İlgili kavramlar

C++ Erişim Belirleyicileri: public, private, protected