C++ arabic course

‫اﻟﻤﺆﻟﻒ‬:‫اﻟﺴﺒﻴﻌﻲ‬ ‫ﻣﺸﺎري‬ ‫ﻣﺠﻼد‬
‫اﻹﻟﻜﺘﺮوﻧﻲ‬ ‫اﻟﺒﺮﻳﺪ‬:com.magedxl@hotmail
‫ﻫﻨﺎ‬ ‫ﻛﺎن‬ ‫إذا‬ ‫ﻣﺮاﺳﻠﺘﻲ‬ ‫ﻳﻤﻜﻨﻜﻢ‬‫اﻟﻜﺘﺎب‬ ‫ﻫﺬا‬ ‫ﻓﻲ‬ ‫ﻳﻮﺟﺪ‬ ‫ﻣﻤﺎ‬ ‫ﻧﺤﻮه‬ ‫أو‬ ‫اﻟﺘﻮﺿﻴﺢ‬ ‫ﺑﻌﺪم‬ ‫ﻣﺘﻌﻠﻘﺔ‬ ‫ﻣﺸﺎﻛﻞ‬ ‫آي‬ ‫ك‬...

‫اﻟﻤﺆﻟﻒ‬ ‫ﻣﻦ‬ ‫ﺧﻄﻲ‬ ‫أذن‬ ‫ﺑﺪون‬ ‫اﻟﻜﺘﺎب‬ ‫ﻫﺬا‬ ‫ﻣﻦ‬ ‫ﺟﺰء‬ ‫أي‬ ‫اﻗﺘﺒﺎس‬ ‫أو‬ ‫ﻃﺒﺎﻋﺔ‬ ‫ﺑﺎﺗﺎ‬ ‫ﻣﻨﻌﺎ‬ ‫ﻣﻤﻨﻮع‬
PDF created with pdfFactory Pro trial version www.pdffactory.com

‫ﻣﺤﻔﻮﻇﺔ‬ ‫اﻟﻄﺒﻊ‬ ‫ﺣﻘﻮق‬©
*‫ﺜﻞ‬‫ﻣ‬ ‫ﺘﺎب‬‫اﻟﻜ‬ ‫ﺬا‬‫ﻫ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻮرة‬‫اﻟﻤﺬﻛ‬ ‫ﺒﺮاﻣﺞ‬‫اﻟ‬"Windows" "visual c++"‫ﻋﻼﻣﺎت‬ ‫أو‬ ‫ﺗﺠﺎرﻳﺔ‬ ‫ﺎت‬‫ﻋﻼﻣ‬ ‫ﻴﺮﻫﺎ‬‫وﻏ‬
‫ﺤﺎﺑﻬﺎ‬‫ﻻﺻ‬ ‫ﺠﻠﺔ‬‫ﻣﺴ‬،‫ﺤﺎﺑﻬﺎ‬‫ﻻﺻ‬ ‫ﺎ‬‫ﺑﻬ‬ ‫ﺮ‬‫وﻳﻘ‬ ‫ﺎت‬‫اﻟﻌﻼﻣ‬ ‫ﺬه‬‫ﻫ‬ ‫ﺘﺮم‬‫ﻳﺤ‬ ‫ﻒ‬‫واﻟﻤﺆﻟ‬،‫ﺒﺎ‬‫ﻃﻠ‬ ‫ﺘﺎب‬‫اﻟﻜ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺮﻳﺤﺎ‬‫ﺗﺼ‬ ‫ﺮﻫﺎ‬‫ﻳﺬﻛ‬ ‫ﻢ‬‫وﻟ‬
‫ﻟﻼﺧﺘﺼﺎر‬.
*‫ﻲ‬ ‫اﻟﺘ‬ ‫ﺎت‬ ‫اﻟﻤﻌﻠﻮﻣ‬ ‫ﺘﺨﺪام‬ ‫اﺳ‬ ‫ﻦ‬ ‫ﻋ‬ ‫ﺐ‬ ‫ﺗﺘﺮﺗ‬ ‫ﺘﺎﺋﺞ‬ ‫ﻧ‬ ‫أي‬ ‫ﻦ‬ ‫ﻋ‬ ‫ﻤﻨﻴﺎ‬ ‫ﺿ‬ ‫أو‬ ‫ﺮﻳﺤﺎ‬ ‫ﺻ‬ ‫ﻜﻞ‬ ‫ﺷ‬ ‫ﺄي‬ ‫ﺑ‬ ‫ﺆوﻻ‬ ‫ﻣﺴ‬ ‫ﺪ‬ ‫ﻳﻌ‬ ‫ﻻ‬ ‫ﻒ‬ ‫اﻟﻤﺆﻟ‬
‫ﻳﺤﺘﻮﻳﻬ‬‫ﻋﻠﻴﻬﺎ‬ ‫اﻟﻘﺎرئ‬ ‫ﻳﺠﺮﻳﻬﺎ‬ ‫ﺗﻌﺪﻳﻼت‬ ‫آي‬ ‫أو‬ ‫اﻟﻜﺘﺎب‬ ‫ﺎ‬.
*‫ﺷﺨﺼﻴﺎ‬ ‫اﻟﻤﺆﻟﻒ‬ ‫رأي‬ ‫ﻋﻦ‬ ‫ﺗﻌﺒﺮ‬ ‫اﻟﻜﺘﺐ‬ ‫ﻫﺬا‬ ‫ﻓﻲ‬ ‫ﻛﺘﺐ‬ ‫وﻣﺎ‬ ‫اﻵراء‬ ‫ﺟﻤﻴﻊ‬.
*‫ﻣﺠﺎﻧﻲ‬ ‫اﻟﻜﺘﺎب‬100%‫ﺗﺠﺎرﻳﺎ‬ ‫اﺳﺘﻐﻼﻟﻪ‬ ‫أو‬ ‫ﺑﻴﻌﻪ‬ ‫ﻻﺣﺪ‬ ‫ﻳﺤﻖ‬ ‫وﻻ‬.

‫ﺒﺔ‬‫اﻟﺤﺒﻴ‬ ‫ﺮاق‬‫اﻟﻌ‬ ‫ارض‬ ‫ﻰ‬‫إﻟ‬ ‫ﺪاء‬‫إﻫ‬ ‫ﺘﺎب‬‫اﻟﻜ‬ ‫ﺬا‬‫ﻫ‬..‫ﻧﻌ‬‫ودﺟﻠﺔ‬ ‫اﻟﻔﺮات‬ ‫ارض‬ ‫ﺮاق‬‫اﻟﻌ‬ ‫ﻌﻨﺎ‬‫أﺿ‬ ‫ﺪ‬‫ﻟﻘ‬ ‫ﺮاق‬‫اﻟﻌ‬ ‫ﻢ‬،‫اﻹﺳﻼم‬ ‫ﻓﺨﺮ‬
‫ﺑــﻐــﺪاد‬ ‫واﻟﻤﺴﻠﻤﻴﻦ‬...
‫أﺿﻌﻨﺎﻫﺎ‬..‫أﺿﻌﻨﺎﻫﺎ‬..
‫اﻹﺳﻼﻣﻴﺔ‬ ‫ﻟﻠﺨﻼﻓﻪ‬ ‫أرﺿﺎ‬ ‫وﺳﺘﻌﻮدﻳﻦ‬ ‫ﺑﺒﻌﻴﺪ‬ ‫ﻟﺴﺖ‬ ‫ﻟﻜﻨﻚ‬..
‫ﻗﺮﻳﺒﺎ‬..‫ﻗﺮﻳﺒﺎ‬


‫أﻋﺰاﺋﻲ‬..
‫وﺑﺤﻤﺪ‬ ‫ﺗﻢ‬‫اﻟﻜﺘﺎب‬ ‫ﻫﺬا‬ ‫ﻣﻦ‬ ‫اﻻﻧﺘﻬﺎء‬ ‫اﷲ‬..‫اﻟﺴﻮاء‬ ‫ﺣﺪ‬ ‫ﻋﻠﻰ‬ ‫واﻟﻤﺤﺘﺮﻓﻴﻦ‬ ‫اﻟﻤﺒﺘﺪﺋﻴﻦ‬ ‫اﷲ‬ ‫ﺑﺈذن‬ ‫ﻟﻠﺠﻤﻴﻊ‬ ‫اﻟﻤﻔﻴﺪ‬..
‫ﻟﻐﺔ‬ ‫ﻋﻦ‬ ‫ﺗﺘﺤﺪث‬ ‫اﻟﺘﻲ‬ ‫اﻟﻜﺘﺐ‬ ‫ﻗﻠﺖ‬ ‫ﻻﺣﻈﺖ‬ ‫أن‬ ‫ﺑﻌﺪ‬ ‫اﻟﻜﺘﺎب‬ ‫ﻫﺬا‬ ‫ﺑﺈﻧﺸﺎء‬ ‫ﻗﻤﺖ‬ ‫وﻗﺪ‬Visual C++..
‫اﻟﺤﺎﺳﺐ‬ ‫ﻟﺘﻄﺒﻴﻘﺎت‬ ‫اﻟﻤﻌﺮوﻓﺔ‬ ‫اوﻓﻴﺲ‬ ‫ﺣﺰﻣﺔ‬ ‫ﺑﻨﺎء‬ ‫ﻣﻨﻬﺎ‬ ‫ﺗﻢ‬ ‫اﻟﺘﻲ‬ ‫اﻟﻠﻐﺔ‬ ‫وﻫﻲ‬..
‫ﻳﺤﻮز‬ ‫أن‬ ‫أرﺟﻮ‬ ‫ﻟﺬﻟﻚ‬‫اﻷﺳﺎﺳﻴﺎت‬ ‫ﺷﺮح‬ ‫ﻣﻊ‬ ‫اﻟﺘﻄﺒﻴﻘﻴﺔ‬ ‫اﻷﻣﺜﻠﺔ‬ ‫ﻣﻦ‬ ‫اﻟﻌﺪﻳﺪ‬ ‫ﻋﻠﻰ‬ ‫ﻳﺤﺘﻮى‬ ‫وﻫﻮ‬ ‫رﺿﺎﻛﻢ‬ ‫ﻋﻠﻰ‬ ‫اﻟﻜﺘﺎب‬ ‫ﻫﺬا‬
‫ﻣﺒﺮﻣﺠﻲ‬ ‫ﻳﺤﺘﺎﺟﻬﺎ‬ ‫اﻟﺘﻲ‬ ‫اﻷﺟﻮﺑﺔ‬ ‫ﻣﻦ‬ ‫واﻟﻌﺪﻳﺪ‬C++.
‫اﻟﺘﻮﻓﻴﻖ‬ ‫وﺑﺎﷲ‬..

‫اﻟﻜﺘﺎب‬ ‫ﻋﻨﻮان‬............................................................................‫أ‬
‫اﻫﺪأ‬.......................................................................................‫ب‬
‫ﻣﻘﺪﻣﺔ‬....................................................................................‫د‬
‫اﻷول‬ ‫اﻟﺒﺎب‬
‫اﻷ‬‫ﺳﺎﺳﻴﺎت‬‫ﻣﻜﻮﻧﺎت‬++c‫وادواﺗﻬﺎ‬
‫ﻟﻐﺔ‬ ‫رﻣﻮز‬c++.........................................................................٧
‫اﻟﻤﺘﻐﻴﺮات‬................................................................................١٣
‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫اﻟﻤﺴﺘﻌﻤﻠﺔ‬ ‫اﻷدوات‬c++....................................................١٥
‫اﻟﺤﺴﺎﺑﻴﺔ‬ ‫اﻷدوات‬......................................................................١٥
‫واﻟﺜﻨﺎﺋﻴﺔ‬ ‫اﻷﺣﺎدﻳﺔ‬ ‫اﻷدوات‬............................................................١٧
‫واﻟﻨﻘﺼﺎن‬ ‫اﻟﺰﻳﺎدة‬.......................................................................١٧
‫اﻟﺤﺴﺎﺑﻴﺔ‬ ‫ﻟﻸدوات‬ ‫اﻟﻌﻤﻠﻴﺎت‬ ‫أوﻟﻴﺎت‬..................................................١٩
‫واﻟﻤﻨﻘﻄﻴﺔ‬ ‫اﻟﻌﻼﻗﻴﺔ‬ ‫اﻷدوات‬..........................................................٢٠
‫اﻟﺪﻗﻴﻘﺔ‬ ‫اﻷدوات‬.........................................................................٢٢
‫اﻟﻨﻔﻲ‬ ‫أداة‬.................................................................................٢٣
‫اﻟﺠﻤﻊ‬ ‫أداة‬...............................................................................٢٤
‫اﻻﺧﺘﻴﺎر‬ ‫أداة‬............................................................................٢٤
‫اﻻﺳﺘﺜﻨﺎﺋﻲ‬ ‫اﻻﺧﺘﻴﺎر‬ ‫أداة‬...............................................................٢٥
‫اﻹزاﺣﺔ‬ ‫أداة‬.............................................................................٢٦
‫اﻟﺸﺮﻃﻴﺔ‬ ‫اﻷداة‬.........................................................................٢٨
‫اﻟﻌﻨﻮان‬ ‫أداة‬..............................................................................٢٩
‫اﻟﻄﻮل‬ ‫ﺗﻌﻴﻴﻦ‬ ‫أداة‬.......................................................................٣٠
‫ﻛﺄداة‬ ‫اﻟﻔﺎﺻﻠﺔ‬...........................................................................٣١
‫اﻟﺘﻌﺮﻳﻒ‬ ‫ﺟﻤﻞ‬..........................................................................٣٢
‫اﻟﻤﻌﻜﻮﺳﺔ‬ ‫اﻟﺸﺮط‬ ‫ذات‬ ‫اﻟﺮﻣﺰﻳﺔ‬ ‫اﻟﺜﻮاﺑﺖ‬...........................................٣٣
‫ﻓﻲ‬ ‫واﻟﺘﻌﻠﻴﻘﺎت‬ ‫اﻟﻤﻼﺣﻈﺎت‬c++...................................................٣٤
‫اﻟﺜﺎﻧﻲ‬ ‫اﻟﺒﺎب‬
‫ﺗﺸﻐﻴﻞ‬++6.0CVisual
‫ﺑﺮﻧﺎﻣﺞ‬ ‫ﺗﺸﻐﻴﻞ‬ ‫ﺧﻄﻮات‬Visual C++..........................................٣٥
‫اﻟﺜﺎﻟﺚ‬ ‫اﻟﺒﺎب‬
‫أﺳﺎﻟﻴﺐ‬‫اﻹدﺧﺎل‬‫واﻹﺧﺮاج‬
‫ﻣ‬‫ﻘﺪﻣﺔ‬..................................................................................٤٠


‫واﻹﺧﺮاج‬ ‫اﻹدﺧﺎل‬...................................................................٤١
‫اﻟﻨﺼﻮص‬ ‫ﻃﺒﺎﻋﺔ‬)‫اﻟﺮﻣﺰﻳﺔ‬ ‫اﻟﺜﻮاﺑﺖ‬...........................................(٤٢
‫ﻃﺒﺎ‬‫اﻟﻌﺪدﻳﺔ‬ ‫اﻟﻘﻴﻢ‬ ‫ﻋﺔ‬.................................................................٤٤
‫واﺣﺪه‬ ‫ﺟﻤﻠﺔ‬ ‫ﻓﻲ‬ ‫اﻟﻌﺪدﻳﺔ‬ ‫واﻟﻘﻴﻢ‬ ‫اﻟﻨﺼﻮص‬ ‫ﻃﺒﺎﻋﺔ‬................................٤٧
‫ﺑﻠﻐﺔ‬ ‫اﻹدﺧﺎل‬c++..................................................................٤٩
‫اﻟ‬ ‫اﻟﺒﺎب‬‫ﺮاﺑﻊ‬
‫ﺟﻤﻞ‬‫اﻟﺘﺤﻜﻢ‬‫واﻟﺸﺮط‬‫واﻟﺘﻜﺮار‬
‫ﻣﻘﺪﻣﺔ‬..................................................................................٥٣
‫اﻟﺸﺮﻃﻴﺔ‬ ‫اﻟﺠﻤﻞ‬.......................................................................٥٣
‫وأﺧﻮاﺗﻬﺎ‬ ‫إذا‬ ‫اﻟﺸﺮط‬ ‫ﺟﻤﻠﺔ‬if statements......................................٥٤
‫اﻟﺘﻮزﻳﻊ‬ ‫ﺟﻤﻠﺔ‬switch statement.............................................٥٩
‫اﻟﺸﺮط‬ ‫أداة‬ ‫ﺟﻤﻠﺔ‬‫؟‬...................................................................٦٠
‫اﻟﺘﻜﺮار‬ ‫وﺣﻠﻘﺎت‬ ‫اﻟﺘﻜﺮار‬............................................................٦١
‫ﺣﻠﻘﺔ‬ ‫ﺑﺎﺳﺘﻌﻤﺎل‬ ‫اﻟﺘﻜﺮار‬ ‫أﺳﻠﻮب‬For.............................................٦١
‫اﻟﻤﺘﺪاﺧﻠﺔ‬ ‫اﻟﺘﻜﺮار‬ ‫ﺣﻠﻘﺎت‬for Loops..........................................٦٦
‫ﺣﻠﻘﺔ‬ ‫ﺑﺎﺳﺘﻌﻤﺎل‬ ‫اﻟﺘﻜﺮار‬ ‫أﺳﻠﻮب‬While & Do................................٦٩
‫ﺣﻠﻘﺎت‬While‫اﻟﻤﺘﺪاﺧﻠﺔ‬...........................................................٧٢
‫اﻹﻳﻘﺎف‬ ‫ﺟﻤﻠﺔ‬Break...............................................................٧٣
‫اﻻﺳﺘﻤﺮار‬ ‫ﺟﻤﻠﺔ‬continue......................................................٧٥
‫ا‬ ‫ﺟﻤﻠﺔ‬‫ﻟﺨﺮوج‬exit()..............................................................٧٧
‫اﻻﻧﺘﻘﺎل‬ ‫ﺟﻤﻠﺔ‬goto................................................................٧٨
‫اﻟﺨﺎﻣﺲ‬ ‫اﻟﺒﺎب‬
‫اﻟﻤﺘﻐﻴﺮات‬‫اﻟﻤﺮﻗﻤﺔ‬‫واﻟﻤﺼﻔﻮﻓﺎت‬
‫ﻣﻘﺪﻣﺔ‬..................................................................................٧٩
‫اﻟﻮاﺣﺪ‬ ‫اﻟﺒﻌﺪ‬ ‫ذات‬ ‫ﻟﻠﻤﺼﻔﻮﻓﺔ‬ ‫أوﻟﻴﺔ‬ ‫ﻗﻴﻤﺔ‬ ‫إﻋﻄﺎء‬..................................٨٣
‫اﻟﺬاﻛﺮة‬ ‫ﻓﻲ‬ ‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫ﻋﻨﺎﺻﺮ‬ ‫ﻋﻨﻮان‬............................................٨٥
‫اﻟﺒﻌﺪﻳﻦ‬ ‫ذات‬ ‫اﻟﻤﺼﻔﻮﻓﺔ‬.............................................................٨٦
‫اﻟﺴﺎدس‬ ‫اﻟﺒﺎب‬
‫اﻟﺪوال‬
‫ﻣﻘﺪﻣﺔ‬.................................................................................٨٨
‫اﻟﺪوال‬ ‫ﻋﻠﻰ‬ ‫ﺗﻄﺒﻴﻘﺎت‬...............................................................٩٠
‫اﻟﺴﺎﺑﻊ‬ ‫اﻟﺒﺎب‬
‫ﺗﻘﻨﻴﺔ‬‫اﻷﻗﺮاص‬‫و‬‫دوال‬‫ا‬‫ﻟﻤﻠﻔﺎت‬‫اﻻﻧﺘﻘﺎﻟﻴﺔ‬
‫ﻣﻘﺪﻣﺔ‬................................................................................٩٤
‫اﻟﻤﻠﻒ‬ ‫ﻓﺘﺢ‬ ‫داﻟﺔ‬()fopen.......................................................٩٥
‫اﻟﻤﻠﻒ‬ ‫داﺧﻞ‬ ‫اﻟﻜﺘﺎﺑﺔ‬ ‫داﻟﺔ‬fprintf()............................................٩٧
‫اﻟﻤﻠﻒ‬ ‫إﻏﻼق‬ ‫داﻟﺔ‬fclose()....................................................٩٨
‫اﻟﺪاﻟﺘﺎن‬putw() getw().......................................................٩٩
‫اﻟﻨﻬﺎﻳﺔ‬...............................................................................١٠١

‫ﻟﻐﺔ‬ ‫رﻣﻮز‬++C
*‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫اﻟﻤﺴﺘﺨﺪﻣﺔ‬ ‫اﻟﺮﻣﻮز‬C++
١-‫اﻟﻜﺒﻴﺮة‬ ‫اﻹﻧﺠﻠﻴﺰﻳﺔ‬ ‫اﻟﺤﺮوف‬A.B.C
٢-‫اﻟﺼﻐﻴﺮة‬ ‫اﻹﻧﺠﻠﻴﺰﻳﺔ‬ ‫اﻟﺤﺮوف‬a.b.c
٣-‫اﻷﺻﻞ‬ ‫اﻟﻌﺮﺑﻴﺔ‬ ‫اﻷرﻗﺎم‬1.2.3
٤-‫ﻣﺜﻞ‬ ‫ﺧﺎﺻﺔ‬ ‫رﻣﻮز‬:
[] " ! < - +
* ، || > ( ) _
>> <> =< => /
!= & % $ # <<
‫اﻟﺠﺪول‬١-١
‫ﺑ‬ ‫ﺮﻣﻮز‬ ‫اﻟ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﺪ‬ ‫وﺗﻌ‬‫ﺔ‬ ‫ﻟﻐ‬ ‫ﺮدات‬ ‫ﻣﻔ‬ ‫ﻨﻬﺎ‬ ‫ﻣ‬ ‫ﺘﻜﻮن‬ ‫ﺗ‬ ‫ﻲ‬ ‫اﻟﺘ‬ ‫ﺎم‬ ‫اﻟﺨ‬ ‫ﺎدة‬ ‫اﻟﻤ‬ ‫ﺎ‬ ‫ﺄﻧﻮاﻋﻬ‬C++،‫وإذا‬
‫ﺔ‬ ‫ﻟﻐ‬ ‫ﺒﻞ‬ ‫ﻗ‬ ‫ﺮى‬ ‫أﺧ‬ ‫ﺔ‬ ‫ﻟﻐ‬ ‫ﺖ‬ ‫درﺳ‬C++،‫ﺔ‬ ‫ﻟﻐ‬ ‫أن‬ ‫ﻆ‬ ‫ﺗﻼﺣ‬ ‫ﺎﻧﻚ‬ ‫ﻓ‬C++،‫ﻮزا‬ ‫رﻣ‬ ‫ﺘﻌﻤﻞ‬ ‫ﺗﺴ‬
‫ﺗﻮﺟ‬ ‫ﻻ‬ ‫اﻟﺤﺎﺳﺐ‬ ‫ﻣﻔﺎﺗﻴﺢ‬ ‫ﻟﻮﺣﺔ‬ ‫ﻓﻲ‬ ‫إﺿﺎﻓﻴﺔ‬‫ﺪ‬‫اﻟﻠﻐﺎت‬ ‫ﺑﻌﺾ‬ ‫ﻓﻲ‬.
*‫ﻟﻐﺔ‬ ‫ﻛﻠﻤﺎت‬C++
‫ﻧﻮﻋﻴﻦ‬ ‫اﻟﻜﻠﻤﺎت‬:-
١-‫ﺗﻌﺮﻳﻔﻴﺔ‬ ‫أﺳﻤﺎء‬(Identifiers)
‫ﻧﺴ‬ ‫اﻟﺘﻲ‬ ‫اﻷﺳﻤﺎء‬ ‫وﻫﻲ‬‫ﻧﺤﻦ‬ ‫ﻤﻴﻬﺎ‬"‫اﻟﻤﺒﺮﻣﺠﻮن‬"‫ﺗﺮﻳﺪ‬ ‫ﺑﻤﺎ‬ ‫اﻟﺤﺎﺳﻮب‬ ‫ﺗﻌﺮف‬.
‫ﻋﻠﻰ‬ ‫اﻟﺘﻌﺮﻳﻔﻴﺔ‬ ‫اﻷﺳﻤﺎء‬ ‫وﺗﻄﻠﻖ‬:-
-A‫اﻟﻤﺘﻐﻴﺮات‬.
-B‫اﻻﺧﺘﺰاﻧﺎت‬)‫اﻟﺪوال‬.(
-C‫اﻟﻤﺆﺷﺮات‬.
‫اﻷﺳﺎﺳﻴﺎت‬
‫ﻣﻜﻮﻧﺎت‬C++‫وادواﺗﻬﺎ‬
Basic Elements of C++

*‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫اﻟﺘﻌﺮﻳﻔﻴﺔ‬ ‫اﻷﺳﻤﺎء‬ ‫ﺗﺴﻤﻴﺔ‬ ‫ﻗﻮاﻋﺪ‬C++:-
١-‫أن‬ ‫ﺮط‬ ‫ﺑﺸ‬ ‫ﺎم‬‫اﻷرﻗ‬ ‫أو‬ ‫ﺮوف‬‫اﻟﺤ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻠﺔ‬‫ﻣﺘﺼ‬ ‫ﻠﺔ‬‫ﺳﻠﺴ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺘﻮﺑﺎ‬‫ﻣﻜ‬ ‫ﻢ‬‫اﻻﺳ‬ ‫ﻮن‬‫ﻳﻜ‬ ‫أن‬
‫أو‬ ‫ﺑﺤﺮف‬ ‫ﻳﺒﺪا‬‫ﺗﺤﺘﻲ‬ ‫ﺑﺨﻂ‬"_"
٢-‫اﻟﺘﺤﺘﻲ‬ ‫اﻟﺨﻂ‬ ‫ﻋﺪا‬ ‫ﺧﺎﺻﺔ‬ ‫رﻣﻮز‬ ‫ﻋﻠﻰ‬ ‫اﻻﺳﻢ‬ ‫ﻳﺤﺘﻮى‬ ‫ﻻ‬ ‫أن‬"_"
٢-‫اﻟﻤﺤﺠﻮزة‬ ‫اﻟﻜﻠﻤﺎت‬ ‫إﺣﺪى‬ ‫اﻻﺳﻢ‬ ‫ﻳﻜﻮن‬ ‫ﻻ‬ ‫أن‬.
‫اﻟﺘﻌﺮﻳﻔﻴﺔ‬ ‫اﻷﺳﻤﺎء‬ ‫ﻋﻠﻰ‬ ‫اﻟﺼﺤﻴﺤﺔ‬ ‫اﻷﻣﺜﻠﺔ‬ ‫ﺑﻌﺾ‬:
a.B6
b.X_ray
c.Matrix
d.Ok_
e.A
f.Soft_fine
g.Door12
h._new
‫ﻣﻘﺒﻮل‬ ‫ﻏﻴﺮ‬ ‫ﺗﻌﺮﻳﻔﻴﺔ‬ ‫أﺳﻤﺎء‬ ‫وﻫﺬه‬(invalid)‫إزاء‬ ‫اﻟﻤﺒﻴﻨﺔ‬ ‫ﻟﻸﺳﺒﺎب‬‫ﻣﻨﻬﺎ‬ ‫ﻛﻞ‬:
7-upÙ‫ﺑﺤﺮف‬ ‫وﻟﻴﺲ‬ ‫ﺑﺮﻗﻢ‬ ‫ﺑﺪا‬ ‫ﻻﻧﻪ‬.
b6.1Ù‫اﻟﺨﺎص‬ ‫اﻟﺮﻣﺰ‬ ‫ﻻﺳﺘﻌﻤﺎﻟﻪ‬(.)
salim!Ù‫اﻟﺨﺎص‬ ‫اﻟﺮﻣﺰ‬ ‫ﻻﺳﺘﻌﻤﺎﻟﻪ‬(!)
Ђ2Ù‫ﻳﺠﻮ‬ ‫ﻻ‬‫ز‬‫إﻧﺠﻠﻴﺰﻳﺔ‬ ‫ﻏﻴﺮ‬ ‫ﺣﺮوف‬ ‫اﺳﺘﻌﻤﺎل‬.
No#1Ù‫اﻟﺨﺎص‬ ‫اﻟﺮﻣﺰ‬ ‫ﻻﺳﺘﻌﻤﺎﻟﻪ‬)#(
‫ﺮ‬‫ﺑﺎﻟﺬﻛ‬ ‫ﺮ‬‫اﻟﺠﺪﻳ‬ ‫ﻦ‬‫وﻣ‬،‫ﺔ‬‫ﻟﻐ‬ ‫أن‬C++‫اﻟﺼﻐ‬ ‫اﻷﺑﺠﺪﻳﺔ‬ ‫ﺮوف‬‫اﻟﺤ‬ ‫ﻦ‬‫ﺑﻴ‬ ‫ﺮق‬‫ﺗﻔ‬‫واﻟﻜﺒﻴﺮة‬ ‫ﻴﺮة‬،
‫ﻤﺎء‬ ‫اﻷﺳ‬ ‫ﺜﻼ‬ ‫ﻓﻤ‬:SYSTEM , system, System‫ﻦ‬ ‫ﻋ‬ ‫ﺘﻠﻔﺔ‬ ‫ﻣﺨ‬ ‫ﻤﺎء‬ ‫ﻛﺄﺳ‬ ‫ﺎﻣﻞ‬ ‫ﺗﻌ‬
‫واﻟﻜﺒﻴﺮة‬ ‫اﻟﺼﻐﻴﺮة‬ ‫ﻟﻠﺤﺮوف‬ ‫اﻟﻤﺘﺮﺟﻢ‬ ‫ﻣﻌﺎﻣﻠﺔ‬ ‫اﺧﺘﻼف‬ ‫ﺑﺴﺒﺐ‬ ‫اﻟﺒﻌﺾ‬ ‫ﺑﻌﻀﻬﺎ‬.

٢-‫اﻟﻤﺤﺠﻮزة‬ ‫اﻟﻜﻠﻤﺎت‬
‫ﺘﺮﺟﻢ‬‫ﻟﻤ‬ ‫ﺒﻘﺎ‬‫ﻣﺴ‬ ‫ﺮوﻓﺔ‬‫ﻣﻌ‬ ‫ﻴﺔ‬‫ﻗﻴﺎﺳ‬ ‫ﺎت‬‫ﻛﻠﻤ‬ ‫ﻲ‬‫وﻫ‬C++،‫ﺻﻐﻴﺮة‬ ‫ﺮوف‬‫ﺑﺤ‬ ‫ﺎدة‬‫ﻋ‬ ‫ﺐ‬‫وﺗﻜﺘ‬،
‫ﺎ‬ ‫ﺑﻬ‬ ‫ﺔ‬ ‫ﺧﺎﺻ‬ ‫ﺎن‬ ‫ﻣﻌ‬ ‫ﺎ‬ ‫وﻟﻬ‬‫ﺮﻧﺎﻣﺞ‬ ‫ﺑ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺎ‬ ‫ﺗﺆدﻳﻬ‬C++،‫ﺐ‬ ‫ﺣﺴ‬ ‫ﻮزة‬ ‫اﻟﻤﺤﺠ‬ ‫ﺎت‬ ‫اﻟﻜﻠﻤ‬ ‫ﺬه‬ ‫وﻫ‬
‫ﻫﻲ‬ ‫اﻷﺑﺠﺪي‬ ‫اﻟﺘﺮﺗﻴﺐ‬:
near Static asm Double long Sizeof
do int While new auto else
For This Void Delete Goto if
const Entry char Class Public Case
Continue Extern struct inline float Private
Virtual Volatile Frinde enum near Static
cdecl Default inline Overload Unsigned Typedef
Signed Pascal Operator Switch Template Union
Register Protected far Catch char Const
break Return
‫اﻟﺠﺪول‬٢-١
‫ﻮزة‬‫اﻟﻤﺤﺠ‬ ‫ﺎت‬‫اﻟﻜﻠﻤ‬ ‫ﺬه‬‫ﻫ‬ ‫أن‬ ‫ﻰ‬‫إﻟ‬ ‫ﻴﻪ‬‫اﻟﺘﻨﺒ‬ ‫ﺒﻐﻰ‬‫وﻳﻨ‬،‫ﺗ‬ ‫ﺎدة‬‫إﻋ‬ ‫ﻮز‬‫ﻳﺠ‬ ‫ﻻ‬‫ﺘﻌﻤﺎﻟﻬﺎ‬‫اﺳ‬ ‫أو‬ ‫ﺮﻳﻔﻬﺎ‬‫ﻌ‬
‫ﻟﻪ‬ ‫ﺧﺼﺼﺖ‬ ‫ﻣﺎ‬ ‫ﻟﻐﻴﺮ‬.
‫ﻮزة‬‫اﻟﻤﺤﺠ‬ ‫ﺎت‬‫اﻟﻜﻠﻤ‬ ‫ﺔ‬‫ﻗﺎﺋﻤ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻆ‬‫ﺗﻼﺣ‬ ‫ﺎ‬‫وﻛﻤ‬،‫ﺔ‬‫ﻟﻐ‬ ‫أن‬C++‫ﺘﻜﻮن‬‫ﺗ‬ ‫إذ‬ ‫ﻐﻴﺮة‬‫ﺻ‬ ‫ﺔ‬‫ﻟﻐ‬ ‫ﺪ‬‫ﺗﻌ‬
‫ﺗﻘﺮﻳﺒﺎ‬ ‫اﻟﻤﺤﺠﻮزة‬ ‫اﻟﻜﻠﻤﺎت‬ ‫ﻣﻦ‬ ‫ﻗﻠﻴﻞ‬ ‫ﻋﺪد‬ ‫ﻣﻦ‬٥٢‫ﻓﻘﻂ‬ ‫ﻣﺤﺠﻮزة‬ ‫ﻛﻠﻤﺔ‬.

•‫اﻟﻌﺪدﻳﺔ‬ ‫اﻟﺜﻮاﺑﺖ‬ ‫ﺗﻤﺜﻴﻞ‬Numeric Constants
‫اﻟﻌﺪدﻳﺔ‬ ‫اﻟﺜﻮاﺑﺖ‬ ‫ﺗﻤﺜﻴﻞ‬ ‫ﻳﻤﻜﻦ‬،‫ﻟﻐﺔ‬ ‫ﻓﻲ‬C++‫ﻫﻲ‬ ‫ﺻﻮر‬ ‫ﺑﺜﻼث‬:-
a.‫اﻟﺼﺤﻴﺢ‬ ‫اﻟﻌﺪدي‬ ‫اﻟﺜﺎﺑﺖ‬integer
-‫ﻣﻦ‬ ‫اﻷرﻗﺎم‬ ‫ﻣﻦ‬ ‫ﻣﻜﻮن‬ ‫ﻋﺪد‬ ‫ﻫﻮ‬0Ù9
-‫ﻋﺸﺮﻳﺔ‬ ‫ﻓﺎﺻﻠﺔ‬ ‫ﻋﻠﻰ‬ ‫ﻳﺤﺘﻮى‬ ‫ﻻ‬.
-‫اﻹﺷﺎرة‬ ‫ﻳﺤﻮى‬ ‫أن‬ ‫ﻳﻤﻜﻦ‬"+"‫أو‬"-"
‫اﻟﺼﺤﻴﺢ‬ ‫اﻟﻌﺪدي‬ ‫اﻟﺜﺎﺑﺖ‬ ‫ﻋﻠﻰ‬ ‫ﺻﺤﻴﺤﺔ‬ ‫أﻣﺜﻠﺔ‬:-
0
15
1000
321
-61
‫ﺻﺤﻴﺤﺔ‬ ‫ﻏﻴﺮ‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫واﻷﻋﺪاد‬‫ﻟﻸﺳﺒﺎب‬‫إزاء‬ ‫اﻟﻤﺒﻴﻨﺔ‬‫ﻣﻨﻬﺎ‬ ‫ﻛﻞ‬:
3.31:‫ﻋﺸﺮﻳﺔ‬ ‫ﻓﺎﺻﻠﺔ‬ ‫ﻋﻠﻰ‬ ‫ﻳﺤﺘﻮى‬ ‫ﻻﻧﻪ‬.
1,000:‫ﻓﺎرزة‬ ‫ﻋﻠﻰ‬ ‫ﻳﺤﺘﻮى‬ ‫ﻻﻧﻪ‬.
J72:‫أﺑﺠﺪي‬ ‫ﺣﺮف‬ ‫ﻋﻠﻰ‬ ‫ﻳﺤﺘﻮى‬ ‫ﻻﻧﻪ‬.
2 4:‫اﻟﻌﺪﻳﺪﻳﻦ‬ ‫ﺑﻴﻦ‬ ‫ﻓﺮاغ‬ ‫ﻟﻮﺟﻮد‬.
1999 1992 1992:‫ﻛﺒﻴﺮ‬ ‫اﻟﻌﺪد‬ ‫ﻻن‬ ‫وأﻳﻀﺎ‬ ‫ﻓﺮاغ‬ ‫ﻟﻮﺟﻮد‬.
‫ﺔ‬ ‫ﻟﻐ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺤﻴﺤﺔ‬ ‫اﻟﺼ‬ ‫ﺪاد‬ ‫اﻷﻋ‬ ‫ﻨﻴﻒ‬ ‫ﺗﺼ‬ ‫ﻦ‬ ‫ﻳﻤﻜ‬ ‫ﺎ‬ ‫ﻛﻤ‬C++،‫ﻃﻮﻟﻬ‬ ‫ﺐ‬ ‫ﺣﺴ‬‫ﺎ‬،‫ﻌﺔ‬ ‫واﻟﺴ‬
‫ﻣﺜﻼ‬ ‫اﻟﺬاﻛﺮة‬ ‫ﻓﻲ‬ ‫ﻟﻬﺎ‬ ‫اﻟﺘﺨﺰﻳﻨﻴﺔ‬:-
‫اﻟﺼﺤﻴﺤﺔ‬ ‫اﻟﺜﻮاﺑﺖ‬40000 , 19897‫ﻃﻮﻳﻠﺔ‬ ‫ﺻﺤﻴﺤﺔ‬ ‫ﺛﻮاﺑﺖ‬ ‫ﺗﺴﻤﻰ‬long int.
‫اﻟﺜﻮاﺑﺖ‬45 , 80 , -16‫ﻗﺼﻴﺮة‬ ‫ﺻﺤﻴﺤﺔ‬ ‫ﺛﻮاﺑﺖ‬ ‫ﺗﺴﻤﻰ‬short int.
‫اﻟﺜﻮاﺑﺖ‬967 , 20000‫إﺷﺎرة‬ ‫ﺑﺪون‬ ‫ﺻﺤﻴﺤﺔ‬ ‫ﺛﻮاﺑﺖ‬ ‫ﺗﺴﻤﻰ‬unsigned int.
‫واﻟﻘ‬ ‫ﺔ‬‫اﻟﻄﻮﻳﻠ‬ ‫ﺖ‬‫اﻟﺜﻮاﺑ‬ ‫ﻦ‬‫ﺑﻴ‬ ‫ﺮق‬‫واﻟﻔ‬‫ﻟﻜﻞ‬ ‫اﻟﻤﻄﻠﻮﺑﺔ‬ ‫اﻟﺘﺨﺰﻳﻨﻴﺔ‬ ‫اﻟﻮﺣﺪات‬ ‫ﺪد‬‫ﻋ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻮ‬‫ﻫ‬ ‫ﻴﺮة‬‫ﺼ‬
‫ﺮة‬‫اﻟﺬاﻛ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻮع‬‫ﻧ‬،‫اﻛﺒﺮ‬ ‫ﺣﻴﺰا‬ ‫ﺄﺧﺬ‬‫ﺗ‬ ‫ﺔ‬‫ﻓﺎﻟﻄﻮﻳﻠ‬،‫اﻟﺘﺨﺰﻳﻨﻴﺔ‬ ‫اﻟﻮﺣﺪات‬ ‫ﻋﺪد‬ ‫ﺗﻮﻓﺮ‬ ‫واﻟﻘﺼﻴﺮة‬
‫ﺘﻌﻤﻠﺔ‬‫اﻟﻤﺴ‬،‫إﺷﺎرة‬ ‫ﺪون‬‫ﺑ‬ ‫ﺤﻴﺤﺔ‬‫اﻟﺼ‬ ‫ﺖ‬‫اﻟﺜﻮاﺑ‬ ‫ﺎ‬‫أﻣ‬unsigned int،‫ﻳﻮﻓﺮ‬ ‫اﺳﺘﻌﻤﺎﻟﻬﺎ‬ ‫ﻓﺎن‬
‫ﺔ‬ ‫ﻛﻠﻤ‬ ‫ﺮ‬ ‫ﺗﺬﻛ‬ ‫ﻨﺪﻣﺎ‬ ‫ﻋ‬ ‫ﺎره‬‫ﻟﻼﺷ‬ ‫ﺘﻌﻤﻞ‬ ‫ﺗﺴ‬ ‫ﺪة‬ ‫واﺣ‬ ‫ﻴﺔ‬ ‫ﺗﺨﺰﻳﻨ‬ ‫ﺪة‬ ‫وﺣ‬unsigned،‫ﺒﻞ‬ ‫ﻗ‬int،

‫ﺎرة‬ ‫إﺷ‬ ‫ﺪون‬ ‫ﺑ‬ ‫ﺒﺔ‬ ‫ﻣﻮﺟ‬ ‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﻰ‬ ‫إﻟ‬ ‫ﻴﻤﺔ‬ ‫اﻟﻘ‬ ‫ﺔ‬ ‫ﺑﺈزاﺣ‬ ‫ﻚ‬ ‫وذﻟ‬،‫ﺎﺑﻘﺔ‬ ‫اﻟﺴ‬ ‫ﻮاع‬ ‫اﻷﻧ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻮع‬ ‫ﻧ‬ ‫ﻞ‬ ‫وﻟﻜ‬
‫اﻟﻤﻨﺎﺳﺒﺔ‬ ‫ﺗﻄﺒﻴﻘﺎﺗﻪ‬.
-b‫اﻟﺤﻘﻴﻘﻲ‬ ‫اﻟﻌﺪدي‬ ‫اﻟﺜﺎﺑﺖ‬Floating-point Constants
-‫اﻷرﻗﺎم‬ ‫ﻣﻦ‬ ‫ﻣﻜﻮن‬ ‫ﻋﺪد‬ ‫ﻫﻮ‬0Ù9
-‫ﻋﺸﺮﻳﺔ‬ ‫ﻓﺎﺻﻠﺔ‬ ‫ﻋﻠﻰ‬ ‫ﻳﺤﺘﻮى‬ ‫أن‬ ‫ﻳﺠﺐ‬
-‫اﻻﺷﺎره‬ ‫ﻳﺤﻮى‬ ‫أن‬ ‫ﻳﻤﻜﻦ‬"+"‫أو‬"-"
-‫ﻻ‬‫ﻓﺎرزة‬ ‫ﻋﻠﻰ‬ ‫ﻳﺤﺘﻮى‬ ‫أن‬ ‫ﻳﺠﻮز‬"،"
‫ﺻﺤﻴﺢ‬ ‫ﺑﺸﻜﻞ‬ ‫اﻟﻌﺸﺮﻳﺔ‬ ‫اﻟﻔﺎﺻﻠﺔ‬ ‫ﺗﺴﺘﻌﻤﻞ‬ ‫ﺣﻘﻴﻘﻲ‬ ‫ﻋﺪد‬ ‫ﺛﻮاﺑﺖ‬ ‫ﻋﻠﻰ‬ ‫أﻣﺜﻠﺔ‬:-
421.5
10.6
0.0
0
01
-68.0
‫ﻣﻨﻬﺎ‬ ‫ﻛﻞ‬ ‫إزاء‬ ‫اﻟﻤﺒﻨﻴﺔ‬ ‫ﻟﻸﺳﺒﺎب‬ ‫ﺻﺤﻴﺤﺔ‬ ‫ﻏﻴﺮ‬ ‫اﻻﺗﻴﻪ‬ ‫واﻷﻣﺜﻠﺔ‬:-
1000:‫ﻋﺸﺮﻳﺔ‬ ‫ﻓﺎﺻﻠﺔ‬ ‫ﻋﻠﻲ‬ ‫ﻳﺤﺘﻮى‬ ‫ﻻ‬ ‫ﻻﻧﻪ‬.
4,000.21:‫ﻓﺎرزة‬ ‫ﻋﻠﻰ‬ ‫ﻳﺤﺘﻮى‬ ‫ﻻﻧﻪ‬.
2 83.4:‫ﻓﺮاغ‬ ‫ﻋﻠﻰ‬ ‫ﻳﺤﺘﻮى‬ ‫ﻻن‬.

•‫اﻟﺮﻣﺰﻳﺔ‬ ‫اﻟﺜﻮاﺑﺖ‬ ‫ﺗﻤﺜﻴﻞ‬Non-numeric
-‫اﻟﻠﻐﺔ‬ ‫رﻣﻮز‬ ‫ﻣﻦ‬ ‫ﺳﻠﺴﻠﺔ‬)‫ﺧﺎﺻﺔ‬ ‫رﻣﻮز‬ ‫أرﻗﺎم‬ ‫أﺣﺮف‬(‫ﺑﻴﻦ‬ ‫ﻣﺤﺼﻮرة‬
‫ﻣﺰدوﺟﺔ‬ ‫ﻋﻠﻮﻳﺔ‬ ‫ﺣﻮاﺻﺮ‬)‫اﻗﺘﺒﺎس‬ ‫أو‬ ‫ﺗﻨﺼﻴﺺ‬ ‫ﻋﻼﻣﺎت‬(
‫ﻳﺄﺗﻲ‬ ‫ﻣﺎ‬ ‫اﻟﺮﻣﺰي‬ ‫اﻟﺜﺎﺑﺖ‬ ‫ﻋﻠﻰ‬ ‫اﻷﻣﺜﻠﺔ‬ ‫وﻣﻦ‬:-
"first"
"my name is"
"30+50=80"
"my,no=123.04"
"Islam"
‫واﻟﺼﺤﻴﺢ‬ ‫رﻣﺰﻳﺎ‬ ‫ﺛﺎﺑﺘﺎ‬ ‫ﻣﺰدوﺟﺘﻴﻦ‬ ‫ﺣﺎﺻﺮﺗﻴﻦ‬ ‫ﺑﻴﻦ‬ ‫ﻣﻮﺿﻮع‬ ‫ﺺ‬‫ﻧ‬ ‫أي‬ ‫ﻤﻴﻨﺎ‬‫ﺳ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﻆ‬‫وﺗﻼﺣ‬
‫اﻟﺤﻘﻴﻘﺔ‬ ‫ﻻ‬ ‫واﻻﺻﻄﻼح‬ ‫اﻟﻤﺠﺎز‬ ‫ﻗﺒﻴﻞ‬ ‫ﻣﻦ‬ ‫ﻲ‬‫ﻫ‬ ‫ﺰﻳﺎ‬‫رﻣ‬ ‫ﺘﺎ‬‫ﺛﺎﺑ‬ ‫ﻤﻴﺘﻪ‬‫ﺗﺴ‬ ‫أن‬،‫رﻣﺰي‬ ‫ﻛﻠﻤﺔ‬ ‫واﻣﺎ‬
:‫ﺮﻣﻮز‬‫اﻟ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺪد‬‫ﻋ‬ ‫ﻦ‬‫ﻣ‬ ‫ﻮن‬‫ﻣﻜ‬ ‫ﻨﺺ‬‫اﻟ‬ ‫ﻼن‬‫ﻓ‬،‫ﺪد‬‫اﻟﻌ‬ ‫ﻴﺮ‬‫ﻏ‬ ‫ﺖ‬‫ﺑﺎﻟﺜﺎﺑ‬ ‫ﺐ‬‫اﻟﻜﺘ‬ ‫ﺾ‬‫ﺑﻌ‬ ‫ﻤﻴﺔ‬‫وﺗﺴ‬
Non-numeric.
‫ﻣﻼﺣﻈﺔ‬/
‫ﻼه‬‫أﻋ‬ ‫ﻮاردة‬‫اﻟ‬ ‫ﺰﻳﺔ‬‫اﻟﺮﻣ‬ ‫ﺖ‬‫اﻟﺜﻮاﺑ‬ ‫ﻞ‬‫ﻛ‬،‫ﺎ‬‫داﺧﻠﻬ‬ ‫ﺎﺑﻴﺔ‬‫ﺣﺴ‬ ‫ﺎ‬‫ارﻗﺎﻣ‬ ‫ﺘﺨﺪﻣﺖ‬‫اﺳ‬ ‫وان‬،‫ﻻ‬ ‫أﻧﺎ‬ ‫أﻻ‬
‫ﺎﺑﻴﺔ‬‫ﺣﺴ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫أي‬ ‫ﻞ‬‫ﺗﺤﻤ‬،‫ﺎﺑﻲ‬‫ﺣﺴ‬ ‫ﻨﻰ‬‫ﻣﻌ‬ ‫ﺎ‬‫ﻟﻬ‬ ‫ﻴﺲ‬‫وﻟ‬،‫ﺎدة‬‫ﻋ‬ ‫ﺖ‬‫اﻟﺜﻮاﺑ‬ ‫ﺬه‬‫ﻫ‬ ‫ﺜﻞ‬‫ﻣ‬ ‫ﺘﺨﺪم‬‫وﺗﺴ‬
‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻧﺘﺎﺋﺞ‬ ‫ﻣﻊ‬ ‫ﺗﻮﺿﻴﺤﻴﺔ‬ ‫ﻛﻤﻌﻠﻮﻣﺎت‬.

‫اﻟﻤﺘﻐﻴﺮات‬
‫أﺳﻤﺎء‬ ‫ﻫﻲ‬)‫ﻋﻨﺎوﻳﻦ‬(‫ذ‬ ‫ﻓﻲ‬ ‫ﻟﻤﻮاﻗﻊ‬‫اﻟﺤﺎﺳﻮب‬ ‫اﻛﺮة‬،‫أﻋﺪاد‬ ‫أو‬ ‫رﻣﻮز‬ ‫ﺑﻬﺎ‬ ‫ﻳﺨﺰن‬.
‫أو‬ ‫ﺤﻴﺤﺔ‬‫اﻟﺼ‬ ‫ﻴﻢ‬‫اﻟﻘ‬ ‫ﺜﻞ‬‫ﻣ‬ ‫ﺘﻠﻔﺔ‬ ‫ﻣﺨ‬ ‫ﺎدة‬‫ﻋ‬ ‫ﻮن‬‫ﺗﻜ‬ ‫ﻨﻬﺎ‬‫ﺗﺨﺰﻳ‬ ‫ﺮاد‬ ‫اﻟﻤ‬ ‫ﺎت‬‫اﻟﻤﻌﻠﻮﻣ‬ ‫ﻮاع‬‫أﻧ‬ ‫أن‬ ‫ﺎ‬‫وﺑﻤ‬
‫ﺰﻳﺔ‬‫اﻟﺮﻣ‬ ‫أو‬ ‫ﻴﺔ‬‫اﻟﺤﻘﻴﻘ‬...‫أﻧﻮاع‬ ‫ﻋﻦ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺑﺪاﻳﺔ‬ ‫ﻓﻲ‬ ‫اﻟﻤﺘﺮﺟﻢ‬ ‫ﺗﻌﻠﻢ‬ ‫أن‬ ‫ﺗﺤﺘﺎج‬ ‫ﺎﻧﻚ‬‫ﻓ‬ ‫ـﺦ‬‫اﻟـ‬
‫ﺒﺮﻧﺎﻣﺞ‬ ‫اﻟ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺘﻌﻤﺎﻟﻬﺎ‬ ‫اﺳ‬ ‫ﺮﻳﺪ‬ ‫ﺗ‬ ‫ﻲ‬ ‫اﻟﺘ‬ ‫ﻴﺮات‬ ‫اﻟﻤﺘﻐ‬،‫اﻟ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺜﻼ‬ ‫ﻓﻤ‬‫أن‬ ‫ﻦ‬ ‫ﺗﺒﻴ‬ ‫ﻴﺔ‬ ‫اﻟﺘﺎﻟ‬ ‫ﻄﻮر‬ ‫ﺴ‬
‫اﻟﻤﺘﻐﻴﺮﻳﻦ‬x‫و‬y‫ﺣﻘﻴﻘﻴﺎن‬،‫واﻟﻤﺘﻐﻴﺮ‬k‫ﺻﺤﻴﺢ‬،‫واﻟﻤﺘﻐﻴﺮ‬c,b,a‫رﻣﺰﻳﺔ‬.
‫اﻷول‬ ‫ﻄﺮﻳﻦ‬‫اﻟﺴ‬ ‫ﻆ‬‫ﻻﺣ‬،‫ﺜﺮ‬‫اﻛ‬ ‫ﻰ‬‫ﻋﻠ‬ ‫ﺘﻮﻳﺎن‬‫ﻳﺤ‬ ‫ﺚ‬‫واﻟﺜﺎﻟ‬‫ﻛﻞ‬ ‫ﻦ‬‫ﺑﻴ‬ ‫ﻞ‬‫ﻳﻔﺼ‬ ‫ﺚ‬‫ﺣﻴ‬ ‫ﻴﺮ‬‫ﻣﺘﻐ‬ ‫ﻦ‬‫ﻣ‬
‫ﻦ‬‫ﻣﺘﻐﻴﺮﻳ‬،‫ﻴﺮات‬‫اﻟﻤﺘﻐ‬ ‫ﻮاع‬‫أﻧ‬ ‫ﺪ‬‫ﺗﺤﺪﻳ‬ ‫ﻦ‬‫ﻳﻤﻜ‬ ‫ﻚ‬‫وﻛﺬﻟ‬ ‫ﻠﺔ‬‫ﻓﺎﺻ‬،‫ﻟﻠﻨﻮع‬ ‫اﻟﺪﻗﻴﻖ‬ ‫اﻟﺘﻔﺼﻴﻞ‬ ‫ﺮ‬‫ﺑﺬﻛ‬
،‫ﻴﺔ‬‫اﻟﺘﺨﺰﻳﻨ‬ ‫ﻌﺔ‬‫اﻟﺴ‬ ‫ﻮل‬‫ﻃ‬ ‫ﺚ‬‫ﺣﻴ‬ ‫ﻦ‬‫ﻣ‬،‫ﻗﺼﻴﺮ‬ ‫ﺣﻘﻴﻘﻲ‬ ‫ﻃﻮﻳﻞ‬ ‫أم‬ ‫ﻗﺼﻴﺮ‬ ‫ﺻﺤﻴﺢ‬ ‫ﻫﻮ‬ ‫ﻞ‬‫ﻫ‬ ‫أي‬
‫ﻣﻀﺎﻋﻒ‬ ‫أو‬...‫اﻟـﺦ‬
Float x, y;
Integer k;
Char c,b,a;
X=2.0;
Y=10.6*x;
K=100;
A=t;
B=f;
C=4;
X‫و‬y‫ﺣﻘﻴﻘﻴﺎن‬ ‫ﻋﺪدان‬
K‫ﺻﺤﻴﺢ‬ ‫ﻋﺪد‬
C,b,a‫رﻣﻮز‬

•‫ﻟﻨﻮﻋﻴﻦ‬ ‫اﻟﻤﺘﻐﻴﺮات‬ ‫وﺗﻘﺴﻢ‬:-
١-‫ﻋﺪدﻳﺔ‬ ‫ﻣﺘﻐﻴﺮات‬
‫ﻓﻲ‬ ‫ﻣﻮاﻗﻊ‬ ‫وﻫﻲ‬‫أﻋﺪاد‬ ‫ﺑﻬﺎ‬ ‫ﺗﺨﺰن‬ ‫اﻟﺬاﻛﺮة‬.
٢-‫رﻣﺰﻳﺔ‬ ‫ﻣﺘﻐﻴﺮات‬
‫رﻣﻮز‬ ‫ﺑﻬﺎ‬ ‫ﺗﺨﺰن‬ ‫اﻟﺬاﻛﺮة‬ ‫ﻓﻲ‬ ‫ﻣﻮاﻗﻊ‬ ‫وﻫﻲ‬.
٣-‫ﻣﻨﻄﻘﻴﺔ‬ ‫ﻣﺘﻐﻴﺮات‬
‫أﻣﺎ‬ ‫ﻣﻨﻄﻘﻴﺔ‬ ‫ﻗﻴﻤﺔ‬ ‫ﺑﻬﺎ‬ ‫وﺗﺨﺰن‬FALSE =0‫أو‬TRUE=1

‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫اﻟﻤﺴﺘﻌﻤﻠﺔ‬ ‫اﻷدوات‬++C
‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫ﻳﻮﺟﺪ‬C++‫وﻫﻲ‬ ‫اﻷدوات‬ ‫ﻣﻦ‬ ‫أﻧﻮاع‬ ‫ﺛﻼﺛﺔ‬:
‫ﺎﺑ‬‫اﻟﺤﺴ‬ ‫اﻷدوات‬‫ﻴﺔ‬–‫ﺔ‬‫واﻟﻌﻼﻗ‬ ‫ﻴﺔ‬‫اﻟﻤﻨﻄﻘ‬ ‫اﻷدوات‬–‫ﻴﻞ‬‫ﺗﻔﺼ‬ ‫ﻲ‬‫ﻳﺄﺗ‬ ‫ﻴﻤﺎ‬‫وﻓ‬ ‫ﻴﻘﺔ‬‫اﻟﺪﻗ‬ ‫اﻷدوات‬
‫اﻟﺜﻼﺛﺔ‬ ‫ﺑﺎﻷﻧﻮاع‬:-
‫اﻟﺤﺴﺎﺑﻴﺔ‬ ‫اﻷدوات‬Arithmetic Operators
‫ﺔ‬ ‫ﻟﻐ‬ ‫ﻤﺢ‬ ‫ﺗﺴ‬C++‫ﻤﺔ‬ ‫وﻗﺴ‬ ‫ﺮي‬ ‫وﺿ‬ ‫ﺮح‬ ‫وﻃ‬ ‫ﻊ‬ ‫ﺟﻤ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺎﺑﻴﺔ‬ ‫اﻟﺤﺴ‬ ‫اﻷدوات‬ ‫ﺘﻌﻤﺎل‬ ‫ﺑﺎﺳ‬،
‫ﺮى‬‫اﻷﺧ‬ ‫ﺎت‬‫ﻛﺎﻟﻠﻐ‬،‫أس‬ ‫ﻰ‬‫إﻟ‬ ‫ﺮف‬‫اﻟ‬ ‫ﻴﺔ‬‫ﻋﻤﻠ‬ ‫أن‬ ‫إﻻ‬،‫ﻣﺜﻞ‬ ‫ﻣﺒﺎﺷﺮة‬ ‫أدوات‬ ‫ﻟﻬﺎ‬ ‫ﻟﻴﺲ‬‫اﻷداة‬h
‫ﻲ‬ ‫ﻓ‬Basic‫واﻷداة‬**‫ﺮان‬‫ﻓﻮرﺗ‬ ‫ﻲ‬ ‫ﻓ‬،‫ﺔ‬ ‫ﻟﻐ‬ ‫ﻲ‬‫ﻓ‬ ‫أس‬ ‫ﻰ‬‫إﻟ‬ ‫ﺮﻓﻊ‬‫اﻟ‬ ‫ﻴﺔ‬ ‫ﻋﻠﻤ‬ ‫ﺘﻢ‬‫ﺗ‬ ‫ﺎ‬‫واﻧﻤ‬C++
‫أﺧﺮى‬ ‫ﺑﻄﺮﻳﻘﺔ‬..
‫ﺔ‬‫ﻟﻐ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻤﺔ‬‫اﻟﻘﺴ‬ ‫ﺘﻠﻒ‬‫ﺗﺨ‬ ‫ﺎ‬‫ﻛﻤ‬C++‫ﻲ‬‫ﻓ‬ ‫ﻨﻬﺎ‬‫ﻋ‬Basic‫ﻦ‬ ‫ﻋ‬ ‫ﺘﺞ‬‫ﻳﻨ‬ ‫ﺮي‬‫ﻛﺴ‬ ‫ﺰء‬‫ﺟ‬ ‫أي‬ ‫أن‬ ‫إذا‬
‫ﻴﺮا‬‫ﻛﺒ‬ ‫ﺎن‬‫ﻛ‬ ‫ﺎ‬‫ﻣﻬﻤﻬ‬ ‫ﻞ‬‫ﻳﻬﻤ‬ ‫ﻤﺔ‬‫اﻟﻘﺴ‬،‫اﻟﻘﺴﻤﺔ‬ ‫ﻧﺎﺗﺞ‬ ‫ﻓﻤﺜﻼ‬ ‫وﻛﻮﺑﻮل‬ ‫ﺑﺎﺳﻜﺎل‬ ‫ﻟﻐﺘﻲ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺎ‬‫ﻛﻤ‬8/3
‫ﻫﻮ‬2‫اﻟﻜ‬ ‫ﻻ‬‫ﺴﺮ‬0.666‫ﻳﻬﻤﻞ‬،‫اﻷداة‬ ‫ﺑﺎﺳﺘﻌﻤﺎل‬ ‫اﻟﻘﺴﻤﺔ‬ ‫ﻧﺎﺗﺞ‬ ‫وﻳﻜﻮن‬/‫اﻟﻌﺪد‬ ‫ﺻﺤﻴﺢ‬.
‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫اﻟﻤﺴﺘﻌﻤﻠﺔ‬ ‫اﻟﺤﺴﺎﺑﻴﺔ‬ ‫اﻷدوات‬ ‫ﻧﻠﺨﺺ‬ ‫أن‬ ‫اﻵن‬ ‫وﻳﻤﻜﻨﻨﺎ‬C++‫ﻳﺄﺗﻲ‬ ‫ﻓﻴﻤﺎ‬:-
‫وﻇﻴﻔﺘﻬﺎ‬ ‫اﻷداة‬
‫ﺳﺎﻟﺒﺔ‬ ‫ﻛﺄﺷﺎره‬ ‫أو‬ ‫ﻟﻠﻄﺮح‬ -
‫ﻟﻠﺠﻤﻊ‬ +
‫ﻟﻠﻀﺮب‬ *
‫ﻟﻠﻘﺴﻤﺔ‬ /
‫اﻟﺼﺤﻴﺤﺔ‬ ‫اﻟﻘﺴﻤﺔ‬ ‫ﻟﺒﺎﻗﻲ‬ %
‫ﻟﻠﻨﻘﺼﺎن‬ --
‫ﻟﻠﺰﻳﺎدة‬ + +
‫اﻟﺠﺪول‬٣-١

‫ﺤﻴﺤﺔ‬‫اﻟﺼ‬ ‫ﻴﺎت‬‫اﻟﻤﻌﻄ‬ ‫ﻮع‬‫ﻧ‬ ‫ﺐ‬‫ﺣﺴ‬ ‫ﺎﺑﻴﺔ‬‫اﻟﺤﺴ‬ ‫اﻷدوات‬ ‫ﺾ‬‫ﺑﻌ‬ ‫أداء‬ ‫ﺘﻠﻒ‬‫وﻳﺨ‬،‫اﻟﺤﻘﻴﻘﺔ‬ ‫أو‬،
‫ﺎﺑﻴﺔ‬ ‫اﻟﺤﺴ‬ ‫ﻸدوات‬ ‫ﻟ‬ ‫ﻴﺔ‬ ‫اﻟﺤﻘﻴﻘ‬ ‫ﻴﺎت‬ ‫اﻟﻤﻌﻄ‬ ‫ﺔ‬ ‫ﻣﻌﺎﻣﻠ‬ ‫ﻨﺪ‬ ‫ﻓﻌ‬ ‫ﺰﻳﺔ‬ ‫اﻟﺮﻣ‬ ‫أو‬،‫أن‬ ‫ﻮل‬ ‫اﻟﻘ‬ ‫ﻦ‬ ‫ﻳﻤﻜ‬
‫ﺮب‬‫وﺿ‬ ‫ﺮح‬‫وﻃ‬ ‫ﻊ‬‫ﺟﻤ‬ ‫ﻦ‬‫ﻣ‬ ‫ﻴﺔ‬‫اﻷﺳﺎﺳ‬ ‫ﻴﺎت‬‫اﻟﻌﻠﻤ‬،‫ﺮﻓﻬﺎ‬‫ﻧﻌ‬ ‫ﻲ‬‫اﻟﺘ‬ ‫ﺮﻳﻘﺔ‬‫ﺑﺎﻟﻄ‬ ‫ﺮي‬‫ﺗﺠ‬،‫أن‬ ‫إﻻ‬
‫ﺐ‬‫ﻳﺠ‬ ‫ﺬورا‬‫ﻣﺤ‬ ‫ﻨﺎك‬‫ﻫ‬‫ﻪ‬‫ﺑ‬ ‫ﺮ‬‫ﻧﺬﻛ‬ ‫أن‬،‫ﺣﺴﺎﺑﻴﺔ‬ ‫ﻋﻤﻠﻴﺔ‬ ‫أﻳﺔ‬ ‫ﻦ‬‫ﻣ‬ ‫ﻴﺠﺔ‬‫اﻟﻨﺘ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﺘﻌﺪي‬‫ﺗ‬ ‫أن‬ ‫ﻮ‬‫وﻫ‬
‫ﻨﺎﺗﺞ‬‫اﻟ‬ ‫ﻴﺮ‬‫اﻟﻤﺘﻐ‬ ‫ﻨﻮع‬‫ﻟ‬ ‫ﻮﻣﺔ‬‫اﻟﻤﺮﺳ‬ ‫ﺪود‬‫اﻟﺤ‬،‫ﺪودا‬‫ﺣ‬ ‫ﻴﺮات‬‫اﻟﻤﺘﻐ‬ ‫ﻮاع‬‫أﻧ‬ ‫ﻦ‬‫ﻣ‬ ‫ﻮع‬‫ﻧ‬ ‫ﻞ‬‫ﻟﻜ‬ ‫ﻻن‬،
‫ﺘﺎﺋﺞ‬ ‫اﻟﻨ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺄ‬ ‫ﺧﻄ‬ ‫ﻨﻪ‬ ‫ﻋ‬ ‫ﺘﺞ‬ ‫ﻳﻨ‬ ‫ﺄ‬ ‫ﺧﻄ‬ ‫ﺎ‬ ‫ﺗﺠﺎوزﻫ‬ ‫ﺪ‬ ‫ﻳﻌ‬،‫ﺤﻴﺤﺔ‬ ‫اﻟﺼ‬ ‫ﻴﺎت‬ ‫اﻟﻤﻌﻄ‬ ‫ﺔ‬ ‫ﻣﻌﺎﻣﻠ‬ ‫ﻨﺪ‬ ‫وﻋ‬
‫ﺘﻮ‬ ‫ﻧ‬ ‫ﻲ‬ ‫اﻟﺘ‬ ‫ﺮﻳﻘﺔ‬ ‫ﺑﺎﻟﻄ‬ ‫اﻷدوات‬ ‫ﻞ‬ ‫ﺗﻌﻤ‬ ‫ﺎﺑﻴﺔ‬ ‫اﻟﺤﺴ‬ ‫ﺎﻷدوات‬ ‫ﺑ‬‫ﻗﻌﻬﺎ‬،‫ﺪود‬ ‫اﻟﺤ‬ ‫ﺪي‬ ‫ﺗﻌ‬ ‫ﻨﺪ‬ ‫وﻋ‬
‫ﺤﻴﺤﺔ‬‫اﻟﺼ‬ ‫ﻴﻢ‬‫اﻟﻘ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺎ‬‫ﺑﻬ‬ ‫ﻤﻮح‬‫اﻟﻤﺴ‬،‫وﻗﻊ‬ ‫ﺪ‬‫ﻗ‬ ‫ﺄ‬‫ﺧﻄ‬ ‫أن‬ ‫ﻲ‬‫ﻳﻌﻨ‬ ‫ﺬا‬‫ﻫ‬ ‫ﺎن‬‫ﻓ‬overflow،‫وﻓﻲ‬
‫ﺧﻄﺄ‬ ‫رﺳﺎﻟﺔ‬ ‫أﻳﺔ‬ ‫اﻟﻤﺘﺮﺟﻢ‬ ‫ﻣﻦ‬ ‫ﺗﺘﻠﻘﻰ‬ ‫ﻟﻦ‬ ‫اﻟﺤﺎﻟﺔ‬ ‫ﻫﺬه‬،‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻟﺪﻳﻨﺎ‬ ‫ﻛﺎن‬ ‫إذا‬ ‫ﻓﻤﺜﻼ‬:
‫ﻴﺠﺔ‬‫اﻟﻨﺘ‬ ‫ﺒﺎﻋﺔ‬‫ﻃ‬ ‫ﻨﺪ‬‫ﻋ‬n‫اﻟﻨﻬﺎ‬‫ﻮاب‬‫اﻟﺠ‬ ‫ﻮن‬‫ﻳﻜ‬ ‫أن‬ ‫ﺘﻮﻗﻊ‬‫ﻧ‬ ‫ﻴﺔ‬‫ﺋ‬99000،‫ﻲ‬‫ﻓ‬ ‫ﻮاب‬‫اﻟﺠ‬ ‫أن‬ ‫أﻻ‬
‫ﺘﻌﺪى‬ ‫ﻳ‬ ‫ﻦ‬ ‫ﻟ‬ ‫ﺔ‬ ‫اﻟﺤﺎﻟ‬ ‫ﺬه‬ ‫ﻫ‬30464،‫ﺤﻴﺤﺔ‬ ‫اﻟﺼ‬ ‫ﻴﻤﺔ‬ ‫ﻟﻠﻘ‬ ‫ﻪ‬ ‫ﺑ‬ ‫ﻤﻮح‬ ‫اﻟﻤﺴ‬ ‫ﻰ‬ ‫اﻻﻋﻠ‬ ‫ﺪ‬ ‫اﻟﺤ‬ ‫ﻮ‬ ‫وﻫ‬،
‫ﻧﻘﺴﻢ‬ ‫ﻓﻌﻨﺪﻣﺎ‬ ‫ﺑﺎﻟﻘﺴﻤﺔ‬ ‫ﺘﻌﻠﻖ‬‫ﻳ‬ ‫ﺮى‬‫أﺧ‬ ‫ﺮ‬‫أﻣ‬ ‫ﻨﺎك‬‫وﻫ‬8‫ﻋﻠﻰ‬3‫ﺻﺤﻴﺤﺔ‬ ‫ﻗﺴﻤﺔ‬8/3‫اﻟﻨﺎﺗﺞ‬ ‫ﻓﺎن‬
‫ﻮ‬‫وﻫ‬ ‫ﺤﻴﺤﺎ‬‫ﺻ‬ ‫ﻮن‬‫ﻳﻜ‬2‫ﻂ‬‫ﻓﻘ‬،‫اﻟ‬ ‫ﺰء‬‫اﻟﺠ‬ ‫ﻰ‬‫ﻋﻠ‬ ‫ﺎﻓﻆ‬‫ﺗﺤ‬ ‫أن‬ ‫ﺖ‬‫رﻏﺒ‬ ‫ﺎ‬‫ﻣ‬ ‫وإذا‬‫ﺬي‬‫اﻟ‬ ‫ﺮي‬‫ﻜﺴ‬
‫ﻘﻂ‬ ‫واﺳ‬ ‫ﻞ‬‫أﻫﻤ‬،‫ﻴﻘﺔ‬‫ﺣﻘ‬ ‫ﻤﺔ‬‫ﻗﺴ‬ ‫ﻰ‬‫إﻟ‬ ‫ﻤﺔ‬‫اﻟﻘﺴ‬ ‫ﻮل‬‫ﺗﺤ‬ ‫أن‬ ‫ﻨﻚ‬ ‫ﻳﻤﻜ‬8.0/3.0‫ﻨﺎﺗﺞ‬ ‫اﻟ‬ ‫ﺎن‬‫ﻓ‬ ‫ﺌﺬ‬ ‫ﺣﻴﻨ‬
‫ﻴﻜﻮن‬ ‫ﺳ‬2.667‫ﺔ‬ ‫ﻟﻐ‬ ‫ﺖ‬ ‫أدﺧﻠ‬ ‫ﺒﺐ‬ ‫اﻟﺴ‬ ‫ﺬا‬ ‫ﻟﻬ‬C++‫ﻤﺔ‬ ‫ﻟﻘﺴ‬ ‫ا‬ ‫ﻲ‬ ‫ﺑﺎﻗ‬ ‫أداة‬%‫ﻤﻰ‬ ‫وﻳﺴ‬
Modulus Operator‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫وﻳﺴﺘﻌﻤﻞ‬:
‫ﻮاب‬‫اﻟﺠ‬ ‫ﻲ‬‫ﺗﻌﻄ‬1‫ﻤﺔ‬‫اﻟﻘﺴ‬ ‫ﻲ‬‫ﺑﺎﻗ‬ ‫ﻮ‬‫وﻫ‬‫ﺤﻴﺤﺔ‬‫اﻟﺼ‬7/3،‫ﻣﻦ‬ ‫ﻛﻼ‬ ‫أن‬ ‫ﺑﺎﻟﺬﻛﺮ‬ ‫ﺮ‬‫اﻟﺠﺪﻳ‬ ‫ﻦ‬‫وﻣ‬
‫ﻴﺔ‬ ‫اﻟﻌﻤﻠ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﺜﻞ‬ ‫ﻣ‬ ‫ﺘﻌﻤﻼن‬ ‫ﺗﺴ‬ ‫ﻮل‬ ‫وﻛﻮﺑ‬ ‫ﻜﺎل‬ ‫ﺑﺎﺳ‬،‫ﻰ‬ ‫ﻋﻠ‬ ‫ﻴﺔ‬ ‫اﻟﻌﻤﻠ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﺐ‬ ‫ﺗﻜﺘ‬ ‫ﻜﺎل‬ ‫ﺑﺎﺳ‬ ‫ﻲ‬ ‫ﻓﻔ‬
‫ﻨﺤﻮ‬ ‫اﻟ‬7 mod 3،‫ﺔ‬ ‫وﻛﻠﻤ‬MOD‫ﺎر‬ ‫اﺧﺘﺼ‬ ‫ﻲ‬ ‫ﻫ‬Modulus،‫ﺔ‬ ‫ﻟﻐ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺎ‬ ‫أﻣ‬C++
‫اﻷداة‬ ‫ﻓﺘﺴﺘﻌﻤﻞ‬%‫اﻟﻌﻤﻞ‬ ‫ﺑﻬﺬا‬ ‫ﻟﺘﻘﻮم‬.
Main( )
{
int n = 33000;
n = n * 3;
}
7 % 3

‫واﻟﺜﻨﺎﺋﻴﺔ‬ ‫اﻷﺣﺎدﻳﺔ‬ ‫اﻷدوات‬BinaryUnary and
Operators
‫ﻴﺔ‬ ‫ﺛﻨﺎﺋ‬ ‫أدوات‬ ‫ﻤﺔ‬ ‫اﻟﻘﺴ‬ ‫ﻲ‬ ‫وﺑﺎﻗ‬ ‫ﻤﺔ‬ ‫واﻟﻘﺴ‬ ‫ﺮب‬ ‫واﻟﻀ‬ ‫ﺮح‬ ‫واﻟﻄ‬ ‫ﻊ‬ ‫اﻟﺠﻤ‬ ‫أدوات‬ ‫ﻴﻊ‬ ‫ﺟﻤ‬ ‫ﺪ‬ ‫ﺗﻌ‬
binary‫ﺄﺧﺬ‬‫ﺗ‬ ‫ﺎ‬‫أﻧﻬ‬ ‫أي‬)‫ﻊ‬‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬‫ﺗ‬(‫واﺣﺪة‬ ‫ﻗﻴﻤﺔ‬ ‫ﺘﺞ‬‫وﺗﻨ‬ ‫ﻦ‬‫ﻗﻴﻤﺘﻴ‬،‫ﻧﺘﻴﺠﺔ‬ ‫ﻓﻤﺜﻼ‬2*3‫ﻫﻲ‬
‫ﻴﻤﺔ‬‫اﻟﻘ‬6‫ﺔ‬‫اﻷﺣﺎدﻳ‬ ‫اﻷداة‬ ‫ﻨﺎك‬‫وﻫ‬–‫ﺜﻼ‬‫ﻓﻤ‬ ‫ﺪ‬‫واﺣ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﻊ‬‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬‫ﺗ‬ ‫ﻨﺪﻣﺎ‬‫ﻋ‬(-1992)‫ﺜﻞ‬‫ﺗﻤ‬
‫ﺎ‬‫ﻟﺴ‬ ‫ا‬ ‫ﺎرة‬‫اﻹﺷ‬‫ﺔ‬‫أﺣﺎدﻳ‬ ‫أداة‬ ‫ﻨﺎ‬‫ﻫ‬ ‫ﻲ‬‫وﻫ‬ ‫ﻟﺒﻪ‬Unary،‫ﻛﻤﺎ‬ ‫ﺮح‬‫ﻃ‬ ‫ﻴﺔ‬‫ﻋﻤﻠ‬ ‫ﺖ‬‫ﻟﻴﺴ‬ ‫ﻨﺎ‬‫ﻫ‬ ‫ﻴﺔ‬‫واﻟﻌﻤﻠ‬
‫ﻧﻌﻠﻢ‬.
‫واﻟﻨﻘﺼﺎن‬ ‫اﻟﺰﻳﺎدة‬Increment and Decrement
‫ﻟﻐﺔ‬ ‫ﻣﺰاﻳﺎ‬ ‫ﻣﻦ‬C++‫اﻟﺤﺴﺎﺑﻴﺘﻴﻦ‬ ‫اﻷداﺗﻴﻦ‬ ‫ﺗﺴﺘﻌﻤﻞ‬ ‫أﻧﻬﺎ‬+ +‫و‬--‫ﺑﻤﻘﺪار‬ ‫اﻟﻘﻴﻢ‬ ‫ﻟﺰﻳﺎدة‬1
‫ﺑﻤﻘﺪار‬ ‫إﻧﻘﺎﺻﻬﺎ‬ ‫أو‬1،‫اﻻﺳﺘﻌﻤﺎل‬ ‫ﻃﺮﻳﻘﺔ‬ ‫ﻳﺒﻴﻦ‬ ‫اﻟﺘﺎﻟﻲ‬ ‫واﻟﻤﺜﺎل‬:
‫ﻗﻴﻤﺔ‬ ‫إﺿﺎﻓﺔ‬ ‫ﻣﻌﻨﺎه‬1‫إﻟﻰ‬a‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫ﻣﻜﺎﻓﺌﺔ‬ ‫ﺑﺼﻮره‬ ‫ﻛﺘﺎﺑﺘﻬﺎ‬ ‫وﻳﻤﻜﻦ‬:-
‫إﻧﻘﺎص‬ ‫ﻳﻤﻜﻦ‬ ‫ﻧﻔﺴﻬﺎ‬ ‫وﺑﺎﻟﻄﺮﻳﻘﺔ‬1‫ﻗﻴﻤﺔ‬ ‫ﻣﻦ‬a‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬:-
‫أو‬
‫اﻟﺼﻮرة‬ ‫ﻳﻜﺎﻓﺊ‬ ‫وﻫﻮ‬
‫ﻴﺬ‬‫اﻟﺘﻨﻔ‬ ‫ﺮﻋﺔ‬‫ﺳ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺮﻗﺎ‬‫ﻓ‬ ‫ﻨﺎك‬‫ﻫ‬ ‫ﻦ‬ ‫ﻟﻜ‬،‫ﻴﺮ‬‫ﻓﺎﻟﺘﻌﺒ‬++a;‫ﻴﺮ‬‫اﻟﺘﻌﺒ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺮع‬‫أﺳ‬a=a+1;‫ﺬه‬‫وﻫ‬
‫اﻷدوات‬ ‫ﻫﺬه‬ ‫ﻣﺜﻞ‬ ‫اﺳﺘﺨﺪام‬ ‫ﺟﺮاء‬ ‫ﻣﻦ‬ ‫اﻟﻔﺎﺋﺪة‬ ‫ﻫﻲ‬.
‫ﻴﻪ‬ ‫إﻟ‬ ‫ﻴﻪ‬ ‫اﻟﺘﻨﺒ‬ ‫ﻲ‬ ‫ﻳﻨﺒﻐ‬ ‫ﺎ‬ ‫وﻣﻤ‬‫ﻦ‬ ‫ﺑﻴ‬ ‫ﺮﻗﺎ‬ ‫ﻓ‬ ‫ﻨﺎك‬ ‫ﻫ‬ ‫أن‬ ‫ﻨﺎ‬ ‫ﻫ‬a++‫و‬++a،‫ﻦ‬ ‫ﻣ‬ ‫ﻼ‬ ‫ﻛ‬ ‫أن‬ ‫ﺤﻴﺢ‬ ‫ﺻ‬
‫ﻊ‬ ‫ﻳﺠﻤ‬ ‫ﻦ‬ ‫اﻟﺘﻌﺒﻴﺮﻳ‬1‫ﻰ‬ ‫إﻟ‬a،‫ﺘﻌﻤﺎل‬ ‫اﺳ‬ ‫ﻨﺪ‬ ‫ﻋ‬ ‫ﻦ‬ ‫ﻟﻜ‬++a‫ﻴﺮ‬ ‫اﻟﺘﻌﺎﺑ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻴﺮ‬ ‫ﺗﻌﺒ‬ ‫ﻲ‬ ‫ﻓ‬،‫ﺎن‬ ‫ﻓ‬a
++a;
A++;
A=a+1;
--a;
a--;
A=a-1;

‫ﻴﺮ‬ ‫اﻟﺘﻌﺒ‬ ‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﺘﺨﺮاج‬ ‫اﺳ‬ ‫ﺒﻞ‬ ‫ﻗ‬ ‫ﺰداد‬ ‫ﺗ‬،‫ﺔ‬ ‫ﺣﺎﻟ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻨﻤﺎ‬ ‫ﺑﻴ‬a++‫ﻴﺮ‬ ‫اﻟﺘﻌﺒ‬ ‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﺘﺨﺮج‬ ‫ﺗﺴ‬
‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﺘﻌﻤﺎل‬‫ﺑﺎﺳ‬a‫ﺪار‬‫ﺑﻤﻘ‬ ‫ﺎ‬‫زﻳﺎدﺗﻬ‬ ‫ﺒﻞ‬‫ﻗ‬ ‫ﻴﺔ‬‫اﻟﺤﺎﻟ‬1،‫ز‬ ‫ﺘﻢ‬‫ﺗ‬ ‫ﻚ‬‫ذﻟ‬ ‫ﺪ‬‫وﺑﻌ‬‫ﺎدة‬‫ﻳ‬a‫ﺪار‬‫ﺑﻤﻘ‬1‫آي‬
‫ﻢ‬‫ﺗﻘﺪﻳ‬ ‫ﻊ‬‫ﺟﻤ‬ ‫ﻰ‬‫اﻷوﻟ‬ ‫ﻴﺔ‬‫اﻟﻌﻤﻠ‬ ‫أن‬،‫ﻴﺮ‬‫ﺗﺄﺧ‬ ‫ﻊ‬‫ﺟﻤ‬ ‫ﻴﺔ‬‫واﻟﺜﺎﻧ‬،‫ﻋﻠﻰ‬ ‫أﻳﻀﺎ‬ ‫اﻟﻜﻼم‬ ‫ﻫﺬا‬ ‫وﻳﻨﻄﺒﻖ‬–
a‫و‬a--.
‫ﻣﺜﺎل‬:
‫اﻟﺠﻤﻠﺘﻴﻦ‬ ‫ﻛﺘﺎﺑﺔ‬ ‫وﺑﺈﻣﻜﺎﻧﻚ‬:
Int x,y,z
X=y=z=0
‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫واﺣﺪ‬ ‫ﺟﻤﻠﺔ‬ ‫ﻓﻲ‬:
Int x=y=z=0
Int x,y,x;
X=y=x=0;
X=++y + ++z;
X=y++ + z++;
X=++y + z++;
X=y-- +--z;
‫ﺟﻤﻊ‬ ‫أوﻟﻴﺔ‬1‫إﻟﻰ‬z‫ﺗﺄﺗﻲ‬
‫ﺟﻤﻌﻬﺎ‬ ‫ﻳﺘﻢ‬ ‫إذ‬ ‫ﻣﺘﺎﺧﺮه‬
‫إﻟﻰ‬ ‫أوﻻ‬x
‫ﺟﻤﻊ‬1‫إﻟﻰ‬y‫ﺑﻌﺪ‬ ‫ﻣﺆﺟﻞ‬
‫إﻟﻰ‬ ‫اﻷوﻟﻰ‬ ‫ﻗﻴﻤﺘﻬﺎ‬ ‫إﻋﻄﺎء‬
x
‫ﺗﻜﻮن‬ ‫اﻟﺤﺎﻟﺔ‬ ‫ﻫﺬه‬ ‫ﻓﻲ‬x=1 , z=1 , y=1
‫ﺗﻜﻮن‬ ‫اﻟﺤﺎﻟﺔ‬ ‫ﻫﺬه‬ ‫ﻓﻲ‬x=2 , y=2 , z=2
‫ﻻن‬x،‫ﻗﻴﻤﺘﻲ‬ ‫ﺗﺠﻤﻊ‬z,y‫ﻛﻞ‬ ‫ﺗﺰداد‬ ‫أن‬ ‫ﻗﺒﻞ‬
‫ﺑﻤﻘﺪار‬ ‫ﻣﻨﻬﻤﺎ‬1
‫اﻵن‬x=3 , y=3 , z=3
‫ﻻن‬x‫ﺗﺠﻤﻊ‬y‫آﺧﺮ‬ ‫وﺗﺠﻤﻊ‬ ‫زﻳﺎدﺗﻬﺎ‬ ‫ﺑﻌﺪ‬z‫أن‬ ‫ﻗﺒﻞ‬
‫ﺗﺰداد‬1
‫اﻵن‬x=5 , y=2 , z=1

‫اﻟﺤﺴﺎﺑﻴﺔ‬ ‫ﻟﻸدوات‬ ‫اﻟﻌﻤﻠﻴﺎت‬ ‫أوﻟﻴﺔ‬Precedence of
thmetic OperationsAri
‫ﺘﺮﺟﻢ‬ ‫ﻣ‬ ‫ﺮﻳﻬﺎ‬ ‫ﻳﺠ‬ ‫ﺎ‬ ‫ﻛﻤ‬ ‫ﻴﺎت‬ ‫اﻟﻌﻤﻠ‬ ‫ﻴﺬ‬ ‫ﺗﻨﻔ‬ ‫ﻴﺔ‬ ‫أوﻟ‬ ‫أن‬ ‫ﻮل‬ ‫اﻟﻘ‬ ‫ﻦ‬ ‫ﻳﻤﻜ‬C++‫ﻸدوات‬ ‫ﻟ‬ ‫ﺒﺔ‬ ‫ﺑﺎﻟﻨﺴ‬
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫ﻫﻲ‬ ‫اﻟﺤﺴﺎﺑﻴﺔ‬:
‫اﻷوﻟﻮﻳﺔ‬ ‫رﻗﻢ‬ ‫اﻷداة‬
1 ++‫أو‬--
2 -
3 *‫أو‬/‫أو‬%
4 +‫أو‬-
5 =
6 ++‫أو‬--)‫اﻟﻌﺪد‬ ‫ﺑﻌﺪ‬ ‫اﻟﻤﺘﺄﺧﺮة‬(
‫اﻟﺠﺪول‬٤-١
‫ﻣﻠﺤﻮﻇﺔ‬:
‫ﻴﺮ‬‫ﺗﻌﺒ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺮح‬ ‫واﻟﻄ‬ ‫ﻊ‬‫اﻟﺠﻤ‬ ‫ﺜﻞ‬‫ﻣ‬ ‫ﺘﺎن‬‫أوﻟﻴ‬ ‫ﺎوت‬‫ﺗﺴ‬ ‫إذا‬،‫ﺎر‬‫ﻳﺴ‬ ‫ﻰ‬‫إﻟ‬ ‫ﺮب‬‫اﻷﻗ‬ ‫ﻴﺔ‬‫اﻟﻌﻤﻠ‬ ‫ﺘﻘﺪم‬ ‫ﻓ‬
‫ﻴﺮ‬‫اﻟﺘﻌﺒ‬،‫ﻲ‬ ‫ﻓ‬ ‫ﻰ‬‫اﻷوﻟ‬ ‫ﺔ‬‫اﻷوﻟﻮﻳ‬ ‫ﺄﺧﺬ‬‫ﺗ‬ ‫ﻮاس‬‫اﻷﻗ‬ ‫ﺎن‬‫ﻓ‬ ‫ﻴﺮ‬‫ﺗﻌﺒ‬ ‫ﻷي‬ ‫ﻮاس‬‫اﻷﻗ‬ ‫ﺘﻌﻤﺎل‬‫اﺳ‬ ‫ﻨﺪ‬‫وﻋ‬
‫ﺒﻞ‬‫ﻗ‬ ‫ﻴﺬ‬‫اﻟﺘﻨﻔ‬)‫ﺎن‬‫اﻟﻨﻘﺼ‬ ‫أو‬ ‫ﺰﻳﺎدة‬‫اﻟ‬(،‫ﺮى‬‫اﻷﺧ‬ ‫ﺒﺮﻣﺠﺔ‬‫اﻟ‬ ‫ﺎت‬‫ﻟﻐ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺎ‬‫ﻛﻤ‬،‫اﻵﺗﻴﺔ‬ ‫واﻷﻣﺜﻠﺔ‬
‫اﻷوﻟﻮﻳﺔ‬ ‫ﻣﻔﻬﻮم‬ ‫ﺗﺒﻴﻦ‬)‫اﻷﺳﺒﻘﻴﺔ‬:(-
‫اﻟﺘﺎﻟﻴﺔ‬ ‫واﻟﺨﻄﻮات‬ ‫اﻟﺸﻜﻞ‬ ‫ﻋﻤﻠﻴﺎﺗﻪ‬ ‫أوﻟﻮﻳﺎت‬ ‫ﺗﺴﻠﺴﻞ‬ ‫ﻳﺄﺧﺬ‬:-
١-‫اﻷوﻟﻰ‬ ‫اﻟﻌﻤﻠﻴﺔ‬:‫اﻟﻘﺴﻤﺔ‬y / z
٢-‫اﻟﺜﺎﻧﻴﺔ‬ ‫اﻟﻌﻤﻠﻴﺔ‬:(y/z)*a
٣-‫اﻟﺜﺎﻟﺜﺔ‬ ‫اﻟﻌﻤﻠﻴﺔ‬:‫اﻟﻨﺎ‬ ‫ﺟﻤﻊ‬‫اﻟﺨﻄﻮة‬ ‫ﻓﻲ‬ ‫ﺗﺞ‬2‫إﻟﻰ‬x‫اﻟﻨﺘﻴﺠﺔ‬ ‫ﻓﺘﻜﻮن‬:
X + y / z * z
‫ﻦ‬‫اﻟﻴﻤﻴ‬ ‫ﻰ‬‫إﻟ‬ ‫ﺎر‬‫اﻟﻴﺴ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺎﺑﻴﺔ‬‫اﻟﺤﺴ‬ ‫ﻴﺎت‬‫اﻟﻌﻠﻤ‬ ‫ﺮاء‬‫ﺑﺈﺟ‬ ‫ﺎ‬‫ﺑﺪأﻧ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﻆ‬‫ﻻﺣ‬،‫وﻟﻮﻳ‬ ‫أﻻ‬ ‫ﻰ‬‫وﺗﻌﻄ‬‫ﻪ‬
‫ﺔ‬‫اﻷوﻟﻮﻳ‬ ‫ﺎﻋﺪة‬‫ﻗ‬ ‫ﺐ‬‫ﺣﺴ‬ ‫ﻴﺔ‬‫ﻋﻤﻠ‬ ‫ﺔ‬‫ﻷﻳ‬،‫ﻤﺔ‬‫اﻟﻘﺴ‬ ‫ﺎءت‬‫ﻓﺠ‬،‫اﻟﺠﻤﻊ‬ ‫ﺒﻞ‬‫ﻗ‬ ‫ﺜﺎل‬‫اﻟﻤ‬ ‫ﻲ‬‫ﻓ‬،‫ﺟﺎء‬ ‫ﻛﻤﺎ‬
‫ﻋﻤﻠﻴﺔ‬ ‫ﻛﺄﺧﺮ‬ ‫اﻟﺠﻤﻊ‬ ‫ذﻟﻚ‬ ‫وﺗﻼ‬ ‫اﻟﻘﺴﻤﺔ‬ ‫ﺑﻌﺪ‬ ‫اﻟﻀﺮب‬.
‫اﻟﻨﻘﺼﺎن‬ ‫أو‬ ‫اﻟﺰﻳﺎدة‬
‫اﻟﺴﺎﻟﺒﺔ‬ ‫اﻹﺷﺎرة‬
‫اﻟﺒﺎﻗﻲ‬ ‫أو‬ ‫اﻟﻘﺴﻤﺔ‬ ‫أو‬ ‫اﻟﻀﺮب‬
‫اﻟﻄﺮح‬ ‫أو‬ ‫اﻟﺠﻤﻊ‬
‫اﻟﻤﺴﺎواة‬
‫ﺑﻤﻘﺪار‬ ‫ﻧﻘﺼﺎن‬ ‫أو‬ ‫زﻳﺎدة‬1
X + y / z * a

‫اﻷد‬‫واﻟﻤﻨﻄﻘﻴﺔ‬ ‫اﻟﻌﻼﻗﻴﺔ‬ ‫وات‬Relational and Logical
Operations
‫ﻮ‬ ‫وﻫ‬ ‫ﺎت‬ ‫ﻋﻼﻗ‬ ‫ﻨﻬﺎ‬ ‫ﺑﻴ‬ ‫ﻲ‬ ‫اﻟﺘ‬ ‫ﻴﻢ‬ ‫ﺑﺎﻟﻘ‬ ‫ﺔ‬ ‫اﻟﻤﺨﺘﺼ‬ ‫ﻴﺎت‬ ‫اﻟﻌﻤﻠ‬ ‫ﻰ‬ ‫إﻟ‬ ‫ﻴﺔ‬ ‫اﻟﻌﻼﻗ‬ ‫اﻷدوات‬ ‫ﻢ‬ ‫اﺳ‬ ‫ﺮﺟﻊ‬ ‫ﻳ‬
‫ﺰﻳﺔ‬‫رﻣ‬ ‫أو‬ ‫ﺎﺑﻴﺔ‬‫ﺣﺴ‬ ‫ﻴﺎت‬‫ﻛﻤ‬ ‫ﻦ‬‫ﺑﻴ‬ ‫ﻴﺔ‬‫ﻣﻨﻄﻘ‬ ‫ﺔ‬‫ﻣﻘﺎرﻧ‬ ‫ﻴﺎت‬‫ﻋﻤﻠ‬ ‫ﺮاء‬‫أﺟ‬،‫ﻣﻨﻄﻘﻴﺔ‬ ‫ﻧﺘﻴﺠﺘﻪ‬ ‫ﻮن‬‫وﺗﻜ‬
‫ﻢ‬ ‫ﻧﻌ‬ ‫ﺎ‬ ‫أﻣ‬ ‫ﻲ‬ ‫وﻫ‬(true)‫أو‬(false)،‫اﻟ‬ ‫ﺘﺨﺪام‬ ‫اﺳ‬ ‫ﺜﺮ‬ ‫وﻳﻜ‬‫ﻞ‬ ‫اﻟﺠﻤ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻴﺔ‬ ‫اﻟﻤﻨﻄﻘ‬ ‫ﻴﺮ‬ ‫ﺘﻌﺎﺑ‬
‫اﻟﺸﺮﻃﻴﺔ‬،‫اﻟﻤﻨﻄﻘﻲ‬ ‫اﻟﺘﻌﺒﻴﺮ‬ ‫ﻫﻮ‬ ‫ﻣﺎ‬ ‫ﻟﻚ‬ ‫ﺗﺒﻴﻦ‬ ‫اﻵﺗﻴﺔ‬ ‫واﻷﻣﺜﻠﺔ‬:
‫اﻟﻤﻨﻄﻘﻲ‬ ‫اﻟﺘﻌﺒﻴﺮ‬:x= =y‫ﻻ‬ ‫أو‬ ‫ﻧﻌﻢ‬ ‫أﻣﺎ‬ ‫ﺟﻮاب‬.
‫اﻟﻤﻨﻄﻘﻲ‬ ‫واﻟﺘﻌﺒﻴﺮ‬:matrix > 100.0‫ﻻ‬ ‫أو‬ ‫ﻧﻌﻢ‬ ‫أﻣﺎ‬ ‫ﺟﻮاب‬.
‫ﺔ‬ ‫ﻟﻐ‬ ‫ﻲ‬ ‫وﻓ‬C++‫ﻻ‬ ‫ﻴﺠﺔ‬ ‫اﻟﻨﺘ‬ ‫ﺎﻣﻞ‬ ‫ﺗﻌ‬(false)‫ﻔﺮ‬ ‫ﺻ‬ ‫ﺎ‬ ‫أﻧﻬ‬ ‫ﻰ‬ ‫ﻋﻠ‬(0)‫ﻢ‬ ‫ﻧﻌ‬ ‫ﻴﺠﺔ‬ ‫اﻟﻨﺘ‬ ‫ﺄﺧﺬ‬ ‫وﺗ‬
(true)‫أﻧﻬﺎ‬ ‫واﻟﻤﺸﻬﻮر‬ ‫اﻟﺼﻔﺮ‬ ‫ﻏﻴﺮ‬ ‫ﻗﻴﻤﺔ‬ ‫أﻳﺔ‬(1).
‫واﻟﻤﻨﻄﻘﻴﺔ‬ ‫اﻟﻌﻼﻗﻴﺔ‬ ‫اﻷدوات‬ ‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺠﺪول‬ ‫ﻟﻨﺎ‬ ‫وﻳﺒﻴﻦ‬:
‫اﻟﻌﻼﻗﻴﺔ‬ ‫اﻷدوات‬
‫ﻣﻌﻨﺎﻫﺎ‬ ‫اﻷداة‬
‫ﻣﻦ‬ ‫اﻛﺒﺮ‬ >
‫ﻣﻦ‬ ‫اﺻﻐﺮ‬ <
‫ﻳﺴﺎوي‬ ‫أو‬ ‫ﻣﻦ‬ ‫اﻛﺒﺮ‬ =>
‫ﻳﺴﺎوي‬ ‫أو‬ ‫ﻣﻦ‬ ‫اﺻﻐﺮ‬ =<
‫ﻳﺴﺎوي‬ = =
‫ﻳﺴﺎوي‬ ‫ﻻ‬ !=
‫اﻟﺠﺪول‬٥-١
‫اﻟﻤﻨﻄﻘﻴﺔ‬ ‫اﻷدوات‬
‫ﻣﻌﻨﺎﻫﺎ‬ ‫اﻷد‬‫اة‬
And)‫واو‬ ‫اﻟﻌﻄﻒ‬ ‫ﺣﺮف‬( &&
Or)‫أو‬ ‫اﻟﻌﻄﻒ‬ ‫ﺣﺮف‬( ||
Not)‫ﻟﻠﻨﻔﻲ‬(‫أﺣﺎدﻳﺔ‬ ‫أداة‬unary !
‫اﻟﺠﺪول‬٦-١
‫اﻷﻣﺜﻠﺔ‬ ‫ﻫﺬه‬ ‫اﻵن‬ ‫إﻟﻴﻚ‬:‫أن‬ ‫اﻓﺮض‬int a=b=3;
‫اﻟﺘﻌﺒﻴﺮ‬ ‫ﻓﺎن‬a < 3‫ﻧﺘﻴﺠﺘﻪ‬false‫أي‬0
‫اﻟﺘﻌﺒﻴﺮ‬a<=3‫ﻧﺘﻴﺠﺘﻪ‬true‫أي‬1
‫اﻟﺘﻌﺒﻴﺮ‬a>b‫ﻧﺘﻴﺠﺘﻪ‬false‫أي‬0
‫اﻟﺘﻌﺒﻴﺮ‬a!=b‫ﻧﺘﻴﺠﺘﻪ‬false‫أي‬0
‫اﻟﺘﻌﺒﻴﺮ‬a= = b‫ﻧﺘﻴﺠﺘﻪ‬true‫أي‬1

‫اﻟﺼﺪق‬ ‫ﺟﺪول‬‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﺠﺪول‬ ‫ﻫﺬا‬ ‫ﻧﺴﻮق‬ ‫ﺳﻮف‬:-
‫اﻟﻨﻔﻲ‬ ‫ﺟﺪول‬
!x (not x)
‫اﻟﺘﺨﻴﻴﺮ‬ ‫ﺟﺪول‬
X||y (x or y)
‫اﻟﺠﻤﻊ‬ ‫ﺟﺪول‬
X && y (x and y)
x !y x Y X||y X Y X&&y
F T F F F F F F
T F F T T F T F
T F T T F F
T T T T T T
‫اﻟﺠﺪول‬٧-١
!!‫أﻋﻼه‬ ‫واﻟﻨﻔﻲ‬ ‫واﻟﺘﺨﻴﻴﺮ‬ ‫اﻟﺠﻤﻊ‬ ‫ﺟﺪاول‬ ‫ﻓﻬﻢ‬ ‫ﻋﻠﻰ‬ ‫اﻟﻤﺴﺎﻋﺪة‬:-
‫اﻟﺠﻤﻊ‬ ‫ﺟﺪول‬:
‫أن‬ ‫ﻴﻞ‬‫ﺗﺨ‬F‫ﻢ‬‫اﻟﺴ‬ ‫ﺜﻞ‬‫ﺗﻤ‬،‫وان‬T‫ﻞ‬‫اﻟﻌﺴ‬ ‫ﺜﻞ‬‫ﺗﻤ‬،‫ﻓﺎن‬ ‫ذﻟﻚ‬ ‫ﻋﻠﻰ‬ ‫وﺑﻨﺎء‬F&&T‫ﺳﻤﺎ‬ ‫ﺗﻌﻨﻲ‬
‫أي‬ ‫ﻢ‬‫ﺳ‬ ‫ﻴﺠﺔ‬‫واﻟﻨﺘ‬ ‫ﻢ‬‫ﺳ‬ ‫ﻊ‬‫ﻣ‬F،‫ﻚ‬‫ﻛﺬﻟ‬F&&T‫ﻲ‬‫ﺗﻌﻨ‬‫ﻢ‬‫ﺳ‬ ‫ﻴﺠﺔ‬‫واﻟﻨﺘ‬ ‫ﻞ‬‫اﻟﻌﺴ‬ ‫ﻊ‬‫ﻣ‬ ‫ﻢ‬‫اﻟﺴ‬ ‫ﻂ‬‫ﺧﻠ‬
‫أي‬F،‫ﻚ‬ ‫وﻛﺬﻟ‬T&&F‫ﻨﻬﺎ‬ ‫ﻋ‬ ‫ﺘﺞ‬ ‫ﻳﻨ‬F‫ﺎ‬ ‫أﻣ‬T&&T‫أن‬ ‫أي‬ ‫ﻞ‬ ‫ﻋﺴ‬ ‫ﻰ‬ ‫ﻋﻠ‬ ‫ﻞ‬ ‫ﻋﺴ‬ ‫ﻲ‬ ‫ﻓﻬ‬
‫اﻟﻨﺘﻴﺠﺔ‬T.
‫اﻟﺘﺨﻴﻴﺮ‬ ‫ﺟﺪول‬:
‫ﻢ‬‫اﻟﺴ‬ ‫ﻦ‬‫ﺑﻴ‬ ‫ﻴﺮت‬‫ﺧ‬ ‫ﻮ‬‫ﻓﻠ‬F‫ﻢ‬‫واﻟﺴ‬FF||F‫ﺮوﻓﻪ‬‫ﻣﻌ‬ ‫ﻴﺠﺔ‬‫ﻓﺎﻟﻨﺘ‬F‫ﻞ‬‫واﻟﻌﺴ‬ ‫ﻢ‬‫اﻟﺴ‬ ‫ﻦ‬‫ﺑﻴ‬ ‫ﺎ‬‫أﻣ‬
F||T‫ﻋﺴﻞ‬ ‫ﻟﻠﻨﺠﺎة‬ ‫ﺑﺎﻟﻄﺒﻊ‬ ‫ﺗﻜﻮن‬ ‫ﺳﻮف‬ ‫ﻓﺎﻟﻨﺘﻴﺠﺔ‬T،‫وﻧﺘﻴﺠﺔ‬T||T‫ﻋﺴﻞ‬ ‫ﻫﻲ‬T...

‫اﻟﺪﻗﻴﻘﺔ‬ ‫اﻷدوات‬Bowties Operators
‫ﺔ‬‫ﻟﻐ‬ ‫ﻴﺰ‬‫ﺗﺘﻤ‬C++‫ﺘﺨﺪم‬‫ﺗﺴ‬ ‫ﺎ‬‫أﻧﻬ‬ ‫ﻜﺎل‬‫وﺑﺎﺳ‬ ‫ﻚ‬‫ﺑﻴﺴ‬ ‫ﻴﺠﻮال‬‫ﻓ‬ ‫ﺜﻞ‬‫ﻣ‬ ‫ﻴﺔ‬ ‫اﻟﺮاﻗ‬ ‫ﺎت‬‫اﻟﻠﻐ‬ ‫ﺎﺋﺮ‬‫ﺳ‬ ‫ﻦ‬‫ﻋ‬
‫ﻴﺔ‬‫اﻷوﻟ‬ ‫ﻦ‬ ‫اﻟﺘﺨﺰﻳ‬ ‫ﺪة‬ ‫وﺣ‬ ‫ﺘﻮى‬‫ﻣﺴ‬ ‫ﻰ‬‫ﻋﻠ‬ ‫ﻴﻘﺔ‬ ‫دﻗ‬ ‫أدوات‬[Bit]‫ﻦ‬ ‫ﻣ‬ ‫ﺮة‬ ‫واﻟﻤﺨﺘﺼ‬Binary
Digit*
‫أدوات‬ ‫أو‬ ‫ﻴﻘﺔ‬‫ﺑﺎﻟﺪﻗ‬ ‫اﻷدوات‬ ‫ﺬه‬‫ﻫ‬ ‫ﻤﻴﺖ‬‫ﺳ‬)‫ﺖ‬‫اﻟﺒ‬(‫ﺎ‬‫ﻷﻧﻬ‬‫ﻣﻊ‬ ‫ﺘﻌﺎﻣﻞ‬‫ﺗ‬[bit])‫اﻟﺘﺨﺰﻳﻦ‬ ‫وﺣﺪة‬
‫ﻴﺔ‬‫اﻷوﻟ‬(‫ﺮة‬‫ﻣﺒﺎﺷ‬،‫ﺎ‬‫ﻓﺤﺼ‬،‫ﺒﻄﺎ‬‫وﺿ‬،‫ﺔ‬‫وإزاﺣ‬،‫اﻟﻤﻌﻄﻴﺎت‬ ‫ﻣﻊ‬ ‫اﻷدوات‬ ‫ﺬه‬‫ﻫ‬ ‫ﺘﻌﻤﻞ‬‫وﺗﺴ‬
‫اﻟﺼﺤﻴﺤﺔ‬int‫واﻟﺮﻣﺰﻳﺔ‬char‫ﻓﻘﻂ‬،‫اﻟﻤﻌﻄﻴﺎت‬ ‫أﻧﻮاع‬ ‫ﻣﻦ‬ ‫ﻏﻴﺮﻫﺎ‬ ‫ﻣﻊ‬ ‫ﺗﺴﺘﻌﻤﻞ‬ ‫وﻻ‬..
‫ﻣﻨﻬﺎ‬ ‫ﻛﻞ‬ ‫ووﻇﻴﻔﺔ‬ ‫اﻟﺪﻗﻴﻘﺔ‬ ‫اﻷدوات‬ ‫ﻳﺒﻴﻦ‬ ‫اﻟﺘﺎﻟﻲ‬ ‫واﻟﺠﺪول‬:
‫ﻋﻤﻠﻬﺎ‬ ‫اﻷداة‬
(not)‫أ‬ ‫آداه‬‫ﺣﺎدﻳﺔ‬ ~
(and)‫اﻟﻮاو‬ ‫ﺣﺮف‬)‫و‬( &
(or)‫اﻟﻌﻄﻒ‬ ‫ﺣﺮف‬)‫و‬( |
‫اﻟﻴﺴﺎر‬ ‫إﻟﻰ‬ ‫إزاﺣﺔ‬ >>
‫اﻟﻴﻤﻴﻦ‬ ‫إﻟﻰ‬ ‫إزاﺣﺔ‬ <<
(xor))‫أو‬(‫اﻻﺳﺘﺜﻨﺎﺋﻴﺔ‬ ^
‫اﻟﺠﺪول‬٨-١
‫اﻷدوات‬ ‫ﻣﻦ‬ ‫وﻛﻐﻴﺮﻫﺎ‬،‫اﻟﺘﺮﺗﻴﺐ‬ ‫وﺣﺴﺐ‬ ‫اﻷوﻟﻴﺔ‬ ‫ﻗﻮاﻋﺪ‬ ‫ﺗﺘﺒﻊ‬ ‫اﻟﺪﻗﻴﻘﺔ‬ ‫اﻷدوات‬ ‫ﻓﺎن‬
‫اﻟﺘﺎﻟﻲ‬:
‫أوﻟﻮﻳﺘﻬﺎ‬ ‫اﻷداة‬
‫اﻷوﻟﻰ‬ ~
‫اﻟﺜﺎﻧﻴﺔ‬ <<‫أو‬>>
‫اﻟﺜﺎﻟﺜﺔ‬ &
‫اﻟﺮاﺑﻌﺔ‬ ^
‫اﻟﺨﺎﻣﺴﺔ‬ |
‫اﻟﺠﺪول‬٩-١

‫اﻟﻨﻔﻲ‬ ‫أداة‬)~(
‫ﻔﺮ‬‫اﻟﺼ‬ ‫ﺪال‬‫إﺑ‬ ‫ﻰ‬‫ﻋﻠ‬ ‫اﻷداة‬ ‫ﺬه‬‫ﻫ‬ ‫ﻞ‬‫ﺗﻌﻤ‬(0)‫ﺪ‬‫ﺑﻮاﺣ‬(1)‫ﺲ‬‫اﻟﻌﻜ‬ ‫أو‬،‫ﺗﻀﻊ‬ ‫أﻧﻬﺎ‬ ‫ﺬا‬‫ﻫ‬ ‫ﻨﻰ‬‫وﻣﻌ‬
0‫ﺎن‬ ‫ﻣﻜ‬1‫ﻚ‬ ‫وﻛﺬﻟ‬1‫ﺎن‬ ‫ﻣﻜ‬0،‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﻨﺎ‬ ‫ﻟﺪﻳ‬ ‫ﺎن‬ ‫ﻛ‬ ‫ﻮ‬ ‫ﻟ‬ ‫ﺜﻼ‬ ‫ﻓﻤ‬x‫ﺪدي‬ ‫اﻟﻌ‬ ‫ﻨﻈﺎم‬ ‫اﻟ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺜﻠﺔ‬ ‫ﻣﻤ‬
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺜﻨﺎﺋﻲ‬)‫ﻣﻦ‬8‫ﺑﺖ‬:(-
‫ﻗﻴﻤﺔ‬x
‫ﻗﻴﻤﺔ‬~x
‫ﻨﻰ‬‫وﻣﻌ‬~‫ﻲ‬‫اﻟﻨﻔ‬(not)‫ﺑﻴﻦ‬ ‫اﻟﺘﻀﺎد‬ ‫ﻨﺎ‬‫ﻫ‬ ‫ﻲ‬‫اﻟﻨﻔ‬ ‫ﻨﻰ‬‫وﻣﻌ‬0‫و‬1‫اﻟﺜﻨﺎﺋﻲ‬ ‫اﻟﻌﺪدي‬ ‫اﻟﻨﻈﺎم‬ ‫ﻓﻲ‬
،‫ﻨﻔﻰ‬‫ﺗ‬ ‫ﻨﺪﻣﺎ‬‫ﻓﻌ‬0‫ﻨﻪ‬‫ﻣ‬ ‫ﺪﻻ‬‫ﺑ‬ ‫ﺖ‬‫ﺗﺜﺒ‬1‫ﺤﻴﺢ‬‫ﺻ‬ ‫ﺲ‬‫واﻟﻌﻜ‬،‫اﻟﺴﺎﺑﻖ‬ ‫اﻟﻤﺜﺎل‬ ‫ﻟﻚ‬ ‫ﺤﻪ‬‫ﻳﻮﺿ‬ ‫ﺬا‬‫وﻫ‬
‫ﺗﻢ‬ ‫إذ‬)‫ﻧﻔﻲ‬(‫ﻗﻴﻤﺔ‬x‫ﻟﻴﺼﺒﺢ‬ ‫ﺑﺎﻟﺒﺖ‬~x‫ﻣ‬ ‫ﺟﻤﻴﻊ‬ ‫ﻓﻲ‬‫اﻟﺒﺖ‬ ‫ﻣﻦ‬ ‫ﻜﻮﻧﺎت‬.
01011000
01011000

‫اﻟﺠﻤﻊ‬ ‫أداة‬&
‫اﻟﺜﻨﺎﺋﻲ‬ ‫اﻟﻌﺪدي‬ ‫ﺑﺎﻟﻨﻈﺎم‬ ‫ﺗﻤﺜﻴﻠﻬﺎ‬ ‫ﻋﻨﺪ‬ ‫اﻟﻘﻴﻢ‬ ‫ﺟﻤﻊ‬ ‫ﻛﻴﻔﻴﺔ‬ ‫ﻳﻮﺿﺢ‬ ‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻤﺜﺎﻟﻲ‬:
‫اﻟﻌﻤﻠﻴﺔ‬x&y;
‫ﻗﻴﻤﺔ‬x‫اﻟﺜﻨﺎﺋﻲ‬ ‫ﺑﺎﻟﻨﻈﺎم‬
‫ﻗﻴﻤﺔ‬y‫اﻟﺜﻨﺎﺋﻲ‬ ‫ﺑﺎﻟﻨﻈﺎم‬
‫اﻟﻨﺎﺗ‬‫ﺞ‬X&Y;
‫ﻳﺠﻤﻊ‬ ‫ﺣﻴﺚ‬0+0‫وﻳﻌﻄﻲ‬0،‫وﻳﺠﻤﻊ‬0+1‫ﻟﻴﻌﻄﻲ‬0‫وﻳﺠﻤﻊ‬1+1‫وﻳﻌﻄﻲ‬1
FÙF&FF&TÙFT&TÙT)‫اﻟﺴﺎﺑﻘﺔ‬ ‫اﻟﺼﺪق‬ ‫ﺟﺪاول‬ ‫اﻧﻈﺮ‬(
‫اﻻﺧﺘﻴﺎر‬ ‫أداة‬|
‫ﻟﻘﻴﻤﺘﻲ‬ ‫اﻟﺴﺎﺑﻖ‬ ‫اﻟﻤﺜﺎل‬ ‫ﻣﻊ‬ ‫اﻻﺧﺘﻴﺎر‬ ‫أداة‬ ‫اﺳﺘﻌﻤﺎل‬ ‫أردﻧﺎ‬ ‫إذا‬X‫و‬y‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬x|y;
x
y
‫اﻟﻨﺎﺗﺞ‬x|y;
‫ﺑﻴﻦ‬ ‫اﻻﺧﺘﻴﺎر‬ ‫ﺣﻴﺚ‬0‫و‬1‫ﻫﻮ‬1،‫ﺑﻴﻦ‬ ‫واﻻﺧﺘﻴﺎر‬1‫و‬1‫ﻫﻮ‬1،‫وﺑﻴﻦ‬0‫و‬0‫ﻫﻮ‬0.
F|TÙTT|TÙTT|FÙT)‫اﻟﺴﺎﺑﻘﺔ‬ ‫اﻟﺼﺪق‬ ‫ﺟﺪاول‬ ‫اﻧﻈﺮ‬(
01011000
10010000
00010000
01011000
10010000
11011000

‫اﻻﺳﺘﺜﻨﺎﺋﻲ‬ ‫اﻻﺧﺘﻴﺎر‬ ‫أداة‬^
‫اﻷداة‬ ‫ﻫﺬه‬ ‫ﺗﺆﺛﺮ‬ ‫ﻛﻴﻒ‬ ‫ﻟﺘﺮى‬ ‫ﻧﻔﺴﺔ‬ ‫اﻟﺴﺎﺑﻖ‬ ‫اﻟﻤﺜﺎل‬ ‫ﺧﺬ‬
x
y
‫اﻟﻨﺎﺗﺞ‬x^y;
‫ﻦ‬‫ﺑﻴ‬ ‫ﻴﺎر‬‫اﻻﺧﺘ‬ ‫أن‬ ‫ﻆ‬‫ﻻﺣ‬0‫و‬0‫ﺘﻪ‬‫ﻧﺘﻴﺠ‬0،‫ﺑﻴﻦ‬ ‫ﻴﺎر‬‫واﻻﺧﺘ‬1‫و‬0‫ﻧﺘﻴﺠﺘﻪ‬1،‫وﺑﻴﻦ‬1‫و‬1
‫ﺘﻪ‬‫ﻧﺘﻴﺠ‬0،‫ﺘﺜﻨﺎﺋﻲ‬‫اﻻﺳ‬ ‫ﻴﺎر‬‫اﻻﺧﺘ‬ ‫أداة‬ ‫أن‬^(XOR)‫ﻴﺎر‬‫اﻻﺧﺘ‬ ‫أداة‬ ‫ﻦ‬‫ﻋ‬ ‫ﺘﻠﻒ‬‫ﺗﺨ‬| (OR)
‫ﺘﻬﺎ‬ ‫ﻧﺘﻴﺠ‬ ‫ﻮن‬ ‫ﺗﻜ‬ ‫إذ‬ ‫ﻴﺔ‬ ‫اﻟﺜﺎﻧ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺔ‬ ‫ﺧﺎﺻ‬ ‫ﺔ‬ ‫ﺣﺎﻟ‬ ‫ﻰ‬ ‫اﻷوﻟ‬ ‫أن‬ ‫ﻲ‬ ‫ﻓ‬true(1)‫ﺪ‬ ‫أﺣ‬ ‫ﻮن‬ ‫ﻳﻜ‬ ‫ﻨﺪﻣﺎ‬ ‫ﻋ‬
‫ﻴﺎر‬‫اﻻﺧﺘ‬ ‫ﻲ‬‫ﻃﺮﻓ‬x‫أو‬y‫ﺘﻪ‬‫ﻧﺘﻴﺠ‬true،‫ﺎ‬‫داﺋﻤ‬ ‫ﺘﻬﺎ‬‫ﻓﻨﺘﻴﺠ‬ ‫ﻚ‬‫ذﻟ‬ ‫ﺪا‬‫ﻋ‬ ‫ﺎ‬‫وﻣ‬false(0)،‫ﺎ‬‫ﻛﻤ‬
‫اﻟﻤﺜﺎل‬ ‫ﻫﺬا‬ ‫ﻓﻲ‬ ‫ﻻﺣﻈﺖ‬،‫اﻟﻌﺎم‬ ‫اﻻﺧﺘﻴﺎر‬ ‫ﺣﺎﻟﺔ‬ ‫ﻓﻲ‬ ‫أﻣﺎ‬(OR)‫ﻧﺘﻴﺠﺔ‬ ‫ﻓﺎن‬1|1‫ﻫﻲ‬1.
10010000
01011000
11001000

‫اﻹزاﺣﺔ‬ ‫أدوات‬>>‫و‬<<
‫ا‬ ‫اﻟﻤﺒﺮﻣﺞ‬ ‫ﻋﻠﻰ‬ ‫ﺒﺔ‬‫ﻏﺮﻳ‬ ‫ﺔ‬‫اﻹزاﺣ‬ ‫أدوات‬ ‫ﺒﺪو‬‫ﺗ‬ ‫ﺪ‬‫ﻗ‬‫ﻣﺜﻞ‬ ‫أﺧﺮى‬ ‫ﻟﻐﺎت‬ ‫ﻳﺴﺘﺨﺪم‬ ‫ﻟﺬي‬Basic‫و‬
Pascal..‫ـﺦ‬ ‫اﻟ‬.‫ﺤﻴﺢ‬ ‫اﻟﺼ‬ ‫ﻴﺮ‬ ‫اﻟﻤﺘﻐ‬ ‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﺔ‬ ‫إزاﺣ‬ ‫ﺎ‬ ‫إﺣﺪاﻫﻤ‬ ‫ﺘﻌﻤﺎل‬ ‫اﺳ‬ ‫ﻦ‬ ‫ﻋ‬ ‫ﺘﺞ‬ ‫ﻳﻨ‬ ‫ﺚ‬ ‫ﺣﻴ‬
‫ﻲ‬ ‫اﻟﺜﻨﺎﺋ‬ ‫ﻨﻈﺎم‬ ‫ﺑﺎﻟ‬)‫ﺖ‬ ‫ﺑﺎﻟﺒ‬(‫ﺐ‬ ‫اﻟﻄﻠ‬ ‫ﺐ‬ ‫ﺣﺴ‬ ‫ﺎت‬ ‫اﻟﺨﺎﻧ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺪدا‬ ‫ﻋ‬ ‫ﺎرا‬ ‫ﻳﺴ‬ ‫أو‬ ‫ﻨﺎ‬ ‫ﻳﻤﻴ‬،‫ﻼ‬ ‫وﺗﻤ‬
‫أﺻﻔﺎرا‬ ‫اﻟﻤﻮﺟﺒﺔ‬ ‫اﻟﺠﻬﺔ‬ ‫ﻣﻦ‬ ‫اﻟﻤﻔﺮﻏﺔ‬ ‫اﻟﺨﺎﻧﺎت‬،‫آﺣﺎدا‬ ‫ﺗﻤﻼ‬ ‫اﻟﺴﺎﻟﺒﺔ‬ ‫اﻟﺠﻬﺔ‬ ‫وﻣﻦ‬.
‫واﻷﻣﺜ‬‫اﻻﺳﺘﻌﻤﺎل‬ ‫ﻃﺮﻳﻘﺔ‬ ‫ﺗﻮﺿﺢ‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫ﻠﺔ‬.
‫ﻣﺜﺎل‬:
‫ﺔ‬‫اﻟﺠﻤﻠ‬x>>2;‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﻰ‬‫ﻋﻠ‬ ‫ﻴﺬﻫﺎ‬‫ﺗﻨﻔ‬ ‫ﻨﺪ‬‫ﻋ‬x)‫ﻲ‬‫وﻫ‬23‫اﻟﻌﺸﺮي‬ ‫ﺑﺎﻟﻨﻈﺎم‬(‫اﻟﺜﻨﺎﺋﻲ‬ ‫ﺑﺎﻟﻨﻈﺎم‬
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫ﺗﺘﻢ‬ ‫اﻟﻌﻤﻠﻴﺔ‬ ‫ﻓﺎن‬:
x
x>>2;
‫ﺧﺎﻧﺘﻴﻦ‬ ‫ﺑﻤﻘﺪار‬ ‫اﻹزاﺣﺔ‬ ‫ﻣﻦ‬ ‫اﻟﻨﺘﻴﺠﺔ‬)٢‫ﺑﺖ‬(‫ﻗﻴﻤﺘﻬﺎ‬ ‫ﺗﺼﺒﺢ‬ ‫ﻟﻠﻴﻤﻴﻦ‬:
5‫اﻟﻌﺸﺮي‬ ‫ﺑﺎﻟﻨﻈﺎم‬.
‫أن‬ ‫ﻳﻌﻨﻲ‬ ‫وﻫﺬا‬23>>2;‫اﻟﻨﺘﻴﺠﺔ‬ ‫ﺗﻌﻄﻲ‬5.
‫ﺣﻴﺚ‬23‫اﻟﻤﺰاﺣﺔ‬ ‫اﻟﻘﻴﻤﺔ‬.
2‫ﻟﻠﻴﻤﻴﻦ‬ ‫اﻟﻤﻄﻠﻮﺑﺔ‬ ‫اﻹزاﺣﺔ‬ ‫ﺧﺎﻧﺎت‬ ‫ﻋﺪد‬.
‫ﺑﻤﺼﻔﺮﻳﻦ‬ ‫ﻣﻠﺌﺘﺎ‬ ‫ﻗﺪ‬ ‫ﻟﻠﻴﻤﻴﻦ‬ ‫اﻹزاﺣﺔ‬ ‫ﺑﺴﺒﺐ‬ ‫اﻟﻤﻔﺮﻏﺘﻴﻦ‬ ‫اﻟﺨﺎﻧﺘﻴﻦ‬ ‫أن‬ ‫ﻻﺣﻆ‬.
11101000
10100000

‫ﺳﺎﻟﺒﺔ‬ ‫ﻗﻴﻤﺔ‬ ‫إزاﺣﺔ‬ ‫ﻋﻠﻰ‬ ‫ﻣﺜﺎل‬:
Z = - 50<<2;
Z
Z<<3
‫إزاﺣﺔ‬)٢‫ﺑﺖ‬(‫ﻟﻠﻴﺴﺎر‬.
‫ﻴﻤﺔ‬ ‫اﻟﻘ‬ ‫ﺮﻏﺔ‬ ‫ﻣﻔ‬ ‫ﺔ‬ ‫ﺧﺎﻧ‬ ‫ﻞ‬ ‫ﻛ‬ ‫ﻦ‬ ‫ﻋ‬ ‫ﺘﺞ‬ ‫ﻳﻨ‬ ‫ﺎﻟﺒﺔ‬ ‫ﺳ‬ ‫ﻴﻤﺔ‬ ‫ﻟﻘ‬ ‫ﺔ‬ ‫اﻹزاﺣ‬ ‫أن‬ ‫ﺜﺎل‬ ‫اﻟﻤ‬ ‫ﺬا‬ ‫ﻫ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺪ‬ ‫اﻟﺠﺪﻳ‬1
‫وﻟﻴﺲ‬0‫اﻟﺴﺎﺑﻖ‬ ‫اﻟﻤﺜﺎل‬ ‫ﻓﻲ‬ ‫ﻛﻤﺎ‬.
11101000
11101000

‫ﺗﺬﻛﺮ‬ ‫ﻟﻢ‬ ‫أﺧﺮى‬ ‫أدوات‬Other Operations
‫اﻟﺸﺮﻃﻴﺔ‬ ‫اﻷداة‬the conditional operator
‫ﺗ‬ ‫اﻷداة‬ ‫ﺬه‬‫وﻫ‬‫ﺔ‬‫ﻟﻐ‬ ‫ﺎ‬‫ﺑﻬ‬ ‫ﻴﺰ‬‫ﺘﻤ‬c++‫ﻴﺮﻫﺎ‬‫ﻏ‬ ‫ﻦ‬‫ﻋ‬،‫ﻓﻲ‬ ‫ﻣﺸﻬﻮرة‬ ‫ﺷﺮﻃﻴﺔ‬ ‫ﺟﻤﻠﺔ‬ ‫ﻣﺤﻞ‬ ‫ﻞ‬‫ﺗﺤ‬ ‫إذ‬
‫ﻲ‬ ‫وﻫ‬ ‫ﻜﺎل‬ ‫وﺑﺎﺳ‬ ‫ﺮان‬ ‫وﻓﻮرﺗ‬ ‫ﻚ‬ ‫ﺑﻴﺴ‬if-then-else،‫ﺎ‬ ‫ﻷﻧﻬ‬ ‫ﻴﺔ‬ ‫ﺛﻼﺛ‬ ‫أداة‬ ‫اﻷداة‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﺒﺮ‬ ‫وﺗﻌﺘ‬
‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﻌﺎﻣﺔ‬ ‫ﺻﻴﻐﺘﻬﺎ‬ ‫ﺣﺴﺐ‬ ‫ﻛﻤﻴﺎت‬ ‫ﺛﻼث‬ ‫ﻣﻊ‬ ‫ﺗﺘﻌﺎﻣﻞ‬:
Expression1 ? Expression2: Expression3
‫ا‬ ‫اﻟﺸﺮﻃﻴﺔ‬ ‫اﻟﺠﻤﻠﺔ‬ ‫ﻟﺪﻳﻨﺎ‬ ‫ﻛﺎن‬ ‫ﻓﻠﻮ‬‫اﻟﻤﺜﺎل‬ ‫ﺳﺒﻴﻞ‬ ‫ﻋﻠﻰ‬ ‫ﻟﺘﺎﻟﻴﺔ‬:
‫ﻨﺎﻫﺎ‬ ‫ﻣﻌ‬:‫ﺮط‬ ‫اﻟﺸ‬ ‫ﻖ‬ ‫ﺗﺤﻘ‬ ‫إذا‬ ‫ﻪ‬ ‫اﻧ‬(b<c)‫ﻄﺮ‬ ‫اﻟﺴ‬ ‫ﻨﻔﺬ‬ ‫ﻓﻴ‬a=b،‫ﺎن‬ ‫ﻓ‬ ‫وإﻻ‬a=c‫ﺘﻌﻤﺎل‬ ‫وﺑﺎﺳ‬
‫ﺮة‬ ‫اﻟﻤﺨﺘﺼ‬ ‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﺎ‬ ‫ﻛﻠﻬ‬ ‫ﺮﻃﻴﺔ‬ ‫اﻟﺸ‬ ‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺪﻻ‬ ‫ﺑ‬ ‫ﺐ‬ ‫ﻧﻜﺘ‬ ‫أن‬ ‫ﻨﺎ‬ ‫ﻳﻤﻜﻨ‬ ‫؟‬ ‫ﺮﻃﻴﺔ‬ ‫اﻟﺸ‬ ‫اﻷداة‬
‫اﻟﺘﺎﻟﻴﺔ‬:
If (b<c)
A=b;
Else
A=c
A=(b<c) ? b:c
A=b
A=c
‫ﻓﺎن‬ ‫اﻟﺸﺮط‬ ‫ﺗﺤﻘﻖ‬ ‫إذا‬
‫اﻟﺸﺮط‬ ‫ﻳﺘﺤﻘﻖ‬ ‫ﻟﻢ‬ ‫إذا‬
‫ﻓﺎن‬

‫اﻟﻌﻨﻮﻧﺔ‬ ‫أداة‬)&(‫و‬(*)Pointer*the & and
Operator
‫ﺮ‬ ‫اﻟﻤﺆﺷ‬Pointer‫ﺮة‬ ‫اﻟﺬاﻛ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺮ‬ ‫اﻟﻤﺆﺷ‬ ‫ﻴﺮ‬ ‫اﻟﻤﺘﻐ‬ ‫ﻨﻮان‬ ‫ﻋ‬ ‫ﻮ‬‫ﻫ‬،‫ﺪ‬ ‫ﻓﻮاﺋ‬ ‫ﺮ‬ ‫اﻟﻤﺆﺷ‬ ‫ﻴﺮ‬ ‫وﻟﻠﻤﺘﻐ‬
‫اﷲ‬ ‫ﺈذن‬ ‫ﺑ‬ ‫ﺔ‬ ‫اﻟﻘﺎدﻣ‬ ‫ﻮل‬ ‫اﻟﻔﺼ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺎ‬ ‫ﻟﻬ‬ ‫ﺘﻌﺮض‬ ‫اﻟ‬ ‫ﻨﺪ‬ ‫ﻋ‬ ‫ﺮﻫﺎ‬ ‫ﻧﺬﻛ‬ ‫ﺒﺮﻣﺠﺔ‬ ‫اﻟ‬ ‫ﻴﺔ‬ ‫ﻋﻤﻠ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺔ‬ ‫ﺟﻤ‬،
‫اﻟﻤﺤ‬ ‫ﺮة‬ ‫اﻟﻤﺆﺷ‬ ‫ﻴﺮات‬ ‫اﻟﻤﺘﻐ‬ ‫ﻊ‬ ‫ﻣ‬ ‫ﻦ‬ ‫اﻟﺪاﻟﺘﻴ‬ ‫ﻦ‬ ‫ﻫﺎﺗﻴ‬ ‫ﺘﻌﻤﺎل‬ ‫اﺳ‬ ‫ﺜﺮ‬ ‫وﻳﻜ‬‫ﻦ‬ ‫أﻣﺎﻛ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺎ‬ ‫ﻟﻬ‬ ‫ﻮزة‬ ‫ﺠ‬
‫اﻟﺬاﻛﺮة‬ ‫ﻓﻲ‬ ‫ﺧﺎﺻﺔ‬.
‫اﻷداة‬ ‫ﺪ‬‫وﺗﻌ‬&‫أﺣﺎدﻳ‬ ‫أداة‬ ‫ﻨﺎ‬‫ﻫ‬‫ﺔ‬‫ﻓﻘﻂ‬ ‫واﺣﺪة‬ ‫ﻛﻤﻴﺔ‬ ‫ﻊ‬‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬‫ﺗ‬،‫ﻋﻨﻮان‬ ‫ﺑﺈﻋﻄﺎء‬ ‫ﺗﻘﻮم‬ ‫ﺣﻴﺚ‬
‫ﻟﻠﻤﻌﺎدﻟﺔ‬ ‫اﻷﻳﻤﻦ‬ ‫اﻟﻄﺮف‬،‫ﻣﻨﻬﺎ‬ ‫اﻷﻳﺴﺮ‬ ‫ﻟﻠﻄﺮف‬،‫اﻟﻌﻤﻠﻴﺔ‬ ‫ﻓﻤﺜﻼ‬:
‫ﻨﻮان‬‫ﻋ‬ ‫ﻲ‬‫ﺗﻌﻄ‬y‫ﺮة‬‫اﻟﺬاﻛ‬ ‫ﻲ‬‫ﻓ‬،‫ﻣﺨﺰن‬ ‫ﻲ‬‫ﻓ‬ ‫ﻌﻪ‬‫ووﺿ‬x،‫ﻋﻦ‬ ‫ﻃﺒﻌﺎ‬ ‫ﺗﺨﺘﻠﻒ‬ ‫اﻟﺠﻤﻠﺔ‬ ‫وﻫﺬه‬
‫ﺔ‬‫اﻟﺠﻤﻠ‬‫ﺎﺑﻴﺔ‬‫اﻟﺤﺴ‬x=y‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﻊ‬‫وﺿ‬ ‫ﻨﺎﻫﺎ‬‫ﻣﻌ‬ ‫ﻲ‬‫اﻟﺘ‬y‫ﺰن‬‫ﻣﺨ‬ ‫ﻲ‬‫ﻓ‬x‫اﺳﺘﻌﻤﺎل‬ ‫ﻨﺪ‬‫ﻋ‬ ‫ﺎ‬‫أﻣ‬&
‫ﺒﻞ‬‫ﻗ‬y‫ﺰن‬‫ﻣﺨ‬ ‫ﻨﻮان‬‫ﻋ‬ ‫ﺎء‬‫إﻋﻄ‬ ‫ﻨﺎﻫﺎ‬‫ﻓﻤﻌ‬y‫ﻴﺮ‬‫ﻟﻠﻤﺘﻐ‬ ‫ﻂ‬‫ﻓﻘ‬ ‫ﺮة‬‫اﻟﺬاﻛ‬ ‫ﻲ‬‫ﻓ‬x،‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﻴﺲ‬‫وﻟ‬y
‫ﺖ‬‫ﻛﺎﻧ‬ ‫ﻮ‬‫ﻓﻠ‬y=10،‫ﻢ‬‫ورﻗ‬)‫ﻨﻮان‬‫ﻋ‬(‫ﻫﻮ‬ ‫ﺮة‬‫اﻟﺬاﻛ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻌﻬﺎ‬‫ﻣﻮﺿ‬120،‫ﻓﺎن‬x‫ﻗﻴﻤﺔ‬ ‫ﺗﺄﺧﺬ‬
120‫ﺘﻌﻤﺎﻟﻨﺎ‬ ‫اﺳ‬ ‫ﻨﺪ‬ ‫ﻋ‬&‫ﻊ‬ ‫ﻣ‬y‫ﻸداة‬ ‫ﻟ‬ ‫ﺒﺔ‬ ‫وﺑﺎﻟﻨﺴ‬‫ﻴﺔ‬ ‫اﻟﺜﺎﻧ‬*‫ﺎ‬ ‫أﻳﻀ‬ ‫ﺔ‬ ‫أﺣﺎدﻳ‬ ‫أداة‬ ‫ﻲ‬ ‫ﻓﻬ‬،
‫ﻟﻸداة‬ ‫وﻣﻜﻤﻠﺔ‬، &‫اﻷداة‬ ‫ﺗﺴﺘﻌﻤﻞ‬ ‫اﻟﺘﻲ‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺠﻤﻠﺔ‬ ‫ﻟﺪﻳﻨﺎ‬ ‫ﻛﺎن‬ ‫ﻟﻮ‬ ‫وﻟﺬﻟﻚ‬. *
‫أن‬ ‫ﻨﻬﺎ‬‫ﻣ‬ ‫ﻢ‬‫ﻳﻔﻬ‬ ‫ﻪ‬‫ﻓﺎﻧ‬x‫ﻨﻮان‬‫ﻋ‬ ‫ﻮى‬‫ﺗﺤ‬)‫ﻊ‬‫ﻣﻮﻗ‬(‫ﻴﺮ‬‫اﻟﻤﺘﻐ‬y‫ﺮة‬‫اﻟﺬاﻛ‬ ‫ﻲ‬‫ﻓ‬،‫اﻟﺠﻤﻠﺔ‬ ‫ﺬه‬‫ﻫ‬ ‫وان‬
‫ﺰن‬‫ﻣﺨ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻊ‬‫ﺗﻀ‬s‫ﻴﺮ‬‫اﻟﻤﺘﻐ‬ ‫ﻴﻤﺔ‬‫ﻗ‬،‫اﻷﺻ‬ ‫اﻟﻤﺨﺰن‬ ‫ﺎﺣﺐ‬‫ﺻ‬‫ﻞ‬،‫ﻗﻴﻤﺔ‬ ‫آي‬y‫وﻫﻲ‬10‫ﻛﻤﺎ‬
‫ﺎﺑﻖ‬‫اﻟﺴ‬ ‫ﺜﺎل‬‫اﻟﻤ‬ ‫ﻲ‬‫ﻓ‬،‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﺎن‬‫ﻓ‬ ‫ﻲ‬‫وﺑﺎﻟﺘﺎﻟ‬10‫ﺰن‬‫ﻣﺨ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺰن‬‫ﺗﺨ‬s‫ﻊ‬‫اﻟﻤﻮﻗ‬ ‫ﻲ‬‫ﻓ‬)‫ﻨﻮان‬‫اﻟﻌ‬(
120‫ﺔ‬ ‫ﺟﻤﻠ‬ ‫أن‬ ‫ﺮى‬ ‫ﻧ‬ ‫ﻚ‬ ‫ﻟﺬﻟ‬x=*&y‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﺌﻬﺎ‬ ‫ﺗﻜﺎﻓ‬x=y‫ﻦ‬ ‫اﻷداﺗﻴ‬ ‫أن‬ ‫ﻲ‬ ‫ﻳﻌﻨ‬ ‫ﺬا‬ ‫وﻫ‬
‫ﻟﻸﺧﺮى‬ ‫ﻣﻌﻜﻮﺳﺔ‬ ‫اﻟﻮاﺣﺪة‬ ‫وﻛﺄن‬ ‫ﺗﻌﻤﻼن‬
‫ﻴﻪ‬ ‫إﻟ‬ ‫ﺒﺎه‬ ‫اﻻﻧﺘ‬ ‫ﺐ‬ ‫ﻳﺠ‬ ‫ﺎ‬ ‫وﻣﻤ‬،‫اﻷداة‬ ‫أن‬*‫ﻟﻌﻤ‬ ‫ﺎ‬ ‫أﻳﻀ‬ ‫ﺘﺨﺪم‬ ‫ﺗﺴ‬‫ﺎ‬ ‫ﻛﻤ‬ ‫ﺎﺑﻲ‬ ‫اﻟﺤﺴ‬ ‫ﺮب‬ ‫اﻟﻀ‬ ‫ﻴﺎت‬ ‫ﻠ‬
‫اﻷداة‬ ‫ﺘﻌﻤﻞ‬ ‫ﺗﺴ‬&‫ﺄداة‬ ‫ﻛ‬AND‫ﻴﻘﺔ‬ ‫دﻗ‬،‫ﺘﻌﻤﺎﻟﻴﻦ‬ ‫اﻻﺳ‬ ‫ﻦ‬ ‫ﺑﻴ‬ ‫ﺮ‬ ‫اﻷﻣ‬ ‫ﻴﻚ‬ ‫ﻋﻠ‬ ‫ﺒﺲ‬ ‫ﻳﻠﺘ‬ ‫ﻻ‬ ‫ﺬا‬ ‫وﻟ‬
‫اﻟﻤﺨﺘﻠﻔﻴﻦ‬.
X=&y;
S=*x;

‫اﻟﻄﻮل‬ ‫ﺗﻌﻴﻴﻦ‬ ‫أداة‬sizeof
‫ﺔ‬‫أﺣﺎدﻳ‬ ‫أداة‬ ‫اﻷداة‬ ‫ﺬه‬‫ﻫ‬ ‫ﺪ‬‫ﺗﻌ‬(unary)،‫ﻴﺮات‬‫اﻟﻤﺘﻐ‬ ‫ﻮل‬‫ﻃ‬ ‫ﻦ‬ ‫ﻟﺘﻌﻴﻴ‬ ‫ﺘﻌﻤﻞ‬‫وﺗﺴ‬)‫ﺖ‬‫ﺑﺎﻟﺒﺎﻳ‬(،
‫ﺎ‬‫أﻧﻮاﻋﻬ‬ ‫ﺐ‬‫ﺣﺴ‬ ‫ﻴﺮات‬‫اﻟﻤﺘﻐ‬ ‫ﻮال‬‫أﻃ‬ ‫ﺘﻠﻒ‬‫وﺗﺨ‬،‫ﻃ‬ ‫ﺬا‬ ‫وﻟ‬‫ﺘﻌﻤﺎل‬‫ﺑﺎﺳ‬ ‫ﻴﺮ‬‫ﻣﺘﻐ‬ ‫ﻮل‬‫ﻃ‬ ‫ﻦ‬ ‫ﺗﻌﻴﻴ‬ ‫ﺐ‬‫ﻠ‬
sizeof،‫ﻗﻮﺳﻲ‬ ‫ﺑﻴﻦ‬ ‫اﻟﻤﺘﻐﻴﺮ‬ ‫ﻫﺬا‬ ‫ﻧﻮع‬ ‫ذﻛﺮ‬ ‫ﻳﻨﺒﻐﻲ‬sizeof،‫ﻓﻤﺜﻼ‬:
‫ﻴﺠﺔ‬‫ﻧﺘ‬ ‫ﺘﻜﻮن‬‫ﺳ‬ ‫ﺚ‬‫ﺣﻴ‬n‫ﺎوي‬‫ﺗﺴ‬ ‫ﻨﺎ‬‫ﻫ‬2‫ﺖ‬‫ﺑﺎﻳ‬،‫اﻟﻤﺘﻐﻴﺮ‬ ‫ﻮل‬‫ﻃ‬ ‫ﻲ‬‫ﻫ‬n‫اﻟﺼﺤﻴﺢ‬(int)‫ﻻن‬
‫ﻫﻮ‬ ‫ﻋﺎدة‬ ‫اﻟﺼﺤﻴﺢ‬ ‫ﻃﻮل‬2‫ﺑﺎﻳﺖ‬،‫اﻟﺤﻘﻴﻘﻲ‬ ‫وﻃﻮل‬4‫ﺑﺎﻳﺖ‬،‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻤﺜﺎل‬ ‫ﻓﻲ‬ ‫ﻛﻤﺎ‬:
‫ﻧﺘﻴﺠﺔ‬ ‫ﺳﺘﻜﻮن‬ ‫ﺣﻴﺚ‬z‫ﻫﻲ‬4‫ﺑﺎﻳﺖ‬،‫ﻃﻮل‬ ‫وﻫﻲ‬x‫اﻟﺤﻘﻴﻘﻲ‬.
Int n;
N=sizeof (n);
Float x;
Z=sizeof (x);

‫اﻟﻔﺎﺻﻠﺔ‬),(‫ﻛﺄداة‬The Comma Operator
‫ﺘﺜﻨﺎﺋﻴﺔ‬‫اﺳ‬ ‫أداة‬ ‫ﻲ‬‫وﻫ‬(binary)‫وﺗﺄﺧﺬ‬ ‫اﻟﻤﺨﺘﻠﻔﺔ‬ ‫اﻷداة‬ ‫ﺳﻠﻢ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻴﺮة‬‫اﻷﺧ‬ ‫ﺔ‬‫اﻷوﻟﻮﻳ‬ ‫ﺘﻞ‬‫وﺗﺤ‬
‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﻌﺎﻣﺔ‬ ‫اﻟﺼﻴﻐﺔ‬:
Experssion1, Experssion2
‫ﺗﻌﺒﻴﺮﻳﻦ‬ ‫ﺑﻴﻦ‬ ‫ﻓﺎﺻﻠﺔ‬ ‫ﺗﻔﺼﻞ‬ ‫ﻓﻌﻨﺪﻣﺎ‬‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺘﺮﺗﻴﺐ‬ ‫ﻳﺄﺧﺬ‬ ‫اﻟﻌﻤﻠﻴﺎت‬ ‫ﺗﺴﻠﺴﻞ‬ ‫ﻓﺎن‬:
١-‫اﻷول‬ ‫اﻟﺘﻌﺒﻴﺮ‬ ‫ﻗﻴﻤﺔ‬ ‫ﺗﺴﺘﺨﺮج‬)‫اﻟﻔﺎﺻﻠﺔ‬ ‫ﻳﺴﺎر‬ ‫ﻋﻠﻲ‬(‫اﻟﺜﺎﻧﻲ‬ ‫ﻟﻠﺘﻌﺒﻴﺮ‬ ‫ﺗﻌﻄﻰ‬ ‫ﺛﻢ‬.
٢-‫ﻲ‬‫اﻟﺜﺎﻧ‬ ‫ﻴﺮ‬‫اﻟﺘﻌﺒ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﺘﺨﺮج‬‫ﺗﺴ‬)‫ﻠﺔ‬‫اﻟﻔﺎﺻ‬ ‫ﻦ‬‫ﻳﻤﻴ‬ ‫ﻲ‬‫ﻋﻠ‬(‫ﻪ‬‫ﻛﻠ‬ ‫ﻴﺮ‬‫ﻟﻠﺘﻌﺒ‬ ‫ﻴﺔ‬‫ﻧﻬﺎﺋ‬ ‫ﻴﻤﺔ‬‫ﻛﻘ‬
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻤﺜﺎل‬ ‫ﻓﻲ‬ ‫ﻛﻤﺎ‬:
‫ﻴﺮ‬‫اﻟﻤﺘﻐ‬ ‫ﻰ‬ ‫ﻳﻌﻄ‬ ‫ﺚ‬‫ﺣﻴ‬b‫ﻴﻤﺔ‬‫ﻗ‬2‫اﻷول‬ ‫ﻴﺮ‬‫اﻟﺘﻌﺒ‬ ‫ﻲ‬ ‫ﻓ‬)‫ﻠﺔ‬‫اﻟﻔﺎﺻ‬ ‫ﺎر‬‫ﻳﺴ‬(،‫ﺬه‬ ‫ﻫ‬ ‫ﻊ‬‫وﺿ‬ ‫ﻢ‬‫ﺛ‬
‫ﻲ‬‫ﻓ‬ ‫ﻴﻤﺔ‬‫اﻟﻘ‬b‫ﻲ‬‫اﻟﺜﺎﻧ‬ ‫ﻴﺮ‬‫اﻟﺘﻌﺒ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺮى‬‫اﻷﺧ‬)‫ﻠﺔ‬‫اﻟﻔﺎﺻ‬ ‫ﻦ‬‫ﻳﻤﻴ‬(،‫ﻋﻠﻰ‬ ‫اﻟﺘﻌﺒﻴﺮ‬ ‫ﻗﻴﻤﺔ‬ ‫ﺒﺢ‬‫ﻓﺘﺼ‬
‫اﻟﻴﻤﻴﻦ‬(b+1)‫ﺗﺴﺎوي‬3‫اﻟﻨﻬﺎﺋﻴﺔ‬ ‫اﻟﺘﻌﺒﻴﺮﻳﻦ‬ ‫ﻧﺘﻴﺠﺔ‬ ‫اﻟﻘﻴﻤﺔ‬ ‫ﻫﺬه‬ ‫وﺗﻜﻮن‬.
‫آﺧﺮ‬ ‫ﻣﺜﺎل‬:
‫ﺎء‬‫إﻋﻄ‬ ‫ﺘﻢ‬‫ﻳ‬ ‫ﺜﺎل‬‫اﻟﻤ‬ ‫ﺬا‬‫ﻫ‬ ‫ﻲ‬‫ﻓ‬b‫ﻴﻤﺔ‬‫اﻟﻘ‬8‫أوﻻ‬،‫اﻟ‬ ‫ﻄﺮ‬‫اﻟﺴ‬ ‫ﻴﺬ‬‫ﺗﻨﻔ‬ ‫ﻨﺪ‬‫ﻋ‬ ‫ﻢ‬‫ﺛ‬‫ﻲ‬‫ﺜﺎﻧ‬،‫ﻲ‬ ‫ﻳﻌﻄ‬b
‫ﻴﻤﺔ‬ ‫اﻟﻘ‬ ‫ﻴﻦ‬ ‫اﻟﻘﻮﺳ‬ ‫ﻞ‬ ‫داﺧ‬ ‫اﻷول‬ ‫ﻴﺮ‬ ‫اﻟﺘﻌﺒ‬ ‫ﻲ‬ ‫ﻓ‬(b-4)‫آي‬(8-4)،‫ﺎوي‬ ‫وﺗﺴ‬4،‫ﺬه‬ ‫وﻫ‬
‫ﻦ‬ ‫اﻷﻳﻤ‬ ‫ﻴﺮ‬‫ﻟﻠﺘﻌﺒ‬ ‫ﻰ‬‫ﺗﻌﻄ‬،‫ﻤﺔ‬‫اﻟﻘﺴ‬ ‫ﺘﻢ‬‫ﺗ‬ ‫ﺚ‬‫ﺣﻴ‬(12/b)‫آي‬(12/4)‫ﻴﺮ‬‫اﻟﺘﻌﺒ‬ ‫ﻴﺠﺔ‬‫ﻧﺘ‬ ‫ﺒﺢ‬‫ﻓﺘﺼ‬
‫ﻛﻠﻪ‬3،‫ﻟﻠﻤﺘﻐﻴﺮ‬ ‫ﺑﺎﻟﺘﺎﻟﻲ‬ ‫ﺗﻌﻄﻲ‬ ‫اﻟﺘﻲ‬a.
A=(b=2,b+1);
B=8;
A=(b=b-4,12/b);

‫اﻟﺘﻌﺮﻳﻒ‬ ‫ﺟﻤﻞ‬
‫ﺑﺘ‬ ‫ﺗﻘﻮم‬ ‫ﺟﻤﻞ‬ ‫ﻫﻲ‬ ‫اﻟﺘﻌﺮﻳﻒ‬ ‫ﺟﻤﻞ‬‫اﻟﻘﻴﻢ‬ ‫ﻌﺮﻳﻒ‬.
‫ﻣﺜﺎل‬:
‫ﺑﻴﺴﻚ‬ ‫ﻓﻴﺠﻮال‬ ‫ﻓﻲ‬ ‫اﻟﺠﻤﻠﺔ‬ ‫ﻫﺬه‬ ‫ﻳﻘﺎﺑﻞ‬
‫إﻟﻴﻪ‬ ‫اﻟﻤﺸﺎر‬ ‫اﻟﺬاﻛﺮة‬ ‫ﻓﻲ‬ ‫ﻣﻜﺎن‬ ‫ﺑﺤﺠﺰ‬ ‫وﺗﻘﻮم‬،‫ﺑﺎﻻﺳﻢ‬a‫ﺻﺤﻴﺤﺔ‬ ‫ﻋﺪدﻳﺔ‬ ‫ﻗﻴﻤﺔ‬ ‫ﻟﺘﺨﺰﻳﻦ‬.
‫ﻟـ‬ ‫اﻟﻤﺴﺘﺨﺪﻣﺔ‬ ‫اﻟﺬاﻛﺮة‬ ‫ﻓﻲ‬ ‫ﺗﺨﺰﻳﻨﻬﺎ‬ ‫اﻟﻤﻤﻜﻦ‬ ‫اﻟﺒﻴﺎﻧﺎت‬ ‫أﻧﻮاع‬C++
١.char‫ﻓﻘﻂ‬ ‫واﺣﺪ‬ ‫رﻣﺰ‬ ‫ﻟﺘﺨﺰﻳﻦ‬.
٢.int‫ﺻﺤﻴﺢ‬ ‫ﻋﺪد‬ ‫ﻟﺘﺨﺰﻳﻦ‬.
٣.float‫ﻟﺘﺨﺰﻳﻦ‬‫ﺣﻘﻴﻘﻲ‬ ‫ﻋﺪد‬.
٤.double‫ﻛﺒﻴﺮ‬ ‫ﺣﻘﻴﻘﻲ‬ ‫ﻋﺪد‬ ‫ﻟﺘﺨﺰﻳﻦ‬.
٥.void‫ﺧﺎﻟﻴﺔ‬ ‫ﺑﻴﺎﻧﺎت‬ ‫ﻟﺘﺨﺰﻳﻦ‬.
‫ﻴﺎﻧﺎت‬ ‫اﻟﺒ‬ ‫ﻮاع‬ ‫أﻧ‬ ‫ﺮﻓﺔ‬ ‫ﻣﻌ‬ ‫أن‬،‫ﺘﻌﻤﺎﻟﻬﺎ‬ ‫اﺳ‬ ‫ﻴﺔ‬ ‫وﻛﻴﻔ‬،‫ﺔ‬ ‫ﻟﻐ‬ ‫ﻢ‬ ‫ﻟﻔﻬ‬ ‫ﺮورﻳﺔ‬ ‫ﺿ‬ ‫ﺪ‬ ‫ﺗﻌ‬c++
‫ﻴﺮات‬‫اﻟﻤﺘﻐ‬ ‫ﺘﻌﻤﺎل‬‫ﻓﻼﺳ‬،‫ﺜﻼ‬‫ﻣ‬،‫ﺮﻧﺎﻣﺞ‬‫ﺑ‬ ‫ﻞ‬‫ﻛ‬ ‫ﺔ‬‫ﺑﺪاﻳ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻦ‬‫ﻧﻌﻠ‬ ‫أن‬ ‫ﺘﺎج‬‫ﻧﺤ‬،‫اﻟﺪوال‬ ‫ﺑﺪاﻳﺔ‬ ‫أو‬
‫ﻴﺮات‬ ‫اﻟﻤﺘﻐ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﻮاع‬ ‫أﻧ‬ ‫ﻦ‬ ‫ﻋ‬،‫ﺘﻌ‬ ‫اﻟ‬ ‫ﺘﻢ‬ ‫وﻳ‬‫ﺎ‬ ‫ﻣﻌﻬ‬ ‫ﺎﻣﻞ‬،‫ﺒﺮﻧﺎﻣﺞ‬ ‫اﻟ‬ ‫ﻼل‬ ‫ﺧ‬،‫ﻮاع‬‫أﻧ‬ ‫ﻮء‬‫ﺿ‬ ‫ﻲ‬ ‫ﻓ‬
‫اﻟﺘﺎﻟﻴﺔ‬ ‫ﻋﻦ‬ ‫اﻹﻋﻼن‬ ‫ﻓﻤﺜﻼ‬ ‫ﻣﻌﻄﻴﺎﺗﻬﺎ‬:
‫ﺘﺮﺟﻢ‬ ‫ﻣ‬ ‫ﺒﺮ‬ ‫ﺗﺨ‬c++‫ﻴﺮات‬ ‫اﻟﻤﺘﻐ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﻊ‬ ‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬ ‫ﻳ‬ ‫أن‬،‫ﺤﻴﺤﺔ‬ ‫ﺻ‬ ‫ﻴﺮات‬ ‫ﻣﺘﻐ‬ ‫ﺎ‬ ‫أﻧﻬ‬ ‫ﻰ‬ ‫ﻋﻠ‬
‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻹﻋﻼن‬ ‫ﺟﻤﻠﺔ‬ ‫وﻛﺬﻟﻚ‬:
‫ﻣﺘﺮﺟﻢ‬ ‫ﺗﺨﺒﺮ‬c++(C++ compiler)‫اﻟﺤﻘﻴﻘﻲ‬ ‫اﻟﻨﻮع‬ ‫ﻣﻦ‬ ‫اﻟﻤﺘﻐﻴﺮات‬ ‫ﻫﺬه‬ ‫أن‬.
Int a;
Dim a as integer
Int a,b,x;
Float m,y;

‫اﻟﺜﻮ‬‫اﻟﻤﻌﻜﻮﺳﺔ‬ ‫اﻟﺸﺮﻃﺔ‬ ‫ذات‬ ‫اﻟﺮﻣﺰﻳﺔ‬ ‫اﺑﺖ‬
‫ﺐ‬ ‫اﻟﺤﺎﺳ‬ ‫ﻴﺢ‬ ‫ﻣﻔﺎﺗ‬ ‫ﺔ‬ ‫ﻟﻮﺣ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻮدة‬ ‫اﻟﻤﻮﺟ‬ ‫ﺮﻣﻮز‬ ‫اﻟ‬ ‫ﺾ‬ ‫ﺑﻌ‬ ‫ﺘﻌﻤﺎل‬ ‫اﺳ‬ ‫ﺘﻄﻴﻊ‬ ‫ﻧﺴ‬ ‫ﻻ‬ ‫ﻨﺎ‬ ‫أﻧ‬ ‫ﺚ‬ ‫ﺣﻴ‬
‫ﺰﻳﺔ‬ ‫رﻣ‬ ‫ﺖ‬ ‫ﻛﺜﻮاﺑ‬،‫ﺔ‬ ‫ﻟﻐ‬ ‫ﺘﺤﺪث‬ ‫اﺳ‬ ‫ﺪ‬ ‫ﻓﻘ‬c++‫ﺮﻃﺔ‬ ‫ﺷ‬ ‫ﺘﻌﻤﻞ‬ ‫ﺗﺴ‬ ‫ﺔ‬ ‫ﺧﺎﺻ‬ ‫ﺰﻳﺔ‬ ‫رﻣ‬ ‫ﻔﺮات‬ ‫ﺷ‬
‫ﻟﻬﺎ‬ ‫ﻣﻌﻜﻮﺳﺔ‬،‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺠﺪول‬ ‫ﻓﻲ‬ ‫ﻣﺪوﻧﺔ‬ ‫اﻟﺸﻔﺮات‬ ‫وﻫﺬه‬:
‫ﻟﻬﺎ‬ ‫اﻟﺼﺤﻴﺤﺔ‬ ‫اﻟﻘﻴﻤﺔ‬ ‫ﻣﻌﻨﺎﻫﺎ‬ ‫اﻟﺸﻔﺮة‬
8 ‫رﺟﻮع‬‫واﺣﺪة‬ ‫ﺧﺎﻧﺔ‬ ‫ﺑﻤﻘﺪار‬ "b"
13 ‫ﺟﺪﻳﺪ‬ ‫ﺳﻄﺮ‬ "n"
9 ‫أﻓﻘﻲ‬ ‫ﺗﺮﺗﻴﺐ‬ "t"
0 ‫اﻟﺨﺎﻟﻴﺔ‬ ‫ﻟﻠﻘﻴﻤﺔ‬ "0"
13 ‫رﺟﻮع‬ ‫ﻋﻼﻣﺔ‬ "r"
11 ‫ﻋﻤﻮدي‬ ‫ﺗﺮﺗﻴﺐ‬ "v"
92 ‫اﻟﻤﻌﻜﻮﺳﺔ‬ ‫اﻟﺸﺮﻃﺔ‬ ""
12 ‫ﺻﻔﺤﺔ‬ ‫ﺗﻘﺪﻳﻢ‬ "/f"
‫اﻟﺠﺪول‬١٠-١
‫اﻟﺸﻔﺮات‬ ‫ﻫﺬه‬ ‫أﻫﻤﻴﺔ‬ ‫وﻟﺒﻴﺎن‬،‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻤﺜﺎل‬ ‫ﺧﺬ‬:
"first linen second line"
‫ﻟ‬‫ﻨﺺ‬ ‫اﻟ‬ ‫ﺬا‬ ‫ﻫ‬ ‫ﺒﻊ‬ ‫ﻃ‬ ‫ﻮ‬)‫ﺰي‬ ‫اﻟﺮﻣ‬ ‫ﺖ‬ ‫اﻟﺜﺎﺑ‬(‫ﻨﺤﻮ‬ ‫اﻟ‬ ‫ﻰ‬ ‫ﻋﻠ‬ ‫ﻦ‬ ‫ﻣﺘﺘﺎﻟﻴ‬ ‫ﻄﺮﻳﻦ‬ ‫ﺳ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻴﻈﻬﺮ‬ ‫ﺳ‬ ‫ﻪ‬ ‫ﻓﺎﻧ‬
‫اﻟﺘﺎﻟﻲ‬:
First line
Second line
‫ﺮ‬‫ﺑﺎﻟﺬﻛ‬ ‫ﺮ‬‫اﻟﺠﺪﻳ‬ ‫ﻦ‬‫وﻣ‬،‫ﺘﻌﻤﺎﻻﺗﻬ‬‫واﺳ‬ ‫ﺰﻳﺔ‬‫اﻟﺮﻣ‬ ‫ﻴﺎت‬‫اﻟﻤﻌﻄ‬ ‫ﻴﻘﺎت‬‫ﺗﻄﺒ‬ ‫ﻢ‬‫أﻫ‬ ‫أن‬‫ﺎ‬،‫ﺔ‬‫ﻣﻌﺎﻟﺠ‬ ‫ﻮ‬‫ﻫ‬
‫ﻮص‬ ‫اﻟﻨﺼ‬،‫ﺘﻤﺎم‬ ‫واﻻﻫ‬ ‫ﺠﻴﻞ‬ ‫اﻟﺘﺴ‬ ‫ﺘﺤﻖ‬ ‫ﻳﺴ‬ ‫ﺎ‬ ‫وﻣ‬،‫ﻰ‬ ‫ﻋﻠ‬ ‫ﻴﺎت‬ ‫ﻋﻤﻠ‬ ‫ﺮاء‬ ‫إﺟ‬ ‫ﻦ‬ ‫ﻳﻤﻜ‬ ‫ﻪ‬ ‫اﻧ‬
‫اﻟﺮﻣ‬ ‫اﻟﻤﻌﻄﻴﺎت‬‫ﺰﻳﺔ‬.

‫ﻓﻲ‬ ‫واﻟﺘﻌﻠﻴﻘﺎت‬ ‫اﻟﻤﻼﺣﻈﺎت‬++cComments
‫واﻟﻤﻼﺣﻈﺎت‬ ‫ﻟﻠﺘﻌﻠﻴﻘﺎت‬ ‫ﺟﻤﻼ‬ ‫اﻟﺒﺮﻣﺠﺔ‬ ‫ﻟﻐﺎت‬ ‫ﺳﺎﺋﺮ‬ ‫ﺗﺴﺘﻌﻤﻞ‬،‫ﻟﻐﺔ‬ ‫وﻛﺬﻟﻚ‬C++‫ﻣﺜﻼ‬
‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺠﻤﻠﺔ‬:
‫ﺑﻴﺴﻚ‬ ‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫ﻣﻼﺣﻆ‬ ‫ﺟﻤﻠﺔ‬ ‫ﻫﻲ‬،‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫ﺗﻌﻠﻴﻖ‬ ‫ﺟﻤﻠﺔ‬ ‫ﺗﻘﺎﺑﻠﻬﺎ‬C++:
‫ﺷﺮﻃﺘﻴﻦ‬ ‫ﺑﻌﺪ‬ ‫ﺗﻮﺿﺢ‬ ‫اﻟﺘﻲ‬)‫ﻣﺎﺋﻠﻴﻦ‬ ‫ﺧﻄﻴﻦ‬(
‫ﻴﻖ‬‫اﻟﺘﻌﻠ‬ ‫ﻞ‬‫ﺟﻤ‬ ‫ﺘﻌﻤﻞ‬‫وﺗﺴ‬،‫ﻣﺎ‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﻹﺑﺪاء‬ ‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺎن‬‫ﻣﻜ‬ ‫أي‬ ‫ﻲ‬‫ﻓ‬،‫ﻣﺎ‬ ‫ﺳﻄﺮ‬ ‫ﻋﻨﺪ‬
‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫ﻲ‬‫ﻓ‬،‫ﻴﺬﻳﺔ‬‫ﺗﻨﻔ‬ ‫ﺔ‬‫ﺟﻤﻠ‬ ‫ﺪ‬‫ﺗﻌ‬ ‫وﻻ‬،‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻣﻦ‬ ‫ﺣﺬﻓﺖ‬ ‫ﻟﻮ‬ ‫أﻧﻬﺎ‬ ‫ﺑﻤﻌﻨﻰ‬،‫ﻓﻴﻪ‬ ‫ﻳﺆﺛﺮ‬ ‫ﻻ‬
‫ﺷﻴﺌﺎ‬ ‫ذﻟﻚ‬،‫اﻟﻤﺒﺮﻣﺠﻴﻦ‬ ‫ﻳﺘﺠﺎﻫﻠﻬﺎ‬ ‫ﻣﺎ‬ ‫وﻋﺎدﺗﺎ‬.
‫ﻣﺜﺎل‬:‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺘﻌﻠﻴﻖ‬ ‫ﺟﻤﻞ‬ ‫ﻻﺣﻆ‬:
‫ﺑﺎﻟﺬ‬ ‫اﻟﺠﺪﻳﺮ‬ ‫وﻣﻦ‬‫ﻫﻨﺎ‬ ‫ﻛﺮ‬،‫ﻳﺄﺗﻲ‬ ‫ﻣﺎ‬:
‫اﻟﺸﺮﻃﺔ‬ ‫ﺑﻴﻦ‬ ‫ﻓﺮاغ‬ ‫أي‬ ‫ﻳﺘﺮك‬ ‫ﻻ‬/‫واﻟﻨﺠﻤﺔ‬*‫اﻟﺘﻌﻠﻴﻖ‬ ‫ﺟﻤﻠﺔ‬ ‫ﺟﻬﺘﻲ‬ ‫ﻣﻦ‬.
١-‫ﻣﺘﺮﺟﻢ‬ ‫ﻳﻘﻮم‬c++‫اﻟﺘﻌﻠﻴﻖ‬ ‫ﺟﻤﻞ‬ ‫ﻓﻲ‬ ‫اﻟﻤﺴﺘﻌﻤﻠﺔ‬ ‫اﻟﻨﺼﻮص‬ ‫ﺑﺈﻫﻤﺎل‬،‫ﻻ‬ ‫أﻧﻬﺎ‬ ‫أي‬
‫ﺗﻨﻔﺬ‬،‫ﻓﻘﻂ‬ ‫ﺳﻄﻮرا‬ ‫أو‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻗﺎﺋﻤﺔ‬ ‫ﻣﻊ‬ ‫ﺗﻈﻬﺮ‬ ‫ﺗﻮﺿﻴﺤﻴﺔ‬ ‫ﺟﻤﻞ‬ ‫ﻫﻲ‬ ‫ﺑﻞ‬.
٢-‫ا‬ ‫ﻣﻦ‬ ‫ﻣﻜﺎن‬ ‫أي‬ ‫ﻓﻲ‬ ‫واﻟﺘﻌﻠﻴﻖ‬ ‫اﻟﻤﻼﺣﻈﺔ‬ ‫ﺟﻤﻠﺔ‬ ‫وﺿﻊ‬ ‫ﻳﻤﻜﻦ‬‫ﻟﺒﺮﻧﺎﻣﺞ‬،‫ﻋﺪا‬ ‫ﻣﺎ‬
‫ﺗﻌﺮﻳﻔﻲ‬ ‫اﺳﻢ‬ ‫وﺳﻂ‬identifier،‫ﻣﺤﺠﻮزة‬ ‫ﻛﻠﻤﺔ‬ ‫أو‬keyword.
10 rem this is Islam
// this is Islam
//this is comment
*/an example on comment in c++ language/*
main() /* start your program/*
{
int x,y,z; //this line declares type of x,y,z
}

‫ﺳﻲ‬ ‫ﻓﻴﺠﻮال‬ ‫ﺑﺮﻧﺎﻣﺞ‬ ‫ﻟﺘﺸﻐﻴﻞ‬++‫اﻟﺘﺎﻟﻲ‬ ‫ﻧﺘﺒﻊ‬:
‫أﺑﺪا‬Ù‫اﻟﺒﺮاﻣﺞ‬Ùvisualc++6.0
‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺸﺎﺷﺔ‬ ‫ﻟﻨﺎ‬ ‫ﺳﺘﻈﻬﺮ‬ ‫ذﻟﻚ‬ ‫ﺑﻌﺪ‬ ‫ﺛﻢ‬:
‫ﺔ‬ ‫اﻟﻘﺎﺋﻤ‬ ‫ﺢ‬ ‫واﺿ‬ ‫ﻮ‬ ‫ﻫ‬ ‫ﺎ‬ ‫ﻛﻤ‬ ‫ﺔ‬ ‫اﻟﺸﺎﺷ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺘﺎر‬ ‫ﻧﺨ‬File‫ﺛ‬‫ﺔ‬ ‫اﻟﻘﺎﺋﻤ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺘﺎر‬ ‫ﻧﺨ‬ ‫ﻚ‬ ‫ذﻟ‬ ‫ﺪ‬ ‫ﺑﻌ‬ ‫ﻢ‬
New‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺸﺎﺷﺔ‬ ‫ﻟﻨﺎ‬ ‫ﻟﺘﻈﻬﺮ‬..
‫اﻟﻘﺎﺋﻤﺔ‬ ‫ﻧﺨﺘﺎر‬file‫ﻫﻨﺎ‬ ‫ﻣﻦ‬
‫ﺗﺸﻐﻴﻞ‬visual c++6.0
Run visual c++6.0

‫ﻣﻮاﻓﻖ‬ ‫ﻧﺨﺘﺎر‬ ‫ﺛﻢ‬ ‫ﺑﺎﻷﺳﻔﻞ‬ ‫ﺑﺎﻟﺼﻮرة‬ ‫ﻳﻮﺟﺪ‬ ‫ﻣﺎ‬ ‫ﻧﻄﺒﻖ‬..
‫اﻟﺘﺴﻤﻴﺔ‬‫ﺑﺎﻟﻤﺸﺮوع‬ ‫اﻟﺨﺎﺻﺔ‬
‫ﻫﻨﺎ‬ ‫ﻧﺨﺘﺎر‬
‫ﻧﻨﻘﺮ‬ ‫ﺛﻢ‬ok

‫ﺑﺎﻷﺳﻔﻞ‬ ‫ﻣﻮﺿﺢ‬ ‫ﻫﻮ‬ ‫ﻛﻤﺎ‬ ‫إﻧﻬﺎء‬ ‫ﻧﺨﺘﺎر‬ ‫ﺛﻢ‬ ‫ﺑﺎﻷﺳﻔﻞ‬ ‫اﻟﻤﻮﺟﻮد‬ ‫اﻟﺘﻄﺒﻴﻖ‬ ‫ﻧﺨﺘﺎر‬..
‫اﻟﺘﻄﺒﻴﻖ‬ ‫ﻫﺬا‬ ‫ﻧﺨﺘﺎر‬
‫ﻧﻨﻘﺮ‬ ‫ﺛﻢ‬finish

‫اﻟﺸﺎﺷﺔ‬ ‫ﺑﺎﻷﺳﻔﻞ‬ ‫وﻧﻼﺣﻆ‬ ‫اﻟﻜﻮد‬ ‫ﺷﺎﺷﺔ‬ ‫ﻟﻨﺎ‬ ‫ﺳﺘﻈﻬﺮ‬ ‫اﻵن‬..
‫ﺔ‬‫اﻟﻘﺎﺋﻤ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺘﺎر‬‫ﻧﺨ‬ ‫ﻚ‬‫ذﻟ‬ ‫ﺪ‬‫ﺑﻌ‬Build‫ﺘﺎر‬‫ﻧﺨ‬ ‫ﻢ‬‫ﺛ‬Execute .exe‫ﺮوع‬‫اﻟﻤﺸ‬ ‫ﻨﺎ‬‫ﻟ‬ ‫ﺒﻖ‬‫ﻟﻴﻄ‬..
‫اﻟﺰر‬ ‫ﻋﻠﻰ‬ ‫اﻟﻤﻔﺎﺗﻴﺢ‬ ‫ﻟﻮﺣﺔ‬ ‫ﻣﻦ‬ ‫ﺑﺎﻟﻨﻘﺮ‬ ‫أو‬F5.

‫اﻟﺒ‬ ‫ﺗﻨﻔﻴﺬ‬ ‫ﺑﻌﺪ‬ ‫ﻃﺒﻌﺎ‬‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺸﻜﻞ‬ ‫ﻓﻲ‬ ‫ﻛﻤﺎ‬ ‫اﻟﻨﺘﺎﺋﺞ‬ ‫ﻟﻨﺎ‬ ‫ﺳﺘﻈﻬﺮ‬ ‫ﺮﻧﺎﻣﺞ‬:
‫ﺑﻠﻐﺔ‬ ‫ﺎص‬‫ﺧ‬ ‫ﺒﻌﻪ‬‫ﺗ‬ ‫ﻮد‬‫اﻟﻜ‬ ‫أن‬ ‫ﻮن‬‫ﺗﻼﺣﻈ‬ ‫ﺮﻧﺎﻣﺞ‬‫ﺑ‬ ‫ﻮ‬‫ﻫ‬ ‫ﻐﻴﺮ‬‫اﻟﺼ‬ ‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫ﺬا‬‫ﻫ‬ ‫ﻲ‬‫أﻋﺰاﺋ‬ ‫ﺒﻌﺎ‬‫ﻃ‬
C‫ﻴﺲ‬ ‫وﻟ‬ ‫اﻻم‬c++‫ﻮ‬ ‫ﻫ‬ ‫ﺘﺮﺟﻢ‬ ‫واﻟﻤ‬ ‫ﺎ‬ ‫ﻣﻌ‬ ‫ﻦ‬ ‫اﻟﻠﻐﺘﻴ‬ ‫ﺒﻞ‬ ‫ﻳﻘ‬ ‫ﺘﺮﺟﻢ‬ ‫ﻣ‬ ‫ﻮ‬ ‫ﻫ‬ ‫ﻴﻪ‬ ‫ﻋﻠ‬ ‫ﻞ‬ ‫ﻧﻌﻤ‬ ‫ﺎ‬ ‫ﻣ‬ ‫ﻦ‬ ‫ﻟﻜ‬
Visual C++،‫ﺒﺎرة‬‫ﻋ‬ ‫ﺒﺎﻋﺔ‬‫ﻃ‬ ‫ﻢ‬‫ﺗ‬ ‫ﻪ‬‫اﻧ‬ ‫ﻆ‬‫وﻧﻼﺣ‬Hello World!‫ﻴﺬ‬‫ﺗﻨﻔ‬ ‫ﻴﺠﺔ‬‫ﻧﺘ‬ ‫ﻲ‬‫وﻫ‬
‫اﻟﺪاﻟﺔ‬printf()‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺳﻄﻮر‬ ‫ﻓﻲ‬ ‫اﻟﻤﻮﺟﻮدة‬.

‫ﻣﻘﺪﻣﺔ‬introduction
‫ﺰﻳﺔ‬‫واﻟﺮﻣ‬ ‫ﺎﺑﻴﺔ‬‫اﻟﺤﺴ‬ ‫ﻴﻢ‬‫اﻟﻘ‬ ‫ﺎل‬‫إدﺧ‬ ‫ﺎﻟﻴﺐ‬‫أﺳ‬ ‫ﺰء‬‫اﻟﺠ‬ ‫ﺬا‬‫ﻫ‬ ‫ﻨﺎول‬‫ﻳﺘ‬،‫وﻃﺒﺎﻋﺔ‬ ‫ﺮاج‬‫إﺧ‬ ‫ﺎﻟﻴﺐ‬‫وأﺳ‬
‫ﺰﻳﺔ‬ ‫واﻟﺮﻣ‬ ‫ﺎﺑﻴﺔ‬ ‫اﻟﺤﺴ‬ ‫ﻴﺮ‬ ‫واﻟﺘﻌﺎﺑ‬ ‫ﺒﺮاﻣﺞ‬ ‫اﻟ‬ ‫ﺘﺎﺋﺞ‬ ‫ﻧ‬،‫ﺐ‬ ‫ﺣﺴ‬ ‫ﺘﻠﻔﺔ‬ ‫اﻟﻤﺨ‬ ‫ﻴﺎت‬ ‫اﻟﻤﻌﻄ‬ ‫ﺒﺎﻋﺔ‬ ‫وﻃ‬
‫اﻟ‬‫ﺤﺎﺟﺔ‬.
‫ﻚ‬‫ﺑﻴﺴ‬ ‫ﺔ‬‫ﻟﻐ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺎ‬‫ﺗﻌﻮدﻧ‬ ‫ﺪ‬‫ﻟﻘ‬،‫ﺑﺎﻹدﺧﺎل‬ ‫ﻟﻠﻘﻴﺎم‬ ‫اﻟﻄﻠﺐ‬ ‫ﻋﻨﺪ‬ ‫ﺰة‬‫وﺟﺎﻫ‬ ‫ﻴﺔ‬‫ﻣﺒﻨ‬ ‫دوال‬ ‫ﺘﻌﻤﻞ‬‫ﻧﺴ‬ ‫أن‬
‫ﺜﻞ‬ ‫ﻣ‬)input‫أو‬read(‫ﺜﻞ‬ ‫ﻣ‬ ‫ﺮاج‬ ‫ﺑﺎﻹﺧ‬ ‫أو‬)print(،‫ﺪد‬ ‫اﻟﺼ‬ ‫ﺬا‬ ‫ﻫ‬ ‫ﻲ‬ ‫وﻓ‬،‫ﺔ‬ ‫ﻟﻐ‬ ‫ﺎن‬ ‫ﻓ‬
C++،‫ﺮاج‬ ‫واﻹﺧ‬ ‫ﺎل‬ ‫اﻹدﺧ‬ ‫ﻊ‬ ‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬ ‫ﺗ‬،‫ﺘﻠﻔﺔ‬ ‫ﻣﺨ‬ ‫ﺮﻳﻘﺔ‬ ‫ﺑﻄ‬،‫ﺔ‬ ‫اﻟﻠﻐ‬ ‫ﺮ‬ ‫ﺗﻮﻓ‬ ‫ﺚ‬ ‫ﺣﻴ‬،‫ﺪدا‬ ‫ﻋ‬
‫واﻹدﺧ‬ ‫ﺮاج‬‫اﻹﺧ‬ ‫دوال‬ ‫ﻦ‬‫ﻣ‬ ‫ﻴﺮا‬‫ﻛﺒ‬‫ﺎل‬،‫ﻳﺴﺘﺪﻋﻴﻬﺎ‬ ‫أن‬ ‫ﻟﻠﻤﺒﺮﻣﺞ‬ ‫ﻳﻤﻜﻦ‬ ‫ﺚ‬‫ﺣﻴ‬،‫ﻣﻨﻬﺎ‬ ‫وﻳﺴﺘﻔﻴﺪ‬
،‫ﻴﺮات‬‫واﻟﻤﺘﻐ‬ ‫ﻴﺎت‬‫اﻟﻤﻌﻄ‬ ‫ﻮع‬‫ﻧ‬ ‫ﺐ‬‫ﺣﺴ‬،‫ﻳﻨﺎﺳﺒﻪ‬ ‫ﻴﻔﻤﺎ‬‫ﻛ‬،‫ﻫﺬا‬ ‫ﻓﻲ‬ ‫اﷲ‬ ‫ﺷﺎء‬ ‫أن‬ ‫ﻧﻮرد‬ ‫وﺳﻮف‬
‫ﻟـ‬ ‫واﺷﻬﺮﻫﺎ‬ ‫اﻟﺪوال‬ ‫ﻫﺬه‬ ‫أﻫﻢ‬ ‫اﻟﻔﺼﻞ‬C++.
‫واﻹﺧﺮاج‬ ‫اﻹدﺧﺎل‬ ‫أﺳﺎﻟﻴﺐ‬
Input/output Techniques

‫واﻹﺧﺮاج‬ ‫اﻹدﺧﺎل‬outputinput
‫ﺔ‬‫ﻟﻐ‬ ‫ﺮ‬ ‫ﺗﻮﻓ‬C++،‫ﻴﺎ‬‫واﻟﺮوﺗﻴﻨ‬ ‫ﺪوال‬‫اﻟ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺔ‬‫ﻣﺠﻤﻮﻋ‬‫ﻤﻦ‬‫ﺿ‬ ‫ﺮﻓﺔ‬ ‫اﻟﻤﻌ‬ ‫ت‬Iostream‫ﺜﻞ‬ ‫ﻣ‬
cout‫و‬ ‫ﻟﻺﺧﺮاج‬cin‫اﻟﻤﻠﻒ‬ ‫ﻧﻌﺮف‬ ‫وﺳﻮف‬ ‫ﻟﻺدﺧﺎل‬iostream.h
‫اﻟﻤﻠﻒ‬Iostream.h‫ﻳﻌﻨﻲ‬:
io:‫ﻟـ‬ ‫ﻣﺨﺘﺼﺮ‬input/output‫واﻹﺧﺮاج‬ ‫اﻹدﺧﺎل‬ ‫آي‬.
Stream:‫اﻟــﺦ‬ ‫واﻹدﺧﺎل‬ ‫ﺑﺎﻹﺧﺮاج‬ ‫ﺧﺎﺻﺔ‬ ‫ﻗﻴﺎﺳﻴﺔ‬ ‫ﻣﻜﺘﺒﺔ‬..
H:header file‫اﻟﺪﻟﻴﻞ‬ ‫اﻟﻤﻠﻒ‬ ‫آي‬.
‫ﻣﺜﺎل‬١:
‫أردت‬ ‫إذا‬‫اﻟﻌﺪد‬ ‫ﻃﺒﺎﻋﺔ‬100‫ﻓﺎﻟﺠﻤﻠﺔ‬ ‫ﺑﻴﺴﻚ‬ ‫ﻟﻐﺔ‬ ‫ﻓﻲ‬:
Print 100
‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﻋﻤﻠﻴﺔ‬ ‫ﺗﺆدي‬،‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫أﻣﺎ‬C++‫ذﻟﻚ‬ ‫ﺗﻌﻤﻞ‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺪاﻟﺔ‬ ‫ﻓﺎن‬:
‫ﺪد‬ ‫اﻟﻌ‬ ‫ﺒﺎﻋﺔ‬ ‫ﻃ‬ ‫ﻰ‬ ‫إﻟ‬ ‫ﺆدي‬ ‫ﺗ‬100‫ﺚ‬ ‫ﺣﻴ‬cout‫واﻷداة‬ ‫ﻲ‬ ‫اﻟﻘﻴﺎﺳ‬ ‫ﺮاج‬ ‫اﻹﺧ‬ ‫ﺪة‬ ‫وﺣ‬ ‫ﻢ‬ ‫اﺳ‬<<
‫ﺪد‬ ‫اﻟﻌ‬ ‫ﺎل‬ ‫إرﺳ‬ ‫ﻰ‬ ‫إﻟ‬ ‫ﺆدي‬ ‫ﺗ‬100‫إﻟ‬‫ﺮاج‬ ‫اﻹﺧ‬ ‫ﺪة‬ ‫وﺣ‬ ‫ﻰ‬،‫ﻲ‬ ‫ﻓ‬ ‫ﺪ‬ ‫اﻟﺠﺪﻳ‬ ‫ﻠﻮب‬ ‫اﻷﺳ‬ ‫ﺬا‬ ‫ﻫ‬ ‫أن‬
‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫ﻋﻤﺎ‬ ‫ﻳﺨﺘﻠﻒ‬ ‫اﻹﺧﺮاج‬c.
#include “ stdafx.h”
#include “ iostream.h”
main ()
{
cout<<100;
return0;
}

‫اﻟﻨﺼﻮص‬ ‫ﻃﺒﺎﻋﺔ‬)‫اﻟﺮﻣﺰﻳﺔ‬ ‫اﻟﺜﻮاﺑﺖ‬(
‫ﻣﺜﺎل‬٢:
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻗﻄﻌﺔ‬ ‫ﺗﺄﻣﻞ‬:
‫أﺧﺮى‬ ‫ﺑﻌﺒﺎرة‬n‫إﻳﻌﺎ‬‫ﺟﺪﻳﺪ‬ ‫ﺳﻄﺮ‬ ‫إﻟﻰ‬ ‫ﻟﻼﻧﺘﻘﺎل‬ ‫ز‬،‫اﻟﺪاﻟﺔ‬ ‫اﺳﺘﺨﺪام‬ ‫ﻳﻤﻜﻦ‬ ‫وﻗﺪ‬endl‫ﺑﺪﻻ‬
‫ﻣﻦ‬n‫ﻳﻠﻲ‬ ‫وﻛﻤﺎ‬:
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺎﺗﺞ‬ ‫ﻳﻄﺒﻊ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺗﻨﻔﻴﺬ‬ ‫وﻋﻨﺪ‬:
smoking is dangerous
main ()
{
cout<<“smoking is dangerous n”;;
return0;
}
‫ﺟﺪﻳﺪ‬ ‫ﻟﺴﻄﺮ‬ ‫ﻟﻼﻧﺘﻘﺎل‬
main ()
{
cout<<“ smoking is dangerous”<<endl;
return0;
}

‫ﻣﺜﺎل‬٣:
‫إﻣﻜﺎﻧﻴﺎ‬ ‫ﻣﻦ‬ ‫ﻟﻼﺳﺘﻔﺎدة‬‫اﻹﻳﻌﺎز‬ ‫ت‬n‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﻋﻤﻠﻴﺎت‬ ‫ﻓﻲ‬:‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺗﺄﻣﻞ‬:
‫اﻟﺸﺎﺷﺔ‬ ‫ﻋﻠﻰ‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﺗﺮى‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺗﻨﻔﻴﺬ‬ ‫ﻋﻨﺪ‬:
‫اﻷول‬ ‫اﻟﺴﻄﺮ‬Ùmatrixmatrix
‫اﻟﺜﺎﻧﻲ‬ ‫اﻟﺴﻄﺮ‬Ùmatrix
‫اﻟﺜﺎﻟﺚ‬ ‫اﻟﺴﻄﺮ‬Ù‫ﻓﺎرغ‬ ‫ﺳﻄﺮ‬
‫اﻟﺮاﺑﻊ‬ ‫اﻟﺴﻄﺮ‬Ùmatrix
‫اﻟﺨﺎﻣﺲ‬ ‫اﻟﺴﻄﺮ‬Ù‫ﻓﺎرغ‬ ‫ﺳﻄﺮ‬
‫اﻟﺴﺎدس‬ ‫اﻟﺴﻄﺮ‬Ù‫ﻓﺎرغ‬ ‫ﺳﻄﺮ‬
‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻫﺬا‬ ‫ﻓﻲ‬ ‫ﻧﻼﺣﻆ‬:
١-‫ﺒﺎﻋﺔ‬ ‫ﻃ‬ ‫ﺪ‬ ‫ﺑﻌ‬ ‫اﻷول‬ ‫ﻄﺮ‬ ‫اﻟﺴ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺘﻘﺎل‬ ‫اﻻﻧ‬ ‫ﺘﻢ‬ ‫ﻳ‬ ‫ﻪ‬ ‫اﻧ‬matrix‫ﺪم‬ ‫ﻟﻌ‬ ‫ﻲ‬ ‫اﻟﺜﺎﻧ‬ ‫ﻄﺮ‬ ‫اﻟﺴ‬ ‫ﻰ‬ ‫إﻟ‬
‫ﺘﻘﺎل‬ ‫اﻻﻧ‬ ‫ﺎز‬ ‫إﻳﻌ‬ ‫ﻮد‬ ‫وﺟ‬n،‫ﺘﺎﺋﺠﻬﺎ‬ ‫ﻧ‬ ‫ﺮت‬ ‫ﻇﻬ‬ ‫ﻴﺔ‬ ‫اﻟﺘﺎﻟ‬ ‫ﺔ‬ ‫اﻟﻄﺎﺑﻌ‬ ‫ﺔ‬ ‫ﺟﻤﻠ‬ ‫ﺎن‬ ‫ﻓ‬ ‫ﺬا‬ ‫وﻟ‬‫ا‬ ‫ﻲ‬ ‫ﻓ‬
‫ﻪ‬ ‫ﻧﻔﺴ‬ ‫اﻷول‬ ‫ﻄﺮ‬ ‫ﻟﺴ‬،‫ﺔ‬ ‫ﺑﻄﺎﻋ‬ ‫ﻠﺔ‬ ‫ﻣﺘﺼ‬matrix‫ﻰ‬ ‫اﻷوﻟ‬،‫ﻮﺋﻲ‬ ‫اﻟﻀ‬ ‫ﺮ‬ ‫اﻟﻤﺆﺷ‬ ‫ﺘﻘﻞ‬ ‫وﻳﻨ‬
‫إﻳﻌﺎز‬ ‫ﻟﻮﺟﻮد‬ ‫ﺟﺪﻳﺪ‬ ‫ﺳﻄﺮ‬ ‫إﻟﻰ‬n.
٢-‫ﺪ‬ ‫اﻟﺠﺪﻳ‬ ‫ﻄﺮ‬ ‫اﻟﺴ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺜﺔ‬ ‫اﻟﺜﺎﻟ‬ ‫ﺒﺎﻋﺔ‬ ‫اﻟﻄ‬ ‫ﺔ‬ ‫ﺟﻤﻠ‬ ‫ﻴﺬ‬ ‫ﺗﻨﻔ‬ ‫ﺘﻢ‬ ‫ﻳ‬)‫ﻲ‬ ‫اﻟﺜﺎﻧ‬(،‫ﻰ‬ ‫إﻟ‬ ‫ﺘﻘﺎل‬ ‫اﻻﻧ‬ ‫ﺘﻢ‬ ‫وﻳ‬
‫ﺚ‬‫اﻟﺜﺎﻟ‬ ‫ﻄﺮ‬‫اﻟﺴ‬ ‫ﻦ‬‫ﻋ‬ ‫ﺰا‬‫ﻗﻔ‬ ‫ﺮاﺑﻊ‬‫اﻟ‬ ‫ﻄﺮ‬‫اﻟﺴ‬،‫اﻹﻳﻌﺎز‬ ‫ﻟﻮﺟﻮد‬ ‫ﻚ‬‫وذﻟ‬nn‫ﻛﻞ‬ ‫ﻳﻘﻮم‬ ‫ﺣﻴﺚ‬
‫ﺎز‬‫إﻳﻌ‬n‫ﺪا‬ ‫واﺣ‬ ‫ﻄﺮا‬ ‫ﺳ‬ ‫ﻮﺋﻲ‬ ‫اﻟﻀ‬ ‫ﺮ‬ ‫اﻟﻤﺆﺷ‬ ‫ﻨﻘﻞ‬ ‫ﺑ‬،‫ﺔ‬ ‫ﺟﻤﻠ‬ ‫ﺒﻊ‬ ‫ﺗﻄ‬ ‫ﺮاﺑﻊ‬ ‫اﻟ‬ ‫ﻄﺮ‬ ‫اﻟﺴ‬ ‫ﻲ‬ ‫وﻓ‬
‫ﺮاﺑﻌﺔ‬ ‫اﻟ‬ ‫ﺒﺎﻋﺔ‬ ‫اﻟﻄ‬،‫ﺎز‬ ‫اﻹﻳﻌ‬ ‫ﺐ‬ ‫ﺣﺴ‬ ‫ﻮرا‬ ‫ﻓ‬ ‫ﺎﺑﻊ‬ ‫اﻟﺴ‬ ‫ﻄﺮ‬ ‫اﻟﺴ‬ ‫ﻰ‬ ‫إﻟ‬ ‫ﺘﻘﺎل‬ ‫اﻻﻧ‬ ‫ﺎ‬ ‫ﺑﻌﺪﻫ‬ ‫ﺘﻢ‬ ‫وﻳ‬
nnn.
main ()
{
cout<<“matrix”;
cout<<“matrix n”;
cout<<“matrix nn”;
cout<<“matrix nnn”;
cout<<“matrix”;
return0;
}

‫اﻟﻌﺪدﻳﺔ‬ ‫اﻟﻘﻴﻢ‬ ‫ﻃﺒﺎﻋﺔ‬
‫ﻣﺜﺎل‬٤:
‫اﻟﻌﺪد‬ ‫ﺑﻄﺎﻋﺔ‬ ‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻳﻘﻮم‬446‫اﻟﺤﺎﺳﻮب‬ ‫ﺷﺎﺷﺔ‬ ‫ﻋﻠﻰ‬ ‫ﺻﺤﻴﺤﺔ‬ ‫ﻛﻘﻴﻤﺔ‬:
‫اﻟﺘﺎﻟﻲ‬ ‫ﻟﻨﺎ‬ ‫ﻳﻈﻬﺮ‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﻋﻨﺪ‬:
446
‫ﻣﺜﺎل‬٥:
‫ﺑﺮﻧﺎﻣﺞ‬C++،‫اﻟﺤﻘﻴﻘﺔ‬ ‫اﻟﻘﻴﻤﺔ‬ ‫ﻳﻄﺒﻊ‬ ‫اﻟﺘﺎﻟﻲ‬10.5:
‫ﻳ‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﻋﻨﺪ‬‫اﻟﺘﺎﻟﻲ‬ ‫ﻈﻬﺮ‬:
10.5
main ()
{
cout<<446;
return0;
}
main ()
{
cout<<10.5;
return0;
}

‫ﻣﺜﺎل‬٦:
‫ﺑﺮﻧﺎﻣﺞ‬ ‫ﻳﻔﻌﻞ‬ ‫ﻣﺎذا‬ ‫اﻧﻈﺮ‬C++‫اﻟﺘﺎﻟﻲ‬:
‫اﻟﺘﺎﻟﻲ‬ ‫ﻟﻨﺎ‬ ‫ﻳﻈﻬﺮ‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﻋﻨﺪ‬:
100
‫ﻣﺜﺎل‬٧:
‫ﺣﻘﻴﻘﻲ‬ ‫ﻣﺘﻐﻴﺮ‬ ‫ﻗﻴﻤﺔ‬ ‫ﺑﻄﺒﺎﻋﺔ‬ ‫ﻳﻘﻮم‬ ‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬:
‫اﻟﺘﺎﻟﻲ‬ ‫ﻟﻨﺎ‬ ‫ﺳﻴﻈﻬﺮ‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﻋﻨﺪ‬:
4.25
main ()
{
int a=100;
cout<<a;
return0;
}
main ()
{
float x;
x=4.25
cout<<x;
return0;
}

‫ﻣﺜﺎل‬٨:
‫ﻦ‬ ‫اﻟﻤﺘﻐﻴﺮﻳ‬ ‫ﺒﺎﻋﺔ‬ ‫ﻃ‬ ‫ﺮ‬ ‫اﻷﻣ‬ ‫ﺐ‬ ‫ﺗﻄﻠ‬ ‫إذا‬a‫ﺤﻴﺢ‬ ‫اﻟﺼ‬،‫و‬x‫ﻦ‬ ‫اﻟﻤﺜﺎﻟﻴ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻦ‬ ‫اﻟﻮاردﻳ‬ ‫ﻲ‬ ‫اﻟﺤﻘﻴﻘ‬
‫اﻟﺴﺎﺑﻘﻴﻦ‬،‫واﺣﺪ‬ ‫ﺑﺮﻧﺎﻣﺞ‬ ‫ﻓﻲ‬،‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫ﺳﻴﻜﻮن‬ ‫ﻓﺎﻟﺒﺮﻧﺎﻣﺞ‬:
‫ﻃﻠﺒﻨﺎ‬ ‫ﻛﻤﺎ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻫﺬا‬ ‫ﻧﺘﺎﺋﺞ‬ ‫وﺳﺘﻈﻬﺮ‬)‫اﻟﺤﻘﻴﻘﻲ‬ ‫ﻳﺴﺒﻖ‬ ‫اﻟﺼﺤﻴﺢ‬(،‫ﻫﻜﺬا‬:
100 4.25
main ()
{
int=100;
float x=4.25
cout<<a<<x;
return0;
}

‫واﻟﺮﻣﺰﻳﺔ‬ ‫اﻟﻌﺪدﻳـﺔ‬ ‫اﻟﻘـﻴﻢ‬ ‫ﻃـﺒﺎﻋﺔ‬)‫اﻟﻨﺼﻮص‬(‫ﺟﻤﻠﺔ‬ ‫ﻓﻲ‬
‫واﺣﺪة‬
‫ﻣﺜﺎل‬٩:
‫اﻟﺒ‬ ‫ﻣﻊ‬ ‫وﻧﺼﻴﺔ‬ ‫ﻋﺪدﻳﺔ‬ ‫ﻗﻴﻢ‬ ‫ﺑﻄﺒﺎﻋﺔ‬ ‫اﻟﻤﺜﺎل‬ ‫ﻫﺬا‬ ‫ﻓﻲ‬ ‫ﻧﻘﻮم‬ ‫ﺳﻮف‬‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫ﻌﺾ‬:
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺎﺗﺞ‬ ‫ﻳﻜﻮن‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﻋﻨﺪ‬:
A=100
‫ﻣﺜﺎل‬١٠:
‫اﻟﻮﻗﺖ‬ ‫ﺑﻨﻔﺲ‬ ‫ﻧﺼﻮص‬ ‫ﻣﻊ‬ ‫وﺣﻘﻴﻘﻲ‬ ‫ﺻﺤﻴﺢ‬ ‫ﻋﺪد‬ ‫ﻃﺒﺎﻋﺔ‬ ‫أردﻧﺎ‬ ‫إذا‬ ‫ﻣﺎذا‬:
‫اﻟﺘﺎﻟﻲ‬ ‫ﻟﻨﺎ‬ ‫ﺳﻴﻈﻬﺮ‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫وﻋﻨﺪ‬:
A=100 x=4.25
main ()
{
int a=100;
cout<<“a=”<<a;
return0;
}
main ()
{
int=100;
float x=4.25
cout<<“a=”<<a<<“x=”<<x;
return0;
}

‫ﻣﺜﺎل‬١١:
‫ﺪ‬ ‫واﺣ‬ ‫ﻄﺮ‬ ‫ﺳ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺪﻻ‬ ‫ﺑ‬ ‫ﻄﺮﻳﻦ‬ ‫ﺳ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺎﺑﻖ‬ ‫اﻟﺴ‬ ‫ﺜﺎل‬ ‫اﻟﻤ‬ ‫ﺘﺎﺋﺞ‬ ‫ﻧ‬ ‫ﺮ‬ ‫ﺗﻈﻬ‬ ‫أن‬ ‫ﺎ‬ ‫أردﻧ‬ ‫إذا‬،‫ﺔ‬ ‫ﻓﺠﻤﻠ‬
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫ﺳﺘﻜﻮن‬ ‫اﻟﻄﺒﺎﻋﺔ‬:
‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺼﻮرة‬ ‫ﻋﻠﻰ‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﻧﺘﻴﺠﺔ‬ ‫وﺗﻜﻮن‬:
A=100
X=4.25
main ()
{
int a=100;
float x=4.25
cout<<“a=”<<a<<“n”<<“x=”<<x;
return0;
}

‫ﺑﻠﻐﺔ‬ ‫اﻹدﺧﺎل‬++CStreams
‫ﺘﺨﺪام‬ ‫اﺳ‬ ‫ﺪ‬ ‫ﻳﻌ‬ ‫ﺚ‬ ‫ﺣﻴ‬ ‫ﺎل‬ ‫اﻹدﺧ‬ ‫ﺔ‬ ‫ﻣﻌﺎﻟﺠ‬ ‫ﺒﺪأ‬ ‫اﻟﻤ‬ ‫ﺬا‬ ‫ﻫ‬ ‫ﻨﺎول‬ ‫ﻳﺘ‬streams‫دوال‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻞ‬ ‫اﻓﻀ‬
‫ﻟﻠـﻐﺔ‬ ‫اﻹدﺧﺎل‬C.
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﺠﻤﻠﺔ‬ ‫وﺻﻴﻐﺔ‬:
‫وﻧ‬‫اﻹﺧﺮاج‬ ‫ﺣﻴﺚ‬ ‫اﻹﺧﺮاج‬ ‫ﻋﻤﻠﻴﺔ‬ ‫ﻋﻜﺲ‬ ‫أﻧﻬﺎ‬ ‫ﺸﺎﻫﺪ‬<<‫اﻹدﺧﺎل‬ ‫أﻣﺎ‬>>.
‫ﺮة‬ ‫اﻟﺬاﻛ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻴﺮات‬ ‫ﻟﻠﻤﺘﻐ‬ ‫ﻴﺢ‬ ‫اﻟﻤﻔﺎﺗ‬ ‫ﺔ‬ ‫ﻟﻮﺣ‬ ‫ﺒﺮ‬ ‫ﻋ‬ ‫ﻴﻢ‬ ‫ﻗ‬ ‫ﺎل‬ ‫ﻹدﺧ‬ ‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﺘﺨﺪم‬ ‫وﺗﺴ‬،‫ﺘﻢ‬ ‫وﻳ‬
‫اﻟﻤﻔﺎﺗﻴﺢ‬ ‫ﻟﻮﺣﺔ‬ ‫ﺑﺎﺳﺘﺨﺪام‬ ‫اﻟﺬاﻛﺮة‬ ‫ﻓﻲ‬ ‫اﻟﻤﺘﻐﻴﺮ‬ ‫ﻗﻴﻤﺔ‬ ‫ﺗﻌﻴﻴﻦ‬.
‫ﻣﻼﺣﻈﺔ‬/
‫ﻳﺠﻮ‬ ‫ﻻ‬‫ز‬‫ﺗﻌﺮﻳﻔﺔ‬ ‫ﻗﺒﻞ‬ ‫اﻟﻤﺘﻐﻴﺮ‬ ‫ﻧﺴﺘﺨﺪم‬ ‫أن‬.
‫ﺻﺤﻴﺢ‬ ‫ﻣﺜﺎل‬:
Int x;
Cin>>x;
‫ﺧﺎﻃﺊ‬ ‫ﻣﺜﺎل‬:
Cin>>x;
‫ﻣﺜﺎل‬١٢:
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫ﺑﻄﺒﺎﻋﺘﻪ‬ ‫ﻧﻘﻮم‬ ‫ﺛﻢ‬ ‫اﻟﺘﻄﺒﻴﻖ‬ ‫ﻫﺬا‬ ‫ﻓﻲ‬ ‫ﺻﺤﻴﺢ‬ ‫ﻋﺪد‬ ‫ﺑﺈدﺧﺎل‬ ‫ﻧﻘﻮم‬ ‫ﺳﻮف‬:
‫اﻟﻤﺘﻐﻴﺮ‬ ‫ﺘﻌﺮﻳﻒ‬‫ﺑ‬ ‫ﻨﺎ‬‫ﻗﻤ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﺜﺎل‬‫اﻟﻤ‬ ‫ﺬا‬‫ﻫ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻆ‬‫ﻧﻼﺣ‬a‫ﺑﺄﻧ‬‫ﺗﻨﻔﻴﺬ‬ ‫ﻋﻨﺪ‬ ‫ذﻟﻚ‬ ‫ﺑﻌﺪ‬ ‫ﺻﺤﻴﺢ‬ ‫ﻋﺪد‬ ‫ﻪ‬
‫ﺪد‬ ‫اﻟﻌ‬ ‫ﻨﺪﺧﻞ‬ ‫ﺳ‬ ‫ﺪد‬ ‫ﻋ‬ ‫ﺎل‬ ‫إدﺧ‬ ‫ﻨﺎ‬ ‫ﻣ‬ ‫ﻴﻄﻠﺐ‬ ‫ﺳ‬ ‫ﺒﺮﻧﺎﻣﺞ‬ ‫اﻟ‬10‫ﻨﺎﺗﺞ‬ ‫اﻟ‬ ‫ﻴﻜﻮن‬ ‫ﺳ‬ ‫ﻚ‬ ‫ذﻟ‬ ‫ﻨﺪ‬ ‫ﻋ‬ ‫ﺜﻼ‬ ‫ﻣ‬
‫ﻛﺎﻟﺘﺎﻟﻲ‬:
10
main ()
{
int=a;
cin>>a;
cout<<a;
return0;
}
Cin>>a;

‫ﻣﺜﺎل‬١٣:
‫ﻃﺒﺎﻋﺘﻪ‬ ‫ﺛﻢ‬ ‫ﻋﻤﺮك‬ ‫ﻹدﺧﺎل‬ ‫ﺑﺮﻧﺎﻣﺠﺎ‬ ‫اﻛﺘﺐ‬،‫وﺿﻌﻔﻪ؟‬ ‫ﻧﺼﻒ‬ ‫وﻃﺒﺎﻋﻪ‬
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﻤﺘﻐﻴﺮ‬ ‫ﺑﺘﻌﺮﻳﻒ‬ ‫أوﻻ‬ ‫ﻗﻤﻨﺎ‬ ‫أﻋﻼه‬ ‫اﻟﻤﺜﺎل‬ ‫ﻓﻲ‬:
Int a;
‫اﻟﻌﻤﺮ‬ ‫إدﺧﺎل‬ ‫ﻣﻨﺎ‬ ‫ﻃﻠﺐ‬ ‫ذﻟﻚ‬ ‫ﺑﻌﺪ‬ ‫ﺛﻢ‬:
‫ﻣﺜﻼ‬ ‫ﺳﻨﺪﺧﻞ‬ ‫اﻟﻄﻠﺐ‬ ‫ﻋﻨﺪ‬20
Cin>>a
‫اﻟﻌﻤﺮ‬ ‫ﺑﻄﺒﺎﻋﺔ‬ ‫ﻗﻤﻨﺎ‬ ‫وﺑﻌﺪﻫﺎ‬:
Cout<<a;
‫اﻟﻌﻤﺮ‬ ‫ﻧﺼﻒ‬ ‫ﺑﻄﺒﺎﻋﺔ‬ ‫اﻟﻤﻄﻠﻮب‬ ‫ﺣﺴﺐ‬ ‫ﻗﻤﻨﺎ‬ ‫ﺛﻢ‬:
Cout<<a/2;
‫اﻟﻤﻄﻠ‬ ‫ﺣﺴﺐ‬ ‫ﻗﻤﻨﺎ‬ ‫ﺛﻢ‬‫اﻟﻌﻤﺮ‬ ‫ﺿﻌﻒ‬ ‫ﺑﻄﺒﺎﻋﺔ‬ ‫اﻷﺧﻴﺮ‬ ‫ﻮب‬:
Cout<<a*2;
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﻬﺎﺋﻴﺔ‬ ‫اﻟﻨﺘﻴﺠﺔ‬ ‫ﻟﺘﻜﻮن‬:
20 10 40
main ()
{
int a;
cin>>a;
cout<<a;
cout<<a/2;
cout<<a*2;
return0;
}

‫ﻣﺜﺎل‬١٤:
‫اﻟﻌﺪد‬ ‫وﻟﻴﻜﻦ‬ ‫ﻣﺎ‬ ‫ﻋﺪد‬ ‫ﻹدﺧﺎل‬ ‫ﺑﺮﻧﺎﻣﺠﺎ‬ ‫اﻛﺘﺐ‬7‫ﻟﻪ؟‬ ‫اﻟﻀﺮب‬ ‫ﺟﺪول‬ ‫ﻃﺒﺎﻋﺔ‬ ‫ﺛﻢ‬ ‫وﻣﻦ‬
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺘﻴﺠﺔ‬ ‫ﺳﺘﻜﻮن‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺗﻨﻔﻴﺬ‬ ‫ﻋﻨﺪ‬:
7 14 21 28 35 42 49 56 63 70
‫ﻣﺜﺎل‬١٥:
‫ﻟﻄﺎﻟﺐ‬ ‫ﻋﻼﻣﺎت‬ ‫ﺛﻼث‬ ‫ﻹدﺧﺎل‬ ‫ﺑﺮﻧﺎﻣﺞ‬ ‫اﻛﺘﺐ‬40 25 30‫اﻟﻌﻼﻣﺎت؟‬ ‫ﻣﻌﺪل‬ ‫وﻃﺒﺎﻋﺔ‬
‫ﺛﻢ‬ ‫ﺑﻌﻀﻬﺎ‬ ‫ﻣﻊ‬ ‫أﻋﺪاد‬ ‫اﻟﺜﻼث‬ ‫ﺟﻤﻊ‬ ‫وﻫﻲ‬ ‫ﺎﻋﺪة‬‫ﻗ‬ ‫ﺘﺎﺑﺔ‬‫ﺑﻜ‬ ‫ﻨﺎ‬‫ﻗﻤ‬ ‫ﺮاج‬‫اﻹﺧ‬ ‫ﻞ‬‫ﺟﻤ‬ ‫ﻲ‬‫ﻓ‬ ‫أن‬ ‫ﻆ‬‫ﻧﻼﺣ‬
‫اﻟﻤﻌﺪل‬ ‫ﻹﻇﻬﺎر‬ ‫ﻣﻌﺮوﻓﺔ‬ ‫ﻗﺎﻋﺪة‬ ‫وﻫﻲ‬ ‫ﻋﺪدﻫﺎ‬ ‫ﻋﻠﻰ‬ ‫ﻗﺴﻤﺘﻬﺎ‬..
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺎﺗﺞ‬ ‫ﻳﻜﻮن‬ ‫وﺳﻒ‬:
31
main ()
{
int a;
cin>>a;
cout<<a*1;
cout<<a*2;
cout<<a*3;
cout<<a*4;
cout<<a*5;
cout<<a*6;
cout<<a*7;
cout<<a*8;
cout<<a*9;
cout<<a*10;
return0;
}
‫ﻧﺪﺧﻞ‬ ‫ﻗﻴﻤﺔ‬ ‫إدﺧﺎل‬ ‫ﻃﻠﺐ‬ ‫ﻋﻨﺪ‬
‫اﻟﺮﻗﻢ‬7‫اﻟﺴﺆال‬ ‫ﻃﻠﺐ‬ ‫ﺣﺴﺐ‬..
main ()
{
int a,b,c;
cin>>a>>b>>c;
cout<<(a+b+c)/3;
return0;
}
‫اﻟﻤﻄﻠﻮب‬ ‫ﺣﺴﺐ‬ ‫ﻧﺪﺧﻞ‬40 25
30

‫ﻣﺜﺎل‬١٦:
‫ﻋﺪدﻳﺔ‬ ‫ﻗﻴﻢ‬ ‫ﺛﻼث‬ ‫إدﺧﺎل‬ ‫اﻵن‬ ‫ﺳﻨﺤﺎول‬،‫ﻃﺒﺎﻋﺘﻬﺎ‬ ‫ﺛﻢ‬ ‫وﻣﻦ‬:
‫ﻗﻤﻦ‬ ‫وأﻳﻀﺎ‬ ‫اﻟﻨﻮع‬ ‫ﺣﻴﺚ‬ ‫ﻣﻦ‬ ‫ﻣﺨﺘﻠﻔﺔ‬ ‫ﻗﻴﻢ‬ ‫ﺛﻼث‬ ‫ﺑﺈدﺧﺎل‬ ‫ﻗﻤﻨﺎ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﻼه‬‫أﻋ‬ ‫ﺆال‬‫اﻟﺴ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻆ‬‫ﻧﻼﺣ‬
‫ﺑﺎﺳﺘﺨﺪام‬‫اﻟﺘﻌﻠﻴﻖ‬ ‫وﻫﻲ‬ ‫ﻟﻠﺘﻮﺿﻴﺢ‬ ‫ﻓﻘﻂ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻓﻲ‬ ‫ﺗﺆﺛﺮ‬ ‫ﻻ‬ ‫وﻫﻲ‬ ‫اﻟﺘﻌﻠﻴﻘﺎت‬:
// input all data
output all data//
‫واﻹﺧﺮاج‬ ‫اﻹدﺧﺎل‬ ‫أﻳﻦ‬ ‫ﻟﻠﻤﺴﺘﺨﺪم‬ ‫ﻟﻨﻮﺿﺢ‬..
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺎﺗﺞ‬ ‫ﻳﻜﻮن‬ ‫وﺳﻮف‬:
print the following items
10
6.3
2001.5
this is the end
main ()
{
int a;
float x;
double z;
cin>>a>>x>>z; // input all data
cout<<endl;
cout<<“n print the following items”;
cout<<endl;
cout<<a<<“n”<<x<<“n”<<z; // output all data
cout<<“n this is the end”<<endl;
return0;
}
‫ﻟﺘﻜﻦ‬10
‫ﻟﺘﻜﻦ‬6.3
‫ﻟﺘﻜﻦ‬2001.5

‫ﺪ‬‫ﻗ‬‫ﺮﻧﺎﻣﺞ‬‫ﺑ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺮ‬‫آﺧ‬ ‫ﻰ‬‫إﻟ‬ ‫ﻄﺮ‬‫ﺳ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺘﻘﻞ‬‫ﻧﻨ‬ ‫أن‬ ‫ﺘﺎج‬‫ﻧﺤ‬C++،‫ﺑﺘﻨﻔﻴﺬ‬ ‫ﻧﻘﻮم‬ ‫أن‬ ‫ﻧﺤﺘﺎج‬ ‫ﺪ‬‫وﻗ‬
‫ﺮوط‬ ‫اﻟﺸ‬ ‫ﺾ‬ ‫ﺑﻌ‬ ‫ﻖ‬ ‫ﺗﺤﻘ‬ ‫ﻨﺪ‬ ‫ﻋ‬ ‫ﻞ‬ ‫اﻟﺠﻤ‬ ‫ﺾ‬ ‫ﺑﻌ‬،‫ﻴﺎت‬ ‫ﻋﻤﻠ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻴﺔ‬ ‫ﻋﻤﻠ‬ ‫ﺮر‬ ‫ﻧﻜ‬ ‫أن‬ ‫ﺘﺎج‬ ‫ﻧﺤ‬ ‫ﺪ‬ ‫وﻗ‬
‫ﺮات‬ ‫اﻟﻤ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺪدا‬ ‫ﻋ‬ ‫ﺎب‬ ‫اﻟﺤﺴ‬ ‫أو‬ ‫ﺮاج‬ ‫اﻹﺧ‬ ‫أو‬ ‫ﺎل‬ ‫اﻹدﺧ‬،‫ﻦ‬ ‫ﻣ‬ ‫ﺒﻜﺔ‬ ‫ﺷ‬ ‫ﻲ‬ ‫ﻧﺒﻨ‬ ‫أن‬ ‫ﺘﺎج‬ ‫ﻧﺤ‬ ‫ﺪ‬ ‫وﻗ‬
‫ﺒﺮﻧﺎﻣﺞ‬ ‫اﻟ‬ ‫ﻄﻮر‬ ‫ﺳ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺪد‬ ‫ﻋ‬ ‫ﻰ‬‫ﻋﻠ‬ ‫ﺮ‬‫اﻷواﻣ‬ ‫ﻊ‬‫ﺗﻮزﻳ‬،‫ﻣ‬ ‫ﺐ‬ ‫ﺣﺴ‬‫ﻮال‬‫اﻷﺣ‬ ‫ﺾ‬‫ﺑﻌ‬ ‫ﻴﺎت‬ ‫ﻘﺘﻀ‬،
‫ﺄﻟﺔ‬‫اﻟﻤﺴ‬ ‫ﻴﻌﺔ‬‫ﻃﺒ‬ ‫ﻴﻪ‬‫ﺗﻘﺘﻀ‬ ‫ﺒﻤﺎ‬‫وﺣﺴ‬،‫ﺎﻻت‬‫اﻟﺤ‬ ‫ﺬه‬‫ﻫ‬ ‫ﻲ‬‫ﻓ‬:‫اﻟﺸﺮط‬ ‫ﺎﻟﻴﺐ‬‫أﺳ‬ ‫ﺘﻌﻠﻢ‬‫ﻧ‬ ‫أن‬ ‫ﺘﺎج‬‫ﻧﺤ‬،
‫ﺘﻜﺮار‬‫اﻟ‬ ‫ﺎﻟﻴﺐ‬‫وأﺳ‬،‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫ﺎر‬‫ﻣﺴ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺘﺤﻜﻢ‬‫اﻟ‬ ‫ﻴﺔ‬‫وﻛﻴﻔ‬،‫واﻟﺘﺤﻜﻢ‬ ‫ﺮط‬‫اﻟﺸ‬ ‫ﺎﻟﻴﺐ‬‫أﺳ‬ ‫ﺪ‬‫وﺗﻌ‬
‫اﻟﺒﺮﻣﺠﺔ‬ ‫ﻟﻐﺎت‬ ‫ﺟﺴﻢ‬ ‫ﻓﻲ‬ ‫اﻟﻘﻠﺐ‬ ‫ﺑﻤﺜﺎﺑﺔ‬ ‫واﻟﺘﻜﺮار‬،‫ﺑﺮﻧﺎﻣﺞ‬ ‫آي‬ ‫ﺗﻨﻈﻴﻢ‬ ‫ﻳﻤﻜﻦ‬ ‫ﻻ‬ ‫وﺑﺪوﻧﻬﺎ‬.
‫ﺮ‬‫وﺗﻮﻓ‬‫ﺔ‬‫ﻟﻐ‬C++‫ﺔ‬‫اﻟﻔﻌﺎﻟ‬ ‫ﺪوال‬‫واﻟ‬ ‫ﺎﻟﻴﺐ‬‫اﻷﺳ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺪدا‬‫ﻋ‬ ‫ﺒﺮﻣﺞ‬‫ﻟﻠﻤ‬،‫اﻟﺸﺄن‬ ‫ﺑﻬﺬا‬ ‫ﺘﻌﻠﻘﺔ‬‫اﻟﻤ‬،
‫ﻴﻮﻳﺔ‬ ‫ﺑﻨ‬ ‫أو‬ ‫ﻴﺔ‬ ‫ﺑﻨﺎﺋ‬ ‫ﺎﻟﻴﺐ‬ ‫أﺳ‬ ‫ﺎ‬ ‫ﺑﺄﻧﻬ‬ ‫ﺎﻟﻴﺐ‬ ‫اﻷﺳ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﺘﺎز‬ ‫وﺗﻤ‬structured‫ﻴﻢ‬ ‫ﺗﻨﻈ‬ ‫ﻦ‬ ‫ﻳﻤﻜ‬ ‫آي‬
‫ﻴﻬﺎ‬‫ﻓ‬ ‫ﺘﻜﺮار‬‫واﻟ‬ ‫ﺘﺤﻜﻢ‬‫اﻟ‬ ‫ﻴﺎت‬‫ﻋﻤﻠ‬،‫دون‬ ‫ﺘﻬﺎ‬‫ﻧﻬﺎﻳ‬ ‫ﺘﻰ‬‫وﺣ‬ ‫ﻴﺎت‬‫اﻟﻌﻤﻠ‬ ‫ﺔ‬‫ﺑﺪاﻳ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻲ‬‫ذاﺗ‬ ‫ﻠﻮب‬‫ﺑﺄﺳ‬
‫ﻟﻌ‬ ‫ا‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﻨﺎء‬ ‫أﺛ‬ ‫ﺒﺮﻣﺞ‬ ‫اﻟﻤ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻞ‬ ‫ﺗﺪﺧ‬‫ﻴﺎت‬ ‫ﻤﻠ‬،‫ﻞ‬ ‫ﻟﻜ‬ ‫ﻴﻂ‬ ‫واﻟﺘﺨﻄ‬ ‫ﻴﻪ‬ ‫اﻟﺘﻮﺟ‬ ‫ﻰ‬ ‫ﻋﻠ‬ ‫ﺮاف‬ ‫ﻟﻸﺷ‬
‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫ﻮات‬‫ﺧﻄ‬ ‫ﻦ‬‫ﻣ‬ ‫ﻮه‬‫ﺧﻄ‬،‫اﻟﺒﻨﻴﻮﻳﺔ‬ ‫اﻟﺒﺮﻣﺠﺔ‬ ‫واﻟﻤﺨﺘﺼﻴﻦ‬ ‫ﺒﺮاء‬‫اﻟﺨ‬ ‫ﺾ‬‫ﺑﻌ‬ ‫ﺮف‬‫وﻳﻌ‬:
‫اﻻﻧﺘﻘﺎل‬ ‫ﺔ‬‫ﺟﻤﻠ‬ ‫ﺘﻌﻤﻞ‬‫ﺗﺴ‬ ‫ﻻ‬ ‫ﻲ‬‫اﻟﺘ‬ ‫ﺒﺮﻣﺠﺔ‬‫اﻟ‬ ‫ﺎ‬‫أﻧﻬ‬GOTO،‫ﺧﻄﻮة‬ ‫ﻛﻞ‬ ‫ﻓﻲ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻟﺘﻮﺟﻴﻪ‬
،‫ﺔ‬ ‫ﻟﻐ‬ ‫ﺎن‬ ‫ﻓ‬ ‫ﻚ‬ ‫ذﻟ‬ ‫ﻊ‬ ‫وﻣ‬C++،‫ﺬه‬ ‫ﻫ‬ ‫ﺘﻘﺎل‬ ‫اﻻﻧ‬ ‫ﺔ‬ ‫ﺟﻤﻠ‬ ‫ﺮ‬ ‫ﺗﻮﻓ‬،‫إﻻ‬ ‫ﺘﻌﻤﻞ‬ ‫ﺗﺴ‬ ‫ﻻ‬ ‫ﻨﻬﺎ‬ ‫ﻟﻜ‬
‫ﻟﻠﻀﺮورة‬.
‫ﻮاﺑﺎ‬‫ﺻ‬ ‫ﻮن‬ ‫ﻳﻜ‬ ‫أن‬ ‫ﺎ‬‫أﻣ‬ ‫ﺮط‬ ‫اﻟﺸ‬ ‫ﻮاب‬‫ﺟ‬ ‫أن‬ ‫ﺚ‬‫وﺣﻴ‬true‫ﺎ‬‫زاﺋﻔ‬ ‫أو‬false‫ﺔ‬ ‫ﻟﻐ‬ ‫ﺎن‬‫ﻓ‬C++،
‫ﻔﺮ‬ ‫اﻟﺼ‬ ‫ﻦ‬ ‫ﻋ‬ ‫ﺘﻠﻒ‬ ‫ﺗﺨ‬ ‫ﺔ‬ ‫ﻋﺪدﻳ‬ ‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﺎﺋﺒﺔ‬ ‫اﻟﺼ‬ ‫ﺔ‬ ‫اﻟﺤﺎﻟ‬ ‫ﻲ‬ ‫ﺗﻌﻄ‬،‫ﺔ‬ ‫ﻟﻠﺤﺎﻟ‬ ‫ﻔﺮ‬ ‫ﺻ‬ ‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﻲ‬ ‫وﺗﻌﻄ‬
‫ﺰاﺋﻔﺔ‬‫اﻟ‬)‫ﺮوط‬‫اﻟﺸ‬ ‫أو‬ ‫ﺮط‬‫اﻟﺸ‬ ‫ﻖ‬‫ﺗﺤﻘ‬ ‫ﺪم‬‫ﻋ‬ ‫ﻨﺪ‬‫ﻋ‬(‫ﻟﻐﺔ‬ ‫ﻓﺎن‬ ‫ﺬا‬‫وﻟ‬C++‫ﻛﺒﻴﺮة‬ ‫ﻣﺮوﻧﺔ‬ ‫ﺗﻮﻓﺮ‬
‫اﻟﺪوال‬ ‫ﻣﻦ‬ ‫ﻛﺒﻴﺮ‬ ‫ﻋﺪد‬ ‫اﺳﺘﺨﺪام‬ ‫ﻓﻲ‬،‫وﻓﺎﺋﻘﺔ‬ ‫ﻓﻌﺎﻟﺔ‬ ‫ﺑﻄﺮﻳﻘﺔ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺗﻮﺟﻴﻪ‬ ‫وﻓﻲ‬.
‫واﻟﺘﻜﺮار‬ ‫واﻟﺸﺮط‬ ‫اﻟﺘﺤﻜﻢ‬ ‫ﺟﻤﻞ‬
ProgramControl,Conditional&Loop Statements

‫اﻟﺸﺮﻃﻴﺔ‬ ‫اﻟﺠﻤﻞ‬
‫ﻟﻐﺔ‬ ‫ﺗﺘﻌﺎﻣﻞ‬C++‫وﻫﻲ‬ ‫اﻟﺸﺮط‬ ‫ﺟﻤﻞ‬ ‫ﻣﻦ‬ ‫أﻧﻮاع‬ ‫ﺛﻼﺛﺔ‬ ‫ﻣﻊ‬:
١-‫وأﺧﻮاﺗﻬﺎ‬ ‫اﻟﺸﺮﻃﻴﺔ‬ ‫إذا‬ ‫ﺟﻤﻠﺔ‬if statements
٢-‫اﻟﺘﻮزﻳﻊ‬ ‫ﺟﻤﻠﺔ‬switch statement
٣-‫اﻟﺸﺮط‬ ‫أداة‬ ‫ﺟﻤﻠﺔ‬?
‫وأﺧﻮاﺗﻬﺎ‬ ‫إذا‬ ‫اﻟﺸﺮط‬ ‫ﺟﻤﻠﺔ‬if statements
-‫إ‬ ‫اﻟﺸﺮط‬ ‫ﺟﻤﻠﺔ‬‫وأﺧﻮاﺗﻬﺎ‬ ‫ذا‬if statements
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻌﺎم‬ ‫اﻟﺸﻜﻞ‬ ‫اﻟﺠﻤﻠﺔ‬ ‫ﻫﺬه‬ ‫ﺗﺄﺧﺬ‬:
If (condition) statement1;
‫ﻨﺎ‬ ‫ﻫ‬ ‫ﺮﻃﻴﺔ‬ ‫اﻟﺸ‬ ‫إذا‬ ‫ﺔ‬ ‫ﺟﻤﻠ‬ ‫ﻮم‬ ‫ﺗﻘ‬،‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﻰ‬ ‫إﻟ‬ ‫ﺒﺮﻧﺎﻣﺞ‬ ‫اﻟ‬ ‫ﻴﺬ‬ ‫ﺗﻨﻔ‬ ‫ﻞ‬ ‫ﺗﺴﻠﺴ‬ ‫ﻨﻘﻞ‬ ‫ﺑ‬)‫ﻠﺔ‬ ‫ﺳﻠﺴ‬ ‫أو‬
‫ﺔ‬ ‫اﻟﺠﻤﻠ‬(statement1‫ﺮط‬ ‫اﻟﺸ‬ ‫ﺘﺤﻘﻖ‬ ‫ﻳ‬ ‫ﻨﺪﻣﺎ‬ ‫ﻋ‬)‫ﺮوط‬ ‫اﻟﺸ‬ ‫أو‬(condition‫ﻮن‬ ‫وﺗﻜ‬
‫ﺘﻪ‬ ‫ﻧﺘﻴﺠ‬true،‫ﺘﺤﻘﻖ‬ ‫ﻳ‬ ‫ﻢ‬ ‫ﻟ‬ ‫وإذا‬‫ﺮط‬ ‫اﻟﺸ‬،‫ﻴﺠﺔ‬ ‫اﻟﻨﺘ‬ ‫ﻮن‬ ‫ﺗﻜ‬ ‫أي‬false،‫ﺘﻘﻞ‬ ‫ﻳﻨ‬ ‫ﻴﺬ‬ ‫اﻟﺘﻨﻔ‬ ‫ﺎن‬ ‫ﻓ‬
‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﻰ‬ ‫إﻟ‬ ‫ﻮرا‬ ‫ﻓ‬)‫ﻞ‬ ‫اﻟﺠﻤ‬ ‫ﻠﺔ‬ ‫ﺳﻠﺴ‬ ‫أو‬(statment2‫ﺘﻌﻤﺎل‬ ‫اﺳ‬ ‫ﺪ‬ ‫وﻳﻌ‬else‫ﻲ‬ ‫ﻓ‬C++
‫ﻴﺎرﻳﺎ‬‫اﺧﺘ‬،‫ﻜﻠﻬﺎ‬‫ﺷ‬ ‫ﻮن‬‫وﻳﻜ‬ ‫واداء‬ ‫ﺒﺎ‬‫ﺗﺮﻛﻴ‬ ‫ﺮﻃﻴﺔ‬‫اﻟﺸ‬ ‫ﺔ‬‫اﻟﺠﻤﻠ‬ ‫ﺘﺄﺛﺮ‬‫ﺗ‬ ‫أن‬ ‫دون‬ ‫ﺎ‬‫ﺣﺬﻓﻬ‬ ‫ﻦ‬‫ﻳﻤﻜ‬ ‫أي‬
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫اﻟﻌﺎم‬:
If (condition) statement1;
Else statment2;
‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﺘﻨﻔﺬ‬ ‫ﺳ‬ ‫ﺔ‬ ‫اﻟﺤﺎﻟ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﻲ‬ ‫وﻓ‬statement1‫ﺮط‬ ‫اﻟﺸ‬ ‫ﻖ‬ ‫ﺗﺤﻘ‬ ‫أن‬condition‫ﺎن‬ ‫ﻓ‬ ‫وإﻻ‬
‫ﺳﻄﺮ‬ ‫إﻟﻰ‬ ‫ﻳﻨﺘﻘﻞ‬ ‫اﻟﺘﻨﻔﻴﺬ‬C++‫ﻟﺠﻤﻠﺔ‬ ‫اﻟﺘﺎﻟﻲ‬if.
‫اﻷوﻟﻰ‬ ‫اﻟﺼﻴﻐﺔ‬
‫اﻟﻌﺎﻣﻠﺔ‬ ‫اﻟﺒﻨﻴﺔ‬ ‫وﺗﺄﺧﺬ‬If (condition) statement1

‫ﺑﻠﻐﺔ‬ ‫ﺑﺮﻧﺎﻣﺠﺎ‬ ‫اﻛﺘﺐ‬C++‫اﻟﻌﺒﺎرة‬ ‫ﻹﻇﻬﺎر‬x is positive‫اﻟﻌﺮض؟‬ ‫ﺷﺎﺷﺔ‬ ‫ﻋﻠﻰ‬
‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﺘﻈﻬﺮ‬ ‫ﺳ‬ ‫ﺜﺎل‬ ‫اﻟﻤ‬ ‫ﺬا‬ ‫ﻫ‬ ‫ﻲ‬ ‫ﻓ‬Saudi‫ﺮط‬ ‫اﻟﺸ‬ ‫ﻻن‬ ‫ﺔ‬ ‫اﻟﺸﺎﺷ‬ ‫ﻰ‬ ‫ﻋﻠ‬x>0)(‫ﺘﺤﻘﻖ‬ ‫ﻣ‬
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫ﻓﺎﻟﻨﺘﻴﺠﺔ‬ ‫ﺻﻔﺮ‬ ‫اﻟﻌﺪد‬ ‫ﻣﻦ‬ ‫اﻛﺒﺮ‬ ‫ﺑﺎﻟﻄﺒﻊ‬ ‫ﻓﺎﻟﺨﻤﺴﺔ‬:
Saudi
‫ﺑﺮ‬ ‫اﻛﺘﺐ‬‫ﻧﺎﻣﺞ‬C++‫ﻟـ‬ ‫اﻟﻤﻄﻠﻘﺔ‬ ‫اﻟﻘﻴﻤﺔ‬ ‫ﻟﻴﺤﺴﺐ‬ ‫اﻟﺘﺎﻟﻲ‬Y‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫اﻟﻤﻌﺮﻓﺔ‬:
x;x>=0
Y=|x|=
-x;x<0
‫اﻟﻤﺜ‬ ‫ﻓﻲ‬‫اﻟﺮﻗﻢ‬ ‫ﻧﺪﺧﻞ‬ ‫ﺳﻮف‬ ‫أﻋﻼه‬ ‫ﺎل‬10‫اﻟﻨﺘﻴﺠﺔ‬ ‫ﻟﺘﻜﻮن‬:
10
main ()
{
int x=5;
if (x>0)
cout<<x<<“ Saudi”;
return0;
}
main ()
{
int x;
cin>>x;
if (x>=0) cout<<x;
else cout<<-x;
return0;
}
‫اﻟﻌﺪد‬ ‫ﺑﺈدﺧﺎل‬ ‫ﻧﻘﻮم‬10

‫ﺗﺴﺎوي‬ ‫أو‬ ‫اﻛﺒﺮ‬ ‫اﻟﻌﻼﻣﺔ‬ ‫ﻛﺎﻧﺖ‬ ‫ﻓﺈذا‬ ‫ﻃﺎﻟﺐ‬ ‫ﺔ‬‫ﻋﻼﻣ‬ ‫ﺎل‬‫ﻹدﺧ‬ ‫ﺮﻧﺎﻣﺞ‬‫ﺑ‬ ‫ﺎء‬‫ﺑﺈﻧﺸ‬ ‫ﻢ‬‫ﻗ‬90‫ﻓﺎﻟﺘﻘﺪﻳﺮ‬
A)(‫ﺎوي‬ ‫ﺗﺴ‬ ‫أو‬ ‫ﺒﺮ‬ ‫اﻛ‬ ‫ﺖ‬ ‫ﻛﺎﻧ‬ ‫إذا‬ ‫ﺎ‬ ‫أﻣ‬80‫ﺘﻘﺪﻳﺮ‬ ‫ﻓﺎﻟ‬B)(‫ﺎوي‬ ‫ﺗﺴ‬ ‫أو‬ ‫ﺒﺮ‬ ‫اﻛ‬ ‫ﺖ‬ ‫ﻛﺎﻧ‬ ‫إذا‬ ‫ﺎ‬ ‫أﻣ‬
70‫ﺘﻘﺪﻳﺮ‬ ‫ﻓﺎﻟ‬)(C‫ﺎوي‬‫ﺗﺴ‬ ‫أو‬ ‫ﺒﺮ‬ ‫اﻛ‬ ‫ﺖ‬ ‫ﻛﺎﻧ‬ ‫إذا‬ ‫ﺎ‬‫أﻣ‬60‫ﺘﻘﺪﻳﺮ‬ ‫ﻓﺎﻟ‬D)(‫ﺒﺮ‬ ‫اﻛ‬ ‫ﺖ‬‫ﻛﺎﻧ‬ ‫إذا‬ ‫ﺎ‬ ‫أﻣ‬
‫ﺗﺴﺎوي‬ ‫أو‬50‫ﻓﺎﻟﺘﻘﺪﻳﺮ‬E)(‫ﻓﺎﻟﺘﻘﺪﻳﺮ‬ ‫ذﻟﻚ‬ ‫ﻋﺪا‬ ‫ﻣﺎ‬(F)‫؟‬
‫ﻓ‬‫ﻴﺮ‬ ‫اﻟﻤﺘﻐ‬ ‫ﺘﻌﺮﻳﻒ‬ ‫ﺑ‬ ‫ﻨﺎ‬ ‫ﻗﻤ‬ ‫ﻼه‬ ‫أﻋ‬ ‫ﺜﺎل‬ ‫اﻟﻤ‬ ‫ﻲ‬mark‫ﻚ‬ ‫ذﻟ‬ ‫ﺪ‬ ‫ﺑﻌ‬ ‫ﻨﺎ‬ ‫ﻗﻤ‬ ‫ﻢ‬ ‫ﺛ‬ ‫ﺤﻴﺢ‬ ‫ﺻ‬ ‫ﺪد‬ ‫ﻋ‬ ‫ﻪ‬ ‫ﺑﺄﻧ‬
‫اﻟﻤﺘﻐﻴﺮ‬ ‫ﺑﺘﻌﺮﻳﻒ‬grade‫اﻟﺘﻘﺪﻳﺮ‬ ‫وﻫﻮ‬ ‫ﻧﺼﻴﻪ‬ ‫ﻗﻴﻤﺔ‬ ‫ﺑﺄﻧﻪ‬.
‫وﻫﻲ‬ ‫اﻟﺪرﺟﺔ‬ ‫ﺑﺈدﺧﺎل‬ ‫ﻗﻤﻨﺎ‬ ‫ﻃﺒﻌﺎ‬85‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﻌﻼﻣﺔ‬ ‫ﺗﻜﻮن‬ ‫ﺳﻮف‬:
B
main ()
{
int mark;
char grade;
cin>>mark;
if (mark>=90)
grade='a';
else
if (mark>=80)
grade='b';
else
if (mark>=70)
grade='c';
else
if (mark>=60)
grade='d';
else
if (mark>=50)
grade='e';
else
grade='f';
cout<<grade;
return0;
}
‫اﻟﺪرﺟﺔ‬ ‫ﺗﻌﺮﻳﻒ‬
‫اﻟﺘﻘﺪﻳﺮ‬ ‫ﺗﻌﺮﻳﻒ‬
‫ﻣﺜﻼ‬ ‫ﺳﻨﺪﺧﻞ‬
‫اﻟﺪرﺟﺔ‬85

‫اﻟﺜﺎﻧﻴﺔ‬ ‫اﻟﺼﻴﻐﺔ‬
‫إذا‬ ‫ﻟﺠﻤﻠﺔ‬ ‫اﻟﻌﺎﻣﻠﺔ‬ ‫اﻟﺒﻨﻴﺔ‬ ‫وﺗﺄﺧﺬ‬....‫وإﻻ‬(if..else)‫اﻟﺸﻜﻞ‬‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻌﺎم‬:
If (condition)
{
statmenet1;
}
else
{
statmenet1;
}
‫اﻟﺴﺎﺑﻖ‬ ‫اﻟﻤﺜﺎل‬ ‫ﻧﻄﺒﻖ‬ ‫ﺳﻮف‬)3(‫ﺑﺎﻟﺸﻜﻞ‬ ‫ﻟﻜﻦ‬(if..else)‫ﻳﻠﻲ‬ ‫ﻛﻤﺎ‬ ‫أﻋﻼه‬:
0#include “ stdafx.h”
main ()
{
int mark;
char grade;
cin>>mark;
if ( mark>=90){
grade='A';
{
else
if (mark>=80){
grade='B';
{
else
if (mark>=70){
grade='C';
{
else
if (mark>=60){
grade='D';
{
else
if (mark>=50){
grade='E';
}
cout<<grade;
return0;
}
‫اﻷ‬ ‫إذا‬‫وﺟﻮاﺑﻬﺎ‬ ‫وﻟﻰ‬
‫وﺟﻮاﺑﻬﺎ‬ ‫اﻟﺜﺎﻧﻴﺔ‬ ‫إذا‬
‫وﺟﻮاﺑﻬﺎ‬ ‫اﻟﺜﺎﻟﺜﺔ‬ ‫إذا‬
‫وﺟﻮاﺑﻬﺎ‬ ‫اﻟﺮاﺑﻌﺔ‬ ‫إذا‬
‫اﻟﺒﺎﻗﻴﺔ‬ ‫ﻓﺎﻟﻨﺘﻴﺠﺔ‬ ‫وإﻻ‬
‫اﻟﺨﺎﻣﺴﺔ‬ ‫ﻫﻲ‬
‫اﻟﺘﻘﺪﻳﺮ‬ ‫ﻟﻄﺒﺎﻋﺔ‬

‫ﻴﻠﻚ‬‫زﻣ‬ ‫ﻮل‬‫وﻃ‬ ‫ﻚ‬‫ﻃﻮﻟ‬ ‫ﺎل‬‫ﻹدﺧ‬ ‫ﺮﻧﺎﻣﺠﺎ‬‫ﺑ‬ ‫ﺐ‬‫اﻛﺘ‬،‫زﻣﻴﻠﻚ‬ ‫ﻃﻮل‬ ‫ﻦ‬‫ﻣ‬ ‫ﺒﺮ‬‫اﻛ‬ ‫ﻚ‬‫ﻃﻮﻟ‬ ‫ﺎن‬‫ﻛ‬ ‫وإذا‬
‫ﻃﻮﻟﻚ‬ ‫اﻃﺒﻊ‬،‫اﻷﻃﻮال‬ ‫ﻣﻌﺪل‬ ‫واﺣﺴﺐ‬،‫اﻃﺒﻌﻪ‬ ‫ﺛﻢ‬‫وأﻻ‬
‫زﻣﻴﻠﻚ‬ ‫ﻃﻮل‬ ‫اﻃﺒﻊ‬،‫اﻟﻄﻮل؟‬ ‫وﻧﺼﻒ‬ ‫اﻟﻄﻮل‬ ‫ﺿﻌﻒ‬ ‫واﻃﺒﻊ‬
‫اﻟﺤـﻞ‬/
‫ﻟﻄﻮﻟﻚ‬ ‫ﺳﻨﺮﻣﺰ‬t1‫زﻣﻴﻠﻚ‬ ‫ﻟﻄﻮل‬ ‫وﺳﻨﺮﻣﺰ‬t2
main ()
{
int t1,t2;
cin>>t1>>t2;
if (t1>t2)
{
cout<<t1;
cout<<(t1+t2)/2;
}
else
{
cout<<t2;
cout<<t2*2;
cout<<t2/2;
}
return0;
}
‫اﻟﻄﻮل‬ ‫ﻧﺼﻒ‬ ‫ﻟﻄﺒﺎﻋﺔ‬
‫اﻟﻄﻮل‬ ‫ﺿﻌﻒ‬ ‫ﻟﻄﺒﺎﻋﺔ‬
‫ﻣﻌﺪل‬ ‫ﻃﺒﺎﻋﺔ‬
‫اﻷﻃﻮال‬
‫اﻷﻃﻮال‬ ‫أدﺧﻞ‬
‫وإﻻ‬

‫اﻟﺘﻮزﻳﻊ‬ ‫ﺟﻤﻠﺔ‬switch statement
‫ﺟﻤﻠﺔ‬ ‫ﺗﺄﺧﺬ‬Switch‫ﻟﻐﺔ‬ ‫ﻓﻲ‬ ‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻌﺎم‬ ‫اﻟﺸﻜﻞ‬c++:
Switch (expression)
{
Case constant1: statments1; break;
Case constant2: statments2; break;
......................................................
......................................................
......................................................
Case constantn: statmentsn; break;
Default; last statements;
}
‫واﻟﻨﺘﻴﺠﺔ‬:
y
‫ﺻﺤﻴﺤﺔ‬ ‫ﻗﻴﻤﺘﻪ‬ ‫ﺗﻌﺒﻴﺮ‬
‫ﻋﻨﺪﻣﺎ‬ ‫ﺗﻨﻔﺬ‬ ‫ﺟﻤﻞ‬ ‫أو‬ ‫ﺟﻤﻠﺔ‬
‫اﻟ‬ ‫ﺳﺎوي‬‫ﻗﻴﻤﺔ‬ ‫ﺘﻌﺒﻴﺮ‬
constant1
‫ﻋﻨﺪﻣﺎ‬ ‫ﺗﻨﻔﺬ‬ ‫ﺟﻤﻞ‬ ‫أو‬ ‫ﺟﻤﻠﺔ‬
‫ﻗﻴﻤﺔ‬ ‫اﻟﺘﻌﺒﻴﺮ‬ ‫ﺳﺎوي‬
constant2
‫ﺗﻨﻔﻴﺬ‬ ‫ﻋﺪم‬ ‫ﻋﻨﺪ‬ ‫ﺗﻨﻔﻴﺬﻫﺎ‬ ‫ﻳﺘﻢ‬
‫اﻟﻮاردة‬ ‫اﻟﺤﺎﻻت‬ ‫ﺟﻤﻴﻊ‬
‫ﺑﻨﻴﺔ‬ ‫ﻓﻲ‬ ‫أﻋﻼه‬Switch
void main()
{
int s1;
s1=2;
switch (s1)
{
case 2 :cout<<"y";
break;
case 3: cout<<"x";
break;
case 4: cout<<"m";
break;
default: cout<<"w";
}
}

‫اﻟﺸﺮط‬ ‫أداة‬ ‫ﺟﻤﻠﺔ‬?
‫إذا‬ ‫ﻴﺔ‬ ‫ﻟﺒﻨ‬ ‫ﺌﺔ‬ ‫ﻣﻜﺎﻓ‬ ‫ﺮﻳﻌﺔ‬ ‫ﺳ‬ ‫أداة‬ ‫ﻲ‬ ‫وﻫ‬...‫وإﻻ‬،‫أول‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺘﻌﻤﺎﻟﻬﺎ‬ ‫اﺳ‬ ‫ﻴﺔ‬ ‫ﻛﻴﻔ‬ ‫ﻨﺎ‬ ‫ﻣﻌ‬ ‫ﺮ‬ ‫ﻣ‬ ‫ﺪ‬ ‫وﻗ‬
‫اﻟﻌﺎﻣﺔ‬ ‫ﺻﻮرﺗﻬﺎ‬ ‫ﻫﻨﺎ‬ ‫ﻧﻮرد‬ ‫وﺳﻮف‬ ‫اﻟﻜﺘﺎب‬:
Variable=(condition)? Result:result2;
‫ﻨﺎﻫﺎ‬ ‫وﻣﻌ‬:‫ﻰ‬ ‫اﻷوﻟ‬ ‫ﻴﺠﺔ‬ ‫اﻟﻨﺘ‬ ‫ﻴﺬ‬ ‫ﺗﻨﻔ‬ ‫ﺘﻢ‬ ‫ﻳ‬ ‫ﻪ‬ ‫اﻧ‬result1‫ﻨﺪﻣ‬ ‫ﻋ‬‫ﺮط‬ ‫اﻟﺸ‬ ‫ﻮاب‬ ‫ﺟ‬ ‫ﻮن‬ ‫ﻳﻜ‬ ‫ﺎ‬
condition‫ﺘﺤﻘﻘﺎ‬ ‫ﻣ‬(true)،‫ﻴﺔ‬ ‫اﻟﺜﺎﻧ‬ ‫ﻴﺠﺔ‬ ‫اﻟﻨﺘ‬ ‫ﻴﺬ‬ ‫ﺗﻨﻔ‬ ‫ﺘﻢ‬ ‫ﻓﻴ‬ ‫وإﻻ‬result2‫ﻮن‬ ‫ﻳﻜ‬ ‫ﻨﺪﻣﺎ‬ ‫ﻋ‬
‫اﻟﺸﺮط‬ ‫ﺟﻮاب‬(false).
‫ﻣﺜﺎل‬٧:
‫أن‬ ‫ﻨﺎﻫﺎ‬‫وﻣﻌ‬b‫ﻴﻤﺔ‬‫اﻟﻘ‬ ‫ﺄﺧﺬ‬‫ﺗ‬10‫ﺮط‬‫اﻟﺸ‬ ‫ﻖ‬‫ﺗﺤﻘ‬ ‫إذا‬a>1‫ﻴﻤﺔ‬‫اﻟﻘ‬ ‫ﺄﺧﺬ‬‫وﺗ‬20‫ﻳﺘﺤﻘﻖ‬ ‫ﻢ‬‫ﻟ‬ ‫إذا‬
‫ﻧﻔﺴﻪ‬ ‫اﻟﺸﺮط‬.
‫واﻟﻨﺘﻴﺠﺔ‬:
10
void main()
{
int a,b;
a=5;
if (a>1) b=10;
else
b=20;
cout<<b;
}

‫اﻟﺘﻜﺮار‬‫اﻟﺘﻜﺮار‬ ‫وﺣﻠﻘﺎت‬Repetition and Loops
‫ﺔ‬‫ﻟﻐ‬ ‫ﺮ‬‫ﺗﻮﻓ‬C++،‫ﺒﺮﻣﺠﺔ‬‫اﻟ‬ ‫ﺎت‬‫ﻟﻐ‬ ‫ﺎﺋﺮ‬‫ﻛﺴ‬،‫اﻟﻤﺸﺮوط‬ ‫اﻟﺘﻜﺮار‬ ‫أﺳﺎﻟﻴﺐ‬ ‫ﻣﻦ‬ ‫ﻋﺪدا‬،‫وﻏﻴﺮ‬
‫اﻷﺳﺎﻟﻴﺐ‬ ‫ﻫﺬه‬ ‫وﻣﻦ‬ ‫اﻟﻤﺸﺮوط‬:
‫ﺣﻠﻘﺔ‬ ‫ﺑﺎﺳﺘﻌﻤﺎل‬ ‫اﻟﺘﻜﺮار‬ ‫أﺳﻠﻮب‬For
‫ﺑﺎﺳﺘﻌﻤﺎل‬ ‫اﻟﺘﻜﺮار‬ ‫أﺳﻠﻮب‬ ‫ﻳﻤﺘﻠﻚ‬for‫وﻣﺮوﻧﺔ‬ ‫ﻗﻮة‬،‫اﻟﻠﻐﺎت‬ ‫ﻣﻦ‬ ‫ﻏﻴﺮﻫﺎ‬ ‫ﻓﻲ‬ ‫ﺗﺘﻮﻓﺮان‬ ‫ﻻ‬.
‫اﻷوﻟﻰ‬ ‫اﻟﻌﺎﻣﺔ‬ ‫اﻟﺼﻴﻐﺔ‬
For ( initial-value; condition; increment ) statement;
‫ﺔ‬‫ﺟﻤﻠ‬ ‫ﻮم‬‫ﺗﻘ‬For‫ﺑﺘﻨﻔ‬ ‫اﻻﺑﺘﺪاﺋﻴﺔ‬ ‫ﺪاد‬‫اﻟﻌ‬ ‫ﻴﻤﺔ‬‫ﺑﻘ‬ ‫ﺘﺪﺋﺔ‬‫ﻣﺒ‬ ‫ﻨﺎ‬‫ﻫ‬‫اﻟﺠﻤﻠﺔ‬ ‫ﻴﺬ‬statement1‫ﻣﺮة‬ ‫أول‬
،‫ﺔ‬ ‫ﺟﻤﻠ‬ ‫ﻨﻔﺬ‬ ‫ﺗ‬ ‫ﻢ‬ ‫ﺛ‬ ‫ﺰﻳﺎدة‬ ‫اﻟ‬ ‫ﺪار‬ ‫ﺑﻤﻘ‬ ‫ﺪاد‬ ‫ﻟﻠﻌ‬ ‫ﻴﺔ‬ ‫اﻻﺑﺘﺪاﺋ‬ ‫ﻴﻤﺔ‬ ‫اﻟﻘ‬ ‫ﺰداد‬ ‫ﺗ‬ ‫ﻴﺔ‬ ‫اﻟﺘﺎﻟ‬ ‫ﺮة‬ ‫اﻟﻤ‬ ‫ﻲ‬ ‫وﻓ‬
statement1‫ﻴﺔ‬‫ﺛﺎﻧ‬ ‫ﺮة‬‫ﻣ‬..‫اﻟﺸﺮط‬ ‫ﺘﻜﻤﻞ‬‫ﻳﺴ‬ ‫ﺘﻰ‬‫ﺣ‬ ‫ﺬا‬‫وﻫﻜ‬condition‫ﻋﻤﻠﻴﺎت‬ ‫إﻧﻬﺎء‬ ‫أﻣﺮ‬
‫ﺔ‬ ‫ﺣﻠﻘ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺮوج‬ ‫واﻟﺨ‬ ‫ﺘﻜﺮار‬ ‫اﻟ‬For،‫ﺎت‬ ‫ﺣﻠﻘ‬ ‫ﺘﻌﻤﺎل‬ ‫اﺳ‬ ‫ﻴﺔ‬ ‫ﻛﻴﻔ‬ ‫ﺢ‬ ‫ﺗﻮﺿ‬ ‫ﻲ‬ ‫اﻟﺘﺎﻟ‬ ‫ﺜﻠﺔ‬ ‫واﻷﻣ‬
‫اﻟﺘﻜﺮا‬‫ﺑﺠﻤﻠﺔ‬ ‫ر‬For:
‫ﻣﺜﺎل‬٨:
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫واﻟﻨﺘﻴﺠﺔ‬:
‫اﻟﻘﻴﻤﺔ‬
‫ﻟﻌﺪاد‬ ‫اﻻﺑﺘﺪاﺋﻴﺔ‬
‫ﺣﻠﻘﺔ‬For
‫ﻳﻘﻴﺪ‬ ‫ﺷﺮط‬
‫ﺣﺮﻛﺔ‬For
‫ﻣﺎ‬ ‫وﻏﺎﻟﺒﺎ‬
‫ﻗﻴﻤﺔ‬ ‫ﻳﺤﻮي‬
‫ﻧﻬﺎﺋﻴﺔ‬
‫اﻟﺰﻳﺎدة‬
‫اﻟﻤﻨﺘﻈﻤﺔ‬
‫اﻟﻌﺪاد‬ ‫ﻓﻲ‬
‫ﻳﺘﻢ‬ ‫آو‬ ‫ﺟﻤﻠﺔ‬
‫ﺗﻜﺮار‬
‫ﻋﺪد‬ ‫ﺗﻨﻔﻴﺬﻫﺎ‬
‫ﺗﻜﺮار‬ ‫ﻣﺮات‬
For
main ()
{
char x;
for (x=1;x<=10;x=x+1)
cout<<“Islam”;
cout<<endl;
return0;
}
‫اﻟﺘﻨﺎزﻟﻴﺔ‬ ‫اﻟﻘﻴﻤﺔ‬
‫ﻟﻠﻌﺪاد‬
‫إﻟﻰ‬ ‫اﻟﺘﻜﺮار‬
10
‫ﺑﻤﻘﺪار‬ ‫اﻟﺰﻳﺎدة‬1

Islam Islam Islam Islam Islam Islam Islam Islam Islam Islam
‫ﻛﻠﻤﺔ‬ ‫ﺗﻜﺮار‬ ‫ﺗﻢ‬ ‫اﻧﻪ‬ ‫ﻫﻨﺎ‬ ‫ﻧﻼﺣﻆ‬Islam10‫ﻣﻦ‬ ‫ﺑﺪاﻳﺔ‬ ‫ﻣﺮات‬‫اﻟﻘﻴﻤﺔ‬1Ù10
‫ﻣﺜﺎل‬٩:
‫ﻣﻦ‬ ‫اﻟﻌﺪاد‬ ‫ﻗﻴﻤﺔ‬ ‫ﻟﻄﺒﺎﻋﺔ‬ ‫ﺑﺮﻧﺎﻣﺠﺎ‬ ‫اﻛﺘﺐ‬1‫إﻟﻰ‬10‫؟‬
‫ﻫﻜﺬا‬ ‫اﻟﺸﺎﺷﺔ‬ ‫ﻋﻠﻰ‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﻧﺘﺎﺋﺞ‬ ‫وﺗﻜﻮن‬:
1
2
3
4
5
6
7
8
9
10
main ()
{
int a;
for (a=1;a<=10;++a)
cout<<a<<endl;
return0;
}
‫ﻗﻴﻤﺔ‬a‫اﻻﺑﺘﺪاﺋﻴﺔ‬
‫ﻗﻴﻤﺔ‬a‫اﻟﻨﻬﺎﺋﻴﺔ‬

‫ﻣﺜﺎل‬١٠:
‫اﻷﻋﺪاد‬ ‫ﻟﻄﺒﺎﻋﺔ‬ ‫ﺑﺮﻧﺎﻣﺠﺎ‬ ‫اﻛﺘﺐ‬‫ﻣﻦ‬ ‫اﻟﻔﺮدﻳﺔ‬1‫إﻟﻰ‬15‫؟‬
‫ﺰﻳﺎدة‬‫اﻟ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﻨﺎ‬‫ﺟﻌﻠ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﻆ‬‫اﻟﻤﻼﺣ‬ ‫ﻦ‬‫وﻣ‬2‫ﻴﺲ‬‫وﻟ‬1‫ﺑﺎﻟﻘﻴﻤﺔ‬ ‫ﺑﺪاﻳﺔ‬ ‫ﻓﺮدﻳﺔ‬ ‫أﻋﺪاد‬ ‫ﺐ‬‫ﻃﻠ‬ ‫ﻪ‬‫ﻻﻧ‬
1‫وﺣﺘﻰ‬15
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫واﻟﻨﺘﻴﺠﺔ‬:
1
3
5
7
9
11
13
main ()
{
int a;
for (a=1;a<=15;a=a+2)
cout<<a<<endl;
return0;
}

‫اﻟﺜﺎﻧﻴﺔ‬ ‫اﻟﻌﺎﻣﺔ‬ ‫اﻟﺼﻴﻐﺔ‬
For ( initial-value; condition; increment )
{
statement;
}
‫أﻋﻼه‬ ‫اﻟﺼﻴﻐﺔ‬ ‫ﻋﻠﻰ‬ ‫اﻛﺜﺮ‬ ‫ﻟﻨﺘﻌﺮف‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻷﻣﺜﻠﺔ‬ ‫ﺷﺎﻫﺪ‬:
‫ﻣﺜﺎل‬١١:
‫اﻟﺘﺎﻟﻲ‬ ‫ﻳﻜﻮن‬ ‫ﺳﻮف‬ ‫واﻟﻨﺎﺗﺞ‬:
1
-1
-3
‫اﻛﺜﺮ‬ ‫أو‬ ‫ﺟﻤﻠﺔ‬
main ()
{ int x,y,z;
y=-4;
for(x=1;x>y;x=x-2)
}
z=x;
cout<<x<<endl;
{
return0;
}
‫ﺑﻴﻦ‬ ‫ﺟﻤﻠﺔ‬ ‫ﻣﻦ‬ ‫اﻛﺜﺮ‬
‫اﻟﻘﻄﻌﺘﻴﻦ‬Block

‫ﻣﺜﺎل‬١٢:
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫واﻟﻨﺎﺗﺞ‬:
14*
‫ﻣﺜﺎل‬١٣:
‫واﻟﻨﺎﺗﺞ‬:
2
1
0
main ()
{ int a,b,c,x;
a=6;
b=1;
c=3;
for (x=11;(a*c)>(x*b);x--)
{
x=x+3;
c=c-2;
cout<<x<<”*”;
}
return0;
}
‫اﻻﺑﺘﺪاﺋﻴﺔ‬ ‫اﻟﻘﻴﻤﺔ‬
‫ﺑﻴﻦ‬ ‫ﺟﻤﻠﺔ‬ ‫ﻣﻦ‬ ‫اﻛﺜﺮ‬
‫اﻟﻘﻄﻌﺘﻴﻦ‬Block
main ()
{ int a,c;
a=1;
c=3;
for (a=c;c;)
{
c--;
cout<<c<<endl;
}
return0;
}
‫ﻗﻴﻤﺔ‬ ‫ﻣﻦ‬ ‫ﺗﻨﻘﺺ‬
C‫ﻗﻴﻤﺔ‬1

‫ـﺘﺪاﺧﻠﺔ‬‫ـ‬‫اﻟﻤ‬ ‫ـﺘﻜﺮار‬‫ـ‬‫اﻟ‬ ‫ـﺎت‬‫ـ‬‫ﺣﻠﻘ‬for)Multiple(Nested
Loops
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻌﺎم‬ ‫اﻟﺸﻜﻞ‬ ‫اﻟﻤﺘﺪاﺧﻠﺔ‬ ‫اﻟﺘﻜﺮار‬ ‫ﺣﻠﻘﺎت‬ ‫ﺻﻴﻐﺔ‬ ‫ﺗﺄﺧﺬ‬:
For (...)
For (...)
For (...)
………………………….
………………………….
Statements;
‫ﺗﻜ‬ ‫ﻓﺎﻧﻬﻤﺎ‬ ‫ﻣﺘﺪاﺧﻠﺘﻴﻦ‬ ‫ﺣﻠﻘﺘﻴﻦ‬ ‫ﺣﺎﻟﺔ‬ ‫أﺧﺬﻧﺎ‬ ‫ﻓﻠﻮ‬‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺼﻮرة‬ ‫ﻋﻠﻰ‬ ‫ﺘﺒﺎن‬:
For(...)
For (...)
Statements;
‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﺔ‬ ‫اﻟﺤﺎﻟ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻮن‬ ‫وﺗﻜ‬)‫ﻞ‬ ‫اﻟﺠﻤ‬ ‫أو‬(‫ﻴﺔ‬ ‫اﻟﺪاﺧﻠ‬ ‫ﺔ‬ ‫ﺑﺎﻟﺤﻠﻘ‬ ‫ﺒﻄﺎ‬ ‫ﻣﺮﺗ‬ ‫ﺮرا‬ ‫ﻣﻜ‬ ‫ﺰءا‬ ‫ﺟ‬،
‫وﻫﻜﺬا‬ ‫اﻟﺨﺎرﺟﻴﺔ‬ ‫اﻟﺤﻠﻘﺔ‬ ‫أواﻣﺮ‬ ‫ﺣﺴﺐ‬ ‫ﺗﺘﻜﺮر‬ ‫اﻟﺨﺎرﺟﻴﺔ‬ ‫واﻟﺤﻠﻘﺔ‬...
‫اﻟﺤﻠﻘﺔ‬ ‫ﺗﺴﻤﻰ‬
‫اﻟﺨﺎرﺟﻴﺔ‬outer
loop
‫اﻟﺤﻠﻘﺔ‬ ‫ﺗﺴﻤﻰ‬
‫اﻟﺪاﺧﻠﻴﺔ‬inner
loop
‫ﺗﻜﺮر‬ ‫ﺟﻤﻞ‬ ‫أو‬ ‫ﺟﻤﻠﺔ‬
‫أواﻣﺮ‬ ‫ﺣﺴﺐ‬
‫اﻟﺤﻠﻘﺘﻴﻦ‬

‫اﻟﻤﺘﺪاﺧﻠﺔ‬ ‫ﺣﻠﻘﺎت‬ ‫اﻟﺜﻼث‬ ‫ﺣﺎﻟﺔ‬ ‫وﻓﻲ‬،‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺼﻮرة‬ ‫ﻋﻠﻰ‬ ‫ﺗﻜﺘﺐ‬ ‫ﻓﺈﻧﻬﺎ‬:
For (...)
For (...)
For (...)
Statement;
‫ﻣﺜﺎل‬١٤:
‫اﻟﺤﻠﻘ‬ ‫أن‬ ‫ﻨﺎ‬ ‫ﻫ‬ ‫ﻆ‬ ‫ﻻﺣ‬‫ﺘﻜﺮر‬ ‫ﺗ‬ ‫ﻴﺔ‬ ‫اﻟﺪاﺧﻠ‬ ‫ﺔ‬٤‫ﻴﻢ‬ ‫ﻗ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﻞ‬ ‫ﻟﻜ‬ ‫ﺮات‬ ‫ﻣ‬I،‫ﺔ‬ ‫اﻟﺤﻠﻘ‬ ‫ﺪاد‬ ‫ﻋ‬
‫ﻴﺔ‬ ‫اﻟﺨﺎرﺟ‬،‫ﺔ‬ ‫ﺟﻤﻠ‬ ‫ﻚ‬ ‫وﻛﺬﻟ‬cout<<،‫أن‬ ‫ﺎ‬ ‫وﺑﻤ‬I،‫ﺄﺧﺬ‬ ‫ﺗ‬3‫ﻴﺔ‬ ‫اﻟﺪاﺧﻠ‬ ‫ﺔ‬ ‫اﻟﺤﻠﻘ‬ ‫ﺎن‬ ‫ﻓ‬ ‫ﻴﻢ‬ ‫ﻗ‬
‫ﺗﺘﻜﺮر‬12‫ﻣﺮة‬،‫ﻓﺘﺘﻜﺮ‬ ‫ﺑﻨﻔﺴﻬﺎ‬ ‫ﻧﻔﺴﻬﺎ‬ ‫ﻓﺘﻜﺮر‬ ‫اﻟﺨﺎرﺟﻴﺔ‬ ‫اﻟﺤﻠﻘﺔ‬ ‫أﻣﺎ‬12‫ﻓﻘﻂ‬ ‫ﻣﺮة‬.
1234246836912
‫اﻟﺨﺎرﺟﻴﺔ‬ ‫اﻟﺤﻠﻘﺔ‬
‫اﻟﺤﻠﻘﺔ‬
‫اﻟﻮﺳﻄﻲ‬
‫ﺟﻤﻠﺔ‬‫ﺗﺘﻜﺮ‬ ‫ﺟﻤﻞ‬ ‫أو‬
‫أواﻣﺮ‬ ‫ﺣﺴﺐ‬
‫اﻟﺜﻼث‬ ‫اﻟﺤﻠﻘﺎت‬
‫اﻟﺤﻠﻘﺔ‬
‫اﻟﺪاﺧﻠﻴﺔ‬
main ()
{
int i,j;
for (i=1;i<=3;++i)
for (j=1;j<=4;++j)
cout<<i*j;
return0;
}
‫ﺗﺘﻜﺮ‬ ‫اﻟﺨﺎرﺟﻴﺔ‬ ‫اﻟﺤﻠﻘﺔ‬3
‫ﻣﺮات‬
‫ﺗﺘﻜﺮر‬ ‫اﻟﺪاﺧﻠﻴﺔ‬ ‫اﻟﺤﻠﻘﺔ‬4
‫ﻗﻴﻢ‬ ‫ﻣﻦ‬ ‫ﻗﻴﻤﺔ‬ ‫ﻟﻜﻞ‬ ‫ﻣﺮات‬I‫أي‬
‫ﻣﺠﻤﻮع‬12‫ﻣﺮة‬

‫ﻣﺜﺎل‬١٥:
‫و‬‫ﺎ‬‫وﻣ‬ ‫ﻴﺮ‬‫اﻷﺧ‬ ‫ﻄﺮ‬‫واﻟﺴ‬ ‫اﻷول‬ ‫ﻄﺮ‬‫ﻟﻠﺴ‬ ‫ﻞ‬‫اﻟﺤ‬ ‫ﻮاب‬‫ﺟ‬ ‫ﺄﻋﻄﻴﻜﻢ‬‫ﺳ‬ ‫ﻚ‬‫ﻟﺬﻟ‬ ‫ﻴﺮ‬‫ﻛﺒ‬ ‫ﻴﻜﻮن‬‫ﺳ‬ ‫ﻨﺎﺗﺞ‬‫اﻟ‬
‫ﻟﻜﻢ‬ ‫ﺑﻴﻨﻬﻤﺎ‬.
‫اﻷول‬ ‫اﻟﺴﻄﺮ‬1612 :
‫اﻷﺧﻴﺮ‬ ‫اﻟﺴﻄﺮ‬203 :
main ()
{
int i,j;
for (i=2;i<=20;i+=2)
for (j=30;j>=3;j-=3)
cout<<i<<j<<endl;
return0;
}
‫ﻋﺪادﻫﺎ‬ ‫ﻳﺘﻐﻴﺮ‬ ‫اﻟﺨﺎرﺟﻴﺔ‬ ‫اﻟﺤﻠﻘﺔ‬
‫ﺑﻴﻦ‬2‫و‬20‫ﻣﻨﻈﻤﺔ‬ ‫ﺑﺰﻳﺎدة‬
‫ﻗﺪرﻫﺎ‬2
‫ﺑﻴﻦ‬ ‫ﻋﺪادﻫﺎ‬ ‫ﻳﺘﻐﻴﺮ‬ ‫ﻟﺪاﺧﻠﻴﺔ‬ ‫ا‬ ‫اﻟﺤﻠﻘﺔ‬
30‫و‬3‫ﻗﺪرﻫﺎ‬ ‫ﻣﻨﺘﻈﻤﺔ‬ ‫ﺑﺰﻳﺎدة‬3-

‫ﺣﻠﻘﺔ‬ ‫ﺑﺎﺳﺘﻌﻤﺎل‬ ‫اﻟﺘﻜﺮار‬ ‫أﺳﻠﻮب‬While & Do
‫ﺔ‬ ‫ﺣﻠﻘ‬ ‫ﺘﻌﻤﺎل‬ ‫ﺑﺎﺳ‬ ‫ﺘﻜﺮار‬ ‫اﻟ‬ ‫ﻠﻮب‬ ‫أﺳ‬while‫ﺔ‬ ‫ﺣﻠﻘ‬ ‫ﻠﻮب‬ ‫أﺳ‬ ‫ﺎﺛﻞ‬ ‫ﻳﻤ‬ ‫ﺮ‬ ‫آﺧ‬ ‫ﻠﻮب‬ ‫أﺳ‬for،‫ﻊ‬ ‫ﻣ‬
‫ﺘﻼ‬ ‫اﻻﺧ‬ ‫ﺾ‬‫ﺑﻌ‬‫ﻴﻄﺔ‬‫اﻟﺒﺴ‬ ‫ﻓﺎت‬،‫ﺔ‬‫ﻟﻐ‬ ‫ﺜﺮى‬‫ﻳ‬ ‫ﻠﻮب‬‫أﺳ‬ ‫ﻮ‬‫وﻫ‬C++،‫ﺮوﻧﺔ‬ ‫وﻣ‬ ‫ﻮة‬‫ﻗ‬ ‫ﺰدﻫﺎ‬ ‫وﻳ‬،
‫اﻷﺳﻠﻮب‬ ‫ﻟﻬﺬا‬ ‫اﻟﻌﺎم‬ ‫واﻟﺸﻜﻞ‬:
While (conditions) statements;
‫اﻟﺘﻜﺮار‬ ‫ﺣﻠﻘﺔ‬ ‫وﻣﻌﻨﻰ‬while‫اﻷﺗﻲ‬ ‫ﻫﻮ‬:
‫ﺮط‬‫اﻟﺸ‬ ‫دام‬ ‫ﺎ‬‫ﻣ‬ ‫آي‬)‫أو‬‫ﺮوط‬‫اﻟﺸ‬(‫ﺘﺤﻘﻘﺎ‬‫ﻣ‬)‫ﻪ‬‫وﺟﻮاﺑ‬true(،‫أو‬ ‫اﻟﺠﻤﻠﺔ‬ ‫ﺗﻨﻔﻴﺬ‬ ‫ﺮار‬‫ﺗﻜ‬ ‫ﺘﻢ‬‫ﻓﻴ‬
‫ﻞ‬ ‫اﻟﺠﻤ‬(statements)،‫ﺔ‬ ‫ﺣﻠﻘ‬ ‫ﻲ‬ ‫ﺗﻠ‬ ‫ﻲ‬ ‫اﻟﺘ‬ ‫ﺔ‬ ‫اﻟﺠﻤﻠ‬ ‫ﻰ‬ ‫إﻟ‬ ‫ﺒﺮﻧﺎﻣﺞ‬ ‫اﻟ‬ ‫ﻴﺬ‬ ‫ﺗﻨﻔ‬ ‫ﻞ‬ ‫ﺗﺴﻠﺴ‬ ‫ﺘﻘﻞ‬ ‫وﻳﻨ‬
while.
‫ذﻟﻚ‬ ‫ﺗﻮﺿﺢ‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫واﻷﻣﺜﻠﺔ‬:
‫ﻣﺜﺎل‬١٦:
‫واﻟﻨﺎﺗﺞ‬
‫ﻳﻜﻮن‬ ‫ﺳﻮف‬:
1 2
‫ﻳﻨﻈﻢ‬ ‫اﻛﺜﺮ‬ ‫أو‬ ‫ﺷﺮط‬
‫اﻟﺘﻜﺮار‬ ‫ﻋﻤﻠﻴﺔ‬ ‫ﻳﺘﻢ‬ ‫ﺟﻤﻠﺔ‬‫ﺗﻨﻔﻴﺬﻫﺎ‬
‫اﻟﺸﺮط‬ ‫ﺣﺴﺐ‬
conditions
main ()
{ int a;
a=1;
while (a<3)
cout<<a++;
return0;
} ‫ﺑﻤﻘﺪار‬ ‫اﻟﺰﻳﺎدة‬1
‫ﻃﺒﺎﻋﺔ‬ ‫ﺑﻌﺪ‬
‫اﻟﻨﺘﻴﺠﺔ‬
‫اﻟﺸﺮط‬ ‫ﻃﺎﻟﻤﺎ‬

‫ﻣﺜﺎل‬١٧:
‫واﻟﻨﺎﺗﺞ‬
****
‫ﻣﺜﺎل‬١٨:
‫ﻗﻴﻤﺔ‬ ‫ﺗﺘﺴﺎوى‬ ‫ﺣﺘﻰ‬ ‫اﻟﺘﻜﺮار‬ ‫ﺳﻴﺘﻢ‬ ‫ﻃﺒﻌﺎ‬x‫ﻗﻴﻤﺔ‬ ‫ﻣﻊ‬y‫اﻟﺘﻜﺮار‬ ‫ﻋﻤﻠﻴﺔ‬ ‫ﺗﺘﻮﻗﻒ‬ ‫ﺛﻢ‬..
2--21--1
main ()
{ int a;
a=1;
do
{
cout<<”*”;
a++;
}
while (a<=4)
return0;
}
‫اﻓﻌﻞ‬
‫ﺑﻤﻘﺪار‬ ‫اﻟﺰﻳﺎدة‬
‫اﻟﻘﻴﻤﺔ‬1
‫ﻃﺎﻟﻤﺎ‬a‫أو‬ ‫اﻗﻞ‬
‫اﻟﻘﻴﻤﺔ‬ ‫ﻳﺴﺎوي‬4
‫اﻟﺘﻜﺮار‬ ‫ارﺟﻊ‬
main ()
{ int x,y;
x=2;
y=-2;
do
{
cout<<x<<”-“<<endl;
x--;
y++;
}
else
cout<<”finish”;
while(x!=y)
return0;
}
‫ﻃﺎﻟﻤﺎ‬x‫ﺗﺴﺎوي‬ ‫ﻻ‬y
‫اﻟﺪوران‬ ‫أو‬ ‫اﻟﺘﻜﺮار‬ ‫ﺗﺎﺑﻊ‬
‫ﺑﻠﻮك‬ ‫أو‬ ‫ﻗﻄﻌﺘﻴﻦ‬
‫اﻟﺠﻤﻞ‬ ‫ﻟﻮﺿﻊ‬
‫ﺑﻴﻨﻬﻤﺎ‬

‫ﻣﺜﺎل‬١٩:
‫ﺔ‬‫ﻋﺪدﻳ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﺎل‬‫إدﺧ‬ ‫ﺘﺨﺪم‬‫اﻟﻤﺴ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺐ‬‫ﻳﻄﻠ‬ ‫ﺮﻧﺎﻣﺠﺎ‬‫ﺑ‬ ‫ﺐ‬‫اﻛﺘ‬،‫أ‬ ‫ﺎ‬‫وﻃﺎﻟﻤ‬‫ﺔ‬‫اﻟﻤﺪﺧﻠ‬ ‫ﻴﻤﺔ‬‫اﻟﻘ‬ ‫ن‬+
‫ﻳﻄﺒﻊ‬*‫ﺟﺪﻳﺪ؟‬ ‫ﺳﻄﺮ‬ ‫ﻋﻠﻰ‬
‫اﻟﺤـﻞ‬/
‫اﻟﺮﻗﻢ‬ ‫ﺑﺈدﺧﺎل‬ ‫ﻗﻤﻨﺎ‬ ‫ﻃﺒﻌﺎ‬10‫ﺳﺘﻜﻮن‬ ‫واﻟﻨﺘﻴﺠﺔ‬:
*
‫ﺪد‬‫اﻟﻌ‬ ‫ﻻن‬10‫أن‬ ‫ﺎول‬‫ﺣ‬ ‫ﻦ‬‫ﻟﻜ‬ ‫ﺐ‬‫ﻣﻮﺟ‬ ‫ﺪد‬‫ﻋ‬‫ﺪم‬‫ﻟﻌ‬ ‫ﻲ‬‫ﺷ‬ ‫ﻚ‬‫ﻟ‬ ‫ﺒﻊ‬‫ﻳﻄ‬ ‫ﻦ‬‫ﻓﻠ‬ ‫ﺎﻟﺐ‬‫ﺳ‬ ‫ﺪد‬‫ﻋ‬ ‫ﻞ‬‫ﺗﺪﺧ‬
‫ﺮط‬‫اﻟﺸ‬ ‫ﻖ‬‫ﺗﺤﻘ‬،‫ﺑﻴﻦ‬ ‫ﺑﺎﻟﻄﺒﺎﻋﺔ‬ ‫اﻟﺨﺎﺻﺔ‬ ‫ﺔ‬‫اﻟﺠﻤﻠ‬ ‫أو‬ ‫ﻞ‬‫اﻟﺠﻤ‬ ‫ﻌﻨﺎ‬‫وﺿ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﻲ‬‫أﺧﻮاﻧ‬ ‫ﻰ‬‫ﻧﻨﺴ‬ ‫وﻻ‬
‫ﻊ‬‫اﻟﻘﻄ‬Block{}‫ﺪم‬‫ﻋ‬ ‫ﻨﺪ‬‫ﻋ‬ ‫ﻦ‬ ‫ﻟﻜ‬ ‫ﻊ‬‫اﻟﻘﻄ‬ ‫ﻊ‬‫وﺿ‬ ‫ﺐ‬‫ﻳﺠ‬ ‫ﻚ‬‫ﻟﺬﻟ‬ ‫ﺔ‬‫ﺟﻤﻠ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺜﺮ‬‫اﻛ‬ ‫ﺪ‬‫وﺟ‬ ‫ﻪ‬‫ﻻﻧ‬
‫ﻛﻤﺜﺎل‬ ‫ﺟﻤﻠﻪ‬ ‫أو‬ ‫ﺳﻄﺮ‬ ‫ﻣﻦ‬ ‫اﻛﺜﺮ‬ ‫وﺟﻮد‬)١٢(‫وﺿﻌﻬﺎ‬ ‫ﻳﺠﻮز‬ ‫ﻓﻼ‬.
main ()
{ int a;
cout<<”please enter a number”;
cin>>a;
while (a>=0)
{
cout<<”*”<<endl;
cout<<” please enter a number”;
cin>>a;
}
return0;
}
‫اﻟﺮﻗﻢ‬ ‫ﻧﺪﺧﻞ‬
‫وﻟﻴﻜﻦ‬10
‫اﻟﺮﻗﻢ‬ ‫أن‬ ‫ﻃﺎﻟﻤﺎ‬
‫أو‬ ‫اﻛﺒﺮ‬ ‫اﻟﻤﺪﺧﻞ‬
‫ﻳﺴﺎوي‬0
‫ﺗﺤﻘﻖ‬ ‫إذا‬
‫اﻃﺒﻊ‬ ‫اﻟﺸﺮط‬

‫ﺣﻠﻘﺎت‬ileWh‫اﻟﻤﺘﺪاﺧﻠﺔ‬Nested While Loops
‫ﺎت‬ ‫ﺣﻠﻘ‬ ‫ﺒﺔ‬ ‫ﺗﺸ‬While‫ﺎت‬ ‫ﺣﻠﻘ‬ ‫ﺘﺪاﺧﻠﺔ‬ ‫اﻟﻤ‬for‫ﺘﺪاﺧﻠﺔ‬ ‫اﻟﻤ‬،‫ﺘﻜﺮار‬ ‫اﻟ‬ ‫ﻲ‬ ‫ﺣﻠﻘﺘ‬ ‫ﺬ‬ ‫ﺧ‬ ‫ﺜﻼ‬ ‫ﻓﻤ‬
‫اﻟﺘﺎﻟﻴﺘﻴﻦ‬ ‫اﻟﻤﺘﺪاﺧﻠﺘﻴﻦ‬:
‫ﻣﺜﺎل‬٢٠:
main ()
{
int i=j=1;
while (i<=3)
{
while(j<=4)
{
cout<<”/n”<<i*j;
++j;
}
++i;
j=1;
}
return0;
}
‫ﺗﻜﺮار‬ ‫ﺣﻠﻘﺎت‬3
‫ﻣﺮات‬
‫اﻟﺪاﺧﻠﻴﺔ‬ ‫اﻟﺤﻠﻘﺔ‬
‫ﺗﺘﻜﺮر‬12‫ﻣﺮة‬
‫ﻓﻲ‬ ‫ﻣﻨﺘﻈﻤﺔ‬ ‫زﻳﺎدة‬
‫ﻋﺪاد‬I‫ﺑﻤﻘﺪار‬1
‫إ‬‫ﻗﻴﻤﺔ‬ ‫ﺗﻌﺮﻳﻒ‬ ‫ﻋﺎدة‬j‫اﻻﺑﺘﺪاﺋﻴﺔ‬
‫ﺣﻠﻘﺔ‬ ‫ﺑﺪاﻳﺔ‬ ‫ﻋﻨﺪ‬j

‫اﻹﻳﻘﺎف‬ ‫ﺟﻤﻠﺔ‬Break
‫ﻴﻔﺔ‬‫وﻇ‬ ‫أن‬ ‫ﻆ‬‫ﻧﻼﺣ‬ ‫أن‬ ‫ﺘﻄﻴﻊ‬‫ﻧﺴ‬ ‫ﻢ‬‫اﻻﺳ‬ ‫ﻦ‬‫ﻣ‬Break‫ﻨﺪ‬ ‫ﻋ‬ ‫ﺮار‬‫ﺗﻜ‬ ‫ﺔ‬‫ﺣﻠﻘ‬ ‫أو‬ ‫ﻴﺔ‬‫ﺑﻨ‬ ‫ﺎف‬‫إﻳﻘ‬ ‫ﻲ‬‫ﻫ‬
‫ﻨﺔ‬‫ﻣﻌﻴ‬ ‫ﺮوط‬‫ﺷ‬ ‫أو‬ ‫ﺮط‬‫ﺷ‬ ‫ﻖ‬‫ﺗﺤﻘ‬،‫ﻟﻠﺒﻨﻴﺔ‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫ﻞ‬‫اﻟﺠﻤ‬ ‫ﻠﺔ‬‫ﺳﻠﺴ‬ ‫ﻰ‬‫إﻟ‬ ‫ﺰ‬‫اﻟﻘﻔ‬ ‫ﺘﻢ‬‫ﻳ‬ ‫ﻴﺬﻫﺎ‬‫ﺗﻨﻔ‬ ‫ﻨﺪ‬‫وﻋ‬
‫ﺘ‬ ‫اﻟ‬ ‫ﺔ‬ ‫ﺣﻠﻘ‬ ‫أو‬‫ﻜﺮار‬،‫ﺘﻌﻤﻞ‬ ‫وﺗﺴ‬Break‫ﻲ‬ ‫ﻻﻧﻬﺎﺋ‬ ‫ﺘﻜﺮار‬ ‫اﻟ‬ ‫ﺔ‬ ‫ﺣﻠﻘ‬ ‫ﺎف‬ ‫إﻳﻘ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺎ‬ ‫أﻳﻀ‬،‫أو‬
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻤﺜﺎل‬ ‫ﻓﻲ‬ ‫وﻛﻤﺎ‬ ‫ﺗﻠﻴﻬﺎ‬ ‫اﻟﺘﻲ‬ ‫اﻟﺠﻤﻞ‬ ‫إﻟﻰ‬ ‫ﻣﻨﻬﺎ‬ ‫اﻟﺨﺮوج‬:
‫ﻣﺜﺎل‬٢١:
‫اﻟﻌﺪد‬ ‫ﺣﺘﻰ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺑﺘﻨﻔﻴﺬ‬ ‫ﺳﻴﻘﻮم‬ ‫وﻃﺒﻌﺎ‬10
‫واﻟﻨﺘﺎﺋﺞ‬:
12345678910
main ()
{
int i;
for (i=1;i<100;++i)
{
cout<<i;
if (i= =10) break;
}
return0;
}
‫اﻟﺠﻤﻠﺔ‬ ‫ﻫﺬه‬ ‫ﺗﻨﻔﻴﺬ‬ ‫ﻳﻮﻗﻒ‬
‫ﻋﻨﺪﻣﺎ‬ ‫اﻟﺘﻜﺮار‬ ‫ﺣﻠﻘﺎت‬
‫ﻳﺼﺒﺢ‬i=10

‫ﻣﺜﺎل‬٢٢:
main ()
{
int number;
for (number=1; number<=100;++ number)
{
if (number%2) // for ood values
break;
else if (number%4)
break;
else if (number%6)
break;
else
cout<< number<<endl;
}
return0;
}

‫اﻻﺳﺘﻤﺮار‬ ‫ﺟﻤﻠﺔ‬continue
‫ﺘﻤﺮار‬ ‫اﻻﺳ‬ ‫ﺔ‬ ‫ﺟﻤﻠ‬ ‫ﻞ‬ ‫ﺗﻌﻤ‬continue‫ﻼل‬ ‫ﺧ‬ ‫ﺘﻜﺮار‬ ‫اﻟ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻞ‬ ‫اﻟﺠﻤ‬ ‫ﻴﺔ‬ ‫ﺑﻘ‬ ‫ﻴﺬ‬ ‫ﺗﻨﻔ‬ ‫ﺎوز‬‫ﺗﺠ‬ ‫ﻰ‬ ‫ﻋﻠ‬
‫اﻟﺜﺎﻧﻴﺔ‬ ‫اﻟﺪورة‬ ‫إﻟﻰ‬ ‫واﻻﻧﺘﻘﺎل‬ ‫اﻟﺤﺎﻟﻴﺔ‬ ‫اﻟﺪورة‬:
‫ﻣﺜﺎل‬٢٣:
main ()
{
int x,n;
do
{
cin>>x>>n;
if (n<1) continue;
cout<<x;
--n;
}
while (n<1);
return0;
}
‫ﺗﻨﻔﻴﺬ‬ ‫ﺗﺠﺎوز‬ ‫ﻋﻠﻰ‬ ‫ﺗﻌﻤﻞ‬
‫اﻟﺘﺎﻟﻴﺘﻴﻦ‬ ‫اﻟﺠﻤﻠﺘﻴﻦ‬
‫إذا‬ ‫ﺟﺪﻳﺪة‬ ‫دورة‬ ‫وﺗﺒﺪاء‬
‫اﻟﺸﺮط‬ ‫ﺗﺤﻘﻖ‬

‫ﻣﺜﺎل‬٢٤:
‫ﻣﻦ‬ ‫اﻷرﻗﺎم‬ ‫ﺟﻤﻴﻊ‬ ‫ﺗﻄﺒﻊ‬1‫إﻟﻰ‬100‫ﺗﻘﺴ‬ ‫اﻟﺘﻲ‬ ‫اﻷرﻗﺎم‬ ‫ﻋﺪا‬ ‫ﻣﺎ‬‫ﻋﻠﻰ‬ ‫ﻢ‬2‫و‬4‫و‬6‫ﺑﺪون‬
‫ﺑﺎق‬:
‫اﻟﻨﺎﺗﺞ‬:
12
24
36
48
60
72
84
96
main ()
{
int number;
for (number=1;number<=100;++number)
{
if (number%2)
continue;
else if (number%4)
continue ;
else if (number%6)
continue;
else
cout<<number<<endl;
}
return0;
}

‫اﻟﺨﺮوج‬ ‫ﺟﻤﻠﺔ‬()exit
‫ﺎف‬‫إﻳﻘ‬ ‫ﻰ‬‫ﻋﻠ‬ ‫ﺔ‬‫اﻟﺪاﻟ‬ ‫ﺬه‬‫ﻫ‬ ‫ﻞ‬‫ﺗﻌﻤ‬)‫ﺮو‬‫اﻟﺨ‬ ‫أو‬‫ج‬‫ﻦ‬‫ﻣ‬(‫ﻣﻨﻪ‬ ‫ﻣﻜﺎن‬ ‫ﻲ‬‫ﻓ‬ ‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬،‫وﺗﺸﺒﺔ‬end
‫ﻚ‬‫ﺑﻴﺴ‬ ‫ﺔ‬‫ﻟﻐ‬ ‫ﻲ‬‫ﻓ‬،‫ﻔﺮا‬‫ﺻ‬ ‫ﺔ‬‫اﻟﺪاﻟ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﻮن‬‫وﺗﻜ‬exit(0)‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺮوج‬‫اﻟﺨ‬ ‫ﺘﻢ‬‫ﻳ‬ ‫ﻨﺪﻣﺎ‬‫ﻋ‬
‫ﻨ‬‫ﺑ‬‫ﻮن‬‫ﺗﻜ‬ ‫ﺔ‬‫اﻟﺪاﻟ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﺎن‬‫ﻓ‬ ‫وأﻻ‬ ‫ﺠﺎح‬exit(1)‫ﻮ‬‫ﻧﺤ‬ ‫أو‬ ‫ﺄ‬‫ﺧﻄ‬ ‫ﻮد‬‫وﺟ‬ ‫ﻨﺪ‬‫ﻋ‬ ‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫ﻒ‬‫وﺗﻮﻗ‬
‫ﻚ‬‫ذﻟ‬،‫ﺔ‬‫اﻟﺤﺎﻟ‬ ‫ﺬه‬‫ﻫ‬ ‫ﻲ‬‫وﻓ‬،‫ﻐﻴﻞ‬‫اﻟﺘﺸ‬ ‫ﺎم‬‫ﻧﻈ‬ ‫ﻰ‬‫إﻟ‬ ‫ﻴﺬه‬‫ﺗﻨﻔ‬ ‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫ﻮد‬‫ﻳﻌ‬ ‫ﻚ‬‫وﺗﻠ‬operating
system.
‫ﻣﺜﺎل‬٢٥:
‫ﻣﺜﺎل‬٢٣:
main ()
{
chat ma;
cin>>ma;
if ( ma != ‘A’) exit(1);
cout<<”n”<<ma;
return0;
}

‫اﻻﻧﺘﻘﺎل‬ ‫ﺟﻤﻠﺔ‬goto
‫ﻴﻮﻳﺔ‬ ‫اﻟﺒﻨ‬ ‫ﺎت‬ ‫ﻟﻐ‬ ‫ﻢ‬ ‫ﻣﻌﻈ‬ ‫أن‬ ‫ﺮوف‬ ‫اﻟﻤﻌ‬ ‫ﻦ‬ ‫ﻣ‬‫ﺜﺔ‬ ‫اﻟﺤﺪﻳ‬،‫ﺮص‬ ‫ﺗﺤ‬،‫أﻻ‬ ‫ﻴﺎن‬ ‫اﻷﺣ‬ ‫ﺐ‬ ‫ﻏﺎﻟ‬ ‫ﻲ‬ ‫ﻓ‬
‫ﺔ‬‫ﺟﻤﻠ‬ ‫ﺘﻌﻤﻞ‬‫ﺗﺴ‬goto‫ﺒﺮﻣﺞ‬‫اﻟﻤ‬ ‫ﻰ‬‫ﻋﻠ‬ ‫ﻴﺪ‬‫اﻟﺘﺄﻛ‬ ‫ﻞ‬‫اﺟ‬ ‫ﻦ‬‫ﻣ‬،‫ﺑﻨﻴﻮﻳﺔ‬ ‫ﺑﻄﺮﻳﻘﺔ‬ ‫ﺮاﻣﺠﻪ‬‫ﺑ‬ ‫ﺘﻌﻠﻢ‬‫ﻳ‬ ‫أن‬
structured‫ﺎرج‬‫واﻟﻤﺨ‬ ‫ﻞ‬‫اﻟﻤﺪاﺧ‬ ‫ﻴﺔ‬‫ذاﺗ‬،‫ﻴﺎت‬‫واﻟﻌﻤﻠ‬،‫ﺑﻘﻮﻟﻪ‬ ‫ﺒﺮﻣﺞ‬‫اﻟﻤ‬ ‫ﻦ‬‫ﻣ‬ ‫ﻞ‬‫ﺗﺪﺧ‬ ‫دون‬:
‫ﺐ‬‫اذﻫ‬goto‫ﻨﺎ‬‫ﻫ‬ ‫ﻦ‬‫ﻣ‬،‫ﻳﻌﺘ‬ ‫ﺔ‬‫اﻟﺤﺎﻟ‬ ‫ﺬه‬‫ﻫ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫أن‬ ‫آي‬ ‫ﻨﺎك‬‫ﻫ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺐ‬‫اذﻫ‬ ‫أو‬‫ﻋﻠﻰ‬ ‫ﻤﺪ‬
‫ﻧﻔﺴﻪ‬.
‫ﻣﺜﺎل‬٢٦:
‫ﻣﻦ‬ ‫ﻞ‬‫اﻗ‬ ‫ﻴﻤﺔ‬‫اﻟﻘ‬ ‫ﺖ‬‫ﻛﺎﻧ‬ ‫ﺈذا‬‫ﻓ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﺎل‬‫إدﺧ‬ ‫ﺘﺨﺪم‬‫اﻟﻤﺴ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺐ‬‫ﻳﻄﻠ‬ ‫ﺆال‬‫اﻟﺴ‬ ‫ﺬا‬‫ﻫ‬ ‫ﻲ‬‫ﻓ‬10‫ﺣﺴﺐ‬
‫اﻟﺮﺳﺎﻟﺔ‬ ‫ﻟﻚ‬ ‫ﻳﻌﺮض‬ ‫ﻓﺎﻧﻪ‬ ‫اﻟﺸﺮط‬value is under 10.
‫ﺪد‬ ‫اﻟﻌ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺒﺮ‬ ‫اﻛ‬ ‫ﺖ‬ ‫ﻛﺎﻧ‬ ‫إذا‬ ‫ﺎ‬ ‫أﻣ‬10‫ﻄﺮ‬ ‫ﻟﻠﺴ‬ ‫ﺎب‬ ‫اﻟﺬﻫ‬ ‫دون‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺮة‬ ‫ﻣﺒﺎﺷ‬ ‫ﺪد‬ ‫اﻟﻌ‬ ‫ﺒﻊ‬ ‫ﻳﻄ‬ ‫ﻪ‬ ‫ﻓﺎﻧ‬
‫اﻟﺸﺮط‬ ‫ﻟﺘﺤﻘﻖ‬ ‫اﻷﺧﻴﺮ‬.
main ()
{
int x;
cin>>x;
if (x<10) goto negative;
negative: cout<<”value is under 10”<<endl;
return0;
}

‫ﺰﻳﺔ‬‫واﻟﺮﻣ‬ ‫ﺔ‬‫اﻟﻌﺪدﻳ‬ ‫ﺖ‬‫واﻟﺜﻮاﺑ‬ ‫ﻴﺮات‬‫اﻟﻤﺘﻐ‬ ‫ﻤﺎء‬‫أﺳ‬ ‫ﻊ‬‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬‫اﻟ‬ ‫ﺮق‬‫ﻃ‬ ‫أن‬،‫ﻲ‬‫ﻓ‬ ‫وردت‬ ‫ﻲ‬‫اﻟﺘ‬
‫ﺎﺑﻘﺔ‬‫اﻟﺴ‬ ‫ﻮل‬‫اﻟﻔﺼ‬،‫واﻟﻤﺘﻐﻴﺮات‬ ‫اﻟﺜﻮاﺑﺖ‬ ‫ﻫﺬه‬ ‫ﻣﻦ‬ ‫ﺪود‬‫ﻣﺤ‬ ‫ﺪد‬‫ﻋ‬ ‫ﻊ‬‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬‫ﻟﻠ‬ ‫ﺎﻟﺤﺔ‬‫ﺻ‬ ‫ﺪ‬‫ﺗﻌ‬،
‫ﻴﺔ‬ ‫واﻟﻤﻨﻄﻘ‬ ‫ﺎﺑﻴﺔ‬ ‫اﻟﺤﺴ‬ ‫ﻴﺎت‬ ‫اﻟﻌﻤﻠ‬ ‫ﻲ‬ ‫ﻓ‬ ‫أو‬ ‫ﺮاج‬ ‫واﻹﺧ‬ ‫ﺎل‬ ‫اﻹدﺧ‬ ‫ﻴﺎت‬ ‫ﻋﻤﻠ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻮاء‬‫ﺳ‬،‫ﻨﺪﻣ‬ ‫وﻋ‬‫ﺎ‬
‫ﺪا‬‫ﺟ‬ ‫ﻴﺮا‬‫ﻛﺒ‬ ‫ﻴﺮات‬‫اﻟﻤﺘﻐ‬ ‫ﺪد‬‫ﻋ‬ ‫ﺒﺢ‬‫ﻳﺼ‬،‫ﻴﺔ‬‫ﻋﻤﻠ‬ ‫ﻴﺮ‬‫ﻏ‬ ‫ﺮق‬ ‫اﻟﻄ‬ ‫ﻚ‬‫ﺗﻠ‬ ‫ﺒﺢ‬ ‫ﺗﺼ‬،‫ﺎ‬‫أردﻧ‬ ‫ﻮ‬‫ﻟ‬ ‫ﺜﻼ‬‫ﻓﻤ‬
‫ﻣﺎﺋ‬ ‫ﺎل‬ ‫إدﺧ‬‫ﺔ‬‫ﻴﺮات‬ ‫ﻟﻠﻤﺘﻐ‬ ‫ﻴﻤﺔ‬ ‫ﻗ‬x2,x1-....‫ﻲ‬ ‫إﻟ‬x100،‫ﻦ‬ ‫ﻣ‬ ‫ﻮب‬ ‫اﻟﻤﻄﻠ‬ ‫ﻴﺰ‬ ‫اﻟﺤ‬ ‫ﻢ‬ ‫ﻓﻜ‬
‫؟‬ ‫اﻟﻤﺘﻐﻴﺮات‬ ‫ﺬه‬‫ﻟﻬ‬ ‫ﻴﺔ‬‫واﻟﻤﻨﻄﻘ‬ ‫ﺎﺑﻴﺔ‬‫اﻟﺤﺴ‬ ‫ﻴﺎت‬‫واﻟﻌﻤﻠ‬ ‫ﺮاج‬‫واﻹﺧ‬ ‫ﺎل‬‫اﻹدﺧ‬ ‫ﻴﺎت‬‫ﻟﻌﻤﻠ‬ ‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬
‫ﺔ‬‫ﺟﻬ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺬا‬‫ﻫ‬،‫ﺮى‬‫أﺧ‬ ‫ﺔ‬‫ﺟﻬ‬ ‫ﻦ‬‫وﻣ‬:‫ﻓﺄﻧ‬‫ﻣﻌﻪ‬ ‫ﻧﺘﻌﺎﻣﻞ‬ ‫ﻣﺘﻐﻴﺮ‬ ‫ﻞ‬‫ﻟﻜ‬ ‫ﺎ‬‫ﺧﺎﺻ‬ ‫ﺰﻧﺎ‬‫ﻣﺨ‬ ‫ﺮ‬‫ﻧﻮﻓ‬ ‫ﻨﺎ‬،
‫ﺒﺮﻧﺎﻣﺞ‬ ‫اﻟ‬ ‫ﻴﺬ‬ ‫ﺗﻨﻔ‬ ‫ﻨﺎء‬ ‫أﺛ‬،‫ﻮن‬ ‫ﻣﺨ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺘﻪ‬ ‫ﻗﻴﻤ‬ ‫ﻆ‬ ‫ﻟﺤﻔ‬ ‫ﻚ‬ ‫وﻟﺬﻟ‬،‫ﻲ‬ ‫ﻓ‬ ‫ﺘﻪ‬ ‫ﻗﻴﻤ‬ ‫ﺘﻌﻤﺎل‬ ‫ﻻﺳ‬ ‫ﻢ‬ ‫ﺛ‬ ‫ﻦ‬ ‫وﻣ‬
‫ﻴﺔ‬‫ﺗﺎﻟ‬ ‫ﺮى‬‫أﺧ‬ ‫ﻴﺎت‬‫ﻋﻤﻠ‬،‫ﺜﺔ‬‫ﺛﺎﻟ‬ ‫ﻴﺔ‬‫ﻧﺎﺣ‬ ‫ﻦ‬‫وﻣ‬،‫ﺑﻤﻜﺎن‬ ‫اﻟﺼﻌﻮﺑﺔ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺎن‬‫ﻓ‬،‫اﻟﻤﺴﺘﺤﻴﻞ‬ ‫ﻣﻦ‬ ‫ﺑﻞ‬
‫ﺑﻌﺪﻳﻦ‬ ‫ذات‬ ‫ﻛﻤﺼﻔﻮﻓﺔ‬ ‫اﻟﺮﻣﺰي‬ ‫أو‬ ‫اﻟﻌﺪدي‬ ‫اﻟﻤﺘﻐﻴﺮ‬ ‫اﺳﻢ‬ ‫اﺳﺘﻌﻤﺎل‬،‫وﺛﻼﺛﺔ‬‫أﺑﻌﺎد‬...‫اﻟـﺦ‬
‫ﻼه‬‫أﻋ‬ ‫ﻮاردة‬‫اﻟ‬ ‫ﺜﻼﺛﺔ‬‫اﻟ‬ ‫ﺒﺎب‬‫ﻟﻸﺳ‬،‫اﺳﻤﻪ‬ ‫ﺗﺤﺖ‬ ‫ﻳﻀﻢ‬ ‫ﺟﻤﺎﻋﻲ‬ ‫ﻣﺘﻐﻴﺮ‬ ‫اﺳﺘﻌﻤﺎل‬ ‫ﺮة‬‫ﻓﻜ‬ ‫ﺎءت‬‫ﺟ‬
‫ﻲ‬‫اﻟﺮﻗﻤ‬ ‫ﻴﺮ‬‫ﺑﺎﻟﻤﺘﻐ‬ ‫ﻤﻰ‬‫ﻳﺴ‬ ‫ﺮ‬‫اﻟﻌﻨﺎﺻ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺪدا‬‫ﻋ‬subscripted variable،‫ﻴﻪ‬‫ﺗﺮﻗﻤ‬ ‫ﺘﻢ‬‫وﻳ‬
‫ﻦ‬ ‫ﻣﺮﺑﻌﻴ‬ ‫ﻴﻦ‬‫ﻗﻮﺳ‬ ‫ﻦ‬ ‫ﺑﻴ‬[ ]‫ﺮﻗﻢ‬ ‫اﻟﻤ‬ ‫ﺪاد‬ ‫اﻟﻌ‬ ‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﻨﻬﻤﺎ‬‫ﺑﻴ‬ ‫ﻊ‬ ‫ﻳﻮﺿ‬subscript،‫ﻤﻴﺔ‬ ‫ﻧﺴ‬ ‫ﺪ‬‫وﻗ‬
‫ﻴﻞ‬‫اﻟﺪﻟ‬index‫ﻴﺎﻧﺎ‬‫أﺣ‬،‫ﺎ‬‫ﻣ‬ ‫ﺔ‬‫ﻟﻤﺆﺳﺴ‬ ‫ﺎﺗﻒ‬‫اﻟﻬ‬ ‫ﻢ‬‫ﺑﻘﺴ‬ ‫ﺮﻗﻢ‬‫اﻟﻤ‬ ‫ﻴﺮ‬‫اﻟﻤﺘﻐ‬ ‫ﺒﻴﻪ‬‫ﺗﺸ‬ ‫ﻨﺎ‬‫وﻳﻤﻜﻨ‬،‫ﻮ‬‫ﻓﻬ‬
‫ﺪ‬‫واﺣ‬ ‫ﻢ‬‫ﻣﻘﺴ‬،‫اﻷرﻗﺎم‬ ‫ﻫﺬه‬ ‫ﻣﻦ‬ ‫رﻗﻢ‬ ‫وﻛﻞ‬ ‫ﻟﻠﻤﻮﻇﻔﻴﻦ‬ ‫اﻟﻔﺮﻋﻴﺔ‬ ‫ﺎم‬‫اﻷرﻗ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺪد‬‫ﻋ‬ ‫ﺘﻪ‬‫ﺗﺤ‬ ‫ﻨﻈﻢ‬‫ﺗ‬
‫ﺮى‬‫اﻷﺧ‬ ‫ﻴﺔ‬‫اﻟﻔﺮﻋ‬ ‫ﺎم‬‫اﻷرﻗ‬ ‫ﻦ‬ ‫ﻋ‬ ‫ﻴﺰ‬‫وﻣﺘﻤ‬ ‫ﺘﻘﻞ‬‫ﻣﺴ‬،‫ﺮة‬‫اﻟﺬاﻛ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺎص‬‫ﺧ‬ ‫ﺰن‬‫ﻣﺨ‬ ‫ﻟﻪ‬‫و‬،‫اﻵن‬
‫ﻟ‬ ‫ﺎم‬ ‫اﻟﻌ‬ ‫ﺮﻗﻢ‬ ‫ﻟﻠ‬ ‫ﺎﺑﻊ‬ ‫ﺗ‬ ‫ﻴﺔ‬ ‫اﻟﻔﺮﻋ‬ ‫ﺎم‬ ‫اﻷرﻗ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻴﺮه‬ ‫ﻛﻐ‬ ‫ﻪ‬ ‫اﻧ‬‫ﺔ‬ ‫اﻟﻤﺆﺳﺴ‬ ‫ﻢ‬ ‫ﻤﻘﺴ‬،‫ﺒﻴﻪ‬ ‫ﺗﺸ‬ ‫ﻦ‬ ‫ﻳﻤﻜ‬ ‫ﺎ‬ ‫ﻛﻤ‬
‫ﺪ‬ ‫واﺣ‬ ‫ﻴﺮ‬ ‫ﻣﺘﻐ‬ ‫ﻢ‬ ‫ﻛﺎﺳ‬ ‫ﺎﻣﻞ‬ ‫ﻳﻌ‬ ‫ﺬي‬ ‫اﻟ‬ ‫ﻴﺶ‬ ‫ﺑﺎﻟﺠ‬ ‫ﺮﻗﻢ‬ ‫اﻟﻤ‬ ‫ﻴﺮ‬ ‫اﻟﻤﺘﻐ‬،‫ﻦ‬ ‫ﻣ‬ ‫ﻴﺮا‬ ‫ﻛﺒ‬ ‫ﺪدا‬ ‫ﻋ‬ ‫ﻢ‬ ‫ﻳﻀ‬ ‫ﻦ‬ ‫ﻟﻜ‬
‫اﻟﻌﻨﺎﺻﺮ‬،‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﻌﻨﺎﺻﺮ‬ ‫ﻓﻤﺜﻼ‬):‫اﻟﻴﺴﺎر‬ ‫إﻟﻰ‬ ‫اﻟﻴﻤﻴﻦ‬ ‫ﻣﻦ‬:(
A[n] ...a[2], a[1], a[0]
‫اﻟﺠﻤﺎﻋﻲ‬ ‫ﻟﻠﻤﺘﻐﻴﺮ‬ ‫ﺗﺎﺑﻊ‬a[ ]
‫اﻟﺬاﻛﺮ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻨﻮان‬‫ﻋ‬ ‫ﻟﻪ‬ ‫ﺮ‬‫اﻟﻌﻨﺎﺻ‬ ‫ﺬه‬‫ﻫ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺮ‬‫ﻋﻨﺼ‬ ‫ﻞ‬‫وﻛ‬address،‫ﻳﻜﻮن‬ ‫اﻷول‬ ‫ﻓﺎﻟﻌﻨﻮان‬
‫ﻟﻠﺜﺎﻟﺚ‬ ‫واﻟﺜﺎﻟﺚ‬ ‫ﻟﻠﺜﺎﻧﻲ‬ ‫واﻟﺜﺎﻧﻲ‬ ‫اﻷول‬ ‫ﻟﻠﻌﻨﺼﺮ‬...‫وﻫﻜﺬا‬.
‫ﻲ‬‫اﻟﺠﻤﺎﻋ‬ ‫ﻴﺮ‬‫اﻟﻤﺘﻐ‬ ‫ﺘﻌﻤﻞ‬‫وﻳﺴ‬]‫ﺮﻗﻢ‬‫اﻟﻤ‬[‫ﻔﻮﻓﺔ‬‫اﻟﻤﺼ‬ ‫أو‬،‫ﺔ‬‫ﻟﻐ‬ ‫ﻲ‬‫ﻓ‬c++‫ﻴﺮﻫﺎ‬‫وﻏ‬،‫ﺰ‬ ‫ﺣﺠ‬
‫ﺮه‬ ‫ﻋﻨﺎﺻ‬ ‫ﻴﻊ‬‫ﻟﺠﻤ‬ ‫ﺮة‬‫اﻟﺬاﻛ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺒﻖ‬‫ﻣﺴ‬ ‫ﻲ‬‫ﺟﻤﺎﻋ‬،‫ﺮا‬‫ﻋﻨﺼ‬ ‫ﻮن‬‫ﺧﻤﺴ‬ ‫ﺒﻌﻪ‬‫ﻳﺘ‬ ‫ﺎن‬‫ﻛ‬ ‫ﻮ‬‫ﻓﻠ‬،‫ﻪ‬‫ﻓﺎﻧ‬
‫ﻟﻪ‬ ‫ﻳﺤﺠﺰ‬50‫ﻣﺨﺰﻧﺎ‬،‫اﻷﻗﻞ‬ ‫ﻋﻠﻰ‬‫اﻟﺬاﻛﺮة‬ ‫ﻓﻲ‬.
‫ﻔﻮﻓﺎت‬ ‫واﻟﻤﺼ‬ ‫ﺮﻗﻤﺔ‬ ‫اﻟﻤ‬ ‫ﻴﺮات‬ ‫ﻟﻠﻤﺘﻐ‬ ‫ﺔ‬ ‫اﻟﻤﻬﻤ‬ ‫ﺪ‬ ‫اﻟﻔﻮاﺋ‬ ‫ﻦ‬ ‫ﻣ‬:‫ﺐ‬ ‫اﻟﺘﺮﺗﻴ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺘﻌﻤﺎﻟﻬﺎ‬ ‫اﺳ‬ ‫ﻮ‬ ‫ﻫ‬
‫ﺘﻠﻔﺔ‬ ‫اﻟﻤﺨ‬ ‫ﻴﻢ‬ ‫واﻟﻘ‬ ‫ﺮ‬ ‫ﻟﻠﻌﻨﺎﺻ‬ ‫ﻲ‬ ‫واﻟﺘﻨﺎزﻟ‬ ‫ﺎﻋﺪي‬ ‫اﻟﺘﺼ‬،‫ﺪي‬ ‫اﻷﺑﺠ‬ ‫ﻤﺎء‬ ‫اﻷﺳ‬ ‫ﺐ‬ ‫ﺗﺮﺗﻴ‬ ‫ﻴﺎت‬ ‫وﻋﻤﻠ‬
‫واﻟﻤﺼﻔﻮﻓﺎت‬ ‫اﻟﻤﺮﻗﻤﺔ‬ ‫اﻟﻤﺘﻐﻴﺮات‬
Arrays and Matrices

‫ﺰﻳﺔ‬ ‫اﻟﺮﻣ‬ ‫ﻮص‬‫اﻟﻨﺼ‬،‫ﻔﻮﻓﺎت‬ ‫اﻟﻤﺼ‬ ‫ﺮب‬ ‫ﺿ‬ ‫ﻴﺎت‬‫ﻋﻤﻠ‬ ‫ﻲ‬ ‫وﻓ‬،‫ﻔﻮﻓﺔ‬ ‫اﻟﻤﺼ‬ ‫ﻮس‬‫ﻣﻌﻜ‬ ‫ﺎد‬‫وإﻳﺠ‬
‫اﻷﺧﺮى‬ ‫وﻋﻤﻠﻴﺎﺗﻬﺎ‬،‫اﻟﺘﺤﻠ‬ ‫وﻓﻲ‬‫اﻟﻌﺪدي‬ ‫ﻴﻞ‬...‫اﻟـﺦ‬.
‫اﻟﻤﺮﻗﻢ‬ ‫اﻟﻤﺘﻐﻴﺮ‬)‫اﻟﻤﺼﻔﻮﻓﺔ‬(‫اﻟﻮاﺣﺪ‬ ‫اﻟﺒﻌﺪ‬ ‫ذو‬one-dimensional Array
‫ﻣﺘﺠﻪ‬ ‫أو‬ ‫واﺣﺪ‬ ‫ﺑﻌﺪ‬ ‫ذات‬ ‫ﻔﻮﻓﺔ‬‫ﻣﺼ‬ ‫ﻮ‬‫ﻫ‬ ‫ﺪ‬‫اﻟﻮاﺣ‬ ‫ﺒﻌﺪ‬‫اﻟ‬ ‫ذو‬ ‫ﺮﻗﻢ‬‫اﻟﻤ‬ ‫ﻴﺮ‬‫اﻟﻤﺘﻐ‬(vector)‫وﻳﻤﺜﻞ‬
‫اﻷﻓﻘﻲ‬ ‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫اﻟﺠﺒﺮ‬ ‫ﻓﻲ‬[a1 a2 ...a3]
‫اﻟﻌﻤﻮدي‬ ‫أو‬
A1
A2
:
:
:
a3
‫ﻓ‬ ‫اﻟﻤﺘﻐﻴﺮ‬ ‫اﻟﻤﺮﻗﻢ‬ ‫وﻳﺄﺧﺬ‬‫ﻲ‬c++‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻌﺎم‬ ‫اﻟﺸﻜﻞ‬:
Type-specifier array-name[size];
‫ﻔﺮ‬ ‫اﻟﺼ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺎدة‬ ‫ﻋ‬ ‫ﺮﻗﻢ‬ ‫اﻟﻤ‬ ‫ﺪاد‬ ‫اﻟﻌ‬ ‫ﺒﺪأ‬ ‫وﻳ‬،‫ﻔﻮﻓﺔ‬ ‫اﻟﻤﺼ‬ ‫ﻦ‬ ‫ﻣ‬ ‫اﻷول‬ ‫ﺮ‬ ‫اﻟﻌﻨﺼ‬ ‫أن‬ ‫آي‬a[]‫ﻮ‬ ‫ﻫ‬
a[0]‫واﻟﺜﺎﻧﻲ‬a[1]...‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫ﻓﻤﺜﻼ‬ ‫وﻫﻜﺬا‬:
Int a[20];
‫اﺳﻤﻬﺎ‬a،‫ﻟﻬﺎ‬ ‫ﺣﺠﺰ‬ ‫وﻗﺪ‬20‫ﻣﻦ‬ ‫ﻋﻨﺼﺮا‬ ‫ﻟﻌﺸﺮﻳﻦ‬ ‫ﻣﻮﻗﻌﺎ‬‫اﻟﺼﺤﻴﺢ‬ ‫اﻟﻨﻮع‬.
‫اﻟﺘﺎﻟﻴﺔ‬ ‫واﻟﻤﺼﻔﻮﻓﺔ‬:
Char name[15];
‫رﻣﺰﻳﺔ‬ ‫ﻣﺼﻔﻮﻓﺔ‬،‫اﺳﻤﻬﺎ‬name‫اﻟﺮﻣﺰي‬ ‫اﻟﻨﻮع‬ ‫ﻣﻦ‬ ‫ﻋﻨﺼﺮا‬ ‫ﻋﺸﺮ‬ ‫ﺧﻤﺴﺔ‬ ‫ﻟﻬﺎ‬ ‫ﻳﺤﺠﺰ‬
‫ﻟﻬﺎ‬.
‫وﻫﻜـﺬا‬...
‫ﻣﺜﻞ‬int–double -
char
‫اﻟﺠﻤﺎﻋﻲ‬ ‫اﻻﺳﻢ‬
‫ﻣﻦ‬ ‫اﻟﻌﺪد‬
‫اﻟﻌﻨﺎﺻﺮ‬

‫ﻣﺮﻗﻢ‬ ‫ﻣﺘﻐﻴﺮ‬ ‫ﻋﻨﺎﺻﺮ‬ ‫ﻟﻘﻴﻢ‬ ‫ذاﺗﻲ‬ ‫إدﺧﺎل‬ ‫ﻋﻤﻠﻴﺔ‬ ‫ﻋﻠﻰ‬ ‫ﻣﺜﺎل‬)‫ﻣﺼﻔﻮﻓﺔ‬(‫واﺣﺪ‬ ‫ﺑﻌﺪ‬ ‫ذي‬
‫ﻋﺸﺮﻳ‬ ‫إدﺧﺎل‬ ‫ﻳﺘﻢ‬ ‫اﻟﺤﺎﻟﺔ‬ ‫ﻫﺬه‬ ‫ﻓﻲ‬‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫ﻋﻨﺎﺻﺮ‬ ‫ﻣﻦ‬ ‫ﻋﻨﺼﺮا‬ ‫ﻦ‬a
A[0]=1‫ﻳﻜﻮن‬ ‫ﻋﻨﺪﻣﺎ‬I=0
A[1]=2‫ﻳﻜﻮن‬ ‫ﻋﻨﺪﻣﺎ‬I=1
…
…
…
a[19]=20‫ﻳﻜﻮن‬ ‫ﻋﻨﺪﻣﺎ‬I=19
main ()
{
int a[20];
int I;
for (I=0;I<20;++I)
a[I]=I+1;
return0;
} ‫ﻣﺮﻗﻢ‬ ‫ﻋﺪاد‬
‫اﻟﻤﺼﻔﻮﻓﺔ‬

‫إدﺧﺎل‬ ‫ﻋﻤﻠﻴﺎت‬ ‫ﻋﻠﻰ‬ ‫ﻣﺜﺎل‬،‫وﺣﺴﺎب‬،‫ﻣﺼﻔﻮﻓﺔ‬ ‫ﻋﻨﺎﺻﺮ‬ ‫ﻃﺒﺎﻋﺔ‬ ‫وﻋﻤﻠﻴﺎت‬:
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻨﺤﻮ‬ ‫ﻋﻠﻰ‬ ‫اﻟﻨﺘﺎﺋﺞ‬ ‫ﻗﻴﻢ‬ ‫وﺳﺘﻜﻮن‬:
0 0
1 1
2 4
3 9
4 16
main ()
{
int x[5], y[5];
int I;
for (I=0;I<5;++I)
{
x[I]=I;
y[I]=I*I;
cout<<endl<<x[I]<<y[I];
}
return0;
}

‫اﻟﻮاﺣﺪ‬ ‫اﻟﺒﻌﺪ‬ ‫ذات‬ ‫ﻟﻠﻤﺼﻔﻮﻓﺔ‬ ‫أوﻟﻴﺔ‬ ‫ﻗﻴﻤﺔ‬ ‫إﻋﻄـﺎء‬Array
Initialization
‫اﻟﺪرﺟﺎت‬ ‫ﻣﺼﻔﻮﻓﺔ‬ ‫ﻣﻦ‬ ‫ﻋﻨﺎﺻﺮ‬ ‫ﻋﺪة‬ ‫إدﺧﺎل‬ ‫ﻋﻠﻰ‬ ‫ﻣﺜﺎل‬grade[]
Int grade[5]={80,90,54,50,95}
‫اﻟﺮﻣﺰﻳﺔ‬ ‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫ﻋﻨﺎﺻﺮ‬ ‫ﻗﻴﻢ‬ ‫إدﺧﺎل‬ ‫ﻋﻠﻰ‬ ‫وﻣﺜﺎل‬name[]
Char name[4]=“nor”
‫ﺮﻗﻢ‬ ‫اﻟﻤ‬ ‫ﻴﺮ‬ ‫اﻟﻤﺘﻐ‬ ‫أن‬ ‫ﻆ‬ ‫ﻻﺣ‬name[]‫ﺔ‬ ‫ﺛﻼﺛ‬ ‫ﺎؤه‬ ‫إﻋﻄ‬ ‫ﻢ‬ ‫ﺗ‬ ‫ﻨﻤﺎ‬ ‫ﺑﻴ‬ ‫ﺮ‬ ‫ﻋﻨﺎﺻ‬ ‫ﺔ‬ ‫أرﺑﻌ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻮن‬ ‫ﻣﻜ‬
‫ﺧﺎﻟﻴﺎ‬ ‫ﻳﻜﻮن‬ ‫اﻟﺮﻣﺰﻳﺔ‬ ‫اﻟﻤﻌﻄﻴﺎت‬ ‫إﻟﻰ‬ ‫ﺑﺎﻟﻨﺴﺒﺔ‬ ‫اﻟﺮاﺑﻊ‬ ‫اﻟﻌﻨﺼﺮ‬ ‫أن‬ ‫واﻟﺴﺒﺐ‬ ‫ﻓﻘﻂ‬ ‫ﻋﻨﺎﺻﺮ‬.
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫ﺳﻴﻜﻮن‬ ‫ﻃﺒﻌﺎ‬ ‫واﻟﻨﺎﺗﺞ‬:
40
60
50
70
80
90
main ()
{
int a[6]={40,60,50,70,80,90}
int I;
for(I=0;I<6;I++)
cout<<a[I]<<endl;
return0;
}
‫ﻗﺒﻞ‬ ‫ﻣﻦ‬ ‫اﻟﻘﻴﻢ‬ ‫إﻋﻄﺎء‬ ‫ﺗﻢ‬
‫ﻫﻨﺎ‬ ‫ﻣﺴﺒﻘﺎ‬ ‫اﻟﻤﺴﺘﺨﺪم‬

‫ﻮع‬ ‫ﻣﺠﻤ‬ ‫ﺎد‬ ‫ﺑﺈﻳﺠ‬ ‫ﻮم‬ ‫ﻳﻘ‬ ‫ﺮﻧﺎﻣﺞ‬ ‫ﺑ‬ ‫ﺘﺎﺑﺔ‬ ‫ﺑﻜ‬ ‫ﻢ‬ ‫ﻗ‬،‫ﻲ‬ ‫ﻓ‬ ‫ﺐ‬ ‫اﻟﻄﺎﻟ‬ ‫ﺎت‬ ‫ﻋﻼﻣ‬ ‫ﺪل‬ ‫وﻣﻌ‬5‫ﺬه‬ ‫وﻫ‬ ‫ﻮاد‬ ‫ﻣ‬
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫اﻟﻌﻼﻣﺎت‬:
87,67,81,90,55
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫ﺳﻴﻜﻮن‬ ‫واﻟﻨﺎﺗﺞ‬:
87
735
‫اﻟﻤﻌﺪل‬87
‫واﻟﻤﺠﻤﻮع‬735
int m,i;
main ()
{
int a[5]={87,67,81,90,55}
int s=0;
for(i=0;i<5;i++)
s=s+m[a];
float avg=s/5;
cout<<avg<<endl;<<s<<endl;
return0;
}
‫اﻟﻤﻌﺪل‬ ‫ﻗﻴﻤﺔ‬
‫اﻟﻌﻼﻣﺎت‬ ‫ﻟﺠﻤﻴﻊ‬

‫ـﺮة‬‫ـ‬‫اﻟﺬاﻛ‬ ‫ـﻲ‬‫ـ‬‫ﻓ‬ ‫ـﻔﻮﻓﺔ‬‫ـ‬‫اﻟﻤﺼ‬ ‫ـﺮ‬‫ـ‬‫ﻋﻨﺎﺻ‬ ‫ـﻨﻮان‬‫ـ‬‫ﻋ‬essingAddr
Array Elements in Memory
‫ﻣﺮﻗﻢ‬ ‫ذاﺗﻲ‬ ‫ﻣﺘﻐﻴﺮ‬ ‫ﻣﻦ‬ ‫ﻋﻨﺼﺮ‬ ‫أو‬ ‫ﻴﺮ‬‫ﻣﺘﻐ‬ ‫آي‬ ‫أن‬ ‫ﺒﻞ‬‫ﻗ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺮﻧﺎ‬‫ذﻛ‬،‫اﻟﺬاﻛﺮة‬ ‫ﻣﻦ‬ ‫ﻣﻮﻗﻌﺎ‬ ‫ﻳﺤﺘﻞ‬
‫ﺮ‬ ‫ﻋﻨﺼ‬ ‫أو‬ ‫ﻴﺮ‬ ‫ﻣﺘﻐ‬ ‫ﻞ‬ ‫ﻟﻜ‬ ‫ﺮا‬ ‫ﻣﺆﺷ‬ ‫ﺎدة‬ ‫ﻋ‬ ‫ﺘﻌﻤﻞ‬ ‫ﻳﺴ‬،‫ﺬه‬ ‫ﻫ‬ ‫ﺘﻌﻤﺎل‬ ‫اﺳ‬ ‫ﻰ‬ ‫ﻋﻠ‬ ‫ﻴﻼ‬ ‫دﻟ‬ ‫ﻴﻜﻮن‬ ‫ﻟ‬
‫ﺮ‬ ‫وﻳﺴ‬ ‫ﻬﻮﻟﺔ‬ ‫ﺑﺴ‬ ‫ﺮ‬ ‫واﻟﻌﻨﺎﺻ‬ ‫ﻴﺮات‬ ‫اﻟﻤﺘﻐ‬،‫ﺒﺔ‬ ‫ﺑﺎﻟﻨﺴ‬ ‫ﻴﺔ‬ ‫اﻟﻌﻤﻠ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﺢ‬ ‫ﻳﻮﺿ‬ ‫ﻲ‬ ‫اﻟﺘﺎﻟ‬ ‫ﺜﺎل‬ ‫واﻟﻤ‬
‫ﻟﻠﻤﺼﻔﻮﻓﺔ‬‫واﺣﺪ‬ ‫ﺑﻌﺪ‬ ‫ذات‬.
Int x[5];
‫ﻔﻮﻓﺔ‬ ‫اﻟﻤﺼ‬ ‫ﺮ‬ ‫ﻋﻨﺎﺻ‬ ‫ﻴﻞ‬ ‫ﺗﻤﺜ‬ ‫ﻦ‬ ‫ﻳﻤﻜ‬x‫ﻨﻬﺎ‬ ‫ﻋ‬ ‫ﻦ‬ ‫اﻟﻤﻌﻠ‬،‫ﻴﺤﻲ‬ ‫اﻟﺘﻮﺿ‬ ‫ﻜﻞ‬ ‫ﺑﺎﻟﺸ‬ ‫ﻨﻬﺎ‬ ‫ﻋﻨﺎوﻳ‬ ‫ﻊ‬ ‫ﻣ‬
‫اﻟﺘﺎﻟﻲ‬)‫اﻟﻴﻤﻴﻦ‬ ‫إﻟﻰ‬ ‫اﻟﻴﺴﺎر‬ ‫ﻣﻦ‬(
‫اﻟﺮاﺑﻊ‬ ‫اﻟﺨﺎﻣﺲ‬‫اﻟﺜﺎﻟﺚ‬‫اﻟﺜﺎﻧﻲ‬‫اﻷول‬
X[0] X[1] X[2] X[3] X[4]
100 101 102 103 104
‫اﻷول‬ ‫ﺮ‬‫اﻟﻌﻨﺼ‬ ‫ﻊ‬‫ﻣﻮﻗ‬ ‫ﻨﻮان‬‫ﻋ‬ ‫أن‬ ‫ﻨﺎ‬‫ﻓﺮﺿ‬ ‫إذا‬x[0]‫ﻮ‬‫ﻫ‬ ‫ﺮة‬‫اﻟﺬاﻛ‬ ‫ﻲ‬‫ﻓ‬100،‫ﻋﻨﺎوﻳﻦ‬ ‫ﻓﺎن‬
‫اﻟﺘﻮاﻟﻲ‬ ‫ﻋﻠﻰ‬ ‫ﺗﻜﻮن‬ ‫اﻷﺧﺮى‬ ‫اﻟﻌﻨﺎﺻﺮ‬101102103104
‫اﻟﻌﻨﺼﺮ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﻦ‬‫ﺑﻴ‬ ‫ﺔ‬‫اﻟﻌﻼﻗ‬ ‫ﺒﻴﻪ‬‫ﺗﺸ‬ ‫ﻦ‬‫ﻳﻤﻜ‬،‫وﻋﻨﻮاﻧﻪ‬،‫ﻃﺎﻟ‬ ‫ﻋﻼﻣﺔ‬ ‫ﺑﻴﻦ‬ ‫ﺑﺎﻟﻌﻼﻗﺔ‬‫ﺐ‬،‫ورﻗﻤﻪ‬
‫اﻟﺠﺎﻣﻌﻲ‬،‫ﻛﻌﻨﺼﺮ‬ ‫ﻧﺸﻄﻪ‬ ‫ﻗﻴﻤﺔ‬ ‫ﻫﻲ‬ ‫ﻋﻼﻣﺘﻪ‬ ‫إذ‬،‫اﻟﺠﺎﻣﻌﻲ‬ ‫ﻣﻘﻌﺪه‬ ‫ﺑﺮﻗﻢ‬ ‫ﻋﻼﻗﺔ‬ ‫ﻟﻬﺎ‬ ‫ﻟﻴﺲ‬.
‫ﻓﻲ‬ ‫ﻋﻨﻮاﻧﻪ‬
‫اﻟﺬاﻛﺮة‬
‫اﻟﻌﻨﺼﺮ‬

‫اﻟﺒﻌﺪﻳﻦ‬ ‫ذات‬ ‫اﻟﻤﺼﻔﻮﻓﺔ‬Dimensional Arrays-Two
‫ﺎ‬‫ﺗﻌﺎﻣﻠﻬ‬ ‫ﺮﻳﻘﺔ‬‫ﻃ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻦ‬‫اﻟﺒﻌﺪﻳ‬ ‫ذات‬ ‫ﻔﻮﻓﺔ‬‫اﻟﻤﺼ‬ ‫ﺒﺔ‬‫ﺗﺸ‬،‫أن‬ ‫إﻻ‬ ‫ﺪ‬‫اﻟﻮاﺣ‬ ‫ﺒﻌﺪ‬‫اﻟ‬ ‫ذات‬ ‫ﻔﻮﻓﺔ‬‫اﻟﻤﺼ‬
‫ﻦ‬ ‫ﻋﺪادﻳ‬ ‫ﺎ‬ ‫ﻟﻬ‬)(index2‫ﻦ‬ ‫ﻣﺮﻗﻤﻴ‬ ‫أو‬ ‫ﻦ‬ ‫دﻟﻴﻠﻴ‬‫ﻔﻮف‬ ‫ﻟﻠﺼ‬ ‫ﺪاد‬ ‫ﻋ‬ ‫ﺎ‬ ‫إﺣﺪاﻫﻤ‬،‫ﺪاد‬ ‫ﻋ‬ ‫ﺮ‬ ‫واﻷﺧ‬
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻌﺎم‬ ‫اﻟﺸﻜﻞ‬ ‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫ﻋﻦ‬ ‫اﻹﻋﻼن‬ ‫وﻳﺄﺧﺬ‬ ‫ﻟﻸﻋﻤﺪة‬:
Type-specifier arraey_name [index 1][index 2];
‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫ﻓﻤﺜﻼ‬:
Int x[2][3];
‫ﺮ‬‫اﻟﻌﻨﺎﺻ‬ ‫ﺤﻴﺤﺔ‬‫ﺻ‬ ‫ﻔﻮﻓﺔ‬‫ﻣﺼ‬ ‫ﻲ‬‫وﻫ‬int‫ﻔﻮف‬‫اﻟﺼ‬ ‫ﺪد‬‫ﻋ‬ ‫ﻲ‬‫ﻫ‬ ‫ﺎ‬‫أﺑﻌﺎدﻫ‬=2،‫اﻷﻋﻤﺪة‬ ‫وﻋﺪد‬
3=
‫وﺣﺪه‬ ‫ﻗﻮﺳﻴﻦ‬ ‫ﺑﻴﻦ‬ ‫ﻳﻮﺿﻊ‬ ‫اﻟﺼﻔﻮف‬ ‫ﻋﺪد‬ ‫أن‬ ‫ﻻﺣﻆ‬،‫اﻷﻋﻤﺪة‬ ‫ﻋﺪاد‬ ‫وﻛﺬﻟﻚ‬.
‫اﻟﺜﺎﻧﻲ‬ ‫اﻟﺪﻟﻴﻞ‬‫اﻷول‬ ‫اﻟﺪﻟﻴﻞ‬‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫اﺳﻢ‬

‫ﻳﺴﺘﺨﺪم‬ ‫اﻟﺬي‬ ‫اﻟﻤﺜﺎل‬ ‫ﻫﺬا‬ ‫ﺷﺎﻫﺪ‬5‫و‬ ‫ﻃﻼب‬3‫ﻋﻼﻣﺎت‬:
‫ﺮة‬ ‫اﻟﺬاﻛ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺎد‬ ‫اﻷﺑﻌ‬ ‫ﺘﻌﺪدة‬ ‫ﻣ‬ ‫ﻔﻮﻓﺔ‬ ‫اﻟﻤﺼ‬ ‫ﺮ‬ ‫اﻟﻌﻨﺎﺻ‬ ‫ﻦ‬ ‫ﻟﻌﻨﺎوﻳ‬ ‫ﺒﺔ‬ ‫وﺑﺎﻟﻨﺴ‬،‫ﺎ‬ ‫ﻋﻤ‬ ‫ﺘﻠﻒ‬ ‫ﻳﺨ‬ ‫ﻻ‬
‫ﺪ‬‫اﻟﻮاﺣ‬ ‫ﺒﻌﺪ‬‫اﻟ‬ ‫ذات‬ ‫ﻔﻮﻓﺎت‬‫ﻟﻠﻤﺼ‬ ‫ﺒﺔ‬‫ﺑﺎﻟﻨﺴ‬ ‫ﺮﻧﺎ‬‫ذﻛ‬،‫ﻓﺮﺿﻨﺎ‬ ‫ﻟﻮ‬ ‫وﻟﺬﻟﻚ‬،‫أن‬ ‫اﻟﺴﺎﺑﻖ‬ ‫اﻟﻤﺜﺎل‬ ‫ﻓﻲ‬
‫ﺮ‬‫اﻟﻌﻨﺼ‬x[0,0]‫ﻨﻮاﻧﻪ‬‫ﻋ‬ ‫ﺎن‬‫ﻛ‬100‫ﻴﺔ‬‫اﻟﺘﺎﻟ‬ ‫ﺮ‬‫اﻟﻌﻨﺎﺻ‬ ‫ﻦ‬‫ﻋﻨﺎوﻳ‬ ‫ﺎن‬‫ﻓ‬ ‫ﺜﻼ‬‫ﻣ‬:‫ﺗﺮﺗﻴ‬ ‫ﺣﺴﺐ‬‫ﺒﻬﺎ‬
‫ﻲ‬ ‫ﻫ‬ ‫ﻼه‬ ‫أﻋ‬ ‫ﻮر‬ ‫اﻟﻤﺬﻛ‬102-101-100‫اﻷول‬ ‫ﻒ‬ ‫اﻟﺼ‬ ‫ﺮ‬ ‫ﻟﻌﻨﺎﺻ‬105-104-103
‫اﻟﺜﺎﻧﻲ‬ ‫اﻟﺼﻒ‬ ‫ﻟﻌﻨﺎﺻﺮ‬.
main ()
{
int m[5][3];
int I,j;
for(I=0;I<5;I++)
for(j=0;j>3;j++)
cin>>m[I][j];
return0;
}

‫ﻣﻘﺪﻣﺔ‬Introduction
‫ﺔ‬‫اﻟﺪاﻟ‬ ‫ﺮف‬‫ﺗﻌ‬)‫ﺘﺮان‬‫اﻻﻗ‬(‫ﺎ‬‫أﻧﻬ‬ ‫ﻰ‬‫ﻋﻠ‬:‫ﺗﻌﻠﻴﻤﺎت‬ ‫أو‬ ‫ﻞ‬‫ﺟﻤ‬ ‫ﺔ‬‫ﻣﺠﻤﻮﻋ‬ ‫أو‬ ‫ﺔ‬‫ﺟﻤﻠ‬،‫ﻛﻴﺎن‬ ‫ذات‬
‫ﺎص‬ ‫ﺧ‬،‫ﻴﺎت‬ ‫ﻋﻤﻠ‬ ‫ﺔ‬ ‫ﻣﺠﻤﻮﻋ‬ ‫أو‬ ‫ﻴﺔ‬ ‫ﺑﻌﻤﻠ‬ ‫ﻮم‬ ‫ﺗﻘ‬،‫ﺎ‬ ‫إدﺧ‬ ‫ﻴﺎت‬ ‫ﻋﻤﻠ‬ ‫ﻮاء‬ ‫ﺳ‬‫أو‬ ‫ﺮاج‬ ‫إﺧ‬ ‫أو‬ ‫ل‬
‫ﻴﺔ‬‫ﻣﻨﻄﻘ‬ ‫أو‬ ‫ﺎﺑﻴﺔ‬‫ﺣﺴ‬ ‫ﻴﺎت‬‫ﻋﻤﻠ‬،‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻣﻦ‬ ‫ﻣﻮﻗﻌﺎ‬ ‫ﺔ‬‫اﻟﺪاﻟ‬ ‫ﺘﻞ‬‫وﺗﺤ‬،‫ﻣﻨﻪ‬ ‫ﺟﺰء‬ ‫أﻧﻬﺎ‬ ‫آي‬،‫أو‬
‫ﺑﺮﻧﺎﻣﺞ‬ ‫أن‬ ‫اﻟﻘﻮل‬ ‫ﻳﻤﻜﻦ‬c++،‫اﻟﺪوال‬ ‫ﻣﻦ‬ ‫ﻣﺠﻤﻮﻋﺔ‬ ‫ﻣﻦ‬ ‫ﻳﺘﻜﻮن‬.
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺪوال‬ ‫ﻓﻮاﺋﺪ‬ ‫وﻣﻦ‬:
١-‫ﺘﻔﻰ‬ ‫ﻳﻜ‬ ‫إذ‬ ‫ﺒﺮﻧﺎﻣﺞ‬ ‫اﻟ‬ ‫ﺎر‬ ‫اﺧﺘﺼ‬ ‫ﻰ‬ ‫ﻋﻠ‬ ‫ﺐ‬ ‫اﻟﺤﺎﺳ‬ ‫ﺮة‬ ‫ذاﻛ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺰﻧﺔ‬ ‫اﻟﻤﺨ‬ ‫ﺪوال‬ ‫اﻟ‬ ‫ﺎﻋﺪ‬ ‫ﺗﺴ‬
‫ﺑﺎﺳﻤﻬ‬ ‫ﺑﺎﺳﺘﻌﺎدﺗﻬﺎ‬‫اﻟﻤﻄﻠﻮب‬ ‫ﺑﺎﻟﻌﻤﻞ‬ ‫ﻟﺘﻘﻮم‬ ‫ﻓﻘﻂ‬ ‫ﺎ‬.
٢-‫اﻟﺤﺎﺳﺐ‬ ‫ﺒﺔ‬‫ﻣﻜﺘ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺰﻧﺔ‬‫اﻟﻤﺨ‬ ‫ﺪوال‬‫اﻟ‬ ‫ﺎﻋﺪ‬‫ﺗﺴ‬،‫ﺗﻼﻓﻲ‬ ‫ﻋﻠﻰ‬ ‫اﻟﻤﺒﺮﻣﺞ‬ ‫ﻳﻜﺘﺒﻬﺎ‬ ‫اﻟﺘﻲ‬ ‫أو‬
‫وﺷﺎﻗﺎ‬ ‫ﻃﻮﻳﻼ‬ ‫ﻋﻤﻼ‬ ‫ﺗﺘﻄﻠﺐ‬ ‫اﻟﺘﻲ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺧﻄﻮات‬ ‫ﻓﻲ‬ ‫اﻟﺘﻜﺮار‬ ‫ﻋﻤﻠﻴﺎت‬.
٣-‫ﻧﻔﺴﻬﺎ‬ ‫اﻟﺒﺮﻣﺠﺔ‬ ‫ﻋﻤﻠﻴﺔ‬ ‫ﺗﺴﻬﻴﻞ‬ ‫ﻋﻠﻰ‬ ‫اﻟﺠﺎﻫﺰة‬ ‫اﻟﺪوال‬ ‫ﺗﺴﺎﻋﺪ‬.
٤-‫اﻟﻤﻄﻠﻮﺑﺔ‬ ‫اﻟﺬاﻛﺮة‬ ‫ﻣﻦ‬ ‫ﻣﺴﺎﺣﺔ‬ ‫ﺗﻮﻓﺮ‬.
٥-‫ﻋﻤﻠ‬ ‫اﺧﺘﺼﺎر‬‫ﻣﻤﻜﻦ‬ ‫وﻗﺖ‬ ‫ﺑﺄﺳﺮع‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫وﺗﻨﻔﻴﺬ‬ ‫اﻟﺒﺮﻣﺠﺔ‬ ‫زﻣﻦ‬ ‫ﻴﺎت‬.
‫ﺑﺮﻣﺠﺔ‬ ‫ﻓﻲ‬ ‫اﻟﺪوال‬ ‫أﻫﻤﻴﺔ‬ ‫ﻋﻠﻰ‬ ‫وﻟﻠﺘﺪﻟﻴﻞ‬c++‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻤﺜﺎل‬ ‫ﺧﺬ‬:
‫ﻳﺄﺗﻲ‬ ‫ﻣﺎ‬ ‫ﻧﻜﺘﺐ‬ ‫ﻓﺄﻧﻨﺎ‬ ‫اﻟﺸﺎي‬ ‫ﻣﻦ‬ ‫ﻛﺄس‬ ‫ﺻﻨﻊ‬ ‫ﻟﺨﻄﻮات‬ ‫ﺧﻮارزﻣﻴﺔ‬ ‫ﻛﺘﺎﺑﺔ‬ ‫أردﻧﺎ‬ ‫ﻟﻮ‬:
١-‫اﻟﺸﺎي‬ ‫ﻏﻼﻳﺔ‬ ‫ﻓﻲ‬ ‫اﻟﻤﺎء‬ ‫ﺿﻊ‬.
٢-‫ﻳﻐﻠﻰ‬ ‫ﺣﺘﻰ‬ ‫اﻟﻤﺎء‬ ‫ﺳﺨﻦ‬.
٣-‫اﻟﻤﺎء‬ ‫إﻟﻰ‬ ‫ﺷﺎﻳﺎ‬ ‫أﺿﻒ‬.
٤-‫إﻟﻴﻪ‬ ‫ﺳﻜﺮا‬ ‫أﺿﻒ‬.
٥-‫أﻃ‬‫اﻟﻨﺎر‬ ‫ﻔﺊ‬.
٦-‫ﻛﺄس‬ ‫ﻓﻲ‬ ‫ﺷﺎﻳﺎ‬ ‫ﺻﺐ‬.
‫ﺎور‬ ‫ﻣﺠ‬ ‫ﻰ‬ ‫ﻣﻘﻬ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺎي‬ ‫اﻟﺸ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺄس‬ ‫ﻛ‬ ‫ﺐ‬ ‫ﻃﻠ‬ ‫ﻮد‬ ‫ﻧ‬ ‫ﻨﺎ‬ ‫أﻧ‬ ‫اﻵن‬ ‫ﺮض‬ ‫اﻓ‬:‫ﻮات‬ ‫ﺧﻄ‬ ‫أن‬
‫وﻫﻲ‬ ‫ﻓﻘﻂ‬ ‫واﺣﺪه‬ ‫ﺧﻄﻮه‬ ‫ﻫﻲ‬ ‫اﻵن‬ ‫ﻧﺤﺘﺎﺟﻬﺎ‬ ‫اﻟﺘﻲ‬ ‫اﻟﺨﻮارزﻣﻴﺔ‬:
١-‫اﻟﺸﺎي‬ ‫ﻣﻦ‬ ‫ﻛﺄس‬ ‫اﺳﺘﺪع‬.
‫ﺰة‬ ‫اﻟﺠﺎﻫ‬ ‫ﺪوال‬ ‫اﻟ‬ ‫ﺘﻌﻤﻠﻨﺎ‬ ‫اﺳ‬ ‫ﻮ‬ ‫ﻟ‬ ‫ﻮات‬ ‫اﻟﺨﻄ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺮﻧﺎ‬ ‫وﻓ‬ ‫ﻢ‬ ‫ﻛ‬ ‫اﻵن‬ ‫ﻴﻞ‬ ‫ﺗﺨ‬)‫ﺰﻫﺎ‬ ‫ﻳﺠﻬ‬ ‫ﻲ‬ ‫اﻟﺘ‬ ‫أو‬
‫ﺒﻞ‬‫ﻗ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺒﺮﻣﺞ‬‫اﻟﻤ‬(‫ﺪﻻ‬‫ﺑ‬‫ﺣﺴﺎﺑﺎت‬ ‫ﻳﺘﻄﻠﺐ‬ ‫ﺑﺮﻧﺎﻣﺞ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺔ‬‫وﺑﺨﺎﺻ‬ ‫ﻴﻠﻴﺔ‬‫اﻟﺘﻔﺼ‬ ‫ﺎ‬‫ﺧﻄﻮاﺗﻬ‬ ‫ﻦ‬‫ﻣ‬
‫وﻗﺘﺬاك‬ ‫وواﺿﺤﺎ‬ ‫ﺳﻬﻼ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻳﻜﻮن‬ ‫وﻛﻢ‬ ‫ﻛﺜﻴﺮة‬ ‫وﻋﻤﻠﻴﺎت‬.
‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﻌﺎم‬ ‫اﻟﺸﻜﻞ‬ ‫اﻟﺪاﻟﺔ‬ ‫وﺗﺄﺧﺬ‬:
‫اﻟﺪوال‬
Functions

Type-specified function-name (formal parameters;
{
function body
}
‫ا‬ ‫أو‬ ‫ﻴﺮ‬ ‫ﻣﺘﻐ‬ ‫ﻰ‬ ‫ﻋﻠ‬ ‫ﺘﻤﺪ‬ ‫ﺗﻌ‬ ‫ﺪ‬ ‫ﻗ‬ ‫ﺔ‬ ‫اﻟﺪاﻟ‬ ‫أن‬ ‫ﺒﻞ‬ ‫ﻗ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺮﻧﺎ‬ ‫ذﻛ‬ ‫ﺪ‬ ‫وﻗ‬‫ﺜﺮ‬ ‫ﻛ‬،‫آي‬ ‫ﻰ‬ ‫ﻋﻠ‬ ‫ﺘﻤﺪ‬ ‫ﺗﻌ‬ ‫ﻻ‬ ‫ﺪ‬ ‫وﻗ‬
‫ﻴﺮ‬ ‫ﻣﺘﻐ‬،‫ﻦ‬ ‫اﻟﺤﺎﻟﺘﻴ‬ ‫ﻼ‬ ‫ﻛ‬ ‫ﻲ‬ ‫وﻓ‬،‫ﻴﻦ‬ ‫ﻗﻮﺳ‬ ‫ﺔ‬ ‫اﻟﺪاﻟ‬ ‫ﻢ‬ ‫اﺳ‬ ‫ﺪ‬ ‫ﺑﻌ‬ ‫ﺘﻌﻤﻞ‬ ‫ﻳﺴ‬()‫ﻨﻬﻤﺎ‬ ‫ﺑﻴ‬ ‫ﺎن‬ ‫ﻛ‬ ‫ﻮاء‬ ‫ﺳ‬
‫ﻻ‬ ‫أم‬ ‫ﻣﺘﻐﻴﺮات‬.
hello hello hello hello
‫ﻟﻠﺒﺮﻧﺎﻣﺞ‬ ‫اﻟﻤﺘﺮﺟﻢ‬ ‫ﻗﺮاءة‬ ‫ﺑﺪاﻳﺔ‬ ‫أن‬ ‫ﻧﻼﺣﻆ‬ ‫اﻟﺪوال‬ ‫اﻟﻔﺼﻞ‬ ‫ﺬا‬‫ﻫ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﻲ‬‫أﻋﺰاﺋ‬ ‫ﻢ‬‫ﻟﻠﻌﻠ‬ ‫ﺒﻌﺎ‬‫ﻃ‬
‫ﺑﺎﻟﻤﺎﻳﻦ‬ ‫ﺗﺒﺪا‬ ‫أﻧﻬﺎ‬ ‫آي‬ ‫ﻔﻞ‬‫اﻷﺳ‬ ‫ﻦ‬‫ﻣ‬ ‫ﺒﺪأ‬‫ﺗ‬ ‫ﺮاءة‬‫ﻓﺎﻟﻘ‬ ‫ﺘﺎد‬‫ﻛﺎﻟﻤﻌ‬ ‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫أول‬ ‫ﻦ‬‫ﻣ‬ ‫ﺒﺪأ‬‫ﺗ‬ ‫ﻻ‬main
‫ـ‬‫اﻟ‬ ‫أوﻻ‬ ‫ﺮاء‬‫ﺗﻘ‬ ‫ﺎ‬‫ﻓﺄﻧﻬ‬ ‫ﻔﻞ‬ ‫اﻷﺳ‬ ‫أو‬ ‫ﻂ‬‫اﻟﻮﺳ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺎن‬‫ﻛ‬ ‫ﻮاء‬‫ﺳ‬main‫ﺒﺪا‬ ‫وﺗ‬ ‫ﻪ‬‫داﺧﻠ‬ ‫ﺎ‬‫ﻣ‬ ‫ﺚ‬‫ﺗﺒﺤ‬ ‫ﻢ‬‫ﺛ‬
‫ﺔ‬ ‫اﻟﻜﻠﻤ‬ ‫ﻨﻰ‬ ‫ﻣﻌ‬ ‫ﻦ‬ ‫ﻋ‬ ‫ﺚ‬ ‫ﺑﺎﻟﺒﺤ‬max1()‫ﺔ‬ ‫اﻟﺪاﻟ‬ ‫ﻲ‬ ‫ﻓ‬max1()‫ﻨﺎك‬ ‫ﻫ‬ ‫أن‬ ‫ﺘﺠﺪ‬ ‫ﻟ‬ ‫ﻰ‬ ‫اﻷﻋﻠ‬ ‫ﻲ‬ ‫ﻓ‬
‫ﻳ‬ ‫ﺣﺘﻰ‬ ‫ﺗﺘﻜﺮر‬ ‫وﻫﻜﺬا‬ ‫ﻃﺒﺎﻋﺔ‬ ‫ﺟﻤﻠﺔ‬‫اﻟـ‬ ‫ﺑﺪاﺧﻞ‬ ‫ﻣﺎ‬ ‫ﺗﻌﺮﻳﻒ‬ ‫ﺘﻢ‬main.
max1()
{
cout<<”hello”;
}
void main()
{
max1 ();
max1();
max1(); max1();
}

‫اﻟﺪوال‬ ‫ﻋﻠﻰ‬ ‫ﺗﻄﺒﻴﻘﺎت‬
‫ﺑﺎﻟـ‬ ‫أوﻻ‬ ‫وﺗﺘﺒﻌﻪ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻫﺬا‬ ‫ﺷﺎﻫﺪ‬main‫ﻟﻠﻨﺘﺎﺋﺞ‬ ‫واﻧﻈﺮ‬:
‫اﻟﻘﺎدﻣﺔ‬ ‫اﻷﻣﺜﻠﺔ‬ ‫ﻓﻲ‬ ‫ﻋﻠﻴﻜﻢ‬ ‫ﻟﻠﺘﺴﻬﻴﻞ‬ ‫إﻇﻬﺎرﻫﺎ‬ ‫ﻗﺒﻞ‬ ‫اﻟﻨﺘﺎﺋﺞ‬ ‫ﺳﺄﺷﺮح‬ ‫أﻋﺰاﺋﻲ‬:
‫ﻛﻮاﻛﺐ‬ ‫ﺛﻼث‬ ‫ﻫﻨﺎك‬ ‫أن‬ ‫ﻟﻨﺘﻌﺒﺮ‬:
‫ﻛﻮاﻛﺐ‬main‫اﻟﺮﺋﻴﺴﻲ‬
‫ﻛﻮﻛﺐ‬fax
‫ﻛ‬‫ﻮﻛﺐ‬max
‫ﺐ‬‫ﺑﻜﻮﻛ‬ ‫ﺒﺪا‬‫ﻧ‬ ‫ﻮف‬‫ﺳ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﺮوف‬‫اﻟﻤﻌ‬ ‫ﻦ‬‫ﻣ‬main‫ﻗﻴﻤﺘﻴﻦ‬ ‫ﻫﻨﺎك‬ ‫أن‬ ‫ﻧﺸﺎﻫﺪ‬ ‫ﻞ‬‫ﺑﺪاﺧ‬ ‫ﺎ‬‫ﻣ‬ ‫ﺎﻫﺪ‬‫ﻟﻨﺸ‬
‫ﻋﺪدﻳﺘﻴ‬‫ﻦ‬yx‫اﻷﻋﻠﻰ‬ ‫ﻓﻲ‬ ‫ﻳﺬﻫﺐ‬ ‫ﻟﺬﻟﻚ‬ ‫ﺤﻴﺤﻪ‬‫ﺻ‬ ‫أم‬ ‫ﻴﺔ‬‫ﺣﻘﻴﻘ‬ ‫ﺪاد‬‫أﻋ‬ ‫ﻲ‬‫ﻫ‬ ‫ﻞ‬‫ﻫ‬ ‫ﺮﻓﻪ‬‫ﻳﻌ‬ ‫ﻻ‬ ‫ﻨﻪ‬‫ﻟﻜ‬
‫ﺤﻴﺤﺔ‬ ‫ﺻ‬ ‫ﺪاد‬ ‫أﻋ‬ ‫ﺎ‬ ‫أﻧﻬ‬ ‫ﻴﺠﺪ‬ ‫ﻟ‬ ‫ﺒﺮﻧﺎﻣﺞ‬ ‫اﻟ‬ ‫أول‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻨﻬﺎ‬ ‫ﻋ‬ ‫ﺚ‬ ‫ﻟﻴﺒﺤ‬int،‫ﺮﺟﻊ‬ ‫ﻳ‬ ‫ﻚ‬ ‫ذﻟ‬ ‫ﺪ‬ ‫ﺑﻌ‬ ‫ﻢ‬ ‫ﺛ‬
‫ﻲ‬ ‫اﻟﺮﺋﻴﺴ‬ ‫ﺐ‬ ‫ﻟﻠﻜﻮﻛ‬main‫ﺒ‬ ‫ﻋ‬ ‫ﺎﻫﺪ‬ ‫ﻟﻴﺸ‬‫ﺎرة‬max()‫ﺐ‬ ‫اﻟﻜﻮﻛ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﻨﻬﺎ‬ ‫ﻋ‬ ‫ﺚ‬ ‫ﻟﻠﺒﺤ‬ ‫ﺐ‬ ‫ﻓﻴﺬﻫ‬
max‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫أن‬ ‫ﺎ‬ ‫ﺑﺪاﺧﻠﻬ‬ ‫ﻴﺠﺪ‬ ‫ﻟ‬ ‫ﺒﻌﺎ‬ ‫ﻃ‬x‫ﺎوي‬ ‫ﺗﺴ‬x+y‫أن‬ ‫أي‬x=0+10‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﺒﺢ‬ ‫ﻟﺘﺼ‬
x=10‫ﺐ‬ ‫اﻟﻜﻮﻛ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺮج‬ ‫ﻳﺨ‬ ‫ﻚ‬ ‫ذﻟ‬ ‫ﺪ‬ ‫ﺑﻌ‬max‫ﺒﺎرة‬ ‫اﻟﻌ‬ ‫ﺎﻫﺪ‬‫ﻟﻴﺸ‬ ‫ﻲ‬ ‫اﻟﺮﺋﻴﺴ‬ ‫ﺐ‬ ‫ﻟﻠﻜﻮﻛ‬ ‫ﺮﺟﻊ‬ ‫وﻳ‬
fax()‫ﺐ‬ ‫ﺑﺎﻟﻜﻮﻛ‬ ‫ﻴﻬﺎ‬ ‫ﻋﻠ‬ ‫ﺘﻌﺮف‬ ‫ﻟﻠ‬ ‫ﺐ‬ ‫ﻓﻴﺬﻫ‬fax()‫ﺒﺎرة‬ ‫ﻋ‬ ‫ﺎ‬ ‫ﺑﺪاﺧﻠﻬ‬ ‫ﺎﻫﺪ‬ ‫وﻳﺸ‬max‫ﺐ‬ ‫ﻟﻴﺬﻫ‬
‫ﻟﻠﻜﻮﻛﺐ‬ ‫ﺑﺬﻟﻚ‬max‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫ﻓﺘﺼﺒﺢ‬ ‫أﺧﺮى‬ ‫ﻣﺮة‬ ‫ﻣﻦ‬ ‫وﻳﺠﻤﻊ‬:
X=10+10‫ﻴﻤﺔ‬ ‫ﻗ‬ ‫ﺒﺢ‬ ‫ﺗﺼ‬ ‫ﻚ‬ ‫وﺑﺬﻟ‬x=20‫ﺐ‬ ‫ﻟﻠﻜﻮﻛ‬ ‫ﺮﺟﻊ‬ ‫ﻳ‬ ‫ﻚ‬ ‫ذﻟ‬ ‫ﺪ‬ ‫ﺑﻌ‬fax‫ﺒﺎرة‬ ‫ﻋ‬ ‫ﺎﻫﺪ‬ ‫ﻟﻴﺸ‬
max()‫ﻟﻠﻜﻮﻛﺐ‬ ‫ﻓﻴﺬﻫﺐ‬max‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫أﺧﺮى‬ ‫ﻣﺮة‬ ‫وﻳﺠﻤﻊ‬:
X=20+10‫ﻗﻴﻤﺔ‬ ‫ﺗﺼﺒﺢ‬ ‫وﺑﺬﻟﻚ‬x=30
‫اﻟﺮﺋﻴﺴﻲ‬ ‫ﻟﻠﻜﻮﻛﺐ‬ ‫ﻳﺮﺟﻊ‬ ‫ﺑﻌﺪﻫﺎ‬ ‫ﺛﻢ‬main‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫واﻟﻨﺎﺗﺞ‬ ‫اﻟﻄﺒﺎﻋﺔ‬ ‫ﺟﻤﻠﺔ‬ ‫ﻟﻴﺸﺎﻫﺪ‬:
30 10
int x,y;
void max()
{
x=x+y;
}
void fax()
{
max();
max();
{
void main()
{
y=10; x=0;
max();
fax();
cout<<x<<y;
}

‫ﻣ‬‫ﺜﺎل‬٣:
‫ﻛﺎﻟﺘﺎﻟﻲ‬ ‫ﺳﻴﻜﻮن‬ ‫واﻟﻨﺎﺗﺞ‬:
* *
* *
* *
* *
void x1()
{
cout<<”*”;
}
void x2()
{
cout<<”t”;
}
void yaya()
{
x1();
x2();
x1();
}
void kiki()
{
cout<<”n”:
}
void main()
{
int I;
for(I=0;I<=3;I++)
{
yaya();
kiki();
}
}

‫أم‬ ‫زوﺟﻲ‬ ‫اﻟﺮﻗﻢ‬ ‫ﻛﺎن‬ ‫إذا‬ ‫ﻣﺎ‬ ‫ﻃﺒﺎﻋﺔ‬ ‫ﻢ‬‫ﺛ‬ ‫ﻦ‬‫وﻣ‬ ‫ﺤﻴﺢ‬‫ﺻ‬ ‫ﺪد‬‫ﻋ‬ ‫ﺮاءة‬‫ﺑﻘ‬ ‫ﻮم‬‫ﻳﻘ‬ ‫ﺮﻧﺎﻣﺞ‬‫ﺑ‬ ‫ﺘﺎﺑﺔ‬‫ﺑﻜ‬ ‫ﻢ‬‫ﻗ‬
‫اﻗﺘﺮان؟‬ ‫أو‬ ‫داﻟﺔ‬ ‫ﺧﻼل‬ ‫ﻣﻦ‬ ‫ﻓﺮدي‬
‫اﻟﻘﻴﻤﺔ‬ ‫ﻣﺜﻼ‬ ‫ﻟﻨﺪﺧﻞ‬ ‫أدﺧﻠﺖ‬ ‫ﺣﺴﺒﻤﺎ‬ ‫ﺳﻴﻜﻮن‬ ‫واﻟﻨﺎﺗﺞ‬ ‫ﻃﺒﻌﺎ‬9..‫ﺳﻴﻜﻮن‬ ‫واﻟﻨﺎﺗﺞ‬:
ood
‫اﻟﻤﺪﺧﻠﺔ‬ ‫اﻟﻘﻴﻤﺔ‬ ‫ﻻن‬9‫زوﺟﻲ‬ ‫وﻟﻴﺲ‬ ‫ﻓﺮدي‬ ‫ﻋﺪد‬.
int x;
check()
{
if ((x%2)==0)
cout<<”even”<<endl;
else
cout<<”ood”<<endl;
}
main()
{
cin>>x;
check ();
return0;
}
‫زوﺟﻲ‬ ‫ﻛﺎن‬ ‫إذا‬ ‫اﻃﺒﻊ‬
‫ﻓﺮدي‬ ‫ﻛﺎن‬ ‫إذا‬ ‫اﻃﺒﻊ‬
‫اﻟﻘﻴﻤﺔ‬ ‫ادﺧﻞ‬9‫ﻣﺜﻼ‬

‫ﻣ‬‫ﺜﺎل‬٥:
‫اﻟﻤﺴﺘﺨﺪم‬ ‫ﻗﺒﻞ‬ ‫ﻣﻦ‬ ‫ﻦ‬‫ﻣﺪﺧﻠﻴ‬ ‫ﻦ‬‫رﻗﻤﻴ‬ ‫ﻦ‬‫ﺑﻴ‬ ‫ﺎ‬‫ﻣ‬ ‫ﻢ‬‫رﻗ‬ ‫ﺒﺮ‬‫اﻛ‬ ‫ﺘﺨﺮاج‬‫ﺑﺎﺳ‬ ‫ﻮم‬‫ﻳﻘ‬ ‫ﺮﻧﺎﻣﺞ‬‫ﺑ‬ ‫ﺘﺎﺑﺔ‬‫ﺑﻜ‬ ‫ﻢ‬‫ﻗ‬
‫اﺳﻤﻬﺎ‬ ‫داﻟﺔ‬ ‫ﺧﻼل‬ ‫ﻣﻦ‬ ‫وذﻟﻚ‬max‫؟‬
‫ﺳﻴﻜﻮن‬ ‫ﻃﺒﻌﺎ‬ ‫واﻟﻨﺎﺗﺞ‬:
20
‫أدﺧﻠﻨﺎ‬ ‫اﻟﺬي‬ ‫اﻟﻌﺪد‬ ‫ﻻن‬20‫أدﺧﻠﻨﺎ‬ ‫اﻟﺬي‬ ‫اﻟﻌﺪد‬ ‫ﻣﻦ‬ ‫اﻛﺒﺮ‬10‫اﻟﺸﺮط‬ ‫ﺣﺴﺐ‬ ‫ﺑﻄﺒﺎﻋﺘﻪ‬ ‫ﻓﻘﺎم‬.
int x,y;
max()
{
if (x>y)
cout<<x<<endl;
else
cout<<y<<endl;
}
main()
{
cin>>x>>y;
max ();
{
return0;
}
‫وﻟﺘﻜﻦ‬ ‫اﻟﻘﻴﻤﺘﻴﻦ‬ ‫ادﺧﻞ‬
‫اﻟﻘﻴﻤﺔ‬10‫و‬20
‫اﻷﻛﺒﺮ‬ ‫ﻣﻦ‬ ‫ﻟﻠﻤﻘﺎرﻧﺔ‬
‫اﻟﻘﻴﻤﺘﻴﻦ‬ ‫ﺑﻴﻦ‬

‫ﻣﻘﺪﻣﺔ‬Introduction
‫ﺮاص‬ ‫ﻟﻸﻗ‬ ‫ﻴﺔ‬ ‫اﻻﻧﺘﻘﺎﻟ‬ ‫ﺎت‬ ‫اﻟﻤﻠﻔ‬ ‫ﻊ‬ ‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬ ‫ﻟﻠ‬ ‫ﺪوال‬ ‫اﻟ‬ ‫ﺬه‬ ‫ﻫ‬ ‫ﻤﻤﺖ‬ ‫ﺻ‬Buffered filw
system‫ﻮص‬ ‫اﻟﻨﺼ‬ ‫ﺔ‬ ‫ﻟﻤﻌﺎﻟﺠ‬،‫ﺎ‬ ‫ﻛ‬ ‫ﺎ‬ ‫ﻛﻤ‬‫ﺔ‬ ‫ﻟﻐ‬ ‫ﻲ‬ ‫ﻓ‬ ‫ﺘﻮﻓﺮا‬ ‫ﻣ‬ ‫ن‬C++‫ﻴﺮ‬ ‫ﻏ‬ ‫ﺮ‬ ‫اﻷﺧ‬ ‫ﻨﻈﺎم‬ ‫اﻟ‬
‫ﻲ‬ ‫اﻻﻧﺘﻘﺎﻟ‬unbuffered‫ﺎﺑﻬ‬ ‫اﻟﻤﺸ‬‫ﺔ‬‫ﺮاج‬ ‫واﻹﺧ‬ ‫ﺎل‬ ‫ﻟﻺدﺧ‬ ‫ﻴﻜﺲ‬ ‫ﻳﻮﻧ‬ ‫ﻨﻈﺎم‬ ‫ﻟ‬UNIX-like
I/O،‫ﻲ‬ ‫اﻟﺜﻨﺎﺋ‬ ‫ﻨﻈﺎم‬ ‫اﻟ‬ ‫ﻖ‬ ‫ﺑﻨﺴ‬ ‫ﻴﺎت‬ ‫اﻟﻤﻌﻄ‬ ‫ﻊ‬ ‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬ ‫ﻟﻠ‬ ‫ﺘﻌﻤﻞ‬ ‫ﻳﺴ‬ ‫ﻴﺮ‬ ‫اﻷﺧ‬ ‫ﻨﻈﺎم‬ ‫اﻟ‬ ‫ﺎن‬ ‫وﻛ‬
binary system،‫ﻨﺔ‬ ‫ﻟﺠ‬ ‫أن‬ ‫أﻻ‬C‫ﺎت‬ ‫ﻟﻠﻐ‬ ‫ﻲ‬ ‫اﻟﻮﻃﻨ‬ ‫ﻲ‬ ‫اﻷﻣﺮﻳﻜ‬ ‫ﻴﺲ‬ ‫اﻟﻤﻘﺎﻳ‬ ‫ﺪ‬ ‫ﻣﻌﻬ‬ ‫ﻲ‬ ‫ﻓ‬
‫ﺒﺮﻣﺠﺔ‬ ‫اﻟ‬ANISI-C Committee‫ﻴﺮ‬ ‫ﻏ‬ ‫ﻨﻈﺎم‬ ‫اﻟ‬ ‫ﻦ‬ ‫ﻋ‬ ‫ﺘﻐﻨﺎء‬ ‫اﻻﺳ‬ ‫ﺮا‬ ‫ﻣﺆﺧ‬ ‫ﺮرت‬ ‫ﻗ‬
‫ﻴﺔ‬ ‫اﻟﺜﻨﺎﺋ‬ ‫ﻴﺎت‬ ‫اﻟﻤﻌﻄ‬ ‫ﻊ‬ ‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬ ‫اﻟ‬ ‫ﺔ‬ ‫أﻧﻈﻤ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻲ‬ ‫اﻻﻧﺘﻘﺎﻟ‬،‫ﺒﺪﻳﻞ‬ ‫اﻟ‬ ‫ﺄوﺟﺪت‬ ‫ﻓ‬،‫ﺒﺢ‬ ‫ﻳﺼ‬ ‫ﺚ‬ ‫ﺑﺤﻴ‬
‫ﻮص‬‫اﻟﻨﺼ‬ ‫ﻦ‬‫ﻣ‬ ‫ﻞ‬‫ﻛ‬ ‫ﻊ‬‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬‫اﻟ‬ ‫ﻲ‬‫اﻻﻧﺘﻘﺎﻟ‬ ‫ﻨﻈﺎم‬‫اﻟ‬ ‫دوال‬ ‫ﺪور‬‫ﺑﻤﻘ‬text‫اﻟﺜﻨﺎﺋﻴﺔ‬ ‫ﻴﺎت‬‫واﻟﻤﻌﻄ‬
binary system‫ﺪ‬‫واﺣ‬ ‫ﺖ‬‫وﻗ‬ ‫ﻲ‬‫ﻓ‬.‫ﻮرة‬‫ﺻ‬ ‫ﺮ‬‫آﺧ‬ ‫أن‬ ‫أي‬(version)‫ﻦ‬‫ﻣ‬C،‫ﺘﻌﺎﻣﻞ‬‫ﻳ‬
‫اﻻﻧﺘﻘﺎﻟﻴﺔ‬ ‫اﻟﻤﻠﻔﺎت‬ ‫ﻧﻈﺎم‬ ‫ﻫﻮ‬ ‫ﻓﻘﻂ‬ ‫واﺣﺪ‬ ‫ﺑﻨﻈﺎم‬.
‫ﻨﻈﺎم‬‫اﻟ‬ ‫ﺬا‬‫ﻫ‬ ‫دوال‬ ‫ﻊ‬‫ﻣ‬ ‫ﺘﻌﺎﻣﻞ‬‫اﻟ‬ ‫ﻨﺪ‬‫ﻋ‬ ‫ﺘﺎج‬‫وﻧﺤ‬،‫واﻹﺧﺮاج‬ ‫ﻟﻺدﺧﺎل‬ ‫اﻟﺪﻟﻴﻞ‬ ‫ﻣﻠﻒ‬ ‫ﻧﺴﺘﻌﻤﻞ‬ ‫أن‬
stdio.h‫اﻟﺪوال‬ ‫ﻫﺬه‬ ‫اﺷﻬﺮ‬ ‫اﻟﺘﺎﻟﻲ‬ ‫اﻟﺠﺪول‬ ‫ﻟﻨﺎ‬ ‫وﻳﻠﺨﺺ‬:
‫وﻇﻴﻔﺘﻬﺎ‬ ‫اﻟﺪاﻟﺔ‬ ‫اﺳﻢ‬
‫ﻣﻠﻔﺎ‬ ‫ﻟﻚ‬ ‫ﺗﻔﺘﺢ‬ fopen()
‫ﻣﻠﻔﺎ‬ ‫ﻟﻚ‬ ‫ﺗﻐﻠﻖ‬ fclose()
‫ﺗﺨﺮج‬)‫ﺗﻄﺒﻊ‬(‫ﻟﺒﻨﺔ‬)‫رﻣﺰا‬(‫ﻣﺜﻞ‬ ‫وﻫﻲ‬char putc()
‫ﻟﺒﻨﺔ‬ ‫ﺗﺪﺧﻞ‬)‫رﻣﺰا‬(‫اﻟﻤﻠﻒ‬ ‫إﻟﻰ‬،‫ﻣﺜﻞ‬ ‫وﻫﻲ‬char getc()
‫اﻟﺮﻣﻮز‬ ‫ﺑﻌﺾ‬ ‫ﻋﻦ‬ ‫ﻟﻚ‬ ‫ﺗﺒﺤﺚ‬)‫ﻧﺺ‬(‫اﻟﻤﻠﻒ‬ ‫ﻓﻲ‬ fseek()
‫وﻇﻴﻔﺔ‬ ‫ﻣﺜﻞ‬printf‫ﻟﻠﻤﻠﻔﺎت‬ ‫ﻟﻜﻦ‬ fprintf()
‫وﻇﻴﻔﺔ‬ ‫ﻣﺜﻞ‬scanf‫ﻟﻠﻤﻠﻔﺎت‬ ‫ﻟﻜﻦ‬ fscanf()
‫اﻟﻨﺘﻴﺠﺔ‬ ‫ﺗﻌﻄﻲ‬true‫ﻧﻬﺎﻳ‬ ‫وﺻﻮل‬ ‫ﻋﻨﺪ‬‫اﻟﻤﻠﻒ‬ ‫ﺔ‬ feof()
‫اﻟﻨﺘﻴﺠﺔ‬ ‫ﺗﻌﻄﻲ‬true‫ﺧﻄﺄ‬ ‫ﺣﺪوث‬ ‫ﻋﻨﺪ‬ ferror()
‫ﺑﺪاﻳﺘﻪ‬ ‫إﻟﻰ‬ ‫اﻟﻤﻠﻒ‬ ‫ﺗﺮﺟﻊ‬ rewind()
‫اﻟﺠﺪول‬١-٥
‫اﻻﻧﺘﻘﺎﻟﻴﺔ‬ ‫اﻟﻤﻠﻔﺎت‬ ‫دوال‬ ‫و‬ ‫اﻷﻗﺮاص‬ ‫ﺗﻘﻨﻴﺔ‬
disk Files

‫اﻟﻤﻠﻒ‬ ‫ﻓﺘﺢ‬ ‫داﻟﺔ‬()fopen
‫ﻧﻼ‬‫ﻃﺒﻌﺎ‬ ‫اﻟﺤﺎﺳﻮب‬ ‫ذاﻛﺮة‬ ‫ﻓﻲ‬ ‫ﻟﻠﻤﻠﻒ‬ ‫ﻊ‬‫ﻣﻮﻗ‬ ‫ﺎء‬‫ﺑﺈﻧﺸ‬ ‫ﻼه‬‫أﻋ‬ ‫اﻷول‬ ‫ﻄﺮ‬‫اﻟﺴ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻨﺎ‬‫ﻗﻤ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﻆ‬‫ﺣ‬
‫ﻧﻜﺘﺐ‬FILE‫ذﻟﻚ‬ ‫ﺑﻌﺪ‬ ‫ﺛﻢ‬ ‫اﻟﻜﺒﺮى‬ ‫اﻷﺑﺠﺪﻳﺔ‬ ‫ﺑﺎﻷﺣﺮف‬*‫ﻣﺜﻼ‬ ‫اﻟﻤﺴﻤﻰ‬ ‫ﻧﻄﻠﻖ‬ ‫وﺑﻌﺪﻫﺎ‬f
‫ﺮص‬‫ﻗ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻒ‬‫ﻣﻠ‬ ‫ﺘﺢ‬‫ﺑﻔ‬ ‫ﺎص‬‫اﻟﺨ‬ ‫ﺔ‬‫اﻟﺪاﻟ‬ ‫ﻞ‬‫ﺑﻌﻤ‬ ‫ﻮم‬‫ﻧﻘ‬ ‫ﻚ‬‫ذﻟ‬ ‫ﺪ‬‫ﺑﻌ‬disk‫وﺗﻌﻮد‬)‫ﻗﻴﻤﺔ‬ ‫ﺗﻌﻄﻲ‬(
‫وﻫﻮ‬ ‫ﻟﻪ‬ ‫اﻟﻤﻌﺮف‬ ‫اﻟﻤﻠﻒ‬ ‫ﺑﻤﺆﺷﺮ‬f‫ﻃﺒﻌﺎ‬.
‫ﺛ‬‫اﺳﻢ‬ ‫ﻛﺘﺎﺑﺔ‬ ‫ﻋﺪم‬ ‫ﻳﺠﺐ‬ ‫اﻧﻪ‬ ‫ﻫﻨﺎ‬ ‫اﻟﺘﺤﺬﻳﺮ‬ ‫وﻳﺠﺐ‬ ‫ﺎءه‬‫إﻧﺸ‬ ‫ﺮاد‬‫اﻟﻤ‬ ‫ﻒ‬‫اﻟﻤﻠ‬ ‫ﻊ‬‫ﻣﻮﻗ‬ ‫ﺘﺤﺪﻳﺪ‬‫ﺑ‬ ‫ﻮم‬‫ﻧﻘ‬ ‫ﻢ‬
‫ﻨﻈﺎم‬‫اﻟ‬ ‫ﺎت‬‫ﻣﻠﻔ‬ ‫ﻦ‬‫ﻣ‬ ‫ﻒ‬‫ﻣﻠ‬system‫ﻧﻜﺘﺐ‬ ‫ﻣﺜﻼ‬ ‫ﺑﺎﻟﺠﻬﺎز‬ ‫وﻣﺸﺎﻛﻞ‬ ‫ﺧﻠﻞ‬ ‫ﺪوث‬‫ﺣ‬ ‫ﺪم‬‫ﻋ‬ ‫ﺐ‬‫ﻟﺘﺠﻨ‬
‫ﻼه‬‫أﻋ‬ ‫ﺎ‬‫ﻛﻤ‬matrix.txt‫اﻟﻌﻼﻣﺘﻴﻦ‬ ‫ﻊ‬‫وﺿ‬ ‫ﺐ‬‫وﻳﺠ‬ ‫ﻲ‬‫ﻧﺼ‬ ‫ﻒ‬‫ﻣﻠ‬ ‫ﻮ‬‫وﻫ‬‫اﻟﻘﺮص‬ ‫ﻛﺘﺎﺑﺔ‬ ‫ﺑﻌﺪ‬
C‫ﺪه‬‫واﺣ‬ ‫ﺔ‬‫ﻋﻼﻣ‬ ‫ﻊ‬‫وﺿ‬ ‫ﺢ‬‫ﻳﺼ‬ ‫وﻻ‬‫ﻂ‬‫ﻓﻘ‬،‫ﺑ‬‫اﻟﺮﻣﺰ‬ ‫ﻧﻜﺘﺐ‬ ‫ﻚ‬‫ذﻟ‬ ‫ﺪ‬‫ﻌ‬w‫اﻟﻤﻠﻒ‬ ‫ﻻﺳﺘﺤﺪاث‬
‫ﺔ‬‫ﺑﺎﻟﺪاﻟ‬ ‫ﻪ‬‫ﺑﺈﻏﻼﻗ‬ ‫ﻮم‬‫ﻧﻘ‬ ‫ﻴﺮ‬‫اﻷﺧ‬ ‫ﻄﺮ‬‫اﻟﺴ‬ ‫ﻲ‬‫ﻓ‬ ‫ﻚ‬‫ذﻟ‬ ‫ﺪ‬‫ﺑﻌ‬ ‫ﻢ‬‫ﺛ‬ ‫ﺪ‬‫اﻟﺠﺪﻳ‬fclose (f)‫ﺘﺎﺑﺔ‬‫ﻛ‬ ‫ﺐ‬‫وﻳﺠ‬
‫ﺻﺤﻴﺢ‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻳﺼﺒﺢ‬ ‫ﻛﻲ‬ ‫اﻟﺪاﻟﺔ‬ ‫ﻫﺬه‬.
‫اذﻫﺐ‬ ‫اﻵن‬ ‫ﺎﺋﺪة‬‫اﻟﻔ‬ ‫ﺎ‬‫ﻣ‬ ‫ﺘﻐﺮب‬‫ﺗﺴ‬ ‫ﺪ‬‫ﻗ‬ ‫ﻲ‬‫ﺷ‬ ‫ﻚ‬‫ﻟ‬ ‫ﺮ‬‫ﻳﻈﻬ‬ ‫ﻦ‬‫ﻟ‬ ‫ﻚ‬‫ذﻟ‬ ‫ﺪ‬‫ﺑﻌ‬ ‫ﺒﺮﻧﺎﻣﺞ‬‫اﻟ‬ ‫ﻴﺬ‬‫ﺑﺘﻨﻔ‬ ‫ﻢ‬‫ﻗ‬ ‫اﻵن‬
‫اﻟﻘﺮص‬ ‫إﻟﻰ‬ ‫ﻋﺰﻳﺰي‬C‫اﻟﺬ‬ ‫وﻫﻮ‬‫ي‬‫ﻗﻤﺖ‬‫ﻓﻴﻪ‬ ‫اﻟﻤﻠﻒ‬ ‫ﺑﺈﻧﺸﺎء‬)‫أﻋﻼه‬ ‫اﻟﻤﺴﺎر‬(
‫اﻟﺠﺪﻳﺪ‬ ‫اﻟﻤﻠﻒ‬ ‫وﺷﺎﻫﺪ‬
#include “stdio.h”
main()
{
FILE *f;
F=fopen(“C:matrix.txt”,”w”);
Fclose (f);
return0;
}
‫ﻟﻠﺘﺨﺰﻳﻦ‬ ‫اﺳﻢ‬ ‫آي‬ ‫ﻧﻜﺘﺐ‬
‫ﻣﺜﻼ‬ ‫اﻟﺬاﻛﺮة‬ ‫ﺑﻤﻮﻗﻊ‬f
‫ﻣﻮﻗﻌﻪ‬ ‫وﻧﺤﺪد‬ ‫اﻟﻤﻠﻒ‬ ‫اﺳﻢ‬)‫ﻣﺴﺎره‬(
‫اﻟﻘﺮص‬ ‫ﻓﻲ‬C
‫اﻟﺮﻣﺰ‬w‫ﻻﺳﺘﺤﺪاث‬
‫ﻟﻠﻜﺘﺎﺑﺔ‬ ‫ﺟﺪﻳﺪ‬ ‫ﻧﺺ‬
‫اﻟﻤﻠﻒ‬ ‫ﻫﻮ‬ ‫ﻫﺬا‬
‫اﻟﺠﺪﻳﺪ‬

‫اﻷﻧﻤﺎط‬ ‫ﺟﺪول‬،‫ﻗﺮرﺗﻪ‬ ‫ﻣﺎ‬ ‫ﺣﺴﺐ‬ANSI‫ﻣﺆﺧﺮا‬:
‫وﻇﻴﻔﺘﻪ‬ ‫اﻟﻨﻤﻂ‬ ‫رﻣﺰ‬
‫ﻟﻠﻘﺮاءة‬ ‫اﻟﻨﺺ‬ ‫ﻣﻠﻒ‬ ‫ﻟﻔﺘﺢ‬ "r"
‫ﻟﻠﻜﺘﺎﺑﺔ‬ ‫ﻧﺺ‬ ‫ﻣﻠﻒ‬ ‫ﻻﺳﺘﺤﺪث‬ "w"
‫ﻧﺺ‬ ‫ﺑﻤﻠﻒ‬ ‫ﻟﻺﻟﺤﺎق‬ "a"
‫اﻟﻘﺮاءة‬ ‫ﺛﻨﺎﺋﻲ‬ ‫ﻣﻠﻒ‬ ‫ﻟﻔﺘﺢ‬ "rb"
‫ﺛﻨﺎ‬ ‫ﻣﻠﻒ‬ ‫ﻻﺳﺘﺤﺪاث‬‫اﻟﻜﺘﺎﺑﺔ‬ ‫ﺋﻲ‬ "wb"
‫ﺛﻨﺎﺋﻲ‬ ‫ﺑﻤﻠﻒ‬ ‫ﻟﻺﻟﺤﺎق‬ "ab"
‫اﻟﻜﺘﺎﺑﺔ‬ ‫أو‬ ‫ﻟﻠﻘﺮاءة‬ ‫ﻧﺺ‬ ‫ﻣﻠﻒ‬ ‫ﻟﻔﺘﺢ‬ "r+"
‫اﻟﻜﺘﺎﺑﺔ‬ ‫أو‬ ‫ﻟﻠﻘﺮاءة‬ ‫ﻧﺺ‬ ‫ﻻﺳﺘﺤﺪاث‬ "w+"
‫اﻟﻜﺘﺎﺑﺔ‬ ‫أو‬ ‫ﻟﻠﻘﺮاءة‬ ‫ﻧﺺ‬ ‫ﻣﻠﻒ‬ ‫ﻟﻔﺘﺢ‬ "a+"
‫اﻟﻜﺘﺎﺑﺔ‬ ‫أو‬ ‫ﻟﻠﻘﺮاءة‬ ‫ﺛﻨﺎﺋﻲ‬ ‫ﻣﻠﻒ‬ ‫ﻟﻔﺘﺢ‬ "r+b"
‫اﻟﻜﺘﺎﺑﺔ‬ ‫أو‬ ‫ﻟﻠﻘﺮاءة‬ ‫ﺛﻨﺎﺋﻲ‬ ‫ﻣﻠﻒ‬ ‫ﻻﺳﺘﺤﺪاث‬ "w+b"
‫ﻟﻠ‬ ‫ﺛﻨﺎﺋﻲ‬ ‫ﻣﻠﻒ‬ ‫ﻟﻔﺘﺢ‬‫اﻟﻜﺘﺎﺑﺔ‬ ‫أو‬ ‫ﻘﺮاءة‬ "a+b"
‫اﻟﺠﺪول‬٢-٥
‫اﻟﺜﻨﺎﺋﻴﺔ‬ ‫واﻟﻤﻠﻔﺎت‬ ‫اﻟﻨﺺ‬ ‫ﻣﻠﻔﺎت‬ ‫ﻣﻦ‬ ‫ﻟﻜﻞ‬ ‫اﺳﺘﻌﻤﺎﻟﻪ‬ ‫ﻳﻤﻜﻦ‬ ‫اﻟﺠﺪول‬ ‫ﻫﺬا‬ ‫أن‬ ‫ﻧﻼﺣﻆ‬.

‫اﻟﻤﻠﻒ‬ ‫داﺧﻞ‬ ‫اﻟﻜﺘﺎﺑﺔ‬ ‫داﻟﺔ‬()fprintf
‫ﻨﺺ‬‫اﻟ‬ ‫ﺘﺎﺑﺔ‬‫ﺑﻜ‬ ‫ﻢ‬‫ﻗ‬"welcome to c++"‫ﺜﺎل‬‫اﻟﻤ‬ ‫ﻲ‬‫ﻓ‬ ‫ﺎﺋﻪ‬‫ﺑﺈﻧﺸ‬ ‫ﻨﺎ‬‫ﻗﻤ‬ ‫ﺬي‬‫اﻟ‬ ‫ﻒ‬‫اﻟﻤﻠ‬ ‫ﻞ‬‫داﺧ‬
‫اﻟﺴﺎﺑﻖ‬(1)‫وﻫ‬‫ﻣﻠﻒ‬ ‫ﻮ‬matrix‫؟‬
‫ﺔ‬‫اﻟﺪاﻟ‬ ‫ﻊ‬‫ﺑﻮﺿ‬ ‫ﻨﺎ‬‫ﻗﻤ‬ ‫ﻨﺎ‬‫أﻧ‬ ‫ﺎرئ‬‫اﻟﻘ‬ ‫ﺰي‬‫ﻋﺰﻳ‬ ‫ﻆ‬‫ﻻﺣ‬)fprintf(‫ﺘﺎﺑﺔ‬‫ﺑﺎﻟﻜ‬ ‫ﺔ‬‫اﻟﺨﺎﺻ‬ ‫ﺔ‬‫اﻟﺪاﻟ‬ ‫ﻲ‬‫وﻫ‬
‫ﺪول‬ ‫ﻟﻠﺠ‬ ‫ﺮﺟﻮع‬ ‫اﻟ‬ ‫ﺎﻧﻚ‬ ‫ﺑﺈﻣﻜ‬ ‫ﺎت‬ ‫اﻟﻤﻠﻔ‬ ‫ﻞ‬ ‫داﺧ‬١-٥‫ا‬ ‫ﺬ‬ ‫ﻧﻔ‬ ‫اﻵن‬‫ﻊ‬ ‫ارﺟ‬ ‫ﻴﺬ‬ ‫ﺗﻨﻔ‬ ‫ﺪ‬ ‫وﺑﻌ‬ ‫ﺒﺮﻧﺎﻣﺞ‬ ‫ﻟ‬
‫اﻟﻘﺮص‬ ‫ﻓﻲ‬ ‫ﻟﻠﻤﻠﻒ‬c‫اﻟﻌﺒﺎرة‬ ‫ﻟﺘﺸﺎﻫﺪ‬ ‫واﻓﺘﺤﻪ‬welcome to c++‫ﺑﺪاﺧﻠﻪ‬ ‫ﻛﺘﺒﺔ‬ ‫ﻗﺪ‬.
main()
{
FILE *f;
f=fopen(“C:matrix.txt”,”w”);
fprintf (f,”welcome to c++”);
return 0;
}
‫اﻇ‬‫اﻟﺴﻄﺮ‬ ‫ﻫﺬا‬ ‫ﻔﻨﺎ‬
‫ﻟﻠﻄﺒﺎﻋﺔ‬ ‫اﻟﺠﺪﻳﺪ‬
‫اﻟﻤﻠﻒ‬ ‫ﺑﺪاﺧﻞ‬

‫اﻟﻤﻠﻒ‬ ‫إﻏﻼق‬ ‫داﻟﺔ‬()fclose
‫ﺔ‬ ‫اﻟﺪاﻟ‬ ‫ﺲ‬ ‫ﻋﻜ‬ ‫ﻞ‬ ‫وﺗﻌﻤ‬fopen()،‫ﺔ‬ ‫ﺑﺎﻟﺪاﻟ‬ ‫ﻨﺎه‬ ‫ﻓﺘﺤ‬ ‫ﺬي‬ ‫اﻟ‬ ‫ﻒ‬ ‫اﻟﻤﻠ‬ ‫ﺘﻐﻠﻖ‬ ‫ﻓ‬fopen()،‫ﻞ‬ ‫وﻛ‬
‫اﻟ‬ ‫ﺔ‬ ‫ﻧﻬﺎﻳ‬ ‫ﺒﻞ‬ ‫ﻗ‬ ‫ﺎ‬ ‫إﻏﻼﻗﻬ‬ ‫ﻨﻚ‬ ‫ﻣ‬ ‫ﺔ‬ ‫اﻟﻤﻄﻠﻮﺑ‬ ‫ﺎت‬ ‫اﻟﻤﻠﻔ‬‫ﺒﺮﻧﺎﻣﺞ‬،‫ﺈﻏﻼق‬ ‫ﺑ‬ ‫ﻨﺎ‬ ‫ﻗﻴﺎﻣ‬ ‫ﺪم‬ ‫ﻋ‬ ‫ﺔ‬ ‫ﺣﺎﻟ‬ ‫ﻲ‬ ‫وﻓ‬
‫ﻊ‬ ‫ﺗﻘ‬ ‫ﺪ‬ ‫ﻗ‬ ‫ﻜﻼت‬ ‫اﻟﻤﺸ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺪدا‬ ‫ﻋ‬ ‫ﺎن‬ ‫ﻓ‬ ‫ﻒ‬ ‫اﻟﻤﻠ‬،‫ﻴﺎت‬ ‫اﻟﻤﻌﻄ‬ ‫ﺾ‬ ‫ﺑﻌ‬ ‫ﻴﺎع‬ ‫ﺿ‬ ‫ﻨﻬﺎ‬ ‫وﻣ‬،‫ﻼف‬ ‫واﺗ‬
‫اﻟﻤﻠﻒ‬،‫اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻓﻲ‬ ‫أﺧﻄﺎء‬ ‫ووﻗﻮع‬.
main()
{
FILE *f;
f=fopen(“C:matrix.txt”,”w”);
fprintf (f,”welcome to c++”);
fclose (f)
return 0;
}
‫ﻓﻲ‬ ‫اﻟﻤﻠﻒ‬ ‫ﺑﺈﻏﻼق‬ ‫ﻗﻤﻨﺎ‬
‫ﺗﻼﺣﻆ‬ ‫ﻛﻤﺎ‬ ‫اﻟﺴﻄﺮ‬ ‫ﻫﺬا‬

‫اﻟﺪاﻟﺘﺎن‬()getw()putw
‫ﺘﺮﺟﻤﺎت‬ ‫ﻣ‬ ‫ﻢ‬ ‫ﻣﻌﻈ‬ ‫ﻮم‬ ‫ﺗﻘ‬c++‫ﻲ‬ ‫ﺑﻌﻤﻠﻴﺘ‬ ‫ﺘﻘﻮﻣﺎ‬ ‫ﻟ‬ ‫ﺎﻓﻴﺘﻴﻦ‬ ‫اﻹﺿ‬ ‫ﻦ‬ ‫اﻟﺪاﻟﺘﻴ‬ ‫ﻦ‬ ‫ﻫﺎﺗﻴ‬ ‫ﺘﻌﻤﺎل‬ ‫ﺑﺎﺳ‬
‫ﺮاص‬ ‫اﻷﻗ‬ ‫ﺎت‬ ‫ﻣﻠﻔ‬ ‫ﻲ‬ ‫واﻟ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﺤﻴﺤﺔ‬ ‫اﻟﺼ‬ ‫ﺪاد‬ ‫اﻷﻋ‬ ‫ﺘﺎﺑﺔ‬ ‫وﻛ‬ ‫ﺮاءة‬ ‫ﻗ‬،‫ﻴﺮ‬ ‫ﻏ‬ ‫ﺘﺎن‬ ‫اﻟﺪاﻟ‬ ‫ﺎن‬ ‫وﻫﺎﺗ‬
‫ﻲ‬ ‫اﻷﻣﺮﻳﻜ‬ ‫ﻲ‬ ‫اﻟﻮﻃﻨ‬ ‫ﻴﺲ‬ ‫اﻟﻤﻘﺎﻳ‬ ‫ﺪ‬ ‫ﻣﻌﻬ‬ ‫ﺒﻞ‬ ‫ﻗ‬ ‫ﻦ‬ ‫ﻣ‬ ‫ﻦ‬ ‫ﻣﻌﺘﻤﺪﻳ‬ANSI،‫ﺘﺎن‬ ‫اﻟﺪاﻟ‬ ‫ﺎن‬ ‫ﻫﺎﺗ‬ ‫ﻞ‬ ‫وﺗﻌﻤ‬
‫ﺗﻤﺎ‬‫ﻦ‬ ‫ﻛﺎﻟﺪاﻟﺘﻴ‬ ‫ﺎ‬‫ﻣ‬getc()‫و‬putc()‫ﺤﻴﺢ‬ ‫ﺻ‬ ‫ﺪد‬‫ﻋ‬ ‫ﻊ‬‫ﻣ‬ ‫ﺘﻌﺎﻣﻼن‬‫ﺗ‬ ‫ﺎ‬‫اﻧﻬﻤ‬ ‫ﻴﺪ‬‫اﻟﻮﺣ‬ ‫ﺮق‬‫واﻟﻔ‬
‫رﻣﺰي‬ ‫ﻣﻦ‬ ‫ﺑﺪﻻ‬.
‫ﺑﻜﺘﺎﺑﺔ‬ ‫ﺗﻘﻮم‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺪاﻟﺔ‬)‫ﻃﺒﺎﻋﺔ‬(‫اﻟﺼﺤﻴﺢ‬ ‫اﻟﻌﺪد‬1000‫إﻟﻴﻪ‬ ‫اﻟﻤﺸﺎر‬ ‫اﻟﻘﺮص‬ ‫ﻣﻠﻒ‬ ‫ﻓﻲ‬
‫اﻟﻤﻠﻒ‬ ‫ﺑﻤﺆﺷﺮ‬f:
Putw (1000,f);
‫ﻴﺮ‬‫اﻟﻤﺘﻐ‬ ‫ﻴﻤﺔ‬‫ﻗ‬ ‫ﺘﺎﺑﺔ‬‫ﺑﻜ‬ ‫ﻮم‬‫ﺗﻘ‬ ‫ﻴﺔ‬‫اﻟﺘﺎﻟ‬ ‫ﺔ‬‫اﻟﺪاﻟ‬‫ﺤﻴﺢ‬‫اﻟﺼ‬x‫ﺑﻤﺆﺷﺮ‬ ‫إﻟﻴﻪ‬ ‫اﻟﻤﺸﺎر‬ ‫اﻟﻘﺮص‬ ‫ﻣﻠﻒ‬ ‫ﻓﻲ‬
‫اﻟﻤﻠﻒ‬f:
Putw (x,f);

‫ﺻﺤﻴﺢ‬ ‫ﻋﺪد‬ ‫ﺑﻘﺮاءة‬ ‫ﺗﻘﻮم‬ ‫اﻟﺘﺎﻟﻴﺔ‬ ‫اﻟﺪاﻟﺔ‬،‫اﻟﻤﻠﻒ‬ ‫ﺑﻤﺆﺷﺮ‬ ‫إﻟﻴﻪ‬ ‫ﻣﺸﺎر‬ ‫ﻣﻠﻒ‬ ‫ﻣﻦ‬f:
main()
{
FILE *f;
int x;
x=getw (f);
printf (“%d”,x);
return 0;
}

‫ﺍﻟﻨﻬﺎﻳﺔ‬


C++ arabic course

More Related Content

Featured

C++ arabic course