‫א‬ ‫اﻟﺪرس اﻟﺘﺎﺳﻊ ‪:‬‬

‫ﻛﻨﺎ ﻗﺪ أﺧﺬﻧﺎ ﻣﻮﺿﻮع ﲤﺮﻳﺮ اﳌﻌﺎﻣﻼت ﰲ اﻟﻮﺳﺎﺋﻞ ﺑﺸﻜﻞ ﴎﻳﻊ ‪ ,‬ﻭﰲ ﻫﺬا اﻟﺪرس ﺳـﻮﻑ ﻧﺘﻌﻤـﻖ ﰲ ﻫـﺬا‬
‫اﳌﻮﺿﻮع ﻭ ﻟﻜﻦ ﻗﺒﻞ ذﻟﻚ أﻭد أﻥ أﻭﺿﺢ ﻧﻘﻄﺔ ﻣﻬﻤﺔ أﻻ ﻭ ﻫﻲ أﻧﻮاع اﳌﺘﻐﲑات ‪.‬‬

‫א ‪:‬‬ ‫א א‬
‫رﺑﲈ أﴍﻧﺎ ﻓﻴﲈ ﺳﺒﻖ ﻣﻦ اﻟﺪرﻭس أﻥ ﻫﻨﺎﻙ ﻧﻮﻋﺎﻥ ﻣﻦ اﳌﺘﻐﲑات ﻧﻮع ذﻭ ﻗﻴﻤﺔ ﻭ أﺧﺮ ذﻭ ﻣﺮﺟﻊ ‪.‬‬

‫اﻟﻨﻮع اﻷول ‪ :‬اﳌﺘﻐﻴﺮات اﻟﻘﻴﻤﻴﺔ‬

‫ﻭ ﻫﺬا اﻟﻨﻮع ﳛﻮﻱ ﻋﲆ اﻷﻧﻮاع اﻟﺘﺎﻟﻴﺔ ﻣﻦ اﻟﺒﻴﺎﻧﺎت ‪:‬‬
‫‪ −1‬اﻷﻋﺪاد اﻟﺼﺤﻴﺤﺔ )‪.(byte,sbyte,int,uint,long,ulong,char‬‬
‫‪ −2‬اﻷﻋﺪاد ذات اﻟﻨﻘﻄﺔ اﻟﻌﺎﺋﻤﺔ )‪.(double,float‬‬
‫‪ −3‬اﻷﻋﺪاد اﻟﻌﴩﻳﺔ )‪(decimal‬‬

‫‪ −4‬اﳌﺘﻐﲑات اﳌﻨﻄﻘﻴﺔ )‪(true,false‬‬

‫‪ −5‬اﻟﺴﺠﻼت ‪.structure‬‬
‫‪ −6‬اﻟﺘﻌﺪدﻳﺎت ‪Enumeration‬‬

‫ﻭﻫﻲ ﲢﻮﻱ ﻗﻴﻤﺔ اﳌﺘﻐﲑ ﻓﻘﻂ ‪ ,‬ﺑﺤﻴﺚ إذا ﻗﻤﺖ ﺑﺈﺳﻨﺎد ﻗﻴﻤﺔ ﻣﺘﻐﲑ إﱃ آﺧﺮ ﻓﺈﻥ ﻗﻴﻤﺘﻪ ﻫﻲ اﻟﺘﻲ ﻳﺘﻢ ﻧـﺴﺨﻬﺎ ‪,‬‬
‫ﻭ ﻃﺮﻳﻘﺔ اﺳﺘﻌﲈﻝ ﻫﺬا ﻧﻮع ﻣﻦ اﳌﺘﻐﲑات ﻫﻲ اﻟﺘﻲ ﻧﺴﺘﻌﻤﻠﻬﺎ ﻣﻦ أﻭﻝ درس ﰲ ﻫﺬﻩ اﻟﺪﻭرة ‪.‬‬

‫اﻟﻨﻮع اﻟﺜﺎﻧﻲ ‪ :‬اﳌﺘﻐﻴﺮات اﳌﺮﺟﻌﻴﺔ‬

‫ﻭﺗﺸﺘﻤﻞ اﻷﻧﻮاع اﻟﺘﺎﻟﻴﺔ ﻣﻦ اﻟﺒﻴﺎﻧﺎت ‪:‬‬
‫‪ −1‬اﻷﺻﻨﺎﻑ ‪ class‬ﻭ ﻣﻨﻬﺎ اﻟﺴﻼﺳﻞ اﳊﺮﻓﻴﺔ ‪ string‬ﻭ اﳌﺼﻔﻮﻓﺎت ‪. array‬‬
‫‪ −2‬اﻟﻮاﺟﻬﺎت ‪interface‬‬

‫‪ −3‬اﻟﻮﻛﻴﻞ ‪. delegate‬‬
‫ﻭ ﲢﻮﻱ ﻫﺬا اﻟﻨﻮع ﻣﻦ اﳌﺘﻐﲑات ﻋﲆ ﻣﺮﺟﻊ ﻟﻠﻜﺎﺋﻦ اﻟﺬﻱ ﻳﻤﺜﻠﻪ ﻫﺬا اﳌﺘﻐﲑ ‪ ,‬ﻓﻤﺜﻼ ﻗﺒﻞ أﻥ ﺗﺴﺘﺨﺪﻡ ﺻـﻨﻒ‬
‫ﳚﺐ ﻋﻠﻴﻚ ﲣﻠﻴﻘﻬﺎ أﻭﻻ ﺑﻮاﺳﻄﺔ اﳌﻌﺎﻣﻞ ‪ – new‬ﻛﲈ ﰲ اﻟﺪرس اﻟﺴﺎﺑﻖ – ﺛﻢ ﻳﻨﺸﺊ ﻣﺮاﺟﻊ إﱃ ذﻟﻚ اﻟﻜﺎﺋﻦ‬
‫ﺧﺬ اﳌﺜﺎﻝ اﻟﺘﺎﱄ ‪:‬‬
‫‪Myclass‬‬ ‫= ‪x‬‬ ‫;)(‪new Myclass‬‬
‫;‪Myclass y‬‬
‫;‪y = x‬‬

‫‪-1-‬‬
‫ﻗﻤﻨﺎ أﻭﻻ ﺑﺈﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻣﺮﺟﻌﻲ ﻭ إﺳﻨﺎدﻩ إﱃ ﻛﺎﺋﻦ اﻟﺬﻱ أﻧﺸﺄﻧﺎﻩ ﺑﻮاﺳﻄﺔ اﻟﻜﻠﻤـﺔ ‪ ,new‬ﻭ ﰲ اﻟـﺴﻄﺮ‬
‫اﻟﺜﺎﲏ ﻗﻤﻨﺎ ﺑﺈﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻣﺮﺟﻌﻲ ﻭ ﻟﻜﻦ ﻻ ﳛﻤﻞ أﻱ ﻣﺮﺟﻊ إﱃ ﻛﺎﺋﻦ ‪ ,‬ﰲ اﻟﺴﻄﺮ اﻟﺜﺎﻟـﺚ ﻗﻤﻨـﺎ ﺑﺈﺳـﻨﺎد‬
‫ﻗﻴﻤﺔ اﳌﺮﺟﻊ ‪ x‬إﱃ ‪ y‬ﺑﺤﻴﺚ أﺻﺒﺤﺎ ﻳﺸﲑاﻥ إﱃ ﻧﻔﺲ اﻟﻜﺎﺋﻦ ﻭ ﻟﻴﺲ ﻛﺎﺋﻨﲔ ﻣﻨﻔﺼﻠﲔ ‪.‬‬

‫‪:‬‬ ‫א‬ ‫א‬

‫ﻭ ذﻟﻚ ﺣﺴﺐ ﻣﺎ ﻗﻤﻨﺎ ﺑﻪ ﰲ اﻟﺪرس اﻟﺴﺎﺑﻖ ‪ ,‬ﺣﻴﺚ ﻳﻘﻮﻡ اﳌﱰﺟﻢ ﺑﺈرﺳﺎﻝ ﻧـﺴﺨﺔ ﻣـﻦ اﳌﺘﻐـﲑات ﻭ ﻟﻴـﺴﺖ‬
‫اﳌﺘﻐﲑات ﺑﻨﻔﺴﻬﺎ ‪ ,‬ﻭ ﻧﺘﻴﺠﺔ ذﻟﻚ أﻧﻪ إذا ﺣﺼﻠﺖ أﻱ ﺗﻐﲑات ﻋﲆ ﺗﻠﻚ اﻟﻨﺴﺦ ﻓﺈﻥ اﳌﺘﻐـﲑات اﻷﺻـﻠﻴﺔ ﻟـﻦ‬
‫ﺗﺘﺄﺛﺮ ﺧﺬ اﳌﺜﺎﻝ اﻟﺘﺎﱄ ‪:‬‬
‫;‪using System‬‬

‫‪class PassParmater‬‬
‫{‬
‫)(‪static void Main‬‬
‫{‬
‫;)(‪PassParmater Example = new PassParmater‬‬
‫;‪int x = 6, y = 5‬‬
‫;)‪Console.WriteLine("x = "+ x + "\t y = " + y‬‬
‫;)‪Example.ByValue(x,y‬‬
‫;)" ‪Console.WriteLine("After Passing Parmater‬‬
‫;)‪Console.WriteLine("x = "+ x + "\t y = " + y‬‬

‫}‬
‫)‪void ByValue(int x, int y‬‬
‫{‬
‫;‪x = 0‬‬
‫;‪y = 1‬‬
‫}‬
‫}‬
‫اﻟﻨﺎﺗﺞ ‪:‬‬

‫ﺑﺸﻜﻞ اﻓﱰاﴈ ﻳﺘﻢ ﲤﺮﻳﺮ اﳌﻌﺎﻣﻼت ﺳﻮاء أﻛﺎﻧﺖ ﻗﻴﻤﻴﺔ أﻡ ﻣﺮﺟﻌﻴﺔ ﺑﻮاﺳﻄﺔ ﻗﻴﻤﺘﻬﺎ ) أﻱ ﳎﺮد إرﺳﺎﻝ ﻧـﺴﺦ‬
‫ﻣﻨﻬﺎ ( ‪.‬‬
‫ﺣﺘﻰ اﻵﻥ اﳉﺰء اﳋﺎص ﺑﺎﳌﺘﻐﲑات اﻟﻘﻴﻤﻴﺔ ﻗﺪ ﺗﻢ ﴍﺣﻪ ‪ ,‬أﻣﺎ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺘﻐﲑات اﳌﺮﺟﻌﻴﺔ ﻓﺈﻧﻪ ﻳﺘﻢ إرﺳﺎﻝ‬
‫ﻧﺴﺨﺔ ﻣﻦ اﳌﺮﺟﻊ ﻭ ﻟﻴﺲ اﻟﻜﺎﺋﻦ ‪ ,‬ﻭﻋﲆ اﻟﻌﻜﺲ ﻓﺈذا ﺣﺪث أﻱ ﺗﻐﲑ ﻋﲆ اﳌﺘﻐﲑات ﰲ اﻟﻮﺳﻴﻠﺔ ﻓﺈﻧﻪ ﺳﻮﻑ‬
‫ﻳﺆﺛﺮ ﻋﲆ اﻟﻜﺎﺋﻦ ﻭ ﻟﻜﻦ ﻟﻦ ﻳﺆﺛﺮ ﻋﲆ اﳌﺮﺟﻊ ﻧﻔﺴﻪ ‪.‬‬
‫ﻗﺪ ﻳﻜﻮﻥ اﻷﻣﺮ ﻣﺮﺑﻚ ﻗﻠﻴﻼ ‪ ,‬ﻭ ﻟﻜﻦ ﺗﺬﻛﺮ أﻥ اﳌﺘﻐﲑات اﳌﺮﺟﻌﻴﺔ ﻫﻲ ﳎﺮد ﻣﺆﴍات أﻭ ﻣﺮاﺟﻊ إﱃ ﻛﺎﺋﻨﺎت‬
‫ﻣﺴﺘﻘﻠﺔ ‪ ,‬ﺳﻨﺄﺧﺬ أﻣﺜﻠﺔ ﻋﲆ ﲤﺮﻳﺮ اﻷﻧﻮاع اﳌﺮﺟﻌﻴﺔ ﰲ اﻟﺪرﻭس اﻟﻘﺎدﻣﺔ ﺑﺈذﻥ اﷲ ﺗﻌﺎﱃ ‪.‬‬

‫‪-2-‬‬
‫ﳑﺎ ﻳﻌﺎب ﻋﲆ اﻟﻄﺮﻳﻘﺔ اﻷﻭﱃ ) أﻱ ﻃﺮﻳﻘﺔ ﲤﺮﻳﺮ اﳌﻌﺎﻣﻼت ( ﻫﻲ أﳖﺎ ﻻ ﺗﺮﺟﻊ إﻻ ﻗﻴﻤﺔ ﻭاﺣﺪة ﻓﻘﻂ ﳑﺎ ﻳﺆدﻱ‬
‫إﱃ ﻓﺼﻞ اﻟﻮﺳﻴﻠﺔ اﳌﱰاﺑﻄﺔ إﱃ ﻭﺳﻴﻠﺘﲔ ﻓﻠﻬﺬا ‪ ,‬ﻗﺮر ﳐﱰﻋﻮ ﻟﻐﺔ اﻟﴘ ﺷﺎرب اﺧﱰاع ﻃﺮﻳﻘﺔ ﻹرﺟـﺎع أﻛﺜـﺮ‬
‫ﻣﻦ ﻗﻴﻤﺔ ﰲ ﻭﺳﻴﻠﺔ ‪.‬‬
‫ﻋﲆ اﻟﻌﻤﻮﻡ ﺗﻌﺘﻤﺪ ﻫﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻋﲆ ﻣﺎ ﻳﺴﻤﻰ ﲤﺮﻳﺮ اﳌﻌﺎﻣﻼت ﺑﻮاﺳﻄﺔ ﻣﺮاﺟﻌﻬـﺎ ‪ ,‬ﻟﺘﺒـﺴﻴﻂ ﻫـﺬﻩ اﻟﻌﻤﻠﻴـﺔ‬
‫دﻋﻨﺎ ﻧﺄﺧﺬ ﻣﺘﻐﲑ ﻗﻴﻤﻲ ﻭ ﻧﻤﺮرﻩ ﺑﻮاﺳﻄﺔ ﻣﺮاﺟﻌﻪ ﻭ ﻧﻘﺎرﻥ اﻟﻨﺘﻴﺠﺔ‪ ,‬اﻧﻈﺮ اﳉﺪﻭﻝ اﻟﺘﺎﱄ ‪:‬‬
‫ﻫﻞ ﻳﺘﺄﺛﺮ اﳌﺘﻐﲑ اﻷﺻﲇ?‬ ‫ﻣﺎذا ﻳﻤﺮر ?‬ ‫ﻣﺘﻐﲑ ﻗﻴﻤﻲ‬
‫ﻻ‬ ‫ﻧﺴﺨﺔ ﻣﻦ اﳌﺘﻐﲑ‬ ‫ﺑﻮاﺳﻄﺔ ﻗﻴﻤﺘﻬﺎ‬
‫ﻧﻌﻢ‬ ‫اﳌﺘﻐﲑ ﻧﻔﺴﻪ‬ ‫ﺑﻮاﺳﻄﺔ ﻣﺮﺟﻌﻬﺎ‬
‫ﻭ ﻗﺒﻞ أﻥ ﻧﺄﺧﺬ ﻣﺜﺎﻝ ﻋﲆ ﻛﻴﻔﻴﺔ ﲤﺮﻳﺮ اﳌﻌﺎﻣﻼت ﺑﻮاﺳﻄﺔ ﻣﺮاﺟﻌﻬـﺎ ﳚـﺐ ﻋﻠﻴﻨـﺎ أﻥ ﻧﻨـﻮﻩ أﻥ ﻫﻨـﺎﻙ ﻛﻠﻤﺘـﺎﻥ‬
‫ﳏﺠﻮزﺗﺎﻥ ﻟﺘﻤﺮﻳﺮ اﳌﻌﺎﻣﻼت ﺑﻮاﺳﻄﺔ ﻣﺮاﺟﻌﻬﺎ أﻻ ﻭ ﳘﺎ ‪ ref‬ﻭ ‪ out‬ﻭ اﻟﻔﺮﻕ ﺑﻴﻨﻬﲈ أﻥ ‪ out‬ﻻ ﲢﺘﺎج‬
‫أﻥ ﻳﻜﻮﻥ اﳌﺘﻐﲑ ﻣﺴﻨﺪ إﻟﻴﻪ ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ ﺑﻌﺪ اﻹﻋﻼﻥ ﻋﻨﻪ أﻣﺎ ‪ ref‬ﻓﻬﻲ ﲢﺘﺎج إﱃ ذﻟﻚ ‪ ,‬ﻭ اﻵﻥ إﱃ اﳌﺜﺎﻝ ‪:‬‬
‫;‪using System‬‬
‫‪class PassByRef‬‬
‫{‬
‫)(‪static void Main‬‬
‫{‬
‫;)(‪PassByRef exmple = new PassByRef‬‬
‫;‪int Number1, Number2‬‬
‫ﻟﻜﻲ ﳕﺮرهﺎ ﺑﻮاﺳﻄﺔ‪int sum = 0; // Ref‬‬
‫;)‪exmple.GetValue(out Number1, out Number2‬‬
‫;)‪exmple.Sum(ref sum,Number1,Number2‬‬
‫;)‪Console.WriteLine("Sum = " + sum‬‬
‫}‬
‫)‪void GetValue(out int x, out int y‬‬
‫{‬
‫;)" ‪Console.Write("Enter number 1 :‬‬
‫;))(‪x = Int32.Parse(Console.ReadLine‬‬
‫;)" ‪Console.Write("Enter number 2 :‬‬
‫;))(‪y = Int32.Parse(Console.ReadLine‬‬
‫}‬
‫)‪void Sum(ref int sum, int x, int y‬‬
‫{‬
‫;‪sum = x + y‬‬
‫}‬
‫}‬
‫اﻟﻨﺎﺗﺞ ‪:‬‬

‫‪-3-‬‬
‫ﻫﺬا ﺑﺨﺼﻮص اﳌﺘﻐﲑات اﻟﻘﻴﻤﻴﺔ أﻣﺎ اﳌﺘﻐﲑات اﳌﺮﺟﻌﻴﺔ ﻓﺎﳉﺪﻭﻝ اﻟﺘﺎﱄ ﻳﴩح ﻣﺎذا ﳛﺪث ﰲ ﺣﺎﻟـﺔ ﲤﺮﻳﺮﻫـﺎ‬
‫ﺑﻮاﺳﻄﺔ ﻗﻴﻤﺘﻬﺎ ﻭ ﻣﺮاﺟﻌﻬﺎ ‪:‬‬
‫ﻣﺎذا ﳛﺪث?‬ ‫ﻣﺎذا ﻳﻤﺮر ?‬ ‫ﻣﺘﻐﲑات ﻣﺮﺟﻌﻴﺔ‬
‫ﻳﺘﺄﺛﺮ اﻟﻜﺎﺋﻦ ﻓﻘﻂ دﻭﻥ اﳌﺮﺟﻊ‬ ‫ﻧﺴﺨﺔ ﻣﻦ اﳌﺮﺟﻊ‬ ‫ﺑﻮاﺳﻄﺔ ﻗﻴﻤﺘﻬﺎ‬
‫ﻳﺘﺄﺛﺮ اﳌﺮﺟﻊ ﻭ اﻟﻜﺎﺋﻦ ‪ ,‬ﻭ ﻟﻜﻦ إذا‬ ‫اﳌﺮﺟﻊ ﻧﻔﺴﻪ‬ ‫ﺑﻮاﺳﻄﺔ ﻣﺮﺟﻌﻬﺎ‬
‫ﺗﻐﲑ اﳌﺮﺟﻊ ﻓﺈﻧﻨﺎ ﺳﻮﻑ ﻧﻔﻘﺪ‬
‫اﻟﻜﺎﺋﻦ‬
‫ﻗﺪ ﺗﺮﻳﺪ ﺑﻌﺾ اﻷﻣﺜﻠﺔ ﻋﲆ اﳌﺘﻐﲑات اﳌﺮﺟﻌﻴﺔ ﻋﻨﺪﻣﺎ ﲤﺮر ﺑﻮاﺳﻄﺔ ﻗﻴﻤﺘﻬﺎ ﻭ ﻣﺮاﺟﻌﻬﺎ ‪ ,‬ﻭ ﻟﻜـﻦ أﺳـﺘﻤﻴﺤﻚ‬
‫أﻥ ﺗﺆﺟﻞ ﻫﺬا ﺣﺘﻰ اﻟﺪرس اﻟﻘﺎدﻡ ﻋﻨﺪ دراﺳﺘﻨﺎ ﻟﻠﻤﺼﻔﻮﻓﺎت ‪ ,‬ﺳﻮﻑ ﻧﺘﻌﺮض ﳍﺬﻩ اﻷﻣﺜﻠﺔ ‪.‬‬

‫‪:‬‬ ‫א‬
‫ﰲ ﻛﺜﲑ ﻣﻦ اﻷﺣﻴﺎﻥ ﺗﺮﻳـﺪ أﻥ ﺗـﺴﺘﻌﻤﻞ ﻭﺳـﻴﻠﺔ ﻣﻌﻴﻨـﺔ ﻷداء ﻣﻬﻤـﺔ ﳏـﺪدة ﻭﻟﻜـﻦ ﳚـﺐ أﻥ ﻳﺘﺨﻠـﻒ ﻧـﻮع‬
‫اﳌﻌﺎﻣﻼت ﰲ ﻛﻞ ﻣﺮة ﻭ رﺑﲈ ﻋﺪدﻫﺎ ‪.‬‬
‫ﻭ ﻟﻜﻲ أﻗﺮب ﻟﻚ ﻫﺬا اﳌﻔﻬﻮﻡ ﺗﺼﻮر أﻧﻚ ﺗﺮﻳﺪ أﻥ ﺗﻨﺸﺊ ﻭﺳﻴﻠﺔ ﺗﻘﻮﻡ ﺑﻌﻤﻠﻴﺔ ﲨﻊ ﻟﺜﻼث ﻣﺘﻐﲑات ‪ ,‬ﻳﻤﻜﻨﻚ‬
‫أﻥ ﺗﻨﺸﺊ ﻭﺳﻴﻠﺔ ﻟﻠﻤﺘﻐﲑات ‪ int‬ﻭ أﺧﺮ￯ ‪ double‬ﺑﻨﻔﺲ اﻻﺳﻢ ‪.‬‬
‫ﻭ ﻫﺬا ﻫﻮ اﳌﺜﺎﻝ ﻣﻜﺘﻮب ﳍﺬﻩ اﻟﻮﺳﻴﻠﺔ ‪:‬‬
‫;‪using System‬‬
‫‪class AddThree‬‬
‫{‬
‫)(‪static void Main‬‬
‫{‬
‫;)(‪AddThree exmple = new AddThree‬‬
‫;‪int x1 = 2, x2 = 3, x3 = 5‬‬
‫;‪double y1= 3.0, y2 = 6.0, y3 = 4.0‬‬
‫;))‪Console.WriteLine(exmple.Add(x1,x2,x3‬‬
‫;))‪Console.WriteLine(exmple.Add(y1,y2,y3‬‬
‫}‬
‫)‪int Add (int x, int y, int z‬‬
‫{‬
‫;‪return x + y + z‬‬
‫}‬
‫)‪double Add (double x, double y, double z‬‬
‫{‬
‫;‪return x + y + z‬‬
‫}‬
‫}‬

‫‪-4-‬‬
 ‫اﻟﻨﺎﺗﺞ ‪:‬‬

‫ﺗﺮ￯ ﺑﻮﺿﻮح ﻛﻴﻒ أﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺈﻋﺎدة ﺗﻌﺮﻳﻒ اﻟﻮﺳﻴﻠﺔ ‪ Add‬ﻣﺮة ﻟﻠﻤﺘﻐﲑات ﻣﻦ ﻧـﻮع ‪ int‬ﻭ ﻣـﺮة ﻣـﻦ ﻧـﻮع‬
‫‪ , double‬ﻭ ﻳﻤﻜﻨﻚ أﻥ ﺗﺰﻳﺪ ﻭ أﻥ ﻧﻨﻘﺺ ﻣﻦ ﻋﺪد اﳌﻌﺎﻣﻼت ﻭ ﺗﻐﲑ ﻧﻮع اﻟﺮاﺟﻊ ﻛﲈ ﺗﺮﻳﺪ ‪.‬‬
‫ﻗﺪ ﺗﻜﻮﻥ ﻫﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻓﻴﻬﺎ ﳾء ﻣﻦ اﻟﺮﺗﺎﺑﺔ ﻭ اﻟﺘﻜﺮار ﻭ ﻗﺪ ﺗﻢ ﺗﻼﰲ ﻫﺬﻩ اﳌﺸﻜﻠﺔ ﰲ اﻹﺻﺪار اﻟﺜﺎﲏ ﻣﻦ ﻟﻐـﺔ‬
‫اﻟﴘ ﺷﺎرب ﺑﲈ ﻳﺴﻤﻰ اﻟﺘﻌﻤﻴﻢ ‪ ,‬ﻭ ﻫﻮ ﻟﻴﺲ ﰲ ﻧﻄﺎﻕ ﻫﺬﻩ اﻟﺪرﻭس ‪.‬‬

‫‪:‬‬ ‫א‬ ‫א‬

‫ﻳﻌﺮﻑ ﻋﻤﺮ اﳌﺘﻐﲑ ﺑﺄﻧﻪ اﳌﺪة اﻟﺘﻲ ﻳﻮﺟﺪ ﻓﻴﻬﺎ اﳌﺘﻐﲑ ﰲ اﻟـﺬاﻛﺮة ‪ ,‬ﻓـﺎﳌﺘﻐﲑات اﻟﺘـﻲ ﺗﻮﺟـﺪ ﰲ اﻟﻮﺳـﻴﻠﺔ ﻳﺒـﺪأ‬
‫ﻋﻤﺮﻫﺎ ﻋﻨﺪﻣﺎ ﻳﺒﺪأ اﳌﱰﺟﻢ ﰲ ﺗﻨﻔﻴﺬ اﳉﻤﻞ اﻟﺘﻲ ﻧﻌﻠﻦ ﻋﻨﻬﺎ ﻭﺗﻨﺘﻬﻲ ﻋﻨﺪﻣﺎ ﻳﻨﺘﻬـﻲ اﳌـﱰﺟﻢ ﻣـﻦ ﺗﻨﻔﻴـﺬ ﺗﻠـﻚ‬
‫اﻟﻮﺳﻴﻠﺔ ‪ ,‬ﺗﺴﻤﻰ ﻫﺬﻩ اﳌﺘﻐﲑات ﺑﺎﳌﺘﻐﲑات ذات اﻟﻌﻤﺮ اﻵﱄ ‪ ,‬أﻱ أﳖﺎ ﺗﺒﺪأ ﻋﻨﺪﻣﺎ ﻳﺼﻞ اﻟﱪﻧـﺎﻣﺞ إﱃ ﻣﻜـﺎﻥ‬
‫إﻋﻼﳖﺎ ﻭ ﺗﺒﻘﻰ ﻣﺎ داﻣﺖ اﻟﻘﻄﻌﺔ اﻟﱪﳎﻴﺔ اﻟﺘﻲ ﺗﻮﺟﺪ ﻓﻴﻬﺎ ) ﺻـﻨﻒ ‪ ,‬ﻭﺳـﻴﻠﺔ ‪ ,‬ﺣﻠﻘـﺔ ﺗﻜﺮارﻳـﺔ ( ﻧـﺸﻄﺔ ‪ ,‬ﻭ‬
‫ﺗﻨﺘﻬﻲ ﺑﺎﻧﺘﻬﺎء ﺗﻠﻚ اﻟﻘﻄﻌﺔ ‪.‬‬
‫ﻭ ﻳﻮﺟﺪ ﻫﻨﺎﻙ ﻧﻮع ﺛﺎﻥ ﻣﻦ اﳌﺘﻐﲑات ﺗﺴﻤﻰ ﻣﺘﻐﲑات ﻋﻤﺮ ﺛﺎﺑﺖ ‪ ,‬ﻭ ﻫﺬﻩ اﳌﺘﻐﲑات ﺗﺒﻘﻰ ﰲ اﻟﺬاﻛﺮة ﺑﻌـﺪ أﻥ‬
‫ﻳﺘﻢ اﻹﻋﻼﻥ ﻋﻨﻬﺎ ﻭ ﳍﺎ ﻛﻠﻤﺔ ﳏﻔﻮﻇﺔ ﻭ ﻫﻲ ‪ static‬ﻭ ﻟﻨﺎ ﳍﺬﻩ اﻟﻜﻠﻤﺔ ﻋﻮدة ﺑﺈذﻥ اﷲ ﺗﻌﺎﱃ ‪.‬‬

‫א ‪:‬‬ ‫א‬
‫ﻭ ﻫﻮ ﻣﺪ￯ اﻟﺬﻱ ﻳﻤﻜﻦ ﻣﻦ ﺧﻼﻟﻪ أﻥ ﺗﺼﻞ إﱃ اﳌﺘﻐﲑ ‪ ,‬ﻭ ﻫﺬﻩ اﳋﺎﺻﻴﺔ ﻣﺮﺗﺒﻄﺔ ﺑﺎﻟﺘﻲ ﻗﺒﻠﻬﺎ ارﺗﺒﺎط ﻭﺛﻴﻖ ‪ ,‬ﻭ‬
‫ﻟﻜﻦ اﻟﻔﺮﻕ اﻟﻮﺣﻴﺪ أﻥ ﻟﻴﺲ ﻛﻞ ﻣﺘﻐﲑ ﻣﻮﺟﻮد ﻳﻤﻜﻦ اﻟﻮﺻﻮﻝ إﻟﻴﻪ ﻭ ﻟﻜﻦ ﻛﻞ ﻣﺘﻐﲑ ﻳﻤﻜﻦ اﻟﻮﺻﻮﻝ إﻟﻴـﻪ‬
‫ﻓﻬﻮ ﻣﻮﺟﻮد ‪.‬‬
‫ﻋﲆ اﻟﻌﻤﻮﻡ ﻭ ﻛﻘﺎﻋﺪة ﻓﺈﻥ ﳎﺎﻝ اﳌﺘﻐـﲑ ﻫـﻮ اﻟﻘﻄﻌـﺔ اﻟﱪﳎﻴـﺔ اﻟﺘـﻲ ﲢﻮﻳـﻪ ) اﻟـﺼﻨﻒ ‪ ,‬اﻟﻮﺳـﻴﻠﺔ ‪ ,‬اﳊﻠﻘـﺔ‬
‫اﻟﺘﻜﺮارﻳﺔ ( ﻭ اﻟﺘﻲ ﺗﺒﺪأ ﺑـ { ﻭ ﺗﻨﺘﻬﻲ ﺑـ } ‪ ,‬ﻭ اﻟﻘﺎﻋﺪة اﻟﺜﺎﻧﻴﺔ أﻧﻪ إذا ﻛﺎﻥ ﻫﻨﺎﻙ ﻣﺘﻐـﲑاﻥ ﺑـﻨﻔﺲ اﻻﺳـﻢ ﰲ‬
‫اﻟﺼﻨﻒ ﻭ اﻟﻮﺳﻴﻠﺔ ﻓﺈﻥ اﻟﱪﻧﺎﻣﺞ ﻳﺄﺧﺬ اﻟﺬﻱ ﻳﻮﺟﺪ ﰲ ﻧﻔﺲ اﻟﻘﻄﻌﺔ اﻟﱪﳎﻴﺔ ‪ ,‬ﻭ اﳌﺜﺎﻝ اﻟﺘﺎﱄ ﻳﻮﺿﺢ ذﻟﻚ ‪:‬‬
‫;‪using System‬‬
‫‪class Scope‬‬
‫{‬
‫;‪int x = 1‬‬
‫)(‪void MethodA‬‬
‫{‬
‫;‪int x = 25‬‬
‫‪Console.WriteLine("Local x in MethodA is " + x‬‬
‫;)"‪+ " After Entering MethodA‬‬
‫;‪++ x‬‬
‫‪Console.WriteLine("Local x in MethodA is " + x‬‬

‫‪-5-‬‬
 ‫;)"‪+ " before exiting MethodA‬‬
‫}‬
‫)(‪void MethodB‬‬
‫{‬
‫‪Console.WriteLine("Instance variable x is " + x‬‬
‫;)"‪+ " on entering MethodB‬‬
‫;‪x = 10‬‬
‫‪Console.WriteLine("Instance variable x is " + x‬‬
‫;)"‪+ " before exiting MethodB‬‬
‫}‬
‫)(‪static void Main‬‬
‫{‬
‫;)(‪Scope example = new Scope‬‬
‫;‪int x = 5‬‬
‫;)‪Console.WriteLine("Local x in Main is " + x‬‬
‫;)(‪example.MethodA‬‬
‫;)(‪example.MethodB‬‬
‫;)(‪example.MethodA‬‬
‫;)(‪example.MethodB‬‬
‫‪}// end Main‬‬
‫‪}// end Scope class‬‬
‫اﳌﺨﺮﺟﺎت ‪:‬‬

‫ﺗﺮ￯ أﻧﻪ ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﻫﺬا اﻟﱪﻧﺎﻣﺞ ﻓﺈﻥ اﻟﻮﺳﻴﻠﺔ ‪ Main‬ﻭ ‪ MethodA‬ﺗﺴﺘﺨﺪﻡ اﳌﺘﻐﲑ اﳌﺤـﲇ ) اﳌﻮﺟـﻮد‬
‫ﰲ اﻟﻮﺳﻴﻠﺔ ﻧﻔﺴﻬﺎ ( ‪ x‬ﺑﺪﻻ ﻣﻦ اﳌﺘﻐﲑ اﻟﻌﺎﻡ اﻟﺬﻱ ﻳﻮﺟﺪ ﰲ اﻟﺼﻨﻒ‪ ,‬ﻭ ﻛﺬﻟﻚ ﺗﻼﺣﻆ أﻥ اﳌﺘﻐﲑات اﻟﻌﺎﻣﺔ‬
‫ﻳﻤﻜﻦ أﻥ ﺗﺴﺘﺨﺪﻡ ﰲ أﻱ ﻣﻜﺎﻥ ﰲ اﻟﺼﻨﻒ ﻟﻴﺲ ﻣﺜﻞ اﳌﺘﻐﲑات اﳌﺤﻠﻴﺔ اﻟﺘﻲ ﺗﻨﺘﻬﻲ ﺑﺎﻧﺘﻬﺎء اﻟﻮﺳﻴﻠﺔ ‪.‬‬

‫‪:‬‬ ‫א א‬ ‫א‬
‫ﻳﻘﺼﺪ ﺑﺎﻟﺘﻜﺮار اﻟﻌﻮدﻱ ﺑﺄﻥ اﻟﻮﺳﻴﻠﺔ ﺗﺴﺘﻄﻴﻊ ﻣﻨﺎداة ﻧﻔﺴﻬﺎ ‪ ,‬اﳌﻤﺘﻊ ﰲ اﻷﻣﺮ أﻥ ﻫﺬﻩ اﳋﺎﺻﻴﺔ ﺗـﺴﻬﻞ اﻟﻜﺜـﲑ‬
‫ﻣﻦ اﻟﻌﺐء ﻋﲆ اﳌﱪﳎﲔ ﻣﻦ ﻋﺸﺎﻕ اﻟﺮﻳﺎﺿﻴﺎت ‪ ,‬ﻭ ﻟﺘﺘﻀﺢ اﻟﺼﻮرة أﻛﺜﺮ ﺧﺬ ﻣﺜﺎﻝ ﻣﴬﻭب اﻟﻌﺪد ! ﻓﻤـﺜﻼ‬
‫ﻣﴬﻭب ﲬﺴﺔ ﻫﻮ ‪:‬‬
‫!‪5‬‬ ‫=‬ ‫‪5* 4*3*2*1‬‬
‫!‪4‬‬ ‫=‬ ‫‪4*3*2*1‬‬
‫!‪3‬‬ ‫=‬ ‫‪3*2*1‬‬
‫!‪2‬‬ ‫=‬ ‫‪2*1‬‬
‫!‪1‬‬ ‫=‬ ‫‪1‬‬
‫ﺑﻄﺮﻳﻘﺔ اﳊﻠﻘﺔ اﻟﺘﻜﺮارﻳﺔ ﻳﻤﻜﻨﻚ ﺣﻞ !‪ 5‬ﻛﺎﻟﺘﺎﱄ ‪:‬‬
‫;‪factorial = 1‬‬
‫)‪for ( int counter = 5; counter >= 1; counter --‬‬
‫‪factorial *= counter‬‬

‫‪-6-‬‬
 ‫أﻣﺎ ﺑﻄﺮﻳﻘﺔ اﻟﺘﻜﺮار اﻟﻌﻮدﻱ ﻓﻘﺎﻧﻮﻥ اﳌﴬﻭب ﰲ اﻟﺮﻳﺎﺿﻴﺎت ﻳﻘﻮﻝ اﻟﺘﺎﱄ ‪:‬‬
‫!)‪n! = n(n-1‬‬
‫)‪long factorial(long number‬‬
‫{‬
‫اﻷﺳﺎﺳﻴﺔ اﳊﺎﻟﺔ‪if ( number <= 1) //‬‬
‫;‪return 1‬‬
‫‪else‬‬
‫;)‪return number * factorial(number -1‬‬
‫}‬
‫ﻭﺣﺘﻰ ﻻ ﻳﺴﲑ اﻟﺘﻜﺮار اﻟﻌﻮدﻱ إﱃ ﻣﺎ ﻻ ﳖﺎﻳﺔ ﳚﺐ أﻥ ﻳﻜﻮﻥ ﻟﻪ ﴍط ﻭ ﻫﻮ اﳊﺎﻟـﺔ اﻷﺳﺎﺳـﻴﺔ ‪ ,‬ﻓﻔـﻲ ﺣﺎﻟـﺔ‬
‫اﳌﴬﻭب ﻛﺎﻧﺖ اﳊﺎﻟﺔ اﻷﺳﺎﺳﻴﺔ ﻫﻲ أﻥ ﻣﴬﻭب ‪ 1‬ﻳﺴﺎﻭﻱ ‪.1‬‬
‫ﻳﻘﻮﻡ اﻟﱪﻧﺎﻣﺞ ﰲ اﻟﺘﻜﺮار اﻟﻌﻮدﻱ ﺑﺤﻔﻆ ﻧﺴﺨﺔ ﻣﻦ ﻣﺘﻐﲑات ﰲ ﻛﻞ ﻣﺮة ﻳﻘﻮﻡ ﺑﺎﺳﺘﺪﻋﺎء اﻟﻮﺳﻴﻠﺔ ‪ ,‬ﻓﻤـﺜﻼ ﰲ‬
‫ﻣﴬﻭب ﲬﺴﺔ ﻳﻘﻮﻡ أﻭﻻ ﺑﺤﻔﻆ اﻟﺮﻗﻢ ﲬﺴﺔ ‪ ,‬ﻭ ﻳﺴﺘﺪﻋﻲ اﳌﴬﻭب ‪ , 4‬ﻭ ﰲ ﻣﴬﻭب أرﺑﻌﺔ ﻳﻘﻮﻡ ﺑﺤﻔـﻆ‬
‫اﻟﺮﻗﻢ ‪ , 4‬ﻭ ﻳﺴﺘﺪﻋﻲ ﻣﴬﻭب ﺛﻼﺛﺔ ﻭ ﻫﻜﺬا ﺣﺘﻰ ﻳـﺼﻞ إﱃ ﻣـﴬﻭب ﻭاﺣـﺪ ﻭﻫـﻮ ﻭاﺣـﺪ ﺣﻴـﺚ ﺗﻘـﻮﻡ‬
‫اﻟﻮﺳﻴﻠﺔ ﺑﺈرﺟﺎع ﻭاﺣﺪ‪ ,‬ﺑﻌﺪ ذﻟﻚ ﻳﻘﻮﻡ اﻟﱪﻧﺎﻣﺞ ﺑﺤﺴﺎب ﻣﴬﻭب اﺛﻨـﺎﻥ ﻭ ﻣـﻦ ﺛـﻢ ﺛﻼﺛـﺔ ﺣﺘـﻰ اﳋﻤـﺴﺔ‬
‫ﻣﺴﺘﺨﺪﻣﺎ اﳌﺘﻐﲑات اﻟﺘﻲ ﺣﻔﻈﻬﺎ ﺳﺎﺑﻘﺎ ‪ ,‬اﻟﺸﻜﻞ اﻟﺘﺎﱄ ﻳﻮﺿﺢ ﻫﺬﻩ اﻟﻌﻤﻠﻴﺔ ‪:‬‬

‫ﻗﺪ ﺗﻜﻮﻥ ﺳﻬﻮﻟﺔ ﺣﻞ اﻟﺘﻜﺮار ﺣﻞ اﻟﺘﻜﺮار اﻟﻌﻮدﻱ ﻫﻮ ﺷﻔﻴﻊ ﻟﺒﻘﺎﺋﻬﺎ ﻓﻬﻲ ﺗﺄﻛﻞ اﻟﺬاﻛﺮة أﻛﻼ ‪ ,‬ﻭ ﻻ ﺗﻔـﻀﻞ‬
‫ﰲ اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﺔ اﳌﻌﻘﺪة ﻭ ﻟﻜﻦ ﰲ اﳌﻌﺎدﻻت ﻏﲑ اﳌﻌﻘﺪة ﻻ ﺑﺄس ﲠﺎ ‪.‬‬

‫‪-7-‬‬
 ‫اﻟﻮاﺟﺐ ‪:‬‬
‫‪ −1‬ﻧﻘﻮﻝ ﻋﻦ ﻋﺪد ﺻﺤﻴﺢ أﻧﻪ ﻋﺪد ﺗﺎﻡ ‪ Perfect number‬إذا ﻛﺎﻥ ﳎﻤﻮع ﻋﻮاﻣﻠـﻪ اﻷﻭﻟﻴـﺔ‬
‫‪ factors‬ﺑﲈ ﻓﻴﻬﺎ اﻟﻌﺪد ‪ ) 1‬ﻣﺎ ﻋﺪا اﻟﻌﺪد ﻧﻔﺴﻪ ( ﺳﺎﻭﻱ اﻟﻌﺪد ذاﺗﻪ ‪ ,‬ﻋﲆ ﺳﺒﻴﻞ اﳌﺜﺎﻝ ‪ ,‬ﻟﺪﻳﻨﺎ ‪6‬‬
‫ﻋﺒﺎرة ﻋﻦ ﻋﺪد ﺗﺎﻡ ﻷﻥ ‪ , 3+ 2+ 1 = 6‬اﻛﺘﺐ ﻭﺳﻴﻠﺔ ﺗﺴﺘﻘﺒﻞ ﻋﺪد ﺛﻢ ﲢﺪد إذا ﻛـﺎﻥ ﺗﺎﻣـﺎ أﻡ ﻻ ‪,‬‬
‫اﺳﺘﺨﺪﻡ ﻫﺬﻩ اﻟﻮﺳﻴﻠﺔ ﰲ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮﻡ ﺑﺘﺤﺪﻳـﺪ ﻭ ﻃﺒﺎﻋـﺔ ﻛﺎﻓـﺔ اﻷﻋـﺪاد اﻟﺘﺎﻣـﺔ اﳌﺤـﺼﻮرة ﺑـﲔ‬
‫اﻟﻌﺪدﻳﻦ ‪ 1‬ﻭ ‪ , 1000‬أﻃﺒﻊ أﻳﻀﺎ اﻟﻌﻮاﻣﻞ اﻷﻭﻟﻴﺔ ﻟﻜﻞ ﻋﺪد ﺗﺎﻡ ﻭ ﺗﺄﻛﺪ أﻥ ﳎﻤﻮع ﻫـﺬﻩ اﻟﻌﻮاﻣـﻞ‬
‫ﻳﺴﺎﻭﻱ اﻟﻌﺪد ﻧﻔﺴﻪ ‪.‬‬
‫‪ −2‬ﻧﻘﻮﻝ ﻋﻦ ﻋﺪد ﺻﺤﻴﺢ اﻧﻪ أﻭﱄ ‪ prime‬إذا ﻛﺎﻥ ﻻ ﻳﻘﺒﻞ اﻟﻘﺴﻤﺔ إﻻ ﻋﲆ ﻧﻔـﺴﻪ ﻭ ﻋـﲆ اﻟﻮاﺣـﺪ ‪,‬‬
‫ﻋﲆ ﺳﺒﻴﻞ اﳌﺜﺎﻝ ‪ ,‬ﻟﺪﻳﻨﺎ ‪ 7 , 5 ,3 , 2‬ﳎﻮﻋﺔ أﻋﺪاد أﻭﻟﻴﺔ ‪ ,‬ﻟﻜـﻦ اﻷﻋـﺪاد ‪ , 9 , 8 , 6 , 4‬ﻟﻴـﺴﺖ‬
‫أﻋﺪاد أﻭﻟﻴﺔ ‪:‬‬
‫أ‪ −‬اﻛﺘﺐ ﻭﺳﻴﻠﺔ ﲢﺪد ﻓﻴﲈ إذا ﻛﺎﻥ ﻋﺪدا ﻣﺎ أﻭﻟﻴﺎ أﻡ ﻻ ‪.‬‬
‫ب‪−‬اﺳﺘﺨﺪﻡ اﻟﻮﺳﻴﻠﺔ اﻟﺴﺎﺑﻖ ﺿﻤﻦ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺤﺪﻳﺪ ﻭ ﻃﺒﺎﻋﺔ ﲨﻴﻊ ا ﻷﻋﺪاد اﻷﻭﻟﻴﺔ اﻟﺘﻲ ﺑـﲔ‬
‫اﻟﻌﺪدﻳﻦ ‪ 1‬ﻭ ‪. 10000‬‬
‫‪ −3‬ﻧﺴﻤﻲ أﻛﱪ ﻋﺪد ﺻﺤﻴﺢ ﻗﺎدر ﻋﲆ ﻗﺴﻤﺔ ﻋﺪدﻳﻦ ﺻﺤﻴﺤﲔ ﺑﺪﻭﻥ ﺑﺎﻗﻲ ﺑﺎﻟﻘﺎﺳﻢ اﳌﺸﱰﻙ اﻷﻋﻈـﻢ‬
‫‪ ,‬اﻛﺘﺐ ﻭﺳﻴﻠﺔ ﻋﻮدﻳﺔ ‪ ,‬ﺗﺴﺘﻘﺒﻞ ﻋﺪدﻳﻦ ‪ ,‬ﻭ ﺗﺮﺟـﻊ اﻟﻘﺎﺳـﻢ اﳌـﺸﱰﻙ اﻷﻋﻈـﻢ ‪ ,‬ﺑﺤﻴـﺚ إذا ﻛـﺎﻥ‬
‫اﻟﻌﺪدﻳﻦ ﳘﺎ س ﻭص ﰲ اﻟﻘﺎﺳﻢ اﳌﺸﱰﻙ اﻷﻋﻈﻢ ﳛﺪد ﺑﺎﻟﺘﺎﱄ ‪ :‬إذا ﻛﺎﻧﺖ ص ﺗﺴﺎﻭﻱ ﺻـﻔﺮ ﻓـﺈﻥ‬
‫اﻟﻘﺎﺳﻢ ﻳﺴﺎﻭﻱ س ‪ ,‬ﻭ إﻻ ﻓﺈﻥ اﻟﻮﺳﻴﻠﺔ ) س ‪ ,‬ص ( ﺗﺴﺎﻭﻱ اﻟﻮﺳﻴﻠﺔ ) ص ‪ ,‬س ‪ %‬ص ( ﺣﻴـﺚ‬
‫‪ %‬ﻫﻲ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ اﻟﺼﺤﻴﺤﺔ ‪.‬‬
‫‪ −4‬اﻛﺘﺐ ﻭﺳﻴﻠﺔ ﻋﻮدﻳﺔ ﺗﻘﻮﻡ ﺑﺤﺴﺎب ﺳﻠﺴﻠﺔ اﻟﻔﺒﻮﻧﻚ ‪ Fibonacci‬ﻭ ﻫﻲ ﺗﺒﺪأ ﻛﺎﻟﺘﺎﱄ ‪:‬‬
‫… ‪0, 1, 1 , 2 , 3 , 5 , 8 , 13 , 21‬‬
‫ﻭ ﻳﻜﻤﻦ ﺗﻌﺮﻳﻒ ﻫﺬﻩ اﻟﺴﻼﺳﻞ ﻋﻮدﻳﺎ ﻛﺎﻟﺘﺎﱄ ‪:‬‬
‫‪Fibonacci ( 0) = 0‬‬
‫‪Fibonacci ( 1) = 1‬‬
‫)‪Fibonacci ( n) = Fibonacci ( n -1‬‬ ‫)‪+ Fibonacci ( n - 2‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮﻡ ﺑﺎﺳﺘﻘﺒﺎﻝ ﻋﺪد ‪ n‬ﻭ ﻳﻈﻬﺮ ﺑﻌﺪ ذﻟﻚ ﻗﻴﻤﺘﻪ ﰲ اﻟﺴﻠﺴﻠﺔ ‪.‬‬
‫*****‬
‫***‬
‫*‬

‫‪-8-‬‬