أصناف ++C: تعريف الكائنات والأعضاء والدوال

ما هو الصنف

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

لقد استخدمت الأصناف بالفعل دون أن تعرّف أيًّا منها: فـ std::string وstd::vector هما صنفان من المكتبة القياسية. واستدعاء name.length() أو v.push_back(3) هو استدعاء دالة عضو على كائن. والآن ستبني أنواعك الخاصة بالطريقة نفسها، ثم تنتقل إلى المُنشئات لتهيئتها.

تعريف صنف وإنشاء كائنات

يَسرد تعريف الصنف أعضاءه بين قوسين معقوفين وينتهي بفاصلة منقوطة - ونسيان تلك ; الختامية من أكثر أخطاء المبتدئين شيوعًا. وكل كائن تنشئه من الصنف يحصل على نسخته الخاصة من المتغيرات الأعضاء.

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

class Dog {
public:
    string name;   // متغير عضو
    int age;       // متغير عضو

    void bark() {  // دالة عضو
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog rex;            // إنشاء كائن (نسخة)
    rex.name = "Rex";   // تعيين الأعضاء بالمعامل .
    rex.age = 4;

    Dog luna;           // كائن ثانٍ مستقل
    luna.name = "Luna";

    rex.bark();
    luna.bark();
    return 0;
}

rex وluna كائنان منفصلان. وتغيير rex.name لا يمس luna.name - فكل كائن يحتفظ ببياناته الخاصة. تصل إلى عضوٍ ما باستخدام معامل النقطة . على كائن (أو -> عندما يكون لديك مؤشر إليه).

public مقابل private

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

#include <iostream>
using namespace std;

class Counter {
private:
    int count = 0;            // مخفي - لا يستطيع الخارج لمسه

public:
    void increment() {        // الواجهة الآمنة
        count++;
    }
    int value() const {       // const: هذه الدالة لن تعدّل الكائن
        return count;
    }
};

int main() {
    Counter c;
    c.increment();
    c.increment();
    cout << "Count: " << c.value() << endl;

    // c.count = 100;   // خطأ: 'count' هو private
    return 0;
}

لأن count هو private، لا يستطيع أي مستدعٍ تمرير قيمة سالبة أو غير منطقية خِلسةً - بل عليه المرور عبر increment(). وكلمة const بعد قائمة معاملات value() تَعِد بأن الدالة لن تعدّل الكائن، مما يتيح استدعاءها على كائنات const ويوضّح النية لمن يقرأ الشيفرة. راجع محددات الوصول للقصة الكاملة حول public وprivate وprotected.

الإعلان مقابل التعريف للدوال

في الأصناف الصغيرة، تعريف الدوال ضمن الصنف مباشرةً (كما سبق) أمر جيد. أما في الأصناف الأكبر، فمن الشائع الإعلان عن الدوال داخل الصنف وتعريف أجسامها خارجه باستخدام صياغة النطاق ClassName::method. وهذا يُبقي تعريف الصنف سهل القراءة كملخّص للواجهة.

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

class Rectangle {
public:
    double width;
    double height;

    double area() const;        // إعلان فقط
    void describe() const;      // إعلان فقط
};

// التعريفات تكون خارج الصنف، مؤهَّلة بـ Rectangle::
double Rectangle::area() const {
    return width * height;
}

void Rectangle::describe() const {
    cout << width << " x " << height
         << " = " << area() << endl;   // يمكن استدعاء أعضاء أخرى مباشرةً
}

int main() {
    Rectangle r;
    r.width = 3.0;
    r.height = 4.0;
    r.describe();
    return 0;
}

تُخبر البادئة Rectangle:: المترجمَ بالصنف الذي تنتمي إليه الدالة. وداخل تعريف كهذا تظل تشير إلى الأعضاء بأسمائها المجرّدة (width، area()) - فالمترجم يعرف أنها تنتمي إلى الكائن الذي استُدعيت عليه الدالة.

مؤشر this

داخل أي دالة عضو غير ساكنة، يكون this مؤشرًا إلى الكائن الذي استُدعيت عليه الدالة. وعادةً لا تحتاجه، لأن اسم العضو المجرّد يشير أصلًا إلى الكائن الحالي. ويثبت فائدته عندما يحجب معامِلٌ عضوًا (shadow) - إذ يتشاركان الاسم نفسه - فيلزمك إزالة الالتباس.

#include <iostream>
using namespace std;

class Point {
public:
    int x = 0;
    int y = 0;

    void setX(int x) {     // المعامل 'x' يحجب العضو 'x'
        this->x = x;       // this->x هو العضو؛ و x هو المعامل
    }

    void print() const {
        cout << "(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Point p;
    p.setX(7);
    p.print();
    return 0;
}

من دون this->، فإن كتابة x = x; داخل setX تُسنِد المعامل إلى نفسه وتترك العضو دون مساس - وهو خطأ صامت. وتجعلها this->x لا لبس فيها. كثير من قواعد الشيفرة تتجنب المشكلة تمامًا بتسمية المعاملات تسميةً مختلفة (مثل setX(int newX))، لكنك سترى this-> باستمرار في الشيفرة الحقيقية.

أخطاء شائعة

حفنة من مزالق الأصناف توقع الناس مرارًا وتكرارًا:

• نسيان الفاصلة المنقوطة الختامية. ينتهي تعريف الصنف بـ };. وإذا أسقطت ; فستحصل على سيل من الأخطاء المربكة التي تشير إلى ما يأتي بعد الصنف، لا إلى الصنف نفسه.
• نسيان تهيئة الأعضاء. الأعضاء من الأنواع المدمجة مثل int وdouble لا تُصفَّر تلقائيًا. وقراءة عضو غير مهيأ سلوك غير معرّف. أعطِ الأعضاء قيمًا افتراضية (int count = 0;) أو هيّئها في مُنشئ.
• الوصول إلى أعضاء private من الخارج. c.count = 5; على عضو private هو خطأ ترجمة - مُرَّ عبر دالة عامة بدلًا من ذلك. وهذا هو التغليف يعمل كما هو مقصود.
• الخلط بين الصنف والكائن. Dog.bark(); خطأ - فـ Dog هو النوع. أنت تستدعي الدوال على الكائنات: rex.bark();.

// عضو غير مهيأ - قراءة 'age' سلوك غير معرّف:
class Cat {
public:
    int age;            // لا قيمة افتراضية
};

Cat c;
std::cout << c.age;     // قيمة عشوائية لا قيمتها 0

التالي: المُنشئات

تعيين كل عضو يدويًا بعد إنشاء الكائن - rex.name = ...; rex.age = ...; - أمر مُمِل وسهل النسيان، وهذا بالضبط ما يقودك إلى أعضاء غير مهيأة. تتناول الصفحة التالية المُنشئات: دوال خاصة تُنفَّذ تلقائيًا عند إنشاء الكائن، تتيح لك ضمان أن يبدأ كل كائن في حالة صالحة بصياغة نظيفة من سطر واحد Dog rex("Rex", 4);.