أهداف التعلم

بعد إنهاء هذا الدرس، ستكون قد تعلمت:

• فهم الغرض من الدوال ولماذا تعتبر أساسية في C++.
• إنشاء دوال بطريقة صحيحة لضمان كود منظم.
• استدعاء الدوال داخل البرنامج وفهم كيفية تنفيذها.
• التمييز بين الدوال التي تُرجع قيمًا وتلك التي تنفذ التعليمات فقط.
• مقارنة بين الطرق المختلفة لتعريف الدوال واختيار الأنسب لكل حالة.

التصريح، الاستدعاء وتعريف الدوال

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

هذه المفاهيم الثلاثة ضرورية، ولكل منها دور محدد في هيكلة الكود. دعونا نناقش كل واحدة بالتفصيل.

1. تصريح الدالة

   قبل أن يتمكن الكود من استخدام دالة معينة، يجب على المترجم (compiler) أن يكون على علم بوجودها. يتم ذلك من خلال تصريح الدالة أو النموذج (prototype).

   يحدد تصريح الدالة للمترجم ثلاث معلومات أساسية:

   • نوع البيانات التي سترجعها الدالة (أو void إذا لم ترجع أي شيء).
   • اسم الدالة.
   • المعاملات التي تستقبلها (إن وجدت)، مع تحديد أنواعها.

   الصياغة العامة لتصريح الدالة هي:

   نوع_الإرجاع اسم_الدالة (لائحة_المعاملات);
   

   يتم عادةً وضع تصريح الدالة قبل main() أو في ملف رأس .h عند العمل مع عدة ملفات.

2. استدعاء الدالة

   بعد التصريح عن الدالة، يمكننا استدعاؤها داخل الكود لتنفيذها.

   عند استدعاء دالة:

   • يتم تنفيذ الكود الموجود داخل تعريفها.
   • إذا كانت الدالة تُرجع قيمة، يمكن تخزينها في متغير أو استخدامها مباشرة في تعبير معين.
   • إذا كانت الدالة من النوع void، فإنها تنفذ تعليماتها فقط دون إرجاع أي قيمة.

   صياغة استدعاء الدالة تكون بكتابة اسمها متبوعًا بأقواس تحتوي على المعاملات (إن وجدت):

   اسم_الدالة(المعاملات);
   

3. تعريف الدالة:

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

   الصياغة العامة لتعريف الدالة هي:

   نوع_الإرجاع اسم_الدالة (لائحة_المعاملات) {
       // جسم الدالة: التعليمات التي سيتم تنفيذها
       return قيمة; // (إذا كانت الدالة تُرجع قيمة)
   }
   

   يجب أن يلتزم كل تعريف دالة بالقواعد التالية:

   • يجب أن يتطابق مع التصريح (إذا تم التصريح عنه مسبقًا).
   • إذا كانت الدالة تُرجع قيمة (مثل int)، فيجب أن تحتوي على تعليمة return مع القيمة المُرجعة.
   • إذا كانت الدالة لا تُرجع شيئًا (void)، فإنها تنفذ تعليماتها فقط دون الحاجة إلى return.

تدفق التنفيذ

عند تشغيل البرنامج، يتم استدعاء الدوال حسب ترتيبها في main(). يتبع تدفق التنفيذ الخطوات التالية:

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

أهمية التصريح المسبق

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

هناك طريقتان رئيسيتان لمعالجة هذا الأمر:

1. تصريح الدالة قبل main() وتعريفها بعده (كما رأينا حتى الآن).
2. تعريف الدالة قبل main()، مما يلغي الحاجة إلى التصريح المسبق.

كلتا الطريقتين صحيحتان، ولكن الطريقة الأولى أكثر فائدة في البرامج الكبيرة حيث تكون الدوال موزعة عبر عدة ملفات.

النهج: التصريح – الاستدعاء – التعريف

يعد أحد أكثر الأساليب استخدامًا لتنظيم الدوال في C++ هو نهج التصريح – الاستدعاء – التعريف. باتباع هذه المنهجية، نقوم بتنظيم الكود في ثلاث مراحل أساسية:

1. التصريح: يتم إعلام المترجم (compiler) بوجود الدالة قبل استخدامها، مع تحديد اسمها، نوع الإرجاع والمعاملات (إن وجدت).
2. الاستدعاء: يتم استدعاء الدالة داخل الكود الرئيسي (main() في معظم الحالات)، مما يؤدي إلى تنفيذ محتواها.
3. التعريف: يتم تنفيذ الدالة فعليًا من خلال تحديد التعليمات التي ستُنفذ عند استدعائها.

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

مثال: الدالة consoladice()

في الكود التالي، نتبع تسلسل التصريح – الاستدعاء – التعريف:

#include <iostream>
using namespace std;
// أولًا، نقوم بتصريح الدالة
void consoladice();
int main() {
    // استدعاء الدالة
    consoladice();
    return 0;
}
// تعريف الدالة بعد التصريح عنها، مع تحديد سلوكها الداخلي
void consoladice() {
    cout << "Hatha nusus aw haruf mustakhdama fi alkhatt." << endl;
    cout << "Alaan sa'arik rakm khamsa. Huna hu: " << 5 << endl;
    cout << "Linaara natijat qismat 10/5. Alnatija hiya: " << 10/5 << endl;
    cout << "Tariqat mu'tada li taqdir alraqam Pi hiya 22/7. Alnatija hiya: " << 22/7 << endl;
    cout << "Fi C++ laysat 22/7 nafs 22.0/7, alma'malat mukhtalifa." << endl;
    cout << "Bihadha altaghyeer, yumkinuna mushahadat 'ann 22.0/7 hiya " << 22.0/7 << endl;
    cout << "Alaysa hadha taqdiran afdal?" << endl;
}

الناتج المتوقع لهذا الكود هو:

Hatha nusus aw haruf mustakhdama fi alkhatt.
Alaan sa'arik rakm khamsa. Huna hu: 5
Linaara natijat qismat 10/5. Alnatija hiya: 2
Tariqat mu'tada li taqdir alraqam Pi hiya 22/7. Alnatija hiya: 3
Fi C++ laysat 22/7 nafs 22.0/7, alma'malat mukhtalifa.
Bihadha altaghyeer, yumkinuna mushahadat 'ann 22.0/7 hiya 3.14286
Alaysa hadha taqdiran afdal?

لفهم نهج التصريح – الاستدعاء – التعريف بشكل أفضل، دعونا نركز على ثلاث نقاط رئيسية في الكود:

1. السطر 5: تصريح الدالة
   • void consoladice(); يُعلم المترجم بأن هناك دالة باسم consoladice() سيتم تعريفها لاحقًا.
   • تم تحديد نوع الإرجاع ليكون void، مما يعني أنها لا تُرجع أي قيمة.
   • على الرغم من أن تنفيذ الدالة غير معروف بعد، إلا أن هذا التصريح يسمح للمترجم بالتعرف عليها عند استخدامها.
2. السطر 9: استدعاء الدالة
   • داخل الدالة main()، يقوم السطر consoladice(); باستدعاء الدالة.
   • في هذه المرحلة، يكون المترجم على دراية بوجود consoladice() بفضل التصريح المسبق.
   • عند استدعاء الدالة، يتم نقل التحكم في التنفيذ إلى تعريفها، حيث يتم تنفيذ محتواها.
3. السطر 14 إلى 22: تعريف الدالة
   • هنا يتم تنفيذ consoladice() وتحديد التعليمات الخاصة بها.
   • في هذا المثال، تقوم الدالة بطباعة عدة رسائل في وحدة الإخراج، بما في ذلك الأرقام والعمليات الحسابية.
   • من النقاط المهمة هنا الفرق بين 22/7 و22.0/7. عند استخدام 22/7، فإن كلا الرقمين عددان صحيحان، مما ينتج عنه 3 بسبب القسمة الصحيحة. لكن عند استخدام 22.0/7، فإن العملية تتم كقيمة عشرية، مما ينتج عنه 3.14286.

النهج: التصريح والتنفيذ قبل الاستدعاء

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

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

البنية العامة لهذا النهج هي كالتالي:

// تعريف الدالة قبل main()
نوع_الإرجاع اسم_الدالة(لائحة_المعاملات) {
    // جسم الدالة
    return قيمة; // إذا لزم الأمر
}
int main() {
    // استدعاء الدالة
    اسم_الدالة(المعاملات);
}

بما أن الدالة تم تعريفها قبل main()، فإن المترجم يكون على علم بها عندما يتم استدعاؤها، مما يلغي الحاجة إلى تصريح مسبق.

مثال: دالة consoladice() بدون تصريح مسبق

الآن لنرَ مثالًا عمليًا يوضح تطبيق هذا النهج:

#include <iostream>
using namespace std;
// تعريف الدالة قبل استدعائها
void consoladice() {
    cout << "Hatha nusus aw haruf mustakhdama fi alkhatt." << endl;
    cout << "Alaan sa'arik rakm khamsa. Huna hu: " << 5 << endl;
    cout << "Linaara natijat qismat 10/5. Alnatija hiya: " << 10/5 << endl;
    cout << "Tariqat mu'tada li taqdir alraqam Pi hiya 22/7. Alnatija hiya: " << 22/7 << endl;
    cout << "Fi C++ laysat 22/7 nafs 22.0/7, alma'malat mukhtalifa." << endl;
    cout << "Bihadha altaghyeer, yumkinuna mushahadat 'ann 22.0/7 hiya " << 22.0/7 << endl;
    cout << "Alaysa hadha taqdiran afdal?" << endl;
}
int main() {
    // استدعاء الدالة
    consoladice();
    return 0;
}

في هذا الكود، يمكننا ملاحظة ما يلي:

1. بين السطرين 5 و13، يتم دمج التصريح والتعريف

   تم تعريف الدالة consoladice() مباشرة قبل main()، دون الحاجة إلى تصريح منفصل.

2. في السطر 17، يتم استدعاء الدالة داخل main()

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

3. النتيجة هي نفسها تمامًا

   من حيث الأداء، هذا النهج ينتج نفس السلوك مثل نهج التصريح – الاستدعاء – التعريف، لكنه يوفر هيكلًا أكثر إحكامًا.

✅ المزايا:

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

❌ العيوب:

• في البرامج الكبيرة، قد يجعل التنظيم أكثر صعوبة إذا تم تعريف العديد من الدوال قبل main().
• أقل فائدة عند العمل مع ملفات متعددة (.h و .cpp)، حيث يفضل عادةً وضع التصريحات في ملف منفصل.

انتشار قيمة الإرجاع

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

في هذا القسم، سنتعلم كيفية عمل الدوال التي تُرجع القيم، وكيف تختلف عن الدوال من النوع void، وكيفية الاستفادة من هذه الآلية في C++.

مثال عملي: دالة لحساب مساحة مستطيل

لتوضيح انتشار قيمة الإرجاع، سنقوم بتنفيذ دالة تستقبل قاعدة وارتفاع مستطيل، وتحسب مساحته.

#include <iostream>
using namespace std;
// دالة تحسب مساحة المستطيل وتعيد النتيجة
double calcularArea(double base, double altura) {
    return base * altura;
}
int main() {
    double base, altura;
    
    // طلب إدخال القيم من المستخدم
    cout << "Adkhal qimat alqa'ida lilmustatil: ";
    cin >> base;
    cout << "Adkhal qimat al'irtifa'a lilmustatil: ";
    cin >> altura;
    // استدعاء الدالة وتخزين نتيجتها
    double area = calcularArea(base, altura);
    // عرض النتيجة
    cout << "Masahat almustatil hiya: " << area << endl;
    
    return 0;
}

1. الدالة calcularArea() تُرجع قيمة
   • تستقبل قيمتين (base و altura) كمعاملات.
   • تحسب المساحة من خلال عملية الضرب base * altura.
   • تستخدم return لإرسال نتيجة العملية إلى الجزء الذي استدعاها من البرنامج.
2. استخدام قيمة الإرجاع في main()
   • يتم إدخال قيم base و altura من قبل المستخدم.
   • يتم استدعاء الدالة calcularArea() وتخزين نتيجتها في المتغير area.
   • أخيرًا، يتم عرض النتيجة في وحدة الإخراج.
3. الفرق الرئيسي مع دالة من النوع void

   لو كانت calcularArea() من النوع void، لكان علينا طباعة النتيجة مباشرة داخل الدالة بدلاً من إرجاعها إلى main() لاستخدامها لاحقًا.

مثال: دالة لتحديد ما إذا كان الرقم زوجيًا أم فرديًا

#include <iostream>
using namespace std;
bool esPar(int numero) {
    return numero % 2 == 0;
}
int main() {
    int numero;
    cout << "Adkhal rakm: "; cin >> numero;
    if (esPar(numero)) {
        cout << "Alrakm zawji." << endl;
    } else {
        cout << "Alrakm fardi." << endl;
    }
    return 0;
}

في هذا المثال، تقوم الدالة esPar() بإرجاع true إذا كان الرقم زوجيًا و false إذا كان فرديًا، مما يسمح لـ main() باستخدام النتيجة لتحديد الرسالة التي سيتم عرضها.

الاستدعاء الذاتي: الدوال التي تستدعي نفسها

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

مثال: مضروب عدد

المضروب لعدد n يُعرف بالصيغة n!=n\cdot(n-1)\cdot(n-2) \cdots 3 \cdot2 \cdot 1. هذه الصيغة تتبع نمطًا تكراريًا يمكن التعبير عنه رياضيًا كما يلي:

\begin{array}{rl} 0! &=1\\ n! &= n\cdot(n-1)!\\ \end{array}

بناءً على ذلك، يمكننا برمجة هذه الدالة في C++ على النحو التالي:

#include <iostream>
using namespace std;
 
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n*factorial(n - 1);
}
 
int main() {
    int numero;
    cout << "Adkhal rakman: "; cin >> numero;
    cout << "Faktoorial " << numero << " huwa " << factorial(numero) << endl;
    return 0;
}

في هذا الكود:

• تقوم الدالة factorial(n) باستدعاء نفسها مع n-1 حتى تصل إلى الحالة الأساسية (n == 0 أو n == 1).
• يتم حساب المضروب بشكل تكراري عن طريق ضرب القيم حتى الوصول إلى النتيجة النهائية.

مثال: متتالية فيبوناتشي

متتالية فيبوناتشي هي سلسلة الأعداد التالية: 1, 1, 2, 3, 5, 8, 13, \cdots. تتميز هذه السلسلة بأن كل عدد فيها يساوي مجموع العددين السابقين له.

رياضيًا، إذا كانت fibo(n) هي الدالة التي تُرجع قيم متتالية فيبوناتشي، فإنها تمتلك البنية الرياضية التالية:

\begin{array}{rl} fibo(0) &= 1\\ fibo(1) &= 1 \\ fibo(n) &= fibo(n-1) + fibo(n-2) \end{array}

يمكننا تطبيق ذلك في C++ بالشكل التالي:

#include<iostream>
 
using namespace std;
 
int fibo(int numero){
    if (numero==0||numero==1){
        return 1;
    }
    return fibo(numero-1)+fibo(numero-2);
}
 
int main(){
    int x=0, i=0;
    cout << "Adkhal rakman: "; cin >> x;
     
    while (i < x){
        cout << "Rakm Fibonacci fi almawqie " << i+1 << " huwa: " << fibo(i) << endl;
        i = i + 1;
    }   
}

الإرجاع المتعدد في الدوال

في C++، يمكن للدالة إرجاع أكثر من قيمة واحدة باستخدام هياكل مثل std::pair، std::tuple أو عبر تمرير المتغيرات كمرجع.

مثال: دالة تُرجع قيمتين باستخدام std::pair

#include <iostream>
#include <utility> // لاستخدام std::pair
using namespace std;
 
pair<int, int> dividir(int a, int b) {
    return make_pair(a / b, a % b);
}
 
int main() {
    int numerador=0, denominador=1;
     
    cout << "Adkhal al-bast: "; cin >> numerador;
    cout << "Adkhal al-makhraj: "; cin >> denominador;
     
    pair<int, int> resultado = dividir(numerador, denominador);
 
    cout << "Al-qisam: " << resultado.first << endl;
    cout << "Al-baqi: " << resultado.second << endl;
 
    return 0;
}

في هذا المثال، تقوم الدالة dividir() بإرجاع قيمتين: ناتج القسمة والباقي من عملية القسمة الصحيحة.

مثال: دالة تُرجع ثلاث قيم باستخدام std::tuple

#include <iostream>
#include <tuple>
using namespace std;
tuple<int, int, int> operaciones(int a, int b) {
    return make_tuple(a + b, a - b, a * b);
}
int main() {
    int suma=0, resta=0, producto=0;
    int a=0, b=0;
    
    cout << "Adkhal rakman: "; cin >> a;
    
    cout << "Adkhal rakman akhar: "; cin >> b;
    
    std::tie(suma, resta, producto) = operaciones(a, b);
    cout << "Al-jam: " << suma << ", Al-taqs: " << resta << ", Al-darb: " << producto << endl;
    return 0;
}

تعدد الأشكال في الدوال (overloading)

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

#include <iostream>
#include <string> // مطلوب لاستخدام std::string
#include <cmath>
using namespace std;
// حساب مساحة المربع أو الدائرة (أشكال بمعطى واحد)
double area(double lado) {
    return lado * lado;
}
// حساب مساحة المستطيل (أو الأشكال ذات معطيين)
double area(double base, double altura) {
    return base * altura;
}
// حساب مساحة المثلث (أو الأشكال ذات ثلاثة معطيات)
double area(double a, double b, double c){
	return 0.25 * sqrt((a+b+c)*(a+b-c)*(a-b+c)*(-a+b+c));
}
int main() {
    string figura;
    double resultado = 0;
    double l1=0, l2=0, l3=0;
    // طلب نوع الشكل
    cout << "Ma hiya alshakl? (murabba, da'ira, mustatil, aw muthallath): ";
    cin >> figura;
    // التحقق من الشكل باستخدام if-else
    if (figura == "murabba") {
        cout << "Kam tatoul janibuh? "; cin >> l1;
        resultado = area(l1);
        cout << "Masahat almurabba hiya: " << resultado << endl;
    } 
    else if (figura == "mustatil"){
        cout << "Kam tatoul alqa'ida? "; cin >> l1;
        cout << "Kam tatoul al'irtifa'a? "; cin >> l2;
        resultado = area(l1, l2);
        cout << "Masahat almustatil hiya: " << resultado << endl;
    } 
    else if (figura == "da'ira") {
		l1 = 3.141592653;
        cout << "Kam tatoul alnisf alqutr? "; cin >> l2;
        resultado = area(l1, l2);
        cout << "Masahat alda'ira hiya: " << resultado << endl;
    } 
    else if (figura == "muthallath"){
    	cout << "Kam tatoul adla'uhu?" << endl;
    	cout << "Aljanib 1: "; cin >> l1;
		cout << "Aljanib 2: "; cin >> l2;
		cout << "Aljanib 3: "; cin >> l3;
			
		if ((l1+l2+l3)*(l1+l2-l3)*(l1-l2+l3)*(-l1+l2+l3) < 0){
			cout << "Almuthallath ghyru mumkin.";
		}	
		else {
			resultado = area(l1, l2, l3);
			cout << "Masahat almuthallath hiya: " << resultado << endl;
		} 			
	}
    else {
        cout << "Shakl ghyru sahih." << endl;
    }
    return 0;
}

الدوال المضمنة (inline) في C++

تتيح الدوال inline في C++ آلية لتحسين أداء البرنامج عن طريق تقليل الحمل الزمني لعملية استدعاء الدوال. بدلاً من تنفيذ استدعاء تقليدي، يحاول المترجم توسيع كود الدالة مباشرة في كل موضع يتم استدعاؤها فيه.

بنية دالة inline

inline نوع_الإرجاع اسم_الدالة(لائحة_المعاملات) {
    // جسم الدالة
    return قيمة; // إذا لزم الأمر
}

عند استخدام inline، يتم إزالة الحاجة إلى الانتقال إلى عنوان ذاكرة آخر لتنفيذ الدالة، مما قد يقلل من وقت التنفيذ.

الفرق بين دالة inline والدالة التقليدية

مثال على دالة inline

#include <iostream>
using namespace std;
inline int cuadrado(int x) {
    return x * x;
}
int main() {
    cout << "Murabba' 5 huwa: " << cuadrado(5) << endl;
    return 0;
}

🔍 آلية عمل المترجم:

1. يقوم المترجم باستبدال استدعاء cuadrado(5) مباشرة بـ 5 * 5.
2. لا يوجد انتقال في التنفيذ.
3. يتم تنفيذ الحساب في نفس السطر حيث تم استدعاء الدالة.

مزايا وعيوب inline

✅ المزايا

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

❌ العيوب

• زيادة حجم الملف التنفيذي: إذا تم استدعاء دالة inline عدة مرات في برنامج كبير، سيتم تكرار الكود في كل مرة، مما يزيد من حجم الملف.
• لا يضمن التوسع دائماً: قد يتجاهل المترجم توجيه inline إذا رأى أنه غير مناسب.