fix(guide): simplify directory structure

guide/arabic/cplusplus/C- STL sets/index.md

@@ -0,0 +1,23 @@
+InlocaleTitle: undefined
+troduction من مجموعات في مكتبة C ++ STL المجموعات هي نوع من الحاويات الترابطية التي يجب أن يكون كل عنصر فيها فريدًا. لا يمكن تعديل قيمة العنصر بمجرد إضافته إلى المجموعة ، على الرغم من أنه من الممكن إزالة القيمة المعدلة لهذا العنصر وإضافتها. يتم تنفيذها باستخدام شجرة سوداء حمراء.
+
+فوائد استخدام المجموعات
+
+1.  يخزن القيم الفريدة فقط.
+2.  تحدد قيمة العنصر نفسه. قيمة العنصر هي أيضًا المفتاح المستخدم لتعريفه.
+3.  يوفر بحثًا سريعًا (O (log n)) باستخدام مفاتيح ie element نفسه.
+4.  هناك العديد من وظائف يحمل في ثناياه عوامل في مجموعات تعريف الطبقة التي تسهل البرمجة.
+
+مثال: '' 'ج ++
+
+# تتضمن
+
+استخدام اسم للمحطة؛ انت مين() { جلس الصورة.
+
+s.insert (2)؛ // insert element 2 in set s s.insert (3)؛ s.insert (5)؛ s.insert (2)؛ // إدراج نفس العنصر 2 s.insert (6)؛ لـ (auto i: s) cout << i << ""؛ محكمة << s.size () << ENDL. // يعطي حجم مجموعة
+
+s.erase (5)؛ // مسح عنصر 5 من مجموعة s العودة 0 } '' ' إنشاء كائن مجموعة '' 'ج ++ جلس الصورة. '' '
+
+إدراج '' 'ج ++ s.insert (القيمة _المراد_ تفسيرها) ؛ '' '
+
+الوصول إلى عناصر المجموعة '' 'ج ++ جلس :: يكررها ؛ لـ (it = s.begin ()؛ it! = s.end ()؛ ++ it) محكمة << \* هو؛ '' '

guide/arabic/cplusplus/arrays/index.md

@@ -0,0 +1,38 @@
+---
+title: C++ Arrays
+localeTitle: صفائف C ++
+---
+## ما هي صفائف؟
+
+المصفوفة هي سلسلة من العناصر من نفس نوع البيانات التي يتم تخزينها في مواقع الذاكرة المتجاورة ويمكن الرجوع إليها بشكل فردي.
+
+على سبيل المثال ، يتم تعريف مصفوفة تحتوي على 5 قيم عدد صحيح تسمى الأرقام كما يلي:
+
+ `int numbers [5]; 
+` 
+
+Initializiation:
+
+ `//Initialization with entries: 
+ int numbers [5] = {1, 2, 3, 4, 5}; 
+ 
+ //Initialization with no values: 
+ int numbers [5] = {}; 
+ 
+ //Initialization with declaration: 
+ int numbers [] = {1, 2, 3, 4, 5}; 
+ //Note that here the number of values defines the size of the array. 
+ //In the examples above, the size was fixed beforehand 
+` 
+
+**لاحظ** أن المصفوفات في C ++ ليست قابلة للتحويل من حيث الحجم ، مما يعني أنه بمجرد أن تقوم بإعلان مصفوفة بحجم 5 ، فلا يمكن تكبيرها أو تصغيرها. في حال كنت بحاجة إلى مصفوفة أكبر بنفس الإدخالات ، فسيتعين عليك نسخ كل الإدخالات إلى مجموعة جديدة من الحجم الأكبر.
+
+### التمكن من:
+
+يمكن الوصول إلى عناصر من مصفوفة من خلال الإشارة إلى موقعها في الصفيف. (ابدأ العد من 0).  
+مثال:
+
+ `x = numbers[0]; // = 1. [0] == first position 
+ numbers[2] = 55; // Sets the third position (3) to the new number 55 
+ //numbers[] is now: {1, 2, 55, 4, 5} 
+`

guide/arabic/cplusplus/casting/index.md

@@ -0,0 +1,86 @@
+---
+title: Casting
+localeTitle: صب
+---
+## صب
+
+المصبوب عامل تشغيل خاص يفرض تحويل نوع بيانات واحد إلى نوع آخر
+
+يختلف الصب في C ++ إلى حد ما عن C ++ يجعل استخدام وظائف الصب متميزة.
+
+### static\_cast
+
+يتم استخدام قالب ثابت للتحويلات الضمنية بين الأوليات ونوع التحميل الزائد.
+
+### const\_cast
+
+يمكن استخدام Const Cast لإلقاء العقوبة. هذا مفيد عندما تكون هناك رغبة في تحوير قيمة ثابتة. وينبغي استخدام ذلك بشكل مقتصد ، وبدلاً من ذلك ، ينبغي للمرء أن يفكر في جعل المعلمات / الوظائف غير ثابتة في الحالات التي يتم فيها استخدام قالب بث.
+
+يمكن أن يؤدي Const Cast أيضًا إلى سلوك غير معروف. يجب أن يكون التطبيق الوحيد لـ Const const هو إزالة الثوابت من القيمة التي تم تمريرها إلى الدالة والعلامة المميزة. إذا كانت القيمة const حقيقةً ، أي ، يتم وضع علامة const في وقت التحويل البرمجي وتعيين قيمة ، سيؤدي تحويل const وتغيير المتغير إلى سلوك غير معروف.
+
+ `const int y = 10;             // y is set to 10. 
+ const_cast<int &>(y) = 20;    // undefined behaviour. 
+` 
+
+### dynamic\_cast
+
+يتم استخدام الإرسال الديناميكي لإلقاء كائن ضمن التسلسل الهرمي الخاص به (إلى الأصل ، من الأصل إلى الأشقاء). لا يمكن استدعاء الطبقة الديناميكية إلا على فئات متعددة الأشكال. وبالتالي ، فإن الطبقة الأصلية في هذه الحالة يجب أن يكون `MyClass` عضوًا ظاهريًا ، موجودًا على شكل destructor افتراضي.
+
+إذا فشل `nullptr` الديناميكي ، فسيتم إرجاع `nullptr` . قد يكون التمثيل الديناميكي مفيدًا في تحديد أنواع الكائنات في وقت التشغيل. ومع ذلك ، تجدر الإشارة إلى أن المصبوب الديناميكي ليس مجانيًا وفي بعض الحالات قد تكون التقنيات الأخرى أكثر كفاءة في تحديد نوع الصف في وقت التشغيل.
+
+### reinterpret\_cast
+
+ربما تكون إعادة التسمية المسببة للتوتر هي الأخطر من بين جميع أشكال C ++ ، ولكن عند استخدامها بشكل صحيح يمكن أن تكون مثالية. لا تؤدي إعادة صياغة التسمية إلى حدوث أي تكلفة للأداء نظرًا لأنها لا تؤدي أي تحويلات. إنه ببساطة يرشد المحول البرمجي لمعالجة الكائن المصبوب كما لو كان من النوع المطلوب. يمكن أن يؤدي ذلك أيضًا إلى ظهور مشكلات المحاذاة ، لذا يجب استخدامها بشكل مقتصد وفقط عندما يتم التعرف على الآثار الجانبية وحسابها.
+
+#### ملاحظة على الطرز C- النمط
+
+يدعم C ++ استخدام قوالب C النمط ، على الرغم من أنها غير مستحسن. سيُسْتَخْدِم استخدام الزهر على النمط C على المحول البرمجي أن يقوم أولاً بأداء _قالب_ ثابت _، في حالة_ فشل الاستطاعة _الثابتة_ ، يتم استخدام reinterpret\_cast في مكانه. لهذا السبب ، قد ينتج عن أنماط C النمط نتائج غير متوقعة وتثير مشكلات غير متوقعة.
+
+## أمثلة
+
+ `#include <iostream> 
+ 
+ class MyClass { 
+ public: 
+    virtual ~MyClass() = default; 
+ 
+    void greet() { 
+        std::cout << "Hello World!" << std::endl; 
+    } 
+ }; 
+ 
+ class MyClassChild : public MyClass { 
+ }; 
+ 
+ void reinterpretCastTest(void *objectPtr) { 
+    // Let's assume we know objectPtr is of type MyClass * 
+    auto myClassObj = reinterpret_cast<MyClassChild *>(objectPtr); 
+    myClassObj->greet(); 
+ } 
+ 
+ void constCastTest(const MyClassChild &myClassChild) { 
+    auto nonConst = const_cast<MyClassChild &>(myClassChild); 
+    nonConst.greet(); 
+ } 
+ 
+ void dynamicCastTest(MyClass *myClass) { 
+    auto *child = dynamic_cast<MyClassChild *>(myClass); 
+    child->greet(); 
+ } 
+ 
+ void staticCastTest(float floatVal) { 
+    // Convert the float into an int. 
+    auto intVal = static_cast<int>(floatVal); 
+    std::cout << intVal << std::endl; 
+ } 
+ 
+ int main() { 
+    MyClassChild myClass; 
+    reinterpretCastTest(&myClass); 
+    constCastTest(myClass); 
+    dynamicCastTest(&myClass); 
+    staticCastTest(10.5); 
+ 
+    return 0; 
+ } 
+`

guide/arabic/cplusplus/clean-code-guidelines/index.md

@@ -0,0 +1,102 @@
+---
+title: Clean Code Guidelines
+localeTitle: تعليمات كود نظيفة
+---
+# تعليمات كود نظيفة
+
+عند الترميز ، يمكن أن يكون نمط الترميز الذي تتابعه مهمًا حقًا. خاصة عندما تعمل مع فريق أو تخطط لمشاركتك الشفرة. معظم هذه الإرشادات قياسية ويمكن تطبيقها على معظم لغات البرمجة ، ومع ذلك ، هنا لديك تطبيقات و مقتطفات مع رمز c ++ ، حتى تتمكن من التعرف عليها بسهولة. تذكر أن هذه ليست سوى توصيات لتحقيق الوضوح ، والتي يمكن أن تكون شخصية ، لذا خذ هذه النصائح في الاعتبار ولكن لا تأخذها إلى الرسالة. في بعض الأحيان قد يؤدي كسر بعض هذه القواعد إلى جعل الشفرة أكثر نظافة.
+
+## استخدم أسماء المتغيرات الجيدة وقم بالتعليقات
+
+تأكد من إنشاء أسماء متغيرة جيدة ، على سبيل المثال ، إذا كنت تقوم بإنشاء لعبة ، تجنب استخدام المتغير "a" استخدم شيئًا مثل "p1" يشير إلى اللاعب 1. إن [الترميز الهنغاري](https://en.wikipedia.org/wiki/Hungarian_notation) منتشر بشكل شائع ويمكن أن يعطيك بعض الخطوط الجانبية للإعلان المتغيرات.
+
+أيضا ، يرجى استخدام التعليقات ، أنا لا أمزح حتى ، مجرد محاولة قراءة بعض المشاريع القديمة التي قمت بها دون تعليقات ... الآن تخيل كونه شخص آخر لم يقم حتى برمجته.
+
+## المتغيرات العالمية
+
+يمكن أن تكون المتغيرات العالمية سهلة الاستخدام ، ومع القليل من التعليمات البرمجية قد تبدو وكأنها حل رائع. ولكن عندما يصبح الرمز أكبر وأكبر ، يصبح من الصعب معرفة متى يتم استخدامه.
+
+بدلاً من استخدام المتغيرات العامة ، يمكنك استخدام المتغيرات التي تم الإعلان عنها في الوظائف والتي يمكن أن تساعدك في تحديد القيم التي يتم تمريرها وتحديد الأخطاء بشكل أسرع.
+
+ `#include <iostream> 
+ using namespace std; 
+ 
+ // Global variables are declared outside functions 
+ int cucumber; // global variable "cucumber" 
+` 
+
+## استخدام الانتقال والمتابعة وما إلى ذلك.
+
+هذا هو النقاش المعتاد بين المبرمجين ، تماما مثل المتغيرات العالمية ، وعادة ما تعتبر هذه الأنواع من البيانات ممارسة سيئة. تعتبر سيئة لأنها تؤدي إلى ["رمز spaguetti"](https://en.wikipedia.org/wiki/Spaghetti_code) . عندما نبرمج نحن نريد التدفق الخطي ، عند استخدام هذه العبارات يتم تعديل التدفق ويؤدي إلى تدفق "ملتوي ومتشابك".
+
+تم استخدام Goto في الماضي عندما ، بينما ، إذا ، إذا كانت الوظائف ، مع ذلك ، تم إنشاء مقدمة هذه البرمجة المنظمة. بشكل عام ، تجنب استخدام goto ما لم تكن متأكدًا من أنها ستجعل رمز نظافتك وأسهل في القراءة. مثال قد يكون استخدامه في حلقات متداخلة.
+
+استخدام الفاصل والمتابعة من الناحية العملية هو نفسه. استخدمها في المحولات ومحاولة جعل الوظائف ذات غرض وحيد بحيث يكون لديك نقطة خروج واحدة فقط.
+
+![IMG](https://imgs.xkcd.com/comics/goto.png)
+
+## تجنب تغيير متغير التحكم داخل حلقة for
+
+عادة ما تكون هناك أعمال حول هذا تبدو أكثر وضوحا وأقل إرباكا ، على سبيل المثال. بينما الحلقات. فعل:
+
+ `int i=1; 
+ while (i <= 5) 
+ { 
+    if (i == 2) 
+        i = 4; 
+ 
+    ++i; 
+ } 
+` 
+
+بدلا من:
+
+ `for (int i = 1; i <= 5; i++) 
+ { 
+    if (i == 2) 
+    { 
+       i = 4; 
+    } 
+    // Do work 
+ } 
+` 
+
+## أعلن الثوابت وأنواع في الجزء العلوي
+
+عادة ما يتم الإعلان عنها بعد المكتبات ، وهذا يجعلها أكثر سهولة وقراءة أسهل. بالنسبة للمتغيرات المحلية ، يحدث الأمر نفسه ، وتعلن عنه في الأعلى (يقوم الآخرون بإعلانه بشكل أكبر في وقت لاحق من أجل توفير الذاكرة انظر: [cplusplus.com](http://www.cplusplus.com/forum/general/33612/)
+
+## استخدم وظيفة إرجاع واحدة فقط في النهاية
+
+وكما قلنا من قبل ، فإننا نميل إلى إدخال مدخل وخروج واحد فقط لجعل التدفق أكثر وضوحًا.
+
+## استخدم الأقواس المتعرجة حتى عند كتابة إحدى الخطوط
+
+سيساعدك جعلها بشكل منتظم على القيام بها بشكل أسرع وفي حالة رغبتك في تغيير الشفرة في المستقبل ، ستتمكن من القيام بذلك دون قلق.
+
+بدلا من:
+
+ `for (int i = 1; i <= 5; i++) 
+    //CODE 
+` 
+
+فعل:
+
+ `for (int i = 1; i <= 5; i++) 
+ { 
+    //CODE 
+ } 
+` 
+
+## توصيات أخرى
+
+*   #### استخدمه عندما تعرف عدد التكرارات ، بينما تفعل عندما لا تفعل ذلك.
+    
+*   #### استخدم const ، مررًا حسب القيمة / المرجع عندما يكون مناسبًا. هذا سوف يساعد في توفير الذاكرة.
+    
+*   \#### كتابة const في أحرف استهلالية ، أنواع البيانات تبدأ بـ T والمتغيرات في الحالة الصغيرة.
+    
+
+ `const int MAX= 100;             //Constant 
+ typedef int TVector[MAX];       //Data type 
+ TVector vector;                 //Vector 
+`

guide/arabic/cplusplus/compilers/index.md

@@ -0,0 +1,55 @@
+---
+title: C++ Compilers
+localeTitle: C ++ Compilers
+---
+# مقدمة إلى C ++ Compilers
+
+من أجل البدء مع C ++ ، سوف تحتاج إلى معرفة القليل عن المجمعين وكيف يعمل C ++ على جهاز الكمبيوتر الخاص بك.
+
+عندما يتم قول وفعل كل شيء ، لا تفهم أجهزة الكمبيوتر إلا لغة واحدة ، لغة الآلة. لغة الآلة تتكون بالكامل من بت ثنائية ، أو صفر و 1 ثانية. في حين أنه سيكون من الممكن برمجة في ثنائي ، سيكون من الممل بشكل لا يصدق وتستغرق وقتا طويلا. لذلك ، نحن البشر تطوير لغات البرمجة لتسهيل تطوير البرمجيات. لغة التجميع هي مباشرة 1 إلى 1 مع الجهاز لغة. تكون اللغات مثل C و C ++ و COBOL أعلى قليلاً وتحتاج إلى تجميعها. يذهب أعلى من ذلك. اللغات مثل JavaScript و Python يحتويان على مكونات يتم ترجمتها إلى لغة C ++ أو لغات أخرى منخفضة المستوى قبل تجميعها ، على نحو فعال جعلهم "أعلى" من اللغات C أو C ++. نظرًا لأن بنية الكمبيوتر تتكون من مفاتيح كهربائية وكابلات إلكترونية لا يمكنها العمل إلا مع الثنائيات والآليات الثنائية ، تحتاج إلى مترجم لترجمة التعليمات البرمجية الخاصة بك من C ++ عالية المستوى إلى لغة الجهاز التي يمكن أن تفهم وحدة المعالجة المركزية.
+
+المجمعات هي برامج مساعدة تأخذ الكود الخاص بك وتحويله إلى ملفات التعليمات البرمجية القابلة للتنفيذ. عند تشغيل مترجم على التعليمات البرمجية الخاصة بك ، أولاً ، يقرأ preprocessor التعليمات البرمجية المصدر (ملف C ++ الذي كتبته للتو). يبحث المعالج مسبقا عن أي توجيهات preprocessor (خطوط التعليمات البرمجية تبدأ بـ #). تعليمات preprocessor تسبب preprocessor لتغيير التعليمات البرمجية الخاصة بك بطريقة ما (عادة بإضافة بعض المكتبة أو ملف C ++ آخر). بعد ذلك ، يعمل المحول البرمجي عبر سطر التعليمات البرمجية المُختبَر مسبقًا عن طريق سطر الترجمة كل سطر في تعليمات لغة الآلة المناسبة. سيكشف هذا أيضًا عن أي أخطاء في بناء الجملة موجودة في التعليمات البرمجية المصدر وسوف يلقي خطأ في سطر الأوامر. وأخيرًا ، في حالة عدم وجود أخطاء ، يقوم المترجم بإنشاء كائن الملف مع ثنائي اللغة آلة اللازمة لتشغيل على جهازك. بينما ملف الكائن الذي أنشأه المترجم من المحتمل أن تقوم بعمل ما على جهاز الكمبيوتر الخاص بك ، فإنه لا يزال غير قابل للتنفيذ من برنامج C ++ الخاص بك. هناك نهائي خطوة مهمة للوصول إلى برنامج قابل للتنفيذ.
+
+يحتوي C ++ على مكتبة كبيرة للمساعدة في أداء المهام الصعبة مثل I / O والتلاعب بالأجهزة. يمكنك تضمين هذه المكتبات مع توجيهات ما قبل المعالجة ، لكن المعالج الأولي لا يضيفها تلقائيًا إلى شفرتك. من أجل أن يكون لديك برنامج نهائي قابل للتنفيذ ، يجب على الأداة المساعدة الأخرى المعروفة باسم رابط دمج ملفات الكائن مع وظائف المكتبة اللازمة لتشغيل التعليمات البرمجية. فكر في الأمر على أنه يحتوي على كل الكتل اللازمة لبناء منزل. قام المترجم بكتابة جميع الكتل ، لكن الرابط هو الذي يربطها معا لخلق منزل في النهاية. بمجرد الانتهاء من ذلك ، لديك الآن ملف تنفيذي فعال!
+
+## كيفية ترجمة ملف
+
+لنفترض أن لديك ملف C ++ يسمى `helloWorld.cpp` ...
+
+### إذا كنت تستخدم نظام Windows -
+
+#### باستخدام و IDE مثل CodeBlocks
+
+إنه بسيط مثل النقر فوق أزرار الإنشاء والتشغيل ، سيقومون بإنشاء ملف في مجلد المشروع. ![IMG](https://i.imgur.com/FwZuFGy.png)
+
+#### باستخدام موجه الأوامر
+
+1.  افتح موجه أوامر المطور - للحصول على هذه الخطوة ، يجب أن يكون لديك Microsoft Visual Studio أو بعض IDE أخرى تمكنك من ترجمة البرنامج الخاص بك من سطر الأوامر. يمكنك أيضًا البحث عبر الإنترنت عن compilers C ++.
+    
+2.  انتقل إلى شفرة المصدر مباشرة
+    
+3.  تشغيل المحول البرمجي على التعليمات البرمجية المصدر (بافتراض أنك تستخدم برنامج التحويل البرمجي Microsoft Visual Studio) `cl /EHsc helloWorld.cpp`
+    
+
+سيؤدي ذلك الآن إلى إنشاء ملف كائن وربطه تلقائيًا نيابة عنك. إذا نظرت في هذا المجلد نفسه ، سترى أ الملف القابل للتنفيذ hellWorld.exe (لاحظ ملحق EXE) موجود الآن.
+
+4.  اكتب `helloWorld` إلى المطالبة بتشغيل الملف القابل للتنفيذ
+
+بدلاً من ذلك ، تسمح العديد من IDEs ببناء البرنامج وعرضه بسرعة. قد يكون هذا أسهل منذ إصدار قد لا تأتي النوافذ قبل تعبئتها باستخدام أداة التحويل البرمجي.
+
+### إذا كنت تستخدم Linux أو OSX -
+
+1.  افتح نافذة طرفية وانتقل إلى دليل التعليمات البرمجية المصدر
+2.  قم بتشغيل المحول البرمجي على شفرتك المصدرية `g++ helloWorld.cpp -o helloWorld`
+
+سيؤدي ذلك إلى إنشاء ملف كائن وربطه تلقائيًا نيابة عنك. ابحث في المجلد وسترى helloWorld.exe ملف قابل للتنفيذ (لاحظ ملحق إكس).
+
+3.  اكتب `./helloWorld` في نافذة طرفية لتشغيل الملف القابل للتنفيذ
+
+g + هو مترجم لينكس القياسي وهو أداة رائعة. انها تأتي معبأة مع نظام التشغيل.
+
+ملحوظة: لترجمة وتنفيذ التعليمات البرمجية الخاصة بك مباشرة ، قم بتشغيل `g++ -o helloWorld helloWorld.cpp; ./helloWorld` لذلك عندما تحتاج إلى ترجمة وتشغيل التعليمات البرمجية الخاصة بك عدة مرات ، يصل السهم-أدخل
+
+* * *
+
+هناك عدد من أنواع مختلفة من المجمعين. وهما المدرجة هي التي يتم حزمها عادة مع ويندوز أو Linux / OSX.

guide/arabic/cplusplus/conditional-operator/index.md

@@ -0,0 +1,41 @@
+---
+title: Conditional Operator
+localeTitle: مشغل شرطي
+---
+## مشغل شرطي
+
+المشغل الشرطي هو مشغل ثلاثي ، وهو يحتاج إلى 3 معاملات. تقوم بإرجاع واحدة من قيمتين بناءً على نتيجة تعبير يستخدم المشغل الشرطي لاستبدال عبارات if-else البسيطة.
+
+بناء الجملة :
+
+ `  (condition)?(expression-1):(expression-2); 
+` 
+
+هنا ، يتم تقييم expression-1 عندما يكون الشرط صحيحًا ويتم تقييم expression-2 عندما تكون condtion خاطئة. عبارة if-else مشابهة ستكون:
+
+ `if(condition) 
+  { 
+    expression-1; 
+  } 
+ else 
+  { 
+    expression-2; 
+  } 
+` 
+
+ومن ثم فإن العامل الشرطي سهل للغاية عندما تحتاج إلى كتابة عبارة if-else بسيطة. ويمكن أيضا أن تستخدم في # تعريف preprocessor عندما يتم استخدام حالة مماثلة في أماكن متعددة.
+
+على سبيل المثال ، يمكن استخدام الحد الأقصى لعدد المشغلين الشرطيين على النحو التالي:
+
+ `#define big(a,b) (a>=b)?a:b 
+ 
+ int maximum,x=5,y=6; // variable to store maximum of two numbers 
+ maximum=(x>y)?x:y; // directly using conditional operator 
+ maximum=big(x,y); // using the #define preprocessor defined above as big 
+` 
+
+**حظا سعيدا لكم جميعا**
+
+**الترميز سعيدة! :)**
+
+**لا تتردد في طرح أي استفسارات على صفحة GitHub [FreeCodeCamp](https://forum.freecodecamp.org/) أو [منتدى FreeCodeCamp.](https://forum.freecodecamp.org/)**

guide/arabic/cplusplus/do-while-loop/index.md

@@ -0,0 +1,40 @@
+---
+title: do while loop
+localeTitle: تفعل في حين حلقة
+---
+## هل في حين حلقة
+
+تكون `do while loop` تقريبًا مماثلة للحلقة "أثناء". `do while loop` " النموذج التالي:
+
+ `do 
+ { 
+  // do something; 
+ } while(expression); 
+` 
+
+ملاحظة: تذكر استخدام فاصلة منقوطة "؛" في نهاية الشرط.
+
+## تفاصيل حول حلقة أثناء الاستخدام
+
+يتم استخدام حلقة do-while عندما تكون متأكدًا أنه يجب إجراء عملية معينة (داخل الحلقة) مرة واحدة على الأقل. له العديد من المزايا مثل عدم تهيئة متغير التحقق (على سبيل المثال char addmore = 'Y') إلخ. الفاصلة المنقوطة في نهاية الوقت أمر لا بد منه.
+
+افعل شيئًا أولاً ثم اختبر إذا كان علينا المتابعة. والنتيجة هي أن الكتلة يتم تنفيذها مرة واحدة على الأقل. (لأن اختبار التعبير يأتي بعد ذلك). ألق نظرة على مثال:
+
+ `#include <iostream> 
+    using namespace std; 
+ 
+    int main() 
+    { 
+        int counter, howmuch; 
+ 
+        cin >> howmuch; 
+        counter = 0; 
+        do 
+        { 
+            counter++; 
+            cout << counter << '\n'; 
+        } 
+        while ( counter < howmuch); 
+        return 0; 
+    } 
+`

guide/arabic/cplusplus/dynamic-memory-allocation/index.md

@@ -0,0 +1,40 @@
+---
+title: Dynamic Memory Allocation
+localeTitle: تخصيص الذاكرة الديناميكية
+---
+## تخصيص الذاكرة الديناميكي في C ++
+
+### ما هو تخصيص الذاكرة الديناميكي في C ++؟
+
+*   يشير **تخصيص الذاكرة** في C ++ إلى الذاكرة المخصصة للمتغيرات التي تستخدمها في البرنامج.
+*   **تخصيص الذاكرة الديناميكي** هو الذاكرة التي يتم تخصيصها للمتغيرات في وقت التشغيل كما يتم تحديد مقدار الذاكرة المطلوبة في وقت التشغيل.
+*   تأتي هذه الذاكرة من **كومة الذاكرة المؤقتة** ، في حين أن المتغيرات _غير الساكنة_ والمتغيرات _المحلية_ تحصل على ذاكرة من **المكدس** .
+*   في C ++ ، يمكن للمبرمج إجراء عمليات تخصيص الذاكرة يدوياً ، ويسمى **_تخصيص الذاكرة الحيوية_** .
+*   كان من الممكن في C القيام بتخصيص الذاكرة الديناميكية ، باستخدام وظائف _calloc_ و _malloc_ لتخصيص الذاكرة واستخدام وظيفة _حرة_ لإزالة تخصيص الذاكرة الديناميكية.
+*   في C ++ ، بالإضافة إلى أعلاه ، هناك وظيفتان ، _جديدتان_ _وحذفان_ لأداء تخصيص الذاكرة الديناميكية _وإلغاء_ التخصيص.
+
+### مشغل جديد
+
+*   يمكن للمشغل `new` منح الذاكرة مبرمج من كومة الذاكرة المؤقتة (إذا كانت متوفرة). إذا كانت الذاكرة التي يطلبها المبرمج متاحة ، يقوم المشغل `new` بتهيئة الذاكرة ثم يقوم بإرجاع العنوان (المرجع) للذاكرة المخصصة.
+*   **بناء الجملة**  
+    `pointer-variable-type` = `pointer-variable-type` `data-type;` **جديد** `data-type;`  
+    المثال 1: `int *ptr` = **new** `int;`  
+    المثال 2: `int *ptr2` = **new** `int[10];`  
+    هنا ، يعد `pointer-variable-type` **مؤشرًا** `data type` . يمكن أن يكون `data-type` int أو char وما إلى ذلك أو نوع بيانات المعرفة من قبل المستخدم.
+
+### مشغل DELETE
+
+*   تقع على عاتق المبرمج مسؤولية إلغاء تخصيص الذاكرة الموزعة ديناميكياً ، وإلا لن تكون الذاكرة متوفرة لإعادة توزيعها حتى نهاية البرنامج.
+    
+*   لإلغاء تخصيص الذاكرة ، يمكن `delete` المشغل ويمكن استخدامه بواسطة المبرمج.
+    
+*   **بناء الجملة**  
+    **حذف** `pointer-type-variable;`  
+    على سبيل المثال ، لتحرير الذاكرة المخصصة في المثال 1 أعلاه ، فإننا نكتب:  
+    `delete ptr;`  
+    وبالمثل ، على سبيل المثال 2 ، يمكن تحرير الذاكرة من خلال:  
+    `delete ptr2` ؛
+    
+    ### تسريبات الذاكرة
+    
+    تحدث التساؤلات عندما تفشل في إلغاء تخصيص الذاكرة الديناميكية التي قمت بتخصيصها من خلال المشغل `New` في نهاية البرنامج. إذا لم تقم بإلغاء تخصيصها مع عامل التشغيل Delete ، فسيستمر الكمبيوتر في إنشاء ذاكرة جديدة في الذاكرة المؤقتة في كل مرة يتم فيها تشغيل البرنامج. يؤدي هذا إلى إبطاء الكمبيوتر لأنه لم يتم حذف الذاكرة وتقلل الذاكرة المتوفرة لديك.

guide/arabic/cplusplus/erase-remove/index.md

@@ -0,0 +1,86 @@
+---
+title: Erase–remove idiom
+localeTitle: مسح-إزالة لغة
+---
+## Desctiprion
+
+كيفية إزالة العناصر من الحاوية هي سؤال شائع في C ++ ، حتى تتمكن من كسب بعض النقاط ، إذا قرأت هذه الصفحة بعناية. إن عبارة idase – remove هي تقنية C ++ للقضاء على العناصر التي تستوفي معيارًا معينًا من الحاوية. Heverever ، من الممكن إزالة العناصر ذات العروق التقليدية المكتوبة يدويًا ، إلا أن عبارة idase – remove لها مزايا عديدة.
+
+### مقارنة
+
+ `// Using a hand-written loop 
+ std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
+ for (auto iter = v.cbegin(); iter < v.cend(); /*iter++*/) 
+ { 
+    if (is_odd(*iter)) 
+    { 
+        iter = v.erase(iter); 
+    } 
+    else 
+    { 
+        ++iter; 
+    } 
+ } 
+ 
+ // Using the erase–remove idiom 
+ std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
+ v.erase(std::remove_if(v.begin(), v.end(), is_odd), v.end()); 
+` 
+
+كما ترون ، يتطلب التعليمة البرمجية ذات حلقة مكتوبة يدويًا كتابة أكثر قليلاً ، ولكن لها أيضًا مشكلة في الأداء. يجب أن تقوم كل مكالمة `erase` بتحويل جميع العناصر بعد المحذوفة ، لتجنب "الفجوات" في المجموعة. داعيا `erase` عدة مرات على نفس الحاوية يولد الكثير من النفقات العامة من تحريك العناصر.
+
+ومن ناحية أخرى ، فإن الشفرة التي تحتوي على المصطلح "إزالة - إزالة" ليست فقط أكثر تعبيرا ، ولكنها أيضا أكثر كفاءة. أولاً ، يمكنك استخدام `remove_if/remove` لنقل جميع العناصر التي لا تلائم معايير الإزالة إلى مقدمة النطاق ، مع الاحتفاظ بالترتيب النسبي للعناصر. لذلك ، بعد استدعاء `remove_if/remove` ، `remove_if/remove` مكالمة واحدة من `erase` جميع العناصر المتبقية في نهاية النطاق.
+
+### مثال
+
+ `#include <vector> // the general-purpose vector container 
+ #include <iostream> // cout 
+ #include <algorithm> // remove and remove_if 
+ 
+ bool is_odd(int i) 
+ { 
+    return (i % 2) != 0; 
+ } 
+ 
+ void print(const std::vector<int> &vec) 
+ { 
+    for (const auto& i : vec) 
+        std::cout << i << ' '; 
+    std::cout << std::endl; 
+ } 
+ 
+ int main() 
+ { 
+    // initializes a vector that holds the numbers from 1-10. 
+    std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
+    print(v); 
+ 
+    // removes all elements with the value 5 
+    v.erase(std::remove(v.begin(), v.end(), 5), v.end()); 
+    print(v); 
+ 
+    // removes all odd numbers 
+    v.erase(std::remove_if(v.begin(), v.end(), is_odd), v.end()); 
+    print(v); 
+ 
+    // removes multiples of 4 using lambda 
+    v.erase(std::remove_if(v.begin(), v.end(), [](int n) { return (n % 4) == 0; }), v.end()); 
+    print(v); 
+ 
+    return 0; 
+ } 
+ 
+ /* 
+ Output: 
+ 1 2 3 4 5 6 7 8 9 10 
+ 1 2 3 4 6 7 8 9 10 
+ 2 4 6 8 10 
+ 2 6 10 
+ */ 
+` 
+
+### مصادر
+
+"مسح - إزالة كلمة" ويكيبيديا: الموسوعة الحرة. Wikimedia Foundation، Inc. [en.wikipedia.org/wiki/Erase-remove\_idiom](https://en.wikipedia.org/wiki/Erase%E2%80%93remove_idiom)
+
+مايرز ، سكوت (2001). STL فعالة: 50 طرق محددة لتحسين استخدامك لمكتبة النماذج القياسية. أديسون ويسلي.

guide/arabic/cplusplus/error handling/index.md

@@ -0,0 +1,48 @@
+---
+title: Error Handling
+localeTitle: معالجة الأخطاء
+---
+# C ++ معالجة الاستثناء
+
+استثناء هو المشكلة التي تنشأ أثناء تنفيذ البرنامج. توفر الاستثناءات طريقة لنقل التحكم من جزء واحد من برنامج إلى آخر. تم بناء معالجة الاستثناء C ++ على ثلاث كلمات رئيسية: #try و #catch و #throw.
+
+*   # throw - يعرض برنامج استثناءً عند ظهور مشكلة. يتم ذلك باستخدام كلمة مرور.
+    
+*   # catch - برنامج يمسك استثناء مع معالج الاستثناء في المكان في برنامج حيث تريد معالجة المشكلة. تشير الكلمة الأساسية catch إلى اصطياد استثناء.
+    
+*   #try - يحدد كتلة المحاولة كتلة من التعليمات البرمجية التي سيتم تنشيط استثناءات معينة لها. يتبعها كتلة التقاط أو أكثر.
+    
+
+ `#include <iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+   int x = -1; 
+ 
+   // Some code 
+   cout << "Before try \n"; 
+   try { 
+      cout << "Inside try \n"; 
+      if (x < 0) 
+      { 
+         throw x; 
+         cout << "After throw (Never executed) \n"; 
+      } 
+   } 
+   catch (int x ) { 
+      cout << "Exception Caught \n"; 
+   } 
+ 
+   cout << "After catch (Will be executed) \n"; 
+   return 0; 
+ } 
+` 
+
+# قبل أن تذهب ...
+
+## مراجعة
+
+*   تجميع أنواع الخطأ.
+*   فصل الخطأ معالجة رمز من الرمز العادي.
+*   يمكن للوظائف / الطرق التعامل مع أي استثناءات يختارونها.

guide/arabic/cplusplus/for-loop/index.md

@@ -0,0 +1,90 @@
+---
+title: For Loop
+localeTitle: لحلقة
+---
+A For Loop هو عبارة تكرارية تستخدم للتحقق من وجود بعض الشرط ، وبناءً على الشرط ، يتم تنفيذ كتلة من التعليمات البرمجية بشكل متكرر حتى يتم استيفاء الشرط المحدد.
+
+يتم تمييز حلقة for عن حلقات التكرار الأخرى من خلال متغير حلقة صريح أو متغير حلقة يسمح للجسم من الحلقة معرفة التسلسل الدقيق لكل تكرار.
+
+ومن ثم ، فإن حلقة for هي بنية تحكم في التكرار تسمح لك بكتابة حلقة بكفاءة تحتاج إلى تنفيذ عدد محدد من المرات.
+
+## بناء الجملة
+
+ `for ( init; condition; increment ) { 
+   statement(s); 
+ } 
+` 
+
+من المسموح به لوضع الزيادة insie للحلقة مثل في حلقة في حين. بمعنى أن بناء الجملة مثل هذا يمكن أن يعمل أيضًا.
+
+ `for ( init; condition;) { 
+   statement(s); 
+   increment; 
+ } 
+` 
+
+### فيه
+
+تسمح لك هذه الخطوة بتعريف وتهيئة أي متغيرات تحكم في الحلقة. يتم تنفيذ هذه الخطوة أولاً ومرة ​​واحدة فقط.
+
+### شرط
+
+القادم يتم تقييم الشرط. إذا كان صحيحًا ، فسيتم تنفيذ نص الحلقة. إذا كانت تحتوي على false ، لا يتم تنفيذ نص الحلقة ويذهب تدفق عنصر التحكم إلى التكرار التالي (تكرار عملية).
+
+### تحديث
+
+يستخدم بيان التحديث لتغيير متغير الحلقة باستخدام عمليات بسيطة مثل الجمع أو الطرح أو الضرب أو القسمة. ينفّذ بيان التحديث بعد تنفيذ نص الحلقة.
+
+## التنفيذ:
+
+ `#include <iostream> 
+ using namespace std; // Here we use the scope resolution operator to define the scope of the standar functions as std:: 
+ 
+ int main () { 
+   // for loop execution 
+   for( int a = 10; a < 20; a = a + 1 ) { // The loop will run till the value of a is less than 20 
+      cout << "value of a: " << a << endl; 
+   } 
+ 
+   return 0; 
+ }``` 
+ 
+ Output: 
+ value of a: 10 
+ value of a: 11 
+ value of a: 12 
+ value of a: 13 
+ value of a: 14 
+ value of a: 15 
+ value of a: 16 
+ value of a: 17 
+ value of a: 18 
+ value of a: 19 
+ 
+ ##Single lined loop 
+ The body of the for loop need not be enclosed in braces if the loop iterates over only one satatement. 
+ ##Example 
+` 
+
+ج ++ #تتضمن استخدام اسم للمحطة؛
+
+انت مين () { // خط واحد للحلقة لـ (int a = 10؛ a <20؛ a = a + 1) cout << "قيمة a:" << a << endl؛
+
+العودة 0 } \`\` \`
+
+هذا من شأنه أن يولد نفس الناتج مثل البرنامج السابق. أي انتاج: قيمة أ: 10 قيمة أ: 11 قيمة أ: 12 قيمة أ: 13 قيمة a: 14 قيمة أ: 15 قيمة أ: 16 قيمة أ: 17 قيمة أ: 18 قيمة من: 19
+
+ `## Explanation 
+ Here's the initialization condition is first set to a=10. The loop first checks for this condition. It then checks for the condition expression ie a<20 which holds true as 10<20(for the first case). Now the body of the loop is executed and we get the output "Value of a: 10". Then the update expression is executed which adds the number 1 to 'a' and the value of 'a' gets updated to 11 and the same steps are followed (as above) until the value of v reaches less than 20 ie 19. 
+ 
+ # Range-based for-loop 
+ C++ also has what we call range-based for loops which iterates through all the elements of a container(eg array). 
+ 
+ ## Syntax 
+` 
+
+لـ (العنصر: الحاوية) صياغات)؛ }
+
+int \[5\] array = {1، 2، 3، 4، 5} لـ (int i: array) cout << i << endl؛ }
+
+انتاج: 1 2 3 4 5 \`\` \`

guide/arabic/cplusplus/functions/index.md

@@ -0,0 +1,57 @@
+---
+title: Functions in C++
+localeTitle: وظائف في C ++
+---
+## فريف:
+
+الوظيفة هي مجموعة من العبارات التي تؤدي معا مهمة. كل برنامج C ++ لديه وظيفة واحدة على الأقل ، والتي هي main ().
+
+يخبر تعريف الدالة المحول البرمجي عن اسم الدالة ونوع الإرجاع والمعلمات. يوفر تعريف الدالة الجسم الفعلي للدالة.
+
+## الشكل العام لتعريف الدالة C ++:
+
+ `return_type function_name( parameter list ) 
+ { 
+   body of the function 
+ } 
+` 
+
+### نوع الإرجاع:
+
+قد ترجع الدالة قيمة. _نوع_ الإرجاع _هو نوع البيانات للقيمة التي ترجعها الدالة. تؤدي بعض الوظائف العمليات المطلوبة دون إرجاع قيمة. في هذه الحالة ، يكون_ نوع _الإرجاع_ هو الكلمة الرئيسية باطلة.
+
+### اسم وظيفة:
+
+هذا هو الاسم الفعلي للوظيفة. يمثل اسم الدالة وقائمة المعلمات معًا توقيع الدالة.
+
+### المعلمات:
+
+المعلمة تشبه عنصرًا نائبًا. عندما يتم استدعاء دالة ، يمكنك تمرير قيمة إلى المعلمة. يشار إلى هذه القيمة كمعلمة أو وسيطة فعلية. تشير قائمة المعلمات إلى نوع ، وترتيب ، وعدد معلمات الدالة. المعلمات اختيارية. أي ، قد لا تحتوي الدالة على معلمات.
+
+### جسم الوظيفة:
+
+يحتوي نص الدالة على مجموعة من العبارات التي تحدد وظيفة الدالة.
+
+## مثال:
+
+ `int max(int num1, int num2) 
+ { 
+   // local variable declaration 
+   int result; 
+ 
+   if (num1 > num2) 
+      result = num1; 
+   else 
+      result = num2; 
+ 
+   return result; 
+ } 
+` 
+
+## لماذا تعتبر الوظائف مهمة؟
+
+تدعم وظائف النمطية (تقسيم العمل إلى أجزاء أصغر تسمى الوحدات) وهي ميزة أساسية لـ OOP والتي تفصل C ++ من C. وجود وظائف محددة لأداء مهام محددة يزيل التشويش ويقلل من طول الوظيفة الرئيسية. تؤدي الوظيفة أيضًا إمكانية إعادة استخدام الشفرة. لذا في المرة التالية التي يتعين عليك فيها حساب الحد الأقصى من رقمين مختلفين ومرة ​​أخرى في نفس البرنامج ، لن تحتاج إلى نسخ الشفرة ولصقها. عليك فقط استدعاء الوظيفة ولا بقية العمل.
+
+## معلومات اكثر
+
+*   [TutorialsPoint](https://www.tutorialspoint.com/cplusplus/cpp_functions.htm)

guide/arabic/cplusplus/goto/index.md

@@ -0,0 +1,27 @@
+---
+title: goto as a powerful utility
+localeTitle: اذهب كمنفعة قوية
+---
+# مقدمة لاستخدام goto والملصقات
+
+goto هي واحدة من أقوى المنطق الذي تم الاستهانة به إلى حد كبير في لغة ++ c ++. يمكن تحقيق مقدارًا فائقًا من التحسين باستخدام goto ، بشرط أن يتم استخدامه بشكل صحيح. يفعل ذلك الذي يدعى باسم. يذهب إلى حدوث المذكورة من التسمية التالية ، أينما يكون.
+
+# المصطلح
+
+ `goto - The keyword used to go to the particular label. 
+ label - this can be named anything. 
+` 
+
+# بناء الجملة
+
+غوتو.
+
+(بدون <>) ؛
+
+// هذا يأخذ إكس إلى المظهر التالي من التسمية.
+
+goto هو أمر يتجاوز كل الحلقات. لكي تكون أكثر وضوحًا في هذه النقطة ، إليك مثال.
+
+https://code.sololearn.com/cI4qqQA8W2q3
+
+ومع ذلك ، يجب توخي الحذر لاستخدام goto بعناية فائقة ، لا سيما في الأيام الأولى من الترميز لأنه يمكن أن يؤدي إلى مشاكل الجنون ، إذا لم يفهم بشكل جيد بما فيه الكفاية.

guide/arabic/cplusplus/if-else-statement/index.md

@@ -0,0 +1,187 @@
+---
+title: If-Else Statement
+localeTitle: If-Else Statement
+---
+## ماذا يفعل بيان If-Else؟
+
+*   عبارة If-Else عبارة عن ملحق عبارة If بسيطة.
+*   في عبارة If البسيطة ، إذا كانت قيمة تعبير الاختبار غير صحيحة ، فإننا نتخطى رمز الحظر ونستمر في بياننا التالي.
+*   ولكن في كثير من الأحيان ، نرغب في تنفيذ خطوات معينة إذا كانت قيمة التعبير التجريبي خاطئة.
+*   في مثل هذه الحالات ، نستخدم بيان if-else.
+
+### الشكل العام لبيان "If-Else"
+
+ `if (test expression) 
+ { 
+  //statements that run if the test expression is true 
+ } 
+ else 
+ { 
+  //statements that run if the test expression is false 
+ } 
+` 
+
+### مثال على بيان If-Else
+
+إذا كان اختبار التعبير صحيحًا:
+
+ `int a=10; 
+ if (a < 20) // This expression is true, so... 
+ { 
+  //...the code in this block gets executed, and... 
+ } 
+ else 
+ { 
+  //...the code in this block gets skipped. 
+ } 
+ //program continues 
+` 
+
+إذا كان اختبار التعبير غير صحيح:
+
+ `int a=10; 
+ if (a>20) // This expression is false, so this time... 
+ { 
+  //...this code gets skipped... 
+ } 
+ else 
+ { 
+  //...and this code executes instead. 
+ } 
+ //program continues 
+` 
+
+### مثال في C ++:
+
+ `//Program to check whether number entered by user is positive or negative 
+ #include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+  int no; 
+  cout << "Enter a number: " << endl; 
+ 
+  cin >> no; 
+ 
+  // condition to check if number is positive or negative 
+  if (no >= 0) // positive 
+  { 
+    // block if value is true 
+    cout << "You entered a positive number: " << no << endl; 
+  } 
+  else         // negative 
+  { 
+    // block if value is false 
+    cout << "You entered a negative number: " << no << endl; 
+  } 
+ 
+  // program continues 
+  cout << "This step is always printed" << endl; 
+  return 0; 
+ } 
+` 
+
+#### انتاج |
+
+*   عندما يتم إدخال رقم موجب:
+
+ `Enter a number: 
+ 4 
+ You entered a positive number: 4 
+ This step is always printed 
+` 
+
+*   عندما يتم إدخال رقم سالب:
+
+ `Enter a number: 
+ -200 
+ You entered a negative number: -200 
+ This step is always printed 
+` 
+
+[جرب الشفرة بنفسك](https://repl.it/MzBq)
+
+# **لا تتردد في طرح أي استفسارات على صفحة GitHub [FreeCodeCamp](https://forum.freecodecamp.org/) أو [منتدى FreeCodeCamp.](https://forum.freecodecamp.org/)**
+
+[جرب الشفرة بنفسك](https://repl.it/MzBq)
+
+### استخدام إذا كان ... آخر إذا ... آخر سلم
+
+إذا كان علينا اتخاذ قرارات استنادًا إلى أكثر من شرط واحد في حالة استخدام آخر. نستخدم آخر إذا كان الشرط على النحو التالي -
+
+ `#include<iostream> 
+ int main() 
+ { 
+    int score; 
+    std::cout<<"Enter your score: \n"; 
+    std::cin>>score; 
+    if(score>=90) 
+        std::cout<<"Top performance."; 
+    else if(score<90 && score>=70) 
+        std::cout<<"Good performance"; 
+    else if(score<70 && score>=45) 
+        std::cout<<"Average performance"; 
+    else if(score<45 && score>=30) 
+        std::cout<<"You can improve it."; 
+   return 0; 
+ } 
+` 
+
+#### انتاج |
+
+ `Enter your score: 
+ 85 
+ Good performance 
+` 
+
+### مثال آخر إذا كان ... آخر إذا ... آخر سلم
+
+لنفترض أن لدينا إدخال المستخدم رقمين وسوف نعرض إذا كان أي من الرقمين أكبر من الآخر. وإذا لم يكن أي منهما أكبر من الآخر ، فنطبع العبارة "كلاهما متساويان".
+
+في هذا scinerio سوف نحتاج إلى ... آخر إذا ... آخر بيان سلم. سيبدو البرنامج كما يلي:
+
+ `#include<iostream> 
+ using namespace std; 
+ int main() 
+ { 
+    int number1,number2; 
+    cout << "Enter first number: \n"; 
+    cin >> number1; 
+    cout << "Enter second number: \n"; 
+    cin >> number2; 
+ 
+    if(number1 > number2)     // Checks if the first number is greater than the second number 
+    { 
+        cout << "Number 1 is greater."; 
+    } 
+    else if(number2 > number1)    // Checks if the second number is greater than the first number 
+    { 
+        cout << "Number 2 is greater."; 
+    } 
+    else    // If both of the above cases return false, then both numbers are equal 
+    { 
+        cout << "Both the numbers are equal."; 
+    } 
+ 
+    return 0; 
+ } 
+` 
+
+#### انتاج |
+
+ `Enter first number: 
+ 85 
+ Enter second number: 
+ 86 
+ Number 2 is greater. 
+` 
+
+*   لاحظ أن البرنامج سيتحقق فقط من حالة "آخر إذا" عندما لا يكون شرط "if" الأولي مرضياً. وإذا لم يتم استيفاء أي من هذه الشروط ، يتم تنفيذ كتلة "آخر" آخر والتي تطبع البيان: "كلا الأرقام متساوية".
+    
+*   حجم إذا كان ... آخر إذا ... قد يختلف السلم الآخر اعتمادًا على المشكلة التي يحاول البرنامج حلها وعدد الشروط التي تحتاج إلى التحقق منها.
+    
+
+**حظا سعيدا لكم جميعا**
+
+**الترميز سعيدة! :)**
+

guide/arabic/cplusplus/index.md

@@ -0,0 +1,99 @@
+---
+title: C++
+localeTitle: C ++
+---
+# مرحبا بالعالم! - برنامج C ++ الأول الخاص بك
+
+## ما هو C ++؟
+
+*   C ++ هي لغة برمجة عامة الغرض تم استخدامها منذ التسعينات
+    
+*   تم تصميمه من قبل Bjarne Stroustrup تحت اسم "C with classes".
+    
+*   وهو إصدار من C يتضمن عناصر موجهة للعناصر ، بما في ذلك الفئات والوظائف.
+    
+*   تعتبر واحدة من أكبر لغات البرمجة ، كما ترون في الصورة التالية: ![IMG](http://static1.businessinsider.com/image/59deb30392406c21008b6148-1200/for-bonus-points-heres-the-chart-showing-these-languages-relative-popularity.jpg) _المصدر: جيثب_
+    
+
+### البرنامج الأول في C ++
+
+ `#include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+    cout << "Hello World" << endl; 
+    return 0; 
+ } 
+` 
+
+#### سيكون الناتج من هذا البرنامج ببساطة:
+
+ `Hello World! 
+` 
+
+الآن ، دعونا نحطم الشفرة:
+
+#### الأسطر 1 و 2
+
+ `#include <iostream> 
+ using namespace std; 
+` 
+
+*   السطر الأول يخبر الكمبيوتر باستخدام ملف الرأس "iostream" لهذا البرنامج المحدد. ملف رأس هو ملف منفصل مع رمز C ++ مكتوبة مسبقا. هناك العديد من الملفات الرأسية الأخرى المطلوبة لتشغيل برنامج معين بشكل صحيح. البعض منهم: الرياضيات ، ناقلات وسلسلة. يتم تمثيل ملفات الرأس بشكل عام بامتداد ".h" (لا تحتاج إلى إضافة .h عند تضمين ملفات مكتبة قياسية C ++)
+*   يقف `iostream` لتيار المدخلات والمخرجات. يحتوي ملف "iostream" على كود يسمح للكمبيوتر بأخذ المدخلات وتوليد مخرجات ، باستخدام لغة C ++.
+*   يخبر السطر الثاني الكمبيوتر لاستخدام مساحة الاسم القياسية التي تتضمن ميزات C ++ القياسية. يمكنك كتابة هذا البرنامج بدون هذا الخط ، ولكن سيكون عليك استخدام `std::cout` بدلاً من `cout` و `std::endl` بدلاً من `endl` على السطر 4. يجعل التعليمة البرمجية أكثر قابلية للقراءة وحياتنا كمبرمجين أسهل.
+
+#### الخط 3 و 4
+
+ `int main() 
+ { 
+` 
+
+*   يبدأ C ++ تنفيذ برنامج من main- `int main()` . أثناء التنفيذ ، يبدأ الكمبيوتر بتشغيل التعليمات البرمجية من كل سطر من `{` (قوس فتح) حتى `}` (قوس الإغلاق) **ملحوظة: تبدأ كل دالة بدعامة مكشوفة افتتاحية "{" وتنتهي باستدارة متعرجة مغلقة "}".**
+*   يشير السطر 4 إلى بداية الدالة main ().
+
+#### خطوط 5 و 6 و 7
+
+ `    cout << "Hello World" << endl; 
+    return 0; 
+ } 
+` 
+
+*   يتم استخدام الكلمة `cout` في C ++ للإخراج.
+*   تليها `<<` ، _مشغل الإدراج_ .
+*   كل ما هو موجود في علامات الاقتباس المزدوجة `""` مطبوع. تحتوي بعض الأحرف الخاصة على صيغة مختلفة لبيانات الطباعة
+*   الآن لطباعة أي نوع آخر من البيانات ، يجب عليك إضافة `<<` .
+
+**_التحدي: حاول تغيير Hello World إلى أي جملة أو كلمة (كلمات) أخرى. ماذا سيكون الإخراج؟_**
+
+*   `endl` كلمة محجوزة عند استخدام لغة C ++ **لإنهاء هذا الخط والانتقال إلى السطر التالي أثناء الإخراج** . - _cout لتقف على "وحدة التحكم الإخراج"_
+*   وأخيراً ، قم بإنهاء الأمر بفاصلة منقوطة `;` .
+
+**ملاحظة: يجب أن يتم إنهاء كل أمر باستثناء تعريف الدالة الرئيسي وتوجيه #include بواسطة الفاصلة المنقوطة. بدون "؛" ، قد تصادف خطأ.**
+
+*   `return 0;` ينهي بأمان الوظيفة الحالية أي "الرئيسية ()" في هذه الحالة ، وبما أن أي وظيفة لا تتبع بعد "الرئيسي ()" يتم إنهاء البرنامج.
+*   لا تنس أن تخبر الكمبيوتر أن هذه نهاية الدالة main (). للقيام بذلك ، يمكنك إضافة قوس الإغلاق مجعد "}". ستواجه خطأ قبل تنفيذ البرنامج إذا لم تقم بتضمين **}** .
+
+### يجب أن يظهر الرمز على النحو التالي:
+
+![IMG](https://i.imgur.com/d1liGwI.png)
+
+يستخدم المبرمجون برنامج Hello World (مثل هذا البرنامج) كطقس يستخدم لغة برمجة جديدة. إنه رمز لحسن الحظ.  
+_لقد انتهيت من برمجة برنامج C ++ الأول وفهمت معظم الشفرة التي كتبتها / كتبت. تهانينا!_
+
+**بالتوفيق لكم جميعا والترميز سعيدة! :)**
+
+**الترميز سعيدة! :)**
+
+**لا تتردد في طرح أي أسئلة على صفحة GitHub [FreeCodeCamp](https://forum.freecodecamp.org/) أو [منتدى FreeCodeCamp.](https://forum.freecodecamp.org/)**
+
+[جربه بنفسك! :)](https://repl.it/L4k3)
+
+**قد تحتاج إلى بعض البرامج لكتابة التعليمات البرمجية لـ C ++ وتنفيذها. أوصي باستخدام CodeBlocks. هناك رابط تنزيل أدناه:**
+
+تنزيل الرابط: [تنزيل هنا](http://www.codeblocks.org/downloads/26)
+
+*   انقر فوق الارتباط مع مترجم GNU / GCC للنوافذ. هذا لن يتطلب تثبيت إضافي
+
+يمكن أن تكون البدائل الأخرى الاستوديو المرئي ، باستخدام مترجم أو IDE عبر الإنترنت مثل Cloud9 أو repl.it
+

guide/arabic/cplusplus/inline-function/index.md

@@ -0,0 +1,80 @@
+---
+title: Inline Function
+localeTitle: وظيفة مضمنة
+---
+# وظيفة مضمنة
+
+## المقدمة
+
+الدالة المضمنة هي دالة خاصة معرفة في C ++ ويتم توسيعها في السطر عندما يتم استدعاؤها.
+
+الآن ، ماذا يعني هذا بالضبط؟
+
+عندما يتم استدعاء الدالة ، فإنه يأخذ الكثير من الوقت الإضافي لتنفيذ سلسلة من الأنشطة مثل القفز إلى الوظيفة وحفظ السجلات ودفع الحجج إلى مكدس والعودة إلى وظيفة الاستدعاء. لذلك يستغرق الكثير من الوقت. لكن الدالة المضمنة هي دالة حيث تم طلب المحول البرمجي لأداء التوسع المضمن. حيث تطلب الدالة المحول البرمجي إدراج كامل جسم الدالة في كل مكان يتم استدعاء الدالة فيه ، بدلاً من توليد كود لاستدعاء الوظيفة في مكان واحد يتم تعريفه.
+
+ومع ذلك ، لا يمكننا ضمان أن كل دالة مضمن مضمنة سيتم مضمنة. لأننا عندما نعلن عن وظيفة على هيئة `inline` ، فهي طلب ، وليست أمرًا. قد تجاهل المحول البرمجي طلب inlining في الحالات التالية: 1) إذا كان يحتوي على وظيفة حلقة على سبيل المثال `for` حلقة، `while` حلقة، `do-while` حلقة الخ 2) إذا كانت الدالة تحتوي على `switch` أو عبارة `goto` . 3) إذا كانت الدالة لا تعيد أي شيء حتى إذا تم ذكر نوع الإرجاع (بخلاف `void` طبعا). 4) إذا كانت الدالة تحتوي على متغير ثابت. 5) إذا كانت الوظيفة تحتوي على استدعاء تكراري.
+
+\`\` \`ج + +
+
+## بناء الجملة :-
+
+اسم _دالة نوع_ الإرجاع المضمن (argument\_list) {
+
+// وظيفة الهيئة
+
+}
+
+ `## When to use Inline function 
+ 
+ * When the function performs small tasks and is called very often. 
+ * When performance is important. 
+ * Instead of a macro. 
+` 
+
+ج ++
+
+# تتضمن
+
+استخدام اسم للمحطة؛
+
+class MathOperation {
+
+عامة:
+
+ `inline int add(int x, int y){ 
+ 
+  return(x+y); 
+ } 
+ 
+ inline float div(int n1, float n2){ 
+ 
+  return(n1/n2); 
+ } 
+` 
+
+}؛
+
+انت مين(){
+
+MathOperation obj؛
+
+cout << "Addition is:" << obj.add (34،12) << <"\\ n"؛ cout << "Division is:" << obj.div (12،3.4) << "\\ n"؛
+
+العودة 0
+
+} \`\` \`
+
+## مزايا وظيفة مضمنة
+
+*   فإنه يحفظ فوق من استدعاء العودة من وظيفة.
+*   يزيد من مرجع المرجع باستخدام ذاكرة التخزين المؤقت للتعليمات.
+*   فإنه يسرع البرنامج الخاص بك عن طريق تجنب النفقات العامة استدعاء وظيفة.
+*   فإنه يحفظ الحمل من عمليات دفع / pop المتغيرات على المكدس ، عندما تحدث مكالمات الدالة.
+*   من الممكن وضع تعريف دالة في ملف رأس ، أي يمكن تضمينه في وحدة تجميع متعددة ، دون أن يشكو الرابط.
+
+## مساوئ وظيفة مضمنة
+
+*   عند استخدامه في رأس الصفحة ، فإنه يجعل ملف رأسك أكبر مع المعلومات التي لا يهتم بها المستخدمون.
+*   يزيد الحجم القابل للتنفيذ بسبب توسيع التعليمة البرمجية.
+*   يتم حل C ++ المضمن في وقت التحويل البرمجي. مما يعني أنه إذا قمت بتغيير رمز الدالة المائلة ، ستحتاج إلى إعادة ترجمة جميع التعليمات البرمجية التي تستخدمها للتأكد من تحديثها.
+*   كما ذكر أعلاه يزيد من حجم الملف التنفيذي ، مما قد يتسبب في الخداع في الذاكرة. عدد أكبر من خطأ الصفحة ، مما يؤدي إلى انخفاض أداء البرنامج.

guide/arabic/cplusplus/inline-functions/index.md

@@ -0,0 +1,116 @@
+---
+title: Inline Functions in C++
+localeTitle: وظائف مضمنة في C ++
+---
+## وظائف مضمنة في C ++
+
+عندما يقوم البرنامج بتنفيذ تعليمات استدعاء الدالة ، تقوم وحدة المعالجة المركزية بتخزين عنوان الذاكرة الخاص بالتعليمات التي تلي استدعاء الدالة ، وتقوم بنسخ وسيطات الدالة الموجودة على المكدس وتقوم بنقل التحكم في النهاية إلى الوظيفة المحددة. تقوم وحدة المعالجة المركزية بعد ذلك بتنفيذ كود الوظيفة ، وتقوم بتخزين قيمة رجوع الدالة في موقع / سجل ذاكرة محدد مسبقًا وتقوم بإرجاع التحكم إلى وظيفة الاستدعاء. هذا يمكن أن يصبح الحمل إذا كان وقت تنفيذ الدالة أقل من وقت التبديل من وظيفة المتصل إلى استدعاء الدالة (callee). بالنسبة للوظائف الكبيرة و / أو التي تقوم بتنفيذ مهام معقدة ، يكون مقدار الحمل للنداء الوظيفي غير هام مقارنة بالمقدار الزمني الذي تستغرقه الوظيفة للتشغيل. ومع ذلك ، بالنسبة للوظائف الصغيرة الشائعة الاستخدام ، فإن الوقت اللازم لإجراء استدعاء الدالة يكون في كثير من الأحيان أكبر بكثير من الوقت اللازم لتنفيذ شفرة الوظيفة. يحدث هذا الحمل للوظائف الصغيرة لأن وقت تنفيذ الدالة الصغيرة أقل من وقت التبديل.
+
+يوفر C ++ وظائف مضمّنة لتقليل الحمل المكالمة الدالة. دالة مضمنة هي دالة يتم توسيعها في السطر عندما يتم استدعاؤها. عندما يتم استدعاء الدالة المضمنة يتم إدخال رمز كامل للدالة المضمنة أو استبدالها في نقطة استدعاء دالة مضمنة. يتم تنفيذ هذا الاستبدال بواسطة برنامج التحويل البرمجي C ++ في وقت التحويل البرمجي. وظيفة مضمنة قد تزيد من الكفاءة إذا كانت صغيرة. إن صيغة تعريف الدالة المضمنة هي:
+
+ `inline return-type function-name(parameters) 
+ { 
+    // function code 
+ } 
+` 
+
+تذكر أن التضمين هو مجرد طلب إلى المحول البرمجي وليس أمرًا. يمكن تجاهل المحول البرمجي طلب forlining. قد لا يؤدّي المحول البرمجي inlining في حالات مثل:
+
+*   إذا احتوت إحدى الدالات على حلقة. (ل ، بينما ، لا أثناء)
+*   إذا كانت الدالة تحتوي على متغيرات ثابتة.
+*   إذا كانت الوظيفة متكررة.
+*   إذا كان نوع إرجاع الدالة مختلفًا عن الفراغ ، ولا يوجد بيان الإرجاع في نص الدالة.
+*   إذا احتوت الدالة على مفتاح تبديل أو عبارة goto.
+
+### توفر الوظائف المضمنة المزايا التالية:
+
+*   لا تحدث الحمل استدعاء المكالمة.
+*   كما يحفظ مقدار ضغط متغيرات push / pop على المكدس عند استدعاء الدالة.
+*   كما يحفظ نفقات استدعاء العودة من وظيفة.
+*   عند تضمين إحدى الدالات ، يمكنك تمكين برنامج التحويل البرمجي من إجراء تحسين معين للسياق على نص الدالة. مثل هذه التحسينات غير ممكنة للمكالمات الدالة العادية. يمكن الحصول على تحسينات أخرى من خلال النظر في تدفقات سياق الاتصال والسياق المطلوب.
+*   قد تكون الدالة المضمّنة مفيدة (إذا كانت صغيرة) للأنظمة المضمنة لأن المضمّنة يمكن أن تسفر عن شفرة أقل من دالة استدعاء التمهيد والعودة.
+
+### عيوب وظيفة مضمنة:
+
+*   تستهلك المتغيرات المضافة من الدالة الموضعية سجلات إضافية ، بعد وظيفة البطانة الداخلية في حالة زيادة عدد المتغيرات التي ستستخدم السجل أكثر مما يمكن أن تنشئه فوق استخدام تسجيل متغير الموارد. وهذا يعني أنه عندما يتم استبدال هيئة وظيفة مضمنة في استدعاء نقطة الوظيفة ، يتم أيضًا إدخال العدد الإجمالي للمتغيرات التي تستخدمها الدالة. وبالتالي فإن عدد التسجيلات التي سيتم استخدامها للمتغيرات سيزداد أيضًا. لذا ، إذا ارتفع عدد الوظائف المتغيرة بشكل ملحوظ بعد ذلك ، فمن المؤكد أن ذلك سيؤدي إلى زيادة النفقات على استخدام السجل.
+    
+*   إذا كنت تستخدم عددًا كبيرًا جدًا من الدالات المضمّنة ، فسيكون حجم الملف التنفيذي الثنائي كبيرًا ، نظرًا لازدواج الشفرة نفسها.
+    
+*   يمكن أيضًا أن يؤدي التنصيص إلى تقليل معدل ضرب ذاكرة التخزين المؤقت للتعليمات ، وبالتالي تقليل سرعة عملية جلب التعليمات من ذاكرة التخزين المؤقت إلى الذاكرة الأساسية.
+    
+*   قد تعمل الدالة المضمّنة على زيادة الحمل الزائد أثناء التحويل إذا قام أحدهم بتغيير الشفرة داخل الدالة المضمّنة ، فيجب إعادة ترجمة كل موقع الاستدعاء لأن المحول البرمجي سيطالب باستبدال كل الشفرة مرة أخرى لتعكس التغييرات ، وإلا فإنه سيستمر مع الوظائف القديمة.
+    
+*   قد لا تكون الوظائف المضمّنة مفيدة للعديد من الأنظمة المضمّنة. نظرًا لأن حجم رمز النظام المضمّن أكثر أهمية من السرعة.
+    
+*   قد تتسبب الدالات المضمنة في سحق لأن قد يؤدي زيادة حجم الملف التنفيذي الثنائي. تسبب السقوط في الذاكرة في انخفاض أداء الكمبيوتر.
+    
+
+يوضح البرنامج التالي هذا المفهوم:
+
+ `#include <iostream> 
+ using namespace std; 
+ class operation 
+ { 
+    int a,b,add,sub,mul; 
+    float div; 
+ public: 
+    void get(); 
+    void sum(); 
+    void difference(); 
+    void product(); 
+    void division(); 
+ }; 
+ inline void operation :: get() 
+ { 
+    cout << "Enter first value:"; 
+    cin >> a; 
+    cout << "Enter second value:"; 
+    cin >> b; 
+ } 
+ 
+ inline void operation :: sum() 
+ { 
+    add = a+b; 
+    cout << "Addition of two numbers: " << a+b << "\n"; 
+ } 
+ 
+ inline void operation :: difference() 
+ { 
+    sub = ab; 
+    cout << "Difference of two numbers: " << ab << "\n"; 
+ } 
+ 
+ inline void operation :: product() 
+ { 
+    mul = a*b; 
+    cout << "Product of two numbers: " << a*b << "\n"; 
+ } 
+ 
+ inline void operation ::division() 
+ { 
+    div=a/b; 
+    cout<<"Division of two numbers: "<<a/b<<"\n" ; 
+ } 
+ 
+ int main() 
+ { 
+    cout << "Program using inline function\n"; 
+    operation s; 
+    s.get(); 
+    s.sum(); 
+    s.difference(); 
+    s.product(); 
+    s.division(); 
+    return 0; 
+ } 
+` 
+
+انتاج:
+
+ `Enter first value: 45 
+ Enter second value: 15 
+ Addition of two numbers: 60 
+ Difference of two numbers: 30 
+ Product of two numbers: 675 
+ Division of two numbers: 3 
+`

guide/arabic/cplusplus/input-and-output/index.md

@@ -0,0 +1,126 @@
+---
+title: Input and Output
+localeTitle: المدخلات والمخرجات
+---
+## المدخلات والمخرجات مع تيارات
+
+لطباعة الأشياء إلى وحدة التحكم ، أو القراءة منها ، يمكنك استخدام `cout` و `cin` ، اللذان يطلق عليهما `streams` . يتم استخدام هذه الاستعارة نظرًا لأنك تستخدم تدفقات مثل استخدامك لحوض أو نقرة: إما أن تقوم بإسقاط البيانات إلى حوض ( `cout` ) أو الحصول على بيانات من صنبور ( `cin` ).
+
+### الإخراج مع cout
+
+يستخدم برنامج "Hello World" `cout` لطباعة "Hello World!" إلى وحدة التحكم:
+
+ `#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  cout << "Hello world!" << endl; 
+ } 
+` 
+
+أول سطرين في الأعلى ضروريان لاستخدام `cout` ومجموعات التدفقات الأخرى. `#include<iostream>` يجعل كائنات الدفق متاحة ، `using namespace std;` يتيح لك كتابة `cout` مباشرة بدلاً من الاضطرار إلى كتابة `std::cout` ، وهذا يعني أن نحتاج إلى استخدام `cout` من مساحة الاسم `std` .
+
+`cout` لتقف على "وحدة التحكم الإخراج" ، وهو ما يسمى _تيار الإخراج_ الذي يمثل وحدة التحكم. عندما تريد طباعة شيء إلى وحدة التحكم ، يمكنك وضعه في `cout` ؛ تخيل أنها حفرة تؤدي إلى المحطة. لوضع الأشياء في هذه الحفرة ، في وقت واحد ، يمكنك استخدام `<<` المشغل ، ويعرف أيضا باسم _مشغل الإدراج_ 1 . يمكن تقييد المشغل ، أي يمكنك وضع عدة أشياء في واحد تلو الآخر. سوف يطبع التالي "الكعكة هي كذبة.":
+
+`cout << "The cake " << "is " << "a " << "lie." << endl;`
+
+`endl` لتقف على "End Line" وهو عنصر آخر يأتي من `<iostream>` . عند وضع `endl` في `cout` ، ستقوم بطباعة حرف السطر الجديد ("\\ n") إلى وحدة التحكم ، وكذلك _مسح_ `cout` ، مما يعني أنه سيجبر `cout` على طباعة كل شيء قمت بوضعه فيه _الآن_ . إذا كنت لا تضع `endl` إلى `cout` ، `cout` قد حفاظ على البيانات التي قد وضعت في ذلك، ولكن تنتظر المزيد من البيانات قبل طباعة كل ذلك في الواقع. هذا يسمى _التخزين المؤقت_ وهو جيد جدًا للأداء ، ولكن إذا كنت قد قدمت بالفعل كل شيء من المفترض طباعته ، فأنت تريد أن `cout` على الفور. لذلك من الممارسات الجيدة أن تنتهي مع `endl` في الأماكن التي يكون لها معنى.
+
+يمكن وضع كل شيء تقريبًا في جدول: السلاسل ، والأرقام ، والمتغيرات ، والتعبيرات ، وما إلى ذلك. في ما يلي بعض الأمثلة على عمليات إدراج البث الصحيحة:
+
+ ``// Notice we can use the number 42 and not the string "42". 
+ cout << "The meaning of life is " << 42 << endl;` // Output: The meaning of life is 42 
+`` 
+
+ ``string name = "Tim"; 
+ cout << "Except for you, " << name << endl;`// Output: Except for you, Tim 
+`` 
+
+ ``string name = "Tim"; 
+ cout << name; 
+ cout << " is a great guy!" << endl;` 
+ // Output: Tim is a great guy! 
+`` 
+
+ ``int a = 3; 
+ cout << a*2 + 18/a << endl;`// Output: 12 
+`` 
+
+### ملاحظة حول المسافة البيضاء
+
+C ++ دائما يضع _لكم_ في السيطرة، ويفعل بالضبط فقط الأشياء التي تقول أن تفعله. قد يكون هذا مفاجئًا في بعض الأحيان ، كما في المثال التالي:
+
+ `string name = "Sarah"; 
+ cout << "Good morning" << name << "how are you today? << endl; 
+` 
+
+قد تتوقع أن تطبع "صباح الخير يا سارة كيف حالك اليوم؟" ، ولكن في الواقع ، سيكون الناتج "Good morningSarahhow هل أنت اليوم؟". سبب هذا الخطأ هو أنك لم تكتب مسافات في السلاسل المحيطة `name` ، وحيث أنك لم تحدد أي مسافات ، فإن `cout` لم يقم بطباعة أي منها. النسخة الصحيحة ستكون: `cout << "Good morning " << name << " how are you today? << endl;`
+
+لا تحدث فواصل الأسطر من تلقاء نفسها. قد تعتقد أن هذا من شأنه أن يطبع وصفة على أربعة أسطر:
+
+ `cout << "To make bread, you need:"; 
+ cout << "* One egg"; 
+ cout << "* One water"; 
+ cout << "* Two wheat"; 
+` 
+
+لكن المخرج هو في الواقع على سطر واحد: "لصنع الخبز ، تحتاج: \* بيضة واحدة \* ماء واحد \* اثنين من القمح". هذا لأنه لا توجد أحرف سطر جديد في نهاية الأسطر ، لذا بشكل طبيعي ، تفترض C ++ أننا لا نريدها أن تطبع أحرف السطر الجديد.
+
+يمكنك إصلاح هذا عن طريق إضافة `endl` s بعد كل سطر ، لأنه كما تمت مناقشته سابقًا ، يدرج `endl` حرفًا في السطر الجديد في دفق الإخراج. ومع ذلك ، فإنه يفرض أيضًا أن يتم مسح المخزن المؤقت ، الأمر الذي يفقدنا بعض الأداء لأننا قد قمنا بطباعة جميع الخطوط دفعة واحدة. لذلك سيكون الأفضل إضافة أحرف سطر جديد فعليًا في نهاية الأسطر ، واستخدام `endl` فقط في النهاية:
+
+ `cout << "To make bread, you need:\n"; 
+ cout << "* One egg\n"; 
+ cout << "* One water\n"; 
+ cout << "* Two wheat" << endl; 
+` 
+
+إذا كنت تقوم فقط بطباعة وصفة صغيرة ، فإن الوقت الذي تقوم فيه بالحفظ يكون ضئيلًا ولا يستحق العناء ، ولكن إذا كنت تطبع ملايين العناصر ، فقد يكون الفرق ملحوظًا جدًا.
+
+### المدخلات مع السينما
+
+لقراءة من وحدة التحكم، يمكنك استخدام _دفق الإدخال_ `cin` بالطريقة نفسها كما تفعل `cout` ، ولكن بدلا من وضع الأمور في `cin` ، وانت "إخراجهم". يقرأ البرنامج التالي رقمين من المستخدم ويضيفهما معًا:
+
+ `#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  int a, b; // Variables to hold the two numbers. 
+ 
+  cout << "Please enter the first number:" << endl; 
+  cin >> a; 
+  cout << "Please enter the second number:" << endl; 
+  cin >> b; 
+ 
+  cout << "The sum of your numbers is: " << a + b << endl; 
+ } 
+` 
+
+يقف `cin` لـ "Console Input" وهو _دفق_ إدخال يمثل الإدخال من وحدة التحكم. في التعبير `cin >> a;` يتم قراءة البيانات من `cin` وحفظها في المتغير `a` ، باستخدام المشغل `>>` ، _عامل الاستخراج_ 2 . يقرأ عامل الاستخراج بالضبط نفس القدر المطلوب من البيانات للكتابة في المتغير الذي نحدده ، ويتخطى أي مسافة بيضاء ، لذلك إذا كان المستخدم يكتب "6" التي ستقرأ فقط كقيمة `6` .
+
+تجدر الإشارة إلى أن `cin` ستوقف البرنامج بأكمله لانتظار أن يكتب المستخدم قيمه. لن يستمر البرنامج حتى يقوم المستخدم بالضغط على enter ، وهناك بعض البيانات المراد كتابتها في المتغير. إذا قام المستخدم فقط بالضغط على الزر enter دون كتابة أي شيء ، فإن `cin` سيستمر في انتظار القيمة.
+
+يمكن ربط عامل الاستخراج `<<` . هنا هو نفس البرنامج كما في المرة السابقة ، ولكن مكتوبة بطريقة أكثر إيجازا:
+
+ `#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  int a, b; // Variables to hold the two numbers. 
+ 
+  cout << "Please enter two numbers:" << endl; 
+  cin >> a >> b; 
+  cout << "The sum of your numbers is: " << a + b << endl; 
+ } 
+` 
+
+عند العمل بالسلاسل ، يقوم مشغل الاستخراج أولاً بقراءة البيانات من `cin` لملء `a` ، ثم قراءة البيانات لملء `b` .
+
+يمكن أيضًا استخدام عبارات printf و scanf القياسية باستخدام c + عن طريق استيراد " ' الملف الاساسي.
+
+## مصادر
+
+1.  http://www.cplusplus.com/reference/ostream/ostream/operator٪3C٪3C/
+2.  http://www.cplusplus.com/reference/istream/istream/operator٪3E٪3E/

guide/arabic/cplusplus/lists/index.md

@@ -0,0 +1,13 @@
+---
+title: C++ Lists
+localeTitle: قوائم C ++
+---
+# ما هي قائمة المحكمة الخاصة بلبنان؟
+
+القوائم في C ++ هي أداة قوية مشابهة لأبناء عمها الأكثر شهرة ، C ++ Vectors. في حين أن المتجهات هي حاوية متسلسلة حيث يتم فهرسة العناصر في سلسلة متصلة ، فإن القوائم هي أيضًا حاوية متسلسلة ولكنها منظمة بشكل مختلف. تشير عناصر القائمة إلى عنصرها التالي بحيث يتم ترتيب جميع العناصر بالتسلسل ولكنها لا تستخدم الفهرسة. ماذا؟ يمكنك السؤال. يفعلون ذلك ليس عن طريق الفهرسة ولكن باستخدام أداة خاصة تسمى التكرارات. المتكررات هي مثل المؤشرات الخاصة مهمتها هي الحفاظ على ترتيب عناصر القائمة كنوع من نوع الربط بين سيارتي القطار. هنا مرئي جميل كيفية تنظيم القوائم مقارنةً بالموجهات والصفائف. ![IMG](https://imgur.com/SiU8uTe.png)
+
+## كيف تعلن القائمة
+
+إذا كنت ترغب في إعلان قائمة الأرقام التي تكتبها:
+
+'' 'الأمراض المنقولة جنسيا :: قائمة أعداد؛'''

guide/arabic/cplusplus/loops/index.md

@@ -0,0 +1,84 @@
+---
+title: Loops
+localeTitle: الحلقات
+---
+# الحلقات
+
+## المقدمة
+
+الآن دعنا نناقش شيئًا يُعرف باسم الحلقة. افترض أنك تريد طباعة الأرقام الزوجية من 1 إلى 1000 على الشاشة. اتجاه واحد للقيام بذلك هو كتابة السطور التالية
+
+\`\` \`ج + + cout << 0 << endl؛ cout << 2 << endl؛ cout << 4 << endl؛ .... .... .... cout << 1000 << endl؛
+
+ `But the problem with this approach is that you have to write the same line again and again. And if suppose you have to print 
+ prime numbers from 1 to 1000 then this will be more hectic. 
+ Therefore, in order to solve such problems loops are introduced. 
+ 
+ There are different types of loop functions: 
+ ### While and do while loops 
+ 
+ While and do while loops allow you to make the loop until a condition finishes. 
+ The difference between While and Do while is that Do while always executes once. 
+ Here you can see an example: 
+` 
+
+ج ++ بينما (الشرط) { // القانون الذي سيتم تنفيذه في حين الشرط هو الصحيح } فعل { // سيتم التنفيذ مرة واحدة وحتى تصبح الحالة خاطئة } في حين (شرط) ؛
+
+ `### For loops 
+ 
+ For loops are usually used when you know how many times the code will execute. 
+ The flow can be seen in this [graph](https://www.tutorialspoint.com/cplusplus/images/cpp_for_loop.jpg). 
+ 
+ They are declared this way: 
+` 
+
+ج ++ لـ (تهيئة متغير ؛ تحقق من شرط ؛ زيادة المتغير الذي تم تهيئته) { // رمز التنفيذ }
+
+ `Lets write a program which will print numbers from 0 to 1000 including 1000 on the screen using a for loop. 
+` 
+
+ج ++ لـ (int i = 0؛ i <= 1000؛ i ++) { cout << i << endl؛ }
+
+ ``When you execute this code in a c++ program numbers from 1 to 1000 will be printed. 
+ Now lets discuss how the for loop works. 
+ 
+ * You start a for loop by typing the keyword 'for'. It means you are starting a for loop 
+ ` for ` 
+ * Next you open and close a round bracket. In this brackets you write some conditions which will be discussed later 
+ ` for()` 
+ * Inside the brackets first you write the initial condition ie the value from where the loop will start. Like in the 
+  above program we write int i = 0 
+ ` for(int i = 0)` 
+ * Then you write the semicolon and then condition until when the loop will be executed. In the above code you define 
+   i < 1000. It means until value of i is less then 1000 execuete the loop. 
+   ` for(int i=0;i<=1000) ` 
+ * Then you define the incremented value that is how much i has to be incremented in each iteration. In the above code 
+   we write i++. It means value of i will be incremented by 1 every time. 
+    ` for(int i=0;i<=1000;i++) ` 
+ * If there is only one statement inside the loop then the curly bracket is optional but its better to write loop code 
+   within brackets so that you don't get confused. 
+    ``` c++ 
+    for(int i=0;i<=1000;i++) 
+        { 
+        } 
+     ``` 
+ * Then inside the loop you write what do you want to do. In the above program we output the value of i. 
+ 
+ So, in this way the for loop works 
+ 
+ If you want to print even numbers from 1 to 1000 then your program will look like this 
+`` 
+
+ج ++ لـ (int i = 0؛ i = 1000 = i = i + 2) { cout << i << endl؛ }
+
+\`\` \`
+
+*   الفرق في البرنامج الأول والثاني هو جزء الزيادة. بقية الكود هو نفسه. هذا البرنامج سوف يطبع 0 و ثم إضافة 2 إليه وطباعة 2 على وحدة التحكم وهكذا تصبح قيمة up تساوي 1000.
+    
+    برنامجنا النهائي لطباعة حتى الأرقام من 0 إلى 1000 سيبدو هكذا.
+    
+    \`\` \`ج + +
+    
+    # تتضمن
+    
+    استخدام اسم للمحطة؛ انت مين() { لـ (int i = 0؛ i = 1000 = i = i + 2) { cout << i << endl؛ } العودة 0 } \`\` \`

guide/arabic/cplusplus/map/index.md

@@ -0,0 +1,78 @@
+---
+title: Map
+localeTitle: خريطة
+---
+## مقدمة من الخريطة
+
+`map` عبارة عن حاوية ربطية تخزن العناصر في زوج القيمة الرئيسية. مثلما هو الحال في `Java` لديك مجموعة ، مجموعة النقابي في PHP وهلم جرا.
+
+## فوائد استخدام الخريطة
+
+*   يخزن فقط مفاتيح فريدة من نوعها وهذا أيضا في ترتيب مفروض على أساس معايير الفرز المخصصة لها.
+*   بما أن المفاتيح في ترتيب مفروز ، فإن عنصر البحث في الخريطة من خلال المفتاح سريع جدًا ، أي أنه يستغرق وقت لوغاريتمي.
+*   في `map` سيكون هناك قيمة واحدة فقط مرفقة بكل مفتاح.
+*   `map` يمكن استخدامها كمصفوفات ارتباطية.
+*   قد يتم تنفيذه باستخدام أشجار ثنائية متوازنة.
+
+هنا مثال:
+
+ `#include <iostream> 
+ #include <map> 
+ 
+ using namespace std; 
+ 
+ int main (){ 
+  map<char,int> first; 
+ 
+  //initializing 
+  first['a']=10; 
+  first['b']=20; 
+  first['c']=30; 
+  first['d']=40; 
+ 
+   map<char, int>::iterator it; 
+   for(it=first.begin(); it!=first.end(); ++it){ 
+      cout << it->first << " => " << it->second << '\n'; 
+   } 
+ 
+  return 0; 
+ } 
+` 
+
+انتاج:
+
+ `a => 10 
+ b => 20 
+ c => 30 
+ d => 40 
+` 
+
+## خلق كائن الخريطة
+
+`map<string, int> myMap;`
+
+## إدراج
+
+إدخال البيانات مع إدراج وظيفة العضو.
+
+ `myMap.insert(make_pair("earth", 1)); 
+ myMap.insert(make_pair("moon", 2)); 
+` 
+
+يمكننا أيضًا إدخال البيانات في خريطة std :: using operator \[\] ie
+
+`myMap["sun"] = 3;`
+
+## الوصول إلى عناصر الخريطة
+
+للوصول إلى عناصر الخريطة ، يتعين عليك إنشاء أداة إعادة تهيئة لها. وهنا مثال على النحو المذكور من قبل.
+
+ `map<char, int>::iterator it; 
+ for(it=first.begin(); it!=first.end(); ++it){ 
+  cout << it->first << " => " << it->second << '\n'; 
+ } 
+` 
+
+هنا يمكنك معرفة المزيد عن الخريطة: [cpluspluc\_map](http://www.cplusplus.com/reference/map/map/map/)
+
+ملاحظة: كل التعليمات البرمجية في المثال في إصدار C ++ 11. يمكنك معرفة المزيد عن إصدار C ++ [هنا](http://en.cppreference.com/w/cpp/compiler_support)

guide/arabic/cplusplus/object-oriented-programming/index.md

@@ -0,0 +1,76 @@
+---
+title: Object Oriented Programming using C++
+localeTitle: البرمجة الشيئية باستخدام C ++
+---
+## البرمجة الشيئية باستخدام C ++
+
+تهدف البرمجة الموجهة للكائنات ، OOP باختصار ، إلى تنفيذ كيانات العالم الحقيقي مثل الميراث والإخفاء وتعدد الأشكال في البرمجة. الهدف الرئيسي من OOP هو ربط البيانات والوظائف التي تعمل عليها بحيث لا يمكن لأي جزء آخر من التعليمات البرمجية الوصول إلى هذه البيانات باستثناء تلك الوظيفة.
+
+دعونا نتعرف على الخصائص المختلفة للغة البرمجة الشيئية المنحى:
+
+### موضوع:
+
+الكائنات هي كيانات وقت التشغيل الأساسية في نظام موجه للكائنات ، والكائنات هي مثيلات للفئة يتم تعريف هذه أنواع البيانات المعرفة من قبل المستخدم.
+
+ `class person 
+ { 
+    char name[20]; 
+    int id; 
+ public: 
+    void getdetails(){} 
+ }; 
+ 
+ int main() 
+ { 
+   person p1; //p1 is an object 
+ } 
+` 
+
+تشغل الكائنات مساحة في الذاكرة ويكون لها عنوان مرتبط مثل سجل في الباسكال أو البنية أو الاتحاد في C.
+
+عندما يتم تنفيذ البرنامج تتفاعل الكائنات عن طريق إرسال الرسائل إلى بعضها البعض.
+
+يحتوي كل كائن على بيانات وتعليمة برمجية لمعالجة البيانات. يمكن أن تتفاعل الكائنات دون الحاجة إلى معرفة تفاصيل كل بيانات أو رموز بعضها البعض. يكفي معرفة نوع الرسالة المقبولة ونوع الاستجابة التي يتم إرجاعها بواسطة الكائنات.
+
+### صف دراسي:
+
+الصف هو مخطط للبيانات والوظائف أو الطرق. الطبقة لا تأخذ أي مساحة.
+
+ `class class_name 
+ { 
+  private: 
+     //data members and member functions declarations 
+  public: 
+     //data members and member functions declarations 
+  protected: 
+     //data members and member functions declarations 
+ }; 
+` 
+
+Class هو نوع بيانات محدد بواسطة المستخدم مثل بنيات ونقابات في C.
+
+متغيرات الطبقة الافتراضية تكون خاصة ولكن في حالة الهيكل تكون عامة. في المثال أعلاه الشخص هو فئة.
+
+### التغليف وتجريد البيانات:
+
+يُعرف التفاف (دمج) البيانات والوظائف في وحدة واحدة بالتغليف. لا يمكن الوصول إلى البيانات إلى العالم الخارجي ويمكن فقط للوظائف التي يتم الالتفاف عليها في الفصل الوصول إليها. ويسمى هذا العزل من البيانات من الوصول المباشر من قبل البرنامج إخفاء البيانات أو إخفاء المعلومات.
+
+يشير استخراج البيانات إلى توفير المعلومات المطلوبة فقط للعالم الخارجي وإخفاء تفاصيل التنفيذ. على سبيل المثال ، ضع في الاعتبار مجمع فئة مع وظائف عامة مثل getReal () و getImag (). قد ننفذ الفصل كمصفوفة بحجم 2 أو كمتغيرين. ميزة التجريدات هي أنه يمكننا تغيير التنفيذ في أي مرحلة ، ولن يتأثر مستخدمو الفئة المعقدة لأن واجهة أسلوبنا تبقى كما هي. لو كان تطبيقنا عامًا ، لما كنا قد تمكنا من تغييره.
+
+### ميراث:
+
+الوراثة هي العملية التي بواسطتها تحصل الكائنات من فئة واحدة على خصائص كائنات من فئة أخرى. وهو يدعم مفهوم التصنيف الهرمي. يوفر الميراث reusability. هذا يعني أنه يمكننا إضافة ميزات إضافية لفئة موجودة دون تعديلها.
+
+### تعدد الأشكال:
+
+تعدد الأشكال يعني القدرة على اتخاذ أكثر من شكل واحد. قد تعرض العملية سلوكيات مختلفة في حالات مختلفة. يعتمد السلوك على أنواع البيانات المستخدمة في العملية.
+
+يدعم C ++ التحميل الزائد على المشغل والعبء الزائد للوظيفة. التحميل الزائد على المشغل هو عملية جعل المشغل يعرض سلوكيات مختلفة في حالات مختلفة. يستخدم التحميل الزائد للوظيفة اسم دالة مفرد لأداء أنواع مختلفة من المهام. يستخدم تعدد الأشكال على نطاق واسع في تنفيذ الميراث.
+
+### الربط الديناميكي:
+
+في الربط الديناميكي ، يتم تحديد الكود المطلوب تنفيذه استجابة لمكالمة الوظيفة في وقت التشغيل. لدى C ++ وظائف ظاهرية لدعم هذا.
+
+### تمرير الرسالة:
+
+تتواصل الكائنات مع بعضها البعض عن طريق إرسال وتلقي المعلومات لبعضها البعض. رسالة لكائن ما هي طلب لتنفيذ إجراء وبالتالي ستقوم باستدعاء وظيفة في كائن المتلقي الذي يقوم بإنشاء النتائج المطلوبة. ينطوي تمرير الرسالة على تحديد اسم الكائن واسم الدالة والمعلومات التي سيتم إرسالها.

guide/arabic/cplusplus/overloading/index.md

@@ -0,0 +1,100 @@
+---
+title: C++ Overloading
+localeTitle: C ++ التحميل الزائد
+---
+يتيح لك C ++ تحديد أكثر من تعريف واحد لاسم دالة أو مشغل في نفس النطاق ، وهو ما يسمى التحميل الزائد للوظيفة والحمولة الزائدة على المشغل على التوالي.
+
+الإعلان المفرط عبارة عن إعلان يتم الإعلان عنه بنفس الاسم مثل الإعلان المعلن مسبقًا في نفس النطاق ، باستثناء أن كلا التعريفين لهما حجج مختلفة و تعريف مختلف بشكل واضح (تطبيق).
+
+عندما تقوم باستدعاء وظيفة أو مشغل فوق طاقتها ، يحدد المحول البرمجي التعريف الأكثر ملاءمة للاستخدام ، من خلال مقارنة أنواع الوسيطات التي استخدمتها للاتصال بالوظيفة أو المشغل باستخدام أنواع المعلمات المحددة في التعريفات. وتسمى عملية اختيار الوظيفة أو المشغل الأكثر انشغالاً بالجلسات الزائدة.
+
+### وظيفة الحمولة الزائدة في C ++
+
+يمكنك الحصول على تعريفات متعددة لنفس اسم الوظيفة في نفس النطاق. يجب أن يختلف تعريف الدالة عن بعضها عن طريق أنواع و / أو عدد الوسيطات في قائمة الوسائط. لا يمكنك تحميل الإعلانات الدالة التي تختلف فقط حسب نوع الإرجاع.
+
+المثال التالي هو المثال الذي يتم فيه استخدام نفس وظيفة الطباعة () لطباعة أنواع مختلفة من البيانات -
+
+ `#include <iostream> 
+ #include <string> 
+ using namespace std; 
+ 
+ class printData { 
+   public: 
+      void print(int i) { 
+        cout << "Printing int: " << i << endl; 
+      } 
+      void print(double  f) { 
+        cout << "Printing float: " << f << endl; 
+      } 
+      void print(const string& s) { 
+        cout << "Printing string: " << s << endl; 
+      } 
+ }; 
+ 
+ int main() { 
+   printData pd; 
+ 
+   // Call print to print integer 
+   pd.print(5); 
+ 
+   // Call print to print float 
+   pd.print(500.263); 
+ 
+   // Call print to print string 
+   pd.print("Hello C++"); 
+ 
+   return 0; 
+ } 
+` 
+
+عندما يتم تجميع التعليمات البرمجية المذكورة أعلاه وتنفيذها ، فإنها تنتج النتيجة التالية -
+
+ `Printing int: 5 
+ Printing float: 500.263 
+ Printing string: Hello C++ 
+` 
+
+### مشغل الحمولة الزائدة في C ++
+
+يمكن أيضًا تحميل معظم المشغلات المضمنة في C ++. يسمح هذا للمبرمجين بتعيين تطبيق مختلف للمشغلين حسب الحجج. يمكن أن تعمل هذه المشغلات ذات التحميل الزائد للفئة المحددة من قبل المستخدم.
+
+ `#include<iostream> 
+ using namespace std; 
+ 
+ class Complex_Number{ 
+ private: 
+    int real; 
+    int imag; 
+ public: 
+    Complex_Number(int i = 0, int j =0) 
+    { 
+        real = i; 
+        imag = j; 
+    } 
+    //Here the operator '+' is being overloaded 
+    Complex_Number operator + (Complex_Number const &a) 
+    { 
+         Complex_Number x; 
+         x.real = real + a.real; 
+         x.imag = imag + a.imag; 
+         return x; 
+    } 
+    void print() 
+    { 
+         cout<<real<<" + i"<<imag<<endl; 
+    } 
+ }; 
+ 
+ int main() 
+ { 
+    Complex_Number c1(3, 2), c2(1, 1); 
+    //Here, the overloaded operator is called. The numbers get added according to the function defined 
+    Complex_Number c3 = c1 + c2; 
+    c3.print(); 
+ } 
+` 
+
+الناتج عن البرنامج أعلاه
+
+ `4 + i3 
+`

guide/arabic/cplusplus/preprocessors/index.md

@@ -0,0 +1,156 @@
+---
+title: Preprocessors
+localeTitle: Preprocessors
+---
+## Preprocessors in C / CPP
+
+كما يشير الاسم ، فإن Preprocessors هي البرامج التي تعالج شفرة المصدر الخاصة بنا قبل تجميعها. هناك عدد من الخطوات المتبعة بين كتابة البرنامج وتنفيذ برنامج في C / C ++. دعونا نلقي نظرة على هذه الخطوات قبل أن نبدأ في التعلم عن Preprocessors.
+
+![IMG](https://i.imgur.com/Pb0aTkV.png)
+
+يمكنك رؤية الخطوات الوسيطة في الرسم البياني أعلاه. يتم تخزين التعليمات البرمجية المصدر المكتوبة من قبل المبرمجين في الملف program.c. ثم يتم معالجة هذا الملف بواسطة preprocessors ويتم إنشاء ملف تعليمات برمجية مصدر موسع يسمى البرنامج. يتم تجميع هذا الملف الموسّع بواسطة المحول البرمجي ويتم إنشاء ملف رمز الكائن المسمى program.obj. وأخيرًا ، يربط رابط ملف كود الكائن هذا برمز الكائن لوظائف المكتبة لإنشاء ملف البرنامج التنفيذي القابل للتنفيذ.
+
+توفر برامج Preprocessor تعليمات preprocessors التي تخبر المترجم ببرمج المصدر قبل التحويل البرمجي. كل من هذه التوجيهات preprocessor يبدأ برمز `#` (التجزئة). يشير هذا الرمز ('#') في بداية العبارة في برنامج C / C ++ إلى أنه توجيه ما قبل المعالج. يمكننا وضع توجيهات المعالج السابقة في أي مكان في برنامجنا. أمثلة لبعض التوجيهات preprocessor هي: `#include` ، `#define` ، `#ifndef` etc.
+
+### أنواع التوجيهات preprocessor:
+
+1.  وحدات الماكرو
+2.  تضمين ملف
+3.  تجميع شرطي
+4.  التوجيهات الأخرى
+
+### وحدات الماكرو:
+
+وحدات الماكرو هي جزء من التعليمات البرمجية في برنامج الذي يتم إعطاء بعض الاسم. كلما تمت مصادفة هذا الاسم بواسطة المحول البرمجي ، يستبدل المحول البرمجي الاسم بقطعة الشفرة الفعلية. يتم استخدام `#define` التوجيه لتعريف ماكرو.
+
+ `  #include<iostream> 
+  #define LIMIT 3 
+  int main() 
+  { 
+    for(int i=0; i < LIMIT; i++) 
+    { 
+      std::cout<<i<<" " ; 
+    } 
+      return 0; 
+  } 
+` 
+
+انتاج:
+
+`0 1 2`
+
+في البرنامج أعلاه ، عندما ينفذ المحول البرمجي الكلمة `LIMIT` فإنه يستبدلها بـ 3. الكلمة `LIMIT` في تعريف الماكرو تسمى قالب الماكرو و "3" هي امتداد الماكرو.
+
+يجب ألا يكون هناك منقوطة ('؛') في نهاية تعريف الماكرو. لا تحتاج تعريفات ماكرو إلى فصل منقوطة.
+
+### تضمين ملف:
+
+يخبر هذا النوع من التوجيهات preprocessor المحول البرمجي لتضمين ملف في برنامج التعليمات البرمجية المصدر. هناك نوعان من الملفات التي يمكن تضمينها من قبل المستخدم في البرنامج:
+
+*   \#### Header File أو الملفات القياسية: تحتوي هذه الملفات على تعريف للوظائف المحددة مسبقًا مثل printf () ، ... scanf () وما إلى ذلك. يجب تضمين هذه الملفات للعمل مع هذه الوظائف. ... يتم الإعلان عن وظيفة مختلفة في ملفات رؤوس مختلفة. على سبيل المثال ... تميز عمليات I / O القياسية في ملف 'iostream' بينما تكون الدوال التي ... تنفذ عمليات السلسلة في ملف 'string'.
+
+#### بناء الجملة:
+
+`#include< file_name >` حيث file\_name هو اسم الملف المراد تضمينه. يخبر الأقواس `<` و `>` المحول البرمجي للبحث عن الملف في الدليل القياسي.
+
+*   \#### ملفات تعريف المستخدم: عندما يصبح البرنامج كبيرًا جدًا ، من الأفضل تقسيمه إلى ملفات أصغر وتضمينه عند الحاجة. هذه الأنواع من الملفات هي ملفات محددة من قبل المستخدم. يمكن تضمين هذه الملفات على النحو التالي: ... `#include"filename"`
+
+### التجميع الشرطي:
+
+توجيهات الترجمة الشرطية هي نوع من التوجيهات التي تساعد على تجميع جزء معين من البرنامج أو تخطي تجميع جزء معين من البرنامج على أساس بعض الشروط. يمكن القيام بذلك بمساعدة اثنين من الأوامر preprocessing `ifdef` و `endif` .
+
+#### بناء الجملة:
+
+ `  ifdef macro_name 
+    statement1; 
+    statement2; 
+    statement3; 
+    . 
+    . 
+    . 
+    statementN; 
+  endif 
+` 
+
+إذا تم تعريف الماكرو بالاسم "macroname" ، فسيتم تنفيذ كتلة البيانات بشكل طبيعي ولكن إذا لم يتم تعريفها ، فسيخسر المجمع ببساطة هذه المجموعة من العبارات.
+
+### التوجيهات الأخرى:
+
+بصرف النظر عن التوجيهات المذكورة أعلاه ، هناك توجيهان آخران لا يستخدمان بشكل شائع. هؤلاء هم:
+
+1.  \##### `#undef` Directive: يتم استخدام الأمر `#undef` ماكرو موجود. يعمل هذا التوجيه على النحو التالي:
+
+##### بناء الجملة:
+
+`#undef LIMIT` سيؤدي استخدام هذا البيان إلى إلغاء تحديد LIMIT الماكرو الحالي. بعد هذا البيان سيتم تقييم كل عبارة `#ifdef LIMIT` إلى false.
+
+2.  \##### `#pragma` Directive: هذا التوجيه هو توجيه خاص الغرض ويستخدم لتشغيل أو إيقاف بعض الميزات. هذا النوع من التوجيهات خاص بالمتحول ، أي أنها تختلف من مترجم إلى مترجم. بعض من `#pragma` توجيهات نوقشت أدناه:
+
+##### `#pragma startup` و `#pragma exit` :
+
+تساعدنا هذه التوجيهات على تحديد الوظائف المطلوبة للتشغيل قبل بدء تشغيل البرنامج (قبل أن يمرر التحكم إلى main ()) وقبل مخرج البرنامج (فقط قبل إرجاع عنصر التحكم من main ()).
+
+ `#include<stdio.h> 
+ void func1(); 
+ void func2(); 
+ #pragma startup func1 
+ #pragma exit func2 
+ void func1() 
+ { 
+    printf("Inside func1() "); 
+ } 
+ void func2() 
+ { 
+    printf("Inside func2() "); 
+ } 
+ int main() 
+ { 
+    printf("Inside main() "); 
+ 
+    return 0; 
+ } 
+` 
+
+انتاج:  
+`Inside func1() Inside main() Inside func2()`  
+سينتج الكود الموضح أعلاه الناتج كما هو موضح أدناه عند تشغيله على compilers GCC:  
+انتاج:  
+`Inside main()`  
+يحدث هذا لأن GCC لا يدعم #pragma بدء التشغيل أو الإنهاء. ومع ذلك ، يمكنك استخدام الشفرة التالية للحصول على إخراج مشابه من المترجمين في دول مجلس التعاون الخليجي.
+
+ `#include<stdio.h> 
+ void func1(); 
+ void func2(); 
+ void __attribute__((constructor)) func1(); 
+ void __attribute__((destructor)) func2(); 
+ void func1() 
+ { 
+    printf("Inside func1()\n"); 
+ } 
+ void func2() 
+ { 
+    printf("Inside func2()\n"); 
+ } 
+ int main() 
+ { 
+    printf("Inside main()\n"); 
+ 
+    return 0; 
+ } 
+` 
+
+##### `#pragma warn` التوجيه:
+
+يتم استخدام هذا التوجيه لإخفاء رسالة التحذير التي يتم عرضها أثناء التحويل البرمجي. يمكننا إخفاء التحذيرات كما هو موضح أدناه:
+
+##### `#pragma warn -rvl` :
+
+يخفي هذا التوجيه تلك التحذيرات التي تثار عندما لا تقوم دالة من المفترض أن تقوم بإرجاع قيمة بإرجاع قيمة.
+
+##### `#pragma warn -par` :
+
+يخفي هذا التوجيه تلك التحذيرات التي تثار عندما لا تستخدم وظيفة المعلمات التي تم تمريرها إليه.
+
+##### `#pragma warn -rch` :
+
+يخفي هذا التوجيه تلك التحذيرات التي يتم رفعها عندما يكون الرمز غير قابل للوصول. على سبيل المثال: أي رمز مكتوب بعد عبارة الإرجاع في إحدى الوظائف غير قابل للوصول.

guide/arabic/cplusplus/queue/index.md

@@ -0,0 +1,190 @@
+---
+title: queue
+localeTitle: طابور
+---
+## طوابير
+
+`queue` هي واحدة من الحاويات الأكثر استخدامًا في C ++. الحاوية عبارة عن بنية بيانات تخزن مجموعة من الكائنات ، بعضها في ترتيب ، وبعضها لا. تحتوي كل الحاويات على مجموعة مختلفة من الوظائف التي تسمح لك بالوصول إلى كائن (كائنات) في تلك المجموعة.
+
+`std::queue` جزء من المكتبة القياسية C ++ (ومن هنا pred `std::` ويسمح لك بتخزين البيانات في First Out First (FIFO). ملاحظة: **يجب أن تكون كافة الكائنات الموجودة في قائمة انتظار من نفس نوع البيانات**
+
+يدخل نوع البيانات الذي تقوم بتخزينه في قائمة الانتظار داخل أقواس زاوية بجوار الكلمة الرئيسية في قائمة الانتظار. على سبيل المثال ، إذا كنت ترغب في تخزين مجموعة من الأعداد الصحيحة ، فستكون قائمة الانتظار `std::queue<int> queue_name`
+
+### Queue LIFO شرح
+
+تتيح لنا `queue` الضغط على / enqueue و pop / dequeue بترتيب معين. **دفع** يعني إدخال كائن في مقدمة قائمة الانتظار. **البوب** تعني سحب الكائن "الأقدم" من نهاية قائمة الانتظار. لذا عندما تضغط عليه في المقدمة وعندما تطفو فإنك تستخرج العنصر الأقدم.
+
+![alt text](https://github.com/mohammadaziz313/helloworld/blob/master/Fifo_queue.png "FIFO Queue Enqueue و Dequeue مثال")
+
+### عمليات قائمة الانتظار
+
+يدعم حاوية قائمة الانتظار العمليات التالية:
+
+*   دفع (enqueue)
+*   pop (dequeue)
+*   فارغة
+*   بحجم
+*   أمامي
+*   الى الخلف
+
+#### إدفع
+
+يسمح لك بإدراج عنصر جديد في نهاية قائمة الانتظار ، بعد العنصر الأخير الحالي.
+
+ `//Push operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  return 0; 
+ } 
+` 
+
+#### أمامي
+
+يسمح لك بالوصول إلى العنصر التالي في قائمة الانتظار دون إزالته. العنصر التالي هو العنصر "الأقدم" في قائمة الانتظار.
+
+ `//Front operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+ 
+  return 0; 
+ } 
+` 
+
+ `Output: 
+ 1 
+ 1 
+` 
+
+#### فرقعة
+
+يسمح لك بإزالة العنصر التالي في قائمة الانتظار ، مما يقلل بشكل فعال حجمه بمقدار واحد. العنصر الذي تمت إزالته هو العنصر "الأقدم".
+
+ `//Pop operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+ 
+  return 0; 
+ } 
+` 
+
+ `Output: 
+ 1 
+ 2 
+` 
+
+#### بحجم
+
+لعرض عدد العناصر في `queue` .
+
+ `//Size operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
+ 
+  return 0; 
+ } 
+` 
+
+ `Output: 
+ 2 
+ 1 
+ 0 
+` 
+
+#### فارغة
+
+إرجاع ما إذا كانت `queue` فارغة ، أي ما إذا كان حجم قائمة الانتظار هو صفر. تقوم بإرجاع `true` إذا كان حجم قائمة الانتظار 0 أخرى بإرجاع `false`
+
+\`\` \`cpp // عملية فارغة في قائمة الانتظار
+
+# تتضمن // std :: cout
+
+# تتضمن // std :: stack
+
+انت مين () { الأمراض المنقولة جنسيا :: طابور ف.
+
+q.push (1)؛ q.push (2)؛
+
+بينما (q.empty ()! = true) { الأمراض المنقولة جنسيا :: محكمة << q.front () << '\\ ن'. q.pop ()؛ }
+
+std :: cout << "الخروج من الحلقة" << '\\ n'؛ العودة 0 }
+
+ `    Output: 
+    1 
+    2 
+    Out of loop 
+ 
+ #### Back 
+ 
+ Allows you to access the last element in the queue without removing it. 
+ The next element is the "newest" element in the queue. 
+` 
+
+حزب الشعب الكمبودي // Back العملية في قائمة الانتظار
+
+# تتضمن // std :: cout
+
+# تتضمن // std :: queue
+
+انت مين () { الأمراض المنقولة جنسيا :: طابور ف.
+
+q.push (1)؛ // دفع 1 أمام قائمة الانتظار q.push (2)؛ // دفع 2 أمام قائمة الانتظار
+
+الأمراض المنقولة جنسيا :: محكمة << q.back () << '\\ ن'. // الوصول إلى الجزء الخلفي من قائمة الانتظار الأمراض المنقولة جنسيا :: محكمة << q.back () << '\\ ن'. // الوصول إلى الجزء الخلفي من قائمة الانتظار
+
+العودة 0 } \`\` \`
+
+ `Output: 
+ 2 
+ 2 
+` 
+
+### لمزيد من الموارد:
+
+http://www.cplusplus.com/reference/queue/queue/
+
+### اقتباسات:
+
+الصورة مجاملة: https://en.wikipedia.org/wiki/FIFO _(computing_ and\_electronics)

guide/arabic/cplusplus/random-functions/index.md

@@ -0,0 +1,86 @@
+---
+title: Random Functions
+localeTitle: وظائف عشوائية
+---
+*   الأرقام العشوائية هي طريقة ملائمة لإدخال العشوائية في برنامجك. على سبيل المثال ، إذا كنت ترغب في تشغيل أي من عمليات المحاكاة أو تشغيل الألعاب ، فاحذف المؤشرات العشوائية لمصفوفة إلخ ، ثم الأرقام العشوائية هي الطريقة التي يمكنك اتباعها.
+*   ملف الرأس لتضمين استخدام أرقام عشوائية في c ++ `cstdlib` .
+*   _نصيحة للمحترفين: -_ يمكنك استخدام `cpp #include<bits/stdc++.h>` لتضمين جميع الوظائف من جميع ملفات الرأس.
+
+وظيفة: - راند ()  
+\- إرجاع رقم زائف عشوائي (عدد صحيح) من 0 إلى RAND _MAX. لا يأخذ أي حجج. - RAND_ MAX هو العدد الصحيح الأقصى المسموح به. هو مركب depedent وعادة ما يكون 2147483647.
+
+فيما يلي مثال على ذلك: -
+
+ `#include <cstdlib> 
+ #include <iostream> 
+ using namespace std; 
+ 
+ int main() { 
+  cout << rand() << endl; 
+  cout << rand() << endl; 
+  cout << rand() << endl; 
+  return 0; 
+ } 
+ 
+ /* 
+ Output:- (Note that the output is random and will differ from what is mentioned here) 
+ 1804289383 
+ 846930886 
+ 1681692777 
+ */ 
+` 
+
+الآن ، قم بتشغيل البرنامج مرة أخرى. ومره اخرى. ومره اخرى. ماذا ترى؟ يتم طباعة نفس الإخراج مرارًا وتكرارًا.
+
+دعونا نعود إلى تعريف الدالة rand (): -
+
+rand (): - _إرجاع رقم **pseudo-random** (عدد صحيح) من 0 إلى RAND\_MAX. لا يأخذ أي حجج._
+
+إذن ما هو الرقم العشوائي؟
+
+*   كما يوحي الاسم ، الرقم الذي ليس عشوائياً حقاً هو رقم شبه عشوائي.
+*   أرقام psuedorandom تخرج آمنة مشفرة وتكون عرضة للهجمات.
+*   في سياق C ++ ، يظهر الرقم عشوائيًا ، لكن ليس عشوائيًا. تفترض الدالة أن كل رقم من 0 إلى RAND\_MAX يكون على الأغلب متساوٍ وأن يبصق رقم واحد. (في الواقع، هذا ليس هو الحال ، لكنه قريب). على سبيل المثال ، يستخدم الرقم 5 في كل مكان تقريبًا. إذا كان الرقم العشوائي يبصق 5 ، فقد لا تعتقد أن الرقم غير فعال ، عشوائي.
+*   تأخذ رواية funtion العشوائية () رقمًا كبيرًا جدًا ، وتطبق modulo برقم أولي كبير وتقوم بجميع أنواع العمليات على رقم وتقوم بإرجاع قيمة. مهما كانت معقدة ، لا يزال من الممكن كسرها.
+
+كيف نحصل على مجموعة فريدة من الأرقام العشوائية durng كل تنفيذ البرنامج؟
+
+نحن نستخدم `void srand(int seed)` ؛
+
+*   "Seed" هو الاسم الذي يطلق على الرقم الذي يجعل مولد التسلسل العشوائي يبدأ عند نقطة بداية مختلفة في كل مرة. هذا يجعل من أن الدالة العشوائية لا تبصق نفس القيم أثناء تشغيل البرنامج.
+*   **من المهم فقط استدعاء استدعاء srand ONCE في بداية البرنامج.**
+*   ليست هناك حاجة لإجراء مكالمات متكررة لبذر مولد الرقم العشوائي (في الواقع ، سوف يجعل رقمك أقل بالتساوي وزعت).
+*   تقنية شائعة الاستخدام هي لبذر مولد الأرقام العشوائية باستخدام الساعة ، حيث تمنحك الساعة مخرجات مختلفة في كل مرة تنظر إليها. لذلك ، بالنسبة للبذرة ، يمكنك أخذ إخراج الوقت وتوصيله إلى مولد الأرقام العشوائية.
+*   ستقوم الدالة time () بإرجاع وقت الكمبيوتر. يتم التعبير عن هذا من حيث عدد ثواني انقضت منذ 1 يناير 1970 (الحقبة).
+*   سيعود وقت الدالة (NULL) عدد الثواني المنقضية في وقت الكمبيوتر.
+*   ملف الرأس الذي يجب تضمينه لوظائف الوقت: \`ctime '.
+
+مقتطف الشفرة:
+
+ `#include <ctime> 
+ 
+ srand(time(NULL)); 
+ cout << rand(); 
+ 
+ /* 
+ Output: (Will differ from computer to computer, and because of the seed, will also differ from time to time, literally. :D) 
+ 1696269016 
+ */ 
+` 
+
+هذا ينتج قيم مختلفة في كل مرة يتم تشغيل البرنامج.
+
+مكافأة: التغيير والتبديل في راند () لراحتك.
+
+*   منذ إرجاع rand () رقم عشوائي من 0 إلى RAND\_MAX ، إذا كنت تريد رقمًا بين 0 و 8 على سبيل المثال ، فافعل -rand () 9٪. أي رقم modulo 9 سيعود قيمة من 0 إلى 8.
+    
+*   أكثر رسمية ، إذا كنت تريد رقمًا بين L (ضمنيًا) و U (ضمنيًا) ، فيجب أن تفعل `int num = L + rand()%(U-L+1).` Explanation: - rand ()٪ (UL + 1) تقوم بارجاع رقم عشوائي (pseudo-random، dont forget) betwwen 0 و (UL). ومن ثم ، فإن إضافة L تتأكد من أننا نحصل على قيمة بين L و U.
+    
+    ملخص:-
+    
+
+1.  int rand (): إرجاع رقم عشوائي بين 0 و RAND\_MAX.
+    
+2.  void srand (int seed): يستخدم لبذر مولد الرقم العشوائي. يكفي استدعاء هذه الوظيفة _مرة واحدة_ فقط.
+    
+    ### المصادر: - إنشاء [عدد عشوائي](http://www.math.uaa.alaska.edu/~afkjm/csce211/handouts/RandomFunctions)

guide/arabic/cplusplus/range-for-loop/index.md

@@ -0,0 +1,27 @@
+---
+title: Range For Loop
+localeTitle: نطاق للحلقة
+---
+## النطاق القائم للحلقة
+
+ومقرها تراوحت `for` حلقة يسمح سهلة حلقات على مجموعة من العناصر (مثل عناصر في وعاء).
+
+مع التقليدية `for` حلقة:
+
+ `std::vector<std::string> stringList {"one", "two", "three"}; 
+ 
+ for (size_t il; il < stringList.size(); il++ 
+ { 
+  std::cout << stringList.at(il) << std::endl; 
+ } 
+` 
+
+مع مجموعة المستندة `for` حلقة:
+
+ `std::vector<std::string> stringList {"one", "two", "three"}; 
+ 
+ for (auto& singleString : stringList) 
+ { 
+  std:cout << singleString << std::endl; 
+ } 
+`

guide/arabic/cplusplus/set/index.md

@@ -0,0 +1,93 @@
+---
+title: Set
+localeTitle: جلس
+---
+يتم تعريف بنية مجموعة البيانات في c ++ بنفس الطريقة التي يتم تحديدها في سياق الرياضيات.
+
+بشكل أكثر رسمية ، المجموعات هي نوع من الحاويات الترابطية التي يجب أن يكون كل عنصر فيها فريدًا.
+
+*   لا يمكن تعديل قيمة العنصر بمجرد إدخاله ، على الرغم من أن حذف عنصر وإدخال عنصر جديد مسموح به ، بنفس الطريقة التي نقوم بها في الرياضيات.
+*   يمكن استخدام هيكل مجموعة البيانات للنموذج ، جيدًا ، يحدد نفسه. يصبح من السهل العثور على التقاطعات والنقابات وما إلى ذلك.
+*   مشابه للمتجه ، ولكن يتم السماح فقط بالقيم الفريدة.
+*   تقوم المجموعة بترتيب العناصر بترتيب متزايد عندما تقوم بإدراج عناصر في المجموعة.
+
+يتم تعيين ملف الرأس المطلوب لاستخدام بنية البيانات المحددة. أي ، يجب `#include<set>` في التعليمات البرمجية الخاصة بك لكي تتمكن من استخدام بنية البيانات المحددة.
+
+**نصيحة للمحترفين** : - استخدم `#include<bits/stdc++.h>` لتضمين جميع هياكل وبيانات C ++ بدلاً من إضافتها واحدة تلو الأخرى.  
+بعض الوظائف التي يمكن القيام بها مع مجموعة: -
+
+1.  start () - إرجاع مكرر إلى العنصر الأول في المجموعة
+2.  end () - إرجاع مكرر إلى العنصر النظري الذي يتبع العنصر الأخير في المجموعة
+3.  size () - لعرض عدد العناصر في المجموعة
+4.  max\_size () - لعرض الحد الأقصى لعدد العناصر التي يمكن أن تحتويها المجموعة
+5.  empty () - إرجاع ما إذا كانت المجموعة فارغة
+6.  محو (const g) - يزيل القيمة "g" من المجموعة
+7.  clear () - يزيل كل العناصر من المجموعة
+
+دعونا ننظر على سبيل المثال :-
+
+ `#include <iostream> 
+ #include <set> 
+ #include <iterator> 
+ 
+ using namespace std; 
+ int main() 
+ { 
+    set <int> myset;   //an empty set container. Note that size of the set need not be declared, similar to vector. 
+ 
+    // insert elements in random order 
+    myset.insert(65); 
+    myset.insert(30); 
+    myset.insert(80); 
+    myset.insert(20); 
+    myset.insert(9); 
+    myset.insert(9); // only one 9 will be added to the list. 
+ 
+ 
+    // printing set myset 
+    set <int> :: iterator itr; //an iterator is like a pointer. 
+    cout << "\nThe contents of myset : "; 
+    for (itr = myset.begin(); itr != myset.end(); ++itr) 
+    { 
+        cout << '\t' << *itr; 
+    } 
+    cout << endl; 
+ 
+ 
+    // remove all elements up to 65 in myset from the beginning:- 
+    cout << "\nContents of myset after removal of elements less than 30 : "; 
+    myset.erase(myset.begin(), myset.find(30)); 
+    for (itr = myset.begin(); itr != myset.end(); ++itr) 
+    { 
+        cout << '\t' << *itr; 
+    } 
+ 
+    // remove element with value 50 in myset 
+ 
+    int num = myset.erase(80); //returns true (and deletes) if 80 is there in the list else returns 0. 
+    cout<<"\n\n After doing myset.erase(80), "<<num<<" element is removed\n\n"; 
+    cout<<"Contents of the modified set:\t"; 
+    for (itr = myset.begin(); itr != myset.end(); ++itr) 
+    { 
+        cout << '\t' << *itr; 
+    } 
+ 
+    cout << endl; 
+ 
+ 
+    return 0; 
+ 
+ } 
+` 
+
+\`\` \`حزب الشعب الكمبودي انتاج:- محتويات myset: 9 20 30 65 80
+
+محتويات myset بعد إزالة العناصر أقل من 30: 30 65 80
+
+بعد القيام بـ myset.erase (80) ، تتم إزالة عنصر واحد
+
+محتويات المجموعة المعدلة: 30 65 \`\` \`
+
+\### المصادر
+
+1.  [المهوسون المهوسون](https://www.geeksforgeeks.org/set-in-cpp-stl/)

guide/arabic/cplusplus/stack/index.md

@@ -0,0 +1,164 @@
+---
+title: stack
+localeTitle: كومة
+---
+## كومات
+
+`stack` واحدة من حاويات الأكثر استخدامًا في C ++. الحاوية عبارة عن بنية بيانات تخزن مجموعة من الكائنات ، بعضها في ترتيب ، وبعضها لا. تحتوي كل الحاويات على مجموعة مختلفة من الوظائف التي تسمح لك بالوصول إلى كائن (كائنات) في تلك المجموعة.
+
+`std::stack` هو جزء من المكتبة القياسية C ++ (ومن هنا pred `std::` ويسمح لك بتخزين البيانات في ترتيب Last In First Out (LIFO). ملاحظة: **يجب أن تكون كافة الكائنات الموجودة داخل بنية تخزين من نفس نوع البيانات**
+
+يدخل نوع البيانات الذي تقوم بتخزينه داخل الكدسة داخل أقواس زاوية بجوار الكلمة الرئيسية للمكدس. على سبيل المثال ، إذا كنت ترغب في تخزين مجموعة من الأعداد الصحيحة ، فقد تكون `std::stack<int> stack_name`
+
+### تكدس ليفو شرح
+
+تسمح لك `stack` بالدفع والإبحار بترتيب معين. **دفع** يعني إدراج كائن في الجزء العلوي من المكدس. يعني " **Pop"** سحب آخر كائن مدرج من الجزء العلوي من المكدس. لذلك عندما تضغط عليه في الأعلى وعندما تطفو فإنك تستخرج آخر عنصر مدرج.
+
+![alt text](https://github.com/mohammadaziz313/helloworld/blob/master/Lifo_stack.png "LIFO Stack Push and Pop Example")
+
+### عمليات المكدس
+
+يدعم حاوية المكدس العمليات التالية:
+
+*   إدفع
+*   فرقعة
+*   فارغة
+*   بحجم
+*   الى الخلف
+
+#### إدفع
+
+للسماح لك بإدراج عنصر جديد أعلى الرصة ، فوق العنصر العلوي الحالي.
+
+ `//Push operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  return 0; 
+ } 
+` 
+
+#### أعلى
+
+يسمح لك بالوصول إلى العنصر العلوي دون إزالته من مجموع رقائقك.
+
+ `//Top operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  std::cout<<s.top()<<'\n';     //Accessing the top of the stack 
+  std::cout<<s.top()<<'\n';     //Accessing the top of the stack 
+ 
+  return 0; 
+ } 
+` 
+
+ `Output: 
+ 2 
+ 2 
+` 
+
+#### فرقعة
+
+يزيل العنصر الموجود أعلى الرصة ، مما يقلل بشكل فعال من حجم الرصة بمقدار واحد.
+
+ `//Pop operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  std::cout<<s.top()<<'\n';   //Accessing the top of the stack 
+  s.pop();                    //Removing element from the top of stack 
+  std::cout<<s.top()<<'\n';   //Accessing the top of the stack 
+ 
+ 
+  return 0; 
+ } 
+` 
+
+ `Output: 
+ 2 
+ 1 
+` 
+
+#### بحجم
+
+يرجع عدد العناصر في `stack` .
+
+ `//Size operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  std::cout<<s.size()<<'\n';  //Showing the size of the stack 
+  s.pop();                    //Removing element from the top of stack 
+  std::cout<<s.size()<<'\n';  //Showing the size of the stack 
+  s.pop();                    //Removing element from the top of stack 
+  std::cout<<s.size()<<'\n';  //Showing the size of the stack 
+ 
+  return 0; 
+ } 
+` 
+
+ `Output: 
+ 2 
+ 1 
+ 0 
+` 
+
+#### فارغة
+
+إرجاع ما إذا كانت `stack` فارغة ، أي ما إذا كان حجم رصة الورق لديك صفرًا أم لا. تقوم بإرجاع `true` إذا كان حجم مكدس 0 else بإرجاع `false`
+
+ `//Empty operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1); 
+  s.push(2); 
+ 
+  while(s.empty() != false){ 
+      std::cout<<s.top()<<'\n'; 
+      s.pop(); 
+  } 
+ 
+  std::cout<<"Out of loop"<<'\n'; 
+  return 0; 
+ } 
+` 
+
+ `Output: 
+ 2 
+ 1 
+ Out of loop 
+`

guide/arabic/cplusplus/switch-statements/index.md

@@ -0,0 +1,43 @@
+---
+title:Switch Statement
+localeTitle: undefined
+---
+يسمح رمز التبديل باختبار متغير من أجل المساواة في قائمة القيم. تسمى كل قيمة بالحالة ، ويتم تحديد المتغير قيد التشغيل لكل حالة.
+
+بناء الجملة: التبديل (تعبير) { حالة ثابت التعبير: صياغات)؛ استراحة؛ //اختياري حالة ثابت التعبير: صياغات)؛ استراحة؛ //اختياري
+
+// يمكنك الحصول على أي عدد من بيانات الحالة. الافتراضي: // اختياري صياغات)؛ }
+
+تنطبق القواعد التالية على بيان التبديل -
+
+يجب أن يحتوي التعبير المستخدم في عبارة switch على نوع متكامل أو تعداد ، أو يكون من نوع الفئة التي يكون للفئة فيها دالة تحويل مفردة إلى نوع متكامل أو تعداد.
+
+يمكنك الحصول على أي عدد من عبارات الحالة داخل أحد المحولات. كل حالة متبوعة بالقيمة المراد مقارنتها مع النقطتين.
+
+يجب أن يكون التعبير الثابت للحالة هو نفس نوع البيانات المتغير في المحول ، ويجب أن يكون ثابتًا أو حرفيًا.
+
+عندما يكون المتغير قيد التشغيل مساوياً لحالة ما ، سيتم تنفيذ العبارات التالية لهذه الحالة حتى يتم الوصول إلى جملة فاصل.
+
+عند الوصول إلى بيان الفاصل ، ينتهي المحول ، ويقفز تدفق التحكم إلى السطر التالي بعد عبارة التبديل.
+
+لا تحتاج كل حالة لاحتواء استراحة. في حالة عدم ظهور أي انقطاع ، فإن تدفق التحكم سوف ينتقل إلى الحالات اللاحقة حتى يتم الوصول إلى فاصل.
+
+يمكن أن يحتوي بيان التبديل على حالة افتراضية اختيارية ، والتي يجب أن تظهر في نهاية المفتاح. يمكن استخدام الحالة الافتراضية لتنفيذ مهمة عندما لا يكون أيًا من الحالات صحيحًا. لا حاجة إلى كسر في الحالة الافتراضية.
+
+مثال: \`\` \`C ++
+
+# تتضمن
+
+استخدام اسم للمحطة؛
+
+انت مين () { // تعريف المتغير المحلي: درجة char = 'D'؛
+
+التبديل (الصف) { الحالة "أ": cout << "ممتاز!" << endl ، استراحة؛ الحالة "ب": حالة 'C': cout << "well done" << endl؛ استراحة؛ الحالة "D": cout << "You passed" << endl؛ استراحة؛ حالة "F": cout << "Better try again" << endl؛ استراحة؛ الافتراضي: cout << "grade not grade" << endl؛ } cout << "درجتك" << grade << endl؛
+
+العودة 0 } \`\` \`
+
+انتاج: لقد نجحت درجتك هي د
+
+### مصادر
+
+https://www.tutorialspoint.com

guide/arabic/cplusplus/terms-to-know-for-beginners/index.md

@@ -0,0 +1,136 @@
+---
+title: IDE and Printing different text 
+localeTitle: IDE وطباعة نص مختلف
+---
+# مقدمة إلى IDE وطباعة نص مختلف:
+
+*   في المقالة الأخيرة ، بعض روابط التنزيل للبرامج المطلوبة للبرمجة. تُعرف برامج مثل هذا بـ IDE. **IDE تعني بيئة التطوير المتكاملة**
+
+## تتكون IDEs بشكل أساسي من 3 أنواع من البرامج:
+
+**1 محرر: محرر** نص معدّل قليلاً لجعل الترميز سهلاً. مثال المحرر للتشفير هو Notepad ++.
+
+**2 Debugger:** برنامج يساعدك في العثور على أخطاء في البرنامج ، وحلها قبل التنفيذ. تخيل تحطم تطبيق FaceBook عند تحميل تطبيق أو لعبة ما يؤدي إلى حدوث انهيار مفاجئ. لمنع تنفيذ خاطئ لبرنامج ، المصحح هو صديق أفضل مبرمج.
+
+**3 Compiler:** المترجم هو ذلك الجزء من الكمبيوتر الذي يحول رمز البرنامج الخاص بك إلى مستوى رفيع إلى رمز الآلة البسيطة: 0s & 1s؛ بحيث يفهم الكمبيوتر الأوامر وينفذها. من الآن فصاعداً ، سنفكر في كلمة **مترجم بشكل** متكرر.
+
+_س: جرب البحث عن IDE على Google وتشغيل برنامجك الأول عليه. تحقق من الإخراج_
+
+الآن ، قم بتثبيت IDE وحاول تغيير النص من البرنامج في المقالة الأخيرة.
+
+### تغيير النص على C ++
+
+*   لتغيير النص ، قم بتغيير ما كتبته في `""` `cout<<`
+
+برنامج عينة:
+
+ `#include <iostream> 
+ using namespace std : 
+ int main() 
+ { 
+    cout << "I Love freeCodeCamp ! "; 
+ } 
+` 
+
+تقوم التعليمة البرمجية الموجودة أعلاه بإرجاع خطأ لأنه في السطر 2 ، استخدمنا نقطتين (:) بدلاً من فاصلة منقوطة (؛) لذا ، دعنا نصحح الخطأ:
+
+ `#include <iostream> 
+ using namespace std ; 
+ int main() 
+ { 
+    cout << "I Love freeCodeCamp ! "; 
+    return 0; 
+ } 
+` 
+
+لاحظ أن البرنامج الآن يعمل على أكمل وجه. سوف يكون الإخراج: `I Love freeCodeCamp!`
+
+### الآن ، دعنا نغير النص إلى شيء آخر مثل هذا:
+
+ `    cout << "Hello World!\t I love freeCodeCamp!"; 
+` 
+
+سيكون الإخراج شيء مختلف هذه المرة:
+
+ `Hello World!     I love freeCodeCamp! 
+` 
+
+إذا أدركت ، أنشأ الأمر `\t` _مساحة تبويب_ بين النصين. هذا هو نوع واحد من الأوامر الخاصة في C ++. تُعرف هذه الأوامر الخاصة باسم _تسلسل Escape_ . يتم استخدامها لطباعة أحرف خاصة معينة لا يمكن عرض المترجم.
+
+#### تسلسلات هروب مفيدة:
+
+*   `\'` لطباعة فاصلة معكوسة واحدة
+*   `\"` لطباعة فاصلة مزدوجة معكوسة
+*   `\n` للطباعة على سطر جديد
+*   `\t` لعلامة تبويب أفقية
+*   `\f` لصفحة جديدة
+*   `\\` لخط مائل عكسي
+*   `\?` لعلامة استفهام
+
+##### الآن ، لنحاول طباعة أرقام وأحرف خاصة مع بعض تسلسلات الهروب:
+
+ `    cout << "40158 \t 236708 ! \n \\ @ \?" << endl; 
+` 
+
+يتغير الإخراج إلى:
+
+ `40158      236708 ! 
+ \ @ ? 
+` 
+
+##### لنجرب بعض الطرق الأخرى للطباعة:
+
+ `    cout << "1+2" << endl; 
+    cout << 1+2 << endl; 
+` 
+
+انتاج:
+
+*   بيان الإخراج الأول هو `1+2`
+*   بيان الإخراج الثاني هو `3`
+
+هذا لأننا لم نقم بإضافة الفواصل المقلوبة لبيان الطباعة الثاني ولذلك قام المترجم بإضافة الأرقام قبل طباعتها.
+
+#### تعليقات:
+
+*   تعتبر التعليقات ميزة مهمة للعديد من لغات البرمجة. أنها تسمح للمبرمج لتدوين الملاحظات للمساعدة الذاتية ، ولن يؤثر على تشغيل البرنامج.
+
+**الأنواع المختلفة من التعليقات وصيغة تعليق أحد التعليقات** :
+
+1 `//` ~ _Single Line تعليقات_ : طول هذه التعليقات عبارة عن سطر واحد (السطر المكتوب عليه). 2 `/* */` ~ _التعليقات متعددة الخط_ : يمكن أن تأخذ هذه التعليقات مساحة أكثر من سطر واحد.
+
+#### مثال على استخدام التعليقات:
+
+\`\` \`حزب الشعب الكمبودي cout << "Hello comment" << endl؛ // cout << "Hello Comment" << endl؛ تعليق واحد على الخط.
+
+ `/* This is an example of a multi line comment. No output is generated for this . 
+ I now end the comment.  :) */ 
+` 
+
+\`\` \`
+
+سيكون الناتج:
+
+`Hello Comment`
+
+كما قد تلاحظ ، يتم تجاهل التعليقات أثناء تنفيذ البرنامج ولا تظهر على التحقق من إخراج البرنامج. تجدر الإشارة إلى أنه على الرغم من أن التعليقات تضيف مستوى إضافيًا من قابلية القراءة إلى رمز واحد ، فمن عادتها أن تعتمد بشدة على التعليقات لوصف المنطق في شفرتك. بشكل عام ، يجب أن تتحدث الشفرة عن نفسها وتعكس نية المبرمج.
+
+كما قد تلاحظ ، يتم تجاهل التعليقات أثناء تنفيذ البرنامج ولا تظهر على التحقق من إخراج البرنامج.
+
+#### العاملين
+
+*   يسمح لك المشغلون بمقارنة تعبيرين أو أكثر
+*   `==` يساوي
+*   `!=` لا يساوي
+*   `<` أقل من
+*   `>` أكبر من
+*   `<=` أقل من أو يساوي
+*   `>=` أكبر من أو يساوي
+
+ `    (7==5); 
+` 
+
+هذا يقيّم إلى false
+
+`cpp (7!=5);` هذا بتقييم صحيح
+

guide/arabic/cplusplus/the-auto-feature/index.md

@@ -0,0 +1,71 @@
+---
+title: The Auto Feature
+localeTitle: الميزة التلقائية
+---
+## الميزة التلقائية
+
+`auto` هي ميزة C ++ 11 تتيح للمبرمج إمكانية استنتاج نوع البيانات في تعريف. هذا يمكن أن يوفر لك الكثير من الكتابة ، وخاصة مع أنواع معقدة.
+
+بدون `auto` :
+
+ `double x = 10.425; 
+ double y = x * x; 
+` 
+
+مع `auto` :
+
+ `double x = 10.425; 
+ auto y = x * x; 
+` 
+
+في حين أنه قد يبدو تافهاً ، فإنه يصبح مفيداً بشكل لا يصدق عندما تبدأ أنواع البيانات في التعقيد. على سبيل المثال ، افترض أنك تريد تخزين [`vector`](https://guide.freecodecamp.org/cplusplus/vector) من الموظفين ، وأنك مهتم فقط باسمهم وعمرهم. إحدى الطرق لتخزين الاسم والعمر يمكن أن تكون `pair` `string` وأخرى `unsigned int` . يتم `std::vector<std::pair<std::string, unsigned int>> employees` كـ `std::vector<std::pair<std::string, unsigned int>> employees` . الآن لنفترض أنك تريد الوصول إلى آخر موظف تمت إضافته:
+
+ `std::vector<std::pair<std::string, unsigned int>> employees; 
+ 
+ // without auto, you have to write: 
+ std::pair<std::string, unsigned int>> last_employee = employees.back(); 
+ 
+ // with auto, you just have to write: 
+ auto last_employee = employees.back(); 
+` 
+
+بمجرد تحديد المحول البرمجي للنوع على الجانب الأيمن من `=` يستبدل `auto` بهذا النوع.
+
+في الإصدارات الحديثة من C ++ (منذ C ++ 14)، `auto` يمكن أن تستخدم أيضا في تعريف الدالة كنوع العودة. سوف يقوم المترجم بعد ذلك باستنتاج نوع الإرجاع من بيان الإرجاع داخل الدالة. على سبيل المثال مع الموظفين:
+
+ `std::vector<std::pair<std::string, unsigned int>> employees; 
+ auto get_last_employee() { 
+    return employees.back(); // Compiler knows the return type from this line. 
+ } 
+` 
+
+سيعرف المحول البرمجي من السطر مع العبارة الإرجاع أنه يجب أن يكون نوع الإرجاع من الدالة `std::vector<std::pair<std::string, unsigned int>>` .
+
+على الرغم من [كونها](http://en.cppreference.com/w/cpp/language/auto) تقنية للغاية ، إلا أن [صفحة cppreference على السيارات](http://en.cppreference.com/w/cpp/language/auto) تصف الكثير من الاستخدامات `auto` وتفاصيل متى يمكن استخدامها أو لا يمكن استخدامها.
+
+### `auto` قبل C ++ 11
+
+في بعض الكتب المدرسية القديمة التي تحتوي على شفرة قديمة _جدًا_ ، يتم استخدام الكلمة الرئيسية `auto` بطريقة مختلفة تمامًا.
+
+كانت هذه `auto` المحددة عبارة عن كلمة رئيسية مستعارة من C ، وربما كانت الكلمة الرئيسية الأقل استخدامًا على الإطلاق.
+
+في C ++ ، تحتوي كل المتغيرات على _مدة تلقائية_ ، أي أنها محددة حتى تخرج من الوظيفة التي تم تعريفها بها.
+
+فمثلا:
+
+\`\` \`حزب الشعب الكمبودي
+
+# تتضمن
+
+انت مين() { كثافة العمليات أ = 1 ؛ // المنطقي ، كما تم تعريفه في نفس الوظيفة
+
+ `    return 0; 
+` 
+
+} أ = 2 ؛ // لا معنى له ، حيث لا يتم تعريف هنا \`\` \`
+
+هذا معطى في C ++ ، وحدد `auto` أن المتغير يجب أن يكون له _مدة تلقائية_ ، وبالتالي عدم الاستخدام.
+
+## قراءة متعمقة :
+
+*   http://www.stroustrup.com/C++11FAQ.html#auto

guide/arabic/cplusplus/the-if-statement/index.md

@@ -0,0 +1,92 @@
+---
+title: C++ If Statement
+localeTitle: C ++ If Statement
+---
+# بيان IF.
+
+**ماذا يفعل بيان if؟**
+
+*   يقوم بيان `if` بتقييم تعبير الاختبار الموجود داخل الأقواس.
+*   تستخدم عبارة `if` معاملات علائقية ومنطقية لإجراء تعابير منطقية.
+
+* * *
+
+الشكل العام لبيان `if` :
+
+ `  if (Test Expression / Condition) 
+  { 
+    // Block of statements if test expression is True 
+  } 
+` 
+
+إذا كانت قيمة تعبير الاختبار **صحيحة** ، فإن كتلة التعبير كود داخل العبارة اذا تم تنفيذها.
+
+إذا كانت قيمة التعبير التجريبي **خاطئة** ، فإن كتلة التعبير كود داخل العبارة إذا تم تخطيها واستمرار التعليمة البرمجية الخاصة بك.
+
+مثال `if` البيان:
+
+ `  int a = 10; 
+ 
+  // true statement 
+  if (a < 20) 
+  { 
+    // execute this block of code 
+  } 
+ 
+  // false statement 
+  if (a < 0) 
+  { 
+    // Skip this block of code. 
+  } 
+` 
+
+مثال في C ++:
+
+ `  // Program to check if number entered by the user is positive 
+  // If negative, the block of code is skipped 
+ 
+  #include <iostream> 
+  using namespace std; 
+ 
+  int main() 
+  { 
+    int no ; 
+    cout << "Enter a number: "; 
+    cin >> no; 
+ 
+    // if statement to check if the number is positive 
+    if ( no > 0) 
+    { 
+      cout << "You have entered a positive number: " << no << endl; 
+    } 
+ 
+    // If number is not positive, then if statement is skipped a program continues 
+    cout << "This step is always printed" << endl; 
+ 
+    return 0; 
+  } 
+` 
+
+**انتاج:**
+
+مخرج 1:
+
+ `Enter a number: 5 
+ You have entered a positive number: 5 
+ This step is always printed 
+ ``` 
+ This is the output when the number entered is positive. 
+ 
+ OUTPUT 2: 
+` 
+
+أدخل رقمًا: -1 تتم دائمًا طباعة هذه الخطوة \`\` \` هذا هو الإخراج عندما يكون الرقم الذي تم إدخاله سالبًا.
+
+[جرب الرمز بنفسك! :)](https://repl.it/Mg9X)
+
+_تهانينا . هذه هي نهاية المقالة على جملة IF_
+
+**حظا سعيدا لكم جميعا**
+
+**الترميز سعيدة! :)**
+

guide/arabic/cplusplus/tokens-operators/index.md

@@ -0,0 +1,183 @@
+---
+title: Operators
+localeTitle: العاملين
+---
+# العاملين :
+
+*   يسمح لك المشغلون بإجراء عمليات على بياناتك.
+*   تسمى البيانات التي يتم تشغيلها باسم _المعامل_ .
+*   الأنواع المختلفة لمشغلي C ++ هي:
+*   _OPERANDS_ هي البيانات التي يقوم المشغل _بتنفيذها_ بأوامر معينة.
+*   المشغلين من 3 أنواع: أحادي (يعمل على 1 المعامل) ، ثنائي (يعمل على 2 معاملات) ، ثلاثي (يعمل على 3 معاملات).
+
+### 1 مشغلات الإدخال / الإخراج -
+
+*   تسمح لك هذه المشغلات بتوجيه الإدخال والإخراج.
+    
+    ## مهارة الإدخال ">>" ##
+    
+    يُستخدم لقراءة البيانات من الإدخال القياسي (بيان "cin").
+    
+    ## عامل الإخراج "<<"
+    
+    يستخدم لإرسال الإخراج في بيان `cout` .
+    
+
+### 2 المشغلين الحساب -
+
+*   تتيح لك هذه الشركات إجراء العمليات الحسابية الأساسية.
+
+1.  _يضيف_ عامل التشغيل `+` المعاملين.
+    
+2.  يقوم `-` المشغل _بطرح_ المعاملتين.
+    
+3.  يقوم المشغل `*` _بضرب_ المعاملتين.
+    
+4.  _يقسم_ `/` المشغل ويعطي _حاصل_ المعاملان.
+    
+5.  _يقسم_ عامل التشغيل `%` ويعطي _الباقي_ من المنطقتين. (أو ، بالنسبة إلى القارئ المائل رياضياً ، `a % b` هو أساسًا نتيجة "mod b"
+    
+    ### مثال على استخدام العوامل الحسابية:
+    
+    \`\` \`حزب الشعب الكمبودي
+    
+
+# تتضمن
+
+استخدام اسم للمحطة؛
+
+انت مين() { int a = 5؛ // المعامل الأول int b = 10؛ // المعامل الثاني
+
+ `    cout << "+ operator " << a+b << "\n"; //Add 
+    cout << "- operator " << ab << "\n"; //Subtract 
+    cout << "* operator " << a*b << "\n"; //Multiply 
+    cout << "/ operator " << b/a << "\n"; //Find Quotient 
+    cout << "modulus operator " << b%a << "\n"; //Find remainder 
+ 
+    return 0; 
+` 
+
+} \`\` \`
+
+انتاج :
+
+ `+ operator 15 
+ - operator -5 
+ * operator 50 
+ / operator 2 
+ modulus operator 0 
+` 
+
+[جرب الرمز بنفسك! :)](https://repl.it/Mge9)
+
+### عامل الزيادة:
+
+*   `++` يُعرف باسم عامل الزيادة. يزيد من قيمة متغير عدد صحيح بواسطة 1.
+
+نوعان من الزيادة:
+
+*   الزيادة الأولية تقوم أولاً بزيادة القيمة ثم تستخدمها. مثال: `int a ; ++a;`
+*   زيادة البريد أولاً يستخدم المتغير ثم زيادة عليه. مثال: `int b; b++;`
+
+### مشغل التناقص:
+
+*   `--` يعرف باسم مشغل تناقص. يقلل من قيمة متغير عدد صحيح بواسطة 1.
+
+نوعان من تناقص:
+
+*   قبل decrement أولاً decrements القيمة ويستخدمها. مثال: `int a ; --a;`
+*   يستخدم decrement بوست أولاً المتغير ثم تقليله. مثال: `int b; b--;`
+
+مثال لمشغلي الزيادة والانقاص:
+
+ `#include <iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+        int a = 3 ,b = 4; 
+ 
+         // INCREMENT 
+        cout<< "Value of int a PRE INCREMENTED : " << ++a << "\n"; 
+        cout<< "Value of int b POST INCREMENTED : " << b++ << "\n"; 
+        cout<< "Value of b is changed after using once : " << b << "\n"; 
+ 
+         // DECREMENT 
+        cout << "\n"; //go to next line 
+        a = 10; //Assigning a new value to a 
+        b = 10; //Assigning a new value to b 
+        cout << "Value of int a PRE DECREMENTED : " << --a << "\n"; 
+        cout << "Value of int b POST DECREMENTED : " << b-- << "\n"; 
+        cout << "Value of b is changed after using once : " << b << "\n"; 
+ 
+        return 0; 
+ } 
+` 
+
+انتاج :
+
+ `Value of int a PRE INCREMENTED : 4 
+ Value of int b POST INCREMENTED : 4 
+ Value of b is changed after using once : 5 
+ 
+ Value of int a PRE DECREMENTED : 9 
+ Value of int b POST DECREMENTED : 10 
+ Value of b is changed after using once : 9 
+` 
+
+[جرب الرمز بنفسك! :)](https://repl.it/Mgg4/2)
+
+### 3: العلاقات العلائقية:
+
+*   تخبرنا عوامل التشغيل هذه العلاقة بين المعاملات 2 وإرجاع قيمة منطقية (0 أو 1). إذا كانت العلاقة `true` فإنه يؤدي إلى 1. إذا كان realtion غير صحيح فإنه ينتج 0.
+    
+*   المشغلين العلائقيين الستة هم:
+    
+    1.  أقل من `<`
+    2.  أكبر من `>`
+    3.  أقل من أو يساوي `<=`
+    4.  أكبر من أو يساوي `>=`
+    5.  يساوي `==`
+    6.  لا يساوي `!=`
+
+### 4: المشغلات المنطقية:
+
+*   تجمع عوامل التشغيل هذه بين التعبيرات الخاصة بالعمليات المنطقية. هم انهم :
+
+1.  منطقية AND `&&` : يتم تقييمها إلى true إذا كانت كلتا القيمتين صحيحة.
+    
+2.  منطقية أو `||` : تقيم إلى true إذا كانت أي قيمة صحيحة.
+    
+3.  منطقي لا `!` : إذا كان _التعبير_ صحيحًا ، فإن _التعبير_ هو false. هذا المشغل يعكس قيمة الحقيقة وهو مشغل وحيد.
+    
+    ### 5\. المشغلين الدائمين:
+    
+    عامل التشغيل `?:` هو المشغل الثلاثي ، أو _المشغل الشرطي_ ، لأنه يمكن استخدامه لاستبدال بيان `if else` ، أو حتى `if else if` statement. بناء الجملة:
+    
+
+`condition ? ValueIfTrue : ValueIfFalse` . هذا يوسع إلى:
+
+ `if(condition) 
+ ValueIfTrue; 
+ else ValueIfFalse; 
+` 
+
+إن استدعاء القيمة `ValueIfTrue` هو أمر خاطئ قليلاً ، لأنه لا يلزم أن يكون رقمًا. شيء من هذا القبيل:
+
+`condition ? FirstLevelTrueValue : ConditionIfFalse ? SecondLevelTrueValue : SecondLevelFalseValue` يعمل أيضًا ، ويتم تفسيره كإجراء `if else if` :
+
+ `if(condition) 
+ FirstLevelTrueValue; 
+ else if(ConditionIfFalse) 
+ SecondLevelTrueValue; 
+ else SecondLevelFalseValue; 
+` 
+
+وبالمثل، متداخلة `if` يمكن أيضا أن تكون البيانات باستخدام مشغلي الثلاثي.
+
+_العربة ، أنت الآن تعرف ما هي الرموز. المقالة القادمة ستكون على وشك_ _تهانينا_
+
+**حظا سعيدا لكم جميعا**
+
+**الترميز سعيدة! :)**
+

guide/arabic/cplusplus/tokens-variables/index.md

@@ -0,0 +1,202 @@
+---
+title: Tokens Part 1
+localeTitle: توكنز الجزء الأول
+---
+### ما هي الرموز المميزة؟
+
+الرموز هي أصغر الوحدات في البرنامج والتي تعتبر مهمة بالنسبة إلى المترجم. هناك أنواع مختلفة من الرموز:
+
+*   الكلمات الدالة
+    
+*   العاملين
+    
+*   Punctuators
+    
+*   الحرفية
+    
+*   معرفات
+    
+*   **مزيج من الرموز تشكل تعبيرا**
+    
+
+### ما هي المتغيرات؟
+
+*   تعريف الكتب: تُسمى المتغيرات أسماء الذاكرة التي يمكن تغيير بياناتها.
+    
+*   لكنني أود منك أن تفكر في متغير ليصبح شيئًا مثل مربع ، شيء من هذا القبيل: ![IMG](https://i.imgur.com/YdbgWHL.png)
+    
+
+لذلك ، على سبيل المثال: أنا أتحول إلى مكان جديد وأحتاج لترتيب الأشياء الخاصة بي في المربعات. وهكذا ، هناك شيئان في ذاكرتي ، **أي نوع من الأشياء سيتم تخزينها في الصندوق ، بحيث يكون الحجم خارج الصندوق معروفًا (نوع البيانات)** **وكيف يمكنني تحديد المربع؟ (تسمية المتغير)**  
+ومن ثم ، فإننا نعلم أن المتغير في C ++ يحتاج إلى _اسم_ _ونوع بيانات_ وأن القيمة المخزنة فيه يمكن تغييرها.
+
+### أنواع البيانات في C ++:
+
+عند التصريح عن المتغيرات في c ++ يجب أن يكون لها اسم ستقوم بإعادة كتابته لاحقاً ، قيمة (ثابتة أم لا) ونوع. سيخبر النوع المحول البرمجي بالقيم التي يمكن للمتغير استخدامها ، والعمليات المحتملة ، وسيحفظ مساحة معينة في الذاكرة. في c ++ يوجد نوعان من البيانات:
+
+*   نوع بسيط
+*   نوع البناء
+
+### أنواع البيانات البسيطة
+
+*   منطقية - بولي يعمل مثل التبديل ، يمكن تشغيله أو إيقافه.
+*   حرف - شار يخزن شخصية واحدة.
+*   عدد صحيح - int يخزن [عددًا صحيحًا](https://en.wikipedia.org/wiki/Integer) .
+*   نقطة عائمة - تعويم يمكنهم استخدام الكسور العشرية.
+*   نقطة عائمة مزدوجة - مزدوجة دقة مزدوجة لنوع العوامة.
+
+هنا يمكنك أن ترى بعض الأمثلة:
+
+ `bool GameRunning = true; 
+ char a; 
+ int x = 2; 
+` 
+
+#### يمكن أيضًا تعديل هذه الأنواع باستخدام معدِّلات مثل:
+
+وقعت غير موقعة قصيرة طويل
+
+### نوع البيانات الهيكلية
+
+#### معرفات.
+
+*   المعرفات هي الأسماء المعطاة لمتغير أو فئة أو دالة أو وظيفة محددة من قبل المستخدم.
+
+## قواعد تسمية المتغير:
+
+*   ابدأ التسمية بحرف من AZ أو az.
+*   يمكن أن تتبع الأرقام الحرف الأول لكن لا يمكننا البدء في تسمية بالأرقام.
+*   لا يسمح باستخدام المسافات أو الأحرف الخاصة ، بدلاً من ذلك ، استخدم UNDERSCORE \_.
+
+#### التصريح عن المتغير:
+
+بناء الجملة كما يلي < _نوع البيانات_ > < _اسم متغير_ > ؛ أو < _نوع البيانات_ > < _اسم المتغير_ > = < _القيمة_ > ؛ إذا أردنا أيضًا تهيئة المتغير.
+
+فمثلا : `cpp int a ; //declaring a variable named 'a' of type integer. a=4; //initializing a variable int b = 5 ; //declaring and initializing a variable 'b' of type integer.`
+
+**أمثلة على إعلان متغير:**
+
+ `int a9; 
+ char A; 
+ double area_circle; 
+ long l; 
+` 
+
+**طرق خاطئة لإعلان المتغيرات** -
+
+ `int 9a; 
+ char -a; 
+ double area of circle; 
+ long l!!; 
+` 
+
+*   لا يمكن أن تبدأ أسماء المتغيرات برقم
+*   يمنع استعمال الرموز
+*   لا يسمح بالمساحات
+
+يمكنك تخيل صناديق مختلفة ذات أحجام مختلفة وتخزين أشياء مختلفة كمتغيرات مختلفة.
+
+**ملاحظات :**
+
+1.  **يتجاهل المحول البرمجي C ++ المسافات البيضاء ويتم استخدامها بشكل عام لتجميل الرمز بحيث يكون من السهل على أي مبرمج تصحيح الأخطاء أو فهمها.**
+2.  **إذا لم يتم تهيئة متغير ، فإنه يحتوي على قيمة للقمامة. اسمحوا لي أن أقدم مثالا على ذلك:**
+
+### نطاق المتغيرات
+
+جميع المتغيرات لها مجال عملها ، ومن خارج هذه الحدود لا تحتفظ بقيمتها ، وتسمى هذه الحدود نطاق المتغير. بالنسبة لمعظم الحالات ، بين الأقواس المجعدة ، حيث يتم الإعلان عن متغير متغير موجود ، وليس خارجها. سنقوم بدراسة فئات التخزين في وقت لاحق ، ولكن حتى الآن ، يمكننا تقسيم المتغيرات على نطاق واسع إلى نوعين رئيسيين ،
+
+\*المتغيرات العالمية.
+
+\* المتغيرات المحلية.
+
+#### المتغيرات العالمية
+
+المتغيرات العالمية هي تلك التي تم الإعلان عنها ذات يوم ويمكن استخدامها طوال فترة البرنامج بأي فئة أو أي وظيفة. يجب إعلانها خارج الوظيفة الرئيسية (). إذا تم الإعلان عنها فقط ، فيمكن تعيين قيم مختلفة في وقت مختلف في عمر البرنامج. ولكن حتى إذا تم إعلانها وتهيئتها في نفس الوقت خارج الوظيفة الرئيسية () ، فيمكن أيضًا تعيين أي قيمة لها في أي نقطة في البرنامج.
+
+على سبيل المثال: المعلنة فقط ، لم تتم تهيئتها.
+
+ `#include <iostream> 
+ using namespace std; 
+ int x;                // Global variable declared 
+ int main() 
+ { 
+ x=10;                 // Initialized once 
+ cout <<"first value of x = "<< x; 
+ x=20;                 // Initialized again 
+ cout <<"Initialized again with value = "<< x; 
+ } 
+` 
+
+#### المتغيرات المحلية
+
+المتغيرات المحلية هي المتغيرات التي لا توجد إلا بين الأقواس المجعدة ، والتي أعلن عنها. خارج أنها غير متوفرة ويؤدي إلى خطأ وقت الترجمة.
+
+مثال:
+
+ `#include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+ int i=10; 
+ if(i<20)        // if condition scope starts 
+  { 
+    int n=100;   // Local variable declared and initialized 
+  }              // if condition scope ends 
+ cout << n;      // Compile time error, n not available here 
+ } 
+` 
+
+### متغيرات ثابتة
+
+المتغير الثابت هو المتغيرات التي لا يمكن تغييرها. على سبيل المثال ، إذا كنت تحتاج إلى "pi" في التعليمة البرمجية ، فلا ترغب في تغييرها بعد التهيئة.
+
+مثال:
+
+ `#include <iostream> 
+ using namespace std; 
+ const double PI = 3.14159253; 
+ int main() 
+ { 
+ //Calculating the area of a circle, using user provided radius 
+ double radius; 
+ //input and output explained in other guide 
+ cin>>radius; 
+ //pi*r^2 
+ double area = PI*radius*radius; 
+ cout<<area<<endl; 
+ } 
+` 
+
+### قيم القمامة في متغير
+
+إذا لم يتم تهيئة متغير ، فإنه يحتوي على قيمة للقمامة. فمثلا:
+
+لذلك من حيث المربعات ، يمكنك تخيل هذا على أنه -
+
+![IMG](https://i.imgur.com/YdbgWHL.png)
+
+\`\` \`حزب الشعب الكمبودي #تتضمن استخدام اسم للمحطة؛ انت مين() { كثافة العمليات cout << "Garbage value in a:" << a << endl؛ // يعلن المتغير المسمى 'a' من عدد صحيح و= 5؛ // تهيئة المتغير. cout << "New value in a" << a << endl؛
+
+} \`\` \`
+
+### الناتج هو:
+
+ `Garbage value in a : 0 
+ New value in a :  5 
+` 
+
+كما ترى ، هناك بالفعل قيمة مخزنة في 'a' قبل أن نعطيها قيمة (هنا ، هي 0). يجب أن يظل هذا في ذهن كل مبرمج بحيث لا يتم إنشاء خطأ منطقي وطباعة قيم البيانات المهملة عند استخدام المتغيرات.
+
+[جرب الرمز بنفسك! :)](https://repl.it/Mg7j)
+
+#### الكلمات الدالة :
+
+_الكلمات المفتاحية هي كلمات محجوزة تنقل معنى خاص إلى المترجم. **لا** يمكن استخدامها لتسمية c ++._ أمثلة على الكلمات الرئيسية: inline، operator، private int، double، void، char، template، using، virtual، break، case، switch، friend، etc.
+
+**يتم استخدام كل من هذه الكلمات الأساسية لوظيفة خاصة في C ++.**
+
+_الجزء المميزات 1 قد انتهى. أراك المعسكر في [الجزء 2](https://guide.freecodecamp.org/cplusplus/tokens-part-II) من الرموز المميزة :)_
+
+**حظا سعيدا لكم جميعا**
+
+**الترميز سعيدة! :)**
+

guide/arabic/cplusplus/tokens-variables/static-variable-info/index.md

@@ -0,0 +1,117 @@
+---
+title: Variables
+localeTitle: المتغيرات
+---
+دعونا نناقش شيء يعرف كمتغيرات. المتغيرات هي بمثابة دلو. يمكنك وضع شيء فيه ثم تغييره بعد ذلك عند الحاجة. في C ++ ، هناك العديد من أنواع المتغيرات مثل الأعداد الصحيحة ، السلاسل ، Booleans وغيرها الكثير. دعونا ننظر إلى برنامج بسيط باستخدام المتغيرات الصحيحة. تخزن أعداد صحيحة الأعداد الصحيحة التي تكون موجبة أو سالبة أو صفر. الأرقام الكاملة ليست أرقام كسور على سبيل المثال 1/2 و 1/4 و 1/5. دعونا ننظر إلى برنامج بسيط يستخدم عددًا صحيحًا متغير.
+
+ `#include <iostream> 
+ using namespace std ; 
+ int main() 
+ { 
+    int a;          // Declare an integer variable a 
+    a = 5;          // Assign value of 5 to variable a 
+    cout << a;      // Display the value of variable a which contains 5 
+    return 0; 
+ } 
+` 
+
+عند تنفيذ هذا البرنامج ، سترى 5 معروضة على الشاشة
+
+*   لاحظ أنه في البرنامج أعلاه // يوضع بعد السطور. الرمز "//" مخصص لتعليق كودنا. رمز بعد الرمز لم يتم تنفيذ "//" في السطر الذي تم وضعه فيه.
+    
+*   على السطر 5 يتم الإعلان عن متغير صحيح بسيط.
+    
+*   في السطر 6 ، يتم تعيين القيمة 5 للمتغير a. الآن عندما نستخدم المتغير a في برنامجنا ، ستكون قيمته 5 ما لم نغيرها.
+    
+*   في السطر 7 ، نعرض قيمة المتغير a و 5 مطبوعة على الشاشة.
+    
+
+### نطاق المتغيرات
+
+جميع المتغيرات لها مجال عملها ، ومن خارج هذه الحدود لا تحتفظ بقيمتها ، وتسمى هذه الحدود نطاق المتغير. بالنسبة لمعظم الحالات ، بين الأقواس المجعدة ، حيث يتم الإعلان عن متغير متغير موجود ، وليس خارجها. سنقوم بدراسة فئات التخزين في وقت لاحق ، ولكن حتى الآن ، يمكننا تقسيم المتغيرات على نطاق واسع إلى نوعين رئيسيين ،
+
+\*المتغيرات العالمية.
+
+\* المتغيرات المحلية.
+
+#### المتغيرات العالمية
+
+المتغيرات العالمية هي تلك التي تم الإعلان عنها ذات يوم ويمكن استخدامها طوال فترة البرنامج بأي فئة أو أي وظيفة. يجب إعلانها خارج الوظيفة الرئيسية (). إذا تم الإعلان عنها فقط ، فيمكن تعيين قيم مختلفة في وقت مختلف في عمر البرنامج. ولكن حتى إذا تم إعلانها وتهيئتها في نفس الوقت خارج الوظيفة الرئيسية () ، فيمكن أيضًا تعيين أي قيمة لها في أي نقطة في البرنامج.
+
+على سبيل المثال: المعلنة فقط ، لم تتم تهيئتها.
+
+ ``include <iostream> 
+ using namespace std; 
+ int x;                // Global variable declared 
+ int main() 
+ { 
+ x=10;                 // Initialized once 
+ cout <<"first value of x = "<< x; 
+ x=20;                 // Initialized again 
+ cout <<"Initialized again with value = "<< x;` 
+ } 
+`` 
+
+#### المتغيرات المحلية
+
+المتغيرات المحلية هي المتغيرات التي لا توجد إلا بين الأقواس المجعدة ، والتي أعلن عنها. خارج أنها غير متوفرة ويؤدي إلى خطأ وقت الترجمة.
+
+مثال:
+
+ `include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+ int i=10; 
+ if(i<20)        // if condition scope starts 
+  { 
+    int n=100;   // Local variable declared and initialized 
+  }              // if condition scope ends 
+ cout << n;      // Compile time error, n not available here 
+ } 
+` 
+
+الآن دعونا نقرأ عن نوع جديد من المتغيرات
+
+#### متغير ثابت
+
+المتغيرات الساكنة: عندما يتم الإعلان عن متغير على أنه ثابت ، يتم تخصيص مساحة له طوال مدة البرنامج. حتى إذا تم استدعاء الدالة عدة مرات ، يتم تخصيص مساحة للمتغير الثابت مرة واحدة فقط ويتم تحميل قيمة المتغير في المكالمة السابقة من خلال استدعاء الوظيفة التالي. يفيد ذلك في تنفيذ الكوروتين في C / C ++ أو أي تطبيق آخر حيث يجب تخزين الحالة السابقة للوظيفة. في المصطلحات العادية ، يعني ذلك أن المتغير الطبيعي عندما يخرج من النطاق يفقد هويته (قيمة) ، ولكن المتغير الثابت له نطاق عالمي ويحتفظ به حتى نهاية البرنامج ، ولكن بخلاف المتغير الشامل ، ليس من الضروري الإعلان عنه. في بداية البرنامج.
+
+#### إضافي-
+
+Static هي كلمة أساسية في C ++ تستخدم لإعطاء خصائص خاصة لعنصر. يتم تخصيص العناصر الثابتة للتخزين مرة واحدة فقط في عمر البرنامج في منطقة التخزين الثابتة. ولديهم نطاق حتى عمر البرنامج.
+
+#### الشفرة-
+
+ `#include <iostream> 
+ #include <string> 
+ using namespace std; 
+ 
+ void howstaticworks() 
+ { 
+    static int count = 0;  // static variable 
+    cout << count << " "; 
+ 
+    /* value is updated and 
+     will be carried to next 
+     function calls*/ 
+    count++; 
+ } 
+ 
+ int main() 
+ { 
+    for (int i=0; i<5; i++) 
+        howstaticworks(); 
+    return 0; 
+ } 
+` 
+
+#### جرب بنفسك
+
+فقط انسخ الكود وألصقه في الرابط المعطى. تشغيل على IDE- https://ideone.com/
+
+انتاج: 0 1 2 3 4
+
+يمكنك أن ترى في البرنامج أعلاه أن العد المتغير يعلن بأنه ثابت. لذلك ، يتم تنفيذ قيمته من خلال المكالمات الدالة. لا تتم تهيئة عدد المتغيرات في كل مرة يتم استدعاء الدالة.
+
+دعونا نعطي نفس رمز المحاولة عن طريق إزالة الكلمة "ثابتة" وتخمين الناتج ومقارنتها مع واحدة على IDE. يتم الآن تحويل ثابت إلى متغير عادي

guide/arabic/cplusplus/vector/index.md

@@ -0,0 +1,200 @@
+---
+title: Vectors
+localeTitle: ثلاثة أبعاد
+---
+## ثلاثة أبعاد
+
+يعد `vector` C ++ واحدًا من أكثر الحاويات استخدامًا في C ++. الحاوية عبارة عن بنية بيانات تخزن مجموعة من الكائنات التي يمكن أن تختلف عن الترتيب (مثل `vector` !) إلى غير مرتبة (مثل `set` ). تحتوي كل حاويات C ++ على مجموعة مختلفة من الوظائف التي تسمح لك بالوصول إلى كائن (كائنات) في تلك المجموعة ، وتعديلها وتكرارها فوق العناصر الموجودة في بنية البيانات تلك.
+
+تتشابه المؤشرات مع ArrayLists في Java حيث لا يلزم تحديد طول الحاوية. مقارنةً بالمصفوفة التي يتعين عليك فيها تحديد حجمها ، يعتمد حجمها على محتوياتها.
+
+`std::vector` هو جزء من مكتبة C ++ القياسية (ومن ثم `std::` ويسمح لك بتخزين البيانات المتجاورة من نفس نوع البيانات. ملاحظة: **يجب أن تكون جميع الكائنات داخل المتجه من نفس نوع البيانات**
+
+يدخل نوع البيانات الذي تقوم بتخزينه ضمن المتجه ضمن أقواس زاوية بجوار الكلمة الأساسية للمتجه. على سبيل المثال ، إذا كنت ترغب في تخزين مجموعة من السلاسل ، فسيكون المتجه `std::vector<std::string> vector_name`
+
+_ملاحظة_ : يجب عليك تضمين مكتبة المتجه عند استخدام المتجهات!
+
+`#include <vector>`
+
+### ناقلات البناء
+
+هناك العديد من الطرق convinent لبناء ناقلات.
+
+استخدام قائمة intializer - حيث يتم إدراج الكائنات داخل مجموعة من الأقواس: `{ }`
+
+ `std::vector<int> a{1, 2, 3, 4, 5}; // a is a vector of 5 ints: 1, 2, 3, 4 and 5 
+ std::vector<std::string> b{"hello", "world"}; // b is a vector of 2 strings: "hello" and "world" 
+ std::vector<bool> v; // v is an empty vector 
+` 
+
+بناءه من متجه آخر (يعرف هذا باسم نسخة البناء)
+
+ `std::vector<double> a{1.0, 2.0, 3.0}; 
+ std::vector<double> b(a); // b is a vector of 3 doubles: 1.0, 2.0 and 3.0 
+` 
+
+استهلاله بنفس العنصر:
+
+ `std::vector<int> a(100, -1); // a is a vector of 100 elements all set to -1 
+` 
+
+### المتجهات المتجهات
+
+يمكن اعتبار المتكررات كمؤشرات تستخدم على وجه التحديد للتنقل في الحاويات (مثل المتجهات). تبدأ أهم التكرارات `begin()` `end()` . `begin()` بإرجاع مؤشر إلى العنصر الأول في متجه بينما تشير نقاط `end()` إلى موضع واحد بعد العنصر الأخير في متجه. على هذا النحو من خلال حلقات ناقلات يمكن أن يتم على النحو التالي:
+
+ `std::vector<int> vec{1, 2, 3}; 
+ 
+ for(auto vec_it = vec.begin(); vec_it != vec.end(); it++){ 
+    // since vec_it is a pointer and points to the memory address of the item 
+    // inside the vector, vec_it must be dereferenced using '*' 
+    std::cout << *it << '\n'; 
+ } 
+ /*  Output 
+    1 
+    2 
+    3 
+ */ 
+` 
+
+### تعديل ناقل
+
+دفع العناصر إلى متجه:
+
+ `std::vector<int> vec; // constructs an empty vector 
+ 
+ for (int i = 0; i < 10; i = i + 2){ 
+    vec.push_back(i); 
+ } 
+ // vec now holds [0, 2, 4, 6, 8] 
+` 
+
+يختلف إدراج عنصر في موضع معين قليلاً. إدراج ناقلات C ++ تعمل وظيفة على المكرر. وسوف تدرج البند المعطى موضع واحد قبل المعطى مكرر.
+
+ `std::vector<unsigned int> vec{3, 400, 12, 45}; 
+ 
+ auto iter = vec.begin() + 2; // iter now points to '12' 
+ vec.insert(iter, 38); // inserts '38' before '12' 
+ 
+ // vec: [3, 400, 38, 12, 45] 
+` 
+
+### الوصول للعنصر
+
+توفر المكتبة القياسية وظائف مختلفة للوصول إلى عناصر معينة في متجهك.
+
+ `std::vector<std::string> a{"test", "element", "access"}; 
+ 
+ std::string first_item = a.front(); // gets the first item of the vector ("test") 
+ std::string last_item = a.back(); // gets the last item in the vector ("access") 
+ 
+ // To get an element at a specific index (remember: vector indices start at 0) 
+ std::string second_item = a.at(2); // gets "element" 
+ // OR 
+ std::string second_item = a[2]; // gets "element" 
+` 
+
+### الالتفاف على العناصر في `vector`
+
+التكرار فوق العناصر الموجودة في المتحد C ++ `std::vector` يختلف اختلافًا كبيرًا عن التكرار فوق العناصر في متجه في JavaScript أو Ruby. نظرًا لأن C ++ عبارة عن تجريد رقيق لـ C ، فيمكنك فقط التكرار فوق العناصر باستخدام هذه المتغيرات الصغيرة الرائعة التي تسمى المتكررات للوصول إلى كل عنصر. غالبًا ما تأتي المتكررات في شكل مؤشرات هي متغيرات تقوم بتخزين عنوان الذاكرة لمتغير آخر. يمكنك معرفة المزيد حول المؤشرات [هنا](https://www.tutorialspoint.com/cplusplus/cpp_pointers.htm) . ومع ذلك ، لأن التكرارات تعمل كمؤشرات (أو العكس) ، من أجل معرفة ما يشيرون إليه ، تحتاج إلى إدخاله في متغير من نوع appropirate. كيف نفعل ذلك؟ هنا. نحن. اذهب!
+
+ `std::vector<std::string> a{"test", "element", "access"}; 
+ for(auto it = v.begin(); it != v.end(); it++) { //notice use of auto keyword 
+    cout<<*it<<endl; //Will print out string that the iterator is currently ppointing to 
+ } 
+` 
+
+من هنا ، يمكنك القيام بكل أنواع الأشياء الرائعة ، مثل التلاعب بالمتجه أو العبث مع أمره كما تشاء!
+
+### بعض وظائف الأعضاء مفيدة
+
+توفر أيضًا مكتبة القوالب القياسية (STL) _طرقًا_ مختلفة لك:
+
+ `std::vector.size(); // returns the size of the vector (the number of positions in the vector) 
+ std::vector.begin(); // returns an iterator which is a pointer to the beginning of the vector 
+ std::vector.end(); // returns an iterator which is a pointer to the end of the vector 
+ std::vector.empty(); // returns true if the vector is empty, otherwise returns false. 
+ std::vector.front(); // returns the first element of the vector. 
+ std::vector.back(); // returns the last element of the vector. 
+ std::vector.push_back(n); // inserts the element "n" to the end of the vector. 
+ std::vector.pop_back(n); // removes the last element of the vector 
+` 
+
+### المتجهات المحاكية
+
+توفر التكرارات طريقة أخرى للوصول إلى العناصر في المتجه.
+
+إعلان Iterator.
+
+ `std::vector<int> v; 
+ //Iterator delcaration for the above vector will correspond to 
+ std::vector<int>::iterator it; 
+` 
+
+استخدام المكرر لطباعة عناصر المتجه باستخدام الحلقة
+
+ `for(it=v.begin(); it!=v.end(); ++it) 
+ //std::vector::begin and std::vector::end return iterator pointing to first and last element of the vector respectively. 
+  cout<<*it; 
+` 
+
+### متكررة من خلال ناقل
+
+هناك طرق مختلفة للتكرار من خلال المتجه والوصول إلى محتوياته. النماذج التالية مكافئة ، أولها ينطوي على استخدام تعبير قائم على أساس (منذ C ++ 11) ، والثاني يستخدم التكرارات ، والآخر هو التكرار المستند إلى الفهرسة
+
+\`\` \`cpp
+
+# تتضمن
+
+# تتضمن
+
+// أعلن أول المتجه الأمراض المنقولة جنسيا :: ناقلات myVector {1، 2، 3، 4، 5}؛ // a عبارة عن متجه 5 أحصمة: 1 و 2 و 3 و 4 و 5
+
+// استخدام حلقة تستند إلى مجموعة (منذ C ++ 11) لـ (int element: myVector) {/ / / / تقرأ مثل "لكل عنصر في myVector" std :: cout << "العنصر هو" << element << std :: endl؛ }
+
+// باستخدام مبرمج الأمراض المنقولة جنسيا :: ناقلات :: يكررها ؛ // تعلن عن المكرر لـ (it = myVector.begin ()؛ it! = myVector.end ()؛ ++ it) { std :: cout << "العنصر هو" << \* it << std :: endl؛ // Dereference the iterator to access data }
+
+// باستخدام المؤشرات ل(الأمراض المنقولة جنسيا :: ناقلات :: size\_type i = 0؛ i! = myVector.size ()؛ ط ++) { std :: cout << "العنصر هو" << myVector \[i\] << std :: endl؛ // Dereference the iterator to access data }
+
+ `### Sorting A Vector In Ascending Order 
+ Sorting a vector based on ascending order can be done with the help of Sort() in C++. 
+` 
+
+حزب الشعب الكمبودي
+
+# تتضمن
+
+# تتضمن
+
+# تتضمن
+
+استخدام اسم للمحطة؛
+
+انت مين(){
+
+قوه موجهة v {10، 5، 82، 69، 64، 70، 3، 42، 28، 0}؛ sort (v.begin ()، v.end ())؛
+
+cout << "Vector Contents Sorted In Ascending Order: \\ n"؛ for (int e: v) { cout << e << ""؛ }
+
+العودة 0 }
+
+ `### Sorting Vector In Descending Order 
+ Sorting Vector in descending order can be done with the help of third argument namely greater<int>() in Sort() in C++. 
+` 
+
+حزب الشعب الكمبودي
+
+# تتضمن
+
+# تتضمن
+
+# تتضمن
+
+استخدام اسم للمحطة؛
+
+انت مين(){
+
+قوه موجهة v {10، 5، 82، 69، 64، 70، 3، 42، 28، 0}؛ نوع (v.begin () ، v.end () ، أكبر ())؛
+
+cout << "Vector Contents Sorted In Ascending Order: \\ n"؛ for (int e: v) { cout << e << ""؛ }
+
+العودة 0 } \`\` \`

guide/arabic/cplusplus/while-loop/index.md

@@ -0,0 +1,36 @@
+---
+title:While-loop
+localeTitle: undefined
+---
+تقوم عبارة loop while بتنفيذ العبارة المستهدفة بشكل متكرر طالما أن الشرط المعطى صحيح.
+
+بناء الجملة: بينما (الشرط) { صياغات)؛ }
+
+النقطة الأساسية في حلقة while هي أن الحلقة قد لا تعمل أبدًا. عندما يتم اختبار الشرط وتكون النتيجة خاطئة ، سيتم تخطي جسم الحلقة وسيتم تنفيذ العبارة الأولى بعد حلقة while.
+
+مثال:
+
+ `#include <iostream> 
+ using namespace std; 
+ 
+ int main () { 
+   // Local variable declaration: 
+   int a = 10; 
+ 
+   // while loop execution 
+   while( a < 20 ) { 
+      cout << "value of a: " << a << endl; 
+      a++; 
+   } 
+ 
+   return 0; 
+ } 
+` 
+
+انتاج:
+
+قيمة أ: 10 قيمة أ: 11 قيمة أ: 12 قيمة أ: 13 قيمة a: 14 قيمة أ: 15 قيمة أ: 16 قيمة أ: 17 قيمة أ: 18 قيمة من: 19
+
+### مصادر
+
+www.tutorialspoint.com