Vous êtes sur la page 1sur 109

‫ﺻﺪﻗﺔ ﺟﺎرﻳﻪ ‪..

‬‬

‫اﻟﻰ روح أﺑﻲ ‪..‬‬

‫ﻓﻲ ﻋﻠﻴﻴﻦ‪...‬‬
‫اﻟﻤﻘﺪﻣﻪ‬

‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﻴﻢ واﻟﺼﻼة واﻟ ﺴﻼم ﻋﻠ ﻰ ﺳ ﻴﺪﻧﺎ ﻣﺤﻤ ﺪ أﺷ ﺮف اﻟﺨﻠ ﻖ وﺧ ﺎﺗﻢ اﻟﻨﺒ ﻴﻦ‬
‫وﻋﻠﻰ أل ﺑﻴﺘﻪ وﺻﺤﺒﻪ اﻟﻄﻴﺒﻴﻦ اﻟﻄﺎهﺮﻳﻦ‪.‬‬

‫أﻣﺎ ﺑﻌﺪ ‪ ,‬ﻓﻬﺎ أﻧﺬا أﺿﻊ ﺑﻴﻦ ﻳﺪي اﻟﻘﺎريء اﻟﻌﺮﺑﻲ ﻧﺘﺎج ﺟﻬﺪ ﺑ ﻀﻌﺔ أﺷ ﻬﺮ ﻣ ﻦ اﻟﻌﻤ ﻞ اﻟﺠ ﺎد‬
‫واﻟﺪؤوب ﻟﻴﻜﻮن هﺬا اﻟﻜﺘﺎب ﺷﺒﻪ آﺎﻣﻞ ) ﻷن اﻟﻜﻤﺎل ﷲ وﺣﺪﻩ ( ﻟﻤﺒ ﺎديء وأﺳﺎﺳ ﻴﺎت اﻟﺒﺮﻣﺠ ﻪ ﺑﻠﻐ ﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪.‬‬

‫ﻟﻘ ﺪ ﻃ ﻮرت ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣ ﻦ ﻗﺒ ﻞ ) ‪ ( Niklaus Wirth‬ﻓ ﻲ‬


‫) ‪ ( Eidgenossische Technische Hochschule in Zurich‬وه ﻲ ﻣ ﺸﺘﻘﻪ ﻣ ﻦ ﻟﻐ ﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ) ‪ ( Algol 60‬وﻟﻜﻦ ﺑﺄﻣﻜﺎﻧﻴﺎت أﻓﻀﻞ ﻣ ﻊ ﺳ ﻬﻮﻟﻪ ﺑﺎﻷﺳ ﺘﺨﺪام ‪ ..‬وﺗ ﺴﺘﺨﺪم ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ‬
‫ﺑﺎﺳﻜﺎل اﻷن ﺑﺸﻜﻞ واﺳﻊ آﻠﻐﺔ ﺑﺮﻣﺠﻪ ﻣﻔﻴﺪﻩ ﻣﻤﻜﻦ ﺗﻨﻔﻴﺬهﺎ ﺑﻜﻔﺎءﻩ وهﻲ أداة ﺗﻌﻠﻴﻤﻴﻪ ﻣﻤﺘﺎزﻩ ‪.‬‬
‫ﻣﻦ اﻟﻤﻬﻢ أن أذآ ﺮ ﺑﻘﻠ ﺔ اﻟﻤ ﺼﺎدر اﻟﻌﺮﺑﻴ ﻪ ﻓ ﻲ اﻟﻤﺠ ﺎﻻت اﻟﻌﻠﻤﻴ ﻪ ﺑ ﺸﻜﻞ ﻋ ﺎم واﻟﺘ ﻲ ﺗ ﺸﻜﻞ‬
‫ﻋﺎﺋﻘﺎ أﻣﺎم اﻟﻤﻌﺮﻓﻪ ﻓﻲ اﻟﻮﻃﻦ اﻟﻌﺮﺑﻲ ‪ ,‬ﻟﺬا آﺎن هﺬا اﻟﻜﺘﺎب أﺳﻬﺎﻣﻪ ﻣﺘﻮاﺿﻌﻪ ﻋﺴﻰ أن ﻳﻜﻮن ﻣﻔﻴﺪا‬
‫ﻟﻠﺮاﻏﺒﻴﻦ ﺑﺘﻌﻠﻢ اﻟﺒﺮﻣﺠﻪ وﺧﺼﻮﺻﺎ اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ ,‬وﺗﻮﺧﻴﺖ اﻷﺟﺘﻬﺎد ﻓ ﻲ ﺗﺮﺟﻤ ﺔ‬
‫اﻟﻤ ﺼﻄﻠﺤﺎت اﻷﺟﻨﺒﻴ ﻪ اﻟ ﻰ اﻟﻠﻐ ﻪ اﻟﻌﺮﺑﻴ ﻪ ﻧﻈ ﺮا ﻟﻌ ﺪم وﺟ ﻮد ﺗﺮﺟﻤ ﻪ ﻋﺮﺑﻴ ﻪ ﻣﻌﺘﻤ ﺪﻩ ﻟﻤ ﺼﻄﻠﺤﺎت‬
‫اﻟﺒﺮﻣﺠﻪ ‪ ,‬وﺑﻤ ﺎ ﻳﺘﻨﺎﺳ ﺐ وﺳ ﻬﻮﻟﺔ ﻓﻬﻤﻬ ﺎ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻘ ﺎريء وﻗﺮﺑﻬ ﺎ ﻣ ﻦ اﻟﻤﻔﻬ ﻮم اﻟﺤﻘﻴﻘ ﻲ ﻟﻬ ﺎ أﺧ ﺬا‬
‫ﺑﻨﻈﺮ اﻷﻋﺘﺒﺎر ذآﺮ اﻟﻤﺼﻄﻠﺢ اﻷﺟﻨﺒﻲ ﻣ ﻊ ﻣ ﺎ ﻳﻘﺎﺑﻠ ﻪ ﻣ ﻦ ﺗﺮﺟﻤ ﻪ ﻋﻨ ﺪ أول ورود ﻟ ﻪ ﻓ ﻲ اﻟﻜﺘ ﺎب ‪..‬‬
‫وﺑﺎﻟﺘﺄآﻴﺪ ﻓﺄن هﺬا اﻟﻌﻤﻞ ﻻﻳﻌﺪ ﻣﺮﺟﻌ ﺎ ﺑﺎﻟﻠﻐ ﻪ اﻟﻌﺮﺑﻴ ﻪ ﻟﻤ ﺼﻄﻠﺤﺎت اﻟﺒﺮﻣﺠ ﻪ ﻷن هﻨ ﺎك ﻣ ﻦ ﻳﻜ ﺮس‬
‫ﺟﻬﺪﻩ ووﻗﺘﻪ ﻟﻠﻌﻤﻞ ﻓﻲ هﺬا اﻟﻤﺠﺎل ‪.‬‬

‫ﻳﺒ ﺪأ اﻟﻜﺘ ﺎب ﺑ ﺸﺮح اﻟﻤﻔ ﺎهﻴﻢ اﻷﺳﺎﺳ ﻴﻪ اﻟﻌﺎﻣ ﻪ ﻟﻠﺒﺮﻣﺠ ﻪ واﻟﺘ ﻲ ﺗ ﺴﺘﺨﺪم ﻣ ﻊ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ‬
‫ﺑﺎﺳ ﻜﺎل ‪ ,‬وه ﻲ ﺑ ﺸﻜﻞ ﻋ ﺎم ﻣ ﺸﺘﺮآﻪ ﺑ ﻴﻦ اﻟﻜﺜﻴ ﺮ ﻣ ﻦ ﻟﻐ ﺎت اﻟﺒﺮﻣﺠ ﻪ ‪ ,‬أﻣ ﺎ اﻟﻔ ﺼﻞ اﻟﺜ ﺎﻧﻲ ﻓﻴﺘ ﻀﻤﻦ‬
‫ﺷﺮﺣﺎ واﻓﻴﺎ ﻷواﻣﺮ اﻷدﺧﺎل واﻷﺧﺮاج وآﻴﻔﻴﺔ أﺳﺘﺨﺪاﻣﻬﺎ ﺑﺸﻜﻞ آﻔﻮء ‪ ,‬ﺑﻴﻨﻤﺎ آ ﺮس اﻟﻔ ﺼﻞ اﻟﺜﺎﻟ ﺚ‬
‫ﻟﻌﺒﺎرات اﻟﻘﺮار واﻟﺘﻜﺮار واﻟﺘ ﻲ ﺗﻌ ﺪ أﺣ ﺪى اﻟﺮآ ﺎﺋﺰ اﻟﻤﻬﻤ ﻪ ﻓ ﻲ اﻟﺒﺮﻣﺠ ﻪ ‪ ,‬وﺗﻨ ﺎول اﻟﻔ ﺼﻞ اﻟﺮاﺑ ﻊ‬
‫اﻟﻤ ﺼﻔﻮﻓﺎت ﺑﻨﻮﻋﻴﻬ ﺎ اﻷﺣﺎدﻳ ﻪ واﻟﺜﻨﺎﺋﻴ ﻪ ‪ ,‬ﺑﻴﻨﻤ ﺎ ﺗﻄ ﺮق اﻟﻔ ﺼﻞ اﻟﺨ ﺎﻣﺲ اﻟ ﻰ اﻷﺟ ﺮاءات واﻟ ﺪوال‬
‫وآﻴﻔﻴﺔ أﺳﺘﺨﺪاﻣﻬﺎ ‪ ,‬اﻟﻔﺼﻞ اﻟﺴﺎدس ﻳﺸﺮح ﺑﺘﻮﺳﻊ ﻧﺴﺒﻲ اﻟﺪوال اﻟﻤﺴﺘﺨﺪﻣﻪ ﻣﻊ اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ‪,‬‬
‫وأﺧﻴﺮا ﺗﻢ اﻟﺨﺘﺎم ﻣﻊ اﻷﻧﻮاع واﻟﻤﺠﻤﻮﻋﺎت ‪.‬‬

‫ﻟﻘﺪ ﺣﺎوﻟﺖ ﺟﺎهﺪا أن أﺑﺴﻂ اﻟﻤﻮاﺿﻴﻊ اﻟﺘﻲ ﺗﻄﺮﻗﺖ ﻟﻬﺎ ﺑﺸﻜﻞ آﺒﻴﺮ وأﺳﻬﺒﺖ ﺑﻌﺾ اﻟ ﺸﻲء‬
‫ﻓ ﻲ ﺷ ﺮﺣﻬﺎ ﻷﺳ ﻬﻞ ﻋﻠ ﻰ اﻟﻘ ﺎريء اﻟﺘﻮاﺻ ﻞ ﻣ ﻊ ﻣﻮاﺿ ﻴﻊ اﻟﻜﺘ ﺎب وه ﻲ ﺟﻤﻴﻌ ﺎ ﻧﺘ ﺎج ﺧﺒﺮﺗ ﻲ ﻓ ﻲ‬
‫ﺗﺪرﻳﺲ هﺬﻩ اﻟﻤﺎدﻩ ﻟﻌﺪد ﻣﻦ اﻟﺴﻨﻮات ‪ ,‬وأرى أن هﺬا اﻟﻜﺘﺎب ﻣﻤﻜﻦ أن ﻳﻜﻮن ﻣﺮﺟﻌﺎ ﺟﻴﺪا ﻟﻠﻤﺒﺘ ﺪﺋﻴﻦ‬
‫ﻓﻲ اﻟﺒﺮﻣﺠﻪ وآﺬﻟﻚ ﻷﺻﺤﺎب اﻟﺨﺒﺮﻩ ‪ ,‬وهﻮ ﻣﻤﻜﻦ أن ﻳﻮﻓﺮ اﻷﺳﺎس اﻟﺠﻴ ﺪ ﻟﻤ ﻦ ﻳﺮﻏ ﺐ ﺗﻌﻠ ﻢ ﻟﻐ ﺎت‬
‫ﺑﺮﻣﺠﻪ أﺧﺮى ‪.‬‬

‫وﻓﻲ آﻞ اﻟﻔﺼﻮل ﺗﻢ اﻷﺳﺘﻌﺎﻧﻪ ﺑﺄﻣﺜﻠﻪ ﺗﻮﺿﻴﺤﻴﻪ وآﺎﻧﺖ اﻟﻔﻘﺮﻩ اﻷﺧﻴﺮﻩ ﻟﻜﻞ ﻓ ﺼﻞ ﺗﺤﺘ ﻮي‬
‫ﻋﻠ ﻰ ﻋ ﺪد ﻻﺑ ﺄس ﺑ ﻪ ﻣ ﻦ اﻷﻣﺜﻠ ﻪ اﻟﻤﺤﻠﻮﻟ ﻪ واﻟﺘ ﻲ ﺗ ﻢ أﻧﺘﻘﺎﺋﻬ ﺎ ﻟﺘﻮﺿ ﻴﺢ ﺣ ﺎﻻت ﻣﺨﺘﻠﻔ ﻪ ﻣ ﻦ ﺗﻘﻨﻴ ﺎت‬
‫اﻟﺒﺮﻣﺠﻪ أﺿﺎﻓﻪ اﻟﻰ اﻟﺘﻨﻮع ﺑﻄﺮق اﻟﺤﻞ ﻟﻬﺬﻩ اﻷﻣﺜﻠﻪ واﻷﻣﺜﻠﻪ اﻷﺧﺮى ﺿﻤﻦ اﻟﻔﻘﺮات اﻷﺧ ﺮى ﻣﻤ ﺎ‬
‫ﻳﺴﺎﻋﺪ اﻟﻘﺎريء ﻋﻠﻰ اﻷﻟﻤﺎم ﺑﻄﺮق ﺣﻞ ﻣﺨﺘﻠﻔﻪ ‪ ,‬وﺑﺎﻟﺮﻏﻢ ﻣﻦ ﻗ ﺼﺮ ه ﺬﻩ اﻟﺒ ﺮاﻣﺞ وﺑ ﺴﺎﻃﺘﻬﺎ ﻟﻜﻨﻬ ﺎ‬
‫آﺎﻣﻠ ﻪ وﻟﻴ ﺴﺖ أﺟ ﺰاء ‪ ,‬وأود أن أاآ ﺪ أن اﻟﻜﺜﻴ ﺮ ﻣ ﻦ ﺣﻠ ﻮل اﻷﻣﺜﻠ ﻪ ﻻ ﺗﻤﺜ ﻞ اﻟﺤ ﻞ اﻟﻨﻤ ﻮذﺟﻲ وذﻟ ﻚ‬
‫ﻷﻧﻲ رآﺰت ﻋﻠﻰ ﺗﻮﺿﻴﺢ ﺗﻘﻨﻴﺎت وﻃﺮق ﺣﻠﻮل ﻣﺨﺘﻠﻔﻪ ﻟﺰﻳ ﺎدة اﻟﻔﺎﺋ ﺪﻩ ‪ ,‬وﺑﺄﻣﻜ ﺎن اﻟﻘ ﺎريء أن ﻳﻔﻬ ﻢ‬
‫ه ﺬﻩ اﻟﺒ ﺮاﻣﺞ ﺑ ﺸﻜﻞ ﺟﻴ ﺪ ﻣ ﻦ ﺧ ﻼل ﻗﺮاﺋﺘﻬ ﺎ ‪ ,‬وﻟﻜ ﻦ ﻧﻨ ﺼﺢ ﺑ ﺄن ﺗﻄﺒ ﻖ ه ﺬﻩ اﻟﺒ ﺮاﻣﺞ وﺗﻨﻔ ﺬ ﻋﻠ ﻰ‬
‫اﻟﺤﺎﺳﺐ ﻟﺰﻳﺎدة أدراآﻬﺎ وﻓﻬﻤﻬﺎ ‪.‬‬
‫أرﺟﻮ ﻣﻦ اﷲ أن ﻳﺘﻘﺒﻞ ﻣﻨﻲ هﺬا اﻟﻌﻤﻞ ﺧﺎﻟﺼﺎ ﻟﻮﺟﻬﻪ ‪.‬‬
‫وأﻧﻲ ﻣﺴﺘﻌﺪ ﻟﺴﻤﺎع أراﺋﻜﻢ وﻣﻘﺘﺮﺣﺎﺗﻜﻢ واﻷﺟﺎﺑﻪ ﻋﻦ أﺳﺌﻠﺘﻜﻢ ﻣﻦ ﺧﻼل اﻟﺒﺮﻳﺪ اﻷﻟﻜﺘﺮوﻧﻲ أدﻧﺎﻩ ‪:‬‬
‫‪Comp_dep_educ@yahoo.com‬‬

‫د‪ .‬ﻧﻀﺎل اﻟﻌﺒﺎدي‬


‫ﺑﻐﺪاد ‪2006 /‬‬
‫اﻟﻤﺤﺘﻮﻳﺎت‬

‫اﻟﻔﺼﻞ اﻷول – ﻣﺪﺧﻞ اﻟﻰ اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫‪1‬‬ ‫‪ 1.1‬اﻟﻤﻘﺪﻣﻪ ‪..........................................................................‬‬


‫‪1‬‬ ‫‪ 1.2‬ﺑﻌﺾ اﻟﺼﻔﺎت اﻟﻌﺎﻣﻪ ﻟﻠﺒﺮﻧﺎﻣﺞ ‪.............................................‬‬
‫‪2‬‬ ‫‪ 1.3‬اﻟﻤﻌﺮﻓﺎت ‪.......................................................................‬‬
‫‪3‬‬ ‫‪ 1.4‬اﻟﺜﻮاﺑﺖ ‪.........................................................................‬‬
‫‪4‬‬ ‫‪ 1.5‬اﻟﺒﻴﺎﻧﺎت ‪.........................................................................‬‬
‫‪4‬‬ ‫‪ 1.5.1‬اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ‪....................................................‬‬
‫‪5‬‬ ‫‪ 1.5.2‬اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ ‪.......................................................‬‬
‫‪7‬‬ ‫‪ 1.5.3‬اﻟﺮﻣﻮز ‪.................................................................‬‬
‫‪9‬‬ ‫‪ 1.5.4‬اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪.....................................................‬‬
‫‪9‬‬ ‫‪ 1.6‬اﻟﺘﻌﺎﺑﻴﺮ اﻟﻤﻨﻄﻘﻴﻪ ‪..............................................................‬‬
‫‪9‬‬ ‫‪ 1.6.1‬اﻟﻌﻤﻠﻴﺎت اﻟﻤﻨﻄﻘﻴﻪ ‪.....................................................‬‬
‫‪13‬‬ ‫‪ 1.7‬ﺗﻮﻟﻴﺪ اﻷرﻗﺎم اﻟﻌﺸﻮاﺋﻲ ‪.......................................................‬‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ – أواﻣﺮ اﻷدﺧﺎل واﻷﺧﺮاج‬

‫‪15‬‬ ‫اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬ ‫‪2.1‬‬


‫‪15‬‬ ‫هﻴﻜﻠﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪...............................................................‬‬ ‫‪2.2‬‬
‫‪16‬‬ ‫اﻟﻤﺨﺮﺟﺎت واﻟﻤﺪﺧﻼت ‪......................................................‬‬ ‫‪2.3‬‬
‫‪24‬‬ ‫ﻣﺘﻐﻴﺮات اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪.................................................‬‬ ‫‪2.4‬‬
‫‪26‬‬ ‫أﻧﻮاع اﻷﺧﻄﺎء اﻟﺘﻲ ﺗﺤﺪث ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪..................................‬‬ ‫‪2.5‬‬
‫‪30‬‬ ‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪..................................................................‬‬ ‫‪2.6‬‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ – أﻳﻌﺎزات اﻟﻘﺮار واﻟﺘﻜﺮار‬

‫‪32‬‬ ‫‪ 3.1‬اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬


‫‪32‬‬ ‫‪ 3.2‬ﻋﺒﺎرة أذا ‪.......................................................................‬‬
‫‪35‬‬ ‫‪ 3.3‬أذا اﻟﻤﺮآﺒﻪ ‪....................................................................‬‬
‫‪36‬‬ ‫‪ 3.4‬ﻋﺒﺎرة اﻟﺘﻜﺮار ‪......................................... Repeat – Until‬‬
‫‪37‬‬ ‫‪ 3.5‬ﻋﺒﺎرة اﻟﺘﻜﺮار ‪............................................ While – Do‬‬
‫‪40‬‬ ‫‪ 3.6‬ﻋﺒﺎرة اﻟﺘﻜﺮار ‪......................................................... For‬‬
‫‪41‬‬ ‫‪ 3.7‬أﺳﺘﺨﺪام ‪ For‬اﻟﻤﺘﺪاﺧﻠﻪ ‪....................................................‬‬
‫‪43‬‬ ‫‪ 3.8‬ﻋﺒﺎرة أﺧﺘﻴﺎر اﻟﺤﺎﻟﻪ ‪................................................. Case‬‬
‫‪47‬‬ ‫‪ 3.9‬ﺟﻤﻠﺔ ‪..................................................................... IN‬‬
‫‪48‬‬ ‫‪ 3.10‬أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪.................................................................‬‬
‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ – اﻟﻤﺼﻔﻮﻓﺎت‬

‫‪53‬‬ ‫‪ 4.1‬اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬


‫‪53‬‬ ‫‪ 4.2‬اﻟﻤﺼﻔﻮﻓﺎت ‪...................................................................‬‬
‫‪53‬‬ ‫‪ 4.2.1‬اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ‪...................................................‬‬
‫‪58‬‬ ‫‪ 4.2.2‬اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ‪....................................................‬‬
‫‪61‬‬ ‫‪ 4.3‬أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪...................................................................‬‬

‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ – اﻷﺟﺮاءات واﻟﺪوال‬

‫‪66‬‬ ‫اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬ ‫‪5.1‬‬


‫‪66‬‬ ‫اﻷﺟﺮاءات ‪....................................................................‬‬ ‫‪5.2‬‬
‫‪75‬‬ ‫اﻟﺪوال ‪..........................................................................‬‬ ‫‪5.3‬‬
‫‪77‬‬ ‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪...................................................................‬‬ ‫‪5.4‬‬

‫اﻟﻔﺼﻞ اﻟﺴﺎدس – اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ‬

‫‪ 6.1‬اﻟﻤﻘﺪﻣﻪ ‪80 .........................................................................‬‬


‫‪ 6.2‬ﻣﺎهﻲ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪80 ......................................................‬‬
‫‪ 6.3‬اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪81 .............................‬‬
‫‪ 6.3.1‬ﺗﺤﺪﻳﺪ اﻟﻤﻮﻗﻊ ‪81 ..........................................................‬‬
‫‪ 6.3.2‬اﻷﺳﺘﻨﺴﺎخ ‪82 .............................................................‬‬
‫‪ 6.3.3‬اﻟﺤﺬف ‪83 .................................................................‬‬
‫‪ 6.3.4‬اﻟﺤﺸﺮ ‪84 .................................................................‬‬
‫‪ 6.3.5‬دﻣﺞ ﺳﻠﺴﻠﺘﺎن ﺣﺮﻓﻴﺘﺎن ‪85 ..............................................‬‬
‫‪ 6.3.6‬ﺣﺴﺎب ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ‪86 ......................................‬‬
‫‪ 6.3.7‬ﺗﺤﻮﻳﻞ اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ اﻟﻰ ﺣﺮوف آﺒﻴﺮﻩ ‪87 ....................‬‬
‫‪ 6.3.8‬ﺗﺤﻮﻳﻞ اﻟﻘﻴﻢ اﻟﺮﻗﻤﻴﻪ اﻟﻰ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪88 ............................‬‬
‫‪ 6.3.9‬ﺗﺤﻮﻳﻞ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ اﻟﻰ أرﻗﺎم ‪88 ................................‬‬
‫‪ 6.4‬أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪90 ..................................................................‬‬

‫اﻟﻔﺼﻞ اﻟﺴﺎﺑﻊ – ﻣﺘﻐﻴﺮات اﻷﻧﻮاع‬

‫‪93‬‬ ‫‪ 7.1‬اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬


‫‪93‬‬ ‫‪ 7.2‬اﻷﻧﻮاع ‪.........................................................................‬‬
‫‪94‬‬ ‫‪ 7.2.1‬اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ ‪.......................................................‬‬
‫‪97‬‬ ‫‪ 7.2.2‬اﻟﻤﺪﻳﺎت اﻟﺠﺰﺋﻴﻪ ‪......................................................‬‬
‫‪98‬‬ ‫‪ 7.2.3‬اﻟﻤﺠﻤﻮﻋﺎت ‪...........................................................‬‬
‫‪102‬‬ ‫‪ 7.3‬أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪...................................................................‬‬
‫‪1‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻔﺼﻞ اﻷول‬
‫ﻣﺪﺧﻞ اﻟﻰ اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫اﻟﻤﻘﺪﻣﻪ‬ ‫‪1.1‬‬

‫اﻟﺒﺮﻧﺎﻣﺞ هﻮ ﺳﻠ ﺴﻠﻪ ﻣﺘﺘﺎﻟﻴ ﻪ ﻣ ﻦ اﻷﻳﻌ ﺎزات ‪ ,‬ﻳﻤﻜﻨﻨ ﺎ ﺗ ﺸﺒﻴﻬﻬﺎ ﺑﻮﺻ ﻔﺔ أﻋ ﺪاد وﺟﺒ ﻪ ﻏﺬاﺋﻴ ﻪ ‪,‬‬
‫اﻟﻨﻮﺗ ﻪ اﻟﻤﻮﺳ ﻴﻘﻴﻪ ‪ ,‬أو ﻧﻤ ﻮذج ﺣﻴﺎآ ﻪ ‪ .‬وﺗﺘﻤﻴ ﺰ ﻋﻨﻬ ﺎ ﺑ ﺮاﻣﺞ اﻟﺤﺎﺳ ﻮب ﺑ ﺸﻜﻞ ﻋ ﺎم ﺑﺄﻧﻬ ﺎ أﻃ ﻮل أﻣﺘ ﺪادا‬
‫وآﺘﺎﺑﺘﻬﺎ ﺗﺴﺘﺪﻋﻲ دﻗﻪ وﻋﻨﺎﻳﻪ ﻓﺎﺋﻘﺘﻴﻦ ‪ .‬وﻗﺒﻞ اﻟﺸﺮوع واﻟﺨﻮض ﻓﻲ ﻣﻮﺿﻮع اﻟﺒﺮﻣﺠﻪ ﻻﺑﺪ ﻣﻦ ﺗﻌﺮﻳﻒ‬
‫ﺑﻌﺾ اﻟﻤﺼﻄﻠﺤﺎت اﻟﺘﻲ ﺗﺄﺗﻲ ﻻﺣﻘﺎ‪.‬‬

‫ﺑﻌﺾ اﻟﺼﻔﺎت اﻟﻌﺎﻣﻪ ﻟﻠﺒﺮﻧﺎﻣﺞ‬ ‫‪1.2‬‬

‫• ﻳﺤﺘﺎج اﻟﺒﺮﻧﺎﻣﺞ ﺑ ﺼﻮرﻩ ﻋﺎﻣ ﻪ اﻟ ﻰ ﻣ ﻦ ﻳﻜﺘﺒ ﻪ وه ﻮ اﻟﻤﺒ ﺮﻣﺞ ) ‪ , ( Programmer‬واﻟ ﻰ‬


‫اﻟﻤﻌ ﺎﻟﺞ ) ‪ ( Processor‬ﻟﺘﻔ ﺴﻴﺮ وﺗﻨﻔﻴ ﺬ ) ‪ ( Execution OR Running‬اﻷﻳﻌ ﺎزات أو اﻷواﻣ ﺮ‬
‫) ‪ , ( Instructions OR Commands‬وﺗﺴﻤﻰ ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ آﺎﻣﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻤﻌﺎﻟﺠﻪ ) ‪( Process‬‬

‫• أن ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ﻳ ﺘﻢ ﺑ ﺼﻮرﻩ ﻣﺘﺘﺎﻟﻴ ﻪ ) أي أﻳﻌ ﺎز ) ‪ ( instruction‬ﺑﻌ ﺪ اﻷﺧ ﺮ ﺣ ﺴﺐ‬


‫ﺗﺴﻠ ﺴﻠﻬﺎ (‪ ,‬ﻣ ﺎﻟﻢ ﻳ ﺘﻢ اﻷﺧﺒ ﺎر ﺧﺎرﺟﻴ ﺎ ﻋ ﻦ ﻏﻴ ﺮ ذﻟ ﻚ‪ .‬ه ﺬا ﻳﻌﻨ ﻲ أن ﻧﺒ ﺪأ ﺑ ﺄول أﻳﻌ ﺎز وﻳﻨﻔ ﺬ ﺛ ﻢ اﻟﺜ ﺎﻧﻲ‬
‫واﻟﺜﺎﻟﺚ وهﻜﺬا ﻟﺤﻴﻦ اﻟﻮﺻﻮل اﻟﻰ اﻷﻳﻌﺎز اﻷﺧﻴﺮ‪ .‬ه ﺬا اﻟﻨﻤ ﻮذج ﻣﻤﻜ ﻦ أن ﻳﻐﻴ ﺮ ﺑﻄﺮﻳﻘ ﻪ ﻣﺤ ﺪدﻩ ﻣ ﺴﺒﻘﺎ‬
‫ﺑﺸﻜﻞ ﺟﻴ ﺪ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ آﻤ ﺎ ﻳﻤﻜ ﻦ أن ﻳ ﺘﻢ ﺗﻜ ﺮار ﺟ ﺰء ﻣ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ وﺣ ﺴﺐ ﺗﺤﺪﻳ ﺪات اﻟﻤﺒ ﺮﻣﺞ‬
‫) ﻣﺜﻠﻤٍﺎ ﻳﺘﻢ ﺗﻜﺮار ﻣﻘﻄﻊ ﻣﻦ ﻧﻮﺗﻪ ﻣﻮﺳﻴﻘﻴﻪ ( ‪.‬‬

‫• أي ﺑﺮﻧﺎﻣﺞ ﻳﺠﺐ أن ﻳﻜﻮن ﻟﻪ ﺗﺄﺛﻴﺮ‪ ..‬ﻣﺜﻼ ﻓ ﻲ اﻟﻘﻄﻌ ﻪ اﻟﻤﻮﺳ ﻴﻘﻴﻪ ﻳﻜ ﻮن ه ﺬا اﻟﺘ ﺄﺛﻴﺮ ﻋﺒ ﺎرﻩ‬
‫ﻋ ﻦ ﺻ ﻮت ‪ ,‬أﻣ ﺎ ﻓ ﻲ ﺑ ﺮاﻣﺞ اﻟﺤﺎﺳ ﻮب ه ﺬا اﻟﺘ ﺄﺛﻴﺮ ﻳﻜ ﻮن ﻋﻠ ﻰ ﺷ ﻜﻞ ﻣﺨﺮﺟ ﺎت ‪ ,‬أﻣ ﺎ ﻣﻄﺒﻮﻋ ﻪ أو‬
‫ﻣﻌﺮوﺿﻪ ﻋﻠﻰ اﻟﺸﺎﺷﻪ ‪.‬‬

‫• آ ﻞ ﺑﺮﻧ ﺎﻣﺞ ﻳﻌﻤ ﻞ ﻋﻠ ﻰ أﺷ ﻴﺎء ﻣﺤ ﺪدﻩ ﻟﻠﻮﺻ ﻮل اﻟ ﻰ اﻟﺘ ﺄﺛﻴﺮ اﻟﻤﻄﻠ ﻮب ) ﻣ ﺜﻼ ﻓ ﻲ وﺻ ﻔﺔ‬
‫أﻋﺪاد اﻟﻄﻌﺎم ﻓﺎن هﺬﻩ اﻻﺷﻴﺎء ﻣﻤﻜﻦ أن ﺗﻜﻮن اﻟﻠﺤﻮم ‪ ,‬اﻟﺨﻀﺎر‪ ,‬وﻏﻴﺮهﺎ ( ‪ ,‬أﻣﺎ ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ ﻓ ﺄن ه ﺬﻩ‬
‫اﻻﺷﻴﺎء ﺗﻜﻮن ﺑﻴﺎﻧﺎت ‪.‬‬

‫• ﻓﻲ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺒﺮاﻣﺞ ﻳﺠﺐ أن ﻳﺘﻢ اﻷﻋﻼن اﻟﻤﺴﺒﻖ ﻋﻦ اﻟﻤﺘﻐﻴﺮات أو اﻟﺒﻴﺎﻧ ﺎت اﻟﺘ ﻲ ﺳ ﻴﺘﻢ‬
‫أﺳﺘﺨﺪاﻣﻬﺎ وﻣﺎهﻴﺔ أﻧﻮاﻋﻬﺎ ) هﺬا ﻣﺸﺎﺑﻪ ﻟﻌﻤﻠﻴﺔ أﻋﺪاد وﺟﺒﺔ ﻃﻌﺎم ﺣﻴﺚ ﻳﺠﺐ أن ﺗﺤﺘﻮي اﻟﻮﺻﻔﻪ اﺑﺘﺪاءا‬
‫ﻣﺎهﻴﺔ اﻟﻤﻮاد اﻟﺘﻲ ﺳﺘﺴﺘﺨﺪم وآﻤﻴﺎﺗﻬﺎ ( ‪.‬‬

‫• ﻓﻲ ﺑﻌ ﺾ اﻷﻳﻌ ﺎزات رﺑﻤ ﺎ ﺗﻜ ﻮن هﻨ ﺎك ﺣﺎﺟ ﻪ أن ﻳﺘ ﺮك أﺗﺨ ﺎذ ﻗ ﺮار ﺗﻨﻔﻴ ﺬهﺎ اﻟ ﻰ اﻟﻤﻌ ﺎﻟﺞ‬
‫وﻓﻘﺎ ﻟﺸﺮوط ﻣﻌﻴﻨﻪ‪ ..‬ﻓﻤﺜﻼ ) ﻋﻨﺪ أﻋ ﺪاد وﺟﺒ ﺔ ﻃﻌ ﺎم ﻳﻜﺘ ﺐ ﻓ ﻲ اﻟﻮﺻ ﻔﻪ ﻣ ﺎ ﻳﻠ ﻲ " ﻋﻨ ﺪ ﺗ ﻮﻓﺮ اﻟﻄﻤﺎﻃ ﻪ‬
‫اﻟﻄﺎزﺟﻪ ﺗﺴﺘﺨﺪم ﺑﻌﺪ ﻧﺰع اﻟﻘﺸﺮ ﻓﻲ ﺧﻼف ذﻟﻚ ﻳﺴﺘﺨﺪم ﻣﻌﺠﻮن اﻟﻄﻤﺎﻃﻢ" ( ‪.‬‬
‫• رﺑﻤ ﺎ ﺗﻜ ﻮن هﻨ ﺎك ﺣﺎﺟ ﻪ ﻟﺘﻨﻔﻴ ﺬ أﻳﻌ ﺎز أو ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻷﻳﻌ ﺎزات ﻷآﺜ ﺮ ﻣ ﻦ ﻣ ﺮﻩ ‪ .‬ﻋﻠﻴ ﻪ‬
‫ﻃﺎﻟﻤﺎ هﻨﺎك أﻳﻌﺎز ﻳﺮاد ﺗﻜﺮارﻩ ﻓﺄن ﻋﺪد ﻣﺮات اﻟﺘﻜﺮار ﻳﺠﺐ ان ﺗﺤﺪد ‪ .‬ﻣﻤﻜﻦ أﻧﺠ ﺎز ذﻟ ﻚ أﻣ ﺎ ﺑﺘﺤﺪﻳ ﺪ‬
‫‪2‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻋﺪد ﻣﺮات اﻟﺘﻜﺮار ) ﻣﺜﻼ ﻳﻮﺿﻊ اﻟﻄﻌﺎم ﻋﻠﻰ اﻟﻨﺎر ﻟﻤﺪة ‪ 30‬دﻗﻴﻘﻪ ( أو ﺑﻔﺤﺺ ﺣﺎﻟ ﻪ ﺗﻜ ﻮن ﻣ ﻦ ﺿ ﻤﻦ‬
‫اﻟﻌﻤﻠﻴﻪ ) ﻣﺜﻼ وﺿﻊ اﻟﻄﻌﺎم ﻋﻠﻰ اﻟﻨﺎر ﻟﺤﻴﻦ أن ﻳﻨﻀﺞ ( ‪.‬‬

‫اﻟﻤﻌﺮﻓﺎت ‪IDENTIFIERS‬‬ ‫‪1.3‬‬

‫آﻞ اﻟﺒﺮاﻣﺞ ﺗﺤﺘﻮي ﻋﻠﻰ ﻧﻮﻋﻴﻦ ﻣﻦ اﻟﺮﻣﻮز ‪:‬‬

‫اﻟﻨﻮع اﻻول ‪ ..‬وهﻲ اﻟﺮﻣﻮز اﻟﺘﻲ ﺗﻌﻮد اﻟﻰ اﻟﻠﻐ ﻪ ‪ ..‬ﻓﻔ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﺗ ﺴﺘﺨﺪم ه ﺬﻩ‬
‫اﻟﺮﻣ ﻮز ﺑﻄ ﺮﻳﻘﺘﻴﻦ أﻣ ﺎ أن ﺗﻜ ﻮن ﻋﻠ ﻰ ﺷ ﻜﻞ رﻣ ﺰ واﺣ ﺪ أو أﺛﻨ ﻴﻦ ﻣﺜ ﻞ ) ‪ ( : , ; , ( ) , : = , + , -‬أو‬
‫ﻋﻠﻰ ﺷﻜﻞ آﻠﻤﺎت ﺗﺴﻤﻰ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزﻩ ﻣﺜﻞ ‪:‬‬

‫) ‪( begin , if , else , repeat , while, until , then , end‬‬

‫اﻟﻨ ﻮع اﻟﺜ ﺎﻧﻲ ‪ ..‬ه ﻮ اﻟﻤﻌﺮﻓ ﺎت وه ﻲ ﻋﺒ ﺎرﻩ ﻋ ﻦ رﻣ ﻮز ﺗ ﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ ﻓﺄﻣ ﺎ أن ﺗﻜ ﻮن‬
‫ﻣﻌﺮﻓﺎت ﻗﻴﺎﺳﻴﻪ ﻣﺜﻞ‬

‫)‪( integer , real , write, sqrt …etc‬‬

‫أو أن ﺗﻜﻮن ﻣﻌﺮﻓ ﺎت ﻳ ﺘﻢ أﺧﺘﻴﺎره ﺎ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ ‪ .‬ه ﺬﻩ اﻟﻤﻌﺮﻓ ﺎت اﻷﺧﻴ ﺮﻩ ﻧ ﺴﻤﻴﻬﺎ أﻳ ﻀﺎ‬
‫اﻟﻤﺘﻐﻴﺮات ) ‪ ( variables‬واﻟﻤﺘﻐﻴﺮ هﻮ رﻣﺰ أو أآﺜﺮ ﻳﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ﻟﻴ ﺸﻴﺮ اﻟ ﻰ ﻣﺤﺘ ﻮى ﻣﻮﻗ ﻊ‬
‫ﻓﻲ اﻟﺬاآﺮﻩ ‪.‬‬

‫اﻟﻤﺘﻐﻴﺮ ‪//:‬‬

‫ﻓﻲ أﻏﻠﺐ ﻟﻐﺎت اﻟﺒﺮﻣﺠﻪ ﻓﺄن اﻟﻤﺘﻐﻴﺮ هﻮ ﻣﻜﺎن ﻟﺘﺨﺰﻳﻦ اﻟﻤﻌﻠﻮﻣﺎت ‪ ,‬اﻟﻤﺘﻐﻴﺮ هﻮ ﻣﻜﺎن أو‬
‫ﻣﻮﻗﻊ ﻓﻲ ذاآﺮة اﻟﺠﻬﺎز ﺣﻴﺚ ﻳﻤﻜﻦ ﺗﺨﺰﻳﻦ ﻗﻴﻤﻪ ﺑﺪاﺧﻠﻪ ﺛﻢ أﻣﻜﺎﻧﻴﻪ أﺳﺘﻌﺎدة هﺬﻩ اﻟﻘﻴﻤﻪ ﻓﻴﻤﺎ‬
‫ﺑﻌﺪ ‪.‬‬
‫واﻟﻤﺘﻐﻴﺮ هﻮ أﺳﻢ ﻳﻤﺜﻞ ﺑﺮﻗﻢ أو ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ) وﻣﻤﻜﻦ ﺣﺮف واﺣﺪ أو ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ ( ‪.‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ ﺗﺼﻮر ذاآﺮة اﻟﺠﻬﺎز ﻋﻠﻰ أﻧﻬﺎ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﻤﻮاﻗﻊ اﻟﺘﻲ ﺗﺨﺰن ﻓﻴﻬ ﺎ اﻟﻤﻌﻠﻮﻣ ﺎت ‪,‬‬
‫هﺬﻩ اﻟﻤﻮاﻗﻊ ﻣﺮﻗﻤﻪ ﺑﺸﻜﻞ ﻣﺘﺴﻠﺴﻞ ﺗﺒﺪأ ﻣﻦ اﻟﺼﻔﺮ وﺗﻨﺘﻬﻲ ﺑﺤﺠﻢ اﻟﺬاآﺮﻩ ‪ ,‬ﺗﻌﺮف ه ﺬﻩ اﻷرﻗ ﺎم ﺑﻌﻨ ﺎوﻳﻦ‬
‫اﻟﺬاآﺮﻩ ﺳﻴﻤﺜﻞ أﺳﻢ اﻟﻤﺘﻐﻴﺮ ﺑﻄﺎﻗﺔ ﻋﻨﻮﻧﻪ ﻣﻠﺼﻘﻪ ﻋﻠﻰ أﺣﺪ اﻟﻤﻮاﻗﻊ ﺑﺤﻴﺚ ﺗﺴﺘﻄﻴﻊ اﻟﻮﺻ ﻮل اﻟﻴ ﻪ ﺳ ﺮﻳﻌﺎ‬
‫دون اﻟﺤﺎﺟﻪ اﻟﻰ ﻣﻌﺮﻓﺔ اﻟﻌﻨﺎوﻳﻦ اﻟﺤﻘﻴﻘﻴﺔ ﻓﻲ اﻟﺬاآﺮة ) ﻟﺬا ﻓﺎن اﻟﻤﺘﻐﻴﺮ ﺳﻴ ﺸﻴﺮ اﻟ ﻰ اﺣ ﺪ ه ﺬﻩ اﻟﻌﻨ ﺎوﻳﻦ‬
‫وﻋﻨﺪ وﺿﻊ ﻗﻴﻤﻪ ﻓﻲ اﻟﻤﺘﻐﻴﺮ ﻓﺎن اﻟﻤﺘﺮﺟﻢ ) ‪ ( compiler‬ﺳﻴﺬهﺐ اﻟﻰ اﻟﻌﻨﻮان اﻟﺬي ﻳﺸﻴﺮ ﻟ ﻪ اﻟﻤﺘﻐﻴ ﺮ‬
‫وﻳﻀﻊ ﻓﻴﻪ اﻟﻘﻴﻤﻪ وآﺬﻟﻚ ﻋﻨ ﺪﻣﺎ ﻧﺮﻳ ﺪ أن ﻧﻌ ﺮف ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ﻓ ﺄن اﻟﻤﺘ ﺮﺟﻢ ﻳ ﺬهﺐ اﻟ ﻰ اﻟﻌﻨ ﻮان اﻟ ﺬي‬
‫ﻳﺸﻴﺮ ﻟﻪ اﻟﻤﺘﻐﻴﺮ وﻳﻘﺮأ اﻟﻘﻴﻤﻪ اﻟﺘﻲ ﻓﻴﻪ ( ‪ .‬ﻳﻌﺮض اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ه ﺬﻩ اﻟﻔﻜ ﺮﻩ واﻟﺘ ﻲ ﺗﺒ ﻴﻦ ﺑﻌ ﺾ اﻟﻤﻮاﻗ ﻊ‬
‫ﻓﻲ اﻟﺬاآﺮة واﻟﺘﻲ ﻣﻤﻜﻦ ان ﻳﺸﻴﺮ اﻟﻴﻬﺎ اﻟﻤﺘﻐﻴﺮ ‪.‬‬
‫‪3‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺷﻜﻞ رﻗﻢ ) ‪ : ( 1.1‬ﺑﻌﺾ ﻣﻮاﻗﻊ اﻟﺬاآﺮﻩ‬

‫ﺗﺘﻜﻮن اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﺣﺮف واﺣﺪ ‪ ,‬ﻣﺠﻤﻮﻋﺔ ﺣﺮوف ‪ ,‬أو ﺣﺮوف وأرﻗﺎم ﻋﻠﻰ أن ﻳﻜ ﻮن أول‬
‫رﻣﺰ ﺣﺮف ﻣﺜﻞ‬
‫) ‪ ( x , b , ad, jasim , endofpoint , hind6 , x345‬هﺬﻩ ﺟﻤﻴﻌﺎ ﻣﺘﻐﻴﺮات ﻣﻘﺒﻮﻟﻪ‪.‬‬

‫أﻣﺎ اﻟﻤﺘﻐﻴﺮات اﻟﺘﺎﻟﻴ ﻪ ﻓﻬ ﻲ ﻏﻴ ﺮ ﻣﻘﺒﻮﻟ ﻪ ) ‪ ( first name , next.word , 15may‬واﻟ ﺴﺒﺐ‬


‫هﻮ أن اﻟﻤﺘﻐﻴﺮ اﻷول ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻓ ﺮاغ واﻟﺜ ﺎﻧﻲ ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻧﻘﻄ ﻪ أﻣ ﺎ اﻷﺧﻴ ﺮ ﻓﻬ ﻮ ﻳﺒ ﺪأ ﺑ ﺮﻗﻢ وه ﺬﻩ‬
‫ﺟﻤﻴﻌﻬﺎ ﻏﻴﺮ ﻣﻘﺒﻮﻟﻪ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫أن أول ﻇﻬﻮر ﻟﻠﻤﺘﻐﻴﺮ ﻳﻜﻮن ﻓﻲ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴ ﺮات ﺣﻴ ﺚ ﻳ ﺘﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮ‬
‫وﻳﺤﺪد ﻧﻮﻋﻪ ) أي هﻞ هﻮ رﻗﻢ ﺻﺤﻴﺢ ) ‪ ( integer‬ﻣﺜﻼ ‪ ,‬آ ﺴﺮ ) ‪ , ( real‬ﻧ ﺺ آﺘ ﺎﺑﻲ ) ‪, ( string‬‬
‫ﺣﺮف ) ‪...( character‬اﻟﺦ ( ‪ .‬أن أﺧﺘﻴﺎر اﻟﻤﺘﻐﻴ ﺮ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ ﺗﻌﺘﺒ ﺮ ﻣ ﺴﺄﻟﻪ ﻣﻬﻤ ﻪ وﻳﻔ ﻀﻞ أن‬
‫ﻳﻌﻜﺲ اﻟﻤﺘﻐﻴﺮ اﻟﻤﻌﻨﻰ اﻟﺬي ﺑﺴﺘﺨﺪم ﻷﺟﻠﻪ اﻟﻤﺘﻐﻴﺮ ﻓﻤﺜﻼ ﻳﻔ ﻀﻞ أﺳ ﺘﺨﺪام اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( sum‬ﻣ ﻊ اﻟﺠﻤ ﻊ‬
‫وأذا ﻣﺎ أﺳﺘﺨﺪم ﻣﺘﻐﻴﺮ أﺧﺮ ﻓﺎن ذﻟﻚ ﺳﻮف ﻻ ﻳﺆدي اﻟﻰ أي اﺷﻜﺎل ‪ ,‬وآﺬﻟﻚ ﻳﻔﻀﻞ أن ﻻ ﻳﻜﻮن اﻟﻤﺘﻐﻴ ﺮ‬
‫ﻃﻮﻳﻞ ﻓﻤ ﺜﻼ ﻳﻔ ﻀﻞ أﺳ ﺘﺨﺪام ﻣﺘﻐﻴ ﺮ ﻣﺘﻜ ﻮن ﻣ ﻦ ﺣ ﺮف واﺣ ﺪ ﻋﻨ ﺪﻣﺎ ﻧ ﺴﺘﺨﺪﻣﻪ ﻓ ﻲ ﺑﺮﻧ ﺎﻣﺞ ﻗ ﺼﻴﺮ وﻻ‬
‫ﻳﺘﻜﺮر آﺜﻴﺮا ‪ ,‬أﻣﺎ أﺳﺘﺨﺪام ﻣﺘﻐﻴﺮ ﻣﻦ ﺣﺮف واﺣﺪ وﻳﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﺘﻜﺮر وﺑﺄﺟﺰاء ﻣﺘﻜﺮرﻩ ﻓﻲ ﺑﺮﻧﺎﻣﺞ‬
‫ﻃﻮﻳﻞ ﻓﺄﻧﻪ ﻳﻌﺘﺒﺮ أﺧﺘﻴﺎر ﺳﻲء ﺑﺎﻟﺮﻏﻢ ﻣﻦ أﻧﻪ ﻻ ﻳﻌﻴﻖ ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬

‫اﻟﺜﻮاﺑﺖ ‪CONSTANTS‬‬ ‫‪1.4‬‬

‫ﻓﻲ ﺑﻌﺾ اﻟﺒﺮاﻣﺞ ﻧﺤﺘﺎج اﻟﻰ أﺳﺘﺨﺪام ﻗﻴﻢ رﺑﻤﺎ ﺗﻜﻮن ﻣﻌﺮوﻓﻪ ﻣ ﺴﺒﻘﺎ ﻗﺒ ﻞ ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ وﻻ‬
‫ﻳﻤﻜﻦ أن ﺗﺘﻐﻴﺮ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻣﺜﻞ اﻟﻨﺴﺒﻪ اﻟﺜﺎﺑﺘ ﻪ ) ‪ ( Л‬واﻟﺘ ﻲ ﺗﻜ ﻮن ﻗﻴﻤﺘﻬ ﺎ ) ‪( 3.1415926585‬‬
‫هﺬﻩ اﻟﻘﻴﻢ اﻟﺜﺎﺑﺘﻪ ﺳﻮاء آﺎﻧﺖ ذات ﻗﻴﻤﻪ ﻣﻌﺮوﻓﻪ ﻣﺴﺒﻘﺎ أو أي ﻗﻴﻤ ﻪ ﻣﻤﻜ ﻦ أن ﺗ ﺴﻨﺪ اﻟ ﻰ ﻣﺘﻐﻴ ﺮ ‪ ,‬ﺟﻤﻴﻌﻬ ﺎ‬
‫ﻣﻤﻜﻦ أن ﺗﻌﺮف ﺑﺤﻘﻞ ﺧﺎص ﻳﺪﻋﻰ ﺣﻘﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﺜﻮاﺑ ﺖ وه ﺬا اﻟﺤﻘ ﻞ ﻳ ﺴﺒﻖ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ‬
‫اﻟﻤﺘﻐﻴﺮات وآﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪Const‬‬
‫; ‪Pi = 3.1413926535‬‬
‫; ' ‪Error = ' Run_Time Error‬‬
‫‪4‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫أﺳﺒﺎب أﺳﺘﺨﺪام اﻟﺜﻮاﺑﺖ ‪:‬‬

‫• أذا آﺎن هﻨﺎك ﻋﺪد ﻳﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﺘﻜﺮر داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻓﺄن اﻟﻤﺒﺮﻧﺞ ﻳﻔﻀﻞ أن ﻳﺼﻔﻪ‬
‫ﺑﺄﺳﻢ ﺿﻤﻦ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ ‪ ,‬وﺑﻌﺪهﺎ ﺑﺎﻷﻣﻜﺎن أﺳﺘﺨﺪام اﻷﺳﻢ اﻟﻤﻮﺻﻮف ﻓﻲ‬
‫اﻟﻘﺴﻢ اﻟﺘﻨﻔﻴﺬي ‪.‬‬

‫• ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام ﺣﻘﻞ اﻟﺜﻮاﺑﺖ ﻟﺘﺴﻤﻴﺔ ﻣﺘﻐﻴﺮات ﻣﻦ ﻧﻮع اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ واﻟﺘﻲ‬
‫ﺗﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻓﻲ ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫ﻣﺜﺎل ‪ :‬ﻧﻔﺮض أﻧﻨﺎ ﻧﺤﺘﺎج اﻟﻰ ﻃﺒﺎﻋﺔ أﺳﻢ ﺟﺎﻣﻌﻪ ﻣﺜﻼ ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬ﻣﻤﻜﻦ أن‬
‫ﻧﻘﻮم ﺑﻤﺎﻳﻠﻲ ‪:‬‬

‫‪Const‬‬
‫; ' ‪University = 'Al _ Mustnsirah university‬‬
‫; '‪Underline = '----------------------------------------------‬‬

‫اﻷن ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام اﻷﺳﻤﺎء اﻟﻤﻌﺮﻓﻪ آﺜﻮاﺑﺖ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وآﻤﺎ ﻳﻠﻲ‪:‬‬

‫; ) ‪Writeln ( university‬‬
‫; ) ‪Writeln ( underline‬‬

‫اﻟﺒﻴﺎﻧﺎت ‪DATA‬‬ ‫‪1.5‬‬

‫آﻞ ﻋﻨﺼﺮ ﻣ ﻦ اﻟﺒﻴﺎﻧ ﺎت ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ أﻣ ﺎ أن ﺗﻜ ﻮن ﻗﻴﻤﺘ ﻪ ﺛﺎﺑﺘ ﻪ أو ﻣﺘﻐﻴ ﺮﻩ ) أن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ‬
‫رﺑﻤﺎ ﺗﺘﻐﻴﺮ ﺧﻼل ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ (‪ .‬آﻞ ﻣﺘﻐﻴﺮ) واﻟﺬي هﻮ ﺑﻴﺎﻧﺎت ( ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻳﺠﺐ أن ﻳﻜ ﻮن ﻟ ﻪ ﻧ ﻮع‬
‫وﺑﻤﻮﺟﺐ هﺬا اﻟﻨﻮع ﺳﻴﺘﻢ ﺗﺤﺪﻳﺪ اﻟﻤﺴﺎ ﺣﻪ اﻟﺨﺰﻧﻴﻪ اﻟﻼزﻣﻪ ﻟﻘﻴﻤ ﺔ ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ‪ ,‬وآ ﺬﻟﻚ ﺗﺤ ﺪد اﻟﻌﻤﻠﻴ ﺎت‬
‫اﻟﺘﻲ ﻣﻤﻜﻦ أﺟﺮاؤهﺎ ﻋﻠﻰ هﺬا اﻟﻤﺘﻐﻴﺮ‪ .‬واﻷﻧﻮاع اﻟﻘﻴﺎﺳﻴﻪ اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل هﻲ ‪:‬‬

‫‪ 1.5.1‬اﻻﻋﺪاد اﻟﺼﺤﻴﺤﻪ ‪INTEGERS‬‬

‫اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ هﻲ آﻞ اﻷﻋﺪاد اﻟﻤﻮﺟﺒﻪ واﻟﺴﺎﻟﺒﻪ اﻟﺘﻲ ﻻ ﺗﺤﺘﻮي ﻋﻠﻰ آ ﺴﺮ‪ .‬ﻓﺎﻟ ﺼﻔﺮ ﻋ ﺪد‬
‫ﺻﺤﻴﺢ و ‪ 567‬هﻮ ﻋﺪد ﺻﺤﻴﺢ و ‪ -23‬أﻳﻀﺎ ﻋﺪد ﺻﺤﻴﺢ ‪ .‬أﻣ ﺎ )‪ 123.345‬و ‪ ( -1.45‬ﻓﻬ ﻲ ﻟﻴ ﺴﺖ‬
‫أﻋ ﺪاد ﺻ ﺤﻴﺤﻪ‪ .‬أن اﻋﻠ ﻰ ﻗﻴﻤ ﻪ وأوﻃ ﺄ ﻗﻴﻤ ﻪ ﻟﻌ ﺪد ﺻ ﺤﻴﺢ ﻣﻤﻜ ﻦ ﺗﻤﺜﻴﻠ ﻪ ﻓ ﻲ اﻟﺤﺎﺳ ﻮب ﺗﺨﺘﻠ ﻒ ﻣ ﻦ‬
‫ﺣﺎﺳﻮب ﻷﺧﺮ ‪ ,‬وﻳﻤﻜﻦ ﻣﻌﺮﻓﺔ هﺬﻩ اﻟﻘﻴﻢ ﻓﻲ أي ﺣﺎﺳﻮب ﺑﺄﺳﺨﺪام اﻷﻳﻌﺎزات اﻟﺘﺎﻟﻴﻪ ‪:‬‬

‫‪maxint‬‬ ‫ﻟﻤﻌﺮﻓﺔ أﻋﻠﻰ ﻗﻴﻤﻪ ﻧﺴﺘﺨﺪم‬


‫‪- maxint‬‬ ‫ﻟﻤﻌﺮﻓﺔ أوﻃﺄ ﻗﻴﻤﻪ ﻧﺴﺘﺨﺪم‬

‫أن أي ﻣﺤﺎوﻟ ﻪ ﻷﺳ ﺘﺨﺪام ﻗ ﻴﻢ ﺧ ﺎرج ﻧﻄ ﺎق اﻟﺤ ﺪود اﻟﻌﻠﻴ ﺎ واﻟ ﺪﻧﻴﺎ ﺳ ﻴﺆدي اﻟ ﻰ ﺣ ﺪوث ﺧﻄ ﺄ‪.‬‬
‫وﺑﺸﻜﻞ ﻋ ﺎم ﻓ ﺄن اﻟﻤﺘﻐﻴ ﺮات ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ﺗ ﺴﺘﺨﺪم أﺿ ﺎﻓﻪ اﻟ ﻰ اﻟﻌﻤﻠﻴ ﺎت اﻟﺮﻳﺎﺿ ﻴﻪ ﻓ ﻲ‬
‫اﻟﻌﺪادات واﻟﻔﻬﺎرس ‪.‬‬
‫اﻟﻌﻼﻗ ﺎت اﻟﺮﻳﺎﺿ ﻴﻪ اﻟﺘ ﻲ ﺗ ﺴﺘﺨﺪم ﻣ ﻊ اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ه ﻲ ) ‪( + , - , * , Div , Mod‬‬
‫وهﻲ ﻋﻠﻰ اﻟﺘﻮاﻟﻲ ) اﻟﺠﻤﻊ ‪ ,‬اﻟﻄﺮح ‪ ,‬اﻟﻀﺮب ‪ ,‬اﻟﻘﺴﻤﻪ ‪ ,‬وﺣﺴﺎب ﺑﺎﻗﻲ اﻟﻘﺴﻤﻪ ( ‪.‬‬
‫‪5‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻳﺠﺐ أن ﻧﻼﺣﻆ هﻨﺎ أن اﻟﻌﻼﻣﻪ ) ‪ ( /‬ﺗﺴﺘﺨﺪم ﻟﻠﻘﺴﻤﻪ ﻟﻜﻦ ﻣﻊ اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ أي اﻟﺘ ﻲ ﺗﺤﺘ ﻮي‬
‫آﺴﻮر‬
‫أﻣﺜﻠﻪ ‪//:‬‬
‫‪2 Div 3 = 0‬‬
‫‪2 / 3 = 0.66666667‬‬
‫‪5 Div 1 = 5‬‬
‫‪5 / 1 = 5.0‬‬
‫‪5 Div 2 = 2‬‬
‫‪2+3*4 = 14‬‬
‫‪(2+3) * 4 = 20‬‬ ‫هﻨﺎ ﻳﻨﻔﺬ داﺧﻞ اﻟﻘﻮس أوﻻ‬
‫‪5 mod 2 = 1‬‬
‫‪7 mod 4 = 3‬‬

‫وﻳ ﺼﺮح ﻋ ﻦ اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات‬
‫) ﺳﻨﻮﺿﺤﻬﺎ ﻻﺣﻘﺎ ( ﺑﺎﻟﺪاﻟﻪ ) ‪. ( integer‬‬

‫‪ 1.5.2‬اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ ‪REAL NUMBERS‬‬

‫‪0.03 , 12.5 , -356.67890 , 10.0‬‬ ‫وهﻲ اﻷﻋﺪاد اﻟﺘﻲ ﺗﺤﺘﻮي ﻋﻠﻰ آﺴﻮر ﻣﺜ ﻞ‬

‫) ‪ ( + , - , * , /‬وه ﻲ‬ ‫أﻣ ﺎ اﻟﻌﻤﻠﻴ ﺎت اﻟﺮﻳﺎﺿ ﻴﻪ اﻟﺘ ﻲ ﻣﻤﻜ ﻦ أﺟﺮاؤه ﺎ ﻋﻠﻴﻬ ﺎ ﻓﻬ ﻲ‬


‫) اﻟﺠﻤﻊ ‪ ,‬اﻟﻄﺮح ‪ ,‬اﻟﻀﺮب ‪ ,‬اﻟﻘﺴﻤﻪ (‪ .‬وﻳﺼﺮح ﻋ ﻦ اﻷﻋ ﺪاد اﻟﺤﻘﻴﻘﻴ ﻪ ﻓ ﻲ ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻓ ﻲ‬
‫ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﺑﺎﻟﺪاﻟﻪ ) ‪. ( Real‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﺗﻤﺜﻞ اﻷرﻗﺎم ﺑﻄﺮﻳﻘﺘﻴﻦ ﻓﺄﻣﺎ أرﻗﺎم ﺻﺤﻴﺤﻪ ﺑﺪون آﺴﺮ أو أرﻗﺎم آﺴﺮﻳﻪ ‪ .‬اﻟﻘﻮاﻋﺪ اﻟﺘﺎﻟﻴﻪ‬
‫ﺗﻄﺒﻖ ﻋﻨﺪ آﺘﺎﺑﺔ أرﻗﺎم‬
‫‪ .1‬اﻟﻔﺎرزﻩ ﻻ ﻳﻤﻜﻦ أن ﺗﻈﻬﺮ ﻓﻲ أي ﻣﻜﺎن ﻓﻲ اﻟﺮﻗﻢ ‪.‬‬
‫‪ .2‬ﻣﻤﻜﻦ أن ﺗﺴﺒﻖ اﻷرﻗﺎم أﺣﺪى اﻟﻌﻼﻣﺘﻴﻦ ) ‪ ( + , -‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ آﻮﻧﻪ ﻣﻮﺟﺐ أو‬
‫ﺳﺎﻟﺐ ) ﻳﻌﺘﺒﺮ اﻟﺮﻗﻢ ﻣﻮﺟﺒﺎ أذا ﻟﻢ ﺗﻈﻬﺮ أي ﻣﻦ اﻟﻌﻼﻣﺘﻴﻦ أﻣﺎﻣﻪ ( ‪.‬‬
‫‪ .3‬ﻳﻤﻜﻦ ﺗﻤﺜﻴﻞ اﻷرﻗﺎم ﺑﻄﺮﻳﻘﺔ اﻟﻌﻼﻣﻪ اﻟﻌﻠﻤﻴﻪ ) وذﻟﻚ ﺑﺄﺳﺘﺒﺪال اﻟﺮﻗﻢ ) ‪( 10‬‬
‫ﺑﺎﻟﺤﺮف ) ‪ . ( ( E‬ﻣﺜﻼ اﻟﺮﻗﻢ ) ‪ ( 2.7 x 10 -6‬ﺗﻜﺘﺐ ﺣﺴﺐ اﻟﻌﻼﻣﻪ اﻟﻌﻠﻤﻴﻪ آﻤﺎ‬
‫ﻳﻠﻲ ) ‪. ( 2.7E-6‬‬
‫‪6‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫أدﻧﺎﻩ ﺑﻌﺾ اﻟﻘﻮاﻋﺪ اﻟﻬﺎﻣﻪ اﻟﺘﻲ ﻳﺠﺐ أن ﺗﺮاﻋﻰ ﻋﻨﺪ آﺘﺎﺑﺔ اﻟﻌﻼﻗﺎت اﻟﺮﻳﺎﺿﻴﻪ ‪:‬‬

‫أن وﺿﻊ أﺷﺎرة اﻟﺴﺎﻟﺐ ﻗﺒﻞ اﻟﻤﺘﻐﻴﺮات هﻲ ﻣﻜﺎﻓﺌﻪ ﻟﻀﺮب اﻟﻤﺘﻐﻴﺮ ﺑﺎﻟﻘﻴﻤﻪ ) ‪( -1‬‬ ‫‪.1‬‬
‫‪ .‬ﻣﺜﻼ اﻟﻤﺘﻐﻴﺮات ) ‪ – ( x+y‬ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﻜﺘﺐ ) ‪. -1 * ( x+y‬‬
‫ﻳﺠﺐ أن ﺗﻜﺘﺐ اﻟﻌﻼﻗﺎت اﻟﺮﻳﺎﺿﻴﻪ وﻓﻘﺎ ﻟﻠﻄﺮﻳﻘﻪ اﻟﺘﻲ ﺗﺤﺪدهﺎ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬ ‫‪.2‬‬
‫ﺑﺤﻴﺚ ﺗﺬآﺮ آﻞ اﻟﻌﻼﻣﺎت اﻟﺮﻳﺎﺿﻴﻪ دون أﺧﺘﺼﺎر ‪ .‬ﻣﺜﺎل ‪ :‬اﻟﻌﻼﻗﻪ اﻟﺮﻳﺎﺿﻴﻪ اﻷﺗﻴﻪ‬
‫ﻏﻴﺮ ﻣﻘﺒﻮﻟﻪ ) ) ‪ ( 2( x1 + 3x2‬هﺬﻩ اﻟﻌﻼﻗﻪ ﻟﻜﻲ ﺗﻜﻮن ﻣﻘﺒﻮﻟﻪ ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ‬
‫ﺑﺎﺳﻜﺎل ﻳﺠﺐ أن ﺗﻜﺘﺐ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪ ( 2 * ( x1 + 3 * x2 ) ) :‬اﻟﻌﻼﻗﻪ‬
‫اﻷوﻟﻰ هﻲ اﻟﺘﻲ ﺗﻌﻮدﻧﺎ ﻋﻠﻰ أﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻟﺮﻳﺎﺿﻴﺎت ‪.‬‬
‫اﻟﺮﻗﻢ اﻟﺴﺎﻟﺐ ﻣﻤﻜﻦ أن ﻳﺮﻓﻊ اﻟﻰ أي أس ﺑﺸﺮط أن ﻳﻜﻮن اﻷس ﻋﺪد ﺻﺤﻴﺢ ) ﻷن‬ ‫‪.3‬‬
‫اﻟﺮﻗﻢ اﻟﻤﺮﻓﻮع اﻟﻰ ﻗﻴﻤﻪ ﻣﻌﻴﻨﻪ ﺳﻴﻀﺮب ﺑﻨﻔﺴﻪ ﻋﺪد ﻣﻦ اﻟﻤﺮات ﺑﻘﺪر اﻷس أذا‬
‫آﺎن ﻋﺪد ﺻﺤﻴﺢ وﻻ ﻳﻬﻢ ﻓﻴﻤﺎ أذا آﺎن اﻷﺳﺎس ﺳﺎﻟﺐ أو ﻣﻮﺟﺐ ( ‪.‬‬
‫ﻻﻳﺠﻮز رﻓﻊ اﻟﻘﻴﻤﻪ اﻟﺴﺎﻟﺒﻪ اﻟﻰ أس آﺴﺮي ) وذﻟﻚ ﻷن ﺣﺴﺎب ﻧﺎﺗﺞ اﻟﺮﻗﻢ‬ ‫‪.4‬‬
‫اﻟﻤﺮﻓﻮع اﻟﻰ أس آﺴﺮي ﻳﺘﻢ ﺑﺤﺴﺎب اﻟﻠﻮﻏﺎرﻳﺜﻢ ﻟﻸﺳﺎس ‪ ,‬وﻳﻀﺮب هﺬا‬
‫اﻟﻠﻮﻏﺎرﻳﺜﻢ ﺑﺎﻷس ‪ ,‬وﻋﻨﺪهﺎ ﻳﺤﺴﺐ ﻣﻌﻜﻮس اﻟﻠﻮﻏﺎرﻳﺜﻢ ‪ ,‬وﺣﻴﺚ أن اﻟﻠﻮﻏﺎرﻳﺜﻢ‬
‫ﻟﻠﺮﻗﻢ اﻟﺴﺎﻟﺐ ﻏﻴﺮ ﻣﻌﺮف ﻟﺬا ﻻﻳﻤﻜﻦ أﻳﺠﺎد اﻟﻨﺘﻴﺠﻪ ( ‪.‬‬
‫اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ ﻻﻳﻤﻜﻦ أﺟﺮاؤهﺎ ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪ .‬ﻣﺜﺎل ‪( 'xyz' + 34‬‬ ‫‪.5‬‬
‫) هﺬا ﻏﻴﺮ ﻣﻘﺒﻮل وذﻟﻚ ﻷن ) ‪ ( xyz‬هﻮ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ وﻟﻴﺲ رﻗﻢ أو ﻣﺘﻐﻴﺮ‬
‫رﻗﻤﻲ ) ﻻﺣﻆ أﻧﻪ ﻣﺤﺼﻮر ﺑﻴﻦ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ) ‪( quotation mark‬‬
‫ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ أﻧﻪ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ( ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻣﻤﻜﻦ أﺳﺘﺨﺪام ﻗﻴﻢ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ﻓﻲ اﻟﺘﻌﺎﺑﻴﺮ اﻟﺮﻳﺎﺿﻴﻪ اﻟﺘﻲ ﺗﺴﺘﺨﺪم اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ‬
‫) وﻻ ﻳﻤﻜﻦ اﻟﻌﻜﺲ ( ‪ ,‬ﻓﺄذا آﺎﻧﺖ أﺣﺪى اﻟﻘﻴﻢ ﻷي ﻣﻦ اﻟﻌﻤﻠﻴﺎت ) * ‪ ( + , – ,‬ﻗﻴﻤﻪ‬
‫ﺣﻘﻴﻘﻴﻪ ﻓﺄن اﻟﻘﻴﻤﻪ اﻷﺧﺮى ﺗﺤﻮل اﻟﻰ ﺣﻘﻴﻘﻴﻪ أﻟﻴﺎ ﻗﺒﻞ ﺗﻄﺒﻴﻖ اﻟﻌﻤﻠﻴﻪ ‪.‬‬
‫أﻣﺎ ﻋﻨﺪ أﺳﺘﺨﺪام ﻋﻤﻠﻴﺔ اﻟﻘﺴﻤﻪ ) ‪ ( /‬ﻓﻴﺠﺐ أن ﻳﻜﻮن آﻼ اﻟﻘﻴﻤﺘﻴﻦ ﺣﻘﻴﻘﻴﺘﻴﻦ ‪.‬‬
‫‪7‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪ 1.5.3‬اﻟﺮﻣﻮز ‪Characters‬‬

‫وهﻲ آﺎﻓﺔ اﻟﺮﻣﻮز اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻓﻲ اﻟﺤﺎﺳﻮب واﻟﺘﻲ ﻏﺎﻟﺒﺎ ﻣﺎ ﻧﺠﺪهﺎ ﻋﻠﻰ ﻟﻮﺣﺔ اﻟﻤﻔ ﺎﺗﻴﺢ واﻟﺘ ﻲ‬
‫ﺗ ﺸﻤﻞ اﻟﺤ ﺮوف اﻷﺑﺠﺪﻳ ﻪ ﺳ ﻮاء آﺎﻧ ﺖ ﺣ ﺮوف آﺒﻴ ﺮﻩ ) ‪ (A . . Z‬أو ﺣ ﺮوف ﺻ ﻐﻴﺮﻩ ) ‪, ( a..z‬‬
‫( ‪ ,‬اﻟﺮﻣ ﻮز اﻻﺧ ﺮى اﻟﺘ ﻲ ﻧﺮاه ﺎ ﻋﻠ ﻰ ﻟﻮﺣ ﺔ اﻟﻤﻔ ﺎﺗﻴﺢ ﻣﺜ ﻞ‬ ‫‪0..9‬‬ ‫اﻷرﻗ ﺎم )‬
‫) ‪ ( + , . , / , ? , # , ! , & , % ..etc‬وﺗﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﻔﺮد ‪ .‬وﻳﺼﺮح ﻋﻦ اﻟﺮﻣﻮز ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ‬
‫ﺑﺎﺳ ﻜﺎل ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﺑﺎﻟﺪاﻟ ﻪ ) ‪ . ( char‬وﻻ ﺗﻮﺟ ﺪ هﻨ ﺎك ﻣﺠﻤﻮﻋ ﻪ ﺧﺎﺻ ﻪ ﻣ ﻦ‬
‫اﻟﺮﻣ ﻮز ﻟﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻷن ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﺗ ﺴﺘﺨﺪم ﻣﺠﻤﻮﻋ ﺔ اﻟﺤ ﺮوف ﻟﻠﺤﺎﺳ ﻮب اﻟ ﺬي‬
‫ﺗﻌﻤﻞ ﻋﻠﻴﻪ ‪.‬‬
‫أن أآﺜﺮ ﻣﺠﺎﻣﻴﻊ اﻟﺤﺮوف أﺳﺘﺨﺪاﻣﺎ هﻤﺎ أﺛﻨﺎن ‪:‬‬

‫‪2 ASCII‬‬
‫)‪(American Standard Code for Information International‬‬
‫‪3 EBCDIC‬‬
‫)‪(Extended Binary Coded Decimal Information Code‬‬

‫وآﻞ ﻣﻨﻬﻢ ﻟﻪ ﺻﻔﺎﺗﻪ اﻟﺨﺎﺻﻪ ﺑﻪ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫آﻞ ﻣﺎ ﻳﻜﺘﺐ ﺑﻴﻦ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ) ' ' ( هﻮ واﺣﺪ ﻣﻦ أﺛﻨﻴﻦ ‪:‬‬
‫‪ .1‬أذا آﺎن أآﺜﺮ ﻣﻦ رﻣﺰ واﺣﺪ ﻓﻴﻌﺘﺒﺮ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪.‬‬
‫‪ .2‬أذا آﺎن رﻣﺰ واﺣﺪ ﻓﻴﻌﺘﺒﺮ ﺣﺮف وﻣﻤﻜﻦ ﻓﻲ ﺑﻌﺾ اﻟﺤﺎﻻت ﻳﻌﺘﺒﺮ ﺳﻠﺴﻠﻪ‬
‫ﺣﺮﻓﻴﻪ أذا آﺎن ﻣﻌﺮف آﺬﻟﻚ ‪.‬‬

‫ﻣﺠﻤﻮﻋﺔ اﻟﺤﺮوف ﻟﻬﺎ اﻟﺨﻮاص واﻟﺼﻔﺎت اﻟﺘﺎﻟﻴﻪ ‪:‬‬

‫‪ .1‬آ ﻞ ﺣ ﺮف ﻟ ﻪ ﻋ ﺪد ﺗﺮﺗﻴﺒ ﻲ ) ‪ ( Ordinal Value‬ﻣﺨﺘﻠ ﻒ ‪ ,‬ﺣﻴ ﺚ أن ه ﺬﻩ اﻟﺤ ﺮوف‬


‫ﻣﺮﺗﺒﻪ وﻓﻘﺎ ﻷﺣﺪ اﻟﻨﻈﺎﻣﻴﻦ أﻋﻼﻩ ‪.‬‬
‫وﺗﺴﺘﺨﺪم اﻟﺪاﻟﻪ ) ‪ ( Ord‬ﻟﺘﻌﻴﺪ ﻗﻴﻤﺔ اﻟﻌﺪد اﻟﺘﺮﺗﻴﺒﻲ ‪ ,‬ﻓﻤﺜﻼ أذا آﺎن آﻞ ﻣﻦ‬
‫) ‪ ( ch1 , ch2‬هﻤﺎ ﻣﻦ ﻧﻮع ﺣﺮوف ) ‪ ( char‬وآﺎن‬

‫‪ch1 ≠ ch2‬‬

‫) ‪ord ( ch1 ) ≠ ord ( ch2‬‬ ‫ﻓﺄن‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫اﻟﻌﻮاﻣﻞ اﻟﻮﺣﻴﺪﻩ اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻣﻊ اﻟﻤﺘﻐﻴﺮات اﻟﺤﺮﻓﻴﻪ هﻲ‪:‬‬


‫أن ﺗ(ﻜﻮن ﻣﺮﺗﺒﻪ وﻣﺘﺘﺎﻟﻴﻪ ) ﻣﺘﻌﺎﻗﺒﻪ (‬
‫ﻳﺠﺐ <‬
‫ﻟﻸرﻗﺎم> ) ‪, <=( 0, ..= 9,‬‬
‫اﻟﺘﺮﺗﻴﺒﻲ ‪= ,‬‬
‫‪ .2‬اﻟﻌﺪد ) >‬
‫‪8‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫) '‪Ord ( '1' ) , ord ( '2' ) , ord ( '3' ) , …….., ord ( '9‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫‪ ord ( ' 0 ' ) ≠ 0‬ﻟﺬا ﻓﺄن اﻟﺪاﻟﻪ‬ ‫ﻓﻲ ﻏﺎﻟﺒﻴﺔ اﻟﻤﺠﺎﻣﻴﻊ اﻟﺤﺮﻓﻴﻪ ﻓﺄن‬
‫) ‪ ( ord‬ﻻ ﺗﺤﻮل اﻷرﻗﺎم اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﻤﻘﺎﺑﻠﻪ ‪.‬‬

‫‪ .3‬ﻟﻜﻲ ﻧﺤﻮل اﻟﺮﻗﻢ ﺑﺎﻟﻤﺘﻐﻴﺮ اﻟﺤﺮﻓﻲ ) ‪ ( ch‬اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﺮﻗﻤﻴﻪ اﻟﻤﻘﺎﺑﻠﻪ ) ‪( num‬‬
‫ﻓﻴﺠﺐ أﺳﺘﺨﺪام اﻟﺼﻴﻐﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬

‫; ) ' ‪Num : = ord ( ch ) – ord ( ' 0‬‬

‫‪ .4‬اﻷﻋ ﺪاد اﻟﺘﺮﺗﻴﺒﻴ ﻪ ﻟﻸﺣ ﺮف اﻟﻜﺒﻴ ﺮﻩ ) ‪ ( A , B , ….. , Z‬ﻳﺠ ﺐ أن ﺗﻜ ﻮن ﻣﺮﺗﺒ ﻪ‬


‫وﻟﻴﺲ ﺑﺎﻟﻀﺮورﻩ أن ﺗﻜﻮن ﻣﺘﻌﺎﻗﺒﻪ ‪.‬‬

‫‪ .5‬اﻷﻋ ﺪاد اﻟﺘﺮﺗﻴﺒﻴ ﻪ ﻟﻸﺣ ﺮف اﻟ ﺼﻐﻴﺮﻩ ) ‪ ) ( a , b , ….. , z‬أذا وﺟ ﺪت ( ﻳﺠ ﺐ أن‬


‫ﺗﻜﻮن ﻣﺮﺗﺒﻪ وﻟﻴﺲ ﺑﺎﻟﻀﺮورﻩ أن ﺗﻜﻮن ﻣﺘﻌﺎﻗﺒﻪ ‪.‬‬

‫أن اﻟﻔﻘﺮﺗﻴﻦ ) ‪ 4‬و ‪ ( 5‬ﺗﺆآﺪان ﻋﻠﻰ أن ﺗﻜ ﻮن اﻟﺤ ﺮوف ﻣﺮﺗﺒ ﻪ هﺠﺎﺋﻴ ﺎ ‪ ,‬وﻟﻜ ﻦ ﻟ ﻴﺲ‬
‫ﺑﺎﻟﻀﺮورﻩ أن ﺗﻜﻮن ﻟﻬﺎ أﻋﺪاد ﺗﺮﺗﻴﺒﻴﻪ ﻣﺘﻌﺎﻗﺒﻪ ‪ ,‬ﻓﻤﺜﻼ ﻓﻲ ﻧﻈﺎم ) ‪: ( EBCDIC‬‬

‫‪Ord ( ' I ' ) = 201‬‬


‫‪Ord ( ' J ' ) = 209‬‬

‫‪ .6‬اﻟﺪاﻟ ﻪ ) ‪ ( chr‬ﺗﻌﻤ ﻞ ﻋﻜ ﺲ اﻟﺪاﻟ ﻪ ) ‪ ( ord‬ﻓﻬ ﻲ ﺗﺄﺧ ﺬ ﻣﻌﺎﻣ ﻞ ﻣ ﻦ ﻧ ﻮع ﻋ ﺪد ﺻ ﺤﻴﺢ‬


‫وﺗﻌﻄﻲ اﻟﻘﻴﻤﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻘﺎﺑﻠﻪ ﻟﻪ ‪ ,‬وﻣﺪى ﻋﻤﻞ هﺬﻩ اﻟﺪاﻟﻪ ه ﻮ ﻣ ﺪى ﻋﻤ ﻞ اﻟﺪاﻟ ﻪ‬
‫) ‪.( ord‬‬

‫; ) ‪num : = ord ( ch‬‬


‫; ) ‪ch : = chr ( num‬‬

‫‪ .7‬ﻋﻤﻠﻴﺎ أذا ﻣﺎ أﺧﺬﻧﺎ رﻗﻢ ) ‪ ( num‬ﻣﻦ ﻧﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ) ‪( 0 ≤ num ≤ 9‬‬
‫ﻓﺄن اﻟﺤﺮف اﻟﻤﻘﺎﺑﻞ ﻟﻪ هﻮ وﻓﻘﺎ ﻟﻠﺼﻴﻐﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬

‫; )) ' ‪ch : = chr ( num + ord ( ' 0‬‬


‫ﻣﺜﻼ ‪:‬‬
‫' ‪chr ( 3 + ord ( ' 0 ' ) ) = ' 3‬‬
‫‪9‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪ 1.5.4‬اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪STRING‬‬

‫وه ﻲ ﻋﺒ ﺎرﻩ ﻋ ﻦ ﻣﺘﻮاﻟﻴ ﻪ ﻣ ﻦ اﻟﺮﻣ ﻮز اﻟﻤﺒﻴﻨ ﻪ ﻓ ﻲ اﻟﻔﻘ ﺮﻩ اﻟ ﺴﺎﺑﻘﻪ ‪ ,‬آ ﺬﻟﻚ ﻳﻤﻜ ﻦ أن ﺗﺤﺘ ﻮي‬
‫اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ﻋﻠﻰ ﻓﺮاغ وﻳﻌﺘﺒﺮ رﻣﺰ وﻟﻜﻦ ﻻ ﻳﻤﻜ ﻦ أن ﺗﺤﺘ ﻮي اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ﻋﻠ ﻰ ﻋﻼﻣ ﺎت‬
‫اﻷﻗﺘﺒ ﺎس ‪ .‬أن اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ﺗ ﺴﺘﺨﺪم ﻟﺘﻌﺮﻳ ﻒ اﻟﻤﻌﻠﻮﻣ ﺎت ﻏﻴ ﺮ اﻟﺮﻗﻤﻴ ﻪ ﻣﺜ ﻞ اﻷﺳ ﻤﺎء ‪ ,‬اﻟﻌﻨ ﺎوﻳﻦ‬
‫وﻏﻴﺮهﺎ‪ ,‬وأن ﻋﺪد اﻟﺤﺮوف اﻟﺘﻲ ﺗﺴﺘﻮﻋﺒﻬﺎ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل هﻲ ) ‪. ( 0 .. 255‬‬
‫وﻳ ﺼﺮح ﻋ ﻦ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﺑﺎﻟﺪاﻟ ﻪ‬
‫) ‪ . ( string‬ﻣﺜﺎل‬

‫'‪'Xyz‬‬
‫'‪'Ali Abbas‬‬
‫'‪'Apollo-17‬‬
‫'‪'Do you wish to try again‬‬

‫اﻟﺠﻤﻠﻪ اﻷﺧﻴﺮﻩ ﺗﻌﺘﺒﺮ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ‪ ,‬آ ﺬﻟﻚ ﻓ ﺄن اﻷرﻗ ﺎم ﻋﻨ ﺪﻣﺎ ﺗﻌ ﺮف ﻣ ﻊ اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ‬
‫ﺗﻌﺎﻣﻞ آﺮﻣﻮز وﻟﻴﺲ أرﻗﺎم ‪.‬‬

‫اﻟﺘﻌﺎﺑﻴﺮ اﻟﻤﻨﻄﻘﻴﻪ ‪THE BOOLEAN EXPRESSIONS‬‬ ‫‪1.6‬‬

‫وه ﻲ اﻟﺘﻌ ﺎﺑﻴﺮ اﻟﺘ ﻲ ﺗﻤﺜ ﻞ ﻧﺘﻴﺠﺘﻬ ﺎ ﺑﺤﺎﻟ ﻪ واﺣ ﺪﻩ ﻣ ﻦ أﺛﻨﺘ ﻴﻦ وهﻤ ﺎ ) ﺻ ﺢ أو ﺧﻄ ﺄ (‬
‫) ‪ , (true OR false‬وهﻨﺎك ﺛﻼث ﻋﻮاﻣﻞ ﻣﻨﻄﻘﻴﻪ وهﻲ ) ‪. (And , Or , Not‬‬
‫واﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﻳﻌﻴ ﺪ اﻟﻘﻴﻤ ﻪ ) ‪ ( 1‬ﻋﻨ ﺪﻣﺎ ﻳﻜ ﻮن اﻟﺘﻌﺒﻴ ﺮ ) ‪ ( TRUE‬واﻟﻘﻴﻤ ﻪ ) ‪ ( 0‬ﻋﻨ ﺪﻣﺎ‬
‫ﻳﻜﻮن اﻟﺘﻌﺒﻴﺮ ) ‪ . ( FALSE‬وهﻲ ﺗﺴﺘﺨﺪم ﻟﻮﺻ ﻒ أي ﺗﻌﺒﻴ ﺮ ﻓﻴﻤ ﺎ أذا آ ﺎن ﺻ ﺢ أو ﺧﻄ ﺄ ‪ .‬أن أﻧ ﻮاع‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻟﻬﺬا اﻟﻐﺮض ﻳﺼﺮح ﻋﻨﻬﺎ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات ﺑﺎﻟﺪاﻟﻪ ) ‪.( Boolean‬‬

‫‪ 1.6.1‬اﻟﻌﻤﻠﻴﺎت اﻟﻤﻨﻄﻘﻴﻪ ‪LOGIC OPERATORS‬‬

‫هﻨﺎك ﺛﻼث أﻧﻮاع ﻣ ﻦ اﻟﻌﻤﻠﻴ ﺎت اﻟﻤﻨﻄﻘﻴ ﻪ وه ﻲ ) ‪ ( AND , OR , NOT‬آ ﻞ ﻣﻨﻬ ﺎ ﻳﺘﻌﺎﻣ ﻞ‬


‫ﻣ ﻊ اﻟﺘﻌ ﺎﺑﻴﺮ اﻟ ﺸﺮﻃﻴﻪ ) أي اﻟﺘ ﻲ ﺗﺤﺘ ﻮي ﺷ ﺮط (‪ .‬آ ﻞ واﺣ ﺪ ﻣ ﻦ ه ﺬﻩ اﻟﺘﻌ ﺎﺑﻴﺮ ﻟ ﻪ ﺗ ﺄﺛﻴﺮ ﻣﺨﺘﻠ ﻒ ﻋﻠ ﻰ‬
‫اﻟﺘﻌ ﺎﺑﻴﺮ اﻟ ﺸﺮﻃﻴﻪ ‪ .‬أدﻧ ﺎﻩ أﻣﺜﻠ ﻪ ﺗﺒ ﻴﻦ آﻴﻔﻴ ﺔ أﺳ ﺘﺨﺪام ه ﺬﻩ اﻟﺘﻌ ﺎﺑﻴﺮ واﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ أن ﺗ ﺴﺘﺨﺪم ﺑ ﻴﻦ‬
‫ﺗﻌﺒﻴﺮﻳﻦ أو أآﺜﺮ ﻣﻦ اﻟﺘﻌﺎﺑﻴﺮ اﻟﺸﺮﻃﻴﻪ‪.‬‬

‫• ‪AND‬‬

‫‪If (Str1 = 'a') AND (Str2 = 'b') then‬‬

‫; ) '‪Writeln ( 'Yes, you got it right.‬‬


10 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

( And ) ( ‫ ﺟﺪول اﻟﺼﺪق ﻟﻠﻌﺎﻣﻞ ) و‬: ( 1.1 ) ‫ﺟﺪول‬

Expression 1 Expression 2 AND (result)

true true true


false true false
true false false
false false false

OR •

If (Str1 = 'a') OR (Str2 = 'b') then

writeln('Yes, you got it right.');

( Or ) ( ‫ ﺟﺪول اﻟﺼﺪق ﻟﻠﻌﺎﻣﻞ ) أو‬: ( 1.2 ) ‫ﺟﺪول‬

Expression 1 Expression 2 OR (result)


true true true
false true true
true false true
false false false

NOT •

( Not ) ( ‫ ﺟﺪول اﻟﺼﺪق ﻟﻠﻌﺎﻣﻞ ) ﻻ‬: ( 1.3 ) ‫ﺟﺪول‬

Input Output
true false
false true
‫‪11‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫اﻟﻌﺎﻣﻞ ) ‪ ( NOT‬ﻳﺨﺘﻠﻒ ﻋ ﻦ اﻟﻌ ﺎﻣﻠﻴﻦ اﻟ ﺴﺎﺑﻘﻴﻦ ﺣﻴ ﺚ أﻧ ﻪ ﻳﺘﻘﺒ ﻞ ﻣ ﺪﺧﻞ واﺣ ﺪ وداﺋﻤ ﺎ ﻳﻌﻜ ﺲ‬
‫ﺣﺎﻟﺔ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﻳ ﺪﺧﻞ ﻋﻠﻴﻬ ﺎ ﻓ ﺄذا آﺎﻧ ﺖ ﺻ ﺤﻴﺤﻪ ﻓﻴﺠﻌﻠﻬ ﺎ ﺧﺎﻃﺌ ﻪ وأن آﺎﻧ ﺖ ﺧﺎﻃﺌ ﻪ ﻳﺠﻌﻠﻬ ﺎ‬
‫ﺻﺤﻴﺤﻪ‪.‬‬

‫ﺟﺪول ) ‪ : ( 1.4‬أهﻢ أﻧﻮاع اﻟﻤﺘﻐﻴﺮات اﻟﻤﺴﺘﺨﺪﻣﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫اﻟﻤﻼﺣﻈﺎت‬ ‫اﻟﺤﺠﻢ‬ ‫اﻟﻤﺪى‬ ‫اﻟﻨﻮع‬


‫)ﺑﺎﻳﺖ (‬
‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬ ‫‪1‬‬ ‫‪0 .. 255‬‬ ‫‪Byte‬‬
‫ﻣﻮﺟﺒﻪ ﻓﻘﻂ‬
‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬ ‫‪2‬‬ ‫‪0 .. 65535‬‬ ‫‪Word‬‬
‫ﻣﻮﺟﺒﻪ ﻓﻘﻂ‬
‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬ ‫‪1‬‬ ‫‪-128 .. 127‬‬ ‫‪Shortint‬‬

‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬ ‫‪4‬‬ ‫‪-2146473648 … 2146473647‬‬ ‫‪Longint‬‬

‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬ ‫‪6‬‬ ‫‪2.9x10-39 .. 1.7x1038‬‬ ‫‪Real‬‬

‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬ ‫‪4‬‬ ‫‪1.5x10-45 .. 3.4x1038‬‬ ‫‪Sigle‬‬

‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬ ‫‪8‬‬ ‫‪5.0x10-324 .. 1.7x10308‬‬ ‫‪Double‬‬

‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬ ‫‪10‬‬ ‫‪3.4x10-4932 .. 1.1x104932‬‬ ‫‪Extended‬‬

‫ﻏﻴﺮ رﻗﻤﻴﻪ‬ ‫‪1‬‬ ‫ﺣﺮف واﺣﺪ‬ ‫‪Char‬‬

‫ﻏﻴﺮ رﻗﻤﻴﻪ‬ ‫‪255‬‬ ‫‪ 255‬ﺣﺮف‬ ‫‪String‬‬

‫ﻏﻴﺮ رﻗﻤﻴﻪ‬ ‫‪1‬‬ ‫‪True / False‬‬ ‫‪Boolean‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫أن أﺳﻨﺎد ﻗﻴﻤﻪ ﻟﻤﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﻣﻌﻴﻦ ﺧﺎرج اﻟﻤﺪى اﻟﻤﺤﺪد ﻟﻪ ﺳﻴﺆدي اﻟﻰ ﺣﺪوث ﺧﻄﺄ ‪ ,‬هﺬا‬
‫اﻟﺨﻄﺄ أﻣﺎ أن ﻳﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ أو ﻳﺆدي اﻟﻰ ﻇﻬﻮر ﻧﺘﺎﺋﺞ ﻏﻴﺮ ﻣﺘﻮﻗﻌﻪ ‪.‬‬
‫‪12‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺟﺪول ) ‪ : ( 1.5‬ﺑﻌﺾ اﻟﺪوال اﻟﻤﻬﻤﻪ اﻟﻤﺴﺘﺨﺪﻣﻪ ﻣﻊ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫ﻣﺜﺎل‬ ‫اﻟﻮﻇﻴﻔﻪ‬ ‫اﻟﺪاﻟﻪ‬

‫‪Abs ( -5 ) = 5‬‬ ‫ﻷﻳﺠ ﺎد اﻟﻘﻴﻤ ﻪ اﻟﻤﻄﻠﻘ ﻪ ﻟﻌ ﺪد‬ ‫‪abs‬‬


‫ﺳﺎﻟﺐ ) ﻳﺤﻮل اﻟﻌﺪد اﻟ ﺴﺎﻟﺐ‬
‫اﻟﻰ ﻣﻮﺟﺐ (‬
‫‪Sqr ( 5 ) = 25‬‬ ‫أﻳﺠﺎد ﻣﺮﺑﻊ ﻋﺪد‬ ‫‪sqr‬‬
‫‪Sqrt ( 25 ) = 5.0000000000E+00‬‬ ‫أﻳﺠﺎد اﻟﺠ ﺬر اﻟﺘﺮﺑﻴﻌ ﻲ ﻟﻌ ﺪد‬ ‫‪sqrt‬‬
‫ﻣﻮﺟﺐ‬
‫‪Sin ( 30 * Pi / 180 ) = 5.0000000000E-01‬‬ ‫اﻳﺠﺎد ﺟﻴﺐ زاوﻳﻪ‬ ‫‪sin‬‬
‫‪Cos ( 60 * Pi / 180 ) = 5.0000000000E-01‬‬ ‫أﻳﺠﺎد ﺟﻴﺐ ﺗﻤﺎم زاوﻳﻪ‬ ‫‪cos‬‬
‫‪Trunk ( 5. 2431 ) = 5‬‬ ‫ﺗﺤﻮل اﻷﻋﺪاد اﻟﻜ ﺴﺮﻳﻪ اﻟ ﻰ‬ ‫‪trunk‬‬
‫‪Trunk ( -5.6 ) = -5‬‬ ‫أﻋﺪاد ﺻﺤﻴﺤﻪ وذﻟﻚ ﺑﺤﺬف‬
‫اﻟﻜﺴﺮ‬
‫‪Round ( 5.2431 ) = 5‬‬ ‫ﻳﻘ ﺮب اﻟﻌ ﺪد اﻟﻜ ﺴﺮي اﻟ ﻰ‬ ‫‪round‬‬
‫‪Round ( 5.765 ) = 6‬‬ ‫أﻗﺮب ﻋﺪد ﺻﺤﻴﺢ‬
‫‪Round ( -5.8 ) = -6‬‬
‫‪Int ( 2.31 ) = 2.0000000000E+00‬‬ ‫ﻳﺤ ﻮل اﻟﻌ ﺪد اﻟﻜ ﺴﺮي اﻟ ﻰ‬ ‫‪Int‬‬
‫ﻋﺪد ﺻﺤﻴﺢ‬
‫ﻧﻔﺮض أن ﻗﻴﻤﺔ ) ‪ ( x‬هﻲ ‪x = 10‬‬ ‫ﻳﻌﻤ ﻞ ﻋﻠ ﻰ زﻳ ﺎدة اﻟﻤﺘﻐﻴ ﺮ‬ ‫‪inc‬‬
‫ﻋﻠﻴﻪ ﻓﺄن ) ) ‪ ( inc ( x‬ﺳﺘﺆدي اﻟﻰ ‪x = 11‬‬ ‫ﺑﻘ ﺪار واﺣ ﺪ أو ﺣ ﺴﺐ ﻣ ﺎ‬
‫أﻣﺎ )) ‪ ( inc ( x, 4‬ﺳﺘﺆدي اﻟﻰ ‪x = 14‬‬ ‫ﻣﺤﺪد‬
‫ﻧﻔﺮض أن ﻗﻴﻤﺔ ) ‪ ( x‬هﻲ ‪x = 15‬‬ ‫ﺗﻘﻠﻴﺺ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺑﻤﻘ ﺪار‬ ‫‪dec‬‬
‫ﻋﻠﻴﻪ ﻓﺄن ) ) ‪ ( dec ( x‬ﺳﺘﺆدي اﻟﻰ ‪x = 14‬‬ ‫واﺣﺪ أو ﺣﺴﺐ ﻣﺎ ﻣﺤﺪد‬
‫أﻣﺎ ) ) ‪ ( dec ( x , 5‬ﺳﺘﺆدي اﻟﻰ ‪x = 10‬‬
‫أذا آﺎﻧﺖ ) ‪ ( x = 10‬ﻓﺄن ) ‪( pred ( x ) = 9‬‬ ‫ﺗﻌﻄ ﻲ اﻟﻘﻴﻤ ﻪ اﻟ ﺴﺎﺑﻘﻪ‬ ‫‪pred‬‬
‫ﻟﻠﻤﺘﻐﻴﺮ‬
‫أذا آﺎﻧﺖ ) ‪ ( x = 10‬ﻓﺄن ) ‪(succ ( x ) = 11‬‬ ‫ﺗﻌﻄ ﻲ اﻟﻘﻴﻤ ﻪ اﻟﻼﺣﻘ ﻪ‬ ‫‪succ‬‬
‫ﻟﻠﻤﺘﻐﻴﺮ‬
‫أذا آﺎﻧﺖ ) ‪ ( x = 9‬ﻓﺄن‬ ‫ﻳﻔﺤﺺ اﻟﻤﺘﻐﻴﺮ ﻓﻴﻤﺎ أذا آﺎن‬ ‫‪odd‬‬
‫) ) ‪ ( odd ( x‬ﺳﺘﻜﻮن ) ‪( true‬‬ ‫ﻋ ﺪد ﻓ ﺮدي أم ﻻ وﻧﺘﻴﺠﺘ ﻪ‬
‫ﺗﻜﻮن ﺻﺢ أو ﺧﻄﺄ‬
‫‪Ln ( 8 ) = 2.0794415417E+0‬‬ ‫ﺗﻌﻄ ﻲ ﻗﻴﻤ ﺔ اﻟﻠﻮﻏ ﺎرﻳﺘﻢ‬ ‫‪ln‬‬
‫اﻟﻄﺒﻴﻌ ﻲ ) أي ﻟﻸﺳ ﺎس‬
‫)‪((e‬‬
‫‪13‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬

‫هﻨﺎك ﻧﻮﻋﺎن ﻣﻦ اﻟﺪوال ‪ ..‬اﻟﺪوال اﻟﻘﻴﺎﺳﻴﻪ وهﻲ اﻟﺪوال اﻟﻤﻌﺮﻓﻪ ﺿﻤﻦ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ‬
‫ﻣﺜﻞ اﻟﺪوال ﻓﻲ اﻟﺠﺪول ) ‪ , ( 1.5‬ودوال ﺗﻌﺮف ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم واﻟﺘﻲ ﺳﻨﺸﺮﺣﻬﺎ‬
‫ﻓﻲ اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﺗﻘﺎس اﻟﺰواﻳﺎ ﻓﻲ اﻟﺪوال اﻟﺘﻲ ﺗﺴﺘﺨﺪم اﻟﺰواﻳﺎ ) ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ( ﺑﻤﺎ ﻳﺴﻤﻰ‬
‫ﺑﺎﻟﻨﺼﻒ ﻗﻄﺮﻳﻪ ) ‪ ( Radians‬وﻟﻴﺲ ﺑﺎﻟﺪرﺟﺎت آﻤﺎ هﻮ اﻟﺤﺎل ﻓﻲ اﻟﺮﻳﺎﺿﻴﺎت ‪,‬‬
‫وﻟﺘﺤﻮﻳﻞ أي زاوﻳﻪ ) ‪ ( angle‬ﻣﻦ اﻟﻘﻴﺎس ﺑﺎﻟﺪرﺟﺎت اﻟﻰ اﻟﻨﺼﻒ ﻗﻄﺮﻳﻪ ﻧﺘﺒﻊ‬
‫اﻟﻌﻼﻗﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬

‫‪Angle ( in radians ) : = angle ( in degree ) * Pi / 180‬‬

‫ﺣﻴﺚ أن ) ‪ ( Pi‬هﻲ اﻟﻨﺴﺒﻪ اﻟﺜﺎﺑﺘﻪ وهﻲ ﻣﻦ اﻟﻘﻴﻢ اﻟﻤﺨﺰوﻧﻪ ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫وﺳﻴﻌﻮض ﻋﻨﻬﺎ أﻟﻴﺎ ﺑﻘﻴﻤﺘﻬﺎ اﻟﺒﺎﻟﻐﻪ ) ‪. ( 3.1415926535897932385‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫‪Ord ( true ) = 1‬‬


‫‪Ord ( false ) = 0‬‬
‫‪Pred ( true ) = false‬‬
‫‪Succ ( false ) = true‬‬

‫ﺗﻮﻟﻴﺪ اﻷرﻗﺎم اﻟﻌﺸﻮاﺋﻲ ‪RANDOM NUMBERS GENERATION‬‬ ‫‪1.7‬‬

‫ﺗﺤﺘﺎج ﺑﻌﺾ اﻟﺘﻄﺒﻴﻘﺎت اﻟﻰ أﺳﺘﺨﺪام أرﻗﺎم ﻋ ﺸﻮاﺋﻴﻪ وه ﺬا ﻣﻤﻜ ﻦ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل وذﻟ ﻚ ﻣ ﻦ‬
‫ﺧﻼل أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Random‬اﻟﺬي ﻳﻌﻤﻞ ﻋﻠﻰ ﺗﻮﻟﻴﺪ رﻗﻢ ﺑ ﺸﻜﻞ ﻋ ﺸﻮاﺋﻲ ‪ ,‬وه ﻮ ﻳﻌﻤ ﻞ وﻓﻘ ﺎ ﻟﻤ ﺎ‬
‫ﻳﻠﻲ ‪:‬‬
‫• ﻳﺴﺘﺨﺪم ﻣ ﻊ اﻷﻣ ﺮ ) ‪ ( Randomize‬ﺣﻴ ﺚ ﻳﺠ ﺐ أن ﻳ ﺴﺒﻖ أﺳ ﺘﺨﺪام اﻷﻣ ﺮ ) ‪ ( Random‬آﺘﺎﺑ ﺔ‬
‫اﻷﻣﺮ ) ‪ , ( Randomize‬وﺑﺬﻟﻚ ﻓﺄن اﻷﻣﺮ ) ‪ ( Random‬ﺳ ﻴﻮﻟﺪ أرﻗ ﺎم ﻋ ﺸﻮاﺋﻴﻪ ﺗﺘ ﺮاوح ﻗﻴﻤﻬ ﺎ‬
‫ﺑﻴﻦ اﻟﺼﻔﺮ واﻟﻮاﺣﺪ ) ﻏﻴﺮ داﺧﻞ ( ) أي أرﻗﺎم آﺴﺮﻳﻪ ﻣﻮﺟﺒﻪ ﻗﻴﻤﺘﻬﺎ أﻗﻞ ﻣﻦ واﺣﺪ ( ﻣﺜﺎل ‪:‬‬
‫‪14‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫; ‪Randomize‬‬
‫; ‪X : = random‬‬

‫هﻨﺎ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﺗﻜﻮن ﻗﻴﻤﺘﻪ ) ‪ ( 0 <= x < 1‬وﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﺗﻨﻔﻴﺬ هﺬا اﻷﻣﺮ ﺳﻨﺤﺼﻞ ﻋﻠﻰ ﻗﻴﻤﻪ‬
‫ﺟﺪﻳﺪﻩ ﺿﻤﻦ ﻧﻔﺲ اﻟﻤﺪى ‪.‬‬

‫• اﻟﻄﺮﻳﻘﻪ اﻟﺜﺎﻧﻴﻪ هﻲ ﺑﺄﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Randomize‬أﻳﻀﺎ ﺛﻢ اﻷﻣﺮ ) ‪ ( Random‬ﻋﻠﻰ أن‬


‫ﻳﺤﺘﻮي اﻷﻣﺮ ) ‪ ( Random‬ﻋﻠﻰ اﻟﻤﺪى اﻟﻤﻄﻠﻮب أﻳﺠﺎد اﻟﺮﻗﻢ اﻟﻌﺸﻮاﺋﻲ ﺿﻤﻨﻪ ) أي أﻧﻪ ﺳﻴﻮﻟﺪ‬
‫أﻋﺪاد ﺻﺤﻴﺤﻪ ﻣﻮﺟﺒﻪ ﻋﺸﻮاﺋﻴﺎ ﺗﺘﺮاوح ﻗﻴﻤﻬﺎ ﺑﻴﻦ اﻟﺼﻔﺮ واﻟﻌﺪد اﻟﻤﺤﺪد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺑﻌﺪ (‬
‫) ‪ Random‬واﻟﺬي ﻳﻤﺜﻞ اﻟﺤﺪ اﻷﻋﻠﻰ ( ‪ ,‬ﻣﺜﺎل ‪:‬‬

‫; ‪Randomize‬‬
‫; ) ‪X : = random ( 100‬‬

‫هﻨﺎ ﺗﻜ ﻮن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( 0 <= x < 100 ) ( x‬وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﻳﻌ ﺎد ﺗﻨﻔﻴ ﺬ ه ﺬا اﻷﻣ ﺮ ﺳﻨﺤ ﺼﻞ‬
‫ﻋﻠﻰ ﻗﻴﻤﻪ ﺟﺪﻳﺪﻩ ‪ .‬أن اﻟﻤﺪى اﻟﻤﺤﺪد ﻳﻤﻜﻦ ﺗﻐﻴﺮﻩ ﺣﺴﺐ ﻃﺒﻴﻌﺔ اﻟﺘﻄﺒﻴﻖ اﻟﻤﺮاد ﺗﻨﻔﻴﺬﻩ ‪.‬‬

‫• اﻟﻄﺮﻳﻘﻪ اﻟﺜﺎﻟﺜﻪ ﻷﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Random‬هﻲ ﺑﺪون أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Randomize‬وﺑ ﺪﻻ‬
‫ﻣﻨﻪ ﻧﺴﺘﺨﺪم اﻟﻤﺘﻐﻴﺮ ) ‪ ( Randseed‬ﻗﺒﻞ اﻷﻣﺮ ) ‪ ( Random‬ﻋﻠﻰ أن ﻳﺘﻢ أﺳﻨﺎد ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴ ﺮ (‬
‫) ‪ , Randseed‬هﺬﻩ اﻟﻄﺮﻳﻘ ﻪ ﻣ ﻦ وﺟﻬ ﺔ ﻧﻈ ﺮي ه ﻲ اﻷﻓ ﻀﻞ ﻷن اﻟﻄ ﺮﻳﻘﺘﻴﻦ اﻟ ﺴﺎﺑﻘﺘﻴﻦ ﺳ ﺘﻮﻟﺪان‬
‫ﻧﻔﺲ ﻣﺠﻤﻮﻋﺔ اﻟﻘﻴﻢ ﻋﻨﺪ أﻳﻘ ﺎف اﻟﺒﺮﻧ ﺎﻣﺞ وأﻋ ﺎدة ﺗﻨﻔﻴ ﺬﻩ ﻣﻤ ﺎ ﻻ ﻳ ﺆدي اﻟ ﻰ ﻋ ﺸﻮاﺋﻴﻪ ﺣﻘﻴﻘﻴ ﻪ ‪ ,‬ﺑﻴﻨﻤ ﺎ‬
‫هﺬﻩ اﻟﻄﺮﻳﻘﻪ ﺳﺘﻮﻟﺪ ﻣﺠﻤﻮﻋﺔ أرﻗﺎم ﻋﺸﻮاﺋﻴﻪ ﻣﺨﺘﻠﻔﻪ ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﻓﻴﻬﺎ أﻋ ﺎدة اﻟﺘﻨﻔﻴ ﺬ ﻋﻠ ﻰ أن ﻳ ﺘﻢ‬
‫أﺳﻨﺎد ﻗﻴﻢ ﻣﺨﺘﻠﻔﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( Randseed‬ﻋﻨﺪ آﻞ ﺗﻨﻔﻴﺬ ‪ ,‬ﻣﺜﺎل‬

‫; ‪Randseed : = 1200‬‬
‫; ‪X : = random‬‬

‫‪OR‬‬

‫; ‪Randseed : = 3425‬‬
‫; ) ‪X : = random ( 1000‬‬

‫ﻓﻲ اﻟﺤﺎﻟﻪ اﻷوﻟﻰ ﻓﺄن اﻟﻤﺘﻐﻴﺮ ) ‪ ( randseed‬أﺳﻨﺪ ﻟﻪ ﻗﻴﻤﻪ وهﻲ ) ‪ ( 1200‬ووﻓﻘﺎ ﻟﻬﺎ ﺳﻴﻮﻟﺪ أرﻗﺎم‬
‫ﻋﺸﻮاﺋﻴﻪ آﺴﺮﻳﻪ أﻗﻞ ﻣﻦ واﺣﺪ وﻟﻮ أﻋﺪﻧﺎ اﻟﺘﻨﻔﻴﺬ ﻣﻊ أﺳﻨﺎد ﻗﻴﻤﻪ ﻣﺨﺘﻠﻔﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( randseed‬ﻓﺄن رﻗﻢ‬
‫ﻋﺸﻮاﺋﻲ ﻣﺨﺘﻠﻒ ﺳﺘﻮﻟﺪ ) ﺣﺎول ﺗﻨﻔﻴﺬ اﻟﻄﺮﻳﻘﺘﻴﻦ وﻻﺣﻆ اﻟﻔﺮق ( ‪.‬‬
‫أﻣﺎ اﻟﻤﺜﺎل اﻟﺜﺎﻧﻲ ﻓﺄﻧﻪ ﺳﻴﻮﻟﺪ أرﻗﺎم ﻋﺸﻮاﺋﻴﻪ أآﺒﺮ ﻣﻦ اﻟﺼﻔﺮ وأﺻﻐﺮ ﻣﻦ ) ‪. ( 1000‬‬
‫‪15‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬

‫أواﻣﺮ اﻷدﺧﺎل واﻷﺧﺮاج ‪INPUT / OUTPUT INSTRUCTIONS‬‬

‫اﻟﻤﻘﺪﻣﻪ‬ ‫‪2.1‬‬

‫ﺟﻤﻴ ﻊ اﻟﻠﻐ ﺎت اﻟﻄﺒﻴﻌﻴ ﻪ اﻟﺘ ﻲ ﻳﺘﻌﺎﻣ ﻞ ﺑﻬ ﺎ اﻷﻧ ﺴﺎن آﻮﺳ ﻴﻠﻪ ﻟﻠﺘﺨﺎﻃ ﺐ واﻟﺘﻮاﺻ ﻞ ﻟﻬ ﺎ ﻗﻮاﻋ ﺪ‬
‫وﺿﻮاﺑﻂ ﺗﺤﺪد أﻟﻴﺔ أﺳﺘﺨﺪاﻣﻬﺎ ‪ ,‬وﻟﻤﺎ آﺎﻧﺖ ﻟﻐﺎت اﻟﺒﺮﻣﺠﻪ ﺗﺼﻨﻒ ﻋﻠﻰ أﻧﻬ ﺎ ﻣ ﻦ اﻟﻠﻐ ﺎت اﻟﻌﻠﻴ ﺎ‬
‫) أي اﻟﻠﻐﺎت اﻟﻘﺮﻳﺒﻪ ﻣﻦ ﻟﻐﺎت اﻟﺒﺸﺮ ( ﻓﻜﺎن ﻻ ﺑ ﺪ وأن ﺗﻜ ﻮن ﻟﻬ ﺎ ﻗﻮاﻋ ﺪ ﺗﺤ ﺪد أﻟﻴ ﺔ أﺳ ﺘﺨﺪاﻣﻬﺎ‬
‫ﻟﺘﻜ ﻮن واﺿ ﺤﻪ ﻟﻠﻤﺘﻌﺎﻣ ﻞ ﻣﻌﻬ ﺎ وآ ﺬﻟﻚ ﻟﻠﻤﺘ ﺮﺟﻢ داﺧ ﻞ اﻟﺤﺎﺳ ﻮب ‪ .‬ﻋﻠﻴ ﻪ ﻓ ﺄن ه ﺬا اﻟﻔ ﺼﻞ‬
‫واﻟﻔ ﺼﻮل اﻻﺣﻘ ﻪ ﺳﺘﻮﺿ ﺢ ه ﺬﻩ اﻟﻘﻮاﻋ ﺪ وﺳ ﻨﺒﺪأ ﺑﻤﻌﺮﻓ ﺔ آﻴﻔﻴ ﺔ ﺗﻠﻘ ﻴﻢ اﻟﺤﺎﺳ ﻮب ﺑﺎﻟﻤﻌﻠﻮﻣ ﺎت‬
‫وﻃﺮق اﻟﺤﺼﻮل ﻋﻠﻰ اﻟﻨﺘﺎﺋﺞ ﺑﻌﺪ أﻧﺠﺎز ﻋﻤﻠﻴﺎت اﻟﺤﺴﺎب ﺧﻼل هﺬا اﻟﻔﺼﻞ ‪.‬‬

‫هﻴﻜﻠﻴﻪ اﻟﺒﺮﻧﺎﻣﺞ ‪PROGRAM CONSTRUCTION‬‬ ‫‪2.2‬‬

‫ﻳﺘﻜ ﻮن اﻟﺒﺮﻧ ﺎﻣﺞ ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣ ﻦ ) اﻟ ﺮأس واﻟﺠ ﺴﻢ ( ) ‪( head and block‬‬
‫واﻟﺮأس هﻮ اﻟﺴﻄﺮ اﻷول ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وﻳﺒ ﺪأ ﺑﻜﻠﻤ ﻪ ﺑﺮﻧ ﺎﻣﺞ ﺑﺎﻟﻠﻐ ﻪ اﻻﻧﻜﻠﻴﺰﻳ ﻪ وﻳﺘﺒ ﻊ ﺑﺄﺳ ﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﺛ ﻢ‬
‫اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ) ; ( وآﻤﺎ ﻳﻠﻲ ‪:‬‬

‫; ‪Program programname‬‬

‫ﻻﺣﻆ هﻨﺎ ﻳﺠﺐ ان ﻳﻜﻮن هﻨﺎك ﻓﺮاغ ﺑﻴﻦ آﻠﻤﺔ ﺑﺮﻧﺎﻣﺞ وأﺳﻢ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬أﻣ ﺎ أﺳ ﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻴ ﺘﻢ‬
‫أﺧﺘﻴﺎرﻩ ﻣﻦ ﻗﺒﻞ اﻟﻤﺒﺮﻣﺞ ‪ ,‬وأﺳﺘﺨﺪام اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃ ﻪ ﺗ ﺪل ﻋﻠ ﻰ ﻧﻬﺎﻳ ﺔ اﻟﻌﺒ ﺎرﻩ وه ﻲ ﺗ ﺴﺘﺨﺪم ﻣ ﻊ آ ﻞ‬
‫اﻟﻌﺒﺎرات ﻓﻲ ﺑﺮاﻣﺞ ﺑﺎﺳﻜﺎل ﻟﻠﺪﻻﻟﻪ ﻋﻠ ﻰ ﻧﻬﺎﻳ ﺔ اﻟﻌﺒ ﺎرﻩ وﺑﺪاﻳ ﺔ ﻋﺒ ﺎرﻩ ﺟﺪﻳ ﺪﻩ ﻋ ﺪا ﺑﻌ ﺾ اﻟﺤ ﺎﻻت اﻟﺘ ﻲ‬
‫ﺳﻴﺘﻢ اﻻﺷﺎرﻩ ﻟﻬﺎ ﻓﻲ ﺣﻴﻨﻬﺎ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬

‫ﻳﺠﺐ أن ﺗﻈﻬﺮ اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ﻓﻲ ‪:‬‬


‫‪ .1‬ﺑﻌﺪ ﻋﺒﺎرة رأس اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬اﻷﺟﺮاء ‪ ,‬أو اﻟﺪاﻟﻪ ‪.‬‬
‫‪ .2‬ﺑﻌﺪ آﻞ ﻗﺎﺋﻤﺔ ﺗﻌﺮﻳﻔﺎت ﻣﻮﺟﻮدﻩ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ ‪ ,‬اﻟﻨﻮع ‪,‬‬
‫واﻟﻤﺘﻐﻴﺮات ‪.‬‬
‫‪ .3‬ﺑﻴﻦ اﻟﻌﺒﺎرات اﻟﻜﺎﻣﻠﻪ ﻓﻲ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬي ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ أهﻤﺎل اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ﺑﻌﺪ اﻟﻌﺒﺎرات اﻟﺘﻲ ﺗﺴﺒﻖ اﻷﻣﺮ ) ‪. ( end‬‬
‫‪16‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫أﻣ ﺎ ﺟ ﺴﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻴﺘﻜ ﻮن ﻣ ﻦ ﻗ ﺴﻤﻴﻦ اﻷول ه ﻮ ﻗ ﺴﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﺜﻮاﺑ ﺖ واﻟﻤﺘﻐﻴ ﺮات‬
‫وﻏﻴﺮهﺎ واﻟﺘﻲ ﺳﻨﺄﺗﻲ ﻋﻠﻴﻬﺎ ﻻﺣﻘﺎ وهﻮ ﻳﺴﺘﺨﺪم ﺣﺴﺐ اﻟﺤﺎﺟﻪ اﻟﻴﻪ أي ﻣﻤﻜﻦ أن ﻧ ﺮى ﺑ ﺮاﻣﺞ ﻟ ﻴﺲ ﻓﻴﻬ ﺎ‬
‫هﺬا اﻟﻘﺴﻢ ﺑﺴﺒﺐ ﻋﺪم أﺣﺘﻴﺎج اﻟﺒﺮﻧﺎﻣﺞ ﻟﻸﻋﻼن ‪ .‬واﻟﻘﺴﻢ اﻟﺜﺎﻧﻲ ﻓﻬ ﻮ ﻳﻤﺜ ﻞ ) اﻷﻳﻌ ﺎزات أو اﻷواﻣ ﺮ(‬
‫) ‪ ( instructions or commands‬اﻟﺘﻲ ﺳﻴﻨﻔﺬهﺎ اﻟﺒﺮﻧﺎﻣﺞ وهﻮ ﻳﺒﺪأ ﺑﻜﻠﻤﺔ أﺑ ﺪأ ﺑﺎﻟﻠﻐ ﻪ اﻻﻧﻜﻠﻴﺰﻳ ﻪ‬
‫) ‪ ( begin‬ﺛ ﻢ اﻷﻳﻌ ﺎزات اﻟﻮاﺟ ﺐ ﺗﻨﻔﻴ ﺬهﺎ ‪ ,‬وﻳﻨﺘﻬ ﻲ ﺑﻜﻠﻤ ﻪ ﻧﻬﺎﻳ ﻪ ﺑﺎﻟﻠﻐ ﻪ اﻻﻧﻜﻠﻴﺰﻳ ﻪ ﻣﺘﺒﻮﻋ ﻪ ﺑﻨﻘﻄ ﻪ‬
‫)‪ ( end .‬وﻋﻠﻴﻪ ﻓﺴﻴﻜﻮن ﺷﻜﻞ اﻟﺒﺮﻧﺎﻣﺞ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫; ‪Program programname‬‬

‫‪Declaration section (may or may not contain Type ,‬‬


‫) ‪Const , Var , Uses , Label‬‬
‫‪Begin‬‬
‫; ) ‪Statements ( instructions‬‬
‫‪End.‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻳﻔﻀﻞ ﻋﻨﺪ ﺗﺴﻤﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ أن ﻳﻜﻮن اﻷﺳﻢ ﻳﺪل ﻋﻠﻰ ﻓﻌﻞ اﻟﺒﺮﻧﺎﻣﺞ أو وﻇﻴﻔﺘﻪ ‪ ,‬وﻻ ﻳﺠﻮز‬
‫أن ﻳﻜﻮن اﻷﺳﻢ أﺣﺪى اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزﻩ ‪ ,‬أو ﻳﻜﻮن أﺳﻢ ﻟﻤﺘﻐﻴﺮ ﻣﺴﺘﺨﺪم ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪,‬‬
‫وﻻ ﻳﺠﻮز أن ﺗﺴﺘﺨﺪم اﻟﻤﺴﺎﻓﺎت ) اﻟﻔﺮاﻏﺎت ( ﺑﻴﻦ أﺣﺮف اﻟﺒﺮﻧﺎﻣﺞ ‪ .‬ﻣﻤﻜﻦ اﺳﺘﺨﺪام‬
‫اﻟﺸﺎرﺣﻪ ) _ ( او اﻷرﻗﺎم ﻣﻊ أﺳﻢ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻳﻤﻜﻦ اﻷﺳﺘﻐﻨﺎء ﻋﻦ رأس اﻟﺒﺮﻧﺎﻣﺞ وﺳﻴﻨﻔﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺸﻜﻞ ﻃﺒﻴﻌﻲ ‪.‬‬

‫اﻟﻤﺨﺮﺟﺎت واﻟﻤﺪﺧﻼت ‪INPUT / OUTPUT‬‬ ‫‪2.3‬‬

‫ﻓ ﻲ آ ﻞ ﺑﺮﻧ ﺎﻣﺞ ﻳﺠ ﺐ أن ﺗﻜ ﻮن هﻨ ﺎك ﻣﺨﺮﺟ ﺎت ﺗﺒ ﻴﻦ اﻟﻨﺘ ﺎﺋﺞ اﻟﺘ ﻲ ﺗ ﻢ اﻟﺤ ﺼﻮل ﻋﻠﻴﻬ ﺎ ﻣ ﻦ‬


‫اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬ه ﺬﻩ اﻟﻨﺘ ﺎﺋﺞ ﺳ ﻴﺘﻢ ﻋﺮﺿ ﻬﺎ ﻋﻠ ﻰ ﺷﺎﺷ ﺔ اﻟﺤﺎﺳ ﻮب ﺑﺄﺳ ﺘﺨﺪام اﻷﻣ ﺮ‬
‫) ) (‪ ( writeln( ) OR writeln‬أن اﻷﻣﺮ ) ) ( ‪ ( write‬ﻳﻌﻨﻲ أآﺘﺐ ﻣﺎﻣﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ‬
‫) ) ( ‪ ( writeln‬ﻓﻬ ﻲ ﺗﻌﻨ ﻲ أآﺘ ﺐ ﻋﻠ ﻰ ﺳ ﻄﺮ‬ ‫ﻋﻠﻰ هﺬا اﻟﺴﻄﺮ اﻟﺬي ﺗﺆﺷﺮ ﻋﻠﻴﻪ ‪ .‬أﻣﺎ اﻷﻣ ﺮ‬
‫ﺟﺪﻳﺪ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ‪ ,‬وهﺬﻩ ﻣﻔﻴﺪﻩ ﻓﻲ ﻋﻤﻠﻴﺔ ﺗﻨﻈﻴﻢ اﻟﻤﺨﺮﺟﺎت‪.‬‬
‫ﻓﻲ ﺟﻤﻴﻊ اﻷﺣﻮال ﺳﻮاء أﺳﺘﺨﺪﻣﻨﺎ ) ) ( ‪ ( write( ) OR writeln‬ﻓﺄﻧﻨﺎ ﻧﺤﺘﺎج أﻟ ﻰ وﺿ ﻊ‬
‫ﻣﺎﻣﻄﻠﻮب أﻇﻬﺎرﻩ ﻋﻠﻰ اﻟﺸﺎﺷﻪ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ‪ .‬أن ﻣﺎ ﻳﻮﺿﻊ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺳﻴﺄﺧﺬ ﺣﺎﻟﻪ ﻣﻦ أﺛﻨﺘﻴﻦ ‪:‬‬

‫‪ 2.3.1‬ان ﻳﻜ ﻮن ﻣ ﺎ ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﻣﺤ ﺼﻮر ﺑﻌﻼﻣ ﺎت أﻗﺘﺒ ﺎس ﻣﻔ ﺮدﻩ‬


‫) ‪ ( ' ' ) ( single quotation mark‬وﺑﻬﺬﻩ اﻟﺤﺎﻟﻪ ﻓﺎن ﻣﺎ ﻣﻮﺟﻮد ﺑﻴﻦ ﻋﻼﻣﺘ ﻲ اﻷﻗﺘﺒ ﺎس‬
‫ﺳﻴﺘﻢ ﻃﺒﺎﻋﺘﻪ ﻋﻠﻰ اﻟﺸﺎﺷﻪ دون أدﻧﻰ ﺗﻐﻴﻴﺮ وآﻤﺎ هﻮ‪ .‬ﻣﺜﺎل‬
‫‪17‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‪Program Ch2_Program1‬‬
‫‪Begin‬‬
‫;)'!!‪Write('Hello World. Prepare to learn PASCAL‬‬
‫‪End.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ان اﻟﺒﺮﻧﺎﻣﺞ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ﻻ ﻳﺘﺄﺛﺮ أو ﻳﺘﺤﺴﺲ ﻟﺸﻜﻞ اﻟﺤﺮوف ﺳﻮاء آﺎﻧﺖ‬
‫ﻣﻜﺘﻮﺑﻪ ﺑﺎﻷﺣﺮف اﻟﻜﺒﻴﺮﻩ أو اﻷﺣﺮف اﻟﺼﻐﻴﺮﻩ ‪.‬‬

‫ﻻﺣﻆ ﻣﺎﻳﻠﻲ ‪// :‬‬

‫أوﻻ ‪ /‬ﻋﺪم أﺳﺘﺨﺪام أو وﺟﻮد ﻗﺴﻢ اﻷﻋﻼن وذﻟﻚ ﻟﻌﺪم وﺟﻮد ﻣﺎ ﻧﻌﻠﻦ ﻋﻨﻪ‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ /‬أن ﻣﺨﺮﺟﺎت ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ه ﻲ اﻟﻌﺒ ﺎرﻩ اﻟﻤﻮﺟ ﻮدﻩ ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﺑﻌ ﺪ آﻠﻤ ﻪ ) ‪( write‬‬
‫وﺳﺘﻈﻬﺮ ﻋﻠﻰ اﻟﺸﺎﺷﻪ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬


‫!!‪Hello World. Prepare to learn PASCAL‬‬

‫ﺛﺎﻟﺜﺎ ‪ /‬ﻋﻨﺪ ﺗﻨﻔﻴﺬ هﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﺳ ﻮف ﻻ ﻳﻤﻜ ﻦ ﻣﻼﺣﻈ ﺔ اﻟﻤﺨﺮﺟ ﺎت واﻟ ﺴﺒﺐ ه ﻮ أن اﻟﺤﺎﺳ ﺐ‬
‫ﺳﺮﻳﻊ ﺟﺪا ﺑﺤﻴﺚ ﻳﻌﺮض وﻳﺨﻔﻲ ﺷﺎﺷﻪ اﻟﺘﻨﻔﻴﺬ دون أن ﻧﻼﺣﻆ ذﻟﻚ ‪ ,‬وﻟﻐﺮض رؤﻳﺔ اﻟﻤﺨﺮﺟ ﺎت ﻓ ﻴﻤﻜﻦ‬
‫ﺑﻌ ﺪ ان ﻳ ﺘﻢ اﻟﺘﻨﻔﻴ ﺬ ﺿ ﻐﻂ اﻟ ﺰرﻳﻦ )‪ (Alt+ F5‬ﻣﻌ ﺎ وﻋﻨ ﺪهﺎ ﺳ ﺘﻈﻬﺮ ﺷﺎﺷ ﻪ اﻟﺘﻨﻔﻴ ﺬ ) اﻟ ﺴﻮداء ( ‪..‬‬
‫وﻳﻤﻜﻦ اﻟﺨﺮوج ﻣﻦ ﺷﺎﺷﺔ اﻟﺘﻨﻔﻴﺬ ﺑﻀﻐﻂ اﻟﺰر ) ‪. ( Enter‬‬
‫‪18‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻣﻤﻜﻦ أﻇﻬﺎر اﻟﻨﺘﺎﺋﺞ ﺑﻌﺪ أﻣﺮ اﻟﻄﺒﺎﻋﻪ ﺑﻄﺮﻳﻘﻪ ﺗﺴﺎﻋﺪ ﻋﻠﻰ ﺗﻨﻈﻴﻢ اﻟﻤﺨﺮﺟﺎت وذﻟﻚ ﻣﻦ ﺧﻼل‬
‫ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﻤﻮاﻗﻊ ) آﻞ ﺣﺮف أو رﻗﻢ ﻳﻄﺒﻊ ﻋﻠﻰ ﻣﻮﻗﻊ واﺣﺪ ( اﻟﺘﻲ ﺳﺘﻄﺒﻊ ﻋﻠﻴﻬﺎ اﻟﻨﺘﺎﺋﺞ‬
‫ﺣﻴﺚ ﺳﺘﻄﺒﻊ اﻟﻘﻴﻤﻪ اﻟﻤﻄﻠﻮب ﻃﺒﺎﻋﺘﻬﺎ ﻣﻦ اﻟﻴﻤﻴﻦ اﻟﻰ اﻟﻴﺴﺎر ‪ ,‬ﻓﺄذا آﺎن ﻋﺪد اﻟﻤﻮاﻗﻊ أآﺒﺮ‬
‫ﻣﻦ ﻋﺪد اﻻرﻗﺎم ﻓﻲ اﻟﻌﺪد ﻓﺴﻴﺘﺮك ﻓﺮاغ ﻣﻦ اﻟﻴﺴﺎر ‪ ,‬واﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ هﻲ ‪:‬‬
‫; )‪Write ( data : fieldwidth‬‬

‫ﻻﺣﻆ أن اﻟﻔﺎﺻﻞ ﺑﻴﻦ اﻟﺒﻴﺎﻧﺎت واﻟﺮﻗﻢ اﻟﺬي ﻳﻤﺜﻞ ﻋﺮض اﻟﺤﻘﻞ هﻮ اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﻌﺎﻣﺪﺗﺎن‪.‬‬
‫ﻣﺜﺎل‬
‫; ‪I : = 2345‬‬
‫; ) ‪Writeln ( I‬‬
‫; ) ‪Writeln ( I : 7‬‬
‫ﺳﺘﻜﻮن ﻧﺘﻴﺠﻪ هﺬﻳﻦ اﻷﻣﺮﻳﻦ آﻤﺎ ﻳﻠﻲ ‪ ,‬ﻻﺣﻆ اﻟﻔﺮق‬
‫‪2345‬‬
‫‪***2345‬‬
‫هﻨﺎ اﻟﻌﻼﻣﻪ ) * ( ﺗﻤﺜﻞ ﻓﺮاغ ﻟﻠﺘﻮﺿﻴﺢ ﻓﻘﻂ ‪.‬‬
‫أﺿﺎﻓﻪ اﻟﻰ أﻣﻜﺎﻧﻴﺔ ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﻤﻮاﻗﻊ اﻟﻤﺨﺼﺼﻪ ﻟﻠﺮﻗﻢ ﻓﻴﻤﻜﻦ ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﻤﺮاﺗﺐ ﺑﻌﺪ‬
‫اﻟﻔﺎرزﻩ ﻟﻄﺒﺎﻋﺔ اﻟﺮﻗﻢ اﻟﻜﺴﺮي وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫; ) ‪Write ( data : fieldwidth : precision‬‬

‫ﺣﻴﺚ أن ) ‪ ( precision‬ﺗﻤﺜﻞ ﻋﺪد اﻟﻤﻮاﻗﻊ اﻟﻤﺤﺪدﻩ ﻟﻄﺒﺎﻋﺔ اﻟﺠﺰء اﻟﻜﺴﺮي ‪ .‬ﻣﺜﺎل‬

‫; ) ‪Writeln ( I : 9 : 3‬‬
‫ﻳﺠﺐ أن ﺗﻜﻮن ) ‪ ( I‬ﻋﺪد ﺣﻘﻴﻘﻲ ‪.‬‬
‫ﻓﻲ ﺟﻤﻴﻊ اﻷﻣﺜﻠﻪ أﻋﻼﻩ ﻓﺄن اﻟﻤﺘﻐﻴﺮ ) ‪ ( I‬ﻣﻌﺮف آﻌﺪد ﺻﺤﻴﺢ ‪ ,‬أﻣﺎ أذا ﻋﺮف آﻌﺪد ﺣﻘﻴﻘﻲ‬
‫ﻓﺄن اﻟﻨﺘﺎﺋﺞ ﺳﺘﺨﺘﻠﻒ وﺗﻜﻮن ﻟﻠﻤﺜﺎل اﻷول آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪2.3450000000E+03‬‬
‫‪2.3E+03‬‬
‫أﻣﺎ ﺑﺎﻟﻨﺴﺒﻪ ﻟﻠﻤﺜﺎل اﻷﺧﻴﺮ ﻓﺘﻜﻮن اﻟﻨﺘﻴﺠﻪ‬
‫‪2345.000‬‬
‫وأﺧﻴﺮا ﻣﻤﻜﻦ أن ﻳﻜﻮن ) ‪ ( I‬ﻣﻦ ﻧﻮع اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ وﺑﻬﺬﻩ اﻟﺤﺎﻟﻪ ﻓﺄن ﺣﻘﻞ ﻋﺪد اﻟﻤﺮاﺗﺐ‬
‫ﺑﻌﺪ اﻟﻔﺎرزﻩ ﺳﻮف ﻻ ﻳﻜﻮن ﻟﻪ ﺣﺎﺟﻪ ‪.‬‬

‫‪ 2.3.2‬أﻣﺎ أذا آﺎن ﻣﺎ ﻣﻮﺟﻮد ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﺑﻌ ﺪ آﻠﻤ ﺔ ) ‪ ( write OR writeln‬ﻟ ﻴﺲ ﻣﺤ ﺼﻮر ﺑ ﻴﻦ‬
‫ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ﻓﻌﻨﺪ ذﻟﻚ ﺳﻴﻌﺎﻣﻞ ﻣﺎ ﻣﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﻋﻠ ﻰ أﻧ ﻪ ﻣﻌ ﺮف واﻟﻤﻌﺮﻓ ﺎت ﻳﺠ ﺐ‬
‫أن ﺗﻜﻮن ﻟﻬﺎ ﻗﻴﻤﻪ ﻟﺬا ﻓﺎن اﻟﺤﺎﺳﻮب ﺳﻴﻄﺒﻊ ﻗﻴﻤﺔ اﻟﻤﻌﺮف ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺘﻨﻔﻴﺬ ‪.‬‬
‫هﻨﺎ ﻋﻠﻴﻨﺎ أن ﻧﻼﺣﻆ أن أﺳﺘﺨﺪام أي ﻣﻌﺮف داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻳﺤﺘﺎج اﻟﻰ ﺷﺮﻃﻴﻦ ‪:‬‬
‫‪19‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻷول ‪ /‬أن ﻳﺘﻢ اﻷﻋﻼن ﻋ ﻦ اﻟﻤﻌ ﺮف ﻓ ﻲ ﻗ ﺴﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﻌﺮﻓ ﺎت ﺁﻟ ﺬي ﺳ ﺒﻖ أن ﻧﻮهﻨ ﺎ‬


‫ﻋﻨﻪ ﻓﺄذا آﺎن ﺛﺎﺑﺖ ﻳﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑ ﺖ ) ‪ ( const‬أﻣ ﺎ أذا آ ﺎن ﻣﺘﻐﻴ ﺮ ﻓ ﻴﻌﻠﻦ ﻋﻨ ﻪ‬
‫ﻓﻲ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ) ‪ ( var‬وﻳﺤﺪد ﻧﻮﻋﻪ ‪ .‬وﻟﻸﻋﻼن ﻋﻦ ﻣﺘﻐﻴﺮ ﻓﻲ ﻗ ﺴﻢ اﻟﻤﺘﻐﻴ ﺮات ﻧﺘﺒ ﻊ‬
‫ﻣﺎﻳﻠﻲ‪:‬‬

‫‪var‬‬ ‫ﺑﺪءا ﻧﻜﺘﺐ آﻠﻤﺔ‬

‫اﻷن ﻧﻜﺘﺐ أﺳﻢ اﻟﻤﺘﻐﻴﺮ وﻳﺘﺒﻊ ﺑﺎﻟﻨﻘﻄﺘﻴﻦ اﻟﻤﺘﻌﺎﻣﺪﺗﻴﻦ ) ‪ ( : ) ( colon‬ﺛﻢ ﻧﻮع اﻟﻤﺘﻐﻴ ﺮ وﺗﻨﺘﻬ ﻲ‬
‫ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃﻪ‬

‫; ‪x : integer‬‬

‫ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ه ﻮ ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ) ‪ ( integer‬أي أن اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻳﺤﻤﻠﻬ ﺎ داﺋﻤ ﺎ‬


‫ﺳﺘﻜﻮن ﻋﺪد ﺻﺤﻴﺢ‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ /‬أن ﺗﻜﻮن ﻟﻬﺬا اﻟﻤﺘﻐﻴﺮ أو اﻟﺜﺎﺑﺖ ﻗﻴﻤ ﻪ ﻋﻨ ﺪ أول أﺳ ﺘﺨﺪام ﻟ ﻪ داﺧ ﻞ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻤ ﺜﻼ أﻧﻨ ﺎ‬
‫ﻋﺮﻓﻨﺎ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﻟﻜﻦ آﻢ هﻲ ﻗﻴﻤ ﺔ ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ه ﻮ ﻋ ﺪد ﺻ ﺤﻴﺢ ﻟﻜ ﻦ آ ﻢ !! ﻓﻌﻨ ﺪﻣﺎ ﻧﻌﻄ ﻲ اﻷﻣ ﺮ‬
‫) )‪ ( write (x‬ﻓﻜﻢ ﻳﺠﺐ ﻋﻠﻰ اﻟﻤﺘﺮﺟﻢ أن ﻳﻄﺒﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺘﻨﻔﻴﺬ !! ﻟﺬا ﻳﺠ ﺐ أن ﻧﺤ ﺪد ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ‬
‫أو اﻟﺜﺎﺑﺖ ﻗﺒﻞ أول أﺳﺘﺨﺪام ‪.‬‬
‫هﺬﻩ اﻟﻘﻴﻤﻪ اﻟﺘﻲ ﺗﺤﺪد ﻟﻠﻤﺘﻐﻴﺮ ﺗﺄﺗﻲ ﻣﻦ أﺣﺪى ﻋﻤﻠﻴﺘﻴﻦ ﻓﺄﻣﺎ أن ﺗﺄﺗﻲ ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ أو ﺗ ﺄﺗﻲ‬
‫ﻣﻦ ﺧﺎرج اﻟﺒﺮﻧﺎﻣﺞ ‪ ...‬ﻟﻨﻨﺎﻗﺶ اﻟﺤﺎﻟﺘﻴﻦ ‪:‬‬

‫• ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬

‫وﻳ ﺘﻢ ذﻟ ﻚ ﻣ ﻦ ﺧ ﻼل اﻟﻤﻌ ﺎدﻻت أو اﻟﺘﻌ ﺎﺑﻴﺮ اﻟﺮﻳﺎﺿ ﻴﻪ أي ﺑﺄﺳ ﺘﺨﺪام اﻟﻤ ﺴﺎواة‬
‫) ‪ , ( assignment‬ﻓﻤﺜﻼ ﻧﻘﻮل‬

‫;‪x:=5‬‬

‫هﻨﺎ أﺳﺘﺨﺪﻣﻨﺎ اﻟﻤﺴﺎواة واﻟﺘﻲ ﻳﺮﻣﺰ ﻟﻬﺎ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ) = ‪ ( :‬وﺑﺬﻟﻚ ﻓﺎن‬
‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﺳﺘﻜﻮن ﻣﺴﺎوﻳﻪ اﻟﻰ اﻟﻌﺪد اﻟﺼﺤﻴﺢ ) ‪ , ( 5‬أو ﻣﻤﻜﻦ أن ﺗﻜﻮن اﻟﻤﻌﺎدﻟﻪ ﻋﻠﻰ ﺷﻜﻞ‬

‫; ‪x : = 3 * 2 +5‬‬

‫هﻨﺎ ﻗﻴﻤﺔ ) ‪ ( x‬ﺗﺴﺎوي ) ‪ , ( 11‬وآﺬﻟﻚ ﻣﻤﻜﻦ أن ﺗﺤﺪد ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ﺑﺎﻟﻤﺴﺎواة وﻟﻜﻦ ﻓﻲ ﺣﻘ ﻞ‬
‫اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ‪.‬‬
‫‪20‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪// :‬‬

‫داﺋﻤﺎ ﻋﻨﺪ وﺟﻮد ﻋﻼﻣﺔ اﻟﻤﺴﺎواة ) = ‪ ( :‬ﻓﺎن اﻟﻀﻮاﺑﻂ اﻟﺘﺎﻟﻴﻪ ﺳﺘﻄﺒﻖ ‪:‬‬
‫• ﻳﺠ ﺐ أن ﻳﻜ ﻮن هﻨ ﺎك ﻃ ﺮﻓﻴﻦ ﺗﻔ ﺼﻞ ﺑﻴﻨﻬﻤ ﺎ ﻋﻼﻣ ﺔ اﻟﻤ ﺴﺎواة ‪ ,‬وﺑ ﺬﻟﻚ ﻣﻤﻜ ﻦ أن‬
‫ﻧﻄﻠﻖ ﻋﻠﻴﻬﺎ ﺗﺴﻤﻴﺔ اﻟﻤﻌﺎدﻟﻪ ‪.‬‬
‫• اﻟﻄﺮف اﻷﻳﺴﺮ ﻣﻦ اﻟﻤﻌﺎدﻟﻪ أي اﻟﺬي ﻳﻘﻊ ﻋﻠﻰ اﻟﺠﺎﻧﺐ اﻷﻳﺴﺮ ﻣﻦ اﻟﻤﺴﺎواة ﻳﻜ ﻮن‬
‫ﻣﺘﻐﻴ ﺮ وﻣﺘﻐﻴ ﺮ واﺣ ﺪ ﻓﻘ ﻂ داﺋﻤ ﺎ وﻻ ﻳﺠ ﻮز أن ﻳﻜ ﻮن ﻗﻴﻤ ﻪ ﺛﺎﺑﺘ ﻪ ) ﻣ ﺜﻼ ‪ 6‬أو‬
‫‪ 456‬أو ‪.. 34.2‬اﻟ ﺦ ( وآ ﺬﻟﻚ ﻻ ﻳﺠ ﻮز أن ﻳﻜ ﻮن رﻣ ﺰ ﻣﻌ ﺮف ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن‬
‫ﻋﻦ اﻟﺜﻮاﺑﺖ ‪ .‬آﺬﻟﻚ ﻻ ﻳﺠﻮز أن ﻳﺤﺘﻮي ﻋﻠﻰ ﻋﻼﻗﺎت رﻳﺎﺿﻴﻪ‬
‫) ﻣﺜﻞ ‪. ( x + 6‬‬
‫• أﻣﺎ اﻟﻄﺮف اﻷﻳﻤﻦ ﻓﻴﻤﻜﻦ أن ﻳﻜﻮن ﻗﻴﻤﻪ ﻋﺪدﻳﻪ واﺣﺪﻩ أو ﻋﻼﻗ ﻪ رﻳﺎﺿ ﻴﻪ ﺗﺤﺘ ﻮي‬
‫ﻋﻠﻰ ﻗﻴﻢ ﻋﺪدﻳﻪ أو ﻋﻼﻗﻪ رﻳﺎﺿ ﻴﻪ ﺗﺤﺘ ﻮي ﻣﺘﻐﻴ ﺮ واﺣ ﺪ أو ﻣﺘﻐﻴ ﺮات أو ﻣﺘﻐﻴ ﺮات‬
‫وﻗﻴﻢ ﻋﺪدﻳﻪ ‪ .‬ﻣﺜﻼ‬
‫; ‪X : = 89‬‬
‫;‪X : = 34 – 45 +3‬‬
‫;‪X:=y‬‬
‫; ‪X : = 3 * y +90‬‬
‫• ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻓﺄن اﻟﻤﺘﺮﺟﻢ ﺳﻴﺒﺪأ ﺑﺎﻟﻄﺮف اﻷﻳﻤﻦ ﻣﻦ اﻟﻤﻌﺎدﻟﻪ داﺋﻤﺎ وﻳﺘﻢ‬
‫ﻓﺤﺺ هﺬا اﻟﻄﺮف ﻓﺄذا آﺎﻧﺖ ﻓﻴﻪ ﻣﺘﻐﻴﺮات ﻓﺴﻴﺒﺤﺚ اﻟﻤﺘﺮﺟﻢ ﻓﻲ اﻟﺨﻄﻮات‬
‫اﻟﺴﺎﺑﻘﻪ ﻟﻠﺘﺄآﺪ ﻣﻦ أن اﻟﻤﺘﻐﻴﺮ ﻣﻌﺮف أوﻻ ﺛﻢ ﻳﺠﺐ أن ﺗﻜﻮن ﻟﻪ ﻗﻴﻤﻪ ﻗﺒﻞ هﺬﻩ‬
‫اﻟﺨﻄﻮﻩ وﺗﺠﻠﺐ ﻟﺘﻌﻮض ﻋﻦ اﻟﻤﺘﻐﻴﺮ ﻓﻲ اﻟﻤﻌﺎدﻟﻪ ) ﻣﻤﻜﻦ أن ﻧﺘﺨﻴﻞ اﻟﻄﺮف‬
‫اﻷﻳﻤﻦ ﻋﻨﺪهﺎ ﺳﻴﺼﺒﺢ ﻋﺒﺎرﻩ ﻋﻦ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺜﻮاﺑﺖ ( ‪ ,‬ﺑﻌﺪهﺎ ﺗﺠﺮى اﻟﻌﻤﻠﻴﺎت‬
‫اﻟﺤﺴﺎﺑﻴﻪ وﺗﻜﻮن ﻣﻦ اﻟﻴﺴﺎر أﻟﻰ اﻟﻴﻤﻴﻦ وﺣﺴﺐ أﺳﺒﻘﻴﺎت اﻟﻌﻼﻣﺎت اﻟﺮﻳﺎﺿﻴﻪ‬
‫اﻟﻤﺒﻴﻨﻪ ﻓﻲ أدﻧﺎﻩ ‪ ,‬ﻓﺎﻷﺳﺒﻘﻴﻪ اﻷﻋﻠﻰ ﺗﻨﻔﺬ أوﻻ وأذا ﺗﺴﺎوت ﻋﻤﻠﻴﺘﺎن ﺑﺎﻷﺳﺒﻘﻴﻪ‬
‫ﻓﺘﻨﻔﺬ اﻟﻌﻤﻠﻴﻪ اﻟﺘﻰ ﻓﻲ اﻟﻴﺴﺎر‪ .‬ﻣﻦ ذﻟﻚ ﺳﻴﻨﺘﺞ ﻟﻨﺎ ﻋﺪد واﺣﺪ ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻦ‬
‫ﻗﻴﻤﺘﻪ هﺬﻩ اﻟﻘﻴﻤﻪ ﺳﺘﺆول اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻓﻲ اﻟﻄﺮف اﻷﻳﺴﺮ ) داﺋﻤﺎ اﻟﻘﻴﻤﻪ‬
‫ﺗﻨﺘﻘﻞ ﻣﻦ اﻟﻄﺮف اﻷﻳﻤﻦ ﻟﻠﻤﻌﺎدﻟﻪ اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻓﻲ اﻟﻄﺮف اﻷﻳﺴﺮ ( ‪.‬‬
‫• ﻳﺠﺐ أن ﻳﻜﻮن اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻋﻠﻰ ﻳﺴﺎر اﻟﻤﺴﺎواة واﻟﻤﺘﻐﻴﺮ أو اﻟﻤﺘﻐﻴﺮات ﻋﻠﻰ‬
‫ﻳﻤﻴﻦ اﻟﻤﺴﺎواة ﻣﻦ ﻧﻔﺲ اﻟﻨﻮع ‪.‬‬

‫أﺳﺒﻘﻴﺎت اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ ‪Operator Precedence‬‬

‫ﺗﻨﻔﺬ اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ وﻓﻘﺎ ﻷﺳﺒﻘﻴﺎﺗﻬﺎ اﻟﻤﺒﻴﻨﻪ أدﻧﺎﻩ ‪ ,‬دوﻧﺖ اﻟﻌﻤﻠﻴﺎت ﺑﺸﻜﻞ ﺗﻨﺎزﻟﻰ أي‬
‫ﻣﻦ اﻟﻌﻤﻠﻴﻪ ذات اﻷﺳﺒﻘﻴﻪ اﻟﻌﻠﻴﺎ اﻟﻰ اﻟﻌﻤﻠﻴﻪ ذات اﻷﺳﺒﻘﻴﻪ اﻟﺪﻧﻴﺎ ‪:‬‬

‫‪1.‬‬ ‫‪– unary‬‬ ‫‪, Not‬‬


‫‪2.‬‬ ‫‪* , / ,‬‬ ‫‪Mod , Div , And , Shl , Shr‬‬
‫‪3.‬‬ ‫‪+ , - ,‬‬ ‫‪Or , Xor‬‬
‫‪4.‬‬ ‫=< ‪< ,‬‬ ‫‪, > , > = , <> , = , In‬‬
‫•‬
‫‪21‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫• اﻟﻤﻌﺎﻣﻼت ) ‪ ( operands‬ﺑﻴﻦ أﺛﻨﻴﻦ ﻣﻦ اﻟﻌﻤﻠﻴﺎت اﻟﻤﺨﺘﻠﻔﺔ اﻷﺳﺒﻘﻴﻪ ﺗﻨﻔﺬ ﺣﺴﺐ‬


‫اﻷﺳﺒﻘﻴﻪ ) أي اﻟﻌﻤﻠﻴﻪ ذات اﻷﺳﺒﻘﻴﻪ اﻟﻌﻠﻴﺎ أوﻻ ( ‪.‬‬
‫• اﻟﻤﻌﺎﻣﻼت ﺑﻴﻦ أﺛﻨﻴﻦ ﻣﻦ اﻟﻌﻤﻠﻴﺎت اﻟﻤﺘﺴﺎوﻳﺔ اﻷﺳﺒﻘﻴﻪ ﺗﻨﻔﺬ ﻣﻦ اﻟﻴﺴﺎر اﻟﻰ اﻟﻴﻤﻴﻦ‬
‫) أي اﻟﻌﻤﻠﻴﻪ اﻟﺘﻲ ﻓﻲ اﻟﻴﺴﺎر أوﻻ ( ‪.‬‬
‫• اﻷﻗﻮاس ﺗﻨﻔﺬ أوﻻ ) أي أﻧﻬﺎ ﺗﺄﺧﺬ أﻋﻠﻰ أﺳﺒﻘﻴﻪ ( ‪.‬‬

‫• ﻣﻦ ﺧﺎرج اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬

‫وﺗ ﺘﻢ ﻋﻤﻠﻴ ﺔ أﺳ ﻨﺎد ) أدﺧ ﺎل ( ﻗﻴﻤ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ أﺛﻨ ﺎء ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ وذﻟ ﻚ ﺑﺄﺳ ﺘﺨﺪام أﻣ ﺮ اﻟﻘ ﺮاءﻩ‬
‫) أﻗﺮأ ( ) ) (‪ ( read( ) , OR readln‬وهﻲ ﺗﻌﻨﻲ ) أﻗﺮأ اﻟﻘﻴﻤ ﻪ اﻟﻤﻄﺒﻮﻋ ﻪ ﻋﻠ ﻰ ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ‬
‫وﺣﻤﻠﻬﺎ ﻓﻲ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺸﺎر اﻟﻴﻪ ﺑﻮاﺳﻄﺔ اﻟﻤﺘﻐﻴﺮ اﻟﻤﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ( ‪ ,‬ﻣﺜﺎل‬

‫;‪Program CH2_Program2‬‬
‫‪Var‬‬
‫;‪Num1, Num2, Sum: Integer‬‬

‫}‪Begin {no semicolon‬‬


‫;)'‪Write ('Input number 1 :‬‬
‫;)‪Readln (Num1‬‬
‫;)'‪Writeln ('Input number 2 :‬‬
‫;)‪Readln (Num2‬‬
‫}‪Sum: = Num1 + Num2; {addition‬‬
‫;)‪Writeln (Sum‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬


‫‪Input number 1: 20‬‬ ‫} ‪{ Press enter‬‬
‫‪Input number 2: 15‬‬ ‫} ‪{ Press enter‬‬
‫‪35‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪/ /:‬‬

‫أوﻻ ‪ //:‬ﺗﻢ أﺳﺘﺨﺪام ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻟﻸﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات اﻟﺘ ﻲ ﺳﺘ ﺴﺘﺨﺪم ﻓ ﻲ‬
‫اﻟﺒﺮﻧ ﺎﻣﺞ وه ﻲ ) ‪ ( num1 , num2 , sum‬وه ﻲ ﺟﻤﻴﻌ ﺎ ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ﻷن ه ﺬا‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﺻﻤﻢ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ) ﻳﻘﻮم ﺑﺠﻤﻊ ﻋﺪدﻳﻦ ﺻﺤﻴﺤﻴﻦ وأﻇﻬﺎر اﻟﻨﺘﻴﺠﻪ ( ‪.‬‬
‫‪22‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺛﺎﻧﻴﺎ ‪ //:‬ﻳﻤﻜﻦ اﻷﻋﻼن ﻋﻦ آﻞ ﻣﺘﻐﻴﺮ ﺑ ﺴﻄﺮ ﻣﻨﻔ ﺼﻞ ‪ ,‬وﻳﻤﻜ ﻦ وﺿ ﻌﻬﺎ ﺟﻤﻴﻌ ﺎ ﺑ ﺴﻄﺮ واﺣ ﺪ‬
‫آﻤ ﺎ ﻓ ﻲ ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻋﻠ ﻰ ﺷ ﺮط أن ﺗﻜ ﻮن ﺟﻤﻴ ﻊ اﻟﻤﺘﻐﻴ ﺮات ﻣ ﻦ ﻧﻔ ﺲ اﻟﻨ ﻮع ) هﻨ ﺎ ﺟﻤﻴﻌﻬ ﺎ أﻋ ﺪاد‬
‫ﺻﺤﻴﺤﻪ ( وذﻟ ﻚ ﻟﻐ ﺮض ﺗﻘﻠﻴ ﻞ اﻟﻤ ﺴﺎﺣﻪ اﻟﺘ ﻲ ﻳﻜﺘ ﺐ ﻋﻠﻴﻬ ﺎ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬وﻳ ﺘﻢ اﻟﻔ ﺼﻞ ﺑ ﻴﻦ ﻣﺘﻐﻴ ﺮ وأﺧ ﺮ‬
‫ﺑﻔﺎرزﻩ ‪ .‬وﻃﺒﻌﺎ اﻟﻌﺒﺎرﻩ ﺗﻨﺘﻬﻲ ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃﻪ ‪.‬‬

‫ﺛﺎﻟﺜﺎ ‪ //:‬ﺑﻌﺪ آﻠﻤﺔ ) ‪ ( begin‬ﻧﻼﺣﻆ اﻟﻌﺒﺎرﻩ اﻟﺘﺎﻟﻴﻪ )} ‪ ({ no semicolon‬وه ﻲ ﺗﻌﻨ ﻲ ﻻ‬


‫ﺗﺴﺘﺨﺪم ﻓﺎرزﻩ ﻣﻨﻘﻮﻃﻪ ‪ ,‬وﺑﻤﺎ أﻧﻬﺎ وﺿﻌﺖ ﺑﻴﻦ ﻗﻮﺳﻴﻦ ﻣﺘﻮﺳﻄﻴﻦ ﻓﺄن ذﻟﻚ ﻳﻌﻨﻲ أﻧﻬﺎ ﻣﻼﺣﻈﻪ أو ﺗﻌﻠﻴ ﻖ‬
‫) ‪ ( Comment‬ﻟﻠﻤ ﺴﺘﺨﺪم أو اﻟﻘ ﺎريء ﺑﻌ ﺪم أﺳ ﺘﺨﺪام اﻟﻔ ﺎرزﻩ اﻟﻤﻨﻘﻮﻃ ﻪ ﺑﻌ ﺪ آﻠﻤ ﺔ ) ‪( begin‬‬
‫هﺬﻩ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ أﻋﺘﺒﺮت ﺗﻌﻠﻴ ﻖ آﺘﺒ ﺖ ووﺿ ﻌﺖ ﺑ ﻴﻦ ﻗﻮﺳ ﻴﻦ ﻣﺘﻮﺳ ﻄﻴﻦ ) } { ( ‪ ,‬وﺑﻤ ﺎ أﻧﻬ ﺎ ﺗﻌﻠﻴ ﻖ‬
‫ﻓﻴﺠﺐ ان ﻻ ﻳﻜﻮن ﻟﻬﺎ ﺗﺄﺛﻴﺮ ﻋﻠﻰ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ) أي أﻧﻬﺎ ﺗﻬﻤﻞ أﺛﻨ ﺎء ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ( ‪ ,‬ﻋﻠﻴ ﻪ ﻓ ﺴﻴﻜﻮن‬
‫ﻟﻨ ﺎ ﻗﺎﻋ ﺪﻩ أن أي ﻋﺒ ﺎرﻩ ﻟﻐ ﺮض اﻟﺘﻮﺿ ﻴﺢ أو اﻟﺘﻌﻠﻴ ﻖ ﻣﻤﻜ ﻦ آﺘﺎﺑﺘﻬ ﺎ داﺧ ﻞ اﻟﺒﺮﻧ ﺎﻣﺞ ﻋﻠ ﻰ أن ﺗﺤ ﺎط‬
‫ﺑﻘﻮﺳﻴﻦ ﻣﺘﻮﺳﻄﻴﻦ وﺳﻮف ﻻ ﺗﻜﻮن ﺟﺰء ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ أﺛﻨﺎء اﻟﺘﻨﻔﻴﺬ ) ﺗﻬﻤﻞ ( ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫اﻟﺘﻌﻠﻴﻘﺎت أو اﻟﻤﻼﺣﻈﺎت ﺗﺴﺘﺨﺪم ﻷﻳﻀﺎح ﻋﻤﻞ ﺑﻌﺾ اﻟﺪوال واﻷﺟﺮاءات اﻟﺘﻲ ﺗﻜﻮن‬
‫ﻣﻌﺮوﻓﻪ ﻟﺪى اﻟﻤﺒﺮﻣﺞ وﻏﻴﺮ ﻣﻌﺮوﻓﻪ ﻟﻠﻤﺴﺘﺨﺪﻣﻴﻦ ‪ ,‬أﻳﻀﺎ ﺗﺴﺘﺨﺪم ﻟﻜﺘﺎﺑﺔ ﺑﻌﺾ‬
‫اﻟﻤﻌﻠﻮﻣﺎت ﺣﻮل اﻟﺒﺮﻧﺎﻣﺞ ) آﻮﻗﺖ اﻧﺸﺎءﻩ أو ﺗﺤﺪﻳﺜﻪ ( أو ﻣﻌﻠﻮﻣﺎت ﺣﻮل اﻟﻤﺒﺮﻣﺞ ﻧﻔﺴﻪ‬
‫) ﻣﺜﻼ اﻷﺳﻢ ‪ ,‬اﻟﻌﻨﻮان اﻷﻟﻜﺘﺮوﻧﻲ ( ‪.‬‬
‫اﻟﺘﻌﻠﻴﻘﺎت ﻣﻤﻜﻦ أن ﺗﻮﺿﻊ ﻓﻲ أي ﻣﻜﺎن ﻓﻲ ﺑﺮﻧﺎﻣﺞ ﺑﺎﺳﻜﺎل ‪ ,‬وﻟﻜﻦ ﻳﻔﻀﻞ أن ﺗﻜﺘﺐ ﻓﻲ‬
‫ﺑﺪاﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ ) ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﻤﻌﻠﻮﻣﺎت ﻋﻦ وﻇﻴﻔﺔ اﻟﺒﺮﻧﺎﻣﺞ أو ﻣﻌﻠﻮﻣﺎت ﻋﻦ‬
‫اﻟﻤﺒﺮﻣﺞ ( ‪ ,‬أو ﺗﻜﺘﺐ ﺑﺠﺎﻧﺐ اﻷواﻣﺮ اﻟﺘﻲ ﺗﺤﺘﺎج اﻟﻰ ﺗﻮﺿﻴﺢ ‪ .‬وﻣﻤﻜﻦ أن ﻧﻀﻊ‬
‫اﻟﺘﻌﻠﻴﻘﺎت ﺑﻴﻦ ﻗﻮﺳﻴﻦ ﻣﺘﻮﺳﻄﻴﻦ ) } ‪ ( { comments‬أو ﺑﻴﻦ ﻗﻮﺳﻴﻦ ﻋﺎدﻳﻴﻦ ﻣﻊ ﻧﺠﻤﻪ‬
‫ﺑﺠﺎﻧﺐ آﻞ ﻗﻮس ) )* ‪ ( (* comments‬وﻻ ﻓﺮق ﺑﻴﻦ اﻷﺛﻨﻴﻦ ‪.‬‬

‫راﺑﻌﺎ ‪ //:‬آﻤﺎ ﺳﺒﻖ وأن ذآﺮﻧﺎ أن ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻳﺘﻢ ﺑﺎﻟﺘﺴﻠﺴﻞ ﻣﻦ اﻷﻋﻠﻰ اﻟﻰ اﻷﺳﻔﻞ ﻓﻴﺒﺪأ ﻣﻦ‬
‫آﻠﻤﺔ ﺑﺮﻧﺎﻣﺞ ﺛﻢ ﻗﺴﻢ اﻷﻋﻼن وﻗﺮاءة اﻟﻤﺘﻐﻴﺮات ﺑﻌﺪهﺎ ﻳﻨﻔ ﺬ اﻷﻣ ﺮ أﺑ ﺪأ ﺛ ﻢ اﻟﻌﺒ ﺎرة اﻟﺘ ﻲ ﺗﻠﻴﻬ ﺎ وه ﻲ هﻨ ﺎ‬
‫اﻷﻣﺮ أآﺘﺐ ) ﻻﺣﻆ اﻟﻤﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﻓﻲ اﻷﻣﺮ أآﺘﺐ ه ﻮ ﻣﺤ ﺼﻮر ﺑ ﻴﻦ ﻋﻼﻣﺘ ﻲ أﻗﺘﺒ ﺎس ﻟ ﺬا ﻓﺄﻧ ﻪ‬
‫ﻳﻄﺒ ﻊ آﻤ ﺎ ه ﻮ ( ه ﺬﻩ اﻟﻌﺒ ﺎرﻩ ﺳ ﺘﻈﻬﺮ ﻋﻠ ﻰ ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ وه ﻲ ﺗﺨﺒ ﺮ اﻟﻤ ﺴﺘﺨﺪم ﻣ ﺎﻳﻠﻲ ) أدﺧ ﻞ اﻟ ﺮﻗﻢ‬
‫اﻷول ( وه ﻲ ﺑ ﺸﻜﻞ ﻋ ﺎم ﻳﻤﻜ ﻦ اﻷﺳ ﺘﻐﻨﺎء ﻋﻨﻬ ﺎ دون أن ﻳﺘ ﺄﺛﺮ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ..‬وﻟﻜﻨﻬ ﺎ ﻣﻔﻴ ﺪﻩ ﺣﻴ ﺚ ﺗﻌﻠ ﻢ‬
‫اﻟﻤﺴﺘﺨﺪم ﻋﻦ اﻟﺨﻄﻮة أو اﻟﺨﻄﻮات اﻟﻮاﺟﺐ أﺗﺒﺎﻋﻬﺎ ﻷﻧﺠﺎز ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ‪ ) ,‬ﻳﻤﻜﻦ ﻣﻼﺣﻈ ﺔ ﻣﺜ ﻞ ذﻟ ﻚ‬
‫ﻓﻲ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﻌﻤﻠﻮن ﻋﻠﻴﻬﺎ ﻣﺜﻼ ﻓﻲ ﺑﺮﻧﺎﻣﺞ ﻟﻠﻌﺒ ﻪ ) ‪ ( game‬ﻣﻌﻴﻨ ﻪ ﻓ ﺄن هﻨ ﺎك ﻣﻼﺣﻈ ﺎت ﺳ ﺘﻈﻬﺮ‬
‫ﻋﻠﻰ اﻟﺸﺎﺷﻪ ﻷرﺷﺎد اﻟﻤﺴﺘﺨﺪم ﻋﻦ اﻟﺨﻄﻮات اﻟﻮاﺟﺐ أﺗﺒﺎﻋﻬﺎ ﻟﺘﺸﻐﻴﻞ اﻟﻠﻌﺒﻪ أو أﺧﺘﻴﺎر درﺟ ﺔ اﻟ ﺼﻌﻮﺑﻪ‬
‫وﻏﻴﺮهﺎ (‪.‬‬

‫ﺧﺎﻣﺴﺎ ‪ //:‬هﻨﺎ ﺗﺒﺪأ ﻋﻤﻠﻴﺔ أدﺧﺎل ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( num1‬وذﻟﻚ ﺑﺄﺳﺘﺨﺪام اﻷﻣ ﺮ ) ‪( readln‬‬
‫‪ ,‬ﻋﻨﺪ اﻟﻮﺻﻮل اﻟﻰ ه ﺬﻩ اﻟﺨﻄ ﻮﻩ ﻓ ﺄن ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ ) اﻟ ﺸﺎﺷﻪ اﻟ ﺴﻮداء ( ﺳ ﺘﻈﻬﺮ وﻳﻜ ﻮن هﻨ ﺎك ﻣﺆﺷ ﺮ‬
‫ﺻﻐﻴﺮ ﻋﻠﻰ ﺷﻜﻞ ﺷﺎرﺣﻪ ) ‪ ( -‬ﻳﻈﻬﺮ وﻳﺨﺘﻔﻲ ﻓﻲ ﻣﻮﻗﻊ ﻋﻠﻰ اﻟﺠﺎﻧﺐ اﻷﻳﺴﺮ ﻣ ﻦ ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ ‪ ,‬ه ﺬا‬
‫اﻟﻤﺆﺷﺮ ﻳﺨﺒﺮ اﻟﻤﺴﺘﺨﺪم ﺑﺄن ﻋﻠﻴﻪ أدﺧﺎل ﻗﻴﻤﻪ ) ﻃﺒﺎﻋﺔ ﻗﻴﻤﻪ ﻣﻌﻴﻨﻪ ﺑﺄﺳﺘﺨﺪام ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ ( ‪ ,‬وﺑﻌ ﺪ أن‬
‫‪23‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻧﻄﺒﻊ ه ﺬﻩ اﻟﻘﻴﻤ ﻪ ﻳ ﺘﻢ أﻋ ﻼم اﻟﺒﺮﻧ ﺎﻣﺞ ) اﻟﻤﺘ ﺮﺟﻢ ( ﺑﺄﻧﺠ ﺎز اﻟﻌﻤ ﻞ وذﻟ ﻚ ﻣ ﻦ ﺧ ﻼل اﻟ ﻀﻐﻂ ﻋﻠ ﻰ اﻟ ﺰر‬
‫) ‪ ( Enter‬ﻓ ﻲ ه ﺬﻩ اﻟﺤﺎﻟ ﻪ ﺳ ﻴﺘﻢ ﻗ ﺮاءة اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻃﺒﻌ ﺖ ﻋﻠ ﻰ اﻟ ﺸﺎﺷﻪ وﺧﺰﻧﻬ ﺎ ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي‬
‫ﻳﺆﺷﺮ ﻋﻠﻴﻪ اﻟﻤﺘﻐﻴﺮ اﻟﻤﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺑﻌﺪ اﻷﻣ ﺮ) ‪ ( readln‬وﺑ ﺬﻟﻚ ﻧﻜ ﻮن ﻗ ﺪ أدﺧﻠﻨ ﺎ ﻗﻴﻤ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ‬
‫) ‪ ) ( num1‬ﺧﺰﻧ ﺎ ﻗﻴﻤ ﻪ ( ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺆﺷ ﺮﻋﻠﻴﻪ اﻟﻤﺘﻐﻴ ﺮ ﺑﻌ ﺪ ه ﺬﻩ اﻟﺨﻄ ﻮﻩ ‪ ,‬وه ﺬا ﻣ ﺎ أﺳ ﻤﻴﻪ‬
‫اﻷدﺧﺎل ﻣﻦ ﺧﺎرج اﻟﺒﺮﻧﺎﻣﺞ ) أي اﻷدﺧﺎل اﻟﺬي ﻳﺘﻢ ﺑﻮاﺳﻄﺔ اﻟﻤﺴﺘﺨﺪم أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ (‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫اﻟﻔﺮق ﺑﻴﻦ اﻷﻣﺮ ‪ Read‬واﻷﻣﺮ ‪ Readln‬وآﻼهﻤﺎ ﻳﺴﺘﺨﺪم ﻟﻠﻘﺮاءﻩ ‪ ,‬أن اﻷﻣﺮ‬


‫‪ Read‬ﻳﻘﺮأ اﻟﻤﺪﺧﻼت اﻟﺘﻲ ﻳﺪﺧﻠﻬﺎ اﻟﻤﺴﺘﺨﺪم وﻳﺘﻮﻗﻒ ﺑﻌﺪ أﺧﺮ ﻗﻴﻤﻪ ﻳﺘﻢ ﻗﺮاﺋﺘﻬﺎ ﻓﺄذا‬
‫ﺟﺎء أﻣﺮ ) ‪ ( read‬أﺧﺮ ﻓﻴﺒﺪأ اﻟﻘﺮاءﻩ أﻋﺘﺒﺎرا ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺆﺷﺮ ﻋﻠﻴﻪ ﺑﻮاﺳﻄﺔ‬
‫اﻟﻤﺆﺷﺮ ﺑﻌﺪ اﻟﻘﺮاءﻩ اﻷوﻟﻰ ‪.‬‬
‫أﻣﺎ اﻷﻣﺮ ‪ Readln‬ﻓﺄﻧﻪ ﻳﻌﻤﻞ ﺑﻨﻔﺲ اﻟﻄﺮﻳﻘﻪ ﻣﻊ أﺳﺘﺜﻨﺎء واﺣﺪ ‪ .‬ﻓﺒﻌﺪ أن ﻳﻨﺘﻬﻲ ﻣﻦ‬
‫ﻗﺮاءة أﺧﺮ ﻗﻴﻤﻪ ﻓﻲ اﻟﻘﺎﺋﻤﻪ ﻓﺄن اﻟﻤﺆﺷﺮ ﺳﻴﻬﻤﻞ آﻞ اﻟﻘﻴﻢ اﻟﻤﺘﺒﻘﻴﻪ ﻋﻠﻰ ذﻟﻚ اﻟﺴﻄﺮ‬
‫وﻳﻨﺘﻘﻞ اﻟﻰ ﺑﺪاﻳﺔ ﺳﻄﺮ ﺟﺪﻳﺪ ‪.‬‬

‫ﺳﺎدﺳﺎ ‪ //:‬اﻷﻣﺮان اﻟﻼﺣﻘﺎن هﻤﺎ ﻣﺸﺎﺑﻬﺎن ﻟﻠﺨﻄﻮﺗﻴﻦ اﻟﺮاﺑﻌﻪ واﻟﺨﺎﻣﺴﻪ‪.‬‬

‫ﺳ ﺎﺑﻌﺎ ‪ //:‬اﻟﻤﻌﺎدﻟ ﻪ ) ‪ ( sum : = num1 + num2‬ﻋﻨ ﺪ اﻟﻮﺻ ﻮل اﻟ ﻰ ه ﺬﻩ اﻟﻤﻌﺎدﻟ ﻪ ﻓ ﺄن‬


‫اﻟﻤﺘﺮﺟﻢ ﺳﻴﺒﺪأ ﺑﺎﻟﻄﺮف اﻷﻳﻤﻦ ﻣﻦ اﻟﻤﻌﺎدﻟﻪ وﻳﻌﻮض ﻋﻦ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻮﺟﻮدﻩ ﺑﻤﺎ ﻳ ﺴﺎوﻳﻬﺎ ﻣ ﻦ ﻗ ﻴﻢ ﺛ ﻢ‬
‫أﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﺠﻤﻊ ﻋﻠﻰ هﺬﻩ اﻟﻘﻴﻢ ﻟﻴﻨﺘﺞ ﻋﻦ ذﻟﻚ ﻗﻴﻤﻪ واﺣﺪﻩ ﻓﻲ اﻟﻄﺮف اﻷﻳﻤﻦ ‪ ,‬هﺬﻩ اﻟﻘﻴﻤ ﻪ ﺳﺘﻮﺿ ﻊ‬
‫) ﺗﺨ ﺰن ( ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺆﺷ ﺮ ﻋﻠﻴ ﻪ اﻟﻤﺘﻐﻴ ﺮ اﻟﻤﻮﺟ ﻮد ﻓ ﻲ اﻟﻄ ﺮف اﻷﻳ ﺴﺮ‪ ,‬وﺑ ﺬﻟﻚ ﻓ ﺎن اﻟﻤﺘﻐﻴ ﺮ‬
‫) ‪ ( sum‬ﺳﺘﺴﻨﺪ ﻟﻪ ﻗﻴﻤ ﻪ ) ﺗﺨ ﺰن ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺆﺷ ﺮ ﻋﻠﻴ ﻪ ( ﻣ ﻦ ﺧ ﻼل اﻟﻤﻌﺎدﻟ ﻪ وه ﺬا ﻣ ﺎ أﺳ ﻤﻴﻪ‬
‫أدﺧﺎل ﻗﻴﻤﻪ ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ) أي أن اﻟﻤﺴﺘﺨﺪم ﻻ ﻳﺘﺪﺧﻞ ﻓﻲ ذﻟﻚ أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ( ‪.‬‬

‫ﺛﺎﻣﻨ ﺎ ‪ //:‬ﺑﻌ ﺪ أﻧﺠ ﺎز اﻟﻌﻤ ﻞ اﻟﻤﻄﻠ ﻮب ﻣ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓ ﻼ ﺑ ﺪ ﻣ ﻦ أﻋ ﻼم اﻟﻤ ﺴﺘﺨﺪم ﺑﺎﻟﻨﺘﻴﺠ ﻪ‬
‫اﻟﻤﺘﺤﺼﻠﻪ ﻣﻦ أﻧﺠﺎز أو ﺗﻨﻔﻴﺬ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬وﻳ ﺘﻢ ذﻟ ﻚ ﻣ ﻦ ﺧ ﻼل ﻃﺒﺎﻋ ﺔ اﻟﻘﻴﻤ ﻪ اﻟﻤﺘﺤ ﺼﻠﻪ واﻟﺘ ﻲ ه ﻲ‬
‫اﻷن ﻣﻮﺟﻮدﻩ ﻓﻲ اﻟﻤﺘﻐﻴﺮ ) ‪ , ( sum‬ﻟﺬا ﺗﻢ أﺳﺘﺨﺪام اﻷﻣﺮ أآﺘﺐ ﻟﻴﻄﺒﻊ ﻣ ﺎ ﻣﻮﺟ ﻮد ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ اﻟﻠﺘ ﻴﻦ‬
‫ﺑﻌﺪﻩ ‪ ,‬وﻟﻤﺎ آﺎن ﻣﺎ ﻣﻮﺟﻮد ﺿﻤﻦ اﻟﻘﻮﺳﻴﻦ ﻏﻴﺮ ﻣﺤﺪد ﺑﻌﻼﻣﺘﻲ أﻗﺘﺒﺎس ﻟ ﺬا ﻓ ﺎن اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻳﺤﻤﻠﻬ ﺎ ه ﺬا‬
‫اﻟﻤﺘﻐﻴﺮ هﻲ اﻟﺘﻲ ﺗﻈﻬﺮ ﻋﻠﻰ ﺷﺎﺷﻪ اﻟﺘﻨﻔﻴﺬ ‪.‬‬

‫ﺗﺎﺳﻌﺎ ‪ //:‬ﺳﺒﻖ وأن ﻧﺒﻬﻨﺎ أﻟﻰ أن ﺳﺮﻋﺔ اﻟﺘﻨﻔﻴﺬ ﺳﻮف ﻻﺗﻤﻜﻦ اﻟﻤﺴﺘﺨﺪم ﻣﻦ رؤﻳﻪ اﻟﻨﺘﺎﺋﺞ وﺑﻴﻨﺎ‬
‫ﺑﺄن ﻣﻦ اﻟﻤﻤﻜ ﻦ أن ﻧ ﺴﺘﺨﺪم اﻟ ﺰرﻳﻦ ) ‪ ( Alt + F5‬ﻣﻌ ﺎ ﻷﻇﻬ ﺎر اﻟﻨﺘ ﺎﺋﺞ ‪ ...‬وﻣﻤﻜ ﻦ أﻳ ﻀﺎ أن ﻧ ﺴﺘﺨﺪم‬
‫ﻃﺮﻳﻘﻪ أﺧﺮى وهﻲ أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( readln‬ﻓﻘﻂ أي ﺑﺪون اﻷﻗﻮاس اﻟﺘﻲ ﺑﻌﺪﻩ آﻤﺎ ﻣﺒﻴﻦ أﻋﻼﻩ ‪ ,‬هﻨ ﺎ‬
‫اﻟﻤﺘﺮﺟﻢ ﺳﻴﻔﺴﺮ اﻷﻣﺮ آﻤﺎ ﻟﻮ أن اﻟﻤﺴﺘﺨﺪم ﻳﺮﻏﺐ ﺑﺎدﺧﺎل ﻗﻴﻤﻪ ﻟﻤﺘﻐﻴﺮ وﺳ ﻴﻈﻬﺮ ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ ﻣﻨﺘﻈ ﺮا‬
‫اﻟﻤﺴﺘﺨﺪم ﻟﻴﺪﺧﻞ اﻟﻘﻴﻤﻪ وﺑﺬﻟﻚ ﺳﻨﺮى اﻟﻨﺘﺎﺋﺞ وﻳﻤﻜﻦ اﻟﺨﺮوج ﻣﻦ هﺬﻩ اﻟﺸﺎﺷﻪ وذﻟﻚ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﻟﺰر‬
‫)‪ ) . (Enter‬هﻲ ﻋﻤﻴﻠﺔ أﺣﺘﻴﺎل ﻋﻠﻰ اﻟﺤﺎﺳﻮب وﻋﻨﺪ اﻟﻀﻐﻂ ﻋﻠﻰ اﻟﺰر ‪ Enter‬ﻓﻬﺬا ﻳﻌﻨ ﻲ أن ﻋﻤﻠﻴ ﺔ‬
‫‪24‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻷدﺧ ﺎل ﺗﻤ ﺖ واﻟﻤﻔ ﺮوض أن ﻳﻘ ﺮأ ﻣ ﺎ ﻣﻄﺒ ﻮع ﻋﻠ ﻰ اﻟ ﺸﺎﺷﻪ وﻳ ﺴﻨﺪﻩ اﻟ ﻰ اﻟﻤﺘﻐﻴ ﺮ واﻟ ﺬي ه ﻮ ﻏﻴ ﺮ‬


‫ﻣﻮﺟﻮد ( ‪.‬‬

‫ﻋﺎﺷﺮا ‪ //:‬اﻷﻣﺮ اﻷﺧﻴ ﺮ ه ﻮ ) ‪ ( end‬وواﺿ ﺢ أﻧ ﻪ ﻳﻌﻨ ﻲ اﻟﻨﻬﺎﻳ ﻪ ) هﻨ ﺎ ﻳﺠ ﺐ أن ﻧﻼﺣ ﻆ أﻧﻨ ﺎ‬


‫ﻳﻤﻜ ﻦ أن ﻧ ﺴﺘﺨﺪم اﻷﻣ ﺮ ) ‪ ( begin‬أآﺜ ﺮ ﻣ ﻦ ﻣ ﺮﻩ ﺑ ﺸﺮط أن ﻳﻜ ﻮن هﻨ ﺎك أﻣ ﺮ ) ‪ ( end‬ﻟﻜ ﻞ أﻣ ﺮ‬
‫) ‪ , ( begin‬ﺟﻤﻴﻊ هﺬﻩ اﻷواﻣﺮ ) ‪ ( end‬ﺗﻨﺘﻬﻲ ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃ ﻪ ﻋ ﺪا أﺧ ﺮ أﻣ ﺮ ) ‪ ( end‬ﻓﺄﻧ ﻪ ﺳ ﻴﻨﺘﻬﻲ‬
‫ﺑﻨﻘﻄﻪ ( ‪ ,‬ان اﻷﻣﺮ ) ‪ ( end‬اﻟﺬي ﻳﻨﺘﻬﻲ ﺑﻨﻘﻄﻪ ﻳﻌﻨﻲ ﻧﻬﺎﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ آﻜﻞ وآ ﻞ ﻣﺎﺑﻌ ﺪ ه ﺬا اﻷﻣ ﺮ ﻳﻬﻤ ﻞ‬
‫وآﻤﺎ هﻮ واﺿﺢ أﻋﻼﻩ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫أدﻧﺎﻩ ﺑﻌﺾ اﻟﻘﻮاﻋﺪ اﻟﺘﻲ ﻳﺠﺐ أن ﺗﻼﺣﻆ ﻋﻨﺪ أدﺧﺎل اﻟﺒﻴﺎﻧﺎت اﻟﻤﻄﻠﻮﺑﻪ ‪:‬‬
‫‪ .1‬ﻳﺠﺐ أن ﻳﺘﻄﺎﺑﻖ ﻋﺪد اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ ﻳﺘﻢ أدﺧﺎﻟﻬﺎ ﻣﻊ ﻋﺪد اﻟﻤﺘﻐﻴﺮات اﻟﻤﺪوﻧﻪ ﺑﻴﻦ‬
‫اﻟﻘﻮﺳﻴﻦ ﻓﻲ أﻳﻌﺎز اﻟﻘﺮاءﻩ ‪.‬‬
‫‪ .2‬ﻳﺠﺐ أن ﻳﺘﻄﺎﺑﻖ ﻧﻮع اﻟﻘﻴﻤﻪ اﻟﻤﺪﺧﻠﻪ ﻟﻤﺘﻐﻴﺮ ﻣﻌﻴﻦ ﻣﻊ اﻟﻨﻮع اﻟﻤﻌﻠﻦ ﻟﻬﺬا اﻟﻤﺘﻐﻴﺮ ‪.‬‬
‫‪ .3‬اﻟﻤﺘﻐﻴﺮات اﻟﻤﺪوﻧﻪ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﻓﻲ أﻳﻌﺎز اﻟﻘﺮاءﻩ ﻳﺠﺐ أن ﺗﻔﺼﻞ ﺑﻴﻨﻬﺎ ﻓﺎرزﻩ أذا آﺎن‬
‫ﻋﺪدهﺎ أآﺜﺮ ﻣﻦ ﻣﺘﻐﻴﺮ واﺣﺪ ‪.‬‬
‫‪ .4‬أذا آﺎن أآﺜﺮ ﻣﻦ ﻣﺘﻐﻴﺮ واﺣﺪ ﻓﻲ أﻳﻌﺎز ﻗﺮاءﻩ واﺣﺪ ﻓﻴﻤﻜﻦ أدﺧﺎﻟﻬﺎ ﺟﻤﻴﻌﺎ ﺛﻢ ﺿﻐﻂ اﻟﺰر‬
‫) ‪ ( Enter‬ﻋﻠﻰ أن ﻳﻔﺼﻞ ﺑﻴﻦ ﻗﻴﻤﻪ وأﺧﺮى ﻓﺮاغ ‪ ,‬أو ﻧﺪﺧﻞ اﻟﻘﻴﻢ واﺣﺪﻩ ﺑﻌﺪ اﻷﺧﺮى‬
‫ﻋﻠﻰ أن ﻧﻀﻐﻂ اﻟﺰر ) ‪ ( Enter‬ﺑﻌﺪ أدﺧﺎل آﻞ ﻗﻴﻤﻪ ‪.‬‬
‫‪ .5‬ﻻ ﻳﺠﻮز أن ﺗﻜﻮن اﻟﻘﻴﻢ اﻟﻤﺪﺧﻠﻪ ﺻﻴﻎ رﻳﺎﺿﻴﻪ ) أي ﻗﻴﻢ ﺑﻴﻨﻬﺎ ﻋﻼﻣﺎت رﻳﺎﺿﻴﻪ (‬

‫ﻣﺘﻐﻴﺮات اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪STRING VARIABLES‬‬ ‫‪2.4‬‬

‫اﻷن ﻧ ﺘﻌﻠﻢ آﻴﻔﻴ ﻪ أدﺧ ﺎل ﻧ ﺺ آﺘ ﺎﺑﻲ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤ ﺴﺘﺨﺪم وذﻟ ﻚ ﺑﺄﺳ ﺘﺨﺪام ﻣﺘﻐﻴ ﺮات اﻟ ﺴﻼﺳﻞ‬
‫اﻟﺤﺮﻓﻴﻪ و اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﻳﺒﻴﻦ آﻴﻔﻴﻪ أدﺧ ﺎل ﻣﺘﻐﻴ ﺮات اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ وذﻟ ﻚ ﺑﺘﺤﻔﻴ ﺰ اﻟﻤ ﺴﺘﺨﺪم ﻟﻬ ﺬا‬
‫اﻻﺟﺮاء ‪ ,‬ﻣﺜﺎل‬

‫;‪Program CH2_Program3‬‬
‫;‪Var name, surname: String‬‬

‫‪Begin‬‬
‫;)'‪Write ('Enter your name :‬‬
‫;)‪readln (name‬‬
‫;)'‪Write ('Enter your surname :‬‬
‫;)‪readln (surname‬‬
‫}‪writeln ;{new line‬‬
‫}‪writeln ;{new line‬‬
‫;)‪Writeln ('your full name is: ', name,' ', surname‬‬
‫;‪Readln‬‬
‫‪End.‬‬
‫‪25‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬


‫‪Enter your name:‬‬ ‫‪Ahmed‬‬ ‫} ‪{ enter‬‬
‫‪Enter your surname: Abass‬‬ ‫} ‪{ enter‬‬

‫‪Your full name is: Ahmed Abass‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪// :‬‬

‫اذا ﻣﺎ ﻧﻈﺮﻧﺎ اﻟﻰ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻓﻤﻦ اﻟﻤﻤﻜﻦ أن ﻧﺴﺠﻞ ﻋﺪد ﻣﻦ اﻟﻤﻼﺣﻈﺎت وﻧﺘﻌﻠﻢ أﺷﻴﺎء ﺟﺪﻳ ﺪﻩ‬
‫وهﻲ ‪:‬‬
‫اوﻻ ‪ //:‬ﺗﻢ أﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮﻳﻦ ) ‪ ( name , surname‬ﻣﻦ ﻧﻮع ﺳﻼﺳﻞ ﺣﺮﻓﻴ ﻪ ) ‪( string‬‬
‫وﻟﺬﻟﻚ ﻓﻌﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﺘﻢ اﻟﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم أدﺧﺎل ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺤﺮوف ﻟﻜﻞ ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮﻳﻦ‬
‫وﻣ ﺎ ﻳ ﺘﻢ ﻃﺒﺎﻋﺘ ﻪ أو أدﺧﺎﻟ ﻪ ﻋ ﻦ ﻃﺮﻳ ﻖ ﻟﻮﺣ ﺔ اﻟﻤﻔ ﺎﺗﻴﺢ ﺳ ﻴﺬهﺐ ﻣﺒﺎﺷ ﺮة اﻟ ﻰ اﻟ ﺬاآﺮﻩ وﻳﺨ ﺰن ﺑ ﺎﻟﻤﻮﻗﻊ‬
‫اﻟﻤﺆﺷﺮ ﻋﻠﻴﻪ ﺑﻮاﺳﻄﺔ اﻟﻤﺘﻐﻴﺮ أﻋﻼﻩ ‪ .‬أن هﺬﻳﻦ اﻟﻤﺘﻐﻴﺮﻳﻦ ﻳﻤﻜﻦ اﺳﺘﺒﺪاﻟﻬﻤﺎ ﺑﺄي ﻣﺘﻐﻴﺮ أﺧ ﺮ ﻣ ﺜﻼ ) ‪( n‬‬
‫ﺑﺪﻻ ﻣﻦ ) ‪ ( name‬وﻃﺒﻌﺎ ذﻟﻚ ﻻ ﻳﺆﺛﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ آﻤﺎ ﺳﺒﻖ وأن ﺑﻴﻨﺎ‪.‬‬

‫ﺛﺎﻧﻴ ﺎ ‪ //:‬ﻻﺣ ﻆ ﻓ ﻲ اﻟ ﺴﻄﺮﻳﻦ اﻟﺘﺎﺳ ﻊ واﻟﻌﺎﺷ ﺮ أﺳ ﺘﺨﺪام اﻷﻣ ﺮ ) ‪ ( writeln‬دون وﺟ ﻮد‬


‫أﻗ ﻮاس ﺑﻌ ﺪهﻤﺎ وه ﺬﻩ اﻟﻌﻤﻠﻴ ﻪ ﺗﻔﻴ ﺪ ﺑﻄﺒﺎﻋ ﺔ ﺳ ﻄﺮ ﻓ ﺎرغ ﻟﻜ ﻞ ﻣﻨﻬﻤ ﺎ أي أن اﻟﻤﺆﺷﺮﺳ ﻴﺘﺤﺮك اﻟ ﻰ ﺳ ﻄﺮ‬
‫ﺟﺪﻳﺪ ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺮد ﻣﺜﻞ هﺬا اﻷﻣﺮ‪ ,‬وهﻲ ﻷﻏﺮاض ﺗﻨﻈﻴﻢ وﺗﺮﺗﻴﺐ اﻟﻤﺨﺮﺟﺎت ‪.‬‬

‫ﺛﺎﻟﺜﺎ ‪ //:‬أﻣﺮ اﻟﻄﺒﺎﻋﻪ اﻷﺧﻴﺮ هﻮ أﻳﻀﺎ ﻳﺨﺘﻠﻒ ﻋﻦ ذﻟ ﻚ اﻟ ﺬي ﺳ ﺒﻖ وأن ﺗ ﻢ أﺳ ﺘﺨﺪاﻣﻪ ‪ ,‬ﺣﻴ ﺚ‬


‫أﻧﻪ ﻳﺤﺘﻮي ﻋﻠ ﻰ ﻋ ﺪد ﻣ ﻦ اﻟﻌﺒ ﺎرات داﺧ ﻞ اﻟﻘﻮﺳ ﻴﻦ ﻳﻔ ﺼﻞ ﺑ ﻴﻦ واﺣ ﺪﻩ واﺧ ﺮى ﻓ ﺎرزﻩ ‪ ,‬وه ﺬﻩ ﻃﺮﻳﻘ ﻪ‬
‫ﻳﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ أواﻣﺮ اﻟﻄﺒﺎﻋﻪ وذﻟﻚ ﺑﺪﻻ ﻣﻦ ﺗﻜﺮار أﻣﺮ اﻟﻄﺒﺎﻋﻪ ﻟﻜ ﻞ ﺣﺎﻟ ﻪ ﻓ ﻴﻤﻜﻦ دﻣﺠﻬ ﺎ ﺟﻤﻴﻌ ﺎ‬
‫ﺑﺄﻣﺮ واﺣﺪ ﻋﻠﻰ أن ﻳﻔﺼﻞ ﺑﻴﻦ واﺣﺪﻩ وأﺧﺮى ﻓﺎرزﻩ‪.‬‬
‫ﻻﺣﻆ اﻟﺠﺰء اﻷول وﺿﻊ ﺑﻴﻦ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ) ‪ ( Your full name is:‬وه ﺬا اﻟﺠ ﺰء ﺳ ﻴﺘﻢ‬
‫ﻃﺒﺎﻋﺘﻪ آﻤﺎ هﻮ آﻤﺎ ﺗﻌﻠﻤﻨﺎ ‪ ,‬أن اﻟﻔ ﺎرزﻩ ﺗﻌﻨ ﻲ اﻟﺒ ﺪأ ﺑ ﺄﻣﺮ ) ‪ ( write‬ﺟﺪﻳ ﺪ ﻟﻤ ﺎ ﻳﻠ ﻲ اﻟﻔ ﺎرزﻩ أي وآﺄﻧﻤ ﺎ‬
‫ﻧﻘ ﻮل ) )‪ , ( write (name‬وﻟ ﺬا ﻓﻬ ﻲ ﺳ ﺘﻄﺒﻊ ﻣ ﺎﻳﻠﻲ اﻟﻔ ﺎرزﻩ وﻋﻠ ﻰ ﻧﻔ ﺲ اﻟ ﺴﻄﺮ وﻟﻤ ﺎ آ ﺎن اﻟﻤﺘﻐﻴ ﺮ‬
‫) ‪ ( name‬ﻟﻴﺲ ﻣﺤﺪد ﺑﻌﻼﻣﺘﻲ أﻗﺘﺒﺎس ﻓﺴﻴﺘﻢ ﻃﺒﺎﻋﺔ ﻣﺎﻳﺤﻤﻠﻪ ﻣﻦ ﻗﻴﻤ ﻪ ‪ ,‬واﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻳﺤﻤﻠﻬ ﺎ هﻨ ﺎ ه ﻲ‬
‫ﻋﺒﺎرﻩ ﻋﻦ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪ .‬ﺑﻌﺪهﺎ ﻧﻼﺣﻆ اﻟﻔﺎرزﻩ ﺛﻢ ﺗﻠﻴﻬﺎ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ﺗﺤﺪد ﺑﻴﻨﻬ ﺎ ﻓ ﺮاغ ﻟ ﺬا ﻓ ﺎن أﻣ ﺮ‬
‫اﻟﻄﺒﺎﻋ ﻪ ﻳ ﺸﻴﺮ اﻟ ﻰ ﻃﺒﺎﻋ ﺔ ﻓ ﺮاغ وهﻜ ﺬا ﺳ ﻴﺘﻢ ﻃﺒﺎﻋ ﺔ ﻓ ﺮاغ ﺣ ﺴﺐ ﺣﺠ ﻢ اﻟﻔ ﺮاغ اﻟﻤﺤ ﺪد ﺑ ﻴﻦ ﻋﻼﻣﺘ ﻲ‬
‫اﻷﻗﺘﺒ ﺎس وأﺧﻴ ﺮا ﻳ ﺄﺗﻲ أﻣ ﺮ اﻟﻄﺒﺎﻋ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ ) ‪ ( surname‬وﺳ ﻴﺘﻢ ﻃﺒﺎﻋ ﺔ ﻗﻴﻤﺘ ﻪ واﻟﺘ ﻲ ه ﻲ ﺳﻠ ﺴﻠﻪ‬
‫ﺣﺮﻓﻴﻪ‪.‬‬
‫ﻣﻤﻜﻦ أﻋ ﺎدة آﺘﺎﺑ ﻪ اﻟﺒﺮﻧ ﺎﻣﺞ ) ‪ ( 3‬وﻟﻜ ﻦ ﺑﺄﺳ ﺘﺨﺪام اﻟﺜﻮاﻳ ﺖ ﻟ ﻨﻼﺣﻆ آﻴﻔﻴ ﺔ أﺳ ﺘﺨﺪام اﻟﺜﻮاﺑ ﺖ ‪,‬‬
‫ﺟﺰء ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻤﻜﻦ أن ﻳﻜﻮن ﺣﻘﻞ اﻟﺜﻮاﺑ ﺖ ‪ ,‬وه ﺬا ﻳﺨﺘﻠ ﻒ ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﺣﻴ ﺚ أن اﻟﻤﻌ ﺮف ﻓ ﻲ‬
‫ه ﺬا اﻟﺤﻘ ﻞ ﺗﺒﻘ ﻰ ﻗﻴﻤﺘ ﻪ ﺛﺎﺑﺘ ﻪ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ وﻻ ﻳﻤﻜ ﻦ ﺗﻐﻴﻴﺮه ﺎ ‪ ,‬ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻻ ﻳﺨﺘﻠ ﻒ آﺜﻴ ﺮا ﻋ ﻦ‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ وﻟﻜﻦ ﺗﻢ أﺳﺘﺨﺪام اﻟﻤﻌﺮف ) ‪ ( name‬آﻘﻴﻤﻪ ﺛﺎﺑﺘ ﻪ وﻟ ﺬﻟﻚ ﺳ ﻮف ﻻ ﻧﺤﺘ ﺎج اﻟ ﻰ أدﺧ ﺎل‬
‫ﻗﻴﻤﻪ ﻟﻬﺬا اﻟﻤﺘﻐﻴﺮ أو اﻟﻤﻌﺮف ﻷﻧﻨﺎ أدﺧﻠﻨﺎ ﻟﻪ ﻗﻴﻤﻪ ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ وﻣﻤﻜﻦ أن ﺗﻜﻮن هﺬﻩ اﻟﻘﻴﻤﻪ ﻋﺪد ‪,‬‬
‫ﺣﺮف ‪ ,‬أو ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪.‬‬
‫‪26‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‪Program CH2_Program4‬‬
‫‪Const‬‬ ‫'‪{the reserved word 'const‬‬
‫}‪is used to initialize constants‬‬
‫;'‪Name = 'Ahmed‬‬
‫‪Var‬‬
‫;‪Surname: String‬‬
‫‪Begin‬‬
‫;)'‪Write ('Enter your surname :‬‬
‫;)‪Readln (surname‬‬
‫;‪Writeln‬‬
‫;‪Writeln‬‬
‫;)‪Writeln ('your full name is: ', name,' ', surname‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت هﺬا اﻟﺒﺮﻧﺎﻣﺞ هﻲ ذات اﻟﻤﺨﺮﺟﺎت ﻟﻠﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻳﺴﺘﺨﺪم اﻷﻣﺮ ) ‪ ( Halt‬ﻷﻳﻘﺎف ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬


‫وﻳﺴﺘﺨﺪم اﻷﻣﺮ ) ‪ ( Exit‬ﻟﻠﺨﺮوج ﻣﻦ اﻟﻜﺘﻠﻪ اﻟﺤﺎﻟﻴﻪ ‪.‬‬

‫أﻧﻮاع اﻷﺧﻄﺎء اﻟﺘﻲ ﺗﺤﺪث ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ‬ ‫‪2.5‬‬

‫هﻨﺎك ﺛﻼث أﻧﻮاع ﻣﻦ أﺧﻄﺎء اﻟﺒﺮاﻣﺞ اﻟﻤﻬﻤﻪ وهﻲ ‪:‬‬

‫‪ 2.5.1‬اﻟﺨﻄ ﺄ اﻟ ﺬي ﻳﻤﻜ ﻦ ﺗﻤﻴ ﺰﻩ أﺛﻨ ﺎء ﺗﺮﺟﻤ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ ﻗﻴ ﻞ اﻟﺘﻨﻔﻴ ﺬ ‪ ,‬ﻣﺜ ﺎل‬
‫ﻋﺪم آﺘﺎﺑ ﺔ اﻷﻣ ﺮ ) ‪ ( End‬ﻷﻣ ﺮ ) ‪ ( begin‬ﻣﻮﺟ ﻮد ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ .‬وه ﺬا ﻧ ﻮع ﻣ ﻦ اﻷﺧﻄ ﺎء‬
‫اﻟﺘﻲ ﺗﺴﻤﻰ أﺧﻄﺎء وﻗﺖ اﻟﺘﺮﺟﻤﻪ ) ‪ , ( Compile _ time errors‬وهﻮ ﺳ ﻴﺆدي اﻟ ﻰ ﻋ ﺪم‬
‫ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻊ ﻇﻬﻮر رﺳﺎﻟﺔ ﺧﻄﺄ ﺗﺤﺪد ﻧﻮع اﻟﺨﻄﺄ ‪.‬‬

‫‪ 2.5.2‬اﻟﺨﻄ ﺄ اﻟ ﺬي ﻻ ﻳﻤﻴ ﺰ أﺛﻨ ﺎء اﻟﺘﺮﺟﻤ ﻪ وأﻧﻤ ﺎ ﻳﻤﻴ ﺰ أﺛﻨ ﺎء اﻟﺘﻨﻔﻴ ﺬ ‪ ,‬ﻣﺜ ﺎل‬
‫أﺛﻨﺎء اﻟﺘﻨﻔﻴﺬ آﺎن هﻨﺎك أﻣﺮ ﻷﻳﺠﺎد اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ ﻟﻤﺘﻐﻴﺮ ﻣﻌﻴﻦ وﻇﻬ ﺮ أن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ﺳ ﺎﻟﺒﻪ‬
‫) ﻣﻌﺮوف أﻧﻪ ﻻ ﻳﻤﻜﻦ أﻳﺠﺎد اﻟﺠﺬر ﻟﻠﻘﻴﻢ اﻟﺴﺎﻟﺒﻪ ( ‪ ,‬هﺬا ﺳﻴﺆدي اﻟﻰ ﺗﻮﻗ ﻒ ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ﻣ ﻊ‬
‫ﻇﻬ ﻮر رﺳ ﺎﻟﺔ ﺧﻄ ﺄ ‪ .‬ه ﺬا اﻟﻨ ﻮع ﻣ ﻦ اﻷﺧﻄ ﺎء اﻟﺘ ﻲ ﺗ ﺴﻤﻰ أﺧﻄ ﺎء وﻗ ﺖ اﻟﺘﻨﻔﻴ ﺬ‬
‫) ‪. ( Run _ time errors‬‬

‫‪ 2.5.3‬أﻷﺧﻄ ﺎء اﻟﺘ ﻲ ﻻ ﺗﻤﻴ ﺰ ﺳ ﻮاء أﺛﻨ ﺎء اﻟﺘﺮﺟﻤ ﻪ أو أﺛﻨ ﺎء وﻗ ﺖ اﻟﺘﻨﻔﻴ ﺬ ‪ ,‬ﻣﺜ ﺎل‬
‫اﻷﺧﻄ ﺎء اﻟﺘ ﻲ ﻳﺮﺗﻜﺒﻬ ﺎ اﻟﻤﺒ ﺮﻣﺞ رﺑﻤ ﺎ ﺳ ﻬﻮا وﻟﻜﻨﻬ ﺎ ﻣﻘﺒﻮﻟ ﻪ ﻟﻠﺤﺎﺳ ﻮب آ ﺄن ﻳﻜ ﻮن اﻟﻤﻄﻠ ﻮب‬
‫أدﺧﺎل اﻟﻘﻴﻤﻪ ) ‪ ( 30‬وﻳﺘﻢ أدﺧﺎل اﻟﻘﻴﻤ ﻪ ) ‪ ( 40‬ه ﺬا اﻟﺨﻄ ﺄ ﻻ ﻳﻌﺘ ﺮض ﻋﻠﻴ ﻪ اﻟﺤﺎﺳ ﻮب وﻟﻜﻨ ﻪ‬
‫ﺳﻴﺆدي اﻟﻰ ﻇﻬﻮر ﻧﺘﺎﺋﺞ ﻏﻴﺮ ﺻﺤﻴﺤﻪ ‪ ,‬ﻣﺜﻞ هﺬﻩ اﻷﺧﻄﺎء ﺳﻮف ﺗ ﺴﻤﺢ ﻟﻠﺒﺮﻧ ﺎﻣﺞ ﺑﺎﻷﺳ ﺘﻤﺮار‬
‫ﺑﺎﻟﺘﻨﻔﻴﺬ ‪.‬‬
‫‪27‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻋﻨﺪ ﺣﺪوث ﺧﻄﺄ ﻣﻦ اﻟﻨﻮﻋﻴﻦ اﻷول واﻟﺜﺎﻧﻲ أﻋﻼﻩ ﻓﺄن اﻟﺒﺮﻧﺎﻣﺞ ﺳﻮف ﻻ ﻳﻨﻔﺬ وﺗﻈﻬﺮ‬
‫رﺳﺎﻟﺔ ﺧﻄﺄ ﻳﻤﻜﻦ أن ﺗﻀﻐﻂ اﻟﺰر ) ‪ ( F1‬ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﻣﺴﺎﻋﺪﻩ ﺗﻮﺿﺢ ﻣﺎهﻴﺔ اﻟﺨﻄﺄ ‪,‬‬
‫آﺬﻟﻚ ﻓﺄن ﻣﺆﺷﺮ ﻋﻠﻰ ﺷﻜﻞ ﺷﺮﻳﻂ أﺣﻤﺮ ﻳﻈﻬﺮ ﻓﻲ اﻷﻋﻠﻰ ﻳﺒﻴﻦ رﻗﻢ اﻟﺨﻄﺄ ‪ ,‬وﻣﺆﺷﺮ‬
‫ﻋﻠﻰ ﺷﻜﻞ ﺷﺎرﺣﻪ ﻳﺆﺷﺮ ﻋﻠﻰ ﻣﻮﻗﻊ اﻟﺨﻄﺄ أو اﻟﺴﻄﺮ اﻟﺬي ﺑﻌﺪﻩ أﺣﻴﺎﻧﺎ ‪.‬‬

‫ﺟﺪول ) ‪ : ( 2.1‬اﻟﺮﻣﻮز اﻟﺨﺎﺻﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫‪+‬‬ ‫)‪(PLUS‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﺠﻤﻊ ﻗﻴﻤﺘﻴﻦ ‪ ,‬ﺗﺴﺘﺨﺪم أﻳﻀﺎ ﻷﺗﺤﺎد‬


‫ﻋﻼﻣﺔ اﻟﺠﻤﻊ‬ ‫ﺳﻠﺴﻠﺘﻴﻦ ﺣﺮﻓﻴﺘﻴﻦ ‪ ,‬وﺗﺴﺘﺨﺪم ﻟﺠﻤﻊ ﻣﺠﻤﻮﻋﺘﻴﻦ‬
‫‪-‬‬ ‫)‪(MINUS‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﻄﺮح ﻗﻴﻤﺘﻴﻦ ‪ ,‬ﺗﺴﺒﻖ اﻟﻘﻴﻢ ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ‬
‫ﻋﻼﻣﺔ اﻟﻄﺮح‬ ‫أن اﻟﻘﻴﻢ ﺳﺎﻟﺒﻪ ‪ ,‬وﺗﺴﺘﺨﺪم ﻟﻠﻔﺮق ﺑﻴﻦ ﻣﺠﻤﻮﻋﺘﻴﻦ‬
‫*‬ ‫)‪(ASTERISK‬‬ ‫ﺗﺴﺘﺨﺪم ﻷﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻀﺮب ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ ‪,‬‬
‫ﻋﻼﻣﺔ اﻟﻀﺮب‬ ‫وآﺬﻟﻚ ﻟﺘﻘﺎﻃﻊ ﻣﺠﻤﻮﻋﺘﻴﻦ‬
‫‪/‬‬ ‫)‪(SLASH‬‬ ‫ﺗﺴﺘﺨﺪم ﻷﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻘﺴﻤﻪ ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ‬
‫ﻋﻼﻣﺔ اﻟﻘﺴﻤﻪ‬ ‫وﺗﻜﻮن اﻟﻨﺘﻴﺠﻪ ﻗﻴﻤﻪ آﺴﺮﻳﻪ‬
‫=‬ ‫)‪(EQUAL‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﻔﺤﺺ اﻟﻤﺴﺎواة ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ‬
‫ﻋﻼﻣﺔ اﻟﻤﺴﺎواة‬
‫<‬ ‫)‪(LESS THAN‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﻤﻘﺎرﻧﺔ ﻗﻴﻤﺘﻴﻦ وﺗﺤﺪﻳﺪ اﻟﻘﻴﻤﻪ اﻷﺻﻐﺮ‬
‫أﻗﻞ ﻣﻦ‬
‫>‬ ‫)‪(GREATER THAN‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﻤﻘﺎرﻧﺔ ﻗﻴﻤﺘﻴﻦ وﺗﺤﺪﻳﺪ اﻟﻘﻴﻤﻪ اﻷآﺒﺮ‬
‫أآﺒﺮ ﻣﻦ‬
‫[‬ ‫)‪(LEFT BRACKET‬‬ ‫)‬‫ﻳﺴﺘﺨﺪم ﻓﻲ اﻟﻤﺠﺎﻣﻴﻊ واﻟﻤﺼﻔﻮﻓﺎت‬
‫اﻟﻘﻮس اﻟﻤﺮﺑﻊ اﻷﻳﺴﺮ‬ ‫ﺑﺎﻷﺷﺘﺮاك ﻣﻊ اﻟﻘﻮس اﻷﻳﻤﻦ (‬
‫]‬ ‫)‪(RIGHT BRACKET‬‬ ‫ﻳﺴﺘﺨﺪم ﻓﻲ اﻟﻤﺠﺎﻣﻴﻊ واﻟﻤﺼﻔﻮﻓﺎت‬
‫اﻟﻘﻮس اﻟﻤﺮﺑﻊ اﻷﻳﻤﻦ‬ ‫) ﺑﺎﻷﺷﺘﺮاك ﻣﻊ اﻟﻘﻮس اﻷﻳﺴﺮ (‬
‫‪.‬‬ ‫)‪(PERIOD‬‬ ‫ﺗﺴﺘﺨﺪم ﻓﻲ أﺧﺘﻴﺎر ﺣﻘﻞ ﻟﻤﺘﻐﻴﺮ اﻟﻘﻴﻮد ‪ ,‬وﺗﺄﺗﻲ ﺑﻌﺪ‬
‫اﻟﻨﻘﻄﻪ‬ ‫اﻷﻣﺮ ) ‪ ( end‬ﻷﻧﻬﺎء اﻟﺒﺮﻧﺎﻣﺞ‬
‫‪,‬‬ ‫)‪(COMMA‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﻔﺼﻞ اﻟﻌﻮاﻣﻞ ) ‪ (arguments‬وﻟﻔﺼﻞ‬
‫اﻟﻤﺘﻐﻴﺮات ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات وﻟﻔﺼﻞ‬
‫اﻟﻔﺎرزﻩ‬ ‫ﻣﺪﻳﺎت اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ‬
‫‪:‬‬ ‫)‪(COLON‬‬ ‫ﺗﺴﺘﺨﺪﻣﺎن ﻟﻔﺼﻞ أﻧﻮاع اﻟﻤﺘﻐﻴﺮات ﻓﻲ ﺣﻘﻞ‬
‫اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﻌﺎﻣﺪﺗﺎن‬ ‫اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات وﻟﻔﺼﻞ أﺳﻢ اﻟﺪاﻟﻪ ﻋﻦ ﻧﻮﻋﻬﺎ‬
‫ﻋﻨﺪ ﺗﻌﺮﻳﻔﻬﺎ‬
‫‪28‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‬ ‫)‪(SEMI-COLON‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﻔﺼﻞ اﻟﻌﺒﺎرات ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ‬


‫اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ‬ ‫ﺑﺎﺳﻜﺎل‬
‫^‬ ‫)‪(POINTER‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﺘﻌﺮﻳﻒ اﻷﻧﻮاع واﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع‬
‫ﻣﺆﺷﺮ وﺗﺴﺘﺨﺪم ﻟﻠﻮﺻﻮل اﻟﻰ ﻣﺤﺘﻮﻳﺎت اﻟﻤﺘﻐﻴﺮات ﻣﻦ‬
‫اﻟﻤﺆﺷﺮ‬ ‫ﻧﻮع ﻣﺆﺷﺮ وآﺬﻟﻚ ﻣﺤﺘﻮﻳﺎت اﻟﻔﺎﻳﻼت‬
‫(‬ ‫‪(LEFT‬‬ ‫ﻳﺴﺘﺨﺪم ﻟﻴﺤﺘﻮي اﻟﺘﻌﺎﺑﻴﺮ اﻟﺮﻳﺎﺿﻴﻪ واﻟﻤﻨﻄﻘﻴﻪ‬
‫)‪PARENTHESIS‬‬ ‫أو ﻣﻌﺎﻣﻼت اﻟﺪوال واﻷﺟﺮاءات ) ﺑﺎﻷﺷﺘﺮاك ﻣﻊ‬
‫اﻟﻘﻮس اﻷﻋﺘﻴﺎدي اﻷﻳﺴﺮ‬ ‫اﻟﻘﻮس اﻷﻳﻤﻦ (‬
‫)‬ ‫‪(RIGHT‬‬ ‫ﻳﺴﺘﺨﺪم ﻟﻴﺤﺘﻮي اﻟﺘﻌﺎﺑﻴﺮ اﻟﺮﻳﺎﺿﻴﻪ واﻟﻤﻨﻄﻘﻴﻪ‬
‫)‪PARENTHESIS‬‬ ‫أو ﻣﻌﺎﻣﻼت اﻟﺪوال واﻟﺮوﺗﻴﻨﺎت اﻟﻔﺮﻋﻴﻪ ) ﺑﺎﻷﺷﺘﺮاك‬
‫اﻟﻘﻮس اﻷﻋﺘﻴﺎدي اﻷﻳﻤﻦ‬ ‫ﻣﻊ اﻟﻘﻮس اﻷﻳﺴﺮ (‬
‫><‬ ‫‪( LESS THAN /‬‬ ‫أﺧﺘﺒﺎر ﻋﺪم اﻟﻤﺴﺎواة ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ‬
‫) ‪GREATER THAN‬‬
‫ﻋﺪم اﻟﻤﺴﺎواة‬
‫=<‬ ‫‪(LESS THAN /‬‬ ‫ﻟﻠﻤﻘﺎرﻧﻪ ﺑﻴﻦ ﻣﺠﻤﻮﻋﺘﻴﻦ ‪ ,‬و أﺧﺘﺒﺎر اﻟﻤﺠﻤﻮﻋﻪ‬
‫)‪EQUAL‬‬ ‫اﻟﺠﺰﺋﻴﻪ‬
‫أﺻﻐﺮ ﻣﻦ أو ﻳﺴﺎوي‬
‫=>‬ ‫‪(GREATER THAN /‬‬ ‫ﻟﻠﻤﻘﺎرﻧﻪ ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ ‪ ,‬وأﺧﺘﺒﺎر اﻟﻤﺠﻤﻮﻋﻪ اﻟﺸﺎﻣﻠﻪ‬
‫)‪EQUAL‬‬ ‫) ‪( superset‬‬
‫أآﺒﺮ ﻣﻦ أو ﻳﺴﺎوي‬
‫=‪:‬‬ ‫)‪(COLON / EQUAL‬‬ ‫ﺗﺴﺘﺨﺪم ﻷﺳﻨﺎد ﻗﻴﻢ ﻟﻠﻤﺘﻐﻴﺮات‬
‫اﻟﻤﺴﺎواة‬
‫‪..‬‬ ‫)‪(PERIOD / PERIOD‬‬ ‫ﺗﻔﺼﻞ‬
‫اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﺠﺎورﺗﺎن‬

‫ﺟﺪول ) ‪ : ( 2.2‬اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزﻩ اﻟﺨﺎﺻﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫‪AND‬‬ ‫ﻣﻌﺎﻣﻞ اﻟﺮﺑﻂ اﻟﻤﻨﻄﻘﻲ‬


‫‪ARRAY‬‬ ‫ﻧﻮع اﻟﻤﺼﻔﻮﻓﻪ‬
‫‪BEGIN‬‬ ‫ﻋﺒﺎرة اﻟﺒﺪأ‬
‫‪CASE‬‬ ‫ﻋﺒﺎرة اﻟﺒﺪأ ) ﻓﻲ ﺣﺎﻟﺔ ( ) ‪( case‬‬
‫‪CONST‬‬ ‫ﺗﻌﺮﻳﻒ اﻟﺜﻮاﺑﺖ‬
‫‪DIV‬‬ ‫ﺗﻘﺴﻴﻢ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ وﻧﺘﻴﺠﺘﻬﺎ أﻳﻀﺎ أﻋﺪاد ﺻﺤﻴﺤﻪ‬
‫‪DO‬‬ ‫ﺗﺘﺒ ﻊ أواﻣ ﺮ اﻟﺘﻜ ﺮار ) ‪ ( For , While‬وﺗ ﺴﺒﻖ اﻻﻓﻌ ﺎل اﻟﺘ ﻲ ﻳﺠ ﺐ أن‬
‫ﺗﻨﻔﺬ‬
‫‪DOWNTO‬‬ ‫ﺗﺴﺘﺨﺪم ﻣﻊ ﺣﻠﻘﺔ اﻟﺘﻜﺮار ) ‪ ( For‬وﺗﺪل ﻋﻠﻰ أن اﻟﻤﺘﻐﻴﺮ ﻳﻘﻞ ﻓﻲ آﻞ‬
‫‪29‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫دورﻩ‬
‫‪ELSE‬‬ ‫ﺗﺴﺘﺨﺪم ﻣﻊ ) ‪ , ( If‬ﺣﻴﺚ ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﺑﻌﺪ ) ‪( if‬‬
‫ﺧﻄﺄ ) ‪ ( false‬ﺗﻨﻔﺬ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪( else‬‬
‫‪END‬‬ ‫ﻧﻬﺎﺑﺔ اﻟﻌﺒﺎرات اﻟﻤﺮآﺒﻪ اﻟﺘﻲ ﺗﺒﺪأ ﺑﺎﻷﻣﺮ اﺑﺪأ ) ‪ , ( begin‬أو ﻧﻬﺎﻳﻪ‬
‫) ‪( record‬‬ ‫اﻷﻣﺮ ) ‪ ( case‬أو ﻧﻬﺎﻳﻪ ﺗﻌﺮﻳﻒ اﻟﻘﻴﻮد‬
‫‪FILE‬‬ ‫ﺗﻌﺮف ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﻣﻠﻒ‬
‫‪FOR‬‬ ‫ﺗﻨﻔﺬ ﺳﻄﺮ أو أآﺜﺮ ﻣﻦ اﻷواﻣﺮ ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻃﺎﻟﻤﺎ اﻟﻤﺘﻐﻴﺮ ﻟﻢ‬
‫ﻳﺼﻞ اﻟﻰ ﻧﻬﺎﻳﺘﻪ‬
‫‪FUNCTION‬‬ ‫ﺗﻌﺮف داﻟﺔ ﺑﺎﺳﻜﺎل‬
‫‪GOTO‬‬ ‫ﺗﻔﻴﺪ ﻟﻠﺘﻔﺮع اﻟﻰ ﻋﻨﻮان ﻣﺤﺪد ) ‪( label‬‬
‫‪IF‬‬ ‫ﺗﻔﺤﺺ ﺷﺮط ﻣﻨﻄﻘﻲ وﺗﻨﻔﺬ اﻟﻌﺒﺎرﻩ أذا آﺎن اﻟﺸﺮط ﺻﺢ ) ‪( true‬‬
‫‪IN‬‬ ‫ﺗﺤﺪد اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﻋﻠﻰ أﻧﻪ ﺻﺢ ) ‪ ( true‬أذا آﺎﻧﺖ اﻟﻘﻴﻤﻪ‬
‫اﻟﻤﻔﺤﻮﺻﻪ ﺿﻤﻦ ﻣﺠﻤﻮﻋﻪ ﺧﺎﺻﻪ‬
‫‪LABEL‬‬ ‫ﺗﺤﺪد اﻟﻌﻨﻮان اﻟﺬي ﺳﻴﺘﻢ اﻟﺘﻔﺮع ﻟﻪ ﻋﻨﺪ اﺳﺘﺨﺪام اﻷﻣﺮ ) ‪( Goto‬‬
‫‪MOD‬‬ ‫ﻟﺤﺴﺎب ﺑﺎﻗﻲ ﻗﺴﻤﺔ ﻋﺪدﻳﻦ‬
‫‪NIL‬‬ ‫اﻟﻘﻴﻤﻪ اﻟﺨﺎﻟﻴﻪ ﻟﻠﻤﺆﺷﺮات ) ‪( pointers‬‬
‫‪NOT‬‬ ‫ﻟﻨﻔﻲ ﻗﻴﻢ اﻟﻌﺒﺎرات اﻟﻤﻨﻄﻘﻴﻪ‬
‫‪OF‬‬ ‫ﺗﺴﺘﺨﺪم ﻓﻲ ﻋﺒﺎرة ) ‪ (case‬ﺑﻌﺪ ﻣﺘﻐﻴﺮ ) ‪( case‬‬
‫‪OR‬‬ ‫ﻣﻌﺎﻣﻞ اﻷﺧﺘﻴﺎر اﻟﻤﻨﻄﻘﻲ ) أو (‬
‫‪PACKED‬‬ ‫ﻳﺴﺘﺨﺪم ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت ‪ ,‬اﻟﻤﻠﻔﺎت ‪ ,‬اﻟﻘﻴﻮد ‪ ,‬واﻟﻤﺠﻤﻮﻋﺎت‬
‫ﻟﻀﻐﻂ اﻟﺒﻴﺎﻧﺎت اﻟﻤﺨﺰﻧﻪ‬
‫‪PROCEDURE‬‬ ‫ﺗﻌﺮف اﻟﺮوﺗﻴﻦ اﻟﻔﺮﻋﻲ ﻓﻲ ﺑﺎﺳﻜﺎل‬
‫‪PROGRAM‬‬ ‫ﻳﺴﺘﺨﺪم ﻓﻲ ﺑﺪاﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ ) رأس اﻟﺒﺮﻧﺎﻣﺞ (‬
‫‪RECORD‬‬ ‫ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع اﻟﻘﻴﻮد‬
‫‪REPEAT‬‬ ‫ﻟﻠﺒﺪأ ﺑﺄﻣﺮ اﻟﺘﻜﺮار ) ‪(repeat‬‬
‫‪SET‬‬ ‫ﻟﺘﻌﺮﻳﻒ اﻟﻤﺠﻤﻮﻋﺎت‬
‫‪THEN‬‬ ‫ﺗﻠﻲ اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﺑﻌﺒﺎرة ) ‪( IF‬‬
‫‪TO‬‬ ‫ﺗﺴﺘﺨﺪم ﻓﻲ ﺣﻠﻘﺔ اﻟﺘﻜﺮار ) ‪ ( for‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ أن اﻟﻤﺘﻐﻴﺮ ﻳﺰداد ﻓﻲ آﻞ‬
‫دورﻩ ﺑﻤﻘﺪار واﺣﺪ‬
‫‪TYPE‬‬ ‫ﻟﻠﺘﺼﺮﺳﺢ ﻋﻦ ﻧﻮع ﺟﺪﻳﺪ ﻣﻦ اﻟﻤﺘﻐﻴﺮات‬
‫‪UNTIL‬‬ ‫ﻳﺴﺘﺨﺪم ﻷﻧﻬﺎء ﺣﻠﻘﺔ اﻟﺘﻜﺮار ) ‪( repeat‬‬
‫‪VAR‬‬ ‫ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ ﻣﺘﻐﻴﺮات اﻟﺒﺮﻧﺎﻣﺞ‬
‫‪WHILE‬‬ ‫ﻳﻨﻔﺬ آﺘﻠﻪ ﻣﻦ اﻷواﻣﺮ ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻟﺤﻴﻦ أن ﻳﺼﺒﺢ اﻟﺸﺮط ) ‪( False‬‬
‫‪WITH‬‬ ‫ﻟﺘﺤﺪﻳﺪ ﻣﺘﻐﻴﺮ ﻗﻴﺪ ﻳﺴﺘﺨﺪم ﻣﻊ آﺘﻠﻪ ﻣﻦ اﻷواﻣﺮ‬
30 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬ 2.6

. ‫ ( اﻟﻰ ﻣﺎ ﻳﻘﺎﺑﻠﻬﺎ ﺑﺎﻟﺴﺎﻋﺎت واﻟﺪﻗﺎﺋﻖ واﻟﺜﻮاﻧﻲ‬42200 sec ) ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺤﻮﻳﻞ‬

Program CH2_Program5;
Var
Hour, min, sec, temp: integer;
Begin
Sec:=42200 mod 60;
Temp:=42200 div 60;
Min:=temp mod 60;
Hour: = temp div 60;
Writeln ('hour=', hour,'min=', min,'sec=', sec);
End.

y = 4x2 + 3x - 6 ‫ ( ﻣﻦ اﻟﻤﻌﺎدﻟﻪ‬y ) ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻗﻴﻤﺔ‬

Program CH2_Program6;
Var
X,y:integer;
Begin
X: =6;
Y: =4*sqr(x) +3*x-6;
Writeln(y);
End.

. ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺤﻮﻳﻞ درﺟﺔ ﺣﺮارﻩ ﻣﻘﺎﺳﻪ ﺑﺎﻟﻔﻬﺮﻧﻬﺎﻳﺖ اﻟﻰ درﺟﻪ ﻣﺌﻮﻳﻪ‬

Program CH2_Program7;
Var
F:integer;
C: real;
Begin
Writeln ('Enter temerature degree in fehrnhite ');
Readln (f);
C :=( 5/9)*(f+32);
Writeln(c);
End.
31 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

. ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﺴﺎﺣﺔ وﻣﺤﻴﻂ داﺋﺮﻩ‬

Program CH2_Program8;
Var
R: integer;
Area, perimeter: real;
Begin
writeln ('Enter circle radius');
Readln(r);
Area: =sqr(r)*pi;
Perimeter: =2*r*pi;
writeln ('area= ',area,'perimeter= ',perimeter);
End.

. ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﺣﺎﺻﻞ ﺿﺮب وﻣﻌﺪل ﺛﻼث أرﻗﺎم‬

Program CH2_Program9;
Var
Prod, a, b, c: integer;
Average: real;
Begin
Writeln ('Enter three numbers');
Readln (a, b, c);
Prod: = a*b*c;
Average :=( a + b + c)/3;
Writeln ('prod= ', prod);
Writeln ('averge= ', average);
End.
‫‪32‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ‬
‫أﻳﻌﺎزات اﻟﻘﺮار واﻟﺘﻜﺮار‬
‫‪DECISION AND REPEAT INSTRUCTIONS‬‬

‫اﻟﻤﻘﺪﻣﻪ‬ ‫‪3.1‬‬

‫اﻷن ﺟ ﺎء دور دراﺳ ﺔ اﻟﻘﻮاﻋ ﺪ اﻷآﺜ ﺮ أهﻤﻴ ﻪ ﻓ ﻲ اﻟﺒﺮﻣﺠ ﻪ ‪ .‬وه ﻲ أﻳﻌ ﺎزات اﻟﻘ ﺮار‬
‫) ‪ ( If statement‬وآ ﺬﻟﻚ اﻷﻳﻌ ﺎز اﻟﻤﺮاﻏ ﻒ ﻟﻬ ﺎ ) ‪ ( Else‬وﻋﺒ ﺎرات اﻟﺘﻜ ﺮار واﻟﺘ ﻲ ه ﻲ‬
‫)‪ .( For loops , Repeat .. Until loop, While loop‬ﻏﺎﻟﺒ ﺎ ﺗﻌﺘﺒ ﺮ ه ﺬﻩ اﻷواﻣ ﺮ ﻣ ﻦ اﻷواﻣ ﺮ‬
‫اﻟﻜﺜﻴﺮة اﻷﺳﺘﺨﺪام ﻓﻲ اﻟﺒﺮﻣﺠﻪ ﻟﺬا ﻧﻨ ﺼﺢ ﺑﻌ ﺪ اﻷﻧﺘﻬ ﺎء ﻣ ﻦ دراﺳ ﺔ ه ﺬا اﻟﻔ ﺼﻞ اﻟ ﺸﺮوع ﺑﻜﺘﺎﺑ ﺔ ﺑ ﺮاﻣﺞ‬
‫ﺗﺴﺘﺨﺪم ﻓﻴﻬﺎ هﺬﻩ اﻟﻘﻮاﻋﺪ وزﻳﺎدة اﻟﺨﺒﺮﻩ اﻟﻌﻤﻠﻴﻪ ﻗﺒﻞ اﻷﻧﺘﻘﺎل اﻟﻰ ﻣﻮﺿﻮع ﺟﺪﻳﺪ‪.‬‬

‫ﻋﺒﺎرة أذا ‪IF STATEMENT‬‬ ‫‪3.2‬‬

‫ﻳﺴﺘﺨﺪم هﺬا اﻷﻣﺮ ﺑﺎﻟﺘﺮاﻓﻖ ﻣﻊ ) ‪ ( then‬آﻤﺎ ﺳﻨﻮﺿﺢ وهﻮ ﻳﻔﻴﺪ ﻷﺗﺨﺎذ ﻗﺮار ﻣﻦ ﻗﺒﻞ اﻟﻤﺘﺮﺟﻢ‬
‫ﺑﻨﺎءا ﻋﻠﻰ ﺑﻌﺾ اﻟﻤﻌﻄﻴﺎت اﻟﺘﻲ ﺗﺮد ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬هﻨﺎك اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺤﺎﻻت اﻟﺘﻲ ﻻﻳﻤﻜﻦ اﻟﺘﻨﺒﺄ ﺑﻬﺎ ﻣ ﻦ‬
‫ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم أﺛﻨﺎء آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬ﻓﻌﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل أﻧﻨﺎ ﻧﻜﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ ﻷﻋﺪاد‬
‫ﺻﺤﻴﺤﻪ ﻳﺘﻢ أدﺧﺎﻟﻬ ﺎ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤ ﺴﺘﺨﺪم أﺛﻨ ﺎء ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬ﻓ ﻲ ه ﺬﻩ اﻟﺤﺎﻟ ﻪ وآﻤ ﺎ ﻣﻌﻠ ﻮم ﻓ ﺄن اﻟﻌ ﺪد‬
‫اﻟﺼﺤﻴﺢ ﻳﺠ ﺐ أن ﻳﻜ ﻮن ﻣﻮﺟ ﺐ ﻷﻧ ﻪ ﻻﻳﻤﻜ ﻦ أﻳﺠ ﺎد اﻟﺠ ﺬر اﻟﺘﺮﺑﻴﻌ ﻲ ﻟﻠﻌ ﺪد اﻟ ﺴﺎﻟﺐ ‪ ,‬اﻟ ﺴﺆال هﻨ ﺎ ه ﻞ‬
‫ﻳﻤﻜﻦ ﻣﻨﻊ اﻟﻤﺴﺘﺨﺪم ﻣﻦ أدﺧﺎل ﻋﺪد ﺳﺎﻟﺐ ﺳﻮاء آﺎن ﺑﻘﺼﺪ أو ﺳﻬﻮا ‪ ,‬أن اﻟﻤﺒﺮﻣﺞ ﺳﻮف ﻻﻳﺠ ﺪ وﺳ ﻴﻠﻪ‬
‫أﺛﻨﺎء آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻤﻌﺎﻟﺠﺔ هﺬا اﻷﺷ ﻜﺎل اﻟﺒ ﺴﻴﻂ أﻻ أن ﻳ ﺴﺘﺨﺪم ﻋﺒ ﺎرة اﻟﻘ ﺮار) أذا ( واﻟﺘ ﻲ ﻣﻤﻜ ﻦ أن‬
‫ﺗﻜﻮن آﻤﺎ ﻳﻠﻲ ) أذا آﺎن اﻟﻌﺪد ﻣﻮﺟ ﺐ أوﺟ ﺪ اﻟﺠ ﺬر اﻟﺘﺮﺑﻴﻌ ﻲ وﺑﺨ ﻼف ذﻟ ﻚ أهﻤﻠ ﻪ ( ‪) ..‬وﺑﺎﻟﺘﺄآﻴ ﺪ ﻓ ﺄن‬
‫اﻟﻤﺘﺮﺟﻢ ﻓ ﻲ اﻟﺤﺎﺳ ﻮب ﻻ ﻳﻔﻬ ﻢ ﻋﺒ ﺎرة ﻣﻮﺟ ﺐ ﻟ ﺬا ﻧ ﺴﺘﺒﺪﻟﻬﺎ ﺑﻤ ﺎ ﻳﺘﻨﺎﺳ ﺐ وﻗﻮاﻋ ﺪ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل‬
‫ﻓﻨﻘﻮل أذا آﺎن اﻟﻌﺪد أآﺒﺮ أو ﻳﺴﺎوي ﺻﻔﺮ ﻓﺄوﺟﺪ اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ (‪.‬‬
‫أن أﺳﺘﺨﺪام ﻋﺒﺎرة ) ‪ ( If‬ﻳﻜﻮن آﻤﺎ ﻳﻠﻲ ) أذا )ﺷ ﺮط( ﻋﻠﻴ ﻪ ( ‪ ( if condition then ) ..‬أذا‬
‫ﺗﺤﻘﻖ اﻟﺸﺮط اﻟﺬي ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( If‬ﻓﻴﺘﻢ ﺗﻨﻔﻴﺬ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪ ( then‬أﻣﺎ أذا ﻟ ﻢ ﻳﺘﺤﻘ ﻖ ه ﺬا اﻟ ﺸﺮط‬
‫ﻓﻴﻬﻤﻞ ﻣﺎ ﺑﻌﺪ ) ‪ ( then‬أذن ﺳﺘﻜﻮن ﻃﺮﻳﻘﺔ آﺘﺎﺑﻪ هﺬا اﻷﻣﺮ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫} ‪If conditional expression true then code ... ;{if one action‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻻ ﺗﻮﺟﺪ ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( If‬أو ) ‪ ( then‬ﻓﺎرزﻩ ﻣﻨﻘﻮﻃﻪ ‪.‬‬

‫ﻣﻤﻜﻦ ﻣﺜﻼ أن ﻧﻄﻠﺐ ﻣﻦ أﺣﺪهﻢ ﻋﻤﻼ وﻧﻘ ﻮل ﻟ ﻪ ) أذا آ ﺎن اﻟﻤﺤ ﻞ ﻣﻔﺘﻮﺣ ﺎ ﻓﺄﺟﻠ ﺐ ﻟ ﻲ ﺷ ﺮاب‬
‫اﻟﺒﺒ ﺴﻲ ( ) ‪ ( If shop open then get me pepsi‬ه ﺬﻩ اﻟﻌﺒ ﺎرﻩ ﻣﻤﻜ ﻦ ﺻ ﻴﺎﻏﺘﻬﺎ ﺑﺮﻣﺠﻴ ﺎ‬
‫آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪33‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪If shopopen then‬‬


‫; ‪Drink : = pepsi‬‬

‫ﻧﻼﺣﻆ ﻓﻲ هﺬا اﻟﻤﺜﺎل أن اﻟﻔﻌﻞ اﻟﻤﻄﻠ ﻮب أﻧﺠ ﺎزﻩ ه ﻮ ) واﺣ ﺪ أن ﻳﺠﻠ ﺐ ﻟﻨ ﺎ ﺷ ﺮاب اﻟﺒﺒ ﺴﻲ ( ‪.‬‬
‫أﻣﺎ أذا آﺎن ﻣﺎ ﻣﻄﻠﻮب أﻧﺠﺎزﻩ هﻮ أآﺜﺮ ﻣﻦ ﻓﻌﻞ واﺣﺪ ﻓﺄن اﻟﺼﻴﻐﻪ ﺳﺘﺨﺘﻠﻒ ﻗﻠﻴﻼ ‪:‬‬

‫‪If conditional expression true then‬‬

‫‪Begin‬‬

‫‪instructions ...‬‬

‫;‪End‬‬ ‫}‪{if more than one action is required‬‬

‫ﻣ ﺎذا ﻳﻌﻨ ﻲ ذﻟ ﻚ أن اﻷﻣ ﺮ ) ‪ ( If‬ﻳﻨﻔ ﺬ ﻋﺒ ﺎرﻩ واﺣ ﺪﻩ ﺗ ﺄﺗﻲ ﺑﻌ ﺪ ) ‪ ( then‬واﻟﺘ ﻲ ﺗﻤﺜ ﻞ اﻟﻔﻌ ﻞ‬
‫اﻟﻤﻄﻠﻮب أﻧﺠﺎزﻩ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟﺸﺮط ‪ ,‬أﻣﺎ أذا آﺎن هﻨﺎك أآﺜﺮ ﻣﻦ ﻓﻌ ﻞ واﺣ ﺪ ﻣﻄﻠ ﻮب أﻧﺠ ﺎزﻩ ﻋﻨ ﺪ ﺗﺤﻘ ﻖ‬
‫اﻟ ﺸﺮط ﻓﻴﺠ ﺐ أن ﻧﺤ ﺪد ه ﺬﻩ اﻷﻓﻌ ﺎل ﻟﻠﻤﺘ ﺮﺟﻢ وﻳﻜ ﻮن ذﻟ ﻚ ﺑ ﺄن ﻧﺤ ﺪدهﺎ ﺑ ﻴﻦ اﻷﻣ ﺮﻳﻦ‬
‫) )‪ (begin‬و )‪ ( (end‬وﺑﺬﻟﻚ ﺳﻴﻜﻮن واﺿﺢ أن اﻷﻓﻌﺎل اﻟﻤﻄﻠﻮب ﺗﻨﻔﻴﺬهﺎ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟ ﺸﺮط ﺗﺒ ﺪأ ﺑﻌ ﺪ‬
‫اﻷﻣﺮ ) ‪ ( begin‬وﺗﻨﺘﻬﻲ ﺑﺎﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﻗﺒﻞ ) ‪ ( end‬ﻣﻊ ﻣﻼﺣﻈﺔ أن ) ‪ ( end‬ﺗﻨﺘﻬﻲ ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃﻪ‪.‬‬
‫ﻟﻨﻌﺪ اﻟﻰ اﻟﻤﺜ ﺎل اﻟ ﺴﺎﺑﻖ وﻧﻄﻠ ﺐ ﻣ ﻦ أﺣ ﺪهﻢ ﻋﻤ ﻼ وﻧﻘ ﻮل ) أذا آ ﺎن اﻟﻤﺤ ﻞ ﻣﻔﺘ ﻮح ﻓﺄﺟﻠ ﺐ ﻟ ﻲ‬
‫ﺷﺮاب اﻟﺒﺒﺴﻲ وﻋﻠﺒﺔ ﺳﻜﺎﺋﺮ آﻨﺖ ( ) ‪( if shop open get me pepsi and kent cigrates‬‬
‫اﻟﻔﻌﻞ اﻟﻤﻄﻠﻮب أﻧﺠﺎزﻩ هﻨﺎ هﻮ أآﺜﺮ ﻣﻦ واﺣﺪ ﺣﻴﺚ اﻟﻤﻄﻠﻮب ﺟﻠﺐ ﺷﺮاب اﻟﺒﺒﺴﻲ وﺳﻜﺎﺋﺮ ﻣﻦ‬
‫ﻧﻮع آﻨﺖ ‪ .‬ﻟﺬا ﺳﺘﻜﻮن ﺻﻴﺎﻏﺔ هﺬﻩ اﻟﻌﺒﺎرﻩ ﺑﺮﻣﺠﻴﺎ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪If shopopen then‬‬


‫‪Begin‬‬
‫; ‪Drink : = pepsi‬‬
‫; ‪Smook : = kent‬‬
‫; ‪End‬‬

‫ﻓ ﻲ ﺣﺎﻟ ﺔ ﻋ ﺪم وﺿ ﻊ ) ‪ ( begin , end‬ﻓ ﺎن أول ﻋﺒ ﺎرﻩ ﺳ ﺘﺄﺗﻲ ﺑﻌ ﺪ ) ‪ ( then‬ه ﻲ اﻟﺘ ﻲ‬


‫ﺳﺘﻌﺎﻣﻞ ﻋﻠﻰ أﻧﻬﺎ ﺗﻌﻮد اﻟﻰ اﻷﻣﺮ ) ‪ ( If‬وﺗﻨﻔﺬ ﻓﻲ ﺣﺎﻟﺔ ﺗﺤﻘﻖ اﻟﺸﺮط وهﻲ هﻨﺎ ﺳﺘﻜﻮن ) ‪ ( drink‬أﻣﺎ‬
‫أﺳ ﺘﺨﺪام ) ‪ ( begin , end‬ﻓﻬ ﻲ دﻻﻟ ﻪ ﻟﻠﻤﺘ ﺮﺟﻢ ﻋﻠ ﻰ أن ﻣﺠﻤﻮﻋ ﺔ اﻷﻳﻌ ﺎزات اﻟﻤﺤ ﺼﻮرﻩ ﺑ ﻴﻦ‬
‫) ‪ ( begin , end‬هﻲ ﺟﻤﻴﻌﺎ ﻣﻄﻠﻮب ﺗﻨﻔﻴﺬهﺎ أذا ﻣﺎ ﺗﺤﻘﻖ اﻟﺸﺮط ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻋﻨﺪ اﻟﺤﺎﺟﻪ ﻷﺳﺘﺨﺪام اﻟﻤﺴﺎواة ﻓﻲ اﻟﺸﺮط ﺑﻌﺪ ) ‪ ( If‬ﻓﻼ ﺗﺴﺘﺨﺪم اﻟﻤﺴﺎواة اﻟﻤﺴﺒﻮﻗﻪ‬
‫ﺑﻨﻘﻄﺘﻴﻦ ) = ‪ ( assignment ) ( :‬وأﻧﻤﺎ ﺗﺴﺘﺨﺪم اﻟﻤﺴﺎواة اﻷﻋﺘﻴﺎدﻳﻪ ) = ( ﻷن أﺳﺘﺨﺪام‬
‫اﻷوﻟﻰ ﺳﻴﺆدي اﻟﻰ ﻋﺪم أآﻤﺎل اﻟﺘﻨﻔﻴﺬ وﻇﻬﻮر رﺳﺎﻟﺔ ﺧﻄﺄ ‪.‬‬
‫‪34‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫هﻨﺎك ﺣﺎﻟﻪ أﺧﺮى ﻋﻨﺪ أﺳﺘﺨﺪام ) ‪ , ( If‬هﻮ أﺳﺘﺨﺪاﻣﻬﺎ ﻷﺧﺘﻴﺎر ﻓﻌﻞ واﺣﺪ ﻣ ﻦ أﺛﻨ ﻴﻦ ﻓﻤ ﺜﻼ ﻓ ﻲ‬
‫ﻣﺜﺎﻟﻨ ﺎ اﻟ ﺴﺎﺑﻖ ﻣﻤﻜ ﻦ أن ﻳﻜ ﻮن اﻟﻄﻠ ﺐ آﻤ ﺎ ﻳﻠ ﻲ ) أذا آ ﺎن اﻟﻤﺤ ﻞ ﻣﻔﺘﻮﺣ ﺎ ﻓﺄﺟﻠ ﺐ ﻟ ﻲ ﺷ ﺮاب اﻟﺒﺒ ﺴﻲ‬
‫ﻮﻩ (‬ ‫ﻲ ﻗﻬ‬ ‫ﻞﻟ‬ ‫ﻖ ( ﻓﺄﻋﻤ‬ ‫ﻞ ﻣﻐﻠ‬ ‫ﺎن اﻟﻤﺤ‬ ‫ﻚ ) أي أذا آ‬ ‫ﻼف ذﻟ‬ ‫وﺑﺨ‬
‫) ‪ ( If shop open then get me pepsi otherwise get me a coffee‬ه ﺬﻩ اﻟﻌﺒ ﺎرﻩ ﺗﻨﻔ ﺬ‬
‫ﺑﺮﻣﺠﻴﺎ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪If shopopen then‬‬


‫‪Drink : = pepsi‬‬
‫‪Else‬‬
‫; ‪Drink : = coffee‬‬

‫ﻟﻨﻼﺣﻆ هﻨﺎ أن اﻟﺸﺮط اﻟﺬي ﺑﻌﺪ ) ‪ ( If‬أﻣﺎ أن ﻳﻜﻮن )ﺻﺢ ‪ ,‬أو ﺧﻄ ﺄ ( ) ‪( true OR false‬‬
‫أي أﻣﺎ أن ﻳﻜﻮن اﻟﻤﺤﻞ ﻣﻔﺘﻮح أو ﻣﻐﻠﻖ وﻻ ﻳﻮﺟﺪ أﺣﺘﻤ ﺎل أﺧ ﺮ‪ .‬ﻓ ﺄذا آ ﺎن اﻟﻤﺤ ﻞ ﻣﻔﺘ ﻮح ﻓ ﺎﻟﻤﻄﻠﻮب أن‬
‫ﻳﺠﻠﺐ ﺷﺮاب وهﻮ اﻟﺒﺒﺴﻲ ﻓﻲ ﺧﻼف ذﻟﻚ ) ‪ ( else‬أي أذا آﺎن اﻟﻤﺤﻞ ﻣﻐﻠﻖ ﻓﻠﻴﻜﻦ اﻟ ﺸﺮاب ه ﻮ ﻗﻬ ﻮﻩ ‪.‬‬
‫اﻟﻤﻼﺣﻈﻪ اﻟﻤﻬﻤﻪ هﻨ ﺎ ه ﻲ أﻧ ﻪ ﻻﻳﻤﻜ ﻦ أن ﻳﻨﻔ ﺬ اﻟﻌﻤ ﻼن ﺳ ﻮﻳﺔ أي ﻻ ﻳﻤﻜ ﻦ أن ﻳﺠﻠ ﺐ ﺑﺒ ﺴﻲ وﻗﻬ ﻮﻩ ﻓ ﻲ‬
‫ﻧﻔ ﺲ اﻟﻮﻗ ﺖ واﻟ ﺴﺒﺐ ه ﻮ أﻧ ﻪ ﻻﻳﻤﻜ ﻦ أن ﻳﻜ ﻮن اﻟﻤﺤ ﻞ ﻣﻔﺘ ﻮح وﻣﻐﻠ ﻖ ﺑ ﺬات اﻟﻮﻗ ﺖ ‪ .‬ﻋﻠﻴ ﻪ ﻓ ﺄذا ﺗﺤﻘ ﻖ‬
‫اﻟﺸﺮط ) أي اﻟﺸﺮط ﺻﺢ ﺑﻤﻌﻨﻰ أن اﻟﻤﺤﻞ ﻣﻔﺘﻮح ( ﻓ ﺄن اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺗ ﺄﺗﻲ ﺑﻌ ﺪ ) ‪ ( then‬ﺳ ﺘﻨﻔﺬ ﺑﻴﻨﻤ ﺎ‬
‫اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪ ( else‬ﺳﺘﻬﻤﻞ ‪ ,‬أﻣﺎ أذا آﺎن اﻟﺸﺮط ﻏﻴﺮ ﻣﺘﺤﻘﻖ ) أي أﺟﺎﺑﺔ اﻟ ﺸﺮط ﺧﻄ ﺄ ﺑﻤﻌﻨ ﻰ أن‬
‫اﻟﻤﺤﻞ ﻣﻐﻠﻖ ( ﻓﺄن اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪ ( If‬ﺳﺘﻬﻤﻞ وﺗﻨﻔﺬ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪. ( else‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫داﺋﻤﺎ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺗﺴﺒﻖ ) ‪ ( else‬ﻣﺒﺎﺷﺮة ﻻ ﺗﺤﺘﻮي ﻋﻠﻰ ﻓﺎرزﻩ ﻣﻨﻘﻮﻃﻪ ) ﺗﺤﺬف(‪.‬‬

‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻣﻤﻜﻦ أن ﻳﻜﻮن ﺟﺰء ﻣﻦ ﻟﻌﺒﻪ ﺑﺎﻣﻜﺎﻧﻚ ان ﺗﻀﻴﻒ أﻟﻴﻬﺎ أﺳ ﺌﻠﻪ أﺧ ﺮى ﻟﺘﻜ ﻮن ﻟﻌﺒ ﻪ‬
‫ﻣﺘﻜﺎﻣﻠﻪ ‪:‬‬

‫;)'?‪Writeln ('Who has discovered the land of America‬‬


‫;)‪Readln (ans‬‬
‫‪If (ans = 'Christopher Columbus') then‬‬
‫‪score := score + 1‬‬ ‫}‪{if this is false,‬‬
‫‪ELSE‬‬
‫;)'!‪Writeln ('sorry, you've got it wrong‬‬ ‫}‪{then this is true‬‬
‫‪35‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫أذا اﻟﻤﺮآﺒﻪ ‪COMPOUND IF‬‬ ‫‪3.3‬‬

‫ﻣﻤﻜﻦ أن ﻧ ﺴﺘﺨﺪم ) ‪ ( If‬ﺑ ﺸﻜﻞ ﻣﺘ ﺪاﺧﻞ ﻣ ﻊ ) ‪ (If OR else‬أﺧ ﺮى ‪ ,‬وﺑﻬ ﺬﻩ اﻟﺤﺎﻟ ﻪ ﺗ ﺴﻤﻰ‬
‫ﻣﺮآﺒﻪ ) أي ﻣﻤﻜﻦ أن ﻳﻜﻮن ﺑﻌﺪ ) ‪ ( then‬ﻋﺒﺎرﻩ ) ‪ ( If‬وﻣﻤﻜﻦ أﻳﻀﺎ ﺑﻌﺪ ﻋﺒ ﺎرة ) ‪ ( else‬وﻣﻤﻜ ﻦ أن‬
‫ﺗﻜ ﻮن أآﺜ ﺮ ﻣ ﻦ واﺣ ﺪﻩ ‪ .‬ﻓﻤ ﺜﻼ ﻧﺮﻳ ﺪ أن ﻧﻔﺤ ﺺ ﻧﻮﻋﻴ ﺔ رﻣ ﺰ ﻣﻌ ﻴﻦ ووﻓﻘ ﺎ ﻟ ﺬﻟﻚ ﻧﻘ ﺮر ﻣ ﺎهﻮ اﻷﺟ ﺮاء‬
‫اﻟﻮاﺟﺐ أﺗﺒﺎﻋﻪ وآﻤﺎﻳﻠﻲ ‪:‬‬

‫‪If ( charkind = digit ) then‬‬


‫‪Readnumber‬‬
‫‪Else‬‬
‫‪If ( charkind = letter ) then‬‬
‫‪Readname‬‬
‫‪Else‬‬
‫; ‪Reporterror‬‬

‫ﻟﻨﺘﺄﻣﻞ هﺬا اﻟﻤﺜﺎل ﻓﻔﻲ اﻟﺒﺪاﻳﻪ ﻳﺘﻢ ﻓﺤﺺ اﻟﺸﺮط ﻟﻤﻌﺮﻓ ﺔ ﻧ ﻮع اﻟﺮﻣ ﺰ ﻟﻠﻤﺘﻐﻴ ﺮ ) ‪( charkind‬‬
‫) ‪ ( digit‬أم ﻻ ‪ ,‬وآﻤﺎ ﺗﻌﻠﻤﻨ ﺎ داﺋﻤ ﺎ أن اﻷﺟﺎﺑ ﻪ أﻣ ﺎ ﻧﻌ ﻢ ) ﺻ ﺢ ( أو ﻻ ) ﺧﻄ ﺄ ( وﻻ‬ ‫هﻞ هﻮ رﻗﻢ‬
‫ﻳﻮﺟ ﺪ أﺣﺘﻤ ﺎل أﺧ ﺮ ‪ ,‬ﻓ ﺄذا آ ﺎن ﺻ ﺢ ﻣﻌﻨ ﺎﻩ أن اﻟﺮﻣ ﺰ ﻣ ﻦ ﻧ ﻮع ) ‪ ( digit‬ﻋﻠﻴ ﻪ ﺗﻨﻔ ﺬ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺑﻌ ﺪ‬
‫) ‪ ( then‬ﻣﺒﺎﺷ ﺮة أي أﻗ ﺮأ رﻗ ﻢ ) ه ﺬا اﻷﺣﺘﻤ ﺎل اﻷول ( ‪ ,‬أﻣ ﺎ اﻷﺣﺘﻤ ﺎل اﻟﺜ ﺎﻧﻲ ﻓﺘﻜ ﻮن أﺟﺎﺑ ﺔ اﻟ ﺸﺮط‬
‫ﺧﻄﺄ أي أن ﻧﻮع اﻟﺮﻣﺰ هﻲ ﻟﻴﺴﺖ أرﻗﺎم ﻋﻠﻴ ﻪ ﻓ ﺴﺘﻬﻤﻞ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺑﻌ ﺪ ) ‪ ( then‬وﺗﻨﻔ ﺬ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ‬
‫ﺑﻌﺪ ) ‪ .. ( else‬ﻋﻨﺪﻣﺎ ﻳﺤﻴﻦ اﻟﺪور ﻟﺘﻨﻔﻴﺬ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪ ( else‬ﻧﻼﺣﻆ أن ه ﺬﻩ اﻟﻌﺒ ﺎرﻩ ه ﻲ أﻳ ﻀﺎ‬
‫ﻋﺒﺎرة ) ‪ ( If‬هﺬا ﻳﻌﻨﻲ أﻧﻪ ﻻزال هﻨﺎك أﺣﺘﻤﺎﻻت أﺧﺮى ﻳﺠﺐ أن ﺗﻔﺤﺺ ﻓﻤﻤﻜﻦ أن ﻳﻜ ﻮن اﻟﺮﻣ ﺰ ﻩ و‬
‫) ‪ ( letter‬أو ﺷ ﻲء أﺧ ﺮ وﺗﻄﺒ ﻖ ﻧﻔ ﺲ اﻟﻘﺎﻋ ﺪﻩ ﻓ ﺄذا آﺎﻧ ﺖ أﺟﺎﺑ ﺔ اﻟ ﺸﺮط ﺻ ﺢ ﺗﻨﻔ ﺬ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺑﻌ ﺪ‬
‫) ‪) ( then‬اﻟﺜﺎﻧﻴ ﻪ( أﻣ ﺎ أذا آﺎﻧ ﺖ اﻷﺟﺎﺑ ﻪ ﺧﻄ ﺄ ﻓﺘﻨﻔ ﺬ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺑﻌ ﺪ ) ‪) ( else‬اﻟﺜﺎﻧﻴ ﻪ( واﻟﺘ ﻲ ه ﻲ‬
‫) ‪( digit OR letter‬‬ ‫أﺻﺪار رﺳﺎﻟﺔ ﺧﻄﺄ ) أي أﻋﻼم اﻟﻤﺴﺘﺨﺪم أن هﺬا اﻟﺮﻣﺰ هﻮ ﻟﻴﺲ‬
‫ﻋﺒﺎرات ) ‪ ( If‬هﺬﻩ ﺗﺴﻤﻰ أﻳﻀﺎ ﻋﺒﺎرات ) ‪ ( If‬اﻟﻤﺘﺪاﺧﻠﻪ ) ‪( nested If statements‬‬

‫‪If (this happens) then‬‬ ‫}‪{if 1‬‬


‫‪If (this happens) then‬‬ ‫}‪{if 2‬‬
‫‪(do this) etc...‬‬
‫)‪Else (do this‬‬ ‫}‪{if 2‬‬
‫‪Else (do this) etc...‬‬ ‫}‪{if 1‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫داﺋﻤﺎ ﺗﺴﺘﺨﺪم ) ‪ ( If‬ﻋﻨﺪﻣﺎ ﻧﺤﺘﺎج أن ﻧﺨﺘﺎر ﺑﻴﻦ أآﺜﺮ ﻣﻦ ﺣﺎﻟﻪ ) أي أﺧﺘﻴﺎر ﻋﻤﻞ‬
‫أو ﺣﺎﻟﻪ واﺣﺪﻩ ﻣﻦ ﺑﻴﻦ أﺛﻨﻴﻦ أو أآﺜﺮ ( ‪.‬‬
‫‪36‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻋﺒﺎرة اﻟﺘﻜﺮار ‪REPEAT -- UNTIL LOOP‬‬ ‫‪3.4‬‬

‫ﻳ ﺴﺘﺨﺪم ه ﺬا اﻷﻣ ﺮ ﻟﺘﻜ ﺮار ﻋﺒ ﺎرﻩ أو أآﺜ ﺮ ﻟﻌ ﺪد ﻣ ﻦ اﻟﻤ ﺮات وﻓﻘ ﺎ ﻟﻤﺘﻄﻠﺒ ﺎت اﻟﺒﺮﻧ ﺎﻣﺞ واﻟﺘ ﻲ‬
‫ﻳﺤﺪدهﺎ اﻟﻤﺒﺮﻣﺞ ‪ ,‬ﻓﻲ هﺬا اﻷﻣﺮ ﻓﺎن اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻨﻔﺬ ﻋﻠﻰ اﻷﻗﻞ ﻟﻤﺮﻩ واﺣ ﺪﻩ ‪ ..‬وﻳﻜ ﻮن ﺗﻮﻗ ﻒ اﻟﺒﺮﻧ ﺎﻣﺞ‬
‫أﻋﺘﻤﺎدا ﻋﻠﻰ ﺷﺮط ﻳﻮﺿﻊ ﺑﻌﺪ ) ‪.( until‬‬
‫اﻟﺘﻜ ﺮار ﻳﺒ ﺪأ ﺑ ﺎﻷﻣﺮ ) أﻋ ﺪ أو آ ﺮر ( ) ‪ ( Repeat‬ﺛ ﻢ ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻷﻳﻌ ﺎزات اﻟﻤﻄﻠ ﻮب‬
‫ﺗﻜﺮارهﺎ وﺗﻨﺘﻬﻲ ﺑﺎﻷﻣﺮ ) ﻟﻐﺎﻳﺔ ( ) ‪ ( until‬اﻟﺬي ﻳﻜﻮن ﺑﻌﺪﻩ ﺷﺮط ) أي ﻟﻐﺎﻳ ﺔ ﺗﺤﻘ ﻖ ه ﺬا اﻟ ﺸﺮط ( ‪,‬‬
‫اﻟﻤﺘﺮﺟﻢ ﺣﻴﻦ ﻳﺠ ﺪ اﻟﻌﺒ ﺎرﻩ ) أﻋ ﺪ ( ﻓﺄﻧ ﻪ ﻳﻌﻠ ﻢ أن اﻟﻤﻄﻠ ﻮب أﻋ ﺎدة ﺗﻨﻔﻴ ﺬ اﻟﻌﺒ ﺎرات اﻟﻤﺤ ﺼﻮرﻩ ﺑ ﻴﻦ ه ﺬا‬
‫اﻷﻣﺮ واﻷﻣﺮ ) ﻟﻐﺎﻳﺔ (‪ ..‬ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺼﻞ اﻟﻤﺘﺮﺟﻢ اﻟﻰ اﻷﻣﺮ ) ﻟﻐﺎﻳ ﺔ ‪ ( until‬ﻳﻔﺤ ﺺ اﻟ ﺸﺮط اﻟ ﺬي‬
‫ﺑﻌ ﺪﻩ ﻓ ﺄذا آ ﺎن اﻟ ﺸﺮط ﻏﻴ ﺮ ﻣﺘﺤﻘ ﻖ ) أﺟﺎﺑﺘ ﻪ ‪ ( false‬ﻓ ﺄن اﻟﻤﺘ ﺮﺟﻢ ﺳ ﻴﻌﻮد اﻟ ﻰ اﻷﻣ ﺮ‬
‫) ‪ ( repeat‬وﻳﺒﺪأ ﺑﺎﻟﺘﻨﻔﻴﺬ ﻧﺰوﻻ ﻣﻦ ﺟﺪﻳﺪ ‪ ,‬هﺬﻩ اﻟﻌﻤﻠﻴﻪ ﺗ ﺴﺘﻤﺮ ﻟﻐﺎﻳ ﺔ أن ﻳﺘﺤﻘ ﻖ اﻟ ﺸﺮط وﺗﻜ ﻮن أﺟﺎﺑﺘ ﻪ‬
‫) ‪ . ( true‬اﻟﺼﻴﻐﻪ اﻟﻘﻮاﻋﺪﻳﻪ ﻟﻬﺬا اﻷﻳﻌﺎز هﻲ ‪:‬‬

‫‪Repeat‬‬
‫; ‪Instruction 1‬‬
‫; ‪Instruction 2‬‬
‫…‪Etc‬‬
‫; ) ‪Until (condition is true‬‬

‫ﻣﺜﺎل ‪ //:‬هﺬا ﺑﺮﻧﺎﻣﺞ ﺑﺴﻴﻂ واﺟﺒ ﻪ أدﺧ ﺎل أﺳ ﻤﺎء اﻟﻄﻠﺒ ﻪ وﻃﺒﺎﻋﺘﻬ ﺎ ‪ ,‬اﻟﺒﺮﻧ ﺎﻣﺞ ﻻ ﻳﺘﻮﻗ ﻒ ﻟﻐﺎﻳ ﺔ‬
‫أدﺧﺎل أﺳﻢ ) ﻋﻠﻲ ( ‪.‬‬

‫;‪Program CH3_Program1‬‬

‫;‪Var YN: String‬‬


‫‪Begin‬‬
‫;)'?‪Writeln ('enter name of students‬‬
‫;)‪Readln (YN‬‬
‫‪If (YN <> ' Ali') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If (YN <> ' Ali ') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If‬‬ ‫‪(YN <> ' Ali ') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If (YN <> ' Ali') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If (YN <> ' Ali ') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If‬‬ ‫‪(YN <> ' Ali ') then‬‬
‫)‪Writeln (YN‬‬
‫…‬
‫…‬
‫‪37‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻣﻤﻜﻦ أن ﻳﺴﺘﻤﺮ ﺑﻌ ﺪد آﺒﻴ ﺮ ﻣ ﻦ اﻟﺨﻄ ﻮات اﻟﻤﺘ ﺸﺎﺑﻪ وﺣ ﺴﺐ ﻋ ﺪد اﻟﻄﻠﺒ ﻪ اﻟﻤ ﺮاد‬
‫ﻃﺒﺎﻋﺔ أﺳﻤﺎﺋﻬﻢ ‪ ,‬أن اﻟﻌﺒﺎرات ) اﻗﺮأ ‪ ,‬أذا ‪ ,‬وأآﺘﺐ ( ﺗﺘﻜﺮر ﺑﺄﺳﺘﻤﺮار ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ‪ ,‬ﻟﺬا ﻓﺎن ﻟﻐ ﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل أوﺟﺪت اﻟﺒﺪﻳﻞ اﻟﺬي ﻳﺴﻬﻞ اﻟﻌﻤﻞ وﻳﺨﺘﺼﺮ ﻋﺪد اﻟﺨﻄﻮات أﻻ وهﻮ ﻋﺒ ﺎرات اﻟﺘﻜ ﺮار ‪.‬‬
‫واﺣ ﺪ ﻣ ﻦ ه ﺬﻩ اﻷواﻣ ﺮ ه ﻮ ) ‪ ( repeat‬وأذا ﻣ ﺎ أﻋ ﺪﻧﺎ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ أﻋ ﻼﻩ وﻟﻜ ﻦ ﻣ ﻊ أﺳ ﺘﺨﺪام‬
‫) ‪ , ( repeat‬ﺳﻴﻨﺘﺞ ﻟﻨﺎ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;‪Program CH3_Program2‬‬

‫;‪Var YN: String‬‬


‫‪Begin‬‬
‫;)'?‪Writeln ('enter name of students‬‬
‫‪Repeat‬‬ ‫}‪{repeat the code for at least one time‬‬
‫;) ‪Readln ( YN‬‬
‫; ) ‪Writeln ( YN‬‬
‫;)'‪Until (YN = 'Ali‬‬
‫‪End.‬‬

‫ﻣﻴﺰة هﺬا اﻷﻣﺮ أن اﻟﺸﺮط هﻮ ﻓﻲ ﻧﻬﺎﻳﺔ اﻟﺘﻜﺮار وﻟﺬا ﻓﺄﻧﻪ ﺳﻴﻨﻔﺬ وﻟﻮ ﻟﻤ ﺮﻩ واﺣ ﺪﻩ ﻗﺒ ﻞ أن ﻳ ﺘﻢ‬
‫ﻓﺤﺺ اﻟﺸﺮط ‪ .‬أرﺟﻮ ﻣﻼﺣﻈﺔ آﻴﻒ أن اﻟﺒﺮﻧﺎﻣﺞ أﺻﺒﺢ أآﺜﺮ أﺧﺘﺼﺎرا وأﺳﻬﻞ ﻟﻠﻤﺘﺎﺑﻌﻪ ‪.‬‬

‫‪WHILE -_DO LOOP‬‬ ‫ﻋﺒﺎرة اﻟﺘﻜﺮار‬ ‫‪3.5‬‬

‫وه ﻮ أﻳ ﻀﺎ ﻣ ﻦ أﻳﻌ ﺎزات اﻟﺘﻜ ﺮار وه ﻮ ﻳ ﺸﺎﺑﻪ أﻟ ﻰ درﺟ ﻪ آﺒﻴ ﺮﻩ اﻷﻳﻌ ﺎز ) ‪( Repeat_until‬‬
‫ﺣﻴﺚ أن واﺟﺐ اﻷﻳﻌﺎزﻳﻦ هﻮ اﻟﺘﻜﺮار ﻟﻤﺮات ﻏﻴﺮ ﻣﺤﺪدﻩ اﺑﺘﺪاءا وأﻧﻤﺎ ﻳﻌﺘﻤﺪان ﻋﻠﻰ ﺗﺤﻘﻖ ﺷﺮط ﻣﻌﻴﻦ‬
‫ﻷﻳﻘﺎف اﻟﺘﻜﺮار ‪ ,‬اﻟﺼﻴﻐﻪ اﻟﻘﻮاﻋﺪﻳﻪ ﻟﻬﺬا اﻟﺘﻜﺮار هﻲ ‪:‬‬

‫‪While <condition is true> do the following:‬‬

‫;‪instruction 1‬‬

‫;‪instruction 2‬‬

‫;‪instruction 3‬‬

‫‪etc...‬‬

‫}‪End; {If while-do loop starts with a begin statement‬‬

‫ﻣﺎذا ﻳﻌﻨﻲ هﺬا اﻷﻣﺮ ) ﻋﻨﺪﻣﺎ ﻳﺘﺤﻘﻖ اﻟﺸﺮط أﻋﻤﻞ ﻣﺎ ﻳﻠﻲ ( وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﺳ ﻴﻨﻔﺬ اﻷﻳﻌ ﺎز اﻟ ﺬي‬
‫) ‪ ( while‬ﻟ ﻴﻔﺤﺺ اﻟ ﺸﺮط ه ﻞ ه ﻮ ﻣﺘﺤﻘ ﻖ أم ﻻ ﻓ ﺄذا آ ﺎن ﻣﺘﺤﻘ ﻖ ﻳﻨﻔ ﺬ‬ ‫ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮة وﻳﻌ ﻮد اﻟ ﻰ‬
‫وأن آﺎن ﻏﻴﺮ ﻣﺘﺤﻘﻖ ﺳﻴﻬﻤﻞ اﻷﻳﻌﺎز اﻟﺬي ﺑﻌﺪ ) ‪ ( while‬وﻳﻨﻔﺬ ﻣﺎ ﺑﻌﺪﻩ ‪.‬‬
‫‪38‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫آﻤﺎ هﻮ اﻟﺤﺎل ﻓﻲ ) ‪ ( If and else‬ﻓﺎن اﻷﻣﺮ ) ‪ ( while‬ﻳﻨﻔﺬ ﻋﺒﺎرﻩ واﺣﺪﻩ ﻓﻘﻂ واﻟﺘﻲ‬
‫ﺗﺄﺗﻲ ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮﻩ ‪ ,‬أﻣﺎ أذا آﺎن هﻨﺎك أآﺜﺮ ﻣﻦ ﻋﺒﺎرﻩ واﺣﺪﻩ ﻣﻄﻠﻮب ﺗﻜﺮارهﺎ ﺿﻤﻦ اﻻﻣﺮ‬
‫) ‪ ( while‬ﻓﻴﺠﺐ أن ﺗﺤﺪد ﺑﻴﻦ اﻷﻣﺮ ) ‪ ( begin‬واﻷﻣﺮ ) ‪( end‬‬

‫اذن ﻣﺎ هﻮ اﻟﻔﺮق ﺑﻴﻦ ) ‪ ( While‬و )‪ .. (Repeat‬ﻻﺣﻆ اﻟﺠﺪول ) ‪: ( 3.1‬‬

‫ﺟﺪول ) ‪ : ( 3.1‬اﻟﻔﺎرق ﺑﻴﻦ أﻣﺮي اﻟﺘﻜﺮار ) ‪( repeat , while‬‬

‫‪Repeat_Until‬‬ ‫‪While_Do‬‬
‫اﻟﺸﺮط ﻓﻲ ﻧﻬﺎﻳﺔ اﻟﺘﻜﺮار‬ ‫اﻟﺸﺮط ﻓﻲ ﺑﺪاﻳﺔ اﻟﺘﻜﺮار‬
‫ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬ اﻷﻳﻌﺎزات اﻟﻤﺸﻤﻮﻟﻪ ﺑﺎﻟﺘﻜﺮار ﻋﻠﻰ اﻻﻗﻞ‬ ‫ﻻ ﻳﻨﻔﺬ أي أﻳﻌﺎز ﻣﺎﻟﻢ ﻳﺘﻢ ﻓﺤﺺ اﻟﺸﺮط وﺗﺤﻘﻘﻪ‬
‫ﻣﺮﻩ واﺣﺪﻩ ﻗﺒﻞ أن ﻳﺘﻢ ﻓﺤﺺ اﻟﺸﺮط‬
‫ﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟﺸﺮط‬ ‫ﺗﻨﻔﺬ اﻷﻳﻌﺎزات اﻟﻤﺸﻤﻮﻟﻪ ﺑﺎﻟﺘﻜﺮار ﻋﻨﺪ ﺗﺤﻘﻖ‬
‫اﻟﺸﺮط‬
‫ﻳﺴﺘﺨﺪم ﻣﻊ ﻃﻠﺒﺎت اﻟﺘﻜﺮار ﻏﻴﺮ اﻟﻤﺤﺪدﻩ ﺑﻌﺪد ﺛﺎﺑﺖ‬ ‫ﻳﺴﺘﺨﺪم ﻣﻊ ﻃﻠﺒﺎت اﻟﺘﻜﺮار ﻏﻴﺮ اﻟﻤﺤﺪدﻩ ﺑﻌﺪد‬
‫ﻣﻦ اﻟﺘﻜﺮارات ﻣﺴﺒﻘﺎ‬ ‫ﺛﺎﺑﺖ ﻣﻦ اﻟﺘﻜﺮارات ﻣﺴﺒﻘﺎ‬
‫ﻳﻌﺘﻤﺪ أﺳﺘﻤﺮار اﻟﺘﻨﻔﻴﺬ ﻋﻠﻰ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط‬ ‫ﻳﻌﺘﻤﺪ أﺳﺘﻤﺮار اﻟﺘﻨﻔﻴﺬ ﻋﻠﻰ ﺗﺤﻘﻖ اﻟﺸﺮط‬
‫وﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟﺸﺮط‬ ‫وﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط‬

‫ﻣﺜﺎل ‪ //:‬ﻣﺜﺎل ﺑﺴﻴﻂ ﻷدﺧﺎل ﻣﺠﻤﻮﻋﺔ أرﻗﺎم وﻃﺒﺎﻋﺘﻬﺎ ﺑﺸﺮط ﻳﺘﻢ اﻟﺘﻮﻗﻒ ﻋﻨﺪ أدﺧﺎل‬
‫اﻟﺮﻗﻢ ) ‪. ( 0‬‬

‫;‪Program CH3_Program3‬‬

‫;‪Var x : integer‬‬
‫‪Begin‬‬
‫;)'‪Writeln ('Enter number‬‬
‫;)‪Readln(x‬‬
‫‪While x <> 0 do‬‬
‫‪Begin‬‬
‫;)‪Writeln(x‬‬
‫;)‪Readln(x‬‬
‫;‪End‬‬
‫‪End.‬‬
‫‪39‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬

‫اﻟﻤﻄﻠﻮب ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ أدﺧﺎل ﻣﺠﻤﻮﻋﺔ أرﻗﺎم ﺑ ﺸﺮط أن ﻳﺘﻮﻗ ﻒ ﻋﻨ ﺪ أدﺧ ﺎل اﻟ ﺮﻗﻢ ) ‪ , ( 0‬أذن‬
‫ﻟﻤﺎ آﺎن أدﺧﺎل ﻣﺠﻤﻮﻋﺔ أرﻗﺎم ﻓﻬﺬا ﻳﻌﻨﻲ أﻧﻨﺎ ﺳﻨﻜﺮر أﻣ ﺮ اﻷدﺧ ﺎل أآﺜ ﺮ ﻣ ﻦ ﻣ ﺮﻩ وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﻳﺠ ﺐ‬
‫ﻓﺤﺺ اﻟﺮﻗﻢ ﻟﻐﺮض ﻃﺒﺎﻋﺘﻪ أذا ﻟﻢ ﻳﻜﻦ ﻳﺴﺎوي ) ‪ ( 0‬هﺬﻩ اﻟﻌﻤﻠﻴﻪ ﻣﻤﻜﻦ ﺗﻜﺮاره ﺎ ‪ 5‬ﻣ ﺮات ‪ 10‬ﻣ ﺮات‬
‫‪ 1000‬ﻣﺮﻩ أو أآﺜﺮ ﺣﺴﺐ ﻃﺒﻴﻌﺔ اﻟﻌﻤﻞ ) ﺗﺼﻮروا ﺑﺮﻧﺎﻣﺞ ﻳﺘﻜﻮن ﻣﻦ هﺬا اﻟﻜ ﻢ اﻟﻬﺎﺋ ﻞ ﻣ ﻦ اﻟﺨﻄ ﻮات‬
‫اﻟﻤﺘ ﺸﺎﺑﻬﻪ !!( ﻟ ﺬﻟﻚ ﻟﺘﺠﻨ ﺐ ه ﺬﻩ اﻟﻌﻤﻠﻴ ﻪ ﺗ ﻢ أﻳﺠ ﺎد أﻳﻌ ﺎزات اﻟﺘﻜ ﺮار ﻓ ﻴﻤﻜﻦ هﻨ ﺎ أن ﻧ ﺴﺘﺨﺪم اﻷﻣ ﺮ‬
‫) ‪ ( While‬ﻷﺧﺘﺼﺎر اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬هﺬا اﻷﻣﺮ ﻳﺤﺘﺎج اﻟﻰ ﺷﺮط ﻟﻐﺮض اﻟﻌﻤﻞ واﻟﺘﻮﻗﻒ ‪ ,‬ﻓ ﻲ ه ﺬا اﻟﻤﺜ ﺎل‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻳﺘﻮﻗﻒ ﻋﻨﺪ ورود اﻟﺮﻗﻢ ) ‪ ( 0‬أي أﻧ ﻪ ﻳﻌﻤ ﻞ ﻣ ﻊ اﻷرﻗ ﺎم اﻷﺧ ﺮى وﻟﻤ ﺎ آ ﺎن اﻟ ﺸﺮط ﻳﺠ ﺐ أن‬
‫ﻳﻜ ﻮن ) ‪ ( true‬ﻟﻜ ﻲ ﻳﻌﻤ ﻞ أذن أي رﻗ ﻢ ﻻﻳ ﺴﺎوي ﺻ ﻔﺮ ﺳ ﻮف ﻳﺠﻌ ﻞ اﻟﺒﺮﻧ ﺎﻣﺞ ﻳﻌﻤ ﻞ ﻟ ﺬا ﺟﻌﻠﻨ ﺎ‬
‫) ‪ , ( x < > 0‬ﻟﻘﺪ ﺳ ﺒﻖ وأن ﺑﻴﻨ ﺎ أن اﻟﻤﺘ ﺮﺟﻢ ﻋﻨ ﺪﻣﺎ ﻳ ﺼﻞ اﻟ ﻰ أي ﺧﻄ ﻮﻩ ﻓﻴﻬ ﺎ ﻣﺘﻐﻴ ﺮ ﺳ ﻴﻘﻮم ﺑﻌﻤﻠ ﻴﻦ‬
‫اﻷول ﻳﺘﺄآﺪ ﻣﻦ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات واﻟﺜﺎﻧﻲ ﻳﺘﺄآﺪ ﻣﻦ أن اﻟﻤﺘﻐﻴﺮ ﻟﻪ ﻗﻴﻤﻪ وﺣﺴﺐ اﻟﻨﻮع‬
‫اﻟﻤﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات ‪ .‬ﻟ ﺬا ﻓﺄﻧ ﻪ ﻋﻨ ﺪﻣﺎ ﻳ ﺼﻞ اﻟﻤﺘ ﺮﺟﻢ اﻟ ﻰ اﻷﻣ ﺮ ) ‪ ( While‬ﻳﺠ ﺐ أن ﻳﺠ ﺪ‬
‫ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( x‬وهﺬا هﻮ اﻟﺴﺒﺐ اﻟﺬي ﺟﻌﻠﻨﺎ ﻧ ﺪﺧﻞ ﻗﻴﻤ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ ) ‪ ( x‬ﻗﺒ ﻞ اﻷﻣ ﺮ ) ‪ ( While‬وأن‬
‫ﻟﻢ ﻧﻘﻢ ﺑﺬﻟﻚ ﻓﺄن اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻔﺸﻞ ﻟﻌﺪم وﺟﻮد ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ . ( x‬آﺬﻟﻚ ﻟﻤﺎ آﺎﻧﺖ هﻨﺎك أآﺜﺮ ﻣﻦ ﺧﻄﻮﻩ‬
‫ﻣﺸﻤﻮﻟﻪ ﺑﺎﻟﺘﻜﺮار واﻟﺘﻲ هﻲ اﻟﻄﺒﺎﻋﻪ واﻟﻘﺮاءﻩ ﻋﻠﻴﻪ ﺗﻢ ﺗﺤﺪﻳﺪهﻤﺎ ﺑﻴﻦ ) ‪. ( begin and end‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﻗﺮاءة ﻗﻴﻤﻪ ﺟﺪﻳﺪﻩ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( x‬ﻓﺄن اﻟﻘﻴﻤﻪ اﻟﺴﺎﺑﻘﻪ ﺳﺘﺰول وﺗﺤﻞ ﻣﺤﻠﻬﺎ‬
‫اﻟﻘﻴﻤﻪ اﻟﺠﺪﻳﺪﻩ وهﺬﻩ ﻗﺎﻋﺪﻩ ﻋﺎﻣﻪ ﻳﺠﺐ أن ﺗﻼﺣﻆ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻳﺘﻢ أﺧﺘﻴﺎر اﻟﺸﺮط ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( While‬ﺑﺤﻴﺚ ﻳﺴﺎﻋﺪ ﺣﻠﻘﺔ اﻟﺘﻜﺮار أن ﺗﺴﺘﻤﺮ ﻃﺎﻟﻤﺎ آﺎن‬
‫هﺬا اﻟﺸﺮط ﻣﺘﺤﻘﻖ ‪ ,‬وأن ﺗﺘﻮﻗﻒ اﻟﺤﻠﻘﻪ ﻋﻦ اﻟﺘﻜﺮار ﻋﻨﺪﻣﺎ ﻻ ﻳﺘﺤﻘﻖ هﺬا اﻟﺸﺮط ‪.‬‬
‫ﻓﻲ ﺣﺎﻟﺔ اﻷﻣﺮ ) ‪ ( Repeat‬ﻓﺄن اﻟﺸﺮط ﻳﺎﺗﻲ ﺑﻌﺪ ) ‪ ( Until‬ﻟﺬا ﻳﺠﺐ أن ﻳﺘﻢ أﺧﺘﻴﺎرﻩ‬
‫ﺑﺤﻴﺚ ﻋﻨﺪﻣﺎ ﻳﺘﻢ ﻓﺤﺼﻪ ﺗﻜﻮن اﻟﻨﺘﻴﺠﻪ ) ‪ ( False‬أي ﻏﻴﺮ ﻣﺘﺤﻘﻖ ‪ ,‬ﻟﻜﻲ ﻳﺴﺘﻤﺮ اﻟﺘﻜﺮار‬
‫ﺑﺎﻟﻌﻤﻞ وﻣﺘﻰ ﻣﺎ أﺻﺒﺤﺖ ﻧﺘﻴﺠﺔ ﻓﺤﺺ اﻟﺸﺮط ) ‪ ( True‬ﻓﺄن اﻟﺘﻜﺮار ﻳﺘﻮﻗﻒ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻣﻦ اﻟﺴﻬﻞ آﺘﺎﺑﺔ ﺣﻠﻘﻪ ﺑﺸﻜﻞ ﻋﻔﻮي ‪ ,‬ﺷﺮﻃﻬﺎ ﻻ ﻳﺼﺒﺢ ﻣﺘﺤﻘﻘﺎ أﺑﺪا ‪ ,‬هﺬا ﺳﻴﺆدي اﻟﻰ‬
‫ﺑﺮﻧﺎﻣﺞ ﻣﻘﻔﻞ أو ﻣﻐﻠﻖ أي ﻳﺴﺘﻤﺮ ﺑﺎﻟﺘﻨﻔﻴﺬ اﻟﻰ ﻣﺎﻻﻧﻬﺎﻳﻪ ‪.‬‬
‫‪40‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫أﻳﻌﺎز اﻟﺘﻜﺮار ‪FOR LOOP‬‬ ‫‪3.6‬‬

‫أن ه ﺬا اﻷﻣ ﺮ ﻳﻘ ﻮم ﺑﺘﻜ ﺮار أﻳﻌ ﺎز أو ﻣﺠﻤﻮﻋ ﺔ أﻳﻌ ﺎزات ﻟﻌ ﺪد ﻣ ﻦ اﻟﻤ ﺮات اﻟﻤﺤ ﺪدﻩ ﻣ ﺴﺒﻘﺎ ‪.‬‬
‫واﻟﺼﻴﻐﻪ اﻟﻘﻮاﻋﺪﻳﻪ ﻟﻪ أذا آﺎن ﻳﺴﺘﺨﺪم ﻟﺘﻜﺮار أﻳﻌﺎز واﺣﺪ ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮة هﻲ ‪:‬‬

‫‪For {variable}* := {original value} to/downto {final value} do‬‬

‫})‪{code...(for one action‬‬

‫) ‪( loop counter‬‬ ‫* ﺑﺸﻜﻞ ﻋﺎم هﺬا اﻟﻤﺘﻐﻴﺮ ﻳﺴﻤﻰ‬

‫ﻗﻴﻤﺔ هﺬا اﻟﻌﺪاد ﺗﺒﺪأ ﺑﺎﻟﻘﻴﻤﻪ اﻷﺻﻠﻴﻪ أو اﻷﺑﺘﺪاﺋﻴﻪ ) ‪ ( original value‬ﺛﻢ ﺗﺰداد ﺑﻤﻘ ﺪار واﺣ ﺪ‬
‫) أو ﺗﻘﻞ ﺑﻤﻘﺪار واﺣﺪ ( ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻷﻳﻌﺎز اﻟﺬي ﺑﻌﺪﻩ ﻣﺒﺎﺷ ﺮة وﻳ ﺴﺘﻤﺮ آ ﺬﻟﻚ ﻟﺤ ﻴﻦ أن ﺗ ﺼﻞ‬
‫ﻗﻴﻤﺔ اﻟﻌﺪاد اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﻨﻬﺎﺋﻴﻪ ) ‪ ( final value‬واﻟﺘﻲ ﺗﻤﺜﻞ اﻟﺘﻨﻔﻴﺬ اﻷﺧﻴﺮ ‪.‬‬

‫أﻣﺎ ) ‪ ( to / downto‬ﻓﺘﺴﺘﺨﺪم واﺣﺪﻩ ﻣﻨﻬﻤﺎ ﻓﻘﻂ ﻓﺎذا آﺎﻧﺖ اﻟﻘﻴﻤﻪ اﻷﺑﺘﺪاﺋﻴﻪ أﻗﻞ ﻣ ﻦ‬
‫اﻟﻘﻴﻤﻪ اﻟﻨﻬﺎﺋﻴﻪ ﻓﻌﻨﺪ ذﻟ ﻚ ﻧ ﺴﺘﺨﺪم ) ‪ ( to‬وﺗﺘﻐﻴ ﺮ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ﺑﺄﺿ ﺎﻓﻪ واﺣ ﺪ ﻟ ﻪ ﻓ ﻲ آ ﻞ ﺗﻨﻔﻴ ﺬ ‪ ,‬أﻣ ﺎ أذا‬
‫آﺎﻧﺖ اﻟﻘﻴﻤﻪ اﻷﺑﺘﺪاﺋﻴﻪ أآﺒﺮ ﻣﻦ اﻟﻘﻴﻤﻪ اﻟﻨﻬﺎﺋﻴﻪ ﻓﻨﺴﺘﺨﺪم ) ‪ ( downto‬وﺗﺘﻐﻴﺮ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺑﻄﺮح واﺣﺪ‬
‫ﻣﻨﻬﺎ ﻓﻲ آﻞ ﺗﻨﻔﻴﺬ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫آﻤﺎ ﻓﻲ ) ‪ ( If , Else , While‬ﻓ ﺎن اﻷﻣ ﺮ ) ‪ ( For‬ﻻﻳﻨﻔ ﺬ أآﺜ ﺮ ﻣ ﻦ أﻳﻌ ﺎز أو ﻋﺒ ﺎرﻩ‬


‫ﺗﺎﺗﻲ ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮﻩ ‪ ,‬ﻓﺄذا آﺎن هﻨﺎك أآﺜﺮ ﻣﻦ أﻳﻌﺎز ﻳﺠﺐ أن ﻳﻜ ﺮر ﺿ ﻤﻦ اﻷﻣ ﺮ ) ‪( For‬‬
‫ﻓﻴﺠﺐ أن ﻳﺤﺪد ﺑﻴﻦ ) ‪( begin and end‬‬

‫;‪Program CH3_Program4‬‬

‫‪Begin‬‬
‫‪Writeln‬‬ ‫‪('for‬‬ ‫;)'‪loop‬‬ ‫}!!!‪{somewhat boring writing all this‬‬
‫‪Writeln‬‬ ‫‪('for‬‬ ‫;)'‪loop‬‬ ‫هﺬا ﻳﻜﻮن ﳑﻞ ﻟﻜﺘﺎﺑﻪ آﻞ ذﻟﻚ‬
‫‪Writeln‬‬ ‫‪('for‬‬ ‫;)'‪loop‬‬
‫‪Writeln‬‬ ‫‪('for‬‬ ‫;)'‪loop‬‬
‫‪Writeln‬‬ ‫‪('for‬‬ ‫;)'‪loop‬‬
‫‪Writeln‬‬ ‫‪('for‬‬ ‫;)'‪loop‬‬
‫‪Writeln‬‬ ‫‪('for‬‬ ‫;)'‪loop‬‬
‫;‪Readln‬‬
‫‪End.‬‬
‫‪41‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﻪ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﺑﻄﺮﻳﻘﻪ أﺳﻬﻞ وأﺳﺮع وﻳﺆدي ﻧﻔﺲ اﻟﻐﺮض آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫;‪Program CH2_Program5‬‬

‫;‪Var Counter: Integer‬‬ ‫}‪{loop counter declared as integer‬‬

‫‪Begin‬‬
‫‪For Counter: = 1 to 7 do‬‬ ‫}!‪{it's easy and fast‬‬
‫;)'‪writeln ('for loop‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻻﺗﺴﺘﺨﺪم اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ﺑﻌﺪ اﻷﻣﺮ ) ‪ , ( for … do‬اﻷﻣﺮ ) ‪, ( while .. do‬‬


‫) ‪. ( repeat‬‬ ‫واﻷﻣﺮ‬

‫أﺳﺘﺨﺪام ) ‪ ( FOR‬اﻟﻤﺘﺪاﺧﻠﻪ ‪NESTED FOR‬‬ ‫‪3.7‬‬

‫ﻣﻤﻜﻦ أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( For‬ﺑﺸﻜﻞ ﻣﺘﺪاﺧﻞ وﻷآﺜﺮ ﻣﻦ ﻣﺮﻩ وﺑﻬﺬﻩ اﻟﺤﺎﻟﻪ ﻓ ﺎن ﺣﻠﻘ ﺔ ) ‪( For‬‬
‫ﺗﻜﺮر آﺎﻣﻠﺔ ﺑﻌﺪد ﻣﺮات اﻟﺘﻜﺮار اﻟﻤﺤﺪدﻩ ﻓﻲ ) ‪ ( For‬اﻟﺨﺎرﺟﻲ ‪ .‬ﻓﻤﺜﻼ ﻟﻮ آﺎن ﻟ ﺪﻳﻨﺎ ﻋ ﺪد ﻣ ﻦ اﻟﻄ ﻼب‬
‫ﻓﻲ ﺻﻒ ﻣﻌﻴﻦ ) ‪ 30‬ﻃﺎﻟﺐ ﻣﺜﻼ ( وﻧﺮﻏﺐ أن ﻧﻄﺒﻊ أﺳﻤﺎء اﻟﻄﻠﺒﻪ ﻣﻊ اﻟﺪرﺟﺎت اﻟﺘﻲ ﺣﺼﻞ ﻋﻠﻴﻬ ﺎ آ ﻞ‬
‫ﻣﻨﻬﻢ ﻓﻲ آﻞ اﻟ ﺪروس اﻟﺘ ﻲ ﻳﺪرﺳ ﻮهﺎ ﻓ ﻲ ﺗﻠ ﻚ اﻟﻤﺮﺣﻠ ﻪ ) ‪ 8‬دروس ﻣ ﺜﻼ ( ‪ .‬هﻨ ﺎ ﻳﺠ ﺐ ﻃﺒﺎﻋ ﺔ أﺳ ﻤﺎء‬
‫اﻟﻄﻠﺒﻪ وهﻲ ‪ 30‬أي أن أﻣﺮ اﻟﻄﺒﺎﻋﻪ ﺳﻴﻜﺮر ‪ 30‬ﻣﺮﻩ ﻟﺬا ﻧﺴﺘﺨﺪم ) ‪ ( for‬ﻟﻬﺬا اﻟﻐﺮض ﻷن ﻋﺪد ﻣﺮات‬
‫اﻟﺘﻜﺮار ﻣﺤﺪد ‪ ,‬وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ) أي ﻟﻜ ﻞ ﻃﺎﻟ ﺐ ( ﻳﺠ ﺐ أن ﻧﻄﺒ ﻊ اﻟ ﺪرﺟﺎت ) ‪ 8‬درﺟ ﺎت ( أي أن أﻣ ﺮ‬
‫ﻃﺒﺎﻋﺔ اﻟﺪرﺟﺎت ﻳﻜﺮر ‪ 8‬ﻣﺮات ﻋﻠﻴﻪ ﻧﺴﺘﺨﺪم ) ‪ ( For‬أﻳﻀﺎ ﻟﻄﺒﺎﻋ ﺔ اﻟ ﺪرﺟﺎت ﻟﻜ ﻞ ﻃﺎﻟ ﺐ ‪ ,‬وﺳ ﻴﻜﻮن‬
‫اﻟﺒﺮﻧﺎﻣﺞ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫;‪Program CH3_Program6‬‬
‫‪Var‬‬
‫;‪Name: string‬‬
‫;‪Degree, i, j: integer‬‬
‫‪Begin‬‬
‫‪For i: = 1 to 30 do‬‬
‫‪Begin‬‬
‫; )'‪Writeln ('enter student name and his/her degree‬‬
‫;)‪Readln (name‬‬
‫;)‪Writeln (name‬‬
‫‪For j: = 1 to 8 do‬‬
‫‪Begin‬‬
‫;)‪Writeln('Enter degree:',j‬‬
‫; ) ‪Readln (degree‬‬
‫; ) ‪Write (degree:5‬‬
‫} ‪End; {second for‬‬
‫;‪End‬‬ ‫} ‪{first for‬‬
‫‪End.‬‬
‫‪42‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬

‫ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ﻓﺄن ) ‪ ( for‬اﻷوﻟﻰ ﺗﺴﺘﺨﺪم ﻟﻄﺒﺎﻋﺔ أﺳﻤﺎء اﻟﻄﻠﺒﻪ ‪ ,‬وﻟﻤﺎ آﺎن آ ﻞ ﻃﺎﻟ ﺐ ﻟ ﻪ‬
‫‪ 8‬درﺟ ﺎت ﻓ ﺄن أﻣ ﺮ ﺗﻜ ﺮار ﻟﻬ ﺬﻩ اﻟ ﺪرﺟﺎت ﺳ ﻴﻜﻮن ﻣ ﻦ ﺿ ﻤﻦ ) ‪ ( for‬اﻷوﻟ ﻰ ) أي ﻋﻨ ﺪ ﻃﺒﺎﻋ ﺔ أﺳ ﻢ‬
‫ﻃﺎﻟ ﺐ ﻣﻌ ﻴﻦ ﻳﺠ ﺐ أن ﻧﻄﺒ ﻊ ﻣﻌ ﻪ درﺟﺎﺗ ﻪ اﻟﺜﻤ ﺎﻧﻲ ﻗﺒ ﻞ اﻷﻧﺘﻘ ﺎل اﻟ ﻰ اﻟﻄﺎﻟ ﺐ اﻟﺘ ﺎﻟﻲ ( ‪ .‬وﺑﻤ ﺎ أن ﻋ ﺪد‬
‫اﻟﺨﻄ ﻮات اﻟﻤ ﺸﻤﻮﻟﻪ ﺑ ﺎﻟﺘﻜﺮار ﺿ ﻤﻦ ) ‪ ( for‬اﻷوﻟ ﻰ ه ﻲ أآﺜ ﺮ ﻣ ﻦ واﺣ ﺪﻩ ﻟ ﺬا ﺗ ﻢ ﺗﺤﺪﻳ ﺪهﺎ ﺑ ﻴﻦ‬
‫) ‪ ( begin , end‬وﻧﻔ ﺲ اﻟ ﺸﻲء ﺑﺎﻟﻨ ﺴﺒﻪ ﻟﻸﻣ ﺮ ) ‪ ( for‬اﻟﺜﺎﻧﻴ ﻪ ‪ .‬وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﻧﻨﻔ ﺬ ) ‪ ( for‬اﻷوﻟ ﻰ‬
‫ﺳﻨﻨﻔﺬ ) ‪ ( for‬اﻟﺜﺎﻧﻴﻪ آﺎﻣﻠﺔ ﻗﺒﻞ أن ﻧﻨﺘﻘﻞ اﻟﻰ زﻳﺎدة اﻟﻌ ﺪاد ) ‪ ) ( I‬أي أن اﻟﻌ ﺪاد ) ‪ ( j‬ﻳﺒ ﺪأ ﺑﻘﻴﻤ ﺔ اﻟﺒﺪاﻳ ﻪ‬
‫وﻳﺴﺘﻤﺮ ﺑﺎﻟﻌﻤﻞ ﺣﺘﻰ ﻳﻨﺘﻬﻲ ﺑﻘﻴﻤﺔ اﻟﻨﻬﺎﻳﻪ ﻓﻲ آﻞ زﻳﺎدﻩ ﻟﻠﻌﺪاد ) ‪ .( ( I‬هﺬا ﻣﺸﺎﺑﻪ ﻟﻌﻘ ﺎرب اﻟ ﺴﺎﻋﻪ ﻓﻠﻜ ﻲ‬
‫ﻳﺘﺤﺮك ﻋﻘﺮب اﻟﺴﺎﻋﺎت ﺧﻄﻮﻩ واﺣﺪﻩ ﻓﺄن ﻋﻘﺮب اﻟﺪﻗﺎﺋﻖ ﻳﺠﺐ أن ﻳﺘﺤﺮك ‪ 60‬ﺧﻄ ﻮﻩ ‪ ,‬وآﺄﻧﻤ ﺎ ﻋﻘ ﺮب‬
‫) ‪ ( for I : = 1 to 60 do‬وه ﻮ ﺣﻠﻘ ﺔ ﺗﻜ ﺮار ﺧ ﺎرﺟﻲ وﻋﻘ ﺮب‬ ‫اﻟ ﺴﺎﻋﺎت ه ﻮ‬
‫)‪. ( for j : = 1 to 60 do‬‬ ‫اﻟﺪﻗﺎﺋﻖ هﻮ ﺣﻠﻘﺔ اﻟﺘﻜﺮار اﻟﺪاﺧﻠﻲ‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻳﺴﺘﺨﺪم اﻷﻣﺮ ) ‪ ( break‬واﻷﻣﺮ ) ‪ ( continue‬ﻣﻊ ﺣﻠﻘﺎت ) ‪ ( for‬وآﺎﻓﺔ ﺣﻠﻘﺎت اﻟﺘﻜﺮار‬


‫اﻷﺧﺮى ﻣﺜﻞ ) ‪ ( while , repeat‬وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪ .1‬اﻷﻣﺮ ) ‪ ( break‬وﻳﺴﺘﺨﺪم ﻟﻠﺴﻴﻄﺮﻩ ﻋﻠﻰ ﺗﺪﻓﻖ ﺗﻜﺮار اﻟﻌﺒﺎرات وهﻲ ﺗﺆدي اﻟﻰ أﻧﻬﺎء‬
‫أو ﺗﻮﻗﻒ اﻟﺘﻜﺮار ‪ ,‬ﻣﺜﺎل‬
‫‪For i: = 1 to 10 do‬‬
‫‪begin‬‬
‫;) ‪Readln ( x‬‬
‫‪If x < 0 then‬‬
‫‪Break‬‬
‫‪Else‬‬
‫;) ) ‪Writeln ( sqrt ( x‬‬
‫;‪End‬‬
‫ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﻪ ﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ورود ﻋﺪد ﺳﺎﻟﺐ ﻟﻌﺪم أﻣﻜﺎﻧﻴﺔ أﻳﺠﺎد اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ‬
‫ﻟﻠﻌﺪد اﻟﺴﺎﻟﺐ ‪.‬‬
‫‪ .2‬اﻷﻣﺮ ) ‪ ( continue‬وﻳﺴﺘﺨﺪم أﻳﻀﺎ ﻣﻊ ﺣﻠﻘﺎت اﻟﺘﻜﺮاروهﻮ ﻳﻌﻨﻲ أﺳﺘﻤﺮ ﻣﻊ ﺣﻠﻘﺔ‬
‫ﺗﻜﺮار ﺟﺪﻳﺪﻩ) أي أهﻤﻞ ﺗﻨﻔﻴﺬ اﻷواﻣﺮ اﻟﺘﻲ ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( continue‬ﻋﻨﺪ ﺗﺤﻘﻖ ﺷﺮط‬
‫ﻣﻌﻴﻦ ﺣﻴﺚ ﺳﻴﻌﻴﺪ اﻟﻤﺆﺷﺮ اﻟﻰ اﻷﻣﺮ ) ‪ , ( ( for‬ﻣﺜﺎل‬
‫‪For i: = 1 to 10 do‬‬
‫‪Begin‬‬
‫;) ‪Readln ( x‬‬
‫‪If x < 0 then‬‬
‫‪Continue‬‬
‫‪Else‬‬
‫;) ) ‪Writeln ( sqrt ( x‬‬
‫;‪End‬‬
‫ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﻪ ﻋﻨﺪ ورود ﻋﺪد ﺳﺎﻟﺐ ﻓﺄن اﻷﻣﺮ ) ‪ ( continue‬ﺳﻴﻤﻨﻊ ﻣﺘﺎﺑﻌﺔ ﺗﻨﻔﻴﺬ‬
‫اﻟﻌﺒﺎرات اﻷﺧﺮى ﻓﻲ ﺣﻠﻘﺔ اﻟﺘﻜﺮار واﻟﻤﺘﻤﺜﻠﻪ ﺑﺄﻣﺮ اﻟﻄﺒﺎﻋﻪ ﻓﻲ هﺬا اﻟﻤﺜﺎل وﻳﻌﻴﺪ اﻟﻤﺆﺷﺮ‬
‫اﻟﻰ اﻷﻣﺮ ) ‪ ( for‬ﻟﻴﺒﺪأ ﺑﺘﻜﺮار ﺟﺪﻳﺪ ‪.‬‬
‫‪43‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻳﻜﻮن اﻟﺘﺪاﺧﻞ ﺑﻴﻦ ﻋﺒﺎرات اﻟﺘﻜﺮار ﺟﻤﻴﻌﺎ ﺳﻮاء اﻟﻤﺘﺸﺎﺑﻬﺎت أو اﻟﻤﺨﺘﻠﻔﺎت ‪,‬‬
‫) ‪, ( for . and repeat ) , ( for , and while ) , ( for , and for‬‬ ‫ﻣﺜﻼ ﺑﻴﻦ‬
‫) ‪( repeat , and repeat ) , ( while , and while ) , ( while , and repeat‬‬

‫ﻋﺒﺎرة أﺧﺘﻴﺎر اﻟﺤﺎﻟﻪ ‪The Simple Case statements‬‬ ‫‪3.8‬‬

‫ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ﺗﺴﺘﺨﺪم ) ‪ ( If‬اﻟﻤﺘﺪاﺧﻠ ﻪ وﻟﻤ ﺮات ﻋﺪﻳ ﺪﻩ ﺑ ﺸﻜﻞ ﻣﻤﻜ ﻦ أن ﻳﻜ ﻮن ﻣﻄ ﻮﻻ أو‬
‫ﻣﻤﻼ ‪ ,‬وﻟﺘﺴﻬﻴﻞ اﻟﻌﻤﻞ ﻓﺄﻧﻪ ﻳﻤﻜﻦ أن ﻧﺴﺘﻌﻴﺾ ﻋﻨﻬﺎ ﺑﻌﺒﺎرة ) ‪ ( Case‬واﻟﺸﻜﻞ اﻟﻘﻮاﻋﺪي ﻟﻬﺎ هﻮ ‪:‬‬

‫‪Case {variable of type: integer or character ONLY} of‬‬

‫‪{input statement- within inverted commas if of type char} :‬‬

‫}‪{code..‬‬

‫‪{input statement- within inverted commas if of type char} :‬‬

‫}‪{code..‬‬

‫‪...‬‬

‫}‪End; {End Case‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫اﻷﻣﺮ) ‪ ( Case‬ﻳﻨﺘﻬﻲ داﺋﻤﺎ ﺑﺎﻷﻣﺮ ) ‪ ( end‬ﺑﺎﻟﺮﻏﻢ ﻣﻦ ﻋﺪم وﺟﻮد ) ‪( begin‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻳﺄﺗﻲ ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( Case‬ﻣﺘﻐﻴﺮ وهﺬا اﻟﻤﺘﻐﻴﺮ ﻣﻦ ﻧﻮع اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ أو اﻟﺤﺮوف ﻓﻘﻂ‬
‫وﻻ ﻳﻤﻜﻦ أن ﻧﺴﺘﺨﺪم اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ هﻨﺎ ‪.‬‬
‫‪44‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻳﻔﻀﻞ أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( case‬ﻓﻲ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﺤﺘﺎج اﻟﻰ ﺛﻼث ﻋﺒﺎرات ) ‪ ( If‬ﻣﺘﺘﺎﻟﻴﻪ‬
‫أو أآﺜﺮ ‪.‬‬

‫ﻟﻨ ﺮى اﻟﻔ ﺮق ﺑ ﻴﻦ أﺳ ﺘﺨﺪام ) ‪ ( If‬و ) ‪ ( Case‬ﻣ ﻦ ﺧ ﻼل اﻟﺒﺮﻧ ﺎﻣﺞ اﻟﺘ ﺎﻟﻲ واﻟ ﺬي ﻳﺤ ﺎآﻲ‬
‫أﺳﺘﺨﺪام اﻟﺤﺎﺳﺒﻪ اﻟﺠﻴﺒﻴﻪ ذات اﻟﻌﻤﻠﻴﺎت اﻷرﺑﻊ ) ‪: ( Calculator‬‬

‫;‪Program CH3_Program7‬‬
‫‪Var‬‬
‫; ‪ch: char‬‬
‫;‪num1, num2: integer‬‬
‫;‪Result: real‬‬
‫‪Begin‬‬
‫;)' ‪Writeln (' enter two numbers‬‬
‫;)‪Readln (num1, num2‬‬
‫‪Writeln (' enter one of operators‬‬ ‫‪" +, - , * , /‬‬ ‫"‬ ‫;)'‬
‫;)‪Readln (ch‬‬
‫‪If (ch = ' + ') then‬‬
‫‪Result: = num1 + num2‬‬
‫‪Else‬‬
‫‪If (ch = ' – ') then‬‬
‫‪Result: = num1 – num2‬‬
‫‪Else‬‬
‫‪If (ch = ' * ') then‬‬
‫‪Result: = num1 * num2‬‬
‫‪Else‬‬
‫‪Result: = num1 / num2‬‬ ‫;‬
‫;)‪Writeln (result‬‬
‫‪End.‬‬

‫اﻟﺒﺮﻧ ﺎﻣﺞ أﻋ ﻼﻩ ﺑﺮﻧ ﺎﻣﺞ ﺑ ﺴﻴﻂ ﺣﻴ ﺚ ﻳ ﺘﻢ أدﺧ ﺎل ﻋ ﺪدﻳﻦ وأدﺧ ﺎل اﻟﻌﻤﻠﻴ ﻪ اﻟﺮﻳﺎﺿ ﻴﻪ اﻟﻤﻄﻠ ﻮب‬
‫أﺟﺮاؤهﺎ ﻋﻠﻴﻬﺎ ﺛﻢ ﻳﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﻔﺤﺺ اﻟﻌﻤﻠﻴﻪ اﻟﺘﻲ ﺗﻢ أدﺧﺎﻟﻬﺎ ﻟﻴﻨﻔﺬ ﻣﺎ ﻣﻄﻠ ﻮب ﻓﻴﻬ ﺎ ﻋﻠ ﻰ اﻷﻋ ﺪاد ‪,‬‬
‫وأﺧﻴﺮا ﺗﻄﺒﻊ اﻟﻨﺘﻴﺠﻪ‪.‬‬
‫اﻻن ﻧﻌﻴﺪ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ أﻋ ﻼﻩ وﻟﻜ ﻦ ﺑﺄﺳ ﺘﺨﺪام ) ‪ ( Case of‬وﻧﻼﺣ ﻆ اﻟﻔ ﺮق ‪ ,‬ﻣ ﻊ اﻟﻌﻠ ﻢ أن‬
‫اﻟﻨﺘﺎﺋﺞ ﻻ ﺗﺘﻐﻴﺮ‪.‬‬
‫‪45‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‪Program CH3_Program8‬‬
‫‪Var‬‬
‫;‪num1, num2: integer‬‬
‫; ‪ch: char‬‬
‫;‪Result: real‬‬
‫‪Begin‬‬
‫;)' ‪Writeln (' enter two numbers‬‬
‫;)‪Readln (num1, num2‬‬
‫;)' " ‪Writeln (' enter one of operators " +, - , * ,/‬‬
‫;)‪Readln (ch‬‬
‫‪Case ch of‬‬
‫;‪'+ ': result: = num1 + num2‬‬
‫;‪'– ': result: = num1 – num2‬‬
‫;‪'* ': result: = num1 * num2‬‬
‫;‪'/ ': result: = num1 / num2‬‬
‫;‪End‬‬
‫;)‪Writeln (result‬‬
‫‪End.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻻ ﺗ ﺴﺘﺨﺪم ) ‪ ( IF‬ﺑﻌ ﺪ ) ‪ ( Else‬ﻋﻨ ﺪﻣﺎ ﻳﻜ ﻮن هﻨ ﺎك أﺣﺘﻤ ﺎل واﺣ ﺪ ﻣﺘﺒﻘ ﻲ ‪ ,‬وﺗ ﺴﺘﺨﺪم‬


‫ﺑﻌ ﺪ ) ‪ ( Else‬أذا آ ﺎن هﻨ ﺎك أآﺜ ﺮ ﻣ ﻦ أﺣﺘﻤ ﺎل واﺣ ﺪ وﻳﺠ ﺐ اﻷﺧﺘﻴ ﺎر ﻣﻨﻬﻤ ﺎ ‪ ..‬ﻷن‬
‫أﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ وﺟﻮد أﺣﺘﻤﺎل واﺣﺪ ﻳﻌﺘﺒ ﺮ ﻏﻴ ﺮ ﻣﻨﻄﻘ ﻲ ﺑ ﺎﻟﺮﻏﻢ ﻣ ﻦ أن اﻟﺒﺮﻧ ﺎﻣﺞ ﻣﻤﻜ ﻦ‬
‫أن ﻳﻨﺠﺰ ‪.‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬

‫اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ) ‪ ( 8‬أآﺜﺮ ﺑﺴﺎﻃﻪ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ) ‪. ( 7‬‬


‫ﻟ ﻨﻼﺣﻆ آﻴﻔﻴ ﺔ أﺳ ﺘﺨﺪام اﻷﻣ ﺮ ) ‪ ( case‬ﺣﻴ ﺚ ﺑﻌ ﺪ أن ﻳ ﺘﻢ أﻋﻄ ﺎء ﻗﻴﻤ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ ) ‪ , ( ch‬ﻳ ﺘﻢ‬
‫ﻓﺤﺺ هﺬﻩ اﻟﻘﻴﻤﻪ ﺑﻮاﺳﻄﺔ ) ‪ ( case‬وآﺄن اﻟﻌﺒﺎرﻩ ﺗﺘﺮﺟﻢ ) أذا آﺎﻧﺖ ﻗﻴﻤﺔ ‪ ch‬ﻣ ﺎﻳﻠﻲ أﻋﻤ ﻞ اﻟﺨﻄ ﻮات‬
‫اﻟﺘﻲ ﺗﻘﺎﺑﻠﻪ ( ‪ ,‬ﺛﻢ ﻧﻜﺘﺐ اﻟﻘﻴﻢ اﻟﺘﻲ ﻣﻤﻜﻦ أن ﺗﻜ ﻮن ﻋﻠﻴﻬ ﺎ ) ‪ ( ch‬ﺣ ﺴﺐ ﻣﺘﻄﻠﺒ ﺎت اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬آ ﻞ ﻗﻴﻤ ﻪ‬
‫ﻓﻲ ﺳﻄﺮ ﻣﻨﻔﺮد وﺗﻮﺿ ﻊ ﺑﻌ ﺪهﺎ اﻟﻨﻘﻄﺘ ﻴﻦ اﻟﻤﺘﻌﺎﻣ ﺪﺗﻴﻦ ) ‪ ( colon ) ( :‬ﺑﻌ ﺪ ذﻟ ﻚ ﻧﻜﺘ ﺐ اﻻﺟ ﺮاء اﻟ ﺬي‬
‫ﻳﺠﺐ أن ﻳﺤﺼﻞ ﻋﻨﺪ ﺗﺤﻘﻖ أدﺧ ﺎل ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ‪ .‬ﻓﻤ ﺜﻼ أذا آﺎﻧ ﺖ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( ch‬ه ﻲ ) * ( ﻓ ﺄن‬
‫اﻟﻤﺘ ﺮﺟﻢ ﻳﻔﺤ ﺺ أوﻻ ) ‪ ( +‬وﺳ ﻮف ﻳﺠ ﺪهﺎ ﻻ ﺗ ﺴﺎوي ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( ch‬أي أن اﻷﺟﺎﺑ ﻪ ه ﻲ ﺧﻄ ﺄ‬
‫) ‪ ( false‬ﻓﻴﺘﺮآﻬ ﺎ ﻟﻴﻘ ﺎرن اﻟﻘﻴﻤ ﻪ اﻟﻼﺣﻘ ﻪ وه ﻲ ) ‪ ( -‬وأﻳ ﻀﺎ ﺳ ﻴﺠﺪ أن اﻷﺟﺎﺑ ﻪ ) ‪ ( false‬ﻓﻴ ﺴﺘﻤﺮ‬
‫ﺑﻔﺤﺺ اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﺑﻌ ﺪهﺎ وه ﻲ ) * ( هﻨ ﺎ ﺳ ﺘﻜﻮن اﻟﻨﺘﻴﺠ ﻪ ) ‪ , ( true‬ﻟ ﺬا ﺳ ﻴﻨﻔﺬ اﻟﻌﺒ ﺎرﻩ أو اﻟﻌﺒ ﺎرات‬
‫اﻟﺘ ﻲ ﺑﻌ ﺪهﺎ وه ﻲ أﺟ ﺮاء ﻋﻤﻠﻴ ﻪ اﻟ ﻀﺮب ووﺿ ﻊ اﻟﻨﺘﻴﺠ ﻪ ﺑ ﺎﻟﻤﺘﻐﻴﺮ ) ‪ . ( result‬أﻣ ﺎ اﻷﻣ ﺮ ) ‪( end‬‬
‫ﻓﻴﻨﻬﻲ آﺎﻓﺔ ﻋﻤﻠﻴﺎت اﻟﻔﺤﺺ ‪ ,‬ﻟﻴﺄﺗﻲ ﺑﻌﺪهﺎ أﻣﺮ ﻃﺒﺎﻋﺔ اﻟﻨﺘﻴﺠﻪ‪.‬‬
‫‪46‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫داﺋﻤﺎ اﻟﺤﺮوف واﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ﻋﻨﺪ أﺳﺘﺨﺪاﻣﻬﺎ وآﺘﺎﺑﺘﻬﺎ ﻓﻲ اﻟﺒﺮاﻣﺞ ﻋﻠﻰ أﺳﺎس أﻧﻬﺎ‬
‫ﺣﺮوف أو ﺳﻼﺳﻞ ﺣﺮﻓﻴﻪ وﻟﻴﺲ ﻟﻐﺮض أﺧﺮ ﻓﺄﻧﻬﺎ ﺗﺤﺪد ﺑﻴﻦ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫آﻤﺎ ﻓﻲ ) ‪ ( for, if ,while , else‬واﻟﺘﻲ ﺗﻨﻔﺬ ﻋﺒﺎرﻩ واﺣﺪﻩ ﺑﻌﺪهﺎ ﻓﻘ ﻂ ‪ ,‬آ ﺬﻟﻚ ﻓ ﻲ ﺣﺎﻟ ﺔ‬
‫) ‪ ( case‬ﻓﺄﻧﻬﺎ ﺳﺘﻨﻔﺬ ﻋﺒﺎرﻩ واﺣﺪﻩ ﻣﻦ اﻟﻌﺒﺎرات اﻟﺘﻲ ﺗﺄﺗﻲ ﺑﻌ ﺪ ﻋﺒ ﺎرات اﻷدﺧ ﺎل ) واﻟﺘ ﻲ‬
‫ﺗﻤﺜﻞ ﻗﻴﻢ اﻟﻤﺘﻐﻴﺮ ( ‪ ,‬وﻟﺬا أذا آﺎﻧﺖ هﻨ ﺎك أآﺜ ﺮ ﻣ ﻦ ﻋﺒ ﺎرﻩ ﻳﺠ ﺐ أن ﺗﻨﻔ ﺬ ﺑﻌ ﺪ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ‬
‫اﻟﺘﻲ ﺗﺘﻄﺎﺑﻖ ﻣﻊ اﻟﻘﻴﻤﻪ اﻟﻤﺪﺧﻠﻪ ﻓﻴﺠﺐ أن ﺗﺤﺪد ﺑﻴﻦ ) ‪. ( begin , end‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﺑﺎﻷﻣﻜﺎن أﺳﺘﺨﺪام ) ‪ ( else‬ﻣﻊ ) ‪ ( case‬آﺨﻄﻮﻩ أﺧﻴﺮﻩ ﺑﻌ ﺪ أﻧﺘﻬ ﺎء ﻋﻤﻠﻴ ﺎت ﻓﺤ ﺺ اﻟﻘ ﻴﻢ‬


‫اﻷﻓﺘﺮاﺿﻴﻪ ﻟﻠﻤﺘﻐﻴﺮ ‪ ,‬وهﻲ ﺗﻌﻨﻲ ﺗﻨﻔﻴﺬ اﻷﺟﺮاء اﻟﺬي ﻳﺄﺗﻲ ﺑﻌﺪ ) ‪ ( else‬ﻓﻲ ﺣﺎﻟﺔ اﻟﻔﺸﻞ ﻓ ﻲ‬
‫ﻣﻄﺎﺑﻘﺔ اﻟﻘﻴﻤﻪ اﻟﻤﺪﺧﻠﻪ ﻟﻠﻤﺘﻐﻴﺮ ﻣﻊ اﻟﻘﻴﻢ اﻟﻤﻔﺮوﺿﻪ ‪.‬‬

‫; ‪Program CH3_Program9‬‬
‫‪Var‬‬
‫; ‪num1, num2 : integer‬‬
‫;‪Ch: char‬‬
‫;‪Result: real‬‬
‫‪Begin‬‬
‫; )' ‪Writeln (' enter two numbers‬‬
‫;)‪Readln (num1, num2‬‬
‫" ‪Writeln (' enter one of operators " +, - , *, /,‬‬ ‫;)'‬
‫;)‪Readln (ch‬‬
‫‪Case ch of‬‬
‫;‪'+ ': result: = num1 + num2‬‬
‫;‪'– ': result: = num1 – num2‬‬
‫;‪'* ': result: = num1 * num2‬‬
‫;‪'/ ': result: = num1 / num2‬‬
‫‪Else‬‬
‫;)' ‪Writeln (' Error in entering operator‬‬
‫;‪End‬‬
‫;)‪Writeln (result‬‬
‫‪End.‬‬
‫‪47‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺟﻤﻠﺔ ‪IN‬‬ ‫‪3.9‬‬

‫ﺗﺴﺘﺨﺪم ﺟﻤﻠﺔ ) ‪ ( in‬ﻓﻲ اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﻪ أﺳﺘﺨﺪاﻣﺎت ﻣﺨﺘﻠﻔﻪ وهﻲ ‪:‬‬

‫أوﻻ ‪ //:‬ﻟﺘﺤﺪﻳﺪ اﻟﻤﺪى اﻟﺬي ﻳﻌﻤﻞ ﺑﻪ ﻣﺘﻐﻴﺮ ﻣﻌﻴﻦ وﻟﺘﻮﺿﻴﺢ ذﻟﻚ ﻟﻨﺮى اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫‪If ( degree > = 90 ) And ( degree <= 100 ) then‬‬


‫; ) ' ‪Writeln ( ' Excellent‬‬

‫ﻧﻼﺣﻆ أن اﻟﺸﺮط ﻓﻲ اﻟﻤﺜﺎل ﻳﺤ ﺪد اﻟﺪرﺟ ﻪ ﺑ ﻴﻦ ) ‪ 90‬ﻟﻐﺎﻳ ﺔ ‪ ( 100‬ﻟﻴﻌﻄ ﻲ درﺟ ﺔ اﻷﻣﺘﻴ ﺎز‪,‬‬


‫ﻣﻦ اﻟﻤﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﻪ اﻟﺸﺮط أﻋﻼﻩ ﺑﺄﺳﺘﺨﺪام أﻳﻌﺎز ﺗﺤﺪﻳﺪ اﻟﻤﺪى ) ‪ , ( in‬وآﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪If degree in [ 90 .. 100 ] then‬‬


‫; ) ' ‪Writeln ( ' Excellent‬‬

‫ﻟﻜﻲ ﻧﺴﺘﺨﺪم اﻷﻳﻌﺎز أو اﻷﻣﺮ ) ‪ ( in‬ﻟﺘﺤﺪﻳﺪ اﻟﻤﺪى ﻧﺴﺘﺨﺪم ﺑﻌﺪﻩ ﻗﻮﺳ ﻴﻦ ﻣ ﺮﺑﻌﻴﻦ وﺗﺤ ﺪد ﺑﺪاﻳ ﺔ‬
‫وﻧﻬﺎﻳﺔ اﻟﻤﺪى ﻋﻠﻰ أن ﻳﻔﺼﻞ ﺑﻴﻨﻬﻤﺎ ﻧﻘﻄﺘﺎن آﻤ ﺎ ﻣﻮﺿ ﺢ ﻓ ﻲ اﻟﻤﺜ ﺎل أﻋ ﻼﻩ ‪ .‬أن اﻟﺘﺮﺟﻤ ﻪ اﻟﺤﺮﻓﻴ ﻪ ﻟﻬ ﺬﻩ‬
‫اﻟﻌﺒﺎرﻩ هﻲ ) أذا اﻟﺪرﺟﻪ ﻓﻲ اﻟﻤﺪى اﻟﻤﺤﺪد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ اﻟﻤﺮﺑﻌﻴﻦ ﻓﺄآﺘﺐ آﺬا ( ‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ //:‬ﻣﻤﻜﻦ أن ﻧﺴﺘﺨﺪﻣﻬﺎ ﺑﻄﺮﻳﻘﻪ أﺧﺮى ‪ ,‬ﻓﺒ ﺪﻻ ﻣ ﻦ أن ﻧﺤ ﺪد اﻟﻤ ﺪى آﺒﺪاﻳ ﻪ وﻧﻬﺎﻳ ﻪ ﻳﻤﻜ ﻦ‬
‫اﻷﺳﺘﻌﺎﺿﻪ ﻋﻨﻬﺎ ﺑﻘﻴﻢ ﻣﻌﻴﻨﻪ ﺑﺤﻴﺚ أن اﻟﻤﺘﻐﻴﺮ ﻣﻤﻜﻦ أن ﻳﻜﻮن واﺣﺪ ﻣﻦ هﺬﻩ اﻟﻘﻴﻢ ‪ .‬ﻣﺜﺎل‬

‫‪If x in [ 5 , 10, 20, 35, 50 ] then‬‬


‫; ) ' ‪Writeln ( ' OK‬‬

‫هﻨ ﺎ ه ﺬا ﻳﻌﻨ ﻲ أذا آﺎﻧ ﺖ ﻗﻴﻤ ﺔ ) ‪ ( x‬ه ﻲ أﺣ ﺪى اﻟﻘ ﻴﻢ اﻟﻤﺤ ﺪدﻩ ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ اﻟﻤ ﺮﺑﻌﻴﻦ ﻓﺄآﺘ ﺐ‬
‫) ‪ ( OK‬أي أن ﻋﻤﻠﻴﺔ اﻟﺘﻄﺎﺑﻖ ﺳﺘﻜﻮن ﻣﻊ واﺣﺪﻩ ﻣﻦ هﺬﻩ اﻟﻘﻴﻢ ﺑﻴﻨﻤﺎ ﻓﻲ اﻟﺤﺎﻟﻪ اﻷوﻟﻰ ﻓﺄن أي ﻗﻴﻤﻪ ﺑﻴﻦ‬
‫اﻟﻘﻴﻤﺘﻴﻦ اﻟﻤﺤﺪدﺗﻴﻦ ﺗﺤﻘﻖ اﻟﺸﺮط ‪.‬‬

‫ﺛﺎﻟﺜﺎ ‪ //:‬اﻟﺤﺎﻟﻪ اﻟﺜﺎﻟﺜﻪ ﻻﺗﺨﺘﻠﻒ ﻋﻦ اﻟﺤ ﺎﻟﺘﻴﻦ اﻟ ﺴﺎﺑﻘﺘﻴﻦ وﻟﻜ ﻦ ﺑ ﺪل ﻣ ﻦ أﺳ ﺘﺨﺪام اﻷرﻗ ﺎم ﻣﻤﻜ ﻦ‬
‫أﺳﺘﺨﺪام اﻟﺤﺮوف ‪ .‬ﻣﺜﺎل‬

‫‪If ch in [ 'a' .. 'z' ] then‬‬


‫; ) ' ‪Writeln ( ' small character‬‬

‫‪OR‬‬

‫‪If ch in [ 'a' , ' b ' , 'c ' ] then‬‬


‫; ) ' ‪Writeln ( ' OK‬‬
48 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

//: ‫ﻣﻼﺣﻈﻪ‬

‫ ( آﻤﺎ‬in ) ‫ ( ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ اﻟﻤﺪى ﺑﺪون اﻷﻣﺮ‬.. ) ‫ﻣﻤﻜﻦ أن ﻧﺴﺘﺨﺪم اﻟﻨﻘﻄﺘﻴﻦ اﻟﻤﺘﺠﺎورﺗﻴﻦ‬
( case ) ‫ﻧﻌﻤﻞ ﻣﻊ‬
: ‫ﻣﺜﻞ‬
Case x of
90 .. 100 : writeln ( ' Excellent ' ) ;

‫ أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬3.10

. ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﺮﻗﻢ اﻷآﺒﺮ ﺑﻴﻦ رﻗﻤﻴﻦ‬ •

Program CH3_Program10;
Var
X,y:integer;
Begin
Writeln ('Enter two numbers');
Readln(x, y);
If(x>y) then
Writeln ('the largest number =', x)
Else
Writeln ('the largest number =, y);
End.

‫ ( ﺣﻴﺚ أن‬z ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻗﻴﻤﺔ‬ •

Z = 5x2 +3x/y when x >= y


and Z = y2 – 3x when x < y

Program CH3_Program11;
Var
X, y: integer; z: real;
Begin
Writeln ('Enter x and y ');
Readln(x); readln(y);
If(x>=y) then
Z: =5*sqr(x) + 3*x/y
Else
Z: =sqr(y)-3*x;
Writeln (z);
End.
49 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

. ( 35 – 55 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻄﺒﺎﻋﺔ اﻷرﻗﺎم اﻟﻔﺮدﻳﻪ اﻟﻤﺤﺪدﻩ ﺑﺎﻟﺮﻗﻤﻴﻦ‬ •

Program CH3_Program12;
Var
I:integer;
Begin
For i: = 35 to 55 do
begin
If (i mod 2<>0) then
Continue ;
Write (i: 4);
End;
End.

. ( 2 – 100) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﺠﻤﻮع اﻷرﻗﺎم اﻟﺰوﺟﻴﻪ اﻟﻤﺤﺪدﻩ ﺑﻴﻦ اﻟﺮﻗﻤﻴﻦ‬ •

Program CH3_Program13;
Var
I, sum: integer;
Begin
Sum: =0;
For i: =2 to 100 do
If (I mod 2=0) then
Sum: =sum+I;
Writeln (sum);
End.

. ‫ ( ﻋﺪد‬15 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد أآﺒﺮ وأﺻﻐﺮ ﻋﺪد ﻣﻦ ﺑﻴﻦ‬ •

Program CH3_Program14;
Var
X,max,min:integer;
Begin
Writeln ('Enter first number');
Readln(x);
Max: =x; min: =x;
For i: =1 to 14 do
Begin
Readln(x);
If(x>max) then
Max: =x;
Else
If(x<min) then
Min: =x;
End;
Writeln ('max number=', max);
Writeln ('min number=', min);
End.
50 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

. ( 0 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﺠﻤﻮع ﻋﺪد ﻣﻦ اﻷرﻗﺎم أﺧﺮ رﻗﻢ ﻓﻴﻬﺎ ﻳﺴﺎوي‬ •

Program CH3_Program15;
Var
Sum, x: integer;
Begin
Sum: =0;
Repeat
Writeln ('Enter new number');
Readln(x);
Sum: =sum+x;
Until(x=0);
Writeln (sum);
End.

. ( 12 )‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﻌﺪل ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻷرﻗﺎم أﺧﺮ رﻗﻢ ﻓﻴﻬﺎ هﻮ‬ •

Program CH3_Program16;
Var
Sum, x, count: integer;
Begin
Sum: =0; count: =0;
Writeln ('Enter first number in group');
Readln(x);
While(x<>12) do
Begin
Sum: =sum+x;
Inc (count);
Readln(x);
End;
Writeln (sum/count);
End.

‫ﻣ ﻦ اﻟﻌﻨﺎﺻ ﺮ ﻓ ﻲ اﻟﻤﻌﺎدﻟ ﻪ‬ (n) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻷﻳﺠ ﺎد ﻧ ﺎﺗﺞ‬ •


2/1*2/3*4/3*4/5*6/5*6/7………

Program CH3_Program17;
Var
I, n: integer; sum: real;
Begin
Writeln ('Enter number of elements ');
Readln (n);
Sum: =1;
For i: =1 to n do
Begin
If (I mod 2=0) then
Sum: =sum * i/ (i+1);
Else
Sum: =sum * (i+1)/i;
End;
Writeln (sum);
End.
51 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﻌﺪد اﻷﺻﻐﺮ ﺑﻴﻦ ﺛﻼث أﻋﺪاد‬ •


Program CH3_Program18;
Var
X,y,z:integer;
Begin
Writeln ('Enter three numbers');
Readln(x, y, z);
If(x<y) and (x<z) then
Writeln ('min number=', x)
Else
If(y<x) and (y<z) then
Writeln ('min number=',y)
Else
Writeln ('min number=',z);
End.

‫) ﻣ ﺜﻼ اﻟﻌ ﺪد‬. ‫أآﺘﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻋ ﺪد ﺛ ﻢ أوﺟ ﺪ ﻣﺠﻤ ﻮع أرﻗﺎﻣ ﻪ واﻟ ﺮﻗﻢ اﻷآﺒ ﺮ ﺑ ﻴﻦ أرﻗﺎﻣ ﻪ‬ •
( (7) ‫( واﻟﺮﻗﻢ اﻷآﺒﺮ ﻓﻴﻪ هﻮ‬18) ‫ ﻓﺄن ﻣﺠﻤﻮع أرﻗﺎﻣﻪ هﻲ‬5472

Program CH3_Program19;
Var
X,z:integer;
Begin
Writeln ('Enter number');
Readln(x);
Repeat
Z: = x mod 10;
Write (z);
If (z > max) then
Max: =z;
X: =x div 10;
Until(x=0);
Writeln ('max number=', max);
End.

( ‫ ( اﻟﻰ ﺛﻨﺎﺋﻲ‬decimal number ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺤﻮﻳﻞ اﻟﺮﻗﻢ اﻟﻌﺸﺮي‬ •


. binary number )

Program CH3_Program20;
Var
Sum, I, x, b: integer;
Bagin
Sum: =0; i: =1;
Writeln ('Enter decimal number');
Readln(x);
While(x<>0) do
Begin
B: =x mod 2;
Sum: =sum+ i*b;
X: =x div 2;
I: =i*10;
End;
Writeln (sum);
End.
52 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

0 3 6 9 …n : ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻄﺒﺎﻋﺔ ﻣﺎﻳﻠﻲ‬ •


3 6 9…n
6 9…n
9…n
.
n

Program CH3_Program19;
Var
N,x,x1:integer;
Begin
Writeln ('Enter the last number N');
Readln (n);
If (n mod 3 = 0) then
Begin
X: =0;
While(x<=n) do
Begin
X1:=x;
Repeat
Write(x1:6);
Inc(x1,3);
Until(x1>n);
writeln;
x:=x+3;
End; {while}
End { if }
Else
writeln('Error, number N should divede by 3');
End.

* : ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻄﺒﺎﻋﺔ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬ •


*
*
*
*
*
*

Program CH_3 Program20;


Var
I:integer;
Begin
For i: = 3 downto -3 do
Writeln ('*': 10 + abs (i));
End.
‫‪53‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‬

‫اﻟﻤﺼﻔﻮﻓﺎت ‪ARRAYS‬‬

‫اﻟﻤﻘﺪﻣﻪ‬ ‫‪4.1‬‬

‫ﺳﻴﺘﻢ اﻟﺘﺮآﻴﺰ ﻓﻲ هﺬا اﻟﻔﺼﻞ ﻋﻠﻰ اﻟﻤﺼﻔﻮﻓﺎت ﺑﻨﻮﻋﻴﻬﺎ اﻷﺣﺎدي واﻟﺜﻨ ﺎﺋﻲ ﻣ ﻊ أﻣﺜﻠ ﻪ ﺗﻮﺿ ﻴﺤﻴﻪ‬
‫ﻟﻘﺮاءة وﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﺎت واﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﻣﻤﻜﻦ أﺟﺮاؤهﺎ ﻋﻠﻴﻬﺎ‪.‬‬

‫اﻟﻤﺼﻔﻮﻓﺎت ‪ARRAYS‬‬ ‫‪4.2‬‬

‫اﻟﻤ ﺼﻔﻮﻓﻪ ه ﻲ هﻴﻜ ﻞ ﺑﻴﺎﻧ ﺎت ﻳﺨ ﺰن ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﻟﻬ ﺎ ﻧﻔ ﺲ اﻟﻨ ﻮع ‪ .‬ه ﻲ ﻣ ﺸﺎﺑﻬﻪ‬
‫ﻟﻤﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺼﻨﺎدﻳﻖ ﻣﺮﺗﺒﻄﻪ واﺣﺪﻩ ﺑﺎﻷﺧﺮى ﺑﺸﻜﻞ ﻣﺘﺴﻠﺴﻞ وآﻞ واﺣ ﺪ ﻣ ﻦ ه ﺬﻩ اﻟ ﺼﻨﺎدﻳﻖ ﻣﻤﻜ ﻦ‬
‫أن ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﺑﻴﺎﻧ ﺎت ﻣﻌﻴﻨ ﻪ وﺟﻤﻴ ﻊ اﻟﺒﻴﺎﻧ ﺎت ﻓ ﻲ ه ﺬﻩ اﻟ ﺼﻨﺎدﻳﻖ ه ﻲ ﻣ ﻦ ﻧ ﻮع واﺣ ﺪ ‪ .‬وﻳﻘ ﺎل ﻋ ﻦ‬
‫اﻟﻤﺼﻔﻮﻓﻪ أﻧﻬﺎ هﻴﻜﻞ ﺑﻴﺎﻧﻲ ﺛﺎﺑﺖ ) ‪ ( static‬وذﻟﻚ ﻷن اﻟﻤﺒﺮﻣﺞ ﻋﻨﺪﻣﺎ ﻳﻌﻠﻦ ﻋﻦ ﻧﻮع وﺣﺠﻢ اﻟﻤ ﺼﻔﻮﻓﻪ‬
‫ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴ ﺮات ‪ ,‬ﻓ ﺎن ﺣﺠﻤﻬ ﺎ ﺳ ﻴﺒﻘﻰ ﺛﺎﺑ ﺖ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ وﻻ ﻳﻤﻜ ﻦ ﺗﻐﻴﻴ ﺮﻩ ‪ ,‬وهﻨ ﺎك‬
‫اﻟﻤ ﺼﻔﻮﻓﺎت اﻟﺪﻳﻨﺎﻣﻴﻜﻴ ﻪ ) ‪ ( dynamic‬اﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ أن ﻧﻐﻴ ﺮ ﺣﺠﻤﻬ ﺎ أﺛﻨ ﺎء ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ‪.‬‬
‫ﻧﺴﺘﺨﺪم ﻟﻠﻤﺼﻔﻮﻓﻪ ﻣﺘﻐﻴﺮا ﻣﻔﺮدا ﻓﻘﻂ آﺎداة ﻟﺨﺰن اﻟﺒﻴﺎﻧﺎت ‪ ,‬وهﺬا اﻟﻤﺘﻐﻴﺮ ﻳﺨﺰن ﻋﻨﻮان اﻟﻤﻮﻗ ﻊ اﻻول‬
‫ﻓﻲ اﻟﺬاآﺮﻩ اﻟﺬي ﺗﺨﺰن ﻓﻴﻪ اﻟﻤﺼﻔﻮﻓﻪ وﺑﺎﻗﻲ اﻟﻤﻮاﻗﻊ ﺗﺄﺗﻲ ﺑﻌﺪﻩ ﺑﺎﻟﺘﺘﺎﺑﻊ ) ﻣﺘﺴﻠﺴﻠﻪ ( ‪.‬‬

‫اﻟﻤﺼﻔﻮﻓﺎت ‪//:‬‬

‫هﻲ ﻣﺠﻤﻮﻋﻪ ﻣﺮﺗﺒﻪ ﻣﻦ اﻟﺒﻴﺎﻧﺎت واﻟﺘﻲ ﻗﺪ ﺗﺤﺘﻮي ﻋﻠﻰ ﻋﺪد ﺛﺎﺑﺖ ﻣﻦ اﻟﻌﻨﺎﺻﺮ أو ﻏﻴﺮ ﺛﺎﺑﺖ ‪,‬‬
‫وﺗﺴﺘﺨﺪم أﺳﻠﻮب اﻟﻌﻨﻮان اﻟﻤﺤﺴﻮب ﻷﻳﺠﺎد ﻣﻮﻗﻊ اﻟﺨﻠﻴﻪ اﻟﻤﻄﻠﻮﺑﻪ ﻓﻲ اﻟﺬاآﺮﻩ وذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ‬
‫ﻣﻌﺎدﻻت رﻳﺎﺿﻴﻪ‪.‬‬

‫ﺑﺸﻜﻞ ﻋﺎم ﻓﺄن اﻟﻤﺼﻔﻮﻓﻪ ﻧﻮﻋﺎن ) هﻨﺎك ﻣﺼﻔﻮﻓﺎت ﻣﺘﻌﺪدﻩ اﻟﻤ ﺴﺘﻮﻳﺎت ه ﻲ ﺧ ﺎرج ﻧﻄ ﺎق ه ﺬا‬
‫اﻟﻜﺘﺎب ( ‪ ,‬ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ وﻣﺼﻔﻮﻓﻪ ﺛﻨﺎﺋﻴﻪ ‪.‬‬

‫‪ 4.2.1‬اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ‪: ONE DIMENSION ARRAY‬‬

‫ﻧﺒﺪأ هﻨﺎ ﻣﺮﺣﻠ ﻪ ﺟﺪﻳ ﺪﻩ ﻣ ﻦ اﻟﺒﺮﻣﺠ ﻪ ‪ .‬ﻟﻐﺎﻳ ﺔ اﻷن ﻟ ﺴﻨﺎ ﻗ ﺎدرﻳﻦ ﻋﻠ ﻰ ﻣﻌﺎﻟﺠ ﻪ وﺧ ﺰن‬
‫آﻤﻴﺎت آﺒﻴ ﺮﻩ ﻣ ﻦ اﻟﺒﻴﺎﻧ ﺎت ﺑﻄﺮﻳﻘ ﻪ ﻣﻨﺎﺳ ﺒﻪ ‪ .‬ﻓﻤ ﺜﻼ أذا أردﻧ ﺎ اﻟﻌﻤ ﻞ ﻋﻠ ﻰ ﻗﺎﺋﻤ ﻪ ﻃﻮﻳﻠ ﻪ ﻣ ﻦ اﻷﻋ ﺪاد أو‬
‫اﻷﺳﻤﺎء ‪ ,‬ﻓﺄﻧﻨﺎ ﺳﻨﻌﻠﻦ ﻋﻦ ﻣﺘﻐﻴﺮات ﻣﻨﻔﺼﻠﻪ ﻟﻜﻞ ﻋﺪد أو أﺳﻢ ‪ .‬ﻟﺤ ﺴﻦ اﻟﺤ ﻆ ﻓ ﺄن ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل‬
‫وﻟﻐﺎت اﻟﺒﺮﻣﺠﻪ اﻷﺧﺮى ﺗﻮﻓﺮ ﻋﺪد ﻣﻦ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻬﻴﻜﻠﻪ ﻟﺘﺴﻬﻴﻞ ﺣﻞ اﻟﻤﺸﺎآﻞ اﻟﺘﻲ ﺗﺤﺘﺎج اﻟﻰ اﻟﻌﻤﻞ‬
‫ﻣﻊ آﻤﻴﻪ آﺒﻴﺮﻩ ﻣﻦ اﻟﺒﻴﺎﻧ ﺎت ‪ ,‬ﺑﺒ ﺴﺎﻃﻪ ﻓ ﺄن اﻟﻤﺘﻐﻴ ﺮ ﻣ ﻦ ه ﺬا اﻟﻨ ﻮع ﻳ ﺴﺘﺨﺪم ﻣﻌ ﺮف واﺣ ﺪ ﻟﺨ ﺰن آﻤﻴ ﻪ‬
‫آﺒﻴﺮﻩ ﻣﻦ اﻟﺒﻴﺎﻧﺎت ﻓﻲ اﻟﺬاآﺮﻩ ‪.‬‬
‫‪54‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻤﺼﻔﻮﻓﻪ ﻣﺼﻤﻤﻪ ﻟﺤﻤﻞ آﻤﻴﻪ آﺒﻴﺮﻩ ﻣﻦ اﻟﺒﻴﺎﻧﺎت ﻣﻦ ﻧﻔﺲ اﻟﻨﻮع ﺑﻄﺮﻳﻘﻪ ﻣﻨﻈﻤﻪ ‪ .‬أن أﺳﺘﺨﺪام‬
‫اﻟﻤﺼﻔﻮﻓﻪ ﻳﺴﻤﺢ ﺑﺤﺠﺰ ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ ﻣﻮاﻗ ﻊ اﻟ ﺬاآﺮﻩ اﻟﻤﺘﺘﺎﻟﻴ ﻪ واﻟﺘ ﻲ ﻳﻤﻜﻨﻨ ﺎ ﻣﻌﺎﻟﺠﺘﻬ ﺎ آﻜﺘﻠ ﻪ واﺣ ﺪﻩ أو‬
‫ﻣﻜﻮﻧﺎت ﻣﻨﻔﺼﻠﻪ ‪.‬‬
‫أذن اﻟﻤ ﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳ ﻪ ه ﻲ اﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ آﺘﺎﺑ ﺔ ﻋﻨﺎﺻ ﺮهﺎ ﻋﻠ ﻰ ﺷ ﻜﻞ ﺻ ﻒ أو ﻋﻤ ﻮد‬
‫واﺣﺪ وﻳﻜﻮن ﻋﺪد اﻟﻌﻨﺎﺻﺮ وﺑﺎﻟﺘﺎﻟﻲ ﻋ ﺪد اﻟﻤﻮاﻗ ﻊ ﻓ ﻲ اﻟ ﺬاآﺮﻩ ﻟﺨ ﺰن ه ﺬﻩ اﻟﻤ ﺼﻔﻮﻓﻪ ﻓﻴﻬ ﺎ ﻣ ﺴﺎوﻳﺎ اﻟ ﻰ‬
‫ﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ ‪.‬‬

‫اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ ﻳﺎﺧﺬ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;>‪<arrayName> : Array [n..m] Of <Data Type‬‬

‫ﻣﻤﻜﻦ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات ﺗﺄﺧﺬ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪:‬‬

‫‪Var‬‬

‫;‪myArray : Array [1..20] of Integer‬‬

‫ﺣﻴﺚ ﻳﺘﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات وﻳﻜﻮن ‪:‬‬

‫أوﻻ ‪ //:‬ﺑﺄﻋﻄ ﺎء أﺳ ﻢ ﻟﻠﻤ ﺼﻔﻮﻓﻪ هﻨ ﺎ ) ‪ ( myarray‬وه ﻮ ﻣﺘﻐﻴ ﺮ وﻳ ﺘﻢ أﺧﺘﻴ ﺎرﻩ ﻣ ﻦ ﻗﺒ ﻞ‬


‫اﻟﻤﺒﺮﻣﺞ ‪ ,‬ﺛﻢ ﺗﺄﺗﻲ اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﻌﺎﻣﺪﺗﺎن آﻤﺎ ﻓﻲ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ //:‬ﻧﻜﺘﺐ آﻠﻤﺔ ﻣﺼﻔﻮﻓﻪ ) ‪ ( array‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ أن هﺬا اﻟﻤﺘﻐﻴ ﺮ ه ﻮ ﻣ ﻦ ﻧ ﻮع ﻣ ﺼﻔﻮﻓﻪ‬


‫واﻟﻤ ﺼﻔﻮﻓﻪ ﻳﺠ ﺐ أن ﻳﻜ ﻮن ﺣﺠﻤﻬ ﺎ ﻣﺤ ﺪد ﻗﺒ ﻞ اﻟﺒ ﺪأ ﺑﺘﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ﻟ ﺬا ﺳ ﻴﻜﻮن اﻟﺘﻌﺮﻳ ﻒ ) ﻣ ﺼﻔﻮﻓﻪ‬
‫ﺣﺠﻤﻬ ﺎ آ ﺬا وﻋﻨﺎﺻ ﺮهﺎ ﻣ ﻦ اﻟﻨ ﻮع اﻟﻤﺤ ﺪد ( ‪ ,‬ﻋﻤﻠﻴ ﺔ ﺗﺤﺪﻳ ﺪ اﻟﺤﺠ ﻢ ﻳﻜ ﻮن ﺑﺄﺳ ﺘﺨﺪام أﻗ ﻮاس ﻣﺮﺑﻌ ﻪ‬
‫وﺑﺪاﺧﻠﻬﺎ اﻟﺤﺠﻢ وهﻮ ﻳﺘﻜﻮن ﻣﻦ ﺟﺰﺋﻴﻦ ﺗﻔﺼﻞ ﺑﻴﻨﻬﻤﺎ ﻧﻘﻄﺘﺎن ﻓﻘﻂ ) ﻟﻠﺪﻻﻟﻪ ﻋﻠ ﻰ اﻟﻤ ﺪى اﻟ ﺬي ﺗﻌﻤ ﻞ ﺑ ﻪ‬
‫اﻟﻤﺼﻔﻮﻓﻪ ( ‪ ,‬اﻟﺠﺰء اﻷول ﻳﻤﺜﻞ رﻗﻢ اﻟﺒﺪاﻳﻪ واﻟﺜﺎﻧﻲ ﻳﻤﺜﻞ رﻗﻢ اﻟﻨﻬﺎﻳﻪ ‪ ,‬وﻋﻠﻴﻪ اﻟﻔ ﺮق ﺑﻴﻨﻬﻤ ﺎ ﻳﻤﺜ ﻞ ﻋ ﺪد‬
‫اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ ) ﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ ( ‪ .‬أن ﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ ﻳﺤﺪد ﻣﻦ ﻗﺒﻞ اﻟﻤﺒﺮﻣﺞ وﻓﻘﺎ ﻟﻤﺘﻄﻠﺒ ﺎت‬
‫اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫أن أﺳﺘﺨﺪام اﻟﻤ ﺼﻔﻮﻓﻪ ﻣ ﺸﺎﺑﻪ ﻷﺳ ﺘﺨﺪام اﻟﻤﺘﻐﻴ ﺮات اﻷﻋﺘﻴﺎدﻳ ﻪ وﺑ ﺪﻻ ﻣ ﻦ أن ﻧ ﺴﺘﺨﺪم ﻋ ﺸﺮﻳﻦ‬
‫ﻣﺘﻐﻴﺮ آﻤﺎ ﻓﻲ اﻟﻤﺜﺎل أﻋﻼﻩ ﻣ ﻦ ﻧ ﻮع أﻋ ﺪاد ﺻ ﺤﻴﺤﻪ ‪ ,‬ﻳﻤﻜ ﻦ أن ﻧ ﺴﺘﺨﺪم ﻣﺘﻐﻴ ﺮ واﺣ ﺪ آﻤ ﺼﻔﻮﻓﻪ ) أي‬
‫آﻤﺠﻤﻮﻋﺔ ﻣﺘﻐﻴﺮات ﺣ ﺴﺐ ﺣﺠ ﻢ اﻟﻤ ﺼﻔﻮﻓﻪ ) ﺳ ﻴﺘﻢ ﺣﺠ ﺰ ﻣﻮاﻗ ﻊ ﻓ ﻲ اﻟ ﺬاآﺮﻩ وﻓﻘ ﺎ ﻟ ﺬﻟﻚ ( ‪ ,‬ﻟﻬ ﺎ ﻧﻔ ﺲ‬
‫اﻷﺳﻢ ) أي أن ﺟﻤﻴﻊ هﺬﻩ اﻟﻤﻮاﻗﻊ ﻟﻬ ﺎ ذات اﻷﺳ ﻢ ( وﺗﺨﺘﻠ ﻒ ﺑﺎﻟﻔﻬﺮﺳ ﻪ ) ‪ ( index‬أي ﻟﻜ ﻞ واﺣ ﺪ ﻣﻨﻬ ﺎ‬
‫رﻗ ﻢ ﻳ ﺸﺎر ﺑ ﻪ ﻟﻠﻤﻮﻗ ﻊ ) ﻟﻠﺘﻤﻴﻴ ﺰ ﺑ ﻴﻦ ﻣﺘﻐﻴ ﺮ وأﺧ ﺮ( ( ‪ ,‬أن اﻟﻌﻤ ﻞ ﻣ ﻊ اﻟﻤ ﺼﻔﻮﻓﺎت ﻳ ﺴﺎﻋﺪ ﻋﻠ ﻰ ﺗ ﺴﻬﻴﻞ‬
‫اﻟﻌﻤ ﻞ ﻣ ﻊ اﻟﻤﺘﻐﻴ ﺮات واﻟﻤﺤﺎﻓﻈ ﻪ ﻋﻠ ﻰ ﻗ ﻴﻢ اﻟﻌﺪﻳ ﺪ ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮات وﺗﻤﻜ ﻦ اﻟﻤﺒ ﺮﻣﺞ ﻣ ﻦ أﺟ ﺮاء أﻋﻤ ﺎل‬
‫آﺜﻴﺮﻩ ﺑﻴﺴﺮ وﺳﻬﻮﻟﻪ ‪.‬‬

‫آﻴﻔﻴﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ‪:‬‬ ‫•‬

‫ﻟﻨﺄﺧﺬ اﻟﻤﺜﺎل أﻋﻼﻩ واﻟﺬي أﻋﻠﻨﺎ ﻓﻴﻪ ﻋﻦ ﻋﺸﺮﻳﻦ ﻋﻨﺼﺮ ﻓﺄﻧﻨﺎ ﻳﻤﻜﻨﻨ ﺎ اﻟﻮﺻ ﻮل اﻟ ﻰ آ ﻞ ﻋﻨ ﺼﺮ‬
‫ﻓﻴﻬﺎ وآﻤﺎ ﻳﻠﻲ ‪:‬‬

‫أوﻻ ‪ // :‬أﺳﻨﺎد ﻗﻴﻢ ﻟﺒﻌﺾ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ‪:‬‬


‫‪55‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺣﻴﺚ ﻳﻤﻜﻦ أﺳﻨﺎد ﻗﻴﻤﻪ ﻣﻦ ﻧﻮع اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ) ﺣ ﺴﺐ ﺗﻌﺮﻳ ﻒ اﻟﻤ ﺼﻔﻮﻓﻪ ( ﻷي ﻋﻨ ﺼﺮ‬
‫ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ وذﻟﻚ ﻣﻦ ﺧﻼل ﺗﺤﺪﻳﺪ رﻗﻢ أو ﺗﺴﻠﺴﻞ اﻟﻌﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ ﺛﻢ اﻟﻤﺴﺎواة ﻣ ﻊ اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ‬
‫ﻣﻦ اﻟﻤﻔﺘﺮض وﺿﻌﻬﺎ ﻓﻴﻪ ) أو ﻣﻦ ﺧﻼل أﺳﺘﺨﺪام أﻳﻌﺎز اﻟﻘﺮاءﻩ ( وآﻤﺎ ﻳﻠﻲ ‪:‬‬

‫>‪<arrayName> [index] := <relevant data‬‬

‫;‪myArray[5] := 10‬‬
‫;‪myArray[1] := 25‬‬
‫‪OR‬‬
‫; ) ]‪Readln ( myArray[1‬‬
‫هﻨﺎ ﺗﻢ أﺳﻨﺎد اﻟﻘﻴﻤﻪ ) ‪ ( 10‬اﻟﻰ اﻟﻤﺘﻐﻴﺮ أو اﻟﻤﻮﻗ ﻊ اﻟﺨ ﺎﻣﺲ ) ﻻﺣ ﻆ آﻴﻔﻴ ﺔ اﻷﺷ ﺎرﻩ اﻟ ﻰ ﻣﻮﻗ ﻊ‬
‫اﻟﻌﻨﺼﺮ‪ ,‬ﻳﻮﺿﻊ رﻗﻢ اﻟﻤﻮﻗ ﻊ ﺑ ﻴﻦ ﻗﻮﺳ ﻴﻦ ﻣ ﺮﺑﻌﻴﻦ ( ﺑﻴﻨﻤ ﺎ ﺗ ﻢ أﺳ ﻨﺎد اﻟﻘﻴﻤ ﻪ ) ‪ ( 25‬اﻟ ﻰ اﻟﻤﻮﻗ ﻊ اﻷول‬
‫وﺳﺘﺒﻘﻰ هﺬﻩ اﻟﻘﻴﻢ ﻟﻬﺬﻩ اﻟﻤﻮاﻗﻊ أﻻ أذا ﺗﻢ ﺗﻐﻴﻴﺮهﺎ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬ﻓﻌﻨ ﺪﻣﺎ ﻧﺮﻳ ﺪ ﻃﺒﺎﻋ ﺔ ﻣﺤﺘﻮﻳ ﺎت اﻟﻤﻮﻗ ﻊ‬
‫اﻷول ﻓﺴﻨﺠﺪ ﻓﻴﻪ اﻟﻘﻴﻤﻪ ) ‪ .( 25‬أن ﻃﺮﻳﻘﺔ أدﺧﺎل ﺑﻴﺎﻧﺎت اﻟﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ هﻲ ذات اﻟﻄ ﺮق اﻟﺘ ﻰ‬
‫ﺳﺒﻖ وأن ﺑﻴﻨﺎهﺎ ﻷدﺧﺎل ﺑﻴﺎﻧﺎت اﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻷﻋﺘﻴﺎدﻳﻪ ‪ .‬ﻟﻨﻼﺣﻆ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫; ‪Program CH4_Program1‬‬
‫‪Var‬‬
‫‪myVar‬‬ ‫;‪: Integer‬‬
‫;‪myArray : Array[1..5] of Integer‬‬
‫‪Begin‬‬
‫;‪myArray[2] := 25‬‬
‫;]‪myVar := myArray[2‬‬
‫‪End.‬‬

‫هﻨ ﺎ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( myvar‬ه ﻮ ﻣﺘﻐﻴ ﺮ أﻋﺘﻴ ﺎدي ﺑﻴﻨﻤ ﺎ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( myarray‬ه ﻮ ﻣ ﺼﻔﻮﻓﻪ‬
‫ﺣﺠﻤﻬﺎ ﺧﻤﺴﺔ ﻋﻨﺎﺻﺮ‪ ,‬أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺗﻢ أدﺧﺎل اﻟﻘﻴﻤﻪ ) ‪ ( 25‬ﻟﻠﻤﻮﻗﻊ اﻟﺜﺎﻧﻲ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ ‪ ,‬وﻓ ﻲ‬
‫اﻟﺨﻄﻮﻩ اﻟﻼﺣﻘﻪ ﺗﻢ ﻣﺴﺎواة اﻟﻌﻨﺼﺮ اﻟﺜﺎﻧﻲ ﻣﻦ اﻟﻤﺼﻔﻮﻓﻪ ﻣﻊ اﻟﻤﺘﻐﻴﺮ ) ‪ ( myvar‬وهﺬا ﺳﻴﺆدي ‪:‬‬

‫ﺗﻌ ﻮﻳﺾ ﻗﻴﻤ ﺔ ﻣﺤﺘﻮﻳ ﺎت اﻟﻤﻮﻗ ﻊ اﻟﺜ ﺎﻧﻲ ﻓ ﻲ اﻟﻤ ﺼﻔﻮﻓﻪ ﺑ ﺪﻻ ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮ‬ ‫•‬
‫) ]‪ ( myarray[2‬أي ﺳ ﻴﻜﻮن اﻟﻄ ﺮف اﻷﻳﻤ ﻦ ﻣ ﻦ اﻟﻤﻌﺎدﻟ ﻪ ﻳﺤﺘ ﻮي ﻋﻠ ﻰ اﻟﻌ ﺪد اﻟ ﺼﺤﻴﺢ‬
‫) ‪. ( 25‬‬

‫ﺳﺘﺆول هﺬﻩ اﻟﻘﻴﻤﻪ اﻟﻰ اﻟﻄﺮف اﻷﻳﺴﺮ ﻣﻦ اﻟﻤﻌﺎدﻟ ﻪ ) أي أن اﻟﻤﺘﻐﻴ ﺮ ‪ myvar‬ﺗﻜ ﻮن ﻗﻴﻤﺘ ﻪ‬ ‫•‬
‫هﻲ ‪ . ( 25‬وهﻲ ﻧﻔﺲ اﻟﻄﺮﻳﻘﻪ اﻟﺘﻲ ﻧﺘﻌﺎﻣﻞ ﺑﻬﺎ ﻣﻊ اﻟﻤﺘﻐﻴﺮات اﻷﻋﺘﻴﺎدﻳﻪ‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ //:‬أﺳﻨﺎد ﻗﻴﻢ ﻟﻜﺎﻓﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ) ﻗﺮاءة اﻟﻤﺼﻔﻮﻓﻪ (‬

‫ﻓﻲ آﻞ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﺤﺘﻮي ﻋﻠﻰ ﻣﺼﻔﻮﻓﺎت ﻳﺠﺐ اﻟﻘﻴﺎم ﺑﺄدﺧ ﺎل ﻗ ﻴﻢ ﻟﻌﻨﺎﺻ ﺮ اﻟﻤ ﺼﻔﻮﻓﻪ ﻗﺒ ﻞ‬
‫أن ﻧﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ‪ ,‬وأن ﻋﻤﻠﻴﺔ أدﺧﺎل ﻗﻴﻢ ﻟﻌﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ﺗ ﺘﻢ أﻣ ﺎ ﻣ ﻦ داﺧ ﻞ اﻟﺒﺮﻧ ﺎﻣﺞ أو ﻣ ﻦ ﺧﺎرﺟ ﻪ‬
‫آﻤ ﺎ آ ﺎن اﻟﺤ ﺎل ﻣ ﻊ اﻟﻤﺘﻐﻴ ﺮات اﻷﻋﺘﻴﺎدﻳ ﻪ ‪ .‬ﻟ ﻨﻼﺣﻆ اﻟﻤﺜ ﺎل اﻟﺘ ﺎﻟﻲ واﻟ ﺬي ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻣ ﺼﻔﻮﻓﺘﻴﻦ‬
‫ﻣﻨﻔﺼﻠﺘﻴﻦ دون وﺟﻮد أي ﻋﻼﻗﻪ ﺑﻴﻨﻬﻤﺎ ﺣﻴﺚ أن اﻷوﻟ ﻰ ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ واﻟﺜﺎﻧﻴ ﻪ ﻣ ﻦ ﻧ ﻮع‬
‫‪56‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻌﺒﺎرات اﻟﻤﻨﻄﻘﻴﻪ وﺳﻨﻀﻊ اﻟﻘﻴﻤ ﻪ )‪ (0‬ﻟﻜ ﻞ ﻋﻨﺎﺻ ﺮ اﻟﻤ ﺼﻔﻮﻓﻪ اﻻوﻟ ﻰ وﻧ ﻀﻊ اﻟﻘﻴﻤ ﻪ ) ‪ ( false‬ﻟﻜ ﻞ‬
‫ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﺎﻧﻴﻪ آﻤﺎ ﻓﻲ ادﻧﺎﻩ ‪:‬‬

‫; ‪Program CH4_Program2‬‬
‫‪Var‬‬
‫‪i‬‬ ‫;‪: Integer‬‬
‫;‪myIntArray : Array[1..20] of Integer‬‬
‫;‪myBoolArray : Array[1..20] of Boolean‬‬
‫‪Begin‬‬
‫‪For i := 1 to 20 do‬‬
‫‪Begin‬‬
‫;‪myIntArray[i] := 0‬‬
‫;‪myBoolArray[i] := false‬‬
‫;‪End‬‬
‫‪End.‬‬

‫ﺛﺎﻟﺜﺎ ‪ //:‬ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ‬

‫ﻧﺤﺘﺎج ﻓﻲ اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﺒﺮاﻣﺞ اﻟﻰ ﻃﺒﺎﻋﺔ اﻟﻤ ﺼﻔﻮﻓﻪ ‪ ,‬وﻃﺒﻌ ﺎ ﻳﺠ ﺐ أن ﺗﻜ ﻮن اﻟﻤ ﺼﻔﻮﻓﻪ ﻏﻴ ﺮ‬
‫ﺧﺎﻟﻴﻪ ) أي أن ﻋﻨﺎﺻﺮهﺎ أو ﻣﻮاﻗﻌﻬﺎ ﺗﺤﺘﻮي ﻋﻠﻰ ﻗﻴﻢ ( ‪.‬‬
‫أن ﻋﻤﻠﻴ ﺔ آﺘﺎﺑ ﺔ أو ﻃﺒﺎﻋ ﺔ ﻋﻨﺎﺻ ﺮ ﻣ ﺼﻔﻮﻓﻪ ﻣﻌﻴﻨ ﻪ ﻻ ﺗﺨﺘﻠ ﻒ ﻋ ﻦ ﻗ ﺮاءة اﻟﻤ ﺼﻔﻮﻓﻪ ﻋ ﺪا أن‬
‫اﻷﻳﻌ ﺎز اﻟﺨ ﺎص ﺑ ﺎﻟﻘﺮاءﻩ ﻳ ﺴﺘﺒﺪل ﺑﺎﻷﻳﻌ ﺎز اﻟﺨ ﺎص ﺑﺎﻟﻄﺒﺎﻋ ﻪ أو اﻟﻜﺘﺎﺑ ﻪ‬
‫) أي أن ) ‪ ( ( : = OR readln‬ﻳﺘﻢ أﺳﺘﺒﺪاﻟﻬﺎ ﺑﺎﻷﻳﻌﺎز أو اﻷﻣﺮ ) ‪. ( write OR writeln‬‬

‫;‪Program CH4_Program3‬‬
‫‪Var‬‬
‫‪i‬‬ ‫;‪: Integer‬‬
‫;‪myIntArray: Array[1..20] of Integer‬‬
‫;‪myBoolArray: Array[1..20] of Boolean‬‬
‫‪Begin‬‬
‫‪For i: = 1 to 20 do‬‬
‫‪Begin‬‬
‫;)]‪Writeln (myIntArray [i‬‬
‫;‪End‬‬
‫‪End.‬‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬

‫اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ هﻲ ذات اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ‬
‫اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ ذﻟﻚ اﻟﻨﻮع ) ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻟﻌﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ اﻟﻤﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﺣﻘﻞ‬
‫اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ( ‪.‬‬
‫‪57‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻤﺼﻔﻮﻓﻪ اﻟﻤﻀﻐﻮﻃﻪ ‪Packed Array‬‬ ‫•‬

‫اﻟﻤﺼﻔﻮﻓﻪ ﻣﻔﻴﺪﻩ ﺟﺪا ﻟﺤﻤﻞ آﻤﻴﻪ آﺒﻴ ﺆﻩ ﻣ ﻦ اﻟﺒﻴﺎﻧ ﺎت ‪ ,‬واﺣ ﺪﻩ ﻣ ﻦ ﺳ ﻠﺒﻴﺎت أﺳ ﺘﺨﺪام اﻟﻤ ﺼﻔﻮﻓﻪ‬
‫ه ﻲ أﺣﺘﻴﺎﺟﻬ ﺎ اﻟ ﻰ آﻤﻴ ﻪ آﺒﻴ ﺮﻩ ﻣ ﻦ اﻟ ﺬاآﺮﻩ ‪ ,‬ﻋﻤﻠﻴ ﺎ اﻟﻤ ﺼﻔﻮﻓﻪ ﻣ ﻦ ﻧ ﻮع اﻷﺣ ﺮف ) اﻟﺘ ﻲ ﻋﻨﺎﺻ ﺮهﺎ‬
‫ﺣﺮوف ( ﺗﺤﺠﺰ ذاآﺮﻩ أآﺒﺮ ﻣﻦ اﻷﻧﻮاع اﻷﺧﺮى ‪ ..‬ﻟﺸﺮح ذﻟﻚ ﻟﻨﺮى اﻟﺘﻌﺮﻳﻒ اﻟﺘﺎﻟﻲ ‪:‬‬

‫‪Var‬‬
‫; ‪X : array [ 1..5 ] of char‬‬

‫ﺑﺎﻟﺘﺄآﻴﺪ ﻓﺄن هﺬا اﻟﺘﻌﺮﻳﻒ ﺳﻴﺤﺠﺰ ﻋﺪد ﻣﻦ اﻟﻤﻮاﻗﻊ ﻓﻲ اﻟﺬاآﺮﻩ ﺑﻤﺎ ﻳﺘﻨﺎﺳﺐ وﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ ‪,‬‬
‫هﻨﺎ ﺳﻴﺘﻢ ﺣﺠﺰ ﺧﻤﺴﺔ ﻣﻮاﻗﻊ ) ﻣﻮﻗﻊ ﻟﻜﻞ ﻋﻨﺼﺮ ( وﻟﻤﺎ آﺎن ﻧﻮع اﻟﻌﻨﺎﺻﺮ ﻣﻦ اﻟﻨﻮع اﻟﺤﺮﻓﻲ ﻓﺴﻴﻌﺎﻣﻞ‬
‫آﻞ ﺣﺮف آﻜﻠﻤﻪ ) ‪ ( word‬ﻓﻲ اﻟﺬاآﺮﻩ ‪ ,‬وآﻞ آﻠﻤﻪ ﺗﺘﻜﻮن ﻣﻦ ﻋﺪد ﻣﻦ اﻟﺒﺎﻳﺘﺎت ‪ .‬ﻟﻮ ﻓﺮﺿﻨﺎ أن اﻟﻜﻠﻤﻪ‬
‫ﺗﺘﻜﻮن ﻣﻦ أرﺑﻊ ﺑﺎﻳﺘﺎت ﻓﺄن اﻟﻤﺼﻔﻮﻓﻪ ﺳﺘﺤﺠﺰ ) ‪ ( 20‬ﺑﺎﻳﺖ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻓﺄذا أﺳﻨﺪﻧﺎ آﻠﻤﺔ ) ‪ ( HELLO‬آﻌﻨﺎﺻﺮ ﻟﻠﻤﺼﻔﻮﻓﻪ ﻓﺴﺘﻜﻮن اﻟﻤﺼﻔﻮﻓﻪ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪:‬‬

‫‪H‬‬
‫‪E‬‬
‫‪L‬‬
‫‪L‬‬
‫‪O‬‬

‫ﻧﻼﺣﻆ أن هﻨﺎك ﺧﻤﺴﺔ ﻋﺸﺮ ﺑﺎﻳﺖ ﻏﻴﺮ ﻣﺴﺘﻐﻠﻪ ‪ ,‬وهﺬا ﺳﻮء أﺳﺘﺨﺪام ﻟﻠﺬاآﺮﻩ ‪ ,‬ﻟﺬا ﻓﺄن ﻟﻐﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل أوﺟﺪت اﻷﻳﻌﺎز ) ‪ ( Packed Array‬ﻟﺘﺤﺪد اﻟﻤﺴﺎﺣﻪ اﻟﺨﺰﻧﻴﻪ ﺑﺄﻗﻞ ﺣﺠﻢ ﻣﻤﻜﻦ وآﻤﺎ‬
‫ﻳﻠﻲ ‪:‬‬

‫‪Var‬‬
‫; ‪X : packed array [ 1..5 ] of char‬‬

‫هﺬا اﻟﺘﻌﺮﻳﻒ ﺳﻴﻮﻟﺪ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺘﺎﻟﻴﻪ ﺑﻌﺪ أﺳﻨﺎد اﻟﻜﻠﻤﻪ ) ‪ ( HELLO‬اﻟﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ‪:‬‬

‫‪H‬‬ ‫‪E‬‬ ‫‪L‬‬ ‫‪L‬‬ ‫‪O‬‬

‫هﻨﺎ ﺗﻢ أﺳﺘﺨﺪام آﻠﻤﺘﻴﻦ ﻓﻘﻂ ) أي ‪ 8‬ﺑﺎﻳﺖ ( ‪.‬‬


‫‪58‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪ 4.2.2‬اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ‪: 2-D ARRAY‬‬

‫اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ هﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺘ ﻲ ﺗﻜﺘ ﺐ ﻋﻨﺎﺻ ﺮهﺎ ﻋﻠ ﻰ ﺷ ﻜﻞ ﺻ ﻔﻮف وأﻋﻤ ﺪﻩ ﻓ ﻲ ذات‬
‫اﻟﻮﻗﺖ ) أي ﻳﻜﻮن هﻨﺎك ﻋﺪد ﻣﻦ اﻟﺼﻔﻮف وآﻞ ﺻﻒ ﻓﻴﻪ ﻋﺪد ﻣﻦ اﻟﻌﻨﺎﺻ ﺮ وآ ﺬﻟﻚ ﻋ ﺪد ﻣ ﻦ اﻷﻋﻤ ﺪﻩ‬
‫وآﻞ ﻋﻤﻮد ﻓﻴﻪ ﻋﺪد ﻣﻦ اﻟﻌﻨﺎﺻﺮ ( ‪ ,‬أن ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ وﺑﺎﻟﺘﺎﻟﻲ ﻋ ﺪد اﻟﻤﻮاﻗ ﻊ ﻓ ﻲ‬
‫اﻟﺬاآﺮﻩ ﻳﺴﺎوي ﺣﺎﺻﻞ ﺿﺮب ﻋﺪد اﻟﺼﻔﻮف ﻓﻲ ﻋ ﺪد اﻷﻋﻤ ﺪﻩ ‪ .‬ﻳ ﺘﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤ ﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴ ﻪ‬
‫ﺑﻨﻔﺲ اﻟﻄﺮﻳﻘﻪ اﻟﺘﻲ ﻳﺘﻢ ﻓﻴﻬﺎ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ﻣﻊ ﻓﺎرق واﺣﺪ ﻓﻘﻂ وهﻮ أن اﻷﻋ ﻼن ﻋ ﻦ‬
‫ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﻳﺘﻢ ﻣﻦ ﺧﻼل ﻗﻴﻤﺘﻴﻦ داﺧﻞ اﻟﻘﻮﺳﻴﻦ اﻟﻤﺮﺑﻌﻴﻦ ﺗﻔ ﺼﻞ ﺑﻴﻨﻬﻤ ﺎ ﻓ ﺎرزﻩ‬
‫آ ﻞ واﺣ ﺪﻩ ﻟﻬ ﺎ اﻟﻤ ﺪى اﻟﺨ ﺎص ﺑﻬ ﺎ وﻟ ﻴﺲ ﻗﻴﻤ ﻪ واﺣ ﺪﻩ آﻤ ﺎ ﻓ ﻲ اﻟﻤ ﺼﻔﻮﻓﺎت اﻷﺣﺎدﻳ ﻪ وﻳﺤﺘ ﻮي اﻟﻤ ﺪى‬
‫اﻷول ﻋﻠﻰ ﻋﺪد اﻟﺼﻔﻮف ﺗﺒﺪأ ﻣﻦ اﻟﺮﻗﻢ واﺣﺪ وﺗﻨﺘﻬﻲ ﺑﺎﻟﺮﻗﻢ اﻟﺬي ﻳﻤﺜﻞ اﻟﻌﺪد اﻟﻜﻠ ﻲ ﻟﻠ ﺼﻔﻮف ) وه ﻲ‬
‫ﺗﻤﺜﻞ ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻌﻤﻮد اﻟﻮاﺣﺪ ( ‪ ,‬أﻣﺎ اﻟﻤﺪى اﻟﺜﺎﻧﻲ ﻓﻴﺤﺘﻮي ﻋﻠﻰ ﻋ ﺪد اﻷﻋﻤ ﺪﻩ وﺑ ﻨﻔﺲ اﻟﻄﺮﻳﻘ ﻪ‬
‫اﻟﻤﺴﺘﺨﺪﻣﻪ ﻟﻌﺪد اﻟﺼﻔﻮف ) وهﻲ ﺗﻤﺜ ﻞ ﻋ ﺪد اﻟﻌﻨﺎﺻ ﺮ ﻓ ﻲ اﻟ ﺼﻒ اﻟﻮاﺣ ﺪ (‪ .‬أﻣ ﺎ اﻷﺷ ﺎرﻩ اﻟ ﻰ ﻋﻨ ﺼﺮ‬
‫ﻣﻌ ﻴﻦ ﻓ ﻲ اﻟﻤ ﺼﻔﻮﻓﻪ ﻓﻴ ﺘﻢ ﻣ ﻦ ﺧ ﻼل أﺳ ﻢ اﻟﻤ ﺼﻔﻮﻓﻪ وﻗ ﻮس ﻣﺮﺑ ﻊ ﻳﺤﺘ ﻮي ﻗﻴﻤﺘ ﻴﻦ اﻷوﻟ ﻰ ﺗﻤﺜ ﻞ رﻗ ﻢ‬
‫اﻟﺼﻒ واﻟﺜﺎﻧﻴﻪ ﺗﻤﺜﻞ رﻗﻢ اﻟﻌﻤﻮد ) وﻻ ﻳﺠﻮز أن ﺗﻜﻮن اﻟﻘﻴﻤﻪ اﻷوﻟﻰ ﻟﻸﻋﻤﺪﻩ واﻟﺜﺎﻧﻴﻪ ﻟﻠﺼﻔﻮف (‪.‬‬

‫ﻃﺮﻳﻘﺔ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺜﻨﺎﺋﻴﻪ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫;>‪my2DArray : Array [ 1..i , 1..j ] of <DataType‬‬

‫هﻲ ذات اﻟﻄﺮﻳﻘﻪ اﻟﻤﺴﺘﺨﺪﻣﻪ ﻓﻲ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺎت اﻷﺣﺎدﻳﻪ ﻋ ﺪا اﻟﻔ ﺮق اﻟ ﺬي ﺳ ﺒﻖ أن‬


‫أﺷﺮﻧﺎ اﻟﻴﻪ ‪.‬‬
‫ﺗﻤﺜﻴﻞ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ) ‪ ( 5 x 5‬ﻣﻨﻄﻘﻴﺎ ﻳﻜﻮن ﻋﻠﻰ ﺷﻜﻞ ﺷﺒﻜﻪ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬


‫‪2‬‬
‫‪3‬‬ ‫‪3,4‬‬
‫‪4‬‬
‫‪5‬‬ ‫‪5,3‬‬ ‫‪5,5‬‬

‫ﺣﻴ ﺚ أن أرﻗ ﺎم اﻟﻤﺮﺑﻌ ﺎت ﻓ ﻲ اﻟ ﺼﻒ اﻷﻓﻘ ﻲ ذات اﻟﻠ ﻮن اﻷﺣﻤ ﺮ ﺗﻤﺜ ﻞ أرﻗ ﺎم اﻷﻋﻤ ﺪﻩ ‪ ,‬ﺑﻴﻨﻤ ﺎ‬
‫أرﻗﺎم اﻟﻤﺮﺑﻌﺎت ﻓﻲ اﻟﺼﻒ اﻟﻌﻤﻮدي ذات اﻟﻠﻮن اﻷﺣﻤﺮ ﺗﻤﺜ ﻞ أرﻗ ﺎم اﻟ ﺼﻔﻮف ‪ .‬أﻣ ﺎ اﻷرﻗ ﺎم اﻟﻤﻮﺟ ﻮدﻩ‬
‫ﻓﻲ اﻟﻤﺮﺑﻌﺎت ذات اﻟﻠﻮن اﻷزرق ﻓﻬﻲ ﺗﻤﺜﻞ رﻗ ﻢ اﻟ ﺼﻒ واﻟﻌﻤ ﻮد ﻟ ﺬﻟﻚ اﻟﻤﻮﻗ ﻊ ) اﻟ ﺮﻗﻢ اﻷول ه ﻮ رﻗ ﻢ‬
‫اﻟ ﺼﻒ واﻟﺜ ﺎﻧﻲ ه ﻮ رﻗ ﻢ اﻟﻌﻤ ﻮد ( ‪ ) ,‬ﻓﻤ ﺜﻼ اﻟ ﺮﻗﻢ ) ‪ ( 3 , 4‬ﻳﻤﺜ ﻞ اﻟﻤﻮﻗ ﻊ أو اﻟﻌﻨ ﺼﺮ اﻟﻤﻮﺟ ﻮد ﻓ ﻲ‬
‫اﻟﺼﻒ اﻟﺜﺎﻟﺚ واﻟﻌﻤﻮد اﻟﺮاﺑﻊ ﻣﻦ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ( ‪.‬‬
‫‪59‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫آﻴﻔﻴﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ‪:‬‬ ‫•‬

‫أن اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺜﻨﺎﺋﻴﻪ ﻣﺸﺎﺑﻪ ﻟﻄﺮﻳﻘﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤ ﺼﻔﻮﻓﺎت اﻷﺣﺎدﻳ ﻪ ﻣ ﻊ اﻷﺧ ﺬ‬
‫ﺑﻨﻈﺮ اﻷﻋﺘﺒﺎر ﺧﺼﻮﺻﻴﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ‪.‬‬

‫أوﻻ ‪ //:‬أﺳﻨﺎد ﻗﻴﻢ ﻟﺒﻌﺾ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ‬

‫وﻳﺘﻢ ذﻟﻚ أﻣﺎ ﺑﺄﺳﺘﺨﺪام اﻟﻤﺴﺎواة أو أﺳﺘﺨﺪام أﻳﻌﺎز اﻟﻘﺮاءﻩ ‪ ,‬ﻣﺜﺎل‬

‫;‪My2DArray [3, 4] := 44‬‬


‫;‪My2DArray [5, 3] := 20‬‬

‫‪OR‬‬
‫;)]‪Readln (My2DArray [1, 2‬‬

‫ﺣﻴﺚ ﺳﻴﺘﻢ وﺿﻊ اﻟﻘﻴﻤﻪ )‪ (44‬ﻓﻲ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺘﻘﺎﻃﻊ ﻓﻴ ﻪ اﻟ ﺼﻒ اﻟﺜﺎﻟ ﺚ ﻣ ﻊ اﻟﻌﻤ ﻮد اﻟﺮاﺑ ﻊ ‪,‬‬
‫وﺗﻮﺿﻊ اﻟﻘﻴﻤﻪ )‪ (20‬ﻓﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺘﻘ ﺎﻃﻊ ﻓﻴ ﻪ اﻟ ﺼﻒ اﻟﺨ ﺎﻣﺲ ﻣ ﻊ اﻟﻌﻤ ﻮد اﻟﺜﺎﻟ ﺚ ) ﻻﺣ ﻆ اﻟ ﺸﻜﻞ‬
‫أﻋﻼﻩ ( ‪ .‬أﻣﺎ آﻴﻔﻴﺔ اﻷﻋﻼن ﻋﻨﻬﺎ ﺑﺮﻣﺠﻴﺎ ﻳﻜﻮن ‪:‬‬

‫;‪Program CH4_Program4‬‬
‫‪Var‬‬
‫;‪my2DArray: Array [1..3 , 1..5] of Byte‬‬
‫‪Begin‬‬
‫;‪my2DArray [2, 4]:= 10‬‬
‫;]‪myVar := my2DArray [3,4‬‬
‫‪End.‬‬

‫اﻟﻤﺼﻔﻮﻓﻪ أﻋﻼﻩ ﻓﻲ اﻟﻤﺜﺎل ‪ 4‬ﻣ ﻦ ﻧ ﻮع ) ‪ ( byte‬أي أن آ ﻞ ﻋﻨ ﺼﺮ ﺳ ﻴﻤﺜﻞ ﺑﺒﺎﻳ ﺖ واﺣ ﺪ ﻓ ﻲ‬


‫اﻟﺬاآﺮﻩ ‪ .‬وﺳﻨﻤﺜﻠﻬﺎ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬

‫‪2‬‬ ‫‪10‬‬
‫‪3‬‬

‫ﺛﺎﻧﻴﺎ ‪ //:‬أدﺧﺎل ﻗﻴﻢ ﻟﻜﺎﻓﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ) ﻗﺮاءة اﻟﻤﺼﻔﻮﻓﻪ (‬

‫أن أدﺧﺎل ﻗﻴﻢ ﻟﻌﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﻳﺤﺘﺎج ﺑﺮﻣﺠﻴ ﺎ اﻟ ﻰ أﺳ ﺘﺨﺪام أواﻣ ﺮ اﻟﺘﻜ ﺮار ) ‪( For‬‬
‫ﻣﺮﺗﻴﻦ وﺑﺸﻜﻞ ﻣﺘﺪاﺧﻞ ‪ ,‬ﺣﻠﻘﺔ اﻟﺘﻜﺮار اﻷوﻟﻰ ﻟﻠﺼﻔﻮف واﻟﺜﺎﻧﻴﻪ ﻟﻸﻋﻤﺪﻩ ‪ .‬آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪60‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‪Program CH4_Program5‬‬
‫‪Var‬‬
‫;‪my2DArray: Array [1..3 , 1..5] of integer‬‬
‫;‪I, j: integer‬‬
‫‪Begin‬‬
‫‪For I: = 1 to 3 do‬‬
‫‪For j: = 1 to 5 do‬‬
‫;)]‪Readln (my2DArray [i, j‬‬
‫‪End.‬‬

‫ﻓﻲ هﺬا اﻟﺒﺮﻧﺎﻣﺞ أﺳﺘﺨﺪﻣﻨﺎ أﻣﺮ اﻷدﺧﺎل ) ‪ ( readln‬ﻷﻧﺠﺎز ﻋﻤﻠﻴﺔ اﻷدﺧﺎل ﺑ ﺪﻻ ﻣ ﻦ اﻟﻤ ﺴﺎواة‬
‫واﻟﺘﻲ أﺳﺘﺨﺪﻣﺖ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ) ‪ ( 2‬ﻟﻨﺘﻌﻠﻢ اﻟﻄﺮﻳﻘﺘﻴﻦ ‪.‬‬

‫ﺛﺎﻟﺜﺎ ‪ //:‬ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ‬

‫ﺗﺘﻢ ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﺑﻨﻔﺲ ﻃﺮﻳﻘﺔ ﻗﺮاءة اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴ ﻪ ﻣ ﻊ ﻣﻼﺣﻈ ﺔ أﺳ ﺘﺒﺪال أﻣ ﺮ‬
‫اﻟﻘﺮاءﻩ ﺑﺄﻣﺮ اﻟﻄﺒﺎﻋﻪ ‪ ,‬ﻻﺣﻆ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;‪Program CH4_Program6‬‬
‫‪Var‬‬
‫;‪my2DArray: Array [1..3 , 1..5] of integer‬‬
‫;‪I, j: integer‬‬
‫‪Begin‬‬
‫‪For I: = 1 to 3 do‬‬
‫‪For j: = 1 to 5 do‬‬
‫; ) ]‪writeln (my2DArray [i,j‬‬
‫‪End.‬‬

‫ﺳﺘﻜﻮن ﻣﺨﺮﺟﺎت هﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ه ﻲ ﻃﺒﺎﻋ ﺔ آ ﻞ ﻗﻴﻤ ﻪ ﻋﻠ ﻰ ﺳ ﻄﺮ ﻣﻨﻔ ﺼﻞ ) أﻣ ﺎ أذا أﺳ ﺘﺨﺪﻣﻨﺎ‬
‫اﻷﻣﺮ ‪ write‬ﻓﺄﻧﻪ ﺳﻴﻄﺒﻊ آﻞ اﻟﻘﻴﻢ ﻋﻠﻰ ذات اﻟﺴﻄﺮ( ‪ ,‬أذن آﻴﻒ ﻳﻤﻜﻨﻨﺎ ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﻋﻠ ﻰ‬
‫ﺷﻜﻞ ﺷﺒﻜﻪ ‪ ,‬ﻻﺣﻆ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;‪Program CH4_Program7‬‬
‫‪Var‬‬
‫;‪my2DArray: Array [1..3 , 1..5] of integer‬‬
‫;‪I, j: integer‬‬
‫‪Begin‬‬
‫‪For I: = 1 to 3 do‬‬
‫‪Begin‬‬
‫‪For j: = 1 to 5 do‬‬
‫;)' '‪Write (my2DArray [i, j],‬‬
‫;‪Writeln‬‬
‫;‪End‬‬
‫‪End.‬‬
‫‪61‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬

‫ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻻﻳﺨﺘﻠ ﻒ آﺜﻴ ﺮا ﻋ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ ) ‪ ( 6‬ﻋ ﺪا أﺿ ﺎﻓﺔ أﻣ ﺮ ﻃﺒﺎﻋ ﻪ ﺧ ﺎﻟﻰ ‪ .‬ﻋﻨ ﺪ اﻟﺒ ﺪأ‬
‫ﺑﺎﻟﺘﻨﻔﻴﺬ ﻓﺎن اﻟﺘﻜﺮار اﻷول اﻟﻤﺘﻤﺜﻞ ﺑﺎﻷﻣﺮ ) ‪ ( for‬ﺳﻴﻨﻔﺬ وﺗﻜﻮن ﻗﻴﻤﺔ ) ‪ ( I‬ﺗﺴﺎوي واﺣﺪ وﺑﻤ ﺎ أن ﺣﻠﻘ ﺔ‬
‫اﻟﺘﻜ ﺮار ﺗﺒ ﺪأ وﺗﻨﺘﻬ ﻲ ﺑ ﺎﻷواﻣﺮ ) ‪ ( begin , end‬ه ﺬا ﻳﻌﻨ ﻲ أن آ ﻞ اﻟﻜﺘﻠ ﻪ اﻟﻤﺤ ﺼﻮرﻩ ﺑ ﻴﻦ‬
‫) ‪ ( begin , end‬ﺳﺘﻨﻔﺬ آﺎﻣﻠﻪ ﻣﻊ آﻞ ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ . ( I‬أن أول أﻳﻌﺎز ﻳﺄﺗﻲ هﻮ ﺣﻠﻘﺔ اﻟﺘﻜﺮار اﻟﺜﺎﻧﻴ ﻪ‬
‫وﻟﻤﺎ ﻟﻢ ﻳﻜ ﻦ ﺑﻌ ﺪهﺎ اﻷﻣ ﺮ ) ‪ ( begin‬ﻓﺄﻧﻬ ﺎ ﺳ ﺘﻨﻔﺬ ﺧﻄ ﻮﻩ واﺣ ﺪﻩ ﺑﻌ ﺪهﺎ ﻓﻘ ﻂ وه ﻲ أﻣ ﺮ اﻟﻄﺒﺎﻋ ﻪ ‪ ,‬ه ﺬا‬
‫اﻷﻣﺮ ﺳﻴﻄﺒﻊ ﻣﺤﺘﻮﻳﺎت اﻟﻤﺼﻔﻮﻓﻪ اﻟﻤﺤﺪدﻩ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ وﺣﺴﺐ اﻟﻤﻮﻗﻊ اﻟﻤﺒﻴﻦ أزاﺋﻬﺎ ﺣﻴﺚ أن اﻟﻤﺘﺮﺟﻢ‬
‫ﺳ ﻴﻘﻮم ﺑ ﺎﻟﺘﻌﻮﻳﺾ ﻋ ﻦ ﻗﻴﻤﺘ ﻲ ) ‪ ( I, j‬وهﻤ ﺎ ) ‪ , ( 1 , 1‬ﺛ ﻢ ﻳ ﺄﺗﻲ ﺑﻘﻴﻤ ﺔ ه ﺬا اﻟﻤﻮﻗ ﻊ ﻟﻄﺒﺎﻋﺘﻬ ﺎ ‪ ,‬وﺑﻌ ﺪ‬
‫ﻃﺒﺎﻋﺔ ﻣﺤﺘﻮﻳﺎت هﺬا اﻟﻤﻮﻗﻊ ﻳﻄﺒﻊ اﻟﻔﺮاغ اﻟﻮارد ﺑﺄﻣﺮ اﻟﻄﺒﺎﻋﻪ وﺣﺴﺐ ﻣﺎ ﻣﺤ ﺪد ﺑ ﺎﻷﻣﺮ) ﻓ ﺮاﻏﻴﻦ ( ‪..‬‬
‫ﻳﺮﺟﻊ اﻟﻤﺘﺮﺟﻢ اﻟﻰ اﻟﺘﻜﺮار اﻟﺜﺎﻧﻲ ﻟﻴﺰﻳﺪ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( j‬ﺑﻤﻘﺪار واﺣﺪ ﻓﺘ ﺼﺒﺢ ﻗﻴﻤﺘ ﻪ أﺛﻨ ﻴﻦ ﻟﻴﻨﻔ ﺬ أﻣ ﺮ‬
‫اﻟﻄﺒﺎﻋﻪ ﺛﺎﻧﻴﺔ وﻳﻄﺒﻊ ﻣﺤﺘﻮﻳ ﺎت اﻟﻤﻮﻗ ﻊ ) ‪ ( 1 , 2‬ﺑﺠﺎﻧ ﺐ اﻟﻘﻴﻤ ﻪ اﻷوﻟ ﻰ ) اﻟﺘ ﻲ ه ﻲ رﻗ ﻢ وﻓ ﺮاغ ( ﻷن‬
‫أﻣﺮ اﻟﻄﺒﺎﻋﻪ هﻮ ) ‪ ( write‬ﺛﻢ اﻟﻌﻮدﻩ ﻟﺰﻳﺎدة ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( j‬ﻟﺘﻜﻮن ﻣ ﺴﺎوﻳﻪ اﻟ ﻰ ) ‪ ( 3‬وﺗ ﺘﻢ ﻃﺒﺎﻋ ﺔ‬
‫ﻣﺤﺘﻮﻳﺎت اﻟﻤﻮﻗﻊ ) ‪ ( 1 , 3‬واﻟﻔﺮغ اﻟﺬي ﺑﻌﺪﻩ ‪ ,‬ﺗﺰاد ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( j‬وﺗ ﺼﺒﺢ ﻗﻴﻤﺘ ﻪ ) ‪ ( 4‬وﺗ ﺴﺘﻤﺮ‬
‫اﻟﻌﻤﻠﻴﻪ ﻟﺤﻴﻦ أن ﺗﺘﻢ ﻃﺒﺎﻋﺔ ﺧﻤﺴﺔ ﻗﻴﻢ ﺟﻤﻴﻌﻬﺎ ﻋﻠﻰ ﺳﻄﺮ واﺣﺪ ﻳﻔﺼﻞ ﺑﻴﻦ واﺣﺪﻩ وأﺧﺮى ﻓﺮاغ ﺣﺴﺐ‬
‫ﻣﺎ ﻣﺒ ﻴﻦ ﺑ ﺄﻣﺮ اﻟﻄﺒﺎﻋ ﻪ ﻋﻨ ﺪ ذاك ﻓ ﺄن ﻗﻴﻤ ﺔ ) ‪ ( j‬ﺳ ﺘﻜﻮن ﻣ ﺴﺎوﻳﻪ اﻟ ﻰ )‪ (6‬ﻟ ﺬﻟﻚ ﻳﺘﻮﻗ ﻒ ﺗﻨﻔﻴ ﺬ اﻷواﻣ ﺮ‬
‫اﻟﺘﺎﺑﻌﻪ ﻟﺤﻠﻘ ﺔ اﻟﺘﻜ ﺮار اﻟﺜﺎﻧﻴ ﻪ وﻳﻨﺘﻘ ﻞ اﻟﺘﻨﻔﻴ ﺬ اﻟ ﻰ اﻷﻣ ﺮ اﻟﺘ ﺎﻟﻲ وه ﻮ ﻃﺒﺎﻋ ﻪ ‪ ...‬وﻟﻤ ﺎ آ ﺎن أﻣ ﺮ اﻟﻄﺒﺎﻋ ﻪ‬
‫ﻻﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻗﻴﻤ ﻪ ﻟﻴﻄﺒﻌﻬ ﺎ ﻓﺄﻧ ﻪ ﺳ ﻴﻜﺘﻔﻲ ﺑﺎﻟﺘﺄﺷ ﻴﺮ ﻋﻠ ﻰ ﺳ ﻄﺮ ﺟﺪﻳ ﺪ دون ﻃﺒﺎﻋ ﺔ أي ﺷ ﻲء‪ , ..‬ﻳﻌ ﻮد‬
‫اﻟﻤﺆﺷ ﺮ اﻟ ﻰ ﺣﻠﻘ ﺔ اﻟﺘﻜ ﺮار اﻷوﻟ ﻰ ﻷﻧﻬ ﺎ ﻟ ﻢ ﺗﻨﺘﻬ ﻲ ﺑﻌ ﺪ وﻳﺰﻳ ﺪ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( I‬ﻟﻴﻜ ﻮن ) ‪ ( 2‬وﺗﺒ ﺪأ‬
‫ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ ﺟﺪﻳﺪﻩ ﻣ ﺸﺎﺑﻬﻪ ﻟﻤ ﺎ ﺷ ﺮح ﺳ ﺎﺑﻘﺎ ﻟﻜ ﻦ ﻣ ﻊ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( I‬اﻟﻤ ﺴﺎوﻳﻪ ﻷﺛﻨ ﻴﻦ وﻋﻠ ﻰ ﺳ ﻄﺮ‬
‫ﺟﺪﻳﺪ ‪ .‬وﺗﺴﺘﻤﺮ اﻟﻌﻤﻠﻴﻪ ﻟﺤﻴﻦ اﻷﻧﺘﻬﺎء ﻣﻦ آﺎﻣﻞ ﺣﻠﻘﺔ اﻟﺘﻜﺮار اﻷوﻟﻰ ﻟﻴﻨﺘﻘﻞ ﺑﻌﺪهﺎ اﻟﻰ ﻧﻬﺎﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬ ‫‪4.3‬‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ ﻣﻜﻮﻧﻪ ﻣﻦ ) ‪ ( 20‬ﻋﻨﺼﺮ‪ ,‬ﺛﻢ أﻃﺒﻌﻬﺎ ﺑﺸﻜﻞ ﻣﻌﻜﻮس ‪.‬‬ ‫•‬

‫;‪Program CH4_Program8‬‬
‫‪Var‬‬
‫;‪A: array [1..20] of integer‬‬
‫;‪I: integer‬‬
‫‪Begin‬‬
‫‪For i: =1 to 20 do‬‬
‫;)]‪Readln (a[i‬‬
‫‪For i: =20 downto 1 do‬‬
‫;)‪Write (a[i]:7‬‬
‫‪End.‬‬
62 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫ ﺛﻢ رﺗﺐ ﻋﻨﺎﺻﺮهﺎ ﺗﺼﺎﻋﺪﻳﺎ‬, ‫ ( ﻋﻨﺼﺮ‬20 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ ﻣﻜﻮﻧﻪ ﻣﻦ‬ •
. ‫ﺣﺴﺐ ﻗﻴﻤﻬﺎ‬

Program CH4:Program9;
Var
A: array [1..20] of integer;
I, j, temp: integer;
Begin
For i: = 1 to 20 do
Readln (a[i]);
For i: =1 to 19 do
For j: = i+1 to 20 do
If (a[i] > a[j]) then
Begin
Temp: =a[i];
A[i]:=a[j];
A[j]:=temp;
End;
For i: =1 to 20 do
Write (a[i]:6);
End.

‫ ﺛ ﻢ أدﻣ ﺞ‬,‫ ( ﻋﻨ ﺼﺮ‬15 ) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻣ ﺼﻔﻮﻓﺘﻴﻦ أﺣ ﺎدﻳﺘﻴﻦ آ ﻞ ﻣﻨﻬﻤ ﺎ ﻣﻜﻮﻧ ﻪ ﻣ ﻦ‬ •
. ‫ ( ﻋﻨﺼﺮ‬30 ) ‫اﻟﻤﺼﻔﻮﻓﺘﻴﻦ ﺑﻤﺼﻔﻮﻓﻪ واﺣﺪﻩ ﺣﺠﻤﻬﺎ‬

Program CH4_Program10;
Var
A, b: array [1..15] of char;
C: array [1..30]of char;
I: integer;
Begin
For i: = 1 to 15 do
Begin
Readln (a[i]);
Readln (b[i]);
End;
For i: = 1 to 30 do
Begin
If (i<=15) then
C[i]:=a[i]
Else
C[i]:=b [i-15];
End;
For i: =1 to 30 do
Write(c[i]:3);
End.
63 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

. ‫ ﺛﻢ أوﺟﺪ ﻣﺠﻤﻮع ﻋﻨﺎﺻﺮهﺎ‬,( 5x4 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﻣﺼﻔﻮﻓﻪ ﺛﻨﺎﺋﻴﻪ ﺣﺠﻤﻬﺎ‬ •

Program CH4_Program11;
Var
A: array [1..5, 1..4] of integer;
I, j, sum: integer;
Begin
Sum: =0;
For i: =1 to 5 do
For j: =1 to 4 do
Readln (a [I, j]);
For i: =1 to 5 do
For j: =1 to 4 do
Sum: =sum + a [I,j];
Writeln (sum);
End.

‫ ﺛﻢ أوﺟﺪ اﻟﻌﺪد اﻷآﺒﺮ ﻣ ﻦ ﺑ ﻴﻦ ﻋﻨﺎﺻ ﺮ‬, ( 5x4 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﻣﺼﻔﻮﻓﻪ ﺛﻨﺎﺋﻴﻪ ﺣﺠﻤﻬﺎ‬ •
. ‫اﻟﻤﺼﻔﻮﻓﻪ‬

Program CH4_program12;
Var
B: array [1..5, 1..4]of integer;
I, j, max: integer;
Begin
For i: =1 to 5 do
For j: =1 to 4 do
Readln (b [I, j]);
Max: =b [1, 1];
For i: =1 to 5 do
For j: =1 to 4 do
If (b [I, j] > max) then
Max: =b [I, j];
Wrireln (max);
End.

‫ ﺛ ﻢ أوﺟ ﺪ ﻣﺠﻤﻮﻋﻬﻤ ﺎ واﻟﻔ ﺮق‬, ( 3x4 ) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻣ ﺼﻔﻮﻓﺘﻴﻦ آ ﻞ ﻣﻨﻬﻤ ﺎ ﺑﺤﺠ ﻢ‬ •
. ‫ﺑﻴﻨﻬﻤﺎ‬
64 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

Program CH4_Program13;
Var
A, b, c, d: array [1..3, 1..4] of integer;
I, j: integer;
Begin
For i: =1 to 3 do
For j: =1 to 4 do
Begin
Readln (a [I, j]);
Readln (b [I, j]);
End;
For i: =1 to 3 do
For j: =1 to 4 do
Begin
C [I, j]:=a [I, j] + b [I, j];
D [I, j]:=a [I, j] - b [I, j];
End;
For i: =1 to 3 do
Begin
For j: =1 to 4 do
Write(c [I, j]:6);
Writeln;
End;
For i: =1 to 3 do
Begin
For j: =1 to 4 do
Write (d [I, j]:6);
Writeln;
End;
End.

‫ ﺛ ﻢ أوﺟ ﺪ ﻣﺠﻤ ﻮع ﻋﻨﺎﺻ ﺮ اﻟﻘﻄ ﺮ اﻟ ﺮﺋﻴﺲ‬, ( 6x6 ) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻣ ﺼﻔﻮﻓﻪ ﺣﺠﻤﻬ ﺎ‬ •
. ‫ﻟﻠﻤﺼﻔﻮﻓﻪ‬

Program CH4_Program14;
Var
Cd: array [1..6, 1..6] of integer;
I, j, sum: integer;
Begin
Sum: =0;
For i: =1 to 6 do
For j: =1 to 6 do
Readln (cd [I, j]);
For i: =1 to 6 do
Sum: =sum + cd [i, i];
Writeln (sum);
End.
65 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫ ﺛ ﻢ أوﺟ ﺪ‬, ( 4x5 ) ‫ ( وﺣﺠ ﻢ اﻟﺜﺎﻧﻴ ﻪ‬3x4 ) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻣ ﺼﻔﻮﻓﺘﻴﻦ ﺣﺠ ﻢ اﻷوﻟ ﻰ‬ •
. ‫ﺣﺎﺻﻞ ﺿﺮﺑﻬﻤﺎ‬

Program CH4_Program15;
Var
A: array [1..3, 1..4] of integer;
B: array [1..4, 1..5] of integer;
C: array [1..3, 1..5] of integer;
I, j,k: integer;
Begin
For i: =1 to 3 do
For j: =1 to 4 do
Readln (a [I, j]);
For i: =1 to 4 do
For j: =1 to 5 do
Readln (b [I, j]);
For k: =1 to 3 do
For i: =1 to 5 do
Begin
C [k, i]:=0;
For j: =1 to 4 do
C [k, i]:=c [k, i] + a [k, j]* b[j,i];
End;
For i: =1 to 3 do
Begin
For j: =1 to 5 do
Write(c [I, j]);
Writeln;
End;
End.
‫‪66‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ‬
‫اﻷﺟﺮاءات واﻟﺪوال ‪PROCEDURES AND FUNCTIONS‬‬

‫اﻟﻤﻘﺪﻣﻪ‬ ‫‪5.1‬‬

‫اﻷﺟ ﺮاءات ه ﻲ ﺑ ﺮاﻣﺞ ﺻ ﻐﻴﺮﻩ ﺗ ﺴﺘﺨﺪم ﺿ ﻤﻦ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ ‪ ,‬ه ﺬا اﻟﻔ ﺼﻞ ﺳ ﻴﺮآﺰ ﻋﻠ ﻰ آﻴﻔﻴ ﺔ‬
‫اﻷﺳﺘﻔﺎدﻩ ﻣﻦ اﻷﺟﺮاءات واﻟﺪوال وﻣﺎهﻴﺔ اﻟﻀﻮاﺑﻂ اﻟﺘﻲ ﺗﺘﺤﻜﻢ ﺑﻬﻤﺎ ‪ ,‬ﻣﻊ ﻋﺪد ﻣﻦ اﻷﻣﺜﻠﻪ اﻟﺘﻮﺿﻴﺤﻴﻪ ‪.‬‬

‫اﻷﺟﺮاءات ‪PROCEDURES‬‬ ‫‪5.2‬‬

‫اﻷﺟﺮاءات أو اﻟﺮوﺗﻴﻨﺎت اﻟﻔﺮﻋﻴﻪ آﻤﺎ ﺗﺴﻤﻰ أﺣﻴﺎﻧﺎ ه ﻲ ﺟ ﺰء ﻣ ﻦ ﺑﺮﻧ ﺎﻣﺞ ﺗ ﻮﻓﺮ ﻓﻌ ﻞ ﺧ ﺎص ‪.‬‬
‫و ﺗﺴﺘﺨﺪم ﻟﻤﺴﺎﻋﺪة اﻟﻤﺒﺮﻣﺞ ﻟﺘﺠﻨ ﺐ اﻟﺘﻜ ﺮار ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ وﺧ ﺼﻮﺻﺎ اﻟﺒ ﺮاﻣﺞ اﻟﻜﺒﻴ ﺮﻩ ﺑ ﺸﻜﻞ ﻋ ﺎم ﻓ ﺄن‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻳﺠﺰأ اﻟﻰ أﺟﺰاء ﺻﻐﻴﺮﻩ ‪ ,‬وهﺬﻩ اﻷﺟﺰاء ﺗﺠﺰأ اﻟﻰ أﺟﺰاء أﺻ ﻐﺮ وهﻜ ﺬا ﻟﺤ ﻴﻦ اﻟﻮﺻ ﻮل اﻟ ﻰ‬
‫أﺟﺰاء ﺳﻬﻠﺔ اﻟﺘﻨﻔﻴﺬ أو اﻷﻧﺠ ﺎز ‪ .‬وآﻤ ﺎ ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ اﻷﻋﺘﻴﺎدﻳ ﻪ ﺗﺒ ﺪأ اﻷﺟ ﺮاءات ﻣ ﻊ اﻷﻣ ﺮ ) ‪( begin‬‬
‫وﺗﻨﺘﻬ ﻲ ﻣ ﻊ اﻷﻣ ﺮ ) ; ‪ ( end‬وﻣﻤﻜ ﻦ أن ﻳﻜ ﻮن ﻟﻬ ﺎ ﻣﺘﻐﻴ ﺮات ﺧﺎﺻ ﻪ ﺑﻬ ﺎ ﻻ ﺗ ﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ‬
‫اﻟﺮﺋﻴﺴﻲ ‪.‬‬
‫ﻳﺒﺪأ اﻷﺟﺮاء ﺑﻜﻠﻤﻪ ) ‪ ( procedure‬ﻣﺘﺒﻮﻋﻪ ﺑﺄﺳﻢ اﻷﺟﺮاء آﻤﺎ ه ﻮ اﻟﺤ ﺎل ﻓ ﻲ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ‬
‫‪ ,‬وﻣﻤﻜ ﻦ أن ﻳﺘﺒ ﻊ ﺑﻘﻮﺳ ﻴﻦ ﻳﺤﺘﻮﻳ ﺎن ﻋﻠ ﻰ اﻟﻤﺘﻐﻴ ﺮات اﻟﺪاﺧﻠ ﻪ واﻟﺨﺎرﺟ ﻪ واﻟﺘ ﻲ ﺗ ﺪﻋﻰ ) اﻟﻮﺳ ﺎﺋﻂ (‬
‫) ‪ ) ( parameters‬وهﻲ ﺗﺴﺘﺨﺪم ﻟﻠﺘﻮاﺻ ﻞ ﺑ ﻴﻦ اﻟﻨﻤ ﺎذج أو اﻷﺟ ﺮاءات ( واﻟﺘ ﻲ ﺳ ﻨﺄﺗﻲ ﻋﻠﻴﻬ ﺎ ﻻﺣﻘ ﺎ‬
‫وهﺬا ﻳﺪﻋﻰ رأس اﻷﺟﺮاء ‪ .‬وآﻞ ﻣﺎﻳﻠﻲ ذﻟﻚ ﻓﻬﻮ ﻣﺸﺎﺑﻪ ﻟﻠﺒﺮاﻣﺞ اﻷﻋﺘﻴﺎدﻳﻪ واﻟﺘﻲ ﺳﺒﻖ وأن ﺗﻄﺮﻗﻨ ﺎ ﻟﻬ ﺎ‬
‫‪.‬‬
‫أن اﻟﻔﺮق ﺑﻴﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻷﻋﺘﻴﺎدي واﻷﺟﺮاء هﻮ ﻣﺎﻳﻠﻲ ‪:‬‬

‫ﻣ ﻦ اﻟﻤﻬ ﻢ ﺟ ﺪا أن ﻳﻜ ﻮن ﺣﺠ ﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﺻ ﻐﻴﺮ ‪ .‬أن آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ ﻋﻠ ﻰ ﺷ ﻜﻞ‬ ‫‪.1‬‬
‫أﺟﺮاءات أو دوال ) ﺳﻨﺄﺗﻲ ﻋﻠﻴﻬﺎ ﻻﺣﻘﺎ ( ﻳﺴﺎﻋﺪ اﻟﻰ درﺟﻪ آﺒﻴﺮﻩ اﻟﻰ ﺗﻘﻠﻴﻞ ﺣﺠﻢ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺸﻜﻞ ﻋﺎم ‪.‬‬

‫أن آﺘﺎﺑﻪ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻠ ﻰ ﺷ ﻜﻞ أﺟ ﺮاءات ﻳ ﺴﺎﻋﺪ اﻟﻤﺒ ﺮﻣﺞ ﻣ ﺴﺘﻘﺒﻼ أو أي ﺷ ﺨﺺ أﺧ ﺮ‬ ‫‪.2‬‬


‫ﻣﻦ ﻣﺘﺎﺑﻌﻪ اﻟﺒﺮﻧﺎﻣﺞ وﺗﺼﺤﻴﺢ أو ﺗﻌﺪﻳﻞ اﻟﺒﺮﻧﺎﻣﺞ أذا أﻗﺘﻀﺖ اﻟﺤﺎﺟﻪ ﺑﺴﻬﻮﻟﻪ وﻳﺴﺮ ‪.‬‬

‫اﻷﺟﺮاءات ﺗﺴﺎﻋﺪ اﻟﻤﺒﺮﻣﺞ ﻋﻠﻰ اﻟﺘﺨﻠﺺ ﻣﻦ ﺗﻜﺮار ﻣﻘﺎﻃﻊ ﻣﻌﻴﻨﻪ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ واﻟﺘﻲ‬ ‫‪.3‬‬
‫ﺗﺴﺒﺐ أﺷﻜﺎﻻت آﺜﻴﺮﻩ ﻟﻠﻤﺒﺮﻣﺞ ‪ ,‬أﺿﺎﻓﻪ اﻟﻰ زﻳﺎدة ﺣﺠﻢ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫اﻷﺟﺮاءات ﺗﻌﻄﻲ اﻟﻤﺒﺮﻣﺞ ﻣﺮوﻧ ﻪ أآﺒ ﺮ ﻟﻤﺘﺎﺑﻌ ﺔ اﻷﺧﻄ ﺎء آﻤ ﺎ أﺳ ﻠﻔﻨﺎ‪ ,‬وآ ﺬﻟﻚ ﺗ ﺴﺎﻋﺪ‬ ‫‪.4‬‬
‫ﻋﻠﻰ أﺳﺘﺨﺪام هﺬﻩ اﻷﺟﺮاءات ﻓﻲ ﺑﺮاﻣﺞ أﺧﺮى ﻋﻨﺪ اﻟﺤﺎﺟﻪ ﻟﻬﺎ دون اﻟﺤﺎﺟﻪ اﻟﻰ أﻋﺎدة آﺘﺎﺑﺘﻬﺎ ‪.‬‬

‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻸﺟﺮاء هﻲ ‪:‬‬


‫‪67‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫; > ‪Procedure < PROCEDURE_NAME‬‬


‫‪OR‬‬
‫; ) ‪Procedure <PROCEDURE_NAME ( Var Variable_Name : Type‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫هﻨ ﺎك ﻧ ﻮﻋﻴﻦ ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮات ‪ ,‬ﻣﺘﻐﻴ ﺮات ﺗ ﺴﺘﺨﺪم داﺧ ﻞ اﻷﺟ ﺮاء ﻓﻘ ﻂ وﻻ ﺗ ﺴﺘﺨﺪم ﻓ ﻲ‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻟ ﺮﺋﻴﺲ وأن أي ﺗﻐﻴ ﺮ ﻋﻠ ﻰ ﻗﻴﻤ ﺔ ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ﺳ ﻮف ﻻ ﻳﻨ ﺴﺤﺐ ﻋﻠ ﻰ اﻟﻤﺘﻐﻴ ﺮات‬
‫اﻷﺧﺮى اﻟﺘﻲ ﺗﺤﻤﻞ ﻧﻔﺲ اﻷﺳﻢ ﻓ ﻲ اﻷﺟ ﺮاءات اﻷﺧ ﺮى أو اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ وه ﺬﻩ ﺗ ﺴﻤﻰ‬
‫ﻣﺘﻐﻴﺮات ﻣﺤﻠﻴﻪ ) ‪. ( local variables‬‬
‫وﻧﻮع أﺧﺮ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻤﻤﻜ ﻦ أن ﻳ ﺴﺘﺨﺪم داﺧ ﻞ اﻷﺟ ﺮاء واﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ وأي‬
‫ﺗﻐﻴﺮ ﻳﻄ ﺮأ ﻋﻠ ﻰ ه ﺬﻩ اﻟﻤﺘﻐﻴ ﺮات ﻳﻨ ﺴﺤﺐ ﻋﻠﻴ ﻪ ﻓ ﻲ آ ﻞ ﻣﻜ ﺎن وه ﻲ ﺗ ﺴﻤﻰ ﻣﺘﻐﻴ ﺮات ﻋﺎﻣ ﻪ‬
‫) ‪. ( global variables‬‬
‫اﻟﻤﺘﻐﻴ ﺮات اﻟﻤﺤﻠﻴ ﻪ ﻳﻌﻠ ﻦ ﻋﻨﻬ ﺎ ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات داﺧ ﻞ اﻷﺟ ﺮاء ﺑﻴﻨﻤ ﺎ‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﻌﺎﻣﻪ ﻳﻌﻠﻦ ﻋﻨﻬﺎ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ) أي أن‬
‫أي ﻣﺘﻐﻴﺮ ﻳﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻟﻠﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﺳﻴﻜﻮن ﻓﻌ ﺎﻻ وﻳ ﺮى‬
‫) ﻧﺴﺘﻄﻴﻊ ﻗﺮاءة وﺗﻐﻴﻴﺮ ﻗﻴﻤﺘﻪ ( ﻓﻲ آﻞ ﻣﻜﺎن ﻳﺘﻮاﺟﺪ ﺑﻪ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬أﻣﺎ اﻟﻤﺘﻐﻴ ﺮات اﻟﺘ ﻲ‬
‫ﺗﻌﺮف ﻓﻲ ﺣﻘﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات داﺧﻠ ﺲ اﻷﺟ ﺮاء ﺳ ﻮف ﻻ ﺗ ﺮى أﻃﻼﻗ ﺎ ﺧ ﺎرج ه ﺬا‬
‫اﻷﺟﺮاء ( ‪.‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪Program CH5_Program1‬‬
‫‪Var‬‬
‫;‪X:integer‬‬

‫;‪Procedure Change‬‬
‫‪Begin‬‬
‫;‪X: =1‬‬
‫;‪End‬‬ ‫}‪{change‬‬

‫‪Begin‬‬ ‫}‪{main program‬‬


‫;‪X: =0‬‬
‫;‪Change‬‬
‫;)‪Write ('x=', x‬‬
‫‪End.‬‬ ‫} ‪{main program‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//: 1‬‬


‫‪X=1‬‬
‫‪68‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 1‬‬

‫هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻳﺤﺘﻮي ﻋﻠﻰ ﻣﺘﻐﻴﺮ واﺣ ﺪ ه ﻮ ) ‪ ( x‬وﻣﻌ ﺮف ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات‬
‫ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻟﺬ ﻓﻬﻮ ﻳﻌﺘﺒﺮ ﻣﺘﻐﻴﺮ ﻋﺎم ) ‪ . ( global‬اﻟﺒﺮﻧﺎﻣﺞ ﻳﺤﺘﻮي ﻋﻠ ﻰ أﺟ ﺮاء ﻳﻘ ﻮم ﺑﺘﻐﻴﻴ ﺮ‬
‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ) ‪ ( x‬اﻟﻰ اﻟﻘﻴﻤﻪ ) ‪. ( 1‬‬
‫ﻳﺒ ﺪأ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ ﺑﺄﺳ ﻨﺎد اﻟﻘﻴﻤ ﻪ ) ‪ ( 0‬اﻟ ﻰ اﻟﻤﺘﻐﻴ ﺮ ) ‪ , ( x‬ﺛ ﻢ ﻳ ﺘﻢ أﺳ ﺘﺪﻋﺎء اﻷﺟ ﺮاء‬
‫) ‪ ( change‬وذﻟ ﻚ ﺑﻜﺘﺎﺑ ﺔ أﺳ ﻢ اﻷﺟ ﺮاء ﻋﻨ ﺪ ذﻟ ﻚ ﻳﻨﺘﻘ ﻞ اﻟﻤﺆﺷ ﺮ اﻟ ﻰ اﻷﺟ ﺮاء ) ‪ ( change‬وﻳﻨﻔ ﺬ‬
‫اﻷواﻣ ﺮ اﻟﺘ ﻲ ﻓﻴ ﻪ ) آﺒﺮﻧ ﺎﻣﺞ ﻣ ﺴﺘﻘﻞ ( وﺑﻌ ﺪ ﻧﻬﺎﻳ ﺔ ﺗﻨﻔﻴ ﺬ اﻷﺟ ﺮاء ﻳﻌ ﻮد اﻟﻤﺆﺷ ﺮ اﻟ ﻰ ﻋﺒ ﺎرة أﺳ ﺘﺪﻋﺎء‬
‫اﻷﺟﺮاء ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻟﻴﺴﺘﻤﺮ ﺑﺎﻟﺘﻨﻔﻴﺬ ﻟﻠﻌﺒﺎرات اﻟﺘﺎﻟﻴﻪ ﻟﻬﺎ واﻟﺘ ﻲ ه ﻲ هﻨ ﺎ ﻋﺒ ﺎرة اﻟﻄﺒﺎﻋ ﻪ ﺣﻴ ﺚ‬
‫ﺳﺘﻄﺒﻊ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ .. ( x‬ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺗﻐﻴﺮت ﻓﻲ اﻷﺟﺮاء وﺗﺒﻌﺎ ﻟﺬﻟﻚ ﺗﻐﻴﺮت ﻗﻴﻤﺘﻬﺎ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ‬
‫اﻟﺮﺋﻴﺲ ﻷن اﻟﻤﺘﻐﻴﺮ ﻣﻌﺮف آﻤﺘﻐﻴﺮ ﻋﺎم ‪.‬‬

‫;‪Program CH5_Program2‬‬
‫‪Var‬‬
‫;‪X:integer‬‬

‫;‪Procedure Change‬‬
‫‪Var‬‬
‫;‪X: integer‬‬
‫‪Begin‬‬
‫;‪X: =1‬‬
‫;‪End‬‬ ‫}‪{change‬‬

‫‪Begin‬‬ ‫}‪{main program‬‬


‫;‪X: =0‬‬
‫;‪Change‬‬
‫;)‪Write ('x=', x‬‬
‫‪End.‬‬ ‫}‪{Main program‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪X=0‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 2‬‬

‫ﻻ ﻳﺨﺘﻠﻒ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻋﻦ اﻟﺒﺮﻧ ﺎﻣﺞ ) ‪ ( 1‬آﺜﻴ ﺮا ‪ ,‬ﻋ ﺪا أن اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( x‬ﻋ ﺮف ﻣﺮﺗ ﺎن ﻣ ﺮﻩ‬
‫ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻟﻴﻜﻮن ﻣﺘﻐﻴﺮ ﻋﺎم ‪ ,‬وﺛﺎﻧﻴﺔ ﻓﻲ ﺣﻘﻞ اﻷﻋ ﻼن ﻋ ﻦ‬
‫اﻟﻤﺘﻐﻴﺮات ﻓﻲ اﻷﺟﺮاء ) ‪ ( change‬ﻟﻴﻜﻮن ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ ‪.‬‬
‫ﺑﻨﺎء ﻋﻠﻰ ﻣﺎ ﺗﻘﺪم ﻓﺄن اﻟﻤﺘﻐﻴﺮﻳﻦ ﻳﺨﺘﻠﻔﺎن ﻷن أﺣﺪهﻤﺎ ﻋﺎم واﻟﺜ ﺎﻧﻲ ﻣﺤﻠ ﻲ وأن ﺗ ﺸﺎﺑﻬﺔ اﻟﺘ ﺴﻤﻴﻪ‪,‬‬
‫ﻣﻦ ذﻟﻚ ﻓﺄن اﻟﺘﻐﻴﻴﺮ اﻟﺬي ﻳﺤﺼﻞ ﻋﻠﻰ اﻟﻤﺘﻐﻴﺮ اﻟﻤﺤﻠﻲ ) ‪ ( x‬داﺧ ﻞ اﻷﺟ ﺮاء ﺳﻴﻨﺤ ﺼﺮ داﺧ ﻞ اﻷﺟ ﺮاء‬
‫ﻓﻘﻂ وﻻ ﻳﺆﺛﺮ ﻋﻠ ﻰ اﻟﻤﺘﻐﻴ ﺮات ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ ﺳ ﻮاء ﺗ ﺸﺎﺑﻬﺔ اﻟﺘ ﺴﻤﻴﻪ أو أﺧﺘﻠﻔ ﺖ ‪ ,‬وﻧﻔ ﺲ اﻷﻣ ﺮ‬
‫ﻳﻨﺴﺤﺐ ﻋﻠﻰ اﻟﻤﺘﻐﻴﺮ اﻟﻌﺎم ‪.‬‬
‫‪69‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫اﻟﻮﺳﺎﺋﻂ ) ‪ ( parameters‬هﻲ ﻗﻴﻤﻪ ﺗﻤﺮر اﻟﻰ اﻷﺟﺮاء أو اﻟﺪاﻟﻪ ‪.‬‬


‫هﻨﺎك أآﺜﺮ ﻣﻦ ﻧﻮع ﻣﻦ اﻟﻮﺳﺎﺋﻂ وﻣﺎ ﻳﻬﻤﻨﺎ هﻨﺎ ﻧﻮﻋﻴﻦ ‪:‬‬

‫‪ .1‬وﺳﺎﺋﻂ اﻟﻘﻴﻤﻪ ) ‪ : ( value parameters‬ﺗﺘﺼﺮف هﺬﻩ اﻟﻮﺳﺎﺋﻂ ﻣﺜﻞ‬


‫اﻟﻤﺘﻐﻴﺮ اﻟﻤﺤﻠﻲ ﺿﻤﻦ اﻷﺟﺮاء أو اﻟﺪاﻟﻪ ) ﺣﻴﺚ أن اﻟﻤﺘﻐﻴﺮ اﻟﻤﺤﻠﻲ ﻳﻤﻜﻦ ﺗﻐﻴﻴﺮ‬
‫ﻗﻴﻤﺘﻪ ﺿﻤﻦ اﻷﺟﺮاء ﻟﻜﻦ اﻟﻘﻴﻤﻪ اﻷﺻﻠﻴﻪ ﺿﻤﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻻﺗﺘﻐﻴﺮ ( ‪,‬‬
‫ﻓﻌﻨﺪﻣﺎ ﻳﺴﺘﺨﺪم أﺟﺮاء وﺳﺎﺋﻂ ﻗﻴﻤﻪ ﻓﺄن اﻟﻤﺘﺮﺟﻢ ﻳﻨﺴﺦ هﺬﻩ اﻟﻤﺘﻐﻴﺮات وﻳﻤﺮر‬
‫ﻧﺴﺨﻪ ﻣﻨﻬﺎ اﻟﻰ اﻷﺟﺮاء ‪ ,‬أﻣﺎ اﻟﻤﺘﻐﻴﺮات اﻷﺻﻠﻴﻪ ﻓﺘﺒﻘﻰ ﻋﻠﻰ ﺣﺎﻟﻬﺎ ﻷن ﻣﺎ‬
‫أرﺳﻞ اﻟﻰ اﻷﺟﺮاء هﻮ ﻧﺴﺨﻪ وأي ﺗﻐﻴﺮ ﻓﻲ اﻟﻨﺴﺨﻪ ﻻ ﻳﺆﺛﺮ ﻓﻲ اﻷﺻﻞ ) آﻤﺎ‬
‫ﻟﻮ ﻧﺴﺨﻨﺎ ﻣﺴﺘﻨﺪ وﺣﻮرﻧﺎ ﻓﻲ اﻟﻨﺴﺨﻪ اﻟﻤﺴﺘﻨﺴﺨﻪ ﻓﻬﻞ ﺳﻴﺆﺛﺮ ﻋﻠﻰ اﻟﻨﺴﺨﻪ‬
‫اﻷﺻﻠﻴﻪ !؟( ‪.‬‬
‫وﺳﺎﺋﻂ اﻟﻘﻴﻤﻪ ﺗﻤﺮر ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ اﻟﻰ اﻷﺟﺮاء ﻓﻘﻂ ‪.‬‬
‫‪ .2‬اﻟﻮﺳﺎﺋﻂ اﻟﻤﺮﺟﻌﻴﻪ )‪ : ( Reference Parameters‬اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺟﻌﻴﻪ‬
‫ﻻ ﺗﺮﺳﻞ ﻧﺴﺨﻪ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﺑﻞ ﺗﺮﺳﻞ اﻟﻤﺘﻐﻴﺮ ذاﺗﻪ ‪ ,‬وﻟﺬا ﻓﺄن أي ﺗﻐﻴﺮ ﻋﻠﻰ‬
‫هﺬا اﻟﻤﺘﻐﻴﺮ ﺳﻴﺆﺛﺮ ﻋﻠﻰ اﻟﻤﺘﻐﻴﺮات اﻷﺻﻠﻴﻪ هﺬﻩ اﻟﻤﺘﻐﻴﺮات ﺗﻜﻮن ﻣﺴﺒﻮﻗﻪ‬
‫ﺑﺎﻷﻣﺮ ) ‪ ( var‬داﺋﻤﺎ ‪.‬‬
‫اﻟﻮﺳﺎﺋﻂ اﻟﻤﺮﺟﻌﻴﻪ ﺗﺴﺘﺨﺪم اﻟﻄﺮﻳﻘﻴﻦ ) أي اﻟﻘﻴﻤﻪ ﺗﻨﺘﻘﻞ ﻣﻦ واﻟﻰ اﻷﺟﺮاء ( ‪.‬‬

‫ﻣﺜﺎل ‪:‬‬
‫أوﺟﺪ ﻗﻴﻤﺔ ) ‪ ( y‬ﻣﻦ اﻟﻤﻌﺎدﻟﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬
‫‪10‬‬ ‫‪8‬‬ ‫‪6‬‬ ‫‪4‬‬
‫‪Y = 10 + 8 + 6 + 4‬‬

‫; ‪Program CH5_Program3‬‬
‫‪Var‬‬
‫;‪Y, p1, p2, p3, p4: longint‬‬
‫;‪i:integer‬‬
‫‪Begin‬‬
‫;‪P1:=1‬‬
‫‪For i: =1 to 10 do‬‬
‫;‪P1:=p1*10‬‬
‫;‪P2:=1‬‬
‫‪For i: =1 to 8 do‬‬
‫;‪P2:=p2*8‬‬
‫;‪P3:=1‬‬
‫‪For i: =1 to 6 do‬‬
‫;‪P3:=p3*6‬‬
‫;‪P4:=1‬‬
‫‪For i: =1 to 4 do‬‬
‫;‪P4:=p4*4‬‬
‫;‪Y: =p1+p2+p3+p4‬‬
‫'‪Writeln (p1,' ', p2' ', p3,‬‬ ‫;)‪', p4‬‬
‫;)‪Writeln(y‬‬
‫;‪Readln‬‬
‫‪End.‬‬
‫‪70‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪1410065408 16777216 46656 256‬‬
‫‪1426889536‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻟﻮ آﺎن اﻟﻤﺘﻐﻴﺮ ) ‪ ( y‬ﻣﻌﺮف ﻣﻦ ﻧﻮع ) ‪ ( integer‬ﻟﻜﺎﻧﺖ ﻗﻴﻤﺔ ) ‪ ( y‬ﺗﺴﺎوي‬


‫) ‪ ( -25792‬وذﻟﻚ ﻷن اﻟﻨﻮع ) ‪ ( integer‬ﻳﺤﺠﺰ ) ‪ ( 2 Byte‬وهﻲ ﻏﻴﺮ آﺎﻓﻴﻪ‬
‫ﻟﺘﻤﺜﻴﻞ رﻗﻢ أآﺒﺮ ﻣﻦ ) ‪ ( 65535‬ﻟﺬﻟﻚ ﻳﺘﺤﻮل اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﺴﺎﻟﺒﻪ ‪ ,‬وهﻮ ﻣﺸﺎﺑﻪ ﻟﻌﺪاد‬
‫اﻟﻤﺴﺎﻓﻪ ﻓﻲ اﻟﺴﻴﺎرﻩ ﻓﻌﻨﺪﻣﺎ ﻳﺼﻞ اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﻌﻠﻴﺎ وهﻲ ) ‪ ( 99999‬ﻓﺎن اﻟﺰﻳﺎدﻩ‬
‫ﺑﻤﻘﺪار واﺣﺪ ﺗﺴﺒﺐ ﺑﺄن ﻳﻜﻮن اﻟﻌﺪاد ﻣﺴﺎوي اﻟﻰ ) ‪. ( 00000‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ) ‪ ( 3‬ﺑﻄﺮﻳﻘﺔ اﻷﺟﺮاءات وآﻤﺎ ﻳﻠﻲ ‪:‬‬

‫;‪Program CH5_Program4‬‬
‫‪Var‬‬
‫;‪P1, p2, p3, p4, y: longint‬‬

‫;)‪Procedure power(x: integer; var p: longint‬‬


‫‪Var‬‬
‫;‪I: integer‬‬
‫‪Begin‬‬
‫;‪P: =1‬‬
‫‪For i: =1 to x do‬‬
‫;‪P: =p*x‬‬
‫;‪End‬‬

‫‪Begin‬‬ ‫}‪{main program‬‬


‫;)‪Power (10, p1‬‬
‫;)‪Power (8, p2‬‬
‫;)‪Power (6, p3‬‬
‫;)‪Power (4, p4‬‬
‫;‪Y: =p1+p2+p3+p4‬‬
‫;)‪Writeln(y‬‬
‫;‪Readln‬‬
‫‪End.‬‬
‫‪71‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 4‬‬

‫أوﻻ ‪ :‬ﻳﺒﺪأ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﻌﺮﻳﻒ ﻋ ﺪد ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮات واﻟﺘ ﻲ ﺗﻌﺘﺒ ﺮ ﻋﺎﻣ ﻪ ﻧﻈ ﺮا ﻷﻧﻬ ﺎ ﻣﻌﺮﻓ ﻪ ﻓ ﻲ‬
‫ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻟﻠﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ :‬آﺘﺎﺑﺔ اﻷﺟﺮاء واﻟﺬي ﻳﺴﺒﻖ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ واﻷﺟ ﺮاء ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻗ ﻮس ﻓﻴ ﻪ‬
‫ﻣﺘﻐﻴ ﺮات وﻧﻼﺣ ﻆ أن ه ﺬﻩ اﻟﻤﺘﻐﻴ ﺮات ﺗﺄﺧ ﺬ ﺷ ﻜﻠﻴﻦ ‪ :‬أﺣ ﺪهﻤﺎ ﻣ ﺴﺒﻮق ﺑ ﺎﻷﻣﺮ ) ‪ ( var‬واﻟﻔ ﺮق هﻨ ﺎ‬
‫ﺑﺒ ﺴﺎﻃﻪ أن اﻟﻤﺘﻐﻴ ﺮ اﻷول ﻳﺤﻤ ﻞ ﻗﻴﻤ ﻪ ﺗ ﺪﺧﻞ اﻟ ﻰ اﻷﺟ ﺮاء ﻟﻠﻌﻤ ﻞ ﻋﻠﻴﻬ ﺎ داﺧ ﻞ اﻷﺟ ﺮاء ‪ ,‬أﻣ ﺎ اﻟﻤﺘﻐﻴ ﺮ‬
‫اﻟﻤ ﺴﺒﻮق ﺑ ﺎﻷﻣﺮ ) ‪ ( var‬ﻓﻬ ﻮ ﻳﻌﺎﻣ ﻞ آﻤﺘﻐﻴﺮﺳ ﻴﺤﻤﻞ ﻗﻴﻤ ﻪ ﺗﺨ ﺮج ﻣ ﻦ اﻷﺟ ﺮاء اﻟ ﻰ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ‬
‫واﻟﺘﻲ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪.‬‬

‫ﺛﺎﻟﺜ ﺎ ‪ :‬اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ واﻟ ﺬي ﺳ ﻴﺘﻢ أﺳ ﺘﺪﻋﺎء اﻷﺟ ﺮاء داﺧﻠ ﻪ ﻟﺤ ﺴﺎب اﻟﻘ ﻴﻢ اﻟﻤﻄﻠﻮﺑ ﻪ‬
‫واﻷﺳﺘﺪﻋﺎء ﻳﺠﺐ أن ﻳﺘﻢ ﻣ ﻦ ﺧ ﻼل آﺘﺎﺑ ﺔ أﺳ ﻢ اﻷﺟ ﺮاء اﻟﻤﻄﻠ ﻮب أﺳ ﺘﺪﻋﺎءﻩ ﺛ ﻢ آﺘﺎﺑ ﺔ اﻟﻤﺘﻐﻴ ﺮات اﻟﺘ ﻲ‬
‫ﻳ ﺮاد أرﺳ ﺎﻟﻬﺎ اﻟ ﻰ اﻷﺟ ﺮاء هﻨ ﺎ ﻧﺮﺳ ﻞ اﻟ ﺮﻗﻢ اﻟﻤﻄﻠ ﻮب ﺣ ﺴﺎب ﻗﻴﻤﺘ ﻪ ﺑﻌ ﺪ رﻓﻌ ﻪ اﻟ ﻰ اﻷس اﻟﻤﻄﻠ ﻮب‬
‫وآ ﺬﻟﻚ ﻳﻜﺘ ﺐ اﻟﻤﺘﻐﻴ ﺮ اﻟ ﺬي ﺳ ﺘﻌﻮد اﻟﻨﺘﻴﺠ ﻪ ﻓﻴ ﻪ ) أن اﻟﻘ ﻴﻢ اﻟﻤﻮﺟ ﻮدﻩ ﻓ ﻲ أﻣ ﺮ اﻷﺳ ﺘﺪﻋﺎء ﺳ ﺘﻨﺘﻘﻞ اﻟ ﻰ‬
‫اﻷﺟﺮاء ﻟﺘﺴﻨﺪ اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻳﻘﺎﺑﻠﻬﺎ ﻓﻲ اﻷﺟﺮاء ( ‪.‬‬

‫راﺑﻌﺎ ‪ :‬ﻧﺘﻴﺠ ﺔ رﻓ ﻊ ﻋ ﺪد اﻟ ﻰ أس ﻣﻌ ﻴﻦ وﺣ ﺴﺐ اﻟﺤ ﺎﻻت أﻋ ﻼﻩ ﺳ ﺘﻌﻮد ﺑ ﺎﻟﻤﺘﻐﻴﺮ ) ‪ ( p‬واﻟﺘ ﻲ‬


‫ﺳﺘﺴﻨﺪ اﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻘﺎﺑﻠﻪ ﻓﻲ أﻣﺮ أﺳﺘﺪﻋﺎء اﻷﺟﺮاء وﻟﻜﻞ ﺣﺎﻟﺔ أﺳﺘﺪﻋﺎء ‪ ,‬هﺬﻩ اﻟﻘﻴﻢ ﺗﺠﻤ ﻊ ﻟﻨﺤ ﺼﻞ‬
‫ﻋﻠﻰ اﻟﻨﺘﻴﺠﻪ اﻟﻨﻬﺎﺋﻴﻪ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻳﺠﺐ أن ﻳﻜﻮن ﻋﺪد اﻟﻮﺳﺎﺋﻂ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺑﻌﺪ أﺳﻢ اﻷﺟﺮاء ﻓﻲ رأس اﻷﺟﺮاء ﻣﺴﺎوﻳﺎ اﻟﻰ‬
‫ﻋﺪد اﻟﻮﺳﺎﺋﻂ اﻟﻤﻮﺟﻮدﻩ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﻓﻲ أﻣﺮ أﺳﺘﺪﻋﺎء اﻷﺟﺮاء ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫اﻟﻮﺳﺎﺋﻂ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﻓﻲ أﻣﺮ اﻷﺳﺘﺪاء ﻳﺠﺐ أن ﺗﻜﻮن ﻣﺘﻨﺎﺳﺒﻪ ﻣﻊ اﻟﻮﺳﺎﺋﻂ ﻓﻲ رأس‬
‫اﻷﺟﺮاء ‪ ,‬ﻓﺎﻟﻮﺳﺎﺋﻂ اﻟﺘﻲ ﻓﻲ رأس اﻷﺟﺮاء أذا ﻟﻢ ﺗﻜﻦ ﻣﺴﺒﻮﻗﻪ ﺑﺎﻷﻣﺮ ) ‪ ( var‬ﻓﻴﺠﺐ أن‬
‫ﻳﻘﺎﺑﻠﻬﺎ ﻓﻲ أﻣﺮ اﻷﺳﺘﺪﻋﺎء أﻣﺎ ﻗﻴﻤﻪ ﺛﺎﺑﺘﻪ أو ﻣﺘﻐﻴﺮ ﻟﻪ ﻗﻴﻤﻪ ﻣﺤﺪدﻩ ﻗﺒﻞ ذﻟﻚ ‪ .‬أﻣﺎ اﻟﻤﺘﻐﻴﺮ اﻟﺬي‬
‫ﻓﻲ رأس اﻷﺟﺮاء واﻟﻤﺴﺒﻮق ﺑﺎﻷﻣﺮ ) ‪ ( var‬ﻓﻴﻘﺎﺑﻠﻪ ﻓﻲ اﻷﺳﺘﺪﻋﺎء ﻣﺘﻐﻴﺮ ‪.‬‬
‫ﻓﻲ اﻟﺤﺎﻟﻪ اﻷوﻟﻰ ﺳﺘﻨﺘﻘﻞ اﻟﻘﻴﻤﻪ ﻣﻦ اﻷﺳﺘﺪﻋﺎء اﻟﻰ اﻷﺟﺮاء وآﻞ ﻗﻴﻤﻪ ﺗﻨﺘﻘﻞ اﻟﻰ اﻟﻤﺘﻐﻴﺮ‬
‫اﻟﺬي ﻳﻘﺎﺑﻠﻬﺎ ﺣﺴﺐ ﺗﺮﺗﻴﺒﻬﺎ ) أي اﻟﻘﻴﻤﻪ اﻷوﻟﻰ ﺗﺴﻨﺪ اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻷول واﻟﻘﻴﻤﻪ اﻟﺜﺎﻧﻴﻪ ﺗﺴﻨﺪ‬
‫اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺜﺎﻧﻲ وهﻜﺬا ( ‪.‬‬
‫أﻣﺎ اﻟﺤﺎﻟﻪ اﻟﺜﺎﻧﻴﻪ ﻓﺘﻨﺘﻘﻞ اﻟﻘﻴﻤﻪ ﻣﻦ داﺧﻞ اﻷﺟﺮاء اﻟﻰ اﻟﻤﺘﻐﻴﺮ ﻓﻲ رأس اﻷﺟﺮاء ﺛﻢ ﻣﻨﻪ ﺗﺴﻨﺪ‬
‫اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻳﻘﺎﺑﻠﻪ ﻓﻲ أﻣﺮ اﻷﺳﺘﺪﻋﺎء وﺣﺴﺐ اﻟﺘﺮﺗﻴﺐ أﻳﻀﺎ ‪.‬‬
‫آﺬﻟﻚ ﻳﺠﺐ أن ﺗﺘﻄﺎﺑﻖ اﻷﻧﻮاع ﺑﻴﻦ اﻟﻤﺘﻐﻴﺮات ﻓﻲ أﻣﺮ اﻷﺳﺘﺪﻋﺎء وﺗﻠﻚ ﻓﻲ رأس اﻷﺟﺮاء وآﻞ‬
‫واﺣﺪ وﻣﺎ ﻳﻘﺎﺑﻠﻪ ‪.‬‬
‫‪72‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪Program CH5_Program5‬‬
‫‪Var‬‬
‫;‪X:integer‬‬

‫;)‪Procedure Change ( var y:integer‬‬


‫‪Begin‬‬
‫;‪y:=1‬‬
‫;‪End‬‬ ‫}‪{change‬‬

‫‪Begin‬‬
‫;‪X: =0‬‬
‫;)‪Change(x‬‬
‫;)‪Write ('x=', x‬‬
‫‪End.‬‬ ‫}‪{Main program‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//: 5‬‬


‫‪X=1‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 5‬‬

‫هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻓﻴﻪ ﻣﺘﻐﻴﺮ ﻋﺎم ﻳﺪﻋﻰ ) ‪ ( x‬ووﺳﻴﻂ ﻣﺮﺟﻌﻲ ﻳﺪﻋﻰ ) ‪ ( y‬آﺘﺒﻨﺎ هﻨﺎ اﻟﻤﺘﻐﻴﺮ ) ‪( y‬‬
‫ﻓﻘﻂ ﻟﺘﺠﻨ ﺐ اﻷﺷ ﺘﺒﺎﻩ واﻟﺤﻘﻴﻘ ﻪ ه ﻮ أن اﻟﺒﺮﻧ ﺎﻣﺞ ﺳ ﻴﻌﻤﻞ ﺑ ﻨﻔﺲ اﻟﻄﺮﻳﻘ ﻪ ﻟ ﻮ أﺳ ﺘﺒﺪﻟﻨﺎ ) ‪ ( y‬وأﻳﻨﻤ ﺎ ﺗ ﺮد‬
‫) ‪ ( y‬ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ﺑﺎﻟﻤﺘﻐﻴﺮ) ‪. ( x‬‬
‫وﻟﻤﺎ آﺎﻧﺖ ) ‪ ( y‬ﻓﻲ رأس اﻷﺟﺮاء ﻣ ﺴﺒﻮﻗﻪ ﺑ ﺎﻷﻣﺮ ) ‪ ( var‬ﻓﻬ ﺬا ﻳﻌﻨ ﻲ أﻧﻬ ﺎ ﻣﺘﻐﻴ ﺮ وﺳ ﺘﻨﺘﻘﻞ‬
‫اﻟﻘﻴﻤﺔ اﻟﻤﻘﺎﺑﻠﻪ ﻣﻦ داﺧﻞ اﻷﺟﺮاء اﻟﻴﻬﺎ )ﻋﻨﺪ أﺳ ﺘﺪﻋﺎء اﻷﺟ ﺮاء وﺗﻨﻔﻴ ﺬﻩ ( ‪ ,‬ﺛ ﻢ ﻣﻨﻬ ﺎ اﻟ ﻰ أﻣ ﺮ اﻷﺳ ﺘﺪﻋﺎء‬
‫) أي ﻣﻦ ‪ y‬اﻟﻰ ‪. ( x‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻋﻨﻤﺎ ﺗﻜﻮن اﻟﻮﺳﺎﺋﻂ ﻣﺘﻐﻴﺮات ) أي ﻣﺴﺒﻮﻗﻪ ﺑﺎﻷﻣﺮ ‪ ( var‬ﻓﻲ رأس اﻷﺟﺮاء ﻓﺄن اﻟﻤﺘﻐﻴﺮات‬
‫اﻟﻤﻘﺎﺑﻠﻪ ﻓﻲ أﻣﺮ اﻷﺳﺘﺪﻋﺎء ﻳﺠﺐ أن ﺗﻜﻮن ﻣﺘﻐﻴﺮات وﻟﻴﺲ ﺗﻌﺎﺑﻴﺮ ) ‪ ( expression‬ﻓﻤﺜﻼ‬
‫اﻷﺳﺘﺪﻋﺎء ) )‪ ( change ( 2*x‬ﻏﻴﺮ ﻣﻘﺒﻮل ﻷﻧﻪ ﻳﺴﺘﺨﺪم اﻟﺘﻌﺒﻴﺮ ) ‪ ( 2*x‬وآﺬﻟﻚ اﻷﺳﺘﺪﻋﺎء‬
‫) ) ‪ ( change ( 2‬أﻳﻀﺎ ﻏﻴﺮ ﻣﻘﺒﻮل ﻷﻧﻪ ﻳﺴﺘﺨﺪم ﺛﺎﺑﺖ ) اﻟﻤﻔﺮوض أن ﻳﻜﻮن ﻣﺘﻐﻴﺮ ( ‪.‬‬
‫‪73‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‪Program CH5_Program6‬‬
‫‪Var‬‬
‫;‪X:integer‬‬

‫;)‪Procedure Change(y: integer‬‬


‫‪Begin‬‬
‫;‪y:=1‬‬
‫;‪End‬‬ ‫}‪{change‬‬

‫‪Begin‬‬
‫;‪X: =0‬‬
‫;)‪Change (x‬‬
‫;)‪Write(x‬‬
‫‪End.‬‬ ‫}‪{Main program‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬


‫‪X=0‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 6‬‬

‫ﻣﺮة أﺧﺮى ‪ ,‬ﻟﺪﻳﻨﺎ ﻣﺘﻐﻴﺮ ﻋﺎم ) ‪ ( x‬ووﺳﻴﻂ ) ‪ . ( y‬ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﻪ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻮﺳ ﻴﻂ ﻏﻴ ﺮ‬
‫ﻣﺴﺒﻮق ﺑﺎﻷﻣﺮ ) ‪ ( var‬وﻟﺬﻟﻚ ﻓﺄن هﺬا اﻟﻮﺳﻴﻂ ﻳﺪﻋﻰ وﺳﻴﻂ ﻗﻴﻤﻪ ‪.‬‬
‫ﻋﻨﺪ أﺳﺘﺪﻋﺎء اﻷﺟﺮاء ﻓ ﺄن اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( x‬ﻳﻤ ﺮر اﻟ ﻰ اﻷﺟ ﺮاء ﻓﻴﻜ ﻮن ) ‪ ( y : = x‬ﻗﺒ ﻞ أن ﻳ ﺘﻢ‬
‫ﺗﻨﻔﻴ ﺬ أي ﻋﺒ ﺎرﻩ ﻣ ﻦ اﻷﺟ ﺮاء ‪ .‬وﻟﻜ ﻦ ﺑﻌ ﺪ اﻟ ﺪﺧﻮل ﻓ ﻲ اﻷﺟ ﺮاء ﻓ ﺴﻮف ﻻﺗﻜ ﻮن هﻨ ﺎك أي ﻋﻼﻗ ﻪ ﺑ ﻴﻦ‬
‫اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( x‬واﻟﻤﺘﻐﻴ ﺮ ) ‪ , ( y‬ﻋﻠﻴ ﻪ ﻓ ﺄن اﻟﺘﻐﻴﻴﺮاﻟ ﺬي ﻳﻄ ﺮأ ﻋﻠ ﻰ ) ‪ ( y‬ﺳ ﻮف ﻻﻳ ﺆﺛﺮﻋﻠﻰ اﻟﻤﺘﻐﻴ ﺮ‬
‫)‪.(x‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﻟﻮﺳﻴﻂ وﺳﻴﻂ ﻗﻴﻤﻪ ﻓﻤﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام اﻟﺘﻌﺎﺑﻴﺮ ﻣﺜﻞ‬
‫) ) ‪ ( change ( x*2 ) OR change ( 2‬ﻷن ﻓﻲ اﻟﺤﺎﻟﻪ اﻷوﻟﻰ ﺳﺘﻜﻮن هﻨﺎك ﻋﻤﻠﻴﺔ‬
‫أﺳﻨﺎد ﺿﻤﻨﻴﻪ ) ‪ ( y : = 2 * x‬وآﺬﻟﻚ ﻓﻲ اﻟﺤﺎﻟﻪ اﻟﺜﺎﻧﻴﻪ ) ‪ , ( y : = 2‬وﻗﺒﻞ ﺗﻨﻔﻴﺬ أي ﻋﺒﺎرﻩ‬
‫ﻣﻦ ﻋﺒﺎرات اﻷﺟﺮاء ‪.‬‬

‫ﻣﺜﺎل ‪ :‬ﻧﻔﺮض أﻧﻨﺎ ﻧﺮﻏﺐ ﺑﺄﺑﺪال ﻗﻴﻢ ﻣﺘﻐﻴﺮﻳﻦ ﺑﺤﻴﺚ ﺗﻜﻮن آﻞ واﺣﺪﻩ ﻓﻲ ﻣﻜﺎن اﻷﺧﺮى‬
74 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

Program CH5_Program7;
Var
X,y:integer;

Procedure swap ( x,y:integer);


Var
T:integer;
Begin
T: =x; x: =y;
Y: =t;
Writeln ('x=', x,'y=', y);
End;

Begin
X: =3;
Y: =42;
Swap(x, y);
Writeln ( 'x= ', x,' y= ', y);
End.

//: 7 ‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ‬


X = 42 y=3
X=3 y = 42

‫ ( ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﺑﻴﻨﻤﺎ ﺗﻐﻴﺮت ﻓﻲ اﻷﺟﺮاء‬x, y ) ‫ﻟﻢ ﺗﺘﻐﻴﺮ ﻗﻴﻢ‬


( ‫)ﺗﻤﺮﻳﺮ وﺳﻴﻄﺔ ﻗﻴﻤﻪ‬

Program CH5_Program8;
Var
X,y:integer;

Procedure swap ( var x,y:integer);


Var
T:integer;
Begin
T:=x; x:=y;
Y: =t;
Writeln ( 'x= ', x,' y= ', y);
End;

Begin
X: =3;
Y: =42;
Swap(x, y);
Writeln ( 'x= ', x,' y= ', y);
End.
‫‪75‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪X = 42‬‬ ‫‪y=3‬‬
‫‪X = 42‬‬ ‫‪y=3‬‬
‫ﺗﻐﻴﺮ ﻗﻴﻤﺘﻲ ) ‪ ( x, y‬ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ واﻷﺟﺮاء‪.‬‬

‫اﻟﺪوال ‪FUNCTIONS‬‬ ‫‪5.3‬‬

‫أن اﻟﻔﺮق اﻟﺮﺋﻴﺲ ﺑﻴﻦ اﻷﺟﺮاءات واﻟﺪوال هﻮ أن اﻟﺪوال ﻳﺠﺐ أن ﺗﻌﻴﺪ ﻗﻴﻤ ﻪ ﻋﻨ ﺪ ﺗﻨﻔﻴ ﺬهﺎ ﺑﻴﻨﻤ ﺎ‬
‫اﻷﺟﺮاءات ﻻﺗﻌﻴﺪ ﻗﻴﻤ ﻪ ‪ .‬ﺗﺒ ﺪأ اﻟ ﺪوال وﺗﻨﺘﻬ ﻲ ﺑ ﻨﻔﺲ اﻟﻄﺮﻳﻘ ﻪ اﻟﺘ ﻲ ﺗﺒ ﺪأ وﺗﻨﺘﻬ ﻲ ﻓﻴﻬ ﺎ اﻷﺟ ﺮاءات ‪ .‬أﻣ ﺎ‬
‫اﻟﻘﻴﻤﻪ اﻟﻤﻌﺎدﻩ ﻓﻲ اﻟﺪوال ﻓﺘﻌﺎد ﺑﺄﺳ ﻢ اﻟﺪاﻟ ﻪ ‪ ,‬وه ﺬا ﻳﻌﻨ ﻲ أن أﺳ ﻢ اﻟﺪاﻟ ﻪ ﺳ ﻴﻜﻮن ﻣﺘﻐﻴ ﺮ ﻳﺤﻤ ﻞ ﻗﻴﻤ ﻪ ه ﺬﻩ‬
‫اﻟﻘﻴﻤﻪ هﻲ اﻟﻘﻴﻤﻪ اﻟﻨﺎﺗﺠﻪ ﻣﻦ ﺗﻨﻔﻴﺬ اﻟﺪاﻟﻪ ‪ ,‬وأزاء ذﻟﻚ وﻟﻤﺎ آﺎن أﺳﻢ اﻟﺪاﻟﻪ هﻮ ﻣﺘﻐﻴﺮ أذن ﻳﺠﺐ أن ﻳﻜ ﻮن‬
‫ﻟﻪ ﻧﻮع ‪ ...‬ﻋﻠﻴﻪ داﺋﻤﺎ ﺳﻨﻼﺣﻆ أﺳﻢ اﻟﺪاﻟﻪ ﻣﺘﺒﻮع ﺑﻨﻮﻋﻪ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻠﺪاﻟﻪ هﻲ ‪:‬‬

‫; ‪Function < function name > : type‬‬


‫‪OR‬‬
‫; ‪Function < function name > ( Arguments ) : type‬‬

‫ﻣﺜﺎل ‪ :‬ﻓﻲ هﺬا اﻟﻤﺜﺎل ﺳﻨﻌﻴﺪ آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ) ‪ ( 3‬وﻟﻜﻦ ﻣﻊ أﺳﺘﺨﺪام اﻟﺪوال‬

‫;‪Program CH5_Program9‬‬
‫‪Var‬‬
‫;‪Y: longint‬‬

‫;‪Function power (m: integer): longint‬‬


‫‪Var‬‬
‫;‪I:integer‬‬
‫;‪P:longint‬‬
‫‪Begin‬‬
‫;‪P: =1‬‬
‫‪For i: =1 to m do‬‬
‫;‪P: =p*m‬‬
‫;‪Power: =p‬‬
‫;‪End‬‬ ‫}‪{end function‬‬

‫‪Begin‬‬ ‫}‪{main program‬‬


‫;)‪Y: = power (10) + power (8) + power (6) + power (4‬‬
‫;)‪Writeln(y‬‬
‫;‪Readln‬‬
‫‪End.‬‬
‫‪76‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬

‫آﻞ اﻟﺪوال واﻷﺟﺮاءات ﺗﻜﺘﺐ ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( var‬ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪,‬‬ ‫‪.1‬‬
‫وﻟﻴﺲ ﻗﺒﻠﻪ ‪.‬‬
‫أن أﺳﺘﺪﻋﺎء اﻟﺪوال واﻷﺟﺮاءات ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻏﻴﺮ ﻣﺤﺪدﻩ ﺑﺘﺮﺗﻴﺐ‬ ‫‪.2‬‬
‫هﺬﻩ اﻟﺪوال أو اﻷﺟﺮاءات ‪.‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﺘﺪاﺧﻞ اﻷﺟﺮاءات أو اﻟﺪوال ) ﺑﺤﻴﺚ ﻳﻤﻜﻦ أن ﺗﺴﺘﺪﻋﻰ‬ ‫‪.3‬‬
‫أﺟﺮاء أو داﻟﻪ ﻣﻦ داﺧﻞ داﻟﻪ أو أﺟﺮاء أﺧﺮ ( ‪.‬‬
‫ﻋﻨﺪ ﺣﺪوث اﻟﺘﺪاﺧﻞ ﻓﻴﺠﺐ ﻣﺮاﻋﺎة اﻟﺘﺮﺗﻴﺐ ﺣﻴﺚ ﻻ ﻳﺠﻮز أﺳﺘﺪﻋﺎء داﻟﻪ أو‬ ‫‪.4‬‬
‫أﺟﺮاء ﻣﻦ داﺧﻞ داﻟﻪ أو أﺟﺮاء أﺧﺮ ﻳﻜﻮن ﺳﺎﺑﻖ ﻟﻪ ﺑﺎﻟﺘﺮﺗﻴﺐ ﻋﻨﺪ آﺘﺎﺑﺔ‬
‫اﻷﺟﺮاءات واﻟﺪوال ) ﻳﺠﺐ أن ﺗﻜﻮن اﻟﻤﺴﺘﺪﻋﺎة ﺳﻠﺒﻘﻪ ( ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬

‫ﻣﺘﻰ ﻧﺴﺘﺨﺪم اﻟﺪاﻟﻪ ﺑﺪل اﻷﺟﺮاء ؟‬


‫اﻟﻘﺎﻋﺪﻩ اﻟﻌﺎﻣﻪ هﻮ أن ﻧﻔﻜﺮ أن اﻟﺪاﻟﻪ آﻬﻴﻜﻞ ﺗﻌﻴﺪ ﻗﻴﻤﻪ واﺣﺪﻩ ﻓﻘﻂ ‪ .‬ﺗﺴﺘﺨﺪم اﻟﺪاﻟﻪ‬
‫ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﻟﻤﻄﻠﻮب ﻗﻴﻤﻪ ﻣﻔﺮدﻩ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪.‬‬
77 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬ 5.4

‫ ﺣﻴﺚ أن‬, ( y ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻗﻴﻤﺔ‬ •

Y = x + x2 / 2! + x3 / 3! + ……..+ xn / n!

Program CH5_Program10;
Var
J, n: integer;
Y: real;

Function power (x, j: integer): integer;


Var
I, p: integer;
Begin
P: =1;
For i: =1 to j do
P: =p*x;
Power: =p;
End;

Function factorial (j:integer):integer;


Var
F,i:integer;
Begin
F: =1;
For i: =j downto 1 do
F: =f*I;
Factorial: =f;
End;

Begin {main program}


Writeln ('Enter number of elements');
Readln (n);
Y: =0;
For j: =1 to n do
Y: =y + power(x, j) / factorial (j);
Writeln(y: 6:4);
End.

.‫ ( ﻋﻨﺼﺮ‬25 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﺮﻗﻢ اﻷآﺒﺮ ﻓﻲ ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ ﺣﺠﻤﻬﺎ‬ •


78 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

Program CH5_Program11;
Const
N=25;
Var
A: array [1..n] of integer;
X: integer;

Procedure readarray;
Var
I: integer;
Begin
For i: =1 to n do
Readln (a[i]);
End;

Procedure findmax (var max: integer);


Var
I: integer;
Begin
Max: =a [1];
For i: =2 to n do
If (a[i] > max) then
Max: =a[i];
End;

Begin {main program}


Readarray;
Findmax(x);
Writeln(x);
End.

. ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﻌﺪد اﻷآﺒﺮ ﺑﻴﻦ ﺛﻼﺛﺔ أﻋﺪاد‬ •

Program CH5_Program12;
Var
T,x,y,z:integer;

Function largest(x, y: integer): integer;


Begin
If x > y then
Largest: =x
Else
Largest: =y;
End;

Begin {main program}


Writeln ('Enter three numbers');
Readln(x, y, z);
T: =largest(x, y);
Writeln (' largest number=', largest (t, z));
End.
79 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﺮﺑﻊ أي ﻋﺪد ) ﺣﻴ ﺚ أن ﻣﺮﺑ ﻊ اﻟﻌ ﺪد ﻳ ﺴﺎوي ﻣﺠﻤ ﻮع ﻋ ﺪد ﻣ ﻦ اﻷﻋ ﺪاد‬ •
‫اﻟﻔﺮدﻳﻪ ) ﻋ ﺪدهﻢ ﺑﻘ ﺪر اﻟﻌ ﺪد اﻟﻤ ﺮاد أﻳﺠ ﺎد ﻣﺮﺑﻌ ﻪ ( أﺑﺘ ﺪاءا ﻣ ﻦ اﻟﻌ ﺪد واﺣ ﺪ ﺻ ﻌﻮدا ( ) ﻣ ﺜﻼ‬
. ( ( 16 ) ‫ ( وﻳﻜﻮن اﻟﻨﺎﺗﺞ‬1+3+5+7 ) ‫ ( هﻮ‬4 ) ‫ﻣﺮﺑﻊ اﻟﻌﺪد‬

Program CH5_Program13;
Var
Y: integer;
Ch: char;

Procedure square (x: integer);


Var
I, sum: integer;
Begin
Sum: =0; i: =1;
Repeat
Sum: = sum + I;
Inc (I, 2);
Dec(x);
Until(x<=0);
Writeln ('Square of number',y,'=',sum);
End;

Begin
Writeln ('Enter number to find its square');
Repeat
Readln(y);
Square(y);
Writeln ('Do you want to enter another number(Y/N)');
Readln (ch):
Until (ch='N');
End.
‫‪80‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻔﺼﻞ اﻟﺴﺎدس‬

‫اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪STRINGS‬‬

‫اﻟﻤﻘﺪﻣﻪ‬ ‫‪6.1‬‬

‫اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ) ‪ ( String‬ه ﻲ ﻋ ﺪد ﻣ ﻦ اﻷﺷ ﻴﺎء ﻓ ﻲ ﺧ ﻂ ‪ ,‬ﻣﺜ ﻞ ﺳﻠ ﺴﻠﻪ دور ‪ ,‬اﻟﺴﻠ ﺴﻠﻪ‬
‫اﻟﺤﺪﻳﺪﻳ ﻪ ) واﻟﺘ ﻲ ه ﻲ ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻟﺤﻠﻘ ﺎت اﻟﻤﺘ ﺼﻠﻪ واﺣ ﺪﻩ ﺑ ﺎﻷﺧﺮى ( ‪ ,‬وآ ﺬﻟﻚ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ‬
‫واﻟﺘﻲ هﻲ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺤﺮوف ‪.‬‬
‫ﻟﻘﺪ ﺗﻌﺮﻓﻨﺎ ﺳﺎﺑﻘﺎ ﻋﻠﻰ ﻣﺎهﻴﺔ ﻣﺘﻐﻴﺮ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ‪ ,‬وﻟﻜ ﻦ ﻣ ﺎﻟﻢ ﻧﺘﻌﻠﻤ ﻪ ﻟﻐﺎﻳ ﺔ اﻷن ه ﻮ ﻣ ﺎهﻲ‬
‫اﻟﻌﻤﻠﻴ ﺎت واﻟ ﺪوال اﻟﺘ ﻲ ﻣﻤﻜ ﻦ أن ﺗﻄﺒ ﻖ ﻋﻠ ﻰ اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ وآﻴﻔﻴ ﺔ اﻟﺘﻌﺎﻣ ﻞ ﻣﻌﻬ ﺎ وﺗﺤﻮﻳﺮه ﺎ‬
‫ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﺳﻼﺳﻞ ﺟﺪﻳﺪﻩ ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻷﺻﻠﻴﻪ ‪.‬‬
‫ﻓﻲ هﺬا اﻟﻔﺼﻞ ﺳﻨﻐﻄﻲ ﺑﻌﺾ اﻟﺪوال اﻟﻤﻬﻤﻪ واﻟﺘﻲ ﺗﻮﻓﺮهﺎ ﻟﻨﺎ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ﺑﺎﺳﻜﺎل ‪.‬‬

‫ﻣﺎهﻲ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ‬ ‫‪6.2‬‬

‫ﻟﻐﺮض اﻟﻔﻬﻢ اﻟﺠﻴﺪ ﻟﻠﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪ ,‬ﻳﺠﺐ أن ﻧﻀﻊ ﻓﻲ أذهﺎﻧﻨﺎ ﺑﺄن اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ‬
‫هﻲ ﻋﺒﺎرﻩ ﻋﻦ ﻣﺼﻔﻮﻓﻪ ﻣﻦ اﻟﺤ ﺮوف ‪ .‬أن ﻧ ﻮع اﻟﺒﻴﺎﻧ ﺎت ﻟﻠ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ه ﻲ ) ﻧ ﻮع ﺑﻴﺎﻧ ﺎت ﻣﺒﻨ ﻲ‬
‫داﺧﻠﻴﺎ ( ﻣﺼﻔﻮﻓﻪ ﻣﻦ ) ‪ 256‬ﺣﺮف ( ‪:‬‬
‫‪Type‬‬
‫; ‪String = array [ 0 .. 255 ] of char‬‬

‫ﻟﻬﺬا اﻟﺴﺒﺐ ﻓﺄن اﻟﻤﺘﻐﻴﺮاﻟﺬي ﻳﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻋﻠﻰ أﻧﻪ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ‬
‫ﻓﺴﻴﺤﺠﺰ ﻟﻪ ) ‪ 256‬ﺑﺎﻳﺖ ( آﻤﺎ ﺳﺒﻖ وﺑﻴﻨﺎ ﻓﻲ اﻟﺠﺪول ) ‪. ( 1.4‬‬
‫أذن أﺻ ﺒﺢ واﺿ ﺢ أن اﻟ ﺬاآﺮﻩ ﺳ ﺘﺤﺠﺰ ) ‪ 256‬ﺑﺎﻳ ﺖ أو ﻣﻮﻗ ﻊ ﻣﺘﺠ ﺎور( ﻟﻤﺘﻐﻴ ﺮ اﻟ ﺴﻼﺳﻞ‬
‫اﻟﺤﺮﻓﻴﻪ ‪ ,‬ﻟﺬﻟﻚ ﻓﺄن اﻟﻤﻌﺎﻟﺞ ﻳﺠ ﺐ أن ﻳﻌ ﺮف ﻣﻮﻗ ﻊ اﻟﺒﺪاﻳ ﻪ ﻟﻠﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ وﻣﻮﻗ ﻊ اﻟﻨﻬﺎﻳ ﻪ أﻳ ﻀﺎ ) أي‬
‫أﻳﻦ ﺗﺒﺪأ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ وأﻳﻦ ﺗﻨﺘﻬﻲ ( ‪ .‬وﻟﻤﺎ آﺎﻧ ﺖ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ﻣ ﺼﻔﻮﻓﻪ ﺣ ﺴﺐ اﻟﺘﻌﺮﻳ ﻒ أﻋ ﻼﻩ‬
‫ﻓ ﺄن ﻣﻮاﻗ ﻊ اﻟﻤ ﺼﻔﻮﻓﻪ ) ‪ ( 1 .. 255‬ﺳ ﺘﺤﺘﻮي ﻋﻠ ﻰ اﻟﺤ ﺮوف اﻟﺘ ﻲ ﺗﺤﺘﻮﻳﻬ ﺎ اﻟﺴﻠ ﺴﻠﻪ وه ﺬا ﻻﻳﻌﻨ ﻲ أن‬
‫ﺗﻜﻮن اﻟﺴﻠﺴﻠﻪ ﺑﻄﻮل ) ‪ ( 255‬ﺣﺮف ﺣﻴﺚ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﻜﻮن أﻗﻞ ﻣ ﻦ ذﻟ ﻚ ﻟﻜ ﻦ اﻟﻄ ﻮل اﻷﻋﻈ ﻢ ﻟﻬ ﺎ‬
‫ه ﻮ ) ‪ . ( 255‬أﻣ ﺎ اﻟﻤﻮﻗ ﻊ ) ‪ ( 0‬ﻓ ﻲ ﻣ ﺼﻔﻮﻓﺔ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ﻓﺄﻧ ﻪ ﺳ ﻴﺤﺘﻮي ﻋﻠ ﻰ ﻃ ﻮل اﻟﺴﻠ ﺴﻠﻪ‬
‫اﻟﺤﺮﻓﻴ ﻪ ) ﻋ ﺪد اﻷﺣ ﺮف ﻓ ﻲ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ( ‪ ,‬وﺑ ﺬﻟﻚ ﺳ ﻴﻜﻮن واﺿ ﺢ ﻟﻠﻤﻌ ﺎﻟﺞ أﻳ ﻦ ﺗﻨﺘﻬ ﻲ اﻟﺴﻠ ﺴﻠﻪ‬
‫اﻟﺤﺮﻓﻴﻪ ﻣﻦ ﺧﻼل ﻗﺮاءة اﻟﻤﻮﻗﻊ ) ‪ ( 0‬ﻓﻲ ﻣﺼﻔﻮﻓﺔ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ‪ .‬ﻣﺜﺎل‬

‫;‪Program CH6_Program1‬‬
‫‪Var‬‬
‫;‪St: string‬‬
‫‪Begin‬‬
‫;' ‪St: = ' computer‬‬
‫;)]‪Writeln (st [2‬‬
‫;)]‪Writeln (st [5‬‬
‫‪End.‬‬
‫‪81‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪c‬‬
‫‪p‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼﻩ ﺗﻢ ﺣﺴﺎب اﻟﻔﺮاﻏﻴﻦ اﻟﻤﻮﺟﻮدﻳﻦ ﻗﺒﻞ وﺑﻌﺪ ) ‪ ( computer‬ﻋﻠﻰ أﻧﻬﻤﺎ‬
‫ﺣﺮوف ‪ ,‬ﻟﺬا داﺋﻤﺎ ﺗﺤﺴﺐ اﻟﻔﺮاﻏﺎت ﻋﻠﻰ أﻧﻬﺎ ﺣﺮوف وﻓﻲ أي ﻣﻮﻗﻊ ﺗﺮد ﻓﻲ اﻟﺴﻠﺴﻠﻪ‬
‫اﻟﺤﺮﻓﻴﻪ ‪.‬‬

‫ﻓﻲ هﺬا اﻟﻤﺜﺎل ﺗ ﻢ اﻟﺘﻌﺎﻣ ﻞ ﻣ ﻊ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ﻋﻠ ﻰ أﻧﻬ ﺎ ﻣ ﺼﻔﻮﻓﻪ دون اﻟﺤﺎﺟ ﻪ اﻟ ﻰ ﺗﻌﺮﻳﻔﻬ ﺎ‬
‫آﻤﺼﻔﻮﻓﻪ ﻷﻧﻬﺎ ﻣﻌﺮﻓﻪ داﺧﻞ اﻟﺤﺎﺳﺐ آﻤﺼﻔﻮﻓﻪ آﻤﺎ ﺑﻴﻨﺎ ‪.‬‬

‫اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ‬ ‫‪6.3‬‬

‫هﻨ ﺎك ﺑﻌ ﺾ اﻟ ﺪوال اﻟﻤﺨﺰوﻧ ﻪ ﻣ ﻊ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل واﻟﺘ ﻲ ﺗ ﺴﺎﻋﺪ ﻋﻠ ﻰ أﺟ ﺮاء ﺑﻌ ﺾ‬


‫اﻟﻌﻤﻠﻴﺎت ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ دون اﻟﺤﺎﺟﻪ اﻟﻰ أﻋﺎدة آﺘﺎﺑﺘﻬﺎ وﻳﻜﻔﻲ أﺳ ﺘﺪﻋﺎﺋﻬﺎ ﺑﺄﺳ ﻤﻬﺎ ﻟﺘﻘ ﻮم ﺑﺎﻟﻌﻤ ﻞ‬
‫اﻟﻤﺤﺪد ﻟﻬﺎ ‪ .‬ﻣﻦ هﺬﻩ اﻟﺪوال ‪:‬‬

‫‪ 6.3.1‬ﺗﺤﺪﻳﺪ اﻟﻤﻮﻗﻊ ‪POS‬‬

‫ﻧﺤﺘﺎج أﺣﻴﺎﻧﺎ اﻟﻰ ﺗﺤﺪﻳﺪ ﻣﻮﻗﻊ ﺣﺮف أو ﻣﺠﻤﻮﻋﺔ ﺣﺮوف داﺧﻞ ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ‪ ,‬وﻟﺘﺤﻘﻴ ﻖ ذﻟ ﻚ‬
‫ﻧ ﺴﺘﺨﺪم اﻟﺪاﻟ ﻪ ) ‪ ( Pos‬واﻟﺘ ﻲ ﺳ ﺘﻘﻮم ﺑﺎﻟﺒﺤ ﺚ ﻋ ﻦ ) اﻟﺤ ﺮف أو ﻣﺠﻤﻮﻋ ﺔ اﻟﺤ ﺮوف واﻟﺘ ﻲ ﺗﻌﺘﺒ ﺮ‬
‫ﻣﺠﻤﻮﻋ ﻪ ﺟﺰﺋﻴ ﻪ ﻣ ﻦ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ( داﺧ ﻞ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ‪ ,‬ﻓ ﺎذا ﻟ ﻢ ﻳ ﺘﻢ أﻳﺠ ﺎد اﻟﺴﻠ ﺴﻠﻪ اﻟﺠﺰﺋﻴ ﻪ‬
‫ﺿﻤﻦ اﻟﺴﻠﺴﻠﻪ اﻷﺻﻠﻴﻪ ﻓﺄﻧﻬﺎ ﺗﻌﻴﺪ اﻟﻘﻴﻤﻪ ) ‪ ( 0‬أﻣﺎ أذا وﺟﺪﺗ ﻪ ﻓﺄﻧﻬ ﺎ ﺳ ﺘﻌﻴﺪ اﻟ ﺮﻗﻢ اﻟ ﺬي ﻳﺤ ﺪد ﻣﻮﻗ ﻊ أول‬
‫ﺣﺮف ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻟﺠﺰﺋﻴﻪ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬

‫; ) ‪N : = Pos ( st , stn‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪ : N‬ﺗﻤﺜﻞ اﻟﻘﻴﻤﻪ اﻟﺘﻲ ﺳﺘﻌﻴﺪهﺎ اﻟﺪاﻟﻪ‪.‬‬
‫‪ : st‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺘﻲ ﻧﺒﺤﺚ ﻋﻨﻬﺎ‪.‬‬
‫‪ : stn‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺘﻲ ﻧﺒﺤﺚ ﻓﻴﻬﺎ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬
‫‪82‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫; ‪Program CH6_Program2‬‬
‫‪Var‬‬
‫;‪N, x: integer‬‬
‫;‪Stn, st1, st2: string‬‬
‫‪Begin‬‬
‫;'‪Stn: = 'System Software‬‬
‫;'‪St1: = 'Soft‬‬
‫;'‪St2: = 'system‬‬
‫;)‪N: = Pos (st1, stn‬‬
‫;)‪X: = Pos (st2, stn‬‬
‫;)‪Writeln (n,' ****** ', x‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪8 ****** 0‬‬

‫ﻻﺣﻆ أن ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﺗﺴﺎوي ) ‪ ( 0‬وذﻟ ﻚ ﻷن اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ اﻟﺘ ﻲ ﻧﺒﺤ ﺚ ﻋﻨﻬ ﺎ ه ﻲ‬
‫) ‪ ( system‬ﺗﺒ ﺪأ ﺑﺤ ﺮف ﺻ ﻐﻴﺮ ﺑﻴﻨﻤ ﺎ اﻟﻜﻠﻤ ﻪ اﻟﻤﻘﺎﺑﻠ ﻪ ﻓ ﻲ ) ‪ ( System ) ( stn‬ﺗﺒ ﺪأ ﺑﺤ ﺮف آﺒﻴ ﺮ‬
‫وﺑﺬﻟﻚ أﺻﺒﺢ أﺧﺘﻼف ﺑﻴﻦ اﻟﻜﻠﻤﺘﻴﻦ ﻟﺬﻟﻚ ﻋﻤﻠﻴﺔ اﻟﺒﺤ ﺚ ﺳ ﻮف ﻻﺗﺠ ﺪ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﻠﺮﻓﻴ ﻪ اﻟﻤﻄﻠﻮﺑ ﻪ ‪ ,‬أذن‬
‫ﺗﻌﻴﺪ اﻟﻘﻴﻤﻪ ) ‪. ( 0‬‬

‫‪ 6.3.2‬اﻷﺳﺘﻨﺴﺎخ ‪COPY‬‬

‫هﺬﻩ اﻟﺪاﻟﻪ ﺳﺘﻘﻮم ﺑﺄﺳﺘﻨﺴﺎخ ﺣﺮف أو ﻣﺠﻤﻮﻋﺔ ﺣﺮوف ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﺤ ﺪدﻩ ‪ ,‬أﻋﺘﺒ ﺎرا‬
‫ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﻤﺤﺪد ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم وﺣﺴﺐ ﻋﺪد اﻟﺤﺮوف اﻟﺘﻲ ﺣﺪدهﺎ اﻟﻤ ﺴﺘﺨﺪم ‪ ,‬وﺳ ﺘﻌﻴﺪ ه ﺬﻩ اﻟﺪاﻟ ﻪ‬
‫ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺟﺰﺋﻴﻪ وهﻲ اﻟﺘﻲ ﺣﺪدهﺎ اﻟﻤﺴﺘﺨﺪم ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬

‫; ) ‪St : = Copy ( stn , Position , count‬‬

‫ﺣﻴﺚ أن ‪:‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﺘﻲ ﺳﺘﻌﻴﺪهﺎ اﻟﺪاﻟﻪ‪.‬‬ ‫‪St‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب اﻷﺳﺘﻨﺴﺎخ ﻣﻨﻬﺎ‪.‬‬ ‫‪Stn‬‬
‫‪ :‬رﻗﻢ ﻳﻤﺜﻞ ﻣﻮﻗﻊ ﺑﺪاﻳﺔ اﻟﺴﻠﺴﻠﻪ اﻟﻤﻄﻠﻮب أﺳﺘﻨﺴﺎﺧﻬﺎ‪.‬‬ ‫‪Position‬‬
‫‪ :‬رﻗﻢ ﻳﻤﺜﻞ ﻋﺪد اﻷﺣﺮف اﻟﻤﻄﻠﻮب أﺳﺘﻨﺴﺎﺧﻬﺎ‪.‬‬ ‫‪Count‬‬
‫ﻣﺜﺎل ‪:‬‬
‫‪83‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‪Program CH6_Program3‬‬
‫‪Var‬‬
‫;‪Stn, st1, st2: string‬‬
‫‪Begin‬‬
‫;'‪Stn:= 'computer science‬‬
‫;)‪St1:= copy (stn, 2, 4‬‬
‫;)‪St2:= copy (stn, 12, 20‬‬
‫;)‪Writeln ( st1,' ****** ', st2‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪ompu ****** ience‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻻﺣﻆ أن اﻟﻤﺘﻐﻴﺮ ) ‪ ( st2‬آﺎن ﻣﻦ اﻟﻤﻔﺮوض أن ﻳﺴﺘﻨﺴﺦ ﻓﻴﻪ ) ‪ ( 20‬ﺣﺮف أﺑﺘﺪاءا ﻣﻦ‬


‫اﻟﺤﺮف رﻗﻢ ) ‪ ( 12‬وﻧﻈﺮا اﻟﻰ أن اﻟﺴﻠﺴﻠﻪ ﺗﻨﺘﻬﻲ ﻗﺒﻞ ﺗﺤﻘﻖ هﺬا اﻟﺸﺮط ﻓﺄﻧﻪ ﺳﻴﻜﺘﻔﻲ‬
‫ﺑﺎﻟﻤﺘﺒﻘﻲ ﻣﻦ اﻟﺤﺮوف ‪.‬‬

‫‪ 6.3.3‬اﻟﺤﺬف ‪DELETE‬‬

‫داﻟ ﺔ اﻟﺤ ﺬف ﺗ ﺴﺘﺨﺪم ﻟﺤ ﺬف ﺣ ﺮف أو ﻋ ﺪد ﻣ ﻦ اﻟﺤ ﺮوف ﻣ ﻦ ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ﻣﻌﻴﻨ ﻪ ‪ ,‬وﺑﻌ ﺪ‬


‫اﻟﺤﺬف ﻳﻌﻴﺪ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ اﻟﺠﺪﻳ ﺪﻩ وﺑ ﻨﻔﺲ ﻣﺘﻐﻴ ﺮ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ اﻷﺻ ﻠﻴﻪ ‪ ,‬أن اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺒ ﺪأ‬
‫ﻣﻨﻪ اﻟﺤﺬف وﻋﺪد اﻟﺤﺮوف اﻟﻤﻄﻠﻮب ﺣﺬﻓﻬﺎ ﺗﺤﺪد ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬

‫; ) ‪Delete (stn, Position, Count‬‬


‫ﺣﻴﺚ أن ‪:‬‬
‫‪ :‬اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب اﻟﺤﺬف ﻣﻨﻬﺎ‪.‬‬ ‫‪Stn‬‬
‫‪ :‬رﻗﻢ ﻳﻤﺜﻞ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺒﺪأ اﻟﺤﺬف ﻣﻨﻪ‪.‬‬ ‫‪Position‬‬
‫‪ :‬رﻗﻢ ﻳﻤﺜﻞ ﻋﺪد اﻟﺤﺮوف اﻟﻤﻄﻠﻮب ﺣﺬﻓﻬﻢ‪.‬‬ ‫‪Count‬‬
‫ﻣﺜﺎل ‪:‬‬
‫‪84‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‪Program CH6_Program4‬‬
‫‪Var‬‬
‫;‪Stn: string‬‬
‫‪Begin‬‬
‫;'‪Stn: ='System Software‬‬
‫;)‪Delete (stn, 8, 3‬‬
‫;)‪Writeln (stn‬‬
‫;)‪Delete (stn, 7, 15‬‬
‫;)‪Writeln (stn‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪System tware‬‬
‫‪System‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻓﻲ أﻣﺮ اﻟﺤﺬف اﻟﺜﺎﻧﻲ آﺎن اﻟﻤﻄﻠﻮب ﺣﺬف ) ‪ ( 15‬ﺣﺮف اﺑﺘﺪاءا ﻣﻦ اﻟﻤﻮﻗﻊ ) ‪ ( 7‬وﻧﻈﺮا‬
‫ﻟﻌﺪم وﺟﻮد ) ‪ ( 15‬ﺣﺮف ﺑﻌﺪ اﻟﺤﺮف اﻟﺴﺎﺑﻊ ﻟﺬا ﺳﻴﺘﻢ ﺣﺬف اﻟﻤﺘﺒﻘﻲ ﻣﻦ اﻟﺤﺮوف ﻓﻘﻂ ‪.‬‬

‫‪ 6.3.4‬اﻟﺤﺸﺮ ‪INSERT‬‬

‫ﺗﻌﻤ ﻞ ه ﺬﻩ اﻟﺪاﻟ ﻪ ﻋﻠ ﻰ ﺣ ﺸﺮ ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ﺑ ﺄي ﻃ ﻮل داﺧ ﻞ ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ أﺧ ﺮى ﺑ ﺪءا ﻣ ﻦ‬


‫اﻟﻤﻮﻗﻊ اﻟﻤﺤﺪد ﻣﻦ اﻟﻤﺴﺘﺨﺪم ) ﻣﻮﻗﻊ اﻟﺤﺮف ﻓﻲ اﻟﺴﻠﺴﻠﻪ اﻟﻤﺼﺪر اﻟﺬي ﺳﻴﺘﻢ اﻟﺤ ﺸﺮ ﺑﻌ ﺪﻩ ( ‪ .‬ﺳ ﻮف ﻻ‬
‫ﻳﺘﻢ ﺣﺬف أي ﻣﻦ اﻟﺤﺮوف ﻣﻦ اﻷﻣﺎم ﻋﺪا أذا آ ﺎن ﻃ ﻮل اﻟﺴﻠ ﺴﻠﻪ اﻟﻨﺎﺗﺠ ﻪ أآﺒ ﺮ ﻣ ﻦ ) ‪ ( 255‬ﻓﻌﻨ ﺪ ذﻟ ﻚ‬
‫ﺳﺘﺤﺬف اﻟﺤﺮوف اﻟﺰاﺋﺪﻩ ﻋﻦ هﺬا اﻟﻌﺪد ﻣﻦ اﻷﻣﺎم ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬

‫; ) ‪Insert ( st , stn , Position‬‬


‫ﺣﻴﺚ أن ‪:‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻷﺻﻠﻴﻪ اﻟﺘﻲ ﺳﻴﺤﺸﺮ ﻓﻴﻬﺎ‪.‬‬ ‫‪stn‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب ﺣﺸﺮهﺎ‪.‬‬ ‫‪st‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﻤﻮﻗﻊ اﻟﺬي ﺳﺘﺤﺸﺮ ﻓﻴﻪ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ‪.‬‬ ‫‪Position‬‬
‫‪85‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪Program CH6_Program5‬‬
‫‪Var‬‬
‫;‪S: String‬‬

‫‪Begin‬‬
‫'?‪S: = 'Hey! How are you‬‬
‫;))‪Write (Insert (' Ali', s, 4‬‬
‫;)‪Writeln(s‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫'?‪'Hey Ali! How are you‬‬

‫‪ 6.3.5‬دﻣﺞ ﺳﻠﺴﻠﺘﺎن ﺣﺮﻓﻴﺘﺎن ‪CONCAT‬‬

‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪاﻟﻪ ﻟﺪﻣﺞ ﺳﻠﺴﻠﺘﻴﻦ ﺣﺮﻓﻴﺘﻴﻦ أو أآﺜﺮﺑﺴﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ واﺣﺪﻩ‪.‬‬


‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬

‫; )… ‪Stn : = Concat ( st1, st2, st3,‬‬


‫ﺣﻴﺚ أن ‪:‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﻨﺎﺗﺠﻪ ﻣﻦ اﻟﺪﻣﺞ‪.‬‬ ‫‪Stn‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻼﺳﻞ اﻟﺘﻲ ﺳﻴﺘﻢ دﻣﺠﻬﺎ‪.‬‬ ‫‪st1, st2, st3‬‬
‫ﻣﺜﺎل ‪:‬‬

‫;‪Program CH6_Program6‬‬
‫‪Var‬‬
‫;‪Stn, st1, st2: string‬‬
‫‪Begin‬‬
‫;'‪St1:='info‬‬
‫;'‪St2:='rmation‬‬
‫;)‪Stn: =concat (st1, st2‬‬
‫;)‪Writeln (stn‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪information‬‬
‫‪86‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻣﻤﻜﻦ اﻷﺳﺘﻌﺎﺿﻪ ﻋﻦ اﻟﺪاﻟﻪ ) ‪ ( concat‬ﺑﻌﻼﻣﺔ اﻟﺠﻤﻊ ) ‪. ( +‬‬

‫ﻳﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ﻟﻴﻜﻮن ‪:‬‬

‫;‪Program CH6_Program7‬‬
‫‪Var‬‬
‫;‪Stn, st1, st2: string‬‬
‫‪Begin‬‬
‫;'‪St1:='Bag‬‬
‫;'‪St2:='hdad‬‬
‫;‪Stn: = st1 + st2‬‬
‫;)‪Writeln (stn‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪Baghdad‬‬

‫‪ 6.3.6‬ﺣﺴﺎب ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ‪LENGTH‬‬

‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪاﻟﻪ ﻟﺤﺴﺎب ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ‪.‬‬


‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬

‫; ) ‪N : = Length ( st‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪ :‬ﻳﻤﺜﻞ ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ‪.‬‬ ‫‪N‬‬
‫‪ :‬ﻳﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب أﻳﺠﺎد ﻃﻮﻟﻬﺎ‪.‬‬ ‫‪St‬‬
‫ﻣﺜﺎل ‪:‬‬

‫;‪Program CH6_Program8‬‬
‫‪Var‬‬
‫;‪St: string‬‬
‫;‪N: integer‬‬
‫‪Begin‬‬
‫;'‪St: ='Data Structure‬‬
‫;)‪N: =Length (st‬‬
‫;)‪Write (n‬‬
‫‪End.‬‬
‫‪87‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪14‬‬

‫‪ 6.3.7‬ﺗﺤﻮﻳﻞ اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ اﻟﻰ ﺣﺮوف آﺒﻴﺮﻩ ‪UPCASE‬‬

‫ﺗﻌﻤﻞ هﺬﻩ اﻟﺪاﻟﻪ ﻋﻠﻰ ﺗﺤﻮﻳﻞ اﻟﺤﺮوف اﻟ ﺼﻐﻴﺮﻩ اﻟ ﻰ ﺣ ﺮوف آﺒﻴ ﺮﻩ ‪ ,‬ﺗﺤ ﻮل ﺣ ﺮف واﺣ ﺪ آ ﻞ‬
‫ﻣﺮﻩ ‪ .‬أﻣﺎ أذا آﺎﻧﺖ اﻟﺤﺮوف هﻲ أﺻﻼ آﺒﻴﺮﻩ أو آﺎﻧﺖ ﺧﺎرج ﻧﻄﺎق ﻣﻔﻬﻮم اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ ﻓ ﺴﺘﺘﺮك‬
‫ﻋﻠﻰ ﺣﺎﻟﻬﺎ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬

‫; )‪C : = UpCase (c‬‬


‫ﺣﻴﺚ أن ‪:‬‬
‫‪ : C‬اﻟﺤﺮف اﻟﻨﺎﺗﺞ وهﻮ ﻣﻦ اﻟﺤﺮوف اﻟﻜﺒﻴﺮﻩ‪.‬‬
‫‪ : c‬اﻟﺤﺮف اﻟﻤﻄﻠﻮب ﺗﺤﻮﻳﻠﻪ اﻟﻰ ﺣﺮف آﺒﻴﺮ وهﻮ ﻣﻦ اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫;‪Program CH6_Program9‬‬
‫‪Var‬‬
‫;‪S: String‬‬
‫;‪i: Integer‬‬

‫‪Begin‬‬
‫;'?‪S: = 'Hey! How are you‬‬
‫‪For i: = 1 to length(S) do‬‬
‫;)]‪S[i]:= UpCase(S[i‬‬
‫;)‪Write(S‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫?‪HEY! HOW ARE YOU‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻟﺘﺤﻮﻳﻞ اﻷﺣﺮف اﻟﻜﺒﻴﺮﻩ اﻟﻰ أﺣﺮف ﺻﻐﻴﺮﻩ ﻧﺘﺒﻊ اﻟﻌﻼﻗﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬
‫; ) ‪S[i] : = chr ( ord ( s[i] + 32‬‬
‫‪88‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪ 6.3.8‬ﺗﺤﻮﻳﻞ اﻟﻘﻴﻢ اﻟﺮﻗﻤﻴﻪ اﻟﻰ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪STR‬‬

‫ﺗﻌﻤﻞ ه ﺬﻩ اﻟﺪاﻟ ﻪ ﻋﻠ ﻰ ﺗﺤﻮﻳ ﻞ اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ﻓﻘ ﻂ اﻟ ﻰ ﺳﻼﺳ ﻞ ﺣﺮﻓﻴ ﻪ ‪ .‬أﻣ ﺎ أذا أﺳ ﺘﺨﺪﻣﻨﺎ‬
‫أرﻗﺎم آﺴﺮﻳﻪ ﻓﺴﺘﻌﻴﺪ ﻟﻨﺎ اﻟﺪاﻟﻪ اﻟﻘﻴﻤﻪ ﺻﻔﺮ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; ) ‪STR ( NUM , ST‬‬
‫ﺣﻴﺚ أن ك‬
‫‪ : NUM‬ﻳﻤﺜﻞ اﻟﻌﺪد اﻟﻤﻄﻠﻮب ﺗﺤﻮﻳﻠﻪ اﻟﻰ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ‪.‬‬
‫‪ : ST‬ﻳﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻨﺎﺗﺠﻪ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫;‪Program CH6_Program10‬‬
‫‪Var‬‬
‫;‪X: integer‬‬
‫;‪St: string‬‬
‫‪Begin‬‬
‫;‪X: =2345‬‬
‫;)‪STR(x, st‬‬
‫;)‪Writeln(s‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬

‫'‪'2345‬‬

‫‪ 6.3.9‬ﺗﺤﻮﻳﻞ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ اﻟﻰ أرﻗﺎم ‪VAL‬‬

‫ﺗﻌﻤﻞ هﺬﻩ اﻟﺪاﻟﻪ ﻋﻠﻰ أﻳﺠﺎد اﻟﻘﻴﻤﻪ اﻟﻌﺪدﻳﻪ ﻟﻠﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﺘ ﻲ ﺗﺤﺘ ﻮي ﻋﻠ ﻰ أرﻗ ﺎم ﻓﻘ ﻂ ﻋﻠ ﻰ‬
‫ﺷﻜﻞ ﺣﺮﻓﻲ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬

‫; ) ‪VAL ( stn, number , Error‬‬


‫ﺣﻴﺚ أن ‪:‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ‪.‬‬ ‫‪Stn‬‬
‫‪ :‬ﻳﻤﺜﻞ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﺳﺘﻮﺿﻊ ﻓﻴﻪ اﻟﻘﻴﻤﻪ اﻟﻌﺪدﻳﻪ اﻟﻤﺘﺤﻮﻟﻪ‪.‬‬ ‫‪Number‬‬
‫‪ :‬ﻣﺘﻐﻴﺮ ﻳﻌﻴﺪ ﻋﺪد ﺻﺤﻴﺢ ) ﻋﻨﺪﻣﺎ ﻳﺘﻢ اﻟﺘﺤﻮﻳﻞ دون أﺧﻄﺎء ﻓﺴﺘﻌﻴﺪ‬ ‫‪Error‬‬
‫اﻟﻘﻴﻤﻪ ) ‪ ( 0‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ ﻋﺪم وﺟﻮد ﺧﻄﺄ ‪ ,‬أﻣﺎ أذا ﺣﺪث ﺧﻄﺄ ﻓﺴﺘﻌﻴﺪ‬
‫ﻋﺪد ﺻﺤﻴﺢ ﻳﺒﻴﻦ ﻣﻮﻗﻊ اﻟﺨﻄﺄ (‪.‬‬
‫ﻣﺜﺎل ‪:‬‬
‫‪89‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‪Program CH6_Program11‬‬
‫‪Var‬‬
‫;‪St: string‬‬
‫;‪N, e: integer‬‬
‫‪Begin‬‬
‫;'‪St: ='1234‬‬
‫;)‪Val (st, n, e‬‬
‫;)‪Writeln (n,' ****** ', e‬‬
‫;'‪St: ='2345.12‬‬
‫;)‪Val (st, n, e‬‬
‫;)‪Writeln (n,' ^^^^^^ ', e‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬


‫‪1234 ****** 0‬‬
‫‪0 ^^^^^^ 5‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫اﻟﺪاﻟﻪ ) ‪ ( val‬ﻻ ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻜﺴﻮر‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻳﻔﻀﻞ أن ﻳﺘﻢ ﺗﺤﺪﻳﺪ ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ﻋﻨﺪ اﻷﻋﻼن ﻋﻨﻬﺎ وذﻟﻚ ﻟﺘﺮﺷﻴﺪ ﻣﺴﺎ‬
‫ﺣﺔ اﻟﺬاآﺮﻩ اﻟﻤﺴﺘﺨﺪﻣﻪ ‪ ,‬وآﻤﺜﺎل ﻣﺎ ﻳﻠﻲ‬
‫; ]‪name : string [30‬‬
‫هﻨﺎ ﺣﺪدﻧﺎ اﻟﻤﻮاﻗﻊ اﻟﺘﻲ ﺗﺤﺠﺰ ﻓﻲ اﻟﺬاآﺮﻩ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( name‬ﺑﺤﺠﻢ ) ‪ ( 30‬ﺣﺮف‬
‫ﺑﺪﻻ ﻣﻦ ﺗﺮآﻬﺎ دون ﺗﺤﺪﻳﺪ وﺑﺎﻟﺘﺎﻟﻲ ﺗﺤﺪد ﻣﻦ ﻗﺒﻞ اﻟﻤﺘﺮﺟﻢ ﺑﺤﺠﻢ ) ‪ ( 256‬ﻣﻮﻗﻊ )‬
‫ﻳﺮاﻋﻰ اﻟﺮﻗﻢ اﻟﺬي ﻧﺤﺪدﻩ ﺑﻤﺎ ﻳﺘﻨﺎﺳﺐ واﻟﺤﺪ اﻻﻋﻠﻰ اﻟﺬي ﻧﺤﺘﺎج اﻟﻴﻪ ﻟﺘﻤﺜﻴﻞ‬
‫اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ( أﻣﺎ أذا آﺎن ﻣﻦ اﻟﺼﻌﺐ ﺗﺨﻤﻴﻦ اﻟﺤﺪ اﻷﻋﻠﻰ ﻓﻴﺘﺮك دون ﺗﺤﺪﻳﺪ‬
‫‪90‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬ ‫‪6.4‬‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءﻩ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺛﻢ أﻃﺒﻌﻬﺎ ﺑﺸﻜﻞ ﻣﻌﻜﻮس ) ﻣﺜﻼ أذا آﺎﻧﺖ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ‬ ‫•‬
‫‪ ABCD‬ﺗﻄﺒﻊ ‪. ( DCBA‬‬

‫;‪Program CH6_Program12‬‬
‫‪Var‬‬
‫;‪S, st: string‬‬
‫;‪I: integer‬‬
‫‪Begin‬‬
‫;)'‪Writeln ('Enter string‬‬
‫;)‪Readln(s‬‬
‫;''= ‪St:‬‬
‫‪For i: =length(s) downto 1 do‬‬
‫;]‪St: = st + s[i‬‬
‫;)‪Writeln (st‬‬
‫‪End.‬‬

‫‪OR‬‬
‫‪For i: =1 to length(s) do‬‬ ‫}‪{instead of for loop above‬‬
‫;‪St: =s[i] + st‬‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ وﺟﺪ ﻋﺪد اﻟﻤﺮات اﻟﺘﻲ ﻳﺘﻜﺮر ﻓﻴﻬﺎ اﻟﺤﺮف ) ‪. ( e‬‬ ‫•‬

‫;‪Program CH6_Program13‬‬
‫‪Var‬‬
‫;‪S:string; k,n,i:integer‬‬
‫‪Begin‬‬
‫;)'‪Writeln ('Enter string‬‬
‫;)‪Readln(s‬‬
‫;‪K: =0‬‬
‫;)‪N: =length(s‬‬
‫‪For i: = 1 to n do‬‬
‫‪If(s[i] ='e') then‬‬
‫;‪K: =k+1‬‬
‫;)‪Writeln ('number of letter e =', k‬‬
‫‪End.‬‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻔﺼﻞ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ اﻟﻰ ﺛﻼث ﻣﺠﺎﻣﻴﻊ واﺣﺪﻩ ﻟﻠﺤﺮوف اﻟﻜﺒﻴ ﺮﻩ واﻟﺜﺎﻧﻴ ﻪ ﻟﻸرﻗ ﺎم‬ ‫•‬
‫واﻟﺜﺎﻟﺜﻪ ﻟﻠﺤﺮوف اﻟﻤﺘﺒﻘﻴﻪ ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ‪.‬‬
91 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

Program CH6_Program14;
Var
S, s1, s2, s3: string;
I: integer;
Begin
Writeln ('Enter string');
Readln(s);
S1:=''; s2:=''; s3:='';
For i: = 1 to length(s) do
Case s[i] of
'A'..'Z': s1:=s1+s[i];
'0'..'9': s2:=s2+s[i]
Else s3:=s3+s[i];
End;
Writeln ('Capital letters are:', s1);
Writeln ('Digits are:' , s2);
Writeln ('Rest of string are:', s3);
End.

. ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺛﻢ أﺣﺬف آﺎﻓﺔ اﻟﻔﺮاﻏﺎت اﻟﻤﻮﺟﻮدﻩ ﻓﻴﻬﺎ‬ •

Program CH6_Program15;
Var
S: string; x: integer;
Begin
Writeln ('Enter string');
Readln(s);
X: =pos ('', x);
While(x<>0) do
Begin
Delete(s, x, 1);
X: =pos ('', s);
End;
Writeln(s);
End.

. ‫ ( ﻓﻲ اﻟﺴﻠﺴﻪ اﻟﺤﺮﻓﻴﻪ‬are ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺛﻢ أﺣﺬف آﻞ اﻟﻜﻠﻤﺎت‬ •

Program CH6_Program16;
Var
S:string; x:integer;
Begin
Writeln ('Enter string'); Readln(s);
X: =pos ('are', s);
While(x<>0) do
Begin
Delete(s, x, 3);
X: =pos ('are', s);
End;
Writeln(s);
End.
92 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ﺛ ﻢ ﺣ ﻮل ﺟﻤﻴ ﻊ اﻷﺣ ﺮف اﻟﻜﺒﻴ ﺮﻩ اﻟ ﻰ ﺣ ﺮوف ﺻ ﻐﻴﺮﻩ‬ •
. ‫وﺟﻤﻴﻊ اﻷﺣﺮف اﻟﺼﻐﻴﺮﻩ اﻟﻰ ﺣﺮوف آﺒﻴﺮﻩ‬
Program CH6_Program17;
Var
S: string; i: integer;
Begin
Writeln ('Enter string');
Readln(s);
For i: = 1 to length(s) do
Case s[i] of
'a'..'z': s[i]:=upcase(s[i]);
'A'..'Z': s[i]:=Chr (ord(s[i]) +32);
End;
Writeln(s);
End.

.(@@@ ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺛﻢ ﻏﻴﺮ آﻞ ﻓﺮاغ ﻓﻲ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻰ‬ •

Program CH6_Program 18;


Var
S:string;
N:integer;
Begin
Writeln ('Enter string');
Readln(s);
N:=pos('',s);
While(n<>0)do
begin
Delete(s, n, 1);
Insert ('@@@', s, n);
N: =pos ('', s);
Writeln(s);
End.

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺗﺘﻜﻮن ﻣﻦ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﻜﻠﻤﺎت ﻳﻔﺼﻞ ﺑﻴﻦ واﺣﺪﻩ وأﺧ ﺮى‬ •
. ‫ اﻟﻤﻄﻠﻮب ﻃﺒﺎﻋﺔ آﻞ آﻠﻤﻪ ﻋﻠﻰ ﺳﻄﺮ ﻣﻨﻔﺮد‬, ‫ﻓﺮاغ‬

Program CH_6Program19;
Var
Stn, st: string; x: integer;
Begin
Writeln ('Enter string');
Readln (stn);
X: =pos ('', stn);
While(x<>0) do
Begin
St: =copy (stn, 1, x-1);
Writeln (st);
Delete (stn, 1, x);
X: =pos ('', stn);
End;
Writeln (stn);
End.
‫‪93‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻔﺼﻞ اﻟﺴﺎﺑﻊ‬

‫ﻣﺘﻐﻴﺮات اﻷﻧﻮاع ‪VARIABLES TYPE‬‬

‫اﻟﻤﻘﺪﻣﻪ‬ ‫‪7.1‬‬

‫ﺳ ﺒﻖ وأن أﻃﻠﻌﻨ ﺎ ﻋﻠ ﻰ اﻷﻧ ﻮاع اﻟﻘﻴﺎﺳ ﻴﻪ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣﺜ ﻞ‬


‫)‪ , ( Integer , Real , Boolean , char …etc‬ﻣﻮاﺻ ﻔﺎت ه ﺬﻩ اﻷﻧ ﻮاع ﺗﺤ ﺪد ﺑ ﺸﻜﻞ آﺎﻣ ﻞ ﻣ ﻦ‬
‫ﻗﺒﻞ اﻟﻤﺘﺮﺟﻢ ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﺑﺮاﻣﺞ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪.‬‬
‫ﻓﻲ هﺬا اﻟﻔ ﺼﻞ ﺳ ﻨﻘﺪم أﻧ ﻮاع أآﺜ ﺮ‪ ,‬ﺗﺤ ﺪد ﻣﻮاﺻ ﻔﺎﺗﻬﺎ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ ‪ ,‬ﺳ ﻴﺘﻢ ﺗﻌﺮﻳ ﻒ أﻧ ﻮاع‬
‫ﻣﻨﺎﺳﺒﻪ ﻟﻜﻞ ﺑﺮﻧﺎﻣﺞ ﻣﻤﺎ ﻳﺴﺎﻋﺪ ﻋﻠﻰ ﺗﻮﺿﻴﺢ اﻟﻤﺸﻜﻠﻪ وﻳﺴﻬﻞ ﻗﺮاءة وآﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫اﻷﻧﻮاع ‪TYPES‬‬ ‫‪7.2‬‬

‫ﺗﺴﺘﺨﺪم آﻠﻤﺔ ﻧﻮع ) ‪ ( Type‬ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ أﻧﻮاع ﺟﺪﻳﺪﻩ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻷﺳﺘﺨﺪام اﻟﻨﻮع هﻲ ‪:‬‬
‫‪Type‬‬
‫; ‪Typename = new type‬‬

‫ﻟﺘﻮﺿﻴﺢ هﺬﻩ اﻟﺼﻴﻐﻪ ﻧﻔﺮض أن اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﻧﻜﺘﺒﻪ ﻳﺤﺘﺎج اﻟﻰ ﻣﺼﻔﻮﻓﻪ ) ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﻘ ﻴﻢ‬
‫ﻣﺘﻜﻮﻧ ﻪ ﻣ ﻦ ‪ 20‬ﻗﻴﻤ ﻪ ( ‪ ,‬وه ﺬا اﻟ ﻨﻤﻂ ﻣ ﻦ اﻟ ﺼﻔﻴﻔﻪ ﺳﻴ ﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ﻣ ﺮارا وﺗﻜ ﺮارا ‪ ,‬ﻓ ﻴﻤﻜﻦ‬
‫اﻷﻋﻼن أو اﻟﺘﺼﺮﻳﺢ ﻋﻦ ﻧﻤﻂ ﺟﺪﻳﺪ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪Type‬‬
‫; ‪MyArray = array [ 1 .. 20 ] of byte‬‬

‫اﻷن ﻳﻤﻜﻦ أن ﻧﻌﻠﻦ ﻋﻦ ﻣﺘﻐﻴﺮات ﻣﻦ ﻧ ﻮع ) ‪ ( myarray‬ﺑ ﺪﻻ ﻣ ﻦ آﺘﺎﺑ ﺔ ﺗﻌﺮﻳ ﻒ اﻟﻤ ﺼﻔﻮﻓﻪ‬


‫أﻋﻼﻩ ﻓﻲ آﻞ ﻣﺮﻩ ﻧﺤﺘﺎج اﻟﻰ ﻣﺜﻞ هﺬﻩ اﻟﻤﺼﻔﻮﻓﻪ ‪.‬‬
‫‪Var‬‬
‫; ‪X : myarray‬‬

‫اﻷﻋﻼن ﻋﻦ اﻷﻧﻮاع اﻟﺠﺪﻳﺪﻩ ﺳﻴﻜﻮن ﻓﻲ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻷﻧ ﻮاع واﻟ ﺬي ﻳ ﺴﻤﻰ ) ‪, ( Type‬‬
‫وﻣﻮﻗﻊ هﺬا اﻟﻘﺴﻢ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻳﻜﻮن ﺑﻴﻦ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ وﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻷﻧﻮاع اﻟﺬي ﻳﻈﻬﺮ ﻓﻲ ﺟﺴﻢ اﻷﺟﺮاءات هﻲ ﻣﺤﻠﻴﻪ ﻟﺘﻠﻚ اﻷﺟﺮاءات ‪.‬‬
‫أﻣﺎ ﺗﻠﻚ اﻟﺘﻲ ﺗﻈﻬﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻓﻬﻲ ﻋﺎﻣﻪ ‪.‬‬
‫‪94‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺑﺸﻜﻞ ﻋﺎم هﻨﺎك ﺛﻼث أﺻﻨﺎف ﻟﻸﻧﻮاع ‪:‬‬

‫‪ 7.2.1‬اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ ‪SCALARS TYPE‬‬

‫اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ هﻲ ﺑﺒﺴﺎﻃﻪ ﻗﺎﺋﻤﻪ ﻣ ﻦ اﻟﻘ ﻴﻢ ‪ ,‬واﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ أن ﺗﻔ ﺮض ﻟﻠﻤﺘﻐﻴ ﺮ ﻗﻴﻤ ﻪ ﻣ ﻦ‬


‫ذﻟﻚ اﻟﻨﻮع ‪ ,‬ﻓﻤﺜﻼ أن اﻟﻨﻮع اﻟﻘﻴﺎﺳﻲ ) ‪ ( integer‬ﻳﻤﺜﻞ ﻗﺎﺋﻤﻪ ﺑﺎﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ وﻋﻨﺪﻣﺎ ﻧﻌﺮف ﻣﺘﻐﻴ ﺮ‬
‫ﻣﻦ هﺬا اﻟﻨﻮع ﻓﺄﻧﻨﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﺴﻨﺪ ﻟﻠﻤﺘﻐﻴﺮ أي ﻗﻴﻤ ﻪ ﻣ ﻦ ﻗ ﻴﻢ اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ) ﻓﻌﻨ ﺪﻣﺎ ﻧﻘ ﻮل أن‬
‫اﻟﻤﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع اﻟﻔﻼﻧﻲ ﻓﻬﺬا ﻳﻌﻨﻲ أن هﺬا اﻟﻤﺘﻐﻴﺮ ﺳﻴﺄﺧﺬ ﻗﻴﻤﻪ ﻣﺤﺪدﻩ ﺑﺬﻟﻚ اﻟﻨﻮع ( ‪ .‬ﻓﻤﺜﻼ‬
‫‪Type‬‬
‫; ) ‪Units = ( inches , feet , miles‬‬

‫ﻻﺣﻆ أن هﺬا اﻟﻨﻮع ﺣﺪد ﺑﺜﻼث وﺣﺪات ﻟﺬﻟﻚ ﻓﺄن اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﺳﻴﻌﺮف ﻣﻦ هﺬا اﻟﻨﻮع ﺳ ﻮف ﻟ ﻦ ﻳﻜ ﻮن‬
‫ﺑﻤﻘﺪورﻩ أن ﻳﺤﻤﻞ ﻗﻴﻤﻪ ﻏﻴﺮ ﺗﻠﻚ اﻟﻤﺤﺪدﻩ ﺑﺎﻟﺘﻌﺮﻳﻒ ) ﻣﻤﻜﻦ أن ﻳﺄﺧﺬ أي ﻗﻴﻤﻪ ﻣﻦ اﻟﻘ ﻴﻢ اﻟ ﺜﻼث اﻟﻤﺤ ﺪدﻩ‬
‫ﻓﻘﻂ ( ‪.‬‬
‫اﻷن ﺑﻌ ﺪ اﻷﻋ ﻼن ﻋ ﻦ ﻧ ﻮع ﺟﺪﻳ ﺪ ﻏﻴ ﺮ ﻣﻮﺟ ﻮد أﺻ ﻼ ﺿ ﻤﻦ اﻷﻧ ﻮاع اﻟﻘﻴﺎﺳ ﻴﻪ اﻟﻤﺤ ﺪدﻩ ﺑﻠﻐ ﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ ,‬ﻓﺄﻧﻨﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﻌﻠﻦ ﻋﻦ ﻣﺘﻐﻴﺮ ﻓﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﻣ ﻦ اﻟﻨ ﻮع (‬
‫) ‪ , units‬وآﻤ ﺎ ﻧﻌﻤ ﻞ ﻣ ﻊ اﻟﻤﺘﻐﻴ ﺮات اﻟﻘﻴﺎﺳ ﻴﻪ ‪ ,‬وﺳ ﻴﻜﻮن ه ﺬا اﻟﻨ ﻮع ﻓﻌ ﺎﻻ ﺿ ﻤﻦ ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻘ ﻂ‬
‫وﻟﻴﺲ اﻟﺒﺮاﻣﺞ اﻷﺧﺮى ‪ ,‬ﻓﺄذا ﻣﺎ آﺎﻧﺖ هﻨﺎك ﺣﺎﺟﻪ ﻷﺳﺘﺨﺪام هﺬا اﻟﻨﻮع ﻓﻲ ﺑﺮﻧﺎﻣﺞ أﺧﺮ ﻓﻴﺠﺐ أن ﻧﻌﻠ ﻦ‬
‫ﻋﻨﻪ ﺿﻤﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺠﺪﻳﺪ ‪.‬‬
‫‪Var‬‬
‫; ‪X : units‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫اﻟﺘﻌﺮﻳﻔﺎن ) اﻷﻋﻼن ﻋﻦ اﻟﻨﻮع واﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮ ﻣﻦ ذﻟﻚ اﻟﻨﻮع ( ﻣﻦ اﻟﻤﻤﻜﻦ‬


‫أن ﻳﺪﻣﺠﺎن ﻣﻌﺎ ﺑﺘﻌﺮﻳﻒ واﺣﺪ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪Var‬‬
‫; ) ‪Scale : ( inches , feet , miles‬‬

‫وﻟﻜﻦ ﻓﻲ ﻣﻌﻈﻢ اﻟﺤﺎﻻت ﻳﻔﻀﻞ أن ﻳﻔﺼﻞ ﺑﻴﻦ ﺗﻌﺮﻳﻒ اﻷﻧﻮاع وﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ‪.‬‬

‫أﻣﺜﻠﻪ ﻋﻦ اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ ‪:‬‬

‫‪Type‬‬
‫‪Day = ( Monday, Tuesday, Wednesday, Thursday, Friday,‬‬
‫; ) ‪Saturday, Sunday‬‬
‫; ) ‪Operator = ( plus, minus, multiply, divide‬‬
‫; ) ‪Trigfunction = ( sine, cosine, tangent, secant, cosecant‬‬

‫هﻨﺎ ﺳﻨﻌﺮض ﻣﺘﻐﻴﺮات ﻣﻦ ﺗﻠﻚ اﻷﻧﻮاع‬


‫‪Var‬‬
‫‪95‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫; ‪Holiday, workday : day‬‬


‫; ‪Addingop, multop : operator‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻟﺴﻮء اﻟﺤﻆ ﻓﺄن ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ﻻ ﺗﻮﻓﺮ أﻣﻜﺎﻧﻴﺔ ﻗﺮاءة وﻃﺒﺎﻋﺔ اﻟﻘﻴﻢ اﻟﻌﺪدﻳﻪ‬
‫ﻣﺒﺎﺷﺮﻩ ) اﻟﻤﺘﻐﻴﺮات ﻣﻦ هﺬا اﻟﻨﻮع ( ‪ .‬ﻣﺜﻼ‬
‫;‪Holiday := Friday‬‬
‫) ‪Write ( holiday‬‬

‫ﺳﻮف ﻻ ﻳﻄﺒﻊ ) ‪ , ( Friday‬ورﺑﻤﺎ ﻻﻧﺤﺼﻞ ﻋﻠﻰ أي ﻣﺨﺮﺟﺎت ﻷن اﻟﻤﺘﺮﺟﻢ ﺳﻴﺼﺪر‬


‫رﺳﺎﻟﺔ ﺧﻄﺄ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻻﺣﻆ أن ﻗﻴﻢ اﻷﻧﻮاع ﻋﺎدة ﺗﻜﻮن ﻣﺤﺪدﻩ ﺑﻴﻦ ﻗﻮﺳﻴﻦ ‪ ,‬وﻻ ﻳﺠﻮز أن ﺗﻜﻮن هﻨﺎك ﻗﻴﻤﻪ ﺗﻌﻮد‬
‫اﻟﻰ ﻧﻮﻋﻴﻦ ﻓﻲ ذات اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬ﻳﺠﺐ أن ﺗﺤﺪد ﻟﻨﻮع واﺣﺪ ‪ ,‬ﻓﻤﺜﻼ ﺗﻌﺮﻳﻒ اﻷﻧﻮاع اﻟﺘﺎﻟﻴﻪ‬
‫ﻏﻴﺮ ﻣﻘﺒﻮل ‪:‬‬
‫‪Type‬‬
‫;) ‪Fruit = ( apple, orange, lemon, pineapple, tomato‬‬
‫; ) ‪Vegetable = ( potato, carrot, tomato, onion‬‬

‫واﻟﺴﺒﺐ ﻷن اﻟﻌﻨﺼﺮ ) ‪ ( tomato‬ﻳﻈﻬﺮ ﻓﻲ اﻟﺘﻌﺮﻳﻔﻴﻦ ‪.‬‬

‫أن اﻟﻘﻴﻢ اﻟﻤﺪوﻧﻪ ﻓﻲ اﻷﻋﻼن ﻋﻦ اﻟﻨﻮع اﻟﻌﺪدي ﺛﺎﺑﺘﻪ ﻟﺬﻟﻚ اﻟﻨﻮع ‪ ,‬ﻟﺬﻟﻚ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﻜﺘﺐ‬

‫; ‪Holiday : = Friday‬‬ ‫; ‪scale : = miles‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻻﻳﺠﻮز أﺳﻨﺎد ﻗﻴﻤﻪ ﻣﻦ ﻧﻮع ﻣﻌﻴﻦ ) أﺳﺘﺨﺪام اﻟﻤﺴﺎواة ( اﻟﻰ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع أﺧﺮ ‪.‬‬
‫ﻣﺜﻼ ‪:‬‬
‫; ‪Holiday := miles‬‬
‫‪96‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫أن اﻟﻌﻤﻠﻴ ﺎت اﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ أﺳ ﺘﺨﺪاﻣﻬﺎ ﻣ ﻊ اﻟﻤﺘﻐﻴ ﺮات اﻟﻌﺪدﻳ ﻪ ه ﻲ اﻟﻌﻤﻠﻴ ﺎت اﻟﻌﻼﺋﻘﻴ ﻪ‬ ‫•‬
‫) ‪ ( relational operators‬وﻃﺒﻌﺎ ﺳﺘﻜﻮن ﻧﺘﻴﺠﺔ هﺬا اﻟﺘﻌﺒﻴﺮ ه ﻲ ﻣ ﻦ اﻟﻨ ﻮع ) ‪( Boolean‬‬
‫أي ﺻﺢ أو ﺧﻄﺄ ‪ .‬ﻓﻤﺜﻼ‬

‫‪Monday < Friday‬‬


‫‪Multiply > divide‬‬

‫أن اﻟﻨﻮع ) ‪ ( Boolean‬هﻮ ﺑﺤﺪ ذاﺗﻪ ﻧﻮع ﻋﺪدي ‪ ,‬ﻓﻬﻮ ﻣﻌﺮف ﺿﻤﻨﻴﺎ آﻨﻮع ﻗﻴﺎﺳﻲ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪Type‬‬
‫;) ‪Boolean = ( false , true‬‬
‫وﻃﺒﻌﺎ أذا ﻗﻠﻨﺎ‬
‫‪False < true‬‬

‫وهﻲ ﻋﺒﺎرﻩ ﺻﺤﻴﺤﻪ ‪.‬‬

‫اﻟ ﺪوال ) ‪ ( succ , pred‬ه ﻲ ﻣﻌﺮﻓ ﻪ ﻟﻸﻧ ﻮاع اﻟﻌﺪدﻳ ﻪ ) أي ﻳﻤﻜ ﻦ أﺳ ﺘﺨﺪاﻣﻬﺎ ﻣ ﻊ اﻷﻧ ﻮاع‬ ‫•‬
‫اﻟﻌﺪدﻳﻪ ( ‪ ,‬واﻟﻘﻴﻤﻪ اﻟﻤﻌﺎدﻩ هﻲ ﻣﻦ ﻧﻔﺲ ﻧﻮع اﻟﻤﻌﺎﻣﻼت اﻟﻤﺴﺘﺨﺪﻣﻪ ‪ ,‬ﻣﺜﻼ‬

‫‪Succ ( Monday ) = Tuesday‬‬

‫ﻣ ﻊ ﻣﻼﺣﻈ ﺔ أن أول ﻋﻨ ﺼﺮ ﻓ ﻲ اﻟﻘﺎﺋﻤ ﻪ ﻟ ﻴﺲ ﻟ ﻪ ) ‪ , ( pred‬وأﺧ ﺮ ﻋﻨ ﺼﺮ ﻓ ﻲ اﻟﻘﺎﺋﻤ ﻪ ﻟ ﻴﺲ ﻟ ﻪ‬


‫) ‪. ( succ‬‬

‫اﻟﺪاﻟﻪ ) ‪ ( ord‬ﻟﻬﺎ ﻣﻌﺎﻣﻼت ﻋﺪدﻳﻪ وﺗﻌﻴﺪ ﻗﻴﻤﺔ ﻋﺪد ﺻﺤﻴﺢ ‪ ,‬واﻟﺬي ه ﻮ اﻟﻌ ﺪد اﻟﺘﺮﺗﻴﺒ ﻲ ﻟﻠﻘﻴﻤ ﻪ‬ ‫•‬
‫اﻟﻌﺪدﻳﻪ ﻓﻲ ﺗﻌﺮﻳﻒ اﻟﻘﺎﺋﻤﻪ ﺣﻴﺚ أن أول ﻗﻴﻤﻪ ﻓﻲ اﻟﻘﺎﺋﻤﻪ ﻟﻬﺎ اﻟﻌﺪد اﻟﺘﺮﺗﻴﺒﻲ ﺻﻔﺮواﻟﺬي ﻳﻠﻴ ﻪ ﻟ ﻪ‬
‫ﻋﺪد ﺗﺮﺗﻴﺒﻲ ﻗﻴﻤﺘﻪ واﺣﺪ وهﻜﺬا ‪ ..‬ﻣﺜﻼ‪ ..‬وﻣﻦ اﻷﻧﻮاع أﻋﻼﻩ ‪:‬‬
‫‪Ord ( plus ) = 0‬‬
‫‪Ord ( tuesdy ) = 1‬‬
‫‪Ord ( cosecant ) = 4‬‬

‫أﻳﻀﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام أﻣﺮ اﻟﺘﻜﺮار ) ‪ ( for‬ﺑﺎﻟﻬﻴﻜﻠﻴﻪ ‪:‬‬ ‫•‬

‫‪For scale : = inches to miles do‬‬


‫; ‪Do something‬‬

‫هﻨﺎ ﻻ ﻳﻤﻜﻦ أﺳﺘﺨﺪام ) ‪ ( while‬ﻣﺜﻼ ‪:‬‬

‫; ‪Scale : = inches‬‬
‫‪While ( scale <= miles ) do‬‬
‫‪Begin‬‬
‫; ‪Do something‬‬
‫; ) ‪Scale: = succ ( scale‬‬
‫‪97‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫;‪End‬‬
‫ﺳﻴﻔﺸﻞ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻋﻨﺪ ﺣﺴﺎب ) ) ‪. ( succ ( miles‬‬

‫‪ 7.2.2‬اﻟﻤﺪﻳﺎت اﻟﺠﺰﺋﻴﻪ ‪SUBRANGE‬‬

‫هﺬا اﻟﻨﻮع ﻳﻌﺮف ﺑﺄﺳﻨﺎد ﺛﺎﺑﺘﻴﻦ ﻟﻠﻤﺘﻐﻴﺮ ﻓﻲ ﺣﻘﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻨ ﻮع ‪ ,‬وه ﺬان اﻟﺜﺎﺑﺘ ﺎن ﻳﻤ ﺜﻼن‬
‫اﻟﺤ ﺪود اﻟ ﺪﻧﻴﺎ واﻟﺤ ﺪود اﻟﻌﻠﻴ ﺎ ﻟﻠﻤ ﺪى اﻟﺠﺰﺋ ﻲ ‪ ,‬وﻳﺠ ﺐ أن ﻳﺨﺘﻠﻔ ﺎن وﻳﻜﻮﻧ ﺎن ﻣ ﻦ ﻧﻔ ﺲ اﻟﻨ ﻮع‬
‫‪.‬ﻣﺜﺎل ‪:‬‬

‫‪Type‬‬
‫; ‪Index = 1 .. 35‬‬

‫هﻨﺎ اﻟﺤﺪ اﻷدﻧﻰ ه ﻮ ) ‪ ( 1‬واﻟﺤ ﺪ اﻷﻋﻠ ﻰ ه ﻮ ) ‪ ( 35‬واﻷﺛﻨ ﺎن ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ‪.‬‬
‫واﻟﻤﺪى ﻳﻜﻮن ﺑﻴﻦ ) ‪ , ( 1 – 35‬ﻋﻠﻴﻪ ﻓﺄن اﻟﻤﺘﻐﻴ ﺮ اﻟ ﺬي ﻳﻌ ﺮف ﻣ ﻦ ﻧ ﻮع ) ‪ ( index‬ﺳ ﻴﺄﺧﺬ‬
‫أي ﻗﻴﻤﻪ ﻣﻦ اﻟﻘﻴﻢ اﻟﻤﺤﺪدﻩ ﺑﺎﻟﻤﺪى ) ‪ ( 1 – 35‬وﻟﻴﺲ ﻗﻴﻤﻪ ﺧﺎرج هﺬا اﻟﻤﺪى ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻻ ﺗﺴﺘﺨﺪم اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ ﻣﻊ هﺬا اﻟﻨﻮع ) أي ﻻ ﻳﻤﻜﻦ أن ﻧﺴﺘﺨﺪم اﻷﻋﺪاد‬


‫اﻟﺤﻘﻴﻘﻴﻪ ﻓﻲ اﻟﻤﺪﻳﺎت اﻟﺠﺰﺋﻴﻪ ( ‪.‬‬

‫اﻟﺘﻌﺮﻳﻔﺎن ) اﻷﻋﻼن ﻋﻦ اﻟﻨﻮع واﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮ ﻣﻦ ذﻟﻚ اﻟﻨﻮع ( ﻣﻦ اﻟﻤﻤﻜﻦ ان ﻳ ﺪﻣﺠﺎن‬ ‫•‬
‫ﻣﻌﺎ ﺑﺘﻌﺮﻳﻒ واﺣﺪ ‪ ..‬ﻣﺜﺎل‬
‫‪Type‬‬
‫; ‪Index = 1 .. 35‬‬
‫; '‪Letter = 'a' .. 'z‬‬
‫; '‪Digit = '0' .. '9‬‬
‫‪Var‬‬
‫; ‪Count : index‬‬
‫; ‪Firstchar , lastchar : letter‬‬

‫هﺬان اﻟﺘﻌﺮﻳﻔﺎن ﻣﻦ اﻟﻤﻤﻜﻦ دﻣﺠﻬﻤﺎ ﺑﺘﻌﺮﻳﻒ واﺣﺪ آﻤﺎ ﻳﻠﻲ ‪:‬‬


‫‪Var‬‬
‫; ‪Counter : 1 .. 35‬‬
‫; '‪Firstchar , lastchar : 'a' .. 'z‬‬

‫ﻟﻜﻦ ﻓﻲ ﻣﻌﻈﻢ اﻟﺤﺎﻻت ﻳﻔﻀﻞ اﻟﻤﺤﺎﻓﻈﻪ ﻋﻠﻰ ﺗﻌﺮﻳﻔﻴﻦ ﻣﻨﻔﺼﻠﻴﻦ ‪.‬‬


‫‪98‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫• اﻟﻤﻌﺎﻣﻼت ) ‪ ( operators‬اﻟﺘﻲ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﺴﺘﺨﺪم ﻣﻊ ﻣﺘﻐﻴﺮ ﻟﻨﻮع‬


‫ﻣﻌﻴﻦ ‪ ,‬ﻣﻤﻜﻦ أﻳﻀﺎ أن ﺗﺴﺘﺨﺪم ﻣﻊ اﻟﻤﺪى اﻟﺠﺰﺋﻲ ﻟﻬﺬا اﻟﻨﻮع ‪ .‬ﻣﺜﺎل ‪ ..‬أذا‬
‫آﺎن ‪:‬‬
‫‪Var‬‬
‫; ‪Index : 1 .. 10‬‬
‫; ‪Number : 1 .. 100‬‬
‫; ‪Result : integer‬‬
‫ﻓﺄن هﺬﻩ اﻟﻌﺒﺎرﻩ هﻲ ﻋﺒﺎرﻩ ﺻﺤﻴﺤﻪ ‪:‬‬
‫‪Result + number div index‬‬
‫• ﻣﺘﻐﻴﺮات اﻟﻤﺪى اﻟﺠﺰﺋﻲ ﻣﻤﻜﻦ أﻳﻀﺎ أﺳﺘﺨﺪاﻣﻬﺎ ﻋﻠﻰ آﻼ ﺟﺎﻧﺒﻲ اﻟﻤﺴﺎواة ‪.‬‬
‫ﻣﺜﺎل‬

‫; ‪index : = number‬‬
‫; ‪result : = index‬‬

‫‪ 7.2.3‬اﻟﻤﺠﻤﻮﻋﺎت ‪SETS‬‬

‫اﻟﻤﺠﻤﻮﻋﻪ هﻲ ﺗﺠﻤﻴﻊ ﻷﺷﻴﺎء ﻣﻦ ﻧﻔ ﺲ اﻟﻨ ﻮع ‪ ,‬ﻓ ﺄذا آﺎﻧ ﺖ ) ‪ ( S‬ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻷﺷ ﻴﺎء ﻣ ﻦ ﻧ ﻮع ) ‪( t‬‬
‫ﻓﺄن أي ﻣﻜﻮن أو أي ﺷﻲء ﻣﻦ اﻟﻨﻮع ) ‪ ( t‬أﻣﺎ أن ﻳﻜ ﻮن ﻋ ﻀﻮ ) ﻋﻨ ﺼﺮ ( ﻓ ﻲ اﻟﻤﺠﻤﻮﻋ ﻪ ) ‪ ( S‬أو ﻻ‬
‫ﻳﻜﻮن ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ ) ‪. ( S‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﻌﺮف ﻧﻮع اﻟﻤﺠﻤﻮﻋﻪ وﻓﻘﺎ ﻷي ﻧﻮع ﻋﺪدي ) أن ﻧﻮع اﻟﻘﻴﻢ ﻓﻲ اﻟﻤﺠﻤﻮﻋ ﻪ ه ﻲ ﻣﺠ ﺎﻣﻴﻊ‬
‫ﻣﻦ اﻟﻨﻮع اﻟﻌﺪدي ( ‪ .‬ﻣﺜﺎل‬

‫‪Type‬‬
‫‪Ingredients = ( apple , orange , bananas , strawberries , nuts ,‬‬
‫; ) ‪icecream , cream , pastry , sugar , ice‬‬

‫ﺗﻌﺮﻳﻒ اﻟﻤﺠﻤﻮﻋﻪ ﻳﻜﻮن ‪:‬‬


‫‪Type‬‬
‫;‪Desert = set of ingredients‬‬

‫أﻣﺎ اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع ) ‪ ( desert‬ﻓﻴﻌﻠﻦ ﻋﻨﻬﺎ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ‪:‬‬

‫‪Var‬‬
‫; ‪Feast , x : desert‬‬
‫‪99‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﻘ ﻴﻢ اﻟﺜﺎﺑﺘ ﻪ أو اﻟﻤﺘﻐﻴ ﺮﻩ ﻣ ﻦ اﻟﻨ ﻮع ) ‪ ( desert‬ه ﻲ ﻣﺠﻤﻮﻋ ﻪ ﺟﺰﺋﻴ ﻪ ﻣ ﻦ اﻟﻨ ﻮع ) ‪( ingredients‬‬


‫واﻟﺘﻲ ﺗﻌﺘﺒﺮ اﻟﻨﻮع اﻷﺳﺎس ﻟﻠﻨﻮع ) ‪. ( desert‬‬
‫ﺗﻤﺜ ﻞ اﻟﻤﺠﻤﻮﻋ ﻪ ﺑﻘﺎﺋﻤ ﻪ ﻣ ﻦ اﻟﻌﻨﺎﺻ ﺮ اﻟﻤﻌﺮﻓ ﻪ ﺿ ﻤﻦ اﻟﻤﺠﻤﻮﻋ ﻪ ‪ ,‬ﺗﻔ ﺼﻞ ﻓ ﺎرزﻩ ﺑ ﻴﻦ ﻋﻨ ﺼﺮ وأﺧ ﺮ ‪,‬‬
‫وﺟﻤﻴﻊ هﺬﻩ اﻟﻌﻨﺎﺻﺮ ﻣﺤﺪدﻩ ﺑﻘﻮﺳﻴﻦ ﻣﺮﺑﻌﻴﻦ ‪ .‬ﻣﺜﺎل‬

‫] ‪[ icecream , cream‬‬
‫] ‪[ apple , bananas , icecream‬‬
‫] ‪[ orange‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫أذا آﺎﻧﺖ ﻋﻨﺎﺻﺮ ﻣﺠﻤﻮﻋﻪ ﻣﻌﻴﻨﻪ ﻣﺘﻌﺎﻗﺒﻪ ﻓﻴﻤﻜﻦ ﺗﺤﺪﻳﺪ اﻟﻌﻨﺼﺮ اﻷول‬
‫واﻷﺧﻴﺮ ﻓﻘﻂ آﻤﺪى ﺟﺰﺋﻲ ‪ .‬ﻣﺜﺎل‬
‫] ‪[ apple , orange , bananas , strawberries‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﻜﺘﺐ ‪:‬‬
‫] ‪[ apple .. strawberries‬‬

‫ﺻﻔﺎت اﻟﻤﺠﻤﻮﻋﺎت‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻻ ﺗﺤﺘﻮي اﻟﻤﺠﻤﻮﻋ ﻪ ﻋﻠ ﻰ أي ﻋﻨ ﺼﺮ ﻋﻨ ﺪهﺎ ﺗ ﺴﻤﻰ ﻣﺠﻤﻮﻋ ﻪ ﺧﺎﻟﻴ ﻪ ‪ ,‬وﻳﺮﻣ ﺰ‬ ‫•‬
‫ﻟﻠﻤﺠﻤﻮﻋﻪ اﻟﺨﺎﻟﻴﻪ ﺑﺎﻟﺮﻣﺰ ] [ ‪.‬‬

‫أﺗﺤ ﺎد ) ‪ ( union‬أﺛﻨ ﺎن ﻣ ﻦ اﻟﻤﺠ ﺎﻣﻴﻊ ﻳﻨ ﺘﺞ ﻋﻨﻬﻤ ﺎ ﻣﺠﻤﻮﻋ ﻪ واﺣ ﺪﻩ ﺗﺤﺘ ﻮي ﻋﻨﺎﺻ ﺮ‬ ‫•‬
‫اﻟﻤﺠﻤﻮﻋﺘﻴﻦ ‪ .‬ﻋﺎﻣﻞ اﻷﺗﺤﺎد هﻮ ) ‪ . ( +‬ﻣﺜﺎل‬

‫]‪[ apple ] + [ bananas , sugar ] = [ apple , bananas , sugar‬‬

‫ﺗﻘﺎﻃﻊ ) ‪ ( intersection‬أﺛﻨﺎن ﻣﻦ اﻟﻤﺠﺎﻣﻴﻊ ﻳﻨﺘﺞ ﻋﻨﻪ ﻣﺠﻤﻮﻋﻪ واﺣﺪﻩ ﺗﺤﺘﻮي ﻓﻘ ﻂ اﻟﻌﻨﺎﺻ ﺮ‬ ‫•‬
‫اﻟﻤ ﺸﺘﺮآﻪ ﺑ ﻴﻦ اﻟﻤﺠﻤ ﻮﻋﺘﻴﻦ ) أي اﻟﻌﻨﺎﺻ ﺮ اﻟﻤﻮﺟ ﻮدﻩ ﻓ ﻲ اﻟﻤﺠﻤﻮﻋ ﻪ اﻷوﻟ ﻰ وﺑ ﺬات اﻟﻮﻗ ﺖ‬
‫ﻣﻮﺟﻮدﻩ ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ اﻟﺜﺎﻧﻴﻪ ( ‪ .‬ﻋﺎﻣﻞ اﻟﺘﻘﺎﻃﻊ هﻮ ) * ( ‪ .‬ﻣﺜﺎل‬

‫] ‪[ Orange , icecream , cream ] * [ icecream , nuts ] = [ icecream‬‬

‫اﻟﻔﺮق ﺑﻴﻦ أﺛﻨﺎن ﻣﻦ اﻟﻤﺠﺎﻣﻴﻊ ﻳﻨﺘﺞ ﻋﻨﻪ ﻣﺠﻤﻮﻋﻪ واﺣ ﺪﻩ ﻓﻘ ﻂ ﺗﺤﺘ ﻮي ﻋﻠ ﻰ آ ﻞ اﻟﻌﻨﺎﺻ ﺮ اﻟﺘ ﻲ‬ ‫•‬
‫ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ اﻷوﻟﻰ وﻟﻜﻨﻬﺎ ﻟﻴ ﺴﺖ ﻋﻨﺎﺻ ﺮ ﻓ ﻲ اﻟﻤﺠﻤﻮﻋ ﻪ اﻟﺜﺎﻧﻴ ﻪ ‪ .‬ﻋﺎﻣ ﻞ اﻟﻔ ﺮق ه ﻮ ) ‪. ( -‬‬
‫ﻣﺜﺎل‬

‫‪[ apple , strawberries , bananas ] – [ strawberries , cream ] = [ apple ,‬‬


‫] ‪bananas‬‬
‫‪100‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫اﻟﺮﻣ ﺰ ) ‪ ( IN‬ه ﻲ ﻣ ﻦ اﻟﻜﻠﻤ ﺎت اﻟﻤﺤﺠ ﻮزﻩ ﺗ ﺴﺘﺨﺪم هﻨ ﺎ ﻷﺧﺘﺒﺎرأﻧﺘﻤ ﺎء ﻋﻨ ﺼﺮ ﻟﻤﺠﻤﻮﻋ ﻪ ‪,‬‬ ‫•‬
‫وﻃﺒﻌﺎ ﻧﺘﻴﺠﻪ ذﻟﻚ هﻮ ﻋﺒﺎرﻩ ﻣﻨﻄﻘﻴﻪ ) ﺻﺢ أو ﺧﻄﺄ ( ‪ ,‬ﻣﺜﺎل اﻟﻌﺒﺎرﻩ اﻟﺘﺎﻟﻴﻪ ﻋﺒﺎرﻩ ﺻﺤﻴﺤﻪ‬

‫] ‪Apple in [ apple , orange , icecream‬‬

‫ﺑﻴﻨﻤﺎ اﻟﻌﺒﺎرﻩ اﻟﺘﺎﻟﻴﻪ هﻲ ﻋﺒﺎرﻩ ﺧﺎﻃﺌﻪ‬

‫] ‪Apple in [ orange , bananas , icecream , cream‬‬

‫ﺗ ﺴﺘﺨﺪم اﻟﻌﻮاﻣ ﻞ اﻟﻌﻼﺋﻘﻴ ﻪ ﻟﻠﻤﻘﺎرﻧ ﻪ ﺑ ﻴﻦ اﻟﻤﺠ ﺎﻣﻴﻊ ‪ ,‬واﻟﻤﺒﻴﻨ ﻪ ﺑﺎﻟﺠ ﺪول ) ‪ .. ( 7.1‬أﻣﺜﻠ ﻪ ﻋﻠ ﻰ‬ ‫•‬
‫ذﻟﻚ ‪:‬‬

‫] ‪[ Orange , cream ] = [ cream , orange‬‬


‫] ‪[ icecream ] ≠ [ ice , cream‬‬
‫] ‪[strawberries ] <= [ strawberries , cream‬‬
‫] ‪[ apple .. ice ] > = [ icecream .. cream‬‬

‫ﻋﺒﺎرة اﻟﻤﺴﺎواة رﺑﻤﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ ﻣﺘﻐﻴﺮات اﻟﻤﺠﺎﻣﻴﻊ وﺗﻌﺎﺑﻴﺮ اﻟﻤﺠﻤﻮﻋﻪ ‪ ..‬ﻣﺜﺎل‬ ‫•‬

‫; ] ‪X : = [ apple , cream , sugar‬‬


‫; ] ‪Feast : = x + [ icecream‬‬

‫ﺟ ﺪول ) ‪ : ( 7.1‬ﻣﻘﺎرﻧ ﺔ اﻟﻌﻤﻠﻴ ﺎت اﻟﻌﻼﺋﻘﻴ ﻪ اﻟﻤ ﺴﺘﺨﺪﻣﻪ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣ ﻊ ﻣ ﺎ ﻳﻘﺎﺑﻠﻬ ﺎ ﻓ ﻲ‬
‫اﻟﺮﻳﺎﺿﻴﺎت‬

‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ‬ ‫اﻟﺮﻣﺰ اﻟﻤﺴﺘﺨﺪم ﻓﻲ‬ ‫اﻟﻤﻌﻨﻰ‬


‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬ ‫اﻟﺮﻳﺎﺿﻴﺎت‬
‫]…[‬ ‫}…{‬ ‫اﻟﻤﺠﻤﻮﻋﻪ ) ‪( set‬‬
‫‪+‬‬ ‫‪U‬‬ ‫اﻷﺗﺤﺎد ) ‪( union‬‬
‫*‬ ‫∩‬ ‫اﻟﺘﻘﺎﻃﻊ ) ‪( intersection‬‬
‫≤‬ ‫≤‬ ‫ﺗﺤﺘﻮي ) ‪( contains‬‬
‫≥‬ ‫≥‬ ‫ﻣﺤﺘ ﻮاة ﺑﺎﻟﻤﺠﻤﻮﻋ ﻪ ) ‪( contained by‬‬
‫) ﻣﺠﻤﻮﻋﻪ ﺟﺰﺋﻴﻪ ﻣﻦ (‬
‫‪IN‬‬ ‫‪є‬‬ ‫ﺗﻌﻮد اﻟﻰ ) ‪( inclusion‬‬
‫][‬ ‫‪Ø‬‬ ‫ﻣﺠﻤﻮﻋﻪ ﺧﺎﻟﻴﻪ ) ‪( empty set‬‬
‫‪101‬‬ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬

‫ﻋﻨﺪ أﺳﺘﺨﺪام اﻟﻌﻼﻣﻪ ) ≤ أو ≥ ( ﻓﺄن ﻓﺘﺤﺔ هﺬﻩ اﻟﻌﻼﻣﻪ داﺋﻤﺎ ﺗﺸﻴﺮ اﻟﻰ اﻟﻤﺠﻤﻮﻋﻪ اﻷآﺒﺮ ‪.‬‬
102 ‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬ 7.3

: ‫ ( ﺛﻢ أوﺟﺪ ﻣﺎﻳﻠﻲ‬0 .. 255 ) ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﻜﻮﻳﻦ ﻣﺠﻤﻮﻋﺘﻴﻦ ذات أﻋﺪاد‬


‫ أﻃﺒﻊ اﻟﻤﺠﻤﻮﻋﺘﻴﻦ‬.1
‫ ﺟﺪ أﺗﺤﺎد اﻟﻤﺠﻤﻮﻋﺘﻴﻦ وأﻃﺒﻊ اﻟﻨﺘﻴﺠﻪ‬.2
‫ ﺟﺪ ﺗﻘﺎﻃﻊ اﻟﻤﺠﻤﻮﻋﺘﻴﻦ وأﻃﺒﻊ اﻟﻨﺘﻴﺠﻪ‬.3
‫ ﺟﺪ ﻣﺘﻤﻤﻪ اﻟﻤﺠﻤﻮﻋﻪ اﻷوﻟﻰ واﻟﺜﺎﻧﻴﻪ وأﻃﺒﻊ اﻟﻨﺘﻴﺠﻪ‬.4
‫ ﺟﺪ اﻟﻌﻨﺎﺻﺮ اﻟﻤﻮﺟﻮدﻩ ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ اﻷوﻟﻰ وﻏﻴﺮ ﻣﻮﺟﻮدﻩ ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ‬.5
.‫اﻟﺜﺎﻧﻴﻪ وأﻃﺒﻊ اﻟﻨﺘﻴﺠﻪ‬

Program CH7_Program1;
Type
Number=set of 0..255;
Var
U, t1, t2, t3, t4, t5, t6, t7: number;

Procedure readset (var s1: number);


Var
I, x: integer;
Begin
S1:= [];
For i: =1 to 10 do
Begin
Writeln ('Enter number 0..255');
Readln(x);
S1:=s1+[x];
End;
End;

Procedure writeset (s1: number);


Var
I: integer;
Begin
Write ('{');
For i: = 0 to 255 do
If (I) IN (s1) then write (i: 4);
Write ('}');
End;

Begin
Readset (t1);
Readset (t2);
Writeset (t1);
Writeset (t2);
T3:=t1+t2; {union}
Writeset (t3);
T4:=t1*t2; {intersection}
Writeset (t4);
U:=[0..255];
T5:=u-t1;
Writeset(t5);
T6:=u-t2;
Writeset (t6);
T7:=t1-t2;
Writeset (t7);
End.

Vous aimerez peut-être aussi