C en Arabe - 1

‫‪2007‬‬
‫ﻣﻘﺪﻣﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺑﻠﻐﺔ ‪C‬‬

‫أﺳﺎﺳﯿﺎت‬
‫اﻟﻠﻐﺔ‬
‫اﻟﺘﺮاﻛﯿﺐ‬ ‫ھﯿﻜﻠﯿﺔ‬
‫اﻟﺸﺮﻃﯿﺔ‬ ‫اﻟﺒﺮاﻣﺞ‬
‫اﻟﻤﺼﻔﻮﻓﺎت‬ ‫اﻟﺤﻠﻘﺎت‬
‫اﻟﺘﻜﺮارﯾﺔ‬
‫اﻟﺪوال‬
‫ﻣﺤﻤﺪ ﺳﺎﻟﻢ اﻟﺒﮭﺎدﻟﻲ‬

‫‪Introduction to C Programming Language‬‬ ‫ﻣﻘﺪﻣﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺑﻠﻐﺔ ‪C‬‬
‫اﻟﻤﺤﺘﻮﯾﺎت‬
‫اﻟﺼﻔﺤﺔ‬ ‫اﻟﻤﻮﺿﻮع‬ ‫اﻟﺼﻔﺤﺔ‬ ‫اﻟﻤﻮﺿﻮع‬
‫‪20‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ‬ ‫‪4‬‬ ‫اﻟﻤﻘﺪﻣﺔ‬
‫‪21‬‬ ‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‪ :‬ﺗﺮاﻛﯿﺐ اﻟﺘﻜﺮار‬ ‫‪4‬‬ ‫اﻟﻔﺼﻞ اﻻول‪ :‬أﺳﺎﺳﯿﺎت اﻟﻠﻐﺔ‬
‫‪21‬‬ ‫اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﯾﺔ )‪(while‬‬ ‫‪4‬‬ ‫اﻟﺮﻣﻮز‬
‫‪22‬‬ ‫اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﯾﺔ )‪(do-While‬‬ ‫‪4‬‬ ‫اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة‬
‫‪24‬‬ ‫اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﯾﺔ )‪(for‬‬ ‫‪4‬‬ ‫اﻟﻤﻌٌﺮﻓﺎت‬
‫‪25‬‬ ‫ﺟﻤﻞ اﻟﺘﻔﺮع‬ ‫‪5‬‬ ‫اﻻﻋﺪاد‬
‫‪25‬‬ ‫ﺟﻤﻠﺔ أﻗﻄﻊ )‪(break‬‬ ‫‪5‬‬ ‫اﻟﺴﻼﺳﻞ واﻟﺤﺮوف‬
‫‪26‬‬ ‫ﺟﻤﻠﺔ اﻻﺳﺘﻤﺮار )‪(continue‬‬ ‫‪6‬‬ ‫اﻟﻤﺘﻐﯿﺮات‬
‫‪26‬‬ ‫ﺟﻤﻠﺔ ﺧﺮوج )‪(exit‬‬ ‫‪7‬‬ ‫اﻟﺜﻮاﺑﺖ‬
‫‪26‬‬ ‫ﺟﻤﻠﺔ أذھﺐ اﻟﻰ )‪(goto‬‬ ‫‪7‬‬ ‫اﻟﻤﺆﺛﺮات‬
‫‪27‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‬ ‫‪10‬‬ ‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ ‪ :‬اﻟﮭﯿﻜﻠﯿﺔ ﻟﻠﺒﺮاﻣﺞ‬
‫‪28‬‬ ‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ‪ :‬اﻟﻤﺼﻔﻮﻓﺎت‬ ‫‪11‬‬ ‫اﻟﺘﻌﻠﯿﻘﺎت‬
‫‪28‬‬ ‫اﻟﻤﺼﻔﻮﻓﺎت ذات اﻟﺒﻌﺪ اﻟﻮاﺣﺪ‬ ‫‪11‬‬ ‫اﻟﺘﻮﺟﯿﮭﺎت‬
‫‪30‬‬ ‫اﻟﻤﺼﻔﻮﻓﺎت ذات اﻟﺒﻌﺪﯾﻦ‬ ‫‪11‬‬ ‫اﻟﺪاﻟﺔ اﻟﺮﺋﯿﺴﯿﺔ ) (‪main‬‬
‫‪33‬‬ ‫اﻟﻤﺼﻔﻮﻓﺎت اﻟﺤﺮﻓﯿﺔ‬ ‫‪11‬‬ ‫أدﺧﺎل وأﺧﺮاج اﻟﺒﯿﺎﻧﺎت‬
‫‪34‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ‬ ‫‪15‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
‫‪35‬‬ ‫اﻟﻔﺼﻞ اﻟﺴﺎدس ‪ :‬اﻟﺪوال‬ ‫‪16‬‬ ‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ ‪ :‬اﻟﺘﺮاﻛﯿﺐ اﻟﺸﺮﻃﯿﺔ‬
‫‪39‬‬ ‫اﻟﺪوال اﻟﺮﯾﺎﺿﯿﺔ‬ ‫‪16‬‬ ‫اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﺒﺴﯿﻂ )‪(if‬‬
‫‪41‬‬ ‫اﻟﻤﺘﻐﯿﺮات اﻟﺨﺎرﺟﯿﺔ‬ ‫‪17‬‬ ‫اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﻜﺎﻣﻞ )‪(if-else‬‬
‫‪43‬‬ ‫اﻟﺪوال واﻟﻤﺼﻔﻮﻓﺎت‬ ‫‪18‬‬ ‫ﺗﺮﻛﯿﺐ اﻟﻤﺆﺛﺮ اﻟﺸﺮﻃﻲ )?(‬
‫‪44‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺴﺎدس‬ ‫‪18‬‬ ‫اﻟﺘﺮﻛﯿﺐ اﻻﻧﺘﻘﺎﺋﻲ )‪(switch‬‬
‫ﺻﻔﺤﺔ ‪2‬‬ ‫‪University of Baghdad-College of Science- Department of Mathematics‬‬ ‫‪Email : m.albahadeli@yahoo.com‬‬

‫ﺑﺴﻢ ﺍﷲ ﺍﻟﺮﲪﻦ ﺍﻟﺮﺣﻴﻢ‬
‫ﺍﳊﻤﺪ ﷲ ﺭﺏ ﺍﻟﻌﺎﳌﲔ‬
‫واﻟﺼ ﻼة واﻟﺴ ﻼم ﻋﻠ ﻰ ﺳ ﯿﺪ اﻻوﻟ ﯿﻦ واﻻﺧ ﺮﯾﻦ اﺑ ﻮ اﻟﻘﺎﺳ ﻢ ﻣﺤﻤ ﺪ وال ﺑﯿﺘ ﮫ اﻟﻄﯿﺒ ﯿﻦ اﻟﻄ ﺎھﺮﯾﻦ واﺻ ﺤﺎﺑﺔ‬
‫اﻟﻤﻨﺘﺠﺒﯿﻦ ‪.‬‬
‫اﻻھﺪاء‬
‫اﻟﻰ اﻟﻣﻼك اﻟطﺎھر ‪...‬‬
‫ذي اﻟﻘﻠب اﻟﻛﺑﻳر واﻟﻧﻔس اﻟﻠواﻣﺔ اﻟﻣطﻣﺋﻧﺔ ‪...‬‬
‫واﻟذي ﺗﻌﻠق ﺑرﺑﻪ ﻓدﻋﺎه ﺧوﻓﺎً وطﻣﻌﺎً ‪...‬‬
‫وﻣﺎ ھو اﻻ ﻗﺑﺿﺔ ﻣن رﺣﻣﺔ وﻋطف وﺣﻧﺎن ‪...‬‬
‫ﻟﻘد اﻧﻔﺻﻞ ﺟﺳﻣﻲ ﻋن ﺟﺳﻣﻪ ‪...‬‬
‫ﻟﻛن روﺣﻲ ﻟم ﺗزل ﺑروﺣﻪ ﻣﺗﺻﻠﺔ ‪...‬‬
‫وﺑﮫدﻳﻪ وارﺷﺎده ﻋرﻓت ﺟﺎدة اﻟﺻواب ‪...‬‬
‫واﺳﺗﺑﺄﻧت ﺳﺑﻳﻞ اﻟرﺷﺎد ‪...‬‬
‫ﻓرﺿﻰ اﷲ ﻋﻧﻪ وأرﺿﺎه ‪...‬‬
‫اﻟﻰ ﻣن اﺳﺗﻠﮫﻣت ﻣﻧﻪ أﺳﺑﺎب اﻟﺑﻘﺎء ‪...‬‬
‫اﻟﻰ أﻣﻲ ‪ ...‬ﺑﻌد اﺳﺗﺋذان ‪ ...‬أﺑﻲ ‪ ...‬اﻟﻌظﻳم ‪...‬‬
‫ﻣﺣﻣد اﻟﺑﮫﺎدﻟﻲ‬
‫أﺳﺌﻠﻜﻢ اﻟﺪﻋﺎء ﻟﻲ وﻟﻮاﻟﺪي‬

‫ﻣﻘﺪﻣﺔ‪:‬‬
‫أﺻﻞ ﻟﻐﺔ ‪، C‬ھﻲ ﻟﻐﺔ ‪ CPL‬واﻟﺘﻲ اﺷﺘﮭﺮت ﺑﺸﺪة ﺗﻌﻘﯿﺪھﺎ ﻣﻤﺎ ﺗﺴﺒﺐ ﻓﻲ اﺑﺘﻌﺎد اﻟﻤﺒﺮﻣﺠﯿﻦ ﻋﻨﮭﺎ‪،‬ﻓﺘﻢ ﺗﻄﻮﯾﺮھﺎ وﺗﺒﺴﯿﻄﮭﺎ إﻟﻰ ﻟﻐﺔ ﺳﻤﯿﺖ ‪BCPL‬‬
‫واﻟﺘﻲ ﻟﻢ ﺗﻠﻘﻰ اﻟﻜﺜﯿﺮ ﻣﻦ اﻟﻨﺠﺎح وﻟﻜﻨﮭﺎ ﺗﻄﻮرت إﻟﻰ ﻟﻐﺔ ‪، B‬وﺑﻌﺪ ﻓﺘﺮة ﻗﺼ ﯿﺮة ﺗ ﻢ ﺗﻄ ﻮﯾﺮ اﻟﻠﻐ ﺔ ‪ B‬ﻓ ﻲ ﻣﺨﺘﺒ ﺮات ﺑﯿ ﻞ ﻣ ﺎﺑﯿﻦ ﻋ ﺎﻣﻲ ‪1972 – 1969‬‬
‫اﻟﻰ ﻟﻐﺔ ﺑﺮﻣﺠﺔ ﺟﺪﯾﺪة ﺗﻀﻤﻨﺖ ﺗﺤﺪﯾﺜﺎت وﺣﻠﻮل ﻟﻤﻌﻈﻢ اﻟﻤﺸﺎﻛﻞ اﻟﺘﻲ ﻇﮭﺮت ﻟﻠﻤﺒﺮﻣﺠﯿﻦ ﻓﻲ ذﻟﻚ اﻟﻮﻗﺖ ‪،‬ﺳﻤﯿﺖ ھ ﺬه اﻟﻠﻐ ﺔ اﻟﺠﺪﯾ ﺪة ﺑﺄﺳ ﻢ اﻟﻠﻐ ﺔ ‪) C‬و‬
‫ھﺬا ھﻮ أﺻﻞ ﺗﺴﻤﯿﺔ ‪ .(C‬ﻟﻐﺔ ‪ C‬ﺗﻤﺜﻞ اﻟﻠﻐﺔ اﻻم ﻟﻠﻌﺪﯾﺪ ﻣﻦ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ وﻣﻨﮭﺎ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ‪ C++‬واﻟﺠﺎﻓﺎ ‪.‬‬
‫ﻓ ﻲ ﻋ ﺎم ‪ 1978‬ﻗ ﺎم اﻟﻌﺎﻟﻤ ﺎن ﺑ ﺮاﯾﻦ ﻛﺮﻧﯿﻜ ﺎن )‪ (Brian Kernighan‬و دﻧ ﺲ رﺗﺸ ﻲ )‪ (Dennis Ritchie‬ﺑﻨﺸ ﺮ أول ﻛﺘ ﺎب ﯾﺘﻀ ﻤﻦ اﻟﻠﻐ ﺔ ‪C‬‬
‫ﺑﺼ ﻮرة ﻣﻔﺼ ﻠﮫ ﺗﺤ ﺖ ﻋﻨ ﻮان )‪ ،(The C Programming Language‬ﺣﯿ ﺚ أﺻ ﺒﺢ ھ ﺬا اﻟﻜﺘ ﺎب اﻟﻤﺮﺟ ﻊ اﻻﺳﺎﺳ ﻲ ﻓ ﻲ اﻟﻠﻐ ﺔ ‪ C‬ﺣﺘ ﻰ ﯾﻮﻣﻨ ﺎ‬
‫ھﺬا‪.‬واﻟﻠﻐﺔ ‪ C‬ﻗﺪ ﺻﻤﻤﺖ ﻓﻲ اﻷﺻﻞ ﻟﺘﺴﺘﻌﻤﻞ ﻓﻲ ﺗﻄﻮﯾﺮ و اﻟﻌﻤﻞ ﺗﺤﺖ ﻧﻈﺎم اﻟﺘﺸﻐﯿﻞ ﯾﻮﻧﻜﺲ‪ ،‬ﺛﻢ ﻟﻘﯿﺖ اﻧﺘﺸﺎرا واﺳﻌﺎ ﻣﻨﺬ ذﻟ ﻚ اﻟﺤ ﯿﻦ و ﺗﻮاﺻ ﻞ إﻟ ﻰ‬
‫اﻟﯿﻮم وﯾﻈﮭﺮ ذﻟﻚ ﻣﻦ ﺧﻼل ﺷﻌﺒﯿﺘﮭﺎ ﻟﺪى أﻏﻠﺐ ﻣﺒﺮﻣﺠﻲ اﻟﺤﺎﺳﻮب و ﻣﻦ ﺧﻼل اﻻﺳﺘﻌﻤﺎﻻت اﻟﻌﺪﯾﺪة واﻟﻤﺘﻨﻮﻋﺔ‪.‬‬
‫اﻟﻔﺼﻞ اﻷول‪ :‬أﺳﺎﺳﯿﺎت ‪( Fundamentals of C) C‬‬

‫ﺗُﺴﺘﺨﺪم ﻓﻲ ﻟﻐﺔ ‪ C‬ﻛﻤﺎ ھﻮ اﻟﺤﺎل ﻓﻲ أي ﻟﻐﺔ ﺑﺮﻣﺠﺔ أﺧﺮى ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﺳﺎﺳﯿﺎت اﻟﺘﻲ ﯾﺠﺐ اﻟﺘﻌﺮف ﻋﻠﯿﮭﺎ ﻋﻨﺪ دراﺳﺔ أي ﻟﻐﺔ ﺑﺮﻣﺠﺔ‪ ،‬وھ ﺬه‬
‫اﻷﺳﺎﺳﯿﺎت ھﻲ ‪:‬‬
‫)‪ (1.1‬اﻟﺮﻣﻮز)‪(Characters‬‬
‫وﺗﺘﺄﻟﻒ ﻣﻦ ‪-:‬‬
‫‪ (a‬اﻷرﻗﺎم)‪ (digits‬وھﻲ ‪9,8,7,6,5,4,3,2,1,0‬‬
‫‪ (b‬اﻟﺤﺮوف اﻟﮭﺠﺎﺋﯿﺔ)‪ (letters‬وھﻲ اﻟﺤﺮوف اﻟﻜﺒﯿﺮة ‪ A,B,C,…,X,Y,Z‬واﻟﺤﺮوف اﻟﺼﻐﯿﺮة ‪a,b,c,…,x,y,z‬‬
‫‪ (c‬اﻟﺮﻣﻮز اﻟﺨﺎﺻﺔ)‪ (special characters‬وھﻲ‬
‫‪+‬‬ ‫‪-‬‬ ‫*‬ ‫‪/‬‬ ‫‪.‬‬ ‫)‬ ‫(‬ ‫‪:‬‬ ‫‪$‬‬ ‫‪#‬‬ ‫;‬ ‫‪,‬‬ ‫=‬ ‫<‬ ‫>‬ ‫} ‪%‬‬ ‫{‬ ‫!‬ ‫"‬ ‫'‬
‫)‪ (1.2‬اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة ) ‪(Reserved words‬‬

‫وھﻲ ﻛﻠﻤﺎت ﻣﻮﺟﻮدة ﻓﻲ اﻟﻤﻜﺘﺒﺔ اﻟﻘﯿﺎﺳﯿﺔ ﻟﻠﻐﺔ ‪ C‬ﺗﺴﺘﻌﻤﻞ أﺳﻤﺎء‪ ،‬وﻟﮭﺎ وﻇﯿﻔﺔ ﻣﻌﯿﻨﺔ‪،‬وﻻﯾﻤﻜﻦ اﺳﺘﻌﻤﺎﻟﮭﺎ ﻟﻐﯿﺮ ﻣﺎ وﻇﻔﺖ ﺑﮫ ﻻن ذﻟﻚ ﺳﻮف ﯾﺤﺪث‬
‫ﺑﺴﺒﺒﮭﺎ أرﺑﺎك ﻟﻠﻤﺘﺮﺟﻢ )‪ .(Compiler‬وﻣﻦ ھﺬه اﻟﻜﻠﻤﺎت ھﻲ ‪:‬‬
‫‪auto‬‬ ‫‪break‬‬ ‫‪case‬‬ ‫‪catch‬‬ ‫‪char‬‬ ‫‪class‬‬ ‫‪const‬‬ ‫‪continue‬‬ ‫‪default‬‬ ‫‪delete‬‬
‫‪do‬‬ ‫‪double‬‬ ‫‪else‬‬ ‫‪enum‬‬ ‫‪extern‬‬ ‫‪false‬‬ ‫‪float‬‬ ‫‪for‬‬ ‫‪goto‬‬ ‫‪if‬‬
‫‪int‬‬ ‫‪long‬‬ ‫‪return‬‬ ‫‪short‬‬ ‫‪signed‬‬ ‫‪sizeof‬‬ ‫‪struct‬‬ ‫‪switch‬‬ ‫‪true‬‬ ‫‪typedef‬‬
‫‪typename‬‬ ‫‪union‬‬ ‫‪unsigned‬‬ ‫‪using‬‬ ‫‪void‬‬ ‫‪while‬‬ ‫‪and‬‬ ‫‪or‬‬
‫)‪ (1.3‬اﻟﻤﻌّﺮﻓﺎت )‪(Identifiers‬‬

‫اﻟﻤﻌّﺮف ھﻮ ذﻟﻚ اﻻﺳﻢ اﻟﺬي ﯾﺨﺰن ﺑﮫ ﻗﯿﻢ ﻣﺜﻞ اﻟﺜﺎﺑﺖ أو اﻟﻤﺘﻐﯿﺮ أو اﻟﺪاﻟﺔ ‪ ،‬وﻣﻦ ﺷﺮوط اﻟﻤﻌّﺮف ھﻲ ‪:‬‬
‫‪ .a‬أن ﯾﺘﻜﻮن ﻣﻦ ﺣﺮف أو ﺣﺮوف أو ﺣﺮوف وأرﻗﺎم‪.‬‬
‫‪ .b‬ﺧﺎﻟﻲ ﻣﻦ أي رﻣﺰ ﺧﺎص ﻣﺎﻋﺪا اﻟﺮﻣﺰ) _ ( ‪. under score‬‬
‫‪ .c‬أن ﯾﺒﺪأ داﺋﻤﺎً ﺑﺤﺮف أو اﻟﺮﻣﺰ ) _ (‪.‬‬
‫‪ .d‬ﯾﺴﻤﺢ ﺑﺎﺳﺘﺨﺪام اﻟﺤﺮوف اﻟﺼﻐﯿﺮة واﻟﺤﺮوف اﻟﻜﺒﯿﺮة ‪.‬‬
‫‪ .e‬أن ﯾﻜﻮن ﻟﮫ اﻟﻄﻮل اﻟﻤﻨﺎﺳﺐ و واﺿﺤﺎً وذا ﻣﻌﻨﻰ وﻣﺪﻟﻮل ‪.‬‬

‫‪x12, student_name, degree, AVARAGE, ToTaL, sum‬‬ ‫ﻣﺜﺎل‪ :‬ﻣﻌّﺮﻓﺎت ﻣﻘﺒﻮﻟﺔ‬

‫ﻣﺜﺎل‪ -:‬ﻣﻌّﺮﻓﺎت ﻏﯿﺮ ﻣﻘﺒﻮﻟﺔ‬
‫ﯾﺒﺪأ ﺑﺮﻗﻢ ‪7UP .......................‬‬
‫ﯾﺒﺪأ ﺑﺎﻟﺮﻣﺰ اﻟﺨﺎص ‪$cost .......... $‬‬
‫ﯾﻤﺜﻞ ﻛﻠﻤﺔ ﻣﺤﺠﻮزة ‪return .............‬‬
‫ﻣﺴﺘﺨﺪم ﻓﺮاﻏﺎً‪LG NAME ..................‬‬
‫)‪ (1.4‬اﻷﻋﺪاد )‪(Numbers‬‬

‫اﻷﻋﺪاد ﻓﻲ ﻟﻐﺔ ‪ C‬ھﻲ ‪:‬‬
‫‪28‬‬ ‫‪-56‬‬ ‫‪0‬‬ ‫‪5476‬‬ ‫‪-927‬‬ ‫‪ .a‬اﻻﻋﺪاد اﻟﺼﺤﯿﺤﺔ ‪ -:‬وھﻲ اﻻﻋﺪاد اﻟﺨﺎﻟﯿﺔ ﻣﻦ اﻟﻔﺎﺻﻠﺔ اﻟﻌﺸﺮﯾﺔ‪ ،‬ﻣﺜﺎل‬
‫‪16.315‬‬ ‫‪-0.67‬‬ ‫‪31.67‬‬ ‫‪0.0‬‬ ‫‪-326.5877‬‬ ‫‪ .b‬اﻻﻋﺪاد اﻟﺤﻘﯿﻘﯿﺔ ‪ -:‬وھﻲ اﻻﻋﺪاد اﻟﺘﻲ ﺗﺘﻀﻤﻦ ﻓﺎﺻﻠﺔ ﻋﺸﺮﯾﺔ ‪ ،‬ﻣﺜﺎل‬
‫‪ .c‬اﻻﻋﺪاد اﻟﺤﻘﯿﻘﯿﺔ ذات اﻟﺪﻗﺔ اﻟﻤﻀﺎﻋﻔﺔ ‪ -:‬وھﻲ اﻻﻋﺪاد اﻟﺤﻘﯿﻘﯿﺔ اﻟﻤﻤﺜﻠﺔ ﺑﺸﻜﻞ ﻗﻮة آﺳ ﯿﺔ ﺑﺎﺳ ﺘﺨﺪام اﻟﺤ ﺮف )‪ (e‬أو اﻟﺤ ﺮف )‪ (E‬ﺣﯿ ﺚ ﯾ ﺪل‬
‫اﻟﺤﺮف ‪ e‬أو ‪ E‬ﻋﻠﻰ اﻟﻘﻮة‪ .‬ﻣﺜﺎل ‪12.3e-5 72e-65 1.23e2 99.432E-8 0.22E9‬‬
‫)‪ (1.5‬اﻟﺴﻼﺳﻞ واﻟﺤﺮوف )‪(Strings and Characters‬‬
‫اﻟﺴﻠﺴﻠﺔ‪ -:‬وھﻲ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺤﺮوف أو اﻷرﻗﺎم أو اﻟﺮﻣﻮز اﻟﺨﺎﺻﺔ‪ ،‬ﺑﺸﺮط أن ﺗﻜﻮن ﻣﻮﺿﻮﻋﺔ ﺑﯿﻦ ﻋﻼﻣﺘﻲ اﻟﺘﻨﺼﯿﺺ اﻟﻤﺰدوﺟﺔ)" "(‪.‬‬
‫ﻣﺜﺎل‪"This is a sentence." , "Go to room" , "NAME:" , "56&4787" -:‬‬

‫اﻟﺤﺮف‪ -:‬وھﻮ ﺣﺮف أو رﻣﺰ أو رﻗﻢ ﻣﻮﺿﻮع ﺑﯿﻦ ﻋﻼﻣﺘﻲ اﻟﺘﻨﺼﯿﺺ اﻟﻤﻔﺮدة )' '(‪.‬‬
‫ﻣﺜﺎل‪'+' , 'A' , 'a' , '*' , '7' -:‬‬
‫)‪ (1.6‬اﻟﻤﺘﻐﯿﺮات )‪(Variables‬‬

‫وھﻲ أﺳﻤﺎء رﻣﺰﯾﺔ ﯾﺨﺼﺺ ﻟﮭﺎ أﻣﺎﻛﻦ ﺗﺨﺰﯾﻦ ﻓﻲ ذاﻛﺮة اﻟﺤﺎﺳﺐ‪ ،‬واﻟﺘﻲ ﺗﺘﻐﯿﺮ ﻗﯿﻤﺘﮭﺎ ﻣﻦ ﻗﯿﻤﺔ اﻟﻰ أﺧﺮى‪،‬وﯾﻤﻜﻦ اﻟﺮﺟﻮع إﻟﯿﮭﺎ ﻋﻦ ﻃﺮﯾ ﻖ ھ ﺬه‬
‫اﻷﺳﻤﺎء أﺛﻨﺎء ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﻓﻲ ﻟﻐﺔ ‪ C‬ﯾﺠﺐ أن ﯾﻌﻠﻦ ﻋﻦ اﻟﻤﺘﻐﯿﺮات ﻣﺴﺒﻘﺎً)أي ﻗﺒﻞ ﺗﺨﺼﯿﺺ ﻗﯿﻤﺔ ﻟﮭﺎ(‪ ،‬وﻻ ﻓﻠﻦ ﯾﺘﻌﺮف ﻟﮭﺎ ﻣﺘﺮﺟﻢ اﻟﻠﻐﺔ)‪.(Complier‬‬
‫وﻟﻐﺮض اﻻﻋﻼن ﻋﻦ اﻟﻤﺘﻐﯿﺮات ﻧﺴﺘﺨﺪم اﻟﺼﯿﻐﺔ اﻵﺗﯿﺔ ‪:‬‬
‫; ‪T y p e V a ri a b l e _ N a m e‬‬
‫‪ :Variable_Name‬ﯾﻤﺜﻞ اﺳﻢ اﻟﻤﺘﻐﯿﺮ‪ ،‬واﻟﺬي ﯾﺨﻀﻊ اﻟﻰ اﻟﺸﺮوط اﻟﺘﺎﻟﯿﺔ ‪:‬‬ ‫ﺣﯿﺚ‬
‫أن ﯾﺘﻜﻮن ﻣﻦ ﺣﺮف أو ﺣﺮوف أو ﺣﺮوف وأرﻗﺎم ‪.‬‬ ‫‪.a‬‬

‫ﺧﺎﻟﻲ ﻣﻦ أي رﻣﺰ ﺧﺎص ﻣﺎﻋﺪا اﻟﺮﻣﺰ) _ ( ‪. under score‬‬ ‫‪.b‬‬
‫أن ﯾﺒﺪأ داﺋﻤﺎً ﺑﺤﺮف أو اﻟﺮﻣﺰ ) _ (‪.‬‬ ‫‪.c‬‬
‫ﯾﺴﻤﺢ ﺑﺎﺳﺘﺨﺪام اﻟﺤﺮوف اﻟﺼﻐﯿﺮة واﻟﺤﺮوف اﻟﻜﺒﯿﺮة ﻣﻊ اﻻﻧﺘﺒﺎه اﻟﻰ أن ﻟﻐﺔ ‪ C‬ﺗﻤﯿﺰ ﺑﯿﻦ اﻻﺣﺮف اﻟﻜﺒﯿﺮة واﻟﺼﻐﯿﺮة ‪.‬‬ ‫‪.d‬‬
‫أن ﯾﻜﻮن ﻟﮫ اﻟﻄﻮل اﻟﻤﻨﺎﺳﺐ ‪،‬ﺣﯿﺚ أن اﻗﺼﻰ ﻃﻮل ﯾﻤﻜﻦ أﺧﺘﯿﺎرة ﻷﺳﻢ ﻣﺘﻐﯿﺮ ھﻮ ‪ 32‬ﺣﺮف أو رﻗﻢ‪.‬‬ ‫‪.e‬‬
‫واﺿﺤﺎً وذا ﻣﻌﻨﻰ وﻣﺪﻟﻮل ) أي ﯾﻔﻀﻞ أﺧﺘﯿﺎر اﺳﻢ اﻟﻤﺘﻐﯿﺮ ﺗﺒﻌ ﺎً ﻟﻠﺒﯿﺎﻧ ﺎت اﻟﺘ ﻲ ﯾﺤﻤﻠﮭ ﺎ ‪ ،‬ﻓﻤ ﺜﻼً ﻧﺨﺘ ﺎر أﺳ ﻢ اﻟﻤﺘﻐﯿ ﺮ ‪ age‬ﻟﻠﻌﻤ ﺮ أو ‪degree‬‬ ‫‪.f‬‬
‫ﻟﻠﺪرﺟﺔ أو ‪ average‬ﻟﻠﻤﻌﺪل‪،‬ھﻜﺬا‪.(...‬‬
‫‪ :Type‬ﯾﻤﺜﻞ ﻧﻮع اﻟﻤﺘﻐﯿﺮ‪ ،‬أي ﻧﻮع اﻟﻘﯿﻤﺔ اﻟﺘﻲ ﯾﺤﻤﻠﮭﺎ ذﻟﻚ اﻟﻤﺘﻐﯿﺮ‪ ،‬وﯾﻤﻜﻦ ان ﯾﻜﻮن اﺣﺪ اﻷﻧﻮاع اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺠﺪول اﻷﺗﻲ‪:‬‬

Introduction to C Programming Language C ‫ﻣﻘﺪﻣﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺑﻠﻐﺔ‬
‫اﻟﻨﻮع‬ ‫اﻟﻮﺻﻒ‬ ‫اﻟﺤﺠﻢ‬ ‫اﻟﻤﺪى‬
short int -32768 to 32767

Short Integer 2bytes
short
unsigned short int

Short Integer 2bytes 0 to 65535
unsigned short
‫ﯾﻌﺘﻤﺪ ﻋﻠﻰ اﻟﻨﻈﺎم‬

2bytes -32768 to 32767
int Integer Or or
4bytes -2147483648 to 2147483647
unsigned int Integer 4bytes 0 to 4294967295
long int -2147483648 to 2147483647

Long integer 4bytes
long
unsigned long int

Long integer 4bytes 0 to 4294967295
unsigned long
bool Boolean value: true or false 1byte true or false
3.4e- 38 to 3.4e+38
float Floating point number 4bytes
(7 digits)
1.7e- 308 to 1.7e+308

double Double precision floating point number 8bytes
(15 digits)
1.2e- 4932 to 1.2e+4932

long double Long double precision floating point number 10bytes
(19 digits)
-128 to 127
char Character 1byte
unsigned char Character 1byte 0 to 255
: (1.6.1) ‫ﻣﺜﺎل‬
Example 1 Example 2 Example 3

int x ; float mynumber ; char m ;
float a ; double cost ; short int n ;
: ‫ وﻛﻤﺎ ﯾﻠﻲ‬،‫ ﯾﻤﻜﻦ اﻻﻋﻼن ﻋﻦ أﻛﺜﺮ ﻣﻦ ﻣﺘﻐﯿﺮ ﻟﻨﻔﺲ اﻟﻨﻮع ﺑﺴﻄﺮ واﺣﺪ‬-:(1.6.2)‫ﻣﻼﺣﻈﺔ‬
Type Variable_Name1, Varible_Name2, Variable_Name3,……;
6 ‫ﺻﻔﺤﺔ‬ University of Baghdad-College of Science- Department of Mathematics Email : m.albahadeli@yahoo.com

‫‪Example‬‬
‫; ‪int a,b‬‬
‫; ‪float x,y,z‬‬
‫ﻣﻼﺣﻈﺔ)‪ -:(1.6.3‬ﻣﻦ اﻟﻤﻤﻜﻦ أﻋﻄﺎء ﻗﯿﻤﺔ ﻟﻠﻤﺘﻐﯿﺮ أﺛﻨﺎء اﻻﻋﻼن ﻋﻦ ذﻟﻚ اﻟﻤﺘﻐﯿﺮ‪،‬وﻛﻤﺎ ﯾﻠﻲ ‪:‬‬
‫; ‪Type Variable_Name=Varible_Value‬‬
‫‪Example 1‬‬ ‫‪Example 2‬‬ ‫‪Example 3‬‬

‫; ‪int x = 168‬‬ ‫; ‪float mynumber = 5.78‬‬ ‫;' ‪char m = ' T‬‬
‫; ‪float a=b= -78.2‬‬ ‫; ‪float sum= 0.0‬‬
‫ﻣﻼﺣﻈﺔ)‪ -:(1.6.4‬أﻧﺸﺎء اﷲ ﺳﻮف ﻧﺘﻄﺮق ﺑﺼﻮرة ﻣﻔﺼﻠﺔ ﻟﻌﻤﻠﯿﺎت أدﺧﺎل اﻟﻘﯿﻢ ﻟﻠﻤﺘﻐﯿﺮات ﻓﻲ اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ ﻓﻲ ﻣﻮﺿﻮع اﻻدﺧﺎل واﻻﺧﺮاج‪.‬‬
‫)‪ (1.7‬اﻟﺜﻮاﺑﺖ )‪(Constants‬‬

‫ﺗﺴﺘﺨﺪم اﻟﺜﻮاﺑﺖ ﻓﻲ ﻟﻐﺔ ‪ C‬ﺣﯿﺚ ﯾﺪل اﻟﺜﺎﺑﺖ ﻋﻠﻰ ﻗﯿﻤﺔ ﻻ ﯾﻤﻜﻦ ﺗﻐﯿﯿﺮھﺎ اﺛﻨﺎء اﻟﺒﺮﻧﺎﻣﺞ ‪.‬واﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺜﺎﺑﺖ ھﻲ‪:‬‬
‫; ‪const Type constant_name=constant_value‬‬

‫ﺣﯿﺚ أن ‪ : Type‬ﯾﻤﺜﻞ ﻧﻮع ﻗﯿﻤﺔ اﻟﺜﺎﺑﺖ‪.‬‬
‫‪ :constant_name‬ﯾﻤﺜﻞ اﺳﻢ اﻟﺜﺎﺑﺖ‪.‬‬
‫‪ : constant_value‬ﺗﻤﺜﻞ ﻗﯿﻤﺔ اﻟﺜﺎﺑﺖ‪.‬‬
‫‪Examples‬‬
‫; ‪const int pathwidth= 100‬‬
‫; '‪const char tabulator= '\t‬‬
‫;"‪const char ch= "C Good Lang.‬‬
‫; ‪const double PI= 3.14159265‬‬
‫)‪ (1.8‬اﻟﻤﺆﺛﺮات)‪(Operators‬‬
‫ﯾﻮﺟﺪ ﻓﻲ ﻟﻐﺔ ‪ C‬ﻋﺪد ﻣﻦ اﻟﻤﺆﺛﺮات ‪،‬وھﻲ ﻛﺎﻻﺗﻲ‪-:‬‬
‫‪ (a‬اﻟﻤﺆﺛﺮات اﻟﺤﺴﺎﺑﯿﺔ)‪ :(Arithmetic Operators‬وھﻲ‬
‫اﻟﻤﺆﺛﺮ‬ ‫ﻣﻌﻨﺎه‬ ‫ﻣﺜﺎل‬
‫‪+‬‬ ‫‪addition‬‬ ‫‪a+b‬‬
‫‪-‬‬ ‫‪subtraction‬‬ ‫‪a-b‬‬
‫*‬ ‫‪multiplication‬‬ ‫‪a*b‬‬
‫‪/‬‬ ‫‪division‬‬ ‫‪a/b‬‬
‫‪%‬‬ ‫‪modulo‬‬ ‫‪a%b‬‬
‫ﻣﻼﺣﻈﺔ)‪ -: (1.8.1‬ﯾﺠﺐ أن ﻧﺎﺧﺬ ﺑﻌﯿﻦ اﻻﻋﺘﺒﺎر ﺑﺎﻟﻨﺴﺒﺔ ﻟﻤﺆﺛﺮ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ) ‪ ( %‬ﯾﺠ ﺐ أن ﺗﻜ ﻮن ﻋﻨﺎﺻ ﺮ اﻟﺒﯿﺎﻧ ﺎت اﻟﻤﺴ ﺘﻌﻤﻠﺔ ﻗ ﯿﻢ ﺻ ﺤﯿﺤﺔ واﻻ‬
‫ﻓﺎن اﻟﻨﺘﯿﺠﺔ ﺗﻜﻮن ﺧﺎﻃﺌﺔ‪.‬‬
‫‪، a%b=2‬‬ ‫ﻣﺜﺎل ‪ -:‬اذا ﻛﺎن ‪ a=11‬و ‪ b=3‬ﻓﺎن‬
‫اﻣﺎ اذا ﻛﺎن ‪ a‬أو ‪ b‬أو ﻛﻼھﻤﺎ ﻋﺪداً ﺣﻘﯿﻘﯿﺎً‪ ،‬ﻓﺎن ﻋﻤﻠﯿﺔ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ﻻ ﯾﻤﻜﻦ ﺗﻄﺒﯿﻘﮭﺎ ‪،‬ﻻن اﻟﻨﺘﯿﺠﺔ ﺗﻜﻮن ﺧﺎﻃﺌﺔ ‪.‬‬
‫ وھ ﻲ ﺳ ﺖ ﻣ ﺆﺛﺮات ﺗﺴ ﺘﺨﺪم ﻋﻠ ﻰ أي زوج ﻣ ﻦ اﻟﻌﻨﺎﺻ ﺮ وﯾﻜ ﻮن ﻧﺎﺗﺠﮭ ﺎ اﻣ ﺎ‬:(Relational Operators)‫( اﻟﻤ ﺆﺛﺮات اﻟﻌﻼﺋﻘﯿ ﺔ‬b
:‫( وھﻲ ﻛﻤﺎ ﯾﻠﻲ‬0 ‫)ﻗﯿﻤﺔ‬False ً‫( أو ﺧﻄﺌﺎ‬0 ‫ )أي ﻗﯿﻤﺔ ﻣﺎ ﻋﺪا‬True ً‫ﺻﺤﯿﺤﺎ‬
‫اﻟﻤﺆﺛﺮ‬ ‫ﻣﻌﻨﺎه‬ ‫ﻣﺜﺎل‬ ‫اﻟﻨﺘﯿﺠﺔ‬
== Equal to 7= =5 False ( 0 )
!= Not equal to 3!=2 True ( 1 )
< Less than 4>9 True ( 1 )
Less than or 7< =6 False ( 0 )

<=
equal to
> Greater than -2>4 False ( 0 )
Greater than or 12> =10 True ( 1 )

>=
equal to
FALSE ‫( أو ﻗﯿﻤ ﺔ ﺧﻄ ﺄ‬1 ‫ )اﻟﻌ ﺪد‬TRUE ‫ وھﻲ ﻣﺆﺛﺮات ﯾﻨﺘﺞ ﻋﻨﮭﺎ اﻣﺎ ﻗﯿﻤﺔ ﺻﺤﯿﺢ‬:(Logical operators)‫( اﻟﻤﺆﺛﺮات اﻟﻤﻨﻄﻘﯿﺔ‬c
. (1 ‫) أي ﻗﯿﻤﺔ ﻣﺎ ﻋﺪا‬
a b a && b a||b !a
‫اﻟﻤﺆﺛﺮ‬ ‫ﻣﻌﻨﺎه‬
True True True True False
&& And
True False False True
|| Or
False True False True True
! negating or anti-thesis
False False False False
‫ وھﻲ‬:(Bitwise Operators)‫( اﻟﻤﺆﺛﺮات اﻟﺨﺎﺻﺔ ﺑﺎﻟﺒﺖ‬d
‫اﻟﻤﺆﺛﺮ‬ ‫اﻟﻤﻜﺎﻓﻰ اﻟﻰ‬ ‫ﻣﻌﻨﺎه‬
& AND Bitwise AND
| OR Bitwise Inclusive OR
^ XOR Bitwise Exclusive OR
~ NOT Unary complement (bit inversion)
<< SHL Shift Left
>> SHR Shift Right
‫ وھ ﻲ اﺳ ﺘﺨﺪام اﻟﻤ ﺆﺛﺮات اﻟﺤﺴ ﺎﺑﯿﺔ واﻟﻤ ﺆﺛﺮات اﻟﺨﺎﺻ ﺔ‬C ‫ ھﻨﺎك ﻣﯿﺰة ﻓ ﻲ ﻟﻐ ﺔ‬:(Compound Operators)‫( اﻟﻤﺆﺛﺮات اﻟﻤﺮﻛﺒﺔ‬e
: ‫ واﻟﻤ ﺆﺛﺮات اﻟﻤﺮﻛﺒ ﺔ ھ ﻲ‬. ‫ وھﻲ ﻃﺮﯾﻘﺔ ﻣﺨﺘﺼﺮة ﻟﺠﻠ ﺔ اﻟﺘﺨﺼ ﯿﺺ‬،‫ﺑﺎﻟﺒﺖ ﻣﻊ اﺷﺎرة اﻟﺘﺨﺼﯿﺺ )=( ﺗﺤﺖ اﺳﻢ اﻟﻤﺆﺛﺮات اﻟﻤﺮﻛﺒﺔ‬
. += , -= , *= , /= , %= , &= , <<= , >>

‫ﻓﻤﺜﻼً اﻟﺘﻌﺒﯿﺮ ‪ x=x+9‬ﺗﻌﻨﻲ اﺿﻒ اﻟﻘﯿﻤﺔ ‪ 9‬ﻟﻠﻤﺘﻐﯿﺮ اﻟﻘﺪﯾﻢ ‪ x‬اﻟﻤﻮﺟ ﻮد ﻓ ﻲ اﻟﻄ ﺮف اﻻﯾﻤ ﻦ‪ ،‬ﺛ ﻢ ﺧﺼ ﺺ ھ ﺬه اﻟﻘﯿﻤ ﺔ اﻟﺠﺪﯾ ﺪة ﻟﻠﻤﺘﻐﯿ ﺮ‬
‫اﻟﺠﺪﯾﺪ اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﻄﺮف اﻻﯾﺴﺮ وھﻮ ‪. x‬‬
‫‪. x+=9‬‬ ‫وﻋﻠﻰ ھﺬا ﯾﻤﻜﻦ اﺳﺘﺨﺪام اﻟﺘﻌﺒﯿﺮ اﻟﺴﺎﺑﻖ ﺑﻄﺮﯾﻘﺔ اﻟﻤﺆﺛﺮ اﻟﻤﺮﻛﺐ =‪ +‬وﻛﻤﺎ ﯾﻠﻲ ‪:‬‬
‫ﺟﻤﻠﺔ اﻟﺘﺨﺼﯿﺺ ﺑﺎﺳﺘﺨﺪام‬

‫ﺟﻤﻠﺔ اﻟﺘﺨﺼﯿﺺ‬
‫اﻟﻤﺆﺛﺮ اﻟﻤﺮﻛﺐ‬
‫;‪value = value + increase‬‬ ‫;‪value += increase‬‬
‫;‪a = a - 5‬‬ ‫;‪a -= 5‬‬
‫;‪a = a / b‬‬ ‫;‪a /= b‬‬
‫;)‪price = price * (units + 1‬‬ ‫;‪price *= units + 1‬‬
‫‪ (f‬ﻣ ﺆﺛﺮات اﻟﺰﯾ ﺎدة واﻟﻨﻘﺼ ﺎن)‪ (Increment Decrement Operators‬ھﻨ ﺎك ﻣﯿ ﺰة ﻓ ﻲ ﻟﻐ ﺔ ‪ C‬ﻗ ﺪ ﻻ ﻧﺠ ﺪھﺎ ﻓ ﻲ ﺑﻌ ﺾ ﻟﻐ ﺎت‬
‫اﻟﺒﺮﻣﺠﺔ اﻻﺧﺮى وھﻲ‪ ،‬ﻣﺆﺛﺮ اﻟﺰﯾﺎدة)‪ (++‬وﻣﺆﺛﺮ اﻟﻨﻘﺼﺎن)‪ (--‬ﺣﯿﺚ ﯾﻤﻜﻦ اﺳﺘﻌﻤﺎﻟﮭﻤﺎ ﻣﻊ اﻟﻤﺘﻐﯿﺮات ﻓﻘﻂ‪.‬‬
‫ﻣﺆﺛﺮ اﻟﺰﯾﺎدة)‪ :(++‬اﻟﺘﻌﺒﯿﺮ ‪ a++‬ﯾﻌﻨﻲ اﺳﺘﺨﺪم اﻟﻘﯿﻤﺔ اﻟﺤﺎﻟﯿﺔ ﻟﻠﻤﺘﻐﯿﺮ ‪ a‬ﻓﻲ ﺣﺴﺎب اﻟﺘﺨﺼﯿﺺ ‪ ،‬ﺛﻢ أﺿ ﻒ اﻟﻘﯿﻤ ﺔ ‪ 1‬اﻟ ﻰ اﻟﻤﺘﻐﯿ ﺮ ‪. a‬‬
‫اﻣﺎ اﻟﺘﻌﺒﯿﺮ ‪ ++a‬ﺑﻌﻨﻲ أﺿﻒ اﻟﻘﯿﻤﺔ ‪ 1‬اﻟﻰ اﻟﻤﺘﻐﯿﺮ ‪ ،a‬ﺛﻢ اﺳﺘﺨﺪم اﻟﻘﯿﻤﺔ اﻟﺠﺪﯾﺪة ﻟﻠﻤﺘﻐﯿﺮ ‪ a‬ﻓﻲ ﺣﺴﺎب اﻟﺘﺨﺼﯿﺺ‪.‬‬
‫ﻣﺆﺛﺮ اﻟﻨﻘﺼﺎن)‪:(--‬اﻟﺘﻌﺒﯿﺮ ‪ a--‬ﯾﻌﻨﻲ اﺳﺘﺨﺪم اﻟﻘﯿﻤﺔ اﻟﺤﺎﻟﯿﺔ ﻟﻠﻤﺘﻐﯿﺮ ‪ a‬ﻓﻲ ﺣﺴ ﺎب اﻟﺘﺨﺼ ﯿﺺ ‪ ،‬ﺛ ﻢ أﻧﻘ ﺺ اﻟﻘﯿﻤ ﺔ ‪ 1‬ﻣ ﻦ اﻟﻤﺘﻐﯿ ﺮ ‪. a‬‬
‫اﻣﺎ اﻟﺘﻌﺒﯿﺮ ‪ --a‬ﯾﻌﻨﻲ أﻧﻘﺺ اﻟﻘﯿﻤﺔ ‪ 1‬ﻣﻦ اﻟﻤﺘﻐﯿﺮ ‪ ،a‬ﺛﻢ اﺳﺘﺨﺪم اﻟﻘﯿﻤﺔ اﻟﺠﺪﯾﺪة ﻟﻠﻤﺘﻐﯿﺮ ‪ a‬ﻓﻲ ﺣﺴﺎب اﻟﺘﺨﺼﯿﺺ‪.‬‬
‫‪Example 1‬‬ ‫‪Example 2‬‬ ‫‪Example 3‬‬ ‫‪Example 4‬‬
‫;‪A=3‬‬ ‫;‪A=3‬‬ ‫;‪B=C=3‬‬ ‫;‪B=C=3‬‬

‫;‪B=++A‬‬ ‫;‪B=A++‬‬ ‫;)‪A=(++B+C++‬‬ ‫;)‪A=(B--+C--‬‬
‫‪/* B contains 4‬‬ ‫‪/* B contains 3‬‬ ‫‪/* B contains 4,C contains 3 /*B contains 3,C contains 3‬‬
‫‪A contains 4 */‬‬ ‫‪A contains 4 */‬‬ ‫‪A contains 7 */‬‬ ‫‪A contains 6 */‬‬
‫‪ (g‬ﻣﺆﺛﺮ اﻟﻔﺎﺻﻠﺔ ) ‪ : (The Comma Operator) ( ,‬أذا ﻛﺎن ﻟﺪﯾﻨﺎ أﻛﺜﺮ ﻣﻦ ﺗﻌﺒﯿﺮ ﻣﻔﺼﻮﻟﺔ ﻋﻦ ﺑﻌﻀﮭﺎ ﺑﻔﺎﺻﻠﺔ ﻓﺄن اﻟﻘﯿﻤﺔ اﻟﻨﮭﺎﺋﯿﺔ‬
‫ﺗﺤﺴﺐ ﻣﻦ اﻟﯿﺴﺎر اﻟﻰ اﻟﯿﻤﯿﻦ‪ ،‬وﻧﻮﻋﮭﺎ ھﻮ ﻧﻮع اﻟﺘﻌﺒﯿﺮ ﺑﺎﻟﻄﺮف اﻻﯾﻤﻦ‪.‬‬
‫; ‪expression_1, expression_1, … , expression_1‬‬ ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬
‫ﻣﺜﺎل )‪-:(1.8.2‬‬
‫;‪a=2‬‬
‫;)‪b= (a+=4, 12/a‬‬
‫ﻧﻼﺣﻆ أن اﻟﺘﻨﻔﯿﺬ ﻓﻲ اﻟﻤﺜﺎل اﻋﻼه ﯾﺘﻢ ﻛﺎﻻﺗﻲ ‪ :‬ﺗﻌﻄﻰ اﻟﻘﯿﻤﺔ ‪ 2‬ﻟﻠﻤﺘﻐﯿ ﺮ ‪ ،a‬ﺛ ﻢ ﯾُﻨﻔ ﺬ ﻣ ﺆﺛﺮ اﻟﻔﺎﺻ ﻠﺔ ﺣﯿ ﺚ ﯾُﻨﻔ ﺬ اﻟﺘﻌﺒﯿ ﺮ اﻷول ‪ a+=4‬واﻟ ﺬي‬
‫ﺗﻨﺘﺞ ﻋﻨﺔ اﻟﻘﯿﻤﺔ ‪ 6‬واﻟﺘﻲ ﺗﺨﺼﺺ ﻟﻠﻤﺘﻐﯿﺮ ‪ a‬ﺑﻌﺪھﺎ ﯾُﻨﻔﺬ اﻟﺘﻌﺒﯿﺮ اﻟﺜﺎﻧﻲ ‪ 12/a‬واﻟﺬي ﺗﻨﺘﺞ ﻋﻨﺔ اﻟﻘﯿﻤﺔ ‪ 3‬واﻟﺘﻲ ﺗﺨﺼﺺ اﻟﻰ اﻟﻤﺘﻐﯿﺮ ‪. b‬‬
‫)‪ (1.9‬أوﻟﻮﯾﺔ ﺗﻨﻔﯿﺬ اﻟﻤﺆﺛﺮات )‪(Operators Precedence‬‬

‫اﺳﺘﺨﺪام‬ ‫اﻻوﻟﻮﯾﺔ ﻓﻲ اﻟﺘﻔﯿﺬ ﺗﺘﻀﺢ ﻋﻨﺪ وﺟﻮد ﺗﻌﺒﯿﺮ ﻣﺎ ﺑﮫ ﻋﺪد ﻣﻦ اﻟﻤﺆﺛﺮات اﻟﻤﺨﺘﻠﻔﺔ‪ ،‬ﻓﺎذا اردﻧﺎ أن ﯾﺎﺧﺬ اﻟﺘﻌﺒﯿﺮ ﻣﺴﺎراً ﻣﺤﺪداً ﻟﺘﻘﯿﯿﻤﮫ ﯾﺠﺐ‬
‫اﻻﻗﻮاس وذﻟﻚ ﺣﺴﺐ ﻣﺎ ﯾﻘﺘﻀﯿﮫ اﻟﺘﻌﺒﯿﺮ‪،‬اﻣﺎ اﻻوﻟﻮﯾﺔ ﻓﻲ اﻟﺘﻨﻔﯿﺬ ﻓﺘﺘﻢ ﺣﺴﺐ اﻻﺗﻲ ‪:‬‬

‫اﻟﺘﺴﻠﺴﻞ‬ ‫اﻟﻤﺆﺛﺮ‬ ‫اﻟﻮﺻﻒ‬ ‫اﻟﺘﻨﻔﯿﺬ‬
1 ++ -- ~ ! unary (prefix) Right-to-left
2 */ % multiplicative Left-to-right
3 + - additive Left-to-right
4 << >> shift Left-to-right
5 < <= > >= relational Left-to-right
6 != == equality Left-to-right
7 & bitwise AND Left-to-right
8 ^ bitwise XOR Left-to-right
9 | bitwise OR Left-to-right
10 && logical AND Left-to-right
11 || logical OR Left-to-right
= *= /= %= += -= >>= <<= &= ^=

13 assignment Right-to-left
|=
14 , comma Left-to-right
(Skeletal of Programs in C) C ‫ اﻟﮭﯿﻜﻠﯿﺔ ﻟﻠﺒﺮاﻣﺞ ﻓﻲ‬:‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬

.C ‫ ﯾﺠﺐ اﻟﻨﻈﺮ اﻟﻰ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺒﺮاﻣﺞ اﻟﺒﺴﯿﻄﺔ واﻟﺘﻲ ﺗﺒﯿﻦ اﻟﮭﯿﻜﻞ اﻟﻌﺎم ﻻي ﺑﺮﻧﺎﻣﺞ ﺑﺎﻟﻠﻐﺔ‬، C ‫ﻟﻐﺮض اﻟﺘﻌﺮف ﻋﻠﻰ ﺷﻜﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﻟﻐﺔ‬
Program 1 ‫اﻟﺘﻨﻔﯿﺬ‬
/* my first program in C */ C is Good Language
#include <stdio.h>
main ( )
{
printf ( "C is Good Language" ) ;
}
Program 2 ‫اﻟﺘﻨﻔﯿﺬ‬
#include <stdio.h> 5–2=3
main ( )
{
int a, b ;
float result ;
a=5;
b=2;
result = a – b ;
printf ( "%d - %d = %f" ,a ,b ,result) ;
}

‫ﺑﻌﺪ اﻻﻃﻼع ﻋﻠﻰ اﻟﻤﺜﺎﻟﯿﻦ اﻋﻼه‪،‬ﯾﻤﻜﻨﻨﺎ اﻻن ﺷﺮح ھﯿﻜﻠﯿﺔ اﻟﺒﺮﻧﺎﻣﺞ ﺑﻠﻐﺔ ‪، C‬ﺣﯿﺚ أن ھﺬه اﻟﮭﯿﻜﻠﯿﺔ ﺗﺘﺄﻟﻒ ﻣﻦ ‪:‬‬
‫)‪ (2.1‬اﻟﺘﻌﻠﯿﻘﺎت )‪(Comments‬‬

‫وھﻲ ﺟﻤﻞ اﯾﻀﺎﺣﯿﺔ ﺗﺴﺘﺨﺪم ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻘﻂ ﻟﺘﺴﮭﯿﻞ ﺗﻮﺛﯿﻖ واﻋﺎدة ﻗﺮاءة اﻟﺒﺮﻧﺎﻣﺞ أو ﺗﻌﺪﯾﻠ ﮫ ﻣ ﻦ ﻃ ﺮف اﻟﻤﺒ ﺮﻣﺞ أو اﻻﺧ ﺮﯾﻦ ‪.‬وھ ﺬه اﻟﺘﻌﻠﯿﻘ ﺎت‬
‫ﯾﻤﻜﻦ أن ﺗﻜﺘﺐ ﻓﻲ أي ﻣﻜﺎن ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬وﻣﻦ اﻟﻤﻤﻜﻦ أن ﻻ ﺗﻜﻮن ﻣﻮﺟﻮدة ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ‪،‬وﻻ ﯾﻜ ﻮن ﻟﮭ ﺎ أي ﺗ ﺎﺛﯿﺮ ﻋﻠ ﻰ اﻟﺒﺮﻧ ﺎﻣﺞ‪ ،‬ﻻن ﻣﺘ ﺮﺟﻢ اﻟﻠﻐ ﺔ‬
‫ﯾﺘﺠﺎھﻠُﮭﺎ اﺛﻨﺎء اﻟﺘﻨﻔﯿﺬ ‪.‬‬
‫‪/* Comment Statement */‬‬ ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺘﻌﻠﯿﻖ ‪:‬‬

‫ﻋﻨﺪ اﺳﺘﺨﺪام ھﺬه اﻟﺼﯿﻐﺔ ﯾﺠﺐ اﻻﻧﺘﺒﺎه اﻟﻰ ﻣ ﺎﯾﻠﻲ‪ :‬اذا ﻛ ﺎن ﻟ ﺪﯾﻨﺎ أﻛﺜ ﺮ ﻣ ﻦ ﺳ ﻄﺮ ﻟﺠﻤﻠ ﺔ اﻟﺘﻌﻠﯿ ﻖ ﻓﯿﺠ ﺐ وﺿ ﻊ اﻟﺮﻣ ﺰ) *‪ ( /‬ﻓ ﻲ ﺑﺪاﯾ ﺔ اﻟﺴ ﻄﺮ‬
‫اﻻول ﻟﺠﻤﻠﺔ اﻟﺘﻌﻠﯿﻖ ووﺿﻊ اﻟﺮﻣﺰ) ‪ ( */‬ﻓﻲ ﻧﮭﺎﯾﺔ اﻟﺴﻄﺮ اﻻﺧﯿﺮ ﻟﺠﻤﻠﺔ اﻟﺘﻌﻠﯿﻖ ‪.‬‬
‫ﻣﺜﺎل )‪-: (2.1.1‬‬

‫‪1. /* first program in C Language */‬‬
‫‪2. /* This Program calculate the Average‬‬

‫‪of n numbers using C Language */‬‬
‫)‪ (2.2‬اﻟﺘﻮﺟﯿﮭﺎت )‪(Directives‬‬

‫اﻟﺘﻮﺟﯿﮫ ھﻮ ﻋﻤﻠﯿﺔ ادراج ﻣﻠﻒ ﻋﻨﻮان رأﺳﻲ)‪ (Header File‬ﺿﻤﻦ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺣﯿﺚ أن ھﺬا اﻟﻤﻠﻒ ﻣﻮﺟﻮد ﺿﻤﻦ ﻣﻠﻔﺎت اﻟﻤﻜﺘﺒﺔ اﻟﻘﯿﺎﺳﯿﺔ ﻟﻠﻐ ﺔ ‪C‬‬
‫واﻟﺬي ﯾﺤﺘﻮي ﻋﻠﻰ ﺑﻌﺾ اﻻﯾﻌﺎزات اﻟﻤﺴﺘﺨﺪﻣﺔ ﺿﻤﻦ اﻟﺒﺮﻧﺎﻣﺞ واﻟﻤﻄﻠﻮب اﻟﺘﻌﺮف ﻋﻠﯿﮭﺎ وﺗﻨﻔﯿﺬھﺎ ﻣ ﻦ ﻗﺒ ﻞ ﻣﺘ ﺮﺟﻢ اﻟﻠﻐ ﺔ‪.‬ﻣ ﻦ ھ ﺬه اﻟﻤﻠﻔ ﺎت )‪(stdio‬‬
‫واﻟ ﺬي ﯾﺤﺘ ﻮي ﻋﻠ ﻰ ﻋﺒ ﺎرات اﻻﺧ ﺎل واﻻﺧ ﺮاج واﻟﻌﻤﻠﯿ ﺎت اﻟﺤﺴ ﺎﺑﯿﺔ‪ ،‬وھ ﺬه اﻟﻤﻠ ﻒ ﯾﺠ ﺐ ادراﺟ ﮫ ﺿ ﻤﻦ ﺟﻤﯿ ﻊ ﺑ ﺮاﻣﺞ اﻟﻠﻐ ﺔ ‪ ،C‬اﻟﻤﻠ ﻒ اﻻﺧ ﺮ ھ ﻮ‬
‫)‪ (math‬واﻟﺬي ﯾﺤﺘﻮي ﻋﻠﻰ اﻟﺪوال اﻟﺮﯾﺎﺿﯿﺔ) اﻟﺪوال اﻟﻤﺜﻠﺜﯿﺔ‪ ،‬اﻟ ﺪوال اﻟﻠﻮﻏﺎرﺗﯿﻤﯿ ﺔ‪ ،‬اﻟ ﺪوال اﻻﺳ ﯿﺔ‪ .(.....،‬وﻛ ﺬﻟﻚ ﯾﻮﺟ ﺪ اﻟﻌﺪﯾ ﺪ ﻣ ﻦ اﻟﻤﻠﻔ ﺎت واﻟﺘ ﻲ‬
‫ﺳﻮف ﻧﺘﻄﺮق ﻟﮭﺎ ﻣﻦ ﺧﻼل اﻟﺒﺮاﻣﺞ اﻟﻼﺣﻘﮫ‪.‬‬
‫> ‪#include< File_Name.h‬‬ ‫اﻣﺎ اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺘﻮﺟﯿﮫ ھﻲ ‪-:‬‬
‫ﺣﯿﺚ‬
‫‪ : File_Name‬ﯾﻤﺜﻞ اﺳﻢ اﻟﻤﻠﻒ‪.‬‬
‫> ‪Example: - (1) #include< stdio.h‬‬
‫> ‪(2) #include< math.h‬‬
‫)‪ (2.3‬اﻟﺪاﻟﺔ اﻟﺮﺋﯿﺴﯿﺔ ) (‪(Main Function) main‬‬

‫وھﻲ اﻟﺪاﻟﺔ اﻟﺘﻲ ﯾﺒﺪأ ﺑﮭﺎ اﻟﺒﺮﻧﺎﻣﺞ‪،‬وﺗﻜﻮن ﻣﻮﺟﻮدة ﻓﻲ ﺟﻤﯿﻊ اﻟﺒﺮاﻣﺞ ﺑﻠﻐﺔ ‪، C‬‬
‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬
‫) (‪main‬‬
‫{‬
‫; ‪Program Body‬‬
‫}‬
‫ﺣﯿﺚ ‪ Program body‬ﯾﻤﺜﻞ ﺟﻤﻠﺔ أو ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺠﻤﻞ اﻟﻤﻄﻠﻮب ﺗﻨﻔﯿﺬھﺎ‪.‬‬
‫)‪ (2.4‬إدﺧﺎل وإﺧﺮاج اﻟﺒﯿﺎﻧﺎت )‪(Input/Output Data‬‬

‫)‪ (1‬اﻻدﺧﺎل‪ ) -:‬راﺟﻊ ﻣﻮﺿﻮع اﻟﻤﺘﻐﯿﺮات( ﻧﻼﺣﻆ أﻧﮫ ﺗﻢ أﺳﺘﺨﺪام ﻣﺆﺛﺮ اﻟﺘﺨﺼﯿﺺ )=( ﻟﺘﺨﺼﯿﺺ ﻗﯿﻢ ﻟﻤﺘﻐﯿﺮات‪ ،‬وھﺬا ﻻ ﯾﺴﻤﺢ ﺑﺘﻐﯿﺮ ﺗﻠﻚ‬
‫اﻟﻘﯿﻢ اﻻ ﺑﺘﻐﯿﺮ ﺟﻤﻠﺔ اﻟﺘﺨﺼﯿﺺ ﺣﯿﺚ ﺗﻜﻮن ﺛﺎﺑﺘﺔ اﺛﻨﺎء ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ ‪ .‬ﻟﺬﻟﻚ ﯾُﻔﻀﻞ ﻓ ﻲ ﻣﻌﻈ ﻢ اﻟﺒ ﺮاﻣﺞ اﺳ ﺘﺨﺪام داﻟ ﺔ اﻻدﺧ ﺎل ) (‪ scanf‬واﻟﻤﻮﺟ ﻮدة‬

‫ﺿﻤﻦ ﻣﻠﻒ اﻟﻌﻨﻮان ‪ ،stdio.h‬وھﺬه اﻟﺪاﻟﺔ ﺗﺄﺧﺬ اﻟﻤﻌﻄﯿﺎت ﻣﻦ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﯿﺢ وﺗﺨﺼﺼﮭﺎ ﻻﺳﻤﺎء ﻣﺘﻐﯿﺮات‪ ،‬ﺣﯿﺚ ﯾﻤﻜﻦ اﺳﺘﺨﺪاﻣﮭﺎ ﻓﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﯿﻤ ﺎ‬
‫ﺑﻌﺪ ‪.‬‬
‫; ) ‪scanf ( "Format" , &Variable_Name‬‬ ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﺪاﻟﺔ اﻻدﺧﺎل ھﻲ‪:‬‬

‫ﺣﯿﺚ ‪ : Format‬ﺗﻌﻨﻲ اﻟﺘﻮﺻﯿﻔﺎت اﻟﻤﺨﺘﻠﻔﺔ اﻟﺘﻲ ﺗﺤﺘﻮﯾﺔ داﻟﺔ اﻻدﺧﺎل ‪.‬اﻟﺠﺪول اﻟﺘﺎﻟﻲ ﯾﻮﺿﺢ اﻟﺘﻮﺻﯿﻔﺎت اﻟﺨﺎﺻﺔ ﺑﺄدﺧﺎل اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫اﻟﻤﻌﻨﻰ‬ ‫اﻟﻤﺆﺛﺮ‬
‫ﯾﺴﺘﺨﺪم ﻟﻠﻌﺪد اﻟﺼﺤﯿﺢ‬ ‫‪%d‬‬
‫ﯾﺴﺘﺨﺪم ﻟﻠﻌﺪد اﻟﺤﻘﯿﻘﻲ‬ ‫‪%f‬‬
‫ﯾﺴﺘﺨﺪم ﻟﻠﺤﺮف‬ ‫‪%c‬‬
‫ﯾﺴﺘﺨﺪم ﻟﻠﺴﻠﺴﻠﺔ‬ ‫‪%s‬‬
‫ﯾﺴﺘﺨﺪم ﻟﻠﻌﺪد اﻟﺼﺤﯿﺢ ﺑﺪون اﺷﺎرة‬ ‫‪%u‬‬
‫ﯾﺴﺘﺨﺪم ﻟﻠﻌﺪد اﻟﺼﺤﯿﺢ ﺑﺎﻟﻨﻈﺎم اﻟﺜﻤﺎﻧﻲ‬ ‫‪%o‬‬
‫ﯾﺴﺘﺨﺪم ﻟﻠﻌﺪد اﻟﺼﺤﯿﺢ ﺑﺎﻟﻨﻈﺎم اﻟﺴﺎدس ﻋﺸﺮ‬ ‫‪%x‬‬
‫ﯾﺴﺘﺨﺪم ﻟﻠﻌﺪد اﻟﺼﺤﯿﺢ ﺑﺎﻟﺼﻮرة اﻻﺳﯿﺔ‬ ‫‪%e‬‬
‫; )‪scanf("%f" , &x‬‬ ‫ﻣﺜﺎل)‪ -: (2.4.1‬ﻻﺣﻆ اﻟﺠﻤﻠﺔ اﻻﺗﯿﺔ ‪:‬‬

‫ﻋﻨﺪﻣﺎ ﯾﺼﻞ اﻟﺘﻨﻔﯿﺬ اﻟﻰ ھﺬه اﻟﺠﻤﻠﺔ‪،‬ﯾﺘﻮﻗﻒ ﻣﻨﺘﻈﺮاً أدﺧﺎل ﻋﺪد ﺣﻘﯿﻘ ﻲ ﻟﻠﻤﺘﻐﯿ ﺮ ‪ x‬ﻋ ﻦ ﻃﺮﯾ ﻖ وﺳ ﯿﻠﺔ اﻻدﺧ ﺎل ﻟﻮﺣ ﺔ اﻟﻤﻔ ﺎﺗﯿﺢ‪،‬ﺛ ﻢ ﺗﺨ ﺰن ﺗﻠ ﻚ‬
‫اﻟﻘﯿﻤﺔ ﻓﻲ ﻋﻨﻮان اﻟﻤﺘﻐﯿﺮ ‪ x‬اﻟﻤﺨﺼﺺ ﻟﮫ ﻓﻲ اﻟﺬاﻛﺮة ‪.‬‬
‫ﻣﻼﺣﻈﺔ)‪ -:(2.4.2‬اذا ﻛﺎن ﻟﺪﯾﻨﺎ اﻛﺜﺮ ﻣﻦ ﻣﺘﻐﯿﺮ‪ ،‬ﻓﺄﻧﺔ ﺑﺎﻻﻣﻜﺎن اﺳﺘﺨﺪام اﻟﺪاﻟﺔ ) ( ‪ scanf‬ﻻدﺧﺎل اﻟﻘﯿﻢ ﻟﮭﺬه اﻟﻤﺘﻐﯿﺮات‪.‬وﻛﻤﺎ ﯾﻠﻲ‬
‫;) ‪scanf ( "Format" , &Variable_1,&Variable_2,&Variable_3, … ,& Variable_n‬‬
‫; )‪scanf("%d%f%f%c" , &a,&b,&c,&op‬‬ ‫ﻣﺜﺎل)‪ -: (2.4.3‬ﻻﺣﻆ اﻟﺠﻤﻠﺔ اﻻﺗﯿﺔ ‪:‬‬
‫)‪ (2‬اﻻﺧﺮاج‪ -:‬ﺗﺴﺘﺨﺪم اﻟﺪاﻟﺔ ) (‪ printf‬ﻻﺧﺮاج اﻟﺒﯿﺎﻧﺎت ﻋﻠﻰ وﺣﺪة اﻻﺧﺮاج اﻟﻘﯿﺎﺳﯿﺔ)اﻟﺸﺎﺷﺔ( ‪ ،‬وھﺬه اﻟﺪاﻟﺔ ﻣﻮﺟ ﻮدة ﺿ ﻤﻦ ﻣﻠ ﻒ اﻟﻌﻨ ﻮان‬
‫‪. stdio.h‬‬
‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﮭﺬة اﻟﺪاﻟﺔ ھﻲ ‪:‬‬

‫) ‪printf( " Format ",arg_1,arg_2,..., arg_n‬‬ ‫;‬
‫ﺣﯿﺚ‬
‫‪ : Format‬ﺗﻌﻨ ﻲ اﻟﺘﻮﺻ ﯿﻒ اﻻزم ﻟﻠﻄﺒﺎﻋ ﺔ‪،‬واﻟﺘ ﻲ ﺗﺘﻀ ﻤﻦ ﻋﺒ ﺎرات اﻻﺧ ﺮاج اﻟﻤﻨﺎﺳ ﺒﺔ واﻟﻤﻨﺴ ﻘﺔ ﻟﻠﺒﯿﺎﻧ ﺎت‪،‬وﻛ ﺬﻟﻚ ﺗﺘﻀ ﻤﻦ اﻟﺘﻮﺻ ﯿﻔﺎت‬
‫اﻟﺨﺎﺻﺔ واﻟﻤﻮﺟﻮدة ﺿﻤﻦ اﻟﺠﺪول اﻟﺨﺎص ﺑﺘﻮﺻﯿﻔﺎت داﻟﺔ اﻻدﺧﺎل ) (‪. scanf‬‬
‫ﻣﻼﺣﻈﺔ)‪ -:(2.4.3‬اﻟﺒﺮﻧﺎﻣﺞ اﻟﺠﯿﺪ ھﻮ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﺗﻜﻮن ﻣﺨﺮﺟﺎﺗﮫ ﻣﻨﺴﻘﺔ وذات ﺗﻮﺻﯿﻒ ﺟﯿﺪ ﻟﻠﺒﯿﺎﻧﺎت‪.‬‬
‫أﻣﺎ ‪ : arg_1, arg_2, arg_3, ….. ,arg_n‬ﻓﮭﻲ ﻋﻨﺎﺻﺮ اﻟﺒﯿﺎﻧﺎت ‪ ،‬وھ ﻲ اﺧﺘﺼ ﺎر ﻟﻜﻠﻤ ﺔ اﻻدﻟ ﺔ)‪ (Arguments‬وﯾﻤﻜ ﻦ أن ﺗﻜ ﻮن‬
‫ھﺬه اﻻدﻟﺔ ﺛﻮاﺑﺖ ﻋﺪدﯾﺔ أو ﻣﺘﻐﯿﺮات ﻣﻦ اﻟﻨﻮع )اﻟﺼﺤﯿﺢ – اﻟﺤﻘﯿﻘﻲ –اﻟﺤﺮﻓﻲ( اﻟﻤﻄﻠﻮب ﻃﺒﺎﻋﺘﮭﺎ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪ ،‬وﻋﻠ ﻰ أن ﺗﻔﺼ ﻞ اﻻدﻟ ﺔ ﻋ ﻦ‬
‫ﺑﻌﻀﮭﺎ ﺑﻮاﺳﻄﺔ ﻓﻮاﺻﻞ ‪.‬‬

‫ﻣﻼﺣﻈﺔ)‪ -:(2.4.4‬ھﻨﺎك ﺑﻌﺾ اﻟﺮﻣﻮز اﻟﺨﺎﺻﺔ‪ ،‬ﯾﻄﻠﻖ ﻋﻠﯿﮭﺎ أﺣﯿﺎﻧﺎً )رﻣﻮز اﻟﮭﺮوب(‪ ،‬و اﻟﻤﻤﻜﻦ اﺳﺘﺨﺪاﻣﮭﺎ ﻣﻊ داﻟﺔ اﻻﺧﺮاج ) (‪ printf‬ﻟﻠﺘﺤﻜﻢ‬
‫ﻓﻲ اﻟﻤﺨﺮﺟﺎت أو اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪ ،‬وھﺬه اﻟﺮﻣﻮز ﯾﻤﻜﻦ أن ﺗﻮﺿﻊ ﺿﻤﻦ اﻟﺘﻮﺻﯿﻔﺎت)‪ (Format‬أو ﺑﺼﻮرة ﻣﻨﻔﺮدة وﻓﻲ ﺣﺎﻟﺔ ﻛﺘﺎﺑﺘﮭﺎ ﺑﺼ ﻮرة‬
‫ﻣﻨﻔﺮدة ﻓﯿﺠﺐ وﺿﻌﮭﺎ داﺧﻞ ﻋﻼﻣﺔ اﻟﺘﻨﺼﯿﺺ اﻟﻤﺰدوﺟﺔ)" "( وھﻲ ﻛﺎﻻﺗﻲ ‪:‬‬
‫اﻟﺮﻣﺰ‬ ‫ﻣﻌﻨﺎه‬ ‫اﻟﺮﻣﺰ‬ ‫ﻣﻌﻨﺎه‬
‫‪\n‬‬ ‫اﻻﻧﺘﻘﺎل اﻟﻰ ﺳﻄﺮ ﺟﺪﯾﺪ‬ ‫‪\f‬‬ ‫اﻻﻧﺘﻘﺎل اﻟﻰ ﺻﻔﺤﺔ ﺟﺪﯾﺪة‬
‫‪\r‬‬ ‫اﻟﺒﺪء ﻣﻦ أول اﻟﺴﻄﺮ‬ ‫‪\a‬‬ ‫اﺳﺘﺨﺪام اﻟﺠﺮس‬
‫‪\b‬‬ ‫اﻟﺘﺮاﺟﻊ ﻣﺴﺎﻓﺔ اﻟﻰ اﻟﺨﻠﻒ‬ ‫\\‬ ‫ﻟﻄﺒﺎﻋﺔ اﻟﺤﺮف‬
‫اﻟﺘﻘﺪم ﻣﺴﺎﻓﺔ ﻣﻌﯿﻨﺔ ﻗﺒﻞ‬ ‫ﻟﻄﺒﺎﻋﺔ ﻋﻼﻣﺔ اﻟﺘﻨﺼﯿﺺ‬

‫‪\t‬‬ ‫'\‬
‫اﻟﻄﺒﺎﻋﺔ‬ ‫اﻟﻤﻔﺮدة‬
‫ﻟﻄﺒﺎﻋﺔ ﻋﻼﻣﺔ اﻟﺘﻨﺼﯿﺺ‬

‫"\‬
‫اﻟﻤﺰدوﺟﺔ‬
‫ﻣﺜﺎل)‪-: (2.4.5‬‬
‫‪Program‬‬ ‫اﻟﺘﻨﻔﯿﺬ‬
‫>‪#include <stdio.h‬‬ ‫‪Hello World! I'm a C program‬‬
‫) ( ‪main‬‬
‫{‬
‫;)" !‪printf ("Hello World‬‬
‫; )"‪printf ("I'm a C program‬‬
‫}‬
‫ﻧﻼﺣﻆ ﻣﻦ ﺧﻼل ھﺬا اﻟﻤﺜﺎل أن اﻟﺘﻔﯿﺬ ﻗﺪ أﻇﮭﺮ اﻟﻄﺒﺎﻋﺔ ﻟﻠﻌﺒﺎرﺗﯿﻦ ﺑﺴﻄﺮ واﺣﺪ ‪،‬وھﺬا ﺗﻨﺴﯿﻖ ﻏﯿﺮ ﺟﯿ ﺪ ﻟﻠﻄﺒﺎﻋ ﺔ اذ اﻧﻨ ﺎ ﻧﺮﯾ ﺪ ﻃﺒﺎﻋ ﺔ ﻛ ﻞ ﻋﺒ ﺎرة ﺑﺴ ﻄﺮ‬
‫واﺣﺪ ﻣﺴﺘﻘﻞ ﻋﻦ اﻟﺴﻄﺮ اﻻﺧﺮ‪ ،‬ﻟﺬﻟﻚ ﺳﻮف ﻧﺴﺘﺨﺪم اﻟﺮﻣﻮز ‪ \n‬ﻟﮭﺬا اﻟﻐﺮض ‪.‬‬
‫>‪#include <stdio.h‬‬ ‫!‪Hello World‬‬
‫) ( ‪main‬‬ ‫‪I'm a C program‬‬
‫{‬
‫;)" ‪printf ("Hello World!\n‬‬
‫; )"‪printf ("I'm a C program‬‬
‫}‬
‫ﻣﺜﺎل)‪ -:(2.4.6‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ ﻣﺴﺎﺣﺔ وﻣﺤﯿﻂ داﺋﺮة ﻧﺼﻒ ﻗﻄﺮھﺎ ‪. r =5.2‬‬
‫‪/* calculate area and circumference */‬‬ ‫‪The Area of circle =84.948663‬‬
‫>‪#include <stdio.h‬‬ ‫‪The Circumference of circle =32.672563‬‬
‫)( ‪main‬‬
‫{‬
‫; ‪const double PI=3.1415926‬‬
‫;‪float r=5.2‬‬
‫; ‪double area ,circumference‬‬
‫; ‪area = PI * r * r‬‬
‫; ‪circumference = 2 * PI * r‬‬
‫; ) ‪printf("The Area of circle =%f" ,area‬‬
‫; )‪printf("\n The Circumference of circle =%f",circumference‬‬
‫}‬

. ‫ﺛﻢ ﺣﺴﺎب وﻃﺒﺎﻋﺔ ﻣﺤﯿﻂ وﻣﺴﺎﺣﺔ ھﺬا اﻟﻤﺴﺘﻄﯿﻞ‬، ‫ اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻻدﺧﺎل اﻟﻄﻮل واﻟﻌﺮض ﻟﻤﺴﺘﻄﯿﻞ ﻣﺎ‬-:(2.4.7)‫ﻣﺜﺎل‬
Program ‫اﻟﺘﻨﻔﯿﺬ‬
#include <stdio.h> Length= 20
main() Width= 15
{ Perimeter is 70
int length, width ; Area is 300
int perimeter, area ;
printf("Length =") ;
scanf("%d",&length) ;
printf("\n Width =") ;
scanf("%d",&width) ;
perimeter = 2*(length+width) ;
area = length*width ;
printf("Perimeter is %d " ,perimeter) ;
printf("\n Area is %d", area) ;
}
. ‫ وﺣﺴﺎب وﻃﺒﺎﻋﺔ ﻣﻌﺪل اﻟﻄﺎﻟﺐ‬،( 77 82 69 95 ) ‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة درﺟﺎت ﻃﺎﻟﺐ ﻓﻲ أرﺑﻌﺔ ﻣﻮاد‬-:(2.4.8)‫ﻣﺜﺎل‬
#include <stdio.h> Enter Four Degrees : 77 82 69 95
main() The Average of Student is 80.75
{
int d1, d2, d3, d4, sum = 0 ;
float average ;
printf("Enter Four Degree : ") ;
scanf("%d%d%d%d",&d1,&d2,&d3,&d4) ;
sum =(d1+d2+d3+d4) ;
average = sum/4 ;
printf("\n") ;
printf("The Average of Student is %f ", average ) ;
}
: ‫ ﻟﺬﻟﻚ ﯾﻤﻜﻦ أﻋﺎدة اﻟﻤﺜﺎل اﻋﻼه ﺑﺎﻟﺒﺮﻧﺎﻣﺞ اﻻﺗﻲ‬، ‫ داﺋﻤﺎ ﯾﺒﺤﺚ ﻋﻦ ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﺔ ﺑﺄﻗﻞ اﻟﺨﻄﻮات‬،‫ اﻟﻤﺒﺮﻣﺞ اﻟﺠﯿﺪ‬-:(2.4.9)‫ﻣﻼﺣﻈﺔ‬
#include <stdio.h> Enter Four Degrees : 77 82 69 95
main() The Average of Student is 80.75
{
int d1, d2, d3, d4 ;
cout << "Enter Four Degree : " ;
scanf("%d%d%d%d",&d1,&d2,&d3,&d4) ;
printf("\n The Average of Student is %f " << (d1+d2+d3+d4)/4 ;
}

‫ﺗﻤﺎرﯾﻦ ) اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ (‬

‫ﺗﻤﺮﯾﻦ ‪ -: 1‬أﻃﺒﻊ أﺳﻤﻚ ﻛﺎﻣﻼً ﻓﻲ اﻟﺴﻄﺮ اﻻول ﻣﻦ اﻟﺠﮭﺔ اﻟﯿﺴﺮى‪،‬وأﻃﺒﻊ ﻋﻨﻮاﻧﻚ ﻓﻲ وﺳﻂ اﻟﺴﻄﺮ اﻟﺜﺎﻟﺚ‪،‬ﺛﻢ أﻃﺒﻊ اﻟﺠﻨﺴﯿﺔ ﻓﻲ اﻟﺴﻄﺮ‬
‫ﻣﻦ اﻟﺠﮭﺔ اﻟﯿﻤﻨﻰ ﻣﻦ اﻟﺸﺎﺷﺔ‪.‬‬
‫ﺗﻤﺮﯾﻦ ‪ -: 2‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﯾﻘﺮأ درﺟﺔ اﻟﺤﺮارة ﺑﺎﻟﺪرﺟﺔ اﻟﻔﮭﺮﻧﮭﺎﯾﺘﯿﺔ‪ ،‬ﺛﻢ ﯾﻄﺒﻌﮭﺎ ﺑﺎﻟﺪرﺟﺔ اﻟﻤﺌﻮﯾﺔ ﻣﺴﺘﺨﺪﻣﺎً اﻟﻤﻌﺎدﻟﺔ )‪C = ( F – 32‬‬
‫ﺗﻤﺮﯾﻦ ‪ -: 3‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻻدﺧﺎل ﻗﯿﻢ ﺣﻘﯿﻘﯿﺔ ﻟﻠﻤﺘﻐﯿﺮات ‪ ، x , y , z , w‬وﺣﺴﺎب وﻃﺒﺎﻋﺔ ﻛﻞ ﻣﻤﺎ ﯾﺎﺗﻲ ‪:‬‬
‫=‪A‬‬ ‫= ‪2) B‬‬
‫ﺗﻤ ﺮﯾﻦ ‪ -: 4‬أﻛﺘ ﺐ ﺑﺮﻧﺎﻣﺠ ﺎً ﻟﻘ ﺮاءة اﻟﻌﺠﻠ ﺔ اﻟﺜﺎﺑﺘ ﺔ ‪ A‬واﻟ ﺰﻣﻦ ‪ ، T‬ﺛ ﻢ أﺣﺴ ﺐ وأﻃﺒ ﻊ اﻟﻤﺴ ﺎﻓﺔ ‪ D‬واﻟﺴ ﺮﻋﺔ اﻟﻨﮭﺎﺋﯿ ﺔ ‪ ، V‬اذا ﻋﻠﻤ ﺖ أن‬
‫‪ D=0.5A‬وأن اﻟﺴﺮﻋﺔ اﻟﻨﮭﺎﺋﯿﺔ ھﻲ ‪. V=AT‬‬
‫ﺗﻤﺮﯾﻦ ‪ -: 5‬ﺗﺘﺒﻊ واﺳﺘﻨﺘﺞ ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪Program‬‬
‫>‪#include <stdio.h‬‬
‫) ( ‪main‬‬
‫{‬
‫; ‪short a,b,c‬‬
‫; ‪short d,e‬‬
‫; ‪d=e=30‬‬
‫; ‪a=4‬‬
‫; ‪b=--a+1‬‬
‫; ‪c=++a + b++‬‬
‫;) ‪printf( "A=%d \t B=%d \t C=%d\n",a,b,c‬‬
‫; ‪c+=--a + --b‬‬
‫; )‪a=b=c-(a*b‬‬
‫; ‪d/=a+b‬‬
‫; ‪e=e/a +b‬‬
‫; )‪printf( "\n D=%d \t E=%f" ,d,e‬‬
‫}‬
‫ﺗﻤﺮﯾﻦ ‪ -: 6‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻻدﺧﺎل اﻟﺠﻨﺲ)‪ (Sex‬وﻓﺼﯿﻠﺔ اﻟﺪم ﻟﺰوﺟﯿﻦ‪ ،‬وأﻇﮭﺎر اﻟﻨﺘﺎﺋﺞ ﻛﺎﻻﺗﻲ‬
‫‪SEX‬‬ ‫‪BLOOD SPECIES‬‬
‫‪M‬‬ ‫‪A+‬‬
‫‪F‬‬ ‫‪O+‬‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ‪ :‬اﻟﺘﺮاﻛﯿﺐ اﻟﺸﺮﻃﯿﺔ )‪(Conditional Structures‬‬

‫ﻧﻼﺣﻆ ان ﺟﻤﯿﻊ اﻻﻣﺜﻠﺔ اﻟﺘﻲ ﻣﺮت ﺑﻨﺎ ﺳﺎﺑﻘﺎً‪ ،‬ﻧﻔﺬت ﺑﻄﺮﯾﻘﺔ ﻣﺘﺴﻠﺴﻠﺔ)أي ﺧﻄﻮة ﺑﻌﺪ ﺧﻄﻮة(‪.‬وھﻨﺎ ﯾﺘﺒﺎدر اﻟﻰ اﻟﺬھﻦ اﻟﺴﺆال اﻻﺗﻲ ‪:‬‬
‫ﺳﺆال‪ -:‬ﻛﯿﻒ ﺑﺎﺳﺘﻄﺎﻋﺘﻨﺎ ﻧﻘﻞ ﺗﻨﻔﯿﺬ ﺧﻄﻮات ﺑﺮﻧﺎﻣﺠﺎً ﻣﺎ ﺑﺪون ﺗﺴﻠﺴﻞ او ﺑﻤﻌﻨﻰ اﺧﺮ‪،‬ﻛﯿﻒ ﯾﺘﻢ اﻟﺘﺤﻜﻢ ﺑﺘﻨﻔﯿﺬ ﺧﻄﻮات اﻟﺒﺮﻧﺎﻣﺞ ﻛﯿﻔﻤﺎ ﻧﺮﯾﺪ؟‬
‫ﻟﻸﺟﺎﺑﺔ ﻋﻦ ھﺬا اﻟﺴﺆال‪ ،‬ﻋﻠﯿﻨﺎ دراﺳﺔ ﻣﻔﮭﻮم اﻟﺘﺮاﻛﯿﺐ اﻟﺸﺮﻃﯿﺔ ‪.‬‬
‫)‪ (3.1‬اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﺒﺴﯿﻂ ) اذا ‪(If /‬‬

‫)‪if(condition‬‬ ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬
‫;‪statement‬‬
‫ﻋﻤﻞ ‪ -: If‬اذا ﻛﺎن اﻟﺸﺮط )‪ (Condition‬ﺻﺤﯿﺤﺎً ‪،‬ﻓﻨﻔﺬ اﻟﺠﻤﻠﺔ )‪.(Statement‬‬
‫ﻣﺜﺎل)‪-: (3.1.1‬‬
‫>‪#include<stdio.h‬‬ ‫‪15‬‬ ‫اﻟﺘﻨﻔﯿﺬ‪:1‬‬
‫) ( ‪main‬‬ ‫‪The number is Positive‬‬
‫{‬
‫;‪int x‬‬
‫; )‪scanf("%d" ,&x‬‬
‫)‪if (x > 0‬‬ ‫‪-6‬‬ ‫اﻟﺘﻨﻔﯿﺬ‪:2‬‬
‫; )"‪printf( " The number is Positive‬‬
‫}‬
‫ﻧﻼﺣﻆ ﻣﻦ ﺧﻼل اﻟﺘﻨﻔﯿﺬ‪ 1‬ﻟﻠﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪،‬ﻋﻨﺪ إدﺧﺎل ‪، x=15‬ﻓﺎن اﻟﺸﺮط ﻣﺘﺤﻘﻖ وﺑﺎﻟﺘﺎﻟﻲ ﻇﮭﺮت ﻟﻨﺎ اﻟﻌﺒﺎرة‬
‫‪The number is Positive‬‬
‫ﺑﯿﻨﻤﺎ ﻋﻨﺪ اﻟﺘﻨﻔﯿﺬ‪، 2‬أي ﻋﻨﺪ ادﺧﺎل ‪ x= -6‬ﻟﻢ ﺗﻈﮭﺮ ﻟﻨﺎ أي ﻋﺒﺎرة‪.‬‬
‫ﻣﺜﺎل)‪-: (3.1.2‬‬
‫) ( ‪main‬‬ ‫‪The number is Positive‬‬
‫{‬
‫;‪int x‬‬
‫; )‪scanf("%d" ,&x‬‬
‫)‪if (x > 0‬‬ ‫‪-6‬‬ ‫اﻟﺘﻨﻔﯿﺬ‪:2‬‬
‫; ) "‪printf( " The number is Positive‬‬ ‫‪The number is Negative‬‬
‫)‪if (x < 0‬‬
‫; ) "‪printf( "The number is Negative‬‬
‫}‬
‫ﻧﻼﺣﻆ ﻣﻦ ﺧﻼل اﻟﻤﺜﺎل اﻋﻼه‪ ،‬ﻓﻲ اﻟﺘﻨﻔﯿﺬ اﻻول ﻇﮭﺮت ﻟﻨﺎ اﻟﻌﺒﺎرة ‪ The number is Positive‬ﺑﯿﻨﻤﺎ ﻓﻲ اﻟﺘﻨﻔﯿﺬ اﻟﺜﺎﻧﻲ ﻇﮭﺮت ﻟﻨﺎ اﻟﻌﺒﺎرة‬
‫‪ ،The number is Negative‬ھﻨﺎ ﺗﻢ اﺳﺘﺨﺪام اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﺒﺴﯿﻂ ﻣﺮﺗﯿﻦ‪.‬‬
‫ﻣﻼﺣﻈﺔ)‪ -:(3.1.3‬اذا ﻛﺎن اﻟﻤﻄﻠﻮب ﺗﻨﻔﯿﺬ أﻛﺜﺮ ﻣﻦ ﺟﻤﻠﺔ ﺿﻤﻦ ﺷﺮﻃﺎً ﻣﺎ‪ ،‬ﻓﯿﺠﺐ وﺿﻊ ھﺬه اﻟﺠﻤﻞ ﺿﻤﻦ اﻟﻘﻮﺳﯿﻦ { ‪ } ،‬وھ ﺬا ﻣ ﺎ اﺻ ﻄﻠﺢ ﻋﻠ ﻰ‬
‫ﺗﺴﻤﯿﺘﮫ اﻟﺠﻤﻠﺔ اﻟﻤﺮﻛﺒﺔ أو اﻟﺒﻠﻮك ‪.‬‬
‫{‬
‫;‪statement_1‬‬
‫…‬
‫;‪statement_n‬‬
‫}‬

‫ﻣﺜﺎل)‪ -:(3.1.4‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة ﻋﺪدﯾﻦ ﺣﻘﯿﻘﯿﯿﻦ ‪ ،‬ﺛﻢ رﺗﺐ ھﺬﯾﻦ اﻟﻌﺪدﯾﻦ ﺗﺼﺎﻋﺪﯾﺎً ‪.‬‬
‫>‪#include<stdio.h‬‬ ‫‪5.7‬‬ ‫‪3.94‬‬ ‫اﻟﺘﻨﻔﯿﺬ‪:1‬‬
‫) ( ‪main‬‬
‫{‬ ‫‪3.94 , 5.7‬‬
‫;‪float a,b,temp‬‬
‫; )‪scanf("%f%f" ,&a ,&b‬‬
‫)‪if (a>b‬‬
‫{‬ ‫‪-1.6‬‬ ‫‪8.17‬‬ ‫اﻟﺘﻨﻔﯿﺬ‪:2‬‬
‫; ‪temp=a‬‬
‫; ‪a=b‬‬ ‫‪-1.6 , 8.17‬‬
‫; ‪b=temp‬‬
‫}‬
‫; ) ‪printf( "%f , %f ",a ,b‬‬
‫}‬
‫ﻧﻼﺣ ﻆ ﻣ ﻦ ﺧ ﻼل اﻟﻤﺜ ﺎل أﻋ ﻼه‪ ،‬ﻋﻨ ﺪ اﻟﺘﻨﻔﯿ ﺬ اﻻول ﻗ ﺪ ﺗﺤﻘ ﻖ اﻟﺸ ﺮط وﺑﺎﻟﺘ ﺎﻟﻲ ﺗ ﻢ اﺟ ﺮاء اﻟﺘﺒ ﺪﯾﻞ وﻇﮭ ﺮت اﻟﻨﺘﯿﺠ ﺔ‪ ،‬ﺑﯿﻨﻤ ﺎ ﻓ ﻲ اﻟﺘﻨﻔﯿ ﺬ اﻟﺜ ﺎﻧﻲ ﻟ ﻢ ﯾﺘﺤﻘ ﻖ‬
‫اﻟﺸﺮط)أي ﻟﻢ ﯾﺘﻢ أﺟﺮاء اﻟﺘﺒﺪﯾﻞ( وﺑﺎﻟﺮﻏﻢ ﻣﻦ ذﻟﻚ ﻇﮭﺮت ﻟﻨﺎ اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺤﺔ أﯾﻀﺎً ‪.‬‬
‫)‪ (3.2‬اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﻜﺎﻣﻞ )اذا‪...‬واﻻ ‪(If…else /‬‬
‫)‪if(condition‬‬ ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬

‫‪else‬‬
‫ﻋﻤ ﻞ ‪ -: If …else‬اذا ﻛ ﺎن اﻟﺸ ﺮط )‪ (Condition‬ﺻ ﺤﯿﺤﺎً ‪،‬ﻓﻨﻔ ﺬ اﻟﺠﻤﻠ ﺔ )‪ (Statement_1‬اﻣ ﺎ اذا ﻛ ﺎن اﻟﺸ ﺮط ﻏﯿ ﺮ ﺻ ﺤﯿﺢ ﻓﻨﻔ ﺬ‬
‫اﻟﺠﻤﻠﺔ)‪.(Statement_2‬‬
‫ﻣﺜﺎل)‪ -: (3.2.1‬اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﺎً ﯾﺘﻀﻤﻦ أدﺧﺎل ﻋﺪد ﺻﺤﯿﺢ‪ ،‬وﻣﻌﺮﻓﺔ ﻓﯿﻤﺎ أذا ﻛﺎن ھﺬا اﻟﻌﺪد زوﺟﻲ ام ﻓﺮدي‪.‬‬
‫) ( ‪main‬‬ ‫‪The number is Even‬‬
‫{‬
‫;‪int x‬‬
‫; )‪scanf("%d" ,&x‬‬ ‫‪11‬‬ ‫اﻟﺘﻨﻔﯿﺬ‪:2‬‬
‫)‪if (x%2==0‬‬
‫; )"‪printf("The number is Even‬‬ ‫‪The number is Odd‬‬
‫‪else‬‬
‫; )"‪printf("The number is Odd‬‬
‫}‬
‫ﻧﻼﺣﻆ ﻋﻨﺪ اﻟﺘﻨﻔﯿﺬ‪،1‬أي ﻋﻨﺪ ادﺧﺎل ‪، x=8‬ﻓﺎن اﻟﺸﺮط ﻣﺘﺤﻘﻖ وﺑﺎﻟﺘﺎﻟﻲ ﻇﮭﺮت ﻟﻨﺎ اﻟﻌﺒﺎرة ‪ The number is Even‬ﺑﯿﻨﻤ ﺎ ﻓ ﻲ اﻟﺘﻔﯿ ﺬ‪،2‬أي ﻋﻨ ﺪ ادﺧ ﺎل‬
‫‪، x=11‬ﻓﺎن اﻟﺸﺮط ﻏﯿﺮ ﻣﺘﺤﻘﻖ ورﻏﻢ ذﻟﻚ ﻇﮭﺮت ﻟﻨﺎ اﻟﻌﺒﺎرة ‪.The number is Odd‬‬
‫ﻣﻼﺣﻈﺔ)‪ (1) -:(3.2.2‬اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﻜﺎﻣﻞ ﯾﻜﺎﻓﺊ ﺗﺮﻛﯿﺒﯿﻦ ﺷﺮﻃﯿﯿﻦ ﺑﺴﯿﻄﯿﻦ ‪.‬‬
‫)‪ (2‬ﯾﻤﻜ ﻦ اﺳ ﺘﺨﺪام أﻛﺜ ﺮ ﻣ ﻦ ﺗﺮﻛﯿ ﺐ ﺷ ﺮﻃﻲ ﻛﺎﻣ ﻞ ﺑﺼ ﻮرة ﻣﺘﺪاﺧﻠ ﺔ ﺿ ﻤﻦ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟﻮاﺣ ﺪ ‪ ،‬وھ ﺬا ﻣ ﺎ أﺻ ﻄﻠﺢ ﻋﻠ ﻰ ﺗﺴ ﻤﯿﺘﺔ‬
‫اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﻤﺘﺪاﺧﻞ ) ‪. ( Nested Conditional Structure‬‬

‫)‪ (3.3‬ﺗﺮﻛﯿﺐ اﻟﻤﺆﺛﺮ اﻟﺸﺮﻃﻲ ? ) ? ‪( Conditional Operator‬‬
‫; ‪(condition)?statement_1:statement_2‬‬ ‫اﻟﺼ ﯿﻐﺔ اﻟﻌﺎﻣ ﺔ‬
‫ﻋﻤﻞ اﻟﻤﺆﺛﺮ اﻟﺸﺮﻃﻲ )? (‪ -:‬ﻣﺸﺎﺑﮫ إﻟﻰ ﻋﻤﻞ اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﻜﺎﻣﻞ ‪. if…else‬‬
‫ﻣﺜﺎل)‪ -:(3.3.1‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ ﻗﯿﻤﺔ ‪ ، Y‬أذا ﻋﻠﻤﺖ أن‬
‫=‪Y‬‬
‫?‪Program by Conditional Operator‬‬ ‫‪Program by If…else‬‬
‫) ( ‪main‬‬
‫{‬
‫) ( ‪main‬‬
‫; ‪float x ,y‬‬
‫{‬
‫; )‪scanf("%d" ,&x‬‬
‫; ‪float x ,y‬‬
‫)‪if(x>=0‬‬
‫; )‪scanf("%d" ,&x‬‬
‫; ‪y= 5-x*x‬‬
‫; ‪y= (x>=0) ? 5-x*x : 2*x*x*x‬‬
‫‪else‬‬
‫; )‪printf(" Y =%f ", y‬‬
‫; ‪y= 2*x*x*x‬‬
‫}‬
‫; )‪printf(" Y =%f ", y‬‬
‫}‬
‫ﻣﺜﺎل)‪ -:(3.3.2‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة ﻋﺪدﯾﻦ ﺻﺤﯿﺤﯿﻦ‪ ،‬ﺛﻢ ﯾﻄﺒﻊ اﻟﻤﺘﻐﯿﺮ اﻟﺬي ﯾﺤﺘﻮي أﻛﺒﺮ ﻗﯿﻤﺔ ‪.‬‬
‫>‪#include <stdio.h‬‬ ‫‪2 7‬‬
‫) ( ‪main‬‬ ‫‪The Maximum Number = 7‬‬
‫{‬
‫; ‪int a,b,max‬‬
‫;)‪scanf("%d%d" ,&a ,&b‬‬
‫; ‪max= (a>b)? a : b‬‬
‫; )‪printf( "The Maximum Number =&d ", max‬‬
‫}‬
‫)‪ (3.4‬اﻟﺘﺮﻛﯿﺐ اﻻﻧﺘﻘﺎﺋﻲ ‪(The selective structure Switch) Switch‬‬

‫ﻛﻤﺎ ﻻﺣﻈﻨﺎ ﺳﺎﺑﻘﺎً‪،‬أن ﺟﻤﯿﻊ اﻟﺘﺮاﻛﯿﺐ اﻟﺸﺮﻃﯿﺔ ﺗﺘﻢ ﻓﯿﮭﺎ اﻟﻤﻘﺎرﻧﺔ ﺑﯿﻦ ﻗﯿﻤﺘﯿﻦ ﺣﯿ ﺚ ﺗﻜ ﻮن اﻟﻨﺘﯿﺠ ﺔ أﻣ ﺎ ﺻ ﺤﯿﺤﺔ أو ﺧﺎﻃﺌ ﺔ‪ ،‬وﻟﻜ ﻦ ﻓ ﻲ ﺑﻌ ﺾ‬
‫اﻻﺣﯿﺎن ﻋﻠﯿﻨﺎ أن ﻧﻘﺎرن ﺑﯿﻦ ﻋﺪد ﻣﻦ اﻟﺤﺎﻻت ﺗﺒﻌﺎً ﻟﺸﺮوط ﻣﺨﺘﻠﻔﺔ ‪.‬‬
‫ﻓ ﻲ ھ ﺬه اﻟﺤﺎﻟ ﺔ ﻧﺴ ﺘﻄﯿﻊ اﺳ ﺘﺨﺪام اﻟﺘﺮﻛﯿ ﺐ اﻻﻧﺘﻘ ﺎﺋﻲ )‪ (switch‬واﻟ ﺬي ﯾﻘ ﻮم ﺑﺎﺧﺘﯿ ﺎر اﻟﻘﯿﻤ ﺔ اﻟﺼ ﺤﯿﺤﺔ ﻣ ﻦ ﻋ ﺪد ﻣ ﻦ اﻟﻘ ﯿﻢ وﺣﺴ ﺐ ﺻ ﺤﺔ‬
‫اﻟﺸﺮط اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﺼﯿﻐﺔ ‪.‬‬

: ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺘﺮﻛﯿﺐ اﻻﻧﺘﻘﺎﺋﻲ ھﻲ‬

switch (expression)
{
case value_1: statements_1 ;
break ;
case value_2: statements_2 ;
break ;
.
.
.
case value_n: statements_n ;
break ;
default: statement_ m ;
‫ﺣﯿﺚ‬
}
. ( char )‫ ( أو ﻣﻦ اﻟﻨﻮع اﻟﺤﺮﻓﻲ‬int ) ‫ ھﻮ ذﻟﻚ اﻟﺘﻌﺒﯿﺮ اﻟﺬي ﯾﺠﺐ أن ﺗﻜﻮن ﻧﺘﯿﺠﺘﺔ ﻣﻦ اﻟﻨﻮع اﻟﺼﺤﯿﺢ‬: expression
. ‫ ﺗﻤﺜﻞ ﻧﻮع اﻟﺤﺎﻟﺔ اﻟﻤﻨﺎﺳﺒﺔ ﺑﻌﺪ اﺣﺘﺴﺎب اﻟﺘﻌﺒﯿﺮ‬: case
. ( char ) ‫ ( أو ﻣﻦ اﻟﻨﻮع اﻟﺤﺮﻓﻲ‬int ) ‫ ﺗﻤﺜﻞ ﻗﯿﻤﺔ اﻟﺘﻌﺒﯿﺮ وﯾﻤﻜﻦ أن ﺗﻜﻮن ﻋﺪداً ﻣﻮﺟﺒﺎً أو ﺳﺎﻟﺒﺎً ﻣﻦ اﻟﻨﻮع اﻟﺼﺤﯿﺢ‬: value
‫ واذا ﻟ ﻢ‬،(cases)‫( ﻟﺘﻔﺎدي اﺳﺘﻤﺮار ﺑﻘﯿﺔ اﻟﺤﺎﻻت‬case) ‫ ﺗﺴﺘﻌﻤﻞ ﻋﻨﺪ آﺧﺮ ﻛﻞ ﻣﺠﻤﻮﻋﺔ ﺟﻤﻞ ﻣﻦ ﺟﻤﻞ اﻟﺤﺎﻟﺔ‬،‫ وھﻲ ﻋﺒﺎرة ﺗﻮﻗﻒ‬: break
. ‫ﺗﺴﺘﻌﻤﻞ ﺑﻌﺪ أي ﺣﺎﻟﺔ ﻓﺎن اﻟﺘﻌﺒﯿﺮ ﯾﻨﺘﻘﻞ اﻟﻰ اﻟﺤﺎﻟﺔ اﻟﻤﻮاﻟﯿﺔ ﻟﮭﺬه اﻟﺤﺎﻟﺔ‬
‫( ﻻ ﺗﺘﺤﻘ ﻖ ﻣ ﻊ أي‬expression) ‫ وﺗﻨﻔﺬ ﻋﻨﺪﻣﺎ ﯾﻜ ﻮن ﻗﯿﻤ ﺔ‬،(‫ وﺗﻌﻨﻲ ﺣﺎﻟﺔ اﺳﻘﺎط وھﻲ اﺧﺘﯿﺎرﯾﺔ )ﯾﻤﻜﻦ ﻋﺪم ذﻛﺮھﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ‬: default
. (value) ‫ﻗﯿﻤﺔ‬
‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻻدﺧﺎل ﻋﺪدﯾﻦ ﻣﻦ اﻟﻨﻮع اﻟﺤﻘﯿﻘﻲ و ﻣ ﺆﺛﺮ ﺣﺴ ﺎﺑﻲ ﯾﺸ ﯿﺮ اﻟ ﻰ اﻟﻌﻤﻠﯿ ﺔ اﻟﺤﺴ ﺎﺑﯿﺔ‬، switch ‫ ﺑﺎﺳﺘﺨﺪام ﺗﺮﻛﯿﺐ اﻻﻧﺘﻘﺎء‬-:(3.4.1)‫ﻣﺜﺎل‬
. ‫ ﻣﻊ ﻃﺒﺎﻋﺔ اﻟﺮﺳﺎﻟﺔ اﻟﻤﻨﺎﺳﺒﺔ أذا ﻟﻢ ﯾﻜﻦ اﻟﻤﺆﺛﺮ اﻟﻤُﺪﺧﻞ ﯾﺸﯿﺮ اﻟﻰ اﺣﺪ اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ اﻻرﺑﻌﺔ‬، (/ , * , - , +) ‫اﻟﻤﺴﺘﺨﺪﻣﺔ‬
#include <stdio.h> : 1 ‫اﻟﺘﻨﻔﯿﺬ‬
main ( ) Enter Two Real Numbers : 2.5 1.7
{ Enter Operator : *
float a , b ; 2.5 * 1.7 = 4.25
char op ;
printf(" Enter Two Real Numbers : ") ; : 2 ‫اﻟﺘﻨﻔﯿﺬ‬
scanf("%f%f" ,&a ,&b) ; Enter Two Real Numbers : -0.9 4.11
printf(" Enter Operator : ") ; Enter Operator : +
scanf("%c",&op) ; -0.9 + 4.11 = 3.21
switch (op)
{ : 3 ‫اﻟﺘﻨﻔﯿﺬ‬
case '+' : printf( "%a + %f = %f" ,a,b,a+b ) ; Enter Two Real Numbers : 1.5 7.67
break ; Enter Operator : ^
case '-' : printf( "%a - %f = %f" ,a,b,a-b ) ; Error Input Operator
break
case'*' :printf( "%a * %f =%f",a,b,a*b ); : 4 ‫اﻟﺘﻨﻔﯿﺬ‬
break ; Enter Two Real Numbers : 2.6 19.2
case '/' : if (b==0) Enter Operator : /
printf(" Error Divide by Zero ") ; 2.6 / 19.2 = 0.135416
else
printf( "%a / %f = %f" ,a ,b ,a/b ) ;
break ;
Default : printf(" Error Input Operator ") ;
}

‫ﻣﺜﺎل)‪ -:(3.4.2‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة ﻣﺘﻐﯿﺮ ﺻﺤﯿﺢ ‪ ،x‬ﺛﻢ أﺣﺴﺐ وأﻃﺒﻊ ﻗﯿﻤﺔ ‪ y‬ﺣﯿﺚ أن‬
‫=‪y‬‬
‫اﻟﺘﻨﻔﯿﺬ ‪: 1‬‬
‫‪Enter Integer Number : 2‬‬
‫) ( ‪main‬‬
‫‪Y= 20‬‬
‫{‬
‫; ‪int x, y‬‬
‫;)" ‪printf(" Enter Integer Number :‬‬
‫; )‪scanf("%d",&x‬‬
‫‪Enter Integer Number : -6‬‬
‫)‪switch (x‬‬
‫‪Error Data out the Range‬‬
‫{‬
‫; ‪case -3: y=3*x-7‬‬
‫; )‪printf("\n Y =%f ", y‬‬
‫; ‪break‬‬
‫‪Y= - 132‬‬
‫‪case 2 :‬‬
‫; ‪case 5 : y=5*x*x‬‬
‫; )‪printf("\n Y =%f ", y‬‬
‫‪Enter Integer Number : -3‬‬
‫; ‪break‬‬
‫‪Y= -16‬‬
‫‪case -4 :‬‬
‫; ‪case 4 : y=x-4*x*x*x‬‬
‫; )‪printf("\n Y =%f ", y‬‬
‫; ‪break‬‬
‫‪Y= 125‬‬
‫;) "‪Default : printf( "\n Error Data out the Range‬‬
‫}‬
‫ﻧﻼﺣﻆ ﻓﻲ اﻟﻤﺜﺎل اﻋﻼه‪ ،‬اﻧﮫ ﺗﻢ ادراج اﻟﺤﺎﻻت اﻟﺘﻲ ﻟﮭﺎ ﻧﻔﺲ اﻟﻤﻌﺎدﻟﺔ اﻟﺤﺎﻟﺔ ﺗﻠﻮ اﻻﺧﺮى ‪،‬واﻻﻛﺘﻔﺎء ﺑﺬﻛﺮ اﻟﻤﻌﺎدﻟ ﺔ وﻋﺒ ﺎرة اﻟﻄﺒﺎﻋ ﺔ ﻓ ﻲ ﻧﮭﺎﯾ ﺔ اﻟﺤﺎﻟ ﺔ‬
‫اﻻﺧﯿﺮة ﻣﻦ اﻟﺤﺎﻻت اﻟﺘﻲ ﻟﮭﺎ ﻧﻔﺲ اﻟﻤﻌﺎدﻟﺔ ‪.‬‬
‫ﺗﻤﺎرﯾﻦ ) اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ (‬
‫ﺗﻤﺮﯾﻦ ‪ : 1‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﯾﻘﺮأ ﺛﻼث ﻣﺘﻐﯿﺮات ﻣﻦ اﻟﻨﻮع اﻟﺤﻘﯿﻘﻲ‪ ،‬ﺛﻢ ﯾﻄﺒﻊ ھﺬه اﻟﻤﺘﻐﯿﺮات ﺑﺘﺮﺗﯿﺐ ﺗﺼﺎﻋﺪي ‪.‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 2‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة أﻃﻮال أﺿﻼع ﻣﺜﻠﺚ ﺛﻢ‪،‬‬

‫‪ .a‬أﻃﺒﻊ ﻛﻠﻤﺔ ‪ EQULLATERAL‬ﻓﻲ ﺣﺎﻟﺔ ﺗﺴﺎوي اﻷﺿﻼع ‪.‬‬
‫‪ .b‬أﻃﺒﻊ ﻛﻠﻤﺔ ‪ ISOSCELES‬ﻓﻲ ﺣﺎﻟﺔ ﻣﺘﺴﺎوي اﻟﺴﺎﻗﯿﻦ ‪.‬‬
‫‪ .c‬أﻃﺒﻊ ﻛﻠﻤﺔ ‪ SCALENE‬ﻓﻲ ﺣﺎﻟﺔ اﺧﺘﻼف اﻷﺿﻼع ‪.‬‬
‫‪ .d‬أﻃﺒﻊ اﻟﻌﺒﺎرة ‪ ERROR TRIANGLE LENGTH‬ﻓﻲ ﺣﺎﻟﺔ ﻋﺪم اﻟﺘﻮاﻓﻖ ﻣﻊ اﻟﺤﺎﻻت اﻟﺜﻼث اﻋﻼه ‪.‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 3‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻻدﺧﺎل ﻣﺘﻐﯿﺮﯾﻦ ﻣﻦ اﻟﻨﻮع اﻟﺼﺤﯿﺢ وﻣﺘﻐﯿﺮ ﺣﺮﻓﻲ ﯾﺪل ﻋﻠﻰ اﻟﺤﺮف اﻷول ﻣﻦ اﻟﻌﻤﻠﯿﺔ اﻟﺤﺴﺎﺑﯿﺔ‬
‫)‪ (Addition, Subtraction, Multiplication, Division‬ﺳﻮاء ﻛﺎن اﻟﺤﺮف ﺻﻐﯿﺮاً أو ﻛﺒﯿﺮاً‪ ،‬ﺛﻢ أﺣﺴﺐ وأﻃﺒﻊ ﻧﺎﺗﺞ اﻟﻌﻤﻠﯿﺔ اﻟﺤﺴﺎﺑﯿﺔ ‪.‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 4‬اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة اﻟﻤﺮﺗﺐ اﻷﺳﺎﺳﻲ ﻟﺒﺎﺋﻊ وﻣﻘﺪار ﻣﺒﯿﻌﺎﺗﮫ‪ ،‬ﺛﻢ ﺣﺴﺎب وﻃﺒﺎﻋﺔ اﻟﺮاﺗﺐ اﻟﺼﺎﻓﻲ ﻟﻠﺒﺎﺋﻊ‪ ،‬ﻋﻠﻤﺎً أن‬
‫اﻟﺮاﺗﺐ اﻟﺼﺎﻓﻲ = اﻟﺮاﺗﺐ اﻷﺳﺎس ‪ +‬اﻟﻤﻜﺎﻓﺌﺔ اﻟﻤﺌﻮﯾﺔ ‪ .‬ﺣﯿﺚ أن اﻟﻤﻜﺎﻓﺌﺔ اﻟﻤﺌﻮﯾﺔ ﺗﺤﺴﺐ ﺑﺎﻟﺼﯿﻐﺔ اﻟﺘﺎﻟﯿﺔ‬
‫‪ 2% .a‬ﻣﻦ ﻣﺮﺗﺒﺔ اﻷﺳﺎﺳﻲ‪ ،‬أذا ﻛﺎﻧﺖ ﻣﺒﯿﻌﺎﺗﮫ أﻗﻞ أو ﺗﺴﺎوي ﺛﻼث أﺿﻌﺎف ﻣﺮﺗﺒﺔ اﻷﺳﺎﺳﻲ‪.‬‬
‫‪ 3% .b‬ﻣﻦ ﻣﺮﺗﺒﺔ اﻷﺳﺎﺳﻲ‪ ،‬أذا ﻛﺎﻧﺖ ﻣﺒﯿﻌﺎﺗﮫ أﻛﺜﺮ ﻣﻦ ﺛﻼث أﺿﻌﺎف ﻣﺮﺗﺒﺔ اﻷﺳﺎﺳﻲ‪.‬‬
‫‪ 5% .c‬ﻣﻦ ﻣﺮﺗﺒﺔ اﻷﺳﺎﺳﻲ‪ ،‬أذا زادت ﻣﺒﯿﻌﺎﺗﮫ ﻋﻠﻰ ﺧﻤﺴﺔ أﺿﻌﺎف ﻣﺮﺗﺒﺔ اﻷﺳﺎﺳﻲ‪.‬‬

‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‪ :‬ﺗﺮاﻛﯿﺐ اﻟﺘﻜﺮارِ )اﻟﺤﻠﻘﺎت( )‪Iteration Structures (Loops‬‬

‫ﺗﺤﺖ ﺷﺮط ﻣﻌ ﯿﻦ ﯾﺘﺤ ﺘﻢ ﻋﻠﯿﻨ ﺎ أﺣﯿﺎﻧ ﺎً ﺗﻨﻔﯿ ﺬ ﺟﻤﻠ ﺔ أو ﻣﺠﻤﻮﻋ ﺔ ﻣ ﻦ اﻟﺠﻤ ﻞ ﻋ ﺪداً ﻣ ﻦ اﻟﻤ ﺮات‪ ،‬وھ ﺬا ﻣ ﺎ ﯾﻮﺻ ﻒ ﺑ ﺎﻟﺘﻜﺮار ‪ .‬ﻓ ﻲ اﻟﻠﻐ ﺔ ‪ C‬ﺗﻮﺟ ﺪ‬
‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺼﯿﻎ اﻟﺘﻲ ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﻣﻔﮭﻮم اﻟﺘﻜﺮار‪ ،‬وﻣﻦ ھﺬه اﻟﺼﯿﻎ ھﻲ ‪while , do…while , for :‬‬
‫)‪ (4.1‬اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﯾﺔ ﺑﯿﻨﻤﺎ )‪(The iteration loop while‬‬
‫)‪while(condition‬‬ ‫اﻟﺼ ﯿﻐﺔ اﻟﻌﺎﻣ ﺔ‬

‫; ‪statement‬‬
‫ﻋﻤﻞ اﻟﺤﻠﻘﺔ ‪ : while‬أﺧﺘﺒﺮ اﻟﺸﺮط )‪ (condition‬أوﻻً‪ ،‬ﻓﺄذا ﻛﺎن اﻟﺸﺮط ﺻﺤﯿﺤﺎً‪ ،‬ﻧﻔﺬ اﻟﺠﻤﻠﺔ )‪ ،(statement‬ﻛﺮر ھﺬا اﻻﺧﺘﺒﺎر واﻟﺘﻨﻔﯿﺬ ﻟﻐﺎﯾﺔ أن‬
‫ﯾﺼﺒﺢ اﻟﺸﺮط ﻏﯿﺮ ﺻﺤﯿﺢ )ﺧﺎﻃﺌﺎً( ‪.‬‬
‫ﻣﻼﺣﻈﺔ)‪ (1) -: (4.1.1‬ﯾﻤﻜﻦ ﺗﻜﺮار ﺗﻨﻔﯿﺬ أﻛﺜﺮ ﻣﻦ ﺟﻤﻠﺔ ﺿﻤﻦ اﻟﺤﻠﻘﺔ ‪ ، while‬ﺑﺸﺮط أن ﺗﻮﺿﻊ ھﺬه اﻟﺠﻤﻞ ﺿﻤﻦ اﻟﺠﻤﻠﺔ اﻟﻤﺮﻛﺒﺔ ) اﻟﺒﻠﻮك ( ‪.‬‬
‫)‪ (2‬ﺗﺴﺘﺨﺪم اﻟﺤﻠﻘﺔ ‪ while‬ﻋﻨﺪﻣﺎ ﯾﻜﻮن ﻋﺪد اﻟﺘﻜﺮارات ﻣﻌﻠﻮم أو ﻏﯿﺮ ﻣﻌﻠﻮم ‪.‬‬
‫)‪ (3‬ﯾﻤﻜﻦ اﺳﺘﺨﺪام أﻛﺜﺮ ﻣﻦ ﺣﻠﻘﺔ ﺗﻜﺮارﯾﺔ ﺑﺼﻮرة ﻣﺘﺪاﺧﻠﺔ ﺿ ﻤﻦ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟﻮاﺣ ﺪ ‪ ،‬وھ ﺬا ﻣ ﺎ أﺻ ﻄﻠﺢ ﻋﻠ ﻰ ﺗﺴ ﻤﯿﺘﺔ اﻟﺤﻠﻘ ﺎت‬
‫اﻟﺘﻜﺮارﯾﺔ اﻟﻤﺘﺪاﺧﻠﺔ ) ‪. ( Nested Iteration Loop‬‬
‫ﻣﺜﺎل)‪-:(4.1.2‬‬
‫‪/*custom countdown using while*/‬‬ ‫‪Enter the starting number : 8‬‬
‫>‪#include <stdio.h‬‬ ‫!‪8, 7, 6, 5, 4, 3, 2, 1, FIRE‬‬
‫)( ‪main‬‬
‫{‬
‫; ‪int n‬‬
‫; ) " ‪printf( "Enter the starting number :‬‬
‫; )‪scanf("%d",&n‬‬
‫)‪while (n>0‬‬
‫{‬
‫; )‪printf( "%d,",n‬‬
‫;‪--n‬‬
‫}‬
‫; ) "!‪printf ( "FIRE‬‬
‫}‬
‫ﻧﻼﺣﻆ ﻣﻦ ﺧﻼل ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧ ﺎﻣﺞ اﻋ ﻼه أﻧ ﮫ ﺗ ﻢ ﺗﺨﺼ ﯿﺺ اﻟﻘﯿﻤ ﺔ ‪ 8‬ﻟﻠﻤﺘﻐﯿ ﺮ ‪، n‬ﺛ ﻢ اﺧﺘﺒ ﺎر اﻟﺸ ﺮط )‪، (n>0‬ﺣﯿ ﺚ أن اﻟﺸ ﺮط ﻛ ﺎن ﺻ ﺤﯿﺤﺎً ﻓ ﺘﻢ ﻃﺒﺎﻋ ﺔ‬
‫اﻟﻘﯿﻤﺔ ‪ 8‬ﺛﻢ أﺻﺒﺤﺖ ﻗﯿﻤﺔ ‪ n=7‬ﻣﻦ ﺧﻼل ﻣﺆﺛﺮ اﻟﻨﻘﺼﺎن ‪ --n‬وﺑﻘﻲ اﻟﺸﺮط ﺻﺤﯿﺤﺎً وھﻜﺬا ﺗﻢ ﺗﻜﺮار اﻟﻌﻤﻠﯿﺔ اﻟﻰ أن أﺻﺒﺤﺖ ﻗﯿﻤﺔ ‪ n=0‬ﻋﻨﺪﺋﺬ أﺻ ﺒﺢ‬
‫اﻟﺸﺮط ﻏﯿﺮ ﺻﺤﯿﺢ وﺑﺎﻟﺘﺎﻟﻲ ﺗﻢ اﻟﺨﺮوج ﻣﻦ اﻟﺤﻠﻘﺔ ﻧﮭﺎﺋﯿﺎً ‪،‬واﻻﻧﺘﻘﺎل اﻟﻰ ﺗﻨﻔﯿﺬ اﻟﻌﺒﺎرة !‪. FIRE‬‬
‫‪4.0,4.5,5.0,5.5,…,9.5,10‬‬ ‫ﻣﺜ ﺎل)‪ -:(4.1.3‬أﻛﺘ ﺐ ﺑﺮﻧﺎﻣﺠ ﺎً ﻟﺤﺴ ﺎب وﻃﺒﺎﻋ ﺔ ﻣﺠﻤ ﻮع اﻷﻋ ﺪاد‬
‫>‪#include <stdio.h‬‬ ‫‪The Total = 87.00‬‬
‫) ( ‪main‬‬
‫{‬
‫; ‪float a=4.0 , sum=0.0‬‬
‫)‪while (a<=10‬‬
‫{‬
‫; ‪sum+=a‬‬
‫; ‪a+=0.5‬‬
‫}‬
‫; )‪printf(" The Total =%f ",sum‬‬
‫}‬

‫ﻣﺜﺎل)‪ -:(4.1.4‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ اﻟﻤﻀﺮوب)‪ (factorial‬ﻟﻸﻋﺪاد ﻣﻦ ‪ 1‬اﻟﻰ ‪ ،10‬ﺣﯿﺚ أن ﻣﻀﺮوب اﻟﻌﺪد ‪ (n! )n‬ﯾﺤﺴﺐ ﻛﺎﻻﺗﻲ ‪:‬‬
‫‪n!=n(n-1)(n-2)…3.2.1‬‬
‫>‪#include <stdio.h‬‬ ‫‪1!= 1‬‬
‫) ( ‪main‬‬ ‫‪2!= 2‬‬
‫{‬ ‫‪3!= 6‬‬
‫; ‪long factorial‬‬ ‫‪4!= 24‬‬
‫; ‪int k ,a=1‬‬ ‫‪5!= 120‬‬
‫)‪while (a<=10‬‬ ‫‪6!= 720‬‬
‫{‬ ‫‪7!= 5040‬‬
‫; ‪factorial=1‬‬ ‫‪8!= 40320‬‬
‫; ‪k=1‬‬ ‫‪9!= 362880‬‬
‫)‪while (k<=a‬‬ ‫‪10!= 3628800‬‬
‫{‬
‫; ‪factorial*=k‬‬
‫; ‪++k‬‬
‫}‬
‫; )‪printf("%d!=%d\n ",a ,factorial‬‬
‫; ‪++a‬‬
‫}‬
‫}‬
‫ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻋﻼه ﺗﻢ ﺗﻨﻔﯿ ﺬ ﺣﻠﻘﺘ ﯿﻦ ﺗﻜ ﺮارﯾﺘﯿﻦ‪ ،‬اﻟﺤﻠﻘ ﺔ أﻻوﻟ ﻰ واﻟﺘ ﻲ ﺗﺴ ﻤﻰ ﺑﺎﻟﺤﻠﻘ ﺔ اﻟﺨﺎرﺟﯿ ﺔ وھ ﻲ ﺗﻨﻔﯿ ﺬ اﻟﺠﻤﻠ ﺔ اﻟﻤﺮﻛﺒ ﺔ ﺑ ﯿﻦ اﻟﻘﻮﺳ ﯿﻦ اﻟﺘ ﺎﺑﻌﯿﻦ ﻟﮭ ﺎ‬
‫ﻃﺎﻟﻤﺎ أن اﻟﻌﺪد ‪ a‬ﻟﻢ ﯾﺘﺠﺎوز ‪ ،10‬ﺗﺄﺗﻲ ﺑﻌﺪھﺎ اﻟﺤﻠﻘﺔ اﻟﺜﺎﻧﯿﺔ واﻟﺘﻲ ﺗﺴﻤﻰ اﻟﺤﻠﻘﺔ اﻟﺪاﺧﻠﯿﺔ وھﻲ أﯾﺠﺎد ﻣﻀﺮوب اﻟﻌﺪد‪ ،‬وذﻟﻚ ﻣﻦ ﺧﻼل اﻟﺠﻤﻠﺘﯿﻦ‬
‫; ‪factorial*=k‬‬
‫; ‪++k‬‬
‫)‪ (4.2‬اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﯾﺔ أﻓﻌﻞ‪...‬ﺑﯿﻨﻤﺎ )‪(The iteration loop do… while‬‬
‫‪do‬‬ ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬

‫; ‪statement‬‬
‫; )‪while(condition‬‬
‫ﻋﻤ ﻞ اﻟﺤﻠﻘ ﺔ ‪ : do…while‬ھ ﺬه اﻟﺤﻠﻘ ﺔ ﻣﺸ ﺎﺑﮫ ﻟﻠﺤﻠﻘ ﺔ اﻟﺘﻜﺮارﯾ ﺔ ‪ while‬وﺗﺨﺘﻠ ﻒ ﻋﻨﮭ ﺎ ﻓ ﻲ أﻣ ﺮﯾﻦ‪ ،‬أوﻻً أن اﻟﺤﻠﻘ ﺔ ‪ do…while‬ﺗﺒ ﺪأ اﻟﺘﻨﻔﯿ ﺬ‬
‫ﻟﻠﺠﻤﻠﺔ)‪ (statement‬ﺛﻢ ﺗﺘﺤﻘﻖ ﻣﻦ اﻟﺸﺮط ﺑﻌﺪ ذﻟﻚ‪ ،‬ﺛﺎﻧﯿﺎ ﯾﺘﻢ اﻟﺘﻔﯿﺬ ﻓﻲ ھﺬه اﻟﺤﻠﻘﺔ ﻣﺮة واﺣﺪة ﻋﻠﻰ اﻻﻗﻞ ﺣﺘﻰ وﻟﻮ ﻛﺎن اﻟﺸﺮط ﻏﯿﺮ ﻣﺘﺤﻘﻖ ‪.‬‬
‫ﻣﺜﺎل)‪ -:(4.2.1‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻻدﺧﺎل وﻃﺒﺎﻋﺔ ﻋﺪد ﺻﺤﯿﺢ‪،‬أوﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻨﺪ أدﺧﺎل ﻋﻨﺪ ادﺧﺎل اﻟﻘﯿﻤﺔ ‪.0‬‬
‫>‪#include <stdio.h‬‬ ‫‪Enter number (0 to end):‬‬ ‫‪1254‬‬
‫) ( ‪main‬‬ ‫‪You entered: 1254‬‬
‫{‬ ‫‪Enter number (0 to end):‬‬ ‫‪160277‬‬
‫; ‪unsigned long n‬‬ ‫‪You entered: 160277‬‬
‫‪do‬‬ ‫‪Enter number (0 to end):‬‬ ‫‪33385‬‬
‫{‬ ‫‪You entered: 33385‬‬
‫; ) " ‪printf( " Enter number (0 to end):‬‬ ‫‪Enter number (0 to end):‬‬ ‫‪0‬‬
‫; )‪scanf("%d%,&n‬‬ ‫‪You entered: 0‬‬
‫; )‪printf( " You entered: %d\n" ,n‬‬
‫; )‪}while (n != 0‬‬
‫}‬

-:(4.2.2)‫ﻣﺜﺎل‬
#include <stdio.h> : 1 ‫اﻟﺘﻨﻔﯿﺬ‬
main ( ) Enter the starting number : 8
{ 8, 7, 6, 5, 4, 3, 2, 1, FIRE!
int n ;
printf( "Enter the starting number : " ) ;
scanf("%d%,&n) ; : 2 ‫اﻟﺘﻨﻔﯿﺬ‬
do Enter the starting number : 0
{ 0, FIRE!
printf( "%d , " , n) ;
--n;
} while (n>0)
printf( "FIRE!" ) ;
}
4.0,4.5,5.0,5.5,…,9.5,10 ‫ أﻛﺘ ﺐ ﺑﺮﻧﺎﻣﺠ ﺎً ﻟﺤﺴ ﺎب وﻃﺒﺎﻋ ﺔ ﻣﺠﻤ ﻮع اﻷﻋ ﺪاد‬-:(4.2.3)‫ﻣﺜ ﺎل‬
#include <stdio.h> The Total = 87.00
main ( )
{
float a=4.0 , sum=0.0 ;
do
{
sum+=a ;
a+=0.5 ;
} while (a<=10) ;
printf( " The Total =%f " ,sum ) ;
}
. 10 ‫ اﻟﻰ‬1 ‫( ﻟﻸﻋﺪاد ﻣﻦ‬factorial)‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ اﻟﻤﻀﺮوب‬-:(4.2.4)‫ﻣﺜﺎل‬
#include <stdio.h> 1!= 1
main ( ) 2!= 2
{ 3!= 6
long factorial ; 4!= 24
int k ,a=1 ; 5!= 120
do 6!= 720
{ 7!= 5040
factorial=1 ; 8!= 40320
k=1 ; 9!= 362880
do 10!= 3628800
{
factorial*=k ;
++k ;
} while (k<=a)
printf("%d!=%d\n ",a ,factorial) ;
++a ;
} while (a<=10)
}

(The iteration loop for) ‫( اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﯾﺔ ﻷﺟﻞ‬4.3)
f o r( i n i t i a l i za t i o n ; c o n d i t i o n ; i n c re a s e ) ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣ ﺔ‬
statement ;
‫ ﺛﺎﻧﯿ ﺎً أﺧﺘﺒ ﺮ اﻟﺸ ﺮط‬،(‫( واﻟﺬي ﯾﻤﺜﻞ اﻟﻘﯿﻤﺔ اﻷوﻟﯿﺔ ﻟﻌﺪاد اﻟﺤﻠﻘ ﺔ)ﻋ ﺪاد اﻟﺤﻠﻘ ﺔ ھ ﻮ ﻋﺒ ﺎرة ﻋ ﻦ ﻣﺘﻐﯿ ﺮ‬initialization) ‫ أوﻻً ﻧﻔﺬ‬: for ‫ﻋﻤﻞ اﻟﺤﻠﻘﺔ‬
‫( واﻟﺬي ﯾﻤﺜﻞ ﻣﻘﺪار اﻟﺰﯾﺎدة أو اﻟﻨﻘﺼﺎن ﺑﻤﻘ ﺪار ﻣﻌ ﯿﻦ ﻓ ﻲ‬increase) ‫ ﺛﺎﻟﺜﺎً ﻧﻔﺬ‬،(statement) ‫ ﻧﻔﺬ اﻟﺠﻤﻠﺔ‬،ً‫ ﻓﺄذا ﻛﺎن اﻟﺸﺮط ﺻﺤﯿﺤﺎ‬، (condition)
. (ً‫ ﻛﺮر اﻟﺨﻄﻮات ﺛﺎﻧﯿﺎً وﺛﺎﻟﺜﺎً ﻟﻐﺎﯾﺔ أن ﯾﺼﺒﺢ اﻟﺸﺮط ﻏﯿﺮ ﺻﺤﯿﺢ )ﺧﺎﻃﺌﺎ‬،‫ﻋﺪاد اﻟﺤﻠﻘﺔ‬
-:(4.3.1)‫ﻣﺜﺎل‬
/*countdown using a for loop */ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FIRE!
#include <stdio.h>
int main ( )
{
int k ;
for (k=10; k>0; k--)
printf("%d,",k);
printf( "FIRE!") ;
}
. 10 ‫ اﻟﻰ‬1 ‫( ﻟﻸﻋﺪاد ﻣﻦ‬factorial)‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ اﻟﻤﻀﺮوب‬-:(4.3.2)‫ﻣﺜﺎل‬
#include <stdio.h> 1!= 1
main ( ) 2!= 2
{ 3!= 6
long factorial ; 4!= 24
int k ,a ; 5!= 120
for (a=1;a<=10;a++) 6!= 720
{ 7!= 5040
factorial=1 ; 8!= 40320
for(k=1;k<=a;k++) 9!= 362880
factorial*=k ; 10!= 3628800
printf("%d!=%d\n ",a ,factorial) ;
}
}
4.0,4.5,5.0,5.5,…,9.5,10 ‫ أﻛﺘ ﺐ ﺑﺮﻧﺎﻣﺠ ﺎً ﻟﺤﺴ ﺎب وﻃﺒﺎﻋ ﺔ ﻣﺠﻤ ﻮع اﻷﻋ ﺪاد‬-: (4.3.3)‫ﻣﺜ ﺎل‬
#include <stdio.h> The Total = 87.00
main ( )
{
float a , sum=0.0 ;
for( a=4.0;a<=10;a+=0.5)
sum+=a ;
printf( " The Total = %f", sum ) ;
}

‫ﻣﺜﺎل)‪ -:(4.3.4‬اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ اﻟﻤﻌﺪل ﻟﻤﺠﻤﻮﻋﺔ ﻣﻦ اﻻﻋﺪاد اﻟﺤﻘﯿﻘﯿﺔ واﻟﺘﻲ ﻋﺪدھﺎ ‪. n‬‬
‫>‪#include <stdio.h‬‬ ‫‪Enter The Size of The List : 7‬‬
‫) ( ‪main‬‬ ‫‪The Data : 12.5 -10.04 35 1.432 7.7 101.1 34.567‬‬
‫{‬ ‫‪The Average of all Numbers = 26.037‬‬
‫; ‪int n, counter‬‬
‫; ‪float number, sum, average‬‬
‫; ‪sum=0.0‬‬
‫; ) " ‪printf( "Enter The Size of The List :‬‬
‫; )‪scanf("%d",&number‬‬
‫; )" ‪printf("\nThe Data :‬‬
‫)‪for( counter=0;counter<n;counter++‬‬
‫{‬
‫; )‪scanf("%",&number‬‬
‫; ‪sum+=number‬‬
‫}‬
‫; ‪average=sum/n‬‬
‫; ) ‪printf( "\n The Average of all Numbers =%f ",average‬‬
‫}‬
‫)‪ (4.4‬اﻟﺠﻤﻞ اﻟﺘﻔﺮﻋﯿﺔ )‪(Branching Statement‬‬
‫ﻓﻲ ﺑﻌﺾ اﻟﺒﺮأﻣﺞ ﯾﺘﻌﯿﻦ ﻋﻠﯿﻨﺎ ﺗﺤﻮﯾﻞ اﻟﻤﺴﺎر اﻟﺘﺘﺎﺑﻌﻲ ﻻواﻣﺮ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﻰ اﻟﺨ ﺮوج ﻣ ﻦ اﻟﺤﻠﻘ ﺎت اﻟﺘﻜﺮارﯾ ﺔ أو اﻟﺮﺟ ﻮع اﻟﯿﮭ ﺎ أو اﻟﺨ ﺮوج ﻧﮭﺎﺋﯿ ﺎً‬
‫ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬اﻟﺠﻤﻞ اﻟﺘﻔﺮﻋﯿﺔ ﺗﺴﺎﻋﺪﻧﺎ ﻓﻲ ھﺬه اﻟﻌﻤﻠﯿﺔ‪ ،‬وﻟﻜﻦ ﯾﺠﺐ أن ﯾﻜﻮن أﺳﺘﺨﺪام ھﺬه اﻟﺠﻤﻞ ﻣﺤ ﺪود‪،‬ﻻﻧ ﮫ اﺣﯿﺎﻧ ﺎ وﻓ ﻲ اﻟﺒ ﺮأﻣﺞ اﻟﻜﺒﯿ ﺮة ﺗﺴ ﺒﺐ ﻟﻨ ﺎ‬
‫ﻣﺸﺎﻛﻞ أﺛﻨﺎء اﻟﺘﻨﻔﯿﺬ ‪ .‬ﻣﻦ ھﺬه اﻟﺠﻤﻞ ھﻲ ‪:‬‬
‫)‪ (1‬ﺟﻤﻠﺔ أﻗﻄﻊ ‪ : Break‬ﺗﺴﺘﺨﺪم ھﺬه اﻟﺠﻤﻠﺔ ﻟﻠﺨﺮوج ﻣﻦ اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﯾﺔ‪ ،‬ﺣﯿﺚ ﯾﺘﻢ أﻧﮭﺎء اﻟﺘﻜﺮار ﻣﺘﻰ ﻣﺎ وﺻ ﻞ اﻟﺘﻨﻔﯿ ﺬ اﻟ ﻰ ھ ﺬه اﻟﺠﻤﻠ ﺔ‪.‬‬
‫ﻧﺘﺬﻛﺮ ﺑﺄن ھﺬه اﻟﺠﻤﻠﺔ اﺳﺘﺨﺪﻣﺖ ﻟﻨﻔﺲ اﻟﻤﻌﻨﻰ ﻓﻲ ﻣﻮﺿﻮع اﻟﺘﺮﻛﯿﺐ اﻻﻧﺘﻘﺎﺋﻲ ‪. switch‬‬
‫ﻣﺜﺎل)‪-: (4.4.1‬‬
‫‪/*break loop example*/‬‬ ‫!‪10, 9, 8, 7, 6, 5, 4, 3, countdown aborted‬‬
‫) ( ‪main‬‬
‫{‬
‫; ‪int n‬‬
‫)‪for (n=10; n>0; n--‬‬
‫{‬
‫; )‪printf("%d ," ,n‬‬
‫)‪if (n==3‬‬
‫{‬
‫; )"!‪printf("countdown aborted‬‬
‫; ‪break‬‬
‫}‬
‫}‬
‫}‬
‫ﺗﻢ اﻟﺘﻔﯿﺬ ﺑﻄﺒﺎﻋﺔ اﻻﻋﺪاد ﻣﻦ ‪ 10‬وﻟﻐﺎﯾﺔ ‪ 3‬ﺛﻢ ﻃﺒﻌ ﺖ اﻟﻌﺒ ﺎرة !‪ countdown aborted‬ﺑﻌ ﺪھﺎ ﺗ ﻢ اﻟﺘﻮﻗ ﻒ واﻟﺨ ﺮوج ﻣ ﻦ اﻟﺤﻠﻘ ﺔ اﻟﺘﻜﺮارﯾ ﺔ وذﻟ ﻚ ﻟﻜ ﻮن‬
‫اﻟﺸﺮط ﻗﺪ ﺗﺤﻘﻖ ﻓﻲ اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﺒﺴﯿﻂ ‪. if‬‬

‫)‪ (2‬ﺟﻤﻠﺔ اﻻﺳ ﺘﻤﺮار ‪ : Continue‬ﺗﺴ ﺘﺨﺪم ھ ﺬه اﻟﺠﻤﻠ ﺔ ﺑﺎﻻﺳ ﺘﻤﺮار ﻓ ﻲ ﺗﻮﺟﯿ ﮫ اﻟ ﺘﺤﻜﻢ اﻟ ﻰ ﻧﮭﺎﯾ ﺔ اﻟﺤﻠﻘ ﺔ وﺑﺎﻟﺘ ﺎﻟﻲ اﻟﺮﺟ ﻮع اﻟ ﻰ ﺑﺪاﯾ ﺔ اﻟﺤﻠﻘ ﺔ‬
‫وأﻛﻤﺎل ﺗﻨﻔﯿﺬھﺎ ﺣﺘﻰ اﻟﻨﮭﺎﯾﮫ ‪.‬‬
‫ﻣﺜﺎل)‪-: (4.4.2‬‬
‫‪/* continue loop example*/‬‬ ‫!‪10, 9, 8, 7, 6, 4, 3, 2, 1, FIRE‬‬
‫) ( ‪main‬‬
‫{‬
‫; ‪int n‬‬
‫)‪for (n=10; n>0; n--‬‬
‫{‬
‫)‪if (n==5‬‬
‫; ‪continue‬‬
‫; )‪printf("%d ," ,n‬‬
‫}‬
‫; )"!‪printf( "FIRE‬‬
‫}‬
‫)‪ (3‬ﺟﻤﻠﺔ ﺧﺮوج ‪: Exit‬وﺗﻌﻨﻲ اﻟﺨﺮوج ﻧﮭﺎﺋﯿ ﺎً ﻣ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ وﺗﺮﺟ ﻊ ﺑﺎﻟﻘﯿﻤ ﺔ ﺻ ﻔﺮاً اذا ﻛ ﺎن اﻟﺒﺮﻧ ﺎﻣﺞ ﻧﻔ ﺬ ﻋﻠ ﻰ أﺣﺴ ﻦ ﻣ ﺎ ﯾ ﺮام‪ ،‬وﺑ ﺄي ﻗﯿﻤ ﺔ ﻻ‬
‫ﺗﺴﺎوي ﺻﻔﺮاً اذا ﻛﺎن ھﻨﺎك ﺧﻄﺄ‪.‬‬
‫ﻣﺜﺎل)‪-: (4.4.3‬‬
‫) ( ‪main‬‬ ‫‪Enter value : 9‬‬
‫{‬ ‫‪Enter value : 4‬‬
‫;‪int i, number, sum=0‬‬ ‫‪Enter value : 6‬‬
‫)‪for (i=1;i<10;i++‬‬ ‫‪Enter value : 8‬‬
‫{‬ ‫‪Enter value : 1‬‬
‫; ) "‪printf("\nEnter value :‬‬ ‫‪Enter value : 12‬‬
‫; )‪scanf("%d",&number‬‬ ‫‪Enter value : -7‬‬
‫)‪if (number< 0‬‬ ‫‪This is negative‬‬
‫{‬
‫; )" ‪printf("This is negative‬‬
‫;) (‪exit‬‬
‫}‬
‫; ‪sum+=number‬‬
‫}‬
‫; )‪printf("The sum of positive numbers %d", sum‬‬
‫}‬
‫ﻋﻨﺪﻣﺎ ﯾﻜﻮن اﻟﺸﺮط اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﺒﺴﯿﻂ ‪ if‬ﺻﺤﯿﺤﺎً ﺗﻄﺒﻊ اﻟﺮﺳﺎﻟﺔ اﻟﻤﻄﻠﻮﺑﺔ‪،‬ﺛﻢ ﺗﻨﻔﺬ ﺟﻤﻠ ﺔ اﻟﺨ ﺮوج )(‪ exit‬اﻟﺘ ﻲ ﺗﻌﻨ ﻲ اﻟﺨ ﺮوج‬
‫ﻟﯿﺲ ﻓﻘﻂ ﻣﻦ اﻟﺤﻠﻘﺔ ‪ for‬ﺑﻞ اﻟﺨﺮوج ﻧﮭﺎﺋﯿﺎً ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ وﺑﺎﻟﺘﺎﻟﻲ ﻟﻦ ﺗﻨﻔﺬ اﻟﺠﻤﻠﺔ اﻟﻤﻮاﻟﯿ ﺔ ﻟﮭ ﺬه اﻟﺤﻠﻘ ﺔ‪ ،‬وﻋﻠﯿ ﺔ ﻟ ﻦ ﯾﻄﺒ ﻊ اﻟﺒﺮﻧ ﺎﻣﺞ ﻣﺠﻤ ﻮع اﻻﻋ ﺪاد‬
‫اﻟﻤﻮﺟﺒﺔ اﻟﻤﺪﺧﻠﺔ‪ ،‬وھﺬا ﻣﺎ ﻧﺸﺎھﺪة ﻓﻲ اﻟﺘﻨﻔﯿﺬ اﻋﻼه ‪.‬‬
‫)‪ (4‬ﺟﻤﻠﺔ أذھﺐ اﻟﻰ ‪ : goto‬ﺗﺴﺘﺨﺪم ھﺬه اﻟﺠﻤﻠﺔ ﺑﺘﺤﻮﯾﻞ اﻟﻤﺴﺎر اﻟﺘﺘﺎﺑﻌﻲ ﻻواﻣﺮ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻰ ﺟﻤﻠﺔ ﻣﻌﯿﻨﺔ‪.‬‬
‫; ‪goto lable‬‬ ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬

‫ﺣﯿﺚ ‪ label‬اﺳﻢ اﻟﻌﻨﻮان وﯾﻨﻄﺒﻖ ﻋﻠﯿﮫ ﻧﻔﺲ ﺷﺮوط اﺳﻢ اﻟﻤﺘﻐﯿﺮ ﺣﯿﺚ ﯾﻤﻜﻦ وﺿﻌﮫ ﻓﻲ أي ﻣﻜﺎن ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫ﻣﺜﺎل)‪-: (4.4.4‬‬
‫‪/*goto loop example*/‬‬ ‫!‪10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FIRE‬‬
‫) ( ‪main‬‬
‫{‬
‫; ‪int n=10‬‬
‫‪last :‬‬
‫; )‪printf("%d ," ,n‬‬
‫;‪n--‬‬
‫)‪if (n>0‬‬
‫; ‪goto last‬‬
‫; ) "‪printf( "FIRE!\n‬‬
‫}‬
‫ﻧﻼﺣﻆ أن اﻟﺸﺮط ﻛﻠﻤﺎ ﻛﺎن ﺻﺤﯿﺤﺎً ﻓﺄن اﻟﻌﺒﺎرة ‪ goto‬ﻣﺘﺤﻘﻘﺔ وﺑﺎﻟﺘﺎﻟﻲ ﻓﺎن اﻟﺘﻔﯿﺬ ﯾﻨﺘﻘﻞ اﻟﻰ اﻟﻌﻨﻮان ‪ last :‬اﻟ ﻰ أن ﯾﺼ ﺒﺢ اﻟﺸ ﺮط ﻏﯿ ﺮ ﺻ ﺤﯿﺢ‬
‫ﻋﻨﺪﺋﺬ ﯾﻨﺘﻘﻞ اﻟﺘﻨﻔﯿﺬ اﻟﻰ ﻃﺒﺎﻋﺔ اﻟﻌﺒﺎرة !‪. FIRE‬‬
‫ﺗﻤﺎرﯾﻦ ) اﻟﻔﺼﻞ اﻟﺮاﺑﻊ(‬
‫ﺗﻤﺮﯾﻦ ‪ : 1‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ ﺣﺎﺻﻞ ﺟﻤﻊ ﻣﺮﺑﻌﺎت اﻻﻋﺪاد اﻟﺼﺤﯿﺤﺔ اﻟﻔﺮدﯾﺔ اﻟﻮاﻗﻌﺔ ﺑﯿﻦ ﻋﺪدﯾﻦ ﯾﺘﻢ ادﺧﺎﻟﮭﻤﺎ ﻋﻦ ﻃﺮﯾﻖ ﻟﻮﺣﮫ‬
‫اﻟﻤﻔﺎﺗﯿﺢ ‪.‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 2‬اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻻﯾﺠﺎد ﺟﻤﯿﻊ اﻻﻋﺪاد اﻻوﻟﯿﺔ اﻟﻮاﻗﻌﺔ ﺑﯿﻦ ‪ 1‬و ‪. 100‬‬
‫ﺗﻤﺮﯾﻦ‪ : 3‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ ﻣﺠﻤﻮع اﻟﻤﺘﺴﻠﺴﻠﺔ اﻟﺘﺎﻟﯿﺔ ‪:‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 4‬ﻓﺼﻞ دراﺳﻲ ﺑﮫ ﻋﺪد ﻏﯿﺮ ﻣﻌﺮوف ﻣﻦ اﻟﻄﻼب‪ ،‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة رﻗﻢ اﻟﻄﺎﻟﺐ ‪ ID‬وﺟﻨﺴﺔ ‪ SEX‬ودرﺟﺎﺗﮫ ﻓﻲ ﺛﻼث اﻣﺘﺤﺎﻧﺎت ‪T1‬‬
‫‪، , T2 , T3‬أوﻗﻒ ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻨﺪ ادﺧﺎل رﻗﻢ اﻟﻄﺎﻟﺐ ﻗﯿﻤﺔ ﺳﺎﻟﺒﺔ ‪ ،‬اﻟﻤﻄﻠﻮب ‪:‬‬
‫ﺣﺴﺎب وﻃﺒﺎﻋﺔ ﻣﻌﺪل اﻟﺪرﺟﺎت ﻟﻜﻞ ﻃﺎﻟﺐ ‪.‬‬ ‫‪.a‬‬

‫ﺣﺴﺎب وﻃﺒﺎﻋﺔ ﻋﺪد اﻟﻄﺎﻟﺒﺎت ﻓﻲ اﻟﺼﻒ ‪.‬‬ ‫‪.b‬‬
‫أﯾﺠﺎد وﻃﺒﺎﻋﺔ أﻛﺒﺮ ﻣﻌﺪل ﻓﻲ اﻟﺼﻒ ‪.‬‬ ‫‪.c‬‬
‫ﻃﺒﺎﻋﺔ رﻗﻢ اﻟﻄﺎﻟﺐ وﻣﻌﺪﻟﮫ ﻣﻊ اﻟﻨﺘﯿﺠﺔ اﻟﻤﻘﺎﺑﻠﺔ ﻟﻤﻌﺪﻟﮫ واﻟﺘﻲ ھﻲ ﻋﻠﻰ اﻟﻨﺤﻮ اﻻﺗﻲ ‪:‬‬ ‫‪.d‬‬
‫اﻟﻨﺘﯿﺠﺔ‬ ‫ﺣﺪود اﻟﻤﻌﺪل‬
‫‪Fail‬‬ ‫أﺻﻐﺮ ﻣﻦ ‪50‬‬
‫‪Admit table‬‬ ‫أﻛﺒﺮ ﻣﻦ أو ﯾﺴﺎوي ‪ 50‬وأﺻﻐﺮ ﻣﻦ ‪60‬‬
‫‪Medial‬‬ ‫أﻛﺒﺮ ﻣﻦ أو ﯾﺴﺎوي ‪ 60‬وأﺻﻐﺮ ﻣﻦ ‪70‬‬
‫‪Good‬‬ ‫أﻛﺒﺮ ﻣﻦ أو ﯾﺴﺎوي ‪ 70‬وأﺻﻐﺮ ﻣﻦ ‪80‬‬
‫‪Very Good‬‬ ‫أﻛﺒﺮ ﻣﻦ أو ﯾﺴﺎوي ‪ 80‬وأﺻﻐﺮ ﻣﻦ ‪90‬‬
‫‪Excellence‬‬ ‫أﻛﺒﺮ ﻣﻦ أ وﯾﺴﺎوي ‪ 90‬وأﺻﻐﺮ ﻣﻦ ‪100‬‬

‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ‪ :‬اﻟﻤﺼﻔﻮﻓﺎت )‪(Arrays‬‬

‫ﻓﻲ اﻟﻔﺼﻮل اﻟﺘﻲ ﻣﺮت ﺑﻨ ﺎ ﺳ ﺎﺑﻘﺎً ‪،‬ﻛ ﺎن اﺳ ﻢ اﻟﻤﺘﻐﯿ ﺮ ﯾﺤﻤ ﻞ ﻗﯿﻤ ﺔ واﺣ ﺪة ﻓﻘ ﻂ ﻗﺎﺑﻠ ﺔ ﻟﻠﺘﻐﯿ ﺮ أﺛﻨ ﺎء ﺗﻨﻔﯿ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ‪،‬ﻓ ﻲ ﺣ ﯿﻦ أﻧ ﮫ ھﻨ ﺎك ﻣﺠﻤﻮﻋ ﺔ ﻣ ﻦ‬
‫اﻟﺒﯿﺎﻧﺎت اﻟﺘﻲ ﻟﮭﺎ ﻧﻔﺲ اﻟﻨﻮع واﻟﺘﻲ ﺗﺤﺘﺎج اﻟﻰ ﻋﻤﻠﯿﺔ ﺗﺨﺰﯾﻦ ﻓﻲ ﻣﺘﻐﯿﺮات ﻗﻠﯿﻠﺔ‪ ،‬وﻟﻜﻲ ﯾﺼﺒﺢ اﻟﺒﺮﻧ ﺎﻣﺞ ﺳ ﮭﻞ اﻟﻜﺘﺎﺑ ﺔ واﻟﻤﺘﺎﺑﻌ ﺔ واﻟﻔﮭ ﻢ ‪،‬ﻋﻠﯿﻨ ﺎً اﺳ ﺘﺨﺪام‬
‫ﻣﻔﮭﻮم اﻟﻤﺼﻔﻮﻓﺔ ) ھﻨﺎ اﻟﻤﺼﻔﻮﻓﺔ ﻋﺒﺎرة ﻋﻦ ﺳﻠﺴﻠﺔ ﻣ ﻦ اﻟﻌﻨﺎﺻ ﺮ اﻟﺘ ﻲ ﻟﮭ ﺎ ﻧﻔ ﺲ اﻟﻨ ﻮع واﻟﻤﻮﺿ ﻮﻋﺔ ﻓ ﻲ اﻟ ﺬاﻛﺮة ﺑﺸ ﻜﻞ ﻣﺘﺠ ﺎور واﻟﺘ ﻲ ﺗﺤﻤ ﻞ اﺳ ﻤﺎً‬
‫واﺣﺪاً ﺑﺤﯿﺚ ﯾﻤﻜﻦ اﻟﺮﺟﻮع اﻟﻰ ھﺬه اﻟﻌﻨﺎﺻﺮ واﻟﺘﻌﺎﻣﻞ ﻣﻌﮭﺎ ﻋﻦ ﻃﺮﯾﻖ ھﺬا اﻻﺳﻢ ( ‪.‬‬
‫وﺗﻘﺴﻢ اﻟﻤﺼﻔﻮﻓﺎت اﻟﻰ ﻗﺴﻤﯿﻦ وھﻤﺎ ‪:‬‬
‫اﻟﻘﺴﻢ أﻻول ‪ :‬ﻣﺼﻔﻮﻓﺎت ذات اﻟﺒﻌﺪ اﻟﻮاﺣﺪ )‪. (One-Dimensional Arrays‬‬
‫اﻟﻘﺴﻢ اﻟﺜﺎﻧﻲ ‪ :‬ﻣﺼﻔﻮﻓﺎت ﻣﺘﻌﺪدة اﻻﺑﻌﺎد )‪. (Multi-Dimensional Arrays‬‬
‫ﻣﻼﺣﻈﺔ ‪ -:‬ﻓﻲ ﻟﻐﺔ ‪ C‬ﯾﻮﺟﺪ اﻻﻣﺮ ‪ #define‬اﻟﺬي ﯾﻌﺘﺒﺮ ﻣﻦ أواﻣﺮ اﻟﻤﻌ ﺎﻟﺞ اﻷوﻟ ﻲ )‪ (Preprocessor‬واﻟ ﺬي ﯾﻘ ﻮم ﺑﺄﻧﺸ ﺎء ﻣﻌﺮﻓ ﺎت ﺗﺴ ﻤﻰ اﻟﺜﻮاﺑ ﺖ‬
‫اﻟﺮﻣﺰﯾﺔ)‪ (Symbolic Constants‬ﺣﯿﺚ ﯾﻤﻜﻦ وﺿﻌﺔ ﻓﻲ أي ﻣﻜﺎن ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ وﻟﻜﻦ ﻣﻦ اﻷﻓﻀﻞ ﻣﺎ ﯾﻮﺿ ﻊ ﻓ ﻲ أوﻟ ﮫ‪،‬أي ﺑﻌ ﺪ ﺟﻤ ﻞ ‪. #include‬‬
‫ﻓﻲ ﻛﺜﯿﺮ ﻣﻦ اﻟﺒﺮاﻣﺞ ﯾﺴﺘﺨﺪم ھﺬا اﻻﻣﺮ ﻓﻲ اﻻﻋﻼن ﻋﻦ ﻋﺪد ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬
‫‪#define Constant_name‬‬ ‫; ‪value‬‬ ‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻼﻣﺮ‬
‫‪#define PI 3.141519‬‬ ‫ﻣﺜﺎل ‪-:‬‬

‫‪#define MAX 15‬‬
‫"‪#define STRING "This is a string‬‬
‫)‪ (5.1‬اﻟﻤﺼﻔﻮﻓﺎت ذات اﻟﺒﻌﺪ اﻟﻮاﺣﺪ ‪-:‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻼﻋﻼن ﻋﻦ ﻣﺼﻔﻮﻓﺔ ذات ﺑﻌﺪ واﺣﺪ‬
‫; ]‪Type Array_name [index‬‬
‫ﺣﯿﺚ‬
‫‪ : Type‬ﯾﻤﺜﻞ ﻧﻮع اﻟﺒﯿﺎﻧﺎت ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫‪ : Array_name‬ﯾﻤﺜﻞ اﺳﻢ اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫‪ : index‬ﯾﻤﺜﻞ ﻋﺪد ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬
‫; ]‪int billy[5‬‬ ‫ﻣﺜﺎل)‪ -: (5.1.1‬ﯾﻤﻜﻦ اﻻﻋﻼن ﻋﻦ ‪ 5‬ﻗﯿﻢ ﺻﺤﯿﺤﺔ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻣﺎ وﺑﺪون اﺳﺘﺨﺪام ‪ 5‬ﻣﺘﻐﯿﺮات ﻣﺨﺘﻠﻔﺔ ‪ .‬ﻓﻤﺜﻼً‬
‫ﺣﯿﺚ أن اﺳﻢ اﻟﻤﺼﻔﻮﻓﺔ ھﻨﺎ ‪ billy‬وﻋﻨﺎﺻﺮھﺎ ﻣ ﻦ اﻟﻨ ﻮع اﻟﺼ ﺤﯿﺢ‪ ،‬ﻧﻼﺣ ﻆ اﻟﺸ ﻜﻞ اﻟﺘ ﺎﻟﻲ واﻟ ﺬي ﯾُﻈﮭ ﺮ ﻛﯿ ﻒ ﯾ ﺘﻢ ﺣﺠ ﺰ ﻣﻮاﻗ ﻊ ﻓ ﻲ اﻟ ﺬاﻛﺮة‬
‫ﻟﻌﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪. billy‬‬
‫ﺣﯿﺚ ان ﻛﻞ ﺧﺎﻧﺔ ﺗﻀﻢ ﻋﻨﺼﺮ ﻣﻦ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ واﻟﺬي ﯾﻜﻮن ﻣﻦ اﻟﻨﻮع اﻟﺼﺤﯿﺢ‪ ،‬دﻟﯿﻞ)‪ (index‬ھﺬه اﻟﻘﯿﻢ رُﻗﻢ ﻣﻦ ‪ 0‬اﻟﻰ ‪، 4‬ﻻﻧﮫ داﺋﻤﺎً ﻓ ﻲ ﻟﻐ ﺔ‬
‫‪ C‬اﻟﻌﻨﺼ ﺮ اﻷول ﻓ ﻲ اﻟﻤﺼ ﻔﻮﻓﺔ ﯾﻜ ﻮن دﻟﯿﻠ ﺔ ‪. 0‬ﻓﻤ ﺜﻼً اﻟﻌﻨﺼ ﺮ اﻻول ﻓ ﻲ اﻟﻤﺼ ﻔﻮﻓﺔ ھ ﻮ ]‪ billy[0‬ﺑﯿﻨﻤ ﺎ اﻟﻌﻨﺼ ﺮ اﻟﺜ ﺎﻧﻲ ھ ﻮ ]‪ billy[1‬وھ ﺬا اﻟ ﻰ‬
‫اﻟﻌﻨﺼﺮ اﻻﺧﯿﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ وھﻮ ]‪ . billy[4‬ﻛﻤﺎ ﻧﻼﺣﻆ ﻓﻲ اﻟﺸﻜﻞ اﻻﺗﻲ ‪:‬‬
‫اﻟﻘﯿﻢ اﻷﺑﺘﺪاﺋﯿﺔ ﻟﻠﻤﺼﻔﻮﻓﺔ ذات اﻟﺒﻌﺪ اﻟﻮاﺣﺪ)‪ -: (Initial Values‬ﯾﻤﻜﻦ ﺗﺨﺼﯿﺺ أو ﺷﺤﻦ ﻗﯿﻢ ﻣﺒﺪﺋﯿﺔ ﻷي ﻣﺼﻔﻮﻓﺔ ﻋﻦ ﻃﺮﯾﻖ ‪:‬‬
‫أوﻻً ‪ -:‬اﺛﻨﺎء اﻻﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺔ‪ .‬واﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ھﻲ‬
‫; } ‪Type Array_name [index]= { value_1,value_2,…,value_n‬‬
‫ﺣﯿﺚ ‪ value_1,value_2,…,value_n‬ﺗﻤﺜﻞ ﻗﯿﻢ اﻟﻤﺼﻔﻮﻓﺔ ﻋﻠﻰ اﻟﺘﺮﺗﯿﺐ ‪.‬ھﻨﺎ ﻋﺪد اﻟﻌﻨﺎﺻﺮ ھﻮ ‪ n‬واﻟﺬي ﯾﻤﺜﻞ ‪. index‬‬

. int billy[5]={ 16, 2, 77, 40, 12071 } ; ‫ ﻟﺘﻜﻦ ﻟﺪﯾﻨﺎ اﻟﻤﺼﻔﻮﻓﺔ‬-: (5.1.2)‫ﻣﺜﺎل‬
: ‫ﻛﻤﺎ ﻧﻼﺣﻆ ﻓﻲ اﻟﺸﻜﻞ اﻻﺗﻲ‬، billy[0]=16 , billy[1]=2 , billy[2]=77 , billy[3]=40 , billy[4]=12071 ‫ھﻨﺎ‬
.scanf( )‫ ﻋﻦ ﻃﺮﯾﻖ داﻟﺔ اﻻدﺧﺎل‬-: ً‫ﺛﺎﻧﯿﺎ‬
for (i=0 ;i<5 ; i++) -: (5.1.3)‫ﻣﺜﺎل‬

scanf("%d",&billy[i]) ;
. ‫ﺛﻢ ﯾﺘﻢ أدﺧﺎل اﻟﻘﯿﻢ ﻋﻦ ﻃﺮﯾﻖ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﯿﺢ‬
‫ ﺛ ﻢ ﻃﺒﺎﻋ ﺔ ﻗ ﯿﻢ اﻟﻤﺼ ﻔﻮﻓﺔ‬billy ‫ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﯾﺘﻢ ﺗﺨﺼﯿﺺ أرﺑﻌﺔ ﻗﯿﻢ ﻣﻦ اﻟﻨﻮع اﻟﺼﺤﯿﺢ اﻟﻰ ﻣﺼ ﻔﻮﻓﺔ ذات ﺑﻌ ﺪ واﺣ ﺪ أﺳ ﻤﮭﺎ‬-: (5.1.4)‫ﻣﺜﺎل‬
. ‫ﻣﻊ ﻣﺠﻤﻮع ﺗﻠﻚ اﻟﻘﯿﻢ‬
/*arrays example*/ billy[0]= 16
#include <stdio.h> billy[1]= 2
#define M 5 billy[2]= 77
main () billy[3]= 40
{ billy[4]= 12071
int billy [M] = {16, 2, 77, 40, 12071}; The sum = 12206
int n, result=0;
for ( n=0 ; n<5 ; n++ )
{
printf( " billy[%d]=%d\n", n, billy[n]) ;
result += billy[n];
}
printf( " The sum =%d ", result) ;
}
.‫ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﯾﺘﻢ ﻓﯿﺔ ادﺧﺎل وﻃﺒﺎﻋﺔ ﻋﻨﺎﺻﺮ ﻣﺼﻔﻮﻓﮫ ذات ﺑﻌﺪ واﺣﺪ وأﯾﺠﺎد وﻃﺒﺎﻋﺔ أﺻﻐﺮ ﻋﻨﺼﺮ ﻓﻲ ھﺬه اﻟﻤﺼﻔﻮﻓﮫ‬-: (5.1.5)‫ﻣﺜﺎل‬
#include <stdio.h> mat[0]= 3
#define LEN 5 mat[1]= 8
main ( ) mat[2]= 7
{ mat[3]= 2
int i, min ,pos , mat[LEN] ; mat[4]= 4
for(i=0 ; i< LEN ; i++)
{ The Smallest is mat[3]= 2
scanf("%d",&mat[i]) ;
printf( " mat[%d]=%d\n", i, mat[i]) ;
}
min=mat[0] ;
for(i=1 ; i< LEN ; i++)
if (mat[i] < min)
{
min=mat[i] ;
pos=i ;
}
printf( " The Smallest is mat[%d]=",pos, min) ;
}

‫ﻣﺜﺎل)‪ -: (5.1.6‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة ﻗﯿﻢ ﺣﻘﯿﻘﯿﺔ ﻟﻤﺼﻔﻮﻓﺔ ‪ a‬ﻋﺪد ﻋﻨﺎﺻﺮھﺎ ‪ ، 6‬ﺛﻢ رﺗﺐ ھﺬه اﻟﻌﻨﺎﺻﺮ ﺗﺼﺎﻋﺪﯾﺎً وﺿﻌﮭﺎ ﻓﻲ ﻣﺼﻔﻮﻓﮫ ﺟﺪﯾﺪة ‪. b‬‬
‫>‪#include <stdio.h‬‬ ‫‪a[0]= 2.5‬‬
‫‪#define M 6‬‬ ‫‪a[1]= 9.1‬‬
‫) ( ‪main‬‬ ‫‪a[2]= 6.06‬‬
‫{‬ ‫‪a[3]= 2.51‬‬
‫; ‪int i, j ,n1 , n2‬‬ ‫‪a[4]= 0.05‬‬
‫; ]‪float temp, a[M‬‬ ‫‪a[5]= 3.0‬‬
‫)‪for(i=0 ; i< M ; i++‬‬
‫{‬ ‫‪The Sorted Array as following :‬‬
‫; )]‪scanf("%f", a[i‬‬ ‫‪b[0]= 0.05‬‬
‫; )]‪printf( " a[%d]=%f\n", i, a[i‬‬ ‫‪b[1]= 2.50‬‬
‫}‬ ‫‪b[2]= 2.51‬‬
‫; ‪n1=M-1‬‬ ‫‪b[3]= 3.00‬‬
‫)‪for(i=1 ; i< n1 ; i++‬‬ ‫‪b[4]= 6.06‬‬
‫{‬ ‫‪b[5]= 9.10‬‬
‫; ‪n2=i+1‬‬
‫)‪for(j=n2 ; j< M ; j++‬‬
‫{‬
‫)‪if(a[j]-a[i]< 0‬‬
‫{‬
‫; ]‪temp=a[i‬‬
‫; ]‪a[i]=a[j‬‬
‫; ‪a[j]=temp‬‬
‫}‬
‫}‬
‫}‬
‫; )" ‪printf(" The Sorted Array as following :\n‬‬
‫)‪for(i=0 ; i<M ; i++‬‬
‫; )]‪printf( " b[%d]=%f\n", i, a[i‬‬
‫}‬
‫)‪ (5.2‬اﻟﻤﺼ ﻔﻮﻓﺎت ﻣﺘﻌ ﺪدة اﻻﺑﻌ ﺎد ‪ -:‬ﺳ ﻮف ﻧﺨﺼ ﺺ دراﺳ ﺘﻨﺎ ﻓ ﻲ ھ ﺬا اﻟﺒﻨ ﺪ ﺣ ﻮل اﻟﻤﺼ ﻔﻮﻓﺎت ذات اﻟﺒﻌ ﺪﯾﻦ ) اﻟﻤﺼ ﻔﻮﻓﺎت اﻟﻤﻜﻮﻧ ﺔ ﻣ ﻦ‬
‫ﺻﻔﻮف واﻋﻤﺪة ( ﻓﻘﻂ‪ ،‬ﺣﯿﺚ ﯾﻤﻜﻦ أن ﺗﻌﻤﻢ اﻟﺪراﺳﮫ اﻟﻰ ﻣﺼﻔﻮﻓﺎت ذات أﺑﻌﺎد أﻛﺜﺮ ‪.‬‬
‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻼﻋﻼن ﻋﻦ ﻣﺼﻔﻮﻓﺔ ذات ﺑﻌﺪﯾﻦ‬

‫; ]‪Type Array_name [index_1][index_2‬‬
‫ﺣﯿﺚ‬
‫‪ : Type‬ﯾﻤﺜﻞ ﻧﻮع اﻟﺒﯿﺎﻧﺎت ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬
‫‪ : Array_name‬ﯾﻤﺜﻞ أﺳﻢ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬
‫‪ : index_1‬ﯾﻤﺜﻞ ﻋﺪد اﻟﺼﻔﻮف ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬
‫‪ : index_2‬ﯾﻤﺜﻞ ﻋﺪد اﻻﻋﻤﺪة ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬
‫; ]‪int jimmy [3][5‬‬ ‫ﻣﺜﺎل)‪-: (5.2.1‬‬
‫ﻓﻲ ھﺬا اﻟﻤﺜﺎل‪ ،‬ﺗﻢ اﻻﻋﻼن ﻋﻦ ﻣﺼﻔﻮﻓﺔ أﺳﻤﮭﺎ ‪ jimmy‬واﻟﺘﻲ ﺗﺘﻀﻤﻦ ‪ 3‬ﺻﻔﻮف و ‪ 5‬أﻋﻤﺪة ) أي أن ﻋﺪد ﻋﻨﺎﺻﺮھﺎ ‪ 15‬ﻋﻨﺼﺮاً (‪.‬‬
‫ﻣﻼﺣﻈﺔ)‪ -: (5.2.2‬دﻟﯿﻞ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ)ﻟﻠﺼﻔﻮف واﻻﻋﻤﺪة(‪ ،‬ﯾُﺮﻗﻢ ﺑﺪاً ﻣﻦ ‪.0‬‬

‫ ھﻮ اﻟﻌﻨﺼﺮ اﻟﻮاﻗﻊ ﻓ ﻲ اﻟﺼ ﻒ اﻟﺜ ﺎﻧﻲ اﻟﻌﻤ ﻮد‬jimmy[1][3] ‫ ﻓﻤﺜﻼً اﻟﻌﻨﺼﺮ‬. ‫ ﻓﻲ اﻟﺬاﻛﺮة‬jimmy ‫ﻧﻼﺣﻆ ﻓﻲ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ﻣﻮاﻗﻊ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‬
.‫اﻟﺮاﺑﻊ‬
: ‫ ﯾﻤﻜﻦ ﺗﺨﺼﯿﺺ أو ﺷﺤﻦ ﻗﯿﻢ ﻣﺒﺪﺋﯿﺔ ﻷي ﻣﺼﻔﻮﻓﺔ ﻋﻦ ﻃﺮﯾﻖ‬-: (Initial Values)‫اﻟﻘﯿﻢ اﻷﺑﺘﺪاﺋﯿﺔ ﻟﻠﻤﺼﻔﻮﻓﺔ ذات اﻟﺒﻌﺪﯾﻦ‬
‫ واﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ھﻲ‬.‫ اﺛﻨﺎء اﻻﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺔ‬-: ً‫أوﻻ‬
Type Array_name [index_1][index_2]={ { list of first row},{list of second row},…,{list of last row] } ;
int jimmy[3][5]={ {1,2,3,4,5},{2,4,6,8,10},{3,6,9,12,15} } ; -: (5.2.3)‫ﻣﺜﺎل‬
.scanf( )‫ ﻋﻦ ﻃﺮﯾﻖ داﻟﺔ اﻻدﺧﺎل‬-: ً‫ﺛﺎﻧﯿﺎ‬
-: (5.2.4)‫ﻣﺜﺎل‬
#include <stdio.h> 1 2 3 4 5 2 4 6 8 10 3 6 9 12 15
#define WIDTH 5
#define HEIGHT 3 jimmy[0][0]= 1
main ( ) jimmy[0][1]= 2
{ jimmy[0][2]= 3
int jimmy [HEIGHT][WIDTH]; jimmy[0][3]= 4
int n,m; jimmy[0][4]= 5
for (n=0 ;n<HEIGHT ;n++) jimmy[1][0]= 2
for (m=0 ;m<WIDTH ;m++) jimmy[1][1]= 4
{ jimmy[1][2]= 6
scanf("%d",&jimmy[n][m]) ; jimmy[1][3]= 8
} jimmy[1][4]= 10
{ jimmy[2][2]= 9
printf( "jimmy[%d][%d]=%d\n" ,n ,m ,jimmy[n][m]) ; jimmy[2][3]= 12
} jimmy[2][4]= 15
}
‫ﻟﺬﻟﻚ ﯾﻤﻜﻦ اﻟﺤﺼﻮل ﻋﻠﻰ ھﺬه اﻟﻌﻨﺎﺻ ﺮ ﻣ ﻦ ﺧ ﻼل ﺗﻠ ﻚ واﻟﻌﻼﻗ ﺔ وﻋ ﺪم اﺳ ﺘﺨﺪام‬، ‫ﻧﻼﺣﻆ أن ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ﺗﺮﺗﺒﻂ ﺑﻌﻼﻗﺔ ﻣﺎ‬
: ‫ ﻟﺬﻟﻚ ﻓﺄن اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ﯾﻤﻜﻦ ﻛﺘﺎﺑﺘﺔ ﺑﺎﻟﻄﺮﯾﻘﺔ اﻻﺗﯿﺔ‬،‫ واﻟﺘﻲ ﻣﻦ ﺧﻼﻟﮭﺎ ﻗﺪ ﯾﺤﺚ ﺧﻄﺎء ﻓﻲ ادﺧﺎل ﺑﻌﺾ اﻟﻘﯿﻢ‬cin>> ‫داﻟﺔ اﻻدﺧﺎل‬

-: (5.2.5)‫ﻣﺜﺎل‬
#include <iostream.h> jimmy[0][0]= 1
#define WIDTH 5 jimmy[0][1]= 2
#define HEIGHT 3 jimmy[0][2]= 3
int main () jimmy[0][3]= 4
{ jimmy[0][4]= 5
int jimmy [HEIGHT][WIDTH]; jimmy[1][0]= 2
int n,m; jimmy[1][1]= 4
{ jimmy[1][4]= 10
jimmy[n][m]=(n+1)*(m+1); jimmy[2][0]= 3
} jimmy[2][1]= 6
{ jimmy[2][4]= 15
printf( "jimmy[%d][%d]=%d\n" ,n ,m ,jimmy[n][m]) ;
}
}
.‫ ﺛﻢ ﯾﻘﻮم ﺑﺎﺟﺮاء ﻋﻤﻠﯿﺔ اﻟﺠﻤﻊ ﻋﻠﻰ اﻟﻤﺼﻔﻮﻓﺘﯿﻦ‬،‫ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﯾﻘﻮم ﺑﻌﻤﻠﯿﺔ أدﺧﺎل ﻣﺼﻔﻮﻓﺘﯿﻦ ﻣﻦ اﻟﻨﻮع اﻟﺼﺤﯿﺢ‬-: (5.2.6)‫ﻣﺜﺎل‬
#include <stdio.h> 2 7 -1 9 0 -3 1 8 3 -1 5 1 19 0 22 0 8 4
#define R 3
#define C 3 Addition of two arrays :
main ()
{ 9 8 -3
int a[R][C] , b[R][C] ,add[R][C] , mult[R][C] ; 9 2 6
int i, j , k ; 19 22 12
for(i=0 ; i< R ; i++)
for(j=0 ; j< C ; j++)
scanf("%d%d" ,&a[i][j],&b[i][j]) ;
for(i=0 ; i< R ; i++)
for(j=0 ; j< C ; j++)
add[i][j]= a[i][j]+b[i][j] ;
printf( "Addition of two arrays :\n" ) ;
for(i=0 ; i< R ; i++)
{
for(j=0 ; j< C ; j++)
printf("%d \t",add[i][j]) ;
printf("\n");
}
}

‫ﻣﺜﺎل)‪ -: (5.2.7‬ﻟﯿﻜﻦ ﻟﺪﯾﻨﺎ اﻟﻤﺼﻔﻮﻓﺔ اﻻﺗﯿﺔ‬
‫أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪ a‬ﺛﻢ أﯾﺠﺎد وﻃﺒﺎﻋﺔ‬

‫)‪ (1‬ﺣﺎﺻﻞ ﺿﺮب ﻋﻨﺎﺻﺮ اﻟﻘﻄﺮ اﻟﺮﺋﯿﺴﻲ ﻟﻠﻤﺼﻔﻮﻓﺔ) أي اﯾﺠﺎد ]‪.( a[0][0]*a[1][1]*a[2][2‬‬
‫)‪ (2‬أﻛﺒﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫>‪#include <stdio.h‬‬ ‫‪The product = 48‬‬
‫‪#define R 3‬‬ ‫‪Maximum element in Array = 22‬‬
‫‪#define C 3‬‬
‫)( ‪int main‬‬
‫{‬
‫; }}‪int a[R][C]={{2,-1,0},{1,3,5},{19,22,8‬‬
‫; ‪int i, j ,max , product‬‬
‫; ]‪max=a[0][0‬‬
‫; ‪product =1‬‬
‫)‪for(i=0 ; i< R ; i++‬‬
‫)‪for(j=0 ; j< C ; j++‬‬
‫{‬
‫)‪if(i==j‬‬
‫; ]‪product*= a[i][j‬‬
‫)‪if(a[i][j] >max‬‬
‫; ]‪max= a[i][j‬‬
‫}‬
‫; )‪printf( "The product = %d\n", product‬‬
‫; ) ‪printf(" Maximum element in Array =%d ",max‬‬
‫}‬
‫ﻧﻼﺣﻆ ﻣﻦ ﺧﻼل اﻟﺒﺮﻧﺎﻣﺞ اﻋﻼه‪ ،‬اﻧﮫ ﺗﻢ ادﺧﺎل ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺑﺼﻮرة ﻣﺒﺎﺷﺮة‪،‬ﺑﻌﺪھﺎ وﺿﻊ اﻟﺸﺮط اﻻول اﻟﺘﺎﺑﻊ ﻟﻠﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﺒﺴ ﯿﻂ اﻻول‬
‫واﻟﻤﺘﻀﻤﻦ ﺣﺴﺎب ﺣﺎﺻﻞ ﺿﺮب ﻋﻨﺎﺻﺮ اﻟﻘﻄﺮ اﻟﺮﺋﯿﺴﻲ‪ ،‬ﺑﯿﻨﻤﺎ اﻟﺸﺮط اﻟﺜﺎﻧﻲ اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﺜﺎﻧﻲ ﻓﯿﺘﻀﻤﻦ اﯾﺠﺎد أﻛﺒﺮ ﻋﻨﺼ ﺮ ﻓ ﻲ‬
‫اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫)‪ (5.3‬اﻟﻤﺼﻔﻮﻓﺎت اﻟﺤﺮﻓﯿﺔ )‪(Character Arrays‬‬

‫ﻓﻲ ﻟﻐﺔ ‪ C‬ﯾﻤﻜﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﯿﺔ وﻛﺎﻧﮭﺎ ﻣﺼ ﻔﻮﻓﺎت ﯾﻄﻠ ﻖ ﻋﻠ ﻰ ھ ﺬا اﻟﻨ ﻮع ﻣ ﻦ اﻟﻤﺼ ﻔﻮﻓﺎت ﺑﺎﻟﻤﺼ ﻔﻮﻓﺎت اﻟﺤﺮﻓﯿ ﺔ‪ ،‬ﻓﻤ ﺜﻼً اﻟﻜﻠﻤ ﺔ‬
‫‪ Hello‬ﯾﻤﻜﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻌﮭﺎ ﺑﺸﻜﻞ ﻣﺼﻔﻮﻓﺔ ﺣﺮﻓﯿﺔ وﻛﻤﺎ ﯾﻠﻲ ‪:‬‬
‫; } '‪char myword [6] = { 'H', 'e', 'l', 'l', 'o', '\0‬‬
‫ﺣﯿﺚ ﺗﻢ اﻻﻋ ﻼن ﻋ ﻦ ﻣﺼ ﻔﻮﻓﺔ ﻣ ﻦ اﻟﻨ ﻮع اﻟﺤﺮﻓ ﻲ)‪ (char‬وأﺳ ﻤﮭﺎ )‪ (myword‬وﺗﺘﻀ ﻤﻦ اﻟﺤ ﺮوف '‪ 'H' , 'e' , 'l' , 'l' , 'o‬ﺑﺎﻻﺿ ﺎﻓﺔ اﻟ ﻰ اﻟﺮﻣ ﺰ‬
‫'‪ '\0‬واﻟﺬي ﯾﺴﻤﻰ اﻟﺮﻣﺰ اﻟﺼﻔﺮي‪ ،‬ﯾﺠﺐ أن ﯾﻜﻮن ھﺬا اﻟﺮﻣﺰ ﻣﻮﺟﻮد ﻓﻲ ﻧﮭﺎﯾﺔ أي ﻣﺼ ﻔﻮﻓﺔ ﺣﺮﻓﯿ ﺔ‪ ،‬ﺣﯿ ﺚ أن اﻟﻐ ﺮض ﻣﻨ ﮫ ھ ﻮ ﻣﻌﺮﻓ ﺔ ﻣﺘ ﺮﺟﻢ اﻟﻠﻐ ﺔ‬
‫ﺑﻨﮭﺎﯾﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‪ ،‬وﻋﻠﯿﮫ ﯾﺠﺐ ﺣﺠﺰ ﻟﮫ ﻣﻜﺎن ﻓﻲ اﻟﺬاﻛﺮة‪ ،‬أي أن دﻟﯿﻞ اﻟﻤﺼ ﻔﻮﻓﺔ)‪ (index‬ﯾﻀ ﺎف ﻟ ﮫ ‪ 1‬ﻋﻨ ﺪ اﻻﻋ ﻼن ﻋ ﻦ اﻟﻤﺼ ﻔﻮﻓﺔ‪.‬ﻻﺣ ﻆ‬
‫أن اﻟﺪﻟﯿﻞ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ‪ myword‬ھﻮ ‪.6‬‬
‫ﻣﻼﺣﻈﺔ)‪ -: (5.3.1‬ﯾﻤﻜ ﻦ ﻛﺘﺎﺑ ﺔ اﻟﻤﺼ ﻔﻮﻓﺔ اﻟﺤﺮﻓﯿ ﺔ ﺑﺼ ﯿﻐﺔ اﻟﺴﻠﺴ ﻠﺔ اﻟﺤﺮﻓﯿ ﺔ‪ ،‬وﻟﻜ ﻦ ﯾﺠ ﺐ اﻻﻧﺘﺒ ﺎه اﻟ ﻰ دﻟﯿ ﻞ اﻟﻤﺼ ﻔﻮﻓﺔ اﻟ ﺬي ﯾﺠ ﺐ أن ﯾﻜ ﻮن ﺑﻌ ﺪد‬
‫; "‪char myword [6] = "Hello‬‬ ‫اﺣﺮف اﻟﺴﻠﺴﻠﺔ اﻟﺤﺮﻓﯿﺔ ﻣﻀﺎف ﻟﮫ ‪ 1‬واﻟﺬي ﯾﻜﻮن ﻣﺨﺼﺺ ﻟﻠﺮﻣﺰ اﻟﺼﻔﺮي '‪ .'\0‬ﻓﻤﺜﻼً ﻧﻜﺘﺐ‬
‫; "‪char myword [] = "Hello‬‬ ‫ﻣﻼﺣﻈﺔ)‪ -: (5.3.2‬ﯾﻤﻜﻦ ﻋﺪم ذﻛﺮ دﻟﯿﻞ اﻟﻤﺼﻔﻮﻓﺔ اﺛﻨﺎء اﻻﻋﻼن ﻋﻨﮭﺎ‪ .‬ﻣﺜﻼأ ﻧﺴﺘﻄﯿﻊ أن ﻧﻜﺘﺐ‬

‫ﻣﺜﺎل)‪-: (5.3.3‬‬
‫‪/*null-terminated sequences of characters*/‬‬ ‫‪Please, enter your first name: Mohammed‬‬
‫>‪#include <stdio.h‬‬ ‫‪Hello, Mohammed‬‬
‫) ( ‪main‬‬
‫{‬
‫;" ‪char question[] = "Please, enter your first name:‬‬
‫;" ‪char greeting[] = "Hello,‬‬
‫;]‪char yourname [80‬‬
‫;)‪printf("%s", question‬‬
‫;)‪scanf("%s",&yourname‬‬
‫;) ‪printf("%s, %s" ,greeting , yourname‬‬
‫}‬
‫ﺗﻤﺎرﯾﻦ ) اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ(‬
‫ﺗﻤﺮﯾﻦ ‪ : 1‬ﻣﺨﺰن ﯾﺘﻀﻤﻦ ﺛﻼث اﺻﻨﺎف ﻣﻦ اﻟﺒﻀﺎﺋﻊ‪،‬اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻻدﺧﺎل رﻗﻢ اﻟﺼﻨﻒ ﻣﻊ ﻋﺪد ﻣﺒﯿﻌﺎت ذﻟﻚ اﻟﺼﻨﻒ ﺧﻼل اﻻﺷﮭﺮ‬
‫اﻟﺜﻼث اﻻوﻟﻰ ﻣﻦ اﻟﺴﻨﺔ ﻣﻊ ﺣﺴﺎب وﻃﺒﺎﻋﺔ اﻻﺗﻲ ‪:‬‬
‫)‪ (1‬ﻣﺠﻤﻮع ﻣﺒﯿﻌﺎت ﻛﻞ ﺻﻨﻒ ﺧﻼل اﻻﺷﮭﺮ اﻟﺜﻼﺛﺔ‪.‬‬

‫)‪ (2‬أﻛﺜﺮ اﻻﺻﻨﺎف ﻣﺒﯿﻌﺎً ﺧﻼل اﻻﺷﮭﺮ اﻟﺜﻼﺛﺔ‪.‬‬
‫)‪ (3‬ﻣﺠﻤﻮع اﻟﻤﺒﯿﻌﺎت ﻟﺠﻤﯿﻊ اﻻﺻﻨﺎف ﺧﻼل اﻟﺸﮭﺮ اﻟﺜﺎﻧﻲ ‪.‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 2‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻻﯾﺠﺎد ﻋﺪد ﻣﺮات ﺗﻜﺮار اﻟﺤﺮف ‪ k‬ﻓﻲ ﻧﺺ ﻣﻌﯿﻦ‪.‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 3‬اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﯾﺘﻀﻤﻦ ادﺧﺎل أﺳﻢ اﻟﻤﻮﻟﻮد‪ ،‬ﻣﻜﺎن اﻟﻮﻻدة‪ ،‬اﻟﺠﻨﺲ‪ ،‬ﺗﺎرﯾﺦ اﻟﻮﻻدة)اﻟﯿﻮم واﻟﺸﮭﺮ واﻟﺴﻨﺔ(‪ ،‬ﺛﻢ ﻋﻤﻞ اﻻﺗﻲ‪:‬‬
‫‪ .i‬ﻃﺒﻊ ﻗﺎﺋﻤﺔ ﺑﺄﺳﻤﺎء اﻟﺬﻛﻮر ﻣﻊ اﻟﻌﻨﺎوﯾﻦ ﺑﺘﺮﺗﯿﺐ ﺗﺼﺎﻋﺪي ﺣﺴﺐ اﻻﺳﻤﺎء‪.‬‬

‫‪ .ii‬ﻃﺒﻊ ﻗﺎﺋﻤﺔ ﺑﺄﺳﻤﺎء اﻻﻧﺎث وﺗﺎرﯾﺦ وﻻدﺗﮭﻦ‪.‬‬
‫‪ .iii‬ﻃﺒﻊ ﻗﺎﺋﻤﺔ ﺳﺄﺳﻤﺎء اﻟﺬﻛﻮر واﻻﻧﺎث اﻟﻤﻮﻟﻮدﯾﻦ ﻗﺒﻞ ‪.2006/12/31‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 4‬ﻓﺼﻞ دراﺳﻲ ﯾﺘﻀﻤﻦ ‪ 50‬ﻃﺎﻟﺒﺎً وﻃﺎﻟﺒﺔ‪ ،‬اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة أﺳﻢ اﻟﻄﺎﻟﺐ ودرﺟﺎﺗﺔ ﻓﻲ ﺛﻼث ﻣﻮاد )‪،(T1,T2,T3‬ﺟﻨﺴﮫ‬
‫)‪ M‬أو ‪ (F‬ﺛﻢ ﺣﺴﺎب وﻃﺒﺎﻋﺔ ﻣﺎﯾﻠﻲ‪:‬‬
‫‪ (a‬ﻣﻌﺪل ﻛﻞ ﻃﺎﻟﺐ ﻓﻲ اﻟﺪرﺟﺎت اﻟﺜﻼث‪.‬‬
‫‪ (b‬اﻟﻤﻌﺪل اﻟﻌﺎم ﻟﻠﻄﻠﺒﺔ‪.‬‬
‫‪ (c‬اﻋﻠﻰ ﻣﻌﺪل وﻃﺒﺎﻋﺘﺔ ﻣﻊ اﺳﻢ اﻟﻄﺎﻟﺐ اﻟﺬي ﯾﻤﺘﻠﻚ ذﻟﻚ اﻟﻤﻌﺪل‪.‬‬
‫‪ (d‬ﻋﺪد اﻟﻄﺎﻟﺒﺎت اﻟﻨﺎﺟﺤﺎت ﺑﺎﻟﻤﻌﺪل ) درﺟﺔ اﻟﻨﺠﺎح ‪ 50‬ﻓﻤﺎﻓﻮق (‪.‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 5‬ﻟﯿﻜﻦ ﻟﺪﯾﻨﺎ اﻟﻤﺼﻔﻮﻓﺎت اﻻﺗﯿﺔ ‪:‬‬
‫اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ ‪:‬‬

‫‪. (2a-5b)*c , b*c , a*b (a‬‬
‫‪ (b‬أﻛﺒﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺜﻼث ﻣﻊ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺘﻲ ﺗﺤﻮي ھﺬا اﻟﻌﻨﺼﺮ‪.‬‬

‫اﻟﻔﺼﻞ اﻟﺴﺎدس‪ :‬اﻟﺪوال )‪(Functions‬‬

‫ﻓﻲ اﻟﺴﺎﺑﻖ ﻛُﺘﺒﺖ اﻟﺒﺮاﻣﺞ ﻋﻠﻰ أﻧﮭﺎ ﻛﺘﻠﺔ واﺣﺪة‪ ،‬وھﺬا ﻗﺪ ﯾﻜﻮن ﻏﯿﺮ ﻣﻨﺎﺳﺐ ﻓﻲ ﺑﻌ ﺾ اﻻﺣﯿ ﺎن ﺣﯿ ﺚ ﯾﺼ ﻌﺐ ﻣﺘﺎﺑﻌﺘﮭ ﺎ وأﺻ ﻼﺣﮭﺎ ﺧﺼﻮﺻ ًﺎ‬
‫ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻄﻮﯾﻞ‪.‬وﻟﺬﻟﻚ ﯾﻔﻀﻞ ﺗﺠﺰﺋﺘ ﮫ اﻟ ﻰ ﻋ ﺪة اﺟ ﺰاء ﺻ ﻐﯿﺮة ﻛ ﻞ ﺟ ﺰء ﯾ ﺆدي ﻣﮭﻤ ﺔ ﻣﻌﯿﻨ ﺔ‪،‬ﺛ ﻢ ﺗﺨﺘﺒ ﺮ ھ ﺬه اﻻﺟ ﺰاء وﺗ ﺮﺗﺒﻂ ﻣ ﻊ ﺑﻌﻀ ﮭﺎ‬
‫ﻟﺘﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ اﻟﻜﺎﻣﻞ‪.‬‬
‫ﻟﮭﺬا اﻟﻐﺮض ﺳﻮف ﻧﺴﺘﺨﺪم ﻣﻔﮭﻮم اﻟﺪوال‪،‬ﺣﯿﺚ أن اﻟﺪاﻟﺔ ﻋﺒﺎرة ﻋﻦ ﺟﻤﻠﺔ أو ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺠﻤﻞ اﻟﺘﻲ ﺗﺆدي وﻇﯿﻔ ﺔ ﻣﻌﯿﻨ ﺔ‪،‬وﯾﻤﻜ ﻦ اﺳ ﺘﺪﻋﮭﺎ‬
‫ﻣﻦ أي ﻧﻘﻄﺔ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ‪.‬وﻣﻦ ﻓﻮاﺋﺪ ھﺬه اﻟﺪوال ﻣﺎﯾﻠﻲ‪:‬‬
‫‪ .i‬ﺗﻌﻤﻞ ﻋﻠﻰ ﺗﺠﺰﺋﺔ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻄﻮﯾﻞ اﻟﻰ أﺟﺰاء ﺻﻐﯿﺮة ﯾﻤﻜﻦ ﻣﺘﺎﺑﻌﺘﮭﺎ واﺻﻼﺣﮭﺎ ﻣﻦ ﻗﺒﻞ اﻟﻤﺒﺮﻣﺞ ‪.‬‬
‫‪ .ii‬ﺗﺴﺎﻋﺪ ﻋﻠﻰ ﺗﻼﻓﻲ ﻋﻤﻠﯿﺎت اﻟﺘﻜﺮار ﻓﻲ ﺧﻄﻮات اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﻲ ﺗﺘﻄﻠﺐ ﻋﻤﻼً ﻃﻮﯾﻼًوﺷﺎﻗﺎً ‪.‬‬
‫‪ .iii‬ﺗﻮﻓﺮ اﻟﺪوال اﻟﺠﺎھﺰة)اﻟﻤﺨﺰوﻧﺔ ﻓﻲ ذاﻛﺮة اﻟﺤﺎﺳﺐ( ﻣﻦ ﻣﺴﺎﺣﺔ اﻟﺬﻛﺮة اﻟﻤﻄﻠﻮﺑﺔ ‪.‬‬
‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺪاﻟﺔ ھﻲ ‪:‬‬

‫)‪Type function_name(argument1,argument2 ...‬‬
‫; ‪Types of the parameter list variables‬‬
‫{‬
‫; ‪types of local variables‬‬
‫; ‪function body‬‬
‫; )‪return(expression‬‬
‫}‬
‫ﺣﯿﺚ‬
‫‪ : Type‬ﯾﻤﺜﻞ ﻧﻮع ﻗﯿﻤﺔ اﻟﺪاﻟﺔ ﻋﻨﺪ رﺟﻮﻋﮭﺎ اﻟﻰ اﻟﺒﻨﺎﻣﺞ اﻟﻤﻨﺎدي ‪.‬‬
‫‪ : function_name‬ﯾﻤﺜﻞ أﺳﻢ اﻟﺪاﻟﺔ ‪.‬‬
‫‪ : argument1, argument2 ...‬ﺗﻤﺜﻞ دﻻﺋﻞ أو ﻣﻌﺎﻣﻼت ﻻﺳﺘﻘﺒﺎل وارﺟﺎع اﻟﺒﯿﺎﻧﺎت ‪.‬‬
‫‪ : Tapes of the parameter variables‬ﻧﻮع اﻟﻤﻌﺎﻣﻼت اﻟﻤﺴﺘﻘﺒﻠﺔ واﻟﻤﺮﺟﻌﺔ ﻟﻠﺒﯿﺎﻧﺎت ‪.‬‬
‫‪ : types of local variables‬اﻟﻤﺘﻐﯿﺮات اﻟﻤﻌﻠﻦ ﻋﻨﮭﺎ داﺧﻞ اﻟﺪاﻟﺔ وھﻲ ﻣﺤﻠﯿﺔ )واﻟﻤﺘﻐﯿﺮات اﻟﻤﺤﻠﯿ ﺔ ھ ﻲ ﻣﺘﻐﯿ ﺮات ﯾﻌﻠ ﻦ ﻋﻨﮭ ﺎ وﺗﺴ ﺘﺨﺪم ﻓ ﻲ‬
‫ﺣﺪود اﻟﺪاﻟ ﮫ وﻻ ﯾﻤﻜ ﻦ اﻟﺘﻌ ﺮف ﻋﻠﯿﮭ ﺎ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟﺮﺋﯿﺴ ﻲ أو أﯾ ﺔ داﻟ ﺔ أﺧ ﺮى ﺣﺘ ﻰ وﻟ ﻮ ﻛﺎﻧ ﺖ ﺗﺤﻤ ﻞ ﻧﻔ ﺲ‬
‫اﻻﺳﻢ(‪.‬‬
‫‪ : function body‬ﯾﻤﺜﻞ ﺟﻤﻠﺔ أو ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺠﻤﻞ ‪.‬‬
‫‪ : return‬ﺗﻤﺜﻞ ﺟﻤﻠﺔ اﻋﺎدة ﻗﯿﻤﺔ اﻟﺘﻌﺒﯿﺮ )‪ (expression‬ﺣﺴﺐ ﻧﻮع اﻟﺪاﻟﺔ ‪.‬‬
‫ﻣﻼﺣﻈﺔ)‪-:(6.1‬‬
‫‪ .i‬ﯾﺘﻢ اﻻﻋﻼن واﻟﺘﻌﺮﯾﻒ ﻋﻦ اﻟﺪاﻟﺔ ﻓﻲ ﺑﺪاﯾﺔ اﻟﺒﺮﻧﺎﻣﺞ وﻗﺒﻞ اﻟﺪاﻟﺔ اﻟﺮﺋﯿﺴﯿﺔ ) (‪. main‬‬
‫‪ .ii‬ﯾﺘﻢ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻦ ﻃﺮﯾﻖ اﺳﻤﮭﺎ ﻓﻘﻂ ‪.‬‬
‫‪ .iii‬ﯾﻨﺒﻐﻲ اﻻﻋﻼن ﻋﻦ ﻧﻮع اﻟﺪاﻟﺔ اذا ﻛﺎﻧﺖ ﺗﺮﺟﻊ ﺑﻘﯿﻤﺔ ﻣﻦ اﻟﻨﻮع ﻏﯿﺮ اﻟﺼﺤﯿﺢ)‪ ،(int‬وﻓﻲ ﺣﺎﻟﺔ ﻋﺪم اﻻﻋ ﻼن ﻋﻨﮭ ﺎ ﻗﺒ ﻞ اﺳ ﺘﺪﻋﺎﺋﮭﺎ‬
‫) (‪(1) float larger‬‬ ‫ﺗﻜﻮن ﻗﯿﻤﺘﮭﺎ ‪ int‬ﺗﻠﻘﺎﺋﯿﺎً ‪ .‬وﯾﺴﺘﺤﺴﻦ اﻻﻋﻼن ﻋﻨﮭﺎ ﻓﻲ ﻛﻞ اﻻﺣﻮال ‪ .‬ﻣﺜﻼً‬
‫) (‪(2) int temp‬‬
‫) (‪(3) temp‬‬
‫‪ .iv‬ﻗﺪ ﯾﻜﻮن ﻟﻠﺪاﻟﺔ ﻣﮭﻤﺔ ﻣﻌﯿﻨﺔ ﺗﺆدﯾﮭﺎ ﺑﺪون ارﺟﺎع ﻗﯿﻤﺔ ﻋﻨﺪ اﻧﺘﮭﺎﺋﮭﺎ‪،‬أي اﻧﮭﺎ داﻟﺔ ﺧﺎﻟﯿ ﺔ ﺑ ﺪون ﻣﻌ ﺎﻣﻼت ﻓ ﻲ ھ ﺬه اﻟﺤﺎﻟ ﺔ ﯾﻌﻠ ﻦ ﻋﻨﮭ ﺎ‬
‫ﻣﻦ اﻟﻨﻮع اﻟﺨﺎﻟﻲ )‪. (void‬ﻓﻤﺜﻼً‬
‫) ( ‪void printmessage‬‬ ‫‪or‬‬ ‫)‪void printmessage (void‬‬

‫ﻣﺜﺎل)‪ -:(6.2‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﯾﺴﺘﺨﺪم داﻟﺔ ﻻﺟﺮاء ﻋﻤﻠﯿﺔ اﻟﺠﻤﻊ ﻷي ﻋﺪدﯾﻦ ﺻﺤﯿﺤﯿﻦ ‪.‬‬
‫‪/* function example */‬‬ ‫‪The result is 8‬‬
‫)‪int addition (int a, int b‬‬
‫{‬
‫; ‪int r‬‬
‫; ‪r=a+b‬‬
‫; )‪return (r‬‬
‫}‬
‫) ( ‪main‬‬
‫{‬
‫; ‪int z‬‬
‫; )‪z = addition (5,3‬‬
‫; )‪printf ("The result is %d", z‬‬
‫}‬
‫ﻧﻼﺣﻆ اﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺘﻌﺮﯾﻒ داﻟﺔ ﻟﻠﺠﻤﻊ )‪ (addition‬ﻓﻲ ﺑﺪاﯾ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ‪ ،‬واﻟﺘ ﻲ ﻟﮭ ﺎ ﻣﻌ ﺎﻣﻼت ﺻ ﺤﯿﺤﺔ ‪ a , b‬ﺛ ﻢ ﻗﻤﻨ ﺎ ﺑﺘﻮﺿ ﯿﺢ ﻋﻤ ﻞ اﻟﺪاﻟ ﺔ ﻣ ﻦ ﺧ ﻼل‬
‫اﻟﺠﻤﻞ اﻟﻤﻮﺟﻮدة داﺧﻞ اﻟﻘﻮﺳﯿﻦ } ‪، { ,‬ھﻨﺎ اﻟﻤﺘﻐﯿﺮ اﻟﺼﺤﯿﺢ ‪ r‬ﯾﻤﺜﻞ ﻣﺘﻐﯿﺮ ﻣﺤﻠﻲ‪ ،‬ﻗﻤﻨﺎ ﺑﺴﺘﺪﻋﺎء اﻟﺪاﻟﺔ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻦ ﻃﺮﯾﻖ اﺳ ﻤﮭﺎ ﻓﻘ ﻂ‪.‬ﺑﻌ ﺪھﺎ‬
‫ﺗﻢ اﻋﻄﺎء اﻟﻘﯿﻢ ‪ 5‬ﻟﻠﻤﺘﻐﯿﺮ ‪ a‬و ‪ 3‬ﻟﻠﻤﺘﻐﯿﺮ ‪. b‬‬
‫ﺑﻌﺪ ذﻟﻚ ﻧُﻔﺬت ﺟﻤﻞ اﻟﺪاﻟﺔ وھﻲ ﻋﻤﻠﯿﺔ اﻟﺠﻤﻊ وﻇﮭﺮت ﻟﻨﺎ اﻟﻨﺘﯿﺠﺔ وھﻲ اﻟﻘﯿﻤﺔ ‪ 8‬واﻟﺘﻲ اﻋﻄﯿﺖ ﻟﻠﻤﺘﻐﯿﺮ ‪ z‬وﻛﻤﺎ ﯾﻠﻲ ‪:‬‬
‫ﻣﺜﺎل)‪ -:(6.3‬اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﯾﻮﺿﺢ اﺳﺘﺨﺪام داﻟﺘﯿﻦ ﺿﻤﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻮاﺣﺪ‪ ،‬اﺣﺪھﻤﺎ ﻟﻌﻤﻠﯿﺔ اﻟﻀﺮب واﻻﺧﺮى ﻟﻌﻤﻠﯿﺔ اﻟﻘﺴﻤﺔ ‪.‬‬
‫>‪#include <stdio.h‬‬ ‫‪10‬‬
‫)‪int mul (int a, int b‬‬ ‫‪2.5‬‬
‫{‬
‫; )‪return (a*b‬‬
‫}‬
‫)‪float div (float a, float b‬‬
‫{‬
‫; )‪return (a/b‬‬
‫}‬
‫) ( ‪main‬‬
‫{‬
‫; ‪int x=5,y=2‬‬
‫; ‪float n=5.0,m=2.0‬‬
‫; ) )‪printf (" %d*%d=%d\n",x,y, mul(x,y‬‬
‫; ) )‪printf (" %d/%d=%f\n",x,y, div (n,m‬‬
‫}‬

. I'm a function! ‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﯾﺴﺘﺨﺪم اﻟﺪاﻟﺔ اﻟﺨﺎﻟﯿﺔ ﻟﻄﺒﺎﻋﺔ اﻟﻌﺒﺎرة‬-:(6.4)‫ﻣﺜﺎل‬
/*void function example*/ I'm a function!
#include <stdio.h>
void printmessage ( )
{
Printf( "I'm a function!" );
}
main ( )
{
printmessage ( );
}
. ‫ﺛﻢ اﺳﺘﺨﺪم اﻟﺪاﻟﺔ ﻻﯾﺠﺎد أﻛﺒﺮ ﻗﯿﻤﺔ ﻣﻦ ھﺬه اﻟﻤﺘﻐﯿﺮات‬، ‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة أرﺑﻊ ﻣﺘﻐﯿﺮات ﺣﻘﯿﻘﯿﺔ‬-:(6.5)‫ﻣﺜﺎل‬
#include <stdio.h> Enter Four Real numbers : 5.26 0.044 9.9 0.4
float large (x,y) The Largest number : 9.9
float x,y ;
{
if(x>y)
return x ;
else
return y ;
}
main( )
{
float temp1,temp2,max ;
float num1,num2,num3,num4 ;
printf("Enter Four Real numbers :") ;
scanf("%f%f%f%f", num1,num,num3,num4) ;
temp1=large(num1,num2) ;
temp2=large(num3,num4) ;
max=large(temp1,temp2) ;
printf( "\nThe Largest number :" ,max) ;
}
. ‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻟﺤﺴﺎب ﻣﺮﺑﻊ اﻟﻌﺪد ﻋﻠﻰ أن ﯾﺤﺴﺐ ﻣﺮﺑﻊ ﺑﺪاﻟﺔ ﻣﺴﺘﻘﻠﺔ‬-:(6.6)‫ﻣﺜﺎل‬
#include <stdio.h> Enter value : 5
int square(int x) The Square of is 25
{
return (x*x) ;
}
main ( )
{
int z ;
printf(" Enter value :") ;
scanf("%d" ,&z) ;
printf ("\n The Square of %d is %d", z, square(z) ) ;
}

. ‫ ﺛﻢ رﺗﺐ ھﺬه اﻻﻋﺪاد ﺗﺼﺎﻋﺪﯾﺎً ﺑﺎﺳﺘﺨﺪام اﻟﺪاﻟﺔ‬،‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة ﺛﻼث اﻋﺪاد ﻣﻦ اﻟﻨﻮع اﻟﺼﺤﯿﺢ‬-:(6.7)‫ﻣﺜﺎل‬
#include <stdio.h> Enter three numbers : 58 25 99
int swap(x,y) Ascending order : 25 , 58 , 99
int x, y ;
{
int temp ;
temp=x ;
x=y ;
y=temp ;
}
main ( )
{
int a, b, c ;
printf(" Enter three numbers :" ) ;
scanf("%d%d%d", a , b , c ) ;
if(a>b)
{
swap(a,b) ;
}
if(b>c)
{
swap(b,c) ;
}
if(a>c)
{
swap(a,c) ;
}
printf("\n Ascending order :%d,%d,%d" ,a ,b, c ) ;
}
‫ ﻟﻜ ﻮن اﻟﺸ ﺮط‬swap(58,25) ‫ﻋﻨﺪ اﻟﺘﻔﯿﺬ ﺗ ﻢ اﺳ ﺘﺪﻋﺎء داﻟ ﺔ اﻟﺘﺒ ﺪﯾﻞ‬. ً‫ ﻛﻠﻤﺎ ﻛﺎن اﻟﺸﺮط ﺻﺤﯿﺤﺎ‬swap(x,y) ‫ﻓﻲ ھﺬا اﻟﺒﺮﻧﺎﻣﺞ ﯾﺘﻢ اﺳﺘﺪﻋﺎء داﻟﺔ اﻟﺘﺒﺪﯾﻞ‬
‫اﻣﺎ ﻓﻲ ﺑﻘﯿﺔ اﻟﺤﺎﻻت ﻓﻘﺪ ﻛﺎﻧﺖ اﻟﺸﺮوط ﻏﯿﺮ ﻣﺘﺤﻘﻘﺔ وﺑﺎﻟﺘﺎﻟﻲ ﻟﻢ ﯾﺘﻢ اﺳﺘﺪﻋﺎء داﻟﺔ اﻟﺘﺒﺪﯾﻞ وﻋﻠﯿ ﺔ‬، 25 ‫ و‬58 ‫ ﻟﺬﻟﻚ ﺗﻢ اﻟﺘﺒﺪﯾﻞ ﺑﯿﻦ اﻟﻘﯿﻢ‬،‫ﻗﺪ ﺗﺤﻘﻖ‬
: ‫ﻇﮭﺮت ﻟﻨﺎ اﻟﻨﺘﺎﺋﺞ ﻛﻤﺎ ﯾﻠﻲ‬
25 , 58 , 99
.‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻟﺤﺴﺎب اﻟﻘﯿﻤﺔ اﻟﻤﻄﻠﻘﺔ ﻟﻠﻌﺪد اﻟﺤﻘﯿﻘﻲ‬-: (6.8)‫ﻣﺜﺎل‬

#include <stdio.h> -19.5
float fabs(float x) Absolute value of -19.5 is 19.5
{ 255
if(x>= 0) Absolute value of 255.12 is 255.12
return (x) ; -6698
else Absolute value of -6698.0 is -6698.0
return(-x) ;
}
main ( )
{
float a;
scanf("%f", a );
printf("\n Absolute value of %f is %f" ,a , fabs(a) ) ;
}

‫ اﻟﺪوال‬،‫ وﻣﻦ ھﺬه اﻟﺪوال ھﻲ‬، ‫ ﺗﻮﺟﺪ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺪوال اﻟﺠﺎھﺰة واﻟﻤﻮﺟﻮدة ﺿﻤﻦ اﻟﻤﻜﺘﺒﺔ اﻟﻘﯿﺎﺳﯿﺔ ﻟﻠﻐﺔ‬C ‫ ﻓﻲ ﻟﻐﺔ‬-: ‫( اﻟﺪوال اﻟﺮﯾﺎﺿﯿﺔ‬6.9)
: ‫ وﻓﯿﻤﺎ ﯾﻠﻲ ﺑﻌﺾ ھﺬه اﻟﺪوال‬، math.h ‫اﻟﺮﯾﺎﺿﯿﺔ اﻟﻤﻮﺟﻮدة ﺿﻤﻦ ﻣﻠﻒ اﻟﻌﻨﻮان‬
‫اﻟﺪاﻟﺔ‬ ‫اﻟﻐﺮض ﻣﻨﮭﺎ‬ ‫ﻧﻮع اﻟﻤﺘﻐﯿﺮ‬ ‫اﻟﻘﯿﻤﺔ اﻟﻤﺮﺟﻌﺔ‬
abs(x) ‫اﻟﻘﯿﻤﺔ اﻟﻤﻄﻠﻘﺔ ﻟﻠﻌﺪد اﻟﺼﺤﯿﺢ‬ int int
fabs(x) ‫اﻟﻘﯿﻤﺔ اﻟﻤﻄﻠﻘﺔ ﻟﻠﻌﺪد اﻟﺤﻘﯿﻘﻲ‬ double double
sqrt(x) ‫اﻟﺠﺬر اﻟﺘﺮﺑﯿﻌﻲ‬ double double
pow(x,y) y ‫ ﺑﻘﻮة‬x double double
sin(x) ‫اﻟﺠﯿﺐ‬ double double
cos(x) ‫اﻟﺠﯿﺐ ﺗﻤﺎم‬ double double
tan(x) ‫اﻟﻈﻞ‬ double double
asin(x) ‫ﻣﻌﻜﻮس اﻟﺠﯿﺐ‬ double double
acos(x) ‫ﻣﻌﻜﻮس اﻟﺠﯿﺐ ﺗﻤﺎم‬ double double
atan(x) ‫ﻣﻌﻜﻮس اﻟﻈﻞ‬ double double
sinh(x) ‫اﻟﺠﯿﺐ اﻟﺰاﺋﺪي‬ double double
cosh(x) ‫اﻟﺠﯿﺐ ﺗﻤﺎم اﻟﺰاﺋﺪي‬ double double
tanh(x) ‫اﻟﻈﻞ اﻟﺰاﺋﺪي‬ double double
exp(x) ‫اﻻﺳﯿﺔ‬ double double
log(x) ‫اﻟﻠﻮﻏﺮﺗﯿﻢ اﻟﻄﺒﯿﻌﻲ‬ double double
log10(x) ‫اﻟﻠﻮﻏﺎرﯾﺘﻢ اﻟﻌﺸﺮي‬ double double
-: (6.9.1)‫ﻣﺜﺎل‬
#include <stdio.h> Enter value : 16
#include <math.h> Sqrt of 16 is 4
main ( ) 16 power 2 is 256
{ Absolute value of 16 is 16
double a ;
printf(" Enter value :") ;
scanf("%f", a );
printf("Sqrt of %d is %d\n" ,a , sqrt(a) ) ;
printf("%d power 2 is %d\n" ,a , pow(a,2) ) ;
printf(Absolute value of %d is %d" ,a ,fabs(a) );
}

-:(6.9.2)‫ﻣﺜﺎل‬
#include <stdio.h> Enter value : -3.5
#include <math.h> Y= -38.5928
main ( )
{
double x , y ;
printf(" Enter value :");
scanf("%f",&x);
y= fabs(x)+pow(x,3)-5*sin(3*x-2) ;i
printf( " Y=%f " , y );
}
‫ ﻋﻠﻤﺎً أن‬،x ‫ ﻋﻨﺪ اﻟﻌﺪد اﻟﺤﻘﯿﻘﻲ‬f ‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ ﻗﯿﻤﺔ اﻟﺪاﻟﺔ‬-:(6.9.3)‫ﻣﺜﺎل‬
#include <stdio.h> : 1 ‫اﻟﺘﻔﯿﺬ‬
#include <math.h> Enter real value : 0.7
float f(float x) f(0.7) = 1.4143
{
If(x>= 0)
return( sqrt(3-cos(2*x)) ) ; : 2 ‫اﻟﺘﻨﻔﯿﺬ‬
else Enter real value : -3.2
return( pow(x,5)-exp(x*x)) ; f(-3.2) = -28694.5654
}
main ( )
{
float x ;
printf(" Enter value :");
scanf("%f",&x);
printf("f(%f)=%f\n",x,f(x) );
}
‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻤﻌﺮﻓﺔ ﻓﯿﻤﺎ أذا ﻛﺎن ﻟﻠﺪاﻟﺔ‬.f(a)*f(b) <0 ‫[ اذا وﻓﻘﻂ اذا ﻛﺎن‬a,b] ‫ ﺿﻤﻦ اﻟﻔﺘﺮة اﻟﻤﻐﻠﻘﺔ‬f ‫ ﯾﻮﺟﺪ ﺟﺬر ﻟﻠﺪاﻟﺔ‬-: (6.9.4)‫ﻣﺜﺎل‬
.‫ﺟﺬراً ﺿﻤﻦ ﻓﺘﺮة ﻣﻌﯿﻨﺔ ام ﻻ‬

#include <stdio.h> 0.5 1.0
#include <math.h> There exists Root between 0.5 and 1.0
float f(float x)
{
return( exp(x)-x-1) ;
}
main ( )
{
float a, b ;
scanf("%f%f",&a,&b);
if ( f(a)*f(b) < 0 )
printf( "There exists Root between%f and %f" ,a , b) ;
}

‫ ﺗﻌﺮﻓﻨﺎ ﺳ ﺎﺑﻘﺎً ﻋﻠ ﻰ اﻟﻤﺘﻐﯿ ﺮات اﻟﻤﺤﻠﯿ ﺔ واﻟﺘ ﻲ ﯾﻌﻠ ﻦ ﻋﻨﮭ ﺎ وﺗﺴ ﺘﺨﺪم داﺧ ﻞ ﺣ ﺪود‬-: (Global Variables)‫( اﻟﻤﺘﻐﯿﺮات اﻟﺨﺎرﺟﯿﺔ‬6.10)
،‫ أﻣﺎ اﻟﻤﺘﻐﯿﺮات اﻟﺨﺮﺟﯿﺔ ﻓﮭﻲ اﻟﺘﻲ ﺗﻜﻮن ﻣﻌﺮوﻓﮫ ﻟﺠﻤﯿﻊ اﻟﺪوال اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟﺮﺋﯿﺴ ﻲ‬.‫اﻟﺪاﻟﺔ وﻻﻋﻼﻗﺔ ﻟﮭﺎ ﺑﺎﻟﺪوال اﻻﺧﺮى‬
.‫ وﻻﯾﺠﻮز اﻻﻋﻼن ﻋﻨﮭﺎ أﻛﺜﺮ ﻣﻦ ﻣﺮة‬main( ) ‫ﺣﯿﺚ ﯾﺘﻢ اﻻﻋﻼن ﻋﻨﮭﺎ ﺧﺎرج ﻛﻞ اﻟﺪوال وﻗﺒﻞ اﻟﺪاﻟﺔ اﻟﺮﺋﯿﺴﯿﺔ‬
:‫ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻌﻤﻞ اﻻﺗﻲ‬-: (6.10.1)‫ﻣﺜﺎل‬

.‫ ﻃﻼب‬5 ‫( ادﺧﺎل ﻧﺘﯿﺠﺔ اﻻﻣﺘﺤﺎن اﻻول واﻟﺜﺎﻧﻲ ﻟﻜﻞ ﻃﺎﻟﺐ ﻓﻲ ﻓﺼﻞ دراﺳﻲ ﯾﻀﻢ‬a
: ‫( اﺳﺘﺨﺪام داﻟﺔ ﻟﺤﺴﺎب أﻛﺒﺮ درﺟﺔ وﻣﻌﺪل وﺣﺎﻟﺔ ﻛﻞ ﻃﺎﻟﺐ ﻋﻠﻰ اﻟﻨﺤﻮ اﻻﺗﻲ‬b
.50 ‫( اذا ﻛﺎن ﻣﻌﺪل اﻟﻄﺎﻟﺐ ﯾﺴﺎوي أو أﻛﺒﺮ ﻣﻦ‬PASS) ‫ ﻧﺎﺟﺢ‬.i
.50 ‫( اذا ﻛﺎن ﻣﻌﺪل اﻟﻄﺎﻟﺐ أﻗﻞ ﻣﻦ‬FAIL) ‫ راﺳﺐ‬.ii
#include <stdio.h> Number of Student : 1
float max , avg ; Enter two numbers : 72 71
char status ; The result : Maximum= 72
main( ) Average = 71.5
{ Status : PASS
int i ;
float t1 , t2 ;
for(i=1 ; i<=5 ; i++) Number of Student : 2
{ Enter two numbers : 45 48
printf( " Number of Student : %d\n" , i ) ; The result : Maximum= 48
printf("Enter two numbers :" ) ; Average = 46.5
scanf("%f%f",&t1,&t2); Status : FAIL
calculate(t1,t2) ;
print_them(t1,t2) ;
} Number of Student : 3
return 0 ; Enter two numbers : 90 86
} The result : Maximum= 90
calculate(m1,m2) Average = 88.0
float m1,m2 Status : PASS
{
if(m1>m2)
max=m1; Number of Student : 4
else Enter two numbers : 50 51
max=m2 ; The result : Maximum= 51
avg==(m1+m2)/2 ; Average = 50.5
if(avg >=50) Status : PASS
status="PASS" ;
else
status="FAIL" ; Number of Student : 5
} Enter two numbers : 25.5 22.5
print_them(n1,n2) The result : Maximum= 25.5
float n1,n2 ; Average = 24.0
{ Status : FAIL
printf(" The result : Maximum=%f\n " ,max);
printf("Average =%f\n" ,avg) ;
printf("Status :%s\n" ,status) ;
}
‫ ﻣ ﻦ اﻟﻨ ﻮع اﻟﺤﺮﻓ ﻲ وذﻟ ﻚ ﻗﺒ ﻞ اﻟﺪاﻟ ﺔ اﻟﺮﺋﯿﺴ ﯿﺔ‬status ‫ ﻣ ﻦ اﻟﻨ ﻮع اﻟﺤﻘﯿﻘ ﻲ و‬max , avg ‫ﻓ ﻲ ھ ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﺗ ﻢ اﻻﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﯿ ﺮات اﻟﺨﺎرﺟﯿ ﺔ‬
.‫ وﺑﺎﻟﺘﺎﻟﻲ ﺟﻤﯿﻊ ھﺬه اﻟﻤﺘﻐﯿﺮات ﺷﺎﻣﻠﺔ وﻣﻌﺮوﻓﺔ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وﺑﻘﯿﺔ اﻟﺪوال اﻟﻤﺴﺘﺨﺪﻣﺔ ﻣﻦ ﻗﺒﻞ ھﺬا اﻟﺒﺮﻧﺎﻣﺞ‬main( )
‫ﺑﯿﻨﻤ ﺎ اﻟﺪاﻟ ﺔ اﻟﺜﺎﻧﯿ ﺔ‬، ‫ ﻟﺤﺴ ﺎب اﻟﺪرﺟ ﺔ اﻻﻛﺒ ﺮ واﻟﻤﻌ ﺪل ﻣ ﻊ اﻟﺤﺎﻟ ﺔ‬calculate(m1,m2) ‫ اﻟﺪاﻟ ﺔ اﻻوﻟ ﻰ‬،‫اﻟﺒﺮﻧ ﺎﻣﺞ ﻛﻤ ﺎ ﻧﻼﺣ ﻆ ﻗ ﺎم ﺑﺎﺳ ﺘﺪﻋﺎء داﻟﺘ ﯿﻦ‬
. ‫ ﻓﻘﺪ اﺳﺘﺨﺪﻣﺖ ﻟﻄﺒﺎﻋﺔ اﻟﻨﺘﺎﺋﺞ ﻓﻘﻂ‬print_them(n1,n2)

‫)‪ (6.11‬اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻟﻨﻔﺴﮭﺎ أو ﻟﺪاﻟﺔ أﺧﺮى ‪ -:‬ﻓﻲ ﻟﻐﺔ ‪ C‬ﯾﻤﻜﻦ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻟﻨﻔﺴﮭﺎ أو ﻟﺪاﻟﺔ أﺧﺮى ﻓﻲ ﻧﻔﺲ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫ﻣﺜﺎل)‪ -: (6.11.1‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﯾﺴﺘﺨﺪم داﻟﺔ ﻟﺤﺴﺎب ﻣﻀﺮوب اﻟﻌﺪد )‪. (factorial‬‬
‫>‪#include <stdio.h‬‬ ‫اﻟﺘﻨﻔﯿﺬ ‪: 1‬‬
‫)‪long factorial (long a‬‬ ‫‪Please type a number: 4‬‬
‫{‬ ‫‪4! = 24‬‬
‫)‪if (a > 1‬‬
‫; ))‪return (a * factorial (a-1‬‬
‫‪else‬‬ ‫اﻟﺘﻨﻔﯿﺬ ‪: 2‬‬
‫; )‪return (1‬‬ ‫‪Please type a number: 9‬‬
‫}‬ ‫‪9! = 362880‬‬
‫) ( ‪main‬‬
‫{‬
‫; ‪long number‬‬
‫; ) " ‪printf("Please type a number:\n‬‬
‫; )‪scanf("%d",&number‬‬
‫;) )‪printf( "%d! =%d " ,number ,factorial (number‬‬
‫}‬
‫ﻓ ﻲ ھ ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﺗ ﻢ اﺳ ﺘﺪﻋﺎء اﻟﺪاﻟ ﺔ ﻟﻨﻔﺴ ﮭﺎ‪ ،‬ﻓﻼﺣ ﻆ اﻟﻤﻄﻠ ﻮب ﺣﺴ ﺎب )‪ factorial(a‬ﻟ ﺬﻟﻚ ﻋﻨ ﺪ اﻻﺳ ﺘﺪﻋﺎء اﺻ ﺒﺢ ﻟ ﺪﯾﻨﺎ اﺳ ﺘﺪﻋﺎء اﺧ ﺮ ھ ﻮ‬
‫)‪factorial(4) = 4*factorial(3‬‬ ‫)‪ ، factorial(a-1‬ﻓﻤﺜﻼً‬
‫)‪= 4*3*factorial(2‬‬
‫)‪= 4*3*2*factorial(1‬‬
‫‪= 4*3*2*1‬‬
‫‪= 24‬‬
‫ﻣﺜﺎل)‪ -: (6.11.2‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب وﻃﺒﺎﻋﺔ اﻟﻤﻀﺎﻋﻒ اﻟﻤﺸﺘﺮك اﻻﺻﻐﺮ)‪ (least common multiple‬ﻟﻌﺪدﯾﻦ ﺻﺤﯿﺤﯿﻦ ‪.‬‬
‫اﻟﻤﻀﺎﻋﻒ اﻟﻤﺸﺘﺮك اﻻﺻﻐﺮ)‪ (LCM‬ﯾﺤﺴﺐ ﻣﻦ اﻟﻘﺎﻧﻮن اﻻﺗﻲ ‪:‬‬
‫‪ GCD‬ﯾﻤﺜﻞ اﻟﻘﺎﺳﻢ اﻟﻤﺸﺘﺮك اﻻﻛﺒﺮ ﻟﻠﻌﺪﯾﻦ ‪ a‬و‪. b‬‬
‫ھﻨﺎك ﻋﺪة ﻃﺮق ﯾﻤﻜﻦ ﻣﻦ ﺧﻼﻟﮭﺎ اﻟﺤﺼﻮل ﻋﻠﻰ اﻟﻘﺎﺳﻢ اﻟﻤﺸﺘﺮك اﻻﻛﺒﺮ ‪ GCD‬وﻣﻨﮭﺎ ھﺬه اﻟﻄﺮﯾﻘﺔ اﻟﺒﺴﯿﻄﺔ ‪:‬‬
‫‪ .i‬ﻧﻘﻮم ﺑﺘﺤﻠﯿﻞ ﻛﻞ ﻋﺪد اﻟﻰ ﻗﻮاﺳﻤﮫ و ﺛﻢ ﻧﺒﺤﺚ ﻋﻦ اﻟﻘﻮاﺳﻢ اﻟﺘﻲ اﺷﺘﺮك ﻓﯿﮭﺎ اﻟﻌﺪدان ‪.‬‬
‫‪ .ii‬ﻧﻀﺮب اﻟﻘﻮاﺳﻢ اﻟﻤﺸﺘﺮﻛﺔ ﻓﯿﻨﺘﺞ ) اﻟﻘﺎﺳﻢ اﻟﻤﺸﺘﺮك اﻻﻛﺒﺮ( ‪.‬‬
‫ﻓﻤﺜﻼً ‪:‬‬
‫‪24=2*2*2*3‬‬ ‫اﻟﻌﺪد‬
‫‪28=2*2*7‬‬ ‫واﻟﻌﺪد‬
‫وﻣﻦ ھﻨﺎ اﺷﺘﺮك اﻟﻌﺪدان ﻓﻲ اﻟﻘﺎﺳﻢ ‪ 2‬ﻣﺮﺗﯿﻦ وﺑﺎﻟﺘﺎﻟﻲ‬
‫‪ 2*2=4‬ھﻮ اﻟﻘﺎﺳﻢ اﻟﻤﺸﺘﺮك اﻻﻛﺒﺮ ﺑﯿﻦ اﻟﻌﺪدﯾﻦ ‪.24 , 28‬‬

‫>‪#include <stdio.h‬‬ ‫‪Enter two numbers : 91 169‬‬
‫)‪least_common_multiple(a,b‬‬ ‫‪LCM = 1183‬‬
‫; ‪int a,b‬‬ ‫‪GCD = 15‬‬
‫{‬
‫; ‪int c,d‬‬
‫; ‪c=a‬‬
‫; ‪d=b‬‬
‫; ) )‪return( c*d/greatest_common_divisar(a,b‬‬
‫}‬
‫)‪greast_common_divisor(x,y‬‬
‫; ‪int x,y‬‬
‫{‬
‫; ‪int temp‬‬
‫)‪if(x==y‬‬
‫; ‪return x‬‬
‫‪else‬‬
‫)‪if(y>x‬‬
‫{‬
‫; ‪temp=y‬‬
‫; ‪y=x‬‬
‫; ‪x=temp‬‬
‫}‬
‫; ))‪return( greatest_common_divisor(x-y,y‬‬
‫}‬
‫) ( ‪main‬‬
‫{‬
‫; ‪int m,n,l,g‬‬
‫;) " ‪printf( " Enter two numbers :‬‬
‫;)‪scanf("%d%d",&n,&m‬‬
‫; )‪l=least_common_multiple(m,n‬‬
‫; )‪g=greatest_common_divisor(m,n‬‬
‫; )‪printf( " LCM =%d\n ", l‬‬
‫; )‪printf(" GCD =%d\n" , g‬‬
‫}‬
‫ﺧﻼل اﻟﺒﺮﻧﺎﻣﺞ اﻋﻼه‪ ،‬ﺗﻢ ﺗﻌﺮﯾﻒ داﻟﺔ اﻟﻤﻀﺎﻋﻒ اﻟﻤﺸﺘﺮك اﻻﺻﻐﺮ ﻟﻠﻌﺪدﯾﻦ اﻟﺼﺤﯿﺤﯿﻦ ‪ ، a,b‬واﻟﺘﻲ ﺧﻼﻟﮭﺎ ﺗﻢ اﺳﺘﺪﻋﺎء داﻟﺔ اﻟﻘﺎﺳ ﻢ اﻟﻤﺸ ﺘﺮك اﻻﻛﺒ ﺮ‬
‫ﻟﻠﻌﺪﯾﻦ اﻟﺼﺤﯿﺤﯿﻦ ‪ a,b‬واﻟﺘﻲ ﺗﻢ ﺗﻌﺮﯾﻔﮭﺎ ﻛﺪاﻟﺔ ﺛﺎﻧﯿﺔ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ‪ .‬ﺑﻌﺪھﺎ ﺗﻢ ادﺧﺎل ﻗﯿﻢ ﻟﻠﻤﺘﻐﯿ ﺮات ‪ m,n‬ﺧ ﻼل اﻟﺒﺮﻧ ﺎﻣﺞ ﺣﯿ ﺚ اﻋﻄﯿ ﺖ‬
‫ھﺬه اﻟﻘﯿﻢ اﻟﻰ اﻟﻤﺘﻐﯿﺮات ‪ a,b‬ﻟﺤﺴﺎب اﻟﻘﺎﺳﻢ اﻟﻤﺸﺘﺮك اﻻﻛﺒﺮ واﻟﻤﻀﺎﻋﻒ اﻟﻤﺸﺘﺮك اﻻﺻﻐﺮ‪.‬‬
‫)‪ (6.12‬اﻟﺪوال واﻟﻤﺼﻔﻮﻓﺎت )‪-: (Functions and Arrays‬‬

‫ذﻛﺮﻧﺎ ﺳﺎﺑﻘﺎً أﻧﮫ ﻋﻨﺪ ﻣﻌﺎﻟﺠﺔ ﺑﯿﺎﻧﺎت ﻛﺜﯿﺮة ﺟﺪاً ﯾﺘﺤﺘﻢ ﻋﻠﯿﻨﺎ اﺳﺘﺨﺪام اﻟﻤﺼﻔﻮﻓﺎت ﻟﯿﺴﮭﻞ ﻣﻌﮭﺎ ﻋﻤﻠﯿﺔ ﺗﺨﺰﯾﻦ اﻟﺒﯿﺎﻧﺎت ﻓﻲ ﻣﺘﻐﯿﺮات ﻗﻠﯿﻠﺔ‪ ،‬وﻟﻜﻲ‬
‫ﯾﺼﺒﺢ اﻟﺒﺮﻧﺎﻣﺞ ﺳﮭﻞ اﻟﻜﺘﺎﺑﺔ واﻟﻤﺘﺎﺑﻌﺔ واﻟﻔﮭﻢ ﯾﺘﻢ اﺳﺘﺨﺪام اﻟﺪوال ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت‪.‬‬
‫وﻟﻜﻦ ﯾﺠﺐ أن ﻧﺄﺧﺬ ﻓﻲ اﻻﻋﺘﺒﺎر ﻛﯿﻔﯿﺔ ﺗﻤﺮﯾﺮ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ اﻟﻰ أي داﻟﺔ‪ ،‬وھﺬا ﻗﺪ ﯾﺤﺪث ﻛﺎﻻﺗﻲ ‪:‬‬
‫‪ .i‬ﯾﻤﻜﻦ أن ﺗﺘﻢ ﻋﻤﻠﯿﺔ ﺗﻤﺮﯾﺮ اﻟﺒﯿﺎﻧﺎت اﻟﻰ اﻟﺪوال ﺑﺄﺳﺘﺨﺪام اﻟﻤﺘﻐﯿﺮات اﻟﺨﺎرﺟﯿﺔ‪.‬‬
‫‪ .ii‬ﻗﺪ ﯾﺤﺪث اﻟﺘﻤﺮﯾﺮ ﺑﺎﻻﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺔ ﻓﻲ اﻟﺪاﻟﺔ ﺑﺤﯿﺚ ﺗﻜﻮن ﻣﻦ ﻧﻔﺲ اﻟﻨﻮع واﻟﻄﻮل‪.‬‬

‫ﻣﺜﺎل)‪ -: (6.12.1‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة ﻗﯿﻢ ﺻﺤﯿﺤﺔ وﺗﺨﺰﯾﻨﮭﺎ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ‪ a‬ذات ﺑﻌﺪ واﺣﺪ ﺛﻢ ﺗﺨﺰﯾﻦ ھﺬه اﻟﺒﯿﺎﻧﺎت ﺑﺎﻟﻌﻜﺲ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ‪ b‬ﻋﻦ‬
‫ﻃﺮﯾﻖ اﻟﺪاﻟﺔ‪.‬‬
‫>‪#include <stdio.h‬‬ ‫‪Enter a[0]= 7‬‬
‫‪#define M 5‬‬ ‫‪Enter a[1]= -3‬‬
‫; ]‪int i , k, a[M] , b[M‬‬ ‫‪Enter a[2]= 8‬‬
‫) ( ‪int main‬‬ ‫‪Enter a[3]= 4‬‬
‫{‬ ‫‪Enter a[4]= 2‬‬
‫)‪for(i=0 ; i< M ; i++‬‬ ‫‪Array after reversed is :‬‬
‫{‬ ‫‪b[0]= 2‬‬
‫; )‪printf (" Enter a[%d]= ",i‬‬ ‫‪b[1]= 4‬‬
‫; )]‪scanf ("%d",&a[i‬‬ ‫‪b[2]= 8‬‬
‫}‬ ‫‪b[3]= -3‬‬
‫; ) (‪reversed_a‬‬ ‫‪b[4]= 7‬‬
‫; "‪printf ("Array after reversed is : \n‬‬
‫)‪for(i=0 ; i< M ; i++‬‬
‫; )]‪printf (" b[%d]=%d",i,b[i‬‬
‫; )"‪printf ("\n‬‬
‫; ‪return 0‬‬
‫}‬
‫) (‪reversed_a‬‬
‫{‬
‫; ‪k=M-1‬‬
‫)‪for(i=0 ; i< M ; i++‬‬
‫{‬
‫; ]‪b[i]=a[k‬‬
‫; ‪k-=1‬‬
‫}‬
‫}‬
‫ﺗﻤﺎرﯾﻦ ) اﻟﻔﺼﻞ اﻟﺴﺎدس(‬
‫ﺗﻤﺮﯾﻦ ‪ : 1‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة اﻃﻮال ﻣﺜﻠﺚ ‪ A,B,C‬ﺛﻢ أﺣﺴﺐ ﻣﺴﺎﺣﺔ ھﺬا اﻟﻤﺜﻠﺚ ﻋﻦ ﻃﺮﯾﻖ اﻟﺪاﻟﺔ ‪،‬ﻋﻠﻤﺎً أن‬
‫ﺗﻤﺮﯾﻦ ‪ : 2‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺪاﻟﺔ ﻣﮭﻤﺘﮭﺎ اﯾﺠﺎد وﻃﺒﺎﻋﺔ ﺟﻤﯿﻊ اﻻﻋﺪاد اﻻوﻟﯿﺔ اﻟﻮاﻗﻌﺔ ﺑﯿﻦ ‪ 20‬و ‪. 500‬‬
‫ﺗﻤﺮﯾﻦ ‪ : 3‬ﺳﻠﺴﻠﺔ ﻓﯿﺒﻮﻧﺎﺷﻲ ‪ Fibonacci Series‬وھﻲ ﻋﺒﺎرة ﻋﻦ ﺳﻠﺴﻠﺔ أرﻗﺎم ﯾﻜﻮن ﻓﯿﮭﺎ اﻟﺮﻗﻤﯿﻦ اﻻول واﻟﺜﺎﻧﻲ ﯾﺴﺎوي ‪ 1‬واﻻرﻗﺎم اﻟﺜﺎﻟﺚ‬
‫وﻣﺎﻓﻮق ﻛﻞ رﻗﻢ ﻣﻨﮭﺎ ﯾﺴﺎوي ﻣﺠﻤﻮع اﻟﺮﻗﻤﯿﻦ اﻟﺴﺎﺑﻘﯿﻦ ﻟﮫ ‪.‬‬
‫… ‪1 1 2 3 5 8 13 21 33‬‬
‫أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﺑﺎﺳﺘﺨﺪام اﻟﺪاﻟﺔ ﻟﺤﺴﺎب ﻣﺠﻤﻮع ﻣﺘﺴﻠﺴﻠﺔ ﻓﯿﺒﻮﻧﺎﺷﻲ‬
‫ﺗﻤﺮﯾﻦ ‪ : 4‬اﻟﻤﻄﻠﻮب ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﺴﺎب ﻣﻌﺪل ‪ N‬ﻣﻦ اﻟﻘﯿﻢ اﻟﺼﺤﯿﺤﺔ ﻋﻠﻰ أن ﯾﺘﻢ ﺣﺴﺎب اﻟﻤﻌﺪل ﻓﻲ داﻟﺔ ﻣﺴﺘﻘﻠﺔ‪.‬‬

‫ﺗﻤﺮﯾﺮ ‪ : 5‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة اﻟﻤﺘﻐﯿﺮﯾﻦ ‪ n,m‬ﺛﻢ ﺣﺴﺎب ﻗﯿﻤﺔ اﻟﻤﻌﺎدﻟﺔ‬
‫ﺗﻤﺮﯾﻦ ‪ : 6‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻻدﺧﺎل رﻗﻢ اﻟﻤﻮﻇﻒ وأﺳﻤﺔ و راﺗﺒﺔ اﻟﺸ ﮭﺮي وﻋ ﺪد ﺳ ﺎﻋﺎت اﻟﻌﻤ ﻞ اﻻﺿ ﺎﻓﻲ اﻟﺘ ﻲ ﻋﻤﻠﮭ ﺎ‪ ،‬ﺛ ﻢ ﺣﺴ ﺎب اﻟﺮاﺗ ﺐ اﻟﺼ ﺎﻓﻲ‬
‫ﻟﻌﺪد ‪ N‬ﻣﻦ اﻟﻤﻮﻇﻔﯿﻦ ﻓﻲ ﻣﺆﺳﺴﺔ ﻣﺎ‪ ،‬ﻋﻠﻤﺎً أن اﻟﺮاﺗﺐ اﻟﺼﺎﻓﻲ ﻟﻠﻤﻮﻇﻒ = اﻟﺮاﺗﺐ اﻟﺸﮭﺮي ‪ +‬ﻣﺒﻠﻎ اﻟﻌﻤﻞ اﻻﺿ ﺎﻓﻲ ‪ .‬ﻣﺒﻠ ﻎ اﻟﻌﻤ ﻞ اﻻﺿ ﺎﻓﻲ ﯾﺤﺴ ﺐ‬
‫ﻋﻦ ﻃﺮﯾﻖ اﻟﺠﺪول اﻻﺗﻲ ‪:‬‬
‫اﻟﻤﺒﻠﻎ ﻓﻲ اﻟﺴﺎﻋﺔ اﻟﻮاﺣﺪة)ﺑﺎﻟﺪﯾﻨﺎر(‬ ‫ﺳﺎﻋﺎت اﻟﻌﻤﻞ ﺧﻼل اﻟﺸﮭﺮ‬
‫‪1000‬‬ ‫أﻗﻞ أو ﯾﺴﺎوي ‪ 10‬ﺳﺎﻋﺎت‬
‫‪1500‬‬ ‫أﻛﺜﺮ ﻣﻦ ‪ 10‬ﺳﺎﻋﺎت‬
‫‪2000‬‬ ‫أﻛﺜﺮ ﻣﻦ ‪ 25‬ﺳﺎﻋﺔ‬
‫ﻋﻠﻰ أن ﺗﻜﻮن اﻟﻨﺘﺎﺋﺞ ﺑﺎﻟﺸﻜﻞ اﻻﺗﻲ ‪:‬‬
‫اﻟﺮاﺗﺐ اﻟﺼﺎﻓﻲ‬ ‫أﺟﺮة اﻟﺴﺎﻋﺔ اﻟﻮاﺣﺪة‬ ‫اﻟﺴﺎﻋﺎت اﻻﺿﺎﻓﯿﺔ‬ ‫أﺳﻢ اﻟﻤﻮﻇﻒ‬ ‫رﻗﻢ اﻟﻤﻮﻇﻒ‬
‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬
‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬
‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬
‫ﺗﻤﺮﯾﻦ ‪ -: 7‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﻘﺮاءة اﻟﻤﺼﻔﻮﻓﺔ )‪ A(25,25‬اﻟﺘﻲ ﺗﺤﺘﻮي ﻋﻠﻰ ﻗﯿﻢ ﺣﻘﯿﻘﯿﺔ‪،‬ﺛﻢ ﻛﺘﺎﺑﺔ داﻟﺔ ﻟﻌﻤﻞ ﻛﻞ ﻣﻤﺎ ﯾﺎﺗﻲ ‪:‬‬
‫‪ (a‬ﺟﻤﻊ اﻟﻌﺎﺻﺮ اﻟﻮاﻗﻌﺔ أﻋﻠﻰ اﻟﻘﻄﺮ اﻟﺮﺋﯿﺴﻲ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫‪ (b‬ﺟﻤﻊ اﻟﻌﻨﺎﺻﺮ اﻟﻮاﻗﻌﺔ أﺳﻔﻞ اﻟﻘﻄﺮ اﻟﺮﺋﯿﺴﻲ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫‪ (c‬ﺣﺎﺻﻞ ﺿﺮب ﻋﻨﺎﺻﺮ اﻟﻘﻄﺮ اﻟﺮﺋﯿﺴﻲ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫‪ (d‬اﯾﺠﺎد أﻛﺒﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫‪ (e‬اﯾﺠﺎد أﺻﻐﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫‪ (f‬ﺗﺮﺗﯿﺐ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺑﺼﻮرة ﺗﺼﺎﻋﺪﯾﺎ‪.‬‬

C en Arabe - 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

C en Arabe - 1

Transféré par

Droits d'auteur :

Formats disponibles

‫‪2007‬‬

‫ﻣﻘﺪﻣﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺑﻠﻐﺔ ‪C‬‬

‫ﻣﺤﻤﺪ ﺳﺎﻟﻢ اﻟﺒﮭﺎدﻟﻲ‬

‫اﻟﺼﻔﺤﺔ‬ ‫اﻟﻤﻮﺿﻮع‬ ‫اﻟﺼﻔﺤﺔ‬ ‫اﻟﻤﻮﺿﻮع‬

‫‪20‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ‬ ‫‪4‬‬ ‫اﻟﻤﻘﺪﻣﺔ‬

‫‪21‬‬ ‫اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﯾﺔ )‪(while‬‬ ‫‪4‬‬ ‫اﻟﺮﻣﻮز‬

‫‪22‬‬ ‫اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﯾﺔ )‪(do-While‬‬ ‫‪4‬‬ ‫اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة‬

‫‪24‬‬ ‫اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﯾﺔ )‪(for‬‬ ‫‪4‬‬ ‫اﻟﻤﻌٌﺮﻓﺎت‬

‫‪25‬‬ ‫ﺟﻤﻞ اﻟﺘﻔﺮع‬ ‫‪5‬‬ ‫اﻻﻋﺪاد‬

‫‪25‬‬ ‫ﺟﻤﻠﺔ أﻗﻄﻊ )‪(break‬‬ ‫‪5‬‬ ‫اﻟﺴﻼﺳﻞ واﻟﺤﺮوف‬

‫‪26‬‬ ‫ﺟﻤﻠﺔ اﻻﺳﺘﻤﺮار )‪(continue‬‬ ‫‪6‬‬ ‫اﻟﻤﺘﻐﯿﺮات‬

‫‪26‬‬ ‫ﺟﻤﻠﺔ ﺧﺮوج )‪(exit‬‬ ‫‪7‬‬ ‫اﻟﺜﻮاﺑﺖ‬

‫‪26‬‬ ‫ﺟﻤﻠﺔ أذھﺐ اﻟﻰ )‪(goto‬‬ ‫‪7‬‬ ‫اﻟﻤﺆﺛﺮات‬

‫‪27‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‬ ‫‪10‬‬ ‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ ‪ :‬اﻟﮭﯿﻜﻠﯿﺔ ﻟﻠﺒﺮاﻣﺞ‬

‫‪28‬‬ ‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ‪ :‬اﻟﻤﺼﻔﻮﻓﺎت‬ ‫‪11‬‬ ‫اﻟﺘﻌﻠﯿﻘﺎت‬

‫‪28‬‬ ‫اﻟﻤﺼﻔﻮﻓﺎت ذات اﻟﺒﻌﺪ اﻟﻮاﺣﺪ‬ ‫‪11‬‬ ‫اﻟﺘﻮﺟﯿﮭﺎت‬

‫‪30‬‬ ‫اﻟﻤﺼﻔﻮﻓﺎت ذات اﻟﺒﻌﺪﯾﻦ‬ ‫‪11‬‬ ‫اﻟﺪاﻟﺔ اﻟﺮﺋﯿﺴﯿﺔ ) (‪main‬‬

‫‪33‬‬ ‫اﻟﻤﺼﻔﻮﻓﺎت اﻟﺤﺮﻓﯿﺔ‬ ‫‪11‬‬ ‫أدﺧﺎل وأﺧﺮاج اﻟﺒﯿﺎﻧﺎت‬

‫‪34‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ‬ ‫‪15‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬

‫‪35‬‬ ‫اﻟﻔﺼﻞ اﻟﺴﺎدس ‪ :‬اﻟﺪوال‬ ‫‪16‬‬ ‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ ‪ :‬اﻟﺘﺮاﻛﯿﺐ اﻟﺸﺮﻃﯿﺔ‬

‫‪39‬‬ ‫اﻟﺪوال اﻟﺮﯾﺎﺿﯿﺔ‬ ‫‪16‬‬ ‫اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﺒﺴﯿﻂ )‪(if‬‬

‫‪41‬‬ ‫اﻟﻤﺘﻐﯿﺮات اﻟﺨﺎرﺟﯿﺔ‬ ‫‪17‬‬ ‫اﻟﺘﺮﻛﯿﺐ اﻟﺸﺮﻃﻲ اﻟﻜﺎﻣﻞ )‪(if-else‬‬

‫‪43‬‬ ‫اﻟﺪوال واﻟﻤﺼﻔﻮﻓﺎت‬ ‫‪18‬‬ ‫ﺗﺮﻛﯿﺐ اﻟﻤﺆﺛﺮ اﻟﺸﺮﻃﻲ )?(‬

‫‪44‬‬ ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ اﻟﺴﺎدس‬ ‫‪18‬‬ ‫اﻟﺘﺮﻛﯿﺐ اﻻﻧﺘﻘﺎﺋﻲ )‪(switch‬‬

‫ﺻﻔﺤﺔ ‪2‬‬ ‫‪University of Baghdad-College of Science- Department of Mathematics‬‬ ‫‪Email : m.albahadeli@yahoo.com‬‬

‫ﺑﺴﻢ ﺍﷲ ﺍﻟﺮﲪﻦ ﺍﻟﺮﺣﻴﻢ‬

‫أﺳﺌﻠﻜﻢ اﻟﺪﻋﺎء ﻟﻲ وﻟﻮاﻟﺪي‬

‫ﺻﻔﺤﺔ ‪3‬‬ ‫‪University of Baghdad-College of Science- Department of Mathematics‬‬ ‫‪Email : m.albahadeli@yahoo.com‬‬

‫اﻟﻔﺼﻞ اﻷول‪ :‬أﺳﺎﺳﯿﺎت ‪( Fundamentals of C) C‬‬

‫)‪ (1.2‬اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة ) ‪(Reserved words‬‬

‫‪typename‬‬ ‫‪union‬‬ ‫‪unsigned‬‬ ‫‪using‬‬ ‫‪void‬‬ ‫‪while‬‬ ‫‪and‬‬ ‫‪or‬‬

‫)‪ (1.3‬اﻟﻤﻌّﺮﻓﺎت )‪(Identifiers‬‬

‫ﺻﻔﺤﺔ ‪4‬‬ ‫‪University of Baghdad-College of Science- Department of Mathematics‬‬ ‫‪Email : m.albahadeli@yahoo.com‬‬

‫‪x12, student_name, degree, AVARAGE, ToTaL, sum‬‬ ‫ﻣﺜﺎل‪ :‬ﻣﻌّﺮﻓﺎت ﻣﻘﺒﻮﻟﺔ‬

‫)‪ (1.4‬اﻷﻋﺪاد )‪(Numbers‬‬

‫)‪ (1.5‬اﻟﺴﻼﺳﻞ واﻟﺤﺮوف )‪(Strings and Characters‬‬

‫ﻣﺜﺎل‪"This is a sentence." , "Go to room" , "NAME:" , "56&4787" -:‬‬

‫ﻣﺜﺎل‪'+' , 'A' , 'a' , '*' , '7' -:‬‬

‫)‪ (1.6‬اﻟﻤﺘﻐﯿﺮات )‪(Variables‬‬

‫أن ﯾﺘﻜﻮن ﻣﻦ ﺣﺮف أو ﺣﺮوف أو ﺣﺮوف وأرﻗﺎم ‪.‬‬ ‫‪.a‬‬

‫ﺻﻔﺤﺔ ‪5‬‬ ‫‪University of Baghdad-College of Science- Department of Mathematics‬‬ ‫‪Email : m.albahadeli@yahoo.com‬‬

‫اﻟﻨﻮع‬ ‫اﻟﻮﺻﻒ‬ ‫اﻟﺤﺠﻢ‬ ‫اﻟﻤﺪى‬

short int -32768 to 32767

unsigned short int

‫ﯾﻌﺘﻤﺪ ﻋﻠﻰ اﻟﻨﻈﺎم‬

unsigned int Integer 4bytes 0 to 4294967295

long int -2147483648 to 2147483647

unsigned long int

bool Boolean value: true or false 1byte true or false

1.7e- 308 to 1.7e+308

1.2e- 4932 to 1.2e+4932

unsigned char Character 1byte 0 to 255

Example 1 Example 2 Example 3

Type Variable_Name1, Varible_Name2, Variable_Name3,……;

6 ‫ﺻﻔﺤﺔ‬ University of Baghdad-College of Science- Department of Mathematics Email : m.albahadeli@yahoo.com

‫‪Example 1‬‬ ‫‪Example 2‬‬ ‫‪Example 3‬‬

‫)‪ (1.7‬اﻟﺜﻮاﺑﺖ )‪(Constants‬‬

‫; ‪const Type constant_name=constant_value‬‬

‫اﻟﻤﺆﺛﺮ‬ ‫ﻣﻌﻨﺎه‬ ‫ﻣﺜﺎل‬

‫‪+‬‬ ‫‪addition‬‬ ‫‪a+b‬‬

‫‪-‬‬ ‫‪subtraction‬‬ ‫‪a-b‬‬

‫*‬ ‫‪multiplication‬‬ ‫‪a*b‬‬

‫‪/‬‬ ‫‪division‬‬ ‫‪a/b‬‬

‫‬ ‫‪multiplication‬‬ ‫‪ab‬‬