محددات الوصول في C++‎: public وprivate وprotected

من يحق له لمس بياناتك

عندما كتبت أول صنف لك، ربما كشفت كل عضو للعالم الخارجي. هذا يعمل، لكنه يهدر أحد الأسباب الرئيسية لوجود الأصناف: التغليف - إخفاء الحالة الداخلية للصنف بحيث لا يستطيع باقي البرنامج التفاعل معه إلا عبر واجهة محكومة. ومحددات الوصول هي الطريقة التي ترسم بها هذا الحد.

هناك ثلاثة بالضبط: public وprivate وprotected. يضع كل منها وسمًا على الأعضاء التي تليه، والوسم يقرر أي كود يُسمح له بقراءتها أو الكتابة إليها. إن أحسنت ذلك فرض صنفك قواعده الخاصة؛ وإن أخطأت فقد يفسد أي خطأ في أي مكان حالة كائنك.

المحددات الثلاثة

المحدِّد كلمة مفتاحية تتبعها نقطتان رأسيتان. وكل عضو يُعلن بعده - حتى المحدِّد التالي - يندرج تحت ذلك المستوى من الوصول.

#include <iostream>
using namespace std;

class Account {
public:
    void deposit(double amount) { balance += amount; }  // يمكن لأي أحد استدعاؤها
    double getBalance() const { return balance; }       // يمكن لأي أحد قراءتها

private:
    double balance = 0.0;   // لا يمكن لمس هذا إلا لكود Account نفسه
};

int main() {
    Account a;
    a.deposit(100.0);
    cout << a.getBalance() << endl; // 100
    // a.balance = 999999;          // خطأ: balance خاص (private)
    return 0;
}

أزل التعليق عن السطر الأخير ويرفض المترجم البناء: balance خاص (private)، لذا لا يستطيع main العبث به مباشرة. هذا هو المقصود - الطريقة الوحيدة لتغيير الرصيد هي عبر deposit، ما يعني أنه يمكنك لاحقًا إضافة تحقق (منع الإيداعات السالبة، والتسجيل، والحدود) في مكان واحد والوثوق بأنه يُطبَّق دائمًا.

وإليك التفصيل الكامل:

//             يمكن الوصول إليه من...
// public      أي مكان (أي كود يملك الكائن)
// private     أعضاء الصنف نفسه فقط (+ friends)
// protected   أعضاء الصنف نفسه والأصناف المشتقة (+ friends)

class مقابل struct: الافتراضي

يمكنك كتابة ما تشاء من كتل المحددات بأي ترتيب. أما ما يحصل عليه الأعضاء قبل أن تكتب المحدِّد الأول فيعتمد على ما إذا كنت استخدمت class أم struct:

• في class، الأعضاء private افتراضيًا.
• في struct، الأعضاء public افتراضيًا.

هذا الافتراضي هو الفرق الوحيد على مستوى اللغة بين الكلمتين المفتاحيتين. فبإمكان struct أن يحتوي على دوال ومنشئات وأقسام private تمامًا كما class.

#include <iostream>
using namespace std;

class Locked {
    int secret = 42;   // private افتراضيًا - لا حاجة إلى محدِّد
};

struct Open {
    int value = 7;     // public افتراضيًا
};

int main() {
    Open o;
    o.value = 99;           // لا بأس: public
    cout << o.value << endl; // 99

    // Locked l;
    // l.secret = 1;         // خطأ: secret خاص (private)
    return 0;
}

العُرف هو استخدام struct لحزم بسيطة من البيانات العامة واستخدام class حين تريد سلوكًا وحالة مخفية - لكن المترجم لا يفرض ذلك، إنما يختلف الافتراضي فقط.

التغليف عبر الـ getters والـ setters

النمط اليومي هو: تذهب البيانات إلى قسم private، وتمنح دالة public وصولًا محكومًا. يعيد الـ getter للقراءة فقط القيمة؛ ويتحقق الـ setter قبل الإسناد. وهنا يؤتي private ثماره.

#include <iostream>
using namespace std;

class Temperature {
public:
    void setCelsius(double c) {
        if (c < -273.15) {          // الفيزياء تقول لا يمكنك النزول أدنى من ذلك
            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);             // مرفوض، تبقى الحالة صالحة
    cout << t.getCelsius() << " C\n"; // ما زالت 25
    return 0;
}

ولأن celsius خاص (private)، فلا سبيل لتسريب قيمة غير صالحة - فكل كتابة يجب أن تمر عبر setCelsius، الذي يحرس الثابت المنطقي (invariant). لاحظ أن الـ getters موسومة بـ const: فهي تَعِد بألا تعدّل الكائن، لذا يمكنك استدعاؤها على كائنات const Temperature أيضًا.

protected والوراثة

لا تكون لـ protected أهمية إلا حين تدخل الوراثة المشهد. فهي تتصرف مثل private تجاه الكود الخارجي، لكن الصنف المشتق يستطيع الوصول إليها. استخدمها للأعضاء التي يحتاجها صنف فرعي بحق لكن لا ينبغي مع ذلك أن تكون متاحة للعموم.

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

class Animal {
protected:
    string name = "unknown";   // يجوز للأصناف الفرعية استخدام هذا...

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

class Dog : public Animal {
public:
    void speak() const {
        // 'name' محمي (protected)، لذا يستطيع Dog قراءته مباشرة
        cout << name << " says Woof!\n";
    }
};

int main() {
    Dog d;
    d.setName("Rex");
    d.speak();            // Rex says Woof!
    // cout << d.name;    // خطأ: protected ممنوع على الكود الخارجي
    return 0;
}

من الأخطاء الشائعة لدى المبتدئين اللجوء إلى protected على كل عضو بيانات "تحسبًا لاحتياج صنف فرعي إليه". وهذا يوسّع عقد صنفك بصمت - فالآن يمكن لكل صنف فرعي أن يعتمد على ذلك الحقل، ولا تستطيع تغييره بحرية. فضّل private ولا ترفّعه إلى protected إلا حين يحتاج صنف مشتق الوصول حاجةً حقيقية.

منفذ الهروب friend

أحيانًا تحتاج دالة أو صنف خارجي واحد بحق إلى رؤية دواخلك - من الحالات الكلاسيكية معامل مثل << لا يمكنك جعله عضوًا. تمنح الكلمة المفتاحية friend تلك الجهة المسمّاة الواحدة الوصول إلى أعضائك private وprotected، ولا شيء غير ذلك.

#include <iostream>
using namespace std;

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

    // امنح هذه الدالة المحددة الوصول إلى الأعضاء الخاصة
    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 << ")"; // يمكنه قراءة x وy الخاصين
}

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

friend استثناء مقصود ودقيق - فالصنف نفسه يسمّي بالضبط من يثق به، بحيث لا يستطيع أحد أن يمنح نفسه الوصول من الخارج. استخدمه باعتدال؛ فإن وجدت نفسك تضيف الكثير من friends، فالأرجح أن أعضاءك ما كان ينبغي أن تكون private من الأساس، أو أن تصميمك يحتاج إلى إعادة نظر.

أخطاء شائعة يجب تجنّبها

• جعل كل عضو public. يبدو سهلًا، لكنك تخسر كل التحقق والثوابت المنطقية التي يوفرها التغليف. اجعل الافتراضي بيانات private مع دوال public.
• نسيان افتراضي class. class Foo { int x; }; يجعل x خاصًا (private)، لذا لن يُترجم foo.x = 5. إن كنت تقصد حزمة بيانات بسيطة، فاستخدم struct أو أضف وسم public:.
• الإفراط في استخدام protected. فهو حدّ أضعف من private ولا صلة له إلا بالوراثة. واللجوء إليه في كل مكان يربط الأصناف الفرعية بحقول قد تريد تغييرها.
• توقّع أن private ميزة أمنية. إنها قاعدة في وقت الترجمة تمنع الوصول العَرَضي، وليست تشفيرًا. فالبايتات ما زالت في الذاكرة؛ وprivate يتعلق بالتصميم النظيف، لا بالسرّية.

التالي: البُنى (Structs)

رأيت الآن أن struct ليست في الحقيقة إلا class أعضاؤها public افتراضيًا. الصفحة التالية، البُنى، تتعمق في متى يكون هذا الافتراضي - public افتراضيًا - هو بالضبط ما تريد - تجميعات خفيفة لتجميع القيم المترابطة - وكيف تُستخدم struct في C++‎ الاصطلاحي إلى جانب الأصناف الكاملة الميزات.