البرمجة عرضية التوجه Object-Oriented Programming

**lovely_roro** · 01-05-2009, 07:16 PM

يسرني أن أقدم لكم هذه الدورة الطويلة بعض الشيء ، سيتم فيها بإذن الله شرح لما هي البرمجة غرضية التوجه
أو ما يعرف بـ OOP ، وسيتم بإذن الله تعالى شرح لمواضيع عديدة ومتفرقة في هذا المجال ،
من تلك الدروس التي سندرسها :

** مقدمة عامة تشمل المفاهيم الأساسية ومزايا البرمجة الشيئية .

** مستويات الحماية وإنشاء الأصناف واستدعاء الأعضاء ( البيانات والدوال ).

** مؤثر دقة الوصول ( :: ) Scope Resolution Operator

** دوال البناء والهدم .

** المؤشر الحسابي & الحجز الديناميكي للذاكرة باستخدام new & delete

** الكائنات والدوال الثابتة constant objects & constant Functions

** المؤشر

** الأعضاء الساكنة static datda member

** الدوال الصديقة friend functions

** الأصناف الصديقة Friend Classes

** الدوال الخطية Inline Functions.

** التحميل الزائد للدوال Function Overloading

** التحميل الزائد للمؤثرات Operator Overloading

** التحويل بين الأنواع Converting between types

** الوراثة

**lovely_roro** · 01-05-2009, 07:24 PM

البرنامج أو المترجم الذي سنعمل عليه هو Dev - c++ أنقر هنا لزيارة الصفحة الرئيسية للمترجم .
ولتحميل البرنامج مباشرة .::

** معنى البرمجة الشيئية :: oop

هي عبارة عن أسلوب جديد من أساليب البرمجة حيث أصبحت وحدة بناء البرنامج هي الصنف class والذي يحوي على البيانات data

والعمليات ( الدوال ) functions .
ولها عدة مسميات منها ..::
1- البرمجة غرضية التوجة .
2- البرمجة الكائنية الموجهة .

* أسلوب البرمجة الشيئية :.

عادة ما تكون البرامج من هذا الأسلوب معقدة بشكل كبير حيث تقسيم البرنامج إلى مجموعة من المهام الرئيسية ومن ثم تقسم إلى مهام فرعية على حسب درجة

التعقيد للمهام الرئيسية لذلك فان البرمجة الهيكلية تنتهج النهج ( من الأعلى إلى الأسفل ) Top Down .

* عيوب هذا الأسلوب : البرمجة الهيكلية .::
1- صعوبة فصل البيانات على العمليات .
2- إعادة إنشاء الحلول وعدة إعادة استخدامها .

* المفاهيم الأساسية للبرمجة الشيئية :.

1- الكائن Object :

عبارة عن وحدة تحوي مجموعة من البيانات تسمي ( خصائص ) properties أو صفات ومعرفة عليها مجموعة من العمليات .
مثال .:: كائن السيارة .:

الخصائص :
Model :Ferrari
Color : Blue
Year : 2005

العمليات ::.
Start ' الانطلاق '
Stop ' التوقف '
Accelerate 'التسارع'

2- الصنف Class : الكائنات ذات الخصائص والأفعال المشتركة بحاجة لآن تجمع مع بعضها البعض حتى يمكن استخدامها في

برنامج ما.
وبالتالي فإن الصنف : عبارة عن مجموعة من الكائنات التي تشترك في الخصائص والعمليات ..
مثلاً ..::
الطالب كائن >> الطلاب صنف .
الموظف كائن >> الموظفين صنف .

* مزايا البرمجة الشيئية :. Features of (opp)

1- التجريدabstraction : وهو عملية تحديد الخصائص والعمليات التي تنتمي لصنف معين وهي نوعان .::

أ- تجريد البيانات Data abstraction : وهي عملية التعرف على الخصائص المرتبطة بكائن معين .
ب- تجريد العمليات Methods abstraction: وهو عملية تحديد العمليات والإجراءات دون ذكر شيء عن كيفية أدائها .

2- التغليف ( الكبسلة )Encapsulation : هي عملية تجميع كل الخصائص properties والطرق ( العمليات ) Methods في وحدة واحدة (

داخل غلاف واحد ) حيث لا يمكن الوصول إليها ( أي الخصائص والطرق ) إلا عن طريق الكائن .

3- إخفاء البيانات Data Hiding:. وهي ميزة ناتجة عن كبسلة البيانات وتعني إضافة مستوى حماية معين على البيانات حتى نمنع

وصول الخطأ إليها .

4- الوراثة Inhertance:. وهي أن يرث صنف ما الخصائص والعمليات الموجودة في الصنف الآخر مما يساعد على إعادة الاستخدام

للأصناف التي تم إنشاؤها من قبل المستخدم . .

** أمثلة لبعض الأصناف المشتقة والأساسية في الوراثة :..

5- تعدد الأشكال ( الأوجه ) polymorfisme: تسمح ميزة تعدد الأشكال لنفس الدالة أن تتعرف بصورة مختلفة في أصناف مختلفة .
ويمكن عمل ذلك بـ الوراثة مع تعدد الأشكال .
واللغات التي تدعم أسلوب البرمجة الشيئية كثيرة نذكر منها ..
C++ و java و C# و vb.net

**lovely_roro** · 01-05-2009, 07:35 PM

الدرس الثاني :..

** مستويات الحماية ( محددات الوصول للعضو ) .:
هي عملية تحديد مدى التعامل مع الأعضاء ( البيانات والعمليات ) . هل هذه الأعضاء خاصة بالصنف المعرفة فيه ، أم يمكن استخدام نطاق الصنف وهي ثلاث

مستويات .::
1- مستوى الحماية الخاص private :
وفيه يتم تعريف الأعضاء التي يتم استخدامها في الصنف ، ولا يمكن الوصول إليها من خارج الصنف .
2- مستوى الحماية المحمي protected :
الأعضاء المعرفة في هذا المستوى تشبه الأعضاء الخاصة غير أنه يمكن توريثها إلى أي صنف آخر .
3- مستوى الحماية العام Public :
وفيه يتم تعريف الأعضاء العامة التي يمكن الوصول إليها من خارج الصنف .

* ملاحظات :.
1- دائماً تتبع محددات الوصول للعضو بنقطتين ( : ) مثلاً

اقتباس:

Private:

2- يمكن أن تظهر عدة مرات وبأي ترتيب في تعريف الصنف .
3- يتم إعادة تعريف البيانات الأعضاء في مستوى الحماية الخاص Private لأن من مبادئ البرمجة الشيئية " إخفاء البيانات " .
4- يتم إعادة تعريف الدوال الأعضاء في مستوى الحماية العام لآن هذه الدوال يتم استدعاؤها من خلال البرنامج الرئيسي .
5- من الممكن أن يكون لدينا بيانات عامة وعمليات خاصة غير أن هذا الاستخدام غير شائع .

**lovely_roro** · 01-05-2009, 07:57 PM

** الأصناف Classes :

تعريف الصنف : هو عبارة عن وحدة تحوي مجموعة من البيانات ( الخاصة والعامة )بالإضافة إلى تعريف

الدوال ( العمليات ) حيث يطلق على الدوال المعرفة داخل الصنف بـ " أعضاء دالية " member Function .

* الإعلان عن الصنف :

أمثلة :.
مثال 1: مثال على صنف الوقت .::

كود PHP:

  class Time 

{ 

private: 

int hor ,minute ,second; 

public: 

void settime(int,int,int); 

void printstandard (); 

void printmilitary(); 

};

مثال 2 : مثال على صنف المستطيل :.

كود PHP:

  class rectangle 

{ 

int x,y; 

public: 

void set_value(int,int); 

int area(); 

};

بمجرد تعريف الصنف يمكن استخدامه كنوع جديد حيث يطلق عليه ( نوع معرّف من قبل المستخدم).

** تعريف الكائنات .::

يتم تعريف الكائنات في البرنامج الرئيسي وفقاً للصيغة التالية :

كود PHP:

  class_name object_name

حيث :
class_name : اسم الصنف ( نفس اسم الصنف الذي كتبناه في بداية البرنامج )
object_name : اسم الكائن ، وهو اختياري ، يستخدم للوصول لعناصر الصنف .

مثال.::

اقتباس:

rectangle rect;

حيث rectangle اسم الصنف ، و rect اسم الكائن .

وإذا أردنا أن نعرف أكثر من كائن بنفس الوقت ، نفس العملية السابقة ، فقط نفصل بين كل كائن والآخر باشارة الفاصلة ( , ) . والمثال التالي يوضح ما سبق .::

اقتباس:

rectangle rect1,rect2,rect3;

** استدعاء الأعضاء :.

أعضاء الصنف لا يمكن أن نصل إليها من خارج الصنف إلا عن طريق الكائنات ويتم ذلك بالصيغة التالية :

اقتباس:

Object_name.member

حيث .::
Object_name : اسم الكائن .
member : اسم العضو الذي نريد الوصول إليه .
مثال : إذا أردنا الوصول للدالة area() باستخدام الكائن rect نكتب الآتي :

اقتباس:

rect1.area()

البرنامج الأول : نقوم بكتابة برنامج يقوم بحساب مساحة المستطيل ( باستخدام الأصناف ) ..

كود PHP:

   

#include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class rectangle 

{ 

int x ,y; 

public : 

void set_value(int a,int b) 

{ 

x=a; 

y=b; 

} 

 

int area() 

{ 

return x*y; 

} 

}; 

main() 

{ 

rectangle rect1,rect2; 

rect1.set_value(3,4); 

rect2.set_value(5,6); 

cout<<"Rect1 Area = "<<rect1.area()<<endl; 

cout<<"Rect2 Area = "<<rect2.area()<<endl; 

system("PAUSE"); 

 

}

شرح للبرنامج :.
في البداية عرفنا متغيرات خاصة Private وهما x ,y وهنا ملاحظة وهي طالما أننا عرفنا ذلك في بداية الصنف ولم نحدد مستوى

الحماية فإن مستوى الحماية الإفتراضي هو Private .
بعد ذلك أنشأنا دالة باسم set_value بوسيطين في مستوى الحماية العام Public وظيفة هذه

الدالة هي مساواة القيم التي يحددها المستخدم بالمتغيرات الخاصة ، أو بمعنى أخر وظيفتها الوصول للمتغيرات الخاصة x,y .
بعد ذلك أنشأنا دالة area() وظيفتها إرجاع مساحة المستطيل وهي عملية حسابية
الطول × العرض .
ثم في الدالة الرئيسية main() قمنا في البداية في باشتقاق كائنين rect1 و

rect2 بعد ذلك قمنا باستدعاء دالة set_value وحددنا قيم الوسائط ..
ثم بعد ذلك استدعينا دالة حساب المساحة area() لكل من الكائنين rect1 ,

rect2 .

** البرنامج الثاني : برنامج يقوم بحساب مساحة ومحيط الدائرة ( مستخدماً الأصناف ) .::

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class circle 

{ 

private : 

int r; 

float area1,c; 

public : 

void get_r() 

{ 

cout<<"Enter radius \n"; 

cin>>r; 

} 

void area() 

{ 

area1=r*r*3.14; 

} 

void cir() 

{ 

c=2*r*3.14; 

} 

void display () 

{ 

cout<<area1<<endl; 

cout<<c<<endl; 

} 

}; 

main() 

{ 

circle c; 

c.get_r(); 

c.area(); 

c.cir(); 

c.display(); 

system("PAUSE"); 

 

}

نفس المثال السابق تقريباً من حيث الفكرة حيث :..
r = نصف القطر . area1=المساحة. c = المحيط .
cir = دالة ايجاد المحيط . display= طباعة المساحة والمحيط . area= المساحة .

**lovely_roro** · 01-05-2009, 08:06 PM

مؤثر دقة الوصول Scope Resolution Operator

عبارة عن مؤثر يستخدم عندما تكتب تفاصيل الدالة العضو خارج الصنف .
** الصيغة العامة للدالة التي تكتب خارج الصنف هي :

كود PHP:

  DataType ClassName::FunctionName (Function Arguments )

** دوال البناء والهدم ::

أولا: دوال البناء Constructor Function .:::

هي عبارة عن دالة تحمل نفس اسم الصنف ويتم استدعاؤها مباشرة عند اشتقاق كائن من الصنف وتستخدم غالباً لإعطاء خصائص (

متغيرات ) الصنف قيم ابتدائية .

- ملاحظات :

1- لا يمكن تهيئة البيانات العضو أثناء التعريف .
2- لا يوجد مردود ( return ) لدوال البناء .
3- يمكن أن يحوي الصنف أكثر من دالة بناء ( التحميل الزائد للدوال ).

** مثال توضيحي لمؤثر دقة الوصول ودوال البناء .:

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

//انشاء صنف باسم MYCLASS 

class myclass 

{ 

int a; 

public: 

myclass(); 

void show(); 

}; 

myclass::myclass() 

{ 

cout<<"Constructor Function \n"; 

a=10; 

} 

void myclass::show() 

{ 

cout<<"a="<<a<<"\n"; 

} 

int main() 

{ 

myclass ob; 

ob.show(); 

 

system("PAUSE"); 

return 0; 

}

والان شرح بسيط لاهم ما ورد في الكودالسابق :

كود PHP:

  myclass();

**lovely_roro** · 01-05-2009, 08:15 PM

[U** المؤشر الحسابي :[/U]

عند الحديث عن مؤشر الكائن يظهر مفهوم جديد وهو المؤشر الحسابي ونقصد به : أن مؤشر الكائن ربّما يخضع لبعض العمليات مثل :
1- ( ++ ) وتعني زيادة قيمة المؤشر Increment وتستخدم لجعل المؤشر يشير إلى الموقع التالي..
2- ( -- ) وتعني إنقاص المؤشر Decrement وتستخدم لجعل المؤشر يشير إلى الموقع السابق .
مثال :

كود PHP:

  #include <iostream> 

#include <cstdlib> 

using namespace std ; 

class samp 

{ 

int a, b; 

public: 

samp(int m,int n) 

{ 

a=n; 

b=m; 

} 

int get_a() 

{ 

return a; 

} 

int get_b() 

{ 

return b; 

} 

}; 

int main() 

{ 

samp ob[4]={samp(1,2),samp(3,4),samp(5,6),samp(7,8)} ; 

samp *x; 

x=&ob[0]; 

for (int i=0;i<4;i++) 

{ 

cout<<x -> get_a()<<"\t"<<x -> get_b()<<"\n"; 

x++; 

} 

system("PAUSE"); 

return 0; 

}

في هذا المثال لدينا مصفوفة من الكائنات كما يظهر في الكود :

كود PHP:

  samp ob[4]={samp(1,2),samp(3,4),samp(5,6),samp(7,8)} ;

ولدينا المؤشر للعنصر الأول :

كود PHP:

  samp *x; 

x=&ob[0];

اذا فنحن نستطيع التنقل الى الكائنات الأخرى من خلال Pointer Arithmatic وهو في حالتنا هذه x++ أي أذهب الى الكائن الأخر في المصفوفه وهكذا إلى ان يصل للكائن

الأخير وستكون المخرجات بالشكل التالي :..

1 2
3 4
5 6
7 8

( المثال من تعديل وتوضيح استاذنا الفاضل romansy )

الحجز الديناميكي للذاكرة باستخدام new & delete :

في لغة c++ نستخدم المؤشر new لحجز الذاكرة الديناميكية و delete لإلغائها .
- الصيغة العامة لحجز ذاكرة وإلغائها لكائن واحد هي :.

كود PHP:

  p-var=new type; 

delete p-var;

أما في حالة عدة مواقع فإننا نستخدم الصيغة التالية :.

كود PHP:

  p-var = new type[size]; 

delete[] p-var;

حيث Type تحدد النوع ( اسم الصنف ) ، وP-Var مؤشر النوع .

مثال على حجز موقع واحد وإلغائه .:::( لابد أن تكون مطلع على موضوع المؤشرات والمراجع )

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class samp 

{ 

int i ,j; 

public: 

void set_ij(int a , int b) 

{ 

i=a; 

j=b; 

} 

int get_product() 

{ 

return i*j; 

} 

}; 

int main() 

{ 

samp *p; 

p= new samp; 

p -> set_ij(4,5); 

cout<<p -> get_product()<<"\n"; 

delete p; 

 

system("PAUSE"); 

return 0; 

}

كما هو الواضح مثال يقوم بطباعة حاصل ضرب عددين باستخدام الدالة get_Product() ، حيث تم حجز موقع واحد فقط في الذاكرة . أما عن حجز عدة مواقع فنقوم بتعديل

طفيف على المثال السابق بحيث يظهر كما في الشكل التالي:

كود PHP:

  #include <iostream.h> 

#include <stdlib.h> 

class samp 

{ 

int i ,j; 

public: 

void set_ij(int a , int b) 

{ 

i=a; 

j=b; 

} 

int get_product() 

{ 

return i*j; 

} 

}; 

int main() 

{ 

samp *p; 

int n; 

cin>>n; 

p=new samp[n]; 

for ( int i=0;i<n;i++) 

{ 

p -> set_ij(i,i); 

cout<<p -> get_product()<<"\n"; 

} 

delete []p; 

 

system("PAUSE"); 

return 0; 

}

وهذاالمثال كما ذكرت نفس المثال السابق ولكن لعدة مواقع بحيث في البداية يتم ادخال رقم ( مثلاُ 7 ) ومن يقوم بطباعة حاصل ضرب الأعداد في نفسها من 1 إلى 6 ( 1*1 ،

2*2 ، ... ، 6*6) وتظهر المخرجات كما في الشكل التالي:

الاعلان عن دالة بناء ( لان اسمها من اسم الصنف ) ولاحظ اننا وضعنا في نهاية تعريف الدالة فاصلة منقوطة ( ; ) وهذه

نضعها في حال لم نريد كتابة تفاصيل الدالة داخل الصنف

.

كود PHP:

  myclass::myclass()

لاحظ اننا كتبنا هذا الكود بعد اقفال الكلاس .
لكتابة تفاصيل الدالة خارج الصنف نستخدم هذه الطريقة بحيث في البداية كتبنا اسم الصنف myclass ومن ثم مؤثر دقة الوصول وهو (

:: ) ومن ثم اسم الدالة myclass().(لاحظ هنا اننا نتحدث عن دالة البناء ، ودالة البناء ليس لها DataType عكس دالة

show التي سترد الان ) .

كود PHP:

  void myclass::show()

لاحظ هنا في البداية نكتب نوع الدالة DataType وهو Void الموجود في دالة show ، ومن ثم

اسم الصنف ومؤثر دقة الوصول واسم الدالة ( كما في الدالة السابقة)

**lovely_roro** · 01-05-2009, 10:01 PM

** دالة الهدمDestructor Function

هي عبارة عن دالة عضو في الصنف ، ويتشكل اسمها من المحرف ( ~ ) مضافاً إليه اسم الصنف . وتستخدم

لإنهاء الأعمال الداخلية للكائنات حتى يستطيع النظام استعادة الذاكرة لحفظ كائنات جديدة .

ملاحظات على دالة الهدم :

1- ليس لها وسائط ، ولا ترجع فيمة .
2- يمكن للصنف أن يحتوي على دالة هدم واحدة فقط .
3- لا يمكن تحميل دالة الهدم بشكل زائد.

** استخدام الوساط ( التلقائية ) الإفتراضية مع دالة :

يمكن أن يستخدم أي نوع أو أي عدد من المعاملات ( الوسائط) داخل دالة البناء ، في هذه الحالة يتم استدعاء دالة البناء للكائنات ذات المعاملات التي تتناسب مع عدد

المعاملات الموجودة داخل دالة البناء .

مثال .:

كود PHP:

   
#include <iostream.h> 
#include <cstdlib> 
using namespace std ; 
class myclass 
{ 
private: 
int x,y; 
public: 
myclass() 
{ 
x=y=1; 
} 
myclass(int a ,int b) 
{ 
x=a; 
y=b; 
} 
void display() 
{ 
cout<<"x="<<x<<endl; 
cout<<"y="<<y<<endl; 
} 
}; 
 
int main() 
{ 
int n,m; 
cin>>n>>m; 
myclass ob1; 
ob1.display(); 
myclass ob2(n,m); 
ob2.display(); 
system("PAUSE"); 
return 0; 
}

توضيح بسيط لأهم ما ورد في هذا الكود :

في البداية يطلب البرنامج من المستخدم ادخال عددين ليسجلهما في المتغيرين m,n

..
و عند اشتقاق الكائن الأول وهو ob1 كما يظهر هنا ::.

.

كود PHP:

  myclass ob1;

فإنه يتم مباشرة استدعاء التعليمات المكتوبة داخل دالة البناء myclass وهي ::.

كود PHP:

  myclass()
{
x=y=1;
}

أي يجعل قيمة x و y تساوي العدد ( 1 ) .

ومن ثم استدعاء دالة الطباعة للكائن ob1 كما في هذا الشكل :.[/FON

T]

كود PHP:

  ob1.display();

]بعد ذلك تم اشتقاق كائن اخر من الصنف myclass باسم ob2 وله

وسيطتين وهما العددين الذين ادخلهما المستخدم في بداية البرنامج .::[/FONT]

كود PHP:

  [right]myclass ob2(n,m);
ob2.display();
[/right]

ليتم بعدها طباعة العددين m,n من خلال دالة الطباعة

display()[/FONT]

** متى تستدعى دوال البناء والهدم ؟!

1- يعتمد الترتيب الذي يستدعى به هذه الدوال على ترتيب الذي يدخل فيه التنفيذ أو يخرج من المجال الذي عرفت فيه الكائنات .
2- بشكل عام . يتم استدعاء دوال الهدم بترتيب معاكس لدوال البناء غير أنه يمكن أن يتغير هذا الترتيب في بعض الحالات ( ستذكر في

السياق :smailes100: )
3- تستدعى دوال البناء للكائنات المعرفة في المجال العام وقبل تنفيذ أي دالة بما فيها الدالة Main() .
4- تستدعى دوال الهدم المقابلة عندما تنتهي الدالة main().
5- تستدعى دوال البناء للكائنات المحلية التلقائية عندما يصل التنفيذ إلى النقطه التي عرفت فيها الكائنات .
6- تستدعى دوال الهدم المقابلة عندما تغادر الكائنات المجال الذي عرفت فيه .
7- تستدعى دوال البناء للكائنات المحلية الساكنة عندما يصل التنفيذ إلى النقطة التي عرّفت فيها الكائنات وتستدعى دوال الهدم المقابلة عند

انتهاء الدالة Main() .

** برنامج يوضح لك النقاط السابقة حتى تتضح الرؤية حول كيفية الاستدعاء :smailes94:

كود PHP:

   
#include <iostream.h> 
#include <cstdlib> 
using namespace std ; 
class createAndDestroy 
{ 
private: 
int data; 
public: 
createAndDestroy (int); 
~createAndDestroy(); 
}; 
createAndDestroy::createAndDestroy(int value) 
{ 
data=value; 
cout<<"object "<<data<<" Constructor \t"; 
} 
createAndDestroy::~createAndDestroy() 
{ 
cout<<"object"<<data<<"destructor"<<endl; 
system("PAUSE"); 
} 
void create(); 
createAndDestroy first(1); 
 
 
int main() 
{ 
cout<<"global object before main"<<endl; 
createAndDestroy second(2); 
cout<<"Local Automatic in main"<<endl; 
static createAndDestroy third(3); 
cout<<"Local Static in main"<<endl; 
create(); 
createAndDestroy fourth(4); 
cout<<"Local Aotumatic in main"<<endl; 
 
system("PAUSE"); 
return 0; 
} 
 
void create() 
{ 
createAndDestroy fifth(5); 
cout<<"Local Aotumatic in Create \n"; 
static createAndDestroy sixth(6); 
cout<<"Local Static in create \n"; 
createAndDestroy seventh(7); 
cout<<"Local Automatic in Create \n"; 
system ("PAUSE"); 
}

وهذا هو شكل المخرجات :

توضيح بسيط للبرنامج :.

في البداية يقوم بتنفيد دوال البناء لكل من ( 1 ، 2 ، 3 ) بعدها يقفز للأسفل لقراءة تفاصيل الدالة Create();فيقرأ كل من ( 5 ، 6 ، 7 )
وبعدها بعملية عكسية يتم الهدم "مثل ما ذكر سابقاً" فيتم الهدم لكل من ( 7 )
وبعدها لا يحدف (6) لانه ساكن Static فينتقل للتي بعدها وهي ( 5) فيتم هدمها وبعد ذلك يعود للبرنامج الرئيسي فيقوم بتنفيذ ( 4 ) ومن بعدها تنتهي الدالة Main() فيقوم

البرنامج بالهدم بعملية عكسية أيضاً فيهدم ( 4 ) ومن ثم ( 2) " 3 لا يهدم لانه ساكن حاله حال 6 " ومن بعدها يهدم الدالة 2 ..
الان يهدم وبعد الانتهاء من هدم الدوال العامة يعود لهدم الدوال الساكنة فيهدم ( 6 ) ومن بعدها يهدم الدالة رقم ( 3 ) .. وفي الأخير يتم هدم الدوال العامة ولا يوجد لدينا الا

دالة واحده وهي ( 1 ) .

**lovely_roro** · 01-05-2009, 10:03 PM

** دالة الهدمDestructor Function

هي عبارة عن دالة عضو في الصنف ، ويتشكل اسمها من المحرف ( ~ ) مضافاً إليه اسم الصنف . وتستخدم

لإنهاء الأعمال الداخلية للكائنات حتى يستطيع النظام استعادة الذاكرة لحفظ كائنات جديدة .

ملاحظات على دالة الهدم :

1- ليس لها وسائط ، ولا ترجع فيمة .
2- يمكن للصنف أن يحتوي على دالة هدم واحدة فقط .
3- لا يمكن تحميل دالة الهدم بشكل زائد.

** استخدام الوساط ( التلقائية ) الإفتراضية مع دالة :

يمكن أن يستخدم أي نوع أو أي عدد من المعاملات ( الوسائط) داخل دالة البناء ، في هذه الحالة يتم استدعاء دالة البناء للكائنات ذات المعاملات التي تتناسب مع عدد

المعاملات الموجودة داخل دالة البناء .

مثال .:

كود PHP:

   

#include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class myclass 

{ 

private: 

int x,y; 

public: 

myclass() 

{ 

x=y=1; 

} 

myclass(int a ,int b) 

{ 

x=a; 

y=b; 

} 

void display() 

{ 

cout<<"x="<<x<<endl; 

cout<<"y="<<y<<endl; 

} 

}; 

 

int main() 

{ 

int n,m; 

cin>>n>>m; 

myclass ob1; 

ob1.display(); 

myclass ob2(n,m); 

ob2.display(); 

system("PAUSE"); 

return 0; 

}

توضيح بسيط لأهم ما ورد في هذا الكود :

في البداية يطلب البرنامج من المستخدم ادخال عددين ليسجلهما في المتغيرين m,n

..
و عند اشتقاق الكائن الأول وهو ob1 كما يظهر هنا ::.

.

كود PHP:

  myclass ob1;

فإنه يتم مباشرة استدعاء التعليمات المكتوبة داخل دالة البناء myclass وهي ::.

كود PHP:

  myclass()

{

x=y=1;

}

أي يجعل قيمة x و y تساوي العدد ( 1 ) .

ومن ثم استدعاء دالة الطباعة للكائن ob1 كما في هذا الشكل :.[/FON

T]

كود PHP:

  ob1.display();

]بعد ذلك تم اشتقاق كائن اخر من الصنف myclass باسم ob2 وله

وسيطتين وهما العددين الذين ادخلهما المستخدم في بداية البرنامج .::[/FONT]

كود PHP:

  [right]myclass ob2(n,m);

ob2.display();

[/right]

ليتم بعدها طباعة العددين m,n من خلال دالة الطباعة

display()[/FONT]

** متى تستدعى دوال البناء والهدم ؟!

1- يعتمد الترتيب الذي يستدعى به هذه الدوال على ترتيب الذي يدخل فيه التنفيذ أو يخرج من المجال الذي عرفت فيه الكائنات .
2- بشكل عام . يتم استدعاء دوال الهدم بترتيب معاكس لدوال البناء غير أنه يمكن أن يتغير هذا الترتيب في بعض الحالات ( ستذكر في

السياق :smailes100: )
3- تستدعى دوال البناء للكائنات المعرفة في المجال العام وقبل تنفيذ أي دالة بما فيها الدالة Main() .
4- تستدعى دوال الهدم المقابلة عندما تنتهي الدالة main().
5- تستدعى دوال البناء للكائنات المحلية التلقائية عندما يصل التنفيذ إلى النقطه التي عرفت فيها الكائنات .
6- تستدعى دوال الهدم المقابلة عندما تغادر الكائنات المجال الذي عرفت فيه .
7- تستدعى دوال البناء للكائنات المحلية الساكنة عندما يصل التنفيذ إلى النقطة التي عرّفت فيها الكائنات وتستدعى دوال الهدم المقابلة عند

انتهاء الدالة Main() .

** برنامج يوضح لك النقاط السابقة حتى تتضح الرؤية حول كيفية الاستدعاء :smailes94:

كود PHP:

   

#include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class createAndDestroy 

{ 

private: 

int data; 

public: 

createAndDestroy (int); 

~createAndDestroy(); 

}; 

createAndDestroy::createAndDestroy(int value) 

{ 

data=value; 

cout<<"object "<<data<<" Constructor \t"; 

} 

createAndDestroy::~createAndDestroy() 

{ 

cout<<"object"<<data<<"destructor"<<endl; 

system("PAUSE"); 

} 

void create(); 

createAndDestroy first(1); 

 

 

int main() 

{ 

cout<<"global object before main"<<endl; 

createAndDestroy second(2); 

cout<<"Local Automatic in main"<<endl; 

static createAndDestroy third(3); 

cout<<"Local Static in main"<<endl; 

create(); 

createAndDestroy fourth(4); 

cout<<"Local Aotumatic in main"<<endl; 

 

system("PAUSE"); 

return 0; 

} 

 

void create() 

{ 

createAndDestroy fifth(5); 

cout<<"Local Aotumatic in Create \n"; 

static createAndDestroy sixth(6); 

cout<<"Local Static in create \n"; 

createAndDestroy seventh(7); 

cout<<"Local Automatic in Create \n"; 

system ("PAUSE"); 

}

وهذا هو شكل المخرجات :

توضيح بسيط للبرنامج :.

في البداية يقوم بتنفيد دوال البناء لكل من ( 1 ، 2 ، 3 ) بعدها يقفز للأسفل لقراءة تفاصيل الدالة Create();فيقرأ كل من ( 5 ، 6 ، 7 )
وبعدها بعملية عكسية يتم الهدم "مثل ما ذكر سابقاً" فيتم الهدم لكل من ( 7 )
وبعدها لا يحدف (6) لانه ساكن Static فينتقل للتي بعدها وهي ( 5) فيتم هدمها وبعد ذلك يعود للبرنامج الرئيسي فيقوم بتنفيذ ( 4 ) ومن بعدها تنتهي الدالة Main() فيقوم

البرنامج بالهدم بعملية عكسية أيضاً فيهدم ( 4 ) ومن ثم ( 2) " 3 لا يهدم لانه ساكن حاله حال 6 " ومن بعدها يهدم الدالة 2 ..
الان يهدم وبعد الانتهاء من هدم الدوال العامة يعود لهدم الدوال الساكنة فيهدم ( 6 ) ومن بعدها يهدم الدالة رقم ( 3 ) .. وفي الأخير يتم هدم الدوال العامة ولا يوجد لدينا الا

دالة واحده وهي ( 1 ) .

**lovely_roro** · 02-05-2009, 01:13 AM

مساواة الكائنات :

يمكن مساواة كائن بكائن أخر مثلاً إذا كان لدينا كائنين A و B إذا جعلنا ( A=B ) فهذه العملية تعني نسخ محتويات الكائن B بالكائن A .

ملاحظات :
1- يجب أن تكون الكائنات من نفس النوع وإلا أدى ذلك إلى خطأ .
2- يمكن إرسال الكائن كوسيطة للدالة ، كما يمكن إرجاعه من الدالة .

مثال :

كود PHP:

   

#include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class date 

{ 

int day,mounth,year; 

public: 

date(int=1,int=1,int=1990); 

void print(); 

}; 

date:: date(int m,int d,int y) 

{ 

mounth=m; 

day=d; 

year=y; 

} 

void date::print() 

{ 

cout<<mounth<<"_"<<day<<"_"<<year; 

} 

int main() 

{ 

date date1(7,4,1993),date2; 

cout<<" date1= "; 

date1.print(); 

cout<<"\n date2= "; 

date2.print(); 

date2=date1; 

cout<<"\n date2= "; 

date2.print(); 

cout<<"\n"; 

system("PAUSE"); 

return 0; 

}

كما هو ظاهر في هذا المثال وهو خاص بطباعة التاريخ ، قمنا في البداية بتعريف دالة بناء افتراضية ذات ثلاثة معاملات وهي اليوم والشهر
والسنة ، ومن ثم قمنا بتعريف دالة للطباعة .
قمنا بعدها باشتقاق كائنين الأول date1 قمنا من خلاله بإرسال المعاملات أو الوسائط وهي اليوم والشهر
والسنة(7,4,1993) ، والكائن الثاني date بدون وسائط ( بحيث ينفذ الوسائط التلقائية الموجودة في دالة البناء وهي 1-1-1990)
بعدها قمنا بطباعة محتويات الكائن الأول وهي 7-4-1993ومن ثم طباعة محتويات الكائن الثاني وهي 1-1-1990
بعد ذلك قمنا بنسخ محتويات الكائن date1 بالكائن date2
كما يظهر في هذا الكود

كود PHP:

  date2=date1;

بعد ذلك قمنا بطباعة محتويات الكائن الثاني لتظهر لنا 7-4-1993 .

**lovely_roro** · 02-05-2009, 01:24 AM

** إرسال الكائن إلى دالة

تسمح لغة C++ بإرسال الكائنات إلى الدوال كما يتم إرسال المعاملات البسيطة ، ويمكن توضيح ذلك في المثال التالي:

كود PHP:

   

#include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class sample 

{ 

int i; 

public: 

sample (int n) 

{ 

i=n ; 

} 

int get_i() 

{ 

return i; 

}}; 

 

int sqr_i(sample ob) 

{ 

return ob.get_i()*ob.get_i(); 

} 

int main() 

{ 

sample s1(2),s2(10); 

cout<<sqr_i(s1)<<endl; 

cout<<sqr_i(s2)<<endl; 

 

system("PAUSE"); 

return 0; 

}

توضيح مبسط لأهم ما ورد في الكود السابق :

كما يتضح من خلال هذا البرنامج البسيط والذي يقوم بطباعة حاصل ضرب العدد بنفسه .
ظهر في هذا المثال الدالة التالية :

كود PHP:

  int sqr_i(sample ob)

الدالة sqr_i له وسيطة واحدة وهي الكائن ob المشتق من الصنف sample ،حيث يتم من خلال هذا الكائن الوصول للدوال الموجودة داخل الصنف sample فكما ظهر قمنابالوصول للدالة get_i() والتي وظيفتها الوصول للمتغيرات الموجودة في مستوى الحماية الخاص Private .
بعد ذلك قمنا باشتقاق كائنين s1 الذي يرسل القيمة ( 2 ) لدالة البناء sample بعد ذلك يتم طباعة حاصل العدد (2) في نفسه من خلال الدالة sqr_i التي تستقبل وسيطة واحدة وهي الكائن s1 .
وكذا الحال مع الكائن الاخر s2 .

**lovely_roro** · 02-05-2009, 01:54 AM

** الكائنات الثابتة والدوال الثابتة

على حسب حاجة البرنامج قد تكون لدينا كائنات غير قابلة للتعديل والبعض الآخر قابل للتعديل ، لجعل الكائن غير قابل للتعديل نستخدم الكلمة المفتاحية Const مثلاً

كود PHP:

  Const time t(12,00);

ملاحظات :
1- لا تسمح مترجمات لغة C++ لأي دالة عضو باستدعاء كائنات ثابتة مالم يصرح عن الدوال العضو نفسها كدوال ثابتة.
2- دوال العضو المصرح عنها كدوال ثابتة لا يمكن أن نعدل على الكائن حيث لا يسمح المترجم بذلك .
3- يتم الإعلان عن الدالة الثابتة باستخدام الكلمة المفتاحية const في تعريفها وعند كتابة التفاصيل مثلاً :

كود PHP:

  int get_hour()const;

OR

كود PHP:

  Int get_hour()const 

{ 

---- 

-- 

}

4- استدعاء دالة عضو غير ثابتة non const على كائن ثابت تعتبر خطأ قواعدياً .

مثال :[/

COLOR]

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class increment 

{ 

int count; 

const int incre; 

 

public: 

increment (int c=0, int i=1); 

void addincement() 

{ 

count+=incre; 

} 

void print()const; 

}; 

increment::increment(int c,int i):incre(i) 

{ 

count=c; 

} 

void increment::print()const 

{ 

cout<<"Count= "<<count<<" , incre = " <<incre<<endl; 

} 

int main() 

{ 

increment value(10,5); 

cout<<"Before Increment :"; 

value.print(); 

for(int j=0;j<3;j++) 

{ 

value.addincement(); 

cout<<"After Inrement :"<<j+1<<":"; 

value.print(); 

} 

 

system("PAUSE"); 

return 0; 

}

مثال بسيط جداً بحيث جعلنا المتغير incre متغير ثابت const بحيث تكون قيمته ثابتة ، ومتغير اخر باسم count ومن قم في كل مرة يضيف قيمة المتغير incre إلى المتغير count ويطبع قيمة المتغيرين ، وستظهر المخرجات بهذا الشكل ::

نقطه هامة جداً بخصوص الدالة increment .
لاحظ اننا كتبناها بهذه الصيغة ( لاحظ المتغير incre )

كود PHP:

  increment::increment(int c,int i):incre(i) 

{ 

count=c; 

}

في الأصل المفروض كما ورد في امثلة سابقة ان تكون بهذه الصيغة

كود PHP:

  increment::increment(int c,int i) 

{ 

count=c; 

incre=i; 

}

لكن في المتغيرات الثابتة const فاننا لا نعرفها بهذا الشكل ...

اانتظرووني لبقية الدرس ان شاااء الله ...

دمتم بخيير ...

**lovely_roro** · 02-05-2009, 07:30 PM

** الدوال الصديقة والأصناف الصديقة Friend Classes & Friend Functions

تعريف الدالة الصديقة : هي عبارة عن دالة تفاصيلها خارج الـ Class مع امتيازها بحق الوصول لجميع أعضاء الـ Class .

- للتصريح عن الدالة الصديقة نستخدم الكلمة المفتاحية friend كما يلي :

كود PHP:

  Friend DataType FunctionName (Parameters)

OR

كود PHP:

  DataType friend FunctionName (Parameters)

ملاحظات :

1- مع أن تعريف الدالة الصديقة يتم داخل الصنف ، إلا أنها لا تعتبر دالة عضو من أعضاء الصنف ، لذلك من الخطأ استدعاؤها باستخدام اسم الكائن مع أداة الوصول ( . ) .
2- لا تؤثر مستويات الحماية على التصريح عن الدالة الصديقة لذلك يمكن التصريح عن الدالة الصديقة في أي موضع داخل الصنف .
3- الدالة الصديقة لها امتيازات الدالة العضو في الصنف ، أي أنها لها المقدرة على الوصول إلى جميع خصائص الصنف .
4- يتم استدعاء الدالة الصديقة عن طريق اسمها مع الوسائط .

* مثال : برنامج يتم فيه التصريح عن الدالة الصديقة setx والتي تستخدم في الوصول إلى عضو البيانات الخاص x .

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class count 

{ 

friend void setx (count&,int); //تعريف لمرجع كائن 

private: 

int x; 

public: 

count(){x=0;} 

void print()const 

{ 

cout<<x<<endl; 

}}; 

void setx (count &c,int val) 

{ 

c.x=val; 

} 

int main() 

{ 

count counter; 

counter.print(); 

setx(counter,8); 

counter.print(); 

 

system("PAUSE"); 

return 0; 

}

هذا المثال بسيط جداً يوضح آلية التعامل مع الدوال الصديقة بحيث يتم في البداية تعريف الدالة في أي موقع داخل الـ Class كما في الشكل التالي :

كود PHP:

  friend void setx (count&,int);

كما يظهر الدالة تحتوي على وسيطة Parameter مرجع لكائن والأخرى متغير ، وطريقة كتابة التفاصيل خارج الـ Class كما ظهر في هذا الشكل :

كود PHP:

  void setx (count &c,int val) 

{ 

c.x=val; 

}

كما ظهر فانه تم الوصول للمتغير x الموجود في مستوى الحماية private مباشرة ومن ثم تخزين القيمة الموجودة في المتغير val في المتغير x ..
بعد ذلك :

كود PHP:

  count counter; 

counter.print(); 

setx(counter,8); 

counter.print();

كما ظهر في البداية يستدعي دالة البناء count والتي تجعل قيمة المتغير x تساوي القيمة 0 ومن ثم طباعة هذه القيمة .
بعد ذلك يتم التعامل مع الدالة setx بحيث نغير قيمة المتغير x بجعلها تساوي الرقم 8 ومن ثم طباعتها ...
هذا باختصار فكرة عمل هذا البرنامج ..

مثال2 : برنامج يستخدم دالة صديقة تقارن بين نصفي قطري دائرتين ( إيجاد المساحة والمحيط لكل دائرة ) :

كود PHP:

  #include <iostream.h> 

#include <stdlib.h> 

class circle 

{ 

int r; 

float ar,c; 

public: 

 

circle (int r1){r=r1;} 

void area () 

{ 

ar=3.14*r*r; 

} 

void cir() 

{ 

c=2*3.14*r; 

} 

void display() 

{ 

cout<<"area = "<<ar<<endl; 

cout<<"cir = "<<c<<endl; 

} 

friend bool compare (circle,circle); 

}; 

 

bool compare (circle c1,circle c2) 

{ 

return c1.r>c2.r; 

/* 

أو بالامكان كتابة الشرط كاملاً كما في هذا الشكل 

if (c1.r>c2.r) 

cout<<"r1 is greator" ; 

else 

cout<<"r2 is gretaor" 

 

*/ 

 

} 

int main() 

{ 

int r1,r2; 

cout<<"Enter radios r1"<<"\n"; 

cin>>r1; 

cout<<"Enter radios r2"<<"\n"; 

cin>>r2; 

circle cc1(r1),cc2(r2); 

cc1.area(); 

cc1.cir(); 

cc1.display(); 

cc2.area(); 

cc2.cir(); 

cc2.display(); 

if (compare (cc1,cc2)) 

/* 

وهنا يكفي السطر الأول فقط في حال طبقنا الكود المكتوب 

في الملاحظة السابقة 

if (compare (cc1,cc2)) 

*/ 

cout<<"r1 is greator"; 

else 

cout<<"r2 is greator"; 

 

system("PAUSE"); 

return 0; 

}

**lovely_roro** · 02-05-2009, 07:39 PM

** الأصناف الصديقة Friend Classes

تعريف : هو عبارة عن صنف تستطيع كل دواله الأعضاء أن تستخدم خصائص الصنف الآخر .

- وللتصريح عن الصنف الصديق : نستخدم الكلمة المفتاحية friend مثلاً لجعل الصنف tow صديق للصنف one نكتب العبارة التالية :

كود PHP:

  Friend class tow

داخل الصنف one .

ملاحظات :
1- يمكن التصريح عن الصنف الصديق بأي موضع داخل الآخر .
2- علاقة الصداقة ليست تناظرية ، بمعنى إذا كان الصنف A صديق للصنف B فهذا لا يعني أن الصنف B صديق للصنف A .
3- علاقة الصداقة ليست متعدية ، بمعنى إذا كان الصنف A صديق للصنف B والصنف B صديق للصنف C فهذا لا يعني أن الصنف A صديق للصنف C .

مثال توضيحي :

كود PHP:

  //تعريف للصنف فقط دون كتابة اي تفاصيل له 

class a; 

class b 

{ 

/* 

كافة التفاصيل الخاصة بالـ class b 

*/ 

friend class a; 

} 

class a 

{ 

/* 

كافة التفاصيل الخاصة بالـ class a 

*/ 

 

}

هذه الصيغة العامة للتعامل مع الأصناف الصديقة .

تنبيه : الصنف الصديق لابد أن يعرف أولا ..

** مثال : برنامج يستخدم الأصناف الصديقة ، ويقوم بإيجاد الوسط الحسابي لـ N من الأعداد الحقيقية المدخلة من قبل المستخدم .بحيث
* الصنف الأول يستخدم لـ ( إدخال الأعداد ثم اثجاد مجموعها والذي نسميه بـ summation ).
* الصنف الثاني يستخدم المعلومات الموجودة في الصنف الأول summation ومن ثم إيجاد الوسط الحسابي والذي نسميه بـ mean ::..

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

//تعريف الصنف الصديق أولاً 

class mean; 

class summation 

{ 

//تم هنا تعريف الصنف الصديف داخل الصنف 

friend class mean; 

private: 

//المتغير الذي يحدد عدد الاعداد المدخلة من قبل المستخدم 

int n; 

float x,sum; 

public: 

//داله بناء 

summation() 

{sum=0; 

 

cout<<"Enter n :"<<endl; 

cin>>n; 

for(int i=1;i<=n;i++) 

{ 

cout<<"Enter x ["<<i<<"] : \n"; 

cin>>x; 

sum+=x; 

} 

cout<<"Summation="<<sum<<endl; 

}}; 

class mean 

{ 

private : 

// متغير عدد حقيقي لتخزين المتوسط 

float s; 

public: 

//لاحظ هنا الدالة لها وسيطة من نوع الكائن الصديق 

//من خلالة يتم الوصول لكافة الأعضاء الموجودة بداخله مثل مجموع الاعداد 

mean(summation ss) 

{ 

s=ss.sum/ss.n; 

cout<<"Mean = "<<s<<"\n"; 

}}; 

int main() 

{ 

//يتم هنا استدعاء دالة البناء مباشرة 

summation s; 

//لاحظ هنا الوسيطة هي الكائن s 

//لانه يحتفظ بكافة العمليات التي اجريناها 

mean m(s); 

system("PAUSE"); 

return 0; 

}

**barboosh** · 02-05-2009, 07:48 PM

بصراحة واااصح جداً انك بذلتي جٌهد للقيام بهذا الموضوع

شكراً لكِ أختي الغالية لوفلي رورو

على الطرح المميز

و في انتظار كل جديدك بكل شوق

مع تحياتي العطرة:

barboosh

**lovely_roro** · 02-05-2009, 08:01 PM

منووورة غاليتي -barboosh-

اشكرك على المرور الطيب....نورتي الموضوع بوجودك العطر...

ما ننحرم من مشاركتك ...

دمت بودِ...

**lovely_roro** · 03-05-2009, 05:11 AM

** أعضاء الصنف الساكنة Static Class members

البيانات الساكنة : هي عبارة عن خصائص ( متغيرات ) مشتركة بين كل كائنات الصنف ، أي أن كل الكائنات لها

نفس النسخة من المتغيرات .

- وللتصريح عن البيانات الساكنة نستخدم المفتاحية static .

* ملاحظات :
1- لابد من تهيئة المتغيرات الساكنة لمرة واحدة فقط في البرنامج .

2-يمكن الوصول للمتغيرات الساكنة العامة باستخدام اسم الصنف مع مؤثر دقة الوصولScope Resolution Operator ( ::

) ، أو باستخدام اسم الكائنات .
مثلاً : ليكن لدينا الصنف Employee والذي يحمل المتغير الصحيح العام count لتهيئة هذا

المتغير نكتب العبارة التالية :

كود PHP:

  int Employee :: count=0;

وللوصول لهذا المتغير في البرنامج الرئيسي نتبع أحد هاتين الطريقتين :

كود PHP:

  Employee::count

OR

كود PHP:

  s.count

حيث s كائن تم اشتقاقه من الصنف Employee .

3- أي دالة تعامل مع بيانات ( متغيرات ) ساكنة لابد أن تكون ساكنة أيضاً . مثلاً

كود PHP:

  static void display() 

{ 

cout<<count; 

}

حيث count هو متغير ساكن والذي سبق تعريفة في الملاحظة السابقة .

4- استدعاء الدالة الساكنة يتم باستخدام :
أ. مؤثر دقة الوصول Scope Resolution Operator .
ب. الكائنات .

مثال على البيانات الساكنة

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class staticproperty 

{ 

public: 

int static n; 

staticproperty() 

{ 

++n; 

} 

}; 

int staticproperty::n=3; 

main() 

{ 

staticproperty s1,s2,s3,s4; 

cout<<s1.n<<endl; 

cout<<staticproperty::n<<endl; 

cout<<s4.n<<endl; 

system("PAUSE"); 

 

}

كماهو ملاحظ لدنيا المتغير الساكن وهو n تم تعريفه في بداية الصنف :

كود PHP:

  int static n;

ومن ثم لدينا دالة البناء التي تزيد قيمة المتغير n بالعدد ( 1 ) من خلال مؤثر

التزايد كما يظهر :.

كود PHP:

  staticproperty() 

{ 

++n; 

}

بعد ذلك تم تطبيق أمر مهم جداً (ملاحظة رقم 1) وهو تهئية قيمة المتغير وهنا في هذا المثال جعلنا

n=3 وتم التعريف خارج الصنف باستخدام مؤثر دقة الوصول Scope Resolution Operator :

كود PHP:

  int staticproperty::n=3;

بعد ذلك تم اشتقاق أربعة كائنات من الصنف staticproperty :

كود PHP:

  staticproperty s1,s2,s3,s4;

لاحظ هنا دالة البناء تزيد قيمة المتغيرn بـ ( 1) وتم تهيئة قيمة المتغير بالعدد (

3) فعند اشتقاق اي كائن تزيد قيمة n باضافة العدد 1 إلي القيمة السابقة .
فعند اشتقاق الكائن s1 أصبحت قيمة n تساوي العدد 4 .
وعند اشتقاق الكائن s2 أصبحت قيمةn تساوي العدد 5 .
وعند اشتقاق الكائن s6 أصبحت قيمةn تساوي العدد 6 .
وعند اشتقاق الكائن s7 أصبحت قيمةn تساوي العدد 7 .
وكما ذكرنا في التعريف الموجود في اول الرد
اقتباس:
البيانات الساكنة : هي عبارة عن خصائص ( متغيرات ) مشتركة بين كل كائنات الصنف ، أي أن كل الكائنات لها نفس النسخة من المتغيرات .
أي ان :

كود PHP:

  s1 = s2 = s3 = s4

وجميع الكائنات تساوي اخر عملية تمت على اي كائن وهي اشتقاق الكائن s4 زادت قيمة المتغير n

وأصبحت تساوي العدد 7 ..
أي عند طباعة أي كائن :.

كود PHP:

  staticproperty s1,s2,s3,s4; 

cout<<s1.n<<endl; 

cout<<staticproperty::n<<endl; 

cout<<s4.n<<endl;

فستكون مخرجات هذا البرنامج هي ::
7
7

7

مثال (2) على الأعضاء ( الدوال ) الساكنة :

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class property 

{ 

private: 

int static n; 

public: 

property () 

{++n;} 

static void display() 

{ 

cout<<n<<endl; 

}}; 

int property::n=2; 

int main() 

{ 

property s1,s2,s3; 

property::display(); 

 

s1.display(); 

s3.display(); 

system("PAUSE"); 

return 0; 

}

وهنا تم تعريف دالة display() على انها دالة ساكنة ::.

كود PHP:

  static void display() 

{ 

cout<<n<<endl; 

}

ومن ثم تم تهيئة قيمة المتغير n بالعدد ( 2 ) :

:

كود PHP:

  int property::n=2;

بعدها تم اشتقاق الكائنات من الصنف property ::

كود PHP:

  property s1,s2,s3;

ونفس العملية في المثال الأول تتم هنا أيضاً .. حيث ان جميع الكائنات تحتوي على المتغير n الذي يساوي العدد ( 5 ) .
بعد ذلك تمت طباعة المخرجات بطرق مختلفة كما هو ظاهر ::.

كود PHP:

  property::display(); 

s1.display(); 

s3.display();

حيث في هذه الحالة تكون المخرجات بـ :
5
5
5

تمرين : وضح مخرجات هذا البرنامج ( دون استخدام اي مترجم )

كود PHP:

  #include <iostream.h> 

#include <stdlib.h> 

class sample 

{ 

public: 

int static n; 

sample() 

{ 

++n; 

} 

~sample() 

{ 

--n; 

} 

}; 

int sample::n=5; 

main() 

{ 

sample a; 

sample b[4]; 

sample *c=new sample[3]; 

cout<<c -> n<<"\n"; 

cout<<b[1].n<<"\n"; 

delete []c; 

cout<<sample::n<<"\n"; 

cout<<a.n<<"\n"; 

system("PAUSE"); 

return 0; 

}

**lovely_roro** · 03-05-2009, 05:17 AM

** استخدام المؤشر This

كل كائن يملك حق الوصول إلى عنوانه عن طريق مؤشر يدعى This .
يُستخدم المؤشر This بشكل ضمني ليشير أن الأعضاء تنتمي إلى كائن معين ، ويمكن استخدام المؤشر This بشكل

صريح .

مثال :

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class test 

{ 

private: 

int x; 

public: 

test ( int =0); 

void print()const; 

}; 

test::test(int a) 

{ 

x=a; 

} 

void test::print()const 

{ 

cout<<"x = "<<x<<endl; 

cout<<"This -> ="<<this->x<<endl; 

cout<<"*this ="<<(*this).x<<endl; 

} 

int main() 

{ 

test t(12); 

t.print(); 

system("PAUSE"); 

return 0; 

}

ملاحظات :
1- تم استخدام الدالة print() لطباعة قيمة المتغير x بشكل مباشر ، ثم بعد ذلك استخدمنا ترميزين مختلفين لطباعة

x :
أ. معامل السهم ( -> ) مع المؤشر This .
ب. معامل النقطة ( . ) مع محتوى المؤشر ( *This ).

2- تم استخدام الأقواس مع محتوى المؤشر This ( *This ) ، لأن عامل النقطة له أولوية أعلى على عامل المحتوى ( *

) .

3- إذا لم يتم استخدام الأقواس مع محتوى المؤشر ( *This ) بحيث نضعها بهذا الشكل :

كود PHP:

  *this.x

فإنه يحدث خطأ قواعدي لأننا استخدمنا عامل النقطة مع المؤشر This .

** وهنالك استخدام آخر ومهم جداً للمؤشر This وهو تفعيل الاستدعاء المتتالي للدوال **

مثال : يبين هذا البرنامج إرجاع مرجع لكائن الصنف sample لتفعيل الاستدعاء المتتالي للدوال .

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class sample 

{ 

public: 

int c; 

sample &cube(int); 

void show() 

{ 

cout<<"Cube ="<<c<<endl; 

} 

}; 

sample &sample::cube (int a) 

{ 

c = a*a*a; 

return *this; 

} 

int main() 

{ 

sample s; 

s.cube(2).show(); 

 

system("PAUSE"); 

return 0; 

}

هذا البرنامج طويل بعض الشيء .. سنشرح ماهو مهم .. :::

كود PHP:

  sample &cube(int);

هذا تعريف الدالة cube وهي لايجاد تكعيب أي عدد مدخل ( نوع الدالة مرجع كائن).

كود PHP:

  sample &sample::cube (int a) 

{ 

c = a*a*a; 

return *this; 

} 

int main()

وهذا هو كتابة تفاصيل الدالة كتبناها خارج الصنف حيث ان كل القيم من الدالة تمثل محتوى المؤشر This .
بعد ذلك والأهم وهو طريقة الاستدعاء المتتالي للدوال وهو كما ظهر في الدالة الرئيسية main().:

كود PHP:

  sample s; 

s.cube(2).show();

فكما هو ملاحظ تم اشتقاق الكائن s من الصنف sample ومن ثم تم استدعاء الدالتين cube

والدالة show بشكل متتالي ..

**lovely_roro** · 03-05-2009, 03:52 PM

** التحميل الزائد للدوال Function Overloading :

وهو إمكانية إنشاء أكثر من دالة تحمل نفس الاسم ولكنها قد تختلف في نوعية المعاملات Parameters Types أو في عدد المعاملات Parameters No ، ولكل دالة الإجراء الخاص بها .
أي أن الدوال تشترك في اسمها ولكنها تختلف في شكلها ومضمونها .

مثال : برنامج يقوم بإجراء عملية الجمع باستخدام محمّلة بشكل زائد .

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class summation 

{ 

public: 

int a,b,c; 

float x,y; 

int sum(int,int); 

float sum(float,float); 

int sum(int,int,int); 

}; 

int summation::sum(int a1,int b1) 

{ 

return a1+b1; 

} 

float summation::sum(float x1,float y1) 

{ 

return x1+y1; 

} 

int summation::sum(int a1,int b1,int c1) 

{ 

return a1+b1+c1; 

} 

int main() 

{ 

summation ob; 

cout<<"Enter A,B,C \n"; 

cin>>ob.a>>ob.b>>ob.c; 

cout<<"Enter X,y \n"; 

cin>>ob.x>>ob.y; 

cout<<"sum1 ="<<ob.sum(ob.a,ob.b)<<endl; 

cout<<"sum2 ="<<ob.sum(ob.x,ob.y)<<endl; 

cout<<"sum3 ="<<ob.sum(ob.a,ob.b,ob.c)<<endl; 

 

system("PAUSE"); 

return 0; 

}

كما ظهر في هذا المثال لدينا ثلاثة دوال تحمل نفس الاسم :

كود PHP:

  int sum(int,int); 

float sum(float,float); 

int sum(int,int,int);

تظهر الدالةالأولى والثانية ان عدد الوسائط Parameters متساوي ولكنها تختلف في النوع حيث أن الأولى int والثانية float .
اما الدالة الثالثة فهي تختلف عنهم من حيث عدد الوسائط Parameters .
هذا باختصار عن ما يسمى بـ Function Overloading .

**lovely_roro** · 03-05-2009, 04:01 PM

** التحميل الزائد للمؤثرات Operator Overloading ::

هو المقدرة على ربط مؤثر معين لدالة عضو في الصنف ويتم استدعاؤها عند تطبيق المؤثر على أحد كائنات الصنف .

* فائدته : مؤثر الجمع ( + ) نستطيع أن نقوم بتطبيقه على عددين صحيحين أو حقيقيين ولكن لا نستطيع استخدامه مع الكائنات إلا بعد ت

حميله تحميلاً زائداً

ملاحظات :
1- لا ينبغي تغيير وظيفة المؤثر عند تحميله . مثلاً إذا قمنا بتحميل مؤثر الجمع فلا ينبغي استخدامه مع عملية أخرى مثل ( - , * , / ) ، لأن هذا الاستخدام يعتبر استخدام سيء لمفهوم التحميل الزائد للمؤثرات ويجعل من الصعب فهمه .
2- يمكن تحميل معظم المؤثرات الموجودة في لغة C++ بشكل زائد .
3-نستخدم الكلمة المفتاحية Operator عند القيام بتحميل مؤثر تحميلاً زائداً .

- والصيغة العامة لدالة التحميل الزائد للمؤثرات :

كود PHP:

  datatype operator operatorSymbol ( Parameters)

حيث :
datatype = القيمة الراجعة من الدالة ( كائن ) .
operator = وهي كلمة مفتاحية Keyword .
operatorSymbol = وهو رمز المؤثر ( + , * , ...)

- المؤثرات التي يمكن تحميلها بشكل زائد في C++ وهي :

كود PHP:

  ++ , -- // مؤثرات التزايد والتناقص 

+ , - , * , / , ^ , % // المؤثرات الرياضية 

= // المساواة 

+= , -= , *= , /= , ^= , %= // المؤثرات المركبة 

== , != , > , < , <= , >= // مؤثرات المقارنة 

&& , || , ! // المؤثرات المنطقية 

new , delete , new[ ] , delete[ ] //المؤشرين newوdelete

- المؤثرات التي لا يمكن تحميلها بشكل زائد :

كود PHP:

  ? 

. 

:: 

->

* تعتبر محاولة تحميل أي مؤثر لا يمكن تحميله بشكل زائد خطأ قواعدي .
* تحميل مؤثري الجمع والإسناد ( + , = ) لجعل هذه الجملة صحيحة

كود PHP:

  object2= object2 + object1

لا نستطيع أن نقوم بكتابة الجملة أعلاه بالشكل التالي :

كود PHP:

  object2+=object1

إلا بعد تحميل المؤثر += بشكل صريح

.

* مثال : على تحميل مؤثر التزايد ( ++ )

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class alpha 

{ 

private: 

int a; 

public: 

alpha() 

{ 

a=1; 

} 

alpha (int); 

void display(); 

alpha operator++(); 

}; 

alpha::alpha(int a1) 

{ 

a=a1; 

} 

void alpha::display() 

{ 

cout<<a<<endl; 

} 

alpha alpha::operator++() 

{ 

++this->a; 

return *this; 

} 

int main() 

{ 

alpha a1,a2(12); 

a1.display(); 

a2.display(); 

++a1; 

a1.display(); 

++a2; 

a2.display(); 

alpha a3; 

a3=++a1; 

a3.display(); 

a3=++a2; 

a3.display(); 

 

 

system("PAUSE"); 

return 0; 

}

هذا المثال يبين كيفية التعامل مع مؤثر التزايد ( ++ ) مع الكائنات بحيث تم تعريف الدالة التحميل الزائد داخل الصنف بالشكل التالي :

كود PHP:

  alpha operator++();

وكما يظهر أن الدالة لا تحتوي على أي وسائط Parameters ، وبالعادة دائما ما تكون مؤثرات التزايد والتناقص ( ++ , -- ) بدون وسائط ، ويظهر أن الدالة أيضاً ترجع كائن ، وتم كتابة تفاصيل الدالة خارج الصنف باستخدام مؤثر دقة الوصول Scope Resolution Operator كما بالشكل التالي :

كود PHP:

  alpha alpha::operator++() 

{ 

++this->a; 

return *this; 

}

وسيتم شرح طرق كتابة دالة التحميل الزائد بعد توضيح مخرجات هذا البرنامج .

كود PHP:

  alpha a1,a2(12); 

// هنا يطبع العدد 1 

a1.display(); 

//وهنا يطبع العدد 12 

a2.display(); 

//بعد ذلك تم تطبيق مؤثر التزايد على الكائن a1 

++a1; 

//وهنا سيطبع العدد 2 

a1.display(); 

//وهنا تم تطبيق مؤثر التزايد على الكائن a2 

++a2; 

// يطبع القيمة 2 

a2.display(); 

//تم اشتقاق كائن جديد 

alpha a3; 

//قمنا بتطبيق مؤثر التزايد على الكائن الأول تم إسناد قيمة الكائن a1 

// في الكائن الجديد a3 

a3=++a1; 

//بعد ذلك طباعة الكائن الثالث التي تساوي العدد (3) 

a3.display(); 

a3=++a2; 

// طباعة العدد ( 14) 

a3.display();

ملاحظة : مؤثر الإسناد ( = ) يعرّف إذا كان لدينا حجز ديناميكي للذاكرة .

# يمكن لدالة التحميل الزائد أن ترجع كائن بثلاث طرق

1- استخدام مؤثر This :

كود PHP:

  alpha alpha :: operator ++() 

{ 

++ this ->a; 

return *this; 

}

2- باستخدام كائن مؤقت Temporary Object :

كود PHP:

  alpha alpha :: operator ++() 

{ 

alpha tmep; 

temp.a=++a; // (Or) ++this->a; 

}

3- باستخدام كائن من غير اسم Name Less Object

كود PHP:

  alpha alpha :: operator ++() 

{ 

int aa; 

aa=++a; (Or) ++this ->a; 

return aa; 

}

هذه الطرق الثلاثة التي بالإمكان استخدامها مع مؤثري التزايد والتناقص ( ++ , -- ) ولكن مع مراعاة تغيير الإشارات بين المؤثرين .

** تحميل المؤثرات الثنائية ( + , - , * , / , ^ , % ) :

يتم تحميل المؤثرات الثنائية باستخدام دالة عضو ذات وسيطة واحدة أو باستخدام دالة غير عضو في الصنف مثلاً ( دالة صديقة ) بوسيطتين .

* مثال على تحميل مؤثر الجمع لإجراء عملية الجمع على كائنين باستخدام دالة تحميل عضو :

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class add 

{ 

private: 

int a; 

public: 

add() 

{ 

a=1; 

} 

add ( int a1) 

{ 

a=a1; 

} 

void display() 

{ 

cout<<a<<endl; 

} 

//الوسيطة عبارة عن كائن 

add operator+(add p1) 

{ 

this -> a=a+p1.a; 

return *this; 

}}; 

int main() 

{ 

int x; 

cout<<"Enter x"; 

cin>>x; 

add add1,add2(x); 

//يطبع القيمة الافتراضية الموجودة في دالة البناء وهي ( 1) 

add1.display(); 

//يطبع القيمة المدخلة 

add2.display(); 

add add3; 

//وهنا الأهم حيث يجمع العدد ( 1 ) مع القيمة المدخلة من قبل المستخدم 

add3=add1+add2; 

//وهنا يطبع القيمة الجديدة 

add3.display(); 

system("PAUSE"); 

return 0; 

}

ويمكن أن تكون دالة التحميل الزائد دالة غير عضو كما ذُكر سابقاً ( مثلاً دالة صديقة Friend Function )وفي هذه الحالة يتم تعريفها داخل الصنف بالشكل التالي :

كود PHP:

  friend add operator + (add,add)

وتفاصيلها تكتب خارج الصنف بالشكل التالي :

كود PHP:

  add operator ( add p1, add p2) 

{ 

p1.a = p1.a + p2.a; 

return p1; 

}

وفي البرنامج الرئيسي يمكن أن نغير add3 إلى

كود PHP:

  add3= operator +(add1,add2)

** تحميل المؤثرات المركبة (+= , -= , *= , /= , ^= , %= )

ذكرنا بأن تحميل أي مؤثر ثنائي مثل مؤثر الجمع لا يؤدي إلى تحميل المؤثرات المرتبطة به كـ ( += ) وبالتالي أي مؤثر مركب حتى نستطيع استخدامه مع الكائنات لابد من تحميله بشكل صريح .

* مثال يوضح طريقة تحميل المؤثر المركب +=

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class meters 

{ 

float m; 

public: 

meters() 

{m=0;} 

meters(float m1) 

{ 

m=m1; 

} 

void show() 

{ 

cout<<m<<endl; 

} 

//تعريف دالة التحميل الزائد على أنها دالة صديقة بوسيطتين 

friend meters operator+=(meters ,meters ); 

}; 

meters operator+=(meters m1,meters m2) 

{ 

m1.m+=m2.m; 

return m1; 

} 

int main() 

{ 

meters m1,m2(12.5); 

meters m3(m2); 

m1.show(); //0 

m2.show();//12.5 

m3.show();//12.5 

//كما يظهر هنا التعامل المؤثر المركب =+ 

m2=operator+=(m2,m1); 

m2.show();//12.5 

m3=operator+=(m3,m2); 

m3.show();//25 

system("PAUSE"); 

return 0; 

}

يظهر في هذا المثال طريقة تحميل دالة التحميل الزائد للمؤثر += وكيفية التعامل معها وهذا الحال ينطبق مع باقي المؤثرات المركبة ، وتم في هذا المثال تغيير بناء الدالة حيث تم هنا على أنها دالة صديقة Friend Function عكس ما تم عمله في الدرس الماضي .

** تحميل مؤثرات المقارنة ( == , != , > , < , <= , >= )

القيمة الراجعة من دالة التحميل الزائد لمؤثرات المقارنة هي عبارة عن قيمة منطقية boolean .

مثال على تحميل مؤثر (>)

كود PHP:

  #include <iostream.h> 

#include <cstdlib> 

using namespace std ; 

class comp 

{ 

int a; 

public: 

comp ( int n ) 

{ 

a=n; 

} 

bool operator>(comp c) 

{ 

return (a > c.a); 

} 

}; 

int main() 

{ 

int x,y; 

cout<<"enter x,y \n"; 

cin>>x>>y; 

comp c1(x),c2(y); 

if (c1>c2) 

cout<<"c1 is greator"; 

else 

cout<<"c2 is greator"; 

system("PAUSE"); 

return 0; 

}

كما يظهر في هذا المثال يتم المقارنة بين الكائنين c1 و c2 ومن ثم طباعة القيمة الأكبر بينهما ...

وهذا باختصار عن ما يسمى بالتحميل الزائد للمؤثرات Operator Overloading .

**barboosh** · 18-05-2009, 06:18 PM

بوجودك يا الغلا

و الله يعطيكِ ألف عاافية يا رب

على تكملت الموضوع

مع تحياتي العطرة:

barboosh

**lovely_roro** · 25-05-2009, 03:48 PM

** الوراثة Inheritance

تعريف الوراثة : هي إمكانية أن يرث صنف ما الخصائص والعمليات الموجودة في صنف آخر ، مما يساعد على إعادة استخدام Reusability الأصناف التي تم إنشاؤها من قبل .

وبناء على هذا التعريف فإنه يمكن تحديد مفهومين جديدين وهما :
1- صنف القاعدة ( الأساس Or الموروث ) base class : وهو الصنف الذي يحوي البيانات والعمليات المراد توريثها لصنف آخر .
2- الصنف المشتق ( الوارث ) Derived class : وهو الصنف الوارث لخصائص وعمليات الصنف الأساس .

# أنواع الوراثة Inheritance Types :
توفر لغة C++ ثلاث أنواع من الوراثة حيث يحدد نوع الوراثة درجة الوصول للبيانات والعمليات الموجودة في صنف الأساس من خلال الصنف المشتق . والأنواع هي :
1- الوراثة الخاصة private Inheritance :

عندما يرث صنف مشتق صنف الأساس وكان نوع الوراثة خاص فإنه كل البيانات والعمليات الموجودة في صنف الأساس تصبح خاصة الصنف المشتق .
2-الوراثة المحمية protected Inheritance :

وفي هذا النوع تصبح كل بيانات وعمليات صنف الأساس محميّة بالصنف المشتق .
3- الوراثة العامة public Inheritance :

في هذا النوع يتم توزيع البيانات والعمليات كما يلي :
أ- المحمي protected في صنف الأساس base class يصبح محمي في الصنف المشتق .
ب- العام public في صنف الأساس يصبح عام في الصنف المشتق .
ج- الخاص لا يورّث أبدا ( البيانات الخاصة لا تورّث أبداً )! ..
ويمكن توضيح ما سبق من خلال هذا الجدول :.

[/CENTER]

تشكل الوراثة هيكل هرمي حيث يمثل صنف الأساس قمة الهرم فمثلاً .::

- الصيغة العامة للوراثة :
لجعل الصنف derived يرث الصنف Base :

كود PHP:

   class derived : InheritanceType Base

ومثال ذلك :

كود PHP:

  [center]#include <iostream.h>

#include <cstdlib>          

using namespace std ;  

 class B

{

int i;

public:

void set_i(int);

int get_i();

};

class D:public B

{

int j;

public:

void set_j(int);

int multi();

};

void B::set_i(int n)

{i=n;}

int B::get_i()

{

return i;

}

void D::set_j(int m)

{

j=m;}

int D::multi()

{

return get_i()*j;

}

int main()

{

int a,b;

cout<<"Enter A,B \n";

cin>>a>>b;

D ob;

ob.set_i(a);

ob.set_j(b);

cout<<"Multi ="<<ob.multi()<<endl;

      system("PAUSE");

      return 0;

}

[/center]

فكما يظهر في هذا المثال البسيط الذي يضرب عددين مدخلين من قبل المستخدم ، في هذا المثال لدينا صنفين ( Class B, Class D ) ، وأن الصنف D يرث وراثة عامة Public من الصنف B كما ظهر في الشكل التالي :.

كود PHP:

    class D:public B

ومن خلال هذه العلاقة فإنه عندما نشتق كائن من الصنف D فإنه بإمكاننا أن نصل لكافة المتغيرات والدوال الموجودة في المستوى ( Protected , public ) في الصنف B ، ويوجد في الصنف D دالة ضرب العددين كما في الشكل التالي :.

كود PHP:

  [center]int D::multi()

{

return get_i()*j;

}

[/center]

فكما يظهر لدينا الدالة get_i() الموجودة في الصنف B تم التعامل معها هنا في الصنف D بدون أي إضافات .

* دوال البناء والهدم تحت الوراثة Constructor And Destructor Functions Under Inheritance :
إن كلاً من الصنف الوارث والصنف الموروث يمكن أن يمتلكا دوال بناء ودوال هدم .
# ملاحظات :
1- دالة بناء الصنف الموروث تنفذ قبل دالة بناء الصنف الوارث .
2- دالة هدم الصنف الوارث تنفذ قبل دالة هدم الصنف الموروث .
3- لا يمكن توريث دوال البناء والهدم من الصنف الأساس إلى الصنف المشتق .
4- يتم إرسال المعاملات لدالة بناء الصنف الموروث من خلال دالة بناء الصنف الوارث باستخدام مهيء العضو ( : ) .
مثال : يوضح هذا البرنامج كيفية استدعاء دوال البناء والهدم للصنف الأساس والصنف المشتق .

كود PHP:

  [center]#include <iostream.h>

#include <cstdlib>          

using namespace std ;  

class point

{

public:

point ( int =0,int =0);

~point();

protected:

int x,y;

};

point::point(int a,int b)

{

x=a;

y=b;

cout<<"Point Constructor ["<<x<<','<<y<<']'<<endl;

}

point::~point()

{

cout<<"Point Destructor:["<<x<<','<<y<<']'<<endl;

system("PAUSE");

}

class circle:public point

{

public:

circle(double r=0,int x=0,int y=0);

~circle();

private:

double radius;

};

circle::circle(double r,int a,int b):point(a,b)

{

radius=r;

cout<<"Circle Constructor : radius is:"<<radius<<'['

<<x<<','<<y<<']'<<endl;

}

circle::~circle()

{

cout<<"Circle Destructor : Radius is :"<<radius

<<'['<<x<<','<<y<<']'<<endl;

system("PAUSE");

}

int main()

{

 {

  point p(11,22);

 }

circle circle1(4.5,72,29);

circle circle2(10,5,5);

      system("PAUSE");

      return 0;

}

[/center]

كما يظهر في هذا المثال لدينا دالة البناء Point والصنف circle الذي يرث من الصنف Point وراثة عامة Public كما يظهر في الشكل التالي :

كود PHP:

   class circle:public point

الأهم في هذا الكود هو أولوية استدعاء الدوال ، في الدالة الرئيسية main() لدينا الكود التالي :

كود PHP:

  [center]{

 {

  point p(11,22);

 }

circle circle1(4.5,72,29);

circle circle2(10,5,5);

      system("PAUSE");

      return 0;

}

[/center]

أول شيء لدينا الكائن P في مجال معين ( بين أقواس )

كود PHP:

  [center]{

  point p(11,22);

 }

 [/center]

في هذه الحالة يقوم باستدعاء دالة البناء point ومن ثم دالة الهدم مباشرة قبل الخروج من هذا المجال بحيث تكون المخرجات بالشكل التالي :.

كود PHP:

  Point Constructor [11,22]

كود PHP:

  [center]Point Destructor:[11,22][/center]

بعد ذلك لدينا اشتقاق للكائن circle1 ، وكما ذكرنا سابقاً في الملاحظات ( ملاحظة رقم 1) ، حيث يتم في البداية تنفيذ دالة البناء point أولاً ومن ثم دالة البناء لـ circle ، وكذا الحال مع الكائن circle2 بحيث تكون المخرجات بالشكل التالي :.

كود PHP:

  Point Constructor [72,29]

كود PHP:

  [center]Circle Constructor : radius is:4.5[72,29]

Point Constructor [5,5]

Circle Constructor : radius is:10[5,5][/center]

[CENTER]( لاحظ هنا يتم أولاً تنفيذ دوال البناء كلها قبل تنفيذ أي دالة هدم قبل الخروج من المجال المحدد ) .

بعد ذلك يتم استدعاء دوال هدم الصنف الوارث قبل الصنف الموروث بترتيب معاكس بحيث الناتج النهائي للبرنامج بكامل مخرجاته ستكون على النحو التالي ::..

كود PHP:

  [center]Point Constructor [11,22]

Point Destructor:[11,22]

Point Constructor [72,29]

Circle Constructor : radius is:4.5[72,29]

Point Constructor [5,5]

Circle Constructor : radius is:10[5,5]

Circle Destructor : Radius is :10[5,5]

Point Destructor:[5,5]

Circle Destructor : Radius is :4.5[72,29]

Point Destructor:[72,29]

 [/center]

* الوراثة المتعددة Multiple Inheritance :
تسمح لغة C++ لصنف ما أن يرث أكثر من صنف ، وهذا النوع من التوارث يتحقق بطريقتين :
1- الصنف الوارث يمكن أن يُستخدم كـصنف موروث من قبل صنف وارث آخر ويمكن توضيح ذلك بالهرمية التالية :

2- الصنف الوارث يمكن أن يرث أكثر من صنف موروث .
والصيغة العامة للتوارث في هذه الحالة هي :

كود PHP:

  [center]class derived :inheritanceType NameOfBaseClass1, inheritanceType NameOfBaseClass2, . . . , inheritanceType NameOfBaseClassN

{

Class Body

};

[/center]

ويمكن تمثيلها كما يظهر في الشكل التالي :.

# ملاحظات :
1- في حالة وراثة عدّة أصناف موروثة فإن دوال البناء يتم تنفيذها من اليسار إلى اليمين والعكس بالنسبة لدوال الهدم :

2- يتم إرسال المعاملات لدالة بناء الصنف الموروث ( الأصناف الموروثة ) من خلال دالة بناء الصنف الوارث .
مثال : على التوارث المتعدد ( الطريقة رقم 2 من الصورة السابقة ) :

كود PHP:

  [center]#include <iostream.h>

#include <cstdlib>          

using namespace std ;  

class B1

{

int a;

public:

B1(int x)

{

a=x;

}

int get_a()

{return a;

}

};

class D1:public B1

{

int b;

public:

D1(int x,int y):B1(y)

{

b=x;

}

int get_b()

{

return b;

}

};

class D2:public D1

{

int c;

public:

D2(int x,int y,int z):D1(y,z)

{

c=x;

}

void show()

{

cout<<get_a()<<"\n"<<get_b()<<"\n"<<c<<endl;

}};

int main()

{

int a,b,c;

cout<<"Entera,b,c \n";

cin>>a>>b>>c;

D2 ob(c,b,a);

ob.show();

      system("PAUSE");

      return 0;

}

[/center]

في هذا المثال ستكون هرمية التوارث :

كود PHP:

  1- B1 .       2-D1 .     3- D2.

بحيث لو كانت المدخلات :
1
2
3
سيكون الناتج أيضاً كما هو في المدخلات :
1
2
3
وهذا المثال آخر على الطريقة الثانية ( الشكل رقم 1 من الصورة السابقة )

كود PHP:

  [center]#include <iostream.h>

#include <cstdlib>          

using namespace std ;  

class B1

{

int a;

public:

B1(int x)

{

a=x;}

int get_a()

{return a;}};

class D1

{

int b;

public:

D1(int x)

{

b=x;}

int get_b()

{return b;}};

class D2:public D1,public B1

{

int c;

public:

D2(int x,int y,int z):D1(y),B1(z)

{c=x;}

void show()

{

cout<<get_a()<<"\n"<<get_b()<<"\n"<<c<<endl;

}};

int main()

{

int a,b,c;

cout<<"Entera,b,c \n";

cin>>a>>b>>c;

D2 ob(c,b,a);

ob.show();

      system("PAUSE");

      return 0;

} 

[/center]

وهذا المثال يوضح كيفية استدعاء دوال البناء والهدم في حال وجود عدّة أصناف موروثة :

كود PHP:

  [center]#include <iostream.h>

#include <cstdlib>          

using namespace std ;  

class B1

{

public:

B1()

{

cout<<"B1 Construcor\n";

}

~B1()

{

cout<<"B1 Destrucor\n";

system("PAUSE");

}

};

class B2

{

public:

B2()

{

cout<<"B2 Construcor\n";

}

~B2()

{

cout<<"B2 Destrucor\n";

system("PAUSE");

}

};

class D:public B1,public B2

{

public:

D()

{

cout<<"D Construcor\n";

}

~D()

{

cout<<"D Destrucor\n";

system("PAUSE");

}

};

int main()

{

B1 ob1;

{

B2 ob2;

}

D ob;

      system("PAUSE");

      return 0;

}

[/center]

يجب التنويه بنقطة ذكرناها سابقاً وهي عند يتم أولاً تنفيذ دوال البناء كلها قبل تنفيذ أي دالة هدم قبل الخروج من المجال المحدد ، وسبق شرح هذه النقطة سابقاً ، وستكون مخرجات هذا البرنامج بالشكل التالي ::.

كود PHP:

  [center]B1 Construcor

B2 Construcor

B2 Destrucor

B1 Construcor

B2 Construcor

D Construcor

D Destrucor

B2 Destrucor

B1 Destrucor

B1 Destrucor

 [/center]

* الصنف الموروث الوهمي Virtual Base Class :
في حالة الوراثة المباشرة لعدة أصناف قد تحدث بعض المشاكل ولفهمها نناقش الهرمية التالية للتوارث :

في هذه الحالة يتم توارث الصنف base1 مرتين في الصنف derived3 مرتين ، مرة من خلال dervied1 ومرة أخرى من خلال الصنف dervied2 .
مما يؤدي إلى ازدواجية عند الوصول أو إرسال المعاملات إلى أعضاء الصنف base1 وفي هذه الحالة يظهر الاستفسار التالي :
- هل يتم إرسال المعاملات إلى الصنف base1 عن طريق derived1 أو عن طريق derived2 ؟
ولحل هذه المشكلة "الازدواجية" توجد في لغة C++ آلية تعمل على إيجاد نسخة واحدة من الصنف الوارث derived3 في الصنف الموروث base1 وهذه الآلية تعرف بالصنف الموروث الوهمي .
* مثال على الصنف الموروث الوهمي :

كود PHP:

  [center]#include <iostream.h>

#include <cstdlib>          

using namespace std ;  

 class base

 {

 public:

 int i;

 };

 class derived1:virtual public base

 {

 public:

 int j;

 };

 class derived2:virtual public base

 {

 public:

 int k;

 };

 class derived3:public derived1,public derived2

 {

 public:

 int protect()

 {

 return i*j*k;}};

int main()

{

 derived3 ob;

 cout<<"Enter i,j,k\n";

 cin>>ob.i>>ob.j>>ob.k;

 cout<<"Result = "<<ob.protect()<<endl;

      system("PAUSE");

      return 0;

}

[/center]

ويلاحظ في هذا الكود هو إضافة الكلمة المفتاحية Virtual في كل من ::..

كود PHP:

  class derived1:virtual public base

كود PHP:

  class derived2:virtual public base

والباقي لا جديد فيه ..

واخيراا ...اتمنى ان يكون الدرس مفييد ...

واستفاد منه الجميع ..

دمتم جميعا بود ...

**lovely_roro** · 25-05-2009, 03:52 PM

نورتي بربوش ...

ما ننحرم من الطلة الحلوة يا رب ....

دمت ....

مواضيع ذات صلة
الموضوع	الكاتب	المجلس	المشاركات	المشاركة الأخيرة
لن انساك حبيبي	mariam08	الخواطر والشعر الفصيح	21	28-02-2006 04:27 AM

أدوات الموضوع
عرض صفحة الطباعة إرسال هذه الصفحة إلى صديق