‫اﻟﺒﺮﻣﺠﺔ‬

‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬

‫…‪Prog‬‬

‫اﻋﺪاد‬
‫أ‪.‬هﺸﺎم ﺣﺴﻦ‬
‫‪1‬‬
 ‫ﺗﻤﻬﻴﺪ‬
‫ﻳﺘﻜﻮن اﻟﺤﺎﺳﺐ ﺑﺼﻮرة أﺳﺎﺳﻴﺔ ﻣﻦ اﻟﻤﻜﻮﻧﺎت اﻟﻤﺎدﻳﺔ ‪ Hardware‬واﻟﻤﻜﻮﻧﺎت اﻟﺒﺮﻣﺠﻴﺔ ‪ Software‬واﻟﺘﻲ ﺗﺘﺄﻟﻒ‬
‫ﻣﻦ ﻧﻈﻢ ﺗﺸﻐﻴﻞ وﺑﺮاﻣﺞ ﺗﻄﺒﻴﻘﻴﺔ‪ ،‬اﻷداة اﻟﻤﺴﺘﺨﺪﻣﺔ ﻹﻧﺘﺎج هﺬﻩ اﻟﻤﻜﻮﻧﺎت هﻲ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ‪.‬‬
‫وهﺬﻩ ﺑﻌﺾ اﻷﻣﺜﻠﺔ ﻋﻠﻰ اﻟﺒﺮﻣﺠﻴﺎت‪:‬‬
‫‪ .1‬ﻧﻈﻢ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت‪.‬‬
‫‪ .2‬اﻟﻨﻈﻢ اﻟﺨﺒﻴﺮة‬
‫‪ .3‬ﻧﻈﻢ اﻟﺘﺤﻜﻢ اﻟﻤﺒﺮﻣﺞ‬
‫‪ .4‬ﻧﻈﻢ اﻟﺘﺸﻐﻴﻞ‬
‫‪ .5‬ﺑﺮاﻣﺞ اﻟﺤﻮاﺳﺐ اﻟﺸﺨﺼﻴﺔ آﺎﻟﺒﺮﻣﺠﻴﺎت اﻟﻤﻜﺘﺒﻴﺔ واﻷﻟﻌﺎب‬
‫‪ .6‬ﺑﺮﻣﺠﺔ ﺷﺒﻜﺎت اﻟﺤﺎﺳﺐ‬
‫‪ .7‬ﺑﺮﻣﺠﺔ ﺻﻔﺤﺎت اﻹﻧﺘﺮﻧﺖ‬
‫ﻳﻤﻜﻦ ﺗﻘﺴﻴﻢ ﻣﺴﺘﻮﻳﺎت ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ إﻟﻰ ﺛﻼث ﻣﺴﺘﻮﻳﺎت آﺎﻵﺗﻲ‪:‬‬
‫‪ .1‬ﻟﻐﺔ اﻟﻤﺴﺘﻮى اﻟﻤﻨﺨﻔﺾ أو ﻣﺎ ﻳﻌﺮف ﺑﻠﻐﺔ اﻵﻟﺔ ‪ Machine Language‬وهﻲ ﻟﻐﺔ اﻟﺼﻔﺮ واﻟﻮاﺣﺪ‬
‫ﺣﻴﺚ ﻳﻤﺜﻞ اﻟﺼﻔﺮ اﻟﺠﻬﺪ اﻟﻜﻬﺮﺑﻲ اﻟﻤﻨﺨﻔﺾ واﻟﻮاﺣﺪ اﻟﺠﻬﺪ اﻟﻜﻬﺮﺑﻲ اﻟﻌﺎﻟﻲ‪.‬‬
‫‪ .2‬ﻟﻐﺔ اﻟﺘﺠﻤﻴﻊ ‪ Assembly Language‬وﺗﺤﺘﻮي ﻋﻠﻰ أواﻣﺮ ﻣﻘﺘﺒﺴﺔ ﻣﻦ اﻟﻠﻐﺔ اﻹﻧﺠﻠﻴﺰﻳﺔ ﻣﺜﻞ ‪add,‬‬
‫‪. sub‬‬
‫‪ .3‬ﻟﻐﺎت اﻟﻤﺴﺘﻮى اﻟﻌﺎﻟﻲ وهﻲ اﻷﻗﺮب ﻟﻤﺴﺘﻮى اﻟﻤﺒﺮﻣﺞ وﺗﺤﺘﻮي أﻳﻀﺎ ﻋﻠﻰ أواﻣﺮ ﻣﻘﺘﺒﺴﺔ ﻣﻦ اﻟﻠﻐﺔ‬
‫اﻹﻧﺠﻠﻴﺰﻳﺔ‪ ،‬وهﻲ اﻟﻠﻐﺎت اﻟﺘﻲ ﻳﺴﺘﺨﺪﻣﻬﺎ اﻟﻤﺒﺮﻣﺠﻮن ﻓﻲ ﺗﻨﻔﻴﺬ اﻟﺘﻄﺒﻴﻘﺎت اﻟﻤﺨﺘﻠﻔﺔ‪ ،‬ﺑﻌﺾ هﺬﻩ اﻟﻠﻐﺎت‬
‫ﻋﺎﻣﺔ اﻟﻐﺮض ﻣﺜﻞ ﻟﻐﺎت ‪....basic, c, c+‬وﺑﻌﻀﻬﺎ ﺧﺎص اﻟﻐﺮض ﻣﺜﻞ ‪Cobol, simula, prolog‬‬
‫‪.......‬‬
‫ﺗﻌﺮﻳﻒ ‪:‬‬
‫اﻟﺒﺮﻧﺎﻣﺞ هﻮ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷواﻣﺮ واﻟﺘﺮآﻴﺒﺎت اﻟﺒﺮﻣﺠﻴﺔ واﻟﺘﻲ ﺗﺘﻢ ﺗﺮﺟﻤﺘﻬﺎ إﻟﻰ ﻟﻐﺔ اﻵﻟﺔ ﺛﻢ ﺗﻨﻔﻴﺬهﺎ‪.‬‬
‫آﻞ اﻟﺘﻄﺒﻴﻘﺎت اﻟﺘﻲ ﺗﻘﻮم ﺑﻬﺎ ﻋﻠﻰ اﻟﺤﺎﺳﺐ ﻟﻴﺴﺖ إﻻ ﺗﻨﻔﻴﺬًا ﻟﺒﺮاﻣﺞ آﺘﺒﺖ ﺑﺈﺣﺪى ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﺑﻌﺪ أن ﺗﻤﺖ‬
‫ﺗﺮﺟﻤﺘﻬﺎ إﻟﻰ ﻟﻐﺔ اﻵﻟﺔ‪.‬‬
‫اﻷﻣﺮ اﻟﺒﺮﻣﺠﻲ‪ :‬هﻮ ﻋﺒﺎرة ﻋﻦ ﻣﻘﻄﻊ ﻟﻐﻮي ﻳﻜﺘﺐ ﺑﺼﻴﻐﻪ ﻣﺤﺪدة ﻟﺘﻨﻔﻴﺬ ﻣﻬﻤﺔ ﻣﻌﻴﻨﻪ‪.‬‬
‫ﺑﻌﺾ اﻷﻣﺜﻠﺔ ﻋﻠﻰ اﻷواﻣﺮ اﻟﺒﺮﻣﺠﻴﺔ‪:‬‬
‫ƒ أواﻣﺮ اﻹدﺧﺎل وهﻲ اﻟﺘﻲ ﺗﺴﻤﺢ ﻟﻠﻤﺴﺘﺨﺪم إدﺧﺎل ﺑﻴﺎﻧﺎت ﻟﻠﺤﺎﺳﺐ ﻋﺒﺮ وﺣﺪات اﻹدﺧﺎل‪.‬‬
‫ƒ أواﻣﺮ اﻹﺧﺮاج وهﻲ اﻟﺘﻲ ﺗﺴﻤﺢ ﻟﻠﻤﺴﺘﺨﺪم ﺑﺈﻇﻬﺎر اﻟﺒﻴﺎﻧﺎت ﻋﺒﺮ وﺣﺪات اﻹﺧﺮاج اﻟﻤﺨﺘﻠﻔﺔ‪.‬‬
‫ƒ اﻷواﻣﺮ اﻟﺘﻲ ﺗﺴﻤﺢ ﺑﻔﺘﺢ اﻟﻤﻠﻔﺎت وﻗﺮاءة ﺑﻴﺎﻧﺎت ﻣﻨﻬﺎ أو آﺘﺎﺑﺔ ﺑﻴﺎﻧﺎت ﻋﻠﻴﻬﺎ‪.‬‬
‫ƒ أدوات اﻟﺘﺤﻜﻢ ﻓﻲ ﻣﺴﺎر اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ ﺣﻴﺚ ﺗﻨﻔﻴﺬ أﻣﺮ ﻋﻨﺪ ﺗﻮﻓﺮ ﺷﺮط ﻣﺤﺪد أو ﺗﻜﺮار ﺗﻨﻔﻴﺬ أﻣﺮ ﻣﻌﻴﻦ‪.‬‬
‫و ﺑﺎﻟﻄﺒﻊ ﻟﻜﻞ ﻟﻐﺔ ﺑﺮﻣﺠﺔ أﺳﻠﻮﺑﻬﺎ اﻟﺨﺎص ﻓﻲ اﻟﺘﻌﺒﻴﺮ ﻋﻦ هﺬﻩ اﻷواﻣﺮ‪.‬‬
‫ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﻋﺎﻟﻴﺔ اﻟﻤﺴﺘﻮى ﻳﻤﻜﻦ ﺗﺼﻨﻴﻔﻬﺎ إﻟﻰ ﺛﻼﺛﺔ ﺗﺼﻨﻴﻔﺎت ﻣﻦ ﺣﻴﺚ اﻟﺘﺮآﻴﺒﻪ اﻟﻌﺎﻣﺔ آﺎﻵﺗﻲ‪:‬‬
‫‪ .1‬اﻟﻠﻐﺎت اﻹﺟﺮاﺋﻴﺔ "‪ "procedural languages‬وﻳﺘﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ ﻓﻴﻬﺎ ﻣﻦ ﻋﺪة أواﻣﺮ ﺑﺮﻣﺠﻴﻪ‬
‫ﻣﺘﺘﺎﺑﻌﺔ‪ ،‬وﻣﻦ أﻣﺜﻠﺔ هﺬﻩ اﻟﻠﻐﺎت ‪...........fortoran,basic,cobol‬‬
‫‪ .2‬اﻟﻠﻐﺎت اﻟﻬﻴﻜﻠﻴﺔ "‪ "structural languages‬وﻳﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ ﻓﻴﻬﺎ ﻣﻬﻴﻜﻞ أي ﻣﺘﻜﻮن ﻣﻦ ﺗﺮآﻴﺒﺎت‬
‫داﺧﻠﻴﺔ ﺗﺴﻤﻰ دوال و اﻟﺪاﻟﺔ ﺗﺤﺘﻮي ﻋﻠﻰ اﻷواﻣﺮ اﻟﺒﺮ ﻣﺠﻴﻪ ‪ ،‬وﻣﻦ أﻣﺜﻠﺔ هﺬﻩ اﻟﻠﻐﺎت‬
‫‪...........prolog,C,pascal‬‬
‫‪ .3‬اﻟﻠﻐﺎت آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ " ‪ "object oriented languages‬وﻳﺘﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ ﻓﻴﻬﺎ ﻣﻦ ﺗﺮآﻴﺒﺎت‬
‫ﺑﺮﻣﺠﻴﻪ ﺗﺴﻤﻰ ﺻﻔﻮف ﺗﺤﺘﻮي ﻋﻠﻰ دوال و ﻣﺘﻐﻴﺮات‪ ،‬وﻳﺘﻤﻴﺰ هﺬا اﻟﻨﻮع ﺑﻌﺪة ﻣﻮاﺻﻔﺎت ﺑﺮﻣﺠﻴﻪ ﺟﺪﻳﺪة‬
‫آﺈﻋﺎدة اﻻﺳﺘﺨﺪام واﻟﻮراﺛﺔ وﺗﻐﻠﻴﻒ اﻟﻜﻮد واﻟﺘﻌﺪدﻳﺔ اﻟﺸﻜﻠﻴﺔ وﺑﺎﻟﻄﺒﻊ ﺳﺘﺘﻀﺢ هﺬﻩ اﻟﻤﺴﻤﻴﺎت ﻻﺣﻘًﺎ ﻋﻨﺪ‬
‫دراﺳﺘﻬﺎ ﻋﻠﻰ اﻋﺘﺒﺎر أن اﻟﻠﻐﺔ اﻟﺘﻲ ﺳﻨﺴﺘﺨﺪﻣﻬﺎ ﻓﻲ دراﺳﺔ هﺬﻩ اﻟﻤﺎدة ﻣﻦ هﺬا اﻟﻨﻮع‪ ،‬وﻣﻦ أﻣﺜﻠﺔ هﺬﻩ‬
‫اﻟﻠﻐﺎت‪….Java,C++‬‬
‫ﻳﻌﺘﺒﺮ هﺬا اﻟﺘﺼﻨﻴﻒ ﻟﻠﻐﺎت اﻟﻌﺎﻟﻴﺔ ﻣﺘﺘﺎﺑﻊ زﻣﻨﻴًﺎ ﺣﻴﺚ آﺎﻧﺖ اﻟﺒﺮﻣﺠﺔ اﻹﺟﺮاﺋﻴﺔ هﻲ أوﻟﻰ أﺳﺎﻟﻴﺐ اﻟﺒﺮﻣﺠﺔ اﻟﺘﻲ‬
‫اﺳﺘﺨﺪﻣﺖ ﺛﻢ ﻇﻬﺮت اﻟﺒﺮﻣﺠﺔ اﻟﻬﻴﻜﻠﻴﺔ ﺛﻢ ﺁﺧﺮهﺎ ﻓﻲ اﻟﻈﻬﻮر اﻟﺒﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﻴﺔ‪.‬‬
‫ﺧﻄﻮات ﺣﻞ اﻟﻤﺸﻜﻠﺔ وﺑﻨﺎء اﻟﻨﻈﺎم‪:‬‬
‫ﻻ ﺷﻚ أن هﺪف اﻟﺒﺮﻣﺠﺔ هﻮ إﻳﺠﺎد اﻟﺤﻞ ﻟﻤﺸﻜﻠﺔ ﻣﺎ‪ ،‬وﻣﻦ ﺛﻢ ﺑﻨﺎء ﻧﻈﺎم ﻳﻤﺜﻞ اﻟﺤﻞ ﻟﻬﺬة اﻟﻤﺸﻜﻠﺔ وﻟﻬﺬا اﻷﻣﺮ‬
‫ﺧﻄﻮات ﻣﺘﺘﺎﺑﻌﺔ ﻻ ﻳﻤﻜﻦ اﻟﺒﺪء ﻓﻲ ﺧﻄﻮة إﻻ إذا اﻧﺘﻬﻴﻨﺎ ﻣﻦ اﻟﺘﻲ ﺗﺴﺒﻘﻬﺎ‪:‬‬
‫‪ .1‬ﺗﻌﺮﻳﻒ اﻟﻤﺸﻜﻠﺔ وﺟﻤﻊ اﻟﺒﻴﺎﻧﺎت وﺗﺤﺪﻳﺪ اﻟﻤﺘﻄﻠﺒﺎت‪ ،‬واﻟﻤﻘﺼﻮد ﺑﺎﻟﻤﺘﻄﻠﺒﺎت هﻨﺎ ﻣﺎذا ﻧﺮﻳﺪ ﻣﻦ أن ﻧﻔﻌﻞ‪.‬‬
‫‪ .2‬ﺗﺤﻠﻴﻞ اﻟﻨﻈﺎم وهﻨﺎ ﻳﺘﻢ ﺗﺤﺪﻳﺪ اﻟﻤﺆﺛﺮات اﻷﺳﺎﺳﻴﺔ ﻓﻲ اﻟﻨﻈﺎم ودور آﻞ ﻣﺆﺛﺮ وهﺬا ﻣﺎ ﻳﻌﺮف ﻓﻲ اﻟﺘﺤﻠﻴﻞ‬
‫اﻟﻜﺎﺋﻨﻲ ﺑﺎﻟـ ‪ , use-case‬آﺬﻟﻚ ﺗﺤﺪﻳﺪ ﻣﺨﻄﻂ اﻟﺤﺎﻟﺔ ‪ state diagram‬ﻟﻜﻞ ﻋﻨﺼﺮ ﻣﻦ ﻋﻨﺎﺻﺮ اﻟﻨﻈﺎم‪.‬‬

‫‪2‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫ﺗﺼﻤﻴﻢ اﻟﻨﻈﺎم‪ :‬وهﻨﺎ ﻳﺘﻢ ﺑﻨﺎء اﻟﻤﻜﻮﻧﺎت اﻟﺒﺮﻣﺠﻴﺔ ﻟﻠﻨﻈﺎم وﺗﺨﻄﻴﻄﻬﺎ ﻋﻠﻰ اﻟﻮرق ﺑﺎﺳﺘﺨﺪام اﻟﻤﺨﻄﻄﺎت‬ ‫‪.3‬‬
‫اﻻﻧﺴﻴﺎﺑﻴﺔ ‪ flow charts‬أو اﻟﺨﻮارزﻣﻴﺎت ‪ algorithms‬وآﻠﻴﻬﻤﺎ ﻳﻤﺜﻞ وﺻﻒ ﻟﺨﻄﻮات اﻟﺒﺮﻧﺎﻣﺞ ﻏﻴﺮ‬
‫أن اﻟﻤﺨﻄﻄﺎت اﻹﻧﺴﻴﺎﺑﻴﺔ ﺗﺨﻄﻴﻄﺎت ﺑﻴﺎﻧﻴﻪ ﻟﻠﺘﻌﺒﻴﺮ ﻋﻦ هﺬﻩ اﻟﺨﻄﻮات وﺳﻨﺘﻨﺎول هﺬﻩ اﻟﻤﺨﻄﻄﺎت ﻣﻊ‬
‫ﻋﺮض أﻣﺜﻠﻪ ﻣﻨﺎﺳﺒﺔ ﺧﻼل هﺬا اﻟﻔﺼﻞ إﻧﺸﺎء اﷲ‪.‬‬
‫آﺘﺎﺑﺔ اﻟﻜﻮد‪ :‬وهﻨﺎ ﺗﻜﺘﺐ أواﻣﺮ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺼﻮرﻩ ﻓﻌﻠﻴﺔ ﺑﺈﺳﺘﺨﺪام إﺣﺪى ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﻋﺎﻟﻴﺔ اﻟﻤﺴﺘﻮى‪.‬‬ ‫‪.4‬‬
‫إﺧﺘﺒﺎر اﻟﻨﻈﺎم‪ :‬وﻳﺘﻢ ﺗﺠﺮﻳﺐ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻌﻠﻴًﺎ وﺗﻨﻔﻴﺬة وإآﺘﺸﺎف اﻷﺧﻄﺎء‪ ،‬وﻳﻤﻜﻦ ﺗﺼﻨﻴﻒ اﻷﺧﻄﺎء‬ ‫‪.5‬‬
‫اﻟﻤﺘﻮﻗﻌﺔ إﻟﻰ‪:‬‬
‫أ‪ .‬أﺧﻄﺎء ﻓﻲ اﻟﺼﻴﻐﺔ ‪ syntax error‬وهﻲ أﺧﻄﺎء ﻓﻲ ﺻﻴﻐﺔ آﺘﺎﺑﺔ أﻣﺮ ﻣﻌﻴﻦ‪ ،‬ﻣﻤﺎ ﻳﺆدي ﻟﻌﺪم‬
‫ﺗﺮﺟﻤﺔ اﻟﺒﺮﻧﺎﻣﺞ وﺗﻨﻔﻴﺬة‪ ،‬وﺑﻴﺌﺔ اﻟﻌﻤﻞ اﻟﺒﺮﻣﺠﻴﺔ ﻏﺎﻟﺒﺎ ﻣﺎ ﺗﻨﺒﻪ ﻟﻬﺬا اﻟﻨﻮع ﻣﻦ اﻷﺧﻄﺎء وأﺣﻴﺎﻧًﺎ‬
‫ﺗﺤﺪﻳﺪ ﻣﻮﻗﻊ و ﺷﻜﻞ اﻟﺨﻄﺄ‬
‫ب‪ .‬أﺧﻄﺎء ﻓﻲ ﺗﻐﻄﻴﺔ ﻣﺘﻄﻠﺒﺎت اﻟﻨﻈﺎم‪ ،‬وهﺬا اﻟﻨﻮع ﻣﻦ اﻷﺧﻄﺎء ﻻ ﻳﻤﻜﻦ اآﺘﺸﺎﻓﻪ ﺑﻮاﺳﻄﺔ ﺑﻴﺌﺔ‬
‫اﻟﻌﻤﻞ اﻟﺒﺮﻣﺠﻴﺔ‪ ،‬وﻟﻜﻦ ﻳﻤﻜﻦ ﻣﺮاﺟﻌﺔ أداء اﻟﻨﻈﺎم ﻣﻊ اﻟﻤﺘﻄﻠﺒﺎت اﻟﺘﻲ ﺗﻢ ﺗﻌﺮﻳﻔﻬﺎ ﻓﻲ اﻟﺨﻄﻮة‬
‫اﻷوﻟﻰ‪.‬‬
‫ﺗﺪرﻳﺐ اﻟﻜﻮادر اﻟﺒﺸﺮﻳﺔ ﻋﻠﻰ إﺳﺘﺨﺪام اﻟﻨﻈﺎم اﻟﺠﺪﻳﺪ وﺗﻄﺒﻴﻖ اﻟﻨﻈﺎم ﻓﻌﻠﻴًﺎ ﻋﻠﻰ أرض اﻟﻮاﻗﻊ‪.‬‬ ‫‪.6‬‬
‫اﻟﻤﺨﻄﻄﺎت اﻹﻧﺴﻴﺎﺑﻴﺔ ‪flow charts‬‬
‫آﻤﺎ ذآﺮﻧﺎ ﻣﻦ ﻗﺒﻞ أن هﺬﻩ اﻟﻤﺨﻄﻄﺎت هﻲ وﺿﻊ ﺧﻄﻮات اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﺷﻜﻞ ﻣﺨﻄﻄﺎت وﺗﺴﺘﺨﺪم ﺑﻌﺾ اﻟﺮﻣﻮز‬
‫اﻟﻤﺘﻔﻖ ﻋﻠﻴﻬﺎ ﻓﻲ هﺬﻩ اﻟﻤﺨﻄﻄﺎت ﻟﺘﻤﺜﻴﻞ اﻷواﻣﺮ اﻟﺒﺮﻣﺠﻴﺔ آﻤﺎ هﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪:‬‬

‫اﻟﻤﺪﻟﻮل‬ ‫اﻟﺮﻣﺰ‬
‫ﺑﺪاﻳﺔ‪ /‬ﻧﻬﺎﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ‬

‫ﻣﻌﺎﻟﺠﺔ‬

‫ﻗﺮار‬

‫إدﺧﺎل ‪/‬إﺧﺮاج اﻟﺒﻴﺎﻧﺎت‬

‫ﻣﺜﺎل)‪(1.1‬‬
‫أﻧﺸﻲ ﻣﺨﻄﻄًﺎ اﻧﺴﻴﺎﺑﻴًﺎ ﻟﺒﺮﻧﺎﻣﺞ ﺣﺴﺎب اﻟﻤﺠﻤﻮع واﻟﻤﺘﻮﺳﻂ‪:‬‬
‫• ﻷي ﺛﻼﺛﺔ أرﻗﺎم ﻣﺪﺧﻠﺔ؟‬
‫• ﻷي ﻋﺪد ﻣﻦ اﻷرﻗﺎم‬
‫اﻟﺤﻞ‪:‬‬
‫اﻟﺒﺪاﻳﺔ‬ ‫• ﺧﻮارزﻣﻴﺔ اﻟﺤﻞ ﻟﻬﺬﻩ اﻟﻤﺸﻜﻠﺔ ﻟﺜﻼﺛﺔ أرﻗﺎم هﻲ‪:‬‬
‫‪ .1‬أدﺧﻞ أي ‪ 3‬أرﻗﺎم‬
‫‪ .2‬أﺣﺴﺐ اﻟﻤﺠﻤﻮع واﻟﻤﺘﻮﺳﻂ ﻟﻬﺬﻩ اﻷرﻗﺎم‬
‫أدﺧﻞ أي ﺛﻼﺛﺔ‬ ‫‪ .3‬أﻃﺒﻊ اﻟﻤﺠﻤﻮع واﻟﻤﺘﻮﺳﻂ‬
‫أرﻗﺎم أ‪،‬ب‪،‬ج‬ ‫وﻳﻤﻜﻦ ﺗﻮﺿﻴﺢ هﺬﻩ اﻟﺨﻄﻮات ﻓﻲ ﺷﻜﻞ ﻣﺨﻄﻂ إﻧﺴﻴﺎﺑﻲ‪:‬‬

‫اﻟﻤﺠﻤﻮع=أ‪+‬ب‪+‬ج‬
‫اﻟﻤﺘﻮﺳﻂ=)أ‪+‬ب‪+‬ج(‪3/‬‬

‫إﻃﺒﻊ اﻟﻤﺠﻤﻮع‬
‫‪،‬اﻟﻤﺘﻮﺳﻂ‬

‫اﻟﻨﻬﺎﻳﺔ‬

‫‪3‬‬
 ‫ﻹﻳﺠﺎد اﻟﺤﻞ ﻷي ﻋﺪد ﻣﻦ اﻷرﻗﺎم ﻧﺴﺘﺨﺪم اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﺔ أي ﻧﻜﺮر ﺗﻨﻔﻴﺬ أواﻣﺮ إدﺧﺎل اﻟﺮﻗﻢ وﺣﺴﺎب‬ ‫•‬
‫اﻟﻤﻌﺎدﻟﺔ ﻟﻌﺪد "ن" ﻣﺮة‪.‬‬

‫اﻟﺒﺪاﻳﺔ‬

‫أدﺧﻞ ﻋﺪد‬
‫اﻷرﻗﺎم ن‬

‫اﻟﻤﺠﻤﻮع=‪0‬‬
‫اﻟﻌﺪاد =‪0‬‬

‫أدﺧﻞ أي‬
‫رﻗﻢ أ‬
‫ﺣﻠﻘﻪ ﺗﻜﺮارﻳﻪ‬

‫اﻟﻤﺠﻤﻮع= اﻟﻤﺠﻤﻮع ‪+‬أ‬

‫ﺷﺮط اﻟﺤﻠﻘﺔ‬ ‫اﻟﻌﺪاد=اﻟﻌﺪاد‪1+‬‬

‫ﻧﻌﻢ‬
‫اﻟﻌﺪاد>ن‬

‫ﻻ‬

‫اﻟﻤﺘﻮﺳﻂ= اﻟﻤﺠﻤﻮع‪/‬ن‬

‫اﻃﺒﻊ اﻟﻤﺠﻤﻮع‪،‬‬
‫اﻟﻤﺘﻮﺳﻂ‬

‫اﻟﻨﻬﺎﻳﺔ‬

‫ﻣﺪﺧﻞ إﻟﻰ ﻟﻐﺔ ‪C++‬‬

‫ﺗﻌﺘﺒﺮ هﺬﻩ اﻟﻠﻐﺔ ﻣﻦ اﻟﻠﻐﺎت اﻟﻜﺎﺋﻨﻴﺔ وهﻲ ﻟﻐﺔ ﺑﺮﻣﺠﻪ ﻋﺎﻣﺔ اﻟﻐﺮض ﻓﻴﻤﻜﻦ أن ﺗﺴﺘﺨﺪم ﻟﻠﺒﺮاﻣﺞ اﻟﺘﻄﺒﻴﻘﻴﺔ وﻧﻈﻢ‬
‫اﻟﺘﺸﻐﻴﻞ واﻟﺘﺤﻜﻢ اﻵﻟﻲ وﺑﺮﻣﺠﺔ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت وﻏﻴﺮهﺎ ﻣﻦ اﻟﻨﻈﻢ اﻟﻤﺨﺘﻠﻔﺔ‪.‬‬
‫ﺑﻨﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ‪ C++‬ﻻﺑﺪ أن ﺗﺤﺘﻮي ﻋﻠﻰ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ ‪ main‬وﻳﻤﻜﻦ أن ﻳﺤﺘﻮي اﻟﺒﺮﻧﺎﻣﺞ ﻋﻠﻰ دوال أﺧﺮي‬
‫ﺳﻮا ًء ﺗﻠﻚ اﻟﺘﻲ ﻳﻨﺸﺌﻬﺎ اﻟﻤﺒﺮﻣﺞ أو ﻣﻦ اﻟﺪوال اﻟﺠﺎهﺰة ﻓﻲ ﻣﻜﺘﺒﺔ اﻟﻠﻐﺔ اﻟﻤﻌﻴﺎرﻳﺔ‪ ،‬وهﺬﻩ اﻟﻤﻜﺘﺒﺔ ﺗﺤﺘﻮي ﻋﻠﻰ ﻋﺪد‬
‫ﻼ ﻣﻠﻒ اﻟﺮﻳﺎﺿﻴﺎت‬ ‫هﺎﺋﻞ ﻣﻦ اﻟﺪوال اﻟﺠﺎهﺰة ﻣﻮﺟﻮدة داﺧﻞ ﻣﻠﻔﺎت ﺗﺴﻤﻰ اﻟﻤﻠﻔﺎت اﻟﺘﺮوﻳﺴﻴﺔ ‪ Header Files‬ﻓﻤﺜ ً‬
‫اﻟﻤﺴﻤﻰ ‪ math‬ﻳﺤﺘﻮي ﻋﻠﻰ دوال آﺎﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ واﻟﻠﻮﻏﺎرﻳﺘﻤﺎت واﻟﻨﺴﺐ اﻟﻤﺜﻠﺜﻴﺔ واﻟﺘﻘﺮﻳﺐ وﻏﻴﺮهﺎ وﺳﻴﺘﻢ‬
‫اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﺪوال واﻟﻤﻠﻔﺎت اﻟﺘﺮوﻳﺴﻴﺔ ﺑﺈذن اﷲ ﻓﻲ أﺑﻮاب ﻻﺣﻘﺔ‪.‬‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﻳﻤﺜﻞ أﺑﺴﻂ ﺑﺮﻧﺎﻣﺞ ﻓﻲ ﻟﻐﺔ ‪ C++‬وهﻮ ﻳﺤﺘﻮي ﻋﻠﻲ اﻟﺤﺪ اﻷدﻧﻰ اﻟﻤﻄﻠﻮب وهﻮ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
‫)(‪Void main‬‬
‫}{‬

‫‪4‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫آﻠﻤﺔ ‪ void‬ﺗﺸﻴﺮ إﻟﻰ ﻋﺪم إرﺟﺎع اﻟﺪاﻟﺔ ﻷي ﻗﻴﻤﻪ واﻷﻗﻮاس اﻟﻤﺴﺘﺪﻳﺮة ﻋﺎد ًة ﺗﻮﺿﻊ ﻓﻴﻬﺎ وﺳﺎﺋﻂ اﻟﺪاﻟﺔ وﻓﻲ هﺬﻩ‬
‫اﻟﺤﺎﻟﺔ ﻻ ﺗﻮﺟﺪ وﺳﺎﺋﻂ‪ ،‬أﻣﺎ اﻷﻗﻮاس اﻟﻤﻌﻘﻮﻓﺔ { } ﻓﻬﻲ ﺗﻤﺜﻞ ﺑﺪاﻳﺔ وﻧﻬﺎﻳﺔ ﺟﺴﻢ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‪.‬‬
‫أواﻣﺮ إدﺧﺎل و إﺧﺮاج اﻟﺒﻴﺎﻧﺎت‪:‬‬
‫ﻳﺴﺘﺨﺪم اﻟﺘﻌﺒﻴﺮ ‪ cout‬ﻟﻺﺧﺮاج و ‪ cin‬ﻟﻺدﺧﺎل وآﻼهﻤﺎ ﻣﻌﺮﻓﻴﻦ ﻓﻲ ﻣﻠﻒ اﻹدﺧﺎل واﻹﺧﺮاج‬
‫اﻟﻤﺴﻤﻰ ‪iostream‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﻹﺳﺘﺨﺪام ‪ cout‬هﻲ‬ ‫‪.....‬‬
‫‪.....‬‬
‫;"‪cout<<" text‬‬
‫ﺣﻴﺚ ﻳﻜﺘﺐ ﺑﻴﻦ ﻋﻼﻣﺘﻲ اﻟﺘﻨﺼﻴﺺ اﻟﻨﺺ اﻟﻤﺮاد إﻇﻬﺎرة ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪ ،‬أﻣﺎ ﻋﻨﺪ اﻟﺮﻏﺒﻪ ﻓﻲ إﻇﻬﺎر ﻗﻴﻢ ﻣﺘﻐﻴﺮات ﻓﻼ‬
‫ﺗﺴﺘﺨﺪم ﻋﻼﻣﺎت اﻟﺘﻨﺼﻴﺺ‪.‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﻹﺳﺘﺨﺪام ‪ cin‬هﻲ‬ ‫‪.....‬‬
‫‪.....‬‬
‫;‪cin>>variable‬‬
‫واﻟﻤﻘﺼﻮد ﺑـ ‪ variable‬اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻧﺮﻳﺪ إدﺧﺎل ﻗﻴﻤﺘﻪ ﻋﻦ ﻃﺮﻳﻖ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻹدراج ﻣﻠﻒ ﻓﻲ ﺑﺮﻧﺎﻣﺞ ﻣﺎ‪:‬‬
‫>‪#include<file_name‬‬
‫و ‪ file_name‬هﻮ إﺳﻢ اﻟﻤﻠﻒ اﻟﻤﺮاد إدراﺟﻪ ﺿﻤﻦ اﻟﺒﺮﻧﺎﻣﺞ‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻷول ﻓﻲ ‪C++‬‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﻳﻘﻮم ﺑﺈﻇﻬﺎر ﻧﺺ ﻋﻠﻰ ﺷﺎﺷﺔ اﻹﻇﻬﺎر‬
‫‪Prog1‬‬
‫>‪#include<iostream.h‬‬
‫)(‪void main‬‬ ‫اﻟﻨﺎﺗﺞ‬ ‫‪welcome to C++‬‬

‫{‬
‫;"‪cout<<"welcome to C++ world‬‬
‫}‬
‫ﻧﻼﺣﻆ أن ﻣﻠﻒ اﻹدﺧﺎل واﻹﺧﺮاج ‪ iostream‬اﺗﺨﺬ اﻻﻣﺘﺪاد ‪ ،h‬وهﺬا ﺷﺄن آﻞ ﻣﻠﻔﺎت اﻟﺘﺮوﻳﺴﻪ‬
‫أدوات اﻟﻬﺮوب‪:‬‬
‫هﻲ أدوات ﺗﺴﺘﺨﺪم ﻟﻠﺘﺤﻜﻢ ﻓﻲ ﻣﻮﻗﻊ اﻟﻤﺨﺮﺟﺎت ﻣﻦ ﺣﻴﺚ اﻟﺘﺤﺮك اﻷﻓﻘﻲ أو اﻟﺮأﺳﻲ ﻋﺒﺮ اﻟﺴﻄﻮر ﺣﻴﺚ ﺗﺴﺘﺨﺪم‬
‫‪ \n‬ﻟﻠﻨﺰول ﺳﻄﺮًا‪ ،‬و ‪ \t‬ﻟﻠﺘﺤﺮك ﻣﺴﺎﻓﺔ أﻓﻘﻴﺔ‪.‬‬
‫أدوات اﻟﺘﻌﻠﻴﻖ‪:‬‬
‫ﻳﻤﻜﻦ اﻟﺘﻌﻠﻴﻖ ﻋﻠﻰ اﻟﺒﺮﻧﺎﻣﺞ ﻟﺘﻮﺿﻴﺢ ﻋﻤﻞ داﻟﻪ أو أﻣﺮ ﻣﻌﻴﻦ ﻟﻤﻦ ﻳﻘﺮأ اﻟﺒﺮﻧﺎﻣﺞ دون أن ﻳﺆﺛﺮ ذﻟﻚ ﻋﻠﻰ ﻋﻤﻞ‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﺣﻴﺚ ﻻ ﻳﻌﺘﺒﺮ اﻟﺘﻌﻠﻴﻖ ﺟﺰ ًء ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺗﺴﺘﺨﺪم اﻷداة ‪ //‬ﻹﺿﺎﻓﺔ ﺗﻌﻠﻴﻖ ﻓﻲ ﺳﻄﺮ واﺣﺪ‪ ،‬ﺑﻴﻨﻤﺎ ﻳﻮﺿﻊ‬
‫اﻟﺘﻌﻠﻴﻖ ﻣﺘﻌﺪد اﻷﺳﻄﺮ ﺑﻴﻦ اﻟﻌﻼﻣﺘﻴﻦ *‪/‬اﻟﺘﻌﻠﻴﻖ‪. */‬‬
‫‪Prog2‬‬ ‫ﻳﻤﻜﻦ إﻋﺎدة آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ﻣﻊ إﺿﺎﻓﺔ أدوات اﻟﻬﺮوب واﻟﺘﻌﻠﻴﻖ‪:‬‬

‫>‪#include<iostream.h‬‬
‫‪Welcome‬‬
‫)(‪void main‬‬ ‫اﻟﻨﺎﺗﺞ‬ ‫‪to C++ world‬‬
‫‪{ //start of main function‬‬
‫;"‪cout<<"\twelcome\n to C++ world‬‬
‫‪} /*end of main function‬‬
‫‪this a multi_line comment */‬‬
‫ﺗﻤﺮﻳﻦ ‪1‬‬
‫‪ .1‬أﻧﺸﻲ ﻣﺨﻄﻄًﺎ اﻧﺴﻴﺎﺑﻴًﺎ ﻟﺒﺮﻧﺎﻣﺞ ﻳﺤﺴﺐ ﻣﺴﺎﺣﺔ وﻣﺤﻴﻂ اﻟﻤﺴﺘﻄﻴﻞ ﻋﻨﺪ إدﺧﺎل اﻟﻄﻮل و اﻟﻌﺮض؟‬
‫‪ .2‬أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﺑﻠﻐﺔ ‪ C++‬ﻳﻈﻬﺮ ﻋﻠﻰ اﻟﺸﺎﺷﺔ اﻟﻨﺺ‪:‬‬
‫‪This is my first program in‬‬
‫‪C++ language‬‬

‫‪5‬‬
 ‫‪Variables & Constants‬‬ ‫اﻟﻤﺘﻐﻴﺮات واﻟﺜﻮاﺑ ﺖ‬
‫اﻟﻤﺘﻐﻴﺮ ه ﻮ ﻣﻮﻗ ﻊ ﻓ ﻲ اﻟ ﺬاآﺮة ﺣﻴ ﺚ ﻳﻤﻜ ﻦ ﺗﺨ ﺰﻳﻦ اﻟﻘ ﻴﻢ واﺳ ﺘﺮﺟﺎﻋﻬﺎ ﻋﻨ ﺪ اﻟﺤﺎﺟ ﺔ‪ ،‬ﺳ ﻌﺔ اﻟ ﺬاآﺮة اﻟﺘ ﻲ ﺗﺨ ﺼﺺ‬
‫ﻟﻠﻤﺘﻐﻴﺮ ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﻧﻮﻋﻪ‪ ،‬واﻟﺬي ﻳﻤﻜﻦ أن ﻳﻜ ﻮن ﻋ ﺪدًا ﺻ ﺤﻴﺤًﺎ أو ﺣﻘﻴﻘﻴ ًﺎ أو ﻣﺘﻐﻴ ﺮًا ﺣﺮﻓﻴ ًﺎ اﻟﺠ ﺪول اﻟﺘ ﺎﻟﻲ ﻳﻮﺿ ﺢ‬
‫أﻧﻮاع اﻟﻤﺘﻐﻴﺮات ﻓﻲ ﻟﻐﺔ ‪:C++‬‬
‫اﻟﻘﻴﻢ‬ ‫اﻟﺘﻤﺜﻴﻞ‬ ‫اﻟﺤﺠﻢ‬ ‫اﻟﻨﻮع‬
‫‪ -32768‬إﻟﻰ‪ 32767‬إﻻ ﻓﻲ ﺣﺎﻟﺔ ‪ 4‬ﺑﺎﻳﺖ ﻓﺎﻟﻘﻴﻢ‬ ‫‪2‬ﺑﺎﻳﺖ ﻋﺪا ﻓﻲ وﻳﻨﺪوز ‪ 95‬أو وﻳﻨﺪوز ‪ NT‬اﻷﻋﺪاد‬
‫‪int‬‬
‫ﻣﻦ ‪-2147483648‬إﻟﻰ‪2147483647‬‬ ‫اﻟﺼﺤﻴﺤﺔ‬ ‫ﻓﺤﺠﻤﻪ ‪ 4‬ﺑﺎﻳﺖ‬
‫اﻷﻋﺪاد‬ ‫‪short‬‬
‫‪ -32768‬إﻟﻰ‪32767‬‬ ‫‪ 2‬ﺑﺎﻳﺖ‬
‫اﻟﺼﺤﻴﺤﺔ‬ ‫‪int‬‬
‫اﻷﻋﺪاد‬ ‫‪long‬‬
‫‪ -2147483648‬إﻟﻰ‪2147483647‬‬ ‫‪ 4‬ﺑﺎﻳﺖ‬
‫اﻟﺼﺤﻴﺤﺔ‬ ‫‪int‬‬
‫اﻷﻋﺪاد‬
‫‪ -1.2e-38‬إﻟﻰ‪3.4e38‬‬ ‫‪ 4‬ﺑﺎﻳﺖ‬ ‫‪float‬‬
‫اﻟﺤﻘﻴﻘﻴﺔ‬
‫اﻷﻋﺪاد‬
‫‪ -2.2e-308‬إﻟﻰ ‪1.8e308‬‬ ‫‪ 8‬ﺑﺎﻳﺖ‬ ‫‪double‬‬
‫اﻟﺤﻘﻴﻘﻴﺔ‬
‫‪ 256‬ﺣﺮﻓﺎ " أﺣﺮف ﺁﺳﻜﻲ "‬ ‫اﻷﺣﺮف‬ ‫‪ 1‬ﺑﺎﻳﺖ‬ ‫‪char‬‬
‫ﻣﻠﺤﻮﻇﺎت‪:‬‬
‫ﻳﺴﺘﺨﺪم اﻟﺘﻌﺒﻴﺮ ‪ signed‬و ‪ unsigned‬ﻟﻠﻤﺘﻐﻴﺮات اﻟﺮﻗﻤﻴﺔ ﻟﺘﺤﺪﻳﺪ هﻞ ﺗﺸﻤﻞ اﻷرﻗﺎم اﻟﻤﻮﺟﺒﺔ واﻟ ﺴﺎﻟﺒﺔ‬ ‫
‬
‫أم ﻻ‪ ،‬ﻓﺎﻟﺘﻌﺒﻴﺮ ‪ unsigned‬ﻳﺪل ﻋﻠﻰ اﻷﻋﺪاد اﻟﻤﻮﺟﺒﺔ ﻓﻘﻂ ﻣﻤﺎ ﻳﻌﻨﻲ ﺗﺨ ﺼﻴﺺ ﻣ ﺪى اﻟﻘ ﻴﻢ ﻓ ﻲ اﻷرﻗ ﺎم‬
‫اﻟﻤﻮﺟﺒﺔ ﻓﻘﻂ‪ ،‬أﻣﺎ ‪ signed‬ﻓﺘﺪل ﻋﻠﻰ اﻷﻋﺪاد اﻟﻤﻮﺟﺒ ﺔ واﻟ ﺴﺎﻟﺒﺔ وإذا ﻟ ﻢ ﻳ ﺬآﺮ أي ﻣ ﻦ اﻟﺘﻌﺒﻴ ﺮﻳﻦ ﻓﻴﺆﺧ ﺬ‬
‫ﻋﻠﻰ أﻧﻪ ‪.signed‬‬
‫ﻼ اﻟﺘﻌﺒﻴﺮ ‪ unsigned short int‬ﻳﻤﺜﻞ ﻣﻦ ‪ 0‬إﻟﻰ‪. 65535‬‬ ‫ﻣﺜ ً‬
‫أﻣﺎ اﻟﺘﻌﺒﻴﺮ ‪ signed short int‬أو ‪ short int‬ﻓﻴﻤﺜﻞ اﻷﻋﺪاد ﻣﻦ ‪ -32768‬إﻟﻰ‪.32767‬‬
‫اﻷﻧﻮاع ‪ int, short int, long int‬ﺟﻤﻴﻌﻬﺎ ﺗﻤﺜﻞ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﺔ واﻹﺧﺘﻼف ﻓﻲ اﻟﻤﺪي اﻟﺬي ﺗﻤﺜﻠﺔ‪.‬‬ ‫
‬
‫اﻷﻧﻮاع ‪float, double‬ﺟﻤﻴﻌﻬﺎ ﺗﻤﺜﻞ اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﺔ واﻹﺧﺘﻼف ﻓﻲ اﻟﻤﺪي اﻟﺬي ﺗﻤﺜﻠﺔ‪.‬‬ ‫
‬
‫‪ Char‬ﺗﻤﺜﻞ آﻞ أﺣﺮف ﺁﺳ ﻜﻲ وه ﻲ ﺗ ﺸﻤﻞ اﻟﺤ ﺮوف اﻟﻠﻐﻮﻳ ﺔ واﻟﻌﻼﻣ ﺎت واﻷﻗ ﻮاس واﻷرﻗ ﺎم ﻏﻴ ﺮ أﻧﻬ ﺎ‬ ‫
‬
‫ﻳﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻋﻠﻰ أﻧﻬﺎ أﺣﺮف أي ﻻ ﺗﺨﻀﻊ ﻟﻠﻌﻤﻠﻴﺎت اﻟﻤﻨﻄﻘﻴﺔ واﻟﺤﺴﺎﺑﻴﺔ‪.‬‬
‫ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات‪:‬‬
‫ﻳﺘﻢ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ﺑﺬآﺮ ﻧﻮﻋﻪ ﺛﻢ اﺳﻤﻪ ﺑﺤﻴﺚ ﻳﻔﺼﻞ ﺑﻴﻨﻬﻤﺎ ﻓﺮاغ وآﺄي ﺳﻄﺮ ﺑﺮﻣﺠﻲ ﻻﺑﺪ ﻣﻦ اﻻﻧﺘﻬﺎء ﺑﻔﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ‬
‫;‪variable_type variable_name‬‬ ‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﻟﺘﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات‬ ‫‪.....‬‬
‫‪.....‬‬

‫ﻼ اﻟﺘﻌﺮﻳﻒ ;‪ int x‬ﻳﺨﺺ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ إﺳﻤﻪ ‪ x‬ﻋﻠﻰ أﻧﻪ ﻋﺪد ﺻﺤﻴﺢ‪ ،‬واﻟﺘﻌﺮﻳﻒ ;‪ float area‬ﻟﻌﺪد ﺣﻘﻴﻘﻲ ‪.area‬‬
‫ﻣﺜ ً‬
‫ﻳﻤﻜﻦ ﺗﻌﺮﻳﻒ ﻋﺪة ﻣﺘﻐﻴﺮات ﻓﻲ ﺳﻄﺮ واﺣﺪ إذ‪ 1‬آﺎﻧﺖ ﻣﻦ ﻧﻮع واﺣﺪ ﻓﺎﻟﺘﻌﺮﻳﻒ‬
‫;‪ char a,b,c‬ﻳﻌﻨﻲ أن ‪ a,b,c‬ﻣﺘﻐﻴﺮات ﺣﺮﻓﻴﻪ‪.‬‬
‫ﻗﻴﻮد ﻋﻠﻰ إﺳﻢ اﻟﻤﺘﻐﻴﺮ‬
‫ﻳﺠﺐ أﻻ ﻳﺤﺘﻮي اﻹﺳﻢ ﻋﻠﻰ ﻓﺮاغ‪.‬‬ ‫‪.1‬‬
‫ﻳﺠﺐ أﻻ ﻳﺤﺘﻮي اﻹﺳﻢ ﻋﻠﻰ اﻟﻌﻼﻣﺎت اﻟﺨﺎﺻﻪ ﻣﺜﻞ ‪............@،#./،*،-،+‬‬ ‫‪.2‬‬
‫ﻳﺠﺐ أﻻ ﻳﺒﺘﺪئ اﻹﺳﻢ ﺑﺮﻗﻢ‪.‬‬ ‫‪.3‬‬
‫ﻳﺠﺐ أﻻ ﻳﻤﺜﻞ اﻹﺳﻢ آﻠﻤﻪ ﻣﻦ آﻠﻤﺎت اﻟﻠﻐﻪ اﻟﻤﺤﺠﻮزة وهﻲ اﻟﻜﻠﻤﺎت اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓ ﻲ اﻷواﻣ ﺮ ﻣﺜ ﻞ ‪for,‬‬ ‫‪.4‬‬
‫‪........................ if, else, int, float, long,‬‬
‫ﻣﻠﺤﻮﻇﺎت‪:‬‬
‫ﻳﻤﻜﻦ أن ﻳﻜﻮن اﻟﺮﻗﻢ ﻓﻲ وﺳﻂ أو ﺁﺧﺮ اﻹﺳﻢ‪.‬‬ ‫
‬
‫اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة ﺗﻈﻬﺮ ﺑﺘﻨﺴﻴﻖ ﻣﻤﻴﺰ ﻓﻲ ﻣﻌﻈﻢ اﻟﻤﺼﺮﻓﺎت اﻟﺘﻲ ﺗﻜﺘﺐ ﻓﻴﻬﺎ اﻟﺒﺮاﻣﺞ‪.‬‬ ‫
‬
‫ﻼ ﺗﺨﺘﻠﻒ ﻋﻦ ‪.AREA‬‬
‫هﻨﺎﻟﻚ ﺣﺴﺎﺳﻴﺔ ﻟﺤﺎﻟﺔ اﻟﺤﺮف ﻓﻲ ﺗﺴﻤﻴﺔ اﻟﻤﺘﻐﻴﺮ أي أن ‪ area‬ﻣﺜ ً‬ ‫
‬

‫‪6‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫ﺗﻌﻴﻴﻦ ﻗﻴﻢ اﻟﻤﺘﻐﻴﺮات‪:‬‬
‫ﺗﺘﻢ ﻧﺴﺒﺔ اﻟﻘﻴﻢ إﻟﻰ اﻟﻤﺘﻐﻴﺮات ﺑﺈﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ اﻹﺳﻨﺎد = واﻟﺬي ﻳﻨﺴﺐ اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﻋﻠ ﻲ ﻳﻤﻴﻨ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ ﻋﻠ ﻲ ﻳ ﺴﺎرﻩ‪،‬‬
‫آﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫;‪x=5‬ﺣﻴﺚ ﺗﻨﺴﺐ اﻟﻘﻴﻤﺔ ‪5‬ﻟﻠﻤﺘﻐﻴﺮ ‪ x‬وهﺬا ﻳﻌﻨﻲ ﺗﺨﺰﻳﻦ هﺬﻩ اﻟﻘﻴﻤﺔ ﻟﻠﻤﻮﻗﻊ اﻟﻤﺤﺠﻮز ﻟـ ‪.x‬‬
‫اﻟﻤﻌﺎﻣﻼت اﻟﺮﻳﺎﺿﻴﺔ ‪Mathematical Operators‬‬
‫ﻟﻜﺘﺎﺑﺔ اﻟﻘﻮاﻧﻴﻦ واﻟﻤﻌ ﺎدﻻت اﻟﺨﺎﺻ ﺔ ﺑﻨﻈ ﺎم ﻣﻌ ﻴﻦ ﺗ ﺴﺘﺨﺪم ه ﺬﻩ اﻟﻤﻌ ﺎﻣﻼت اﻟﺮﻳﺎﺿ ﻴﺔ‪ ،‬وه ﻲ ﻣﻮﺿ ﺤﺔ ﻓ ﻲ اﻟﺠ ﺪول‬
‫اﻟﺘﺎﻟﻲ‪:‬‬
‫اﻟﻌﻤﻠﻴﺔ اﻟﺮﻳﺎﺿﻴﺔ‬ ‫اﻟﻤﻌﺎﻣﻞ‬
‫اﻟﺠﻤﻊ‬ ‫‪+‬‬
‫اﻟﻄﺮح‬ ‫‪-‬‬
‫اﻟﻀﺮب‬ ‫*‬
‫اﻟﻘﺴﻤﺔ‬ ‫‪/‬‬
‫ﻼ ‪23%7=2‬‬ ‫ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ اﻟﺼﺤﻴﺢ ﻣﺜ ً‬ ‫‪%‬‬
‫آﻞ هﺬﻩ اﻷدوات ﺗﻌﻤﻞ ﻓﻲ اﻻﺗﺠﺎﻩ ﻣﻦ اﻟﻴﺴﺎر إﻟﻰ اﻟﻴﻤﻴﻦ‬
‫اﻷوﻟﻮﻳﺔ ﻓﻲ ﺗﻨﻔﻴﺬ اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﺔ‬
‫ﺗﺠﻌ ﻞ ﻟﻐ ﺔ ‪ C++‬اﻷوﻟﻮﻳ ﺔ اﻷوﻟ ﻰ ﻓ ﻲ اﻟﺘﻨﻔﻴ ﺬ ﻟﻌﻤﻠﻴ ﺎت اﻟ ﻀﺮب واﻟﻘ ﺴﻤﺔ وﺑ ﺎﻗﻲ اﻟﻘ ﺴﻤﺔ اﻟ ﺼﺤﻴﺢ ﻋﻠ ﻰ اﻟ ﺴﻮاء ﺛ ﻢ‬
‫ﻋﻤﻠﻴﺘﻲ اﻟﺠﻤﻊ واﻟﻄﺮح‪ .‬وإذا اﺣﺘﻮى ﺗﻌﺒﻴﺮ رﻳﺎﺿﻲ ﻋﻠﻰ أآﺜﺮ ﻣﻦ ﻋﻤﻠﻴﺔ ﻟﻬ ﺎ ﻧﻔ ﺲ اﻷوﻟﻮﻳ ﺔ ﻓ ﺈن اﻟﻌﻤﻠﻴ ﺔ اﻟﺘ ﻲ ﻋﻠ ﻰ‬
‫ﻻ‪.‬‬
‫ﻻ‪ .‬وﻓﻲ آﻞ اﻷﺣﻮال ﻓﺈن اﻟﻌﻤﻠﻴﺎت داﺧﻞ اﻷﻗﻮاس ﺗﻨﻔﺬ أو ً‬‫اﻟﻴﺴﺎر ﺗﻨﻔﺬ أو ً‬
‫ﻣﺜﺎل)‪(2.1‬ﻣﺎ ﻗﻴﻤﺔ ‪x‬ﻓﻲ آﻞ ﻣﻤﺎ ﻳﺄﺗﻲ‪:‬‬
‫أ‪X=4+2*5 .‬‬
‫ب‪X=5%3*7+2 .‬‬
‫ج‪X=5+(4%3) .‬‬
‫اﻟﺤﻞ‪:‬‬
‫أ‪X=4+10=14 .‬‬
‫ب‪X=2*7+2=14+2=16 .‬‬
‫ج‪X=5+1=6 .‬‬
‫ﻣﻠﺤﻮﻇﺔ‪:‬‬
‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ اﻹﺳﻨﺎد= ﻣ ﻊ أي ﻣ ﻦ اﻟﻤﻌ ﺎﻣﻼت اﻟﺮﻳﺎﺿ ﻴﺔ ﻋﻨ ﺪﻣﺎ ﻳ ﺮاد إﺳ ﻨﺎد ﻗﻴﻤ ﻪ ﻟﻤﺘﻐﻴ ﺮ ﻣﻌ ﻴﻦ‬ ‫
‬
‫ﺑﺪﻻﻟﺔ ﻧﻔﺲ اﻟﻤﺘﻐﻴﺮ آﻤﺎ هﻮ ﻣﺒﻴﻦ ﻓﻲ اﻟﺠﺪول‪:‬‬
‫اﻟﺘﻌﺒﻴﺮ اﻟﻤﺨﺘﺼﺮ‬ ‫اﻟﺘﻌﺒﻴﺮ‬
‫‪x+=3‬‬ ‫‪x=x+3‬‬
‫‪a*=2‬‬ ‫‪a=a*2‬‬
‫ﻣﺜﺎل)‪ (2.2‬أآﺘﺐ ﺑﺮﻧﺎﻣﺠًﺎ ﺑﻠﻐﺔ ‪ C++‬ﻳﺤﺴﺐ ﻣﺴﺎﺣﺔ وﻣﺤﻴﻂ اﻟﻤﺴﺘﻄﻴﻞ ﻋﻨﺪ إدﺧﺎل اﻟﻄﻮل و اﻟﻌﺮض؟‬
‫اﻟﺤ ﻞ‪ :‬ﻓ ﻲ ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻧﺘﻌﺎﻣ ﻞ ﻣ ﻊ أرﺑﻌ ﺔ ﻣﺘﻐﻴ ﺮات ه ﻲ اﻟﻄ ﻮل‪ ، length‬اﻟﻌ ﺮض‪ width,‬اﻟﻤ ﺴﺎﺣﻪ‪،area‬‬
‫واﻟﻤﺤﻴﻂ‪ . perimeter‬هﺬﻩ اﻟﻤﺘﻐﻴﺮات ﻻ ﻳﺸﺘﺮط أن ﺗﻜﻮن أﻋﺪادًا ﺻﺤﻴﺤﺔ ‪ int‬ﺑ ﻞ ﻳﻤﻜ ﻦ أن ﺗﺤﺘ ﻮي ﻋﻠ ﻰ آ ﺴﻮر‬
‫ﻟﺬا ﻓﺈن ﻣﻦ اﻟﻤﻨﺎﺳﺐ ﻟﻬﺎ أن ﺗﻌﺮف أﻋﺪادًا ﺣﻘﻴﻘﻴﺔ‪ ، float‬واﻟﻄﻮل واﻟﻌﺮض ﺳﻨﺤﺼﻞ ﻋﻠﻰ ﻗﻴﻤﻬﺎ ﻋﻦ ﻃﺮﻳﻖ إدﺧ ﺎل‬
‫اﻟﻤﺴﺘﺨﺪم‪ .‬أﻣﺎ اﻟﻤﺴﺎﺣﺔ و اﻟﻤﺤﻴﻂ ﻓﺘﺤﺴﺒﺎن ﺑﺎﻟﻌﻼﻗﺘﻴﻦ اﻟﻤﻌﺮوﻓﺘﻴﻦ‪:‬‬
‫‪Prog3‬‬ ‫اﻟﻤﺴﺎﺣﺔ=اﻟﻄﻮل * اﻟﻌﺮض‬
‫اﻟﻤﺤﻴﻂ=‪)*2‬اﻟﻄﻮل ‪+‬اﻟﻌﺮض(‬
‫ﻟﺬا ﻳﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ آﺎﻵﺗﻲ‬

‫‪7‬‬
 ‫اﻟﻤﻌﺎﻣﻼت اﻟﺨﺎﺻﺔ ﺑﺘﻐﻴﻴﺮ ﻗﻴﻤﺔ ﻣﺘﻐﻴﺮ‬
‫ƒ ﻣﻌﺎﻣﻞ اﻟﺰﻳﺎدة ﺑﻮاﺣﺪ"‪ "++‬وﻳﻤﻜﻦ أن ﻳﻜﻮن ﻗﺒﻠﻲ ‪ pre_ incrimination‬ﺑﺤﻴﺚ ﺗﺘﻢ اﻟﺰﻳﺎدة ﻗﺒﻞ ﺗﻨﻔﻴﺬ‬
‫اﻷﻣﺮ اﻟﺤﺎﻟﻲ وﻳﻜﺘﺐ اﻟﻤﻌﺎﻣﻞ ﻗﺒﻞ اﺳﻢ اﻟﻤﺘﻐﻴﺮ أو ﺑﻌﺪي ‪ post_ incrimination‬ﺑﺤﻴﺚ ﺗﺘﻢ اﻟﺰﻳﺎدة ﺑﻌﺪ‬
‫ﺗﻨﻔﻴﺬ اﻷﻣﺮ اﻟﺤﺎﻟﻲ ﻣﺒﺎﺷﺮ ًة وﻳﻜﺘﺐ اﻟﻤﻌﺎﻣﻞ ﺑﻌﺪ اﺳﻢ اﻟﻤﺘﻐﻴﺮ‪.‬‬
‫ƒ ﻣﻌﺎﻣﻞ اﻟﻨﻘﺼﺎن ﺑﻮاﺣﺪ"‪ "--‬وﻳﻤﻜﻦ أن ﻳﻜﻮن ﻗﺒﻠﻲ ‪ pre_ decrimintation‬ﺑﺤﻴﺚ ﻳﻜﻮن اﻟﻨﻘﺼﺎن ﻗﺒﻞ‬
‫ﺗﻨﻔﻴﺬ اﻷﻣﺮ اﻟﺤﺎﻟﻲ وﻳﻜﺘﺐ اﻟﻤﻌﺎﻣﻞ ﻗﺒﻞ اﺳﻢ اﻟﻤﺘﻐﻴﺮ أو ﺑﻌﺪي ‪ post_ decrimintation‬ﺑﺤﻴﺚ ﻳﺘﻢ اﻟﻨﻘﺼﺎن‬
‫ﺑﻌﺪ ﺗﻨﻔﻴﺬ اﻷﻣﺮ اﻟﺤﺎﻟﻲ ﻣﺒﺎﺷﺮ ًة وﻳﻜﺘﺐ اﻟﻤﻌﺎﻣﻞ ﺑﻌﺪ اﺳﻢ اﻟﻤﺘﻐﻴﺮ‪.‬‬
‫‪Prog4‬‬ ‫ﺑﺮﻧﺎﻣﺞ ﻳﻮﺿﺢ اﻟﻔﺮق ﺑﻴﻦ "‪ "++‬و" –"‪:‬‬

‫‪a=6‬‬
‫اﻟﻨﺎﺗﺞ‬ ‫‪b=8‬‬
‫‪after incrimination b=9‬‬

‫‪Constants‬‬ ‫اﻟﺜﻮاﺑﺖ‬
‫اﻟﺜﺎﺑﺖ ﻳﺄﺧﺬ ﻧﻔﺲ اﻟﺤﻴﺰ اﻟﺘﺨﺰﻳﻨﻲ ﻟﻠﻤﺘﻐﻴﺮ ﻏﻴﺮ أن ﻗﻴﻤﺘﻪ ﻏﻴﺮ ﻗﺎﺑﻠﻪ ﻟﻠﺘﻐﻴﺮ‪ .‬ﻳﺘﻢ اﻹﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮ ﺑﺎﺳﺘﺨﺪام‬
‫اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزﻩ ‪ const‬ﻳﻌﻘﺒﻬﺎ ﻧﻮع اﻟﺜﺎﺑﺖ ﺛﻢ اﺳﻨﺎد ﻗﻴﻤﻪ ﻟﻬﺬا اﻟﺜﺎﺑﺖ آﻤﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ اﻟﺬي ﻳﺤﺴﺐ ﻣﺴﺎﺣﺔ‬
‫اﻟﺪاﺋﺮﻩ ﻋﻨﺪ إدﺧﺎل ﻗﻴﻤﺔ ﻧﺼﻒ ﻗﻄﺮهﺎ‪.‬‬
‫‪Prog5‬‬

‫ﻣﻠﺤﻮﻇﺎت‬
‫ﻻﺑﺪ ﻣﻦ اﺳﻨﺎد ﻗﻴﻤﻪ ﻟﻠﺜﺎﺑﺖ ﻋﻨﺪ اﻹﻋﻼن ﻋﻨﻪ‪.‬‬ ‫
‬
‫إذا ﻟﻢ ﻳﺤﺪد ﻧﻮع اﻟﺜﺎﺑﺖ ﻓﺈﻧﻪ ﻳﻌﺘﺒﺮ اﻓﺘﺮاﺿﻴﺎ ﻋﺪد ﺻﺤﻴﺢ ‪.int‬‬ ‫
‬

‫‪8‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫ﺗﻤﺮﻳﻦ ‪2‬‬
‫‪ .1‬إذا آﺎن ‪ y‬ﻣﺘﻐﻴﺮًا ﻣﻦ ﻧﻮع ‪ int‬ﻓﻤﺎ ﻗﻴﻤﺘﻪ ﻓﻲ آﻞ ﻣﻤﺎ ﻳﺄﺗﻲ‪:‬‬
‫أ‪y=10*7%(5+8-3) .‬‬
‫ب‪y=18/5+4 .‬‬
‫‪ .2‬اآﺘﺐ ﺑﺮﻧﺎﻣﺠ ًﺎ ﻟﺤﺴﺎب اﻟﺪﺧﻞ اﻹﺟﻤﺎﻟﻲ‪ total_income‬ﻟﻤﻮﻇﻒ إذا ﻋﻠﻢ اﻟﺮاﺗﺐ‬
‫اﻷﺳﺎﺳﻲ‪ ،bs‬ﺑﺪل اﻟﻨﻘﻞ‪ %5" t‬ﻣﻦ اﻟﺮاﺗﺐ اﻷﺳﺎﺳﻲ"‪ ،‬ﺑﺪل ﺧﺒﺮﻩ‪ ،e‬ﺣﻴﺚ ﻳﺤﺴﺐ اﻟﺪﺧﻞ‬
‫اﻹﺟﻤﺎﻟﻲ آﺎﻵﺗﻲ‪total_income=bs+t+e :‬‬
‫‪ .3‬ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﺗﻮﺟﺪ ﺛﻼﺛﻪ أﺧﻄﺎء اﺳﺘﺨﺮﺟﻬﺎ‪ ،‬ﻣﻊ ﺗﺤﺪﻳﺪ ﺳﺒﺐ اﻟﺨﻄﺄ‪ ،‬ﺛﻢ أﻋﺪ آﺘﺎﺑﺔ‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﺑﻌﺪ ﺗﺼﺤﻴﺢ اﻷﺧﻄﺎء‪:‬‬

‫‪9‬‬
‫‪Control Structures‬‬ ‫ُﺑ َﻨﻰ اﻟﺘﺤﻜﻢ‬
‫اﻟﻤﻘﺼﻮد ﺑﺬﻟﻚ اﻟﺘﺮآﻴﺒﻪ اﻟﺘﻲ ﺗﺘﺤﻜﻢ ﻓﻲ ﻣﺴﺎر ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﻓﺈﻟﻰ اﻵن ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺼﻮرة ﺗﺘﺎﺑﻌﻴﻪ إﻻ إذا‬
‫اﺳﺘﺨﺪﻣﺖ هﺬﻩ اﻟﺒﻨﻲ‪ ،‬وﺑﻨﻰ اﻟﺘﺤﻜﻢ ﺗﺸﻤﻞ اﻟﺸﺮط واﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﺔ‪.‬‬
‫ﺑﻨﻴﺔ اﻟﺸﺮط ﻓﻲ‪:C++‬‬
‫اﻟﺸﺮط هﻮ رﺑﻂ ﺗﻨﻔﻴﺬ أﻣﺮ ﻣﻌﻴﻦ " أو ﻋﺪة أواﻣﺮ " ﺑﺘﻮﻓﺮ ﺷﺮط ﻣﻌﻴﻦ أوﻋﺪﻣﻪ‪.‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﻪ‪:‬‬ ‫‪.....‬‬
‫‪.....‬‬
‫)‪if(condition‬‬
‫{‬
‫‪statements if true‬‬
‫‪....................‬‬ ‫ﻻ‪……….‬ﺗﻌﻠﻴﻤﺎت‬ ‫اﻟﺸﺮط‬ ‫ﻧﻌﻢ‬ ‫ﺗﻌﻠﻴﻤﺎت‬
‫………‬
‫}‬
‫‪else‬‬
‫{‬
‫‪statements if false‬‬
‫‪……….‬‬
‫………‬
‫}‬
‫ﻧﻼﺣﻆ ﻣﻦ اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ اﺳﺘﺨﺪام أداة اﻟﺸﺮط ‪if‬ﻳﻌﻘﺒﻬﺎ اﻟﺸﺮط ﺛﻢ اﻷﻣﺮ أو اﻷواﻣﺮ اﻟﻤﻄﻠﻮب ﺗﻨﻔﻴﺬهﺎ ﻋﻨﺪ ﺗﻮﻓﺮ‬
‫هﺬا اﻟﺸﺮط‪ ،‬ﻻﺣﻆ أن هﺬﻩ اﻷواﻣﺮ ﻟﻦ ﺗﻨﻔﺬ إﻻ ﻋﻨﺪ ﺗﻮﻓﺮ اﻟﺸﺮط وهﺬﻩ اﻷﺟﺰاء إﺟﺒﺎرﻳﺔ ﻓﻲ ﺑﻨﻴﺔ اﻟﺸﺮط " أي ﻳﻤﻜﻦ‬
‫أن ﻧﻜﺘﻔﻲ ﺑﺎﻟﺸﺮط واﻟﺘﻌﻠﻴﻤﺎت اﻟﺘﻲ ﺗﻨﻔﺬ ﻋﻨﺪ ﺗﻮﻓﺮﻩ دون ﻃﺮح ﺧﻴﺎر ﺁﺧﺮ‪ .‬وﻳﻤﻜﻦ اﺳﺘﺨﺪام اﻷداة ‪ else‬ﻟﺮﺑﻂ‬
‫اﻷواﻣﺮ اﻟﺘﻲ ﻳﺮاد ﻟﻬﺎ أن ﺗﻨﻔﺬ ﻋﻨﺪ اﻧﺘﻔﺎء اﻟﺸﺮط‪.‬‬
‫ﻣﻠﺤﻮﻇﺎت‪:‬‬
‫ﻋﻨﺪﻣﺎ ﺗﻜﻮن اﻷواﻣﺮ ﻣﺘﻌﺪدة ﻳﺠﺐ اﺳﺘﺨﺪام اﻷﻗﻮاس اﻟﺤﺼﺮﻳﻪ } ‪ { ،‬وﻳﻤﻜﻦ اﻻﺳﺘﻐﻨﺎء ﻋﻨﻬﺎ ﻓﻲ‬ ‫
‬
‫ﺣﺎﻟﺔ اﻷﻣﺮ اﻟﻮاﺣﺪ‪.‬‬
‫ﺗﺴﺘﺨﺪم اﻟﻤﻌﺎﻣﻼت اﻟﻌﻼﺋﻘﻴﺔ ﻟﺼﻴﺎﻏﺔ اﻟﺸﺮط وهﻲ ﻣﺒﻴﻨﻪ ﻓﻲ ﺟﺪول ﻻﺣﻖ‪.‬‬ ‫
‬
‫ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﻟﺸﺮط ﻣﺮآﺒًﺎ ﺗﺴﺘﺨﺪم اﻟﻤﻌﺎﻣﻼت اﻟﻤﻨﻄﻘﻴﺔ ﻟﻠﺮﺑﻂ ﺑﻴﻦ اﻟﺸﺮوط‪.‬‬ ‫
‬
‫‪Relational Operators‬‬ ‫اﻟﻤﻌﺎﻣﻼت اﻟﻌﻼﺋﻘﻴﺔ‬
‫وهﻲ ﺗﺤﺪد ﻋﻼﻗﺔ ﻣﺘﻐﻴﺮ ﺑﻜﻤﻴﻪ‪ ،‬أو ﻣﺘﻐﻴﺮ ﺑﻤﺘﻐﻴﺮ ﺁﺧﺮ وهﻲ ﺳﺘﺔ ﺗﺸﻤﻞ أآﺒﺮ ﻣﻦ‪ ،‬أآﺒﺮ ﻣﻦ أو ﻳﺴﺎوي‪،‬‬
‫أﺻﻐﺮ ﻣﻦ‪ ،‬أﺻﻐﺮ ﻣﻦ أو ﻳﺴﺎوي‪ ،‬ﻳﺴﺎوي‪ ،‬ﻻ ﻳﺴﺎوي وهﻲ ﻣﻮﺿﺤﻪ ﻓﻲ اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪.‬‬

‫اﻟﻤﻌﻨﻰ‬ ‫اﻷداة‬
‫أآﺒﺮ ﻣﻦ‬ ‫>‬
‫أآﺒﺮ ﻣﻦ أو ﻳﺴﺎوي‬ ‫=>‬
‫أﺻﻐﺮ ﻣﻦ‬ ‫<‬
‫أﺻﻐﺮ ﻣﻦ أو ﻳﺴﺎوي‬ ‫=<‬
‫ﻳﺴﺎوي‬ ‫==‬
‫ﻻ ﻳﺴﺎوي‬ ‫=!‬

‫آﻞ هﺬﻩ اﻷدوات ﺗﻌﻤﻞ ﻓﻲ اﻻﺗﺠﺎﻩ ﻣﻦ اﻟﻴﺴﺎر إﻟﻰ اﻟﻴﻤﻴﻦ‬

‫ﻣﺸﻜﻠﺔ اﻟﺨﻠﻂ ﺑﻴﻦ = و==‬
‫اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﻄﻼب ﻳﺨﻠﻄﻮن ﺑﻴﻦ ﻣﻌﻨﻴﻲ هﺬﻳﻦ اﻟﻤﻌﺎﻣﻠﻴﻦ‪ ،‬ﻓﻤﻌﺎﻣﻞ اﻹﺳﻨﺎد = ﻳﺴﺘﺨﺪم ﻟﻨﺴﺒﺔ آﻤﻴﻪ ﻋﻠﻰ ﻳﻤﻴﻨﻪ إﻟﻰ‬
‫ﻣﺘﻐﻴﺮ ﻋﻠﻰ ﻳﺴﺎرﻩ‪ ،‬إذن ﻓﻬﺬا اﻟﻤﻌﺎﻣﻞ ﻻ ﻳﻌﻨﻲ ﻳﺴﺎوي ﺑﻞ ﻳﻌﻨﻲ أﺳﻨﺪ ﻗﻴﻤﻪ‪ .‬أﻣﺎ == ﻓﻬﻮ ﻣﻌﺎﻣﻞ ﻋﻼﺋﻘﻲ ﻳﻌﻨﻲ ﻳﺴﺎوي‬
‫وﻻ ﻳﺴﺘﺨﺪم إﻻ ﻣﻊ ‪.if‬‬

‫‪10‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫ﻣﺜﺎل)‪ (1.3‬ﻋﺒﺮ ﻋﻦ اﻟﺸﺮوط اﻟﺘﺎﻟﻴﻪ ﺑﺼﻴﻐﺔ ﺗﻨﺎﺳﺐ ﻟﻐﺔ ‪.C++‬‬
‫‪ .1‬إذا آﺎﻧﺖ ‪ x‬أآﺒﺮ ﻣﻦ ‪ y‬ﻓﺈن ‪.d=5‬‬
‫‪ .2‬إذا آﺎﻧﺖ اﻟﺪرﺟﺔ ‪ d‬أآﺒﺮ أو ﻳﺴﺎوي ‪ 60‬اﻃﺒﻊ ﻧﺎﺟﺢ ”‪ ”pass‬وإﻻ اﻃﺒﻊ راﺳﺐ ”‪.“fail‬‬
‫‪ .3‬إذا آﺎﻧﺖ ﻗﻴﻤﺔ اﻟﺠﺬر اﻟﺮﺑﻴﻌﻲ ‪ sr‬أﻗﻞ ﻣﻦ ‪ 0‬اﻃﺒﻊ ﻋﺪد ﺗﺨﻴﻠﻲ"‪."imaginary number‬‬
‫‪ .4‬إذا آﺎﻧﺖ ‪ a‬ﻻ ﺗﺴﺎوي ‪ 5‬ﻓﺈن ‪ ،b=2a+3‬و‪ ،c=3a-4b‬وإﻻ ﻓﺈن‪ ، b=2a-11‬و‪.c=3a+b‬‬
‫اﻟﺤﻞ‪:‬‬
‫)‪1. if(x>y‬‬
‫;‪d=5‬‬
‫)‪2. if(d>=60‬‬
‫;”‪cout<<”pass‬‬
‫‪else‬‬
‫;”‪cout<<”fail‬‬
‫)‪3. if(sr<0‬‬
‫;”‪cout<<” imaginary number‬‬
‫)‪4. if(a!=5‬‬
‫{‬
‫;‪b=2a+3‬‬
‫;‪c=3a-4b‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;‪b=2a-11‬‬
‫;‪c=3a+b‬‬
‫}‬

‫‪Logical Operators‬‬ ‫اﻟﻤﻌﺎﻣﻼت اﻟﻤﻨﻄﻘﻴﺔ‬

‫وﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻘﻬﺎ اﻟﺮﺑﻂ ﺑﻴﻦ اﻟﺸﺮوط وهﻲ ﺛﻼﺛﺔ ﻣﻌﺎﻣﻼت ﻣﺒﻴﻨﻪ ﻓﻲ اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪:‬‬

‫اﺗﺠﺎﻩ اﻟﺘﻨﻔﻴﺬ‬ ‫اﻟﻤﻌﻨﻰ‬ ‫اﻷداة‬

‫آﻼ اﻻﺗﺠﺎهﻴﻦ‬ ‫ﺗﻌﻨﻲ ‪" and‬و"‬ ‫&&‬
‫آﻼ اﻻﺗﺠﺎهﻴﻦ‬ ‫ﺗﻌﻨﻲ ‪" or‬أو"‬ ‫||‬
‫اﻟﻴﺴﺎر ﻟﻠﻴﻤﻴﻦ‬ ‫ﺗﻌﻨﻲ ‪ not‬ﻻ‬ ‫!‬

‫ﻣﻠﺤﻮﻇﻪ‪:‬‬
‫أوﻟﻮﻳﺔ اﻟﺘﻨﻔﻴﺬ ﻟﻬﺬﻩ اﻟﻤﻌﺎﻣﻼت ﻟﻠﺘﻲ ﺗﻜﻮن داﺧﻞ أﻗﻮاس وإﻻ ﻓﺈن اﻷوﻟﻮﻳﺔ ﺗﻜﻮن ﻣﻦ‬ ‫
‬
‫اﻟﻴﺴﺎر ﻟﻠﻴﻤﻴﻦ‪.‬‬
‫ﺟﺪاول اﻟﺤﻘﻴﻘﺔ ‪Truth Tables‬‬
‫آﻤﺎ هﻮ ﻣﻌﻠﻮم أن ﻧﺘﻴﺠﺔ اﻟﺸﺮط إﻣﺎ ﺻﻮاب أو ﺧﻄﺄ‪ ،true or false‬وﻓﻲ ﺣﺎﻟﺔ اﻟﺠﻤﻠﻪ اﻟﺸﺮﻃﻴﻪ اﻟﻤﺮآﺒﻪ ﻓﺈن اﻟﻨﺎﺗﺞ‬
‫ﻳﻌﺘﻤﺪ ﻋﻠﻰ اﻟﺸﺮﻃﻴﻦ اﻟﻤﻜﻮﻧﻴﻦ ﻟﻠﺠﻤﻠﻪ وﻧﻮع اﻟﺮاﺑﻂ اﻟﻤﻨﻄﻘﻲ‪ ،‬وهﺬا ﻣﻮﺿﺢ ﻓﻴﻤﺎ ﻳﻌﺮف ﻓﻲ ﻋﻠﻢ اﻟﺮﻳﺎﺿﻴﺎت‬
‫اﻟﻤﺘﻘﻄﻌﻪ‪ discrete mathematics‬ﺑﺠﺪاول اﻟﺨﻄﺄ واﻟﺼﻮاب أو ﺟﺪاول اﻟﺤﻘﻴﻘﻪ ‪ truth tables‬واﻟﻤﻮﺿﺤﻪ‬
‫أدﻧﺎﻩ‪" .‬ﺳﻨﺮﻣﺰ ﻟﻠﺸﺮﻃﻴﻦ ﺑﺎﻟﺤﺮﻓﻴﻦ ‪ A,B‬وﻟﻠﺼﻮاب ﺑﺎﻟﺤﺮف‪ T‬واﻟﺨﻄﺄ ﺑﺎﻟﺤﺮف‪"F‬‬
‫أو ًﻻ ﺟﺪول اﻟﺤﻘﻴﻘﻪ ﻟﻠﺮاﺑﻂ اﻟﻤﻨﻄﻘﻲ &&‬
‫‪A‬‬ ‫‪B‬‬ ‫‪Result‬‬
‫‪T‬‬ ‫‪T‬‬ ‫‪T‬‬
‫‪T‬‬ ‫‪F‬‬ ‫‪F‬‬
‫‪F‬‬ ‫‪T‬‬ ‫‪F‬‬
‫‪F‬‬ ‫‪F‬‬ ‫‪F‬‬

‫‪11‬‬
 ‫ﺛﺎﻧﻴًﺎ ﺟﺪول اﻟﺤﻘﻴﻘﻪ ﻟﻠﺮاﺑﻂ اﻟﻤﻨﻄﻘﻲ ||‬
‫‪A‬‬ ‫‪B‬‬ ‫‪Result‬‬
‫‪T‬‬ ‫‪T‬‬ ‫‪T‬‬
‫‪T‬‬ ‫‪F‬‬ ‫‪T‬‬
‫‪F‬‬ ‫‪T‬‬ ‫‪T‬‬
‫‪F‬‬ ‫‪F‬‬ ‫‪F‬‬

‫ﺛﺎﻟﺜًﺎ ﺟﺪول اﻟﺤﻘﻴﻘﻪ ﻟﻠﺮاﺑﻂ اﻟﻤﻨﻄﻘﻲ !‬

‫‪A‬‬ ‫‪!B‬‬
‫‪T‬‬ ‫‪F‬‬
‫‪F‬‬ ‫‪T‬‬

‫ﻣﺜﺎل)‪ (2.3‬ﻋﺒﺮ ﻋﻦ اﻟﺸﺮوط اﻟﺘﺎﻟﻴﻪ ﺑﺼﻴﻐﺔ ﺗﻨﺎﺳﺐ ﻟﻐﺔ ‪.C++‬‬

‫‪ .1‬إذا آﺎﻧﺖ ‪ x‬أآﺒﺮ ﻣﻦ ‪ y‬و ‪y‬ﺗﺴﺎوي ‪ 0‬ﻓﺈن ‪.d=5‬‬
‫‪ .2‬إذا آﺎﻧﺖ اﻟﺪرﺟﺔ ‪ d‬أآﺒﺮ أو ﻳﺴﺎوي ‪ 80‬أو‪ d‬أﻗﻞ ﻣﻦ ‪ 90‬اﻃﺒﻊ ”‪.“B‬‬
‫‪ .3‬إذا ﻟﻢ ﺗﻜﻦ) ‪ x‬أآﺒﺮ ﻣﻦ ‪ y‬و ‪y‬ﺗﺴﺎوي ‪ (0‬أو ‪x‬ﺗﺴﺎوي ‪3‬ﻓﺈن ‪d‬ﺗﺴﺎوي‪ 10‬وإﻻ ﻓﺈن ‪ d‬ﺗﺴﺎوي ‪.20‬‬
‫اﻟﺤﻞ‪:‬‬
‫)‪1. if(x>y&&y==0‬‬
‫;‪d=5‬‬
‫)‪2. if(d>=80||d<90‬‬
‫;”‪cout<<”B‬‬
‫)‪3. if(!(x>y&&y==10)||x==3‬‬
‫;‪d=10‬‬
‫‪else‬‬
‫;‪d=20‬‬
‫‪Carno Maps‬‬ ‫ﺧﺮاﺋﻂ آﺎرﻧﻮ‬
‫ﻓﻲ ﺣﺎﻟﺔ اﻟﺸﺮوط اﻟﻤﻌﻘﺪة ﺗﺴﺘﺨﺪم ﺧﺮاﺋﻂ آﺎرﻧﻮ ﻟﻠﻮﺻﻮل ﻟﻠﺼﻴﻐﺔ اﻟﺼﺤﻴﺤﻪ واﻟﻤﺒﺴﻄﺔ ﻟﻠﺸﺮط‪ ،‬هﺬﻩ اﻟﺨﺮاﺋﻂ‬
‫ﻋﺒﺎرة ﻋﻦ ﺗﻤﺜﻴﻞ ﻟﻜﻞ اﻻﺣﺘﻤﺎﻻت اﻟﻤﻤﻜﻨﺔ ﻟﻠﺸﺮوط وﻳﺆﺧﺬ اﻟﺸﺮط اﻟﻤﺮآﺐ اﻟﺬي ﻳﺆدي إﻟﻰ ﺻﺤﺔ اﻟﻌﺒﺎرة‬
‫اﻟﻤﻨﻄﻘﻴﻪ ﺑﻤﺠﻤﻠﻬﺎ‪.‬‬
‫ﻣﺜﺎل)‪(3.3‬‬
‫ﻓﻲ رﻗﻌﺔ اﻟﺸﻄﺮﻧﺞ ﺗﺘﺤﺮك ﻗﻄﻌﺔ اﻟﺤﺼﺎن ﺑﺸﻜﻞ ﻳﻤﺜﻞ اﻟﺤﺮف ‪ L‬ﻓﻲ آﻞ اﻻﺗﺠﺎهﺎت آﻤﺎ هﻮ ﻣﺒﻴﻦ ﺑﺎﻟﺸﻜﻞ‪:‬‬

‫ﺣﻴﺚ اﻟﻤﻮاﻗﻊ اﻟﻤﻮﺿﺤﺔ ﺑـ ‪ X‬ﺗﻤﺜﻞ اﻷﻣﺎآﻦ‬

‫اﻟﻤﻤﻜﻦ اﻟﺘﺤﺮك إﻟﻴﻬﺎ‪.‬‬
‫إذا اﻋﺘﺒﺮﻧﺎ أن ﻣﻘﺪار اﻟﺘﺤﺮك اﻷﻓﻘﻲ ‪nx‬وﻣﻘﺪار‬
‫اﻟﺘﺤﺮك اﻟﺮأﺳﻲ ‪ ny‬واﻟﻤﻮﻗﻊ اﻟﺤﺎﻟﻲ ﻟﻠﻘﻄﻌﻪ‬
‫)‪ (x,y‬ﻓﺈن اﻟﺸﺮوط اﻟﻮاﺟﺐ ﺗﻮﻓﺮهﺎ ﻟﺘﺤﺮﻳﻚ‬
‫اﻟﻘﻄﻌﻪ هﻲ‪:‬‬ ‫‪X‬‬ ‫‪X‬‬
‫‪A- nx==1‬‬
‫‪nx==2‬‬ ‫‪X‬‬ ‫‪X‬‬
‫‪B- ny==1‬‬
‫‪C- ny==2‬‬
‫‪D- x+ nx<=8‬‬
‫‪E- x- nx>=1‬‬ ‫‪X‬‬ ‫‪X‬‬
‫‪F- y+ ny<=8‬‬
‫‪G- y- ny>=1‬‬ ‫‪X‬‬ ‫‪X‬‬
‫اﻟﺸﺮوط ‪ H,G,F,E‬ﻟﻀﻤﺎن ﺗﺤﺮك اﻟﻘﻄﻌﺔ‬
‫ﺿﻤﻦ ﺣﺪود اﻟﺮﻗﻌﺔ وهﻲ ﺗﺨﺺ ﺗﺤﺮآﺎت ﺟﻤﻴﻊ‬
‫اﻟﻘﻄﻊ‪ ،‬وﻳﺠﺐ ﺗﻮﻓﺮهﺎ ﺟﻤﻴﻌًﺎ ﻓﻲ ﺁن واﺣﺪ أي أن‬

‫‪12‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫اﻟﺮاﺑﻂ ﻓﻴﻤﺎ ﺑﻴﻨﻬﺎ هﻮ && أﻣﺎ اﻟﺸﺮوط ‪ D,C,B,A‬ﻓﺘﺨﺺ اﻟﺤﺮآﺔ ﻓﻲ اﻻﺗﺠﺎﻩ ‪ L‬اﻟﺮواﺑﻂ ﺑﻴﻦ هﺬﻩ اﻟﺸﺮوط ﻳﻤﻜﻦ‬
‫اﺳﺘﻨﺘﺎﺟﻬﺎ ﻋﻦ ﻃﺮﻳﻖ ﺧﺮاﺋﻂ آﺎرﻧﻮ ﺣﻴﺚ ﺗﻮﺿﻊ آﻞ اﻻﺣﺘﻤﺎﻻت اﻟﻤﻤﻜﻨﺔ ﻟﻠﻌﻼﻗﺎت ﺑﻴﻦ اﻟﺸﺮوط ‪D,C,B,A‬‬
‫وﻋﺪدهﺎ ‪ 24‬واﻟﻌﺪد ‪ 4‬ﻳﺸﻴﺮ إﻟﻰ ﻋﺪد اﻟﺸﺮوط‪ ،‬أﻣﺎ اﻟﻌﺪد‪ 2‬ﻳﺸﻴﺮ إﻟﻰ اﺣﺘﻤﺎﻟﻲ اﻟﺼﻮاب واﻟﺨﻄﺄ ﻟﻜﻞ ﺷﺮط‪ ،‬ﻓﻲ‬
‫ﺧﺮاﺋﻂ آﺎرﻧﻮ ﻳﻮﺿﻊ ﺷﺮﻃﻴﻦ ﻋﻠﻰ آﻞ ﺟﺎﻧﺐ وﺗﺆﺧﺬ اﻹﺣﺘﻤﺎﻻت اﻟﻤﻤﻜﻨﻪ ﻟﻜﻞ ﻣﻨﻬﻤﺎ آﻤﺎ هﻮ ﻣﻮﺿﺢ‪:‬‬

‫‪AB‬‬ ‫‪A !B‬‬ ‫‪!A B‬‬ ‫‪!A !B‬‬

‫‪CD‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪C !D‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪!C D‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪!C !D‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬

‫ﻧﻼﺣﻆ اﺳﺘﺨﺪام ‪ 0‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ ﻋﺪم إﻣﻜﺎﻧﻴﺔ هﺬا اﻻﺣﺘﻤﺎل‪ ،‬واﺳﺘﺨﺪام ‪ 1‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ ﺗﺤﻘﻖ اﻹﺣﺘﻤﺎل‪ ،‬ﻟﺬا ﻧﺠﺪ أن‬
‫اﻟﺠﻤﻠﻪ اﻟﻤﻨﻄﻘﻴﻪ ﻳﻤﻜﻦ أن ﺗﺼﺎغ ﺑﺪﻻﻟﺔ اﻟﺤﺮوف ‪ D,C,B,A‬آﺎﻵﺗﻲ‪:‬‬
‫)‪(A &&!B&&!C&&D)||(!A&&B&&C&&!D‬‬
‫وﺑﻌﺪ إﺿﺎﻓﺔ ﺷﺮوط وﺟﻮد اﻟﻘﻄﻌﻪ ﻋﻠﻰ اﻟﺮﻗﻌﺔ ﺗﻜﻮن اﻟﺠﻤﻠﻪ اﻟﻤﻨﻄﻘﻴﻪ‪:‬‬
‫])‪(E&&F&&G&&H)&&[ (A &&!B&&!C&&D)||(!A&&B&&C&&!D‬‬
‫ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﻳﺘﻢ اﻟﺘﻌﻮﻳﺾ ﻋﻦ اﻟﺤﺮوف‪ A,B,C,D,E,F,G,H‬ﺑﺎﻟﺸﺮوط‪ ،‬وﺑﺎﻟﺘﺎﻟﻲ ﻳﻜﻮن اﻟﺸﺮط آﺎﻵﺗﻲ‪:‬‬
‫])‪if[(x+nx<=8&&x-nx>=1&&y+ny<=8&&y-ny>=1)]&&[(nx==1&&ny==2)||(nx==2&&ny==1‬‬
‫ﻧﻼﺣﻆ أﻧﻪ ﺑﺎﻟﺮﻏﻢ ﻣﻦ ﺗﻌﻘﻴﺪ اﻟﺸﺮط اﻟﻨﺎﺗﺞ إﻻ أﻧﻪ أﻣﻜﻦ اﻟﻮﺻﻮل إﻟﻴﺔ ﺑﺼﻮرﻩ ﺳﺮﻳﻌﺔ ﺑﻮاﺳﻄﺔ ﺧﺮاﺋﻂ آﺎرﻧﻮ‪.‬‬
‫اﻻﺧﺘﻴﺎر اﻟﻤﺘﻌﺪد‪:‬‬
‫اﻟﻤﻼﺣﻆ ﻋﻠﻰ ﺟﻤﻠﺔ ‪ if-else‬وﺟﻮد ﻣﺴﺎرﻳﻦ ﻓﻘﻂ ﻳﺠﺐ أن ﻳﻨﻔﺬ أﺣﺪهﻤﺎ أﻣﺎ إن آﺎﻧﺖ اﻟﻤﺴﺎرات " اﻟﺨﻴﺎرات" أآﺜﺮ‬
‫ﻣﻦ اﺛﻨﻴﻦ ﻓﺘﺴﺘﺨﺪم ﺟﻤﻠﺔ ‪.switch-case‬‬
‫)‪switch(variable‬‬ ‫‪ .....‬اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ‬
‫{‬ ‫‪.....‬‬

‫‪case value1:‬‬
‫‪statement/statements‬‬
‫;‪break‬‬
‫‪case value2:‬‬
‫‪statement/statements‬‬
‫;‪break‬‬
‫‪case value3:‬‬
‫‪statement/statements‬‬
‫;‪break‬‬
‫‪.‬‬
‫‪.‬‬
‫‪default:‬‬
‫‪statement/statements‬‬
‫;‪break‬‬
‫}‬
‫ﻻﺣﻆ أن ‪ value3 ،value2 ،value1‬هﻲ ﻗﻴﻢ ﻟﻠﻤﺘﻐﻴﺮ ‪ variable‬اﻟﻤﺬآﻮر ﻣﻊ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة‪، switch‬‬
‫وﺗﻤﺜﻞ آﻞ ‪ case‬ﺧﻴﺎر‪ ،‬إذن ﻓﻘﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺗﺤﺪد اﻟﺨﻴﺎر اﻟﺬي ﺳﻴﻨﻔﺬ "أي ﺗﻘﻮم ﻣﻘﺎم اﻟﺸﺮط" وإذا ﻓﺸﻠﺖ آﻞ اﻟﻘﻴﻢ ﻓﺈن‬
‫اﻷواﻣﺮ اﻟﺘﻲ ﺗﻠﻲ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ default‬ﺳﺘﻨﻔﺬ ﺗﻠﻘﺎﺋﻴًﺎ‪ ،‬ﻧﻼﺣﻆ أن آﻞ ﺗﻌﻠﻴﻤﻪ ﺧﺘﻤﺖ ﺑﺎﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪break‬‬
‫ﻟﻺﺷﺎرة إﻟﻰ اﻧﺘﻬﺎء اﻟﺘﻌﻠﻴﻤﺎت اﻟﺒﺮﻣﺠﻴﻪ ﻟﻠﺨﻴﺎر اﻟﻤﻌﻴﻦ‪.‬‬
‫ﻣﺜﺎل)‪(3.4‬‬
‫اآﺘﺐ ﺑﺮﻧﺎﻣﺠًﺎ ﺑﻠﻐﺔ ‪ C++‬ﻳﺤﺴﺐ اﻟﺪﺧﻞ اﻟﻜﻠﻲ ﻟﻤﻮﻇﻒ‪ , total_income‬إذا ﻋﻠﻤﺖ درﺟﺘﻪ اﻟﻮﻇﻴﻔﻴﺔ ‪grade‬‬
‫ﺣﻴﺚ ﻳﺤﺴﺐ اﻟﺪﺧﻞ اﻟﻜﻠﻲ ﺑﺎﻟﻤﻌﺎدﻟﺔ‪:‬‬
‫‪total_income=bsaic_salary+bonus+fees‬‬
‫و‪ bsaic_salary‬هﻮ اﻟﺮاﺗﺐ اﻷﺳﺎﺳﻲ‪ bonus ،‬ﻳﻤﺜﻞ اﻟﻌﻼوة‪ ،‬و‪ fees‬اﻟﺒﺪﻻت وﻗﻴﻢ هﺬﻩ اﻟﻤﺘﻐﻴﺮات ﺗﻌﺘﻤﺪ ﻋﻠﻰ‬
‫اﻟﺪرﺟﺔ اﻟﻮﻇﻴﻔﻴﺔ ﺣﺴﺐ اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪:‬‬

‫‪13‬‬
 grade bsaic_salary bonus fees
1 6000 =.04*bsaic_salary 700
2 5200 =.04*bsaic_salary 700
3 5000 =.03*bsaic_salary 500
4 3000 =.02*bsaic_salary 400
Other grades 2000 =.01*bsaic_salary 200
:‫اﻟﺤﻞ‬
‫ﻻ ﺑﺘﺤﺪﻳﺪ اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﺳﻨﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ‬
ً ‫ﻧﺒﺪأ أو‬
‫ وﻳﺘﻢ إدﺧﺎﻟﻪ ﻋﻦ ﻃﺮﻳﻖ اﻟﻤﺴﺘﺨﺪم وﻳﺘﻢ ﺗﻌﺮﻳﻔﻪ آﻌﺪد ﺻﺤﻴﺢ‬Grade
‫ وهﺬﻩ اﻟﻤﺘﻐﻴﺮات ﺗﺤﺴﺐ ﺣﺴﺐ اﻟﺠﺪول أﻋﻼﻩ‬fees ،bonus ،bsaic_salary
:‫ ﺑﺎﻟﺘﺎﻟﻲ ﻳﻤﻜﻦ ﺗﺼﻤﻴﻢ اﻟﻤﺨﻄﻂ اﻻﻧﺴﻴﺎﺑﻲ آﺎﻵﺗﻲ‬.‫ وﻳﺤﺴﺐ ﺣﺴﺐ اﻟﻤﻌﺎدﻟﻪ أﻋﻼﻩ‬total_income

‫اﺑﺪأ‬

‫ادﺧﻞ اﻟـ‬
grade

yes
bsaic_salary=6000;
grade=1 bonus=.04*bsaic_salary;
fees=700;
No
yes
bsaic_salary=5200;
grade=2 bonus=.04*bsaic_salary;
fees=700;
No

yes bsaic_salary=5000;
grade=3 bonus=.03*bsaic_salary;
fees=500;
No

yes bsaic_salary=3000;
grade=4 bonus=.02*bsaic_salary;
fees=400;
No

No
bsaic_salary=2000;
bonus=.01*bsaic_salary;
fees=200;

total_income=bsaic_salary+bonus+fees

total_income ‫اﻃﺒﻊ‬

‫اﻟﻨﻬﺎﻳﺔ‬

14
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
Prog6 :‫وﺑﺎﻟﺘﺎﻟﻲ ﻳﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ آﺎﻵﺗﻲ‬

#include<iostream.h>
void main()
{
int grade;
float bonus, total_income,bsaic_salary,fees;
cout<<"\n enter the employee grade: ";
cin>>grade;
switch(grade)
{
case 1:
bsaic_salary=6000;
bonus=.04*bsaic_salary;
fees=700;
break;
case 2:
bsaic_salary=5200;
bonus=.04*bsaic_salary;
fees=700;
break;
case 3:
bsaic_salary=5000;
bonus=.03*bsaic_salary;
fees=500;
break;
case 4:
bsaic_salary=3000;
bonus=.02*bsaic_salary;
fees=400;
break;
default:
bsaic_salary=2000;
bonus=.01*bsaic_salary;
fees=200;
break;
}
total_income=bsaic_salary+bonus+fees;
cout<<" the total income for this employee is "<<total_income;
}
:‫ﻣﻠﺤﻮﻇﻪ‬
،‫ ﺑﻴﻨﻬﺎ ﻓﻮاﺻﻞ‬switch ‫ ﺗﻜﺘﺐ هﺬﻩ اﻟﻤﺘﻐﻴﺮات ﻣﻊ ﻋﺒﺎرة‬،‫ﻋﻨﺪ ارﺗﺒﺎط اﻟﺨﻴﺎرات ﺑﺄآﺜﺮ ﻣﻦ ﻣﺘﻐﻴﺮ‬

.‫ ﺑﻴﻨﻬﺎ ﻓﻮاﺻﻞ‬case ‫ ﺗﻜﺘﺐ ﻗﻴﻤﻬﺎ ﻣﻊ ﻋﺒﺎرة‬،‫وآﺬﻟﻚ ﻗﻴﻢ اﻟﻤﺘﻐﻴﺮات‬

15
 ‫‪Loops‬‬ ‫اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﺔ‬
‫ﺗﻤﺜﻞ هﺬﻩ اﻟﺤﻠﻘﺎت اﻟﺠﺰء اﻟﺜﺎﻧﻲ ﻣﻦ ﺑﻨﻰ اﻟﺘﺤﻜﻢ ﻓﻌﻨﺪ اﻟﺮﻏﺒﺔ ﻓﻲ ﺗﻜﺮار أﻣﺮ" أو أواﻣﺮ" ﻣﻌﻴﻨﻪ ﺗﺴﺘﺨﺪم هﺬﻩ‬
‫اﻟﺤﻠﻘﺎت‪ ،‬و ﺳﻨﺘﻨﺎول ﻓﻲ هﺬا اﻟﺪرس ﺛﻼﺛﺔ أﻧﻮاع ﻣﻦ هﺬﻩ اﻟﺤﻠﻘﺎت‪ .‬ﻳﺠﺐ ﻋﻨﺪ ﺗﺼﻤﻴﻢ اﻟﺤﻠﻘﺔ ﺗﺤﺪﻳﺪ اﻵﺗﻲ‪:‬‬
‫♦ اﻷواﻣﺮ اﻟﺘﻲ ﺗﺤﺘﺎج إﻟﻰ ﺗﻜﺮار ﻟﺘﻮﺿﻊ داﺧﻞ ﺟﺴﻢ اﻟﺤﻠﻘﺔ‪.‬‬
‫♦ ﻋﺪد ﻣﺮات ﺗﻨﻔﻴﺬ اﻟﺤﻠﻘﺔ‪ ،‬وذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ‪ int‬ﻳﺴﻤﻰ ﻋﺪاد اﻟﺤﻠﻘﺔ وﺻﻴﺎﻏﺔ ﺷﺮط اﺳﺘﻤﺮار‬
‫اﻟﺤﻠﻘﺔ أو ﺗﻮﻗﻔﻬﺎ‪.‬‬
‫‪ -1‬ﺣﻠﻘﺔ ‪for‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﺔ‬ ‫‪.....‬‬
‫)‪for(counter_initial_value;condition;counter_incrementation/decrementation‬‬ ‫‪.....‬‬

‫{‬
‫‪.‬‬ ‫"‪statements " loop body‬‬
‫‪.‬‬
‫}‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﺗﺤﺘﻮي ﻋﻠﻰ ‪:‬‬
‫‪ for‬وهﻲ آﻠﻤﻪ ﻣﺤﺠﻮزة وﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ اﻟﻤﺴﺘﺪﻳﺮﻳﻦ ﺗﻮﺟﺪ ﺛﻼﺛﺔ ﺟﻤﻞ ﺑﺮﻣﺠﻴﺔ‪:‬‬
‫ƒ ‪ counter_initial_value‬وهﻲ اﻟﺠﻤﻠﺔ اﻟﻤﺤﺘﻮﻳﺔ ﻋﻠﻰ إﻋﻄﺎء ﻋﺪاد اﻟﺤﻠﻘﺔ ‪ counter‬اﻟﻘﻴﻤﻪ اﻹﺑﺘﺪاﺋﻴﺔ‪،‬‬
‫وﻳﻤﻜﻦ أن ﺗﺤﺘﻮي هﺬﻩ اﻟﺨﻄﻮة ﻋﻠﻰ ﺗﻌﺮﻳﻒ اﻟﻌﺪاد إذا ﻟﻢ ﻳﻜﻦ أﻋﻠﻦ ﻋﻦ ﺗﻌﺮﻳﻔﻪ ﻣﻦ ﻗﺒﻞ‪ ،‬وﻳﻤﻜﻦ أن ﺗﺘﻢ ﻋﻤﻠﻴﺘﻲ‬
‫اﻟﺘﻌﺮﻳﻒ وإﻋﻄﺎء اﻟﻘﻴﻤﻪ اﻹﺑﺘﺪاﺋﻴﺔ ﻗﺒﻞ اﻟﺤﻠﻘﺔ وﺑﺎﻟﺘﺎﻟﻲ ﻧﺴﺘﻐﻨﻲ ﻋﻦ هﺬا اﻟﺘﻌﺒﻴﺮ هﻨﺎ‪.‬‬
‫ƒ ‪ condition‬وهﻮ ﺷﺮط اﺳﺘﻤﺮار اﻟﺤﻠﻘﺔ أي أن اﻟﺤﻠﻘﻪ ﺗﺴﺘﻤﺮ إذا آﺎن اﻟﺸﺮط ﺻﺤﻴﺢ وﺗﺘﻮﻗﻒ إذا اﻧﺘﻔﻰ‬
‫اﻟﺸﺮط‪ ،‬وهﺬا اﻟﺸﺮط ﻳﻜﺘﺐ ﺑﺎﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻼت اﻟﻌﻼﺋﻘﻴﻪ ﺁﻧﻔﺔ اﻟﺬآﺮ‪ ،‬آﻤﺎ ﻳﻤﻜﻦ أن ﻳﻜﻮن اﻟﺸﺮط ﻣﺮآﺒًﺎ‪.‬‬
‫ƒ ‪ counter_incrimintation/decrimintation‬وهﻮ ﻣﻌﺪل اﻟﺰﻳﺎدة ‪ incrimination‬أو اﻟﻨﻘﺼﺎن‬
‫‪ decrimintation‬ﻓﻲ ﻗﻴﻤﺔ ﻋﺪاد اﻟﺤﻠﻘﻪ‪ ،‬وﻳﻤﻜﻦ أن ﺗﺘﻢ هﺬﻩ اﻟﺨﻄﻮة ﺿﻤﻦ اﻷواﻣﺮ داﺧﻞ ﺟﺴﻢ اﻟﺤﻠﻘﺔ‬
‫وﺑﺎﻟﺘﺎﻟﻲ ﻧﺴﺘﻐﻨﻲ ﻋﻦ هﺬا اﻟﺘﻌﺒﻴﺮ هﻨﺎ‪ ،‬وﻳﺴﺘﺨﺪم ﻟﺬﻟﻚ ﻣﻌﺎﻣﻼت ﺧﺎﺻﺔ آﻤﺎ هﻮ ﻣﻮﺿﺢ‪:‬‬

‫‪x++‬‬ ‫‪x=x+1‬‬
‫‪x--‬‬ ‫‪x=x-1‬‬
‫"‪x=variable "mathematical_operator" " value‬‬
‫"‪x"mathematical_operator"= " value‬‬
‫أﻣﺜﻠﻪ ﺗﻮﺿﻴﺤﻴﻪ‬
‫•‬ ‫ﺗﻢ ﺗﻌﺮﻳﻒ اﻟﻌﺪاد وإﻋﻄﺎء اﻟﻘﻴﻤﻪ اﻹﺑﺘﺪاﺋﻴﺔ ﻟﻪ داﺧﻞ ﺗﺮآﻴﺒﺔ ‪for(int i=3;i<=8;i++) {…….} for‬‬
‫•‬ ‫;‪int i=3‬‬ ‫ﺗﻢ ﺗﻌﺮﻳﻒ اﻟﻌﺪاد ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ وإﻋﻄﺎء اﻟﻘﻴﻤﻪ اﻹﺑﺘﺪاﺋﻴﺔ ﻟﻪ داﺧﻞ ﺗﺮآﻴﺒﺔ‪for‬‬
‫}‪for( ;i<=8;i--) {…….‬‬
‫•‬ ‫}‪for(int i=3;i<=8;) { i*=3;….‬‬ ‫ﻣﻌﺪل اﻟﺘﻐﻴﺮ ﻓﻲ اﻟﻌﺪاد ﻣﻮﺿﻮع داﺧﻞ ﺟﺴﻢ اﻟﺤﻠﻘﻪ‬
‫•‬ ‫ﺗﻢ ﺗﻌﺮﻳﻒ اﻟﻌﺪاد وإﻋﻄﺎء اﻟﻘﻴﻤﻪ اﻹﺑﺘﺪاﺋﻴﺔ ﻟﻪ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ ووﺿﻊ ﻣﻌﺪل اﻟﺘﻐﻴﺮ ﻓﻴﻪ ﻓﻲ ;‪int i=3‬‬
‫}‪for( ;i<=8;) { i/=3;….‬‬ ‫ﺟﺴﻢ اﻟﺤﻠﻘﻪ‬

‫•‬ ‫}‪for(int i=3,int j=9;i<=8||j>0;i=i+2,j--) {…….‬‬ ‫ﺣﻠﻘﻪ ﻣﺮﺗﺒﻄﻪ ﺑﻤﺘﻐﻴﺮﻳﻦ‬

‫ﻣﺜﺎل)‪ (3.5‬اآﺘﺐ ﺑﺮﻧﺎﻣﺠًﺎ ﺑﻠﻐﺔ ‪ C++‬ﻳﻄﺒﻊ اﻷرﻗﺎم اﻟﻔﺮدﻳﺔ ‪odd number‬اﻟﻤﺤﺼﻮرة ﺑﻴﻦ ‪ 2‬و ‪20‬‬
‫اﻟﺤﻞ‪ :‬هﺬﻩ اﻟﺤﻠﻘﻪ ﺗﺤﺘﺎج ﻟﻌﺪاد ﻳﺘﻐﻴﺮ ﺑﻤﻌﺪل اﺛﻨﻴﻦ "اﻟﻔﺮق ﺑﻴﻦ آﻞ ﻋﺪد ﻓﺮدي واﻟﺬي ﻳﻠﻴﻪ" واﻟﻌﺪاد ﻗﻴﻤﺘﻪ اﻹﺑﺘﺪاﺋﻴﺔ‬
‫‪ 3‬وﻳﻨﺘﻬﻲ ﺑـ ‪" 20‬ﺷﺮط اﻟﺤﻠﻘﻪ" آﻤﺎ هﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬
‫‪Prog7‬‬

‫‪16‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬

‫‪ -2‬ﺣﻠﻘﺔ ‪while‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ‬ ‫‪.....‬‬
‫)‪while(condition‬‬ ‫‪.....‬‬

‫{‬
‫‪.‬‬ ‫"‪statements " loop body‬‬
‫‪.‬‬
‫}‬
‫ﻧﻔﺲ اﻟﻮﺿﻊ اﻟﻘﺎﺋﻢ ﻓﻲ اﻟﺤﻠﻘﻪ اﻟﺴﺎﺑﻘﺔ ﻏﻴﺮ أن ﻣﻌﺪل اﻟﺘﻐﻴﺮ ﻓﻲ ﻗﻴﻤﺔ اﻟﻌﺪاد ﻳﻜﻮن داﺧﻞ ﺟﺴﻢ اﻟﺤﻠﻘﻪ‪ ،‬وﺗﻌﺮﻳﻒ اﻟﻌﺪاد‬
‫وإﻋﻼن ﻗﻴﻤﺘﻪ اﻹﺑﺘﺪاﺋﻴﺔ ﻗﺒﻞ اﻟﺤﻠﻘﻪ‪ ،‬ﻳﻤﻜﻦ إﻋﺎدة آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ﺑﺎﺳﺘﺨﺪام ﺣﻠﻘﺔ ‪:while‬‬
‫‪Prog8‬‬

‫‪ -3‬ﺣﻠﻘﺔ ‪do-while‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ‬ ‫‪.....‬‬
‫‪.....‬‬
‫‪do‬‬
‫{‬
‫‪.‬‬ ‫"‪statements " loop body‬‬
‫‪.‬‬
‫}‬
‫;)‪while(condition‬‬
‫ﻧﻔﺲ اﻟﻮﺿﻊ اﻟﻘﺎﺋﻢ ﻓﻲ اﻟﺤﻠﻘﻪ اﻟﺴﺎﺑﻘﺔ ﻏﻴﺮ أن ﻣﻌﺪل اﻟﺘﻐﻴﺮ ﻓﻲ ﻗﻴﻤﺔ اﻟﻌﺪاد ﻳﻜﻮن داﺧﻞ ﺟﺴﻢ اﻟﺤﻠﻘﻪ‪ ،‬وﺗﻌﺮﻳﻒ اﻟﻌﺪاد‬
‫وإﻋﻼن ﻗﻴﻤﺘﻪ اﻹﺑﺘﺪاﺋﻴﺔ ﻗﺒﻞ اﻟﺤﻠﻘﻪ‪ ،‬ﻧﺠﺪ أن هﺬﻩ اﻟﺤﻠﻘﻪ ﻋﻜﺲ ﺣﻠﻘﺔ ‪ while‬ﺣﻴﺚ اﺧﺘﺒﺎر اﻟﺸﺮط ﻣﺆﺧﺮ ﺑﻌﺪ ﺟﺴﻢ‬
‫اﻟﺤﻠﻘﻪ ﻣﻤﺎ ﻳﻌﻨﻲ أن ﺣﻠﻘﺔ ‪ do-while‬ﻻﺑﺪ أن ﺗﻨﻔﺬ ﻣﺮﻩ ﻋﻠﻰ اﻷﻗﻞ ﺣﺘﻰ وﻟﻮ اﻧﺘﻔﻰ ﺷﺮط اﻟﺤﻠﻘﻪ‪ ،‬ﻳﻤﻜﻦ إﻋﺎدة آﺘﺎﺑﺔ‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ﺑﺎﺳﺘﺨﺪام ﺣﻠﻘﺔ ‪:do-while‬‬
‫‪Prog9‬‬

‫‪Nested Loops‬‬ ‫اﻟﺤﻠﻘﺎت اﻟﻤﺘﺪاﺧﻠﻪ‬

‫ﻼ‬
‫ﺣﻴﻨﻤﺎ ﻳﺘﻄﻠﺐ اﻷﻣﺮ اﻟﺒﺮﻣﺠﻲ ﺗﻜﺮارﻩ ﻋﻠﻰ ﻣﺴﺘﻮﻳﻴﻦ ﺗﺴﺘﺨﺪم اﻟﺤﻠﻘﺎت اﻟﻤﺘﺪاﺧﻠﻪ ﺣﻴﺚ ﺗﻜﺘﺐ ﺣﻠﻘﻪ داﺧﻞ أﺧﺮى‪ ،‬ﻣﺜ ً‬
‫إذا أردﻧﺎ اﻟﺘﻌﺎﻣﻞ ﻣﻊ درﺟﺎت ﻣﺠﻤﻮﻋﺔ ﻃﻼب ﻓﻲ ﻋﺪد ﻣﻦ اﻟﻤﻮاد ﻓﺈن هﻨﺎﻟﻚ ﻣﺴﺘﻮي اﻟﻤﻮاد واﻟﻄﻼب ﻓﻴﺠﻌﻞ ﻟﻜﻞ‬
‫ﻣﻨﻬﻤﺎ ﺣﻠﻘﻪ ﺧﺎﺻﺔ‪ ،‬وﻧﻈﺮًا ﻷن ﻟﻜﻞ ﻃﺎﻟﺐ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﻤﻮاد ﻓﺈن اﻟﺤﻠﻘﺘﻴﻦ ﻣﺮﺗﺒﻄﺘﻴﻦ ﺑﺒﻌﻀﻬﻤﺎ اﻟﺒﻌﺾ ﻟﺬا ﺗﻮﺿﻊ‬
‫ﺣﻠﻘﻪ داﺧﻞ أﺧﺮى‪ .‬ﻋﺪد ﻣﺮات ﺗﻨﻔﻴﺬ اﻷﻣﺮ اﻟﻤﻮﺟﻮد ﺑﺎﻟﺤﻠﻘﺔ اﻟﺪاﺧﻠﻴﺔ ﻳﺴﺎوي ﺣﺎﺻﻞ ﺿﺮب ﻋﺪد ﻣﺮات اﻟﺘﻨﻔﻴﺬ ﻟﻜﻞ‬
‫ﻣﻨﻬﻤﺎ‪.‬‬

‫‪17‬‬
 ‫ﻣﺜﺎل)‪ (3.6‬اآﺘﺐ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﻳﻌﻄﻲ اﻟﺨﺮج اﻟﺘﺎﻟﻲ‪:‬‬

‫‪Prog10‬‬
‫اﻟﺤﻞ‪:‬‬

‫‪18‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬

‫ﺗﻤﺮﻳﻦ ‪3‬‬
‫‪ .1‬آﻢ ﻋﺪد ﻣﺮات ﺗﻨﻔﻴﺬ اﻟﺤﻠﻘﺎت اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫)‪a. for(i=1;i<15;i=i+3‬‬
‫)‪b. for(int i=0,int j=9;i<=16&&j>6;i++,j-=2‬‬
‫;‪c. int t=4‬‬
‫)‪while(t<=17‬‬
‫‪{….‬‬
‫};‪t+=3‬‬
‫;‪d. int t=4‬‬
‫‪do‬‬
‫‪{….‬‬
‫;)‪t+=3;} while(t>17‬‬
‫)‪e. for(i=9;i>5;i++‬‬
‫)‪f. while(6>3‬‬
‫}‪{……….‬‬
‫‪ .2‬أﻋﺪ آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪ prog5‬ﻟﻴﺼﻠﺢ ﻟﻌﺪد ‪ n‬ﻣﻮﻇﻒ؟‬
‫‪ .3‬اآﺘﺐ ﺑﺮﻧﺎﻣﺠًﺎ ﺑﻠﻐﺔ ‪ C++‬ﻳﻄﺒﻊ اﻷﻋﺪاد اﻷوﻟﻴﺔ "‪ "primary numbers‬ﻓﻲ اﻟﻤﺪى ﻣﻦ ‪ 10‬و‪100‬‬
‫‪ .4‬اآﺘﺐ ﺑﺮﻧﺎﻣﺠًﺎ ﺑﻠﻐﺔ ‪ C++‬ﻳﻄﻠﺐ إدﺧﺎل درﺟﺔ ﻃﺎﻟﺐ ﻓﻲ ﻣﺎدة وﻳﺨﺮج اﻟﺘﻘﺪﻳﺮ ﺣﺴﺐ اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪:‬‬

‫اﻟﺘﻘﺪﻳﺮ"‪"grade‬‬ ‫اﻟﺪرﺟﻪ "‪"degree‬‬

‫‪A+‬‬ ‫‪ 95‬ﻓﻤﺎ ﻓﻮق‬
‫‪A‬‬ ‫‪-90‬أﻗﻞ ﻣﻦ ‪95‬‬
‫‪B+‬‬ ‫‪-85‬أﻗﻞ ﻣﻦ ‪90‬‬
‫‪B‬‬ ‫‪-80‬أﻗﻞ ﻣﻦ ‪85‬‬
‫‪C+‬‬ ‫‪-75‬أﻗﻞ ﻣﻦ ‪80‬‬
‫‪C‬‬ ‫‪-70‬أﻗﻞ ﻣﻦ ‪75‬‬
‫‪D+‬‬ ‫‪-65‬أﻗﻞ ﻣﻦ ‪70‬‬
‫‪D‬‬ ‫‪-60‬أﻗﻞ ﻣﻦ ‪65‬‬
‫‪F‬‬ ‫أﻓﻞ ﻣﻦ ‪60‬‬

‫‪ .5‬أآﺘﺐ ﺑﺮﻧﺎﻣﺠًﺎ ﺑﻠﻐﺔ ‪ C++‬ﻳﺤﺴﺐ ﻣﻀﺮوب اﻟﻌﺪد "‪ n! "factorial‬ﺣﺴﺐ اﻟﻌﻼﻗﻪ‬

‫‪n!=n*(n-1)*n-2)*……..3*2*1‬‬
‫‪ .6‬أﻋﺪ آﺘﺎﺑﺔ هﺬﻩ اﻟﺤﻠﻘﻪ ﺑﺎﺳﺘﺨﺪام ‪ for‬ﻣﺮﻩ‪ ،‬وﻣﺮﻩ أﺧﺮى ﺑﺎﺳﺘﺨﺪام ‪ do-while‬ﻣﺮﻩ أﺧﺮى؟‬
‫;‪int x=4‬‬
‫{)‪while(x<10‬‬
‫;"‪cout<<"\n C++‬‬
‫};‪x++‬‬
‫‪ .7‬اآﺘﺐ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﻳﻌﻄﻲ اﻟﺨﺮج اﻟﺘﺎﻟﻲ‪:‬‬
‫ب‪-‬‬ ‫أ‪-‬‬

‫‪19‬‬
int float

20
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫‪Arrays‬‬ ‫اﻟﻤﺼﻔﻮﻓﺎت‬
‫اﻟﻤﺼﻔﻮﻓﺎت هﻲ أﺣﺪ ﺑﻨﻰ اﻟﺒﻴﺎﻧﺎت اﻟﻬﺎﻣﻪ‪ ،‬وهﻲ ﻋﺒﺎرة ﻋﻦ ﻣﺠﻤﻮﻋﻪ ﻣﻦ ﺧﺎﻧﺎت اﻟﺬاآﺮﻩ اﻟﻤﺘﺘﺎﻟﻴﺔ اﻟﺘﻲ ﻟﻬﺎ ﻧﻔﺲ‬
‫اﻻﺳﻢ وﻧﻔﺲ ﻧﻮع اﻟﺒﻴﺎﻧﺎت‪ .‬وﻣﻦ أﺟﻞ اﻟﺮﺟﻮع إﻟﻰ ﺧﺎﻧﻪ ﻣﻌﻴﻨﻪ ﻣﻦ هﺬﻩ اﻟﺨﺎﻧﺎت ﻧﺴﺘﺨﺪم اﺳﻢ اﻟﻤﺼﻔﻮﻓﻪ ورﻗﻢ‬
‫اﻟﻌﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺬي ﻳﺒﺪأ ﻣﻦ ‪.0‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻺﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ‪:‬‬ ‫‪.....‬‬
‫‪.....‬‬

‫;]‪array_type array_name[elements_number‬‬

‫ﻼ اﻹﻋﻼن ;]‪ ، int x[5‬ﻳﻤﺜﻞ إﻋﻼن ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﻣﻦ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ﺑﻬﺎ ﺧﻤﺴﻪ ﻋﻨﺎﺻﺮ وﺗﺘﻤﻴﺰ ﻋﻨﺎﺻﺮ‬ ‫ﻣﺜ ً‬
‫اﻟﻤﺼﻔﻮﻓﻪ ﺑﺎﻟﺮﻗﻢ اﻟﻤﺤﺼﻮر ﺑﻴﻦ ﻗﻮﺳﻲ اﻟﻤﺼﻔﻮﻓﻪ آﺎﻵﺗﻲ‪.x[0],x[1],x[2],x[3],x[4]:‬‬
‫ﻳﻤﻜﻦ أن ﺗﻘﺮأ ﻗﻴﻢ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ﻋﻦ ﻃﺮﻳﻖ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ أو ﺗﺴﻨﺪ ﻟﻬﺎ اﻟﻘﻴﻢ ﻋﻦ ﻃﺮﻳﻖ ﻣﻌﺎﻣﻞ اﻹﺳﻨﺎد"=" آﻤﺎ‬
‫ﻳﻠﻲ‪:‬‬
‫;}‪array_type array_name[elements_number]={values‬‬
‫ﻳﻔﺘﺮض أن ﻳﻜﻮن ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻣﻄﺎﺑﻘﺎ ﻟﻌﺪد اﻟﻘﻴﻢ وﺗﺴﻨﺪ اﻟﻘﻴﻢ ﻟﻠﻌﻨﺎﺻﺮ ﻋﻠﻰ اﻟﺘﻮاﻟﻲ اﺑﺘﺪا ًء ﻣﻦ اﻟﻌﻨﺼﺮ اﻷول ]‪،[0‬‬
‫ﻟﻜﻦ ﻋﻨﺪﻣﺎ ﻳﻜﻮن ﻋﺪد اﻟﻘﻴﻢ أﻗﻞ ﻣﻦ اﻟﻌﻨﺎﺻﺮ ﺗﺴﻨﺪ اﻟﻘﻴﻤﺔ ‪ 0‬ﺗﻠﻘﺎﺋﻴًﺎ ﻟﻠﻌﻨﺎﺻﺮ اﻟﻤﺘﺒﻘﻴﻪ‪.‬‬
‫ﻣﻠﺤﻮﻇﻪ‪:‬‬
‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﻪ ﻟﺘﺴﻬﻴﻞ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت ﻓﻲ ﻋﻤﻠﻴﺎت اﻹدﺧﺎل واﻹﺧﺮاج أو اﻟﻤﻌﺎﻟﺠﺔ‬ ‫
‬
‫ﺑﺤﻴﺚ ﻳﺴﺘﺨﺪم ﻋﺪاد اﻟﺤﻠﻘﺔ ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ رﻗﻢ اﻟﻌﻨﺼﺮ‪.‬‬
‫‪Prog11‬‬ ‫ﻣﺜﺎل )‪(1.4‬‬
‫اآﺘﺐ ﺑﺮﻧﺎﻣﺠًﺎ ﻟﺤﺴﺎب اﻟﻤﺠﻤﻮع واﻟﻤﺘﻮﺳﻂ ﻟﻌﺸﺮة أرﻗﺎم ﻣﺪﺧﻠﻪ؟‬

‫ﻣﻠﺤﻮﻇﻪ‪:‬‬
‫ﺗﺴﺘﺨﺪم اﻟﻤﺼﻔﻮﻓﺎت ﻓﻲ ﺗﻤﺜﻴﻞ ﺳﻼﺳﻞ اﻟﺤﺮوف آﺎﻷﺳﻤﺎء ﺣﻴﺚ ﻳﻜﻮن ﻧﻮع اﻟﻤﺼﻔﻮﻓﻪ ‪.char‬‬ ‫
‬
‫‪Multiple Subscripts Array‬‬ ‫اﻟﻤﺼﻔﻮﻓﺎت ﻣﺘﻌﺪدة اﻷﺑﻌﺎد‬
‫ﻳﻤﻜﻦ ﻟﻠﻤﺼﻔﻮﻓﺎت أن ﺗﺄﺧﺬ ﻋﺪة أﺑﻌﺎد‪ .‬وﻣﻦ ﺑﻴﻦ اﻻﺳﺘﺨﺪاﻣﺎت اﻟﺸﺎﺋﻌﺔ ﻟﻬﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤﺼﻔﻮﻓﺎت هﻮ اﻟﺠﺪاول‬
‫اﻟﺘﻲ ﺗﻨﺘﻈﻢ ﻓﻴﻬﺎ اﻟﺒﻴﺎﻧﺎت ﺿﻤﻦ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺼﻔﻮف و اﻷﻋﻤﺪة وﺑﺎﻟﺘﺎﻟﻲ ﻟﻨﺼﻞ ﻟﻤﻌﻠﻮﻣﻪ ﻣﻌﻴﻨﻪ ﻳﺠﺐ ﺗﺤﺪﻳﺪ اﻟﺴﻄﺮ‬
‫واﻟﻌﻤﻮد وآﻞ ﻣﻨﻬﻤﺎ ﻳﻤﺜﻞ ﺑﻌﺪًا ﻟﻠﻤﺼﻔﻮﻓﻪ‪ .‬اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻳﻮﺿﺢ اﻹﻋﻼن ﻋﻦ ﻣﺼﻔﻮﻓﻪ ذات ﺑﻌﺪﻳﻦ‪:‬‬
‫]‪float w[4][5‬‬
‫ﻓﻬﺬﻩ اﻟﻤﺼﻔﻮﻓﻪ ﺑﻬﺎ ‪ 20‬ﻋﻨﺼﺮًا "‪ "5*4‬وﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ هﺬﻩ اﻟﻤﺼﻔﻮﻓﻪ ﻓﻲ ﻋﻤﻠﻴﺎت اﻹﺧﺮاج واﻹدﺧﺎل واﻟﻤﻌﺎﻟﺠﻪ‬
‫ﻧﺴﺘﺨﺪم اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﻪ اﻟﺘﻲ ﻣﺮت ﻣﻌﻨﺎ ﺳﺎﺑﻘًﺎ‪.‬‬

‫‪21‬‬
 ‫ﻣﺜﺎل)‪ (2.4‬اآﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻳﺤﺴﺐ ﻣﺘﻮﺳﻂ درﺟﺎت اﻟﻄﺎﻟﺐ ﻓﻲ أرﺑﻌﻪ ﻣﻮاد‬
‫‪Prog12‬‬ ‫اﻟﺤﻞ‪:‬‬

‫ﻧﻼﺣﻆ اﺳﺘﺨﺪام اﻟﻤﺼﻔﻮﻓﺎت ﻓﻲ ﺗﻤﺜﻴﻞ ﺳﻼﺳﻞ اﻟﺤﺮوف ﻓﻲ اﻻﺳﻢ اﻷول واﻟﺜﺎﻧﻲ ﻟﻠﻄﺎﻟﺐ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ‪.‬‬
‫ﻣﻠﺤﻮﻇﻪ‬
‫ﻋﻨﺪ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺳﻼﺳﻞ اﻟﺤﺮوف ‪،‬ﻳﺴﺘﺨﺪم اﺳﻢ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺤﺮﻓﻴﺔ ﻓﻘﻂ ‪.‬‬ ‫
‬
‫ﻣﺜﺎل )‪ (3.4‬اﻋﺪ آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ﻋﻠﻰ أن ﻳﺤﺴﺐ ﻣﺘﻮﺳﻂ اﻟﺪرﺟﺎت ﻟﻌﺪد ‪ 6‬ﻃﻼب آﻤﺎ ﻓﻲ اﻟﺠﺪول‪:‬‬

‫اﻟﻤﻮاد‬
‫اﻟﻤﺘﻮﺳﻂ‬ ‫اﺳﻢ اﻟﻄﺎﻟﺐ‬
‫ﺣﺎﺳﺐ‬ ‫اﺣﺼﺎء‬ ‫رﻳﺎﺿﻴﺎت‬ ‫ﻓﻴﺰﻳﺎء‬
‫‪38‬‬ ‫‪56‬‬ ‫‪78‬‬ ‫‪34‬‬ ‫ﺣﺴﻦ ﻋﻠﻲ‬
‫‪90‬‬ ‫‪89‬‬ ‫‪90‬‬ ‫‪67‬‬ ‫ﻋﻠﻲ ﺳﻌﺪ‬
‫‪76‬‬ ‫‪78‬‬ ‫‪23‬‬ ‫‪45‬‬ ‫ﺳﺎﻟﻢ ﻋﻠﻲ‬
‫‪34‬‬ ‫‪56‬‬ ‫‪78‬‬ ‫‪89‬‬ ‫ﺻﺎﻟﺢ ﺧﻠﻴﻞ‬
‫‪54‬‬ ‫‪63‬‬ ‫‪78‬‬ ‫‪45‬‬ ‫ﻓﻮاز ﻋﻠﻲ‬
‫‪63‬‬ ‫‪78‬‬ ‫‪58‬‬ ‫‪47‬‬ ‫ﻋﻤﺮ ﺧﻠﻴﻞ‬

‫اﻟﺠﺪول أﻋﻼﻩ ﻳﻮﺿﺢ درﺟﺎت ﻣﺠﻤﻮﻋﺔ ﻃﻼب ﻓﻲ ﺑﻌﺾ اﻟﻤﻮاد‪ .‬ﻟﺘﻤﺜﻴﻞ هﺬﻩ اﻟﺒﻴﺎﻧﺎت ﻻﺑﺪ ﻟﻨﺎ ﻣﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺑﻌﺪﻳﻦ‬
‫هﻤﺎ اﻟﻄﻼب واﻟﻤﻮاد آﻤﺎ ﻳﻈﻬﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬

‫‪22‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫‪Prog13‬‬

‫ﻧﻼﺣﻆ اﺳﺘﺨﺪام ﻣﺼﻔﻮﻓﺎت ذات ﺑﻌﺪﻳﻦ ﻟﺘﻤﺜﻴﻞ اﻟﺪرﺟﻪ‪ degree‬و اﻹﺳﻢ اﻷول ‪ first_name‬واﻹﺳﻢ اﻷﺧﻴﺮ‬
‫‪.last_name‬‬
‫اﺳﺘﺨﺪام اﻟﻤﺼﻔﻮﻓﺎت ﻓﻲ ﻓﺮز اﻟﺒﻴﺎﻧﺎت‪:‬‬
‫ﻳﻌﺘﺒﺮ اﻟﻔﺮز ﻣﻦ أهﻢ ﻋﻤﻠﻴﺎت اﻟﻤﻌﺎﻟﺠﺔ اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ ﻧﻈﻢ اﻟﺘﺸﻐﻴﻞ واﻟﺒﺮاﻣﺞ اﻟﺘﻄﺒﻴﻘﻴﺔ‪ ،‬وﺗﻮﺟﺪ ﻋﺪة ﺧﻮارزﻣﻴﺎت‬
‫ﻟﻠﻔﺮز‪ ،‬ﻣﻨﻬﺎ ﻣﺎ ﺳﻨﺘﻨﺎوﻟﻪ اﻵن وهﻮ اﻟﻔﺮز اﻟﻔﻘﺎﻋﻲ ‪ bubble sort‬واﻟﺬي ﻳﻌﺘﻤﺪ ﻋﻠﻰ ﻣﻘﺎرﻧﻪ اﻟﻤﺘﻐﻴﺮات ﻓﻴﻤﺎ ﺑﻴﻨﻬﺎ‬
‫وﺗﺒﺪﻳﻞ ﻣﻮاﻗﻌﻬﺎ ﺑﻤﺎ ﻳﺘﻨﺎﺳﺐ ﻣﻊ ﻧﻮع اﻟﺘﺮﺗﻴﺐ ﺳﻮا ًء آﺎن ﺗﺼﺎﻋﺪﻳًﺎ أم ﺗﻨﺎزﻟﻴًﺎ وهﺬا ﻳﺘﻄﻠﺐ ﻣﻘﺎرﻧﺔ آﻞ اﻟﻌﻨﺎﺻﺮ ﻓﻴﻤﺎ‬
‫ﺑﻴﻨﻬﺎ ﻣﻤﺎ ﻳﺴﺘﻮﺟﺐ اﺳﺘﺨﺪام ﺣﻠﻘﺘﻴﻦ ﻣﺘﺪاﺧﻠﺘﻴﻦ ﺗﻌﻤﻞ آﻞ ﻣﻨﻬﻤﺎ ‪ n-1‬ﻣﺮﻩ ﺣﻴﺚ ‪ n‬ﻋﺪد اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮاد ﺗﺮﺗﻴﺒﻬﺎ‪.‬‬
‫ﻋﻤﻠﻴﺔ اﻟﺘﺒﺪﻳﻞ ﺗﺘﻢ ﺑﺎﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ اﻹﺳﻨﺎد= ﺣﻴﺚ ﺗﺴﻨﺪ اﻟﻘﻴﻤﺔ اﻷوﻟﻰ ﻟﻤﺘﻐﻴﺮ اﻟﺘﺒﺪﻳﻞ ﺛﻢ اﻟﻘﻴﻤﻪ اﻟﺜﺎﻧﻴﻪ ﻟﻸوﻟﻰ ﺛﻢ ﻗﻴﻤﺔ‬
‫ﻣﺘﻐﻴﺮ اﻟﺘﺒﺪﻳﻞ ﻟﻠﺜﺎﻧﻴﻪ آﻤﺎ ﻓﻲ اﻟﺮﺳﻢ ﻟﻠﺘﺒﺪﻳﻞ ﺑﻴﻦ ﻗﻴﻤﺘﻲ ‪:x,y‬‬
‫‪1‬‬
‫‪X‬‬
‫‪SWAP‬‬
‫‪3‬‬ ‫‪2‬‬
‫‪Y‬‬ ‫ﻳﻤﻜﻦ آﺘﺎﺑﺔ اﻟﺨﻮارزﻣﻴﺔ ﻟﻠﺘﺮﺗﻴﺐ اﻟﺘﺼﺎﻋﺪي آﺎﻵﺗﻲ‪:‬‬
‫)‪Loop(i=0 toi<n-1‬‬ ‫أﻣﺎ اﻟﺘﺮﺗﻴﺐ اﻟﺘﻨﺎزﻟﻲ ﻓﻨﻔﺲ اﻟﺨﻮارزﻣﻴﻪ ﻣﻊ ﺗﻐﻴﻴﺮ اﻟﺸﺮط إﻟﻰ‪:‬‬
‫)‪Loop(j=0 toj<n-1‬‬ ‫)]‪If(x[i]<x[i-1‬‬
‫)]‪If(x[i]>x[i-1‬‬
‫]‪Swap=x[i‬‬
‫]‪x[i]=x[i-1‬‬
‫‪x[i-1]=swap‬‬
‫ﺗﻤﺮﻳﻦ)‪(4‬‬
‫اآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﺑﻠﻐﺔ ‪ C++‬ﻳﻘﻮم ﺑﺘﺮﺗﻴﺐ ‪ n‬رﻗﻢ ﺗﺮﺗﻴﺒًﺎ ﺗﺼﺎﻋﺪﻳًﺎ ؟‬ ‫‪.1‬‬
‫أﻋﺪ آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪ 12‬ﻟﻌﺪد ‪ n‬ﻃﺎﻟﺐ ﻓﻲ ‪ m‬ﻣﺎدة ﺑﺤﻴﺚ ﻳﺤﺴﺐ ﻣﺘﻮﺳﻂ درﺟﺎت اﻟﻄﻼب ﻓﻲ آﻞ ﻣﺎدة؟‬ ‫‪.2‬‬

‫‪23‬‬
 Main( )
{
statements
………… Function A
…………. statements
Function D Function B
……… statements
……… return
}
return

………
………
return

24
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫‪Function‬‬ ‫اﻟﺪوال‬
‫اﻟﺪاﻟﻪ ﻋﺒﺎرﻩ ﻋﻦ ﺑﺮﻧﺎﻣﺞ ﻓﺮﻋﻲ ﻳﺤﺘﻮي ﻋﻠﻰ ﺗﻌﻠﻴﻤﻪ ﺑﺮﻣﺠﻴﻪ أو أآﺜﺮ وﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻟﺪاﻟﻪ ﻋﻨﺪ اﺳﺘﺪﻋﺎﺋﻬﺎ ﻣﻦ ﻗﺒﻞ اﻟﺪاﻟﻪ‬
‫اﻟﺮﺋﻴﺴﻴﻪ أو أي داﻟﻪ أﺧﺮى ﺛﻢ ﺗﺮﺟﻊ اﻟﺪاﻟﻪ ﻗﻴﻤﻪ ﻟﻠﺪاﻟﺔ اﻟﺘﻲ ﻗﺎﻣﺖ ﺑﺎﻻﺳﺘﺪﻋﺎء آﻤﺎ هﻮ ﻣﻮﺿﺢ ﺑﺎﻟﺮﺳﻢ‬

‫اﻟﺒﺮﻧﺎﻣﺞ‬
‫) (‪Main‬‬
‫{‬
‫‪Function A‬‬ ‫‪statements‬‬
‫…………‬ ‫‪Function A‬‬
‫‪Function D‬‬ ‫‪statements‬‬
‫‪………….‬‬
‫‪Function D‬‬ ‫‪Function B‬‬
‫………‬
‫‪return‬‬ ‫‪statements‬‬
‫………‬
‫}‬
‫‪return‬‬

‫‪Function B‬‬
‫………‬
‫………‬
‫‪return‬‬

‫ﺗﺬﺧﺮ اﻟﻤﻜﺘﺒﻪ اﻟﻤﻌﻴﺎرﻳﻪ ﻟﻠﻐﻪ ﺑﻤﺠﻤﻮﻋﻪ آﺒﻴﺮﻩ ﻣﻦ اﻟﺪوال اﻟﺠﺎهﺰﻩ واﻟﺘﻲ ﺗﺘﺒﻊ آﻞ ﻣﺠﻤﻮﻋﻪ ﻣﻨﻬﺎ ﻟﻤﻠﻒ ﺗﺮوﻳﺴﻲ ﻻﺑﺪ‬
‫ﻼ اﻟﺪاﻟﻪ ‪ sqrt‬ﻟﺤﺴﺎب اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ‬
‫ﻣﻦ ﺿﻤﻪ ﻟﻠﺒﺮﻧﺎﻣﺞ ﻋﻨﺪ اﻟﺮﻏﺒﻪ ﻓﻲ اﺳﺘﺨﺪام اﺣﺪى دوال هﺬا اﻟﻤﻠﻒ‪ ،‬ﻣﺜ ً‬
‫ﻻﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ اﻻ إذاﺗﻢ ﺿﻢ اﻟﻤﻠﻒ ‪ math.h‬ﻟﻠﺒﺮﻧﺎﻣﺞ‪ ،‬وﻳﻤﻜﻦ اﻹﻃﻼع ﻋﻠﻰ هﺬﻩ اﻟﻤﻠﻔﺎت و اﻟﺪوال اﻟﺘﻲ‬
‫ﺑﺪاﺧﻠﻬﺎ ﻣﻦ ﻗﺎﺋﻤﺔ اﻟﻤﺴﺎﻋﺪﻩ اﻟﻤﻮﺟﻮدﻩ ﻓﻲ ﺑﻴﺌﺔ اﻟﻌﻤﻞ وإﻟﻴﻚ ﺑﻌﺾ اﻟﺪوال اﻟﺮﻳﺎﺿﻴﻪ اﻟﻤﻨﻀﻮﻳﻪ ﺗﺤﺖ اﻟﻤﻠﻒ ‪math‬‬
‫ﻣﺜﺎل‬ ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ‬ ‫اﻟﻤﻬﻤﻪ‬ ‫اﻟﺪاﻟﻪ‬
‫‪tan(0)=0‬‬ ‫)‪tan(x‬‬ ‫ﺣﺴﺎب ﻃﻞ اﻟﺰاوﻳﻪ اﻟﻨﺼﻒ ﻗﻄﺮﻳﻪ‬ ‫‪tan‬‬
‫‪sin(0)=0‬‬ ‫)‪sin(x‬‬ ‫ﺣﺴﺎب ﺟﻴﺐ اﻟﺰاوﻳﻪ اﻟﻨﺼﻒ ﻗﻄﺮﻳﻪ‬ ‫‪sin‬‬
‫‪cos(0)=1‬‬ ‫)‪cos(x‬‬ ‫ﺣﺴﺎب ﺟﻴﺐ ﺗﻤﺎم اﻟﺰاوﻳﻪ اﻟﻨﺼﻒ ﻗﻄﺮﻳﻪ‬ ‫‪cos‬‬
‫‪abs(-7)=7‬‬ ‫)‪abs(y‬‬ ‫ﺣﺴﺎب اﻟﻘﻴﻤﻪ اﻟﻤﻄﻠﻘﻪ ﻟﻸﻋﺪاد اﻟﺼﺤﻴﺤﻪ‬ ‫‪abs‬‬
‫‪ceil(4.2)=5, ceil(-4.2)=-4‬‬ ‫)‪ceil(t‬‬ ‫ﺗﻘﺮﻳﺐ ﻷﻋﻠﻰ‬ ‫‪ceil‬‬
‫‪floor(4.2)=4, floor(-4.2)=-5‬‬ ‫)‪floor(t‬‬ ‫ﺗﻘﺮﻳﺐ ﻷﺳﻔﻞ‬ ‫‪floor‬‬
‫‪pow(2,3)=8, pow(.16,.5)=.4‬‬ ‫)‪pow(x,y‬‬ ‫ﻧﺎﺗﺞ رﻓﻊ ﻋﺪد ﺣﻘﻴﻘﻲ ﻵﺧﺮ‬ ‫‪pow‬‬
‫‪sqrt(9)=3, sqrt(.01)=.1‬‬ ‫)‪sqrt(w‬‬ ‫اﻳﺠﺎد اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ ﻟﻌﺪد ﺣﻘﻴﻘﻲ‬ ‫‪sqrt‬‬
‫‪fmod(5,3)=2,fmod(3,.7)=.2‬‬ ‫)‪fmod(t,y‬‬ ‫اﻳﺠﺎد ﺑﺎﻗﻲ اﻟﻘﺴﻤﻪ ﻟﻌﺪد ﺣﻘﻴﻘﻲ‬ ‫‪fmod‬‬
‫‪Log(4)=1.38629‬‬ ‫)‪log(x‬‬ ‫اﻳﺠﺎد اﻟﻠﻮﻏﺮﻳﺜﻢ اﻟﻄﺒﻴﻌﻲ ﻟﻌﺪد ﺣﻘﻴﻘﻲ‬ ‫‪log‬‬
‫‪Log10(100)=2‬‬ ‫)‪Log10(x‬‬ ‫اﻳﺠﺎد اﻟﻠﻮﻏﺮﻳﺜﻢ اﻟﻌﺸﺮي ﻟﻌﺪد ﺣﻘﻴﻘﻲ‬ ‫‪Log10‬‬

‫وهﺬﻩ ﺑﻌﺾ اﻟﺪوال اﻟﻤﺘﻌﻠﻘﻪ ﺑﻤﻌﺎﻟﺠﺔ ﺳﻼﺳﻞ اﻟﺤﺮوف ﺿﻤﻦ اﻟﻤﻠﻒ ‪string.h‬‬
‫ﻣﻠﺤﻮﻇﻪ‬ ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ‬ ‫اﻟﻤﻬﻤﻪ‬ ‫اﻟﺪاﻟﻪ‬
‫ﻧﺴﺦ ‪s2‬ﻓﻲ‪s1‬‬ ‫)‪strcpy(s1,s2‬‬ ‫ﻧﺴﺦ اﻟﻨﺺ‬ ‫‪strcpy‬‬
‫ﺗﻤﺜﻞ ‪ s1‬ﻧﺎﺗﺞ اﻟﺪﻣﺞ‬ ‫)‪strcat(s1,s2‬‬ ‫دﻣﺞ ﻧﺺ ﻣﻊ ﺁﺧﺮ‬ ‫‪strcat‬‬
‫ﻧﺎﺗﺞ اﻟﺪاﻟﻪ ﻋﺪد ﺻﺤﻴﺢ‬ ‫)‪strlen(s1‬‬ ‫ﺗﺤﺴﺐ ﻃﻮل اﻟﻨﺺ‬ ‫‪Strlen‬‬
‫ﺗﺮﺟﻊ ‪ 0‬إذا آﺎن اﻟﻨﺼﺎن ﻣﺘﻄﺎﺑﻘﺎن‪1،‬إذا آﺎن ﺗﺮﻣﻴﺰ‪s1‬أآﺒﺮ‬ ‫ﻣﻘﺎرﻧﺔ ﻧﺺ ﻣﻊ ﺁﺧﺮ‬
‫)‪strcmp(s1,s2‬‬ ‫‪strcmp‬‬
‫ﻣﻦ ‪-1 s2‬إذا آﺎن ﺗﺮﻣﻴﺰ ‪s1‬أﺻﻐﺮ ﻣﻦ ‪s2‬‬ ‫ﺣﺴﺐ ﺗﺮﻣﻴﺰ ﺁﺳﻜﻲ‬
‫ﺗﺮﺟﻊ ﻣﻌﻜﻮس اﻟﻨﺺ ﻣﺜﻼ ‪car‬ﺗﺼﺒﺢ‪rac‬‬ ‫)‪strrev(s1‬‬ ‫ﻋﻜﺲ اﻟﻨﺺ‬ ‫‪strrev‬‬

‫‪25‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫ﻣﺜﺎل)‪(2.5‬اﺳﺘﺨﺪم اﻟﺪاﻟﻪ ‪ strrev‬ﻓﻲ ﺗﺸﻔﻴﺮ اﻟﻨﺺ‬
‫‪C++ programming language is an object oriented language‬‬
‫‪Prog15‬‬
‫اﻟﺤﻞ‬

‫اﻟﻨﺎﺗﺞ‬

‫إﻧﺸﺎء اﻟﺪوال ‪Function Creation‬‬

‫ﻓﻲ اﻟﻔﻘﺮﻩ اﻟﺴﺎﺑﻘﻪ ﺗﻨﺎوﻟﻨﺎ اﺳﺘﺨﺪام اﻟﺪوال اﻟﺠﺎهﺰﻩ ﻓﻲ اﻟﻤﻜﺘﺒﻪ اﻟﻤﻌﻴﺎرﻳﻪ ﻟﻠﻐﻪ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﻪ‪ ،‬وآﻤﺎ هﻮ‬
‫واﺿﺢ أن ﻟﻜﻞ داﻟﻪ ﺻﻴﻐﻪ ﺧﺎﺻﺔ ﻻﺳﺘﺪﻋﺎﺋﻬﺎ ﻣﻦ ﺣﻴﺚ ﻋﺪد اﻟﻮﺳﺎﺋﻂ‪ arguments‬ﻓﺪاﻟﺔ ‪ sqrt‬ﺗﺤﺘﺎج إﻟﻰ وﺳﻴﻂ‬
‫واﺣﺪ ﻓﻘﻂ هﻮ اﻟﻌﺪد اﻟﻤﺮاد إﻳﺠﺎد اﻟﺠﺬر ﻟﻪ‪ ،‬ﺑﻴﻨﻤﺎ ﻧﺠﺪ اﻟﺪاﻟﻪ‪ pow‬ﺗﺤﺘﺎج إﻟﻰ وﺳﻴﻄﻴﻦ اﻷﺳﺎس واﻷس‪ .‬وﻳﻤﻜﻦ أن‬
‫ﻳﻨﺸﺊ اﻟﻤﺒﺮﻣﺞ اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﻪ وﺑﺎﻟﺘﺎﻟﻲ ﻋﻠﻴﻪ اﻹﻋﻼن ﻋﻦ اﻟﺪاﻟﻪ وﺑﻨﺎﺋﻬﺎ وﻣﻦ ﺛﻢ اﺳﺘﺪﻋﺎﺋﻬﺎ‪ ،‬وهﻨﺎ ﻳﺠﺐ ﺗﺤﺪﻳﺪ‪:‬‬
‫♦ اﻷواﻣﺮ واﻟﻤﻬﺎم اﻟﺘﻲ ﺳﺘﻘﻮم ﺑﻬﺎ اﻟﺪاﻟﻪ‪.‬‬
‫♦ ﻧﻮع وﻋﺪد اﻟﻮﺳﺎﺋﻂ اﻟﺘﻲ ﺳﺘﺮﺳﻞ ﻟﻠﺪاﻟﻪ‪.‬‬
‫♦ ﻧﻮع اﻟﻘﻴﻢ اﻟﺘﻲ ﺳﺘﺮﺟﻌﻬﺎ اﻟﺪاﻟﻪ‪.‬‬
‫‪Function Declaration‬‬ ‫اﻹﻋﻼن ﻋﻦ اﻟﺪاﻟﻪ‬
‫اﻟﻤﻘﺼﻮد ﺑﺎﻹﻋﻼن ﺗﺤﺪﻳﺪ ﻣﻮاﺻﻔﺎت اﻟﺪاﻟﻪ ﻣﻦ ﺣﻴﺚ ﻧﻮع اﻹرﺟﺎع‪ returned type‬وﻋﺪد وﻧﻮع اﻟﻮﺳﺎﺋﻂ‬
‫‪arguments type‬واﺳﻢ اﻟﺪاﻟﻪ‪.function name‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ‪:‬‬ ‫‪.....‬‬
‫‪.....‬‬
‫;)‪Returned type function name(arg1 type name,arg2 type name,…….‬‬
‫ﺣﻴﺚ ‪ arg1 type,arg2 type‬ﻳﻤﺜﻼن ﻧﻮع اﻟﻮﺳﻴﻂ "واﻟﻮﺳﻴﻂ هﻮ ﻣﺘﻐﻴﺮ ﻓﻴﺄﺧﺬ أﺣﺪ أﻧﻮاع اﻟﻤﺘﻐﻴﺮات اﻟﻤﻌﺮوﻓﻪ"‪،‬‬
‫وﻳﻌﻘﺐ ذﻟﻚ ‪ name‬وهﻮ اﺳﻢ اﻟﻮﺳﻴﻂ وهﻮ اﺧﺘﻴﺎري ﻓﻲ اﻹﻋﻼن‪.‬‬
‫ﻣﻠﺤﻮﻇﻪ‪:‬‬
‫ﻳﺘﻢ اﻹﻋﻼن ﻋﻦ اﻟﺪاﻟﻪ ﻗﺒﻞ ﺑﺪء اﻟﺪاﻟﻪ اﻟﺮﺋﻴﺴﻴﺔ‬ ‫
‬
‫إذا أﺳﻨﺪ ﻟﻠﻮﺳﻴﻂ ﻗﻴﻤﻪ ﺧﻼل اﻹﻋﻼن ﻓﺴﺘﻌﺘﺒﺮ ﻗﻴﻤﻪ اﻓﺘﺮاﺿﻴﻪ ﻟﻪ ﻣﺎ ﻟﻢ ﺗﺮﺳﻞ ﻟﻠﺪاﻟﻪ ﻗﻴﻤﻪ أﺧﺮى وهﻨﺎ ﻻ‬ ‫
‬
‫ﻳﻠﺰم ﻣﻨﺎداة اﻟﺪاﻟﻪ ﺑﻮﺳﺎﺋﻂ‪.‬‬
‫ﻣﺜﺎل)‪(3.5‬ﻗﻢ ﺑﺎﻹﻋﻼن ﻋﻦ اﻟﺪوال اﻟﺘﺎﻟﻴﻪ ﺣﺴﺐ اﻟﻤﻮاﺻﻔﺎت اﻟﻤﻮﺿﺤﻪ ﻓﻲ آﻞ ﻓﻘﺮﻩ ﻣﻤﺎ ﻳﺄﺗﻲ‪:‬‬
‫أ‪ .‬اﻟﺪاﻟﻪ ‪ swap‬ﻟﻬﺎ وﺳﻴﻄﻴﻦ ﻣﻦ ﻧﻮع أﻋﺪاد ﺻﺤﻴﺤﺔ وﺗﺮﺟﻊ ﻋﺪد ﺣﻘﻴﻘﻲ؟‬
‫ب‪ .‬اﻟﺪاﻟﻪ ‪ invert‬ﻟﻬﺎ وﺳﻴﻂ ﻋﺪد ﺻﺤﻴﺢ ﻃﻮﻳﻞ وﺗﺮﺟﻊ ﻋﺪد ﺻﺤﻴﺢ ﻃﻮﻳﻞ؟‬
‫ج‪ .‬اﻟﺪاﻟﻪ ‪ print‬ﻟﻴﺲ ﻟﻬﺎ وﺳﺎﺋﻂ وﻻ ﺗﺮﺟﻊ ﺷﺊ؟‬
‫اﻟﺤﻞ‪:‬‬
‫أ‪float swap(int, int) .‬‬
‫ب‪long int invert(long int) .‬‬
‫ج‪Void print() .‬‬
‫ﺗﻌﺮﻳﻒ اﻟﺪاﻟﻪ‬
‫ﺗﻌﺮﻳﻒ اﻟﺪاﻟﻪ هﻮ ﺟﺴﻢ اﻟﺪاﻟﻪ اﻟﺬي ﻳﺤﺘﻮي ﻋﻠﻰ اﻷواﻣﺮ واﻟﺘﻌﻠﻴﻤﺎت اﻟﺒﺮﻣﺠﻴﻪ اﻟﺘﻲ ﺗﻨﺠﺰ ﻣﻬﺎم اﻟﺪاﻟﻪ واﻟﺬي ﻳﻤﻜﻦ‬
‫أن ﻳﺴﺘﺨﺪم ﻓﻴﻪ أي ﻣﻦ اﻟﺘﻌﻠﻴﻤﺎت اﻟﺒﺮﻣﺠﻴﻪ اﻟﺘﻲ درﺳﻨﺎهﺎ ﺁﻧﻔًﺎ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ‪:‬‬ ‫‪.....‬‬
‫‪.....‬‬
‫)‪Returned type function name(arg1 type name,arg2 type name,…….‬‬
‫{‬
‫‪function body‬‬
‫}‬

‫‪27‬‬
 ‫ﻣﻠﺤﻮﻇﺎت‪:‬‬
‫
‬
‫إذا أﻋﻠﻦ ﻋﻦ اﻟﺪاﻟﻪ أﻧﻬﺎ ‪ void‬ﻓﺈن اﻟﺪاﻟﻪ ﻟﻦ ﺗﺮﺟﻊ ﺷﺊ وإﻧﻤﺎ ﺗﻨﺠﺰ ﻣﻬﺎﻣﻬﺎ ﻣﺒﺎﺷﺮ ًة‪.‬‬
‫
إذا آﺎﻧﺖ اﻟﺪاﻟﻪ ﺗﺮﺟﻊ ﻗﻴﻤﻪ‪ ،‬ﻟﺰم ذﻟﻚ اﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻤﻪ ‪return‬ﻣﻠﺤﻘﻪ ﺑﻘﻴﻤﺔ اﻹرﺟﺎع ﻓﻲ ﺁﺧﺮ ﺟﺴﻢ اﻟﺪاﻟﻪ‪.‬‬
‫ﻼ ﻋﻦ اﻟﺪوال اﻷﺧﺮى‪.‬‬ ‫
ﺟﺴﻢ اﻟﺪاﻟﻪ ﻳﺠﺐ أن ﻳﻜﻮن ﻣﺴﺘﻘ ً‬
‫ﻣﺜﺎل)‪ (4.5‬اآﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻳﺴﺘﺨﺪم اﻟﺪوال ﻓﻲ ﺗﺤﺪﻳﺪ اﻟﻘﻴﻤﻪ اﻷآﺒﺮ واﻟﻘﻴﻤﻪ اﻷﺻﻐﺮ ﺑﻴﻦ رﻗﻤﻴﻦ ﺻﺤﻴﺤﻴﻦ ﻣﺪﺧﻠﻴﻦ‬
‫ﺑﺤﻴﺚ ﺗﺴﻤﻰ اﻟﺪاﻟﺘﻴﻦ ‪max, min‬؟‬
‫اﻟﺤﻞ‪:‬‬
‫ﻟﻮ ﺗﻤﻌﻨﺎ ﻓﻲ ﻣﻬﺎم اﻟﺪاﻟﺘﻴﻦ ﻧﺠﺪ أن آﻞ ﻣﻨﻬﻤﺎ ﺗﺤﺘﺎج إﻟﻰ وﺳﻴﻄﻴﻦ "اﻟﻌﺪدﻳﻦ اﻟﻤﺨﻠﻴﻦ" ﻣﻦ ﻧﻮع ‪ int‬وأن آﻞ ﻣﻨﻬﻤﺎ‬
‫ﺗﺮﺟﻊ ﻋﺪدًا ﺻﺤﻴﺤًﺎ أﻳﻀًﺎ هﻮ اﻟﻘﻴﻤﻪ اﻷآﺒﺮ ﻓﻲ ‪max‬أو اﻷﺻﻐﺮ ﻓﻲ ‪ min‬وﻳﻤﻜﻦ اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ اﻟﺸﺮﻃﻲ ‪?:‬‬
‫‪Prog16‬‬ ‫ﻓﻲ ﺑﻨﻴﺔ اﻟﺪوال ﻟﺘﺤﺪﻳﺪ اﻟﻘﻴﻤﻪ اﻷآﺒﺮ أو اﻷﺻﻐﺮ‪ ،‬ﻟﺬا ﻳﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ آﺎﻵﺗﻲ‪:‬‬

‫اﻹﻋﻼن ﻋﻦ اﻟﺪوال‬

‫اﺳﺘﺪﻋﺎء اﻟﺪوال‬

‫ﺗﻌﺮﻳﻒ اﻟﺪوال‬

‫إرﺳﺎل اﻟﻤﺼﻔﻮﻓﺎت آﻮﺳﺎﺋﻂ ﻟﻠﺪاﻟﻪ‪:‬‬

‫وﺳﻴﻂ اﻟﺪاﻟﻪ آﻤﺎ ذآﺮﻧﺎ ﻳﻤﻜﻦ أن ﻳﻜﻮن ﻣﺘﻐﻴﺮ ﻣﻦ أي ﻧﻮع ﻣﻦ أﻧﻮاع اﻟﺒﻴﺎﻧﺎت اﻟﻤﻌﺮوﻓﻪ ﻓﻲ ‪ ،C++‬آﻤﺎ ﻳﻤﻜﻦ أن‬
‫ﻳﻜﻮن ﻣﺼﻔﻮﻓﻪ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﻣﻦ أي ﻧﻮع‪ ،‬ﻓﻤﺜﻼ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻟﻮ أردﻧﺎ أن ﻧﺤﺼﻞ ﻋﻠﻰ اﻟﻌﺪد اﻷآﺒﺮ‬
‫واﻷﺻﻐﺮ ﻣﻦ ﺑﻴﻦ ﻋﺸﺮة أﻋﺪاد ﻓﺈن ﻣﺼﻔﻮﻓﻪ ﻣﻦ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ﺳﻮف ﺗﺮﺳﻞ ﻟﻠﺪاﻟﻪ‪.‬‬
‫ﻣﻠﺤﻮﻇﺎت‪:‬‬
‫ﻋﻨﺪ اﻹﻋﻼن واﻟﺘﻌﺮﻳﻒ ﺑﺎﻟﺪاﻟﻪ ﻳﺴﺘﺨﺪم اﺳﻢ اﻟﻤﺼﻔﻮﻓﻪ ﻣﺘﺒﻮﻋًﺎ ﺑﺄﻗﻮاس اﻟﻤﺼﻔﻮﻓﻪ ﺧﺎﻟﻴﻪ‪.‬‬ ‫
‬
‫ﻋﻨﺪ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﻪ ﻧﻜﺘﻔﻲ ﺑﺎﺳﻢ اﻟﻤﺼﻔﻮﻓﻪ ﻓﻘﻂ‪.‬‬ ‫
‬
‫ﻳﻤﻜﻦ إﻋﺎدة آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ‪ prog 16‬ﻟﻌﺸﺮة أرﻗﺎم ﺑﺎﺳﺘﺨﺪام اﻟﻤﺼﻔﻮﻓﺎت آﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪28‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫‪Prog17‬‬

‫‪Recursive Function‬‬ ‫اﻟﺪوال اﻟﻌﻮدﻳﻪ‬

‫ﻣﻦ اﻟﻤﻼﺣﻆ أن ﻧﺪاء اﻟﺪاﻟﺔ ﻳﺘﻢ ﻣﻦ ﻧﻘﻄﻪ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﺧﺎرج اﻟﺪاﻟﻪ‪ ،‬وهﻲ ﺑﺪورهﺎ ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﻴﻤﻪ ﻟﻨﻔﺲ اﻟﻨﻘﻄﻪ‬
‫اﻟﺘﻲ ﺗﻢ ﻓﻴﻬﺎ اﻟﻨﺪاء وﻗﺪ ﻳﺘﻄﻠﺐ اﻟﺒﺮﻧﺎﻣﺞ أن ﺗﻜﺮر اﻟﺪاﻟﻪ ﻧﻔﺴﻬﺎ ﻋﺪة ﻣﺮات وﺑﺎﻟﺘﺎﻟﻲ ﺗﻘﻮم اﻟﺪاﻟﻪ ﺑﺎﺳﺘﺪﻋﺎء ﻧﻔﺴﻬﺎ وهﺬا‬
‫ﻣﺎ ﻳﻌﺮف ﺑﺎﻟﺪوال اﻟﻌﻮدﻳﻪ‪.‬‬
‫ﻣﻠﺤﻮﻇﻪ ‪:‬‬
‫ﻳﺴﺘﺨﺪم اﻷﺳﻠﻮب اﻟﻌﻮدي ﻋﻨﺪﻣﺎ ﺗﻜﻮن اﻟﺪاﻟﻪ ﻋﻼﻗﺔ ﻓﻲ ﻧﻔﺴﻬﺎ أي ﻋﻠﻰ اﻟﺼﻴﻐﻪ‪:‬د)س(=د)د)س((‬ ‫
‬
‫ﻼ د)س(=د)س(‪+‬د)س‪(1+‬‬ ‫ﻣﺜ ً‬
‫ﻣﺜﺎل)‪ (5.5‬اﻟﺼﻴﻎ اﻟﺘﺎﻟﻴﺔ ﺗﻤﺜﻞ أﺷﻜﺎ ً‬
‫ﻻ ﻟﺪوال ﻋﻮدﻳﻪ‪:‬‬
‫•‬ ‫)‪int xx(int a‬‬
‫{‬
‫…‬
‫‪….‬‬
‫)‪return xx(a‬‬
‫}‬
‫•‬ ‫;) ‪float ww( int b‬‬
‫{‬
‫‪….‬‬
‫‪….‬‬
‫;)‪return ww(b)+ww(b-1‬‬

‫‪29‬‬
‫‪Hanoi Tower‬‬ ‫ﻣﺸﻜﻠﺔ أﺑﺮاج هﺎﻧﻮي‬
‫ﻳﺴﺘﻌﻤﻞ هﺬا اﻟﻤﺜﺎل ﻟﺘﻮﺿﻴﺢ اﻟﺪوال اﻟﻌﻮدﻳﻪ واﻟﻤﺸﻜﻠﺔ ﺗﺘﻠﺨﺺ ﻓﻲ وﺟﻮد ﺛﻼﺛﺔ أﻋﻤﺪة ‪ A, B, C‬وﻳﻮﺟﺪ ﻋﺪد ﻣﻦ‬
‫اﻷﻗﺮاص ﻣﺘﺪرﺟﺔ اﻟﻘﻄﺮ ﻋﻠﻰ اﻟﻌﻤﻮد ‪A‬ﺑﺤﻴﺚ ﻳﻜﻮن اﻟﻘﺮص ذو اﻟﻘﻄﺮ اﻷآﺒﺮ أﺳﻔﻞ‪ ،‬و اﻟﺬي أﻗﻞ ﻣﻨﻪ أﻋﻠﻰ‪ ،‬آﻤﺎ‬
‫هﻮ ﻣﻮﺿﺢ ﺑﺎﻟﺸﻜﻞ‪ ،‬واﻟﻤﻄﻠﻮب ﻧﻘﻞ اﻷﻗﺮاص إﻟﻰ اﻟﻌﻤﻮد ‪ C‬ﺑﻨﻔﺲ اﻟﻮﺿﻊ ﺑﺎﻹﺳﺘﻌﺎﻧﻪ ﺑﺎﻟﻌﻤﻮد ‪ B‬ﻣﻊ ﻣﺮاﻋﺎة ﻋﺪم‬
‫وﺿﻊ ﻗﺮص ﻋﻠﻰ ﺁﺧﺮ أﻗﻞ ﻣﻨﻪ ﻓﻲ اﻟﻘﻄﺮ‪.‬‬
‫اﻟﻤﻄﻠﻮب ﺑﺮﻧﺎﻣﺞ ﻳﺤﺪد ﺧﻄﻮات اﻟﺤﻞ ﺣﺴﺐ ﻋﺪد اﻷﻗﺮاص اﻟﻤﺪﺧﻞ؟‬

‫‪A‬‬ ‫‪B‬‬ ‫‪C‬‬

‫اﻟﺤﻞ‪:‬‬
‫ﻟﻮ ﺣﺎوﻟﻨﺎ ﺣﻞ اﻟﻤﺴﺄﻟﺔ ﻓﻲ ﺣﺎﻟﺔ وﺟﻮد ﻗﺮﺻﻴﻦ ﻧﺠﺪ اﻵﺗﻲ‪:‬‬
‫ﺣﺮك ﻗﺮص ﻣﻦ ‪ A‬إﻟﻰ ‪.B‬‬
‫ﺣﺮك ﻗﺮص ﻣﻦ ‪ A‬إﻟﻰ ‪.C‬‬
‫ﺣﺮك ﻗﺮص ﻣﻦ ‪ B‬إﻟﻰ ‪.C‬‬
‫إذن ﻳﺘﻢ اﻟﺤﻞ ﻓﻲ ‪ 3‬ﺧﻄﻮات‪ ،‬أﻣﺎ إذا آﺎن ﻋﺪد اﻷﻗﺮاص ‪ 3‬ﻓﺈﻧﻨﺎ ﻧﺤﺘﺎج ﻟﻨﻘﻞ اﻟﻘﺮﺻﻴﻦ اﻟﻌﻠﻮﻳﻴﻦ ﻣﻦ ‪ A‬إﻟﻰ ‪B‬‬
‫" وهﺬا ﻳﺤﺘﺎج إﻟﻰ ‪ 3‬ﺧﻄﻮات" ﺛﻢ ﻳﻨﻘﻞ اﻟﻘﺮص اﻷﺧﻴﺮ ﻣﻦ ‪ A‬إﻟﻰ ‪ B‬ﻓﻲ ﺧﻄﻮﻩ واﺣﺪﻩ‪ ،‬ﺛﻢ ﻳﻨﻘﻞ اﻟﻘﺮﺻﻴﻦ‬
‫اﻟﻌﻠﻮﻳﻴﻦ ﻣﻦ ‪ B‬إﻟﻰ ‪ “ C‬وهﺬا ﻳﺤﺘﺎج إﻟﻰ ‪ 3‬ﺧﻄﻮات"‪ ،‬إذن ﻳﺘﻢ اﻟﺤﻞ ﻓﻲ ‪ 7‬ﺧﻄﻮات‪ ،‬ﻳﻤﻜﻦ ﺗﻠﺨﻴﺺ ﺧﻄﻮات‬
‫اﻟﺤﻞ آﺎﻵﺗﻲ‪:‬‬
‫أﻧﻘﻞ ‪ n-1‬ﻗﺮص ﻣﻦ ‪ A‬إﻟﻰ ‪B‬‬
‫اﻧﻘﻞ اﻟﻘﺮص اﻷﺧﻴﺮ ﻣﻦ ‪A‬إﻟﻰ ‪C‬‬
‫أﻧﻘﻞ ‪ n-1‬ﻗﺮص ﻣﻦ ‪ B‬إﻟﻰ ‪C‬‬
‫ﻧﺠﺪ أن ﻓﻲ اﻟﺨﻄﻮﺗﻴﻦ اﻷوﻟﻰ واﻟﺜﺎﻟﺜﺔ ﺗﻄﺒﻴﻖ ﻟﻤﺒﺪأ اﻟﻌﻮدﻳﻪ ﺣﻴﺚ ﻳﺘﻢ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﻪ ﻣﻦ داﺧﻠﻬﺎ‪.‬‬
‫ﻧﺠﺪ أن ﻋﺪد ﺧﻄﻮات اﻟﺤﻞ ﻳﺴﺎوي ﻋﺪد ﺧﻄﻮات اﻟﺤﻞ ﻟـ ‪ n-1‬ﻗﺮص ﻣﻀﺮوﺑًﺎ ﻓﻲ اﺛﻨﻴﻦ زاﺋﺪًا واﺣﺪ أي أن‬
‫د)ن(=‪*2‬د)ن‪1+(1-‬‬
‫ﻼ إذا ن=‪ 5‬ﻓﺈن‬
‫ﻣﺜ ً‬
‫د)‪*2=(5‬د)‪ 1+(4‬وهﺬا ﻻﻳﻤﻜﻦ اﻟﺤﺼﻮل ﻋﻠﻴﻪ إﻻ إذا ﺣﺴﺒﻨﺎ د)‪(4‬‬
‫د)‪*2=(4‬د)‪1+(3‬‬
‫د)‪*2=(3‬د)‪1+(2‬‬
‫د)‪*2=(2‬د)‪1+(1‬‬
‫د)‪1=(1‬‬
‫إذن د)‪ 31=(5‬إذن هﺬﻩ اﻟﺪاﻟﻪ ﺗﺤﺘﺎج إﻟﻰ ﺗﻄﺒﻴﻖ ﻟﻤﺒﺪأ اﻟﻌﻮدﻳﻪ‪ ،‬اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﻳﻮﺿﺢ ﺣﻞ هﺬﻩ اﻟﻤﺸﻜﻠﺔ‪:‬‬

‫‪30‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫‪Prog18‬‬

‫ﻣﺜﺎل)‪(6.5‬اآﺘﺐ ﺑﺮﻧﺎﻣﺤًﺎ ﻳﺤﺴﺐ اﻟﺤﺪ ‪ n‬ﻣﻦ ﺳﻠﺴﻠﺔ ﻓﺎﻳﺒﻮﻧﺎﺗﺸﻲ ‪ Fibonacci Series‬اﻟﺘﻲ ﺗﻤﺜﻞ اﻷرﻗﺎم‬
‫…………‪0,1,1,2,3,5,8,13,21,‬‬
‫ﺣﻴﺚ اﻟﺤﺪ اﻟﻌﺎم ح)ن( ﻳﺤﺴﺐ ﺑﺎﻟﻌﻼﻗﺔ‪:‬‬
‫ح)ن(= ح)ن‪ +(1-‬ح)ن‪ (2+‬ﻣﻊ اﻟﻌﻠﻢ أن ح)‪،0=(0‬ح)‪1=(1‬‬
‫اﻟﺤﻞ‪:‬اﻟﻨﺴﺒﺔ ﺑﻴﻦ أي ﺣﺪ واﻟﺬي ﻳﺴﺒﻘﻪ ﺗﺴﻤﻰ ﺑﺎﻟﻨﺴﺒﻪ اﻟﺬهﺒﻴﻪ ‪ golden ratio‬وﺗﺴﺘﺨﺪم ﻓﻲ اﻟﺘﺼﻤﻴﻢ اﻟﻤﻌﻤﺎري‬
‫آﻨﺴﺒﻪ ﺑﻴﻦ اﻟﻄﻮل واﻟﻌﺮض ﻟﻠﻨﻮاﻓﺬ واﻟﻐﺮف‪ ،‬ﻣﻦ ﺻﻴﻐﺔ اﻟﺤﺪ اﻟﻌﺎم ﻟﻬﺬﻩ اﻟﺴﻠﺴﻠﻪ ﻧﺠﺪ أن أي ﺣﺪ ﻣﻦ ﺣﺪودهﺎ هﻮ‬
‫داﻟﻪ ﻓﻲ اﻟﺤﺪﻳﻦ اﻟﺴﺎﺑﻘﻴﻦ ﻟﻪ "ﺣﺎﺻﻞ ﺟﻤﻌﻬﻤﺎ" أي أن اﻟﻌﻼﻗﻪ داﻟﻪ ﻓﻲ ﻧﻔﺴﻬﺎ‪ ،‬ﻟﺬا ﻳﺴﺘﺤﺴﻦ أن ﺗﻜﻮن اﻟﺪاﻟﻪ‬
‫‪ Fibonacci‬داﻟﻪ ﻋﻮدﻳﻪ‪ ،‬ﻳﺒﺪأ اﻟﺒﺮﻧﺎﻣﺞ ﺑﻄﻠﺐ إدﺧﺎل ﺗﺮﺗﻴﺐ اﻟﺤﺪ اﻟﻤﺮاد إﻳﺠﺎد ﻗﻴﻤﺘﻪ وﻓﻲ ﺣﺎل إدﺧﺎل ﻗﻴﻤﻪ ‪0‬أو‪1‬‬
‫ﻓﺈن اﻟﺪاﻟﻪ ﺗﺮﺟﻊ ‪.n‬‬
‫‪Prog19‬‬

‫‪31‬‬
 ‫‪Function Overloading‬‬ ‫ﻓﺮط ﺗﺤﻤﻴﻞ اﻟﺪوال‬
‫اﻟﻤﻘﺼﻮد ﺑﺬﻟﻚ ﺗﻌﺪد اﻟﺪوال اﻟﺸﻜﻠﻲ ﺣﻴﺚ ﻳﻤﻜﻦ أن ﺗﻌﻄﻲ أآﺜﺮ ﻣﻦ داﻟﻪ اﻻﺳﻢ ﻧﻔﺴﻪ ﻣﻊ ﺗﻐﻴﻴﺮ ﻓﻲ ﻋﺪد اﻟﻮﺳﺎﺋﻂ أو‬
‫ﻧﻮﻋﻬﺎ وﻳﺮﺳﻞ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﻪ ﺑﻌﺪ ﻣﻄﺎﺑﻘﺔ ﻋﺪد وﻧﻮع اﻟﻮﺳﺎﺋﻂ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻳﻤﺜﻞ ﻓﺮط ﺗﺤﻤﻴﻞ اﻟﺪاﻟﻪ‪ dd‬ﺣﻴﺚ ﺗﻈﻬﺮ‬
‫ﻣﺮﻩ ﺑﻮﺳﻴﻂ واﺣﺪ ﻣﻦ ﻧﻮع ‪ ،int‬وﻣﺮﻩ ﺑﻮﺳﻴﻂ ﻣﻦ ﻧﻮع ‪ ، double‬وﻣﺮﻩ ﺑﺪون وﺳﻴﻂ‪:‬‬
‫‪Prog20‬‬

‫‪Inline Function‬‬ ‫اﻟﺪوال اﻟﻤﺒﺎﺷﺮة‬

‫ﻋﻨﺪ ﺗﻌﺮﻳﻒ داﻟﺔ ﻣﺎ ﺗﻨﺸﺄ ﻧﺴﺨﻪ ﻣﻦ ﺗﻌﻠﻴﻤﺎت هﺬﻩ اﻟﺪاﻟﻪ ﻓﻲ اﻟﺬاآﺮة وﻋﻨﺪ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﻪ ﻳﻨﺘﻘﻞ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ إﻟﻰ‬
‫هﺬﻩ اﻟﺘﻌﻠﻴﻤﺎت ﺛﻢ ﻳﻌﻮد إﻟﻰ أول ﺳﻄﺮ ﺑﻌﺪ اﻻﺳﺘﺪﻋﺎء‪ ،‬ﻓﺈذا اﺳﺘﺪﻋﻴﺖ داﻟﻪ ﻋﺪد ﻣﻦ اﻟﻤﺮات ﻓﺈن وﻗﺖ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﺳﻴﻬﺪر ﺑﺴﺒﺐ اﻟﻘﻔﺰ ﻣﻦ وإﻟﻰ اﻟﺪاﻟﻪ‪ ،‬وﻟﻠﺘﻘﻠﻴﻞ ﻣﻦ هﺬا اﻷﺛﺮ ﻳﻌﻠﻦ ﻋﻦ اﻟﺪاﻟﻪ أﻧﻬﺎ ﺧﻄﻴﻪ ﻋﻦ ﻃﺮﻳﻖ اﻟﻜﻠﻤﺔ‬
‫اﻟﻤﺤﺠﻮزة‪ inline‬ﻣﻤﻞ ﻳﺆدي إﻟﻰ اﻟﺘﺨﻠﺺ ﻣﻦ اﻟﻘﻔﺰ ﺑﺄن ﺗﻨﺸﺄ ﻧﺴﺨﻪ ﻣﻦ اﻟﺪاﻟﻪ ‪ inline‬إﻟﻰ اﻟﺪاﻟﻪ اﻟﻤﺴﺘﺪﻋﻴﺔ‪.‬‬
‫ﻣﻠﺤﻮﻇﻪ‪:‬‬
‫ﻟﻴﺲ ﻣﻦ اﻟﻤﻨﺎﺳﺐ اﺳﺘﺨﺪام ‪ inline‬إذا آﺎن ﺣﺠﻤﻬﺎ آﺒﻴﺮا وﻋﺪد ﻣﺮات اﻻﺳﺘﺪﻋﺎء ﻟﻠﺪاﻟﻪ آﺜﻴﺮ ﻷن ذﻟﻚ ﺳﻴﺆدي‬ ‫
‬
‫إﻟﻰ ﻧﺴﺦ اﻟﺪاﻟﻪ‪ inline‬ﻋﺪة ﻣﺮات ﻣﻤﺎ ﻳﺆدي ﻟﺘﻀﺨﻢ اﻟﻤﺴﺎﺣﺔ اﻟﻤﺤﺠﻮزة ﻟﻠﺒﺮﻧﺎﻣﺞ وﺑﺎﻟﺘﺎﻟﻲ ﺑﻂء ﻓﻲ أداء‬
‫اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫‪Global & Local Variables‬‬ ‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﺤﻠﻴﺔ واﻟﻤﺘﻐﻴﺮات اﻟﺸﺎﻣﻠﺔ‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﻌﺮﻓﻪ ﺧﺎرج ﻧﻄﺎق أي داﻟﻪ ﺗﺴﻤﻰ ﻣﺘﻐﻴﺮات ﺷﺎﻣﻠﻪ و ﺗﻜﻮن ﻣﺘﺎﺣﻪ ﻷي داﻟﻪ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﺑﻤﺎ ﻓﻲ ذﻟﻚ‬
‫اﻟﺪاﻟﻪ اﻟﺮﺋﻴﺴﻴﻪ‪ ،‬أﻣﺎ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻌﺮﻓﻪ داﺧﻞ ﻧﻄﺎق أي داﻟﻪ ﻓﻬﻲ ﻣﺘﻐﻴﺮات ﻣﺤﻠﻴﻪ ﻻ ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ إﻻ ﻓﻲ ﻧﻄﺎق‬
‫ﻼ ﻳﻤﻜﻦ ﺗﻨﺎوﻟﻪ ﻣﻦ أي داﻟﻪ‪ ،‬ﻏﻴﺮ أن ‪y‬‬
‫اﻟﺪاﻟﻪ ﻧﻔﺴﻬﺎ‪ .‬اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﻳﻮﺿﺢ هﺬا اﻟﻤﻔﻬﻮم ﺣﻴﺚ ﻳﻤﺜﻞ ‪ a‬ﻣﺘﻐﻴﺮًا ﺷﺎﻣ ً‬
‫ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ ﻣﻌﺮف ﻟﻠﺪاﻟﻪ اﻟﺮﺋﻴﺴﻴﻪ ﻓﻘﻂ‪.‬‬
‫‪Prog21‬‬

‫‪32‬‬
 ‫اﻟﺒﺮﻣﺠﺔ‬
‫إﻟﻰ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﺪﺧﻞ إﻟﻰ‬
‫ﻣﺪﺧﻞ‬
‫إﻧﺸﺎء ﻣﻠﻔﺎت اﻟﺘﺮوﻳﺴﻪ اﻟﺨﺎﺻﻪ ﺑﺎﻟﻤﺒﺮﻣﺞ‬
‫آﻤﺎ ﻣﺮ ﻣﻌﻨﺎ ﺳﺎﺑﻘ ًﺎ وﺟﻮد ﻋﺪد ﻣﻦ ﻣﻠﻔﺎت اﻟﺘﺮوﻳﺴﻪ‪ Header Files‬ﻓﻲ ﻣﻜﺘﺒﺔ اﻟﻠﻐﺔ اﻟﻤﻌﻴﺎرﻳﻪ وﺑﺈﻣﻜﺎن‬
‫اﻟﻤﺒﺮﻣﺞ اﻧﺸﺎء ﻣﻠﻔﺎت ﺧﺎﺻﻪ ﺑﻪ ﻋﻦ ﻃﺮﻳﻖ ﺣﻔﻆ اﻟﻤﻠﻒ ﺑﺎﻹﻣﺘﺪاد‪ h‬وﻳﺘﻢ ﺿﻢ اﻟﻤﻠﻒ ﻷي ﺑﺮﻧﺎﻣﺞ ﻋﻦ‬
‫ﻃﺮﻳﻖ اﻟﺼﻴﻐﻪ"‪#include”file_name‬‬
‫ﺗﻤﺮﻳﻦ)‪(5‬‬
‫‪ .1‬ﻣﺎ هﻮ ﻧﺎﺗﺞ اﻟﺘﻌﻠﻴﻤﺎت اﻟﺘﺎﻟﻴﻪ‪:‬‬
‫أ‪cout<<strlen("I love C++ programming") .‬‬
‫ب‪cout<<strrev("I love C++ programming") .‬‬
‫ج‪strcat("death to ","israil") .‬‬
‫د‪pow(4,2) .‬‬
‫ﻩ‪sqrt(.36) .‬‬
‫و‪ceil(2.05) .‬‬
‫ز‪floor(3.99) .‬‬
‫ح‪ceil(-8.2) .‬‬
‫ط‪floor(-.99) .‬‬
‫‪ .2‬أﻋﻠﻦ ﻋﻦ اﻟﺪوال اﻟﺘﺎﻟﻴﻪ‪:‬‬
‫أ‪ .‬اﻟﺪاﻟﻪ ‪ aa‬ﻟﻬﺎ وﺳﻴﻂ واﺣﺪ ﺣﺮﻓﻲ وﻻ ﺗﺮﺟﻊ ﺷﺊ‪.‬‬
‫ب‪ .‬اﻟﺪاﻟﻪ‪ bb‬ﻟﻬﺎ وﺳﻴﻂ ﻋﺪد ﺣﻘﻴﻘﻲ وﺗﺮﺟﻊ ﻋﺪد ﺻﺤﻴﺢ‪.‬‬
‫‪ .3‬اﺳﺘﺨﺪم اﻟﺪوال اﻟﻌﻮدﻳﻪ ﻟﺤﺴﺎب ﻣﻀﺮوب اﻟﻌﺪد؟‬

‫‪33‬‬