وظائف الصديق والشكل الصديق C++

في هذا المقال، ستعلم كيفية إنشاء وظائف الصديق وفئات الصديق في C++ وكيفية استخدامها بشكل فعال في البرنامج.

OOPمن المفاهيم الهامة في OOP هي الحجب البياني، وهيوظيفة غير عضولا يمكن الوصول إلى البيانات الخاصة أو المحمية للعنصر.

لكن، في بعض الأحيان قد تتطلب هذه القيود كتابة كود طويل ومعقد. لذلك، يحتوي برمجة C++ على ميكانيكية يمكن من خلالها الوصول إلى البيانات الخاصة أو المحمية من قبل الوظائف غير الأعضاء.

هذا يتم من خلال استخدام وظائف الصديق وفئات الصديق.

وظائف الصديق في C++

إذا تم تعريف الوظيفة كوظيفة صديقة، يمكن استخداموظيفةللوصول إلى البيانات الخاصة والمعزولة للفئة.

من خلال استخدام كلمة المفتاحصديق، يعرف الماكرو الوظيفة المقدمة كوظيفة صديقة.

للوصول إلى البيانات، يجب بيان صديق الوظيفة باستخدام كلمة المفتاح friend في داخل الفئة (يمكن أن يكون في أي مكان داخل الفئة، سواء في الجزء الخاص أو العام).

بيان صديق الوظيفة في C++

فئة  class_name
{
　　　　...  ..  ...
　　　　صديق  نوع_الرجوع  function_name(المستخدم/الرئيسي);
　　　　...  ..  ...
}

الآن، يمكنك تعريف صديق الوظيفة كوظيفة عادية لتحقيق الوصول إلى بيانات الفئة. لم يتم استخدام أي كلمات مفتاحية في تعريف صديق.

فئة  className
{
　　　　...  ..  ...
　　　　صديق  نوع_الرجوع  function_name(المستخدم/الرئيسي);
　　　　...  ..  ...
}
نوع_الرجوع  function_name(المستخدم/الرئيسي)
{
　　　　...  ..  ...
　　　　// يمكن الوصول إلى البيانات الخاصة والمعزولة لـ className من هذا الموقع
　　　　　// لأن هذه الوظيفة هي صديقة للفئة className.
　　　　...  ..  ...
}

مثال 1: كيف تعمل وظيفة الصديق

/*برنامج C ++ يوضح كيف تعمل وظيفة الصديق.*/
#include  <iostream>
using  namespace  std;
class Distance
{
　　　　private:
　　　　　　　　int meter;
　　　　public:
　　　　　　　　Distance(): meter(0) {}
　　　　　　　　//وظيفة الصديق
　　　　　　　　friend int addFive(Distance);
};
//تعريف وظيفة الصديق
int addFive(Distance d)
{
　　　　//وصول إلى بيانات الخصوصية من وظيفة غير عضوية
　　　　d.meter += 5;
　　　　return d.meter;
}
int main()
{
　　　　Distance D;
　　　　cout << "المسافة: " << addFive(D);
　　　　return 0;
}

نتيجة الخرج

المسافة: 5

في هذا المكان،تم إعلان وظيفة الصديق addFive() في فئة Distance. لذلك،يمكن الوصول إلى بيانات الخصوصية من خلال هذه الوظيفة.

على الرغم من أن هذا المثال يقدم لك فكرة عن مفهوم وظيفة الصديق،لكن لم يظهر أي استخدام متميز.

عندما تحتاج إلى التعامل مع أوبجكتين من فئتين مختلفتين،سيكون هناك استخدام أكثر معنى. في تلك اللحظة،ستكون وظيفة الصديق مفيدة جدًا.

يمكنك بالتأكيد التعامل مع أوبجكتين من فئتين مختلفتين دون استخدام وظيفة الصديق، ولكن البرنامج سيكون طويلاً ومتعقيدًا جدًا، وسيكون من الصعب فهمه.

مثال 2: استخدام وظيفة الصديق لضيف عضو من فئتين مختلفتين

#include  <iostream>
using  namespace  std;
//إعلان مقدم
class  B;
class A {
　　　　private:
　　　　　　int numA;
　　　　public:
　　　　　　A(): numA(12) {}
　　　　　　//إعلان وظيفة الصديق
　　　　　　friend int add(A, B);
};
class B {
　　　　private:
　　　　　　　int numB;
　　　　public:
　　　　　　　B(): numB(1) {}
　　　　　　　//إعلان وظيفة الصديق
　　　　　　　friend int add(A, B);
};
//وظيفة add() هي صديقة للفئتين A و B
//وصول إلى متغيرات العQuarter numA و numB
int add(A objectA, B objectB)
{
　　　return (objectA.numA + objectB.numB);
}
int main()
{
　　　　A objectA;
　　　　B objectB;
　　　　cout << "مجموع: " << add(objectA, objectB);
　　　　return 0;
}

نتيجة الخرج

المجموع: 13

في هذا البرنامج،أعلنت الفئات A و B عن add() ك�数ون صديق. لذلك،يمكن لهذه الوظيفة الوصول إلى بيانات الخصوصية الخاصة بكل من هذه الفئتين.

في هذا المكان،�数ون add() تضيف بيانات الخصوصية numA و numB لكل من الأوبجكت objectS والأوبجكت، وتعيد إياها إلى وظيفة main.

لجعل هذا البرنامج يعمل بشكل صحيح، يجب أن يتم إعلان فئة B المسبقًا مثل المثال أعلاه.

هذا لأنه تم استدعاء وظيفة الصديق التالية في فئة A: friend int add (A،B);

فئات الصديق في C ++ البرمجة

مثلًا، مثل وظيفة صديقة، يمكن للفئة أيضًا استخدام كلمة المفتاح friend لتصبح فئة صديقة لفئة أخرى. على سبيل المثال:

...  ..  ...
class  B;
class  A
{
　　　//  class  B  هو فئة صديقة لـ class  A
　　　friend  class  B;
　　　...  ..  ...
}
class  B
{
　　　...  ..  ...
}

عندما تصبح فئة واحدة فئة صديقة لفئة أخرى (فئة صديقة)، هذا يعني أن جميع وظائف هذه الفئة هي وظائف صديقة لفئة أخرى.

في هذا البرنامج، جميع وظائف فئة B هي وظائف صديقة لفئة A، لذا يمكن لكل وظيفة من وظائف فئة B الوصول إلى البيانات الخاصة والمعزولة لفئة A، ولكن لا يمكن لوظائف فئة A الوصول إلى بيانات فئة B.

كيف يمكن لفئات C ++ أن تكون مجاورة لبعضها البعض

كيف يمكن تنفيذ أن تكون classA و B مجاورة لبعضها البعض، أي أن A يمكنها الوصول إلى الخصوصية الخاصة بB، وأن B يمكنها الوصول إلى الخصوصية الخاصة بA؟ مثال كما يلي:

#include  <iostream>
using  namespace  std;
//必须提前声明class  B不然编译会报错
class  B;
class  A{
private:
　　　　int  a;
public:
　　　　friend  class  B;
　　　　A(){
　　　　　　　　cout  <<  "类A被构造"  <<  endl;
　　　　　　　　a  =  20;
　　　　}
　　　　~A(){
　　　　　　　　cout  <<  "类A被析构"  <<  endl;
　　　　}
　　　　void  show(B  &  b);
};
class  B{
private:
　　　　int  b;
public:
　　　　friend  class  A;
　　　　B(){
　　　　　　　　cout  <<  "类B的构造"  <<  endl;
　　　　　　　　b  =  12;
　　　　}
　　　　~B(){
　　　　　　　　cout  <<  "类B被析构"  <<  endl;
　　　　}
　　　　void  show(A  &a){
　　　　　　　　cout  <<  "a="<<a.a  ;
　　　　　　　　cout  <<  "  b="  <<b<<endl;
　　　　}
};
//函数不能放在class  A  中，不然会编译报错
void  A::show(B  &b){
　　　　cout  <<  "a="<<a  ;
　　　　cout  <<  "  b="<<b.b<<  endl;
}
int  main(){
　　　　A  a;
　　　　B  b;
　　　　a.show(b);
　　　　b.show(a);
　　　　return 0;
}

تم بناء فئة A
تم بناء فئة B
a=20 b=12
a=20 b=12
فئة B يتم تدميرها
فئة A يتم تدميرها

الطريقة التي يتم بها أن تكون الفئتين صديقتين هي، في فئة A يتم إعلان friend class B; في فئة B يتم إعلان friend class A;

ملاحظة:يجب أن تكون الأماكن التي تستخدم فئة A من فئة B بعد تعريف فئة B، وأن يتم تعريفها فقط في فئة A. على سبيل المثال، الوظيفة show في فئة A على اليسار، لا يمكن تعريفها مباشرة في فئة A، بل يجب وضعها بعد تعريف فئة B.