برمجة 1

‫ﺑﺮﻣﺠﺔ ‪۱‬‬
‫اﻟﻤﺤﺎﺿﺮة اﻷوﻟﻰ )ﻧﻈﺮي(‬

‫اﻟﻤﮭﻨﺪس ‪ :‬ﻣﺤﻤﺪ أزرق‬
‫ﻣﻘﺪﻣﺔ‬
‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ‪ :‬ﻟﻐﺔ ﺧﺎﺻﺔ ﺑﺎﻟﻜﻤﺒﯿﻮﺗﺮ ﻳﺘﻢ ﻣﻦ ﺧﻼﻟﮭﺎ إﻧﺸﺎء ﺑﺮاﻣﺞ ﻣﻌﯿﻨﺔ ﻳﻔﮭﻤﮭﺎ‬ ‫‪‬‬
‫اﻟﻜﻤﺒﯿﻮﺗﺮ‪.‬‬
‫ﻣﮭﻤﺔ ھﺬه اﻟﺒﺮاﻣﺞ اﻟﺴﯿﻄﺮة واﻟﺘﺤﻜﻢ ﺑﻌﻤﻞ اﻟﺠﮭﺎز‪.‬‬ ‫‪‬‬
‫ﻤﺒﺮ ِﻣﺞ ﺑﻜﺘﺎﺑﺔ ﺷﯿﻔﺮة)‪ ، (code‬واﻟﺘﻲ‬ ‫اﻟﺒﺮﻣﺠﺔ ‪ :‬ھﻲ اﻟﻌﻤﻠﯿّﺔ اﻟﺘﻲ ﻳﻘﻮم ﻓﯿﮭﺎ اﻟ ُ‬ ‫‪‬‬
‫ﱠ‬
‫ﺗﺘﻤﺜﻞ ﺑﻤﺠﻤﻮﻋﺔ ﻣﻦ اﻷواﻣﺮ‪ ،‬واﻟﺘﻲ ﺑﺪورھﺎ ﺗُﻨ ﱠﻔﺬ ﻋﻠﻰ اﻷﺟﮭﺰة اﻟﺤﺎﺳﻮﺑﯿ ّﺔ‪.‬‬
‫اﻟﻤﺘﺮﺟﻢ )‪ : (compiler‬ھﻮ ﻋﺒﺎرة ﻋﻦ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺘﺤﻮﻳﻞ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ إﻟﻰ‬ ‫‪‬‬
‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻻﺻﻔﺎر و اﻟﻮاﺣﺪات اﻟﺘﻲ ﻳﻔﮭﻤﮭﺎ اﻟﺤﺎﺳﺐ‪.‬‬
‫أﻧﻮاع ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ‬
‫‪ ‬ﻟﻐﺔ اﻷﻟﺔ ‪ :‬ھﻲ اﻟﻠﻐﺔ اﻟﺘﻲ ﻳﻔﮭﻤﮭﺎ اﻟﺤﺎﺳﺐ ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ و ھﻲ ﻋﺒﺎرة ﻋﻦ ﻣﺠﻤﻮﻋﺔ‬
‫ﻣﻦ اﻷﺻﻔﺎر واﻟﻮاﺣﺪات ‪.‬‬
‫‪ ‬ﻟﻐﺎت ﺑﺮﻣﺠﺔ ﻣﻨﺨﻔﻀﺔ اﻟﻤﺴﺘﻮى ‪ :‬ھﻲ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ اﻷﻗﺮب ﻟﻠﻐﺔ اﻵﻟﺔ‪ ،‬ﺑﺤﯿﺚ ﺗُﻌﺪ ﻟﻐﺔ‬
‫اﻵﻟﺔ ھﻲ اﻷﻗﻞ ﻣﺴﺘﻮى‪ ،‬وﻳﺄﺗﻲ ﻓﻲ ﻣﺴﺘﻮى أﻗﻞ ﻣﻦ ﺑﻌﺪھﺎ ﻟﻐﺔ اﻟﺘﺠﻤﯿﻊ ) ‪Assembly‬‬
‫ﻤﻦ ﻓﻘﻂ اﻷواﻣﺮ اﻟﺘﻲ ﻳﻔﮭﻤﮭﺎ ﺟﮭﺎز‬ ‫‪ ،(language‬إذ ﱠ‬
‫إن ھﺬه اﻟﻠﻐﺎت ﺗﺘﻤﯿﱠﺰ ﺑﻜﻮﻧﮭﺎ ﺗﺘﻀ ﱠ‬
‫اﻟﺤﺎﺳﻮب‪ ،‬وﺑﺎﻟﺘﺎﻟﻲ ھﻲ اﻷﻛﺜﺮ ُﺑﻌﺪاً ﻋﻦ اﻟﻠﻐﺔ اﻟﺘﻲ ﻳﻔﮭﻤﮭﺎ اﻹﻧﺴﺎن‪ ،‬وﻟﻜﻦ ﻓﻲ ﻧﻔﺲ‬
‫ﱡ‬
‫اﻟﺘﺤﻜﻢ اﻟﻜﺎﻣﻞ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻪ‪.‬‬ ‫ﻤﺒﺮﻣﺞ‬‫اﻟﻮﻗﺖ ﺗﺘﯿﺢ ﻟﻠ ُ‬
‫‪ ‬ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﻋﺎﻟﯿﺔ اﻟﻤﺴﺘﻮى‪ :‬وھﻲ اﻷﺑﻌﺪ ﻋﻦ ﻟﻐﺔ اﻵﻟﺔ‪ ،‬واﻷﻗﺮب ﻟﻔﮭﻢ اﻹﻧﺴﺎن‪ ،‬وﻟﻜﻨّﮭﺎ‬
‫اﻟﺘﺤﻜﻢ اﻟﺬي ﺗﺘﯿﺤﻪ اﻟﻠﻐﺎت ﻣﻨﺨﻔﻀﺔ اﻟﻤﺴﺘﻮى ﻟﻠﻤﺒﺮﻣﺞ‪ ،‬وذﻟﻚ‬ ‫ﱡ‬ ‫أﻳﻀﺎً ﻻ ﺗﺘﯿﺢ ﻧﻔﺲ ﻣﻘﺪار‬
‫ﻣﻦ ﺣﯿﺚ طﺮﻳﻘﺔ ﺗﻨﻈﯿﻢ اﻟﺤﺎﺳﻮب ﻟﻠﺬاﻛﺮة واﻟﺒﯿﺎﻧﺎت‪.‬‬
‫أﺷﮭﺮ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ‬
‫‪ ‬ﻟﻐﺔ ‪ : C‬ﻟﻐﺔ ﻗﺪﻳﻤﺔ ظﮭﺮت ﻓﻲ اﻟﺴﺒﻌﯿﻨﯿﺎت ﻣﻦ اﻟﻘﺮن اﻟﻤﺎﺿﻲ و ﻣﺎ ﺗﺰال ﺗﺴﺘﺨﺪم اﻟﻰ‬
‫ﻳﻮﻣﻨﺎ ھﺬا‪ ،‬ﺗﺘﻤﯿﺰ ﺑﺎﻟﺴﮭﻮﻟﺔ و ﻣﺘﻌﺪدة اﻻﺳﺘﻌﻤﺎل ﻣﻦ أﺷﮭﺮ اﺳﺘﺨﺪاﻣﺎﺗﮭﺎ ﺑﺮﻣﺠﺔ‬
‫اﻟﻤﺘﺤﻜﻤﺎت اﻟﻤﺼﻐﺮة ‪.‬‬
‫‪ ‬ﻟﻐﺔ ‪ : C++‬و ھﻲ ﺗﻄﻮﻳﺮ ﻟﻠﻐﺔ ‪ C‬و ﺗﻢ ﺗﺤﺪﻳﺜﮭﺎ واﺿﺎﻓﺔ اﻟﻘﻮاﻟﺐ ﻋﻠﯿﮭﺎ ‪ ،‬وھﻲ ﻟﻐﺔ واﺳﻌﺔ‬
‫اﻻﺳﺘﺨﺪام و ﺗﺴﺘﺨﺪم ﻓﻲ ﺑﺮﻣﺠﺔ اﻟﻤﺘﺤﻜﻤﺎت و أﻧﻈﻤﺔ اﻟﺘﺸﻐﯿﻞ و اﻟﺒﺮﻣﺠﯿﺎت اﻟﻤﺘﺨﻠﻘﺔ‪.‬‬
‫‪ ‬ﻟﻐﺔ ‪ : Java‬وھﻲ ﻟﻐﺔ ﻛﺎﺋﻨﯿﺔ اﻟﺘﻮﺟﻪ وﺗﻌﺘﻤﺪ ﻋﻠﻰ اﻟﻘﻮاﻟﺐ و ظﮭﺮت ﻓﻲ اﻟﺘﺴﻌﯿﻨﯿﺎت ﻣﻦ‬
‫اﻟﻘﺮن اﻟﻤﺎﺿﻲ و ھﻲ ﻣﻦ أﻛﺜﺮ اﻟﻠﻔﺎت طﻠﺒﺎ ‪ ،‬ﺗﺴﺘﺨﺪم ﻓﻲ ﺗﻄﻮﻳﺮ اﻟﻮوﻳﺐ و اﻷﻟﻌﺎب و‬
‫ﺗﻄﺒﯿﻘﺎت اﻟﻤﻮﺑﺎﻳﻞ‪.‬‬
‫‪ ‬ﻟﻐﺔ ‪ : C#‬ھﻲ ﻟﻔﺔ ﻣﺘﻄﻮرة ﻣﻦ ﺷﺮﻛﺔ ﻣﺎﻳﻜﺮوﺳﻮﻓﺖ و ﺗﺪﻣﺞ ﺧﺼﺎﺋﺺ ﻟﻐﺘﻲ ‪c , c++‬‬
‫ﺗﺴﺘﺨﺪم ﻓﻲ ﺗﻄﻮﻳﺮ اﻟﺒﺮﻣﺠﯿﺎت اﻟﻤﺨﺘﻠﻔﺔ ﻛﻤﺎ أﻧﮭﺎ ﺗﺪﻋﻢ ﺑﺮﻣﺠﺔ واﺟﮭﺔ اﻟﻤﺴﺘﺨﺪم‪.‬‬
‫‪ ‬ﻟﻔﺔ ‪ : Python‬و ھﻲ ﻟﻔﺔ ﻋﺎﻟﯿﺔ اﻟﻤﺴﺘﻮى‪ ،‬ﺗﺴﺘﺨﺪم ﻓﻲ ﺗﻄﻮﻳﺮ اﻟﻨﺼﻮص اﻟﺘﻲ ﻳﺘﻢ‬
‫ﺗﻨﻔﯿﺬھﺎ ﻣﻦ ﺟﮭﺔ اﻟﺨﺎدم ‪.‬‬
‫‪ ‬ﻟﻔﺔ ‪ : SQL‬و ھﻲ ﻟﻔﺔ ﻣﺨﺘﺼﺔ ﻓﻲ ﺑﺮﻣﺠﺔ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫ﻟﻐﺔ ‪C++‬‬
‫‪ ‬ھﻲ ﻟﻐﺔ ﺑﺮﻣﺠﺔ ﻛﺎﺋﻨﯿﺔ‪ ،‬ﻣﺘﻌﺪدة أﻧﻤﺎط اﻟﺒﺮﻣﺠﺔ‪ ،‬وﺗﻀﻢ اﻟﻌﺪﻳﺪ ﻣﻦ ﻣﯿﺰات ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ‬
‫ﻋﺎﻟﯿﺔ اﻟﻤﺴﺘﻮى وﻣﻨﺨﻔﻀﺔ اﻟﻤﺴﺘﻮى‪ .‬ﺑﺪأ ﺗﻄﻮﻳﺮ ھﺬه اﻟﻠﻐﺔ ﻛﺎﻣﺘﺪاد ﻟﻠﻐﺔ ‪C‬ﺗﺤﺖ اﺳﻢ ) ‪C‬‬
‫ﻣﻊ اﻟﺼﻔﻮف( ﻣﻦ ﻗﺒﻞ ﺑﯿﺎرن ﺳﺘﺮوﺳﺘﺮوب ﻓﻲ ﻣﺨﺘﺒﺮات ﺑﻞ ﻋﺎم ‪ ۱۹۷۹‬وﺗﻢ إﺿﺎﻓﺔ اﻟﻌﺪﻳﺪ‬
‫ﻣﻦ اﻟﻤﯿﺰات اﻷﺧﺮى ﻻﺣﻘﺎً وﺗﻐﯿﺮ اﻻﺳﻢ ﻋﺎم ‪ ۱۹۸۳‬ﻟﯿﺼﺒﺢ ‪C ++‬ﻣﻦ ﺑﺎب اﻟﺪﻋﺎﺑﺔ ﻋﺒﺮ‬
‫اﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ اﻟﺰﻳﺎدة ﻟﺠﺎﻧﺐ اﺳﻢ ﻟﻐﺔ ‪C‬ﺗﺄﻛﯿﺪاً ﻋﻠﻰ أﻧﮭﺎ اﻟﻠﻠﻌﺔ اﻟﺘﺎﻟﯿﺔ ﻟـ ‪C‬‬
‫‪ ‬ﺗﻌﺘﺒﺮ ‪C ++‬إﺣﺪى اﻟﻠﻐﺎت اﻷﻛﺜﺮ ﺷﯿﻮﻋﺎً وﻗﺪ اﺳﺘﺨﺪﻣﺖ ﻋﻠﻰ ﻧﻄﺎق واﺳﻊ ﻓﻲ ﺑﻨﺎء أﻧﻈﻤﺔ‬
‫اﻟﺘﺸﻐﯿﻞ واﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺒﻨﯿﺔ اﻟﺼﻠﺒﺔ ﻟﻠﺤﺎﺳﻮب اﺑﺘﺪا ًء ﻣﻦ اﻷﻧﻈﻤﺔ اﻟﺒﺮﻣﺠﯿﺔ وﺑﺮاﻣﺞ‬
‫اﻟﻤﺴﺘﺨﺪم‪ ،‬ﻣﺮوراً ﺑﻤﺸﻐﻼت اﻷﺟﮭﺰة واﻷﻧﻈﻤﺔ اﻟﻤﺪﻣﺠﺔ واﻧﺘﮭﺎ ًء ﺑﺎﻟﻤﺨﺪﻣﺎت ﻋﺎﻟﯿﺔ اﻷداء‬
‫وﺑﺮاﻣﺞ اﻟﺘﺴﻠﯿﺔ ﻛﺎﻷﻟﻌﺎب اﻟﻔﯿﺪﻳﻮﻳﺔ ﻧﻈﺮاً ﻟﻘﺪرة ﺗﺼﺮﻳﻔﮭﺎ إﻟﻰ ﻛﻮد ﻟﻐﺔ ﺗﺠﻤﯿﻊ ﺷﺪﻳﺪ‬
‫اﻟﻔﻌﺎﻟﯿﺔ‪.‬‬
‫‪ ‬أﺣﺪ أﻛﺜﺮ اﺳﺘﺨﺪاﻣﺎت ‪ C ++‬إﺛﺎر ًة ﻟﻺﻋﺠﺎب ﺣﺴﺐ رأي ﺳﺘﺮوﺳﺘﺮوب ھﻮ اﺳﺘﺨﺪام ‪C ++‬‬
‫ﻓﻲ ﻛﺘﺎﺑﺔ ﻗﺴﻢ ﻛﺒﯿﺮ ﻣﻦ أﻧﻈﻤﺔ اﻟﻘﯿﺎدة اﻷوﺗﻮﻣﺎﺗﯿﻜﯿﺔ ﻟﻠﻌﺮﺑﺎت اﻟﺘﻲ ﺗﺠﻮﻟﺖ ﻋﻠﻰ ﺳﻄﺢ‬
‫اﻟﻤﺮﻳﺦ‪.‬‬
‫ﺻﻔﺎت ﻟﻐﺔ ‪c++‬‬
‫‪ ‬ﻳﻤﻜﻦ إﺿﺎﻓﺔ ﻛﻢ ھﺎﺋﻞ ﻣﻦ اﻟﻤﻜﺘﺒﺎت إﻟﻰ اﻟﺒﺮﻧﺎﻣﺞ و ذﻟﻚ ﺑﺎﺳﺘﺨﺪام ﺗﻌﻠﯿﻤﺔ ‪include‬‬
‫‪ ‬ﻣﺜﺎل ‪ :‬إﺿﺎﻓﺔ ﻣﻜﺘﺒﯿﺔ اﻟﺮﻳﺎﺿﯿﺎت‬
‫‪‬‬ ‫>‪#include <cmath.h‬‬
‫‪ ‬ﻳﻜﺘﺐ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﯿﺴﻲ ﻛﻤﺎ ﻓﻲ اﻟﺸﻜﻞ‪:‬‬
‫‪‬‬ ‫{ )( ‪int main‬‬
‫‪‬‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‬
‫‪‬‬ ‫; ‪return 0‬‬
‫‪‬‬ ‫}‬
‫‪ ‬ﻳﺘﻢ إﻧﮭﺎء اﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﻌﻠﯿﻤﺔ ‪.return 0‬‬
‫‪ ‬ﻻ ﺑﺪ ﻣﻦ وﺿﻊ ﻓﺎﺻﻠﺔ ﻣﻨﻘﻮطﺔ ﻋﻨﺪ ﻧﮭﺎﻳﺔ ﻛﻞ ﺳﻄﺮ ﻓﻲ ‪.‬‬
‫اﻟﻤﺘﺤﻮﻻت )‪(Variables‬‬
‫‪ ‬ھﻲ ﻋﺒﺎرة ﻋﻦ أﺳﻤﺎء ﺗﺤﺠﺰ ﻣﻜﺎن ﻓﻲ اﻟﺬاﻛﺮة ﻟﯿﺘﻢ ﺗﺨﺰﻳﻦ اﻟﺒﯿﺎﻧﺎت ﻋﻠﯿﮭﺎ‪.‬‬
‫‪ ‬ﻋﻨﺪ ﺣﺠﺰ اﻟﻤﺘﺤﻮل ﻻﺑﺪ ﻣﻦ اﺧﺘﯿﺎر اﺳﻢ ﻟﻪ و ﻧﻮع اﻟﺒﯿﺎﻧﺎت اﻟﻤﺮاد ﺗﺨﺰﻳﻨﮭﺎ ﻓﯿﻪ ‪.‬‬
‫‪ ‬ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺤﺠﺰ ﻣﺴﺎﺣﺔ ﻓﻲ اﻟﺬاﻛﺮة ﺣﺴﺐ ﻧﻮع اﻟﻤﺘﺤﻮل اﻟﻤﺤﺠﻮز‪.‬‬
‫ﺗﺴﻤﯿﺔ اﻟﻤﺘﺤﻮﻻت‬
‫‪ ‬ﻳﻤﻜﻦ ان ﻳﺤﻮي اﺳﻢ اﻟﻤﺘﺤﻮل ﻋﻠﻰ أرﻗﺎم و ﺣﺮوف ﺷﺮط أﻻ ﻳﻜﻮن أول ﺣﺮف رﻗﻢ‪.‬‬
‫ﻣﺜﺎل ‪ :‬ﻻ ﻳﻤﻜﻦ ﺗﺴﻤﯿﺔ ﻣﺘﺤﻮل ‪ 4sensore‬ﺑﻞ ﻳﺴﻤﻰ ‪.sensore4‬‬ ‫‪‬‬
‫‪ ‬ﻻ ﻳﻤﻜﻦ ﻟﻼﺳﻢ أن ﻳﺤﻮي أي رﻣﺰ ﻻﺗﯿﻨﻲ أو إﺷﺎرات اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ و ﻏﯿﺮھﺎ‪.‬‬
‫‪ ‬ﻻ ﻳﻤﻜﻦ ﻟﻼﺳﻢ ان ﻳﺤﻮي ﻋﻠﻰ ﻓﺮاغ ‪.‬‬
‫‪ ‬ﻟﻐﺔ ال ‪ c++‬ﺣﺴﺎﺳﺔ ﻟﻸﺣﺮف اﻟﺼﻐﯿﺮة و اﻟﻜﺒﯿﺮة‪.‬‬
‫‪ ‬ﻣﺜﺎل ‪ :‬اﻟﻤﺘﺤﻮل ‪ Speed‬ﻏﯿﺮ اﻟﻤﺘﺤﻮل ‪.speed‬‬
‫‪ ‬ﻳﻤﻜﻦ اﺳﺘﺨﺪام اﻟﺸﺮﻳﻄﺔ اﻟﺴﻔﻠﯿﺔ )_( ﻓﻲ ﺗﺴﻤﯿﺔ اﻟﻤﺘﺤﻮﻻت ‪.‬‬
‫‪ ‬ﻣﺜﺎل ‪ fisrt_sensor :‬و ﻻ ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ‪.first sensor‬‬
‫أﻧﻮاع اﻟﻤﺘﺤﻮﻻت ‪Data Types‬‬
‫ﻓﻲ ﻟﻐﺔ ‪ C‬ﻳﻮﺟﺪ ‪ ٥‬أﻧﻮاع رﺋﯿﺴﯿﺔ ﻟﻠﺒﯿﺎﻧﺎت‪:‬‬ ‫●‬
‫–ﺣﺮف )‪char : (character‬‬

‫–ﻋﺪد ﺻﺤﯿﺢ)‪int :(integer‬‬
‫–ﻋﺪد ذو ﻓﺎﺻﻠﺔ ﻋﺎﺋﻤﺔ‪float :‬‬
‫–ﻋﺪد ذو ﻓﺎﺻﻠﺔ ﻋﺎﺋﻤﺔ ﻣﻀﺎﻋﻒ‪double :‬‬
‫–اﻟﻼ ﻗﯿﻤﺔ ‪void‬‬
‫ﺗﻌﺪﻳﻞ اﻷﻧﻮاع اﻟﺮﺋﯿﺴﯿﺔ‬
‫‪‬‬ ‫)إﻓﺗراﺿﻲ( ﻟﺘﻌﺮﻳﻒ اﻷﻋﺪاد ذات اﻹﺷﺎرة ‪signed‬‬

‫‪‬‬ ‫ﻟﺘﻌﺮﻳﻒ اﻷﻋﺪاد اﻟﻄﺒﯿﻌﯿﺔ ‪unsigned‬‬
‫‪‬‬ ‫ﻟﺘﻌﺮﻳﻒ اﻷﻋﺪاد اﻟﻄﻮﻳﻠﺔ ‪long‬‬
‫‪‬‬ ‫ﻟﺘﻌﺮﻳﻒ اﻷﻋﺪاد اﻟﻘﺼﯿﺮة ‪short‬‬
‫أﻣﺜﻠﺔ‬
‫ﺣﺠﺰ ﻣﺘﺤﻮل ﺻﺤﯿﺢ ﻏﯿﺮ ﻣﺆﺷﺮ ﻳﺴﻤﻰ ‪num1‬‬ ‫‪‬‬
‫‪‬‬ ‫;‪unsigned int num1‬‬

‫ﺣﺠﺰ ﻣﺘﺤﻮل ﻣﻦ ﻧﻮع ﻣﺤﺮف ﻏﯿﺮ ﻣﺆﺷﺮ ﻳﺴﻤﻰ ‪num2‬‬ ‫‪‬‬
‫‪‬‬ ‫;‪unsigned char num2‬‬

‫ﺣﺠﺰ ﻣﺘﺤﻮل ﻣﻊ ﻓﺎﺻﻠﺔ ﻋﺸﺮﻳﺔ ﻳﺴﻤﻰ ‪ pi‬ﺑﻘﯿﻤﺔ ‪3.14‬‬ ‫‪‬‬
‫‪‬‬ ‫‪float pi = 3.14‬‬

‫ﺣﺠﺰ ﻣﺘﺤﻮل ﺻﺤﯿﺢ طﻮﻳﻞ وﻳﺴﻤﻰ ‪x‬‬ ‫‪‬‬
‫‪‬‬ ‫; ‪long int x‬‬ ‫أو‬

‫‪‬‬ ‫; ‪long x‬‬
ASCII Code
‫ﻣﺎ ھﻮ ﺟﺪول اﻻﺳﻜﻲ‬
‫ﻣﻦ اﻟﻤﻌﺮوف ان اﻟﺤﺮوف ﻓﻲ اﻟﺤﺎﺳﺐ و اﻷﺟﮭﺰة اﻟﺮﻗﻤﯿﺔ ﺗﺤﺰن ﻓﻲ‬ ‫‪‬‬

‫اﻟﺤﺎﺳﺐ ﻛﺄرﻗﺎم ﺣﺘﻰ ﻳﺴﺘﻄﯿﻊ اﻟﺘﻌﺎﻣﻞ ﻣﻌﮭﺎ ‪.‬‬
‫ﻟﺬﻟﻚ ﺗﻢ اﻧﺸﺎء ﻧﻈﺎم ﺗﺸﻔﯿﺮ ﻟﺘﺤﻮﻳﻞ اﻻﺣﺮف إﻟﻰ أرﻗﺎم ﺳﻤﻲ‬ ‫‪‬‬
‫ﺟﺪول اﻻﺳﻜﻲ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬ ‫‪‬‬
‫‪‬‬ ‫;’‪char c = ‘A‬‬
‫ﻳﺘﻢ ﺗﺨﺰﻳﻦ اﻟﻘﯿﻤﺔ ‪ ٤۱‬ﻓﻲ اﻟﺬاﻛﺮة‪.‬‬ ‫‪‬‬
‫اﻟﺜﻮاﺑﺖ ‪Constants‬‬
‫ھﻲ ﻣﺘﺤﻮﻻت ﻳﺘﻢ اﺳﻨﺎد ﻗﯿﻤﺔ ﻟﮭﺎ ﻋﻨﺪ ﺗﻌﺮﻳﮭﺎ وﻻ ﻳﻤﻜﻦ اﻟﺘﻌﺪﻳﻞ‬ ‫‪‬‬
‫ﻋﻠﯿﮭﺎ أﺑﺪا ‪.‬‬
‫ﻳﺘﻢ ﺗﻌﺮﻳﻔﮭﺎ ﺑﺈﺿﺎﻓﺔ ﻛﻠﻤﺔ ‪ const‬ﻗﺒﻞ اﻟﺘﻌﺮﻳﻒ ‪.‬‬ ‫‪‬‬
‫ﻣﺜﺎل ‪:‬‬ ‫‪‬‬

‫‪‬‬ ‫; ‪const float pi = 3.14‬‬
‫‪‬‬ ‫; ‪const int K= 273‬‬
‫اﻟﺘﻌﺮﻳﻔﺎت ‪define‬‬
‫ﻳﻤﻜﻦ ﺗﻌﺮﻳﻒ اﻷرﻗﺎم و اﻷﺳﻤﺎء ﺑﺄﺳﻤﺎء ﺧﺎﺻﺔ ﻻ ﺗﺪﺧﻞ ﻓﻲ اﻟﺬاﻛﺮة ﺗﻨﺎﺳﺐ اﻟﻤﺒﺮﻣﺞ ‪.‬‬ ‫‪‬‬
‫و ﻻ ﻳﻤﻜﻦ ﺗﻄﺒﯿﻖ اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ ﻋﻠﯿﮭﺎ ﻣﺜﻞ اﻟﻤﺘﺤﻮﻻت ‪.‬‬ ‫‪‬‬
‫ﺗﺘﻤﯿﺰ أﻧﮭﺎ ﻻ ﺗﺤﺠﺰ أي ﻣﻜﺎن ﻓﻲ اﻟﺬاﻛﺮة ‪.‬‬ ‫‪‬‬
‫ﺗﻌﺮﻳﻒ ﺑﺈﺿﺎﻓﺔ ﻛﻠﻤﺔ ‪ #define‬ﺛﻢ اﻻﺳﻢ اﻟﺠﺪﻳﺪ و ﺑﻌﺪه اﻻﺳﻢ أو اﻟﺮﻗﻢ اﻟﻤﺮاد ﺗﻌﺮﻳﻔﻪ‪.‬‬ ‫‪‬‬
‫ﻻ ﺗﻀﺎف اﻟﻔﺎﺻﻠﺔ اﻟﻤﻨﻘﻮطﺔ إﻟﯿﻪ ‪.‬‬ ‫‪‬‬
‫ﻣﺜﺎل ‪:‬‬ ‫‪‬‬
‫‪‬‬ ‫‪#define pi 3.14‬‬
‫ﺗﻌﺮﻳﻒ ﻗﯿﻤﺔ ‪pi 3.14‬‬ ‫‪‬‬
‫ﺗﺸﺎﺑﻪ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬ ‫‪‬‬
‫‪‬‬ ‫; ‪S = 2*3.14* r‬‬
‫‪‬‬ ‫; ‪S= 2*pi * 3.14‬‬
‫اﻟﺘﻌﻠﯿﻘﺎت ‪Comments‬‬
‫‪/* … */‬ﻟﻠﺗﻌﻠﯾﻘﺎت اﻟﻣﺗﻌددة اﻷﺳطر‬ ‫●‬
‫‪//‬ﻟﻠﺗﻌﻠﯾﻖ ﻋﻠﻰ اﻟﺳطر اﻟﺣﺎﻟﻲ‬ ‫●‬
‫‪// This program will add two numbers‬‬

‫‪/* print the sum of‬‬
‫‪the two numbers x + y */‬‬
‫‪ ‬اﻻﺳﻄﺮ اﻟﺴﺎﻳﻘﺔ ﻻ ﻳﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﺘﺮﺟﻤﺘﮭﺎ ‪.‬‬

‫ﺗﺤﻮﻳﻞ أﻧﻮاع اﻟﺒﯿﺎﻧﺎت ﻋﻨﺪ اﻹﺳﻨﺎد‬
Type Conversion in Assignments
 int x = 65;
 char ch = 'B';
 float f = 14.34;
 int main()
 {
 ch = x; //ch = 'A'
 x = f; //x = 14
 f = ch; //65
 f = x; //f=14.0
 }
‫اﻹدﺧﺎل و اﻹﺧﺮاج ﻓﻲ ﻟﻐﺔ ‪C++‬‬
‫‪ ‬ﻳﻤﻜﻦ ادﺧﺎل و اﺧﺮاج اﻟﺒﯿﺎﻧﺎت ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ‪ C++‬ﺑﺎﺳﺘﺨﺪام ﺗﻌﻠﯿﻤﺘﻲ ‪.cin , cout‬‬
‫‪ ‬ﻻﺳﺘﻌﻤﺎل ﺟﺪاول اﻻدﺧﺎل و اﻹﺧﺮاج ﻻ ﺑﺪ ﻣﻦ إﺿﺎﻓﺔ ﻣﻜﺘﺒﯿﺔ ‪. iostream‬‬
‫‪ ‬و ذﻟﻚ و ﻓﻖ اﻟﻄﺮﻳﻘﺔ اﻟﺘﺎﻟﯿﺔ‪:‬‬
‫‪‬‬ ‫>‪#include <iostream‬‬
‫‪ ‬وذﻟﻚ ﻹﺿﺎﻓﺔ ﻣﻜﺘﺒﯿﺔ اﻻدﺧﺎل و اﻹﺧﺮاج و ﺗﻮﺿﻊ ﻓﻲ ﺑﺪاﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ و ﻳﻀﺎف ﺑﻌﺪھﺎ اﻟﺴﻄﺮ‬
‫اﻟﺘﺎﻟﻲ‪:‬‬
‫‪‬‬ ‫;‪using namespace std‬‬
‫ﺗﻌﻠﯿﻤﺔ اﻹﺧﺮاج ﻓﻲ ﻟﻐﺔ ‪C++‬‬
‫ﻹﺧﺮاج أي ﻧﺺ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﻌﺮض ﻧﺴﺘﻌﻤﻞ ﺗﻌﻠﯿﻤﺔ ‪ cout‬وﻧﺘﺒﻌﮭﺎ ﺑـ <<‪.‬‬ ‫‪‬‬
‫ﺛﻢ ﻧﻜﺘﺐ اﻟﻨﺺ اﻟﻤﺮاد إظﮭﺎره وﻳﻜﻮن ﺑﯿﻦ ”“‪.‬‬ ‫‪‬‬
‫ﻓﻲ ﺣﺎل أردﻧﺎ إظﮭﺎر ﻗﯿﻤﺔ ﻣﺘﺤﻮل ﻓﺘﻜﺘﺐ اﺳﻢ اﻟﻤﺘﺤﻮل ﺑﺪون)”“(‪.‬‬ ‫‪‬‬
‫ﻣﺜﺎل‪:‬‬ ‫‪‬‬
‫‪‬‬ ‫;”‪cout << “Text‬‬ ‫ﻟﻄﺒﺎﻋﺔ ﻧﺺ ‪//‬‬

‫‪‬‬ ‫ﻟﻄﺒﺎﻋﺔ ﻗﯿﻤﺔ اﻟﻤﺘﺤﻮل ‪cout << x_val; // x_val‬‬
‫‪‬‬ ‫‪cout << “the number is ” << num << endl; // the number is 64‬‬
 #include <iostream> // ‫إﺿﺎﻓﺔ ﻣﻜﺘﺒﯿﺔ اﻻدﺧﺎل واﻻﺧﺮاج‬
 using namespace std;
 int main() // ‫ﺑﺪاﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ‬
 {
 cout << “Welcome to mechanical Engineering Faculty”;
 return 0; // ‫دﻻﻟﺔ ﻋﻠﻰ ﻧﮭﺎﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ‬
 }
: ‫ﻣﺨﺮج اﻟﺒﺮﻧﺎﻣﺞ‬ 
 Welcome to mechanical Engineering Faculty
endl ‫ﺗﻌﻠﯿﻤﺔ‬
.‫ ﺗﺴﺘﺨﺪم ﻟﻠﻨﺰول إﻟﻰ ﺳﻄﺮ ﺟﺪﻳﺪ ﻋﻨﺪ اﻹﺧﺮاج‬

:‫ ﻣﺜﺎل‬
 cout << “Welcome to”<<endl <<“Electrical Engineering ”<<endl;
 cout <<“Third Year” << endl<<“Prograing c++”<<endl
:‫ ﺗﺨﺮﻳﺞ اﻟﺒﺮﻧﺎﻣﺞ‬
 Welcome to
 Electrical Engineering
 Third Year
 Prograing c++
‫ﻣﺜﺎل‬
‫‪‬‬ ‫{ )(‪int main‬‬
‫‪‬‬ ‫; ‪char a = 65‬‬
‫‪‬‬ ‫; ‪float b =75.3‬‬
‫‪‬‬ ‫; ‪int c =15‬‬
‫‪‬‬ ‫‪cout << a << endl ; // A‬‬ ‫ﺗﻘﻮم ھﺬه اﻟﺘﻌﻠﯿﻤﺔ ﺑﺈطﮭﺎر ﻗﯿﻤﺔ ‪ a‬ﻛﻤﺤﺮف ﺣﺴﺐ ﺟﺪول اﺳﻜﻲ‬
‫‪‬‬ ‫; ‪c=b‬‬ ‫ﻳﻘﻮم ﺑﺎﺳﻨﺎد ﻗﯿﻤﺔ اﻟﻤﺘﺤﻮل ‪ b‬ﻓﻲ اﻟﻤﺘﺤﻮل ‪c‬ﻟﻜﻦ ﺑﻤﺎ ان‬
‫اﻟﻤﺘﺤﻮل ‪ c‬ﻣﻦ ﻧﻮع ‪ integer‬ﻓﯿﺘﻢ ﺣﺬف اﻟﻔﻮاﺻﻞ‪.‬‬
‫‪‬‬ ‫‪cout << c <<endl ; //75‬‬ ‫و ﻳﺘﻢ ﻋﺮﺿﮭﺎ ﺑﻌﺪ ذﻟﻚ‬
‫‪‬‬ ‫;‪c=a‬‬ ‫ﻳﻘﻮم ﺑﺎﺳﻨﺎد ﻗﯿﻤﺔ اﻟﻤﺘﺤﻮل ‪ a‬ﻓﻲ اﻟﻤﺘﺤﻮل ‪ c‬ﻟﻜﻦ ﺑﻤﺎ ان اﻟﻤﺘﺤﻮل‬
‫‪ c‬ﻣﻦ ﻧﻮع ‪ integer‬ﻓﯿﺘﻢ ﺗﺨﺰﻳﻨﮭﺎ ﻛﺮﻗﻢ و ﻟﯿﺲ ﻛﻤﺤﺮف ‪.‬‬
‫‪‬‬ ‫‪cout <<c<<endl ;//65‬‬
‫و ﻳﺘﻢ ﻋﺮﺿﮭﺎ ﺑﻌﺪ ذﻟﻚ‬
‫‪‬‬ ‫; ‪a= b‬‬ ‫ﻳﻘﻮم ﺑﺎﺳﻨﺎد ﻗﯿﻤﺔ اﻟﻤﺘﺤﻮل ‪ b‬ﻓﻲ اﻟﻤﺘﺤﻮل ‪ a‬ﻟﻜﻦ ﺑﻤﺎ ان‬
‫‪‬‬ ‫‪cout <<a<< endl ; // K‬‬ ‫اﻟﻤﺘﺤﻮل ‪ a‬ﻣﻦ ﻧﻮع ‪ character‬ﻓﯿﺘﻢ ﺗﺨﺰﻳﻨﻪ ﻛﻤﺤﺮف ﺣﺴﺐ‬
‫ﺟﺪول اﺳﻜﻲ‬
‫‪‬‬ ‫}‬ ‫و ﻳﺘﻢ ﻋﺮﺿﮭﺎ ﺑﻌﺪ ذﻟﻚ‬
‫ﺗﻌﻠﯿﻤﺎت اﻹدﺧﺎل ﻓﻲ ﻟﻐﺔ ‪C++‬‬
‫ﻹدﺧﺎل أي ﻗﯿﻤﺔ ﻟﻤﺘﺤﻮل ﻧﺴﺘﻌﻤﻞ ﺗﻌﻠﯿﻤﺔ ‪ cin‬وﻧﺘﺒﻌﮭﺎ ﺑـ >> ‪.‬‬ ‫‪‬‬
‫ﺛﻢ ﻧﻜﺘﺐ اﺳﻢ اﻟﻤﺘﺤﻮل اﻟﻤﺮاد ادﺧﺎل ﻗﯿﻤﺘﻪ‪.‬‬ ‫‪‬‬
‫ﻛﻤﺎ ﻳﻤﻜﻦ ادﺧﺎل ﻋﺪة ﻗﯿﻢ ﻓﻲ ﻧﻔﺲ اﻟﺘﻌﻠﯿﻤﺔ‪.‬‬ ‫‪‬‬
‫ﻣﺜﺎل‪:‬‬ ‫‪‬‬
‫‪‬‬ ‫;‪cin >> var‬‬
‫‪‬‬ ‫;‪cin >> var1 >> var2‬‬
Basic operators ‫اﻟﻌﻤﻠﯿﺎت اﻷﺳﺎﺳﯿﺔ‬
(Assignment operator " = ")‫ﻋﻤﻠﯿﺔ اﻹﺳﻨﺎد‬ ●
● int x = 4;
● x = 10; //x ‫إﻟﻰ اﻟﻣﺗﺣول‬10 ‫ﺗﻘﻮم ﺑﺈﺳﻨﺎد اﻟﻌﺪد‬
" - + ": ‫ﻋﻤﻠﯿﺘﻲ اﻟﺠﻤﻊ و اﻟﻄﺮح‬ ●
● int x = 35, y = 10, z;

● z = x + y – 4; // z = 41
:" * "‫ ﻋﻤﻠﯿﺔ اﻟﻀﺮب‬
● int value_1 = 5;
● int value_2 = value_1 * 3; // value_2 = 15
:" / " ‫ﻋﻤﻠﯿﺔ اﻟﻘﺴﻤﺔ‬ ●
● int number1 = 9;
● int number2 = number1 / 5; //number2 = 1
‫‪ ‬ﻣﺜﺎل ﻟﺤﺴﺎب ﺳﺮﻋﺔ ﺣﺮﻛﺔ ﺟﺴﻢ ‪:‬‬
‫●‬ ‫‪double distance = 15 ,time, speed; // km‬‬
‫●‬ ‫‪time = 10.300; // sec‬‬
‫●‬ ‫‪speed = distance / time; //‬‬ ‫‪speed = 1.45631068 km/sec‬‬
‫‪ ‬ﻋﻤﻠﯿﺔ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ” ‪: %‬‬
‫●‬ ‫;‪int number1 = 9‬‬
‫●‬ ‫‪int number2 = number1 % 5; //number2 = 4‬‬
‫‪ ‬ﻣﻼﺣﻈﺔ ﻣﮭﻤﺔ ‪ :‬ﻳﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﺤﺴﺎب اﻟﻌﻼﻗﺎت ﻣﻦ اﻟﯿﺴﺎر إﻟﻰ اﻟﯿﻤﯿﻦ و ﻓﻲ ﺣﺎل وﺟﻮد‬
‫اﻷﻗﻮاس ﻓﺘﻜﻮن اﻷوﻟﻮﻳﺔ ﻟﻸﻗﻮاس ﻛﻤﺎ ﻓﻲ اﻟﺮﻳﺎﺿﯿﺎت ﺗﻤﺎﻣﺎ‪.‬‬
‫‪ ‬ﻣﺜﺎل ﺣﺴﺎب طﻮل اﻟﻤﻮﺟﺔ ﺗﺮددھﺎ ‪:khz ۳۰‬‬
‫‪‬‬ ‫‪double wave_length = (1 / 30000. ) * 1000; //note the dot‬‬
‫‪//‬‬ ‫‪wave_length = 0.033333‬‬
‫اﻹﺷﺎرات اﻟﺤﺴﺎﺑﯿﺔ اﻟﻤﺨﺘﺼﺮة‬
‫ﻋﻤﻠﯿﺔ زﻳﺎدة ﻗﯿﻤﺔ ﻣﺘﺤﻮل ﺑﻮاﺣﺪ وﻟﮭﺎ ﺷﻜﻠﯿﻦ‪:‬‬ ‫‪‬‬
‫●‬ ‫ﺗﻘﻮم ﺑﺎﻟﺰﻳﺎدة ﺑﻮاﺣﺪ ﻋﻠﻰ اﻟﻤﺘﺤﻮل ﺛﻢ إرﺟﺎﻋﻪ‪++n; //‬‬

‫●‬ ‫ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ اﻟﻤﺘﺤﻮل ﺛﻢ ﺗﺰﻳﺪه ﺑﻮاﺣﺪ‪n++; //‬‬
‫ﻋﻤﻠﯿﺔ طﺮح ﻗﯿﻤﺔ ﻣﺘﺤﻮل ﺑﻮاﺣﺪ وﻟﮭﺎ ﺷﻜﻠﯿﻦ‪:‬‬ ‫‪‬‬
‫●‬ ‫ﺑﺘﻘﻮم ﺑﺘﻨﻘﯿﺺ ﺑﻮاﺣﺪ ﻣن اﻟﻣﺗﺣول ﺛم إرﺟﺎﻋﮫ ‪--n; //‬‬

‫‪‬‬ ‫ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ اﻟﻤﺘﺤﻮل ﺛﻢ ﺗﻘﻮم ﺑﺈﻧﻘﺎﺻﻪ ﺑﻮاﺣﺪ ‪n--; //‬‬
‫‪‬‬ ‫;‪x_val = x_val + 3‬‬
‫‪‬‬ ‫ﺗﻜﺎﻓﺊ اﻟﺘﻌﻠﯿﻤﺔ اﻟﺴﺎﺑﻘﺔ ‪x_val += 3; //‬‬
‫‪‬‬ ‫;‪y_var = y_var – 9‬‬

‫‪‬‬ ‫ﺗﻜﺎﻓﺊ اﻟﺘﻌﻠﯿﻤﺔ اﻟﺴﺎﺑﻘﺔ ‪y_var -= 9; //‬‬
‫‪‬‬ ‫;‪num = num * 30‬‬

‫‪‬‬ ‫ﺗﻜﺎﻓﺊ اﻟﺘﻌﻠﯿﻤﺔ اﻟﺴﺎﺑﻘﺔ ‪num *= 30 //‬‬
‫‪‬‬ ‫;‪variable = variable / 68‬‬

‫‪‬‬ ‫ﺗﻜﺎﻓﺊ اﻟﺘﻌﻠﯿﻤﺔ اﻟﺴﺎﺑﻘﺔ ‪variable /= 68; //‬‬
‫‪‬‬ ‫;‪rest = rest % 50‬‬

‫‪‬‬ ‫ﺗﻜﺎﻓﺊ اﻟﺘﻌﻠﯿﻤﺔ اﻟﺴﺎﺑﻘﺔ ‪rest %= 50; //‬‬
‫وﺑﺎﻗﻲ اﻟﻌﻤﻠﯿﺎت ﺑﺎﻟﻤﺜﻞ‬ ‫●‬
:‫ ﻳﺪﺧﻠﮭﺎ اﻟﻤﺴﺘﺨﺪم‬x ‫ﺑﺈﻋﺘﺒﺎر أن‬ ‫أﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺤﺴﺎب ﻧﺎﺗﺞ‬
● #include <iostream>
● using namespace std;
● int main()
● {
double x_value; // the x variable
double answer; // answer storage
cout << "Enter the x value: "; // ask for input
cin >> x_value; // get the input
// compute the answer
answer = (x_value * (1 - x_value)) / (1 - 7 * x_value);
// print the answer
cout << "The answer is " << answer;
return 0; // exit the program
● }
‫أﻧﻈﻤﺔ اﻟﻌﺪ‬
‫اﻟﻨﻈﺎم اﻟﻌﺸﺮي ‪Decimal System‬‬
‫ھﻮ اﻟﻨﻈﺎم اﻟﺬي ﻳﺴﺘﺨﺪﻣﻪ اﻟﺒﺸﺮ ﻓﻲ اﻟﻌﻤﻠﯿﺎت اﻟﺮﻳﺎﺿﯿﺔ و‬ ‫●‬
‫اﻟﻤﻌﺎﻣﻼت و ‪...‬إﻟﺦ‪.‬‬
‫ﻧﻈﺎم اﻟﻌﺪ اﻟﻌﺸﺮي ﻳﻠﺰﻣﻨﺎ أن ﺗﻜﻮن اﻟﺨﺎﻧﺔ اﻟﻮاﺣﺪة ﻣﻨﻪ أﺣﺪ اﻷرﻗﺎم‬ ‫●‬
‫ﻣﻦ )‪ (۹ ~ ۰‬ﺣﯿﺚ ﻳﻀﺮب ﻛﻞ ﺧﺎﻧﺔ ﻣﻨﻪ ﺑﻌﺸﺮة ﻣﺮﻓﻮﻋﺔ إﻟﻰ ﻗﻮة‬

‫ﺗﺤﺪد و ﻓﻖ ﺗﻮﺿﻊ اﻟﺨﺎﻧﺔ‪.‬‬
‫ﻣﺜﺎل‪:‬‬ ‫●‬
‫●‬
‫اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ‪Binary System‬‬
‫ھﻮ اﻟﻨﻈﺎم اﻟﺮﻗﻤﻲ اﻟﺬي ﻳﺴﺘﺨﺪم اﻟﻜﻤﺒﯿﻮﺗﺮ ﻓﻲ ﻣﻌﺎﻟﺠﺔ و ﺗﺨﺰﻳﻦ‬ ‫●‬
‫اﻟﺒﯿﺎﻧﺎت‬
‫ﻳﺘﻜﻮن اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﻣﻦ ﺳﻠﺴﻠﺔ ﻣﻦ اﻟﺨﺎﻧﺎت ﻛﻞ ﺧﺎﻧﺔ ﺗﺤﺘﻤﻞ ان‬ ‫●‬
‫ﺗﻜﻮن ‪ ۱‬أو ‪.۰‬‬

‫و أﺳﺎﺳﻪ اﻟﺮﻗﻢ ‪۲‬‬ ‫●‬
‫و ﻳﻄﻠﻖ ﻋﻠﻰ اﻟﺨﺎﻧﺔ ﻣﻨﻪ أﺳﻢ اﻟﺒﺖ ‪bit‬‬ ‫●‬
‫ﺗﻀﺮب ﻛﻞ ﺧﺎﻧﺔ ﻣﻨﻪ ﺑﺈﺛﻨﯿﻦ ﻣﺮﻓﻮﻋﺔ إﻟﻰ ﻗﻮة ﺗﺤﺪد و ﻓﻖ ﺗﻮﺿﻊ‬ ‫●‬
‫اﻟﺨﺎﻧﺔ‬
‫ﻣﺜﺎل‪:‬‬ ‫●‬
‫ﺗﺤﻮﻳﻞ ﻣﻦ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ إﻟﻰ اﻟﻨﻈﺎم اﻟﻌﺸﺮي‬
‫‪ ‬ﺗﺤﻮﻳﻞ ﻣﻦ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ إﻟﻰ اﻟﻨﻈﺎم اﻟﻌﺸﺮي‬

‫ﺗﺤﻮﻳﻞ ﻣﻦ اﻟﻨﻈﺎم اﻟﻌﺸﺮي إﻟﻰ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‬
‫ﻧﺴﺘﺨﺪم اﻟﻘﺴﻤﺔ ﻋﻠﻰ أﺳﺎس ‪ ۲‬ﺑﺎﻟﺘﻮاﻟﻲ‪.‬‬ ‫●‬
‫ﻣﺜﺎل‪:‬ﺣﻮل اﻟﻌﺪد اﻟﻌﺸﺮي ‪ ۸۷‬إﻟﻰ ﻋﺪد ﺛﻨﺎﺋﻲ‪:‬‬ ‫●‬

‫اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي‬
‫)‪Hexadecimal system(Hexa‬‬
‫ھﻮ ﻧﻈﺎم ﻋﺪ ﺗﺄﺧﺬ ﻛﻞ ﺧﺎﻧﺔ ﻣﻦ ﺧﺎﻧﺎﺗﻪ ﻗﯿﻤﺔ ﻣﻦ أﺻﻞ ﺳﺖ ﻋﺸﺮة ﻗﯿﻤﺔ ﺑﯿﻦ )‪ (F~۰‬و‬ ‫●‬
‫ﻳﺴﺘﺨﺪم ﻓﻲ إﺧﺘﺼﺎر اﻷرﻗﺎم اﻟﺜﻨﺎﺋﯿﺔ و ﻓﻲ ﻣﺤﺮرات اﻟﻤﻠﻔﺎت اﻟﻤﺘﻘﺪﻣﺔ ﻣﺜﺎل ‪WinHex‬‬

‫وﺗﻤﺜﻞ ﻛﻞ ﺧﺎﻧﺔ ﻣﻨﻪ ‪ ٤‬ﺑﺘﺎت ﺛﻨﺎﺋﯿﺔ‬
‫●‬ ‫ﻣﺜﺎل‪:‬‬
‫اﻟﻤﺤﺎﺿﺮة اﻟﺜﺎﻧﯿﺔ‬
‫اﻟﺒﻮاﺑﺎت اﻟﻤﻨﻄﻘﯿﺔ ‪Logic gates‬‬
‫اﻟﺒﻮاﺑﺔ ‪NOT‬‬ ‫●‬
‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ ال ‪~ :C‬‬ ‫●‬
‫ا�خﺮج‬ ‫اﻟﺪﺧﻞ‬
‫‪Y‬‬ ‫‪A‬‬
‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪1‬‬
‫اﻟﺒﻮاﺑﺔ ‪OR‬‬ ‫‪‬‬
‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ ال ‪ | : C‬ﻟﻠﻌﻤﻠﯿﺎت ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﺒﺖ‬ ‫‪‬‬
‫‪Y‬‬ ‫‪B‬‬ ‫‪A‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫اﻟﺒﻮاﺑﺔ ‪AND‬‬ ‫‪‬‬
‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ ال ‪ & : C‬ﻟﻠﻌﻤﻠﯿﺎت ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﺒﺖ‬ ‫‪‬‬
‫‪Y‬‬ ‫‪B‬‬ ‫‪A‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫اﻟﺒﻮاﺑﺔ ‪XOR‬‬ ‫‪‬‬
‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ ال ‪^ : C‬‬ ‫‪‬‬
‫‪Y‬‬ ‫‪B‬‬ ‫‪A‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
Boolean
false ‫ أو‬true ‫ ﺛﻨﺎﺋﯿﺔ ﺗﺄﺧﺬ إﻣﺎ ﻗﯿﻤﺔ‬Data Type ‫ھﻮ ﺑﻨﯿﺔ ﻣﻌﻄﯿﺎت‬ 
true ‫ وﻏﯾر ذﻟك ﯾﻘﺎﺑل‬false ‫ ﺗﻘﺎﺑﻞ‬۰ ‫ اﻟﻘﯿﻤﺔ‬،‫ﻓﻲ ﻟﻐﺔ اﻟﺴﻲ‬ 
 int x_value = -50;

 bool isNegative = (x_value < 0);
 cout << isNegative; // ‫اﻟﺨﺮج‬1
 -----------------------------
 bool isEqual = false;
 cout << isEqual; // ‫اﻟﺨﺮج‬0
‫ﻋﻤﻠﯿﺎت اﻟﻌﻼﻗﺔ و اﻟﻤﻘﺎرﻧﺔ‬
‫ھﻲ ﻋﻤﻠﯿﺎت ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﻋﻼﻗﺔ ﺑﯿﻦ ﻣﺪﺧﻠﯿﻦ ﺣﯿﺚ ﻳﻜﻮن ﻧﺎﺗﺞ ھﺬه اﻟﻌﻤﻠﯿﺎت إﻣﺎ‬ ‫‪‬‬
‫‪ (false)۰‬أو ‪(true)۱‬‬
‫ﻋﻤﻠﯿﺔ اﻟﺘﺤﻘﻖ ﻣﻦ اﻟﻤﺴﺎواة “ == ”‪:‬‬ ‫‪‬‬
‫‪‬‬ ‫‪0‬اﻟﺨﺮج ‪cout << (3 == 4); //‬‬

‫‪‬‬ ‫;‪int x = 50‬‬
‫‪‬‬ ‫‪bool y = x == 50; // y = 1‬‬
‫‪‬‬ ‫ھﺬا اﻓﻀﻞ ‪bool y = (x == 50); //‬‬
‫ﻋﻤﻠﯿﺔ اﻟﺘﺤﻘﻖ ﻣﻦ ﻋﺪم اﻟﻤﺴﺎواة “ =! “ ‪:‬‬ ‫‪‬‬
‫‪‬‬ ‫;‪int x_val = 20‬‬

‫‪‬‬ ‫;‪int y_val‬‬
‫‪‬‬ ‫;‪y_val = 23‬‬
‫‪‬‬ ‫;)‪cout << (x_val != y_val‬‬ ‫‪1‬اﻟﺨﺮج ‪//‬‬
“ < “ , “ > “: ‫ﻋﻤﻠﯿﺘﻲ اﻟﺘﺤﻘﻖ أﻛﺒﺮ أو أﺻﻐﺮ‬ 
 int value_temp = 50;

 bool isStable = x < 75;
 cout << isStable;
 int age;
 age = 60;
 cout << (age > 60); // ‫اﻟﺨﺮج‬0
‫ﻋﻤﻠﯿﺘﻲ اﻟﺘﺤﻘﻖ أﻛﺒﺮ ﻣﻊ اﻟﻤﺴﺎواة او اﺻﻐﺮ ﻣﻊ اﻟﻤﺴﺎواة” =< ” و “ => ” ‪:‬‬ ‫‪‬‬
‫‪‬‬ ‫;‪int num_one = 50‬‬

‫‪‬‬ ‫;‪int num_two = 50‬‬
‫‪‬‬ ‫‪1‬اﻟﺨﺮج ‪cout << (num_one <= num_two); //‬‬
‫اﻟﻌﻤﻠﯿﺎت اﻟﻤﻨﻄﻘﯿﺔ‬
‫‪Logical operators‬‬
‫ھﻲ ﻋﻤﻠﯿﺎت ﻣﻨﻄﻘﯿﺔ ﺗﻄﺒﻖ ﻋﻠﻰ ﻣﺪﺧﻞ أو‬ ‫‪‬‬
‫ﻣﺪﺧﻠﯿﻦ ﻣﻦ ﻧﻮع ‪boolean‬‬

‫ﻋﻤﻠﯿﺔ اﻟﻌﻜﺲ ‪:“ ! “ NOT‬‬ ‫‪‬‬
‫‪‬‬ ‫;‪int value = 30‬‬

‫‪‬‬ ‫;)‪cout << !(value == 30‬‬
‫‪‬‬ ‫; ) ‪cout << (value != 30‬‬
‫اﻟﻌﻤﻠﯿﺎت اﻟﻤﻨﻄﻘﯿﺔ‬
‫‪Logical operators‬‬
‫ﻋﻤﻠﯿﺔ " و " اﻟﻤﻨﻄﻘﯿﺔ ﻓﻲ اﻟﺘﺤﻘﻖ " && "‪:‬‬ ‫‪‬‬
‫‪‬‬ ‫;)‪int a = (5 > 3) && (32 != 1‬‬

‫‪‬‬ ‫اﻟﺨﺮج ‪cout << a; //1‬‬
‫ﻋﻤﻠﯿﺔ " أو " اﻟﻤﻨﻄﻘﯿﺔ ﻓﻲ اﻟﺘﺤﻘﻖ " || "‪:‬‬ ‫‪‬‬
‫‪‬‬ ‫;‪int c = 32‬‬

‫‪‬‬ ‫;))‪int d = ((c < 30) || !(c == 1‬‬
‫‪‬‬ ‫‪1‬اﻟﺨﺮج ‪cout << d; //‬‬
‫اﻟﻘﺮار ‪Decision‬‬
‫ً‬ ‫ً‬
‫‪ ‬ﻣﺜﺎل ﳌﻌﺮﻓﺔ ﻓﺌﺔ اﻟﻄﺎﻟﺐ ﻣﻦ ﻋﻼﻣﺘﮫ �� إﺣﺪى اﻹﻣﺘﺤﺎﻧﺎت ﺣﻴﺚ ﻧﻘﺮر أن ﻳ�ﻮن راﺳﺒﺎ أو ﻧﺎجحﺎ‪:‬‬
‫اﻟﺠﻤﻠﺔ اﻟﺸﺮطﯿﺔ ‪if – else‬‬
‫‪‬‬ ‫)‪ */‬اﻟﺸﺮط … *‪if( /‬‬

‫‪‬‬ ‫{‬
‫إذا ﺗﺣﻘﻖ اﻟﺷرط ﻧﻔذ اﻷﺗﻲ ‪//...‬‬
‫‪‬‬ ‫}‬
‫‪‬‬ ‫‪else‬‬
‫‪‬‬ ‫{‬
‫إذا ﻟم ﯾﺗﺣﻘﻖ اﻟﺷرط ﻧﻔذ اﻷﺗﻲ ‪//...‬‬
‫‪‬‬ ‫}‬
if – else ‫ﻣﺜﺎل‬
‫ ﻣﺜﺎل ﻟﻤﻌﺮﻓﺔ ﻓﺌﺔ اﻟﻄﺎﻟﺐ ﻣﻦ ﻋﻼﻣﺘﻪ ﻓﻲ إﺣﺪى اﻹﻣﺘﺤﺎﻧﺎت ﺣﯿﺚ ﻧﻘﺮر أن ﻳﻜﻮن راﺳﺒﺎً أو‬
:ً‫ﻧﺎﺟﺤﺎ‬

 int main()
 {
 unsigned int student_grade; // Student grade variable
 cout << “Enter student grade: “;
 cin >> student_grade;
if(student_grade >= 60) // 60 is pass
{
cout << “Pass!” << endl;
}
else // if it's less than 60
{
cout << “Fail!” << endl;
}
return 0;
}
‫اﻟﺸﺮطﯿﺔ‪else if‬‬
‫)‪ */‬اﻟﺸﺮط … *‪if( /‬‬
‫{‬
‫إذا ﺗﺣﻘﻖ اﻟﺷرط ﻧﻔذ اﻷﺗﻲ ‪//...‬‬
‫}‬
‫) ‪ */‬ﺷﺮط أﺧﺮ … *‪else if( /‬‬
‫{‬
‫إذا ﻟم ﺗﺗﺣﻘﻖ اﻟﺷروط اﻟﺳﺎﺑﻘﺔ و ﺗﺣﻘﻖ اﻟﺷرط ھذا ﻧﻔذ اﻷﺗﻲ ‪//...‬‬
‫}‬
‫‪else‬‬
‫{‬
‫إذا ﻟم ﺗﺗﺣﻘﻖ أي ﻣن اﻟﺷروط ﻧﻔذ اﻷﺗﻲ ‪//...‬‬
‫}‬
‫ﻣﺜﺎل ﻧﻘﺮر أن ﻳﻜﻮن ﺿﻌﯿﻔﺎً ﻟﻤﻌﺮﻓﺔ ﻓﺌﺔ اﻟﻄﺎﻟﺐ ﻣﻦ ﻋﻼﻣﺘﻪ ﻓﻲ إﺣﺪى‬
:ً‫اﻹﻣﺘﺤﺎﻧﺎت ﺣﯿﺚ أو وﺳﻄﺎً أو ﺟﯿﺪاً أو ﻣﻤﺘﺎزا‬
#include <iostream>
using namespace std;
int main()
{
unsigned int student_grade; // Student grade variable
cout << “Enter student grade: “;
cin >> student_grade;
if(student_grade < 60) // Bad grade
{
cout << “Fail!” << endl;
}
else if((student_grade >= 60 )&&(student_grade < 70) // Moderate grade
{
cout << “Fair” << endl;
}
elseif((student_grade >=70)&&(student_grade < 80) // Good grade
{cout << “Good.” << endl;
}
elseif((student_grade >=80)&&(student_grade < 90) // Good grade
{cout << “Very Good.” << endl;
}
else // Excellent grade
{
cout << “Excellent!” << endl;
}
‫اﻟﻤﺤﺎﺿﺮة اﻟﺜﺎﻟﺜﺔ‬
‫أﻣﺜﻠﺔ‬
‫ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺈﻳﺠﺎد اﻟﻘﯿﻤﺔ اﻟﻤﻄﻠﻘﺔ ﻷي رﻗﻢ‬
‫ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺈدﺧﺎل رﻗﻢ وﻓﺤﺼﻪ ﻓﻲ ﺣﺎل ﻛﺎن اﻟﺮﻗﻢ ﺳﺎﻟﺒﺎ و ﻓﺮدﻳﺎ‬
‫ﻳﻀﺎف ﻟﻪ رﻗﻢ واﺣﺪ و ﻳﻀﺮب ﺑـ ‪۱-‬‬
‫ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺈدﺧﺎل رﻗﻢ ﻓﺎن ﻛﺎن ﻣﻦ ‪ ۱۸‬ﺣﺘﻰ ‪ ٥٦‬ﻳﻄﺒﻊ ﻣﻘﺒﻮل و اﻻ‬
‫ﻳﻄﺒﻊ ﻏﯿﺮ ﻣﻘﺒﻮل‬
‫وﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﻪ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫ﺑﺮﻧﺎﻣﺞ آﻟﺔ ﺣﺎﺳﺒﺔ ﺗﻘﻮم ﺑﺎﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ اﻷﺳﺎﺳﯿﺔ‬
‫ﻣﻼﺣﻈﺔ ﻣﮭﻤﺔ ﺟﺪا‪:‬‬

‫ﻓﻲ ﺣﺎل ﻛﺎن ﺟﻮاب اﻟﺸﺮط ﺳﻄﺮ‬
‫واﺣﺪ ﻓﻘﻂ ﻳﻤﻜﻦ اﻻﺳﺘﻐﻨﺎء ﻋﻦ‬
‫اﻷﻗﻮاس اﻟﻜﺒﯿﺮة‪.‬‬
‫ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل‬
‫ﻟﺪﻳﻨﺎ ﺣﺴﺎس ﻳﻌﻄﻲ درﺟﺔ اﻟﺤﺮارة و اﻟﺮطﻮﺑﺔ )ﻳﻤﻜﻦ ﻟﻠﻤﺴﺘﺨﺪم ادﺧﺎﻟﮭﻤﺎ( ﻓﻲ‬
‫ﺣﺎل ﻛﺎﻧﺖ درﺟﺔ اﻟﺤﺮاة أﻗﻞ ﻣﻦ ‪ ۳۰‬درﺟﺔ وأﻛﺒﺮ ﻣﻦ ‪۳٥‬و اﻟﺮطﻮﺑﺔ أﻗﻞ ﻣﻦ ‪ ٦۰‬و اﻛﺜﺮ‬
‫ﻣﻦ ‪ ۷۰‬ﻳﻌﻄﻲ اﻟﺒﺮﻧﺎﻣﺞ رﺳﺎﻟﺔ ﺧﻄﺄ‬
‫ﻣﻼﺣﻈﺔ‪:‬‬
‫ان وﺿﻊ إﺷﺎرة ‪\a‬ﻓﻲ أﺧﺮ‬
‫إﺷﺎرة اﻟﺘﻨﺼﯿﺺ ﻳﻌﻄﻲ‬
‫ﻧﻐﻤﺔ ﺧﻄﺄ‬
‫ﻣﺜﺎل أﻋﺪ ﺣﺴﺎب اﻟﻘﯿﻤﺔ اﻟﻤﻄﻠﻘﺔ ﺑﺎﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ اﻟﺜﻼﺛﻲ‬
#include <iostream>
int main()
{
int number;
int abs_number;
cout << "Enter a number ";
cin >> nummber;
abs_number = (number < 0)? number * 1: number;
cout << abs_number;
return 0;
}
‫برمجة ‪1‬‬
‫المحاضرة الرابعه‬
‫المهندس ‪ :‬محمد أزرق‬
‫ال ‪switch‬‬
‫‪‬‬ ‫)‪ */‬القيمة *‪switch (/‬‬
‫‪‬‬ ‫{‬
‫‪‬‬ ‫‪1 */:‬الحالة *‪case /‬‬
‫‪‬‬ ‫إذا نفذ حتى تصل إلى ‪1‬إذا تحققت أن القيمة تساوي الحالة ‪// break‬‬
‫‪‬‬ ‫;‪break‬‬
‫‪‬‬ ‫‪2 */:‬الحالة *‪case /‬‬
‫‪‬‬ ‫إذا نفذ حتى تصل إلى ‪2‬إذا تحققت أن القيمة تساوي الحالة ‪// break‬‬
‫‪‬‬ ‫;‪break‬‬
‫‪‬‬ ‫‪default:‬‬
‫‪‬‬ ‫نفذ إذا لم تتحقق أي حالة مما سبق ‪//‬‬
‫‪‬‬ ‫}‬
‫ وقت وصول القطار‬:‫مثال‬
 include <iostream>
 int main()
 {
int day_number;
cout << “Enter day by number (saturday = 0 ...): “;
cin >> day_number;
switch (day_number)
{
case 0:
cout << “Train will arrive at 8:00 AM” << endl;
break;
case 1:
case 4:
break;
case 2:
break;
case 3:
case 5:
case 6:
cout << “Holiday!!!” << endl;
break;
default:
cout << “Wrong Input” << endl;
}
return 0;}
‫برنامج آلة حاسبة باستخدام ‪switch‬‬
‫الحلقات ‪Loops‬‬
‫الحلقات‪ :‬هي تكرار سلسلة من التعليمات‪ ،‬و تقسم الحلقات إلى فئتين‪:‬‬ ‫●‬
‫الحلقات العددية‪ :‬التي يكون فيها عدد الدورات معين برقم‪ ،‬مثال عليها حلقة ‪for‬‬ ‫●‬
‫الحلقات الشرطية‪ :‬هي الحلقات التي يكون عدد الدورات فيها غير معينا ً لكن تنتهي الحلقة بتحقق شرط معين‪،‬‬ ‫●‬
‫مثال عليها حلقة ‪while‬‬

‫الحلقة ‪for‬‬
‫هي حلقة عددية تنتهي بعدم تحقق شرط الحلقة‬ ‫●‬
‫الشكل العام لحلقة ‪:for‬‬ ‫●‬
‫‪‬‬ ‫)‪for (Init-statement; condition; Expr‬‬

‫‪‬‬ ‫{‬
‫‪‬‬ ‫;‪Code block‬‬
‫‪‬‬ ‫}‬
‫‪Init-statement:‬تعلمية تنفذ مرة واحدة في بداية الحلقة‬ ‫‪‬‬
‫‪condition: ‬هو الشرط الذي بعدم تحققه تتوقف الحلقة‬

‫‪Expr: ‬هي تعليمة تنفذ كل ما إنتهت الحلقة من دورة عمل‬
‫‪Code block: ‬هي التعليمات المراد تنفيذها داخل الحلقة في كل دورة عمل‬
flow chart ‫ في ال‬for ‫شكل ال‬
‫مثال على الحلقة ‪for‬‬
‫لطباعة عبارة ‪ Hello‬عشر مرات نكتب التالي‪:‬‬ ‫●‬
‫‪‬‬ ‫)‪for(int i = 0; i < 10; i++‬‬ ‫‪10‬الحظ الرقم ‪//‬‬

‫‪‬‬ ‫{‬
‫‪‬‬ ‫;‪cout << "Hello" << endl‬‬
‫‪‬‬ ‫}‬
‫مثال أخر على إستخدام ‪for‬‬
‫نريد طباعة عدد التكرار الحالي للحلقة ‪:‬‬ ‫●‬
‫‪‬‬ ‫)‪for(int i = 0; i < 10; i++‬‬

‫‪‬‬ ‫{‬
‫‪‬‬ ‫مع فراغ بينها ‪9‬إلى ‪0‬تقوم بطبع الرقم من ‪cout << i << ' '; //‬‬
‫‪‬‬ ‫}‬
‫مثال أخر على استخدام ‪for‬‬
‫‪ ‬طباعة األرقام من قيمة نهائية إلى قيمة إبتدائية (يطبع رقم ‪ ،‬ويهمل رقم)‪:‬‬
‫برنامج يحسب عدد مع قوة محددة‬
#include <iostream>
int main()
{
int number; // Input number storage
int power; // input power storage
int result; // the result of multiplying
cout << "Enter number and it's power: ";
cin >> number >> power;

result = 1;
for(int i = 1; i <= power ; i++)

{
result *= number;
}
cout << number << '^' << power << " = " << result << endl;
return 0;
}
‫برنامج لحساب العاملي لرقم‬
#include <iostream>
int main()
{
int number; // Input number storage
int result; // the result of multiplying
cout << "Enter number: ";
cin >> number ;
result = 1;
for(int i = 1; i <= number; i++)
{
result *=i;
}
cout <<“! Number=“<< result << endl;

return 0;
}
‫اﻟﻤﺤﺎﺿﺮة اﻟﺨﺎﻣﺴﺔ‬
‫م ﻣﺤﻤﺪ أزرق‬
‫ﻣﺜﺎل ﻋﻠﻰ رﺳﻢ ﻣﺜﻠﺚ ﻣﺘﺴﺎوي اﻟﺴﺎﻗﯿﻦ ﺑﺎﻟﺤﻠﻘﺔ ‪for‬‬
‫اﻟﺤﻠﻘﺔ ‪while‬‬
‫ھﻲ ﺣﻠﻘﺔ ﺷﺮطﯿﺔ ﺗﻨﺘﮭﻲ ﺑﻌﺪم ﺗﺤﻘﻖ ﺷﺮط اﻟﺤﻠﻘﺔ‬ ‫●‬
‫اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﺤﻠﻘﺔ ‪:while‬‬ ‫●‬
‫‪‬‬ ‫)‪while(Condition‬‬
‫‪‬‬ ‫{‬
‫‪‬‬ ‫;‪code block‬‬
‫‪‬‬ ‫}‬
‫‪Condition: ‬ھﻮ اﻟﺸﺮط اﻟﺬي ﺑﺘﺤﻘﻘﺔ ﺗﻜﻤﻞ اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮار‬
‫‪Code block: ‬ھﻲ اﻟﺘﻌﻠﯿﻤﺎت اﻟﻤﺮاد ﺗﻨﻔﯿﺬھﺎ داﺧﻞ اﻟﺤﻠﻘﺔ ﻓﻲ ﻛﻞ دورة ﻋﻤﻞ‬
flow chart ‫ ﻓﻲ ال‬while ‫ﺷﻜﻞ ال‬
while ‫ﻣﺜﺎل ﻋﻦ إﺳﺘﻌﻤﺎل‬
‫وﻣن ﺛم ﯾطﺑﻌﮭﺎ و‬capital letter ‫و ﯾﺣوﻟﮭﺎ إﻟﻰ‬small letter ‫ﺑﺮﻧﺎﻣﺞ ﯾﻘﺒﻞ اﻟﺤﺮوف ﺑﺤﺠﻢ‬ ●
:‫ﯾرﻓض اي ﺣروف أُﺧرى‬
 #include <iostream>
 int main()
 {
 const unsigned char BEGIN_OF_SMALL_CHARS = 97;
 const unsigned char END_OF_SMALL_CHARS = 122;
 unsigned char ch;
 cin >> ch;

while(ch >= BEGIN_OF_SMALL_CHARS &&
ch <= END_OF_SMALL_CHARS) //ASCII ‫ﻓﻘﻂ‬
‫اﻷﺣﺮف اﻟﺼﻐﯿﺮة ﻓﻲ ﺷﯿﻔﺮة ال‬
{
cout << (char)(ch - 32);
cin >> ch;
}
cout << "end of input!" << endl;
return 0;
}
‫اﻟﺤﻠﻘﺔ ‪do...while‬‬
‫ھﻲ ﺣﻠﻘﺔ ﺗﻨﻔﺬ اﻟﺘﻌﻠﯿﻤﺎت أوﻻً داﺧﻞ اﻟﺤﻠﻘﺔ ﻗﺒﻞ أن ﺗﺘﺤﻘﻖ ﻣﻦ اﻟﺸﺮط‬ ‫●‬
‫اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﺤﻠﻘﺔ ‪:do...while‬‬ ‫●‬
‫‪‬‬ ‫‪do‬‬
‫‪‬‬ ‫{‬
‫‪‬‬ ‫;‪Code block‬‬
‫‪‬‬ ‫;) ‪}while( condition‬‬
‫‪Condition: ‬ھﻮ اﻟﺸﺮط اﻟﺬي ﺑﺘﺤﻘﻘﺔ ﺗﻜﻤﻞ اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮار‬
‫‪Code block: ‬ھﻲ اﻟﺘﻌﻠﯿﻤﺎت اﻟﻤﺮاد ﺗﻨﻔﯿﺬھﺎ داﺧﻞ اﻟﺤﻠﻘﺔ ﻓﻲ ﻛﻞ دورة ﻋﻤﻞ‬
flow chart ‫ ﻓﻲ ال‬do...while‫ﺷﻜﻞ ال‬
do...while ‫ﻣﺜﺎل ﻋﻦ ال‬
‫ﻗﺎﺋﻤﺔ أواﻣﺮ‬
 int main()
 {
 char ch;
 bool is_invalid_char;
 cout << "1. First choice" << endl;

 cout << "2. Second choice" << endl;
 cout << "3. Third choice" << endl;
 cout << "Enter your choice: " << endl;
 do {
 is_invalid_char = false;
 cin >> ch;
 }
switch(ch)
{
case '1':
cout << "You have chosen first choice";
break;
case '2':
cout << "You have chosen second choice";
break;
case '3':
cout << "You have chosen third choice";
break;
default:
cout << "Wrong choice!" << endl;
is_invalid_char = true;
}
} while(is_invalid_char);
return 0 ;
}
‫اﻟﻌﺒﺎرة ‪break‬‬
‫‪ ‬ھﻲ ﻋﺒﺎرة ﺗﺴﺘﻌﻤﻞ ﻟﻠﺨﺮوج اﻟﻘﺴﺮي ﻣﻦ اﻟﺤﻠﻘﺔ‬

‫‪ ‬ﺗﺴﺘﺨﺪم ﻓﻲ اﻟﺨﺮوج ﻣﻦ اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﺔ ‪ ،‬وأﻳﻀﺎً ﻣﻦ ﺣﻠﻘﺔ ‪Switch‬‬
‫‪ ‬ﻻ ﺗﺴﺘﺨﺪم ﻣﻊ اﻟﺠﻤﻠﺔ ‪if‬‬
‫‪ ‬ﺗﻘﻮم ﺑﺈﻧﮭﺎء اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﻳﺔ ﻗﺒﻞ إﻛﻤﺎل اﻟﺸﺮط‪.‬‬
‫ﺗﻔﯿﺪ ﻓﻲ اﻟﺨﺮوج ﻣﻦ اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﺔ اﻷﺑﺪﻳﺔ‪.‬‬ ‫‪‬‬
loops ‫ ﻣﻊ ال‬break ‫ﻋﻤﻞ‬
12
break ‫ﻣﺜﺎل أﺧﺮ ﻋﻦ إﺳﺘﺨﺪام‬
#include <iostream>
cout << "value of a: " << a << endl;
int main () a = a + 1;
if( a > 15)
{
{
int a = 10; // Local variable // terminate the loop
declaration: break;
cout << “Enter number: “; }
}while( a < 20 );
cin >> a;
do // do loop execution return 0;
{ }
‫ﻣﺜﺎل أﺧﺮ ﺑﺮﻧﺎﻣﺞ ﻳﺠﻤﻊ ﻗﯿﻢ اﻹدﺧﺎل اﻟﻤﺘﺘﺎﻟﯿﺔ و ﻳﻘﻮم ﺑﻮﻗﻒ اﻹدﺧﺎل ﻋﻨﺪ إدﺧﺎل‬
۰ ‫اﻟﻤﺴﺘﺨﺪم رﻗﻢ‬
#include <iostream>
int main(){
float number, sum = 0.0;
while (true) else
{ {
cout << "Enter a number: "; break; // terminating the loop if
number equals to 0.0
cin >> number;
}
if(number != 0.0) }
{ cout << "Sum = " << sum;
sum += number; return 0;
}
}
‫ﺑﺮﻧﺎﻣﺞ ﻳﺤﺴﺐ ﻣﺠﻤﻮع ﻋﺸﺮ أرﻗﺎم و ﻳﻘﻒ ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﻟﻤﺠﻤﻮع‬
ً‫اﻟﺤﺎﻟﻲ ﺳﺎﻟﺒﺎ‬
#include <iostream>
if(sum < 0)
int main()
{
{ cout << "Negative sum" << endl;
const int INPUT_NUMBER_COUNT = 10; break;
}
int input_number; }
int sum = 0; if(sum >= 0)
{
for (int i = 1; i <= INPUT_NUMBER_COUNT; i++) cout << "The sum is " << sum << endl;
{ }
cout << "Enter number #" << i << ": ";
cout << "Program terminated!" << endl;
cin >> input_number; return 0;
sum += input_number; }
‫اﻟﻌﺒﺎرة ‪continue‬‬
‫>‪#include <iostream‬‬
‫;‪using namespace std‬‬ ‫ھﻲ ﻋﺒﺎرة ﺗﺴﺘﺨﺪم ﻟﻠﻘﻔﺰ ﻣﻦ‬
‫)(‪int main‬‬ ‫اﻟﺪورة اﻟﺤﺎﻟﯿﺔ و اﻻﻧﺘﻘﺎل ﻋﻠﻰ‬
‫اﻟﺪورة اﻟﺘﻲ ﺗﻠﯿﮭﺎ‬
‫{‬
‫)‪for (int i = 1; i <= 10; ++i‬‬
‫{‬
‫)‪if( i == 6 || i == 9‬‬ ‫ﻓﻲ ھﺬا اﻟﻤﺜﺎل ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﺑﺎﻟﻌﺪ ﻣﻦ اﻟﻮاﺣﺪ ﺣﺘﻰ اﻟﻌﺸﺮة‬
‫{‬
‫ﻟﻜﻨﻪ ﻟﻦ ﻳﻘﻮم ﺑﻌﺪ اﻟﺮﻗﻤﯿﻦ ‪ ٦‬و ‪۹‬‬
‫;‪continue‬‬
‫}‬
‫;'‪cout << i << '\t‬‬
‫}‬
‫;‪return 0‬‬
‫}‬
loops ‫ ﻣﻊ ال‬continue ‫ﻋﻤﻞ‬
17
‫ ﻟﻌدد ﯾدﺧﻠﮫ اﻟﻣﺳﺗﺧدم‬3 ‫ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﻄﺒﻊ ﺳﻠﺴﺔ اﻟﻘﻮاﺳﻢ ﻋﻠﻰ‬
#include <iostream>
int main()
{
int input_value;
cout << "Enter number: ";
cin >> input_value;
for(int i = 1; i <= input_value; i++)
{
if(i % 3==1) continue; // ‫إذا ﻛﺎن اﻟﺮﻗﻢ ﻏﯿﺮ ﻗﺎﺳﻢ ﻋﻠﻰ‬3 ‫ﻓﺗﺧطﻰ ھذه اﻟﺧطوة‬
cout << i << '\t';
}
return 0;}
‫اﻟﻤﺤﺎﺿﺮة اﻟﺴﺎدﺳﺔ‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺤﺴﺎب ﻗﺎﻧﻮن اوم‬
‫ﺑﺮﻧﺎﻣﺞ ﻟﺤﺴﺎب ﻣﻘﺴﻢ اﻟﺠﮭﺪ‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺤﺴﺎب ﺟﺪول اﻟﻀﺮب ﻟﺮﻗﻢ ﻣﺎ‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺎﻟﻌﺪ ﻣﻦ ‪ ۲۰‬ﺣﺘﻰ ‪ ۸۰‬ﺑﺨﻄﺔ ﻋﺪ ‪ ٥‬وﻻ‬
‫ﻳﻄﺒﻊ اﻟﻘﯿﻢ ‪ ۳۰‬و ‪ ٥۰‬و ‪٦۰‬‬
‫وظﯿﻔﺔ‬
‫‪ ‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺤﺴﺎب ﻧﺎﺗﺞ ﻋﺪد ﻣﺮﻓﻮع إﻟﻰ ﻗﻮة ﻣﺘﻀﻤﻨﺎَ اﻟﻘﻮى اﻟﺴﺎﻟﺒﺔ‬
‫‪ ‬اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺤﺴﺎب اﻟﻌﻼﻗﺔ اﻟﺘﺎﻟﯿﺔ ‪:‬‬
‫ﻣﺴﺘﺨﺪﻣﺎ ﻣﻜﺘﺒﺔ اﻟﺮﻳﺎﺿﯿﺎت‬
‫= 𝑆𝑆‬ ‫‪10 + 21 + 32 + 𝑛𝑛𝑛𝑛−1‬‬
‫اﻟﻤﺼﻔﻮﻓﺎت ‪Arrays‬‬
‫ھﻲ ﻋﺒﺎرة ﻋﻦ ﺳﻠﺴﻠﺔ ﻣﺘﻮاﺻﻠﺔ ﻣﻦ اﻟﻤﺘﻐﯿﺮات ذات اﻟﻨﻮع اﻟﻮاﺣﺪ ﻓﻲ اﻟﺬاﻛﺮة‬ ‫●‬
‫طﺮﯾﻘﺔ ﺗﻌﺮﯾﻒ اﻟﻤﺼﻔﻮﻓﺎت ﻓﻲ ﻟﻐﺔ ‪: C/C++‬‬ ‫●‬
‫‪‬‬ ‫;]‪Type Name[Size‬‬

‫‪Type :‬وھﻮ ﻧﻮع اﻟﻤﺼﻔﻮﻓﺔ ﻣﺜﺎل‪int‬‬ ‫‪‬‬
‫‪Name:‬أﺳم اﻟﻣﺻﻔوﻓﺔ‬ ‫‪‬‬
‫‪Size:‬وھو طول اﻟﻣﺻﻔوﻓﺔ‬ ‫‪‬‬
‫‪ ‬ﻣﺜﺎل‪:‬‬
‫‪‬‬ ‫;]‪int foo[5‬‬
‫ﺗﻌﺮﯾﻒ اﻟﻤﺼﻔﻮﻓﺔ ‪Array decleration‬‬
‫ﯾﻤﻜﻦ أن ﯾﺘﻀﻤﻦ ﺗﻌﺮﯾﻒ اﻟﻤﺼﻔﻮﻓﺔ ﻗﯿﻢ إﺑﺘﺪاﺋﯿﺔ ﻟﮭﺎ ﻣﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫;}‪char input_values[5] = {10, 20, 30, 60, 65‬‬
‫وﯾﻤﻜﻦ أن ﻻ ﺗﺘﻀﻤﻦ اﻟﻘﯿﻢ ﻛﻠﮭﺎ ﻓﯿﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﻮﺿﻊ أﺻﻔﺎر ﻣﻜﺎن اﻟﻌﻨﺎﺻﺮ اﻟﻠﺘﻲ ﻟﻢ ﺗﺤﺪد ﻗﯿﻤﮭﺎ ﻣﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫;} ‪int bar [5] = { 10, 20, 30‬‬

‫‪ ‬ﻓﯿﺼﺒﺢ ﺷﻜﻞ اﻟﻤﺼﻔﻮﻓﺔ ‪bar‬ﻓﻲ اﻟذاﻛرة‪:‬‬
‫اﻟﻮﺻﻮل إﻟﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‬
‫‪Accessing array elements‬‬
‫ﺑﺈﻣﻜﺎﻧﻨﺎ إﺳﻨﺎد ﻗﯿﻤﺔ إﻟﻰ ﻋﻨﺼﺮ ﻣﻦ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬ ‫●‬
‫‪‬‬ ‫;‪ArrayName[Index] = Value‬‬

‫‪ ‬ﺑﺤﯿﺚ أن‪:‬‬
‫‪ArrayName: ‬ھﻮ اﺳﻢ اﻟﻤﺼﻔﻮﻓﺔ‬
‫‪Index: ‬ھﻮ رﻗﻢ اﻟﻌﻨﺼﺮ اﻟﻤﺮاد إﺳﻨﺎد اﻟﻘﯿﻤﺔ ‪.‬‬
‫‪ ‬ﺗﺒﺪأ اﻟﻔﮭﺮﺳﺔ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺎت ﻣﻦ اﻟﺮﻗﻢ ‪۰‬‬
‫‪Value: ‬ھﻲ اﻟﻘﯿﻤﺔ اﻟﻤﺮاد إﺳﻨﺎدھﺎ ﻟﻠﻌﻨﺼﺮ‬
‫ﻣﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫;]‪int sum_array[5‬‬

‫‪‬‬ ‫إﻟﻰ اﻟﻌﻧﺻر اﻟﺮاﺑﻊ ‪52‬ﯾﻘﻮم ﺑﺈﺳﻨﺎد اﻟﻘﯿﻤﺔ ‪sum_array[3] = 52; //‬‬
‫ﺑﺈﻣﻜﺎﻧﻨﺎ ﻗﺮاﺋﺔ ﻗﯿﻤﺔ ﻋﻨﺼﺮ ﻣﺼﻔﻮﻓﺔ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬ ‫●‬
‫‪‬‬ ‫;]‪ArrayName[Index‬‬
‫‪Index: ‬ھﻮ رﻗﻢ اﻟﻌﻨﺼﺮ اﻟﻤﺮاد ﻗﺮاﺋﺔ ﻗﯿﻤﺘﮫ‬
‫‪ ‬ﻧﺎﺗﺞ ھﺬه اﻟﺘﻌﻠﯿﻤﺔ ھﻲ ﻗﯿﻤﺔ اﻟﻌﻨﺼﺮ‬
‫ﻣﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫;}‪int my_arr[] = {10, 68, 48‬‬

‫‪‬‬ ‫‪int num = my_arr[2]; // num = 48‬‬
‫ﻣﺜﺎل ﻋﻠﻰ إﺳﺘﺨﺪام اﻟﻤﺼﻔﻮﻓﺎت‬
:‫ﺑﺮﻧﺎﻣﺞ ﯾﻘﻮم ﺑﺠﻤﻊ ﻗﯿﻢ ﻣﺼﻔﻮﻓﺔ ﯾﺪﺧﻠﮭﺎ اﻟﻤﺴﺘﺨﺪم‬ ●
 // arrays example
 int main()
 {
 int foo[5];
 int result = 0;
for (int n = 0; n < 5; n++)
{
cout << “Enter element #” << n << “: “;
cin >> foo[n];
}
for (int j = 0; j < 5; j++)
{
result += foo[j];
}
cout << result << endl;
return 0;
}
‫ﻣﺜﺎل أﺧﺮ ﻋﻠﻰ اﻟﻤﺼﻔﻮﻓﺎت‬
‫ﺑﺮﻧﺎﻣﺞ ﯾﻘﻮم ﺑﺤﺴﺎب اﻟﻘﯿﻤﺔ اﻟﻜﺒﺮى و اﻟﻘﯿﻤﺔ اﻟﺼﻐﺮى ﻟﺴﻠﺴﻠﺔ‬ ‫●‬
‫ﻣﻦ ‪10‬ﻗﯾم ﯾدﺧﻠﮭﺎ اﻟﻣﺳﺗﺧدم‪:‬‬

‫‪‬‬ ‫>‪#include <iostream‬‬
‫‪‬‬ ‫;‪using namespace std‬‬
‫‪‬‬ ‫)(‪int main‬‬

‫‪‬‬ ‫{‬
‫‪‬‬ ‫;‪const int INPUT_NUMBERS_COUNT = 10‬‬
‫‪‬‬ ‫;]‪int input_values[INPUT_NUMBERS_COUNT‬‬ ‫ﯾﺠﺐ أن ﯾﻜﻮن اﻟﺤﺠﻢ إﻣﺎ ﻗﯿﻤﺔ ﻓﻮرﯾﺔ ‪//‬‬
‫أو ﺛﺎﺑﺖ‬
‫‪‬‬ ‫;‪int min, max‬‬
for (int i = 0; i < INPUT_NUMBERS_COUNT; i++)
{
cin >> input_values[i];
}
min = max = input_values[0]; // set all registers to the first input number
for (int j = 1; j < INPUT_NUMBERS_COUNT; j++)
{
if(input_values[j] < min)
{
min = input_values[j];
}
else if(input_values[j] > max)
{
max = input_values[j];
}
}
cout << "The maximum number is: " << max << endl;
cout << "The minmum number is: " << min << endl;
return 0;
}
‫اﻟﻤﺤﺎﺿﺮة اﻟﺴﺎدﺳﺔ‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺤﺴﺎب ﻗﺎﻧﻮن اوم‬
‫ﺑﺮﻧﺎﻣﺞ ﻟﺤﺴﺎب ﻣﻘﺴﻢ اﻟﺠﮭﺪ‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺤﺴﺎب ﺟﺪول اﻟﻀﺮب ﻟﺮﻗﻢ ﻣﺎ‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺎﻟﻌﺪ ﻣﻦ ‪ ۲۰‬ﺣﺘﻰ ‪ ۸۰‬ﺑﺨﻄﺔ ﻋﺪ ‪ ٥‬وﻻ‬
‫ﻳﻄﺒﻊ اﻟﻘﯿﻢ ‪ ۳۰‬و ‪ ٥۰‬و ‪٦۰‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺤﺴﺎب ﻣﻌﺪل ﻋﻼﻣﺔ اﻟﻄﺎﻟﺐ ﺑﺤﯿﺚ ﻳﺴﺘﻤﺮ ﺑﺠﻤﻊ اﻟﻤﻮاد ﺣﯩﺚ ﻳﺪﺧﻞ‬
‫اﻟﻤﺴﺘﺨﺪم اﻟﺮﻗﻢ ﺻﻔﺮ ﻋﻨﺪھﺎ ﺗﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ و ﻓﻲ ﺣﺎل ادﺧﻞ اﻟﻤﺴﺘﺨﺪم ﻋﻼﻣﺔ أﻗﻞ ﻣﻦ ‪ ٦۰‬و‬
‫اﻛﺒﺮ ﻣﻦ ‪ ۱۰۰‬ﻳﻄﺒﻊ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻼﻣﺔ ﺧﻄﺎ و ﻳﻄﻠﺐ اﻋﺎدة اﻻدﺧﺎل دون ان ﻳﺤﺴﺐ اﻟﻌﻼﻣﺔ اﻟﺘﻲ‬
‫ادﺧﻠﮭﺎ ﻓﻲ اﻟﻤﻌﺪل و ﻋﻨﺪ اﻧﺘﮭﺎء اﻟﺒﺮﻧﺎﻣﺞ ﻳﻄﺒﻊ ﻋﺪد اﻟﻤﻮاد اﻟﻤﺪﺧﻠﺔ واﻟﻤﻌﺪل‬
‫وظﯿﻔﺔ‬
‫‪ ‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺤﺴﺎب ﻧﺎﺗﺞ ﻋﺪد ﻣﺮﻓﻮع إﻟﻰ ﻗﻮة ﻣﺘﻀﻤﻨﺎَ اﻟﻘﻮى اﻟﺴﺎﻟﺒﺔ‬
‫‪ ‬اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺤﺴﺎب اﻟﻌﻼﻗﺔ اﻟﺘﺎﻟﯿﺔ ‪:‬‬
‫ﻣﺴﺘﺨﺪﻣﺎ ﻣﻜﺘﺒﺔ اﻟﺮﻳﺎﺿﯿﺎت‬
‫= 𝑆𝑆‬ ‫‪10 + 21 + 32 + 𝑛𝑛𝑛𝑛−1‬‬

‫‪ ‬ﻣﺜﺎل‪:‬‬
‫‪‬‬ ‫;]‪int foo[5‬‬
‫‪‬‬ ‫;}‪char input_values[5] = {10, 20, 30, 60, 65‬‬
‫‪‬‬ ‫;} ‪int bar [5] = { 10, 20, 30‬‬


‫‪ ‬ﺑﺤﯿﺚ أن‪:‬‬
‫ﻣﺜﺎل‪:‬‬ ‫●‬

‫ﻣﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫;}‪int my_arr[] = {10, 68, 48‬‬

‫‪‬‬ ‫‪int num = my_arr[2]; // num = 48‬‬
// arrays example
#include <iostream>
int main()
{
int foo[5];
int result = 0;
for (int n = 0; n < 5; n++)
{
cin >> foo[n];
}
for (int j = 0; j < 5; j++)
{
result += foo[j];
}
return 0;
}
‫ﺑﺮﻧﺎﻣﺞ ﯾﻘﻮم ﺑﺤﺴﺎب اﻟﻘﯿﻤﺔ اﻟﻜﺒﺮى و اﻟﻘﯿﻤﺔ اﻟﺼﻐﺮى و اﻟﻤﺘﻮﺳﻂ اﻟﺤﺴﺎﺑﻲ‬ ‫●‬
‫ﻟﺴﻠﺴﻠﺔ ﻣﻦ ‪10‬ﻗﯾم ﯾدﺧﻠﮭﺎ اﻟﻣﺳﺗﺧدم‪:‬‬

‫اﻟﻤﺤﺎﺿﺮة اﻟﺜﺎﻣﻨﺔ‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺤﺴﺎب ﻣﻌﺪل ﻋﻼﻣﺔ اﻟﻄﺎﻟﺐ ﺑﺤﯿﺚ ﻳﺴﺘﻤﺮ ﺑﺠﻤﻊ اﻟﻤﻮاد ﺣﯩﺚ ﻳﺪﺧﻞ‬
‫اﻟﻤﺴﺘﺨﺪم اﻟﺮﻗﻢ ﺻﻔﺮ ﻋﻨﺪھﺎ ﺗﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ و ﻓﻲ ﺣﺎل ادﺧﻞ اﻟﻤﺴﺘﺨﺪم ﻋﻼﻣﺔ أﻗﻞ ﻣﻦ ‪ ٦۰‬و‬
‫اﻛﺒﺮ ﻣﻦ ‪ ۱۰۰‬ﻳﻄﺒﻊ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻼﻣﺔ ﺧﻄﺎ و ﻳﻄﻠﺐ اﻋﺎدة اﻻدﺧﺎل دون ان ﻳﺤﺴﺐ اﻟﻌﻼﻣﺔ اﻟﺘﻲ‬
‫ادﺧﻠﮭﺎ ﻓﻲ اﻟﻤﻌﺪل و ﻋﻨﺪ اﻧﺘﮭﺎء اﻟﺒﺮﻧﺎﻣﺞ ﻳﻄﺒﻊ ﻋﺪد اﻟﻤﻮاد اﻟﻤﺪﺧﻠﺔ واﻟﻤﻌﺪل‬

‫‪ ‬ﻣﺜﺎل‪:‬‬
‫‪‬‬ ‫;]‪int foo[5‬‬
‫‪‬‬ ‫;}‪int input_values[5] = {10, 20, 30, 60, 65‬‬
‫‪‬‬ ‫;} ‪int bar [5] = { 10, 20, 30‬‬


‫‪ ‬ﺑﺤﯿﺚ أن‪:‬‬
‫ﻣﺜﺎل‪:‬‬ ‫●‬

‫ﻣﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫;}‪int my_arr[] = {10, 68, 48‬‬

‫‪‬‬ ‫‪int num = my_arr[2]; // num = 48‬‬
// arrays example
#include <iostream>
int main()
{
int foo[5];
int result = 0;
for (int n = 0; n < 5; n++)
{
cin >> foo[n];
}
for (int j = 0; j < 5; j++)
{
result += foo[j];
}
return 0;
}
‫ﺑﺮﻧﺎﻣﺞ ﯾﻘﻮم ﺑﺤﺴﺎب اﻟﻘﯿﻤﺔ اﻟﻜﺒﺮى و اﻟﻘﯿﻤﺔ اﻟﺼﻐﺮى و اﻟﻤﺘﻮﺳﻂ اﻟﺤﺴﺎﺑﻲ‬ ‫●‬
‫ﻟﺴﻠﺴﻠﺔ ﻣﻦ ‪10‬ﻗﯾم ﯾدﺧﻠﮭﺎ اﻟﻣﺳﺗﺧدم‪:‬‬

‫‪a) $200 – $499‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﻌﻤﻞ إﺣﺼﺎء ﺷﺮﻛﺔ ﻟﺪﺧﻞ اﻟﻤﻮظﻔﯿﻦ‪ ،‬ﻋﻠﻤﺎ ان ﻛﻞ اﻟﻤﻮظﻔﯿﻦ ﻟﺪﻳﮭﻢ ﻧﻔﺲ‬
‫‪b) $500- $799‬‬
‫اﻟﺮاﺗﺐ و ھﻮ ‪ ، $۲۰۰‬ﺑﺎﻟﻨﺴﺒﺔ إﻟﻰ ‪ % ۹‬ﻣﻦ اﻷرﺑﺎح اﻟﺘﻲ ﻳﺤﻘﻘﮭﺎ ﻛﻞ ﻣﻮظﻒ ﻋﻠﻰ ﺣﺪا ‪.‬‬
‫‪c) $800 – $999‬‬
‫و ﺑﻌﺪ ﺣﺴﺎب اﻷرﺑﺎح ﻗﻢ ﺑﺘﻘﺴﯿﻢ اﻟﻨﺎﺗﺞ إﻟﻰ ﺷﺮاﺋﺢ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬
‫أو أﻛﺜﺮ ‪d) 1000‬‬
‫ﻗﻢ ﺑﺈﻳﺠﺎد أﻋﻠﻰ راﺗﺐ وأﻗﻞ راﺗﺐ ‪.‬‬
‫اﻟﻤﺤﺎﺿﺮة اﻟﺘﺎﺳﻌﺔ‬
Swapping ‫اﻟﺘﺒﺪﯾﻞ‬
‫ھﻮ ﻋﺒﺎرة ﻋﻦ ﺗﺒﺪﯾﻞ ﻗﯿﻤﺘﻲ ﻣﺘﺤﻮﻟﯿﻦ‬ 
‫ﻻﺑﺪ ﻟﮫ ﻣﻦ إﺳﺘﺨﺪام ﻣﺘﺤﻮل وﺳﯿﻂ‬ 
:‫ ﻣﺜﺎل‬
 int value_a = 34;
 int value_b = 98;
 int temp_value = value_b;
 value_b = value_a;
 value_a = temp_value;
 // Now: value_a = 98; value_b = 98
‫اﻟﺘﺮﺗﯿﺐ ‪Sorting‬‬
‫ﻧﻘﻮم ﺑﺘﺮﺗﯿﺐ اﻷﻋﺪاد ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﯾﺪﺧﻠﮭﺎ اﻟﻤﺴﺘﺨﺪم ﺗﺼﺎﻋﺪﯾﺎ ً ﺑﺈﺳﺘﺨﺪام اﻟﺘﺒﺪﯾﻞ ‪ Swaping‬ﺑﯾن‬ ‫‪‬‬
‫ﻋﻧﺎﺻرھﺎ ﻣﺛﺎل ﻋﻠﻰ ھذه اﻟﻌﻣﻠﯾﺔ‪:‬‬

‫اﻟﺘﺮﺗﯿﺐ)ﺗﻜﻤﻠﺔ( ‪Sorting‬‬
‫ﺑﺮﻧﺎﻣﺞ ﯾﻘﺮأ ﺳﻠﺴﻠﺔ ﻧﺼﯿﺔ و ﯾﺤﻮﻟﮭﺎ إﻟﻰ أﺣﺮف ﺻﻐﯿﺮة‬
#include <iostream>
int main()
{ const int STRING_SIZE = 30; ‫ﻋﻦ اﻟﻄﺒﺎﻋﺔ‬cout ‫ ﻳﺘﻮﻗﻒ اﻷﻣﺮ‬:‫ﻣﻼﺣﻈﺔ‬
char input_str[STRING_SIZE]; 0 ‫ﻟﺴﻠﺴﺔ ﻧﺼﻴﺔ ﻋﻨﺪﻣﺎ ﻳﺼﻞ إ�� ﻋﻨﺼﺮ ﻗﻴﻤﺘﮫ‬
cout << "Enter a String: "; ;;
Null terminator‫ويﺴ�ى هﺬا اﻟﻌﻨﺼﺮ ﺑﺎل‬
cin >> input_str ;
for (int i = 0; i < STRING_SIZE; i++)
{ if (input_str[i] >= 'A' && input_str[i] <= 'Z'))
{input_str[i] += 32;}
}
cout << "string in lower case is :" << input_str ;
return 0;
}
‫اﻟﻤﺼﻔﻮﻓﺎت اﻟﻤﺘﻌﺪدة اﻷﺑﻌﺎد‬
‫ﯾﻤﻜﻦ إﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ ذات ﺑﻌﺪﯾﻦ ﻋﻠﻰ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬ ‫●‬
‫‪‬‬ ‫;]‪Type Name [Size_of_y][Size_of_x‬‬

‫‪‬‬ ‫‪int‬وھﻮ ﻧﻮع اﻟﻤﺼﻔﻮﻓﺔ ﻣﺜﺎل ‪Type :‬‬
‫‪Name: ‬أﺳم اﻟﻣﺻﻔوﻓﺔ‬
‫‪Size_of_y: ‬وھو ﻋدد اﻷﺳطر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬
‫‪Size_of_x: ‬وھو ﻋدد اﻷﻋﻣدة ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬
‫‪ ‬ﻣﺜﺎل‪ :‬ﻟﺘﻌﺮﯾﻒ ﻣﺼﻔﻮﻓﺔ ‪2*3‬وإﺳﻧﺎد ﻗﯾم إﺑﺗداﺋﯾﺔ ﻟﮭﺎ‬
‫‪int matrx[2][3] = {{5,12,13},{10,20,30}}; ‬‬
‫ﻟﻘﺮاﺋﺔ ﻗﯿﻤﺔ ﻋﻨﺼﺮ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺜﻨﺎﺋﯿﺔ ﻧﻜﺘﺐ ﻣﻜﺎن اﻟﻌﻨﺼﺮ اﻟﻤﺮاد ﻗﺮاﺋﺔ ﻗﯿﻤﺘﮫ ﻛﻤﺎ ﻗﻠﻨﺎ أﻧﻔﺎ ً ﻣﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ‪2 , 3‬ﺗﻘﻮم ﺑﻄﺒﻊ ﻗﯿﻤﺔ اﻟﻌﻨﺼﺮ اﻟﻤﺘﻮﺿﻊ ﻓﻲ اﻟﻤﻜﺎن ‪cout << matrix[1][2]; //‬‬
‫وﻛﺬﻟﻚ اﻷﻣﺮ ﯾﻄﺒﻖ ﻋﻠﻰ اﻟﻤﺼﻔﻮﻓﺎت اﻟﻤﺘﻌﺪدة اﻷﺑﻌﺎد‬ ‫●‬
‫‪‬‬ ‫ﻣﺼﻔﻮﻓﺔ ﺛﻼﺛﯿﺔ اﻷﺑﻌﺎد‪int matrix[4][5][10] //‬‬

‫ ﺟﻤﻊ ﻣﺼﻔﻮﻓﺘﯿﻦ‬:‫ﻣﺜﺎل‬
#include <iostream>
int main()
{
const int MATRIX_ROWS = 3;
const int MATRIX_COLS = 3;
int a_mat[MATRIX_ROWS][MATRIX_COLS];
int b_mat[MATRIX_ROWS][MATRIX_COLS];
int sum_mat[MATRIX_ROWS][MATRIX_COLS];
}
}
cout << "Enter A matrix elements: " << endl;
for(int row_index = 0; row_index < MATRIX_ROWS; row_index++)
{
for(int col_index = 0; col_index < MATRIX_COLS; col_index++)
{
cout << "Element at(" << row_index << ", " << col_index
<< "): ";
cin >> a_mat[row_index][col_index];
}
}
cout << "Enter B matrix elements: " << endl;

{
{
cout << "Element at(" << row_index << ", " << col_index
<< "): ";
cin >> b_mat[row_index][col_index];
{
{
// sum both of matrices and put the sum into sum_mat matrix
sum_mat[row_index][col_index] = a_mat[row_index][col_index]
+ b_mat[row_index][col_index];
}
}
// sum stage
// print sum matrix
cout << "Sum matrix elements: " << endl;
{
{
cout << sum_mat[row_index][col_index] << '\t';
}
cout << endl;
}
return 0;
}
‫ﻣﺜﺎل‪ :‬ﺿﺮب ﻣﺼﻔﻮﻓﺘﯿﻦ‬
‫أﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺘﺸﻔﯿﺮ وﻟﻔﻚ ﺗﺸﻔﯿﺮ ﻧﺺ ﻳﺪﺧﻠﻪ اﻟﻤﺴﺘﺨﺪم ﺑﻄﺮﻳﻘﺔ زﻳﺎدة اﻟﺤﺮف‬
‫ﺑﻘﯿﻤﺔ ﻣﻌﯿﻨﺔ ھﻲ اﻟﻤﻔﺘﺎح اﻟﺬي ﻳﺪﺧﻠﻪ اﻟﻤﺴﺘﺨﺪم‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺈدﺧﺎل اﻟﻤﺴﺘﺨﺪم ﺟﻤﻠﺔ ﻧﺼﯿﺔ وﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﻌﺪ اﻻﺣﺮف و ﻋﺪد ﻣﺮات‬
‫اﻟﺤﺮف ‪a ,A‬‬
‫ﺟﺪوﻟﺔ اﻟﺬاﻛﺮة ﻓﻲ اﻟﻜﻤﺒﯿﻮﺗﺮ‬
‫اﻟﺬاﻛﺮة ھﻲ ﻋﺒﺎرة ﻋﻦ ﻣﺼﻔﻮﻓﺔ طﻮﻳﻠﺔ ﻣﻦ ال‪ bytes‬و ﻳﺘﻢ اﻟﻮﺻﻮل ﻟﻌﻨﺎﺻﺮھﺎ ﺑﺎﻟﻌﻨﺎوﻳﻦ‪ ،‬و‬ ‫●‬
‫ھﺬه اﻟﻌﻨﺎوﻳﻦ ﺗﻌﺒﺮ ﻋﻦ ﻣﻜﺎن ﺗﻮﺿﻊ اﻟﻌﻨﺼﺮ اﻟﻤﺮاد طﻠﺒﻪ‬

‫اﻟﻤﺆﺷﺮات ‪pointers‬‬
‫اﻟﻤﺆﺷﺮات)‪ (pointers‬ھﻲ ﻣﺘﻐﯿﺮات ﺗﺤﺘﻮي ﻋﻠﻰ ﻋﻨﻮان ﻓﻲ اﻟﺬاﻛﺮة ﺗﻮﺷﺮ ﻋﻠﯿﻪ‪.‬‬ ‫●‬
‫ﻳﻤﻜﻦ ﺗﻌﺮﻳﻒ ‪ pointer‬ﺑﻠﻐﺔ ‪ C/C++‬ﻛﺘﻌﺮﻳﻒ اﻟﻤﺘﺤﻮل اﻹﻋﺘﯿﺎدي ﻟﻜﻦ ﺑﺈﺿﺎﻓﺔ رﻣﺰ * ﻗﺒﻞ‬ ‫●‬
‫أﺳﻢ اﻟﻤﺘﺤﻮل ﻣﺜﺎل‪:‬‬
‫‪‬‬ ‫;‪int num = 5‬‬

‫‪‬‬ ‫;‪int *ptr = &num‬‬
‫و ھﺬه اﻟﻌﺒﺎرة ﺗﻌﻨﻲ أن اﻟﻤﺆﺷﺮ ‪ptr‬ﯾؤﺷر إﻟﻰ ﻋﻧوان اﻟذاﻛرة ﻟﻠﻣﺗﻐﯾر ‪num‬‬ ‫‪‬‬
‫‪17‬‬
‫اﻟﻌﻤﻠﯿﺔ )ﻋﻨﻮان ال( &‬
‫ﻳﻤﻜﻦ ﻣﻌﺮﻓﺔ ﻋﻨﻮان ﻣﺘﻐﯿﺮ ﻣﺎ ﻓﻲ اﻟﺬاﻛﺮة ﻋﻦ طﺮﻳﻖ اﻟﻌﻤﻠﯿﺔ )&(‪ address of‬ﻛﻤﺎ ﻓﻲ‬ ‫●‬
‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫‪‬‬ ‫;‪int var‬‬
‫‪‬‬ ‫تﻗﻮم ﺑﻄﺒﻊ ﻋﻨﻮان اﻟﻤﺘﻐﯿﺮ ‪ var‬ﻓﻲ اﻟﺬاﻛﺮة ‪cout << &var; //‬‬
‫ﻓﺒﺘﻠﻚ اﻟﻌﻤﻠﯿﺔ ﻧﻘﻮم ﺑﺈﺳﻨﺎد ﻗﯿﻤﺔ ﻟﻠﻤﺆﺷﺮ ﻋﻠﻰ ﺳﺒﯿﻞ اﻟﻤﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫;‪char ch‬‬

‫‪‬‬ ‫;‪char *ptr1 = &ch‬‬ ‫ﺗﻘﻮم ﺑﺘﮭﯿﺌﺔ اﻟﻤﺆﺷﺮ ‪ ptr1‬ﺑﻤﻜﺎن اﻟﻤﺘﺤﻮل ‪//ch‬‬
‫إذا أردﻧﺎ أن ﻧﻄﺒﻊ ﻗﯿﻤﺔ ﻣﺆﺷﺮ ﻋﻠﻰ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻧﻜﺘﺐ‪:‬‬ ‫●‬
‫‪‬‬ ‫ﺗﻘﻮم ﺑﻄﺒﻊ اﻟﻤﻜﺎن اﻟﺬاﻛﺮي اﻟﻤﺆﺷﺮ إﻟﯿﻪ ‪cout << ptr; //‬‬
‫‪18‬‬
‫اﻟﻌﻤﻠﯿﺔ ﻗﯿﻤﺔ ال)*(‬
‫ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﻟﻰ اﻟﺒﯿﺎﻧﺎت اﻟﻤﺆﺷﺮ إﻟﯿﮭﺎ ﺑﻤﺆﺷﺮ ﻣﺎ ﻋﺒﺮ اﻟﻌﻤﻠﯿﺔ )*(‪ value of‬ﻗﺒﻞ إﺳﻢ‬ ‫●‬
‫اﻟﻤﺆﺷﺮ ﻣﺜﺎل‪:‬‬
‫‪‬‬ ‫;‪int z_val = 56‬‬
‫‪‬‬ ‫;‪int *ptr_to_z = &z_val‬‬
‫‪‬‬ ‫ﺗﻘﻮم ﺑﻄﺒﻊ ﻗﯿﻤﺔ اﻟﻤﺘﺤﻮل ‪56 z_val‬اﻟﺘﻲ ھﻲ ‪cout << *ptr_to_z; //‬‬
‫وﻳﻤﻜﻨﻨﺎ إﺳﻨﺎد ﻗﯿﻤﺔ ﻟﻠﻌﻨﻮان اﻟﺬاﻛﺮي اﻟﻤﺆﺷﺮ إﻟﯿﻪ ﻋﻠﻰ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﺑﺎﻟﻄﺮﻳﻘﺔ اﻟﺘﺎﻟﯿﺔ‪:‬‬ ‫●‬
‫‪‬‬ ‫ﻟﻠﻣﺗﺣول ‪20‬ﺗﻘﻮم ﺑﺈﺳﻨﺎد اﻟﻘﯿﻤﺔ ‪*ptr_to_z = 20; //z_value‬‬

‫‪‬‬ ‫‪20‬ﺗﻘﻮم ﺑﻄﺒﻊ اﻟﻌﺪد ‪cout << *ptr_to_z; //‬‬
‫ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﻌﻤﺎل اﻟﻤﺆﺷﺮات‬
#include <iostream>
int main ()
{
int var = 20; // actual variable declaration.
int *ip; // pointer variable
ip = &var; // store address of var in pointer
variable
cout << "Value of var variable: ";

cout << var << endl;
// print the address stored in ip pointer variable

cout << "Address stored in ip variable: ";
cout << ip << endl;
// access the value at the address available in

pointer
cout << "Value of *ip variable: ";
cout << *ip << endl;
return 0;
}
‫اﻟﺘﺤﻮﻳﻼت ﻓﻲ اﻟﻤﺆﺷﺮات‬
‫‪Casting in pointers‬‬
‫إن اﻟﺘﺤﻮﻳﻞ ﻣﻦ ﻧﻮع ﻣﺆﺷﺮ إﻟﻰ ﻧﻮع ﻣﺆﺷﺮ أﺧﺮ ﻛﺎﻟﺘﺤﻮﻳﻞ ﻣﻦ ‪ * int‬إﻟﻰ ‪* char‬ﻣﻣﻛن ﻟﻛن ﻣﻌﻧﺎه‬ ‫●‬
‫أن اﻟﻌﻨﺼﺮ اﻟﻤﺆﺷﺮ إﻟﯿﻪ ﺳﻮف ﻳﺘﻢ ﻗﺮاءة أول ‪ byte‬ﻣﻨﻪ ﻓﻘﻂ‬
‫ﻣﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫;‪int some_value = 1900‬‬

‫‪‬‬ ‫;‪unsigned char *ptr = (char *)&some_value‬‬
‫‪‬‬ ‫‪1‬ﺗﻄﺒﻊ ‪cout << (int)*ptr; //‬‬
‫ﻓﮭﻢ اﻟﻤﺼﻔﻮﻓﺎت ﺑﺸﻜﻞ أﻋﻤﻖ‬
‫اﻟﻌﺒﺎرة‪:‬‬ ‫●‬
‫‪‬‬ ‫;}‪int arr[5] = {1 ,9 ,10, 7, 3‬‬

‫‪ ‬ﺗﻘﻮم ﺑﺤﺠﺰ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ ٥‬ﻋﻨﺎﺻﺮ ﻓﻲ ﺑﺪاﻳﺔ ﺗﺸﻐﯿﻞ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬و ﻳﻜﻮن ‪ arr‬ھﻮ ﻋﺒﺎرة ﻋﻦ‬
‫ﻣﺆﺷﺮ إﻟﻰ ﺑﺪاﻳﺔ اﻟﻤﺼﻔﻮﻓﺔ أي إن ‪arr‬ﺗﺳﺎوي ‪[0]arr& :‬‬
‫‪23‬‬
‫ﻓﮭﻢ اﻟﻤﺼﻔﻮﻓﺎت ﺑﺸﻜﻞ أﻋﻤﻖ ‪۲‬‬
‫اﻷﻣﺮ اﻟﺘﺎﻟﻲ ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻋﻨﻮان أول ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‬ ‫●‬
‫‪‬‬ ‫;‪cout << arr‬‬

‫‪ ‬ﺷﺮﻳﻄﺔ أن ﺗﻜﻮن ال ‪ arr‬ﻟﯾﺳت ﻣن اﻟﻧوع ‪* char‬ﻷن ال ‪cout‬‬
‫‪ ‬ﺳﺘﻌﺘﺒﺮھﺎ ﻧﺼﺎً ‪ String‬أﻧذاك‬
‫اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ ﻋﻠﻰ اﻟﻤﺆﺷﺮات‬
‫ﻳﻤﻜﻦ ﺗﻄﺒﯿﻖ اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ ﻋﻠﻰ اﻟﻤﺆﺷﺮات ﻛﻤﺎ ﻳﺘﻢ = )‪1‬ﺗﻄﺒﯿﻖ اﻟﻌﻤﻠﯿﺎت ذاﺗﮭﺎ‬ ‫●‬
‫ﻋﻠﻰ اﻟﻤﺘﻐﯿﺮات وﻟﻜﻦ ھﻨﺎ ﻳﺘﻢ اﻟﺘﻌﺪﻳﻞ ﻋﻠﻰ اﻟﻌﻨﻮان اﻟﻤﺆﺷﺮ إﻟﯿﻪ‪.‬‬
‫ﻣﺜﺎل‪:‬‬ ‫●‬
‫‪‬‬ ‫;]‪int *ptr = new int[3‬‬

‫‪‬‬ ‫;‪*ptr + = 20‬‬
‫‪ ‬ﺗﻌﻨﻲ رﻳﺎﺿﯿﺎً و ﻟﯿﺲ ﺑﺮﻣﺠﯿﺎً أن‪:‬‬
‫‪‬‬ ‫;‪*(ptr + 1 * sizeof(int)) = 20‬‬
‫‪ ‬وﺗﻌﻨﻲ ﺑﺮﻣﺠﯿﺎ‪ :‬اﺳﻨﺎد اﻟﺮﻗﻢ ‪ ۲۰‬إﻟﻰ اﻟﻌﻨﺼﺮ اﻟﺜﺎﻧﻲ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬
‫‪25‬‬
‫ﺑﻌﺾ اﻷﻣﻮر ﻓﻲ اﻟﻤﺆﺷﺮات‬
‫ﺑﺈﻣﻜﺎﻧﻨﺎ إﺳﺘﻌﻤﺎل اﻟﻤﺆﺷﺮات ﻟﻠﻮﺻﻮل إﻟﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺎت‪:‬‬ ‫●‬
‫ﻓﺈن اﻟﻌﺒﺎرة‪:‬‬ ‫‪‬‬

‫‪‬‬ ‫;)‪cin >> *(ptr + 3‬‬
‫ﺗﻜﺎﻓﺊ اﻟﻌﺒﺎرة‪:‬‬ ‫‪‬‬

‫‪‬‬ ‫;]‪cin >> ptr[3‬‬
‫‪‬‬
‫‪26‬‬

برمجة 1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

برمجة 1

Uploaded by

Copyright:

Available Formats

‫ﺑﺮﻣﺠﺔ ‪۱‬‬

‫اﻟﻤﺤﺎﺿﺮة اﻷوﻟﻰ )ﻧﻈﺮي(‬

‫ﻓﻲ ﻟﻐﺔ ‪ C‬ﻳﻮﺟﺪ ‪ ٥‬أﻧﻮاع رﺋﯿﺴﯿﺔ ﻟﻠﺒﯿﺎﻧﺎت‪:‬‬ ‫●‬

‫–ﺣﺮف )‪char : (character‬‬

‫‪‬‬ ‫)إﻓﺗراﺿﻲ( ﻟﺘﻌﺮﻳﻒ اﻷﻋﺪاد ذات اﻹﺷﺎرة ‪signed‬‬

‫‪‬‬ ‫;‪unsigned int num1‬‬

‫‪‬‬ ‫;‪unsigned char num2‬‬

‫‪‬‬ ‫‪float pi = 3.14‬‬

‫‪‬‬ ‫; ‪long int x‬‬ ‫أو‬

‫ﻣﻦ اﻟﻤﻌﺮوف ان اﻟﺤﺮوف ﻓﻲ اﻟﺤﺎﺳﺐ و اﻷﺟﮭﺰة اﻟﺮﻗﻤﯿﺔ ﺗﺤﺰن ﻓﻲ‬ ‫‪‬‬

‫ﻣﺜﺎل ‪:‬‬ ‫‪‬‬

‫‪/* … */‬ﻟﻠﺗﻌﻠﯾﻘﺎت اﻟﻣﺗﻌددة اﻷﺳطر‬ ‫●‬

‫‪//‬ﻟﻠﺗﻌﻠﯾﻖ ﻋﻠﻰ اﻟﺳطر اﻟﺣﺎﻟﻲ‬ ‫●‬

‫‪// This program will add two numbers‬‬

‫‪the two numbers x + y */‬‬

‫‪ ‬اﻻﺳﻄﺮ اﻟﺴﺎﻳﻘﺔ ﻻ ﻳﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﺘﺮﺟﻤﺘﮭﺎ ‪.‬‬

‫ﻹﺧﺮاج أي ﻧﺺ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﻌﺮض ﻧﺴﺘﻌﻤﻞ ﺗﻌﻠﯿﻤﺔ ‪ cout‬وﻧﺘﺒﻌﮭﺎ ﺑـ <<‪.‬‬ ‫‪‬‬

‫ﺛﻢ ﻧﻜﺘﺐ اﻟﻨﺺ اﻟﻤﺮاد إظﮭﺎره وﻳﻜﻮن ﺑﯿﻦ ”“‪.‬‬ ‫‪‬‬

‫‪‬‬ ‫;”‪cout << “Text‬‬ ‫ﻟﻄﺒﺎﻋﺔ ﻧﺺ ‪//‬‬

.‫ ﺗﺴﺘﺨﺪم ﻟﻠﻨﺰول إﻟﻰ ﺳﻄﺮ ﺟﺪﻳﺪ ﻋﻨﺪ اﻹﺧﺮاج‬

‫ﻹدﺧﺎل أي ﻗﯿﻤﺔ ﻟﻤﺘﺤﻮل ﻧﺴﺘﻌﻤﻞ ﺗﻌﻠﯿﻤﺔ ‪ cin‬وﻧﺘﺒﻌﮭﺎ ﺑـ >> ‪.‬‬ ‫‪‬‬

‫ﺛﻢ ﻧﻜﺘﺐ اﺳﻢ اﻟﻤﺘﺤﻮل اﻟﻤﺮاد ادﺧﺎل ﻗﯿﻤﺘﻪ‪.‬‬ ‫‪‬‬

‫ﻛﻤﺎ ﻳﻤﻜﻦ ادﺧﺎل ﻋﺪة ﻗﯿﻢ ﻓﻲ ﻧﻔﺲ اﻟﺘﻌﻠﯿﻤﺔ‪.‬‬ ‫‪‬‬

(Assignment operator " = ")‫ﻋﻤﻠﯿﺔ اﻹﺳﻨﺎد‬ ●

● int x = 35, y = 10, z;

‫ﻋﻤﻠﯿﺔ زﻳﺎدة ﻗﯿﻤﺔ ﻣﺘﺤﻮل ﺑﻮاﺣﺪ وﻟﮭﺎ ﺷﻜﻠﯿﻦ‪:‬‬ ‫‪‬‬

‫●‬ ‫ﺗﻘﻮم ﺑﺎﻟﺰﻳﺎدة ﺑﻮاﺣﺪ ﻋﻠﻰ اﻟﻤﺘﺤﻮل ﺛﻢ إرﺟﺎﻋﻪ‪++n; //‬‬

‫●‬ ‫ﺑﺘﻘﻮم ﺑﺘﻨﻘﯿﺺ ﺑﻮاﺣﺪ ﻣن اﻟﻣﺗﺣول ﺛم إرﺟﺎﻋﮫ ‪--n; //‬‬

‫‪‬‬ ‫;‪y_var = y_var – 9‬‬

‫‪‬‬ ‫;‪num = num * 30‬‬

‫‪‬‬ ‫;‪variable = variable / 68‬‬

‫‪‬‬ ‫;‪rest = rest % 50‬‬

double answer; // answer storage

cout << "Enter the x value: "; // ask for input

cin >> x_value; // get the input

// compute the answer

answer = (x_value * (1 - x_value)) / (1 - 7 * x_value);

// print the answer

cout << "The answer is " << answer;

return 0; // exit the program

‫ﻣﻦ )‪ (۹ ~ ۰‬ﺣﯿﺚ ﻳﻀﺮب ﻛﻞ ﺧﺎﻧﺔ ﻣﻨﻪ ﺑﻌﺸﺮة ﻣﺮﻓﻮﻋﺔ إﻟﻰ ﻗﻮة‬

‫ھﻮ اﻟﻨﻈﺎم اﻟﺮﻗﻤﻲ اﻟﺬي ﻳﺴﺘﺨﺪم اﻟﻜﻤﺒﯿﻮﺗﺮ ﻓﻲ ﻣﻌﺎﻟﺠﺔ و ﺗﺨﺰﻳﻦ‬ ‫●‬

‫ﺗﻜﻮن ‪ ۱‬أو ‪.۰‬‬

‫و ﻳﻄﻠﻖ ﻋﻠﻰ اﻟﺨﺎﻧﺔ ﻣﻨﻪ أﺳﻢ اﻟﺒﺖ ‪bit‬‬ ‫●‬

‫‪ ‬ﺗﺤﻮﻳﻞ ﻣﻦ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ إﻟﻰ اﻟﻨﻈﺎم اﻟﻌﺸﺮي‬

‫ﻧﺴﺘﺨﺪم اﻟﻘﺴﻤﺔ ﻋﻠﻰ أﺳﺎس ‪ ۲‬ﺑﺎﻟﺘﻮاﻟﻲ‪.‬‬ ‫●‬

‫ﻣﺜﺎل‪:‬ﺣﻮل اﻟﻌﺪد اﻟﻌﺸﺮي ‪ ۸۷‬إﻟﻰ ﻋﺪد ﺛﻨﺎﺋﻲ‪:‬‬ ‫●‬

‫ﻳﺴﺘﺨﺪم ﻓﻲ إﺧﺘﺼﺎر اﻷرﻗﺎم اﻟﺜﻨﺎﺋﯿﺔ و ﻓﻲ ﻣﺤﺮرات اﻟﻤﻠﻔﺎت اﻟﻤﺘﻘﺪﻣﺔ ﻣﺜﺎل ‪WinHex‬‬

‫اﻟﺒﻮاﺑﺔ ‪NOT‬‬ ‫●‬

‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ ال ‪~ :C‬‬ ‫●‬

‫اﻟﺒﻮاﺑﺔ ‪OR‬‬ ‫‪‬‬

‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ ال ‪ | : C‬ﻟﻠﻌﻤﻠﯿﺎت ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﺒﺖ‬ ‫‪‬‬

‫اﻟﺒﻮاﺑﺔ ‪AND‬‬ ‫‪‬‬

‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ ال ‪ & : C‬ﻟﻠﻌﻤﻠﯿﺎت ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﺒﺖ‬ ‫‪‬‬

‫اﻟﺒﻮاﺑﺔ ‪XOR‬‬ ‫‪‬‬

‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ ال ‪^ : C‬‬ ‫‪‬‬

true ‫ وﻏﯾر ذﻟك ﯾﻘﺎﺑل‬false ‫ ﺗﻘﺎﺑﻞ‬۰ ‫ اﻟﻘﯿﻤﺔ‬،‫ﻓﻲ ﻟﻐﺔ اﻟﺴﻲ‬ 

 int x_value = -50;

‫‪‬‬ ‫‪0‬اﻟﺨﺮج ‪cout << (3 == 4); //‬‬

‫ﻋﻤﻠﯿﺔ اﻟﺘﺤﻘﻖ ﻣﻦ ﻋﺪم اﻟﻤﺴﺎواة “ =! “ ‪:‬‬ ‫‪‬‬

‫‪‬‬ ‫;‪int x_val = 20‬‬

“ < “ , “ > “: ‫ﻋﻤﻠﯿﺘﻲ اﻟﺘﺤﻘﻖ أﻛﺒﺮ أو أﺻﻐﺮ‬ 

 int value_temp = 50;

‫‪‬‬ ‫;‪int num_one = 50‬‬

‫‪‬‬ ‫)‪ /‬اﻟﺸﺮط … ‪if( /‬‬