لغات البرمجة

دليل شامل لتعلم أساسيات لغة ++C: من البداية إلى الاحتراف

صورة
Azoul Code
اخر تحديث :

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

لغة ++C هي واحدة من أقوى لغات البرمجة، تم تطويرها سنة 1979 على يد المبرمج الدنماركي "بيارن ستروستروب" تحت اسم C with Classes. لم تُطلق النسخة الرسمية الأولى باسم ++C حتى عام 1985. اسم ++C مشتق من لغة C، مع إضافة "++" التي تعني في البرمجة "زيادة بمقدار واحد"، في إشارة إلى كونها تطويرًا وتحسينًا للغة C، مع إدخال مفاهيم جديدة مثل البرمجة الكائنية (Object-Oriented Programming). 

تتميز لغة ++C بقدرتها على العمل على جميع أنظمة التشغيل تقريبًا، مما يجعلها اختيارًا مثاليًا لتطوير البرامج عالية الأداء. وقد شهدت اللغة تحديثات مهمة عبر الزمن، مثل إصدار C++11 في عام 2011، وC++14 في عام 2014، وC++17 في عام 2017.
من أبرز استخدامات لغة ++C نجد تطوير أنظمة التشغيل، برمجة المترجمات البرمجية (Compilers)، إنشاء أنظمة قواعد البيانات، تطوير تطبيقات سطح المكتب، والأنظمة المدمجة (Embedded Systems). كما تُستخدم في تطوير الألعاب ومحركات الألعاب بفضل أدائها العالي ومرونتها.
بفضل قوتها وأدائها الفائق، تعتمد عليها شركات كبرى ووكالات فضائية مثل ناسا، مما يجعلها لغة أساسية في المشاريع التي تتطلب أداءً عاليًا ودقة كبيرة.
تعلم لغة ++C تجربة ممتعة للغاية، ومع إتقانها، ستتمكن بسهولة من الانتقال إلى أي لغة برمجة أخرى والتكيف مع أي مجال برمجي تريده دون عناء. لنبدأ الدورة على بركة الله! 

تحميل بيئة التطوير 

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

1. لأصحاب الهواتف:

يمكنهم تحميل تطبيق  Replit  من Google Play. هو  بيئة تطوير متكاملة عبر الإنترنت تتيح لهم كتابة الأكواد بلغة  ++C (أو أي لغة برمجة أخرى) مباشرة من هواتفهم.
بعد تحميل التطبيق، يمكنهم الدخول إليه وبدء كتابة الأكواد بسهولة وبدون الحاجة إلى تثبيت أي شيء على الهاتف.

2. لأصحاب الحواسيب الضعيفة:

يمكنهم استخدام المترجم البرمجي عبر الإنترنت (Online Compiler). كل ما عليهم فعله هو البحث عن "Online Compiler" في محرك البحث، واختيار أي مترجم برمجي يفضلونه، ثم البدء في كتابة الأكواد عبر الإنترنت مباشرة، دون الحاجة لتحميل أي برامج.

3. لأصحاب الحواسيب القوية: 

بالنسبة لمن يمتلكون أجهزة حواسيب قوية، سنستخدم Visual Studio كبيئة تطوير. أول خطوة هي البحث في محرك البحث عن "Download Visual Studio" لتحميل البرنامج، ومن ثم تثبيته والبدء في البرمجة باستخدامه.
قبل أن نبدأ بكتابة أول كود في الدورة، من المهم أن تكون لدينا بيئة العمل جاهزة. بالنسبة لأولئك الذين يرغبون في تحميل Visual Studio بالطريقة الصحيحة، يمكنهم التعرف على طريقة التحميل من هذا المقال المفصل مع فيديو يوثق الخطوات.
الرابط: طريقة التحميل
وللقيام بكل هذا، سنحتاج إلى تحميل مترجم الأكواد، وفي هذا الفيديو ستجدون طريقة التحميل بشكل بسيط وواضح.
أمر التحميل:
pacman -S --needed base-devel mingw-w64-ucrt-x86_64-toolchain

شرح الكود الأساسي في لغة ++C 

قبل أن نبدأ في الطباعة والتعليقات، يجب أن نشرح الكود الأساسي بلغة ++C. هذا الكود ضروري ويجب كتابته في أي برنامج نستخدمه للعمل بلغة ++C.
#include <iostream>
using namespace std;
int main()  {
    cout << "Azoul Code" << endl;
    return 0;
 }
هذا هو الكود الأساسي الذي يُعتبر نقطة البداية لأي مشروع بلغة ++C. تأكد من كتابته وتجربته في بيئة التطوير التي اخترتها قبل الانتقال إلى خطوات أخرى.
  1. <include<iostream#
هذا السطر في لغة ++C يُستخدم لتضمين مكتبة الإدخال والإخراج القياسية (Input/Output Stream).
iostream: تشير إلى المكتبة التي تحتوي على دوال التعامل مع الإدخال والإخراج، مثل:
cin: لقراءة البيانات من المستخدم (Input).
cout: لعرض البيانات على الشاشة (Output).
include#: تعني "تضمين" أو "إضافة". وهي تُستخدم لاستدعاء مكتبة أو ملف خارجي يحتوي على تعريفات جاهزة يمكننا استخدامها في البرنامج.
ملحوظة:
مكتبة iostream جزء من المكتبات القياسية في لغة ++C ولا تحتاج إلى تثبيت إضافي.
إذا أردت استخدام هذه المكتبة، يجب دائمًا كتابتها في بداية الكود.
   2. ;using namespace std
الشرح:
هذا السطر يُستخدم في لغة ++C لتجنب كتابة اسم النطاق (namespace) "std" قبل كل عنصر من المكتبة القياسية (مثل cout, cin, endl). 
ما هو الـ Namespace؟
في++namespace ،C هو طريقة لتنظيم الكود ومنع تعارض الأسماء بين العناصر (مثل الدوال والمتغيرات) في البرامج الكبيرة. 
المكتبة القياسية لـ ++C تُخزّن عناصرها داخل نطاق يُسمى std (اختصارًا لـ standard). 
بدون: ;using namespace std
إذا لم تستخدم هذا السطر، ستحتاج إلى كتابة ::std قبل كل عنصر من المكتبة القياسية، كما يلي:
#include <iostream>
int main()  {
  std::cout <<"Azoul Code" <<std::endl;
    return 0;
 }
مع: ;using namespace std
عند استخدام هذا السطر، لا تحتاج إلى كتابة ::std في كل مرة، مما يجعل الكود أقصر وأسهل للقراءة:
#include <iostream>
using namespace std;
int main()  {
    cout << "Azoul Code" << endl;
    return 0;
 } 
هل يجب دائمًا استخدامه؟
في البرامج الصغيرة أو التعليمية: يُفضل استخدام ;using namespace std لتبسيط الكود.
في البرامج الكبيرة: من الأفضل تجنب استخدامه، لأن ذلك قد يؤدي إلى تعارض الأسماء (Name Conflicts) إذا كنت تستخدم مكتبات أو نطاقات أخرى.
طريقة بديلة:
يمكنك استخدام ::std فقط مع العناصر التي تحتاجها، مما يقلل احتمال تعارض الأسماء:
#include <iostream>
int main()  {
    std::cout << "Azoul Code" << std::endl;
    return 0;
 }
3. {}()int   main 
الشرح:
هذا السطر هو نقطة البداية لأي برنامج مكتوب بلغة ++C.
تفصيل الأجزاء:
    1.int:
هذا النوع (Data Type) يُحدد أن الدالة main ستُعيد قيمة صحيحة (Integer) عند انتهاء التنفيذ.
إذا لم تُعيد قيمة، فسيظهر تحذير أو خطأ حسب المترجم (compiler) الذي تستخدمه.
    2.main: 
اسم الدالة الرئيسية التي يبدأ النظام تشغيل البرنامج من خلالها.
كل برنامج مكتوب بلغة ++C يجب أن يحتوي على دالة واحدة على الأقل باسم main.
3.():
الأقواس الفارغة تُشير إلى أن الدالة main لا تأخذ أي مُدخلات (Arguments).
هناك صيغة أخرى للدالة يمكن أن تأخذ مدخلات:
{}int   main(int   argc, char* argv[]) 
هذا يُستخدم في البرامج المتقدمة لتلقي مدخلات من سطر الأوامر (Command Line Arguments).
    4.{}:
الأقواس المعقوفة تحتوي على جسم الدالة، أي يجب كتابة  التعليمات البرمجية داخل الأقواس المعقوفة.
إضافة التفاصيل:
برنامج أساسي كامل:
#include <iostream>
using namespace std;
int main()  {
    // طباعة رسالة على الشاشة
    cout << "Azoul Code" << endl;
    // إعادة قيمة 0 للدلالة على نجاح التنفيذ
    return 0;
 }
تفسير الأجزاء:
   .على الشاشة "Azoul Code" يعرض النص: cout << "Azoul Code"   
;return 0:  يعيد القيمة 0 إلى نظام التشغيل للإشارة إلى أن البرنامج انتهى بنجاح.
ملاحظات إضافية:
لماذا int وليس void؟
استخدام int يُعتبر معيارًا، لأن نظام التشغيل يعتمد على القيمة التي تُعيدها الدالة main لمعرفة حالة انتهاء البرنامج.
إذا استخدمت ()void main، قد يعمل الكود في بعض المترجمات، لكنه ليس قياسيًا. 
القيم المُعادة من main:
;return 0: يشير إلى نجاح التنفيذ.
;return 1 أو أي قيمة أخرى: يشير إلى حدوث خطأ.

الطباعة و التعليقات(Print and Comments)

1. cout (الطباعة): 
في لغة++cout، C هي الكلمة المفتاحية الخاصة بـ "طباعة النصوص" أو "إظهار المخرجات" على الشاشة.
cout هي اختصار لـ "Character Output"، أي إخراج الأحرف (أو النصوص) إلى الشاشة.
تُستخدم لطباعة النصوص و القيم من المتغيرات.
طريقة الاستخدام:
نكتب cout، ثم نستخدم مشغل الطباعة >> لنقل البيانات إلى الشاشة.
في نهاية الطباعة، يمكن استخدام endl لإضافة سطر جديد أو استخدام n\ داخل علامات الإقتباس الزوجية("") . 
مثال:
// طباعة النص على الشاشة
 cout << "Azoul Code" << endl;
شرح المثال:
cout: تعني طباعة على الشاشة.
>>: مشغل الطباعة الذي ينقل البيانات إلى cout.
"Azoul Code": النص الذي سيتم طباعته على الشاشة.
endl: يضيف سطر جديد بعد طباعة النص.
2. التعليقات في ++C:
التعليقات في ++C تُستخدم لشرح الكود وتوضيح ما يفعله، لكن التعليقات لا يتم تنفيذها من قبل البرنامج. هناك نوعان من التعليقات:
أ. تعليق أحادي السطر: 
التعليق الأحادي السطر يتم باستخدام //. كل شيء بعد // في السطر يتم تجاهله من قبل البرنامج ويُعتبر تعليقًا فقط.
مثال:
// هذا تعليق أحادي السطر
cout << "Azoul Code"; // هذا تعليق بعد الكود
ب. تعليق متعدد الأسطر:
التعليق متعدد الأسطر يُستخدم لكتابة تعليقات طويلة أو توضيح فكرة كبيرة. يبدأ التعليق بـ */ وينتهي بـ/* .
مثال:
/*
    هذا تعليق متعدد الأسطر
    يمكننا استخدامه لشرح فكرة معقدة
    أو توضيح بعض التفاصيل
*/
cout << "Azoul Code";
ملخص:
cout: تستخدم لطباعة النصوص والنتائج على الشاشة.
>>: مشغل الطباعة الذي يُرسل البيانات إلى cout.
endl: يُستخدم لإضافة سطر جديد بعد الطباعة.
التعليقات: تساعد في توضيح الكود وجعل البرنامج أكثر قابلية للفهم.
بهذه الطريقة، يمكننا إظهار المخرجات وتوضيح الكود باستخدام التعليقات لتسهيل الفهم.

(Variables) C++ المتغيرات في لغة

 تُستخدم المتغيرات في لغة ++C لتخزين البيانات التي يمكن أن تتغير أثناء تنفيذ البرنامج. لكي نستخدم المتغيرات، يجب أن نحدد نوع البيانات (Data Type) واسم المتغير، ثم يمكننا إعطاؤه قيمة.
خطوات تعريف المتغيرات:      
1.تحديد نوع المتغير(Data Type):
يُحدد نوع البيانات التي يمكن تخزينها في المتغير، مثل الأرقام الصحيحة، الأعداد العشرية، النصوص، أو الأحرف.
2.إعطاء اسم للمتغير(Variable Name): 
يجب أن يكون اسم المتغير فريدًا ويتبع قواعد التسمية.
3.إعطاء قيمة للمتغير (Initialization):
يمكن إعطاء قيمة ابتدائية عند تعريف المتغير، أو يمكن إعطاؤها لاحقًا.
أنواع البيانات الأساسية في ++C:
int: لتخزين الأرقام الصحيحة (مثل: 1، 2، -3).
float: لتخزين الأرقام العشرية (مثل: 3.14، -0.5).
double: لتخزين الأرقام العشرية بدقة أعلى.
char: لتخزين الأحرف الفردية (مثل: 'a'، 'b').
string: لتخزين النصوص (مثل: "Hello").
bool: لتخزين القيم المنطقية (true أو false).
طرق تعريف المتغيرات:
1. تعريف متغير بدون قيمة ابتدائية:
int age; // int من النوع age تعريف متغير باسم
age = 25; // إعطاء قيمة لاحقًا
2. تعريف متغير مع قيمة ابتدائية:
int age = 29; // 29 وإعطاؤه قيمة age تعريف متغير باسم
3. تعريف عدة متغيرات في نفس السطر:
int   x = 10, y = 20, z = 30;  // تعريف عدة متغيرات مع قيمها
مثال عملي:
#include <iostream>// تضمين مكتبة الإدخال والإخراج
using namespace std;
int main()  {
// تعريف متغيرات بأنواع مختلفة
    int age = 25;  // متغير لتخزين العمر
    float pi = 3.14;  //pi متغير لتخزين قيمة تقريبية لـ pi
    char grade = 'A';  // متغير لتخزين حرف التقدير
    string name = "Azoul code";  // متغير لتخزين اسم
    bool isPassed = true;  // متغير لتخزين قيمة منطقية
  // طباعةالقيم
   cout << age << endl;
   cout << pi << endl;
   cout << grade << endl;
   cout << name << endl;
   cout << isPassed << endl;
    return 0;
 }
قواعد تسمية المتغيرات:
يجب أن يبدأ الاسم بحرف أو رمز underscore (_).
لا يمكن أن يحتوي الاسم على مسافات أو رموز خاصة (مثل: @، $، #).
يُفضل أن يكون الاسم معبرًا عن محتوى المتغير (مثل: age بدلاً من x).
نصائح:
اختر أسماء متغيرات واضحة وسهلة الفهم.
استخدم التعليقات لشرح الغرض من المتغيرات، خاصة إذا كانت تُستخدم في أماكن مختلفة من الكود.
انتبه لنوع البيانات عند إعطاء قيمة للمتغير (مثلاً، لا يمكن تخزين نص داخل متغير من نوع int).
بهذا الشرح، أصبحت تعرف كيفية تعريف المتغيرات في لغة ++C، أنواعها، وكيفية استخدامها في الكود!

العوامل: التخصيص، الزيادة، والنقصان في لغة ++C

لغة ++C تحتوي على مجموعة من العوامل (Operators) التي تُستخدم لإجراء عمليات مختلفة على البيانات. في هذا الشرح، سنركز على ثلاثة أنواع من العوامل المهمة: التخصيص، الزيادة، والنقصان.
1. عامل التخصيص (=):
يُستخدم لتخزين قيمة في متغير.
يُكتب كالتالي:
int   x = 5; // x يتم تخصيص القيمة 5 للمتغير
مثال عملي:
int a = 10; // a تخصيص القيمة 10 للمتغير
2. عوامل الزيادة (++):
تُستخدم لزيادة قيمة المتغير بمقدار 1.
لها نوعان:
الزيادة السابقة (++x): تزيد القيمة أولاً ثم تُستخدم في التعبير.
الزيادة اللاحقة (x++): تُستخدم القيمة أولاً ثم تزيد.
مثال عملي:
int x = 5;
cout << ++x; // الناتج: 6 (زيادة قبل الطباعة)
cout << x; // (x = 7 زيادة بعد الطباعة، تصبح) الناتج: 6
x++;
3. عوامل النقصان (--):
تُستخدم لتقليل قيمة المتغير بمقدار 1.
لها نوعان:
النقصان السابق (--x): تُنقص القيمة أولاً ثم تُستخدم في التعبير.
النقصان اللاحق (x--): تُستخدم القيمة أولاً ثم تُنقص.
مثال عملي:
int   y = 5;
cout << --y; // الناتج: 4 (نقصان قبل الطباعة)
cout << y--; // (y = 3 نقصان بعد الطباعة، تصبح) الناتج: 4
4. الجمع بين التخصيص والزيادة/النقصان:
يمكن دمج عوامل التخصيص مع العمليات الأخرى (مثل: الجمع، الطرح، الضرب، القسمة).
أمثلة:
إضافة قيمة:
int x = 10;
x += 5; // x = 15 الآن
طرح قيمة:
int   y = 20;
y -= 3; // y = 17 الآن
مثال عملي شامل:
#include <iostream>
using namespace std;
int main () {
    int   a = 10, b = 20;
    // التخصيص
    a = b; // بعد التخصيص a قيمة
    cout << "Value of a after assignment: " << a << endl;
    // الزيادة
    cout << "Value of b before increment: " << b << endl;
    cout << "Value of b after increment: " << ++b << endl;
    // النقصان
    cout << "Value of b after decrement: " << --b << endl;
    // الجمع مع التخصيص
    a += 5; // بعد الجمع مع التخصيص a قيمة
    cout << "Value of a after addition with assignment: " << a << endl;
    return 0;
}
ملخص:
التخصيص (=): تخزين قيمة في متغير.
الزيادة (++): زيادة القيمة بمقدار 1 (قبل أو بعد).
النقصان (--): تقليل القيمة بمقدار 1 (قبل أو بعد).
دمج العمليات مع التخصيص: اختصار لكتابة العمليات (مثل: +=، -=).
هذه العوامل أساسية لفهم كيفية التعامل مع المتغيرات في لغة C++، وستحتاجها في كل البرامج تقريبًا.

العمليات الحسابية في لغة ++C

لغة ++C توفر مجموعة واسعة من العمليات الحسابية التي تُستخدم لإجراء الحسابات الرياضية على المتغيرات. هذه العمليات أساسية لأي برنامج يحتاج إلى التعامل مع الأرقام.
1. العمليات الحسابية الأساسية:
الجمع (+):
يُستخدم لإضافة قيمتين.
مثال:
int a = 5, b = 3;
int sum = a + b; // الناتج: 8
الطرح (-):
يُستخدم لطرح قيمة من أخرى.
مثال:
int a = 5, b = 3;
int diff = a - b; // الناتج: 2
الضرب (*):
يُستخدم لضرب قيمتين.
مثال:
int a = 5, b = 3;
int product = a * b; // الناتج: 15
القسمة (/):
يُستخدم لقسمة قيمة على أخرى.
ملاحظة: عند قسمة عددين صحيحين (int)، يتم تجاهل الكسر.
مثال:
int a = 10, b = 3;
int div = a / b; // الناتج: 3 (بدون كسر)
باقي القسمة (%):
يُستخدم للحصول على باقي القسمة بين عددين.
مثال:
int a = 10, b = 3;
int mod = a % b; // الناتج: 1
2. الجمع بين العمليات والتخصيص:
يمكنك دمج العمليات الحسابية مع عامل التخصيص (=) لتوفير الوقت.
أمثلة:
الجمع مع التخصيص:
int x = 5;
x += 3; // x = x + 3
الطرح مع التخصيص:
int x = 5;
x -= 2; // x = x - 2
الضرب مع التخصيص:
int x = 5;
x *= 2; // x = x * 2
3. الأولويات في العمليات الحسابية:
العمليات الحسابية لها أولويات:
الأقواس () تُنفذ أولاً.
الضرب والقسمة وباقي القسمة (*, /, %) تُنفذ قبل الجمع والطرح.
الجمع والطرح (+, -) تُنفذ أخيرًا.
مثال:
int result = 5 + 3 * 2; // الناتج: 11 (لأن الضرب يتم أولاً)
int result2 = (5 + 3) * 2; // الناتج: 16 (الأقواس تُنفذ أولاً)
4. أمثلة عملية:
برنامج لحساب العمليات الأساسية:
#include<iostream>
using namespace std;
int main () {
    int a = 10, b = 3;
    cout << "Addition: " << a + b << endl;
    cout << "Subtraction: " << a - b << endl;
    cout << "Multiplication: " << a * b << endl;
    cout << "Division: " << a / b << endl;
    cout << "Remainder of division: " << a % b << endl;
    return 0;
 }
برنامج لحساب مساحة مستطيل:
#include<iostream>
using namespace std;
int main()  {
    int length, width;
    cout << "Enter the length of the rectangle:"; 
    cin >> length;
    cout << "Enter the width of the rectangle: "; 
    cin >> width;
    int area = length * width;
    cout << "The area of the rectangle is: " << area << endl;
    return 0;
 }
ملخص:
العمليات الحسابية تشمل: الجمع، الطرح، الضرب، القسمة، وباقي القسمة.
الأولويات تحدد ترتيب تنفيذ العمليات.
يمكنك دمج العمليات مع التخصيص لتبسيط الأكواد.
هذه العمليات هي الأساس لأي تطبيق رياضي أو حسابي، وستُستخدم كثيرًا في البرامج المختلفة. 

العوامل المنطقية في لغة ++C

العوامل المنطقية (Logical Operators) تُستخدم في لغة ++C لإجراء عمليات منطقية بين التعبيرات (Expressions). وهي تلعب دورًا أساسيًا في التحكم بتدفق البرامج، خاصة في الشروط والحلقات.
أنواع العوامل المنطقية:
1. عامل "و" المنطقي (&&):
يُعيد true إذا كانت كل التعبيرات صحيحة.
يُستخدم للتأكد من تحقق أكثر من شرط في نفس الوقت.
مثال:
#include<iostream>
using namespace std;
int main () {
    int a = 10, b = 5;
    if (a > 0 && b > 0) {
        cout << "Both numbers are positive" << endl;
    }
    return  0;
}  
2. عامل "أو" المنطقي (||):
يُعيد true إذا كان أحد التعبيرات على الأقل صحيحًا.
يُستخدم للتأكد من تحقق شرط واحد على الأقل.
مثال:
#include<iostream>
using namespace std;
int main()  {
    int a = -5, b = 10;
    if (a > 0 || b > 0) {
        cout << "There is at least one positive number" << endl;
    }
    return 0;
 }
3. عامل "ليس" المنطقي (!):
يُعكس القيمة المنطقية.
إذا كان التعبير true، فإنه يُعيد false، والعكس صحيح.
مثال:
#include<iostream>
using namespace std;
int main () {
    bool isRaining = false;
    if (!isRaining) {
        cout << "The weather is sunny" << endl;
    }
    return 0;
 }
الاستخدام مع العوامل المقارنة:
غالبًا ما تُستخدم العوامل المنطقية مع العوامل المقارنة لتكوين شروط معقدة.
العوامل المقارنة:
==: يساوي
!=: لا يساوي
<: أكبر من
>: أصغر من
 أكبر من أو يساوي=<:
=>: أصغر من أو يساوي
مثال عملي:
#include <iostream>
using namespace std;
int main () {
    int age = 20;
    if (age >= 18 && age <= 30) {
        cout << "The age is between 18 and 30" << endl;
    }
    return  0;
 }
أمثلة عملية:
مثال 1: التحقق من شروط متعددة باستخدام "و"  و "أو":
#include <iostream>
using namespace std;
int main () {
    int grade = 85;
    if (grade >= 50 && grade < 60) {
        cout << "Accepted" << endl;
    } else if (grade >= 60 && grade < 80) {
        cout << "Good" << endl;
    } else if(grade >= 80) {
        cout << "Excellent" << endl;
    } else {
        cout << "Failed" << endl;
    }
    return 0;
 }
مثال 2: التحقق من القيم باستخدام "ليس":
#include <iostream>
using namespace std;
int main () {
    bool isLoggedIn = false;
    if (!isLoggedIn) {
        cout << "Please log in" << endl;
    } else {
        cout << "Welcome!" << endl;
    }
    return 0;
 }
ملخص:
العوامل المنطقية: && (و)، || (أو)، ! (ليس).
تُستخدم لدمج الشروط أو التحقق من صحة التعبيرات.
تُساعد على كتابة برامج ديناميكية وذكية.
العوامل المنطقية تُعد من أساسيات البرمجة بلغة ++C، وستستخدمها كثيرًا عند العمل على البرامج التي تحتاج إلى اتخاذ قرارات.

المكتبة الرياضية والنصية في لغة ++C

في لغة ++C، تُستخدم المكتبات النصية والرياضية لتوفير مجموعة من الوظائف الجاهزة التي تُسهل العمليات المختلفة، مثل التعامل مع النصوص أو إجراء العمليات الحسابية المعقدة.
المكتبة النصية: <string>
المكتبة <string> تُستخدم للتعامل مع النصوص (Strings) في ++C. باستخدام هذه المكتبة، يمكنك تخزين النصوص، تعديلها، أو إجراء عمليات عليها مثل الإضافة والبحث.
أهم الوظائف في المكتبة النصية:
إنشاء النصوص: يمكنك تعريف متغير نصي باستخدام النوع string.
#include <iostream>
using namespace std;
int main()  {
    string name = "Hello";
    cout << name << endl;
    return 0;
 }  
إضافة النصوص: يمكنك دمج نصوص باستخدام العامل +.
string firstName = "Azoul";
string lastName = "Code";
string fullName = firstName + " " + lastName;
cout << fullName << endl;  // Azoul Code :النتيجة
حساب طول النص: الدالة ()length تحسب عدد الأحرف في النص.
string text = "Hello";
cout << "Text length: " << text.length() << endl;
الوصول إلى حرف معين: باستخدام الأقواس [ ].
string text = "C++";
cout << text[0] << endl;  // C :النتيجة
المكتبة الرياضية: <cmath>
المكتبة <cmath> تحتوي على دوال رياضية تُستخدم لإجراء العمليات الحسابية مثل الجذر التربيعي، القوة، اللوغاريتمات، وغيرها.
أهم الوظائف في المكتبة الرياضية:
الجذر التربيعي (sqrt): تُستخدم لحساب الجذر التربيعي لرقم.
#include <iostream>
using namespacestd;
int main()  {
    double number = 16.0;
    cout << "Square root: " << sqrt(number) << endl;  // النتيجة: 4
    return 0;
 }
القوة (pow): تُستخدم لحساب الرقم المرفوع إلى قوة معينة.
cout << "2 raised to the power of 3: " << pow(2,3) << endl;  // النتيجة: 8
القيمة المطلقة (abs): تحسب القيمة المطلقة لرقم.
int num = -10;
cout << "Absolute value: " << abs(num) << endl;  // النتيجة: 10
الجيب وجيب التمام (sin, cos): تُستخدم لحساب القيم المثلثية.
cout << "Sine of 90 degrees: " << sin(90 * M_PI / 180) << endl;  // النتيجة: 1
//  ( cmath موجود في مكتبة)  𝜋 ثابت يمثل قيمة : M_PI
التقريب (round, ceil, floor):    
round: تقريب الرقم لأقرب عدد صحيح.
ceil: التقريب لأعلى عدد صحيح.
floor: التقريب لأسفل عدد صحيح.
double num = 5.6;
cout << "Rounded: " << round(num) << endl; // النتيجة: 6
cout << "Ceiling: " << ceil(num) << endl;    // النتيجة: 6
cout << "Floor: " << floor(num) << endl;  // النتيجة: 5
دمج المكتبتين معًا:
يمكنك استخدام المكتبتين معًا في برنامج واحد لإنشاء تطبيق يتعامل مع النصوص ويجري العمليات الحسابية.
مثال عملي:
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
int main()  {
    string name;
    cout << "Enter your name: ";
    cin >> name;
    double number;
    cout << "Enter a number: ";
    cin >> number;
    cout << "Hello, " << name << "!" << endl;
    cout << "The square root of the number is: " << sqrt(number) << endl;
    return 0;
 }
ملخص:
المكتبة النصية <string> تُستخدم لمعالجة النصوص.
المكتبة الرياضية <cmath> تُستخدم لإجراء العمليات الرياضية.
كلا المكتبتين تُسهل عليك كتابة برامج قوية ومتنوعة. 

التعامل مع النصوص في لغة ++C

النصوص (Strings) في لغة ++C تُعتبر جزءًا أساسيًا في برمجة التطبيقات التي تحتاج إلى التعامل مع البيانات النصية. لغة ++C توفر عدة طرق للتعامل مع النصوص، سواء باستخدام المصفوفات الحرفية أو الكائنات النصية عبر مكتبة <string>.
أنواع النصوص في ++C:
المصفوفات الحرفية (Character Arrays): هي الطريقة التقليدية للتعامل مع النصوص باستخدام مصفوفة من الأحرف.
char name[] = "Hello";
cout << name << endl;
كائنات النصوص (std::string): هي الطريقة الحديثة والمرنة للتعامل مع النصوص، وتوفرها مكتبة <string>.
#include <iostream>
#include <iostream> 
using namespace $std;
int main () {
    string name = "Hello";
    cout << name << endl;
    return 0;
 }
أهم العمليات على النصوص
1. إنشاء النصوص:
باستخدام كائن std::string.
string text = "C++ is great";
2. دمج النصوص:
باستخدام العامل + أو +=.
string firstName = "Azoul ";
string lastName = "Coude";
string fullName = firstName + " " + lastName;
cout << fullName << endl; // Azoul Code : النتيجة
3. حساب طول النص:
باستخدام الدالة ()length. أو ()size.
string text = "Hello";
cout << "Text length: " << text.length() << endl; // النتيجة: 5
//يتم حساب حتى المسافة الفارغة بين الحروف و الكلمات
4. الوصول إلى حرف معين:
باستخدام الأقواس [ ].
string text = "C++";
cout << text[0] << endl; // C : النتيجة 
 في لغة C++، العد في المصفوفات والسلاسل النصية يبدأ من 0.//
5. إدخال النصوص من المستخدم:
باستخدام cin أو getline.
string name;
cout << "Enter your name: "; // أدخل اسمك:
getline(cin, name);
*/ 
الدالة ()getline تُستخدم في لغة ++C لقراءة سطر كامل من الإدخال (input) بما في ذلك الفراغات، 
وتُخزن النص في متغير من نوع std::string.
عند استخدام cin بشكل مباشر، يتوقف عن القراءة عند أول فراغ أو علامة نهاية السطر، 
لكن ()getline تتيح قراءة النصوص التي تحتوي على فراغات.
/*
cout << "Hello, " << name << endl; //، مرحبًا 
6. البحث عن نص داخل نص:
باستخدام ()find :
string text = "I love programming in C++";
size_t position = text.find("C++");
if (position != string::npos) {
    cout << "The text was found at position: " << position << endl;
} else {
    cout << "The text was not found!" << endl;
}
7. حذف النصوص:
باستخدام ()erase :
string text = "I love programming in C++";
text.erase(0, 7); // Remove the first 7 characters
cout << text << endl; // Result: programming in C++
8. استبدال النصوص:
باستخدام ()replace:
string text = "I love programming in C++";
text.replace(21, 3, "Python"); // Replace "C++" with "Python"
cout << text << endl; // Result: I love programming in Python
:شرح الكود
:تعريف النص
string text = "I love programming in C++";
يتم تعريف سلسلة نصية (std::string) تحتوي على النص " أحب البرمجة بلغة ++C".
استخدام ()replace :
text.replace(11, 3, "Python");
11: الموضع الذي يبدأ عنده الاستبدال. الموضع 11 يشير إلى بداية "++C".
3: عدد الأحرف التي سيتم استبدالها. هنا يتم استبدال الأحرف الثلاثة "++C".
"Python": النص الجديد الذي سيحل محل الأحرف المستبدلة.
بعد هذه العملية، يتم استبدال "++C" بـ "Python".
:طباعة النص المعدّل
cout << text << endl;
يتم طباعة النص الجديد على الشاشة:
Python أحب البرمجة بلغة
:النتيجة
:عند تنفيذ الكود، تكون النتيجة
أحب البرمجة بلغة Python
ملاحظات:
التأكد من الموضع والطول: إذا كان الموضع أو الطول غير صحيح، قد يؤدي ذلك إلى أخطاء أو نتائج غير متوقعة.
النصوص متعددة اللغات: عند التعامل مع نصوص تحتوي على أحرف غير لاتينية (مثل العربية)، تأكد من أن البيئة تدعم النصوص متعددة اللغات لتجنب مشاكل الترميز.
مثال عملي:
#include <iostream>
#include <string>
using namespace std;
int main () {
    string sentence;
    cout << "Enter a sentence: ";
    getline(cin, sentence);
    cout << "Sentence length: " << sentence.length() << endl;
    cout << "First character: " << sentence[0] << endl;
    size_t found = sentence.find("C++");
    if (found != string::npos) {
        cout << "'C++' found at position: " << found << endl;
    } else {
        cout << "'C++' not found in the sentence" << endl;
    }
    return 0;
}
ملخص:
النصوص في ++C تُستخدم للتعامل مع النصوص المختلفة باستخدام مكتبة <string>.
يمكنك تنفيذ عمليات مثل الإنشاء، الإضافة، الحذف، البحث، والاستبدال بسهولة.
استخدام كائنات النصوص أكثر مرونة وأمانًا من المصفوفات الحرفية.

المدخلات في لغة C++ (Inputs)

في لغة ++C، يمكننا استخدام المدخلات (Inputs) للحصول على البيانات من المستخدم أثناء تنفيذ البرنامج. لتسهيل هذه العملية، توفر ++C أدوات مثل cin و getline لجمع المدخلات.
المدخلات باستخدام cin:
cin هو كائن يُستخدم لقراءة البيانات من المدخلات القياسية (عادةً من لوحة المفاتيح).
مثال:
#include <iostream>
using namespace std;
int main()  {
    int age;
    cout << "Enter your age: ";
    cin >> age;  // قراءة مدخل من المستخدم
    cout << "Your age is:" << age << " سنة" << endl;
    return 0;
}
شرح المثال:
هنا نستخدم cin لقراءة عدد صحيح (int) من المستخدم وتخزينه في المتغير age.
بعدها نعرض النتيجة باستخدام cout.
المدخلات باستخدام getline
getline هو دالة تُستخدم لقراءة النصوص بالكامل، بما في ذلك المسافات بين الكلمات. إذا كنت بحاجة إلى قراءة جمل أو نصوص تحتوي على مسافات، فإن getline هو الخيار الأفضل.
مثال:
#include <iostream>
#include <string>
using namespace std;
int main()  {
    string name;
    cout << "Enter your name: ";
    getline(cin, name);  // قراءة النص بالكامل بما في ذلك المسافات
    cout << "Hello، " << name << endl;
    return 0;
}
شرح المثال:
هنا نستخدم getline لقراءة النص من المستخدم وتخزينه في المتغير name.
getline يقرأ النص بالكامل حتى الضغط على مفتاح Enter، ويشمل المسافات بين الكلمات.
ملاحظات:
استخدام cin مع الأنواع الأخرى:
يمكن استخدام cin مع أنواع البيانات المختلفة مثل int, float, char, إلخ.
إذا كنت تريد قراءة نص أو جملة مع مسافات، استخدم getline بدلاً من cin.
الفرق بين cin و getline:
cin يقرأ المدخلات حتى أول مسافة أو نهاية السطر.
getline يقرأ السطر بالكامل بما في ذلك المسافات.
مثال تطبيقي مع المدخلات:
#include <iostream>
#include <string>
using namespace std;
int main()  {
    string name;
    int age;
    // قراءة المدخلات
    cout << "Enter your name:";
    getline(cin, name);
    cout << "Enter your age: ";
    cin >> age;
    // عرض المدخلات
    cout << "Hello " << name << "Your age is" << age << " years" << endl;
    return 0;
}
شرح المثال:
في هذا المثال، نقرأ اسم المستخدم باستخدام getline ثم نقرأ عمره باستخدام cin.
بعدها نعرض النتيجة باستخدام cout.
ملخص:
cin يُستخدم لقراءة المدخلات البسيطة مثل الأعداد.
getline يُستخدم لقراءة النصوص أو الجمل التي تحتوي على مسافات.
يجب الانتباه لاختيار الأداة المناسبة حسب نوع البيانات التي نريد قراءتها.

الجمل الشرطية في لغة ++C

الجمل الشرطية في ++C تُستخدم لتنفيذ كود معين بناءً على شرط معين. تُساعد هذه الجمل في اتخاذ قرارات داخل البرنامج. من أشهر الجمل الشرطية في ++C هي if, else if, else, و switch.
1. if:
if تُستخدم لتنفيذ كود معين إذا كان الشرط صحيحًا.
مثال:
#include <iostream>
using namespace std;
int main () {
    int age;
    cout << "Enter your age: ";
    cin >> age;
    if (age >= 18) {
        cout << "You are an adult." << endl;
    }
    return 0;
}
شرح المثال:
في هذا المثال، إذا كان العمر أكبر من أو يساوي 18، سيتم عرض الرسالة "أنت بالغ".
إذا كان الشرط غير صحيح، فإن الكود الذي داخل if لن يُنفذ.
2. else:
else تُستخدم لتحديد ما يجب فعله إذا كان الشرط في جملة if غير صحيح.
مثال:
#include <iostream>
using namespace std;
int main () {
    int   age;
    cout << "Enter your age: ";
    cin >> age;
    if (age >= 18) {
        cout << "You are an adult." << endl;
    } else {
        cout << "You are a minor." << endl;
    }
    return 0;
}
شرح المثال:
إذا كان العمر أكبر من أو يساوي 18، سيتم عرض "أنت بالغ".
إذا كان العمر أقل من 18، سيتم عرض "أنت قاصر".
3. else if:
تُستخدم else if للتحقق من شروط متعددة.
مثال:
#include <iostream>
using namespace std;
int main () {
    int   age;
    cout << "Enter your age: ";
    cin >> age;
    if (age >= 18) {
        cout << "You are an adult." << endl;
    } else if (age >= 13) {
        cout << "You are a teenager." << endl;
    } else {
        cout << "You are a child." << endl;
    }
    return 0;
}
شرح المثال:
إذا كان العمر أكبر من أو يساوي 18، سيتم عرض "أنت بالغ".
إذا كان العمر أكبر من أو يساوي 13 وأقل من 18، سيتم عرض "أنت مراهق".
إذا كان العمر أقل من 13، سيتم عرض "أنت طفل".
4. switch:
تُستخدم switch للتحقق من عدة حالات مختلفة لمتغير واحد. وهي مفيدة عندما يكون لديك العديد من القيم المحتملة لمتغير معين.
مثال:
#include <iostream>
using namespace std;
int main () {
    int   day;
    cout << "Enter the day number (1-7): ";
    cin >> day;
    switch (day) {
        case 1:
            cout << "Today is Sunday." << endl;
            break;
        case 2:
            cout << "Today is Monday." << endl;
            break;
        case 3:
            cout << "Today is Tuesday." << endl;
            break;
        case 4:
            cout << "Today is Wednesday." << endl;
            break;
        case 5:
            cout << "Today is Thursday." << endl;
            break;
        case 6:
            cout << "Today is Friday." << endl;
            break;
        case 7:
            cout << "Today is Saturday." << endl;
            break;
        default:
            cout << "Invalid number." << endl;
            break;
    }
    return 0;
}
شرح المثال:
في هذا المثال، إذا أدخل المستخدم رقم اليوم من 1 إلى 7، سيتم عرض اسم اليوم المناسب.
إذا كان الرقم غير صحيح (أي خارج النطاق 1-7)، سيتم عرض "رقم غير صالح".
ملخص:
if: تنفذ الكود إذا كان الشرط صحيحًا.
else: تنفذ الكود إذا كان الشرط في if غير صحيح.
else if: للتحقق من شروط متعددة.
switch: للتحقق من قيم متعددة لمتغير معين.
الجمل الشرطية تتيح لك اتخاذ قرارات بناءً على المدخلات أو القيم أثناء تنفيذ البرنامج.

جملة switch في ++C

تُستخدم جملة switch في ++C للتحقق من قيمة متغير معين ومقارنته مع مجموعة من القيم المختلفة، ثم تنفيذ الكود المناسب بناءً على تلك القيمة. هي بديل جيد لجملة if عندما يكون لديك العديد من القيم المحتملة لمتغير واحد.
التركيب الأساسي ل switch:
switch (variable) {
    case value1:
        //   value1 الكود الذي سينفذ إذا كانت قيمة المتغير تساوي
        break;
    case value2:
        // value2 الكود الذي سينفذ إذا كانت قيمة المتغير تساوي
        break;
    default:
        // الكود الذي سينفذ إذا لم تكن القيمة تساوي أي من القيم المذكورة
}
variable: هو المتغير الذي يتم التحقق من قيمته.
case: يتم استخدامها لمقارنة قيمة المتغير مع القيم المحتملة.
break: تُستخدم لإنهاء تنفيذ الجملة switch بعد تنفيذ الكود المناسب. إذا لم يتم استخدام break، سيتم تنفيذ جميع الأكواد التالية.
default: يُستخدم عندما لا تتطابق أي من القيم مع المتغير.
مثال على استخدام switch:
#include <iostream>
using namespace std;
int main () {
    int   day;
    cout << "Enter the day number (1-7): ";
    cin >> day;
    switch (day) {
        case 1:
            cout << "Today is Sunday." << endl;
            break;
        case 2:
            cout << "Today is Monday." << endl;
            break;
        case 3:
            cout << "Today is Tuesday." << endl;
            break;
        case 4:
            cout << "Today is Wednesday." << endl;
            break;
        case 5:
            cout << "Today is Thursday." << endl;
            break;
        case 6:
            cout << "Today is Friday." << endl;
            break;
        case 7:
            cout << "Today is Saturday." << endl;
            break;
        default:
            cout << "Invalid number." << endl;
            break;
    }
    return 0;
}
شرح المثال:
يقوم البرنامج بقراءة رقم اليوم من المستخدم (من 1 إلى 7).
ثم يتم التحقق من الرقم باستخدام switch:
إذا كانت القيمة تساوي 1، يتم طباعة "اليوم هو الأحد".
إذا كانت القيمة تساوي 2، يتم طباعة "اليوم هو الإثنين"، وهكذا.
إذا كانت القيمة غير صحيحة (أي لا تساوي أي من القيم من 1 إلى 7)، يتم طباعة "رقم غير صالح" باستخدام جملة default.
ملاحظات:
break: إذا تم نسيان break بعد كل حالة، سيستمر البرنامج في تنفيذ الأكواد التالية حتى يجد break أو ينتهي من جميع الحالات.
default: هي حالة اختيارية وتُنفذ إذا لم تتطابق القيمة مع أي من الحالات المحددة.
لماذا نستخدم switch؟
إذا كان لدينا العديد من القيم التي نريد التحقق منها لمتغير معين، فإن استخدام switch يكون أكثر وضوحًا وأسهل من استخدام العديد من جمل if.
switch يكون أكثر كفاءة في بعض الحالات مقارنةً بـ if، خاصة إذا كانت القيم كثيرة.
خلاصة:
جملة switch تُستخدم لتنفيذ الكود بناءً على قيمة المتغير، وتعد بديلاً مناسبًا لجملة if عندما تكون لدينا العديد من القيم المحتملة.

الحلقات التكرارية في ++C

الحلقات التكرارية تُستخدم لتنفيذ كود معين بشكل متكرر طالما كان الشرط صحيحًا. تُعتبر الحلقات من الأساسيات في البرمجة لأنها تُسهل العمليات التي تتطلب تكراراً عدة مرات.
أنواع الحلقات التكرارية في ++C:
حلقة for
حلقة while
حلقة do-while
1. حلقة for:
تُستخدم حلقة for عندما نعرف مسبقًا عدد المرات التي نريد تكرار الكود خلالها.
التركيب الأساسي:
for (initialization; condition; increment/decrement) {
    // الكود الذي سيتم تنفيذه في كل مرة
}
initialization: يتم تحديد المتغيرات التي نريد استخدامها (مثل المتغير الذي يبدأ العد).
condition: هو الشرط الذي يتحقق في كل مرة قبل تنفيذ الكود.
increment/decrement: تعديل المتغير (زيادة أو نقصان).
مثال:
#include <iostream>
using namespace std;
int main()  {
    for (int   i = 1; i <= 5; i++) {
        cout << "the number is: " << i << endl;
    }
    return 0;
}
شرح المثال:
في هذا المثال، يتم تكرار الكود 5 مرات.
في كل مرة، يتم زيادة قيمة i بمقدار 1، ويطبع العدد الحالي.
2. حلقة while:
تُستخدم حلقة while عندما لا نعرف مسبقًا عدد المرات التي سيتم فيها التكرار، ولكننا نعرف الشرط الذي يجب أن يكون صحيحًا لاستمرار التكرار.
التركيب الأساسي:
while (condition) {
    // الكود الذي سيتم تنفيذه طالما أن الشرط صحيح
}
condition: هو الشرط الذي يتم التحقق منه في كل مرة قبل تنفيذ الكود.
مثال:
#include <iostream>
using namespace std;
int main()  {
    int   i = 1;
    while (i <= 5) {
        cout << "the number is: " << i << endl;
 زيادة i بمقدار 1 //  ;++i 
    }
    return 0;
}
شرح المثال:
في هذا المثال، نبدأ بـ i = 1، وتستمر الحلقة طالما أن i أقل من أو يساوي 5.
في كل مرة، يتم طباعة العدد وزيادة i بمقدار 1.
3. حلقة do-while:
حلقة do-while مشابهة لحلقة while، ولكن الفرق هو أن الكود داخل الحلقة يتم تنفيذه مرة واحدة على الأقل قبل التحقق من الشرط.
التركيب الأساسي:
do {
    // الكود الذي سيتم تنفيذه
} while (condition);
condition: هو الشرط الذي يتم التحقق منه بعد تنفيذ الكود داخل الحلقة.
مثال:
#include <iostream>
using namespace std;
int main()  {
    int   i = 1;
    do {
        cout << "the number is: " << i << endl;
        i++; // 1 بمقدر  i زيادة
    } while (i <= 5);
    return 0;
}
شرح المثال:
في هذا المثال، سيتم تنفيذ الكود داخل الحلقة مرة واحدة على الأقل.
بعد تنفيذ الكود، سيتم التحقق من الشرط i <= 5 وإذا كان صحيحًا، ستستمر الحلقة.
الفرق بين الحلقات:
حلقة for: تُستخدم عندما نعرف عدد المرات التي يجب تكرار الكود خلالها.
حلقة while: تُستخدم عندما نريد التكرار طالما أن الشرط صحيح.
حلقة do-while: تُنفذ الكود مرة واحدة على الأقل ثم تتحقق من الشرط.
ملاحظات مهمة:
يجب التأكد من أن الشرط في الحلقات سينتهي في وقت ما، وإلا سيؤدي ذلك إلى حلقة لا نهائية.
في الحلقات، يمكن استخدام جملة break للخروج من الحلقة بشكل مبكر إذا تحقق شرط معين.
خلاصة:
الحلقات التكرارية هي أداة قوية لتكرار الكود بناءً على شرط معين. باستخدام الحلقات، يمكن تنفيذ العمليات المتكررة بسهولة وفعالية.

المصفوفات في ++C

المصفوفات هي هياكل بيانات تُستخدم لتخزين مجموعة من العناصر من نفس النوع. تُعتبر المصفوفات مفيدة عندما تحتاج إلى تخزين بيانات متعددة في مكان واحد والوصول إليها باستخدام فهرس (index).
تعريف المصفوفة:
في ++C، يمكن تعريف المصفوفة باستخدام الصيغة التالية:
type arrayName[size];
type: هو نوع البيانات الذي ستخزنه المصفوفة (مثل int, float, char, ...).
arrayName: هو اسم المصفوفة.
size: هو عدد العناصر التي يمكن أن تحتوي عليها المصفوفة.
مثال على تعريف مصفوفة:
#include <iostream>
using namespace std;
int main()  {
    // int تعريف مصفوفة تحتوي على 5 عناصر من النوع 
    int   numbers[5] = {1, 2, 3, 4, 5};
    // طباعة العناصر
   for (int   i = 0; i < 5; i++) {
    cout << "Item " << i + 1 << " is " << numbers[i] << endl;
}
    return 0;
}
شرح المثال:
هنا قمنا بتعريف مصفوفة numbers تحتوي على 5 عناصر من النوع int   وتم إعطاؤها القيم {1, 2, 3, 4, 5}.
ثم استخدمنا حلقة for للوصول إلى كل عنصر في المصفوفة وطباعة قيمتها.
الخصائص الأساسية للمصفوفات في ++C:
الوصول إلى العناصر: يمكن الوصول إلى العناصر في المصفوفة باستخدام الفهرس (index). المصفوفات في ++C تبدأ من الفهرس 0.
int   numbers[5] = {10, 20, 30, 40, 50};
cout << numbers[0];  // يطبع 10
حجم المصفوفة: في ++C، لا يمكنك تغيير حجم المصفوفة بعد تعريفها. يجب أن تحدد الحجم مسبقًا.
الاستفادة من الحلقات: عادة ما يتم استخدام الحلقات للتعامل مع المصفوفات، خاصةً عند الحاجة للتكرار عبر جميع العناصر.
المصفوفات متعددة الأبعاد:
يمكن أيضًا تعريف مصفوفات تحتوي على أكثر من بعد (مثل المصفوفات الثنائية أو ثلاثية الأبعاد).
مثال على مصفوفة ثنائية الأبعاد:
#include <iostream>
using namespace std;
int main()  {
    // (مصفوفة تحتوي على 3 صفوف و 2 عمود) 2D تعريف مصفوفة
   int   matrix[3][2] = {{1, 2}, {3, 4}, {5, 6}};
    // طباعة المصفوفة
    for (int   i = 0; i < 3; i++) {
        for (int   j = 0; j < 2; j++) {
            cout << "array[" << i << "][" << j << "] = " << matrix[i][j] << endl;
        }
    }
    return 0;
}
شرح المثال:
هنا قمنا بتعريف مصفوفة ثنائية الأبعاد matrix تحتوي على 3 صفوف و 2 عمود.
ثم استخدمنا حلقتين for للوصول إلى جميع العناصر في المصفوفة وطباعة قيمتها.
المصفوفات الديناميكية:
إذا كنت لا تعرف حجم المصفوفة مسبقًا أو إذا كان الحجم سيعتمد على مدخلات المستخدم، يمكنك استخدام المصفوفات الديناميكية باستخدام المؤشرات.
مثال على مصفوفة ديناميكية:
#include <iostream>
using namespace std;
int main()  {
    int   n;
    cout << "enter the number of items:";
    cin >> n;
   // إنشاء مصفوفة ديناميكية
    int* arr = new int[n];
    // إدخال القيم في المصفوفة
    for (int   i = 0; i < n; i++) {
        cout << "enter the item " << i + 1 << ": ";
        cin >> arr[i];
    }
    // طباعة المصفوفة
    for (int   i = 0; i < n; i++) {
        cout << "item " << i + 1 << "is: " << arr[i] << endl;
    }
    // تحرير الذاكرة
    delete[] arr;
    return 0;
}
شرح المثال:
هنا قمنا بإنشاء مصفوفة ديناميكية باستخدام new بناءً على المدخلات التي قدمها المستخدم.
بعد استخدام المصفوفة، قمنا بتحرير الذاكرة باستخدام []delete.
ملاحظات مهمة:
المصفوفات ثابتة الحجم: في ++C التقليدية، المصفوفات ثابتة الحجم بعد تعريفها.
المصفوفات الديناميكية: تستخدم المؤشرات لتحديد حجم المصفوفة أثناء تنفيذ البرنامج.
الفهرس يبدأ من 0: يجب الانتباه إلى أن الفهرس يبدأ من 0 في ++C، لذا إذا كانت المصفوفة تحتوي على 5 عناصر، فالفهرس يتراوح من 0 إلى 4.
خلاصة:
المصفوفات هي وسيلة لتخزين مجموعة من العناصر في مكان واحد في ++C. يمكنك استخدام المصفوفات في حل الكثير من المشكلات البرمجية التي تتطلب تخزين بيانات متعددة.

التعامل مع الملفات في ++C

التعامل مع الملفات في ++C يُعتبر من المهارات الأساسية في البرمجة، حيث يسمح لك بقراءة وكتابة البيانات من وإلى الملفات. يمكن التعامل مع الملفات باستخدام مكتبة fstream التي توفر مجموعة من الوظائف لفتح، قراءة، كتابة، وإغلاق الملفات.
أنواع الملفات في ++C:
الملفات النصية (Text files): تحتوي على نصوص يمكن قراءتها بواسطة البشر.
الملفات الثنائية (Binary files): تحتوي على بيانات غير قابلة للقراءة المباشرة بواسطة البشر، مثل الصور أو الصوت.
فتح الملفات:
في ++C، يمكن فتح الملفات باستخدام الكائنات من النوع ifstream (للقراءة)، و ofstream (للكتابة)، و fstream (لكلا العمليتين).
ifstream: لقراءة البيانات من الملفات.
ofstream: لكتابة البيانات إلى الملفات.
fstream: لقراءة وكتابة البيانات إلى الملفات في نفس الوقت.
فتح الملف:
#include <iostream>
#include <fstream>
using namespace std;
int main () {
    // فتح الملف للقراءة
    ifstream inputFile("example.txt");
    // التأكد من فتح الملف بنجاح
    if (!inputFile) {
        cout << "Failed to open the file!" << endl;
        return 1;
    }
    // قراءة البيانات من الملف
    string line;
    while (getline(inputFile, line)) {
        cout << line << endl;  // طباعة كل سطر من الملف
    }
    // إغلاق الملف بعد الانتهاء
    inputFile.close();
    return 0;
}
كتابة البيانات إلى ملف:
يمكنك استخدام ofstream لكتابة البيانات إلى الملف.
مثال على الكتابة إلى ملف:
#include <iostream>
#include <fstream>
using namespace std;
int main () {
    // فتح الملف للكتابة
    ofstream outputFile("output.txt");
    // التأكد من فتح الملف بنجاح
    if (!outputFile) {
        cout << "Failed to open the file!" << endl;
        return  1;
    }
    // كتابة البيانات إلى الملف
    outputFile << "Hello, this is text in the file!" << endl;
    outputFile << "This is another sentence in the file." << endl;
    // إغلاق الملف بعد الكتابة
    outputFile.close();
    return 0;
}
فتح الملف للقراءة والكتابة:
باستخدام fstream، يمكنك فتح الملف للقراءة والكتابة في نفس الوقت.
مثال على فتح الملف للقراءة والكتابة:
#include <iostream>
#include <fstream>
using namespace std;
int main () {
    // فتح الملف للقراءة والكتابة
    fstream file("example.txt", ios::in | ios::out);
    // التأكد من فتح الملف بنجاح
    if (!file) {
        cout << "Failed to open the file!" << endl;
        return   1;
    }
    // قراءة البيانات من الملف
    string line;
    getline(file, line);
    cout << "First line from the file: " << line << endl;
    // كتابة البيانات إلى الملف
    file << "Writing this text to the file!" << endl;
    // إغلاق الملف بعد الانتهاء
    file.close();
    return 0;
}
التعامل مع الملفات الثنائية:
إذا كنت ترغب في التعامل مع الملفات الثنائية (مثل الصور أو البيانات غير النصية)، يمكنك استخدام ifstream و ofstream مع وضع binary.
مثال على قراءة وكتابة ملف ثنائي:
#include <iostream>
#include <fstream>
using namespace std;
int main()  {
    // فتح الملف الثنائي للقراءة
    ifstream inputFile("example.bin", ios::binary);
    // التأكد من فتح الملف بنجاح
    if (inputFile!) {
        cout << "Failed to open the file!"<< endl;
        return  1;
    }
//قراءة البيانات من الملف الثنائي 
char buffer[100];
inputFile.read(buffer, sizeof(buffer));
cout << "Data read from the file: " << buffer << endl;
// إغلاق الملف بعد القراءة
inputFile.close();
// فتح الملف الثنائي للكتابة
ofstream outputFile("output.bin", ios::binary);
// التأكد من فتح الملف بنجاح
if (outputFile!) {
    cout << "Failed to open the file!" << endl;
    return  1;
}
// كتابة البيانات إلى الملف الثنائي
outputFile.write(buffer, sizeof(buffer));
// إغلاق الملف بعد الكتابة
outputFile.close();
return  0;
ملاحظات مهمة:
التأكد من فتح الملف: دائمًا تأكد من أن الملف قد تم فتحه بنجاح باستخدام if (!file) قبل البدء في العمليات عليه.
إغلاق الملف: بعد الانتهاء من العمليات على الملف، تأكد من إغلاقه باستخدام ()close لتجنب فقدان البيانات.
وضعية الملفات: استخدم ios::in للقراءة، و ios::out للكتابة، و ios::binary للعمل مع الملفات الثنائية.
خلاصة:
الملفات في ++C تسمح لك بالتعامل مع البيانات بشكل دائم، سواء كانت نصية أو ثنائية. من خلال استخدام مكتبة fstream، يمكنك قراءة البيانات من الملفات، كتابة البيانات إليها، والتعامل مع الملفات في وضعيات مختلفة.

الدوال في لغة ++C

الدوال (Functions) هي واحدة من أهم المفاهيم في البرمجة بلغة ++C. تُستخدم الدوال لتنظيم الكود وجعله أكثر قابلية للفهم والصيانة. كما أنها تساعد في تجنب تكرار الكود، وتُسهل عملية إعادة الاستخدام.
ما هي الدالة؟
الدالة هي مجموعة من التعليمات تُنفذ مهمة معينة. يمكن استدعاء الدالة في أي مكان في البرنامج لتنفيذ تلك المهمة، بدلًا من كتابة نفس الكود عدة مرات.
هيكل الدالة في ++C
الدالة تتكون من:
نوع الإرجاع (return Type): يحدد نوع البيانات التي ستُرجعها الدالة.
اسم الدالة (Function Name): اسم فريد يُستخدم لاستدعاء الدالة.
المعاملات (Parameters): بيانات تُمرر إلى الدالة (اختياري).
الجسم (Body): الكود الذي يُنفذ عند استدعاء الدالة.
الصيغة العامة:
return_type function_name(Parameters) {
    // الكود الذي سيتم تنفيذه
return value;  //تُستخدم إذا كانت الدالة تُرجع قيمة (اختياري)
}
أنواع الدوال في ++C
الدوال التي تُرجع قيمة: هذه الدوال تُرجع قيمة باستخدام الكلمة المفتاحية return.
مثال:
#include <iostream>
using namespace std;
int   sum(int   a, int   b) {
    return a + b;  // إرجاع مجموع الرقمين
}
int main()  {
    int   result = sum(5, 3);
    cout << "result = " << result << endl;  // طباعة النتيجة
    return 0;
}
الدوال التي لا تُرجع قيمة: تُستخدم الكلمة المفتاحية void إذا كانت الدالة لا تُرجع أي قيمة.
مثال:
#include <iostream>
using namespace std;
void printMessage() {
    cout << "Welcome to C++ programming!" << endl;
}
int main () {
    // استدعاء الدالة
    printMessage();  
    return 0;
}
تمرير المعاملات إلى الدوال:
تمرير بالقيمة (Pass by Value): يتم إنشاء نسخة من القيمة المُمررة، وأي تعديل داخل الدالة لا يؤثر على القيمة الأصلية.
مثال:
void plus(int   x) {
    x++;
    cout << "Inside the function: " << x << endl;
}
int main()  {
    int   num = 5;
    plus(num);
    cout << "Outside the function:  " << num << endl;  // القيمة الأصلية لم تتغير
    return 0;
}
تمرير بالمرجع (Pass by Reference): يتم تمرير المرجع، وأي تعديل داخل الدالة يؤثر على القيمة الأصلية.
مثال:
void plus(int   &x) {
    x++;
}
int main () {
    int   num = 5;
    plus(num);
    cout << "The value after the increase: " << num << endl;  // القيمة الأصلية تغيرت
    return 0;
}
تمرير بالمؤشر (Pass by Pointer): يتم تمرير عنوان المتغير باستخدام المؤشرات.
مثال:
void plus(int   *x) {
    (*x)++;
}
int main()  {
    int   num = 5;
    plus(&num);
    cout << "The value after the increase:" << num << endl;  // القيمة الأصلية تغيرت
    return 0;
}
الدوال مع القيم الافتراضية للمعاملات
يمكن تحديد قيم افتراضية للمعاملات، مما يجعلها اختيارية عند استدعاء الدالة.
مثال:
#include <iostream>
using namespace std;
int   sum(int   a, int   b = 10) {
    return a + b;
}
int main () {
    cout << "The sum of 5 and 10: " << sum(5) << endl;  // ستأخذ القيمة الافتراضية 10b
    cout << "The sum of 5 and 3: " << sum(5, 3) << endl;
    return 0;
}
الدوال التكرارية (Recursive Functions)
الدالة التكرارية هي دالة تستدعي نفسها.
مثال: 
حساب مضروب رقم باستخدام التكرار:
#include <iostream>
using namespace std;
int   factorial(int   n) {
    if (n <= 1)  // شرط الإيقاف
        return  1;
    return n * factorial(n - 1);
}
int main () {
    int   number = 5;
    cout << "The factorial of " << number << " is: " << factorial(number) << endl;
    return 0;
}
أهمية الدوال:
إعادة الاستخدام: يمكن استدعاء الدالة عدة مرات بدلًا من تكرار الكود.
تنظيم الكود: يجعل الكود أكثر وضوحًا وأسهل في القراءة.
تقليل الأخطاء: يقلل من احتمالية الأخطاء بفضل تقليل تكرار الكود.
سهولة الصيانة: يمكن تعديل الكود بسهولة إذا كان مُقسمًا إلى دوال.
خلاصة:
الدوال في ++C هي أدوات قوية لتنظيم الكود وجعله أكثر كفاءة. باستخدام الدوال، يمكنك تقسيم البرنامج إلى أجزاء صغيرة يمكن إدارتها بسهولة، مما يُسهل عملية التطوير والصيانة.

البرمجة الكائنية التوجه (OOP) في ++C:

البرمجة الكائنية التوجه (Object-Oriented Programming - OOP) هي نمط من أنماط البرمجة التي تعتمد على فكرة الكائنات (Objects) والفئات (Classes). الفئات هي القوالب التي يتم منها إنشاء الكائنات، بينما الكائنات هي نسخ من هذه الفئات التي تحتوي على بيانات وسلوكيات.
في ++C، يتم تنظيم الكود باستخدام هذه المبادئ الأساسية في OOP:
الفئات (Classes):
الفئة هي هيكل يحتوي على البيانات والدوال. تُستخدم لتحديد خصائص وسلوك الكائنات.
مثال:
classCar {
public:
    string color;
    int   speed;
    void drive() {
        cout << "The car is driving." << endl;
    }
};
في المثال السابق، Car هي فئة تحتوي على بيانات color و speed، بالإضافة إلى دالة ()drive التي تُظهر سلوك السيارة.
الكائنات (Objects):
الكائن هو نسخة من الفئة، ويمكنك إنشاء عدة كائنات من نفس الفئة.
مثال:
Car myCar;  // Car إنشاء كائن من فئة 
myCar.color = "Red";  // color تعيين قيمة للمتغير 
myCar.speed = 100;  // speed تعيين قيمة للمتغير 
myCar.drive();  // drive استدعاء دالة 
المُنشئ (Constructor):
هو دالة خاصة يتم استدعاؤها تلقائيًا عند إنشاء الكائن. يُستخدم لتخصيص القيم الأولية للمتغيرات.
مثال:
classCar {
public:
    string color;
    int speed;
    Car(string c, ints) {  // Constructor
        color = c;
        speed = s;
    }
};
int main () {
    Car myCar("Red", 100);  // استدعاء المُنشئ
    cout << "Color: " << myCar.color << ", Speed: " << myCar.speed << endl;
    return 0;
}
الوراثة (Inheritance):
هي قدرة الفئات على وراثة خصائص وسلوكيات من فئات أخرى. يسمح لك ذلك بإنشاء فئات جديدة تعتمد على فئات موجودة مسبقًا.
مثال:
#include <iostream>
using namespace std;
class Device {
public:
    void turnOn() {
        cout << "The device is turning on." << endl;
    }
};
class Smartphone : public Device {  // Device يرث من Smartphone
public:
    void turnOn() {
        cout << "Smartphone is booting up." << endl;
    }
};
int main() {
    Smartphone myPhone;
    myPhone.turnOn();  // Smartphone من فئة turnOn سيتم استدعاء دالة
    return 0;
}

التعدد في الأشكال (Polymorphism):
التعدد في الأشكال يسمح لك باستخدام نفس الدالة لتنفيذ وظائف مختلفة بناءً على نوع الكائن الذي يتم استدعاؤه. يُستخدم عادة مع دوال افتراضية (virtual).
مثال:
#include <iostream>
using namespace std;
class Device {
public:
    virtual void turnOn() {  // دالة افتراضية
        cout << "The device is turning on." << endl;
    }
};
class Laptop : public Device {
public:
    void turnOn() override {
        cout << "Laptop is booting up." << endl;
    }
};
class Smartphone : public Device {
public:
    void turnOn() override {
        cout << "Smartphone is powering on." << endl;
    }
};
int main() {
    Device* device1 = new Laptop();
    Device* device2 = new Smartphone();
    device1->turnOn();  // الحاسوب المحمول قيد الإقلاع
    device2->turnOn();  // الهاتف الذكي قيد التشغيل
    delete device1;
    delete device2;
    return 0;
}
التغليف (Encapsulation):
التغليف يعني إخفاء تفاصيل البيانات وحمايتها من الوصول المباشر. يتم ذلك باستخدام مُحددات الوصول مثل private و public.
مثال:
classCar {
private:
    intspeed;
public:
    void setSpeed(ints) {  // setter
        speed = s;
    }
    intgetSpeed() {  // getter
        return speed;
    }
};
int main () {
    Car myCar;
    myCar.setSpeed(120);   // setter تعيين السرعة باستخدام
    cout << "Speed: " << myCar.getSpeed() << endl;  // الحصول على السرعة باستخدام getter
    return 0;
}
الخلاصة:
البرمجة الكائنية التوجه (OOP) في ++C هي أسلوب قوي ومرن لتنظيم الكود. من خلال استخدام الفئات والكائنات والوراثة والتعدد في الأشكال والتغليف، يمكنك كتابة برامج قابلة للتوسع، منظمة، وسهلة الفهم. هذه المبادئ تساهم في إعادة استخدام الكود وتسهيل صيانته.
تعديل المقال
الأقسام

مقالات قد تهمك

تعليقات