Cplusplus

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

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

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

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

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

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

‫اﻷﺳﺎﺳﻴﺎت‬
‫ﻣﻜﻮﻧﺎت ‪ C++‬وادواﺗﻬﺎ‬
‫‪Basic Elements of C++‬‬
‫رﻣﻮز ﻟﻐﺔ ‪C++‬‬

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

‫اﻟﻜﻠﻤﺎت ﻧﻮﻋﻴﻦ‪-:‬‬
‫‪ -١‬أﺳﻤﺎء ﺗﻌﺮﻳﻔﻴﺔ )‪(Identifiers‬‬
‫وﻫﻲ اﻷ ﺳﻤﺎء اﻟﺘﻲ ﻧﺴﻤﻴﻬﺎ ﻧﺤﻦ " اﻟﻤﺒﺮﻣﺠﻮن" ﺗﻌﺮف اﻟﺤﺎﺳﻮب ﺑﻤﺎ ﺗﺮﻳﺪ‪.‬‬
‫وﺗﻄﻠﻖ اﻷﺳﻤﺎء اﻟﺘﻌﺮﻳﻔﻴﺔ ﻋﻠﻰ‪-:‬‬

‫‪ -A‬اﻟﻤﺘﻐﻴﺮات‪.‬‬
‫‪ -B‬اﻻﺧﺘﺰاﻧﺎت )اﻟﺪوال(‪.‬‬
‫‪ -C‬اﻟﻤﺆﺷﺮات‪.‬‬

‫*ﻗﻮاﻋﺪ ﺗﺴﻤﻴﺔ اﻷﺳﻤﺎء اﻟﺘﻌﺮﻳﻔﻴﺔ ﻓﻲ ﻟﻐﺔ ‪-: C++‬‬
‫‪ -١‬أن ﻳﻜ ﻮن اﻻﺳ ﻢ ﻣﻜﺘﻮﺑ ﺎ ﻣ ﻦ ﺳﻠﺴ ﻠﺔ ﻣﺘﺼ ﻠﺔ ﻣ ﻦ اﻟﺤ ﺮوف أو اﻷرﻗ ﺎم ﺑﺸ ﺮط أن‬
‫ﻳﺒﺪا ﺑﺤﺮف أو ﺑﺨﻂ ﺗﺤﺘﻲ "_"‬
‫‪ -٢‬أن ﻻ ﻳﺤﺘﻮى اﻻﺳﻢ ﻋﻠﻰ رﻣﻮز ﺧﺎﺻﺔ ﻋﺪا اﻟﺨﻂ اﻟﺘﺤﺘﻲ "_"‬
‫‪ -٢‬أن ﻻ ﻳﻜﻮن اﻻﺳﻢ إﺣﺪى اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة‪.‬‬
‫ﺑﻌﺾ اﻷﻣﺜﻠﺔ اﻟﺼﺤﻴﺤﺔ ﻋﻠﻰ اﻷﺳﻤﺎء اﻟﺘﻌﺮﻳﻔﻴﺔ‪:‬‬
‫‪B6 .a‬‬
‫‪X_ray .b‬‬
‫‪Matrix .c‬‬
‫‪Ok_ .d‬‬
‫‪A .e‬‬
‫‪Soft_fine .f‬‬
‫‪Door12 .g‬‬
‫‪_new .h‬‬
‫وﻫﺬه أﺳﻤﺎء ﺗﻌﺮﻳﻔﻴﺔ ﻏﻴﺮ ﻣﻘﺒﻮل )‪ (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++ ‫ أن ﻟﻐ ﺔ‬، ‫وﻛﻤ ﺎ ﺗﻼﺣ ﻆ ﻣ ﻦ ﻗﺎﺋﻤ ﺔ اﻟﻜﻠﻤ ﺎت اﻟﻤﺤﺠ ﻮزة‬
.‫ ﻛﻠﻤﺔ ﻣﺤﺠﻮزة ﻓﻘﻂ‬٥٢ ‫ﻣﻦ ﻋﺪد ﻗﻠﻴﻞ ﻣﻦ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة ﺗﻘﺮﻳﺒﺎ‬
PDF created with FinePrint pdfFactory trial version www.pdffactory.com

‫• ﺗﻤﺜﻴﻞ اﻟﺜﻮاﺑﺖ اﻟﻌﺪدﻳﺔ ‪Numeric Constants‬‬
‫ﻳﻤﻜﻦ ﺗﻤﺜﻴﻞ اﻟﺜﻮاﺑﺖ اﻟﻌﺪدﻳﺔ ‪ ،‬ﻓﻲ ﻟﻐﺔ ‪ C++‬ﺑﺜﻼث ﺻﻮر ﻫﻲ‪-:‬‬
‫‪ .a‬اﻟﺜﺎﺑﺖ اﻟﻌﺪدي اﻟﺼﺤﻴﺢ ‪integer‬‬

‫‪ -‬ﻫﻮ ﻋﺪد ﻣﻜﻮن ﻣﻦ اﻷرﻗﺎم ﻣﻦ ‪9 Ù 0‬‬
‫‪ -‬ﻻ ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺎﺻﻠﺔ ﻋﺸﺮﻳﺔ‪.‬‬
‫‪ -‬ﻳﻤﻜﻦ أن ﻳﺤﻮى اﻹﺷﺎرة "‪ "+‬أو "‪"-‬‬
‫أﻣﺜﻠﺔ ﺻﺤﻴﺤﺔ ﻋﻠﻰ اﻟﺜﺎﺑﺖ اﻟﻌﺪدي اﻟﺼﺤﻴﺢ‪-:‬‬

‫‪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‬‬
‫‪ -‬ﻫﻮ ﻋﺪد ﻣﻜﻮن ﻣﻦ اﻷرﻗﺎم ‪9 Ù 0‬‬
‫‪ -‬ﻳﺠﺐ أن ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺎﺻﻠﺔ ﻋﺸﺮﻳﺔ‬
‫‪ -‬ﻳﻤﻜﻦ أن ﻳﺤﻮى اﻻﺷﺎره "‪ "+‬أو "‪"-‬‬
‫‪ -‬ﻻ ﻳﺠﻮز أن ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺎرزة "‪"،‬‬
‫أﻣﺜﻠﺔ ﻋﻠﻰ ﺛﻮاﺑﺖ ﻋﺪد ﺣﻘﻴﻘﻲ ﺗﺴﺘﻌﻤﻞ اﻟﻔﺎﺻﻠﺔ اﻟﻌﺸﺮﻳﺔ ﺑﺸﻜﻞ ﺻﺤﻴﺢ ‪-:‬‬
‫‪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‬‬ ‫‪ X‬و‪ y‬ﻋﺪدان ﺣﻘﻴﻘﻴﺎن‬
‫;‪Integer k‬‬ ‫‪ K‬ﻋﺪد ﺻﺤﻴﺢ‬
‫;‪Char c,b,a‬‬ ‫‪ C,b,a‬رﻣﻮز‬
‫;‪X=2.0‬‬
‫;‪Y=10.6*x‬‬
‫;‪K=100‬‬
‫;‪A=t‬‬
‫;‪B=f‬‬
‫;‪C=4‬‬
‫ﻻﺣﻆ اﻟﺴ ﻄﺮﻳﻦ اﻷول ‪ ،‬واﻟﺜﺎﻟ ﺚ ﻳﺤﺘﻮﻳ ﺎن ﻋﻠ ﻰ اﻛﺜ ﺮ ﻣ ﻦ ﻣﺘﻐﻴ ﺮ ﺣﻴ ﺚ ﻳﻔﺼ ﻞ ﺑ ﻴﻦ ﻛ ﻞ‬

‫ﻣﺘﻐﻴﺮﻳﻦ ‪ ،‬ﻓﺎﺻﻠﺔ وﻛﺬﻟﻚ ﻳﻤﻜ ﻦ ﺗﺤﺪﻳ ﺪ أﻧ ﻮاع اﻟﻤﺘﻐﻴ ﺮات ‪ ،‬ﺑ ﺬﻛﺮ اﻟﺘﻔﺼ ﻴﻞ اﻟ ﺪﻗﻴﻖ ﻟﻠﻨ ﻮع‬
‫‪ ،‬ﻣﻦ ﺣﻴﺚ ﻃﻮل اﻟﺴﻌﺔ اﻟﺘﺨﺰﻳﻨﻴﺔ ‪ ،‬أي ﻫﻞ ﻫ ﻮ ﺻ ﺤﻴﺢ ﻗﺼ ﻴﺮ أم ﻃﻮﻳ ﻞ ﺣﻘﻴﻘ ﻲ ﻗﺼ ﻴﺮ‬
‫أو ﻣﻀﺎﻋﻒ ‪ ...‬اﻟـﺦ‬

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

‫اﻷدوات اﻟﻤﺴﺘﻌﻤﻠﺔ ﻓﻲ ﻟﻐﺔ ‪C++‬‬
‫ﻳﻮﺟﺪ ﻓﻲ ﻟﻐﺔ ‪ C++‬ﺛﻼﺛﺔ أﻧﻮاع ﻣﻦ اﻷدوات وﻫﻲ‪:‬‬
‫اﻷدوات اﻟﺤﺴ ﺎﺑﻴﺔ – اﻷدوات اﻟﻤﻨﻄﻘﻴ ﺔ واﻟﻌﻼﻗ ﺔ – اﻷدوات اﻟﺪﻗﻴﻘ ﺔ وﻓﻴﻤ ﺎ ﻳ ﺄﺗﻲ ﺗﻔﺼ ﻴﻞ‬
‫ﺑﺎﻷﻧﻮاع اﻟﺜﻼﺛﺔ‪-:‬‬
‫اﻷدوات اﻟﺤﺴﺎﺑﻴﺔ ‪Arithmetic Operators‬‬

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

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

‫اﻷدوات اﻷﺣﺎدﻳﺔ واﻟﺜﻨﺎﺋﻴﺔ ‪Unary and Binary‬‬
‫‪Operators‬‬
‫ﺗﻌ ﺪ ﺟﻤﻴ ﻊ أدوات اﻟﺠﻤ ﻊ واﻟﻄ ﺮح واﻟﻀ ﺮب واﻟﻘﺴ ﻤﺔ وﺑ ﺎﻗﻲ اﻟﻘﺴ ﻤﺔ أدوات ﺛﻨﺎﺋﻴ ﺔ‬
‫‪ binary‬أي أﻧﻬﺎ ﺗﺄﺧﺬ )ﺗﺘﻌﺎﻣﻞ ﻣﻊ ( ﻗﻴﻤﺘﻴﻦ وﺗﻨ ﺘﺞ ﻗﻴﻤ ﺔ واﺣ ﺪة ‪ ،‬ﻓﻤ ﺜﻼ ﻧﺘﻴﺠ ﺔ ‪ 2*3‬ﻫ ﻲ‬
‫اﻟﻘﻴﻤ ﺔ ‪ 6‬وﻫﻨ ﺎك اﻷداة اﻷﺣﺎدﻳ ﺔ – ﻋﻨ ﺪﻣﺎ ﺗﺘﻌﺎﻣ ﻞ ﻣ ﻊ ﻗﻴﻤ ﺔ واﺣ ﺪ ﻓﻤ ﺜﻼ )‪ (-1992‬ﺗﻤﺜ ﻞ‬
‫اﻹﺷﺎرة ا ﻟﺴ ﺎﻟﺒﻪ وﻫ ﻲ ﻫﻨ ﺎ أداة أﺣﺎدﻳ ﺔ ‪ ، Unary‬واﻟﻌﻤﻠﻴ ﺔ ﻫﻨ ﺎ ﻟﻴﺴ ﺖ ﻋﻤﻠﻴ ﺔ ﻃ ﺮح ﻛﻤ ﺎ‬
‫ﻧﻌﻠﻢ‪.‬‬
‫اﻟﺰﻳﺎدة واﻟﻨﻘﺼﺎن ‪Increment and Decrement‬‬

‫ﻣﻦ ﻣﺰاﻳﺎ ﻟﻐﺔ ‪ C++‬أﻧﻬﺎ ﺗﺴﺘﻌﻤﻞ اﻷداﺗﻴﻦ اﻟﺤﺴﺎﺑﻴﺘﻴﻦ ‪ + +‬و ‪ - -‬ﻟﺰﻳﺎدة اﻟﻘﻴﻢ ﺑﻤﻘﺪار ‪1‬‬
‫أو إﻧﻘﺎﺻﻬﺎ ﺑﻤﻘﺪار ‪ ، 1‬واﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻳﺒﻴﻦ ﻃﺮﻳﻘﺔ اﻻﺳﺘﻌﻤﺎل‪:‬‬
‫;‪A++‬‬
‫;‪++a‬‬
‫ﻣﻌﻨﺎه إﺿﺎﻓﺔ ﻗﻴﻤﺔ ‪ 1‬إﻟﻰ ‪ a‬وﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﻬﺎ ﺑﺼﻮره ﻣﻜﺎﻓﺌﺔ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪-:‬‬
‫;‪A=a+1‬‬
‫وﺑﺎﻟﻄﺮﻳﻘﺔ ﻧﻔﺴﻬﺎ ﻳﻤﻜﻦ إﻧﻘﺎص ‪ 1‬ﻣﻦ ﻗﻴﻤﺔ ‪ a‬ﻋﻠﻰ اﻟﻨﺤﻮ‪-:‬‬
‫;‪--a‬‬
‫أو‬
‫;‪a--‬‬
‫;‪A=a-1‬‬
‫وﻫﻮ ﻳﻜﺎﻓﺊ اﻟﺼﻮرة‬
‫ﻟﻜ ﻦ ﻫﻨ ﺎك ﻓﺮﻗ ﺎ ﻓ ﻲ ﺳ ﺮﻋﺔ اﻟﺘﻨﻔﻴ ﺬ ‪ ،‬ﻓ ﺎﻟﺘﻌﺒﻴﺮ ;‪++a‬أﺳ ﺮع ﻣ ﻦ اﻟﺘﻌﺒﻴ ﺮ ;‪ a=a+1‬وﻫ ﺬه‬
‫ﻫﻲ اﻟﻔﺎﺋﺪة ﻣﻦ ﺟﺮاء اﺳﺘﺨﺪام ﻣﺜﻞ ﻫﺬه اﻷدوات ‪.‬‬
‫وﻣﻤ ﺎ ﻳﻨﺒﻐ ﻲ اﻟﺘﻨﺒﻴ ﻪ إﻟﻴ ﻪ ﻫﻨ ﺎ أن ﻫﻨ ﺎك ﻓﺮﻗ ﺎ ﺑ ﻴﻦ ‪ a++‬و ‪ ، ++a‬ﺻ ﺤﻴﺢ أن ﻛ ﻼ ﻣ ﻦ‬
‫اﻟﺘﻌﺒﻴ ﺮﻳﻦ ﻳﺠﻤ ﻊ ‪ 1‬إﻟ ﻰ ‪ ، a‬ﻟﻜ ﻦ ﻋﻨ ﺪ اﺳ ﺘﻌﻤﺎل ‪ ++a‬ﻓ ﻲ ﺗﻌﺒﻴ ﺮ ﻣ ﻦ اﻟﺘﻌ ﺎﺑﻴﺮ ‪ ،‬ﻓ ﺎن ‪a‬‬
‫ﺗ ﺰداد ﻗﺒ ﻞ اﺳ ﺘﺨﺮاج ﻗﻴﻤ ﺔ اﻟﺘﻌﺒﻴ ﺮ ‪ ،‬ﺑﻴﻨﻤ ﺎ ﻓ ﻲ ﺣﺎﻟ ﺔ ‪ a++‬ﺗﺴ ﺘﺨﺮج ﻗﻴﻤ ﺔ اﻟﺘﻌﺒﻴ ﺮ‬
‫ﺑﺎﺳ ﺘﻌﻤﺎل ﻗﻴﻤ ﺔ ‪ a‬اﻟﺤﺎﻟﻴ ﺔ ﻗﺒ ﻞ زﻳﺎدﺗﻬ ﺎ ﺑﻤﻘ ﺪار ‪ ، 1‬وﺑﻌ ﺪ ذﻟ ﻚ ﺗ ﺘﻢ زﻳ ﺎدة ‪ a‬ﺑﻤﻘ ﺪار ‪ 1‬آي‬

‫أن اﻟﻌﻤﻠﻴﺔ اﻷوﻟﻰ ﺟﻤﻊ ﺗﻘﺪﻳﻢ ‪ ،‬واﻟﺜﺎﻧﻴﺔ ﺟﻤ ﻊ ﺗ ﺄﺧﻴﺮ ‪ ،‬وﻳﻨﻄﺒ ﻖ ﻫ ﺬا اﻟﻜ ﻼم أﻳﻀ ﺎ ﻋﻠ ﻰ –‬
‫‪ a‬و ‪. a--‬‬
‫ﻣﺜﺎل‪:‬‬
‫;‪Int x,y,x‬‬
‫;‪X=y=x=0‬‬ ‫أوﻟﻴﺔ ﺟﻤﻊ ‪ 1‬إﻟﻰ ‪ z‬ﺗﺄﺗﻲ‬
‫;‪X=++y + ++z‬‬ ‫ﻣﺘﺎﺧﺮه إذ ﻳﺘﻢ ﺟﻤﻌﻬﺎ‬
‫أوﻻ إﻟﻰ ‪x‬‬
‫;‪X=y++ + z++‬‬
‫;‪X=++y + z++‬‬
‫ﺟﻤﻊ ‪ 1‬إﻟﻰ ‪ y‬ﻣﺆﺟﻞ ﺑﻌﺪ‬
‫إﻋﻄﺎء ﻗﻴﻤﺘﻬﺎ اﻷوﻟﻰ إﻟﻰ‬
‫;‪X=y-- +--z‬‬ ‫‪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‬‬
‫وﺑﺈﻣﻜﺎﻧﻚ ﻛﺘﺎﺑﺔ اﻟﺠﻤﻠﺘﻴﻦ‪:‬‬

‫‪Int x,y,z‬‬
‫‪X=y=z=0‬‬
‫ﻓﻲ ﺟﻤﻠﺔ واﺣﺪ ﻋﻠﻰ اﻟﻨﺤﻮ‪:‬‬

‫‪Int x=y=z=0‬‬

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

‫‪ -١‬اﻟﻌﻤﻠﻴﺔ اﻷوﻟﻰ‪ :‬اﻟﻘﺴﻤﺔ ‪y / z‬‬
‫‪ -٢‬اﻟﻌﻤﻠﻴﺔ اﻟﺜﺎﻧﻴﺔ‪a * (y/z) :‬‬
‫‪ -٣‬اﻟﻌﻤﻠﻴﺔ اﻟﺜﺎﻟﺜﺔ‪ :‬ﺟﻤﻊ اﻟﻨﺎﺗﺞ ﻓﻲ اﻟﺨﻄﻮة ‪ 2‬إﻟﻰ ‪ x‬ﻓﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ‪:‬‬
‫‪X+ y/ z*z‬‬
‫ﻻﺣ ﻆ أﻧﻨ ﺎ ﺑ ﺪأﻧﺎ ﺑ ﺈﺟﺮاء اﻟﻌﻠﻤﻴ ﺎت اﻟﺤﺴ ﺎﺑﻴﺔ ﻣ ﻦ اﻟﻴﺴ ﺎر إﻟ ﻰ اﻟﻴﻤ ﻴﻦ ‪ ،‬وﺗﻌﻄ ﻰ أﻻ وﻟﻮﻳ ﻪ‬
‫ﻷﻳﺔ ﻋﻤﻠﻴﺔ ﺣﺴﺐ ﻗﺎﻋ ﺪة اﻷوﻟﻮﻳ ﺔ ‪ ،‬ﻓﺠ ﺎءت اﻟﻘﺴ ﻤﺔ ‪ ،‬ﻓ ﻲ اﻟﻤﺜ ﺎل ﻗﺒ ﻞ اﻟﺠﻤ ﻊ ‪ ،‬ﻛﻤ ﺎ ﺟ ﺎء‬
‫اﻟﻀﺮب ﺑﻌﺪ اﻟﻘﺴﻤﺔ وﺗﻼ ذﻟﻚ اﻟﺠﻤﻊ ﻛﺄﺧﺮ ﻋﻤﻠﻴﺔ‪.‬‬

‫اﻷدوات اﻟﻌﻼﻗﻴﺔ واﻟﻤﻨﻄﻘﻴﺔ ‪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||F‬ﻓﺎﻟﻨﺘﻴﺠ ﺔ ﻣﻌﺮوﻓ ﻪ ‪ F‬أﻣ ﺎ ﺑ ﻴﻦ اﻟﺴ ﻢ واﻟﻌﺴ ﻞ‬ ‫ﻓﻠ ﻮ ﺧﻴ ﺮت ﺑ ﻴﻦ اﻟﺴ ﻢ ‪ 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‬ﺑﺖ (‪-:‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫ﻗﻴﻤﺔ ‪x‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫ﻗﻴﻤﺔ ‪~x‬‬
‫وﻣﻌﻨﻰ ~ اﻟﻨﻔﻲ )‪ (not‬وﻣﻌﻨﻰ اﻟﻨﻔﻲ ﻫﻨﺎ اﻟﺘﻀﺎد ﺑ ﻴﻦ ‪ 0‬و ‪ 1‬ﻓ ﻲ اﻟﻨﻈ ﺎم اﻟﻌ ﺪدي اﻟﺜﻨ ﺎﺋﻲ‬
‫‪ ،‬ﻓﻌﻨﺪﻣﺎ ﺗﻨﻔﻰ ‪ 0‬ﺗﺜﺒﺖ ﺑ ﺪﻻ ﻣﻨ ﻪ ‪ 1‬واﻟﻌﻜ ﺲ ﺻ ﺤﻴﺢ ‪ ،‬وﻫ ﺬا ﻳﻮﺿ ﺤﻪ ﻟ ﻚ اﻟﻤﺜ ﺎل اﻟﺴ ﺎﺑﻖ‬
‫إذ ﺗﻢ )ﻧﻔﻲ( ﻗﻴﻤﺔ ‪ x‬ﺑﺎﻟﺒﺖ ﻟﻴﺼﺒﺢ ‪ ~x‬ﻓﻲ ﺟﻤﻴﻊ ﻣﻜﻮﻧﺎت ﻣﻦ اﻟﺒﺖ‪.‬‬

‫أداة اﻟﺠﻤﻊ &‬
‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺟﻤﻊ اﻟﻘﻴﻢ ﻋﻨﺪ ﺗﻤﺜﻴﻠﻬﺎ ﺑﺎﻟﻨﻈﺎم اﻟﻌﺪدي اﻟﺜﻨﺎﺋﻲ‪:‬‬
‫اﻟﻌﻤﻠﻴﺔ ;‪x&y‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫ﻗﻴﻤﺔ ‪ x‬ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫ﻗﻴﻤﺔ ‪ y‬ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬

‫اﻟﻨﺎﺗﺞ ;‪X&Y‬‬
‫ﺣﻴﺚ ﻳﺠﻤﻊ ‪ 0+0‬وﻳﻌﻄﻲ ‪ ، 0‬وﻳﺠﻤﻊ ‪ 0+1‬ﻟﻴﻌﻄﻲ ‪ 0‬وﻳﺠﻤﻊ ‪ 1+1‬وﻳﻌﻄﻲ ‪1‬‬

‫‪) T Ù T&T F Ù F&T FÙF&F‬اﻧﻈﺮ ﺟﺪاول اﻟﺼﺪق اﻟﺴﺎﺑﻘﺔ(‬
‫أداة اﻻﺧﺘﻴﺎر|‬
‫إذا أردﻧﺎ اﺳﺘﻌﻤﺎل أداة اﻻﺧﺘﻴﺎر ﻣﻊ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻟﻘﻴﻤﺘﻲ ‪ X‬و‪ y‬ﻋﻠﻰ اﻟﻨﺤﻮ ;‪x|y‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪x‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪y‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬

‫اﻟﻨﺎﺗﺞ ;‪x|y‬‬
‫ﺣﻴﺚ اﻻﺧﺘﻴﺎر ﺑﻴﻦ ‪ 0‬و‪ 1‬ﻫﻮ ‪ ، 1‬واﻻﺧﺘﻴﺎر ﺑﻴﻦ ‪ 1‬و‪ 1‬ﻫﻮ ‪ ، 1‬وﺑﻴﻦ ‪ 0‬و‪ 0‬ﻫﻮ ‪. 0‬‬
‫‪ ) T Ù T|F T Ù T|T T Ù F|T‬اﻧﻈﺮ ﺟﺪاول اﻟﺼﺪق اﻟﺴﺎﺑﻘﺔ (‬

‫أداة اﻻﺧﺘﻴﺎر اﻻﺳﺘﺜﻨﺎﺋﻲ ^‬
‫ﺧﺬ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻧﻔﺴﺔ ﻟﺘﺮى ﻛﻴﻒ ﺗﺆﺛﺮ ﻫﺬه اﻷداة‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪x‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪y‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬

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

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

‫اﻟﺠﻤﻠﺔ ;‪ x>>2‬ﻋﻨﺪ ﺗﻨﻔﻴﺬﻫﺎ ﻋﻠﻰ ﻗﻴﻤ ﺔ ‪ ) x‬وﻫ ﻲ ‪ 23‬ﺑﺎﻟﻨﻈ ﺎم اﻟﻌﺸ ﺮي( ﺑﺎﻟﻨﻈ ﺎم اﻟﺜﻨ ﺎﺋﻲ‬
‫ﻓﺎن اﻟﻌﻤﻠﻴﺔ ﺗﺘﻢ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪:‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪x‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫;‪x>>2‬‬
‫اﻟﻨﺘﻴﺠﺔ ﻣﻦ اﻹزاﺣﺔ ﺑﻤﻘﺪار ﺧﺎﻧﺘﻴﻦ )‪ ٢‬ﺑﺖ ( ﻟﻠﻴﻤﻴﻦ ﺗﺼﺒﺢ ﻗﻴﻤﺘﻬﺎ ‪:‬‬

‫‪ 5‬ﺑﺎﻟﻨﻈﺎم اﻟﻌﺸﺮي‪.‬‬
‫وﻫﺬا ﻳﻌﻨﻲ أن ;‪ 23>>2‬ﺗﻌﻄﻲ اﻟﻨﺘﻴﺠﺔ ‪. 5‬‬
‫ﺣﻴﺚ ‪ 23‬اﻟﻘﻴﻤﺔ اﻟﻤﺰاﺣﺔ‪.‬‬
‫‪ 2‬ﻋﺪد ﺧﺎﻧﺎت اﻹزاﺣﺔ اﻟﻤﻄﻠﻮﺑﺔ ﻟﻠﻴﻤﻴﻦ‪.‬‬
‫ﻻﺣﻆ أن اﻟﺨﺎﻧﺘﻴﻦ اﻟﻤﻔﺮﻏﺘﻴﻦ ﺑﺴﺒﺐ اﻹزاﺣﺔ ﻟﻠﻴﻤﻴﻦ ﻗﺪ ﻣﻠﺌﺘﺎ ﺑﻤﺼﻔﺮﻳﻦ‪.‬‬

‫ﻣﺜﺎل ﻋﻠﻰ إزاﺣﺔ ﻗﻴﻤﺔ ﺳﺎﻟﺒﺔ‪:‬‬
‫;‪Z = - 50<<2‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪Z‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪Z<<3‬‬
‫إزاﺣﺔ )‪٢‬ﺑﺖ( ﻟﻠﻴﺴﺎر‪.‬‬

‫اﻟﺠﺪﻳ ﺪ ﻓ ﻲ ﻫ ﺬا اﻟﻤﺜ ﺎل أن اﻹزاﺣ ﺔ ﻟﻘﻴﻤ ﺔ ﺳ ﺎﻟﺒﺔ ﻳﻨ ﺘﺞ ﻋ ﻦ ﻛ ﻞ ﺧﺎﻧ ﺔ ﻣﻔﺮﻏ ﺔ اﻟﻘﻴﻤ ﺔ ‪1‬‬
‫وﻟﻴﺲ ‪ 0‬ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‪.‬‬

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

‫)‪If (b<c‬‬
‫;‪A=b‬‬
‫‪Else‬‬
‫‪A=c‬‬
‫ﻣﻌﻨﺎﻫ ﺎ‪ :‬اﻧ ﻪ إذا ﺗﺤﻘ ﻖ اﻟﺸ ﺮط )‪ (b<c‬ﻓﻴﻨﻔ ﺬ اﻟﺴ ﻄﺮ ‪ ، a=b‬وإﻻ ﻓ ﺎن ‪ a=c‬وﺑﺎﺳ ﺘﻌﻤﺎل‬
‫اﻷداة اﻟﺸ ﺮﻃﻴﺔ ؟ ﻳﻤﻜﻨﻨ ﺎ أن ﻧﻜﺘ ﺐ ﺑ ﺪﻻ ﻣ ﻦ اﻟﺠﻤﻠ ﺔ اﻟﺸ ﺮﻃﻴﺔ ﻛﻠﻬ ﺎ اﻟﺠﻤﻠ ﺔ اﻟﻤﺨﺘﺼ ﺮة‬
‫اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪A=(b<c) ? b:c‬‬ ‫إذا ﺗﺤﻘﻖ اﻟﺸﺮط ﻓﺎن‬
‫‪A=b‬‬
‫‪A=c‬‬
‫إذا ﻟﻢ ﻳﺘﺤﻘﻖ اﻟﺸﺮط‬
‫ﻓﺎن‬

‫أداة اﻟﻌﻨﻮﻧﺔ )&( و )*( ‪the & and * Pointer‬‬
‫‪Operator‬‬
‫اﻟﻤﺆﺷ ﺮ ‪ Pointer‬ﻫ ﻮ ﻋﻨ ﻮان اﻟﻤﺘﻐﻴ ﺮ اﻟﻤﺆﺷ ﺮ ﻓ ﻲ اﻟ ﺬاﻛﺮة ‪ ،‬وﻟﻠﻤﺘﻐﻴ ﺮ اﻟﻤﺆﺷ ﺮ ﻓﻮاﺋ ﺪ‬
‫ﺟﻤ ﺔ ﻓ ﻲ ﻋﻤﻠﻴ ﺔ اﻟﺒﺮﻣﺠ ﺔ ﻧ ﺬﻛﺮﻫﺎ ﻋﻨ ﺪ اﻟﺘﻌ ﺮض ﻟﻬ ﺎ ﻓ ﻲ اﻟﻔﺼ ﻮل اﻟﻘﺎدﻣ ﺔ ﺑ ﺈذن اﷲ ‪،‬‬
‫وﻳﻜﺜ ﺮ اﺳ ﺘﻌﻤﺎل ﻫ ﺎﺗﻴﻦ اﻟ ﺪاﻟﺘﻴﻦ ﻣ ﻊ اﻟﻤﺘﻐﻴ ﺮات اﻟﻤﺆﺷ ﺮة اﻟﻤﺤﺠ ﻮزة ﻟﻬ ﺎ ﻓ ﻲ أﻣ ﺎﻛﻦ‬
‫ﺧﺎﺻﺔ ﻓﻲ اﻟﺬاﻛﺮة ‪.‬‬
‫وﺗﻌﺪ اﻷداة & ﻫﻨﺎ أداة أﺣﺎدﻳﺔ ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﻛﻤﻴﺔ واﺣﺪة ﻓﻘ ﻂ ‪ ،‬ﺣﻴ ﺚ ﺗﻘ ﻮم ﺑﺈﻋﻄ ﺎء ﻋﻨ ﻮان‬
‫اﻟﻄﺮف اﻷﻳﻤﻦ ﻟﻠﻤﻌﺎدﻟﺔ ‪ ،‬ﻟﻠﻄﺮف اﻷﻳﺴﺮ ﻣﻨﻬﺎ ‪ ،‬ﻓﻤﺜﻼ اﻟﻌﻤﻠﻴﺔ‪:‬‬
‫;‪X=&y‬‬
‫ﺗﻌﻄﻲ ﻋﻨﻮان ‪ y‬ﻓﻲ اﻟﺬاﻛﺮة ‪ ،‬ووﺿﻌﻪ ﻓﻲ ﻣﺨ ﺰن ‪ ، x‬وﻫ ﺬه اﻟﺠﻤﻠ ﺔ ﺗﺨﺘﻠ ﻒ ﻃﺒﻌ ﺎ ﻋ ﻦ‬

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

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

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

‫ﺟﻤﻞ اﻟﺘﻌﺮﻳﻒ‬
‫ﺟﻤﻞ اﻟﺘﻌﺮﻳﻒ ﻫﻲ ﺟﻤﻞ ﺗﻘﻮم ﺑﺘﻌﺮﻳﻒ اﻟﻘﻴﻢ‪.‬‬
‫;‪Int a‬‬
‫ﻳﻘﺎﺑﻞ ﻫﺬه اﻟﺠﻤﻠﺔ ﻓﻲ ﻓﻴﺠﻮال ﺑﻴﺴﻚ‬

‫‪Dim a as integer‬‬
‫وﺗﻘﻮم ﺑﺤﺠﺰ ﻣﻜﺎن ﻓﻲ اﻟﺬاﻛﺮة اﻟﻤﺸﺎر إﻟﻴﻪ ‪ ،‬ﺑﺎﻻﺳﻢ ‪ a‬ﻟﺘﺨﺰﻳﻦ ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﺻﺤﻴﺤﺔ‪.‬‬
‫أﻧﻮاع اﻟﺒﻴﺎﻧﺎت اﻟﻤﻤﻜﻦ ﺗﺨﺰﻳﻨﻬﺎ ﻓﻲ اﻟﺬاﻛﺮة اﻟﻤﺴﺘﺨﺪﻣﺔ ﻟـ ‪C++‬‬

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

‫اﻟﺜﻮاﺑﺖ اﻟﺮﻣﺰﻳﺔ ذات اﻟﺸﺮﻃﺔ اﻟﻤﻌﻜﻮﺳﺔ‬
‫ﺣﻴ ﺚ أﻧﻨ ﺎ ﻻ ﻧﺴ ﺘﻄﻴﻊ اﺳ ﺘﻌﻤﺎل ﺑﻌ ﺾ اﻟﺮﻣ ﻮز اﻟﻤﻮﺟ ﻮدة ﻓ ﻲ ﻟﻮﺣ ﺔ ﻣﻔ ﺎﺗﻴﺢ اﻟﺤﺎﺳ ﺐ‬
‫ﻛﺜﻮاﺑ ﺖ رﻣﺰﻳ ﺔ ‪ ،‬ﻓﻘ ﺪ اﺳ ﺘﺤﺪث ﻟﻐ ﺔ ‪ c++‬ﺷ ﻔﺮات رﻣﺰﻳ ﺔ ﺧﺎﺻ ﺔ ﺗﺴ ﺘﻌﻤﻞ ﺷ ﺮﻃﺔ‬
‫ﻣﻌﻜﻮﺳﺔ ﻟﻬﺎ ‪ ،‬وﻫﺬه اﻟﺸﻔﺮات ﻣﺪوﻧﺔ ﻓﻲ اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪:‬‬
‫اﻟﻘﻴﻤﺔ اﻟﺼﺤﻴﺤﺔ ﻟﻬﺎ‬ ‫ﻣﻌﻨﺎﻫﺎ‬ ‫اﻟﺸﻔﺮة‬

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

‫اﻟﻤﻼﺣﻈﺎت واﻟﺘﻌﻠﻴﻘﺎت ﻓﻲ ‪Comments c++‬‬
‫ﺗﺴﺘﻌﻤﻞ ﺳﺎﺋﺮ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﺟﻤﻼ ﻟﻠﺘﻌﻠﻴﻘﺎت واﻟﻤﻼﺣﻈﺎت ‪ ،‬وﻛﺬﻟﻚ ﻟﻐﺔ ‪ C++‬ﻣﺜﻼ‬
‫اﻟﺠﻤﻠﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪10 rem this is Islam‬‬
‫ﻫﻲ ﺟﻤﻠﺔ ﻣﻼﺣﻆ ﻓﻲ ﻟﻐﺔ ﺑﻴﺴﻚ ‪ ،‬ﺗﻘﺎﺑﻠﻬﺎ ﺟﻤﻠﺔ ﺗﻌﻠﻴﻖ اﻟﺘﺎﻟﻴﺔ ﻓﻲ ﻟﻐﺔ ‪:C++‬‬
‫‪// 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‬‬
‫}‬
‫وﻣﻦ اﻟﺠﺪﻳﺮ ﺑﺎﻟﺬﻛﺮ ﻫﻨﺎ ‪ ،‬ﻣﺎ ﻳﺄﺗﻲ‪:‬‬

‫ﻻ ﻳﺘﺮك أي ﻓﺮاغ ﺑﻴﻦ اﻟﺸﺮﻃﺔ ‪ /‬واﻟﻨﺠﻤﺔ * ﻣﻦ ﺟﻬﺘﻲ ﺟﻤﻠﺔ اﻟﺘﻌﻠﻴﻖ‪.‬‬
‫‪ -١‬ﻳﻘﻮم ﻣﺘﺮﺟﻢ ‪ c++‬ﺑﺈﻫﻤﺎل اﻟﻨﺼﻮص اﻟﻤﺴﺘﻌﻤﻠﺔ ﻓﻲ ﺟﻤﻞ اﻟﺘﻌﻠﻴﻖ ‪ ،‬أي أﻧﻬﺎ ﻻ‬
‫ﺗﻨﻔﺬ ‪ ،‬ﺑﻞ ﻫﻲ ﺟﻤﻞ ﺗﻮﺿﻴﺤﻴﺔ ﺗﻈﻬﺮ ﻣﻊ ﻗﺎﺋﻤﺔ اﻟﺒﺮﻧﺎﻣﺞ أو ﺳﻄﻮرا ﻓﻘﻂ ‪.‬‬
‫‪ -٢‬ﻳﻤﻜﻦ وﺿﻊ ﺟﻤﻠﺔ اﻟﻤﻼﺣﻈﺔ واﻟﺘﻌﻠﻴﻖ ﻓﻲ أي ﻣﻜﺎن ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪ ،‬ﻣﺎ ﻋﺪا‬
‫وﺳﻂ اﺳﻢ ﺗﻌﺮﻳﻔﻲ ‪ ، identifier‬أو ﻛﻠﻤﺔ ﻣﺤﺠﻮزة ‪. keyword‬‬

‫ﺗﺸﻐﻴﻞ ‪visual c++6.0‬‬
‫‪Run visual c++6.0‬‬
‫ﻟﺘﺸﻐﻴﻞ ﺑﺮﻧﺎﻣﺞ ﻓﻴﺠﻮال ﺳﻲ ‪ ++‬ﻧﺘﺒﻊ اﻟﺘﺎﻟﻲ‪:‬‬

‫أﺑﺪا‪ Ù‬اﻟﺒﺮاﻣﺞ‪visualc++6.0 Ù‬‬
‫ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﺳﺘﻈﻬﺮ ﻟﻨﺎ اﻟﺸﺎﺷﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫ﻧﺨﺘﺎر اﻟﻘﺎﺋﻤﺔ ‪ file‬ﻣﻦ ﻫﻨﺎ‬
‫ﻧﺨﺘ ﺎر ﻣ ﻦ ﻫ ﺬه اﻟﺸﺎﺷ ﺔ ﻛﻤ ﺎ ﻫ ﻮ واﺿ ﺢ اﻟﻘﺎﺋﻤ ﺔ ‪ File‬ﺛ ﻢ ﺑﻌ ﺪ ذﻟ ﻚ ﻧﺨﺘ ﺎر ﻣ ﻦ اﻟﻘﺎﺋﻤ ﺔ‬

‫‪ New‬ﻟﺘﻈﻬﺮ ﻟﻨﺎ اﻟﺸﺎﺷﺔ اﻟﺘﺎﻟﻴﺔ‪..‬‬

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

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

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

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

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

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

‫ﺗ ﺆدي إﻟ ﻰ إرﺳ ﺎل اﻟﻌ ﺪد ‪ 100‬إﻟ ﻰ وﺣ ﺪة اﻹﺧ ﺮاج ‪ ،‬أن ﻫ ﺬا اﻷﺳ ﻠﻮب اﻟﺠﺪﻳ ﺪ ﻓ ﻲ‬
‫اﻹﺧﺮاج ﻳﺨﺘﻠﻒ ﻋﻤﺎ ﻓﻲ ﻟﻐﺔ ‪. c‬‬

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

smoking is dangerous

‫ﻣﺜﺎل ‪:٣‬‬
‫ﻟﻼﺳﺘﻔﺎدة ﻣﻦ إﻣﻜﺎﻧﻴﺎت اﻹﻳﻌﺎز ‪ \n‬ﻓﻲ ﻋﻤﻠﻴﺎت اﻟﻄﺒﺎﻋﺔ ‪:‬ﺗﺄﻣﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;”‪cout<<“matrix‬‬
‫;”‪cout<<“matrix \n‬‬
‫;”‪cout<<“matrix \n\n‬‬
‫;”‪cout<<“matrix \n\n\n‬‬
‫;”‪cout<<“matrix‬‬
‫}‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺗﺮى اﻟﻄﺒﺎﻋﺔ اﻟﺘﺎﻟﻴﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪:‬‬

‫اﻟﺴﻄﺮ اﻷول‪matrixmatrix Ù‬‬
‫اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ‪matrix Ù‬‬
‫اﻟﺴﻄﺮ اﻟﺜﺎﻟﺚ‪ Ù‬ﺳﻄﺮ ﻓﺎرغ‬
‫اﻟﺴﻄﺮ اﻟﺮاﺑﻊ‪matrix Ù‬‬
‫اﻟﺴﻄﺮ اﻟﺨﺎﻣﺲ‪Ù‬ﺳﻄﺮ ﻓﺎرغ‬
‫اﻟﺴﻄﺮ اﻟﺴﺎدس‪Ù‬ﺳﻄﺮ ﻓﺎرغ‬
‫ﻧﻼﺣﻆ ﻓﻲ ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬

‫‪ -١‬اﻧ ﻪ ﻳ ﺘﻢ اﻻﻧﺘﻘ ﺎل ﻣ ﻦ اﻟﺴ ﻄﺮ اﻷول ﺑﻌ ﺪ ﻃﺒﺎﻋ ﺔ ‪ matrix‬إﻟ ﻰ اﻟﺴ ﻄﺮ اﻟﺜ ﺎﻧﻲ ﻟﻌ ﺪم‬
‫وﺟ ﻮد إﻳﻌ ﺎز اﻻﻧﺘﻘ ﺎل ‪ ، \n‬وﻟ ﺬا ﻓ ﺎن ﺟﻤﻠ ﺔ اﻟﻄﺎﺑﻌ ﺔ اﻟﺘﺎﻟﻴ ﺔ ﻇﻬ ﺮت ﻧﺘﺎﺋﺠﻬ ﺎ ﻓ ﻲ ا‬
‫ﻟﺴ ﻄﺮ اﻷول ﻧﻔﺴ ﻪ ‪ ،‬ﻣﺘﺼ ﻠﺔ ﺑﻄﺎﻋ ﺔ ‪ matrix‬اﻷوﻟ ﻰ ‪ ،‬وﻳﻨﺘﻘ ﻞ اﻟﻤﺆﺷ ﺮ اﻟﻀ ﻮﺋﻲ‬
‫إﻟﻰ ﺳﻄﺮ ﺟﺪﻳﺪ ﻟﻮﺟﻮد إﻳﻌﺎز ‪. \n‬‬
‫‪ -٢‬ﻳ ﺘﻢ ﺗﻨﻔﻴ ﺬ ﺟﻤﻠ ﺔ اﻟﻄﺒﺎﻋ ﺔ اﻟﺜﺎﻟﺜ ﺔ ﻓ ﻲ اﻟﺴ ﻄﺮ اﻟﺠﺪﻳ ﺪ )اﻟﺜ ﺎﻧﻲ( ‪ ،‬وﻳ ﺘﻢ اﻻﻧﺘﻘ ﺎل إﻟ ﻰ‬
‫اﻟﺴﻄﺮ اﻟﺮاﺑﻊ ﻗﻔﺰا ﻋﻦ اﻟﺴﻄﺮ اﻟﺜﺎﻟ ﺚ ‪ ،‬وذﻟ ﻚ ﻟﻮﺟ ﻮد اﻹﻳﻌ ﺎز ‪ \n\n‬ﺣﻴ ﺚ ﻳﻘ ﻮم ﻛ ﻞ‬
‫إﻳﻌ ﺎز ‪ \n‬ﺑﻨﻘ ﻞ اﻟﻤﺆﺷ ﺮ اﻟﻀ ﻮﺋﻲ ﺳ ﻄﺮا واﺣ ﺪا ‪ ،‬وﻓ ﻲ اﻟﺴ ﻄﺮ اﻟﺮاﺑ ﻊ ﺗﻄﺒ ﻊ ﺟﻤﻠ ﺔ‬
‫اﻟﻄﺒﺎﻋ ﺔ اﻟﺮاﺑﻌ ﺔ ‪ ،‬وﻳ ﺘﻢ ﺑﻌ ﺪﻫﺎ اﻻﻧﺘﻘ ﺎل إﻟ ﻰ اﻟﺴ ﻄﺮ اﻟﺴ ﺎﺑﻊ ﻓ ﻮرا ﺣﺴ ﺐ‬
‫اﻹﻳﻌﺎز‪. \n\n\n‬‬

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

446
:٥‫ﻣﺜﺎل‬
:10.5 ‫ اﻟﺘﺎﻟﻲ ﻳﻄﺒﻊ اﻟﻘﻴﻤﺔ اﻟﺤﻘﻴﻘﺔ‬، C++ ‫ﺑﺮﻧﺎﻣﺞ‬
main ()
{
cout<<10.5;
return0;
}
:‫ﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﻳﻈﻬﺮ اﻟﺘﺎﻟﻲ‬

10.5

:٦‫ﻣﺜﺎل‬
:‫ اﻟﺘﺎﻟﻲ‬C++ ‫اﻧﻈﺮ ﻣﺎذا ﻳﻔﻌﻞ ﺑﺮﻧﺎﻣﺞ‬
main ()
{
int a=100;
cout<<a;
return0;
}
:‫ﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﻳﻈﻬﺮ ﻟﻨﺎ اﻟﺘﺎﻟﻲ‬

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

4.25

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

‫ﻃﺒﺎﻋﺔ اﻟﻘﻴﻢ اﻟﻌﺪدﻳﺔ واﻟﺮﻣﺰﻳﺔ )اﻟﻨﺼـﻮص( ﻓـﻲ ﺟﻤﻠـﺔ‬
‫واﺣﺪة‬
‫ﻣﺜﺎل‪:٩‬‬
‫ﺳﻮف ﻧﻘﻮم ﻓﻲ ﻫﺬا اﻟﻤﺜﺎل ﺑﻄﺒﺎﻋﺔ ﻗﻴﻢ ﻋﺪدﻳﺔ وﻧﺼﻴﺔ ﻣﻊ اﻟﺒﻌﺾ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;‪int a=100‬‬
‫;‪cout<<“a=”<<a‬‬
‫}‬
‫ﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪A=100‬‬
‫ﻣﺜﺎل‪:١٠‬‬
‫ﻣﺎذا إذا أردﻧﺎ ﻃﺒﺎﻋﺔ ﻋﺪد ﺻﺤﻴﺢ وﺣﻘﻴﻘﻲ ﻣﻊ ﻧﺼﻮص ﺑﻨﻔﺲ اﻟﻮﻗﺖ‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;‪int=100‬‬
‫‪float x=4.25‬‬
‫;‪cout<<“a=”<<a<<“x=”<<x‬‬
‫}‬
‫وﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﺳﻴﻈﻬﺮ ﻟﻨﺎ اﻟﺘﺎﻟﻲ‪:‬‬

‫‪A=100 x=4.25‬‬

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

A=100
X=4.25

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

‫ﻣﺜﺎل‪:١٣‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻹدﺧﺎل ﻋﻤﺮك ﺛﻢ ﻃﺒﺎﻋﺘﻪ ‪ ،‬وﻃﺒﺎﻋﻪ ﻧﺼﻔﻪ وﺿﻌﻔﻪ؟‬
‫)( ‪main‬‬
‫{‬
‫;‪int a‬‬
‫;‪cin>>a‬‬
‫;‪cout<<a‬‬
‫;‪cout<<a/2‬‬
‫;‪cout<<a*2‬‬
‫}‬
‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﻗﻤﻨﺎ أوﻻ ﺑﺘﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫;‪Int a‬‬
‫ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﻃﻠﺐ ﻣﻨﺎ إدﺧﺎل اﻟﻌﻤﺮ‪:‬‬
‫ﻋﻨﺪ اﻟﻄﻠﺐ ﺳﻨﺪﺧﻞ ﻣﺜﻼ ‪20‬‬
‫‪Cin>>a‬‬
‫وﺑﻌﺪﻫﺎ ﻗﻤﻨﺎ ﺑﻄﺒﺎﻋﺔ اﻟﻌﻤﺮ‪:‬‬
‫;‪Cout<<a‬‬
‫ﺛﻢ ﻗﻤﻨﺎ ﺣﺴﺐ اﻟﻤﻄﻠﻮب ﺑﻄﺒﺎﻋﺔ ﻧﺼﻒ اﻟﻌﻤﺮ‪:‬‬
‫;‪Cout<<a/2‬‬
‫ﺛﻢ ﻗﻤﻨﺎ ﺣﺴﺐ اﻟﻤﻄﻠﻮب اﻷﺧﻴﺮ ﺑﻄﺒﺎﻋﺔ ﺿﻌﻒ اﻟﻌﻤﺮ‪:‬‬
‫;‪Cout<<a*2‬‬
‫ﻟﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ اﻟﻨﻬﺎﺋﻴﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪20 10 40‬‬

‫ﻣﺜﺎل‪:١٤‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻹدﺧﺎل ﻋﺪد ﻣﺎ وﻟﻴﻜﻦ اﻟﻌﺪد ‪ 7‬وﻣﻦ ﺛﻢ ﻃﺒﺎﻋﺔ ﺟﺪول اﻟﻀﺮب ﻟﻪ؟‬
‫)( ‪main‬‬
‫{‬
‫;‪int a‬‬ ‫ﻋﻨﺪ ﻃﻠﺐ إدﺧﺎل ﻗﻴﻤﺔ ﻧﺪﺧﻞ‬
‫;‪cin>>a‬‬ ‫اﻟﺮﻗﻢ ‪ 7‬ﺣﺴﺐ ﻃﻠﺐ اﻟﺴﺆال‪..‬‬
‫;‪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‬‬
‫}‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪7 14 21 28 35 42 49 56 63 70‬‬
‫ﻣﺜﺎل‪:١٥‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻹدﺧﺎل ﺛﻼث ﻋﻼﻣﺎت ﻟﻄﺎﻟﺐ ‪ 40 25 30‬وﻃﺒﺎﻋﺔ ﻣﻌﺪل اﻟﻌﻼﻣﺎت؟‬
‫)( ‪main‬‬ ‫ﻧﺪﺧﻞ ﺣﺴﺐ اﻟﻤﻄﻠﻮب ‪40 25‬‬
‫{‬ ‫‪30‬‬
‫;‪int a,b,c‬‬
‫;‪cin>>a>>b>>c‬‬
‫;‪cout<<(a+b+c)/3‬‬
‫}‬
‫ﻧﻼﺣﻆ أن ﻓﻲ ﺟﻤﻞ اﻹﺧﺮاج ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ ﻗﺎﻋﺪة وﻫ ﻲ ﺟﻤ ﻊ اﻟ ﺜﻼث أﻋ ﺪاد ﻣ ﻊ ﺑﻌﻀ ﻬﺎ ﺛ ﻢ‬

‫ﻗﺴﻤﺘﻬﺎ ﻋﻠﻰ ﻋﺪدﻫﺎ وﻫﻲ ﻗﺎﻋﺪة ﻣﻌﺮوﻓﺔ ﻹﻇﻬﺎر اﻟﻤﻌﺪل‪..‬‬
‫وﺳﻒ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪31‬‬

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

print the following items
10
6.3
2001.5
this is the end

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

‫اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ‬
‫ﺗﺘﻌﺎﻣﻞ ﻟﻐﺔ ‪ 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‬ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﻌﺮض؟‬
‫)( ‪main‬‬
‫{‬
‫;‪int x=5‬‬
‫)‪if (x>0‬‬
‫;”‪cout<<x<<“ x is positive‬‬
‫}‬
‫ﻓﻲ ﻫﺬا اﻟﻤﺜﺎل ﺳﺘﻈﻬﺮ اﻟﺠﻤﻠﺔ ‪ x is positive‬ﻋﻠﻰ اﻟﺸﺎﺷﺔ ﻻن اﻟﺸﺮط )‪(x>0‬‬

‫ﻣﺘﺤﻘﻖ ﻓﺎﻟﺨﻤﺴﺔ ﺑﺎﻟﻄﺒﻊ اﻛﺒﺮ ﻣﻦ اﻟﻌﺪد ﺻﻔﺮ ﻓﺎﻟﻨﺘﻴﺠﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪x is positive‬‬
‫ﻣﺜﺎل‪:٢‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ‪ C++‬اﻟﺘﺎﻟﻲ ﻟﻴﺤﺴﺐ اﻟﻘﻴﻤﺔ اﻟﻤﻄﻠﻘﺔ ﻟـ‪ Y‬اﻟﻤﻌﺮﻓﺔ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪:‬‬
‫‪x;x>=0‬‬
‫=|‪Y=|x‬‬
‫‪-x;x<0‬‬
‫)( ‪main‬‬
‫{‬ ‫ﻧﻘﻮم ﺑﺈدﺧﺎل اﻟﻌﺪد ‪10‬‬
‫;‪int x‬‬
‫;‪cin>>x‬‬
‫;‪if (x>=0) cout<<x‬‬
‫;‪else cout<<-x‬‬
‫}‬
‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﺳﻮف ﻧﺪﺧﻞ اﻟﺮﻗﻢ ‪ 10‬ﻟﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ ‪:‬‬

‫‪10‬‬

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

‫ﺑﺘﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ‪ grade‬ﺑﺄﻧﻪ ﻗﻴﻤﺔ ﻧﺼﻴﻪ وﻫﻮ اﻟﺘﻘﺪﻳﺮ‪.‬‬
‫ﻃﺒﻌﺎ ﻗﻤﻨﺎ ﺑﺈدﺧﺎل اﻟﺪرﺟﺔ وﻫﻲ ‪ 85‬ﺳﻮف ﺗﻜﻮن اﻟﻌﻼﻣﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪B‬‬

‫اﻟﺼﻴﻐﺔ اﻟﺜﺎﻧﻴﺔ‬
:‫( اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‬if..else)‫ وإﻻ‬.... ‫وﺗﺄﺧﺬ اﻟﺒﻨﻴﺔ اﻟﻌﺎﻣﻠﺔ ﻟﺠﻤﻠﺔ إذا‬
If (condition)
{
statmenet1;
}
else
{
statmenet1;
}
:‫( أﻋﻼه ﻛﻤﺎ ﻳﻠﻲ‬if..else) ‫( ﻟﻜﻦ ﺑﺎﻟﺸﻜﻞ‬3) ‫ﺳﻮف ﻧﻄﺒﻖ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‬
0
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‬‬
‫}‬ ‫ﻟﻄﺒﺎﻋﺔ ﻧﺼﻒ اﻟﻄﻮل‬
‫}‬

switch statement ‫ﺟﻤﻠﺔ اﻟﺘﻮزﻳﻊ‬
: c++ ‫ اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ ﻓﻲ ﻟﻐﺔ‬Switch ‫ﺗﺄﺧﺬ ﺟﻤﻠﺔ‬
Switch (expression) ‫ﺗﻌﺒﻴﺮ ﻗﻴﻤﺘﻪ ﺻﺤﻴﺤﺔ‬

{
‫ﺟﻤﻠﺔ أو ﺟﻤﻞ ﺗﻨﻔﺬ ﻋﻨﺪﻣﺎ‬
Case constant1: statments1; break; ‫ﺳﺎوي اﻟﺘﻌﺒﻴﺮ ﻗﻴﻤﺔ‬
Case constant2: statments2; break; constant1
......................................................
......................................................
‫ﺟﻤﻠﺔ أو ﺟﻤﻞ ﺗﻨﻔﺬ ﻋﻨﺪﻣﺎ‬
...................................................... ‫ﺳﺎوي اﻟﺘﻌﺒﻴﺮ ﻗﻴﻤﺔ‬
Case constantn: statmentsn; break; constant2
Default; last statements;
}
‫ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﻋﻨﺪ ﻋﺪم ﺗﻨﻔﻴﺬ‬

‫ﺟﻤﻴﻊ اﻟﺤﺎﻻت اﻟﻮاردة‬
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";
}
}
:‫واﻟﻨﺘﻴﺠﺔ‬
y

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

‫اﻟﺘﻜﺮار وﺣﻠﻘﺎت اﻟﺘﻜﺮار ‪Repetition and Loops‬‬
‫ﺗﻮﻓﺮ ﻟﻐﺔ ‪ ، C++‬ﻛﺴﺎﺋﺮ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ‪ ،‬ﻋﺪدا ﻣ ﻦ أﺳ ﺎﻟﻴﺐ اﻟﺘﻜ ﺮار اﻟﻤﺸ ﺮوط ‪ ،‬وﻏﻴ ﺮ‬
‫اﻟﻤﺸﺮوط وﻣﻦ ﻫﺬه اﻷﺳﺎﻟﻴﺐ‪:‬‬
‫أﺳﻠﻮب اﻟﺘﻜﺮار ﺑﺎﺳﺘﻌﻤﺎل ﺣﻠﻘﺔ ‪For‬‬

‫ﻳﻤﺘﻠﻚ أﺳﻠﻮب اﻟﺘﻜﺮار ﺑﺎﺳﺘﻌﻤﺎل ‪ for‬ﻗﻮة وﻣﺮوﻧﺔ ‪ ،‬ﻻ ﺗﺘﻮﻓﺮان ﻓﻲ ﻏﻴﺮﻫﺎ ﻣﻦ اﻟﻠﻐﺎت‪.‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ اﻷوﻟﻰ‬

‫;‪For ( initial-value; condition; increment ) statement‬‬
‫اﻟﻘﻴﻤﺔ‬ ‫ﺷﺮط ﻳﻘﻴﺪ‬ ‫اﻟﺰﻳﺎدة‬ ‫ﺟﻤﻠﺔ ﻳﺘﻢ‬

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

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

1 ‫ اﻻﺑﺘﺪاﺋﻴﺔ‬a ‫ﻗﻴﻤﺔ‬
2
3
4
5
6
7
8
9
10 ‫ اﻟﻨﻬﺎﺋﻴﺔ‬a ‫ﻗﻴﻤﺔ‬

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

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

1
-1
-3

:١٢‫ﻣﺜﺎل‬
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;
Block ‫اﻟﻘﻄﻌﺘﻴﻦ‬
cout<<x<<”*”;
}
return0;
}
14*
:١٣‫ﻣﺜﺎل‬
main ()
{ int a,c;
a=1;
c=3;
for (a=c;c;) ‫ﺗﻨﻘﺺ ﻣﻦ ﻗﻴﻤﺔ‬
{ 1 ‫ ﻗﻴﻤﺔ‬C
c--;
cout<<c<<endl;
}
return0;
}
:‫واﻟﻨﺎﺗﺞ‬
2
1
0

‫ﺣﻠﻘــﺎت اﻟﺘﻜــﺮار اﻟﻤﺘﺪاﺧﻠــﺔ ‪Nested (Multiple) for‬‬
‫‪Loops‬‬
‫ﺗﺄﺧﺬ ﺻﻴﻐﺔ ﺣﻠﻘﺎت اﻟﺘﻜﺮار اﻟﻤﺘﺪاﺧﻠﺔ اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‪:‬‬
‫)‪For (...‬‬
‫)‪For (...‬‬
‫)‪For (...‬‬
‫…………………………‪.‬‬
‫…………………………‪.‬‬
‫;‪Statements‬‬
‫ﻓﻠﻮ أﺧﺬﻧﺎ ﺣﺎﻟﺔ ﺣﻠﻘﺘﻴﻦ ﻣﺘﺪاﺧﻠﺘﻴﻦ ﻓﺎﻧﻬﻤﺎ ﺗﻜﺘﺒﺎن ﻋﻠﻰ اﻟﺼﻮرة اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫)‪For(...‬‬
‫)‪For (...‬‬
‫;‪Statements‬‬
‫ﺗﺴﻤﻰ اﻟﺤﻠﻘﺔ‬ ‫ﺗﺴﻤﻰ اﻟﺤﻠﻘﺔ‬

‫اﻟﺪاﺧﻠﻴﺔ ‪inner‬‬ ‫اﻟﺨﺎرﺟﻴﺔ ‪outer‬‬
‫‪loop‬‬ ‫‪loop‬‬
‫ﺟﻤﻠﺔ أو ﺟﻤﻞ ﺗﻜﺮر‬

‫ﺣﺴﺐ أواﻣﺮ‬
‫اﻟﺤﻠﻘﺘﻴﻦ‬
‫وﺗﻜﻮن ﻓﻲ ﻫﺬه اﻟﺤﺎﻟﺔ اﻟﺠﻤﻠﺔ )أو اﻟﺠﻤﻞ( ﺟﺰءا ﻣﻜﺮرا ﻣﺮﺗﺒﻄﺎ ﺑﺎﻟﺤﻠﻘﺔ اﻟﺪاﺧﻠﻴﺔ ‪،‬‬
‫واﻟﺤﻠﻘﺔ اﻟﺨﺎرﺟﻴﺔ ﺗﺘﻜﺮر ﺣﺴﺐ أواﻣﺮ اﻟﺤﻠﻘﺔ اﻟﺨﺎرﺟﻴﺔ وﻫﻜﺬا ‪...‬‬

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

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

‫أﺳﻠﻮب اﻟﺘﻜﺮار ﺑﺎﺳﺘﻌﻤﺎل ﺣﻠﻘﺔ ‪While & Do‬‬
‫أﺳ ﻠﻮب اﻟﺘﻜ ﺮار ﺑﺎﺳ ﺘﻌﻤﺎل ﺣﻠﻘ ﺔ ‪ while‬أﺳ ﻠﻮب آﺧ ﺮ ﻳﻤﺎﺛ ﻞ أﺳ ﻠﻮب ﺣﻠﻘ ﺔ ‪ ، for‬ﻣ ﻊ‬
‫ﺑﻌ ﺾ اﻻﺧﺘﻼﻓ ﺎت اﻟﺒﺴ ﻴﻄﺔ ‪ ،‬وﻫ ﻮ أﺳ ﻠﻮب ﻳﺜ ﺮى ﻟﻐ ﺔ ‪ ، C++‬وﻳﺰدﻫ ﺎ ﻗ ﻮة وﻣﺮوﻧ ﺔ ‪،‬‬
‫واﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻬﺬا اﻷﺳﻠﻮب‪:‬‬
‫;‪While (conditions) statements‬‬
‫ﺷﺮط أو اﻛﺜﺮ ﻳﻨﻈﻢ‬

‫ﻋﻤﻠﻴﺔ اﻟﺘﻜﺮار‬ ‫ﺟﻤﻠﺔ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ‬
‫ﺣﺴﺐ اﻟﺸﺮط‬
‫‪conditions‬‬
‫وﻣﻌﻨﻰ ﺣﻠﻘﺔ اﻟﺘﻜﺮار ‪ while‬ﻫﻮ اﻷﺗﻲ‪:‬‬

‫آي ﻣﺎ دام اﻟﺸﺮط ) أو اﻟﺸ ﺮوط ( ﻣﺘﺤﻘﻘ ﺎ )وﺟﻮاﺑ ﻪ ‪ ، (true‬ﻓﻴ ﺘﻢ ﺗﻜ ﺮار ﺗﻨﻔﻴ ﺬ اﻟﺠﻤﻠ ﺔ أو‬
‫اﻟﺠﻤ ﻞ )‪ ، (statements‬وﻳﻨﺘﻘ ﻞ ﺗﺴﻠﺴ ﻞ ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ إﻟ ﻰ اﻟﺠﻤﻠ ﺔ اﻟﺘ ﻲ ﺗﻠ ﻲ ﺣﻠﻘ ﺔ‬
‫‪. while‬‬
‫واﻷﻣﺜﻠﺔ اﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ذﻟﻚ‪:‬‬
‫ﻣﺜﺎل‪:١٦‬‬
‫)( ‪main‬‬
‫;‪{ int a‬‬
‫;‪a=1‬‬
‫)‪while (a<3‬‬ ‫ﻃﺎﻟﻤﺎ اﻟﺸﺮط‬
‫;‪cout<<a++‬‬
‫}‬ ‫اﻟﺰﻳﺎدة ﺑﻤﻘﺪار ‪1‬‬
‫ﺑﻌﺪ ﻃﺒﺎﻋﺔ‬
‫اﻟﻨﺘﻴﺠﺔ‬
‫واﻟﻨﺎﺗﺞ‬
‫ﺳﻮف ﻳﻜﻮن‪:‬‬
‫‪12‬‬

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

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

‫*‬
‫ﻻن اﻟﻌ ﺪد ‪ 10‬ﻋ ﺪد ﻣﻮﺟ ﺐ ﻟﻜ ﻦ ﺣ ﺎول أن ﺗ ﺪﺧﻞ ﻋ ﺪد ﺳ ﺎﻟﺐ ﻓﻠ ﻦ ﻳﻄﺒ ﻊ ﻟ ﻚ ﺷ ﻲ ﻟﻌ ﺪم‬

‫ﺗﺤﻘﻖ اﻟﺸﺮط ‪ ،‬وﻻ ﻧﻨﺴﻰ أﺧ ﻮاﻧﻲ أﻧﻨ ﺎ وﺿ ﻌﻨﺎ اﻟﺠﻤ ﻞ أو اﻟﺠﻤﻠ ﺔ اﻟﺨﺎﺻ ﺔ ﺑﺎﻟﻄﺒﺎﻋ ﺔ ﺑ ﻴﻦ‬
‫اﻟﻘﻄ ﻊ ‪ {} Block‬ﻻﻧ ﻪ وﺟ ﺪ اﻛﺜ ﺮ ﻣ ﻦ ﺟﻤﻠ ﺔ ﻟ ﺬﻟﻚ ﻳﺠ ﺐ وﺿ ﻊ اﻟﻘﻄ ﻊ ﻟﻜ ﻦ ﻋﻨ ﺪ ﻋ ﺪم‬
‫وﺟﻮد اﻛﺜﺮ ﻣﻦ ﺳﻄﺮ أو ﺟﻤﻠﻪ ﻛﻤﺜﺎل )‪ (١٢‬ﻓﻼ ﻳﺠﻮز وﺿﻌﻬﺎ‪.‬‬

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

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

‫واﻟﻨﺘﺎﺋﺞ‪:‬‬
‫‪12345678910‬‬

:٢٢‫ﻣﺜﺎل‬
main ()
{
int number;
for (number=1; number<=100;++ number)
{
if (number%2) // for odd 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‬‬
‫}‬

:٢٤‫ﻣﺜﺎل‬
‫ ﺑﺪون‬6‫ و‬4 ‫ و‬2 ‫ ﻣﺎ ﻋﺪا اﻷرﻗﺎم اﻟﺘﻲ ﺗﻘﺴﻢ ﻋﻠﻰ‬100 ‫ إﻟﻰ‬1 ‫ﺗﻄﺒﻊ ﺟﻤﻴﻊ اﻷرﻗﺎم ﻣﻦ‬
:‫ﺑﺎق‬
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;
}
:‫اﻟﻨﺎﺗﺞ‬
12
24
36
48
60
72
84
96

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

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

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

‫اﻟﻨﺼ ﻮص اﻟﺮﻣﺰﻳ ﺔ ‪ ،‬وﻓ ﻲ ﻋﻤﻠﻴ ﺎت ﺿ ﺮب اﻟﻤﺼ ﻔﻮﻓﺎت ‪ ،‬وإﻳﺠ ﺎد ﻣﻌﻜ ﻮس اﻟﻤﺼ ﻔﻮﻓﺔ‬
‫وﻋﻤﻠﻴﺎﺗﻬﺎ اﻷﺧﺮى ‪ ،‬وﻓﻲ اﻟﺘﺤﻠﻴﻞ اﻟﻌﺪدي ‪ ...‬اﻟـﺦ‪.‬‬
‫اﻟﻤﺘﻐﻴﺮ اﻟﻤﺮﻗﻢ ) اﻟﻤﺼﻔﻮﻓﺔ ( ذو اﻟﺒﻌﺪ اﻟﻮاﺣﺪ ‪one-dimensional Array‬‬
‫اﻟﻤﺘﻐﻴﺮ اﻟﻤﺮﻗﻢ ذو اﻟﺒﻌﺪ اﻟﻮاﺣﺪ ﻫ ﻮ ﻣﺼ ﻔﻮﻓﺔ ذات ﺑﻌ ﺪ واﺣ ﺪ أو ﻣﺘﺠ ﻪ )‪ (vector‬وﻳﻤﺜ ﻞ‬
‫ﻓﻲ اﻟﺠﺒﺮ ﻋﻠﻰ اﻟﻨﺤﻮ اﻷﻓﻘﻲ ]‪[a1 a2 ...a3‬‬
‫أو اﻟﻌﻤﻮدي‬
‫‪A1‬‬
‫‪A2‬‬
‫‪:‬‬
‫‪:‬‬
‫‪:‬‬
‫‪a3‬‬
‫وﻳﺄﺧﺬ اﻟﻤﺮﻗﻢ اﻟﻤﺘﻐﻴﺮ ﻓﻲ ‪ c++‬اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‪:‬‬

‫;]‪Type-specifier array-name[size‬‬
‫اﻟﻌﺪد ﻣﻦ‬
‫اﻻﺳﻢ اﻟﺠﻤﺎﻋﻲ‬
‫ﻣﺜﻞ ‪double -–int‬‬ ‫اﻟﻌﻨﺎﺻﺮ‬
‫‪char‬‬
‫وﻳﺒ ﺪأ اﻟﻌ ﺪاد اﻟﻤ ﺮﻗﻢ ﻋ ﺎدة ﻣ ﻦ اﻟﺼ ﻔﺮ ‪ ،‬آي أن اﻟﻌﻨﺼ ﺮ اﻷول ﻣ ﻦ اﻟﻤﺼ ﻔﻮﻓﺔ ][‪ a‬ﻫ ﻮ‬
‫]‪ a[0‬واﻟﺜﺎﻧﻲ ]‪ ... a[1‬وﻫﻜﺬا ﻓﻤﺜﻼ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫;]‪Int a[20‬‬
‫اﺳﻤﻬﺎ ‪ ، a‬وﻗﺪ ﺣﺠﺰ ﻟﻬﺎ ‪ 20‬ﻣﻮﻗﻌﺎ ﻟﻌﺸﺮﻳﻦ ﻋﻨﺼﺮا ﻣﻦ اﻟﻨﻮع اﻟﺼﺤﻴﺢ ‪.‬‬
‫واﻟﻤﺼﻔﻮﻓﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫;]‪Char name[15‬‬
‫ﻣﺼﻔﻮﻓﺔ رﻣﺰﻳﺔ ‪ ،‬اﺳﻤﻬﺎ ‪ name‬ﻳﺤﺠﺰ ﻟﻬﺎ ﺧﻤﺴﺔ ﻋﺸﺮ ﻋﻨﺼﺮا ﻣﻦ اﻟﻨﻮع اﻟﺮﻣﺰي‬
‫ﻟﻬﺎ ‪.‬‬
‫وﻫﻜـﺬا‪...‬‬

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

:٢‫ﻣﺜﺎل‬
:‫ وﻋﻤﻠﻴﺎت ﻃﺒﺎﻋﺔ ﻋﻨﺎﺻﺮ ﻣﺼﻔﻮﻓﺔ‬، ‫ وﺣﺴﺎب‬، ‫ﻣﺜﺎل ﻋﻠﻰ ﻋﻤﻠﻴﺎت إدﺧﺎل‬
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;
}
:‫وﺳﺘﻜﻮن ﻗﻴﻢ اﻟﻨﺘﺎﺋﺞ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‬

0 0
1 1
2 4
3 9
4 16

‫إﻋﻄﺎء ﻗﻴﻤﺔ أوﻟﻴﺔ ﻟﻠﻤﺼﻔﻮﻓﺔ ذات اﻟﺒﻌﺪ اﻟﻮاﺣـﺪ ‪Array‬‬
‫‪Initialization‬‬
‫ﻣﺜﺎل ﻋﻠﻰ إدﺧﺎل ﻋﺪة ﻋﻨﺎﺻﺮ ﻣﻦ ﻣﺼﻔﻮﻓﺔ اﻟﺪرﺟﺎت ][‪grade‬‬
‫}‪Int grade[5]={80,90,54,50,95‬‬
‫وﻣﺜﺎل ﻋﻠﻰ إدﺧﺎل ﻗﻴﻢ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺮﻣﺰﻳﺔ ][‪name‬‬

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

‫‪40‬‬
‫‪60‬‬
‫‪50‬‬
‫‪70‬‬
‫‪80‬‬
‫‪90‬‬

‫ ﻣ ﻮاد وﻫ ﺬه‬5 ‫ وﻣﻌ ﺪل ﻋﻼﻣ ﺎت اﻟﻄﺎﻟ ﺐ ﻓ ﻲ‬، ‫ﻗ ﻢ ﺑﻜﺘﺎﺑ ﺔ ﺑﺮﻧ ﺎﻣﺞ ﻳﻘ ﻮم ﺑﺈﻳﺠ ﺎد ﻣﺠﻤ ﻮع‬
:‫اﻟﻌﻼﻣﺎت ﻛﺎﻟﺘﺎﻟﻲ‬
87,67,81,90,55
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;
}
:‫واﻟﻨﺎﺗﺞ ﺳﻴﻜﻮن ﻛﺎﻟﺘﺎﻟﻲ‬

87
735
87 ‫اﻟﻤﻌﺪل‬
735 ‫واﻟﻤﺠﻤﻮع‬

‫ﻋﻨــﻮان ﻋﻨﺎﺻــﺮ اﻟﻤﺼــﻔﻮﻓﺔ ﻓــﻲ اﻟــﺬاﻛﺮة ‪Addressing‬‬
‫‪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‬ﻓ ﺎن ﻋﻨ ﺎوﻳﻦ‬
‫اﻟﻌﻨﺎﺻﺮ اﻷﺧﺮى ﺗﻜﻮن ﻋﻠﻰ اﻟﺘﻮاﻟﻲ ‪104 103 102 101‬‬
‫ﻳﻤﻜﻦ ﺗﺸﺒﻴﻪ اﻟﻌﻼﻗﺔ ﺑﻴﻦ ﻗﻴﻤﺔ اﻟﻌﻨﺼﺮ ‪ ،‬وﻋﻨﻮاﻧﻪ ‪ ،‬ﺑﺎﻟﻌﻼﻗ ﺔ ﺑ ﻴﻦ ﻋﻼﻣ ﺔ ﻃﺎﻟ ﺐ ‪ ،‬ورﻗﻤ ﻪ‬
‫اﻟﺠﺎﻣﻌﻲ ‪ ،‬إذ ﻋﻼﻣﺘﻪ ﻫﻲ ﻗﻴﻤﺔ ﻧﺸﻄﻪ ﻛﻌﻨﺼﺮ ‪ ،‬ﻟﻴﺲ ﻟﻬﺎ ﻋﻼﻗﺔ ﺑﺮﻗﻢ ﻣﻘﻌﺪه اﻟﺠﺎﻣﻌﻲ‪.‬‬

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

‫;]‪Int x[2][3‬‬
‫وﻫﻲ ﻣﺼﻔﻮﻓﺔ ﺻ ﺤﻴﺤﺔ اﻟﻌﻨﺎﺻ ﺮ ‪ int‬أﺑﻌﺎدﻫ ﺎ ﻫ ﻲ ﻋ ﺪد اﻟﺼ ﻔﻮف=‪ ، 2‬وﻋ ﺪد اﻷﻋﻤ ﺪة‬
‫=‪3‬‬
‫ﻻﺣﻆ أن ﻋﺪد اﻟﺼﻔﻮف ﻳﻮﺿﻊ ﺑﻴﻦ ﻗﻮﺳﻴﻦ وﺣﺪه ‪ ،‬وﻛﺬﻟﻚ ﻋﺪد اﻷﻋﻤﺪة ‪.‬‬

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

‫اﻟﺪوال‬
‫‪Functions‬‬
‫ﻣﻘﺪﻣﺔ ‪Introduction‬‬
‫ﺗﻌﺮف اﻟﺪاﻟﺔ ) اﻻﻗﺘ ﺮان ( ﻋﻠ ﻰ أﻧﻬ ﺎ ‪ :‬ﺟﻤﻠ ﺔ أو ﻣﺠﻤﻮﻋ ﺔ ﺟﻤ ﻞ أو ﺗﻌﻠﻴﻤ ﺎت ‪ ،‬ذات ﻛﻴ ﺎن‬
‫ﺧ ﺎص ‪ ،‬ﺗﻘ ﻮم ﺑﻌﻤﻠﻴ ﺔ أو ﻣﺠﻤﻮﻋ ﺔ ﻋﻤﻠﻴ ﺎت ‪ ،‬ﺳ ﻮاء ﻋﻤﻠﻴ ﺎت إدﺧ ﺎل أو إﺧ ﺮاج أو‬
‫ﻋﻤﻠﻴﺎت ﺣﺴﺎﺑﻴﺔ أو ﻣﻨﻄﻘﻴﺔ ‪ ،‬وﺗﺤﺘﻞ اﻟﺪاﻟﺔ ﻣﻮﻗﻌﺎ ﻣ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ،‬آي أﻧﻬ ﺎ ﺟ ﺰء ﻣﻨ ﻪ ‪ ،‬أو‬
‫ﻳﻤﻜﻦ اﻟﻘﻮل أن ﺑﺮﻧﺎﻣﺞ ‪ ، c++‬ﻳﺘﻜﻮن ﻣﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺪوال‪.‬‬
‫وﻣﻦ ﻓﻮاﺋﺪ اﻟﺪوال اﻟﺘﺎﻟﻲ‪:‬‬

‫‪ -١‬ﺗﺴ ﺎﻋﺪ اﻟ ﺪوال اﻟﻤﺨﺰﻧ ﺔ ﻓ ﻲ ذاﻛ ﺮة اﻟﺤﺎﺳ ﺐ ﻋﻠ ﻰ اﺧﺘﺼ ﺎر اﻟﺒﺮﻧ ﺎﻣﺞ إذ ﻳﻜﺘﻔ ﻰ‬
‫ﺑﺎﺳﺘﻌﺎدﺗﻬﺎ ﺑﺎﺳﻤﻬﺎ ﻓﻘﻂ ﻟﺘﻘﻮم ﺑﺎﻟﻌﻤﻞ اﻟﻤﻄﻠﻮب‪.‬‬
‫‪ -٢‬ﺗﺴﺎﻋﺪ اﻟﺪوال اﻟﻤﺨﺰﻧﺔ ﻓﻲ ﻣﻜﺘﺒﺔ اﻟﺤﺎﺳﺐ ‪ ،‬أو اﻟﺘ ﻲ ﻳﻜﺘﺒﻬ ﺎ اﻟﻤﺒ ﺮﻣﺞ ﻋﻠ ﻰ ﺗﻼﻓ ﻲ‬
‫ﻋﻤﻠﻴﺎت اﻟﺘﻜﺮار ﻓﻲ ﺧﻄﻮات اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﻲ ﺗﺘﻄﻠﺐ ﻋﻤﻼ ﻃﻮﻳﻼ وﺷﺎﻗﺎ‪.‬‬
‫‪ -٣‬ﺗﺴﺎﻋﺪ اﻟﺪوال اﻟﺠﺎﻫﺰة ﻋﻠﻰ ﺗﺴﻬﻴﻞ ﻋﻤﻠﻴﺔ اﻟﺒﺮﻣﺠﺔ ﻧﻔﺴﻬﺎ‪.‬‬
‫‪ -٤‬ﺗﻮﻓﺮ ﻣﺴﺎﺣﺔ ﻣﻦ اﻟﺬاﻛﺮة اﻟﻤﻄﻠﻮﺑﺔ‪.‬‬
‫‪ -٥‬اﺧﺘﺼﺎر ﻋﻤﻠﻴﺎت زﻣﻦ اﻟﺒﺮﻣﺠﺔ وﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺄﺳﺮع وﻗﺖ ﻣﻤﻜﻦ‪.‬‬
‫وﻟﻠﺘﺪﻟﻴﻞ ﻋﻠﻰ أﻫﻤﻴﺔ اﻟﺪوال ﻓﻲ ﺑﺮﻣﺠﺔ ‪ c++‬ﺧﺬ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬

‫ﻟﻮ أردﻧﺎ ﻛﺘﺎﺑﺔ ﺧﻮارزﻣﻴﺔ ﻟﺨﻄﻮات ﺻﻨﻊ ﻛﺄس ﻣﻦ اﻟﺸﺎي ﻓﺄﻧﻨﺎ ﻧﻜﺘﺐ ﻣﺎ ﻳﺄﺗﻲ‪:‬‬
‫‪ -١‬ﺿﻊ اﻟﻤﺎء ﻓﻲ ﻏﻼﻳﺔ اﻟﺸﺎي‪.‬‬
‫‪ -٢‬ﺳﺨﻦ اﻟﻤﺎء ﺣﺘﻰ ﻳﻐﻠﻰ‪.‬‬
‫‪ -٣‬أﺿﻒ ﺷﺎﻳﺎ إﻟﻰ اﻟﻤﺎء‪.‬‬
‫‪ -٤‬أﺿﻒ ﺳﻜﺮا إﻟﻴﻪ‪.‬‬
‫‪ -٥‬أﻃﻔﺊ اﻟﻨﺎر‪.‬‬
‫‪ -٦‬ﺻﺐ ﺷﺎﻳﺎ ﻓﻲ ﻛﺄس‪.‬‬
‫اﻓ ﺮض اﻵن أﻧﻨ ﺎ ﻧ ﻮد ﻃﻠ ﺐ ﻛ ﺄس ﻣ ﻦ اﻟﺸ ﺎي ﻣ ﻦ ﻣﻘﻬ ﻰ ﻣﺠ ﺎور ‪ :‬أن ﺧﻄ ﻮات‬

‫اﻟﺨﻮارزﻣﻴﺔ اﻟﺘﻲ ﻧﺤﺘﺎﺟﻬﺎ اﻵن ﻫﻲ ﺧﻄﻮه واﺣﺪه ﻓﻘﻂ وﻫﻲ‪:‬‬
‫‪ -١‬اﺳﺘﺪع ﻛﺄس ﻣﻦ اﻟﺸﺎي‪.‬‬
‫ﺗﺨﻴ ﻞ اﻵن ﻛ ﻢ وﻓﺮﻧ ﺎ ﻣ ﻦ اﻟﺨﻄ ﻮات ﻟ ﻮ اﺳ ﺘﻌﻤﻠﻨﺎ اﻟ ﺪوال اﻟﺠ ﺎﻫﺰة ) أو اﻟﺘ ﻲ ﻳﺠﻬﺰﻫ ﺎ‬
‫اﻟﻤﺒﺮﻣﺞ ﻣﻦ ﻗﺒﻞ ( ﺑ ﺪﻻ ﻣ ﻦ ﺧﻄﻮاﺗﻬ ﺎ اﻟﺘﻔﺼ ﻴﻠﻴﺔ وﺑﺨﺎﺻ ﺔ ﻓ ﻲ ﺑﺮﻧ ﺎﻣﺞ ﻳﺘﻄﻠ ﺐ ﺣﺴ ﺎﺑﺎت‬
‫وﻋﻤﻠﻴﺎت ﻛﺜﻴﺮة وﻛﻢ ﻳﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ ﺳﻬﻼ وواﺿﺤﺎ وﻗﺘﺬاك‪.‬‬
‫وﺗﺄﺧﺬ اﻟﺪاﻟﺔ اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‪:‬‬

‫;‪Type-specified function-name (formal parameters‬‬
‫{‬
‫‪function body‬‬
‫}‬
‫وﻗ ﺪ ذﻛﺮﻧ ﺎ ﻣ ﻦ ﻗﺒ ﻞ أن اﻟﺪاﻟ ﺔ ﻗ ﺪ ﺗﻌﺘﻤ ﺪ ﻋﻠ ﻰ ﻣﺘﻐﻴ ﺮ أو اﻛﺜ ﺮ ‪ ،‬وﻗ ﺪ ﻻ ﺗﻌﺘﻤ ﺪ ﻋﻠ ﻰ آي‬

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

‫ﺗﻄﺒﻴﻘﺎت ﻋﻠﻰ اﻟﺪوال‬
‫ﺷﺎﻫﺪ ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ وﺗﺘﺒﻌﻪ أوﻻ ﺑﺎﻟـ‪ main‬واﻧﻈﺮ ﻟﻠﻨﺘﺎﺋﺞ‪:‬‬
‫;‪int x,y‬‬
‫)(‪void max‬‬
‫{‬
‫;‪x=x+y‬‬
‫}‬
‫)(‪void fax‬‬
‫{‬
‫;)(‪max‬‬
‫;)(‪max‬‬
‫{‬
‫{‬
‫;‪y=10; x=0‬‬
‫;)(‪max‬‬
‫;)(‪fax‬‬
‫;‪cout<<x<<y‬‬
‫}‬
‫أﻋﺰاﺋﻲ ﺳﺄﺷﺮح اﻟﻨﺘﺎﺋﺞ ﻗﺒﻞ إﻇﻬﺎرﻫﺎ ﻟﻠﺘﺴﻬﻴﻞ ﻋﻠﻴﻜﻢ ﻓﻲ اﻷﻣﺜﻠﺔ اﻟﻘﺎدﻣﺔ‪:‬‬

‫ﻟﻨﺘﻌﺒﺮ أن ﻫﻨﺎك ﺛﻼث ﻛﻮاﻛﺐ‪:‬‬
‫ﻛﻮاﻛﺐ ‪ main‬اﻟﺮﺋﻴﺴﻲ‬
‫ﻛﻮﻛﺐ ‪fax‬‬
‫ﻛﻮﻛﺐ ‪max‬‬
‫ﻣﻦ اﻟﻤﻌﺮوف أﻧﻨﺎ ﺳ ﻮف ﻧﺒ ﺪا ﺑﻜﻮﻛ ﺐ ‪ main‬ﻟﻨﺸ ﺎﻫﺪ ﻣ ﺎ ﺑ ﺪاﺧﻞ ﻧﺸ ﺎﻫﺪ أن ﻫﻨ ﺎك ﻗﻴﻤﺘ ﻴﻦ‬
‫ﻋﺪدﻳﺘﻴﻦ ‪ x y‬ﻟﻜﻨﻪ ﻻ ﻳﻌﺮﻓﻪ ﻫﻞ ﻫ ﻲ أﻋ ﺪاد ﺣﻘﻴﻘﻴ ﺔ أم ﺻ ﺤﻴﺤﻪ ﻟ ﺬﻟﻚ ﻳ ﺬﻫﺐ ﻓ ﻲ اﻷﻋﻠ ﻰ‬
‫ﻟﻴﺒﺤ ﺚ ﻋﻨﻬ ﺎ ﻓ ﻲ أول اﻟﺒﺮﻧ ﺎﻣﺞ ﻟﻴﺠ ﺪ أﻧﻬ ﺎ أﻋ ﺪاد ﺻ ﺤﻴﺤﺔ ‪ ، 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‬‬

:٣‫ﻣﺜﺎل‬
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();
}
}
:‫واﻟﻨﺎﺗﺞ ﺳﻴﻜﻮن ﻛﺎﻟﺘﺎﻟﻲ‬

* *
* *
* *
* *

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

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

‫‪20‬‬
‫ﻻن اﻟﻌﺪد اﻟﺬي أدﺧﻠﻨﺎ ‪ 20‬اﻛﺒﺮ ﻣﻦ اﻟﻌﺪد اﻟﺬي أدﺧﻠﻨﺎ ‪ 10‬ﻓﻘﺎم ﺑﻄﺒﺎﻋﺘﻪ ﺣﺴﺐ اﻟﺸﺮط ‪.‬‬

‫ﺗﻘﻨﻴﺔ اﻷﻗﺮاص و دوال اﻟﻤﻠﻔﺎت اﻻﻧﺘﻘﺎﻟﻴﺔ‬
‫‪disk Files‬‬
‫ﻣﻘﺪﻣﺔ ‪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‬‬
‫اﻟﺠﺪول ‪٥ -١‬‬

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

‫ﺑﻤﺆﺷﺮ اﻟﻤﻠﻒ اﻟﻤﻌﺮف ﻟﻪ وﻫﻮ ‪ f‬ﻃﺒﻌﺎ‪.‬‬
‫ﺛﻢ ﻧﻘﻮم ﺑﺘﺤﺪﻳﺪ ﻣﻮﻗﻊ اﻟﻤﻠﻒ اﻟﻤﺮاد إﻧﺸﺎءه وﻳﺠﺐ اﻟﺘﺤ ﺬﻳﺮ ﻫﻨ ﺎ اﻧ ﻪ ﻳﺠ ﺐ ﻋ ﺪم ﻛﺘﺎﺑ ﺔ اﺳ ﻢ‬
‫ﻣﻠﻒ ﻣﻦ ﻣﻠﻔﺎت اﻟﻨﻈﺎم ‪ system‬ﻟﺘﺠﻨﺐ ﻋ ﺪم ﺣ ﺪوث ﺧﻠ ﻞ وﻣﺸ ﺎﻛﻞ ﺑﺎﻟﺠﻬ ﺎز ﻣ ﺜﻼ ﻧﻜﺘ ﺐ‬
‫ﻛﻤﺎ أﻋﻼه ‪ matrix.txt‬وﻫﻮ ﻣﻠﻒ ﻧﺼ ﻲ وﻳﺠ ﺐ وﺿ ﻊ اﻟﻌﻼﻣﺘ ﻴﻦ \\ ﺑﻌ ﺪ ﻛﺘﺎﺑ ﺔ اﻟﻘ ﺮص‬
‫‪ C‬وﻻ ﻳﺼﺢ وﺿﻊ ﻋﻼﻣﺔ واﺣﺪه \ ﻓﻘ ﻂ ‪ ،‬ﺑﻌ ﺪ ذﻟ ﻚ ﻧﻜﺘ ﺐ اﻟﺮﻣ ﺰ ‪ w‬ﻻﺳ ﺘﺤﺪاث اﻟﻤﻠ ﻒ‬
‫اﻟﺠﺪﻳ ﺪ ﺛ ﻢ ﺑﻌ ﺪ ذﻟ ﻚ ﻓ ﻲ اﻟﺴ ﻄﺮ اﻷﺧﻴ ﺮ ﻧﻘ ﻮم ﺑﺈﻏﻼﻗ ﻪ ﺑﺎﻟﺪاﻟ ﺔ )‪ fclose (f‬وﻳﺠ ﺐ ﻛﺘﺎﺑ ﺔ‬
‫ﻫﺬه اﻟﺪاﻟﺔ ﻛﻲ ﻳﺼﺒﺢ اﻟﺒﺮﻧﺎﻣﺞ ﺻﺤﻴﺢ ‪.‬‬
‫اﻵن ﻗﻢ ﺑﺘﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ﺑﻌ ﺪ ذﻟ ﻚ ﻟ ﻦ ﻳﻈﻬ ﺮ ﻟ ﻚ ﺷ ﻲ ﻗ ﺪ ﺗﺴ ﺘﻐﺮب ﻣ ﺎ اﻟﻔﺎﺋ ﺪة اﻵن اذﻫ ﺐ‬

‫ﻋﺰﻳﺰي إﻟﻰ اﻟﻘﺮص ‪ C‬وﻫﻮ اﻟﺬي ﻗﻤﺖ ﺑﺈﻧﺸﺎء اﻟﻤﻠﻒ ﻓﻴﻪ ) اﻟﻤﺴﺎر أﻋﻼه(‬
‫وﺷﺎﻫﺪ اﻟﻤﻠﻒ اﻟﺠﺪﻳﺪ‬
‫ﻫﺬا ﻫﻮ اﻟﻤﻠﻒ‬
‫اﻟﺠﺪﻳﺪ‬

‫ﺟﺪول اﻷﻧﻤﺎط ‪ ،‬ﺣﺴﺐ ﻣﺎ ﻗﺮرﺗﻪ ‪ ANSI‬ﻣﺆﺧﺮا‪:‬‬
‫وﻇﻴﻔﺘﻪ‬ ‫رﻣﺰ اﻟﻨﻤﻂ‬

‫ﻟﻔﺘﺢ ﻣﻠﻒ اﻟﻨﺺ ﻟﻠﻘﺮاءة‬ ‫"‪"r‬‬
‫ﻻﺳﺘﺤﺪث ﻣﻠﻒ ﻧﺺ ﻟﻠﻜﺘﺎﺑﺔ‬ ‫"‪" w‬‬
‫ﻟﻺﻟﺤﺎق ﺑﻤﻠﻒ ﻧﺺ‬ ‫"‪" a‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﺛﻨﺎﺋﻲ اﻟﻘﺮاءة‬ ‫"‪"rb‬‬
‫ﻻﺳﺘﺤﺪاث ﻣﻠﻒ ﺛﻨﺎﺋﻲ اﻟﻜﺘﺎﺑﺔ‬ ‫" ‪"wb‬‬
‫ﻟﻺﻟﺤﺎق ﺑﻤﻠﻒ ﺛﻨﺎﺋﻲ‬ ‫"‪"ab‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﻧﺺ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"r+‬‬
‫ﻻﺳﺘﺤﺪاث ﻧﺺ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"w+‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﻧﺺ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"a+‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﺛﻨﺎﺋﻲ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"r+b‬‬
‫ﻻﺳﺘﺤﺪاث ﻣﻠﻒ ﺛﻨﺎﺋﻲ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"w+b‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﺛﻨﺎﺋﻲ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"a+b‬‬
‫اﻟﺠﺪول ‪٥ -٢‬‬
‫ﻧﻼﺣﻆ أن ﻫﺬا اﻟﺠﺪول ﻳﻤﻜﻦ اﺳﺘﻌﻤﺎﻟﻪ ﻟﻜﻞ ﻣﻦ ﻣﻠﻔﺎت اﻟﻨﺺ واﻟﻤﻠﻔﺎت اﻟﺜﻨﺎﺋﻴﺔ‪.‬‬

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

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

‫}‬ ‫ﻫﺬا اﻟﺴﻄﺮ ﻛﻤﺎ ﺗﻼﺣﻆ‬

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

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

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

Cplusplus

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cplusplus

Uploaded by

Copyright:

Available Formats

‫ﺗﻢ ﺗﺤﻤﻴﻞ اﻟﻤﻠﻒ ﻣﻦ ﻣﻮﻗﻊ‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫رﻣﻮز ﻟﻐﺔ ‪C++‬‬

‫*ﻛﻠﻤﺎت ﻟﻐﺔ ‪C++‬‬

‫وﺗﻄﻠﻖ اﻷﺳﻤﺎء اﻟﺘﻌﺮﻳﻔﻴﺔ ﻋﻠﻰ‪-:‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫وﻫﺬه أﺳﻤﺎء ﺗﻌﺮﻳﻔﻴﺔ ﻏﻴﺮ ﻣﻘﺒﻮل )‪ (invalid‬ﻟﻸﺳﺒﺎب اﻟﻤﺒﻴﻨﺔ إزاء ﻛﻞ ﻣﻨﻬﺎ‪:‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

near Static asm Double long Sizeof

‫ ﻻ ﻳﺠ ﻮز إﻋ ﺎدة ﺗﻌﺮﻳﻔﻬ ﺎ أو اﺳ ﺘﻌﻤﺎﻟﻬﺎ‬، ‫وﻳﻨﺒﻐ ﻰ اﻟﺘﻨﺒﻴ ﻪ إﻟ ﻰ أن ﻫ ﺬه اﻟﻜﻠﻤ ﺎت اﻟﻤﺤﺠ ﻮزة‬

PDF created with FinePrint pdfFactory trial version www.pdffactory.com

‫ﻳﻤﻜﻦ ﺗﻤﺜﻴﻞ اﻟﺜﻮاﺑﺖ اﻟﻌﺪدﻳﺔ ‪ ،‬ﻓﻲ ﻟﻐﺔ ‪ C++‬ﺑﺜﻼث ﺻﻮر ﻫﻲ‪-:‬‬

‫‪ .a‬اﻟﺜﺎﺑﺖ اﻟﻌﺪدي اﻟﺼﺤﻴﺢ ‪integer‬‬

‫أﻣﺜﻠﺔ ﺻﺤﻴﺤﺔ ﻋﻠﻰ اﻟﺜﺎﺑﺖ اﻟﻌﺪدي اﻟﺼﺤﻴﺢ‪-:‬‬

‫واﻷﻋﺪاد اﻟﺘﺎﻟﻴﺔ ﻏﻴﺮ ﺻﺤﻴﺤﺔ ﻟﻸﺳﺒﺎب اﻟﻤﺒﻴﻨﺔ إزاء ﻛﻞ ﻣﻨﻬﺎ‪:‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫واﻷﻣﺜﻠﺔ اﻻﺗﻴﻪ ﻏﻴﺮ ﺻﺤﻴﺤﺔ ﻟﻸﺳﺒﺎب اﻟﻤﺒﻨﻴﺔ إزاء ﻛﻞ ﻣﻨﻬﺎ‪-:‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫وﻣﻦ اﻷﻣﺜﻠﺔ ﻋﻠﻰ اﻟﺜﺎﺑﺖ اﻟﺮﻣﺰي ﻣﺎ ﻳﺄﺗﻲ ‪-:‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫;‪Float x, y‬‬ ‫‪ X‬و‪ y‬ﻋﺪدان ﺣﻘﻴﻘﻴﺎن‬

‫;‪Integer k‬‬ ‫‪ K‬ﻋﺪد ﺻﺤﻴﺢ‬

‫;‪Char c,b,a‬‬ ‫‪ C,b,a‬رﻣﻮز‬

‫ﻻﺣﻆ اﻟﺴ ﻄﺮﻳﻦ اﻷول ‪ ،‬واﻟﺜﺎﻟ ﺚ ﻳﺤﺘﻮﻳ ﺎن ﻋﻠ ﻰ اﻛﺜ ﺮ ﻣ ﻦ ﻣﺘﻐﻴ ﺮ ﺣﻴ ﺚ ﻳﻔﺼ ﻞ ﺑ ﻴﻦ ﻛ ﻞ‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫اﻷدوات اﻟﺤﺴﺎﺑﻴﺔ ‪Arithmetic Operators‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫اﻟﺰﻳﺎدة واﻟﻨﻘﺼﺎن ‪Increment and Decrement‬‬

‫وﺑﺎﻟﻄﺮﻳﻘﺔ ﻧﻔﺴﻬﺎ ﻳﻤﻜﻦ إﻧﻘﺎص ‪ 1‬ﻣﻦ ﻗﻴﻤﺔ ‪ a‬ﻋﻠﻰ اﻟﻨﺤﻮ‪-:‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫ﻓﻲ ﻫﺬه اﻟﺤﺎﻟﺔ ﺗﻜﻮن ‪x=1 , z=1 , y=1‬‬

‫ﻓﻲ ﻫﺬه اﻟﺤﺎﻟﺔ ﺗﻜﻮن ‪x=2 , y=2 , z=2‬‬

‫اﻵن ‪x=3 , y=3 , z=3‬‬

‫اﻵن ‪x=5 , y=2 , z=1‬‬

‫وﺑﺈﻣﻜﺎﻧﻚ ﻛﺘﺎﺑﺔ اﻟﺠﻤﻠﺘﻴﻦ‪:‬‬

‫ﻓﻲ ﺟﻤﻠﺔ واﺣﺪ ﻋﻠﻰ اﻟﻨﺤﻮ‪:‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫ﻳﺄﺧﺬ ﺗﺴﻠﺴﻞ أوﻟﻮﻳﺎت ﻋﻤﻠﻴﺎﺗﻪ اﻟﺸﻜﻞ واﻟﺨﻄﻮات اﻟﺘﺎﻟﻴﺔ‪-:‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ‪ x= =y :‬ﺟﻮاب أﻣﺎ ﻧﻌﻢ أو ﻻ ‪.‬‬

‫وﻓ ﻲ ﻟﻐ ﺔ ‪ C++‬ﺗﻌﺎﻣ ﻞ اﻟﻨﺘﻴﺠ ﺔ ﻻ )‪ (false‬ﻋﻠ ﻰ أﻧﻬ ﺎ ﺻ ﻔﺮ )‪ (0‬وﺗﺄﺧ ﺬ اﻟﻨﺘﻴﺠ ﺔ ﻧﻌ ﻢ‬

‫إﻟﻴﻚ اﻵن ﻫﺬه اﻷﻣﺜﻠﺔ ‪ :‬اﻓﺮض أن ;‪int a=b=3‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫واﻟﺠﺪول اﻟﺘﺎﻟﻲ ﻳﺒﻴﻦ اﻷدوات اﻟﺪﻗﻴﻘﺔ ووﻇﻴﻔﺔ ﻛﻞ ﻣﻨﻬﺎ‪:‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬

‫ﺣﻴﺚ ﻳﺠﻤﻊ ‪ 0+0‬وﻳﻌﻄﻲ ‪ ، 0‬وﻳﺠﻤﻊ ‪ 0+1‬ﻟﻴﻌﻄﻲ ‪ 0‬وﻳﺠﻤﻊ ‪ 1+1‬وﻳﻌﻄﻲ ‪1‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪x‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬

‫‪PDF created with FinePrint pdfFactory trial version www.pdffactory.com‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪x‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬