CSC-SY

Computer SCience in SYria، CSC-SY موقع يجمع طلاب كليات الهندسة المعلوماتية بجامعات دمشق وحلب والبعث وتشرين وغيرها من الجامعات الخاصة والمؤسسات التعليمية بالإضافة إلى المدرسين والباحثين والعاملين والمهتمين بمختلف مجالات علوم الكمبيوتر وتطبيقاتها وتقنياتها في سوريا.

 

انطلق الموقع رسمياً في 24 كانون الثاني عام 2004 نتيجة جهود مجموعة صغيرة من طلاب السنة الثالثة في كليات الهندسة المعلوماتية بالجامعات الأربعة المذكورة، واعتمد على نظام مبني على PHP-Nuke في تصميم أقسامه وتوفير خدماته التي عكست متطلبات أعضاء الموقع من الطلاب بشكل أساسي. 

تعرض الموقع لتغيير نطاق في بداية عام 2005، وفي 1 تشرين الأول من العام نفسه تبنى الموقع نظام Drupal مقدماً بذلك مرافق جديدة ذات خصائص متقدمة تتيح تكامل أفضل لأقسامه وقيمة أكبر لمحتواه.

 

يدار الموقع من قبل أربع مدراء من طلاب كليات الهندسة المعلوماتية بالجامعات الأربعة كما يقوم بالإشراف على نشاطاته عدد من المشرفين المخولين من قبل المدراء.

يسود الموقع جو من الوفاق والتعاون بين أعضاءه في سبيل إغناء مضمونه وتوسيع قاعدته وربطه بالحياة الجامعية والواقع المعلوماتي في سوريا.

 

تم اللقاء الرسمي الأول لأعضاء الموقع في 7 شباط 2005 في مدينة اللاذقية.

 

استفسارات الأعضاء حول مادة البرمجة 3

 

السؤال الجواب

إذا كان عنا ال class

class c

{

int x;

public:

c()

operator int() }

c c1; شو يعني هالتعليمة int a=(int)c1 ؟؟؟؟

التعليمة يلي مكتوبة هي بتحول الغرض (c1) إلى النمط (int), وهو ما يدعى (casting)...أي التحويل من نمط إلى نمط آخر من خلال وضع اسم النمط المطلوب ضمن قوسين قبل الغرض الأصلي و تتطلب هذه العملية تعريف العملية(operator) الموجودة:operator int()
بس بظن الغلط أنو التابع الأخير مو موجود الو جسم وأقترح تعريفه كما يلي:
int operator int (){
return x;}...
int يلي حاططا هي اسم الـoperator يعني متل وقت منعيد تعريف العملية + (+operator)...
بالنسبة للcast انت يلي بتجددي نوعا من خلال النمط يلي بتحطي اسم و شو النوع يلي بيعيدو التابع(و المفروض يكون نفس بعض)...
يعني ال cast ممكن تكون لأي نوع أساسي ...
------------------------------------------------------------------------------------------------
First:
You must look out for the simple mistakes you have done up there!
Second:
The operator you have defined is called a cast operater, it is used to cast your entire object into some other type! (in this case to an int), you may as well cast to any other primitive (float, char...)all in the same way... just define the correct operator, but you don't need to cast down in the main function you just type:
int a=cl;
Third:
And by the way, to do the exact opposite of that,i.e. make an object out of an integer value just define a constructor with one int parameter: i.e.:
c(int m){x=m};
شباب إذا في مجال حدا يشرحلنا معناة auto , register , static , extern في الصفحة 51,52,53,54 في السلايد الراب

هلئ static معناها أنو هاد المتحول ثابت, يعني يعرف مرة وحدة خلال البرنامج و يحافظ على قيمته... يعني اذا كنت معرفة بقلب تابع المتحول من نوع static بينحجز بالذاكرة عند أول استدعاء للتابع و بينحفظ بالذاكرة لنهاية تنفيذ البرنامج, يعني لو استدعي التابع أكتر من مرة ما حينحجز هاد المتحول مرة تانية و بتتنفذ التعليمات على المتحول اللي نحجز أول مرة وبيحافظ على قيمتو بعد انتهاء تنفيذ التابع, وعند الاستدعاء التالي منتعامل مع المتحول نفسو وبنفس القيمة يلي كان بيحملا قبل ما ينتهي التنفيذ السابق للتابع...
ان شاء الله تكون وضحت الفكرة...

------------------------------------------------------------------------------------------

رح اشرحلك الـ extern لأنو بشغلي بالـ ++C ما مر معي غيرها هي والـ static

الـ extern معناها انو المتحول المطلوب معرف بملف تاني غير الملف الحالي

يعني مثلا لو كنت معرف متحول بملف اسمو int i

وحبيت تستعملو بملف تاني بتكتب بس

extern int i

بالملف التاني وهيك بروح الـ compiler بدور على هالمتحول بالملفات اللي عامللها include انت بداخل الملف التاني

ان شاء الله تكون وضحت الفكرة !!

-----------------------------------------------------------------------------------------------

بالنسبة للregister and auto فهنن للتصريح عن متحولات اتوماتيكية يعني وقت بتحطن- قبل تعريف المتحولات- بيقى التعامل مع المتحولات فعال ضمن الكتلة
يلي عرفت بقلبها المتحولات وتدمر هي المتحولات بعد تجاوز الكتلة وبالتالي منقدر نصنف المتحولات المحلية انها من هاد النمط..
والفرق بين هل الكلمتين انو register بيطلب من compiler وضع قيم المتحول ضمن احد سجلات الحاسب بدلا من انو يحطها في الذاكرة(مشان سرعة التنفيذ)
وعلى كلا بالمختصر الcompiler بميز المتحولا ت المحلية دون الحاجة ان تكتبهن قبل التصريح عن المتحول

---------------------------------------------------------------------------------------------

الstatic :
إذا عرفنا متحول داخل تابع على أنه static ، واستدعينا هالتابع لأكتر من مرة، مثلاً استدعيناه داخل حلقة for ، بكل مرة عم ياخد المتحول القيمة الجديدة اللي حصل عليها من التغيرات اللي صارت عليه بالتابع...
أما ال auto فهو متل الlocal variable يعني إذا كان عنا متحول دخل لتابع، وكان هالتابع ما بيرجع شي، فإذا طبعنا قيمة هالمتحول هاد بعد استدعاء التابع مارح تتغير قيمته..
وكل أنواع المتحولات هي لما بينتهي تنفيذ البرنامج بتخسر قيمها.
بس كأنو لاحظت أنو الstatic هو الوحيد اللي بيحافظ على التغيرات اللي بتصير عليه.

---------------------------------------------------------------------------------------------

#include <iostream.h>

int *p;

void test()
{
static int u=6;
p=&u;
cout<<*p<<endl;
}

void main()
{
p=new int;
test();
cout<<*p<<endl;
}

 

في شغلة باول سلايد عم تحكي علىoutput-cerr

#include
#include
int main ()
{
ofstream
out("\&quotWink;
if (!out)

{
cerr<
exit(1);

بظن أنو هاي متعلقة بالـ(Files) لأنو الـ(ofstream) بظن أنو تابع للخرج على الملفات...أما (cerr) فهو تابع بيظهر رسالة خطأ يعني متل (cout) بس بدل ما يكون الخرج على شاشة الDos الخرج بيكون على شكل رسالة خطأ...

----------------------------------------------------------------------------------------------------------------------------------

أول شي مشان الـ cerr .. هي متل الـ cout ما بتختلف عنها شي بس لتدل انو هي الرسالة هي رسالة خطأ ...

انو وقت بدنا لتابع يردلنا عنوان لمتحول لازم بقلب التابع نعرف المتحول المطلوب على انو من نمط static حصريا لانو اذا ما عرفنا من هاد النمط فالتابع لح يرجع
المتحول من نمط اتوماتيكي والمتحول الاتوماتيكي ما بيحتفظ بقيمته خارج التابع وبالتالي ما لح نعرف شو هي القيمة يلي حيرجعها التابع .....

ومشان فكرة static لما بدنا يردلنا التابع عنوان شي متحول ... فما بتصور انو هالكلام صح

شو يعني متحول static معرف بداخل تابع .. هالشي بيعني ان المتحول بيحتفظ بقيمته من استدعاء إلى آخر للتابع وما بيرجع للقيمة 0 مثلا اذا كان int ..

وبالنسبة للطريقة اللي ذكرتيها مشان اعادة عنوان المتحول فهي بتعتمد على فكرة انو المتحول الـ static بيبقى بالذاكرة ... وما بموت مشان هيك بقدر استعملو من عنوانو ايمتا ما بدي ... بس هالشي غلط (ليس برمجي ولكن خطأ بالمفهوم)

أصلا لما بعرف متحول داخلي بتابع فما في أي معنى أبدا لإني رجع عنوانو ..

اما برجع متحول Int كامل بيحوي قيمة المتحول أو بعرفو برا التابع وبمررو by reference للتابع وبترجع فيه القيمة اللي بدي ياها نتيجة عمليات داخل التابع

اما اني عرف متحول static داخل تابع ورجع عنوانو فما الها اي فائدة عملية ابدا

شو هاد الماكرو؟؟؟؟؟؟؟؟؟؟؟؟
شو بفيد
وشو بيفرق عن التوابع العادية؟؟
وإمتى بستخدمو؟؟

الماكرو هو ماكرو بشكل أساسي قبل ما يكون أي شي تاني Smile

 

بيفرق عن التابع العادي انو بيتنفذ بالـ compile time يعني بدل ما وقت التنفيذ نبدل التابع بتعليماتو ... وقت الترجمة بيحط الcompiler التعليمات المناسبة مكان الاستدعاء

وبالتالي بصير التنفيذ أسرع

 

inline function نفس الشي وهي انو نكتب تابع ونكتب قبلو كملة inline بصير الـ compiler يبدل التعليمات وقت الترجمة

بس ما لازم يكون التابع طويل كتير

وممكن الـ compiler يتجاهل كلمة inline اذا شاف انو التابع ما ممكن يكون inline

----------------------------------------------

أما بالنسبة للماكرو في المثال مستدعين التابع للقيمة a++ وهيك عما يبدل كل قيمة للمتحول داخل التابع ب a++ مشان هيك عما تزداد قيمتو 3 مرات كل استدعاء.

بس في سوال تاني عن الموشرات
اذا كان عنا مصفوفة وموشر p يبياخد قيمة بدائية اسم المصفوفة ....بقا شو الفرق بين ++p* وp++*؟

هلأ الزيادة الخلفية ++P والتأشير P* لها نفس الاولوية وهي تجميعية من اليمين.............لذلك:
التعبير ++p* يعني العنصر التالي للعنصر p في المصفوفة او الذاكرة
أما الزيادة الامامية P++ فهي اعلى في الاولوية من p* ولذلك
التعبير P++* يكافئ (p++)* يعني كمان العنصر التالي في المصفوفة
بس بظن لازم يكون في اقواس...............أين مر معك هذا التعبير

-----------------------------------------------------------------------

++p* بتزيد (1) على قيمة المؤشر وبالتالي بينتقل للعنصر التاني من المصفوفة وبعدين بياخد عن طريق (*) قيمة العنصر

أما p++* بتزيد (1) للمؤشر وبتاخد ما يؤشر إليه كمان

يعني باختصار ولا وحدة منون رح تزيد شي على قيمة الرقم الموجود بالمصفوفة

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

بس مثلا لو كنت عم اطبع ... بالأولى رح يطبع محتوى p وبعدين ينقل p للأمام

أما التانية رح ينقل P للأمام وبعدين يطبع المحتوى

تماما متل مبدأ i++ و ++i

 

إذا حدا بيتكرم علينا وبيعطينا فكرة مختصرة عن ال operator overloading يعني فكرة شاملة وله جزيل الشكر.

الـOperator overloading يعني التحميل الزائد للعمليات متل الجمع (+), الضرب(*), (>,<,==,...) وهيك...
مبدأها: أنو هدول العمليات هنن توابع عادية بس اسمهون +operator مثلا و وقت الاستدعاء بتقدر تشيل الحاشية يلي ما الا داعي (كلمة operatorو المعامل تبعها)...
وبنصح تقرا السلايدات والأمثلة منيح...وان شاء الله تكون وصلت الفكرة....

------------------------------------------------------------------------------------

يعني رح وضح الفكرة مباشرة عن طريق مثال

لو كان عنا عددين i و j من نمط int ببساطة يمكن أن نطبق إحدى العمليات المعرفة في لغة ++C عليهما فورا مثل الجمع +أو الطرح - ... الخ

بجوز تقول انو الموضوع بسيط بس هو لأ ...

الفكرة انو اللغة مكتوبة بحيث تقبل عملية الجمع إذا كان على يمينها ويسارها int

هلأ لو كان عنا صف اسمو مثلا Complex بيمثل العدد العقدي وفيه 2 data members اللي هنن float realPart القسم الحقيقي و float imaginaryPart اللي هو القسم التخيلي

لو عرفت متحولين من هذا الصف c1 و c2 و متحول تالت c3 وكتبت c3 = c1 + c2

ما رح يقبل الـ Compiler هالسطر ورح يقلك انو عملية الجمع ما معرفة على هيك نمط

فالمطلوب هو انك ترجع تعرف العملية على هذا الصف بحيث تقوم باللي انت بدك ياه

واللي هو بحالتنا انو تجمع القسم الحقيقي للأول مع القسم الحقيقي للثاني وتحط الناتج بالثالث ونفس الشي القسم التخيلي

هي مبدؤها

مشان الـ syntax كيف بتنكتب راجع السلايدات واذا كان في مشكلة بوضحها ان شاء الله

 

سؤال عن المصفوفة الديناميكية :
شو يعني .. وشو بتفرق عن المصفوفة العادية .. لأن شفتها بسؤال دورة السنة الماضية .. وبصراحة هي أول مرة بسمع فيها

المصفوفة الديناميكية من اسمها: هي مصفوفة ما بتحددي حجما وقت تعرفيا, وانما بتحجزي الحجم يلي بدك من خلال التعليمة (new)...
هاد فرقا الوحيد عن المصفوفة العادية... والفائدة منا أنو انت ممكن تكوني ما بتعرفي اديش الحجم المطلوب وقت البرمجة بقا بتعرفي مصفوفة ديناميكية وبتحجزي الحجم من خلال تحديد طولا بمتحول من النوع int بتقدري تخلي المستخدم يدخلو ومشان الكود تبعا راجعي السلايدات

-------------------------------------------------------------------

المصفوفة العادية static هي اللي بتكون معرفة بالشكل العادي اللي منعرفو int a[10]; // static

وهي مضطرين نحدد فيها بعد المصفوفة وقت كتابة البرنامج

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

وممكن ما يحتاج غير 1 وهيك بكون حجز مساحة عالفاضي ولازم الرقم يكون عدد ثابت ما بصير يكون متحول ...

الحل هو بالحجز الديناميكي وقت التنفيذ

متل ما منعرف انو المصفوفة هي مؤشر على أول عنصر فيها وبدل ما اكتب التعريف كما سبق بعرفها على شكل مؤشر صريح كالتالي

int* p = null

ووقت اعرف اديش بيلزمني .. (مثلا ممكن اقرأ الرقم من الدخل n)

بعمل p = new int[n]; // dynamic

وبتصير p بتأشر على أول عنصر من مصفوفة int بعدها n ... ومنستعملها عادي

p[i] // get item number i in array

وفي فرق كمان (بس لزيادة العلم) انو المتحولات كلها بالبرنامج بما فيها المصفوفات الـ static بتنحجز بالـ stack اللي مساحتو صغيرة مشان هيك ما منقدر نعرف كتير متحولات وبيطلعلنا أحيانا بالعودية stack over flow

اما الحجز الديناميكي بالمؤشرات بصير بالـ heap وهي حجمها كبير كتير

 

شو منقصد باستخدامنا & باسم التابع

int & new_index (int a[],int i){

...

return a[i-1];

}

هي ما لاسم التابع

هي للنوع اللي عم يرجعو التابع اللي هو &int ..

يعني عنوان لمتحول int وليس المتحول نفسو .....

يا ريت حدا يوضحلي الـ this

والمثال اللي بـ C8-Classes2

page 23

this باختصار هي مؤشر للـ object الحالي من الصف

يعني لو كان عندي بأحد توابع الصف this->x

لما بعرف Student s ... وبستدعي التابع اللي بيحوي التعلمية الماضية بكون المقصود هو الـ x الخاصة بـ s ..

وبالنسبة للمثال بس هو كاتب method بالـ class بتاخد متحول من نفس نوع الـ class وبتشوف اذا هالـ object اللي مررناه هو نفسو اللي استدعينا منو التابع ...

عن طريق الـ this ممكن اعرف هالشي

يعني هي بدها شرح أكتر من هيك .. بس حاولت وضح الفكرة الاساسية باختصار

هلأ في بالسلايدات مثال :

int *iptr
if(true)
{
int p=5
iptr=&p
}
cout *iptr

هلأ مو لازم بعد ال scope يضيع المؤشر .. يعني ما يعود يأشر على 5 ويطبع قيمة عشوائية .. ؟؟؟

الدكتور هيك كاتب ...
بس أنا وقت جربته ما صار هيك وطبعلي 5 ... ولما جربته على تابع .. يعني لما خليت ال p معرف داخل حدود التابع بس .. وطبعت المؤشر بال main طبع قيمة عشوائية ..
كيف هيك صار مع إنو نفس الحالة ؟؟ !!!!!!!!

هلآ iptr عما يأشر على موقع P قبل نهاية ال scope بس بعد ال scope p رح تروح بس iptr لسعتو عما يأشر على موقع (يلي هو موقع p سابقا وهل موقع في قيمة (5) وهالموقع بتتغير قيمتو وقت بيجي متحول تاني محلو (يعني الفكرة إنو iptr عم يأشر عل موقع بس ما حجزو ) حسب ما فهمت.

 

سؤال :
إذا مان لدينا مايلي :
int a = 5;
const int * u = &a;
int b = 6;
int * const v = &b;
شو الفرق بينهما وإنا طبقتون عل حاسب : طلع الفرق بينهما إنو فقط لانستطيع التعديل على (*v)

أخي عبيدة ...

لاستعمال const مع المؤشرات أربع حالات مختلفة ...

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

1. مؤشر متغير على قيمة متغيرة: من الاسم واضح انو بقدر غير قيمة المؤشر والقيمة اللي بأشر عليها وهي الحالة العامة اللي منستعملها عادة متل

int i = 3

int* p = & i

بقدر بأي تعليمة بعد الإسناد أسند عنوان جديد للمؤشر p أو أسند قيمة لما يؤشر إليه p*

وبتصور هي بسيطة

2. مؤشر متغير إلى قيمة ثابتة: متل التالي

const int* p

وهي معناها المؤشر p هو مؤشر إلى قيمة int ثابتة .. يعني ممكن لسهولة الفهم نعتبر const int كلها هي النمط اللي بأشر إليه p

هون القيمة اللي بأشر عليها التابع لا يمكن أن تتغير .. يعني ما بصير أسند شي لـ p*

ممكن اكتب p = &i .. بس ما بصير اكتب p = 10* .. لأنو القيمة اللي بأشر عليها ثابتة ولا تتغير (هيك بكون حميت القيمة اللي بأشر عليها p من التعديل)

 

3. مؤشر ثابت إلى قيمة متغيرة: يعني p* ممكن تتغير وقت بدنا ... بس p ما منقدر نأسندلها اي شي لأنو المؤشر ثابت .. (يعني يؤشر على نفس الموقع دائما) طبعا بعطيه العنوان وقت التعريف (قيمة ابتدائية) متل

int i

int* const p = & i

لاحظ انو كتبنا const قبل المؤشر للدلالة انو المؤشر هو الثابت وليس القيمة اللي بأشر عليها

وما بصير بعد التعريف نكتب p = &i بس ممكن نكتب p = 10*

 

4. مؤشر ثابت إلى قيمة ثابتة: وهي أكتر الأنواع restricted وفيها ما منقدر نغير القيمة اللي بأشر عليها ولا نغير الموقع اللي بأشر عليه

p = 10* ممنوع ، p = &i ممنوع

بس منعطي القيمة وقت التعريف

int i = 10

const int * const p = & i
سؤال بالclasses :
شو بيعمل الcopy constructor ؟؟ فهمت أنو يستدعى لما منكون بدنا نأسند object لobject تاني، طيب بيسمح أنو نعمل اسناد فوراً بيناتهن باستخدام =؟؟
بس ساويت class وحطيت فيه copy constructor وأسندت متحولين من هالclass لبعضهن، بس ما استدعى ال copy constructor!!!! وصارت عملية الاسناد عادي!!!! وحتى لما حذفت هاد الconstructor مشي الحال تمت عليمة الاسناد عادي!!
طيب إذا هيك معناها شو فرق ال copy constructor عن التحميل لعملية ال= !!!!
وفرق بين الdeep and shallow constructor أنو الdeep بيعمل نسخة مو بس للobject وللمؤشرات اللي ضمن الobject ؟؟؟
وأنو لما بدنا نعمل اسناد بين 2 objects كمان بينسخ المؤشرات؟؟؟
شغلة تانية:
لما بيكون عنا const object ما بيصير نستخدم معو إلا const functions أو الconstructor صح؟؟؟ أما إذا كان object عادي فينا نستعمل معو أي تابع؟
ولما بيكون عنا const member ما بيصير كمان نستخدم معو إلا const function ، والmembers الباقيين فينا نستخدم معهن شو ما بدنا؟؟

مشان الـ copy constructor ... يتم استدعاؤه بـ 3 حالات

أول شي لما عرف object جديد من الصف وابعتلو نسخة من object قديم يعني متل

Student s1

Student s2(s1) // this is a copy constructor call

حالة تانية هي وقت إسناد object لـ object من نفس النمط متل

s2 = s1

هلأ بدون copy constructor تتم العملية من دون مشاكل بالـ compiling بس وقت التنفيذ اللي رح يصير هون انو رح تنسخ الـ data members من s1 إلى s2 واللي هي int أو float أو اي نوع آخر بسيط أما المصفوفات والمؤشرات فرح ينسخ العنوان تبعها وبالتالي بتصير المؤشرات الموجودة بـ s1 و s2 عم تأشر على نفس المتحولات اللي هي اللي بتأشر عليها مؤشرات s1 .. والآن اذا هدمنا s1 .. رح يروح كلشي بيأشر عليه مؤشرات s2 .. هيدا اسمو shallow copy .. ولحل المشكلة منضيف copy constructor مننسخ فيه بايدنا المصفوفات أو القيم اللي بتأشر عليها المؤشرات وهيدا اسمو deep copy ... وطبعا يتم استدعاء الـ copy constructor بشكل تلقائي عند الإسناد

الحالة التالتة التي يتم فيها استدعاء الـ copy constructor هي عند تمرير object من الصف كوسيط لأحد التوابع بالقيمة ( بدون & ) ... وقتها يتم استدعاء الـ copy constructor لعمل نسخة من الـ object متل أي متحول وإرسالها للتابع ... بس لا تنسو الملاحظة الهامة انو إذا كان التمرير بالعنوان & ... ما في داعي للنسخ ... !!!

بتمنى كون وضحت تماما فكرة الـ deep & shallow copy و الـ copy constructor

hey when do we write the constructer in this way

A ( int l, int r)
{ nl= 1, nr=r;}

and when do we write it in this way
A ( int l, int r)
: nl(l),nr(r){}

الطريقتين صح

بس التانية هي منقدر نعمل من خلالها إسناد للقيم خارج الـ body تبع الـ constructor ...

في سلايد ال polymorphism :
المثال الأخير لماذا تم استخدام Dynamic_cast من ال class الأب إلى ال class الإبن.
 
بس ممكن حدا يوضحلنا الفرق بين بين التابعين (ما بياخد شي) cin.get و (بتاخد وسطاء) cin.get
وشو بيعمل التابع strcspn ؟

strcspn(s1,s2)
يبحث في s1 عن أي ورود لأي محرف من s2 ويعيد فهرس أول محرف موافق في s1 ويرجع طول s1 إذا لم يجد أي محرف موافق.

------------------------------------------------------------------------------------

cin.get بدون وسطاء بيقرا حرف

cin.get مع وسطاء ... بياخد المتحول اللي بدو يعبي فيه السلسلة النصية

وعدد الحروف اللي بدو يقراها

وأخيرا المحرف اللي بيوقف عندو وغالبا منحطو /n يعني نهاية السطر

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

 

هلأ في إلها شروط متل أنو ما يكون في تغيير بعدد الباراميترات الممررة للعملية متل أنو عملية الجمع بتاخد باراميترين وما بيصير نعطيها واحد أون تلاتة...

 

bool array::operation == (const array & ) const;

هلأ هي شو يعني ؟؟؟

وليش في أمبرساين عند الأرري وليش الconst بالأخير

هلأ من شان ال(ref)عند ال(array)فهي بس لتسريع البرنامج وأما ال(const)فهي منشان يقدر أي (object)ساكن أنو يقوم بهالعملية المحملة بشكل زائد.إن شاء الله تكون وصلت الفكرة.

-----------------------------------------------------------------------------------------------

على فكرة & عند الـ array حتى لو ما حطيتها نفس الشي

الهدف منها انو نسرع عملية التمرير للتابع ونعملها تمرير بالعنوان وليس بالقيمة مشان ما نعمل نسخة خاصة للتابع من المتحول

بس المصفوفة هي اصلا عنوان أول عنصر فيها .. يعني حتى لو ما حطيتها نفس الشي

والـ const بآخر السطر .. أما الـ const قبل المصفوفة فهي منحطها قبل أي متحول وسيط ممرر لتابع مشان نضمن انو ما تتعدل قيمتو داخل التابع

 

فيكن ترجعو لدروس ال++C الموجودة في قسم الملفات في الموقع -> جامعة دمشق.