حاسبات (لغة البرمجة ++c

overloading

مقدمة: Introduction

العملية: هي استدعاء لتابع من اجل أن يقوم بتنفيذ هذه العملية وقد تتوفر عدة توابع تابعة لعملية واحدة ويتحدد التابع من نوع العناصر الموجودة بجوار هذه العملية وهذه التوابع الكثيرة لعملية واحدة تعبر عن التحميل الزائد لها. إن الغاية من التحميل الزائد هو إضافة عمل على عملية لم تكن تقوم به قبل الإضافة (ويمكن ذلك عندما تختلف أنواع المعاملات على أحد أو كلا طرفي العملية), وكذلك استخدام العمليات المطبقة على الأنماط القياسية على الأنماط التي يعرفها المستخدم.
من أهم ميزات التحميل الزائد هي زيادة الوضوح والتبسيط في البرنامج.
إن بعض العمليات محملة بشكل زائد مثل عملية الإدخال والإخراج >> و << حيث تستخدم >> من أجل الإدخال ضمن إحدى مجاري الدخل( ومن ثم إلى الذاكرة) وكذلك الإزاحة بمقدار مرتبة إلى اليمين (أي التقسيم على اثنين) وهذا مثال لعمل عملية>> عملين مختلفين وفق المهمة وهو ما يدعى بالتحميل الزائد وكذلك عملية الإخراج والإزاحة نحو اليسار (أي الضرب باثنين).
مثال آخر: العمليات الحسابية +, - التي تنفذ مع عدة أنماط من المعطيات فهى محملة بشكل زائد حيث تعمل عمل مختلف ويتبع ذلك لنوع القيم الموجودة على طرفيها( صحيح, حقيقي, مؤشر ... ).

ملاحظة : لغة C++ لا تسمح بتعريف عمليات جديدة , وإنما تملك ميزة السماح بتحميل العمليات الموجودة بمعان لم تكن مرتبطة بها من قبل وهذه من أهم ميزاتها والتي تجعل منها لغة قابلة للتطوير.

أساسيات التحميل الزائد للعمليات Fundamentals of operator overloading

إن عملية البرمجة بلغة C++ عملية مرتبطة بالأنماط ومقادة بها أي يمكن استخدام الأنماط المعرفة مسبقاً ويمكن تعريف أنماط جديدة ويمكن استخدام العمليات المتوفرة مع الأنماط التي يتم تعريفها.
لقد درسنا فيما سبق الطبقة Time ورأينا أنه لجمع كائنين من الصنف Time كان لابد من نداء التابع add باستخدام إحدى الكائنات المشتقة من الصنف ذاته, كذلك الأمر كان طرح زمن من زمن يحتاج إلى الشيء ذاته.
- أي إن التعامل مع الكائنات يتم من خلال إرسال رسائل إلى هذه الكائنات وهذه الرسائل تكون على شكل استدعاء لتوابع.
- تعتبر هذه الطريقة مزعجة عند التعامل مع بعض الطبقات كالطبقات الرياضية التي يفضل أن يتم التعامل معها من خلال المجموعة الغنية للعمليات المعرفة مسبقاً في لغة C++ . سوف نبين في هذا الفصل كيف يمكن لكائنات طبقة أن تصبح قادرة على استخدام عمليات لغة C++ . وسوف نسمي عملية التعامل هذه بالتحميل الزائد للعمليات operator overloading .

يجري التحميل الزائد للعمليات بعد كتابة تعريف التابع ( مؤلف من رأس التابع وجسمه) يختلف هذا التابع عن غيره في أن اسمه يتألف من الكلمة المفتاحية operator متبوعة بإشارة العملية المطلوب تحميلها بشكل زائد, فمثلاً لتحميل عملية الضرب * بشكل زائد نكتب اسم التابع operator* .
لتطبيق عملية على كائنات طبقة عرفها المستخدم يجب أن تكون تلك العملية محملة بشكل زائد إلا أن هناك استثناءان اثنان في أن بعض العمليات محملة بشكل زائد سلفاً.
1- عملية الإسناد: (=) التي يمكن استخدامها مع الكائنات بدون أي تعريف ظاهري لتحميلها بشل زائد, حيث أنها تقوم بشكل افتراضي بنسخ المعطيات الأعضاء من طبقة إلى طبقة أخرى مماثلة, ولكن لهذه العملية محاذير وخطورة عندما تتضمن الطبقة أعضاء تؤشر على مناطق محجوزة ديناميكياً في الذاكرة. ويتم تجاوز المشكلة المذكورة من خلال ذكر تعريف واضح لطريقة التحميل الزائد لعملية الإسناد على هذا النوع من الطبقات.
2- يمكن استخدام عملية العنونة & مع الكائنات أي طبقة بدون أي تحميل زائد لها فهي تعيد عنوان الكائن ضمن الذاكرة, ولكن أيضاً يمكن تحميل العنونة يشكل زائد.



قيود التحميل الزائد Restrictions on operator overloading:
1- يمكن تحميل معظم عمليات لغة C++ بشكل زائد ويوجد أربع عمليات لا يمكن تحميلها بشكل زائد وهي: . .* :: ?:
والعمليات التي تحمل بشكل زائد منها:
+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= . << >> >>= <<= == != <= >= && || ++ -- ->* / -> [ ] ( ) new delete new[ ] delete[ ]

2- لا تتغير أولوية العملية بعد تحميلها بشكل زائد ( لا تتغير طريقة تجميعها أو افضليتها) ولا يمكن استخدام القيم الوسيطة الممره بشكل افتراضي مع هذه العمليات.
3- لا يمكن تغيير عدد المعاملات التي تقبلها عملية من خلال تحميلها بحمل زائد وبالتالي العملية الأحادية تبقى أحادية والثنائية تبقى ثنائية ولا تحمل العمليات الثلاثية ?: ومنها يملك صيغتين أحادية وثنائية مثل +,- ,*,& .
4- لا يمكن تعريف عملية جديدة وبالتالي كان مبرر التحميل الزائد أي تحميل العملية الموجودة بما كان على العملية الجديدة أن تقوم به.
5- لا يمكن تغيير عمل عملية وتبقى تقوم بما كانت تقوم إليه ويضاف إليها عمل زائد سواء على الكائنات المعرفة سابقا أو على الكائنات التي يعرفها المستخدم.
6- يجب أن يكون أحد وسطاء تابع عملية على الأقل كائن من كائنات طبقة ما أو عنوان لأحد الكائنات المعرفة مسبقاً يمنع ذلك المبرمج من تعديل طريقة تطبيق عملية على أغراض من أنماط معرفة مسبقاً.
7- عند الرغبة في كتابة الشكل التالي object1 = object2 + object3 يجب أن يتم تحميل + والنسب بشكل زائد وهذا الشكل لا يعني نفس العملية += ومن أجل تنفيذ object1 += object2 يجب تحميل العملية += بشكل زائد من أجل كائنات تلك الطبقة.
8- يفضل استخدام بعض عمليات التحميل الزائد لتطوير بعضها الآخر مثلاً قم باستخدام العملية + المحملة بشكل زائد لبناء العملية += المحملة بشكل زائد أيضاً هي الأخرى.

مقارنة بين توابع العمليات كتوابع أعضاء أو كتوابع عامة (غير أعضاء):
1- يمكن لتوابع العمليات أن تكون توابع أعضاء أو توابع غير أعضاء ( وإذا احتاجت الوصول إلى الجزء الخاص أو المحمي يجب جعلها توابع أصدقاء بهدف تحسين الأداء ) , تستطيع التوابع الأعضاء استخدام المؤشر this للوصول إلى أحد الوسطاء ككائن من الكائنات المرتبطة ضمنياً بهذه الطبقة, في حين يجب تحديد هذا الوسيط بشكل ظاهري في حاله استخدام توابع للعمليات غير أعضاء.
2- عند التحميل الزائد للعمليات ( ), [ ] , -> , = يجب التصريح عن توابع العمليات المرتبطة بها على أنها توابع أعضاء , أما بالنسبة لبقية العمليات فيمكن التصريح عن توابع العمليات المرتبطة بتحميلها الزائد على شكل توابع غير أعضاء, أو على شكل توابع أعضاء ولا تتغير طريقة عملها في كلا الحالتين.
3- عند كتابة تابع عملية على شكل تابع عضو فإن المعامل الموجود في أقصى يسار العملية يجب أن يكون كائن أو مرجع لكائن من كائنات العملية, سواء أكان هذا المعامل وحيد أم لا . وإذا كان هذا المعامل كائن من طبقة مختلفة أو من طبقة معرفة مسبقاً فيجب تعريف تابع العملية على شكل تابع غير عضو , تماماً كما سنرى عند تحميل مجاري الدخل والخرج بشكل زائد.
4- إذا كان تابع العملية المحملة بشكل زائد تابع غير عضو فيجب التصريح عنه كتابع صديق إذا كان يحتاج الوصول إلى الأعضاء الخاصة والمحمية في الطبقة, عندما نكتب cout<< object; نلاحظ أن الكائن على يسار العملية هو cout وهو من النمط ostream أما الكائن على يمين العملية فهو من طبقة ما مختلفة عن الطبقة ostream لذلك وجب استخدام تابع غير عضو لتحميل العملية << بشكل زائد ويمكن لهذا التابع غير العضو أن يحتاج الوصول إلى المعطيات الخاصة والمحمية في الطبقة لذلك يفضل الإعلان عنه كتابع غير عضو صديق للطبقة كما ذكرنا سابقاً. وفي حال أعلن عنه كتابع غير عضو وغير صديق يمكن استخدام توابع الوصول للوصول إلى المعطيات الخاصة والمحمية, لكن هذا يسيء إلى أداء البرنامج.
5- يمثل السبب الذي من أجله يمكن أن نلجأ إلى تعريف تابع غير عضو تابع عملية نرغب بتحميلها بشكل زائد , في أن نعطي العملية الصفة التبديلية. مثلاً إذا كان لدينا
objectclass2 + objectclass1 يمكن استخدام تابع عضو لتحميل العملية + في الطبقة class2 لكن إذا كنا نرغب بجعل العملية تبديلية أي objectclass1 + objectclass2 وجب تعريف تابع العملية + في الطبقة class1 على شكل تابع غير عضو ( صديق ) لأن الكائن على يسار العملية ليس من النوع class2 .

التحميل الزائد لمجاري الدخل والخرج:
لقد تم تحميل العمليتين >> و << بشكل زائد ( ضمن مكتبات الطبقات المتوفرة في C++ ) بحيث يمكن لها التعامل مع أنماط المعطيات المعيارية بما في ذلك سلاسل المحارف والعناوين , ويمكن أيضاً تحميل هاتين العمليتين بشكل زائد بحيث تصبحان قادرتين على إدخال وإخراج معطيات من أنماط معرفة من قبل المستخدم.
سنقوم بتطوير الطبقة Time المدروسة سابقاً بحيث يتم تحميل العمليتين >> و<< بشكل زائد لكي يمكن إخراج و إدخال الزمن بأمر واحد.

• تحميل العملية >> بشكل زائد : overloading operator >>
السؤال المطروح هل تابع العملية تابع عضو أم هو تابع صديق أم غير ذلك؟.
للإجابة على ذلك لنمعن النظر في العبارة cin>>object or cin>>t;
- الكائن على يسار العملية من النوع istream وأما العنصر على اليمين فهو من النوع Time وبما أن الكائن على يسار العملية ليس من النوع على اليمين Time لذلك وجب تحميل العملية >> بتابع غير عضو. وبما أن المعطيات المراد إدخالها هي hour, minute, second وهى معطيات خاصة في الطبقة Time لذلك وجب أن يكون تابع العملية تابع صديق حتى يمكن الوصول إلى المعطيات الخاصة في الطبقة.
ليكن لدينا البرنامج التالي:
#ifndef TIME1_H
#define TIME1_H
#include <iostream.h>

class Time {
friend istream& operator>>( istream& input , Time &t);
friend ostream& operator<<( ostream &output , Time &t);

//friend void operator>>(istream& input , Time& t); //1
//friend void operator<<(ostream& output , Time& t); //2

//friend Time operator + ( const Time &t, const Time &t1);

public:
Time(); // constructor
void setTime( int, int, int ); // set hour, minute, second
void Time::convert1();
Time operator + ( const Time &t);
Time operator += ( const Time &t);

private:
int hour; // 0 - 23 (24-hour clock format)
int minute; // 0 - 59
int second; // 0 - 59
}; // end class Time

#endif
//********END CLASS ********************/

#include "time1.h"
#include <iostream.h>
#include <iomanip.h>

Time::Time()
{ hour = minute = second = 0; } // end Time constructor

void Time::setTime( int h, int m, int s )
{ hour = ( h >= 0 && h < 24 ) ? h : 0;
minute = ( m >= 0 && m < 60 ) ? m : 0;
second = ( s >= 0 && s < 60 ) ? s : 0; } // end function setTime

/* overloading with non_member function(friend)
void operator >> ( istream &input , Time &t) //3
{ char ch; //4
input >> t.hour>>ch>> t.minute>>ch>> t.second ; //5
t.setTime(t.hour,t.minute,t.second); //6
}*/

/* // overloading with non_member function(friend)
void operator << ( ostream &output , Time &t) //7
{ output << t.hour<<":"<< t.minute<<":"<< t.second ;} //8*/

// overloading with non_member function (friend)
ostream& operator << ( ostream &output , Time &t)
{ output << t.hour<<":"<< t.minute<<":"<< t.second ;
return output; }

// overloading with non_member function (friend)
istream& operator>>( istream& input , Time &t)
{ char ch;
input >> t.hour>>ch>> t.minute>>ch>> t.second ;
t.setTime(t.hour,t.minute,t.second);
return input; }

// overloading with non_member function (friend)
/* Time operator + ( const Time &t, const Time &t1)
{ Time temp;
temp.hour = t1.hour + t.hour;
temp.minute = t1.minute + t.minute;
temp.second = t1.second + t.second;
temp.convert1();
return temp;
}*/

// overloading with member function
void Time::convert1()
{ if( second >=0 && second <60) second =second;
else {second = second - 60;minute++;}
if(minute >=0 && minute <60) minute = minute;
else { minute = minute -60;hour++;}
hour = (hour >=0 && hour <24)? hour: hour -24;
// day ++;
}
// overloading + with member function
Time Time::operator + ( const Time &t)
{ Time temp;
temp.hour = hour + t.hour;
temp.minute = minute + t. minute;
temp.second = second + t. second;
temp.convert1( );
return temp;
}
// overloading += with member function

Time Time::operator+= ( const Time& t)
{
hour = hour + t.hour;
minute = minute + t.minute;
second = second + t.second;
convert1();
return *this;
}
//********* END FILE FUNCTIONS *********************/

#include "time1.h"
#include <iostream.h>

int main()
{ //Time t1; //9
Time t1,t2,t3,t4;
cout << endl<<"input t1 format nn:nn:nn \n";

//overloading >>
// cin>>t1;
cin>>t1>>t2;
cout<<t1<<endl<<t2; cout<<"\n\n";
//overloading +
t3=t1+t2; cout<<t3<<endl<<endl;
//overloading +=
t3+=t1+=t2;
cout<<t3<<endl<<endl;
return 0;
}
//***********************/
إن تفعيل الأسطر من 1 إلى 9 يمكن من إدخال وإخراج زمن مره في كل أمر :
- وهو تابع غير عضو ( تابع صديق) وبما أن العملية ثنائية لذلك سيأخذ هذا التابع وسيطين الأول من نمط المعامل اليساري والثاني من نمط المعامل اليميني ونجد ذلك في المقطع التالي:

void operator >> ( istream &input , Time &t) //3
{ char ch; //4
input >> t.hour>>ch>> t.minute>>ch>> t.second ; //5
t.setTime(t.hour,t.minute,t.second); //6
}
هذا التابع سيسمح لنا بعمليات إدخال من الشكل:
cin>>t1;
أما من اجل عمليات إدخال متسلسلة فلا بد من إعادة الكائن input بالمرجع ليصبح التابع على الشكل التالي:
istream& operator>>( istream& input , Time &t)
{ char ch;
input >> t.hour>>ch>> t.minute>>ch>> t.second ;
t.setTime(t.hour,t.minute,t.second);
return input; }
هذا التابع سيسمح لنا بإدخال متسلسل مثل التالي : cin >> t1 >>t2 >>t3 ;
ويعرفان ضمن الصنف وفق ما يلي:
friend void operator>>(istream& input , Time& t);
friend istream& operator>>( istream& input , Time &t);

وبالمثل يمكن أن نصل تحميل عملية الإخراج <<; من خلال التابع التالي:

ostream& operator << ( ostream &output , Time &t)
{ output << t.hour<<":"<< t.minute<<":"<< t.second ;
return output; }

لقد تم النداء بالمرجع من أجل الكائن t من أجل تجنب عمليات النسخ و استخدام الثابت const للتأكد على منع تغيير الكائن.
في البرنامج الرئيسي
عند كتابة cin>>t1; سيتم نداء تابع العملية >> بالشكل التالي: .operator>>(cin,t1)
عند كتابةcout<<t1; سيتم نداء تابع العملية << بالشكل التالي: .operator<<(cout,t1)

- التابع setTime(): سيقوم بضبط الساعة على القيمة 0 في حال تم إدخال قيمة خارج المجال
[0 .. 23] وكذلك الأمر بالنسبة للدقائق على القيمة 0 في حال تم إدخال قيمة خارج المجال
[0 .. 59] وكذلك الأمر بالنسبة للثواني.
وتم تعريفة في القسم private لعدم الحاجة للوصول إليه من خارج الطبقة وله البنية التالية:
void Time::setTime( int h, int m, int s )
{ hour = ( h >= 0 && h < 24 ) ? h : 0;
minute = ( m >= 0 && m < 60 ) ? m : 0;
second = ( s >= 0 && s < 60 ) ? s : 0; }

ملاحظة يمكن ذكر تمرين إدخال أرقام التلفون.

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

• التحميل الزائد لعملية الجمع + :
لتحميل عملية الجمع بشكل زائد لتصبح قادرة على جمع كائنين من النوع Time من خلال التعليمة التالية t3=t1+t2; لوجب كتابتها t3=t1.add(t2); أو t3=add(t1,t2);
1- يمكن استخدام تابع عضو:
لجمع الزمنين t1+t2 بحيث يتم نداء تابع العملية بالشكل التالي t1.operator+(t2) وهو يعيد الناتج من النمط Time وخزن في الكائن t1 وعليه نكتب التابع التالي:
Time Time ::operator + ( const Time &t)
{ Time temp;
temp.hour = hour + t.hour;
temp.minute = minute + t. minute;
temp.second = second + t. second;
temp.convert1( );
return temp;
}
وهنا تم استخدام المؤشر this والذي سمح بكتابة البيانات بالشكل hour وminute و second بدون استخدام اسم الكائن التابع له وكان بالإمكان استخدام this->hour بدل من hour وهكذا, وتم الاستعانة بالتابع convert1( ); من أجل ضبط قيمة الجمع لتصبح من النمط Time.

2- يمكن استخدام تابع غير عضو ( صديق):
Time operator + ( const Time &t, const Time &t1)
{ Time temp;
temp.hour = t1.hour + t.hour;
temp.minute = t1.minute + t.minute;
temp.second = t1.second + t.second;
temp.convert1();
return temp;
}

وعند كتابة t3=t1+t2 ضمن البرنامج main سيتم نداء تابع العملية + بالشكل .operator+(t1,t2) ويعيد قيمة من النط Time عن طريق return temp;
إن التابع convert1( ) له البنية التالية
void Time::convert1()
{ if( second >=0 && second <60) second =second;
else {second = second -60;minute++;}
if(minute >=0 && minute <60) minute = minute;
else { minute = minute -60;hour++;}
hour = (hour >=0 && hour <24)? hour: hour -24;
// day ++;}
}
ملاحظة :
طالما أن أعظم قيمة ممكنة للثواني هي 59 فعند جمع كائني Time لن يزيد مجموع الثواني عن 1 دقيقة و 58 ثانية (أي أقل من دقيقتين) وينطبق ذلك أيضا على الدقائق والساعات كلا في مجاله وفي حال التعميم (لجمع أكثر من كائنين –حالة الضرب بعدد مثلا-) يجب أخذ باقي القسمة على 60(بدلا من الطرح) في الثواني والدقائق وإضافة ناتج القسمة الصحيحة على 60 إلى الدقائق والساعات على الترتيب, وعلى 24 في الساعات مع إضافة ناتج القسمة الصحيحة على 24 إلى الأيام (في حال معالجتنا للأيام).

• التحميل الزائد لعملية الطرح - :
يمكن تحميل عملية الطرح بشكل زائد لتصبح قادرة على طرح كائنين من النوع Time من خلال تعليمات مشابهة لما هو عند الجمع مع مراعاة تعديل التابع convert1() ليصبح convert2() لتحويل الناتج لكائن من النوع Time:




• تحميل العملية =+ بشكل زائد:
من أجل أن نستطيع كتابة الشكل التالي t1 += t2; وعند استخدام تابع عضو سيتم نداء العملية بالشكل التالي t1.operator+=(t2) وعند إعادة كائن من النمط Time يتيح عمليات متسلسلة من الشكل
t3 += t1 += t2;
Time Time::operator += ( const Time &t)
{
hour = hour + t.hour;
minute = minute + t.minute;
second = second + t.second;
convert1( );
return *this;
}
تحميل العملية += بشكل زائد باستخدام تابع صديق:
لإضافته إلى البرنامج السابق ضع التصريح التالي ضمن تعريف الصنف الملف time1.h:
friend Time & operator += (Time &t, const Time &t1);
وضع النص التالي ضمن الملف time1.cpp :

Time & operator += (Time &t, const Time &t1)
{
t.hour = t.hour + t1.hour;
t.minute = t.minute + t1.minute;
t.second = t.second + t1.second;
t.convert1( );
return t;
}
- تحميل العملية += بشكل زائد بالاعتماد على العملية + المحملة بشكل زائد كتابع عضو(يمكن إضافته إلى البرنامج السابق):

Time & Time::operator += ( const Time & t)
{ *this =*this + t;
return *this;
}
إن * هي عامل فك المرجع حيث *this هو الكائن نفسه أي إعادة الكائن الذي استدعاه ولكن بالمرجع .

- تحميل العملية += بشكل زائد بالاعتماد على العملية + المحملة بشكل زائد كتابع غير عضو:
friend Time & operator += (Time & t ,const Time & t1);
…….
Time & operator += (Time & t ,const Time & t1)
{ t =t +t1;
return t;
}
• التحميل الزائد للعملية = :
وهنا يجب التحميل من خلال تابع عضو حصراً ويكون تابع التحميل من الشكل:
Time & Time ::operator = (const Time &t)
{
hour = t.hour;
minute = t.minute;
second = t.second;
return *this;
}
لقد تم إعادة كائن من النمط Time لتأمين عمليات التخصيص المتكررة مثلاً.

• التحميل الزائد للعملية == :
يمكن أن يكون تابع عضو بالشكل التالي من خلال تابع يعيد int وتابع يعيد bool كما وتم جعل الكائن ثابت لكي لا يتم تغييره بطريقة الخطأ وتم النداء بالمرجع لتلافي الاستنساخ :
int Time::operator == ( const Time & t)
{
if(hour ==t.hour)&&(minute==t.minute)&&( second == t.second))
return 1;
else return 0;
}
يمكن أن يعرف كذلك
bool Time::operator == ( const Time & t)
{
if(hour ==t.hour)&&(minute==t.minute)&&( second == t.second))
return true;
else return false;
}
ويمكن أن يكون على شكل تابع صديق:

int operator == ( const Time & t, const Time & t1 )
{
if(t.hour ==t1.hour)&&(t.minute==t1.minute)&&( t.second == t1.second))
return 1;
else return 0;
}

• التحميل الزائد للعملية =! :

سنقوم بكتابة تابع التحميل بالاعتماد على العملية == المحملة بشكل زائد:
1- تابع عضو:
int Time::operator != ( const Time & t)
{
if(*this ==t) return 1; else return 0;
}
2- تابع غير عضو تابع صديق:

int operator != ( const Time & t, const Time & t1 )
{
return !(t ==t1) ;
}