المرجع الشامل فى ال ++VC

‫ﻃﺮﻳﻖ اﻟﺒﺮﻣﺠﺔ‬
‫ﻓﻲ‬
‫هﺎﻧﻲ اﻷﺗﺎﺳﻲ – اﻟﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ‬

‫ﺁﺧﺮ ﺗﻌﺪﻳﻞ ﻓﻲ ‪11/20/2001‬‬
‫اﻟﺪرس اﻷول – أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﺔ‬ ‫ﻃﺮﻳﻖ اﻟﺒﺮﻣﺠﺔ ﻓﻲ ﺳﻲ‪++‬‬
‫اﻵن ﻣﻦ أﺟﻞ آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ اﻷول ﻳﺠﺐ ﻋﻠﻴﻨﺎ ﻣﻦ اﻧﺸﺎء ﻣﻠﻒ آﻮد ﺟﺪﻳﺪ وهﺬا ﻣﻦ اﻷﻣﺮ ‪ New‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ ‪ . File‬ﺳـﻮف‬
‫ﺗﺤﺼﻞ ﻋﻠﻰ ﻧﻔﺲ اﻟﻨﺎﻓﺬة ﻓﻲ اﻟﺸﻜﻞ ‪ 1-1‬وﻟﻜﻦ هﻨﺎ اﻟﺼﻔﺤﺔ ‪ Files‬هﻲ اﻟﻈﺎهﺮة ﻋﻮﺿﺎ ﻋﻦ ‪ . Projects‬ﻃﺒﻌـﺎ ﻳﻤﻜﻨـﻚ أن‬
‫ﺗﺨﻤﻦ ﻣﺎهﻮ اﻟﺬي ﺳﻮف ﻧﺨﺘﺎرﻩ ‪ .‬ﻃﺒﻌﺎ هﻮ ‪ . C++ Source File‬ﺑﻌﺪ أن ﺗﺨﺘـﺎرﻩ اآﺘـﺐ اﺳـﻢ اﻟﻤﻠـﻒ وﻟـﻴﻜﻦ ‪ test‬وﻣـﻦ ﺛـﻢ‬
‫اﺿﻐﻂ ﻣﻮاﻓﻖ ‪.‬‬
‫ﺳﻮف ﺗﺠﺪ أﻧﻪ ﺗـﻢ اﺿـﺎﻓﺔ اﻟﻤﻠـﻒ ‪ test.cpp‬إﻟـﻰ اﻟـﺪﻟﻴﻞ اﻟـﻮهﻤﻲ ‪ Source Files‬وذﻟـﻚ ﺑﺴـﺒﺐ أن هـﺬا اﻟﻤﻠـﻒ ﺳـﻮف‬
‫ﻳﺤﺘﻮي ﻋﻠﻰ آﻮد ﻟﻠﻤﺸﺮوع ‪ .‬اﻵن ﻗﻢ ﺑﻜﺘﺎﺑﺔ اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﻓﻲ اﻟﻤﻠﻒ اﻟﻔﺎرغ اﻟﺬي أﻧﺸﺌﺘﻪ ‪.‬‬
‫>‪#include <iostream.h‬‬
‫)(‪int main‬‬
‫{‬
‫;"‪cout << "My first program.‬‬
‫;)‪return (0‬‬
‫}‬
‫‪PROGRAM 1‬‬
‫ﻳﺠﺐ أن ﺗﻨﺘﺒﻪ أن ﻟﻐﺔ اﻟﺴﻲ‪ ++‬ﺗﻔﺮق ﺑﻴﻦ اﻷﺣﺮف اﻟﻜﺒﻴﺮة واﻷﺣﺮف اﻟﺼﻐﻴﺮة ‪ .‬ﻋﻠـﻰ ﺳـﺒﻴﻞ اﻟﻤﺜـﺎل ﻓـﺈن اﺳـﻢ اﻟﺘـﺎﺑﻊ‬
‫‪ main‬ﻳﺠﺐ أن ﻳﻜﺘﺐ آﻤﺎ هﻮ وﻻ ﻳﻤﻜﻦ آﺘﺎﺑﺘﻪ ك ‪ Main‬أو ‪ MAIN‬وهﻲ آﻠﻬﺎ ﺗﻌﺘﺒﺮ آﺄﺳﻤﺎء ﻣﺨﺘﻠﻔﺔ ﻋﻦ اﻟﺘﺎﺑﻊ ‪. main‬‬
‫‪ 1.2‬ﺗﺮﺟﻤﺔ وﺑﻨﺎء اﻟﻤﺸﺮوع‬

‫ﻣﻦ أﺟﻞ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ وﺑﻨﺎء ﻣﻠﻒ ﺗﻨﻔﻴﺬي ‪ exe‬ﻗﺎﺑـﻞ ﻟﻠﺘﻨﻔﻴـﺬ ﻓـﻲ أي وﻗـﺖ ﻳﺤـﺐ أوﻻ ﺗﺮﺟﻤﺘـﻪ وﺗﺤﻮﻳﻠـﻪ ﻣـﻦ‬
‫اﻟﻠﻐﺔ اﻟﻤﻘﺮوﺋﺔ إﻟﻰ ﻟﻐﺔ اﻵﻟﺔ اﻟﺘﻲ آﻠﻬﺎ أﺻﻔﺎر وواﺣﺪات وﺑﻌﺪهﺎ ﻳﻤﻜﻦ ﺗﻨﻔﻴﺬﻩ ‪.‬‬
‫ﻋﻤﻠﻴﺔ ﺗﺮﺟﻤﺔ اﻟﻤﺸﺮوع وﺑﻨﺎء اﻟﻤﻠﻒ اﻟﺘﻨﻔﻴﺬي ﻓﻲ اﻟﻔﻴﺠﻮال ﺳﻲ‪ ++‬ﺗﺘﻢ ﺑﺨﻄﻮة واﺣﺪة وهﻲ ﻋﻦ ﻃﺮﻳﻖ اﺧﺘﻴﺎر اﻷﻣـﺮ‬
‫‪ Build FirstProg.exe‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ ‪ Build‬أو اﻟﻀﻐﻂ ﻋﻠﻰ ‪ . F7‬وﻣﻦ أﺟﻞ ﺗﻨﻔﻴـﺬ اﻟﻤﺸـﺮوع أو اﻟﻤﻠـﻒ اﻟﺘﻨﻔﻴـﺬي اﺧﺘـﺮ اﻷﻣـﺮ‬
‫‪ Execute FirstProg.exe‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ ‪ Build‬أو ﻋﻦ ﻃﺮﻳﻖ اﻟﻤﻔﺘـﺎﺣﻴﻦ ‪ . Ctrl+F5‬ﻃﺒﻌـﺎ ﻳﻤﻜﻨـﻚ أوﻻ ﺑﻨـﺎء اﻟﻤﻠـﻒ اﻟﺘﻨﻔﻴـﺬي‬
‫وﻣﻦ ﺑﻌﺪهﺎ ﺗﻨﻔﻴﺬﻩ ﺑﺨﻄﻮﺗﻴﻦ وﻟﻜﻦ اﻷﻣﺮ ‪ Execute‬ﻳﻘﻮم ﺑﺸﻜﻞ ﺁﻟﻲ ﺑﻌﻤﻠﻴﺔ اﻟﺘﺮﺟﻤﺔ وﺑﻨﺎء اﻟﻤﻠﻒ اﻟﺘﻨﻔﻴـﺬي إذا دﻋـﺎ اﻷﻣـﺮ‬
‫إﻟﻰ ذﻟﻚ ‪.‬‬
‫إذا آﺎن آﻞ ﺷﺊ ﻋﻠﻰ ﻣﺎﻳﺮام ﺳﻮف ﺗﺮى ﻧﺎﻓﺬة ﻣﻤﺎﺛﻠﺔ ﻟﻨﺎﻓﺬة اﻟﺪوس أو ال ‪ Command Line‬وﺳﻮف ﺗﺮى اﻟﻌﺒـﺎرة ‪My‬‬
‫‪ first program‬ﻓﻲ أﻋﻠﻰ اﻟﺸﺎﺷﺔ آﻤﺎ ﻓﻲ اﻟﺸﻜﻞ ‪. 4-1‬‬
‫ﺷﻜﻞ ‪5- 1‬‬
‫‪8‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 1.3‬اﻷهﻢ ﻣﻦ ﺗﻌﻠﻢ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ‬

‫هﻞ ﺳﺌﻠﻨﺎ أﻧﻔﺴﻨﺎ ﻓﻲ ﻟﺤﻈﺔ ﻣﻦ اﻟﻠﺤﻈﺎت ﻣﺎهﻢ اﻷهﻢ ﻣﻦ ﺗﻌﻠﻢ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ﻣﻦ أﺟﻞ أن ﻧﺼﺒﺢ ﻣﺒﺮﻣﺠﻴﻦ ؟ ﺑﺼـﺮاﺣﺔ‬
‫اﻹﺟﺎﺑﺔ ﻋﻠﻰ هﺬا اﻟﺴﺆال ﺿﺨﻤﺔ ﺟﺪا وﻳﻮﺟﺪ آﺘﺐ آﺎﻣﻠﺔ ﻋﻦ هﺬا اﻟﻤﻮﺿﻮع أو ﻋﻦ ﻣﻮﺿﻮع هﻨﺪﺳـﺔ اﻟﺒﺮﻣﺠﻴـﺎت ‪ .‬اﻹﺟﺎﺑـﺔ‬
‫هﻲ آﻠﻤﺘﻴﻦ ﻃﺒﻌﺎ وهﻲ هﻨﺪﺳﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪ ،‬ﺗﻤﺎﻣﺎ آﻤﺎ ﻳﻔﻌﻞ إﺧﻮاﻧﻨﺎ ﻓﻲ اﻟﻬﻨﺪﺳﺔ اﻟﻤﺪﻧﻴﺔ أم اﻟﻤﻌﻤﺎرﻳﺔ ‪ .‬ﺗﺨﻴﻞ ﺑﺮﻧﺎﻣﺠـﻚ‬
‫هﻮ ﻋﺒﺎرة ﻋﻦ ﻋﻤﺎرة أو ﺑﻨﺎء ﺗﺮﻳﺪ ﺗﺸﻴﻴﺪﻩ ‪ ،‬ﺳﻮف ﺗﺒﺪأ ﺑﺎﻟﺘﺼﻤﻴﻢ وﺗﺤﻠﻴﻞ ﻣﻮاردك واﻣﻜﺎﻧﻴﺎﺗﻚ وﻣﻦ ﺛـﻢ وﺿـﻊ )ﺳـﻜﻴﺘﺶ( أو‬
‫ﺗﺼﻤﻴﻢ أوﻟﻲ ﻟﻠﺒﻨﺎء وﺑﻌﺪ ذﻟﻚ ﺗﺒﺪأ ﺑﺎﻟﺒﻨﺎء ﺑﻠﻮك ﺑﻠﻮك وﻃﺎﺑﻖ ﻃﺎﺑﻖ ‪.‬‬
‫ﻟﻦ أﺗﻄﺮق ﻓﻲ هﺬﻩ اﻟﺪروس إﻟﻰ ﻣﻮاﺿﻴﻊ اﻟﺘﺼﻤﻴﻢ وﺗﺤﻠﻴﻞ اﻟﻤﻮارد ﻷﻧﻬﺎ ﻗﺪ ﺗﻜﻮن ﺧﺎرﺟﺔ ﻋﻦ اﻃﺎر هﺬﻩ اﻟـﺪروس وﻟﻜـﻦ‬
‫آﺪروس ﻟﺘﻌﻠﻴﻢ ﻟﻐﺔ اﻟﺴﻲ‪ ++‬ﻳﺠﺐ أن أﻧﻮﻩ إﻟﻰ ﻣﻮاﺿﻴﻊ ﺗﻨﻈﻴﻢ اﻟﺒﺮﻧﺎﻣﺞ واﻟﺘﻲ هﻲ ﺟﺰء ﻻ ﻳﺘﺠﺰء ﻣﻦ هﻨﺪﺳﺔ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﺳﻮف أﺗﻄﺮق اﻵن إﻟﻰ أهﻢ اﻷﻣﻮر وأﺳﻬﻠﻬﺎ وهﻲ اﺿﺎﻓﺔ اﻟﺘﻌﻠﻴﻘﺎت ﻓﻲ ﺑﺮﻧﺎﻣﺠﻚ ‪ .‬اﻟﺘﻌﻠﻴﻘـﺎت هـﻲ ﺟـﺰء ﻣـﻦ اﻟﺒﺮﻧـﺎﻣﺞ‬
‫اﻟﺬي ﻳﻬﻤﻞ أﺛﻨﺎء ﻋﻤﻠﻴﺔ ﺗﺮﺟﻤﺔ اﻟﺒﺮﻧﺎﻣﺞ وهﻲ ﺗﻔﻴﺪ ﻓﻲ ﺗﻔﺴـﻴﺮ اﻟﺨﻄـﻮات اﻟﺘـﻲ ﺗﻘـﻮم ﺑﻬـﺎ ‪ .‬ﺳـﻮف أﻃﻠـﺐ ﻣﻨـﻚ ﻣﻘﺎرﻧـﺔ‬
‫اﻟﺒﺮﻧﺎﻣﺠﻴﻦ اﻟﺘﺎﻟﻴﻦ وﻣﻼﺣﻈﺔ أﻳﻬﻤﺎ أﺳﻬﻞ ﻟﻠﻔﻬﻢ ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻦ ﻟﻐﺔ اﻟﺴﻲ‪ ++‬اﻟﻤﺴﺘﺨﺪﻣﺔ اﻟﺘﻲ ﻗﺪ ﻻ ﺗﻜـﻮن ﻣﻠـﻢ ﺑﻬـﺎ‬
‫ﻓﻲ هﺬﻩ اﻟﻠﺤﻈﺔ ‪.‬‬
‫)‪PROGRAM 1.2 (a‬‬
‫{‬
‫;‪int sum‬‬
‫;‪sum = 10 + 20‬‬
‫;‪cout << sum << endl‬‬
‫;)‪return (0‬‬
‫}‬
‫)‪PROGRAM 1.2 (b‬‬
‫*‪/‬‬
‫**‬ ‫‪This program calculates the sum of 10 and 20 and prints it on screen‬‬
‫**‬ ‫‪Programmed by : Anonymous‬‬
‫**‬ ‫‪Date : 1/1/3000‬‬
‫‪*/‬‬
‫{‬
‫;‪int sum‬‬ ‫‪// This will hold the sum of the numbers‬‬
‫;‪sum = 10 + 20‬‬ ‫‪// Store 10 + 20 in sum‬‬

‫;‪cout << sum << endl‬‬ ‫‪// Print the sum value‬‬
‫;)‪return (0‬‬ ‫‪// End the program‬‬

‫}‬
‫ﻃﺒﻌﺎ ﺳﻮف ﺗﻘﻮل أن اﻟﺒﺮﻧﺎﻣﺞ اﻟﺜﺎﻧﻲ أﺳﻬﻞ ﻟﻠﻘﺮاﺋﺔ واﻟﻔﻬﻢ ﻣﻦ اﻷول ﻟﻌﺪة أﺳﺒﺎب ‪.‬‬
‫• اﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻘﺎت أﻳﻨﻤﺎ دﻋﺖ اﻟﺤﺎﺟﺔ ﻟﻬﺎ ‪.‬‬
‫• وﺿﻊ أﺳﻄﺮ ﻓﺎرﻏﺔ ﺑﻴﻦ ﻗﺴﻢ وﺁﺧﺮ ﻓﻲ اﻟﻜﻮد ‪ ،‬اﻷﻗﺴﺎم ﺗﻜﻮن ﻣﺘﺮاﺑﻄﺔ ﻣﻨﻄﻘﻴﺎ ﻓﻴﻤﺎ ﺑﻴﻨﻬﺎ ‪.‬‬
‫• ﺗﺮك ﻣﺴﺎﻓﺎت ﺑﺎدﺋﺔ ﻣﻦ أﺟﻞ ﺳﻬﻮﻟﺔ اﻟﻘﺮاﺋﺔ وﺗﺘﺒﻊ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫ﺑﺎﻟﻨﺴﺒﺔ إﻟﻰ اﻟﺘﻌﻠﻴﻘﺎت ﻓﻴﻤﻜﻦ آﺘﺎﺑﺘﻬﺎ ﺑﺸﻜﻠﻴﻦ آﻤﺎ هﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻷﺧﻴﺮ ‪ .‬اﻷوﻟﻰ ﺑﺎﺳﺘﺨﺪام ‪ //‬وهﻲ ﺗﻘـﻮم‬
‫ﺑﺎﻋﺘﺒﺎر آﻞ اﻟﺬي ﺑﻌﺪهﺎ ﺣﺘﻰ ﻧﻬﺎﻳﺔ اﻟﺴﻄﺮ آﺘﻌﻠﻴﻖ ‪ .‬أﻣﺎ اﻟﺸﻜﻞ اﻵﺧﺮ ﺑﺎﺳﺘﺨﺪام *‪ /‬و ‪ */‬اﻟﺮﻣﺰ اﻷول ﻳﻔـﺘﺢ ﻓﻘـﺮة ﺗﻌﻠﻴـﻖ‬
‫واﻟﺮﻣﺰ اﻟﺜﺎﻧﻲ ﻳﻐﻠﻖ هﺬﻩ اﻟﻔﻘﺮة ‪ ،‬ذآﺮت ﻓﻘﺮة ﻷن هﺬا اﻟﻨﻮع ﻣﻦ اﻟﺘﻌﻠﻴﻖ ﻣﻤﻜـﻦ أن ﻳﻤﺘـﺪ ﻋﻠـﻰ ﻋـﺪة أﺳـﻄﺮ أو ﻳﻤﻜـﻦ أن‬
‫ﻳﻜﻮن ﻓﻲ ﺳﻄﺮ واﺣﺪ ‪.‬‬
‫‪ 1.4‬ﻣﻠﺨﺺ اﻟﺪرس‬
‫• ﻣﻦ أﺟﻞ اﻟﺒﺪأ ﺑﻤﺸﺮوع ﺑﺮﻣﺠﻲ ﻳﺠﺐ اﻧﺸﺎء ﻣﺸﺮوع ﺟﺪﻳﺪ ﻓﻲ اﻟﻔﻴﺠﻮال ﺳﻲ‪ ++‬ﻋﻦ ﻃﺮﻳـﻖ اﺧﺘﻴـﺎر ‪ New‬ﻣـﻦ‬
‫اﻟﻘﺎﺋﻤﺔ ‪. File‬‬
‫• ﻳﺘﻢ اﻧﺸﺎء ﻣﻠﻔﺎت آﻮد ﺟﺪﻳﺪة واﺿﺎﻓﺘﻬﺎ ﻟﻠﻤﺸﺮوع أﻳﻀﺎ ﻣﻦ ﺧﻼل اﻷﻣﺮ ‪ New‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ ‪. File‬‬
‫• ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ أول ﺑﺮﻧﺎﻣﺞ ﻓﻲ اﻟﺴﻲ‪ ++‬وﺗﻨﻔﻴﺬﻩ ‪.‬‬
‫• ﺗﻌﻠﻤﻨﺎ آﻴﻔﻴﺔ آﺘﺎﺑﺔ ﺗﻌﻠﻴﻘﺎت ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫ﻣﻦ أﺟﻞ ﺗﻨﺰﻳﻞ ﻣﻠﻔﺎت ﻣﺸﺮوع هﺬا اﻟﺪرس اﻧﻘﺮ هﻨﺎ ‪.‬‬

‫اﻟﺪرس اﻟﺜﺎﻧﻲ – اﻷﻧﻮاع و اﻟﻌﻮاﻣﻞ و اﻟﺘﻌﺎﺑﻴﺮ‬ ‫ﻃﺮﻳﻖ اﻟﺒﺮﻣﺠﺔ ﻓﻲ ﺳﻲ‪++‬‬
‫اﻷﻧﻮاع واﻟﻌﻮاﻣﻞ واﻟﺘﻌﺎﺑﻴﺮ – ‪Types, Operators, and Expressions‬‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ اﻟﺴﻲ‪ ++‬ﻳﺼﻒ اﻟﻌﻤﻠﻴﺎت واﻟﻤﻬـﺎم اﻟﺘـﻲ ﺳـﻮف ﺗﻄﺒـﻖ ﻋﻠـﻰ اﻟﻌﻨﺎﺻـﺮ اﻟﺘـﻲ ﺗﺤﻤـﻞ اﻟﺒﻴﺎﻧـﺎت ‪ .‬ﻣـﻦ اﻷﻣـﻮر‬
‫اﻟﻤﻬﻤﺔ ﺟﺪا آﻤﺎ هﻮ اﻟﺤﺎل ﻓﻲ ﺑﺎﻗﻲ اﻟﻠﻐﺎت هﻮ ﻋﻤﻠﻴﺔ ﺗﺤﺪﻳﺪ ﻣﺎ هﻮ ﻧﻮع هﺬﻩ اﻟﻌﻨﺎﺻﺮ أو ﺑﻜﻠﻤـﺔ أﺧـﺮى أﻧـﻮاع اﻟﻤﻌﻄﻴـﺎت‪.‬‬
‫ﻳﻤﻜﻦ ﺗﺼﻨﻴﻒ هﺬﻩ اﻷﻧﻮاع ﻓﻲ اﻟﺴﻲ‪ ++‬آﺄﻧﻮاع أﺳﺎﺳﻴﺔ وأﻧﻮاع ﻣﺸﺘﻘﺔ ‪ .‬ﻋﻠـﻰ ﺳـﺒﻴﻞ اﻟﻤﺜـﺎل اﻷﻧـﻮاع اﻟﻤﺸـﺘﻘﺔ هـﻲ‬
‫ﺗﻠﻚ اﻷﻧﻮاع اﻟﺘﻲ ﺗﻌﺘﻤﺪ ﻋﻠﻰ اﻷﻧﻮاع اﻷﺳﺎﺳﻴﺔ ﻣﺜﻞ اﻟﻤﺼﻔﻮﻓﺎت ‪.‬‬
‫إن اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻳﻤﻜﻦ ﺗﺼﻨﻴﻔﻬﺎ إﻟﻰ ﻗﺴﻤﻴﻦ ‪ .‬اﻷوﻟﻰ هﻲ اﻟﺘـﻲ ﺗﺒﻘـﻰ ﺛﺎﺑﺘـﺔ ﻃـﻮل‬
‫ﻓﺘﺮة ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ‪ ،‬أﻣﺎ اﻟﺜﺎﻧﻴﺔ هﻲ اﻟﺘﻲ ﺗﺘﻐﻴﺮ ﻗﻴﻤﺘﻬﺎ ‪ .‬اﻻﺳﻢ اﻟﺬي ﻳﻄﻠﻖ ﻋﻠﻰ اﻷوﻟﻰ هﻲ اﻟﺜﻮاﺑﺖ أو ‪ Constants‬أﻣﺎ‬
‫اﻟﺜﺎﻧﻴﺔ ﻓﺴﻮف ﻧﻄﻠﻖ ﻋﻠﻴﻬﺎ اﺳﻢ اﻟﻤﺘﺤﻮﻻت أو ‪ . Variables‬ﻃﺒﻌﺎ آﻼ اﻟﺼﻨﻔﻴﻦ اﻟﺴﺎﺑﻘﻴﻦ ﻳﺠﺐ أن ﺗﻨﻄﺒﻖ ﻋﻠﻴـﻪ ﻣﺎذآﺮﻧـﺎﻩ‬
‫ﺑﺎﻟﻨﺴﺒﺔ إﻟﻰ اﻷﻧﻮاع ؛ ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل اﻟﻤﺘﺤﻮﻻت ﻳﺠﺐ ﺗﺤﺪﻳﺪ ﻧﻮﻋﻬﺎ ﺣﺘﻰ ﻧﺴﺘﻄﻴﻊ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ‪.‬‬
‫أﻣﺎ اﻟﺘﻌﺒﻴﺮ ‪ expression‬ﻓﻬﻮ ﻋﺒﺎرة ﻋﻦ اﻟﺨﻄﻮات واﻟﻘﻮاﻧﻴﻦ اﻟﺘﻲ ﺳﻮف ﻳﺘﻢ ﻣﻦ ﺧﻼﻟﻬﺎ ﺣﺴﺎب ﻗﻴﻤﺔ ﻣﻌﻴﻨـﺔ ‪ .‬اﻟﺘﻌﺒﻴـﺮ‬
‫ﻳﺘﻜﻮن ﻣﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺤـﺪود ‪ operands‬أو اﻟﻘـﻴﻢ و اﻟﻌﻮاﻣـﻞ ‪ . operators‬ﻟﻐـﺔ اﻟﺴـﻲ‪ ++‬ﻏﻨﻴـﺔ ﺟـﺪا ﺑﺎﻟﻌﻮاﻣـﻞ اﻟﺘـﻲ‬
‫ﺗﻌﻜﺲ اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺗﺘﻢ ﻓﻲ اﻟﻤﻌﺎﻟﺞ ﻣﺜﻞ ﻋﻤﻠﻴﺎت اﻟﺠﻤﻊ واﻟﻀﺮب واﻻزاﺣﺔ ‪ .‬اﻟﻌﻮاﻣﻞ ﻳﻤﻜﻦ ﺗﺼﻨﻴﻔﻬﺎ إﻟـﻰ ﻋـﺪة أﺻـﻨﺎف‬
‫أﻳﻀﺎ ﻓﻤﻨﻬﺎ ﻋﻮاﻣﻞ ﻣﻦ أﺟﻞ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ آﺎﻟﺠﻤﻊ واﻟﻀﺮب وﻣﻨﻬـﺎ ﻋﻮاﻣـﻞ اﻟﻤﻘﺎرﻧـﺔ آﺎﻷﺻـﻐﺮ واﻷآﺒـﺮ ‪ .‬ﺳـﻮف ﻧﻘـﻮم‬
‫ﺑﺸﺮح ﺑﻌﺾ اﻟﻌﻮاﻣﻞ ﻓﻲ هﺬا اﻟﺪرس ﻣﻊ ﺗﻜﻤﻴﻠﻬﺎ ﻓﻲ ﺑﺎﻗﻲ اﻟﺪروس ‪.‬‬
‫هﺬا اﻟﺪرس ﻳﻮﺟﺪ ﻓﻴﻪ ﻋﺪد هﺎﺋﻞ ﻣﻦ اﻟﻤﻌﻠﻮﻣﺎت ﻣـﻊ ﻗﻠﻴـﻞ ﻣـﻦ اﻟﺘﻄﺒﻴـﻖ ‪ ،‬ﻟـﺬا ﻟـﻴﺲ ﻣـﻦ اﻟﻀـﺮوري ﻓﻬﻤـﻪ‬ ‫½‬
‫ﺑﺸﻜﻞ آﺎﻣﻞ وﻟﻜﻦ ﻳﺠﺐ ﻗﺮاﺋﺘﻪ ﺑﺸﻜﻞ آﺎﻣﻞ واﻟﺮﺟﻮع إﻟﻴﻪ إذا دﻋﺖ اﻟﺤﺎﺟﺔ ﻓﻲ اﻟﺪروس اﻟﻼﺣﻘﺔ ‪.‬‬
‫‪ 2.1‬اﻟﺜﻮاﺑﺖ اﻟﺼﺤﻴﺤﺔ – ‪Integer Constants‬‬

‫هﺬﻩ اﻟﺜﻮاﺑﺖ هﻲ ﻋﺒﺎرة ﻋﻦ أﻋﺪاد ﻗﺪ ﺗﻜﻮن ﻣﻮﺟﺒﺔ أو ﺳـﺎﻟﺒﺔ ‪ .‬وﻳﻤﻜـﻦ ﺗﻤﺜﻴﻠﻬـﺎ آﺄﻋـﺪاد ﺑﺎﻟﻨﻈـﺎم اﻟﻌﺸـﺮي أو اﻟﺜﻤـﺎﻧﻲ أو‬
‫اﻟﺴﺖ ﻋﺸﺮي ‪ .‬اﻷﻋﺪاد ﺑﺎﻟﻨﻈﺎم اﻟﻌﺸﺮي ﺗﺘﻜﻮن ﻣـﻦ اﻷرﻗـﺎم ﻣـﻦ ‪ 0‬إﻟـﻰ ‪ 9‬واﻟـﺮﻗﻢ اﻷول ﻳﺠـﺐ أن ﻳﻜـﻮن ﻏﻴـﺮ اﻟـﺮﻗﻢ ‪. 0‬‬
‫وآﺄﻣﺜﻠﺔ ﻋﻠﻰ هﺬا ﻟﺪﻳﻨﺎ اﻷﻋﺪاد ‪:‬‬
‫‪10‬‬ ‫‪9999‬‬ ‫‪801‬‬ ‫‪1234‬‬
‫آﻠﻨﺎ ﻧﻌﻠﻢ أن اﻟﺤﺎﺳﺐ اﻵﻟﻲ ﻳﺴﺘﻄﻴﻊ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻣﺠﺎل ﻣﺤﺪد ﻟﻸﻋﺪاد ‪ .‬دﻗﺔ هـﺬﻩ اﻷﻋـﺪاد ﺗﻌﺘﻤـﺪ ﻋﻠـﻰ اﻟﻤﺴـﺎﺣﺔ‬
‫اﻟﺘﻲ ﻳﺤﺠﺰهﺎ اﻟﻤﺘﺮﺟﻢ ﻟﻠﻌﺪد ‪ ،‬وهﺬا ﻳﺨﺘﻠﻒ ﻣﻦ ﺣﺎﺳﺐ إﻟﻰ ﺁﺧـﺮ ﻓﻔـﻲ اﻷﺟﻬـﺰة اﻟﺘـﻲ ﺗﺤﺘـﻮي ﻋﻠـﻰ ﻣﺴـﺠﻼت ﺑﺤﺠـﻢ‬
‫‪16‬ﺑﺖ ﻓﺈن ال ‪ integer‬ﺳﻮف ﻳﺤﺠﺰ ﻟﻪ ‪16‬ﺑﺖ وﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن ﻣﺠﺎﻟﻪ ﻳﺘﺮاوح ﺑﻴﻦ ‪ -32768‬إﻟﻰ ‪ . 32767‬ﻓﻲ اﻷﺟﻬـﺰة اﻟﺤﺎﻟﻴـﺔ‬
‫وﺗﺤﺖ ﻧﻈﺎم وﻧﺪوز ‪32‬ﺑﺖ ﻓﺈن ال ‪ integer‬ﻳﺤﺠﺰ ﻟﻪ ‪32‬ﺑﺖ وﺑﺎﻟﺘﺎﻟﻲ ﻳﻜﻮن ﻣﺠﺎﻟﻪ ﺑﻴﻦ ‪ -2147483648‬إﻟﻰ ‪. 2147483647‬‬
‫ﺑﺎﻟﻨﺴﺒﺔ إﻟﻰ اﻷﻋﺪاد ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻤﺎﻧﻲ ﻓﺈﻧﻬﺎ ﻳﺠﺐ أن ﺗﺒﺪأ ﺑﺎﻟﺮﻗﻢ ‪ 0‬وهﺬﻩ أﻣﺜﻠﺔ ﻋﻠﻴﻬﺎ ‪:‬‬
‫‪020‬‬ ‫‪0777‬‬ ‫‪0123‬‬ ‫‪0235‬‬
‫أﻣﺎ اﻷﻋﺪاد ﺑﺎﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي ﻓﻬﻲ ﺗﺒﺪأ ﺑﺎﻟﺮﻣﺰ ‪ 0x‬أو ‪ 0X‬وهﺬا أﻣﺜﻠﺔ ﻋﻠﻰ هﺬا ‪:‬‬
‫‪0xFFFF‬‬ ‫‪0x1234‬‬ ‫‪0XECA2‬‬ ‫‪0x0A2F‬‬
‫ﻓﻲ ﺣﺎل ﺗﺨﻄﻰ اﻟﺜﺎﺑﺖ اﻟﻤﺠﺎل اﻟﻤﺴﻤﻮح ﻓﻴﻪ ﻓﺈن ﻣﻌﻈﻢ اﻟﻤﺘﺮﺟﻤﺎت ﺗﻘﻮم ﺑﺎﻟﺘﺤﺬﻳﺮ ﻋﻦ ذﻟﻚ ‪.‬‬
‫ﻓﻲ اﻷﺟﻬﺰة ‪16‬ﺑﺖ ﻓﺈﻧﻪ ﻳﻤﻜـﻦ اﺟﺒـﺎر اﻟﻤﺘـﺮﺟﻢ ﻋﻠـﻰ اﻋﺘﺒـﺎر اﻟﻌـﺪد ذو ﺣﺠـﻢ ‪32‬ﺑـﺖ ﺑﺎﺿـﺎﻓﺔ اﻟﻼﺣﻘـﺔ ‪ L‬أو‬ ‫½‬
‫)اﻟﺤﺮق اﻟﺼﻐﻴﺮ ‪ ( l‬ﻣﺜﻞ اﻟﺘﺎﻟﻲ ‪ 0x23A1L‬أو ‪. 982L‬‬
‫‪ 2.2‬اﻟﺜﻮاﺑﺖ ﻟﻸﻋﺪاد اﻟﺤﻘﻴﻘﺔ – ‪Floating point Constants‬‬

‫أي رﻗﻢ ﻳﺤﺘﻮي ﻋﻠﻰ ﻗﺴﻢ آﺴﺮي ﻳﻌﺘﺒﺮ ﻋﺪد ﺣﻘﻴﻘﻲ ‪ .‬وﺗﻜﺘـﺐ هـﺬﻩ اﻷرﻗـﺎم ﺑﺼـﻴﻐﺘﻴﻦ ‪ .‬اﻟﺼـﻴﻐﺔ اﻟﻤﺒﺎﺷـﺮة واﻟﺒﺴـﻴﻄﺔ‬
‫أﻣﺜﻠﺔ ﻋﻠﻰ هﺬا ‪:‬‬
‫‪0.00001‬‬ ‫‪0.1‬‬ ‫‪12.0‬‬ ‫‪3.1415926‬‬
‫اﻟﻨﻘﻄﺔ اﻟﺘﻲ ﺗﻔﺼـﻞ اﻟﻘﺴـﻢ اﻟﺤﻘﻴﻘـﻲ واﻟﻜﺴـﺮي ﻻ ﺗﺸـﺘﺮط أن ﺗﺤﻄـﺎط ﺑـﺮﻗﻤﻴﻦ ﺣﻴـﺚ ﻳﻤﻜـﻦ آﺘﺎﺑـﺔ اﻟـﺮﻗﻢ اﻟﺜﺎﻧﻴـﺔ‬
‫واﻟﺜﺎﻟﺚ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫‪.1‬‬ ‫‪12.‬‬

‫وﻟﻜﻦ ﻳﻔﻀﻞ ‪ ،‬ﻋﻠﻰ آﻞ اﻷﺣﻮل ‪ ،‬اﺳﺘﺨﺪام اﻟﺼﻴﻐﺔ اﻟﺘﻲ ﺗﺠﻌﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻗﺎﺑﻞ ﻟﻠﻘﺮاﺋﺔ ﺑﺸﻜﻞ واﺿﺢ ‪.‬‬
‫اﻟﺼﻴﻐﺔ اﻟﺜﺎﻧﻴﺔ أو ﻣﺎﻳﺴﻤﻰ ﺑﺎﻟﺘﻤﺜﻴﻞ اﻟﻌﻠﻤﻲ وهﻮ ﻋﺒﺎرة ﻋﻦ رﻗﻢ ﻣﺜﻞ اﻟﺴﺎﺑﻖ وﻟﻜﻦ ﻣﻀﺮوب ﺑﺮﻗﻢ ﻣﺮﻓﻮع إﻟﻰ اﻟﻌـﺪد‬
‫‪ 10‬هﺬا اﻷس ﻳﻤﺜﻠﻪ اﻟﺤﺮف ‪ e‬أو ‪ E‬أﻣﺜﻠﺔ ﻋﻠﻰ هﺬﻩ اﻟﺼﻴﻐﺔ هﻲ ‪:‬‬
‫)‪12.34e-3 (= 0.01234‬‬ ‫)‪1.0e2 (= 100‬‬
‫‪ 2.3‬ﺛﻮاﺑﺖ اﻟﻤﺤﺎرف – ‪Character constants‬‬

‫اﻟﺜﺎﺑﺖ اﻟﻤﺤﺮﻓﻲ هﻮ أي ﺣﺮف آﺘﺐ ﺑﻴﻦ اﺛﻨﺘﻴﻦ ﻣﻦ اﻟﻔﺎﺻﻠﺔ اﻟﻌﻠﻮﻳﺔ اﻟﻮاﺣﺪة أو ‪ single quotes‬؛ ﻣﺜﻞ ’‪ . ‘X‬إن ﻗﻴﻤﺔ اﻟﺜﺎﺑﺖ‬
‫اﻟﻤﺤﺮﻓﻲ هﻲ ﻋﺒﺎرة ﻋﻦ ﻗﻴﻤﺔ هـﺬا اﻟﺤـﺮف ﻓـﻲ ﺟـﺪول اﻟﻤﺤـﺎرف ﻓـﻲ اﻟﻨﻈـﺎم أو اﻟﺠﻬـﺎز ‪ .‬ﻣـﻦ أﺷـﻬﺮ ﺟـﺪاول اﻟﻤﺤـﺎرف‬
‫اﺳـﺘﺨﺪاﻣﺎ هـﻮ )‪ . ASCII (American Standard Code for Information Interchange‬ﻓﻔـﻲ ﺟـﺪول ‪ ASCII‬ﺗﺒﻠـﻎ ﻗﻴﻤـﺔ‬
‫اﻟﻤﺤﺮف ’‪ ‘X‬اﻟﻘﻴﻤﺔ ‪. 88‬‬
‫ﻳﻮﺟﺪ أﻳﻀﺎ اﻟﻌﺪﻳـﺪ ﻣـﻦ اﻟﻤﺤـﺎرف ﻓـﻲ ﻟﻐـﺔ اﻟﺴـﻲ واﻟﺘـﻲ ﺗﺴـﻤﻰ ﺑﻤﺤـﺎرف اﻟﻬـﺮوب أو ‪ . escape character‬وهـﻲ‬
‫ﺗﺴﺘﺨﺪم ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺤﺎرف اﻟﺘﻲ ﻣﻦ اﻟﺼﻌﺐ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ أو ﻣﻦ اﻟﺼﻌﺐ ادﺧﺎﻟﻬﺎ ﻣﻦ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ ﻣﺒﺎﺷﺮة ‪ .‬وهـﻲ‬
‫ﺗﺒﺪأ ﺑﺎﻟﺮﻣﺰ \ ﺛﻢ ﻳﻠﻴﻪ ﻣﺤﺮف واﺣﺪ ‪ .‬اﻟﻤﺤﺮﻓﻴﻦ اﻟﺴﺎﺑﻘﻴﻦ ﻳﻌﺘﺒﺮو آﻤﺤﺮف واﺣﺪ ﻣﻦ وﺟﻬﺔ ﻧﻈﺮ اﻟﻤﺘﺮﺟﻢ ‪ ،‬ﺳﻮف أﺳﺮد هﺬﻩ‬
‫اﻟﻤﺤﺎرف هﻨﺎ ‪:‬‬
‫‪\a‬‬ ‫‪Alarm bell‬‬
‫‪\n‬‬ ‫‪New line‬‬
‫‪\t‬‬ ‫‪Horizontal tab‬‬
‫‪\v‬‬ ‫‪Vertical tab‬‬
‫‪\b‬‬ ‫‪backspace‬‬
‫‪\r‬‬ ‫‪Carriage return‬‬
‫‪\f‬‬ ‫‪Formfeed‬‬
‫’\‬ ‫‪Single quote‬‬
‫”\‬ ‫‪Double quote‬‬
‫\\‬ ‫‪backslash‬‬
‫?\‬ ‫‪Question mark‬‬
‫‪\0‬‬ ‫‪NULL character‬‬
‫اﻵن ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل إذا أردت اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺤـﺮف \ ﻓﻴﺠـﺐ أن ﺗﻜﺘـﺐ ’\\‘ ﻋﻮﺿـﺎ ﻋـﻦ ’\‘ ‪ .‬أﻳﻀـﺎ ﺑﺎﻹﺿـﺎﻓﺔ إﻟـﻰ‬
‫ﻣﺤﺎرف اﻟﻬﺮوب اﻟﺴﺎﺑﻘﺔ ﻳﻤﻜﻦ أن أن ﺗﺘﻜﻮن ﺳﻠﺴﻠﺔ اﻟﻬﺮوب ﻣﻦ اﻟﻤﺤﺮف \ ﻳﺘﺒﻌﻬﺎ ‪ x‬وﻣـﻦ ﺛـﻢ واﺣـﺪ أو أآﺜـﺮ ﻣـﻦ اﻷرﻗـﺎم‬
‫اﻟﺴﺖ اﻟﻌﺸﺮﻳﺔ ‪ .‬اﻟﻨﺎﺗﺞ هﻮ ﻋﺒﺎرة ﻋﻦ رﻗﻢ ﺳﺖ ﻋﺸﺮي ﻳﻤﺜﻞ دﻟﻴﻞ ﻓﻲ ﺟﺪول اﻟﻤﺤﺎرف ﻓﻲ اﻟﺠﻬﺎز ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜـﺎل‬
‫ﻓﺈن اﻟﻤﺤﺮف ’‪ ‘X‬ﻗﻴﻤﺘﻪ ‪ 0x58‬ﻓﻲ ﺟﺪول ‪ ASCII‬وﺑﺎﻟﺘﺎﻟﻲ ﻳﻤﻜﻦ ﺗﻤﺜﻴﻠﻪ أﻳﻀـﺎ ﺑﺎﻟﺼـﻴﻐﺔ ’‪ . ‘\x58‬ﺣﺘـﻰ ﻧﻜـﻮن دﻗﻴﻘـﻴﻦ أآﺜـﺮ‬
‫اﻟﺼﻴﻐﺔ اﻷﺧﻴـﺮة ﺗﺴـﺘﺨﺪم ﻟﻄﺒﺎﻋـﺔ اﻟﻤﺤـﺎرف اﻟﻤﻮﺟـﻮدة ﻓـﻲ ﺟـﺪول ‪ ASCII‬اﻟﺘـﻲ ﻻ ﻳﻤﻜـﻦ ادﺧﺎﻟﻬـﺎ ﻣـﻦ ﻟﻮﺣـﺔ اﻟﻤﻔـﺎﺗﻴﺢ‬
‫آﺎﻟﻤﺤﺎرف اﻟﻼﺗﻴﻨﻴﺔ وﻏﻴﺮهﺎ ‪.‬‬
‫اﻟﻤﺤﺮف اﻷﺧﻴﺮ اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﻘﺎﺋﻤﺔ اﻟﺴﺎﺑﻘﺔ ﻳﻌﺘﺒﺮ اﻟﻤﺤﺮف اﻷول ﻓﻲ ﺟﺪول ‪ ASCII‬وﻳﺴﻤﻰ ﺑﻤﺤﺮف اﻟﺼـﻔﺮ أو ال‬
‫‪ . ‘\0’ NULL Character‬هﺬا اﻟﻤﺤﺮف ﻟﻪ اﺳﺘﺨﺪاﻣﺎت ﺧﺎﺻﺔ ﻓﻲ اﻟﺴﻲ وهﺬا ﻣﺎﺳﻮف ﻧﺮاﻩ ﻻﺣﻘﺎ ﻓﻲ هﺬا اﻟﺪرس ‪.‬‬
‫‪ 2.4‬ﺛﻮاﺑﺖ اﻟﺴﻼﺳﻞ اﻟﻨﺼﻴﺔ – ‪String constants‬‬

‫اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ هﻲ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﺤﺎرف ﻣﺤﺎﻃﺔ ﺑﺰوج ﻣﻦ اﻟﻔﺎﺻﻠﺘﻴﻦ اﻟﻌﻠﻮﻳﺎت أي " ‪ .‬وﻳﻤﻜﻦ أﻳﻀـﺎ اﺳـﺘﺨﺪام ﻧﻔـﺲ‬
‫ﻣﺤﺎرف اﻟﻬﺮوب اﻟﺴﺎﺑﻘﺔ ﺑﺪاﺧﻞ اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ ‪ .‬وآﺄﻣﺜﻠﺔ ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﻨﺼﻴﺔ هﻲ ‪:‬‬
‫”‪“Hello world‬‬
‫”‪“The C++ Programming Language‬‬
‫”“‬
‫””\‪“He said \”Good morning‬‬
‫”‪“This string terminates with a newline \n‬‬
‫أﻳﻀﺎ اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ ﻳﻤﻜﻦ أن ﺗﻤﺘﺪ إﻟﻰ أآﺜﺮ ﻣﻦ ﺳﻄﺮ ﻋـﻦ ﻃﺮﻳـﻖ اﺳـﺘﺨﺪام اﻟﻤﺤـﺮف \ ﻓـﻲ ﺁﺧـﺮ اﻟﺴـﻄﺮ اﻷول‬
‫وﻣﻨﻪ اﻻﺳﺘﻤﺮار ﻓﻲ اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ وآﻤﺜﺎل ﻋﻠﻰ هﺬا إﻟﻴﻚ اﻟﺘﺎﻟﻲ ‪:‬‬

‫\ ‪“This string extends‬‬

‫”‪over two lines.‬‬
‫اﻟﻤﺘﺮﺟﻢ ﻳﻌﺘﺒﺮ اﻟﺴﻠﺴﻠﺔ اﻟﺴﺎﺑﻘﺔ آﺴﻠﺴﻠﺔ واﺣﺪة أي ﻳﻘﻮم ﺑﺘﺠﺎهﻞ اﻟﻤﺤﺮف \ ﺑﺎﻻﺿﺎﻓﺔ إﻟـﻰ رﻣـﺰ اﻟﺴـﻄﺮ اﻟﺠﺪﻳـﺪ‬
‫اﻟﺬي ﺑﻌﺪﻩ ‪ .‬وهﻲ ﻣﺸﺎﺑﻬﺔ ﺗﻤﺎﻣﺎ إﻟﻰ اﻟﺴﻼﺳﻠﺔ ‪:‬‬
‫”‪“This string extends over two lines.‬‬
‫وأﻳﻀﺎ اﻟﺴﻠﺴﻠﺘﻴﻦ اﻟﻤﻨﻔﺼﻠﺘﻴﻦ اﻟﺘﻲ ﺗﻠﻲ أﺣﺪهﻤﺎ اﻷﺧﺮى ﻳﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﺎﺿﺎﻓﺘﻬﻤﺎ إﻟﻰ ﺑﻌﻀـﻬﻤﺎ ﻟﺘﻜـﻮﻳﻦ ﺳﻠﺴـﻠﺔ‬
‫واﺣﺪة ‪ .‬ﻣﺜﻼ هﺬا اﻟﻤﺜﺎل ‪:‬‬
‫”‪“This “ “string‬‬
‫ﻳﺤﻮل إﻟﻰ ‪:‬‬
‫”‪“This string‬‬
‫اﻟﻄﺮﻳﻘﺔ اﻟﺴﺎﺑﻘﺔ ﺟﺪا ﻣﻬﻤﺔ ﻓﻲ ﻗﺺ اﻟﺴﻼﺳﻞ اﻟﻄﻮﻳﻠﺔ ووﺿﻌﻬﻢ ﻋﻠﻰ أآﺜﺮ ﻣﻦ ﺳﻄﺮ‪.‬‬
‫أﻳﻀﺎ اﻷﻣﺮ اﻟﻬﺎم ﺟﺪا ﺑﺎﻟﻨﺴﺒﺔ إﻟﻰ ﻣﻮﺿـﻮع اﻟﺴﻼﺳـﻞ ﻓـﻲ اﻟﺴـﻲ‪ ++‬ﻓـﺈن أي ﺳﻠﺴـﻠﺔ ﺳـﻮف ﺗﻨﺘﻬـﻲ ب ‪NULL‬‬
‫‪ Character‬أو ’‪ . ‘\0‬وهﺬا اﻟﻤﺤﺮف هﻮ اﻟﺬي ﻳﺤﺪد اﻧﺘﻬﺎء اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ ‪ .‬هﺬا ﻳﻌﻨﻲ إذا آﺎﻧﺖ اﻟﺴﻠﺴﻠﺔ ﺗﺤﺘﻮي ﻋﻠـﻰ‬
‫ﻋﺪد ‪ N‬ﻣﻦ اﻟﻤﺤﺎرق ﻓﺈﻧﻬﺎ ﺣﻘﻴﻘﺔ ﺳﻮف ﺗﺤﺘﻮي ﻋﻠﻰ ‪ N+1‬ﻣﻦ أﺟﻞ اﺣﺘـﻮاء ﻣﺤـﺮف اﻟﻨﻬﺎﻳـﺔ ‪ .‬ﻟـﺬﻟﻚ ﺗﺴـﻤﻰ اﻟﺴﻼﺳـﻞ‬
‫اﻟﻨﺼﻴﺔ ﻓﻲ ﻟﻐﺔ اﻟﺴﻲ ب ‪ Null terminated string‬أو اﻟﺴﻠﺴﻠﺔ اﻟﻤﻨﺘﻬﻴﺔ ﺑﻤﺤﺮف اﻟﺼﻔﺮ ‪ .‬وإﻟﻴﻚ هﺬا اﻟﺸﻜﻞ ‪:‬‬
‫‪h‬‬ ‫‪e‬‬ ‫‪l‬‬ ‫‪l‬‬ ‫‪o‬‬ ‫‪\0‬‬
‫ﺷﻜﻞ ‪6- 2‬‬

‫ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ ﺳﺒﻖ ﻳﺠﺐ أن ﻧﻼﺣـﻆ أن اﻟﻤﺤـﺮف ’‪ ‘X‬واﻟﺴﻠﺴـﻠﺔ ”‪ “X‬ﻟﻴﺴـﺎ ﻧﻔـﺲ اﻟﺸـﺊ ﻓـﺎﻟﻤﺤﺮف ﻓـﻲ ﻣﻌﻈـﻢ‬
‫اﻷﺟﻬﺰة ﻋﺒﺎرة ﻋﻦ ‪8‬ﺑﺖ أو ﺑﺎﻳﺖ أﻣﺎ اﻟﺴﻠﺴﺔ ”‪ “X‬ﻓﺴﻮف ﻳﺤﺠﺰ ﻟﻬﺎ ﻣﺤﺮﻓﻴﻦ وﺑﺎﻟﺘﺎﻟﻲ ﺳﻮف ﺗﻜﻮن ﺑﺎﻳﺘﻴﻦ ‪ .‬وﺑﺎﻟﺘﺎﻟﻲ ﻳﺠﺐ‬
‫اﻻﻧﺘﺒﺎﻩ ﻓﻲ ﺣﺎﻟﺔ اﺳﺘﺨﺪام اﻟﻤﺤﺎرق واﻟﺴﻼﺳﻞ واﻟﺘﻔﺮﻳﻖ ﻓﻴﻤﺎ ﺑﻴﻨﻬﻤﺎ ‪.‬‬
‫‪ 2.5‬اﻟﻤﻌﺮﻓﺎت – ‪Identifiers‬‬
‫ﻟﻐﺔ اﻟﺴﻲ‪ ++‬ﻣﺜﻞ ﺑﺎﻗﻲ اﻟﻠﻐﺎت ﺗﺘﻄﻠﺐ ﻣﻨﻚ اﻋﻄﺎء أﺳﻤﺎء ﻣﻌﻴﻨﺔ ﻟﻠﻤﻌﻄﻴﺎت اﻟﺘﻲ ﺗﺴﺘﺨﺪﻣﻬﺎ ﻓﻲ ﺑﺮﻧﺎﻣﺠـﻚ ‪ .‬هـﺬﻩ‬
‫اﻷﺳﻤﺎء ﺗﺪﻋﻰ ﺑﺎﻟﻤﻌﺮﻓﺎت أو ‪ Identifiers‬وﻳﺘﻢ وﺿﻌﻬﺎ أو ﺗﻜﻮﻳﻨﻬﺎ ﻣﻦ ﻗﺒـﻞ اﻟﻤﺒـﺮﻣﺞ ‪ .‬وﻳﺠـﺐ أن ﻳﺼـﻨﻊ اﻟﻤﻌـﺮف ﺑﺎﻻﻋﺘﻤـﺎد‬
‫ﻋﻠﻰ اﻟﻘﺎﻋﺪة اﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫اﻟﻤﻌﺮف هﻮ ﻋﺒﺎرة ﻋﻦ ﺧﻠﻴﻂ ﻣـﻦ اﻟﻤﺤـﺎرف واﻷرﻗـﺎم واﻟﺘـﻲ ﻳﺠـﺐ أن ﺗﺒـﺪأ ﺑﻤﺤـﺮف ‪ .‬اﻟﺮﻣـﺰ )_( أو ‪Underscore‬‬
‫ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻪ ﺑﺎﻟﻤﻌﺮف وهﻮ ﻳﻌﺘﺒﺮ آﺤﺮف ﻋﺎدي ‪.‬‬
‫ﻣﻦ اﻟﻘﺎﻋﺪة اﻟﺴﺎﺑﻘﺔ ﻳﻤﻜﻦ أن ﻧﻀﻊ ﺑﻌﺾ اﻷﻣﺜﻠﺔ ﻟﻤﻌﺮﻓﺎت ﺗﻌﺘﺒﺮ ﺻﺤﻴﺤﺔ ﻟﻤﺘﺮﺟﻢ اﻟﺴﻲ‪: ++‬‬
‫‪time‬‬ ‫‪counter‬‬ ‫‪BUFFER‬‬
‫‪x‬‬ ‫‪unit_cost‬‬ ‫‪h2o‬‬
‫‪_MAX‬‬ ‫‪programName AVeryLongIdentifier‬‬
‫ﻳﻌﺘﺒﺮ أي ﻣﻌﺮﻓﻴﻦ هﻤﺎ واﺣﺪ ﻓﻲ ﺣﺎﻟﺔ آﺎن ﻟﻬﻤﺎ ﻧﻔﺲ اﻻﻣﻼء وﻧﻔﺲ ﺣﺎﻟﺔ اﻷﺣـﺮف )اﻟﺼـﻐﻴﺮة أم اﻟﻜﺒﻴـﺮة( ‪ .‬وﺑﺎﻟﺘـﺎﻟﻲ‬
‫اﻟﻤﻌﺮﻓﻴﻦ ‪ abcd‬و ‪ abcD‬ﻻ ﻳﻌﺘﺒﺮا واﺣﺪ‪.‬‬
‫ﻳﻔﻀﻞ أن ﻳﻌﻄﻲ اﻟﻤﺒﺮﻣﺞ اﺳﻤﺎء ﻟﻠﻤﻌﺮﻓﺎت ﺗﺪل ﻋﻠﻰ اﺳﺘﺨﺪاﻣﻬﺎ ‪ .‬ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل إذا آﺎن اﻟﻤﺒﺮﻣﺞ ﻳﺘﻌﺎﻣـﻞ ﻣـﻊ‬
‫اﻟﻮﻗﺖ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻪ ﻓﻴﻔﻀﻞ أن ﻳﺴﻤﻲ ﻣﻌﺮﻓﺎﺗﻪ ب ‪ hours‬و ‪ minutes‬و ‪ seconds‬وهﺬا ﻃﺒﻌﺎ أﻓﻀﻞ ﺑﻜﺜﻴﺮ ﻣﻦ ﺗﺴـﻤﻴﺘﻬﺎ ‪h‬‬
‫و‪m‬و‪.s‬‬
‫ﺑﻌﺾ اﻟﻤﻌﺮﻓﺎت ﺗﻜﻮن ﻣﺤﺠﻮزة ﻻﺳﺘﺨﺪام ﻟﻐﺔ اﻟﺴﻲ‪ ++‬وهﻲ ﻣﺎﺗﺴﻤﻰ ب ‪ . language keywords‬اﻟﺴﺮد اﻟﻜﺎﻣـﻞ‬
‫ﻟﻬﺬﻩ اﻟﻤﻌﺮﻓﺎت ﻣﻌﻄﻰ ﻓﻲ اﻷﺳﻔﻞ وﻟﻜﻦ ﺷﺮﺣﻬﺎ ﺳﻮف ﻳﺎﺗﻲ ﻻﺣﻘﺎ آﻞ ﻓﻲ ﻗﺴﻤﻪ ‪.‬‬

‫‪asm‬‬ ‫‪auto‬‬ ‫‪bad_cast‬‬ ‫‪bad_typeid‬‬

‫‪bool‬‬ ‫‪break‬‬ ‫‪case‬‬ ‫‪catch‬‬
‫‪char‬‬ ‫‪class‬‬ ‫‪const‬‬ ‫‪const_cast‬‬
‫‪continue‬‬ ‫‪default‬‬ ‫‪delete‬‬ ‫‪do‬‬
‫‪double‬‬ ‫‪dynamic_cast‬‬ ‫‪else‬‬ ‫‪enum‬‬
‫‪except‬‬ ‫‪explicit‬‬ ‫‪extern‬‬ ‫‪false‬‬
‫‪finally‬‬ ‫‪float‬‬ ‫‪for‬‬ ‫‪friend‬‬
‫‪goto‬‬ ‫‪if‬‬ ‫‪inline‬‬ ‫‪int‬‬
‫‪long‬‬ ‫‪mutable‬‬ ‫‪namespace‬‬ ‫‪new‬‬
‫‪operator‬‬ ‫‪private‬‬ ‫‪protected‬‬ ‫‪public‬‬
‫‪register‬‬ ‫‪reinterpret_cast‬‬ ‫‪return‬‬ ‫‪short‬‬
‫‪signed‬‬ ‫‪sizeof‬‬ ‫‪static‬‬ ‫‪static_cast‬‬
‫‪struct‬‬ ‫‪switch‬‬ ‫‪template‬‬ ‫‪this‬‬
‫‪throw‬‬ ‫‪true‬‬ ‫‪try‬‬ ‫‪type_info‬‬
‫‪typedef‬‬ ‫‪typeid‬‬ ‫‪typename‬‬ ‫‪union‬‬
‫‪unsigned‬‬ ‫‪using‬‬ ‫‪virtual‬‬ ‫‪void‬‬
‫‪volatile‬‬ ‫‪while‬‬
‫ﺑﻘﻲ أﻣﺮ هﺎم ﻳﺠﺐ اﻟﺘﻨﻮﻳﻪ ﻟﻪ وذﻟﻚ أﻧﻪ ﻻ ﻳﻨﺼﺢ ﺑﺎﺳﺘﺨﺪام رﻣـﺰزﻳﻦ )_( ﻓـﻲ ﺑﺪاﻳـﺔ اﻟﻤﻌـﺮف ‪ ،‬ﻣﺜـﻞ ‪ ، __MAX‬وذﻟـﻚ‬
‫ﺑﺴﺒﺐ أن اﻟﻤﻌﺮﻓﺎت ﺑﻬﺬا اﻟﺸﻜﻞ ﻣﺤﺠﻮزة ﻻﺳﺘﺨﺪام اﻟﻤﻜﺘﺒﺎت اﻟﻘﻴﺎﺳﻴﺔ ﻟﻠﺴﻲ‪ . ++‬ﻟﺬﻟﻚ ﺗﺠﻨﺐ ﻣﻦ اﺳﺘﺨﺪاﻣﻬﺎ ‪.‬‬
‫‪ 2.6‬ﺗﻌﺮﻳﻒ اﻟﻤﺘﺤﻮﻻت – ‪Variable definition‬‬

‫ﻣﻦ اﺳﻤﻬﺎ ﻓﺈن اﻟﻤﺘﺤﻮﻻت هﻲ ﻋﺒﺎرة ﻋﻦ ﻋﻨﺎﺻﺮ ﻣﻌﻄﻴﺎت ﺗﺘﻐﻴﺮ ﻗﻴﻤﻬﺎ أﺛﺘﺎء وﻗـﺖ ﺗﻨﻔﻴـﺬ اﻟﺒﺮﻧـﺎﻣﺞ ‪ .‬هـﺬﻩ اﻟﻨﺘﺤـﻮﻻت‬
‫ﻳﺠﺐ أن ﻳﻜﻮن ﻟﻬﺎ ﻧﻮع ﻳﺘﻢ ﺗﺤﺪﻳﺪﻩ ﺣﺘﻰ ﻳﺴﺘﻄﻴﻊ اﻟﻤﺘﺮﺟﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ وﺗﻮﻟﻴﺪ اﻟﻜﻮد اﻟﺼـﺤﻴﺢ ‪ .‬ﻃﺒﻌـﺎ إن ﻋﻤﻠﻴـﺔ ﺗﺤﺪﻳـﺪ‬
‫ﻧﻮع اﻟﻤﺘﺤﻮل ﺗﻌﺮف ﺑﺘﻌﺮﻳﻒ اﻟﻤﺘﺤﻮﻻت أو ‪ . Variable definition‬إن اﻟﺘﻌﺮﻳﻒ ﻳﻜﻮن ﻋﻠﻰ اﻟﻬﻴﺌﺔ اﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪type-specifier‬‬ ‫;‪list-of-variables‬‬
‫إن ‪ list-of-variables‬هﻲ ﻋﺒﺎرة ﻋـﻦ ﻣﻌﺮﻓـﺎت ﻳﻔﺼـﻞ ﺑﻴﻨﻬـﺎ ﻋﻼﻣـﺔ اﻟﻔﺎﺻـﻠﺔ هـﺬﻩ اﻟﻤﻌﺮﻓـﺎت ﺗﻤﺜـﻞ اﻟﻤﺘﺤـﻮﻻت ﻓـﻲ‬
‫ﺑﺮﻧﺎﻣﺠﻚ ‪ .‬آﻞ ﻣﺘﺤﻮل أو ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﺘﺤﻮﻻت ﻳﺘﻢ ﺗﺤﺪﻳﺪ ﻧﻮﻋﻬﺎ ﻋﻦ ﻃﺮﻳﻖ ال ‪ . type-specifier‬إن اﻷﻧـﻮاع اﻷﺳﺎﺳـﻴﺔ‬
‫ﻓﻲ اﻟﺴﻲ‪ ++‬ﻳﻤﻜﻦ اﻋﺘﺒﺎرهﺎ ‪:‬‬
‫‪int‬‬ ‫)‪(integer‬‬
‫‪char‬‬ ‫)‪(character‬‬
‫‪float‬‬ ‫)‪(single precision floating point‬‬
‫‪double‬‬ ‫)‪(double precision floating point‬‬
‫وآﻤﺜﺎل ﻋﻠﻰ ﺗﻌﺮﻳﻒ اﻟﻤﺘﺤﻮﻻت ‪:‬‬
‫‪int‬‬ ‫;‪hours, minutes, seconds‬‬
‫هﻨﺎ اﻟﻤﺘﺤﻮﻻت ‪ hours‬و ‪ minutes‬و ‪ seconds‬آﻠﻬـﺎ ﻋﺒـﺎرة ﻋـﻦ ﻣﺘﺤـﻮﻻت ﻷﻋـﺪاد ﺻـﺤﻴﺤﺔ ‪ integer‬وﺑﺎﻟﺘـﺎﻟﻲ ﻳﻤﻜـﻦ‬
‫ﺗﺨﺰﻳﻦ أي ﻋﺪد ‪ integer‬ﺿﻤﻨﻬﺎ واﺳﺘﺨﺪام هﺬا اﻟﻌﺪد ﻻﺣﻘﺎ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻚ ‪.‬‬
‫ﻃﺒﻌﺎ ﻳﻤﻜﻦ أن ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﺘﺤﻮﻻت ذات أﻧﻮاع ﻣﺨﺘﻠﻔﺔ وهﺬا ﻃﺒﻌﺎ ﻳﺘﻢ ﺑﺎﺳﺘﺨﺪام اﻟﻔﺎﺻـﻠﺔ اﻟﻤﻨﻘﻮﻃـﺔ‬
‫آﻔﺎﺻﻞ ‪ .‬وﻳﻔﻀﻞ آﺘﺎﺑﺔ آﻞ ﺗﻌﺮﻳﻒ ﺑﺴﻄﺮ ﻣﻨﻔﺼﻞ ﻣﻦ أﺟﻞ زﻳﺎدة اﻟﻮﺿﻮح ‪ .‬وهﺬا ﻣﺜﺎل ﻋﻠﻰ ذﻟﻚ ‪:‬‬
‫‪int‬‬ ‫;‪day, month, year‬‬
‫‪float‬‬ ‫;‪centigrade, fahrenheit‬‬
‫‪char‬‬ ‫;‪initial‬‬
‫‪double‬‬ ‫;‪epsilon‬‬
‫وﻋﻨﺪ اﻟﺘﻌﺮﻳﻒ ﻳﻔﻀﻞ ﺗﻌﺮﻳﻒ اﻟﻤﺘﺤﻮﻻت ذات اﻟﻌﻼﻗﺔ ﻓﻴﻤﺎ ﺑﻴﻨﻬﺎ ﻓﻲ ﻣﺠﻤﻮﻋﺔ واﻟﺒﺎﻗﻲ ﻓﻲ ﻣﺠﻤﻮﻋﺔ أﺧﺮى آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫‪int‬‬ ‫;‪counter, value‬‬
‫‪int‬‬ ‫;‪day, month, year‬‬
‫وأﻳﻀﺎ ﻳﻤﻜﻦ آﺘﺎﺑﺔ اﻟﺘﻌﺮﻳﻒ ﻋﻠﻰ ﻋﺪة أﺳﻄﺮ آﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫‪int‬‬ ‫‪day, month, year,‬‬

‫;‪hours, minutes, seconds‬‬
‫أﻳﻀﺎ ﻳﻤﻜﻦ اﻋﻄﺎء ﻗﻴﻢ ﻣﻌﻴﻨﺔ ﻟﻠﻤﺘﺤﻮﻻت أﺛﻨﺎء ﺗﻌﺮﻳﻔﻬﺎ وهﺬا ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪام رﻣﺰ اﻻﻟﺤﺎق )=( آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫‪int‬‬ ‫;‪sum = 0‬‬
‫‪float‬‬ ‫;‪pi = 3.14‬‬
‫اﻟﻤﺘﺤﻮﻻت اﻟﺴﺎﺑﻘﺔ ﺗﺒﻘﻰ ﻣﺤﺘﻔﻈﺔ ﺑﻘﻴﻤﺘﻬﺎ ﺣﺘﻰ ﻳﺘﻢ ﺗﻐﻴﻴﺮهﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪ .‬أﻣﺎ اﻟﻤﺘﺤﻮﻻت اﻟﺘﻲ ﻳـﺘﻢ ﺗﻌﺮﻳﻔﻬـﺎ ﻣـﻦ‬
‫ﻏﻴﺮ اﻋﻄﺎﺋﻬﺎ ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ ﻓﻘﻴﻤﺘﻬﺎ ﻏﻴﺮ ﻣﻌﺮوﻓﺔ وﻻ ﻳﻨﺼﺢ ﺑﺎﺳﺘﺨﺪاﻣﻬﺎ ﺣﺘﻰ ﻳﺘﻢ اﻋﻄﺎﺋﻬﺎ ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫ﺑﺼﺮاﺣﺔ ﻓﺈن هﺬا اﻟﻌﺮض اﻟﺒﺴﻴﻂ ﻟﺘﻌﺮﻳﻒ اﻟﻤﺘﺤﻮﻻت ﻏﻴﺮ آﺎﻓﻲ وﻟﻴﺲ ﻣﻦ اﻟﻤﻌﻘﻮل اﻋﻄﺎء آـﻞ اﻟﻨـﻮاﺣﻲ ﻓـﻲ ﺗﻌﺮﻳـﻒ‬
‫اﻟﻤﺘﺤﻮﻻت ﻓﻲ اﻟﺪروس اﻷوﻟﻰ ﻟﺬﻟﻚ ﺳﻮف ﻧﺘﻮﺳﻊ ﻓـﻲ ذﻟـﻚ ﻻﺣﻘـﺎ ‪ .‬ﻳﻜﻔـﻲ اﻵن أن ﺗﻌـﺮف أن آـﻞ ﻣﺘﺤـﻮل ﻟـﻪ اﻟﺨـﻮاص‬
‫اﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫إﻧﻬﺎ ﻣﻦ ﻧﻮع ﻣﺎ ‪.‬‬ ‫•‬
‫ﺗﻤﻠﻚ ﻋﻨﻮان ﻣﻌﻴﻦ ﻓﻲ اﻟﺬاآﺮة ‪.‬‬ ‫•‬
‫آﻞ ﻣﺘﺤﻮل ﻳﺠﺐ أن ﻳﻜﻮن ﻣﺘﻮاﺟﺪ ﻓﻲ اﻟﺬاآﺮة ﻓﻲ ﻋﻨﻮان ﻣﻌﻴﻦ ‪ .‬وﻳﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﺎﻟﺮﺟﻮع إﻟﻰ هﺬا اﻟﻌﻨﻮان ﻓﻲ ﺣـﺎل‬
‫وﺟﺪ اﻟﻤﺘﺤﻮل ﻓﻲ اﻟﺴﻴﺎق ‪ .‬ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل اﻋﺘﺒﺮ اﻟﺘﻌﺮﻳﻒ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪int‬‬ ‫;‪x = 25‬‬
‫ﻋﻠﻰ ﻣﺴﺘﻮى ﻓﻬﻤﻨﺎ ﻓﺈﻧﻪ ﻳﻤﻜﻦ اﻟﻘﻮل أن ﺗﻢ ﺣﺠﺰ ﻣﺴـﺎﺣﺔ ﻓـﻲ اﻟـﺬاآﺮة ﻣـﻦ أﺟـﻞ اﺳـﺘﻴﻌﺎب أرﻗـﺎم ‪ integer‬وهـﺬﻩ‬
‫اﻟﻤﺴﺎﺣﺔ ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻋﻦ ﻃﺮﻳﻖ اﻟﻤﻌﺮف ‪ . x‬ﺑﺎﻟﻨﺴـﺒﺔ إﻟـﻰ اﻟﻤﺴـﺘﻮى اﻟﻤـﻨﺨﻔﺾ ﻟﻠﺤﺎﺳـﺐ ﻓـﺈن هـﺬﻩ اﻟﻤﺴـﺎﺣﺔ‬
‫ﺗﻤﻠﻚ اﻟﻌﻨﻮان )ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل ‪ . (1234‬اﻧﻈﺮ اﻟﺸﻜﻞ ‪. 2-2‬‬
‫‪x‬‬ ‫‪25 1234‬‬
‫‪Memory‬‬
‫ﺷﻜﻞ ‪7- 2‬‬

‫‪ 2.7‬اﻟﻮاﺻﻔﺎت – ‪Qualifiers‬‬
‫اﻟﻮاﺻﻔﺎت ﻓﻲ ﻟﻐﺔ اﻟﺴﻲ‪ ++‬اﻟﺘﻲ ﺳﻮف ﻧﺸﺮﺣﻬﺎ ﻓﻲ هﺬﻩ اﻟﻔﻘﺮة هﻲ ‪:‬‬
‫‪ long‬و ‪. short‬‬ ‫•‬
‫‪ signed‬و ‪. unsigned‬‬ ‫•‬
‫‪. const‬‬ ‫•‬
‫اﻟﻮاﺻﻔﻴﻦ ‪ long‬و ‪ short‬ﻳﺴﺘﺨﺪان ﻗﺒﻞ اﻟﻨﻮع ‪ int‬ﻣﻦ أﺟﻞ اﻟﺘﻌﺪﻳﻞ ﻓـﻲ ﻃـﻮل اﻟﻤﺘﺤـﻮل ‪ .‬إن اﺳـﺘﺨﺪام ‪ long‬ﻳﻌﻄـﻲ‬
‫اﻟﻤﺘﺤﻮل أآﺒﺮ ﻣﺠﺎل ﻣﻤﻜﻦ ﻟﻸﻋﺪاد اﻟﺘﻲ ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ ‪ .‬وآﻤﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام ‪: long‬‬
‫‪long int‬‬ ‫;‪memory_address‬‬
‫ﻓﻲ ﻣﻌﻈﻢ اﻷﺟﻬﺰة اﻟﻘﺪﻳﻤﺔ آﺎﻧﺖ ال ‪ int‬ﺗﺄﺧﺬ ﻣﺎﻣﻘﺪارﻩ ‪16‬ﺑﺖ وال ‪ long‬ﻣﺎﻣﻘﺪارﻩ ‪32‬ﺑـﺖ ‪ .‬أﻣـﺎ ﺣﺎﻟﻴـﺎ ﺗﺤـﺖ اﻟﻮﻧـﺪوز‬
‫وﺑﺎﺳﺘﺨﺪام اﻷﺟﻬﺰة اﻟﺤﺪﻳﺜﺔ ﻓﺈن ال ‪ int‬وال ‪ long‬آﻼهﻤﺎ ﺗﺄﺧﺬ ﻣﺴـﺎﺣﺔ ﻣﻘـﺪارهﺎ ‪32‬ﺑـﺖ ‪ .‬أي ﻻ ﻳﻮﺟـﺪ أي اﺧـﺘﻼف ﺑـﻴﻦ‬
‫اﺳــﺘﺨﺪام ‪ int‬أو ‪ . long‬وﻟﻜــﻦ ﻣــﻦ أﺟــﻞ اﻟﺘﻮاﻓﻘﻴــﺔ ﺑــﻴﻦ اﻟﻤﺘﺮﺟﻤــﺎت اﻟﻤﺨﺘﻠﻔــﺔ ﻳﺠــﺐ أن ﺗﻌﻠــﻢ أن ‪ int‬ﺗﺘﻌﻠــﻖ ﺑﺎﻟﺤﺎﺳــﺐ‬
‫اﻟﻤﺴﺘﺨﺪم واﻟﻤﺘﺮﺟﻢ اﻟﻤﺴﺘﺨﺪم أﻣﺎ ‪ long‬ﻓﻬﻲ دوﻣﺎ ﺗﺤﺠﺰ أآﺒﺮ ﻣﺴﺎﺣﺔ ﻣﻤﻜﻨﺔ ﻣﻦ أﺟﻞ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻷﻋﺪاد وﻗـﺪ ﺗﻜـﻮن‬
‫‪64‬ﺑﺖ ﻓﻲ ﻋﻠﻰ ﻣﻌﺎﻟﺠﺎت ‪64‬ﺑﺖ اﻟﺠﺪﻳﺪة ‪.‬‬
‫أﻣﺎ اﻟﻮاﺻﻒ ‪ short‬اﻟﺬي ﻳﻮﺿﻊ ﻗﺒﻞ ‪ . int‬ﻓﻴﺪل ﻋﻠﻰ أن اﻟﻤﺘﺤﻮل ﺳـﻮف ﻳﺴـﺘﺨﺪم ﻣـﻦ أﺟـﻞ ﻣﺠـﺎل ﺻـﻐﻴﺮ ﻟﻸﻋـﺪاد ‪.‬‬
‫وﻋﻠﻰ اﻷﻏﻠﺐ ﻓﺈن ‪ short‬ﺗﻘﻮم ﺑﺤﺠﺰ ‪16‬ﺑﺖ ﻟﻠﻤﺘﺤﻮل ‪ .‬وﻳﻜﻤﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ ﺣﺎﻟﺔ أردﻧﺎ اﻟﺘﻘﻠﻴﻞ ﻣﻦ اﺳﺘﻬﻼك اﻟﺬاآﺮة ‪.‬‬
‫وﻣﺜﺎل ﻋﻠﻰ ﺗﻌﺮﻳﻒ اﻟﻤﺘﺤﻮﻻ ﺑﺎﺳﺘﺨﺪام اﻟﻮاﺻﻒ ‪: short‬‬
‫‪short int‬‬ ‫;‪day_of_week‬‬
‫ﻓﻲ اﻟﻤﺜﺎﻟﻴﻦ اﻟﺴﺎﺑﻘﻴﻦ ﻳﻤﻜﻦ ﺗﺠﺎهﻞ اﻟﻨﻮع ‪ ، int‬أي ﻳﻤﻜﻦ اﻟﺘﻌﺮﻳﻒ آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫‪long‬‬ ‫;‪memory_address‬‬
‫‪short‬‬ ‫;‪day_of_week‬‬
‫أﻳﻀﺎ اﺳﺘﺨﺪام ‪ long‬ﻗﺒﻞ ‪ double‬ﻳﻌﻄﻲ اﻟﻤﺘﺤﻮل ﻣﺠﺎل أآﺒﺮ ﻣﻦ اﻟﻤﺠﺎل اﻟﻤﺴﺘﺨﺪم ﻓﻲ ‪. double‬‬
‫إن ﺟﻤﻴﻊ ﻣﺎذآﺮﻧﺎﻩ ﻣﻦ ﻣﺘﺤﻮﻻت آﺎﻧﺖ ﻣﺘﺤﻮﻻت ﻣﺆﺷﺮة أي ﻳﻤﻜﻦ أن ﺗﺤﻤﻞ ﻗﻴﻢ ﻣﻮﺟﺒﺔ وﺳﺎﻟﺒﺔ ‪ .‬أﻣﺎ ﻓﻲ ﺣﺎﻟﺔ أردﻧﺎ‬
‫أن ﻳﻜﻮن ﻣﺠﺎل اﻷﻋﺪاد اﻟﻤﺴﺘﺨﺪﻣﺔ هﻲ ﻓﻘﻂ ﻣﻮﺟﺒﺔ ﻓﻴﺠﺐ أن ﻧﺴـﺒﻖ ‪ int‬أو ‪ char‬ﺑﺎﻟﻮاﺻـﻒ ‪ . unsigned‬هـﺬا ﻳﻌﻨـﻲ أن‬
‫اﻟﻤﺘﺤﻮل ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ﻳﻌﺘﺒﺮ ﻣﻮﺟﺐ ﻓﻘﻂ ﺿﻤﻦ اﻟﻤﺠﺎل ‪ 0‬إﻟﻰ ‪ 65535‬ﻓﻲ ﺣﺎﻟﺔ ‪ int‬ذات ‪16‬ﺑﺖ و ﻣﻦ ‪ 0‬إﻟـﻰ ‪ 255‬ﻓـﻲ‬
‫ﺣﺎﻟﺔ ‪ . char‬وآﻤﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام هﺬا اﻟﻮاﺻﻒ ‪:‬‬
‫‪unsigned int‬‬ ‫;‪natural‬‬
‫‪unsigned‬‬ ‫;‪record_number‬‬
‫‪unsigned char‬‬ ‫;‪i_am_byte‬‬
‫إن اﺳﺘﺨﺪام ‪ int‬ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ آﺎن اﺧﺘﻴـﺎري وﻳﻤﻜـﻦ ﺗﺠﺎهﻠﻬـﺎ ‪ .‬واﻟﻮاﺻـﻒ ‪ signed‬ﺗﻌﻨـﻲ أن اﻟﻤﺘﺤـﻮﻻت هـﻲ‬
‫ﻣﺆﺷﺮة وﻟﻜﻦ آﻤﺎ ذآﺮﻧﺎ ﻓﺈﻧﻪ ﺑﺸﻜﻞ اﻓﺘﺮاﺿﻲ اﻟﻤﺘﺤﻮﻻت ﺣﻴﻦ ﺣﺠﺰهﺎ ﺗﻜﻮن ﻣﺆﺷﺮة ﻓـﺈن اﺳـﺘﺨﺪام ‪ signed‬هـﻮ ﺗﺤﺼـﻴﻞ‬
‫ﺣﺎﺻﻞ ‪.‬‬
‫أﺧﻴﺮا ‪ ،‬إن اﻟﻮاﺻﻒ ‪ const‬ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻪ ﻣﻊ ﺗﻌﺮﻳﻒ أي ﻣﺘﺤﻮل وذﻟﻚ ﻟﺘﺤﺪﻳﺪ أن ﻗﻴﻤﺔ هﺬا اﻟﻤﺘﺤﻮل ﻟﻦ ﺗﺘﻐﻴـﺮ أﺑـﺪا‬
‫أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ‪ .‬ﻣﺜﻞ هﺬﻩ اﻟﻤﺘﺤـﻮﻻت ﻻ ﻳﻤﻜـﻦ اﺳـﺘﺨﺪاﻣﻬﺎ ﻋﻠـﻰ اﻟﻄـﺮف اﻷﻳﺴـﺮ ﻟﻌﻼﻣـﺔ اﻻﻟﺤـﺎق )=( أو ﻻ ﻳﻤﻜـﻦ‬
‫اﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ أي ﺷﻜﻞ ﻣﻦ اﻷﺷـﻜﺎل ﻳـﺆدي إﻟـﻰ ﺗﻐﻴﻴـﺮ ﻗﻴﻤﺘﻬـﺎ ‪ .‬اﻟﻤﺘـﺮﺟﻢ ﻓـﻲ هـﺬﻩ اﻟﺤﺎﻟـﺔ ﻳﺴـﺘﻄﻴﻊ أن ﻳﻀـﻊ هـﺬا‬
‫اﻟﻤﺘﺤﻮل ﻓﻲ ذاآﺮة ﻗﺎﺑﻠﺔ ﻟﻠﻘﺮاﺋﺔ ﻓﻘﻂ أو ﻳﻘﻮم ﺑﺎﻟﺘﻌﺪﻳﻞ ﻋﻠﻰ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﻟﺸـﻜﻞ اﻟـﺬي ﻳﺮﻳـﺪ )‪ . (Optimization‬ﻃﺒﻌـﺎ ﻓـﻲ‬
‫ﺣﺎﻟﺔ اﺳﺘﺨﺪﻣﻨﺎ اﻟﻮاﺻﻒ ‪ const‬ﻳﺠﺐ ﻋﻠﻴﻨﺎ اﻋﻄﺎء ﻗﻴﻤﺔ ﻟﻠﻤﺘﺤﻮل وﻗﺖ ﺗﻌﺮﻳﻔﻪ آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫‪const double‬‬ ‫;‪pi = 3.1415926‬‬
‫‪const int‬‬ ‫;‪student_number = 10‬‬
‫ﻣﻦ ﻏﻴﺮ أي ﻋﻤﻠﻴﺔ ﺗﻬﻴﺌﺔ ﻓﺈن هﺬا ﻳﻌﺘﺒﺮ ﺧﻄﺄ أن ﺗﻜﺘﺐ ‪:‬‬
‫‪const double‬‬ ‫;‪pi‬‬
‫هﻨﺎ ﻟﻢ ﻧﻌﻄﻲ اﻟﻤﺘﺤﻮل ‪ pi‬أي ﻗﻴﻤﺔ وﺑﻤﺎ أﻧﻪ ﻻ ﻳﻤﻜﻦ اﻋﻄﺎء ‪ pi‬أي ﻗﻴﻤﺔ أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻓﺈن ‪ pi‬ﺗﺒﻘﻰ ذات ﻗﻴﻤـﺔ‬
‫ﻏﻴﺮ ﻣﻌﺮﻓﺔ وﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن ﻣﺜﻞ هﺬا اﻟﻨﻮع ﻣﻦ اﻟﺘﻌﺮﻳﻔﺎت ﻳﻌﻄﻴﻨﺎ ﺧﻄﺄ أﺛﻨﺎء اﻟﺘﺮﺟﻤﺔ ‪.‬‬

‫ﺑﻤﺎ أﻧﻪ اﻧﺘﻬﻴﻨﺎ ﻣﻦ ذآـﺮ أﻧـﻮاع اﻟﻤﺘﺤـﻮﻻت وﺟﻤﻴـﻊ اﻟﻮاﺻـﻔﺎت ﻓـﺈن اﻟﺠـﺪول اﻟﺘـﺎﻟﻲ )ﺟـﺪول ‪ (1-2‬ﻳـﺬآﺮ ﺟﻤﻴـﻊ اﻷﻧـﻮاع‬
‫اﻷﺳﺎﺳﻴﺔ اﻟﺘﻲ ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻟﺴﻲ‪) ++‬وأﺧﺺ ﺑﺎﻟﺬآﺮ ﻓﻴﺠﻮال ﺳﻲ‪) . (++‬اﻟﺠﺪول ﻣﺄﺧﻮذ ﻣﻦ ‪. ( MSDN‬‬
‫‪Type Name‬‬ ‫‪Bytes‬‬ ‫‪Other Names‬‬ ‫‪Range of Values‬‬

‫‪int‬‬ ‫*‬ ‫‪signed,‬‬ ‫‪System dependent‬‬
‫‪signed int‬‬
‫‪unsigned int‬‬ ‫*‬ ‫‪unsigned‬‬ ‫‪System dependent‬‬
‫‪__int8‬‬ ‫‪1‬‬ ‫‪char,‬‬ ‫‪–128 to 127‬‬
‫‪signed char‬‬
‫‪__int16‬‬ ‫‪2‬‬ ‫‪short,‬‬ ‫‪–32,768 to 32,767‬‬
‫‪short int,‬‬
‫‪signed short int‬‬
‫‪__int32‬‬ ‫‪4‬‬ ‫‪signed,‬‬ ‫‪–2,147,483,648 to 2,147,483,647‬‬
‫‪signed int‬‬
‫‪__int64‬‬ ‫‪8‬‬ ‫‪none‬‬ ‫‪–9,223,372,036,854,775,808 to‬‬
‫‪9,223,372,036,854,775,807‬‬
‫‪char‬‬ ‫‪1‬‬ ‫‪signed char‬‬ ‫‪–128 to 127‬‬
‫‪unsigned char‬‬ ‫‪1‬‬ ‫‪none‬‬ ‫‪0 to 255‬‬
‫‪short‬‬ ‫‪2‬‬ ‫‪short int,‬‬ ‫‪–32,768 to 32,767‬‬
‫‪signed short int‬‬
‫‪unsigned short‬‬ ‫‪2‬‬ ‫‪unsigned short int‬‬ ‫‪0 to 65,535‬‬
‫‪long‬‬ ‫‪4‬‬ ‫‪long int,‬‬ ‫‪–2,147,483,648 to 2,147,483,647‬‬
‫‪signed long int‬‬
‫‪unsigned long‬‬ ‫‪4‬‬ ‫‪unsigned long int‬‬ ‫‪0 to 4,294,967,295‬‬
‫‪float‬‬ ‫‪4‬‬ ‫‪none‬‬ ‫)‪3.4E +/- 38 (7 digits‬‬
‫‪double‬‬ ‫‪8‬‬ ‫‪none‬‬ ‫)‪1.7E +/- 308 (15 digits‬‬
‫‪long double‬‬ ‫‪10‬‬ ‫‪none‬‬ ‫)‪1.2E +/- 4932 (19 digits‬‬
‫ﺟﺪول ‪1- 2‬‬
‫ﻓﻲ أﻧﻈﻤﺔ وﻧﺪوز ‪ 95‬وﻣﺎﺑﻌﺪهﺎ )أي اﻷﻧﻈﻤﺔ اﻟﻤﻌﺘﻤﺪة ﻋﻠﻰ ‪32‬ﺑﺖ( ﻓﺈن ‪ int‬ﺳﻮف ﺗﻜـﻮن ‪ 4‬ﺑﺎﻳﺘـﺎت أي أﻧﻬـﺎ‬ ‫½‬
‫ﻣﺜﻞ ال ‪ long‬ﺗﻤﺎﻣﺎ ‪ .‬وﻻﺣﻆ ﻓﻲ اﻟﺠﺪول اﻟﺴﺎﺑﻖ ﻓﺈن اﻷﻧﻮاع اﻟﻤﺴـﺒﻮﻗﺔ ب ﻋﻼﻣﺘـﻴﻦ )_( هـﻲ اﺿـﺎﻓﺔ ﻣـﻦ‬
‫اﻟﻔﻴﺠﻮال ﺳﻲ‪ ++‬أي أن اﺳﺘﺨﺪاﻣﻬﺎ ﻳﻌﻨﻲ أن ﺑﺮﻧﺎﻣﺠﻚ ﺳﻮف ﻳﺘﺮﺟﻢ ﻓﻘﻂ ﻓﻲ ﺑﻴﺌﺔ اﻟﻔﻴﺠـﻮال ﺳـﻲ‪. ++‬‬
‫ﻟﺬﻟﻚ ﻻ ﻳﻨﺼﺢ ﺑﺎﺳﺘﺨﺪاﻣﻬﺎ ﺑﻜﺜﺮة وﺑﺎﻟﺘﺎﻟﻲ ﻳﻔﻘﺪ ﺑﺮﻧﺎﻣﺠﻚ ﺧﺎﺻـﻴﺔ اﻟﺘﻮاﻓـﻖ ﻣـﻊ ﺑـﺎﻗﻲ اﻟﻤﺘﺮﺟﻤـﺎت ‪ .‬اﻟﺸـﺊ‬
‫اﻟﻮﺣﻴﺪ اﻟﺬي ﻗﺪ ﻳﻔﻴﺪك هﻮ ‪ __int64‬اﻟﺘﻲ ﺗﻌﻄﻴﻚ ﻣﺠﺎل ﺿﺨﻢ ﺟﺪا ﻟﻼﻋـﺪاد وﻟﻜـﻦ ﻳﺠـﺐ أن ﺗﻨﺘﺒـﻪ ﻋﻠـﻰ أن‬
‫اﺳﺘﺨﺪام ‪ __int64‬هﻮ أﺑﻄﺄ ﻣﻦ اﺳﺘﺨﺪام ‪ long‬أو ‪ int‬وﺧﺎﺻﺔ ﻓﻲ ﺣﺴﺎب اﻟﺘﻌﺎﺑﻴﺮ اﻟﺮﻳﺎﺿﻴﺔ ‪.‬‬

‫‪ 2.8‬اﻟﺘﻌﺎﺑﻴﺮ اﻟﺤﺴﺎﺑﻴﺔ – ‪Arithmetic expressions‬‬

‫إن ﻟﻐﺔ اﻟﺴﻲ‪ ++‬ﺗﺪﻋﻢ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ اﻟﻌﺎدﻳﺔ ﻣﺜﻞ اﻟﺠﻤﻊ )‪ (+‬و اﻟﻄﺮح )‪ (-‬و اﻟﻀـﺮب )*( واﻟﻘﺴـﻤﺔ )‪ (/‬وأﻳﻀـﺎ‬
‫ﺗﺪﻋﻢ ﻋﻤﻠﻴﺔ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ﻟﻸﻋﺪاد اﻟﺼﺤﻴﺤﺔ وهﻲ )‪ . (%‬اﻟﻌﻤﻠﻴﺎت اﻟﺴﺎﺑﻘﺔ آﻠﻬﺎ ﺗﻄﺒـﻖ ﻋﻠـﻰ ﺣـﺪﻳﻦ أي ‪. operands‬‬
‫اﻟﻤﻌﺎﻣﻼت اﻟﺴﺎﺑﻘﺔ ﺗﺴﻤﻰ ﺛﻨﺎﺋﻴﺔ أو ‪ binary‬ﻷﻧﻬﺎ ﺗﻄﺒﻖ ﻋﻠﻰ ﺣﺪﻳﻦ ‪ .‬ﻳﻮﺟﺪ ﻣﻌﺎﻣﻼت أﺧﺮى ﺗﻄﺒﻖ ﻋﻠﻰ ﺣﺪ واﺣﺪ وهـﻲ‬
‫ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ﻣﻌﺎﻣﻞ اﻻﺷﺎرة اﻟﺴـﺎﻟﺒﺔ )‪ (-‬وﻣﻌﺎﻣـﻞ اﻻﺷـﺎرة اﻟﻤﻮﺟﺒـﺔ )‪ ، (+‬اﻷﺧﻴﺮﺗـﺎن ﺗﺴـﻤﻰ ﻣﻌـﺎﻣﻼت أﺣﺎدﻳـﺔ أو‬
‫‪ unary‬وذﻟﻚ ﺑﺴﺒﺐ أﻧﻬﺎ ﺗﻄﺒﻖ ﻋﻠﻰ ﺣﺪ واﺣﺪ ‪ .‬وآﺄﻣﺜﻠﺔ ﻋﻠﻰ هﺬا ‪:‬‬
‫‪12 * length‬‬
‫‪-1024‬‬
‫‪3.14 * radius * radius‬‬
‫‪distance / time‬‬
‫‪money % 100‬‬
‫آﻤﺎ ﺗﻼﺣﻆ ﻓﻲ اﻟﻤﺜﺎل اﻷول ﻓﺈن اﻟﻘﻴﻤﺔ ‪ 12‬ﺿﺮﺑﺖ ﻣﻊ ﻣﺎ ﻳﺤﺘﻮي ﻋﻠﻴﻪ اﻟﻤﺘﺤﻮل ‪ . length‬أﻣﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺜﺎﻧﻲ ﻓـﺈن‬
‫ﻣﻌﺎﻣﻞ اﻻﺷﺎرة اﻟﺴﺎﻟﺒﺔ ﻗﺎم ﺑﻌﻜﺲ ﻗﻴﻤﺔ اﻟﻌﺪد ‪ 1024‬اﻟﻤﻮﺟﺒﺔ إﻟﻰ ﺳﺎﻟﺒﺔ ‪.‬‬
‫إن اﻟﺘﻌﺒﻴﺮ اﻟﺤﺴﺎﺑﻲ ﻓﻲ ﻟﻐﺔ ﺳﻲ‪ ++‬ﻳﺘﻢ ﺣﺴﺎﺑﻪ ﻋﻠﻰ ﺣﺴﺐ أوﻟﻮﻳﺔ اﻟﻌﻮاﻣﻞ اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ اﻟﺘﻌﺒﻴﺮ ‪ .‬إن أوﻟﻮﻳﺔ‬
‫اﻟﻌﻮاﻣﻞ هﻲ اﻟﺘﻲ ﺗﺤﺪد ﺗﺮﺗﻴﺐ ﺣﺴﺎب اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﺔ ﻓﻲ اﻟﺘﻌﺒﻴـﺮ ‪ .‬اﻟﺠـﺪول ‪ 2-2‬ﻳﻮﺿـﺢ اﻟﻤﻌـﺎﻣﻼ اﻟﺤﺴـﺎﺑﻴﺔ ﺣﺴـﺐ‬
‫أوﻟﻮﻳﺘﻬﺎ ‪ .‬ﻃﺒﻌﺎ اﻟﺠﺪول اﻟﻜﺎﻣﻞ ﻟﻸوﻟﻮﻳﺎت ﺳﻮف ﻳﺄﺗﻲ ﻻﺣﻘﺎ ﻓﻲ دروس ﻗﺎدﻣﺔ ‪.‬‬
‫‪Operator‬‬ ‫‪Description‬‬ ‫‪Associativity‬‬
‫‪+‬‬ ‫‪Unary plus‬‬ ‫‪Right to left‬‬
‫‪-‬‬ ‫‪Unary minus‬‬ ‫‪Right to left‬‬
‫*‬ ‫‪Multiplication‬‬ ‫‪Left to right‬‬
‫‪/‬‬ ‫‪Division‬‬ ‫‪Left to right‬‬
‫‪%‬‬ ‫‪Modules‬‬ ‫‪Left to right‬‬
‫‪+‬‬ ‫‪Addition‬‬ ‫‪Left to right‬‬
‫‪-‬‬ ‫‪Subtraction‬‬ ‫‪Left to right‬‬
‫ﺟﺪول ‪2- 2‬‬
‫ﻣﻦ اﻟﺠﺪول اﻟﺴﺎﺑﻖ ﺗﻼﺣﻆ أن ﻣﻌﺎﻣﻼت اﻻﺷـﺎرة ﻟﻬـﺎ أﻋﻠـﻰ أوﻟﻴـﺔ وﻣﻌـﺎﻣﻼت اﻟﺠﻤـﻊ واﻟﻄـﺮح ﻟﻬـﺎ أدﻧـﻰ اﻷوﻟﻮﻳـﺎت ‪.‬‬
‫واﻟﻀﺮب واﻟﻘﺴﻤﺔ وﺑﺎﻗﻲ اﻟﻘﺴـﻤﺔ هـﻲ ﻓـﻲ اﻟﻤﻨﺘﺼـﻒ ‪ .‬وﺑﺎﻟﺘـﺎﻟﻲ ﻓـﺈن أي ﺗﻌﺒﻴـﺮ ﻳﺤﺘـﻮي ﻋﻠـﻰ ﺧﻠـﻴﻂ ﻣـﻦ اﻟﻤﻌـﺎﻣﻼت‬
‫اﻟﺴﺎﺑﻘﺔ ﻓﺈن اﻟﺬي ﻳﻨﻔﺬ أوﻻ هـﻮ ﺟﻤﻴـﻊ ﻣﻌـﺎﻣﻼت اﻻﺷـﺎرة إن وﺟـﺪت وﺑﻌـﺪهﺎ ﻋﻠـﻰ اﻟﺘﺮﺗﻴـﺐ ﺣﺴـﺐ اﻟﺠـﺪول اﻟﺴـﺎﺑﻖ ‪.‬‬
‫وآﻤﺜﺎل ﻋﻠﻰ هﺬا إﻟﻴﻚ ﺑﺎﻟﺘﻌﺒﻴﺮ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪2+3*4‬‬
‫اﻟﺘﻌﺒﻴﺮ اﻟﺴﺎﺑﻖ ﻗﻴﻤﺘﻪ ﺗﺴﺎوي ‪ 14‬ﻷﻧﻪ أوﻻ ﻳﺘﻢ ﺗﻨﻔﻴﺬ ﻣﻌﺎﻣﻞ اﻟﻀﺮب ﻋﻠﻰ ‪ 3‬و ‪ 4‬اﻟﺬي ﻧﺘﻴﺠﺘﻪ ‪ 12‬وﻣﻨﻪ اﻟﺠﻤﻊ ﻋﻠـﻰ‬
‫‪ 2‬و ‪ 12‬اﻟﺬي ﻳﻨﺘﺞ ‪. 14‬‬
‫اﻟﻤﻌﺎﻣﻼت ﻓﻲ ﻧﻔﺲ اﻟﻤﺠﻤﻮﻋﺔ ﻋﻨﺪ وﺟﻮدهﺎ ﻓﻲ اﻟﺘﻌﺒﻴﺮ ﻓﺈﻧﻪ ﻳﺘﻢ ﺗﻨﻔﻴﺬهﺎ ﻋﻠـﻰ ﺣﺴـﺐ ورودهـﺎ ‪ .‬ﻓـﻲ اﻟﻤﺠﻤﻮﻋـﺔ‬
‫اﻷوﻟﻰ ﺑﺘﻢ اﻟﺘﻨﻔﻴﺬ ﻣﻦ اﻟﻴﻤﻴﻦ إﻟﻰ اﻟﻴﺴﺎر ‪ ،‬أﻣﺎ اﻟﺜﺎﻧﻴﺔ واﻟﺜﺎﻟﺜﺔ ﻓﻴﺘﻢ ﺗﻨﻔﻴـﺬهﺎ ﻣـﻦ اﻟﻴﺴـﺎر إﻟـﻰ اﻟﻴﻤـﻴﻦ ‪ .‬وآﺄﻣﺜﻠـﺔ ﻋﻠـﻰ‬
‫هﺬا‪.‬‬
‫‪-+-10‬‬ ‫)‪(right to left‬‬ ‫‪Î‬‬ ‫)))‪(-(+(-10‬‬
‫‪10 * 2 / 5 * 4‬‬ ‫)‪(left to right‬‬ ‫‪Î‬‬ ‫)‪(((10 * 2) / 5) * 4‬‬
‫‪2–3+5‬‬ ‫)‪(left to right‬‬ ‫‪Î‬‬ ‫)‪((2 – 3) + 5‬‬
‫اﻟﻤﺜﺎل اﻷول ﻻﺣﻆ أن اﻟﺘﻨﻔﻴﺬ ﻳﺘﻢ ﻣﻦ اﻟﻴﻤﻴﻦ إﻟﻰ اﻟﻴﺴﺎر وﺑﺎﻟﺘﺎﻟﻲ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﺷـﺎرة اﻟﻨـﺎﻗﺺ اﻷﻗـﺮب إﻟـﻰ اﻟﻌـﺪد أوﻻ‬
‫ﻟﺘﺮﺟﻊ اﻟﻘﻴﻤﺔ ‪ -10‬وﻣﻨﻪ اﺷﺎرة اﻟﻤﻮﺟﺐ ﻟﺘﺮﺟﻊ ‪ -10‬وأﺧﻴﺎر اﻟﺴﺎﻟﺐ ﻟﺘﺮﺟﻊ ‪ . 10‬اﻟﻤﺜﺎل اﻟﺜﺎﻧﻲ ﻳﺘﻢ ﺗﻨﻔﻴﺬ أول ﻋﻤﻠﻴﺔ ﺿـﺮب‬
‫ﻋﻠﻰ ‪ 10‬و ‪ 2‬ﻟﺘﺮﺟﻊ ‪ 20‬وﺑﻌﺪهﺎ اﻟﻘﺴﻤﺔ ﻋﻠﻰ ‪ 20‬و ‪ 5‬ﻟﺘﺮﺟﻊ ‪ 4‬وﺑﻌﺪهﺎ اﻟﻀﺮب ﻋﻠﻰ ‪ 4‬و ‪ 4‬ﻟﺘﺮﺟﻊ ‪ . 16‬اﻟﻤﺜﺎل اﻷﺧﻴـﺮ ﻳـﺘﻢ‬
‫ﺗﻨﻔﻴﺬ أول ﻋﻤﻠﻴﺔ ﻃﺮح ﻟﺘﺮﺟﻊ ‪ -1‬وﺑﻌﺪهﺎ اﻟﺠﻤﻊ ﻋﻠﻰ ‪ -1‬و ‪ 5‬ﻟﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ ‪ . 4‬وأﺿﻊ أﻳﻀﺎ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪2+3*4+5‬‬
‫هﻨﺎ ﻳﺘﻢ أوﻻ ﺣﺴﺎب ﻣﻌﺎﻣﻞ اﻟﻀﺮب ﻷن ﻟﻪ أوﻟﻮﻳﺔ أﻋﻠﻰ ﻣـﻦ اﻟﺠﻤـﻊ ‪ .‬وﺑﺎﻟﺘـﺎﻟﻲ اﻟﺘﻌﺒﻴـﺮ ﻳﺼـﺒﺢ ‪ 2 + 12 + 5‬اﻵن ﻳـﺘﻢ‬
‫ﺣﺴﺎب اﻟﺠﻤﻊ ﻣﻦ اﻟﻴﺴﺎر إﻟﻰ اﻟﻴﻤﻴﻦ ﺑﺪأ ﻣﻦ ‪ 2‬و ‪ 12‬ﻟﻴﺼﺒﺢ اﻟﺘﻌﺒﻴﺮ ‪ 14 + 5‬وأﺧﻴﺮا ﺗﻜﻮن ﻧﺘﻴﺠﺔ اﻟﺘﻌﺒﻴﺮ ‪. 19‬‬

‫ﺑﺎﻟﻨﺴﺒﺔ إﻟﻰ ﻋﻤﻠﻴﺔ اﻟﻘﺴﻤﺔ )‪ (/‬ﻓﺈن وﻇﻴﻔﺘﻬﺎ هـﻲ اﻟﻘﺴـﻤﺔ ﻃﺒﻌـﺎ وﻟﻜـﻦ ﻳﺠـﺐ اﻻﻧﺘﺒـﺎﻩ أﻧـﻪ ﻋﻨـﺪ ﻗﺴـﻤﺔ ﻋـﺪدﻳﻦ‬
‫ﺻﺤﻴﺤﻴﻦ ‪ integer‬ﻓﺈن اﻟﺠﻮاب ﻳﻜﻮن ﻋﺪد ﺻﺤﻴﺢ ‪ .‬أﻣﺎ ﻓﻲ ﺣﺎﻟﺔ آـﺎن أﺣـﺪ اﻟﺤـﺪﻳﻦ ﻋﻠـﻰ اﻷﻗـﻞ ﻋـﺪد ﺣﻘﻴﻘـﻲ ‪ float‬ﻓـﺈن‬
‫اﻟﺠﻮاب ﻳﻜﻮن ﻋﺪد ﺣﻘﻴﻘﻲ ‪ .‬وإﻟﻴﻚ ﺑﺎﻷﻣﺜﻠﺔ اﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪2‬‬ ‫ﺗﺴﺎوي‬ ‫‪13 / 5‬‬
‫‪2.6‬‬ ‫ﺗﺴﺎوي‬ ‫‪13.0 / 5‬‬
‫‪2.6‬‬ ‫ﺗﺴﺎوي‬ ‫‪13 / 5.0‬‬
‫ﻳﻌﻨﻲ ﻓﻲ ﺣﺎﻟﺔ اﻟﻘﺴﻤﺔ اﻟﺼﺤﻴﺤﺔ ﻓﺈن اﻟﻌﺪد اﻟﻨﺎﺗﺞ هﻮ اﻟﻘﺴﻢ اﻟﺼﺤﻴﺢ ﻣـﻦ اﻟﻌـﺪد وﻳـﺰال ﻣﺎﺑﻌـﺪ اﻟﻔﺎﺻـﻠﺔ ‪ .‬وآﻤﺜـﺎل‬
‫ﻋﻠﻰ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ﻟﺪﻳﻨﺎ ‪:‬‬
‫‪3‬‬ ‫ﺗﺴﺎوي‬ ‫‪13 % 5‬‬
‫‪0‬‬ ‫ﺗﺴﺎوي‬ ‫‪15 % 5‬‬
‫‪-3‬‬ ‫ﺗﺴﺎوي‬ ‫‪-13 % 5‬‬
‫‪3‬‬ ‫ﺗﺴﻮاي‬ ‫‪13 % -5‬‬
‫ﻓﻲ ﺣﺎﻟﺔ أﺣﺪ اﻟﺤﺪﻳﻦ آﺎن ﺳﺎﻟﺒﺎ ﻓﺈن اﺷﺎرة ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ﺗﻜﻮن ﻣﺸﺎﺑﻬﺔ ﻷﺷﺎرة اﻟﻤﻘﺴﻮم ﻋﻠﻴﻪ آﻤـﺎ ﻓـﻲ اﻟﻤﺜـﺎل‬
‫اﻟﺴﺎﺑﻖ ‪ .‬وﺣﺘﻰ ﻧﻜﻮن دﻗﻴﻘﻴﻦ أآﺜﺮ ﻓﺈن ﻋﻤﻠﻴﺔ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ داﺋﻤﺎ ﺗﺴﺎوي إﻟﻰ اﻟﺘﻌﺒﻴﺮ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪a%b‬‬ ‫==‬ ‫‪a – (a / b) * b‬‬
‫ﺣﻴﺚ ‪ a‬و ‪ b‬هﻲ أﻋﺪاد ﺻﺤﻴﺤﺔ وﻗﻴﻤﺔ ‪ b‬ﻻﺗﺴﺎوي اﻟﺼﻔﺮ ‪ ،‬أي أن اﻟﻘﺴﻤﺔ اﻟﻤﺴﺘﺨﺪﻣﺔ هﻲ ﻗﺴﻤﺔ ﺻﺤﻴﺤﺔ ‪.‬‬
‫ﻗﻤﺖ ﺑﺎﻻﺳﺘﻔﺎﺿﺔ ﻓﻲ اﻟﺸﺮح ﻋﻠﻰ هﺬﻩ اﻟﻤﻌﺎﻣﻼت اﻟﺴﻬﻠﺔ ﻷﻧﻪ ﻓﻲ اﻟﺴﻲ‪ ++‬وآﻤـﺎ ﺳـﻮف ﻧـﺮى ﻻﺣﻘـﺎ‬ ‫½‬
‫ﻓﻲ ﻗﺴﻢ اﻟﺒﺮﻣﺠﺔ ﻏﺮﺿﻴﺔ اﻟﺘﻮﺟﻪ ‪ Object Oriented Programming‬أﻧﻪ ﻳﻤﻜﻦ اﻋﺎدة ﺑﺮﻣﺠـﺔ اﻟﻌﻮاﻣـﻞ ﻣـﻦ‬
‫أﺟﻞ اﻋﻄﺎﺋﻬﺎ ﺧﻮاص ﺟﺪﻳﺪة ‪.‬‬
‫‪ 2.9‬اﻟﺘﺤﻮﻳﻞ ﺑﻴﻦ اﻷﻧﻮاع – ‪Type conversions‬‬

‫ﻓﻲ هﺬا اﻟﻘﺴﻢ ﺳﻮف ﻧﺤﺎول اﻻﺟﺎﺑﺔ ﻋﻠﻰ اﻟﺴﺆال اﻟﺘﺎﻟﻲ ‪ :‬ﻣﺎذا ﻳﺤﺪث إذا أردﻧﺎ ﺗﻨﻔﻴـﺬ ﺗﻌﺒﻴـﺮ ﺣﺴـﺎﺑﻲ ﻳﺘﺮآـﺐ ﻣـﻦ‬
‫ﺣﺪود ذات أﻧﻮاع ﻣﺨﺘﻠﻔﺔ ؟‬
‫ﻓﻲ اﻟﺒﺪﻳﺔ ﻳﺤﺐ أن أﻧﻮﻩ ﻋﻠﻰ أن ﻣﻌﻈﻢ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ ﺗﺘﻢ ﻋﻠﻰ ﻧﻮع ‪ int‬وذﻟﻚ ﺑﺴﺐ أن ‪ int‬داﺋﻤﺎ ﺗﻜﻮن ﺑﺤﺠـﻢ‬
‫ﻣﺴﺠﻞ اﻟﻤﻌﺎﻟﺞ اﻟﺪاﺧﻠﻲ وﺑﺎﻟﺘﺎﻟﻲ ﺗﻜﻮن اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ ﻋﻠﻴﻬﺎ أﺳﺮع ﻣﺎﻳﻤﻜﻦ ‪ .‬ﻋﻠﻲ ﺳﺒﻴﻞ اﻟﻤﺜﺎل اﻷرﻗﺎم اﻟﺜﺎﺑﺘـﺔ أو‬
‫اﻟﻤﺤﺎرف ﻳﺘﻢ ﺗﺤﻮﻳﻠﻬﺎ إﻟﻰ ‪ int‬ﻗﺒﻞ اﻟﻘﻴﺎم ﺑﺎﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ ﻋﻠﻴﻬﺎ وذﻟﻚ ﻓﻲ ﺣﺎﻟﺔ آﺎﻧـﺔ ال ‪ int‬ﻳﻤﻜـﻦ أن ﺗﺤـﻮي اﻟـﺮﻗﻢ‬
‫وإﻻ ﻳﺘﻢ اﺳﺘﺨﺪام ‪ . unsigned int‬ﻃﺒﻌﺎ هﺬا ﻓﻲ ﺣﺎﻟﺔ ﻟﻢ ﻧﻘـﻢ ﺑﺎﺟﺒـﺎر اﻟﺜﺎﺑـﺖ أو اﻟـﺮﻗﻢ ﻋﻠـﻰ أن ﻳﻜـﻮن ‪ long‬وذﻟـﻚ ﺑـﺬآﺮ‬
‫اﻟﻼﺣﻘﺔ ‪ L‬ﺑﻌﺪ اﻟﺮﻗﻢ وﻋﻨﺪهﺎ ﻳﺠﺐ أن ﻧﻘﻮم ﺑﺘﺤﻮﻳﻼت أﺧﺮى ﻋﻠﻰ اﻷرﻗﺎم أو اﻟﻤﺘﺤﻮﻻت ﻓﻲ اﻟﺘﻌﺒﻴﺮ ‪.‬‬
‫اﻟﻘﺎﻋﺪة هﻨﺎ ﺑﺸﻜﻞ ﻋﺎم أﻧﻪ ﻳﺘﻢ ﺗﺤﻮﻳﻞ اﻟﺤﺪود ﻣﻦ اﻷﻧﻮاع اﻟﺼـﻐﻴﺮة إﻟـﻰ اﻷﻧـﻮاع اﻟﻜﺒﻴـﺮة ‪ .‬وﻳـﺘﻢ هـﺬا ﻋﻠـﻰ ﺣﺴـﺐ‬
‫اﻟﺘﺮﺗﻴﺐ اﻟﺘﺎﻟﻲ ‪:‬‬
‫إذا آﺎن أﺣﺪ اﻟﺤﺪﻳﻦ ‪ ، long double‬ﻳﺘﻢ ﺗﺤﻮﻳﻞ اﻵﺧﺮ إﻟﻰ ‪. long double‬‬ ‫•‬
‫إذا آﺎن أﺣﺪ اﻟﺤﺪﻳﻦ ‪ ، double‬ﻳﺘﻢ ﺗﺤﻮﻳﻞ اﻵﺧﺮ إﻟﻰ ‪. double‬‬ ‫•‬
‫إذا آﺎن أﺣﺪ اﻟﺤﺪﻳﻦ ‪ ، float‬ﻳﺘﻢ ﺗﺤﻮﻳﻞ اﻵﺧﺮ إﻟﻰ ‪. float‬‬ ‫•‬
‫ﻧﻄﺒﻖ ﻋﻤﻠﻴﺔ ﺗﺤﻮﻳﻞ ال‪ int‬اﻟﺴﺎﺑﻘﺔ ‪.‬‬ ‫•‬
‫إذا آﺎن أﺣﺪ اﻟﺤـﺪﻳﻦ ‪ ، unsigned long int‬ﻳـﺘﻢ ﺗﺤﻮﻳـﻞ اﻵﺧـﺮ إﻟـﻰ ‪ . unsigned long int‬أﻣـﺎ إذا آـﺎن أﺣـﺪ‬ ‫•‬
‫اﻟﺤـﺪود ‪ ، long int‬واﻵﺧـﺮ ‪ unsigned int‬وآﺎﻧـﺔ ال ‪ long int‬ﻳﻤﻜـﻦ أن ﺗﺤـﻮي ﺟﻤﻴـﻊ اﻟﻘـﻴﻢ اﻟﻤﻤﻜﻨـﺔ ﻓـﻲ‬
‫‪ unsigned int‬ﻓﺈﻧﻪ ﻳﺘﻢ ﺗﺤﻮﻳﻞ اﻷﺧﻴﺮة إﻟﻰ ‪ long int‬؛ وإﻻ ﻳﺘﻢ ﺗﺤﻮﻳﻞ اﻻﺛﻨﻴﻦ إﻟﻰ ‪. unsigned long int‬‬
‫إذا آﺎن أﺣﺪ اﻟﺤﺪﻳﻦ ‪ ، long int‬ﻳﺘﻢ ﺗﺤﻮﻳﻞ اﻵﺧﺮ إﻟﻰ ‪. long int‬‬ ‫•‬
‫إذا آﺎن أﺣﺪ اﻟﺤﺪﻳﻦ ‪ ، unsigned int‬ﻳﺘﻢ ﺗﺤﻮﻳﻞ اﻵﺧﺮ إﻟﻰ ‪. unsigned int‬‬ ‫•‬
‫اﻟﻌﻤﻠﻴﺔ ﺗﺒﺪو ﻣﻌﻘﺪة ﻋﻨﺪ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻷﻋﺪاد اﻟﻐﻴﺮ ﻣﺆﺷﺮة أو ‪ . unsigned‬ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل اﻋﺘﺒﺮ اﻟﺘﺼﺮﻳﺢ اﻟﺘﺎﻟﻲ‪:‬‬
‫;‪unsigned int ui = 10‬‬
‫;‪int si = -7‬‬
‫واﻋﺘﺒﺮ اﻟﺘﻌﺒﻴﺮ اﻟﺘﺎﻟﻲ ‪ . ui + si :‬ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻟﻘﻮاﻋﺪ اﻟﺴﺎﺑﻘﺔ ﻓﺈن اﻟﺤﺪ اﻟﺜﺎﻧﻲ ﺳﻮف ﻳﺤـﻮل إﻟـﻰ ‪unsigned‬‬
‫‪ . int‬ﻋﻠﻰ ﻓﺮض أن ‪ int‬هﻨﺎ هﻲ ‪16‬ﺑﺖ ‪ .‬ﻓـﺈن ﻣﺠـﺎل اﻟﻘـﻴﻢ اﻟﻤﻤﻜـﻦ ﺗﻤﺜﻴﻠﻬـﺎ ﺑﺎﺳـﺘﺨﺪام ‪ unsigned int‬هـﻮ ﻣـﻦ ‪ 0‬إﻟـﻰ‬
‫‪ . 65535‬اﻟﻘﻴﻤﺔ ‪ -7‬ﺑﺎﻟﻨﻈـﺎم اﻟﺴـﺖ ﻋﺸـﺮي ﺗﺴـﺎوي ‪ 0xFFF9‬وﺑﺎﻟﺘـﺎﻟﻲ إذا اﻋﺘﺒﺮﻧـﺎ اﻟﻘﻴﻤـﺔ اﻟﺴـﺎﺑﻘﺔ آﻌـﺪد ﻏﻴـﺮ ﻣﺆﺷـﺮ‬

‫)‪ (unsigned int‬ﻓﺈﻧﻨــﺎ ﻧﺤﺼــﻞ ﻋﻠــﻰ اﻟﻘﻴﻤــﺔ ‪ . 65529‬وإذا ﺟﻤﻌﻨﺎهــﺎ ﻣــﻊ اﻟﻘﻴﻤــﺔ ‪ 10‬ﻧﺤﺼــﻞ ﻋﻠــﻰ ‪ 65539‬أو ‪0x10003‬‬
‫ﺑﺎﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي وﺑﺎﻟﺘﺎﻟﻲ ﻳﻜﻮن اﻟﺠﻮاب ‪ 3‬ﻷﻧﻨﺎ ﻧﺘﻌﺎﻣﻞ ﻣﻊ أﻋﺪاد ‪16‬ﺑﺖ ‪.‬‬
‫ﻓﻲ اﻷﻧﻈﻤﺔ اﻟﺤﺪﻳﺜﺔ ﻧﺠﺪ أن ‪ int‬هﻮ ‪32‬ﺑﺖ وأﻳﻀﺎ ‪ long‬هـﻮ ‪32‬ﺑـﺖ ‪ .‬ﻓﻌﻤﻠﻴـﺔ اﻟﺘﺤﻮﻳـﻞ ﺗﺼـﺒﺢ أﺳـﻬﻞ ‪ .‬وأﻳﻀـﺎ ﺗﺠﻨـﺐ‬
‫اﺳﺘﺨﺪام اﻷﻋﺪاد اﻟﻐﻴﺮ ﻣﺆﺷﺮة ﻗﺪر اﻟﻤﺴﺘﻄﺎع وآﻦ ﺣﺬرا ﻓﻲ ﺣﺎﻟﺔ ﺗﻢ اﺳﺘﺨﺪاﻣﻬﺎ ‪.‬‬
‫‪ 2.10‬ﻣﻌﺎﻣﻞ اﻻﻟﺤﺎق – ‪The assignment operator‬‬

‫ﻣﻌﺎﻣﻞ اﻻﻟﺤﺎق ﻳﺴﻤﺢ ﺑﺎﻟﺤﺎق ﻗﻴﻤﺔ ﺗﻌﺒﻴﺮ ﻣﺎ إﻟﻰ ﻣﺘﺤﻮل ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪ .‬وأﺑﺴﻂ ﺻﻴﻐﺔ إﻟﻰ ﻣﻌﺎﻣﻞ اﻻﻟﺤﺎق هﻲ ‪:‬‬
‫;‪variable = expression‬‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﻋﻤﻠﻴﺔ اﻻﻟﺤﺎق ﻓﺈﻧﻪ ﻳﺘﻢ أوﻻ ﺣﺴﺎب ﻗﻴﻤﺔ اﻟﺘﻌﺒﻴﺮ وﺑﻌﺪهﺎ ﻳﺘﻢ اﻋﻄـﺎء اﻟﻤﺘﺤـﻮل اﻟﻘﻴﻤـﺔ اﻟﺠﺪﻳـﺪة ﻟﻠﺘﻌﺒﻴـﺮ ‪.‬‬
‫أﻳﻀﺎ ﻳﺘﻢ ﺗﺤﻮﻳﻞ ﻧﻮع اﻟﻘﻴﻤﺔ ﺣﺘﻰ ﺗﻮاﻓﻖ ﻧﻮع اﻟﻤﺘﺤﻮل ‪ .‬إن ﻣﻌﺎﻣﻞ اﻻﻟﺤﺎق ﻣﺜﻠﻪ ﻣﺜﻞ ﺑﺎﻗﻲ اﻟﻤﻌـﺎﻣﻼت ﻟـﻪ أوﻟﻮﻳـﺔ وﺗﺮﺗﻴـﺐ‬
‫ﻓﻲ اﻟﺤﺴﺎب ‪ ،‬ﻃﺒﻌﺎ أوﻟﻮﻳﺘﻪ هﻲ أﺻﻐﺮ ﻣﺎﻳﻤﻜﻦ وﻳﺘﻢ ﺣﺴﺎﺑﻪ ﻣﻦ اﻟﻴﻤﻴﻦ إﻟﻰ اﻟﻴﺴﺎر آﻤﺎ ﻓـﻲ ﻣﻌﺎﻣـﻞ اﻻﺷـﺎرة اﻟﺴـﺎﻟﺒﺔ‬
‫واﻟﻤﻮﺟﺒﺔ ‪ .‬أوﻟﻴﺘﻪ ﺻﻐﺮى هﺬا ﻳﻀﻤﻦ ﺗﻨﻔﻴﺬ اﻟﺘﻌﺒﻴﺮ ﻗﺒﻞ ﻋﻤﻠﻴﺔ اﻻﻟﺤﺎق ‪.‬‬
‫وآﻤﺎ أن اﻟﺘﻌﺒﻴﺮ ‪ a + b‬ﻳﺮﺟﻊ ﻗﻴﻤﺔ ﺟﺪﻳﺪة ﻓﺄﻳﻀﺎ اﻟﺘﻌﺒﻴﺮ ‪ a = b‬ﻳﺮﺟﻊ ﻗﻴﻤﺔ ﺟﺪﻳـﺪة وذﻟـﻚ ﺑﻌـﺪ ﺣﺴـﺎب ﻗﻴﻤـﺔ اﻟﺘﻌﺒﻴـﺮ‬
‫واﺳﻨﺎدهﺎ إﻟﻰ اﻟﻤﺘﺤﻮل ‪ ،‬هﺬﻩ اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﻳﺮﺟﻌﻬﺎ ﺗﻌﺒﻴﺮ اﻻﻟﺤﺎق ﺗﺴﺎوي ﻗﻴﻤﺔ اﻟﻤﺘﺤﻮل ﺑﻌﺪ اﻻﺳـﻨﺎد ‪ .‬هـﺬا ﻣﻔﻴـﺪ ﺟـﺪا‬
‫ﻓﻲ ﺑﻨﺎء ﺳﻠﺴﻠﺔ اﻻﺳﻨﺎدات ﻣﺜﻞ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪variable1 = variable2 = variable3 = … variablek = expression‬‬
‫آﻤﺎ ذآﺮﻧﺎ ﻓﺈن ﺗﻨﻔﻴﺬ ﻣﻌﺎﻣﻞ اﻻﻟﺤﺎق ﻳﺘﻢ ﻣﻦ اﻟﻴﻤﻴﻦ إﻟﻰ اﻟﻴﺴﺎر ﻓﺈﻧﻪ أوﻻ ﻳﺘﻢ اﺳﻨﺎد ﻗﻴﻤﺔ اﻟﺘﻌﺒﻴـﺮ ‪ expression‬إﻟـﻰ‬
‫اﻟﻤﺘﺤﻮل ‪ variablek‬وﺑﻌﺪهﺎ ﻗﻴﻤﺔ هﺬا اﻟﻤﺘﺤـﻮل ﺗﺴـﻨﺪ إﻟـﻰ )‪ variable(k-1‬وهﻜـﺬا ﺣﺘـﻰ ﻳـﺘﻢ اﺳـﻨﺎدهﺎ إﻟـﻰ ‪variable2‬‬
‫وﻣﻨﻪ إﻟﻰ ‪ .variable1‬وﻣﻨﻪ ﻓﺈن اﻟﺘﻌﺒﻴﺮ اﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪X = y = z = p + q‬‬
‫ﻳﺘﻢ ﺗﻔﺴﻴﺮﻩ ﻋﻠﻰ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫;))‪x = (y = (z = p + q‬‬
‫آﻤﺎ ذآﺮﻧﺎ ﻓﺈن ﻋﻤﻠﻴﺔ اﻟﺘﺤﻮﻳﻞ ﺗﺘﻢ ﻋﺒﺮ ﻣﻌﺎﻣﻞ اﻻﻟﺤﺎق ﻓﻤﺜﻼ إذا أردﻧﺎ اﻟﺤﺎق ﻣﺎهﻮ ﻣﻦ ﻧﻮع ‪ int‬إﻟـﻰ ‪ double‬ﻓﺴـﻮف‬
‫ﻳﺘﻢ ﺗﺤﻮﻳﻞ ال ‪ int‬إﻟﻰ ال ‪ double‬أﻣﺎ اﻟﻌﻜﺲ أي ﻣﻦ ‪ double‬إﻟﻰ ‪ int‬ﻓﻄﺒﻌﺎ هـﺬﻩ اﻟﻌﻤﻠﻴـﺔ ﻧﺴـﻤﻴﻬﺎ ﻋﻤﻠﻴـﺔ ﻣـﺪﻣﺮة ﻷن‬
‫اﻟﺮﻗﻢ ﺳﻮف ﻳﻘﺮب إﻟﻰ أﻗﺮب ﻋﺪد ﺻﺤﻴﺢ وﻗﺪ ﻳﻔﻘﺪ ﻣﻦ ﻗﻴﻤﺘﻪ ‪ .‬ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل اﻧﻈﺮ ﻣﺎذا ﺳـﻮف ﻳﺤـﺪث ﻓـﻲ اﻟﺘﻌـﺎﺑﻴﺮ‬
‫اﻟﺘﺎﻟﻲ ‪:‬‬
‫ﺗﺘﻢ ﻣﻦ ﻏﻴﺮ ﺗﺤﻮﻳﻞ‬ ‫‪int = int‬‬
‫ﻗﺺ اﻟﻘﻴﻤﺔ ﻣﻊ اﻟﺘﻘﺮﻳﺐ‬ ‫‪float = double‬‬
‫ﻗﺺ اﻟﻘﻴﻤﺔ إذا آﺎﻧﺖ ‪ int‬هﻲ ‪16‬ﺑﺖ‬ ‫‪int = long‬‬
‫ﻗﺺ اﻟﻘﻴﻤﺔ دوﻣﺎ ‪.‬‬ ‫‪char = int‬‬
‫أﻳﻀﺎ ﻳﺠﺐ اﻟﺤﺮص ﻋﻨﺪﻣﺎ ﻳﺘﻢ اﺳﺘﺨﺪام ﺳﻠﺴﻠﺔ اﻻﻟﺤﺎﻗﺎت ﻣﻊ أﻧﻮاع ﻣﺨﺘﻠﻔﺔ ﻣﻦ اﻟﻤﺘﺤﻮﻻت ‪ .‬إذا آﺎﻧـﺖ ‪ iii‬هـﻲ ﻣـﻦ‬
‫ﻧﻮع ‪ int‬ﻓﺈن اﻟﺘﻌﺒﻴﺮ اﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪iii = 12.34‬‬
‫ﻳﻀﻊ وﻳﺮﺟﻊ اﻟﻘﻴﻤﺔ ‪ 12‬وﺑﺎﻟﺘﺎﻟﻲ ﻓﻔﻲ اﻟﺘﻌﺒﻴﺮ اﻟﺘﺎﻟﻲ ﺣﻴﺚ ‪ fff‬هﻲ ﻣﻦ ﻧﻮع ‪. float‬‬
‫;‪fff = iii = 12.34‬‬
‫ﻓﺈن اﻟﻘﻴﻤﺔ ‪ 12‬ﻣﻦ ﻧﻮع ‪ int‬ﺳﻮف ﺗﺤﻮل إﻟﻰ ‪ float‬أي اﻟﻘﻴﻤﺔ ‪ 12.0‬ﺳﻮف ﻳﺘﻢ اﺳﻨﺎدهﺎ إﻟﻰ اﻟﻤﺘﺤﻮل ‪. fff‬‬

‫‪ 2.11‬ﻣﻌﺎﻣﻼت اﻻﻟﺤﺎق اﻟﻤﺮآﺒﺔ – ‪The compound assignment operator‬‬

‫إن ﻋﻤﻠﻴﺔ اﻻﻟﺤﺎق ﻣﻦ اﻟﺸﻜﻞ‬
‫‪count = count + 2‬‬
‫ﺗﺘﻜﺮر ﺑﺸﻜﻞ آﺒﻴﺮ ﻓﻲ ﺑﺮاﻣﺠﻨﺎ وهﻲ ﺗﻌﻨﻲ أﻧﻪ ﻳـﺘﻢ اﺿـﺎﻓﺔ ﻣﺎﻣﻘـﺪارﻩ ‪ 2‬إﻟـﻰ اﻟﻤﺘﺤـﻮل ‪ count‬وﺑﻌـﺪهﺎ وﺿـﻊ اﻟﻘﻴﻤـﺔ‬
‫اﻟﺠﺪﻳﺪة ﻓﻲ اﻟﻤﺘﺤﻮل ‪ . count‬أي ﺑﻜﻠﻤﺔ أﺧﺮى ﻳـﺘﻢ اﺿـﺎﻓﺔ اﺛﻨـﺎن إﻟـﻰ اﻟﻤﺘﺤـﻮل ‪ . count‬ﻣﺜـﻞ اﻻﻟﺤـﺎق اﻟﺴـﺎﺑﻖ ﻳﻤﻜـﻦ‬
‫آﺘﺎﺑﺘﻪ ﻓﻲ اﻟﺴﻲ‪ ++‬ﺑﺎﻟﺼﻴﻐﺔ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪count += 2‬‬
‫ﻓﻲ اﻟﻮاﻗﻊ ﻓﺈن ﻳﻤﻜﻦ ﺗﻄﺒﻴﻖ ﻧﻔﺲ اﻷﻣﺮ ﻋﻠﻰ ﺑﺎﻗﻲ اﻟﻤﻌﺎﻣﻼت اﻟﺤﺴﺎﺑﻴﺔ اﻷرﺑﻌﺔ وﺑﺎﻟﺘﺎﻟﻲ ﻳﻤﻜﻦ أن ﻧﻜﺘﺐ ﻣﺎﻳﻠﻲ ‪:‬‬
‫‪count += 2‬‬
‫‪count -= 1‬‬
‫‪power *= 2.71828‬‬
‫‪divisor /= 10.0‬‬
‫‪remainder %= 10‬‬
‫ﻓﻲ آﻞ اﻟﺤﺎﻻت اﻟﺴﺎﺑﻘﺔ اﻟﺤﺪﻳﻦ ﻋﻠﻰ ﻃﺮﻓﻴﻦ اﻟﻤﻌﺎﻣﻞ ﻳﻤﻜﻦ أن ﻳﻜﻮﻧﺎ ﻣﻦ أي ﻧﻮع ﻣﺎﻋﺪا ﻓﻲ اﻟﺤﺎﻟـﺔ اﻷﺧﻴـﺮة ﺣﻴـﺚ‬
‫آﻤﺎ ﻧﻌﺮف ﻓﺈن ﻣﻌﺎﻣﻞ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ﻳﺤﺘﺎج إﻟﻰ ﻧﻮع ﺻﺤﻴﺢ ﻋﻠﻰ ﻃﺮﻓﻴﻪ ‪ .‬أﻳﻀﺎ ﻓﺈن اﻷوﻟﻴﺔ وﻃﺮﻳﻘﺔ اﻟﺘﻨﻔﻴﺬ هﻲ ﺗﻤﺎﻣﺎ ﻣﺜﺎ‬
‫ﻣﻌﺎﻣﻞ اﻻﻟﺤﺎق اﻟﺬي ﺷﺮﺣﻨﺎﻩ ﻓﻲ اﻟﻔﻘﺮة اﻟﺴﺎﺑﻘﺔ ‪.‬‬
‫أﻳﻀﺎ ﻳﺠﺐ أن ﻧﻨﺘﺒﻪ إﻟﻰ أن ‪:‬‬
‫‪variable op= expression‬‬
‫ﺗﻔﺴﺮ آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫)‪Variable = variable op (expression‬‬
‫وﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪ sum /= 3 + 7:‬ﻳﺘﻢ ﺣﺴﺎﺑﻪ آﺎﻟﺘﺎﻟﻲ ‪. sum = sum / (3 + 7) :‬‬
‫أﻳﻀﺎ ﻳﻤﻜﻦ اﺳﺘﺨﺪام ﺳﻠﺴﻠﺔ اﻻﻟﺤﺎﻗﺎت هﻨﺎ أﻳﻀﺎ وﻟﻜﻦ ﻣﺮة أﺧﺮى ﻣﻊ اﻟﺤﺬر ﻓﻲ ﺑﻌﺾ اﻟﺤﺎﻻت ﻻﺣﻆ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫‪fff = iii *= fff‬‬
‫إذا آﺎﻧﺖ ‪ fff‬ﻣﻦ ﻧﻮع ‪ float‬وﺗﺤﺘﻮي ﻋﻠـﻰ اﻟﻘﻴﻤـﺔ ‪ 1.234‬واﻟﻤﺘﺤـﻮل ‪ iii‬ﻣـﻦ ﻧـﻮع ‪ int‬وﻳﺤﺘـﻮي ﻋﻠـﻰ اﻟﻘﻴﻤـﺔ ‪ 12‬ﻓـﺈن‬
‫اﻟﺘﻌﺒﻴﺮ اﻟﺴﺎﺑﻖ ﻳﺘﻢ ﺣﺴﺎﺑﻪ آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫)‪fff = (iii = iii * fff‬‬
‫وﺑﺎﻟﺘﺎﻟﻲ ‪ iii‬ﺳﻮف ﻳﺘﻢ اﺳﻨﺎد اﻟﻘﻴﻤﺔ )‪ 14 (12 * 1.234 = 14.808‬ﺑﻌﺪ ازاﻟﺔ اﻟﻘﺴﻢ ﺑﻌﺪ اﻟﻔﺎﺻﻠﺔ ‪.‬وﺑﻌﺪهﺎ ﻳﺘﻢ اﺳﻨﺎد‬
‫اﻟﻘﻴﻤﺔ ‪ 14.0‬ﻟﻠﻤﺘﺤﻮل ‪. fff‬‬
‫‪ 2.12‬ﻣﻌﺎﻣﻼ اﻟﺰﻳﺎدة واﻟﻨﻘﺼﺎن – ‪The increment and decrement operators‬‬

‫ﻓﻲ اﻟﻘﺴﻢ اﻟﺴﺎﺑﻖ ﺷﺮﺣﻨﺎ ﻣﻌﺎﻣﻞ اﻻﺳﻨﺎد اﻟﻤﺮآﺐ ‪ .‬وﻳﻤﻜـﻦ أن ﻧﺴـﺘﺨﺪم ﻣﻌﺎﻣـﻞ اﻻﺳـﻨﺎد اﻟﻤﺮآـﺐ آﺎﻟﺘـﺎﻟﻲ ﻣـﻦ‬
‫أﺟﻞ اﺿﺎﻓﺔ اﻟﻘﻴﻤﺔ ‪ 1‬إﻟﻰ اﻟﻤﺘﺤﻮل ‪:‬‬
‫‪x += 1‬‬
‫ﻓﻲ اﻟﺤﻘﻴﻘﺔ ﻓﺈن اﻟﺰﻳﺎدة ﺑﻤﻘﺪار واﺣﺪ هﻲ ﻣﻦ اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺗﻤﺮ ﻋﻠﻴﻨﺎ آﺜﺮة ﻓﻲ ﺑﺮاﻣﺠﻨـﺎ ﻓـﻼ ﻳﺨﻠـﻮ ﺑﺮﻧـﺎﻣﺞ ﻣﻨﻬـﺎ ‪.‬‬
‫وأﻳﻀﺎ هﻲ ﻣﻦ اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﻳﺘﻢ ﺗﻨﻔﻴﺬهﺎ ﺑﺴﺮﻋﺔ ﻷﻧﻬﺎ ﺗﻜﺎﻓﺊ إﻟﻰ ﺗﻌﻠﻴﻤﺔ واﺣﺪﻩ ﻋﻠﻰ اﻷﻏﻠﺐ ﻟﻠﻤﻌﺎﻟﺞ ‪ .‬هﺬﻩ اﻟﻌﻤﻠﻴـﺔ‬
‫ﺗﺴﻤﻰ ﺑﻤﻌﺎﻣﻞ اﻻﺿـﺎﻓﺔ اﻟﺒﻌﺪﻳـﺔ أو ‪ postincrement operator‬و ﻣﻌﺎﻣـﻞ اﻻﺿـﺎﻓﺔ اﻟﻘﺒﻠﻴـﺔ أو ‪. preincrement operator‬‬
‫اﻟﺜﺎﻧﻴﺔ ﻟﻬﺎ اﻟﺼﻴﻐﺔ ‪:‬‬
‫‪++ variable‬‬
‫أﻣﺎ اﻟﺘﻌﺒﻴﺮ ذو اﻻﺿﺎﻓﺔ اﻟﺒﻌﺪﻳﺔ ﻓﻬﻮ ﻋﻠﻰ اﻟﺼﻴﻐﺔ ‪:‬‬
‫‪variable ++‬‬

‫ﻓﻲ آﻼ اﻟﺤﺎﻟﺘﻴﻦ اﻟﺴﺎﺑﻘﺘﻴﻦ ﻓﺈﻧﻪ ﻳﺘﻢ اﻟﺰﻳﺎدة ﺑﻤﻘﺪار واﺣﺪ إﻟﻰ اﻟﻤﺘﺤﻮل ‪ . variable‬وأﻳﻀـﺎ آـﻼ اﻟﺤـﺎﻟﺘﻴﻦ اﻟﺴـﺎﺑﻘﺘﻴﻦ‬
‫ﻓﺈﻧﻬــﺎ ﻳﺮﺟﻌــﺎ ﻗﻴﻤــﺔ ‪ .‬ﻓــﻲ اﻷوﻟــﻰ )‪ (preincrement‬ﻓﺈﻧــﻪ ﻳــﺘﻢ ارﺟــﺎع اﻟﻘﻴﻤــﺔ اﻟﺠﺪﻳــﺪة ﺑﻌــﺪ اﻟﺰﻳــﺎدة ‪ .‬أﻣــﺎ اﻟﺜﺎﻧﻴــﺔ‬
‫)‪ (postincrement‬ﻓﺈﻧﻪ ﻳﺘﻢ ارﺟﺎع ﻗﻴﻤﺔ اﻟﻤﺘﺤﻮل ﻗﺒﻞ اﻟﺰﻳﺎدة ‪ .‬ﻟﻮ اﻋﺘﺒﺮﻧﺎ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪sum += ++count‬‬
‫ﻓﺈن اﻟﻤﺘﺤﻮل ‪ count‬ﺳﻮف ﻳﺰاد ﺑﻘﻴﻤﺔ ‪ 1‬وﻣﻦ ﺛﻢ ﻳﺘﻢ اﺳـﺘﺨﺪام اﻟﻘﻴﻤـﺔ اﻟﺠﺪﻳـﺪة ﻓـﻲ اﻟﺘﻌﺒﻴـﺮ أي ﻳـﺘﻢ اﺿـﺎﻓﺘﻬﺎ ﻣـﻊ‬
‫‪ sum‬وﺗﺨﺰﻳﻦ اﻟﻨﺘﻴﺠﺔ ﻓﻲ ‪ . sum‬وﻟﻮ اﻋﺘﺒﺮﻧﺎ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪sum += count++‬‬
‫ﻳﺘﻢ اﺿﺎﻓﺔ ﻗﻴﻤﺔ اﻟﻤﺘﺤﻮل ‪ count‬أﻳﻀﺎ ﺑﻤﻘﺪار ‪ 1‬وﻟﻜﻦ ﻳﺘﻢ اﺳـﺘﺨﺪام اﻟﻘﻴﻤـﺔ اﻟﺴـﺎﺑﻘﺔ ل‪ count‬ﻓـﻲ اﻟﺘﻌﺒﻴـﺮ ‪ .‬ﻋﻠـﻰ‬
‫ﺳﺒﻴﻞ اﻟﻤﺜﺎل إذا آﺎﻧﺖ ﻗﻴﻤﺔ ‪ sum‬و ‪ count‬هﻲ ‪ 10‬و ‪ 20‬ﻋﻠﻰ اﻟﺘﺮﺗﻴﺐ ﻓﺈن ‪ count‬ﺳـﻮف ﺗﺼـﺒﺢ ‪ 21‬وﻳـﺘﻢ ﺟﻤـﻊ اﻟﻘﻴﻤـﺔ‬
‫‪) 20‬اﻟﻘﺪﻳﻤﺔ( ﻣﻊ ‪ 10‬ﻣﻦ أﺟﻞ أن ﻧﺤﺼﻞ ﻋﻠﻰ ‪ 30‬وﺗﺨﺰﻳﻨﻬﺎ ﻓﻲ ‪. sum‬‬
‫ﻓﻲ ﺣﺎﻟﺔ اﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ اﻻﻧﻘﺎص ﻓﺎﺳﺘﺨﺪاﻣﻪ ﺗﻤﺎﻣﺎ ﻣﺜﻞ ﻣﻌﺎﻣﻞ اﻟﺰﻳﺎدة وﻟﻜﻦ ﻳﺘﻢ هﻨـﺎ اﺳـﺘﺨﺪام )‪ (--‬ﻋﻮﺿـﺎ ﻋـﻦ‬
‫)‪ (++‬وﻳﺘﻢ اﻻﻧﻘﺎص ﺑﻤﻘﺪار ‪. 1‬‬
‫‪-- variable‬‬
‫‪variable --‬‬
‫ﺑﺎﻟﻨﺴﺒﺔ إﻟﻰ أوﻟﻮﻳﺔ وآﻴﻔﻴـﺔ ﺗﻨﻔﻴـﺬ هـﺬﻳﻦ اﻟﻤﻌـﺎﻣﻠﻴﻦ ﻓﺴـﻮف ﺗﺠـﺪهﻞ ﻓـﻲ ﺟـﺪول ﻓـﻲ ﺁﺧـﺮ اﻟـﺪرس ﻳﺠﻤـﻊ ﺟﻤﻴـﻊ‬
‫اﻟﻤﻌﺎﻣﻼت اﻟﺘﻲ ﺗﻢ ﺷﺮﺣﻬﺎ ﻓﻲ هﺬا اﻟﺪرس ‪.‬‬
‫‪ 2.13‬ﻣﻌﺎﻣﻞ اﻟﺘﺤﻮﻳﻞ – ‪The type cast operator‬‬

‫ﺟﻤﻴﻊ اﻟﻤﻌﺎﻣﻼت اﻟﺴﺎﺑﻘﺔ آﺎﻧﺔ ﻋﺒﺎرة ﻋﻦ رﻣﻮز ‪ ،‬أﻣﺎ هﻨﺎ ﻓﺎﻷﻣﺮ ﻣﺨﺘﻠﻒ ‪ ،‬ﻓﺎﻟﻤﻌﺎﻣﻞ هﻨﺎ ﻟﻴﺲ ﺛﺎﺑـﺖ وهـﻮ ﻋﺒـﺎرة ﻋـﻦ‬
‫آﻠﻤﺔ ‪ .‬ﺗﺤﺪﺛﻨﺎ ﺳﺎﺑﻘﺎ ﻋﻦ ﻋﻤﻠﻴﺔ اﻟﺘﺤﻮﻳﻞ اﻟﻀﻤﻨﻴﺔ اﻟﺘﻲ ﺗﺘﻢ ﻓﻲ اﻟﺘﻌﺎﺑﻴﺮ اﻟﺤﺴﺎﺑﻴﺔ وﺧـﻼل ﻣﻌﺎﻣـﻞ اﻻﺳـﻨﺎد ‪ .‬أﻣـﺎ ﻋﻤﻠﻴـﺔ‬
‫اﻟﺘﺤﻮﻳﻞ اﻟﺘﻲ ﻧﻘﻮم ﺑﻬﺎ ﻧﺤﻦ ﻓﺘﺴـﻤﻰ ‪ . cast‬إن اﻟﻄﺮﻳﻘـﺔ اﻟﻘﻴﺎﺳـﻴﺔ ﻓـﻲ ﻋﻤﻠﻴـﺔ ﺗﺤﻮﻳـﻞ ﻧـﻮع إﻟـﻰ ﺁﺧـﺮ هـﻮ ﻋـﻦ ﻃﺮﻳـﻖ‬
‫اﺳﺘﺨﺪام اﺳﻢ اﻟﻨﻮع اﻟﺬي ﻧﺮﻳﺪ اﻟﺘﺤﻮﻳﻞ إﻟﻴﻪ وﻣﻨﻪ ﻧﺬآﺮ اﺳﻢ اﻟﺘﺎﺑﻊ أو اﻟﻘﻴﻤﺔ ﺑﻴﻦ ﻗﻮﺳﻴﻦ آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫)‪double(date‬‬
‫هﻨﺎ إذا آﺎن اﻟﻤﺘﺤﻮل ‪ date‬ﻣﻦ ﻧﻮع ‪ int‬ﻓﻴﺘﻢ ﺗﺤﻮﻳﻠﻪ إﻟﻰ ‪ . double‬إن ﻣﻌﺎﻣﻞ اﻟﺘﺤﻮﻳـﻞ ﺗﻤﺎﻣـﺎ ﻣﺜـﻞ ﺑـﺎﻗﻲ اﻟﻤﻌـﺎﻣﻼت‬
‫أي ﻟﻪ أوﻟﻮﻳﺔ وآﻴﻔﻴﺔ ﻓﻲ اﻟﺘﻨﻔﻴﺬ وهﺬا ﻣﺎﺳﻮف ﺗﺮاﻩ ﻓﻲ ﺁﺧﺮ اﻟﺪرس ‪.‬‬
‫اﻟﻄﺮﻳﻘﺔ اﻟﺴﺎﺑﻘﺔ ﻓﻲ آﺘﺎﺑﺔ ﻧﻮع اﻟﺘﺤﻮﻳﻞ هﻲ ﺗﺸﺎﺑﻪ ﻃﺮﻳﻘﺔ اﺳﺘﺪﻋﺎء اﻟﺘﻮاﺑﻊ آﻤﺎ ﺳﻮف ﻧﺮى ﻓﻲ دروس ﻻﺣﻘﺔ ‪ .‬أﻣﺎ‬
‫اﻟﻄﺮﻳﻘﺔ اﻷﺧﺮى ﻓﻲ آﺘﺎﺑﺔ اﻟﺘﺤﻮﻳﻞ هﻲ اﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪(type-specifier) expression‬‬
‫أي ﻳﺘﻢ آﺘﺎﺑﺔ اﻟﻨﻮع داﺧﻞ أﻗﻮاس ﺛﻢ ﻳﻠﻴﻬﺎ اﻟﺘﻌﺒﻴﺮ اﻟﻤﺮاد ﺗﺤﻮﻳﻠﻪ ‪ .‬هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻣﺄﺧﻮذة ﻣﻦ ﻟﻐﺔ اﻟﺴﻲ وﻣﺎزال ﻳﻤﻜﻦ‬
‫اﺳﺘﺨﺪاﻣﻬﺎ هﻨﺎ ﻣﻦ أﺟﻞ اﻟﺘﻮاﻓﻘﻴﺔ ‪ .‬وآﺄﻣﺜﻠﺔ ﻋﻠﻰ هﺬﻩ ﻟﺪﻳﻨﺎ ‪:‬‬
‫‪(double) date‬‬
‫‪(char) x‬‬
‫‪(int) d1 + d2‬‬
‫)‪(int) (d1 + d2‬‬
‫ﻓﻲ اﻟﻤﺜﺎل ﻗﺒﻞ اﻷﺧﻴﺮ ﺳﻮف ﻳﺘﻢ ﺗﺤﻮﻳﻞ ‪ d1‬وﺟﻤﻊ اﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة ﻣﻊ ‪ . d2‬أﻧﺎ ﻓﻲ اﻟﻤﺜﺎل اﻷﺧﻴﺮ ﻓﺴﻮف ﻳـﺘﻢ ﺟﻤـﻊ‬
‫‪ d1‬و ‪ d2‬وﻣﻦ ﺛﻢ اﻟﻘﻴﺎم ﺑﻌﻤﻠﻴﺔ اﻟﺘﺤﻮﻳﻞ ‪ .‬هﺬا ﺑﺴﺒﺐ أن ﻣﻌﺎﻣﻼت اﻟﺘﺤﻮﻳﻞ ﻟﻬﺎ أوﻟﻮﻳﺔ أﻋﻠﻰ ﻣـﻦ اﻟﺠﻤـﻊ وهـﺬا ﻣـﺎ ﺳـﻮف‬
‫ﺗﺮاﻩ ﻓﻲ ﺟﺪول اﻷوﻟﻮﻳﺎت ﻓﻲ ﺁﺧﺮ اﻟﺪرس ‪.‬‬

‫‪ 2.14‬ﻣﻌﺎﻣﻞ اﻟﻔﺎﺻﻠﺔ – ‪The comma operator‬‬

‫ﺁﺧﺮ اﻟﻤﻌﺎﻣﻼت اﻟﺘﻲ ﺳﻮف ﻧﺸﺮﺣﻬﺎ ﻓﻲ هﺬا اﻟﺪرس هﻮ ﻣﻌﺎﻣـﻞ اﻟﻔﺎﺻـﻠﺔ اﻟﺘـﻲ ﺗﺠـﺪ ﻟﻬـﺎ اﺳـﺘﺨﺪاﻣﺎت ﻓـﻲ ﺷـﺘﻰ‬
‫اﻟﺘﻄﺒﻴﻘﺎت ‪ .‬ﺳﻮف أﻗﻮم ﺑﺸﺮح ﺳﺮﻳﻊ ﻋﻠﻴﻬﺎ ﻋﻠﻰ أن ﻳﺄﺗﻲ ﻣﺰﻳﺪ ﻣﻦ اﻟﺸﺮح واﻟﺘﻄﺒﻴﻘﺎت ﻋﻠﻴﻬﺎ ﻻﺣﻘﺎ ﻓـﻲ دروس أﺧـﺮى ‪.‬‬
‫إن ﻣﻌﺎﻣﻞ اﻟﻔﺎﺻﻠﺔ ﻳﺘﻜﻮن ﻣﻦ ﺗﻌﺒﻴﺮﻳﻦ ﻳﻔﺼﻞ ﺑﻴﻨﻬﺎ ﻓﺎﺻﻠﺔ آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫‪expression1 , expression2‬‬
‫ﺑﻴﻦ آﻞ اﻟﻤﻌﺎﻣﻼت اﻟﺴﺎﺑﻘﺔ ﻓﺈن ﻣﻌﺎﻣﻞ اﻟﻔﺎﺻﻠﺔ ﻟﺪﻳﻪ اﻷوﻟﻮﻳﺔ اﻟﺪﻧﻴﺎ ﺣﺘﻰ أﻗﻞ ﻣﻦ ﻣﻌﺎﻣﻞ اﻻﺳﻨﺎد وﻳﺘﻢ ﺗﻨﻔﻴﺬهﺎ ﻣـﻦ‬
‫اﻟﻴﺴﺎر إﻟﻰ اﻟﻴﻤﻴﻦ ‪ .‬وﺑﺎﻟﺘﺎﻟﻲ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻓﺈن ‪ expression1‬ﻳﺘﻢ ﺣﺴﺎﺑﻬﺎ ﺑﺸﻜﻞ آﺎﻣﻞ وﻣـﻦ ﺛـﻢ ‪. expression2‬‬
‫إن ﻗﻴﻤﺔ اﻟﺘﻌﺒﻴﺮ اﻟﺴﺎﺑﻖ ﺗﻌﺘﺒﺮ هﻲ ﻗﻴﻤﺔ اﻟﺘﻌﺒﻴﺮ اﻟﺜﺎﻧﻲ أي ‪ . expression2‬ﻣﺜﺎل ﻋﻠﻰ هﺬا ‪:‬‬
‫) ‪s = ( t = 2, t + 3‬‬
‫أوﻻ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻟﺘﻌﺒﻴـﺮ ‪ t = 2‬وﺑﻌـﺪهﺎ اﻟﺘﻌﺒﻴـﺮ ‪ t + 3‬اﻟـﺬي ﺗﻜـﻮن ﻧﺘﻴﺠﺘـﻪ ‪ 5‬وﻧﺘﻴﺠـﺔ ﺗﻌﺒﻴـﺮ اﻟﻔﺎﺻـﻠﺔ اﻟﺴـﺎﺑﻖ ﻳﻜـﻮن ‪5‬‬
‫وﺑﺎﻟﺘﺎﻟﻲ ﻳﺘﻢ اﺳﻨﺎد ‪ 5‬إﻟﻰ اﻟﻤﺘﺤﻮل ‪ . s‬ﻃﺒﻌﺎ ﻻﺣﻆ أهﻤﻴﺔ اﻷﻗﻮاس ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ وإﻻ ﻻﺣﻆ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪s = t = 2, t + 3‬‬
‫هﻨﺎ ﻳﺘﻢ اﺳﻨﺎد اﻟﻘﻴﻤﺔ ‪ 2‬إﻟﻰ آﻼ اﻟﻤﺘﺤﻮﻟﻴﻦ ‪ s‬و ‪ t‬وﻣﻦ ﺛﻢ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻟﺘﻌﺒﻴـﺮ ‪ t+3‬اﻟـﺬي ﺗﻜـﻮن ﻗﻴﻤﺘـﻪ ‪ 5‬وﻟﻜـﻦ هـﺬﻩ‬
‫اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﺗﻜﻮن ﻗﻴﻤﺔ ﻣﻌﺎﻣﻞ اﻟﻔﺎﺻﻠﺔ ﻳﺘﻢ ﺗﺪﻣﻴﺮهﺎ ﻷﻧﻬﺎ ﻏﻴﺮ ﻣﺴﺘﺨﺪﻣﺔ ‪.‬‬
‫أوﻟﻮﻳﺎت اﻟﻤﻌﺎﻣﻼت اﻟﻤﺬآﻮرة ﻓﻲ هﺬا اﻟﺪرس ‪:‬‬

‫)اﻟﺠﺪول اﻟﺘﺎﻟﻲ ﻣﺄﺧﻮذ ﻣﻦ ‪(MSDN‬‬
‫‪Symbol‬‬ ‫‪Name or Meaning‬‬ ‫‪Associativity‬‬
‫‪Highest Precedence‬‬
‫‪++‬‬ ‫‪Post-increment‬‬ ‫‪Left to right‬‬
‫‪--‬‬ ‫‪Post-decrement‬‬
‫‪++‬‬ ‫‪Pre-increment‬‬ ‫‪Right to left‬‬
‫‪--‬‬ ‫‪Pre-decrement‬‬
‫‪-‬‬ ‫‪Unary minus‬‬ ‫‪Right to left‬‬
‫‪+‬‬ ‫‪Unary plus‬‬
‫)‪(type‬‬ ‫]‪Type cast [for example, (float) i‬‬ ‫‪Right to left‬‬
‫*‬ ‫‪Multiply‬‬ ‫‪Left to right‬‬
‫‪/‬‬ ‫‪Divide‬‬
‫‪%‬‬ ‫‪Remainder‬‬
‫‪+‬‬ ‫‪Add‬‬ ‫‪Left to right‬‬
‫‪-‬‬ ‫‪Subtract‬‬
‫=‬ ‫‪Assignment‬‬ ‫‪Right to left‬‬
‫=‪*=, /=, %=, +=, -‬‬ ‫‪Compound assignment‬‬ ‫‪Right to left‬‬
‫‪,‬‬ ‫‪Comma‬‬ ‫‪Left to right‬‬
‫‪Lowest Precedence‬‬

‫اﻟﺪرس اﻟﺜﺎﻟﺚ – ﻣﺒﺎدئ اﻻدﺧﺎل واﻻﺧﺮاج‬ ‫ﻃﺮﻳﻖ اﻟﺒﺮﻣﺠﺔ ﻓﻲ ﺳﻲ‪++‬‬
‫ﻣﺒﺎدئ اﻻدﺧﺎل واﻻﺧﺮاج – ‪Simple Input and Output‬‬
‫ﻣﻦ أهﻢ اﻷﻣﻮر ﻓﻲ اﻟﺒﺮاﻣﺞ اﻟﺤﻘﻴﻘﺔ هﻲ أن ﻳﺴﺘﻄﻴﻊ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻮﺳﻂ اﻟﻤﺤﻴﻂ ﺑﻪ ‪ .‬ﻓﻲ هﺬا اﻟﺪرس ﺳﻮف‬
‫أﻗﺪم ﻗﺴﻢ ﺻـﻐﻴﺮ ﻣـﻦ ﻣﻜﺘﺒـﺔ ﺳـﻲ‪ ++‬اﻟﻘﻴﺎﺳـﻴﺔ ﻓـﻲ اﻻدﺧـﺎل واﻻﺧـﺮاج ‪ .‬ﻟـﻦ أﻗـﻮم ﺑﺸـﺮح آـﻞ اﻟﺘﻌﻠﻴﻤـﺎت واﻟﻌﻤﻠﻴـﺎت‬
‫اﻟﻤﻮﺟﻮدة ﻓﻲ هﺬﻩ اﻟﻤﻜﺘﺒﺔ وﺳﻮف أﺗﺮك هﺬا إﻟﻰ دروس ﻻﺣﻘﺔ ‪ .‬اﻵن ﺳﻮف أﻗﻮم ﺑﺸﺮح اﻟﻌﻤﻠﻴـﺎت اﻟﻼزﻣـﺔ ﻟﻠﺘﻌﺎﻣـﻞ ﻣـﻊ‬
‫ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ واﻟﺸﺎﺷﺔ ﻓﻘﻂ ‪ .‬هﺬا ﺳﻮف ﻳﻌﻄﻴﻨﺎ ﺧﻄﻮة أوﻟﻴﺔ ﻓﻲ ﺑﻨﺎء ﺑﺮﻣﺠﻴﺎت ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻷﺟﻬـﺰة اﻟﻄﺮﻓﻴـﺔ اﻟﺴـﺎﺑﻘﺔ‪.‬‬
‫ﻓﻲ دروس ﻗﺎدﻣﺔ ﺑﺎذن اﷲ ﺳﻮف ﻧﻜﻤـﻞ ﻋﻤﻠﻴـﺎت اﻻدﺧـﺎل واﻻﺧـﺮاج ﺣﺘـﻰ ﺗﻀـﻢ اﻟﺘﻌﺎﻣـﻞ ﻣـﻊ اﻟﻤﻠﻔـﺎت ﻋﻠـﻰ اﻟﻘـﺮص أو‬
‫اﻟﻌﻤﻠﻴﺎت ﻋﻠﻰ اﻟﺴﻼﺳﻞ ‪.‬‬
‫‪ 3.1‬اﻟﻮﺻﻮل إﻟﻰ ﻣﻜﺘﺒﺔ ﺳﻲ‪ ++‬اﻟﻘﻴﺎﺳﻴﺔ – ‪Access to the standard C++ library‬‬
‫ﻓﻲ أي ﺑﺮﻧﺎﻣﺞ ﺳﻲ‪ ++‬ﻳـﺘﻢ ﺗﻨﻔﻴـﺬﻩ ﻓـﺈن أرﺑـﻊ ﻣﺘﺤـﻮﻻت ﻳـﺘﻢ ﺣﺠﺰهـﺎ هـﺬﻩ اﻟﻤﺘﺤـﻮﻻت هـﻲ ﻋﺒـﺎرة ﻋـﻦ ﻣﺴـﺎرات‬
‫)‪ (streams‬ﻟﻠﻤﻌﻠﻮﻣﺎت ﻣﻦ وإﻟﻰ اﻷﺟﻬﺰة اﻟﻄﺮﻓﻴﺔ ‪ .‬اﺛﻨﺎن ﻣﻦ هﺬﻩ اﻟﻤﺴـﺎرات ﻳﺴـﻤﻴﺎن ب ‪ standard input‬و ‪standard‬‬
‫‪ . output‬ﻟﻤﺎذا ﺳﻤﻴﻨﺎ اﻟﻤﺘﺤﻮﻻت اﻟﺴﺎﺑﻘﺔ ﻣﺴﺎرات هﺬا ﺑﺴﺒﺐ أﻧﻬﺎ ﺗﻤﺜﻞ آﻤﺴﺎر ﻟﻠﺒﻴﺎﻧﺎت ﺑﻴﻦ اﻟﺒﺮﻧﺎﻣﺞ وﻣﺼﺪر اﻟﺒﻴﺎﻧـﺎت‬
‫أو وﺟﻬﺘﻬﺎ ‪ .‬اﻟﻤﺼﺪر أو اﻟﻮﺟﻬﺔ ﻗﺪ ﺗﻜﻮﻧﺎ أﺣﺪ اﻟﻤﻠﻔﺎت أو ﺣﺘﻰ اﻟﺬاآﺮة ‪ .‬وﻳﻤﻜﻦ أﻳﻀﺎ ﺗﺤﻮﻳﻞ هﺬا اﻟﻤﺴﺎر ﻓﻲ أي وﻗﺖ آـﺎن‬
‫ﻣﻦ ﻣﺼﺪر إﻟﻰ ﺁﺧﺮ أو ﻣﻦ وﺟﻬﺔ إﻟﻰ أﺧﺮى ‪ .‬اﻻﻓﺘﺮاﺿﻲ ﻓﻲ اﻟﺴﻲ‪ ++‬أن ﻳﻜﻮﻧﺎ اﻟﻤﺴﺎرﻳﻦ اﻻﻓﺘﺮاﺿﻴﻴﻦ هﻤﺎ ﻣﻦ اﻟﻜﻴﺒﻮرد‬
‫)‪ (standard input‬أو إﻟــﻰ اﻟﺸﺎﺷــﺔ )‪ . (standard output‬وﻟﻜــﻦ ﻋﻠــﻰ ﺣﺴــﺐ ﺿــﻮء اﻟﺒﺮﻧــﺎﻣﺞ ﻓــﻴﻤﻜﻦ ﺗﺤﻮﻳــﻞ هــﺬﻩ‬
‫اﻟﻤﺴﺎرات ﻷن ﻳﻜﻮن اﻟﺪﺧﻞ اﻻﻓﺘﺮاﺿﻲ ﻣﻦ ﻣﻠﻒ ﻣﻌﻴﻦ ؛ وهﺬا ﻣﺎ ﻧﻼﺣﻈﻪ إذا ﻓﻜﺮﻧﺎ ﻓﻲ ﺑﺮﻣﺠﺔ ﻣﺘﺮﺟﻢ ﻓﺎﻟﺒﺪﻳﻬﻲ أن ﻳﻜـﻮن‬
‫ﻣﺴﺎر اﻟﺪﺧﻞ اﻻﻓﺘﺮاﺿﻲ ﻣﻦ اﻟﻤﻠﻒ ﺑﺪﻻ ﻣﻦ اﻟﻜﻴﺒﻮرد ‪.‬‬
‫ﺟﻤﻴﻊ ﻣﻠﻔﺎت ﺑﺮاﻣﺠﻚ اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻣﻜﺘﺒﺔ اﻟﺪﺧﻞ واﻟﺨﺮج ﻳﺠﺐ أن ﺗﺤﺘﻮي ﻋﻠﻰ هﺬا اﻟﺴﻄﺮ ﻓﻲ ﺑﺪاﻳﺔ اﻟﻤﻠﻒ ‪:‬‬
‫ﺳــﻮف ﻧﻘــﻮم ﺑﺸــﺮح ﻋﺒــﺎرة ‪ #include‬ﻓــﻲ اﻟــﺪرس اﻟﻘــﺎدم ‪ .‬اﻵن أرﻳــﺪك أن ﺗﺘﻘﺒــﻞ أن ﻣﻠــﻒ اﻟﺘﻌﺮﻳــﻒ ‪iostream.h‬‬
‫)‪ (header file‬ﻳﺤﺘﻮي ﻋﻠﻰ ﻣﻌﻠﻮﻣﺎت وﺗﻌﺮﻳﻔﺎت ﺿﺮورﻳﺔ ﻣﻦ أﺟﻞ اﺳﺘﺨﺪام ﻣﻜﺘﺒﺔ اﻟﺪﺧﻞ واﻟﺨﺮج وهﻮ اﻟﺬي ﻳﻘـﻮم ﺑﺘﻌﺮﻳـﻒ‬
‫اﻟﻤﺴـﺎرات اﻟﺘـﻲ ﺗﺤــﺪﺛﻨﺎ ﻋﻨﻬـﺎ ﺳــﺎﺑﻘﺎ ‪ .‬هـﺬا اﻟﻤﻌﻠﻮﻣــﺎت ﺟﻤﻴﻌﻬـﺎ ﺳـﻮف ﺗﻀــﻤﻦ ﻓـﻲ اﻟﻤﻠــﻒ اﻟﺤـﺎﻟﻲ ﻷﻧﻨــﺎ آﺘﺒﻨـﺎ ﻋﺒــﺎرة‬
‫‪ #include‬ﻓﻲ أﻋﻠﻰ اﻟﻤﻠﻒ ‪.‬‬
‫‪ 3.2‬اﻻﺧﺮاج ﻏﻴﺮ اﻟﻤﻨﺴﻖ – ‪Unformatted output‬‬

‫ﻋﻤﻠﻴﺎت اﻻﺧﺮاج ﺗﺘﻢ ﻋﻦ ﻃﺮﻳﻖ اﻟﻤﻌﺎﻣﻞ << وهﻲ ﺗﺪﻋﻰ ﺑﻤﻌﺎﻣﻞ اﻻﺿـﺎﻓﺔ أو ‪ . insertion operator‬اﺳـﻤﻪ ﻣﻌﺎﻣـﻞ‬
‫اﻻﺿﺎﻓﺔ ﻷﻧﻪ ﻳﺴﺘﺨﺪم ﻓﻲ اﺿﺎﻓﺔ اﻟﺒﻴﺎﻧﺎت إﻟﻰ ال ‪ stream‬أو اﻟﻤﺴﺎر اﻟﺬي ﻳﺆدي ﻓﻲ اﻟﻨﻬﺎﻳـﺔ إﻟـﻰ ﻇﻬـﻮر اﻟﺒﻴﺎﻧـﺎت ﻋﻠـﻰ‬
‫اﻟﺸﺎﺷﺔ ﺑﺸﻜﻞ اﻓﺘﺮاﺿﻲ ‪ .‬ﺑﺎﺳﺘﺨﺪام اﻟﻤﺘﺤﻮل ‪ cout‬اﻟﺬي هﻮ )‪ (standard output‬اﻟﻤﻌﺮف ﻓﻲ ‪ iostream.h‬و اﻟﻤﻌﺎﻣﻞ‬
‫اﻟﺴﺎﺑﻖ ﻳﻤﻜﻦ ﺗﺤﻮﻳﻞ اﻟﺒﻴﺎﻧﺎت إﻟﻰ اﻟﺸﺎﺷﺔ ﺑﺸﻜﻞ اﻓﺘﺮاﺿﻲ أو إﻟﻰ أي ‪ stream‬ﺁﺧﺮ ‪ ،‬آﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪cout << x‬‬
‫إن ﻣﻌﺎﻣﻞ اﻻﺿﺎﻓﺔ ﺗﻤﺎﻣﺎ ﻣﺜﻞ ﺑﻘﻴﺔ ﻣﻌﺎﻣﻼت اﻟﺴﻲ‪ ++‬ﻟﻪ أوﻟﻮﻳﺔ وﺗﻜﻮن دﻧﻴﺎ وﻳﺘﻢ ﺗﻨﻔﻴﺬ أو ﺗﺠﻤﻴﻊ اﻟﺘﻌﺒﻴﺮ ﻣﻦ اﻟﻴﺴـﺎر‬
‫إﻟﻰ اﻟﻴﻤﻴﻦ‪ .‬وﺑﺎﻟﺘﺎﻟﻲ ﺑﻤﺎ أن أوﻟﻮﻳﺘﻪ دﻧﻴﺎ ﻓﺈن اﻟﻌﺒﺎرة اﻟﺘﺎﻟﻴﺔ ﺳﻮف ﺗﻨﻔﺬ اﻟﻤﻄﻠﻮب ﺑﺎﺧﺮاج ﻧﺎﺗﺞ ﺟﻤﻊ اﻟﻤﺘﺤﻮﻟﻴﻦ ‪ x‬و ‪: y‬‬
‫;‪cout << x + y‬‬
‫إن ﻣﻌﺎﻣﻞ اﻻﺿﺎﻓﺔ << ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻪ أآﺜﺮ ﻣﻦ ﻣﺮة ﺗﻤﺎﻣﺎ آﻤﺎ ﻓﻲ ﺳﻠﺴـﻠﺔ اﻻﺳـﻨﺎدات ﻷن هـﺬا اﻟﻤﻌﺎﻣـﻞ ﻳﺮﺟـﻊ‬
‫ﻗﻴﻤﺔ ﺗﺸﻴﺮ إﻟﻰ ﻣﺴﺎر اﻟﺨﺮج اﻟﻤﺴﺘﺨﺪم ‪ .‬وﺑﻤﺎ أن ﺗﺠﻤﻴﻊ أو ﻃﺮﻳﻘﺔ ﺗﻨﻔﻴﺬ اﻟﺘﻌﺒﻴﺮ ﺗـﺘﻢ ﻣـﻦ اﻟﻴﺴـﺎر إﻟـﻰ اﻟﻴﻤـﻴﻦ ﻓـﻴﻤﻜﻦ‬
‫اﺳﺘﺨﺪاﻣﻪ ﻓﻲ ﻋﻤﻠﻴﺔ اﺧﺮاج أﻧﻮاع ﻣﺨﺘﻠﻔﺔ ﻣﻦ اﻟﺒﻴﺎﻧﺎت إﻟﻰ اﻟﺸﺎﺷﺔ آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪cout << “The sum of “ << x << “ and “ << y << “ is “ << x + y‬‬
‫أوﻻ ﻳﺘﻢ اﺧﺮاج اﻟﺠﻤﻠﺔ “ ‪ “The sum of‬إﻟـﻰ ال ‪ stream‬وﻧﺘﻴﺠـﺔ اﻟﻤﻌﺎﻣـﻞ هـﻲ ﻋﺒـﺎرة ﻋـﻦ ﻣﺆﺷـﺮ إﻟـﻰ ال ‪stream‬‬
‫اﻟﻤﺴﺘﺨﺪم هﻨﺎ وهﻮ ‪ . cout‬هﺬﻩ اﻷﺧﻴﺮة ﺳﻮف ﺗﺴﺘﺨﺪم ﻣﺮة أﺧﺮى ﻣﻦ أﺟﻞ اﺧﺮاج اﻟﻤﺘﺤﻮل ‪ x‬وهﻜﺬا ‪..‬‬

‫‪ 3.3‬اﻻدﺧﺎل ﻏﻴﺮ اﻟﻤﻨﺴﻖ – ‪Unformatted input‬‬

‫ﻋﻤﻠﻴﺎت اﻻدﺧﺎل ﺗﺘﻢ ﻋﻦ ﻃﺮﻳـﻖ اﻟﻤﻌﺎﻣـﻞ >> وهـﻲ ﺗـﺪﻋﻰ ﺑﻤﻌﺎﻣـﻞ اﻻﺳـﺘﺨﺮاج أو ‪ . extraction operator‬اﺳـﻤﻪ‬
‫ﻣﻌﺎﻣﻞ اﻻﺳﺘﺨﺮاج ﻷﻧﻪ ﻳﺴﺘﺨﺪم ﻓﻲ اﺳﺘﺨﺮاج اﻟﺒﻴﺎﻧﺎت ﻣﻦ ال ‪ stream‬أو اﻟﻤﺴﺎر إﻟﻰ ﻣﺘﺤﻮل ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪ .‬ﺑﺎﺳـﺘﺨﺪام‬
‫اﻟﻤﺘﺤﻮل ‪ cin‬اﻟﺬي هﻮ )‪ (standard input‬اﻟﻤﻌﺮف ﻣﺴﺒﻘﺎ ﻓﻲ ‪ iostream.h‬ﺟﻨﺒﺎ إﻟﻰ ﺟﻨﺐ ﻣـﻊ اﻟﻤﻌﺎﻣـﻞ اﻟﺴـﺎﺑﻖ ﻳﻤﻜـﻦ‬
‫اﺳﺘﺨﻼص اﻟﺒﻴﺎﻧﺎت ﻣﻦ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ ﺑﺸﻜﻞ اﻓﺘﺮاﺿﻲ أو ﻣﻦ أي ‪ stream‬ﺁﺧﺮ ‪ ،‬آﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪cin >> x‬‬
‫إن ﻣﻌﺎﻣﻞ اﻻﺳﺘﺨﺮاج أوﻟﻮﻳﺘﻪ ﺗﻤﺎﻣﺎ ﻣﺜﻞ ﻣﻌﺎﻣﻞ اﻻﺿﺎﻓﺔ وأﻳﻀـﺎ ﺑﺎﻟﻨﺴـﺒﺔ إﻟـﻰ آﻴﻔﻴـﺔ ﺗﻨﻔﻴـﺬﻩ أو ﺗﺠﻤﻴﻌـﻪ ‪ .‬أﻳﻀـﺎ هـﺬا‬
‫اﻟﻤﻌﺎﻣﻞ ﻳﺮﺟﻊ ﻗﻴﻤﺔ ﺗﺸﻴﺮ إﻟﻰ ﻣﺴﺎر اﻟﺪﺧﻞ اﻟﻤﺴﺘﺨﺪم وﺑﺎﻟﺘﺎﻟﻲ ﻳﻤﻜﻦ ﻟﻬﺬا اﻟﻤﻌﺎﻣﻞ أن ﻳﺘﻢ اﺳﺘﺨﺪاﻣﻪ آﺴﻠﺴـﻠﺔ ﻣـﻦ‬
‫اﻻدﺧﺎﻻت آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫;” ‪cout << “Please enter three numbers :‬‬
‫;‪cin >> first >> second >> third‬‬
‫إن هﺬا اﻟﻤﻌﺎﻣﻞ ﻣﺘﻮاﻓﻖ ﻣﻊ ﺟﻤﻴﻊ اﻷﻧﻮاع اﻷﺳﺎﺳﻴﺔ ﻓﻲ ﺳﻲ‪ . ++‬ﻳﻘﻮم هﺬا اﻟﻤﻌﺎﻣﻞ ﺑﺎهﻤـﺎل أي ﻣﺴـﺎﻓﺎت أو ﻣﺤـﺎرف‬
‫ال )‪ (tab‬أو ﻣﺤﺎرف )‪ (new line‬ﺣﺘﻰ ﻳﺘﻢ ﻗﺮاﺋﺔ اﻟﻤﺤﺎرف اﻟﻤﺘﻮاﻓﻘﺔ ﻣﻊ اﻟﻨﻮع اﻟﺬي ﻧﺮﻳﺪ ﻗﺮاﺋﺘﻪ ‪ .‬ﻋﻠـﻰ ﺳـﺒﻴﻞ اﻟﻤﺜـﺎل إذا‬
‫آﺎﻧﺖ ‪ first‬و ‪ second‬هﻤﺎ ﻣﻦ ﻧﻮع ‪ int‬أﻣﺎ ‪ third‬ﻓﻬﻲ ﻣﻦ ﻧﻮع ﺳﻠﺴﻠﺔ ﻣﺤﺎرف ‪ .‬وآﺎن اﻟﺪﺧﻞ ﻋﻠﻰ اﻟﺼﻮرة اﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪167‬‬ ‫‪34hello‬‬
‫ﻓﺈن ﺳﻮف ﻳﺘﻢ اﺳﺘﺨﺮاج اﻟﻘﻴﻤﺔ ‪ 167‬ووﺿﻌﻬﺎ ﻓﻲ ‪ first‬وﺑﻌﺪهﺎ ﻳﺘﻢ اهﻤﺎل اﻟﻤﺴﺎﻓﺎت اﻟﺘﻲ ﺑﻌﺪهﺎ ﺣﺘﻰ ﻳﺘﻢ ﻗﺮاﺋﺔ اﻟﻘﻴﻤﺔ‬
‫‪ 34‬ووﺿﻌﻬﺎ ﻓﻲ اﻟﻤﺘﺤﻮل ‪ . second‬ﻻﺣﻆ أﻧﻪ ﻟﻢ ﻳﺘﻢ ﻗﺮاﺋﺔ ‪ hello‬ﻣـﻊ أﻧﻬـﺎ ﻣﻮﺻـﻮﻟﺔ ﻣـﻊ اﻟﻘﻴﻤـﺔ ‪ 34‬ﻷﻧﻬـﺎ ﻣـﻦ ﻧـﻮع ﺁﺧـﺮ ‪.‬‬
‫وأﺧﻴﺮا ﻳﺘﻢ ﻗﺮاﺋﺔ ‪ hello‬ووﺿﻌﻬﺎ ﻓﻲ اﻟﻤﺘﺤﻮل ‪. third‬‬
‫‪ 3.4‬ﺗﻨﺴﻴﻖ اﻟﺨﺮج – ‪Manipulating the output‬‬

‫إن ﻣﻜﺘﺒﺔ اﻟﺪﺧﻞ واﻟﺨﺮج ﺗﺤﺘﻮي ﻋﻠﻰ ﻋـﺪة ﻃـﺮق ﻣـﻦ أﺟـﻞ ﺗﻨﺴـﻴﻖ اﻟﺨـﺮج إﻟـﻰ ال ‪ stream‬ﻣـﻦ داﺧـﻞ اﻟﺒﺮﻧـﺎﻣﺞ ‪.‬‬
‫ﺳﻮف ﻧﺸﺮح هﻨﺎ آﻴﻔﻴﺔ اﺳﺘﺨﺪام اﻟﻤﻌﺪﻻت أو ‪ . Manipulators‬ﺳـﻮف أآﻤـﻞ ﺷـﺮح هـﺬﻩ اﻟﻤﻌـﺪﻻت وﻃـﺮق أﺧـﺮى ﻓـﻲ‬
‫دروس ﻗﺎدﻣﺔ ﺑﺎذن اﷲ ‪ .‬أﻣﺎ هﻨﺎ ﻓﺴﻮف أﻗﺪم ﻃﺮﻳﻘﺔ ﺳﻬﻠﺔ ﻟﺘﻨﺴﻴﻖ اﻟﺨﺮج ‪ .‬وهﺬا اﻟﻤﻨﺴﻖ ﻳﻈﻬﺮ ﻓﻲ ﻋﺒﺎرة اﻟﺨﺮج ﺗﻤﺎﻣﺎ‬
‫ﻣﺜﻞ ﺑﻘﻴﺔ اﻟﺤﺪود ﻓﻲ اﻟﺨﺮج وﻟﻜﻨﻪ ﻻ ﻳﺨﺮج أي ﺷﺊ إﻟﻰ ال‪ stream‬ﺑﻞ ﻟﻪ ﺗـﺄﺛﻴﺮ ﻋﻠـﻰ اﻟﻜﻤﻴـﺔ اﻟﺘـﻲ ﺗﺨـﺮج ﺑﻌـﺪﻩ ‪ .‬ﻣـﺜﻼ‬
‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪int index = 10‬‬
‫;”]“ << ‪cout << “[“ << index‬‬
‫ﺳﻮف ﻳﻨﺘﺞ ﻟﻨﺎ اﻟﺨﺮج اﻟﺘﺎﻟﻲ ‪:‬‬
‫]‪[10‬‬
‫ﻋﻠﻰ ﻓﺮض أﻧﻨﺎ ﻧﺮﻳﺪ ﻃﺒﺎﻋﺔ ‪ index‬ﻓﻲ ﻣﺴﺎﺣﺔ ﺗﻜﻔﻲ ﻟﺠﻤﻴﻊ اﻟﻘﻴﻢ اﻟﻤﻤﻜﻨﺔ ﻟﻬﺎ ﻓﺈﻧﻨﺎ ﻧﺴﺘﺨﺪم اﻟﺘﺎﻟﻲ ‪:‬‬
‫;”]“ << ‪cout << “[“ << setw(4) << index‬‬
‫ﺳﻮف ﻧﺤﺼﻞ ﻋﻠﻰ ‪:‬‬
‫]‪[ 10‬‬
‫ﺣﻴﺚ ﺗﻘﻮم ‪ setw‬ﺑﺎﺧﺒﺎر أن ﺗﻈﻬﺮ اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﺑﻌﺪهﺎ ﻓـﻲ ﻣﺴـﺎﺣﺔ ﻣﻜﻮﻧـﺔ ﻣـﻦ أرﺑـﻊ ﻣﺤـﺎرف ‪ .‬أﻣـﺎ إن آﺎﻧـﺖ اﻟﻘﻴﻤـﺔ‬
‫‪ index‬ﺗﺤﺘﺎج إﻟﻰ أآﺜﺮ ﻣﻦ ذﻟﻚ ﻓﻄﺒﻌﺎ ﺳﻮف ﻳﺘﻢ ﻃﺒﺎﻋﺔ اﻟﺮﻗﻢ آﺎﻣﻞ ‪.‬‬
‫ﺑﺎﻟﻨﺴﺒﺔ إﻟﻰ ﻃﺒﺎﻋﺔ اﻷرﻗﺎم اﻟﺤﻘﻴﻘﺔ ﻓﺈﻧﻪ ﺑﺸﻜﻞ اﻓﺘﺮاﺿﻲ ﻳﺘﻢ ﻃﺒﺎﻋﺔ ﺳﺘﺔ أرﻗـﺎم ﺑﻌـﺪ اﻟﻔﺎﺻـﻠﺔ وﻳﻤﻜـﻦ ﺗﻐﻴﻴـﺮ هـﺬا‬
‫ﺑﺎﺳﺘﺨﺪام اﻟﻤﻌﺪل ‪ setprecision‬آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪double pi = 3.1415926‬‬
‫;‪cout << setprecision(4) << pi‬‬
‫ﺳﻮف ﺗﺤﺪد أﻧﻨﺎ ﻣﻬﺘﻤﻴﻦ ﻓﻘﻂ ﺑﺄرﺑﻊ أرﻗﺎم آﻤﺠﻤﻮع آﻠﻲ وﺑﺎﻟﺘﺎﻟﻲ ﺳﻮف ﻧﺤﺼﻞ ﻋﻠﻰ اﻟﺨﺮج اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪3.142‬‬

‫ﻻﺣﻆ آﻴﻒ أﻧﻪ ﺗﻢ ﺗﻘﺮﻳﺐ اﻟﻌﺪد ﻗﺒﻞ اﻻﺧﺮاج ‪ .‬ﻳﺠﺐ أن ﻧﻨﺘﺒﻪ إﻟﻰ أﻣﺮ هﺎم وهﻮ ﻣﻦ أﺟﻞ اﺳﺘﺨﺪام هـﺬﻩ اﻟﻤﻌـﺪﻻت أو‬
‫ﻏﻴﺮهﺎ ﻳﺠﺐ ﺗﻀﻤﻴﻦ اﻟﻤﻠﻒ ‪ iomanip.h‬ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬
‫>‪#include <iomanip.h‬‬
‫‪ 3.5‬اﻟﺘﺎﺑﻌﻴﻦ ‪ get‬و ‪The functions get and put – put‬‬

‫أﺣﺪ اﻟﻤﻴﺰات اﻟﺴﻬﻠﺔ اﻟﺘﻲ ﻻﻏﻨﻰ ﻋﻨﻬﺎ أﺣﻴﺎﻧﺎ وهﻲ آﻴﻔﻴﺔ اﺧﺮاج أو ادﺧﺎل ﻣﺤﺮف وﺣﻴﺪ ‪ .‬ﺑﺎﻟﻨﺴﺒﺔ ﻟﻼﺧﺮاج ﻓﻬﺬا ﻳﺘﻢ‬
‫ﻋﻦ ﻃﺮﻳﻖ اﻟﺘﺎﺑﻊ ‪ put‬وهﺬا ﻣﺜﺎل ﻋﻠﻰ هﺬا ‪:‬‬
‫;’‪char ch = ‘h‬‬
‫;)‪cout.put(ch‬‬
‫إن اﻟﺘــﺎﺑﻊ اﻟﺴــﺎﺑﻖ ‪ put‬ﻳﺄﺧــﺬ ﻣﺘﺤــﻮل واﺣــﺪ وﻳﻄﺒﻌــﻪ ﻓــﻲ ‪ cout‬أو ‪ . output standard stream‬إن آﻴﻔﻴــﺔ اﻟﻜﺘﺎﺑــﺔ‬
‫اﻟﺴﺎﺑﻘﺔ ﺳﻮف ﺗﺘﻌﺮف ﻋﻠﻴﻬﺎ أآﺜﺮ ﻋﻨﺪﻣﺎ ﻧﺒﺪأ ﻓﻲ دروس ﻋﻦ ال ‪ classes‬ﻻﺣﻘﺎ ‪.‬‬
‫اﻟﺘﺎﺑﻊ ‪ get‬ﻳﻘﺮأ اﻟﻤﺤﺮف اﻟﺘﺎﻟﻲ ﻣﻦ ‪ standard input stream‬وﻳﻀﻌﻪ ﻓﻲ ﻣﺘﺤﻮل ﻣﺎ آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪char ch‬‬
‫;)‪cin.get(ch‬‬
‫‪ 3.6‬اﺳﺘﺨﺪام ﻣﻜﺘﺒﺔ اﻟﺪﺧﻞ واﻟﺨﺮج اﻟﺠﺪﻳﺪة – ‪Using the new standard I/O stream library‬‬
‫ﻻ ﻳﻮﺟﺪ ﻟﻐﺔ ﻣﻦ اﻟﻠﻐﺎت ﺗﺘﻄﻮر أو ﻳﻀﺎف ﻟﻬﺎ ﺗﻮاﺑﻊ داﻋﻤﺔ ﺟﺪﻳﺪة ‪ ،‬وآﺬﻟﻚ اﻟﻤﻜﺘﺒﺔ اﻟﻘﻴﺎﺳﻴﺔ ﻓﻲ اﻻدﺧﺎل واﻻﺧﺮاج ﻓﻲ‬
‫اﻟﺴﻲ‪ . ++‬وﻣﻦ أﺟﻞ اﺳﺘﺨﺪام ﺁﺧﺮ اﻟﻨﺴﺦ ﻣﻦ هﺬﻩ اﻟﻤﻜﺘﺒﺔ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻚ ﻓﻴﺠﺐ أن ﻳﺘﻢ اﻟﺘﻀﻤﻴﻦ ﺑﺎﻟﻄﺮﻳﻘﺔ اﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫>‪#include <iostream‬‬
‫;‪using namespace std‬‬
‫ﻻﺣﻆ أﻧﻨﺎ ﻟﻢ ﻧﺴﺘﺨﺪم اﻻﻣﺘﺪاد ‪ h‬ﻟﻠﻤﻠﻒ ‪ iostream‬وهﺬا ﻣﺎﻳﺨﺒﺮ اﻟﻤﺘﺮﺟﻢ أﻧﻨﺎ ﻧﺮﻳﺪ اﺳـﺘﺨﺪام اﻟﻨﺴـﺨﺔ اﻟﺤﺪﻳﺜـﺔ ﻣـﻦ‬
‫اﻟﻤﻜﺘﺒﺔ ‪ .‬أﻣﺎ اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ ﻓﻬﻮ ﺿﺮوري وﺳﻮف ﻧﺘﻘﺒﻠﻪ ﺣﺎﻟﻴﺎ ﻣﺜﻞ ﻣﺎهﻮ ﺣﺘﻰ ﻧﺄﺗﻲ ﻟﺸﺮﺣﻪ ﻻﺣﻘﺎ ﻓﻲ دروس أﺧﺮى ‪ .‬إذا‬
‫ﻳﺠﺐ أن ﺗﻨﺘﺒﻪ أﻧﻪ إذا أردت أن ﺗﺴﺘﺨﺪم ﻣﻜﺘﺒﺎت اﻟﺴﻲ‪ ++‬اﻟﺠﺪﻳﺪة ﻗﻢ ﺑﺘﻀﻤﻴﻦ ﻣﻠﻔﺎت اﻟﺘﻌﺮﻳﻒ ﺑﺪون اﺳﺘﺨﺪام اﻻﻣﺘـﺪاد‬
‫‪ h‬ﺣﺘﻰ ﻳﻌﺮف اﻟﻤﺘﺮﺟﻢ أي ﻣﻦ اﻟﻤﻜﺘﺒﺎت ﺳﻮف ﻳﺮﺑﻄﻬﺎ ﻣﻊ ﺑﺮﻧﺎﻣﺠﻚ ‪ .‬ﻣﺜﻼ إذا أردت اﺳﺘﺨﺪام اﻟﻤﻌﺪﻻت ﻓﻲ اﻟﺨﺮج ﺳﻮف‬
‫ﺗﻜﺘﺐ اﻟﺘﺎﻟﻲ ‪:‬‬
‫>‪#include <iomanip‬‬
‫;‪using namespace std‬‬
‫ﻓﻲ اﻟﺪروس اﻟﻘﺎدﻣﺔ ﺳﻮف ﻧﺴﺘﺨﺪم هﺬﻩ اﻟﺼﻴﻐﺔ ﻓﻲ ﺗﻀﻤﻴﻦ ﻣﻜﺘﺒﺔ اﻟﺪﺧﻞ واﻟﺨﺮج ‪.‬‬
‫‪ 3.6‬ﻣﻠﺨﺺ اﻟﺪرس‬
‫ﻣﻴﺰات اﻟﺪﺧﻞ واﻟﺨﺮج ﻓﻲ ﺳﻲ‪ ++‬ﻳﺘﻢ اﻟﺤﺼﻮل ﻋﻠﻴﻬﺎ ﻣﻦ ﻣﻜﺘﺒﺔ اﻟﺪﺧﻞ واﻟﺨﺮج اﻟﻘﻴﺎﺳﻴﺔ ‪Standard I/O‬‬ ‫•‬
‫‪. stream library‬‬
‫ﻋﻨــﺪ اﺳــﺘﺨﺪام اﻟﻤﻜﺘﺒــﺔ اﻟﺴــﺎﺑﻘﺔ ﻳﺠــﺐ ﺗﻀــﻤﻴﻦ اﻟﻤﻠــﻒ ‪ iostream.h‬ﻣــﻊ اﻟﺒﺮﻧــﺎﻣﺞ ﺑﺎﺳــﺘﺨﺪام اﻟﻌﺒــﺎرة‬ ‫•‬
‫>‪#include<iostream.h‬‬
‫ﻳﻤﻜﻦ ﺗﻨﺴﻴﻖ اﻟﺨﺮج ﺑﺎﺳﺘﺨﺪام اﻟﻤﻌﺪﻻت ‪. manipulators‬‬ ‫•‬
‫ﻳﻔﻀﻞ اﺳﺘﺨﺪام اﻟﺘﺎﺑﻌﻴﻦ ‪ get‬و ‪ put‬ﻣﻦ أﺟﻞ ﺗﺒﺎدل ﻣﺤﺮف وﺣﻴﺪ ﻣﻊ اﻟﻤﺴﺎر )‪. (stream‬‬ ‫•‬

‫اﻟﻤﺆﻟﻒ‪ :‬ﻣﺠﻼد ﻣﺸﺎري اﻟﺴﺒﻴﻌﻲ‬
‫اﻟﺒﺮﻳﺪ اﻹﻟﻜﺘﺮوﻧﻲ‪magedxl@hotmail.com :‬‬
‫ﻳﻤﻜﻨﻜﻢ ﻣﺮاﺳﻠﺘﻲ إذا ﻛﺎن ﻫﻨﺎك آي ﻣﺸﺎﻛﻞ ﻣﺘﻌﻠﻘﺔ ﺑﻌﺪم اﻟﺘﻮﺿﻴﺢ أو ﻧﺤﻮه ﻣﻤﺎ ﻳﻮﺟﺪ ﻓﻲ ﻫﺬا اﻟﻜﺘﺎب ‪...‬‬
‫‪‬‬
‫ﻣﻤﻨﻮع ﻣﻨﻌﺎ ﺑﺎﺗﺎ ﻃﺒﺎﻋﺔ أو اﻗﺘﺒﺎس أي ﺟﺰء ﻣﻦ ﻫﺬا اﻟﻜﺘﺎب ﺑﺪون أذن ﺧﻄﻲ ﻣﻦ اﻟﻤﺆﻟﻒ‬
‫‪PDF created with pdfFactory Pro trial version www.pdffactory.com‬‬

‫ﺣﻘﻮق اﻟﻄﺒﻊ ﻣﺤﻔﻮﻇﺔ©‬
‫* اﻟ ﺒﺮاﻣﺞ اﻟﻤﺬﻛ ﻮرة ﻓ ﻲ ﻫ ﺬا اﻟﻜ ﺘﺎب ﻣ ﺜﻞ " ‪"visual c++" "Windows‬وﻏ ﻴﺮﻫﺎ ﻋﻼﻣ ﺎت ﺗﺠﺎرﻳﺔ أو ﻋﻼﻣﺎت‬
‫ﻣﺴ ﺠﻠﺔ ﻻﺻ ﺤﺎﺑﻬﺎ ‪ ،‬واﻟﻤﺆﻟ ﻒ ﻳﺤ ﺘﺮم ﻫ ﺬه اﻟﻌﻼﻣ ﺎت وﻳﻘ ﺮ ﺑﻬ ﺎ ﻻﺻ ﺤﺎﺑﻬﺎ ‪ ،‬وﻟ ﻢ ﻳﺬﻛ ﺮﻫﺎ ﺗﺼ ﺮﻳﺤﺎ ﻓ ﻲ اﻟﻜ ﺘﺎب ﻃﻠ ﺒﺎ‬
‫ﻟﻼﺧﺘﺼﺎر‪.‬‬
‫* اﻟﻤﺆﻟ ﻒ ﻻ ﻳﻌ ﺪ ﻣﺴ ﺆوﻻ ﺑ ﺄي ﺷ ﻜﻞ ﺻ ﺮﻳﺤﺎ أو ﺿ ﻤﻨﻴﺎ ﻋ ﻦ أي ﻧ ﺘﺎﺋﺞ ﺗﺘﺮﺗ ﺐ ﻋ ﻦ اﺳ ﺘﺨﺪام اﻟﻤﻌﻠﻮﻣ ﺎت اﻟﺘ ﻲ‬
‫ﻳﺤﺘﻮﻳﻬﺎ اﻟﻜﺘﺎب أو آي ﺗﻌﺪﻳﻼت ﻳﺠﺮﻳﻬﺎ اﻟﻘﺎرئ ﻋﻠﻴﻬﺎ‪.‬‬
‫* ﺟﻤﻴﻊ اﻵراء وﻣﺎ ﻛﺘﺐ ﻓﻲ ﻫﺬا اﻟﻜﺘﺐ ﺗﻌﺒﺮ ﻋﻦ رأي اﻟﻤﺆﻟﻒ ﺷﺨﺼﻴﺎ‪.‬‬
‫* اﻟﻜﺘﺎب ﻣﺠﺎﻧﻲ ‪ % 100‬وﻻ ﻳﺤﻖ ﻻﺣﺪ ﺑﻴﻌﻪ أو اﺳﺘﻐﻼﻟﻪ ﺗﺠﺎرﻳﺎ‪.‬‬

‫ﻫ ﺬا اﻟﻜ ﺘﺎب إﻫ ﺪاء إﻟ ﻰ ارض اﻟﻌ ﺮاق اﻟﺤﺒﻴ ﺒﺔ ‪ ..‬ﻧﻌ ﻢ اﻟﻌ ﺮاق ﻟﻘ ﺪ أﺿ ﻌﻨﺎ اﻟﻌ ﺮاق ارض اﻟﻔﺮات ودﺟﻠﺔ ‪ ،‬ﻓﺨﺮ اﻹﺳﻼم‬
‫واﻟﻤﺴﻠﻤﻴﻦ ﺑــﻐــﺪاد ‪...‬‬
‫أﺿﻌﻨﺎﻫﺎ ‪ ..‬أﺿﻌﻨﺎﻫﺎ‪..‬‬
‫ﻟﻜﻨﻚ ﻟﺴﺖ ﺑﺒﻌﻴﺪ وﺳﺘﻌﻮدﻳﻦ أرﺿﺎ ﻟﻠﺨﻼﻓﻪ اﻹﺳﻼﻣﻴﺔ‪..‬‬
‫ﻗﺮﻳﺒﺎ ‪ ..‬ﻗﺮﻳﺒﺎ‬
‫‪‬‬

‫أﻋﺰاﺋﻲ‪..‬‬
‫ﺗﻢ وﺑﺤﻤﺪ اﷲ اﻻﻧﺘﻬﺎء ﻣﻦ ﻫﺬا اﻟﻜﺘﺎب ‪ ..‬اﻟﻤﻔﻴﺪ ﻟﻠﺠﻤﻴﻊ ﺑﺈذن اﷲ اﻟﻤﺒﺘﺪﺋﻴﻦ واﻟﻤﺤﺘﺮﻓﻴﻦ ﻋﻠﻰ ﺣﺪ اﻟﺴﻮاء‪..‬‬
‫وﻗﺪ ﻗﻤﺖ ﺑﺈﻧﺸﺎء ﻫﺬا اﻟﻜﺘﺎب ﺑﻌﺪ أن ﻻﺣﻈﺖ ﻗﻠﺖ اﻟﻜﺘﺐ اﻟﺘﻲ ﺗﺘﺤﺪث ﻋﻦ ﻟﻐﺔ ‪..Visual C++‬‬
‫وﻫﻲ اﻟﻠﻐﺔ اﻟﺘﻲ ﺗﻢ ﻣﻨﻬﺎ ﺑﻨﺎء ﺣﺰﻣﺔ اوﻓﻴﺲ اﻟﻤﻌﺮوﻓﺔ ﻟﺘﻄﺒﻴﻘﺎت اﻟﺤﺎﺳﺐ‪..‬‬
‫ﻟﺬﻟﻚ أرﺟﻮ أن ﻳﺤﻮز ﻫﺬا اﻟﻜﺘﺎب ﻋﻠﻰ رﺿﺎﻛﻢ وﻫﻮ ﻳﺤﺘﻮى ﻋﻠﻰ اﻟﻌﺪﻳﺪ ﻣﻦ اﻷﻣﺜﻠﺔ اﻟﺘﻄﺒﻴﻘﻴﺔ ﻣﻊ ﺷﺮح اﻷﺳﺎﺳﻴﺎت‬
‫واﻟﻌﺪﻳﺪ ﻣﻦ اﻷﺟﻮﺑﺔ اﻟﺘﻲ ﻳﺤﺘﺎﺟﻬﺎ ﻣﺒﺮﻣﺠﻲ ‪.C++‬‬
‫وﺑﺎﷲ اﻟﺘﻮﻓﻴﻖ‪..‬‬

‫‪‬‬
‫ﻋﻨﻮان اﻟﻜﺘﺎب‪............................................................................‬أ‬
‫اﻫﺪأ‪.......................................................................................‬ب‬
‫ﻣﻘﺪﻣﺔ‪ ....................................................................................‬د‬
‫اﻟﺒﺎب اﻷول‬
‫اﻷﺳﺎﺳﻴﺎت ﻣﻜﻮﻧﺎت ‪ c++‬وادواﺗﻬﺎ‬
‫رﻣﻮز ﻟﻐﺔ ‪٧......................................................................... c++‬‬
‫اﻟﻤﺘﻐﻴﺮات‪١٣................................................................................‬‬
‫اﻷدوات اﻟﻤﺴﺘﻌﻤﻠﺔ ﻓﻲ ﻟﻐﺔ ‪١٥.................................................... c++‬‬
‫اﻷدوات اﻟﺤﺴﺎﺑﻴﺔ ‪١٥......................................................................‬‬
‫اﻷدوات اﻷﺣﺎدﻳﺔ واﻟﺜﻨﺎﺋﻴﺔ‪١٧............................................................‬‬
‫اﻟﺰﻳﺎدة واﻟﻨﻘﺼﺎن‪١٧.......................................................................‬‬
‫أوﻟﻴﺎت اﻟﻌﻤﻠﻴﺎت ﻟﻸدوات اﻟﺤﺴﺎﺑﻴﺔ‪١٩..................................................‬‬
‫اﻷدوات اﻟﻌﻼﻗﻴﺔ واﻟﻤﻨﻘﻄﻴﺔ ‪٢٠..........................................................‬‬
‫اﻷدوات اﻟﺪﻗﻴﻘﺔ‪٢٢.........................................................................‬‬
‫أداة اﻟﻨﻔﻲ‪٢٣.................................................................................‬‬
‫أداة اﻟﺠﻤﻊ‪٢٤...............................................................................‬‬
‫أداة اﻻﺧﺘﻴﺎر‪٢٤............................................................................‬‬
‫أداة اﻻﺧﺘﻴﺎر اﻻﺳﺘﺜﻨﺎﺋﻲ‪٢٥...............................................................‬‬
‫أداة اﻹزاﺣﺔ‪٢٦.............................................................................‬‬
‫اﻷداة اﻟﺸﺮﻃﻴﺔ ‪٢٨.........................................................................‬‬
‫أداة اﻟﻌﻨﻮان‪٢٩..............................................................................‬‬
‫أداة ﺗﻌﻴﻴﻦ اﻟﻄﻮل‪٣٠.......................................................................‬‬
‫اﻟﻔﺎﺻﻠﺔ ﻛﺄداة‪٣١...........................................................................‬‬
‫ﺟﻤﻞ اﻟﺘﻌﺮﻳﻒ‪٣٢..........................................................................‬‬
‫اﻟﺜﻮاﺑﺖ اﻟﺮﻣﺰﻳﺔ ذات اﻟﺸﺮط اﻟﻤﻌﻜﻮﺳﺔ‪٣٣...........................................‬‬
‫اﻟﻤﻼﺣﻈﺎت واﻟﺘﻌﻠﻴﻘﺎت ﻓﻲ ‪٣٤...................................................c++‬‬
‫اﻟﺒﺎب اﻟﺜﺎﻧﻲ‬
‫ﺗﺸﻐﻴﻞ ‪Visual C++6.0‬‬
‫ﺧﻄﻮات ﺗﺸﻐﻴﻞ ﺑﺮﻧﺎﻣﺞ ‪٣٥.......................................... Visual C++‬‬
‫اﻟﺒﺎب اﻟﺜﺎﻟﺚ‬
‫أﺳﺎﻟﻴﺐ اﻹدﺧﺎل واﻹﺧﺮاج‬
‫ﻣﻘﺪﻣﺔ‪٤٠..................................................................................‬‬

‫اﻹدﺧﺎل واﻹﺧﺮاج‪٤١...................................................................‬‬
‫ﻃﺒﺎﻋﺔ اﻟﻨﺼﻮص ) اﻟﺜﻮاﺑﺖ اﻟﺮﻣﺰﻳﺔ (‪٤٢...........................................‬‬
‫ﻃﺒﺎﻋﺔ اﻟﻘﻴﻢ اﻟﻌﺪدﻳﺔ ‪٤٤.................................................................‬‬
‫ﻃﺒﺎﻋﺔ اﻟﻨﺼﻮص واﻟﻘﻴﻢ اﻟﻌﺪدﻳﺔ ﻓﻲ ﺟﻤﻠﺔ واﺣﺪه‪٤٧................................‬‬
‫اﻹدﺧﺎل ﺑﻠﻐﺔ ‪٤٩.................................................................. c++‬‬
‫اﻟﺒﺎب اﻟﺮاﺑﻊ‬
‫ﺟﻤﻞ اﻟﺘﺤﻜﻢ واﻟﺸﺮط واﻟﺘﻜﺮار‬
‫ﻣﻘﺪﻣﺔ ‪٥٣..................................................................................‬‬
‫اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ‪٥٣.......................................................................‬‬
‫ﺟﻤﻠﺔ اﻟﺸﺮط إذا وأﺧﻮاﺗﻬﺎ ‪٥٤......................................if statements‬‬
‫ﺟﻤﻠﺔ اﻟﺘﻮزﻳﻊ ‪٥٩............................................. switch statement‬‬
‫ﺟﻤﻠﺔ أداة اﻟﺸﺮط ؟‪٦٠...................................................................‬‬
‫اﻟﺘﻜﺮار وﺣﻠﻘﺎت اﻟﺘﻜﺮار‪٦١............................................................‬‬
‫أﺳﻠﻮب اﻟﺘﻜﺮار ﺑﺎﺳﺘﻌﻤﺎل ﺣﻠﻘﺔ ‪٦١............................................. For‬‬
‫ﺣﻠﻘﺎت اﻟﺘﻜﺮار اﻟﻤﺘﺪاﺧﻠﺔ ‪٦٦.......................................... for Loops‬‬
‫أﺳﻠﻮب اﻟﺘﻜﺮار ﺑﺎﺳﺘﻌﻤﺎل ﺣﻠﻘﺔ ‪٦٩................................While & Do‬‬
‫ﺣﻠﻘﺎت ‪ While‬اﻟﻤﺘﺪاﺧﻠﺔ‪٧٢...........................................................‬‬
‫ﺟﻤﻠﺔ اﻹﻳﻘﺎف ‪٧٣...............................................................Break‬‬
‫ﺟﻤﻠﺔ اﻻﺳﺘﻤﺮار ‪٧٥...................................................... continue‬‬
‫ﺟﻤﻠﺔ اﻟﺨﺮوج )(‪٧٧.............................................................. exit‬‬
‫ﺟﻤﻠﺔ اﻻﻧﺘﻘﺎل ‪٧٨................................................................ goto‬‬
‫اﻟﺒﺎب اﻟﺨﺎﻣﺲ‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﻗﻤﺔ واﻟﻤﺼﻔﻮﻓﺎت‬
‫ﻣﻘﺪﻣﺔ‪٧٩..................................................................................‬‬
‫إﻋﻄﺎء ﻗﻴﻤﺔ أوﻟﻴﺔ ﻟﻠﻤﺼﻔﻮﻓﺔ ذات اﻟﺒﻌﺪ اﻟﻮاﺣﺪ‪٨٣..................................‬‬
‫ﻋﻨﻮان ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﻓﻲ اﻟﺬاﻛﺮة‪٨٥............................................‬‬
‫اﻟﻤﺼﻔﻮﻓﺔ ذات اﻟﺒﻌﺪﻳﻦ‪٨٦.............................................................‬‬
‫اﻟﺒﺎب اﻟﺴﺎدس‬
‫اﻟﺪوال‬
‫ﻣﻘﺪﻣﺔ‪٨٨.................................................................................‬‬
‫ﺗﻄﺒﻴﻘﺎت ﻋﻠﻰ اﻟﺪوال‪٩٠...............................................................‬‬
‫اﻟﺒﺎب اﻟﺴﺎﺑﻊ‬
‫ﺗﻘﻨﻴﺔ اﻷﻗﺮاص و دوال اﻟﻤﻠﻔﺎت اﻻﻧﺘﻘﺎﻟﻴﺔ‬
‫ﻣﻘﺪﻣﺔ‪٩٤................................................................................‬‬
‫داﻟﺔ ﻓﺘﺢ اﻟﻤﻠﻒ )(‪٩٥....................................................... fopen‬‬
‫داﻟﺔ اﻟﻜﺘﺎﺑﺔ داﺧﻞ اﻟﻤﻠﻒ )(‪٩٧............................................ fprintf‬‬
‫داﻟﺔ إﻏﻼق اﻟﻤﻠﻒ )(‪٩٨.................................................... fclose‬‬
‫اﻟﺪاﻟﺘﺎن )(‪٩٩.......................................................putw() getw‬‬
‫اﻟﻨﻬﺎﻳﺔ‪١٠١...............................................................................‬‬

‫اﻷﺳﺎﺳﻴﺎت‬
‫ﻣﻜﻮﻧﺎت ‪ C++‬وادواﺗﻬﺎ‬
‫‪Basic Elements of C++‬‬
‫رﻣﻮز ﻟﻐﺔ ‪C++‬‬

‫*اﻟﺮﻣﻮز اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ ﻟﻐﺔ ‪C++‬‬
‫‪ -١‬اﻟﺤﺮوف اﻹﻧﺠﻠﻴﺰﻳﺔ اﻟﻜﺒﻴﺮة ‪A.B.C‬‬
‫‪ -٢‬اﻟﺤﺮوف اﻹﻧﺠﻠﻴﺰﻳﺔ اﻟﺼﻐﻴﺮة ‪a.b.c‬‬
‫‪ -٣‬اﻷرﻗﺎم اﻟﻌﺮﺑﻴﺔ اﻷﺻﻞ ‪1.2.3‬‬
‫‪ -٤‬رﻣﻮز ﺧﺎﺻﺔ ﻣﺜﻞ‪:‬‬
‫][‬ ‫"‬ ‫!‬ ‫<‬ ‫‪-‬‬ ‫‪+‬‬
‫*‬ ‫‪،‬‬ ‫||‬ ‫>‬ ‫)(‬ ‫_‬
‫>>‬ ‫><‬ ‫=<‬ ‫=>‬ ‫\‬ ‫‪/‬‬
‫=!‬ ‫&‬ ‫‪%‬‬ ‫‪$‬‬ ‫‪#‬‬ ‫<<‬
‫اﻟﺠﺪول‪١-١‬‬
‫وﺗﻌ ﺪ ﻫ ﺬه اﻟ ﺮﻣﻮز ﺑﺄﻧﻮاﻋﻬ ﺎ اﻟﻤ ﺎدة اﻟﺨ ﺎم اﻟﺘ ﻲ ﺗ ﺘﻜﻮن ﻣ ﻨﻬﺎ ﻣﻔ ﺮدات ﻟﻐ ﺔ ‪ ، C++‬وإذا‬
‫درﺳ ﺖ ﻟﻐ ﺔ أﺧ ﺮى ﻗ ﺒﻞ ﻟﻐ ﺔ ‪ ، C++‬ﻓ ﺎﻧﻚ ﺗﻼﺣ ﻆ أن ﻟﻐ ﺔ ‪ ، C++‬ﺗﺴ ﺘﻌﻤﻞ رﻣ ﻮزا‬
‫إﺿﺎﻓﻴﺔ ﻓﻲ ﻟﻮﺣﺔ ﻣﻔﺎﺗﻴﺢ اﻟﺤﺎﺳﺐ ﻻ ﺗﻮﺟﺪ ﻓﻲ ﺑﻌﺾ اﻟﻠﻐﺎت‪.‬‬
‫*ﻛﻠﻤﺎت ﻟﻐﺔ ‪C++‬‬

‫اﻟﻜﻠﻤﺎت ﻧﻮﻋﻴﻦ‪-:‬‬
‫‪ -١‬أﺳﻤﺎء ﺗﻌﺮﻳﻔﻴﺔ )‪(Identifiers‬‬
‫وﻫﻲ اﻷﺳﻤﺎء اﻟﺘﻲ ﻧﺴﻤﻴﻬﺎ ﻧﺤﻦ " اﻟﻤﺒﺮﻣﺠﻮن" ﺗﻌﺮف اﻟﺤﺎﺳﻮب ﺑﻤﺎ ﺗﺮﻳﺪ‪.‬‬
‫وﺗﻄﻠﻖ اﻷﺳﻤﺎء اﻟﺘﻌﺮﻳﻔﻴﺔ ﻋﻠﻰ‪-:‬‬

‫‪ -A‬اﻟﻤﺘﻐﻴﺮات‪.‬‬
‫‪ -B‬اﻻﺧﺘﺰاﻧﺎت )اﻟﺪوال(‪.‬‬
‫‪ -C‬اﻟﻤﺆﺷﺮات‪.‬‬

‫*ﻗﻮاﻋﺪ ﺗﺴﻤﻴﺔ اﻷﺳﻤﺎء اﻟﺘﻌﺮﻳﻔﻴﺔ ﻓﻲ ﻟﻐﺔ ‪-: C++‬‬
‫‪ -١‬أن ﻳﻜ ﻮن اﻻﺳ ﻢ ﻣﻜ ﺘﻮﺑﺎ ﻣ ﻦ ﺳﻠﺴ ﻠﺔ ﻣﺘﺼ ﻠﺔ ﻣ ﻦ اﻟﺤ ﺮوف أو اﻷرﻗ ﺎم ﺑﺸ ﺮط أن‬
‫ﻳﺒﺪا ﺑﺤﺮف أو ﺑﺨﻂ ﺗﺤﺘﻲ "_"‬
‫‪ -٢‬أن ﻻ ﻳﺤﺘﻮى اﻻﺳﻢ ﻋﻠﻰ رﻣﻮز ﺧﺎﺻﺔ ﻋﺪا اﻟﺨﻂ اﻟﺘﺤﺘﻲ "_"‬
‫‪ -٢‬أن ﻻ ﻳﻜﻮن اﻻﺳﻢ إﺣﺪى اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة‪.‬‬
‫ﺑﻌﺾ اﻷﻣﺜﻠﺔ اﻟﺼﺤﻴﺤﺔ ﻋﻠﻰ اﻷﺳﻤﺎء اﻟﺘﻌﺮﻳﻔﻴﺔ‪:‬‬
‫‪B6 .a‬‬
‫‪X_ray .b‬‬
‫‪Matrix .c‬‬
‫‪Ok_ .d‬‬
‫‪A .e‬‬
‫‪Soft_fine .f‬‬
‫‪Door12 .g‬‬
‫‪_new .h‬‬
‫وﻫﺬه أﺳﻤﺎء ﺗﻌﺮﻳﻔﻴﺔ ﻏﻴﺮ ﻣﻘﺒﻮل )‪ (invalid‬ﻟﻸﺳﺒﺎب اﻟﻤﺒﻴﻨﺔ إزاء ﻛﻞ ﻣﻨﻬﺎ‪:‬‬

‫‪ Ù 7-up‬ﻻﻧﻪ ﺑﺪا ﺑﺮﻗﻢ وﻟﻴﺲ ﺑﺤﺮف‪.‬‬
‫‪ Ù b6.1‬ﻻﺳﺘﻌﻤﺎﻟﻪ اﻟﺮﻣﺰ اﻟﺨﺎص )‪(.‬‬
‫!‪ Ù salim‬ﻻﺳﺘﻌﻤﺎﻟﻪ اﻟﺮﻣﺰ اﻟﺨﺎص )!(‬
‫‪ Ù Ђ2‬ﻻ ﻳﺠﻮز اﺳﺘﻌﻤﺎل ﺣﺮوف ﻏﻴﺮ إﻧﺠﻠﻴﺰﻳﺔ‪.‬‬
‫‪ Ù No#1‬ﻻﺳﺘﻌﻤﺎﻟﻪ اﻟﺮﻣﺰ اﻟﺨﺎص )‪(#‬‬
‫وﻣ ﻦ اﻟﺠﺪﻳ ﺮ ﺑﺎﻟﺬﻛ ﺮ ‪ ،‬أن ﻟﻐ ﺔ ‪ C++‬ﺗﻔ ﺮق ﺑﻴ ﻦ اﻟﺤ ﺮوف اﻷﺑﺠﺪﻳﺔ اﻟﺼﻐﻴﺮة واﻟﻜﺒﻴﺮة ‪،‬‬
‫ﻓﻤ ﺜﻼ اﻷﺳ ﻤﺎء ‪ SYSTEM , system, System :‬ﺗﻌ ﺎﻣﻞ ﻛﺄﺳ ﻤﺎء ﻣﺨ ﺘﻠﻔﺔ ﻋ ﻦ‬
‫ﺑﻌﻀﻬﺎ اﻟﺒﻌﺾ ﺑﺴﺒﺐ اﺧﺘﻼف ﻣﻌﺎﻣﻠﺔ اﻟﻤﺘﺮﺟﻢ ﻟﻠﺤﺮوف اﻟﺼﻐﻴﺮة واﻟﻜﺒﻴﺮة‪.‬‬

‫ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة‬-٢
، ‫ وﺗﻜﺘ ﺐ ﻋ ﺎدة ﺑﺤ ﺮوف ﺻﻐﻴﺮة‬، C++ ‫وﻫ ﻲ ﻛﻠﻤ ﺎت ﻗﻴﺎﺳ ﻴﺔ ﻣﻌ ﺮوﻓﺔ ﻣﺴ ﺒﻘﺎ ﻟﻤ ﺘﺮﺟﻢ‬
‫ وﻫ ﺬه اﻟﻜﻠﻤ ﺎت اﻟﻤﺤﺠ ﻮزة ﺣﺴ ﺐ‬، C++ ‫وﻟﻬ ﺎ ﻣﻌ ﺎن ﺧﺎﺻ ﺔ ﺑﻬ ﺎ ﺗﺆدﻳﻬ ﺎ ﻓ ﻲ ﺑ ﺮﻧﺎﻣﺞ‬
:‫اﻟﺘﺮﺗﻴﺐ اﻷﺑﺠﺪي ﻫﻲ‬
near Static asm Double long Sizeof

do int While new auto else
For This Void Delete Goto if
const Entry char Class Public Case
Continue Extern struct inline float Private
Virtual Volatile Frinde enum near Static
cdecl Default inline Overload Unsigned Typedef
Signed Pascal Operator Switch Template Union
Register Protected far Catch char Const
break Return
١-٢‫اﻟﺠﺪول‬
‫ ﻻ ﻳﺠ ﻮز إﻋ ﺎدة ﺗﻌ ﺮﻳﻔﻬﺎ أو اﺳ ﺘﻌﻤﺎﻟﻬﺎ‬، ‫وﻳﻨ ﺒﻐﻰ اﻟﺘﻨﺒ ﻴﻪ إﻟ ﻰ أن ﻫ ﺬه اﻟﻜﻠﻤ ﺎت اﻟﻤﺤﺠ ﻮزة‬

.‫ﻟﻐﻴﺮ ﻣﺎ ﺧﺼﺼﺖ ﻟﻪ‬
‫ ﺗﻌ ﺪ ﻟﻐ ﺔ ﺻ ﻐﻴﺮة إذ ﺗ ﺘﻜﻮن‬C++ ‫ أن ﻟﻐ ﺔ‬، ‫وﻛﻤ ﺎ ﺗﻼﺣ ﻆ ﻣ ﻦ ﻗﺎﺋﻤ ﺔ اﻟﻜﻠﻤ ﺎت اﻟﻤﺤﺠ ﻮزة‬

.‫ ﻛﻠﻤﺔ ﻣﺤﺠﻮزة ﻓﻘﻂ‬٥٢ ‫ﻣﻦ ﻋﺪد ﻗﻠﻴﻞ ﻣﻦ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة ﺗﻘﺮﻳﺒﺎ‬
PDF created with pdfFactory Pro trial version www.pdffactory.com

‫• ﺗﻤﺜﻴﻞ اﻟﺜﻮاﺑﺖ اﻟﻌﺪدﻳﺔ ‪Numeric Constants‬‬
‫ﻳﻤﻜﻦ ﺗﻤﺜﻴﻞ اﻟﺜﻮاﺑﺖ اﻟﻌﺪدﻳﺔ ‪ ،‬ﻓﻲ ﻟﻐﺔ ‪ C++‬ﺑﺜﻼث ﺻﻮر ﻫﻲ‪-:‬‬
‫‪ .a‬اﻟﺜﺎﺑﺖ اﻟﻌﺪدي اﻟﺼﺤﻴﺢ ‪integer‬‬

‫‪ -‬ﻫﻮ ﻋﺪد ﻣﻜﻮن ﻣﻦ اﻷرﻗﺎم ﻣﻦ ‪9 Ù 0‬‬
‫‪ -‬ﻻ ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺎﺻﻠﺔ ﻋﺸﺮﻳﺔ‪.‬‬
‫‪ -‬ﻳﻤﻜﻦ أن ﻳﺤﻮى اﻹﺷﺎرة "‪ "+‬أو "‪"-‬‬
‫أﻣﺜﻠﺔ ﺻﺤﻴﺤﺔ ﻋﻠﻰ اﻟﺜﺎﺑﺖ اﻟﻌﺪدي اﻟﺼﺤﻴﺢ‪-:‬‬

‫‪0‬‬
‫‪15‬‬
‫‪1000‬‬
‫‪321‬‬
‫‪-61‬‬
‫واﻷﻋﺪاد اﻟﺘﺎﻟﻴﺔ ﻏﻴﺮ ﺻﺤﻴﺤﺔ ﻟﻸﺳﺒﺎب اﻟﻤﺒﻴﻨﺔ إزاء ﻛﻞ ﻣﻨﻬﺎ‪:‬‬

‫‪ : 3.31‬ﻻﻧﻪ ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺎﺻﻠﺔ ﻋﺸﺮﻳﺔ‪.‬‬
‫‪ : 1,000‬ﻻﻧﻪ ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺎرزة‪.‬‬
‫‪ : J72‬ﻻﻧﻪ ﻳﺤﺘﻮى ﻋﻠﻰ ﺣﺮف أﺑﺠﺪي‪.‬‬
‫‪ : 2 4‬ﻟﻮﺟﻮد ﻓﺮاغ ﺑﻴﻦ اﻟﻌﺪﻳﺪﻳﻦ‪.‬‬
‫‪ : 1999 1992 1992‬ﻟﻮﺟﻮد ﻓﺮاغ وأﻳﻀﺎ ﻻن اﻟﻌﺪد ﻛﺒﻴﺮ‪.‬‬
‫‪ ، C++‬ﺣﺴ ﺐ ﻃﻮﻟﻬ ﺎ ‪ ،‬واﻟﺴ ﻌﺔ‬ ‫ﻛﻤ ﺎ ﻳﻤﻜ ﻦ ﺗﺼ ﻨﻴﻒ اﻷﻋ ﺪاد اﻟﺼ ﺤﻴﺤﺔ ﻓ ﻲ ﻟﻐ ﺔ‬
‫اﻟﺘﺨﺰﻳﻨﻴﺔ ﻟﻬﺎ ﻓﻲ اﻟﺬاﻛﺮة ﻣﺜﻼ‪-:‬‬
‫اﻟﺜﻮاﺑﺖ اﻟﺼﺤﻴﺤﺔ ‪ 40000 , 19897‬ﺗﺴﻤﻰ ﺛﻮاﺑﺖ ﺻﺤﻴﺤﺔ ﻃﻮﻳﻠﺔ ‪.long int‬‬
‫اﻟﺜﻮاﺑﺖ ‪ 45 , 80 , -16‬ﺗﺴﻤﻰ ﺛﻮاﺑﺖ ﺻﺤﻴﺤﺔ ﻗﺼﻴﺮة ‪.short int‬‬
‫اﻟﺜﻮاﺑﺖ ‪ 967 , 20000‬ﺗﺴﻤﻰ ﺛﻮاﺑﺖ ﺻﺤﻴﺤﺔ ﺑﺪون إﺷﺎرة ‪.unsigned int‬‬
‫واﻟﻔ ﺮق ﺑﻴ ﻦ اﻟﺜﻮاﺑ ﺖ اﻟﻄﻮﻳﻠ ﺔ واﻟﻘﺼ ﻴﺮة ﻫ ﻮ ﻓ ﻲ ﻋ ﺪد اﻟﻮﺣﺪات اﻟﺘﺨﺰﻳﻨﻴﺔ اﻟﻤﻄﻠﻮﺑﺔ ﻟﻜﻞ‬

‫ﻧ ﻮع ﻓ ﻲ اﻟﺬاﻛ ﺮة ‪ ،‬ﻓﺎﻟﻄﻮﻳﻠ ﺔ ﺗ ﺄﺧﺬ ﺣﻴﺰا اﻛﺒﺮ ‪ ،‬واﻟﻘﺼﻴﺮة ﺗﻮﻓﺮ ﻋﺪد اﻟﻮﺣﺪات اﻟﺘﺨﺰﻳﻨﻴﺔ‬
‫اﻟﻤﺴ ﺘﻌﻤﻠﺔ ‪ ،‬أﻣ ﺎ اﻟﺜﻮاﺑ ﺖ اﻟﺼ ﺤﻴﺤﺔ ﺑ ﺪون إﺷﺎرة ‪ ، unsigned int‬ﻓﺎن اﺳﺘﻌﻤﺎﻟﻬﺎ ﻳﻮﻓﺮ‬
‫وﺣ ﺪة ﺗﺨﺰﻳﻨ ﻴﺔ واﺣ ﺪة ﺗﺴ ﺘﻌﻤﻞ ﻟﻼﺷ ﺎره ﻋ ﻨﺪﻣﺎ ﺗﺬﻛ ﺮ ﻛﻠﻤ ﺔ ‪ ، unsigned‬ﻗ ﺒﻞ ‪، int‬‬

‫وذﻟ ﻚ ﺑﺈزاﺣ ﺔ اﻟﻘ ﻴﻤﺔ إﻟ ﻰ ﻗ ﻴﻤﺔ ﻣﻮﺟ ﺒﺔ ﺑ ﺪون إﺷ ﺎرة ‪ ،‬وﻟﻜ ﻞ ﻧ ﻮع ﻣ ﻦ اﻷﻧ ﻮاع اﻟﺴ ﺎﺑﻘﺔ‬
‫ﺗﻄﺒﻴﻘﺎﺗﻪ اﻟﻤﻨﺎﺳﺒﺔ‪.‬‬
‫‪ -b‬اﻟﺜﺎﺑﺖ اﻟﻌﺪدي اﻟﺤﻘﻴﻘﻲ ‪Floating-point Constants‬‬

‫‪ -‬ﻫﻮ ﻋﺪد ﻣﻜﻮن ﻣﻦ اﻷرﻗﺎم ‪9 Ù 0‬‬
‫‪ -‬ﻳﺠﺐ أن ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺎﺻﻠﺔ ﻋﺸﺮﻳﺔ‬
‫‪ -‬ﻳﻤﻜﻦ أن ﻳﺤﻮى اﻻﺷﺎره "‪ "+‬أو "‪"-‬‬
‫‪ -‬ﻻ ﻳﺠﻮز أن ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺎرزة "‪"،‬‬
‫أﻣﺜﻠﺔ ﻋﻠﻰ ﺛﻮاﺑﺖ ﻋﺪد ﺣﻘﻴﻘﻲ ﺗﺴﺘﻌﻤﻞ اﻟﻔﺎﺻﻠﺔ اﻟﻌﺸﺮﻳﺔ ﺑﺸﻜﻞ ﺻﺤﻴﺢ ‪-:‬‬
‫‪421.5‬‬
‫‪10.6‬‬
‫‪0.0‬‬
‫‪0‬‬
‫‪01‬‬
‫‪-68.0‬‬
‫واﻷﻣﺜﻠﺔ اﻻﺗﻴﻪ ﻏﻴﺮ ﺻﺤﻴﺤﺔ ﻟﻸﺳﺒﺎب اﻟﻤﺒﻨﻴﺔ إزاء ﻛﻞ ﻣﻨﻬﺎ‪-:‬‬

‫‪ : 1000‬ﻻﻧﻪ ﻻ ﻳﺤﺘﻮى ﻋﻠﻲ ﻓﺎﺻﻠﺔ ﻋﺸﺮﻳﺔ‪.‬‬
‫‪ : 4,000.21‬ﻻﻧﻪ ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺎرزة‪.‬‬
‫‪ : 2 83.4‬ﻻن ﻳﺤﺘﻮى ﻋﻠﻰ ﻓﺮاغ ‪.‬‬

‫• ﺗﻤﺜﻴﻞ اﻟﺜﻮاﺑﺖ اﻟﺮﻣﺰﻳﺔ ‪Non-numeric‬‬
‫‪ -‬ﺳﻠﺴﻠﺔ ﻣﻦ رﻣﻮز اﻟﻠﻐﺔ ) أﺣﺮف أرﻗﺎم رﻣﻮز ﺧﺎﺻﺔ( ﻣﺤﺼﻮرة ﺑﻴﻦ‬
‫ﺣﻮاﺻﺮ ﻋﻠﻮﻳﺔ ﻣﺰدوﺟﺔ )ﻋﻼﻣﺎت ﺗﻨﺼﻴﺺ أو اﻗﺘﺒﺎس(‬
‫وﻣﻦ اﻷﻣﺜﻠﺔ ﻋﻠﻰ اﻟﺜﺎﺑﺖ اﻟﺮﻣﺰي ﻣﺎ ﻳﺄﺗﻲ ‪-:‬‬

‫"‪"first‬‬
‫"‪"my name is‬‬
‫"‪"30+50=80‬‬
‫"‪"my,no=123.04‬‬
‫"‪"Islam‬‬
‫وﺗﻼﺣ ﻆ أﻧ ﻨﺎ ﺳ ﻤﻴﻨﺎ أي ﻧ ﺺ ﻣﻮﺿﻮع ﺑﻴﻦ ﺣﺎﺻﺮﺗﻴﻦ ﻣﺰدوﺟﺘﻴﻦ ﺛﺎﺑﺘﺎ رﻣﺰﻳﺎ واﻟﺼﺤﻴﺢ‬

‫أن ﺗﺴ ﻤﻴﺘﻪ ﺛﺎﺑ ﺘﺎ رﻣ ﺰﻳﺎ ﻫ ﻲ ﻣﻦ ﻗﺒﻴﻞ اﻟﻤﺠﺎز واﻻﺻﻄﻼح ﻻ اﻟﺤﻘﻴﻘﺔ ‪ ،‬واﻣﺎ ﻛﻠﻤﺔ رﻣﺰي‬
‫‪ :‬ﻓ ﻼن اﻟ ﻨﺺ ﻣﻜ ﻮن ﻣ ﻦ ﻋ ﺪد ﻣ ﻦ اﻟ ﺮﻣﻮز ‪ ،‬وﺗﺴ ﻤﻴﺔ ﺑﻌ ﺾ اﻟﻜﺘ ﺐ ﺑﺎﻟﺜﺎﺑ ﺖ ﻏ ﻴﺮ اﻟﻌ ﺪد‬
‫‪.Non-numeric‬‬
‫ﻣﻼﺣﻈﺔ‪/‬‬
‫ﻛ ﻞ اﻟﺜﻮاﺑ ﺖ اﻟﺮﻣ ﺰﻳﺔ اﻟ ﻮاردة أﻋ ﻼه ‪ ،‬وان اﺳ ﺘﺨﺪﻣﺖ ارﻗﺎﻣ ﺎ ﺣﺴ ﺎﺑﻴﺔ داﺧﻠﻬ ﺎ ‪ ،‬أﻻ أﻧﺎ ﻻ‬
‫ﺗﺤﻤ ﻞ أي ﻗ ﻴﻤﺔ ﺣﺴ ﺎﺑﻴﺔ ‪ ،‬وﻟ ﻴﺲ ﻟﻬ ﺎ ﻣﻌ ﻨﻰ ﺣﺴ ﺎﺑﻲ ‪ ،‬وﺗﺴ ﺘﺨﺪم ﻣ ﺜﻞ ﻫ ﺬه اﻟﺜﻮاﺑ ﺖ ﻋ ﺎدة‬
‫ﻛﻤﻌﻠﻮﻣﺎت ﺗﻮﺿﻴﺤﻴﺔ ﻣﻊ ﻧﺘﺎﺋﺞ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬

‫اﻟﻤﺘﻐﻴﺮات‬
‫ﻫﻲ أﺳﻤﺎء )ﻋﻨﺎوﻳﻦ( ﻟﻤﻮاﻗﻊ ﻓﻲ ذاﻛﺮة اﻟﺤﺎﺳﻮب ‪ ،‬ﻳﺨﺰن ﺑﻬﺎ رﻣﻮز أو أﻋﺪاد‪.‬‬
‫وﺑﻤ ﺎ أن أﻧ ﻮاع اﻟﻤﻌﻠﻮﻣ ﺎت اﻟﻤ ﺮاد ﺗﺨﺰﻳ ﻨﻬﺎ ﺗﻜ ﻮن ﻋ ﺎدة ﻣﺨ ﺘﻠﻔﺔ ﻣ ﺜﻞ اﻟﻘ ﻴﻢ اﻟﺼ ﺤﻴﺤﺔ أو‬
‫اﻟﺤﻘﻴﻘ ﻴﺔ أو اﻟﺮﻣ ﺰﻳﺔ ‪ ...‬اﻟـ ـﺦ ﻓ ﺎﻧﻚ ﺗﺤﺘﺎج أن ﺗﻌﻠﻢ اﻟﻤﺘﺮﺟﻢ ﻓﻲ ﺑﺪاﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻦ أﻧﻮاع‬
‫اﻟﻤﺘﻐ ﻴﺮات اﻟﺘ ﻲ ﺗ ﺮﻳﺪ اﺳ ﺘﻌﻤﺎﻟﻬﺎ ﻓ ﻲ اﻟ ﺒﺮﻧﺎﻣﺞ ‪ ،‬ﻓﻤ ﺜﻼ ﻓ ﻲ اﻟﺴ ﻄﻮر اﻟﺘﺎﻟ ﻴﺔ ﺗﺒﻴ ﻦ أن‬
‫اﻟﻤﺘﻐﻴﺮﻳﻦ ‪ x‬و ‪ y‬ﺣﻘﻴﻘﻴﺎن ‪ ،‬واﻟﻤﺘﻐﻴﺮ ‪ k‬ﺻﺤﻴﺢ ‪ ،‬واﻟﻤﺘﻐﻴﺮ ‪ c,b,a‬رﻣﺰﻳﺔ‪.‬‬
‫;‪Float x, y‬‬ ‫‪ X‬و‪ y‬ﻋﺪدان ﺣﻘﻴﻘﻴﺎن‬
‫;‪Integer k‬‬ ‫‪ K‬ﻋﺪد ﺻﺤﻴﺢ‬
‫;‪Char c,b,a‬‬ ‫‪ C,b,a‬رﻣﻮز‬
‫;‪X=2.0‬‬
‫;‪Y=10.6*x‬‬
‫;‪K=100‬‬
‫;‪A=t‬‬
‫;‪B=f‬‬
‫;‪C=4‬‬
‫ﻻﺣ ﻆ اﻟﺴ ﻄﺮﻳﻦ اﻷول ‪ ،‬واﻟﺜﺎﻟ ﺚ ﻳﺤ ﺘﻮﻳﺎن ﻋﻠ ﻰ اﻛ ﺜﺮ ﻣ ﻦ ﻣﺘﻐ ﻴﺮ ﺣﻴ ﺚ ﻳﻔﺼ ﻞ ﺑﻴ ﻦ ﻛﻞ‬

‫ﻣﺘﻐﻴﺮﻳ ﻦ ‪ ،‬ﻓﺎﺻ ﻠﺔ وﻛﺬﻟ ﻚ ﻳﻤﻜ ﻦ ﺗﺤﺪﻳ ﺪ أﻧ ﻮاع اﻟﻤﺘﻐ ﻴﺮات ‪ ،‬ﺑﺬﻛ ﺮ اﻟﺘﻔﺼﻴﻞ اﻟﺪﻗﻴﻖ ﻟﻠﻨﻮع‬
‫‪ ،‬ﻣ ﻦ ﺣﻴ ﺚ ﻃ ﻮل اﻟﺴ ﻌﺔ اﻟﺘﺨﺰﻳﻨ ﻴﺔ ‪ ،‬أي ﻫ ﻞ ﻫﻮ ﺻﺤﻴﺢ ﻗﺼﻴﺮ أم ﻃﻮﻳﻞ ﺣﻘﻴﻘﻲ ﻗﺼﻴﺮ‬
‫أو ﻣﻀﺎﻋﻒ ‪ ...‬اﻟـﺦ‬

‫• وﺗﻘﺴﻢ اﻟﻤﺘﻐﻴﺮات ﻟﻨﻮﻋﻴﻦ ‪-:‬‬
‫‪ -١‬ﻣﺘﻐﻴﺮات ﻋﺪدﻳﺔ‬
‫وﻫﻲ ﻣﻮاﻗﻊ ﻓﻲ اﻟﺬاﻛﺮة ﺗﺨﺰن ﺑﻬﺎ أﻋﺪاد ‪.‬‬
‫‪ -٢‬ﻣﺘﻐﻴﺮات رﻣﺰﻳﺔ‬
‫وﻫﻲ ﻣﻮاﻗﻊ ﻓﻲ اﻟﺬاﻛﺮة ﺗﺨﺰن ﺑﻬﺎ رﻣﻮز‪.‬‬
‫‪ -٣‬ﻣﺘﻐﻴﺮات ﻣﻨﻄﻘﻴﺔ‬
‫وﺗﺨﺰن ﺑﻬﺎ ﻗﻴﻤﺔ ﻣﻨﻄﻘﻴﺔ أﻣﺎ ‪ FALSE =0‬أو ‪TRUE=1‬‬

‫اﻷدوات اﻟﻤﺴﺘﻌﻤﻠﺔ ﻓﻲ ﻟﻐﺔ ‪C++‬‬
‫ﻳﻮﺟﺪ ﻓﻲ ﻟﻐﺔ ‪ C++‬ﺛﻼﺛﺔ أﻧﻮاع ﻣﻦ اﻷدوات وﻫﻲ‪:‬‬
‫اﻷدوات اﻟﺤﺴ ﺎﺑﻴﺔ – اﻷدوات اﻟﻤﻨﻄﻘ ﻴﺔ واﻟﻌﻼﻗ ﺔ – اﻷدوات اﻟﺪﻗ ﻴﻘﺔ وﻓ ﻴﻤﺎ ﻳﺄﺗ ﻲ ﺗﻔﺼ ﻴﻞ‬
‫ﺑﺎﻷﻧﻮاع اﻟﺜﻼﺛﺔ‪-:‬‬
‫اﻷدوات اﻟﺤﺴﺎﺑﻴﺔ ‪Arithmetic Operators‬‬

‫ﺗﺴ ﻤﺢ ﻟﻐ ﺔ ‪ C++‬ﺑﺎﺳ ﺘﻌﻤﺎل اﻷدوات اﻟﺤﺴ ﺎﺑﻴﺔ ﻣ ﻦ ﺟﻤ ﻊ وﻃ ﺮح وﺿ ﺮي وﻗﺴ ﻤﺔ ‪،‬‬
‫ﻛﺎﻟﻠﻐ ﺎت اﻷﺧ ﺮى ‪ ،‬إﻻ أن ﻋﻤﻠ ﻴﺔ اﻟ ﺮف إﻟ ﻰ أس ‪ ،‬ﻟﻴﺲ ﻟﻬﺎ أدوات ﻣﺒﺎﺷﺮة ﻣﺜﻞ اﻷداة ‪h‬‬
‫ﻓ ﻲ ‪ Basic‬واﻷداة ** ﻓ ﻲ ﻓﻮرﺗ ﺮان ‪ ،‬واﻧﻤ ﺎ ﺗ ﺘﻢ ﻋﻠﻤ ﻴﺔ اﻟ ﺮﻓﻊ إﻟ ﻰ أس ﻓ ﻲ ﻟﻐ ﺔ ‪C++‬‬
‫ﺑﻄﺮﻳﻘﺔ أﺧﺮى ‪..‬‬
‫ﻛﻤ ﺎ ﺗﺨ ﺘﻠﻒ اﻟﻘﺴ ﻤﺔ ﻓ ﻲ ﻟﻐ ﺔ ‪ C++‬ﻋ ﻨﻬﺎ ﻓ ﻲ ‪ Basic‬إذا أن أي ﺟ ﺰء ﻛﺴ ﺮي ﻳﻨ ﺘﺞ ﻋ ﻦ‬
‫اﻟﻘﺴ ﻤﺔ ﻳﻬﻤ ﻞ ﻣﻬﻤﻬ ﺎ ﻛ ﺎن ﻛﺒ ﻴﺮا ‪ ،‬ﻛﻤ ﺎ ﻓ ﻲ ﻟﻐﺘﻲ ﺑﺎﺳﻜﺎل وﻛﻮﺑﻮل ﻓﻤﺜﻼ ﻧﺎﺗﺞ اﻟﻘﺴﻤﺔ ‪8/3‬‬
‫ﻫﻮ ‪ 2‬ﻻ اﻟﻜﺴﺮ ‪ 0.666‬ﻳﻬﻤﻞ ‪ ،‬وﻳﻜﻮن ﻧﺎﺗﺞ اﻟﻘﺴﻤﺔ ﺑﺎﺳﺘﻌﻤﺎل اﻷداة ‪ /‬ﺻﺤﻴﺢ اﻟﻌﺪد‪.‬‬
‫وﻳﻤﻜﻨﻨﺎ اﻵن أن ﻧﻠﺨﺺ اﻷدوات اﻟﺤﺴﺎﺑﻴﺔ اﻟﻤﺴﺘﻌﻤﻠﺔ ﻓﻲ ﻟﻐﺔ ‪ C++‬ﻓﻴﻤﺎ ﻳﺄﺗﻲ‪-:‬‬
‫وﻇﻴﻔﺘﻬﺎ‬ ‫اﻷداة‬
‫ﻟﻠﻄﺮح أو ﻛﺄﺷﺎره ﺳﺎﻟﺒﺔ‬ ‫‪-‬‬
‫ﻟﻠﺠﻤﻊ‬ ‫‪+‬‬
‫ﻟﻠﻀﺮب‬ ‫*‬
‫ﻟﻠﻘﺴﻤﺔ‬ ‫‪/‬‬
‫ﻟﺒﺎﻗﻲ اﻟﻘﺴﻤﺔ اﻟﺼﺤﻴﺤﺔ‬ ‫‪%‬‬
‫ﻟﻠﻨﻘﺼﺎن‬ ‫‪--‬‬
‫ﻟﻠﺰﻳﺎدة‬ ‫‪++‬‬
‫اﻟﺠﺪول‪١-٣‬‬

‫وﻳﺨ ﺘﻠﻒ أداء ﺑﻌ ﺾ اﻷدوات اﻟﺤﺴ ﺎﺑﻴﺔ ﺣﺴ ﺐ ﻧ ﻮع اﻟﻤﻌﻄ ﻴﺎت اﻟﺼ ﺤﻴﺤﺔ ‪ ،‬أو اﻟﺤﻘﻴﻘﺔ ‪،‬‬
‫أو اﻟﺮﻣ ﺰﻳﺔ ﻓﻌ ﻨﺪ ﻣﻌﺎﻣﻠ ﺔ اﻟﻤﻌﻄ ﻴﺎت اﻟﺤﻘﻴﻘ ﻴﺔ ﻟ ﻸدوات اﻟﺤﺴ ﺎﺑﻴﺔ ‪ ،‬ﻳﻤﻜ ﻦ اﻟﻘ ﻮل أن‬
‫اﻟﻌﻠﻤ ﻴﺎت اﻷﺳﺎﺳ ﻴﺔ ﻣ ﻦ ﺟﻤ ﻊ وﻃ ﺮح وﺿ ﺮب ‪ ،‬ﺗﺠ ﺮي ﺑﺎﻟﻄ ﺮﻳﻘﺔ اﻟﺘ ﻲ ﻧﻌ ﺮﻓﻬﺎ ‪ ،‬إﻻ أن‬
‫ﻫ ﻨﺎك ﻣﺤ ﺬورا ﻳﺠ ﺐ أن ﻧﺬﻛ ﺮ ﺑ ﻪ ‪ ،‬وﻫ ﻮ أن ﺗ ﺘﻌﺪي ﻗ ﻴﻤﺔ اﻟﻨﺘ ﻴﺠﺔ ﻣ ﻦ أﻳﺔ ﻋﻤﻠﻴﺔ ﺣﺴﺎﺑﻴﺔ‬
‫اﻟﺤ ﺪود اﻟﻤﺮﺳ ﻮﻣﺔ ﻟ ﻨﻮع اﻟﻤﺘﻐ ﻴﺮ اﻟ ﻨﺎﺗﺞ ‪ ،‬ﻻن ﻟﻜ ﻞ ﻧ ﻮع ﻣ ﻦ أﻧ ﻮاع اﻟﻤﺘﻐ ﻴﺮات ﺣ ﺪودا ‪،‬‬
‫ﻳﻌ ﺪ ﺗﺠﺎوزﻫ ﺎ ﺧﻄ ﺄ ﻳﻨ ﺘﺞ ﻋ ﻨﻪ ﺧﻄ ﺄ ﻓ ﻲ اﻟﻨ ﺘﺎﺋﺞ ‪ ،‬وﻋ ﻨﺪ ﻣﻌﺎﻣﻠ ﺔ اﻟﻤﻌﻄ ﻴﺎت اﻟﺼ ﺤﻴﺤﺔ‬
‫ﺑ ﺎﻷدوات اﻟﺤﺴ ﺎﺑﻴﺔ ﺗﻌﻤ ﻞ اﻷدوات ﺑﺎﻟﻄ ﺮﻳﻘﺔ اﻟﺘ ﻲ ﻧ ﺘﻮﻗﻌﻬﺎ ‪ ،‬وﻋ ﻨﺪ ﺗﻌ ﺪي اﻟﺤ ﺪود‬
‫اﻟﻤﺴ ﻤﻮح ﺑﻬ ﺎ ﻓ ﻲ اﻟﻘ ﻴﻢ اﻟﺼ ﺤﻴﺤﺔ ‪ ،‬ﻓ ﺎن ﻫ ﺬا ﻳﻌﻨ ﻲ أن ﺧﻄ ﺄ ﻗ ﺪ وﻗﻊ ‪ ، overflow‬وﻓﻲ‬
‫ﻫﺬه اﻟﺤﺎﻟﺔ ﻟﻦ ﺗﺘﻠﻘﻰ ﻣﻦ اﻟﻤﺘﺮﺟﻢ أﻳﺔ رﺳﺎﻟﺔ ﺧﻄﺄ ‪ ،‬ﻓﻤﺜﻼ إذا ﻛﺎن ﻟﺪﻳﻨﺎ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ‪:‬‬
‫) (‪Main‬‬
‫{‬
‫;‪int n = 33000‬‬
‫;‪n = n * 3‬‬
‫}‬
‫ﻋ ﻨﺪ ﻃ ﺒﺎﻋﺔ اﻟﻨﺘ ﻴﺠﺔ ‪ n‬اﻟﻨﻬﺎﺋ ﻴﺔ ﻧ ﺘﻮﻗﻊ أن ﻳﻜ ﻮن اﻟﺠ ﻮاب ‪ ، 99000‬أﻻ أن اﻟﺠ ﻮاب ﻓ ﻲ‬
‫ﻫ ﺬه اﻟﺤﺎﻟ ﺔ ﻟ ﻦ ﻳ ﺘﻌﺪى ‪ ، 30464‬وﻫ ﻮ اﻟﺤ ﺪ اﻻﻋﻠ ﻰ اﻟﻤﺴ ﻤﻮح ﺑ ﻪ ﻟﻠﻘ ﻴﻤﺔ اﻟﺼ ﺤﻴﺤﺔ ‪،‬‬
‫وﻫ ﻨﺎك أﻣ ﺮ أﺧ ﺮى ﻳ ﺘﻌﻠﻖ ﺑﺎﻟﻘﺴﻤﺔ ﻓﻌﻨﺪﻣﺎ ﻧﻘﺴﻢ ‪ 8‬ﻋﻠﻰ ‪ 3‬ﻗﺴﻤﺔ ﺻﺤﻴﺤﺔ ‪ 8/3‬ﻓﺎن اﻟﻨﺎﺗﺞ‬
‫ﻳﻜ ﻮن ﺻ ﺤﻴﺤﺎ وﻫ ﻮ ‪ 2‬ﻓﻘ ﻂ ‪ ،‬وإذا ﻣ ﺎ رﻏﺒ ﺖ أن ﺗﺤ ﺎﻓﻆ ﻋﻠ ﻰ اﻟﺠ ﺰء اﻟﻜﺴ ﺮي اﻟ ﺬي‬
‫أﻫﻤ ﻞ واﺳ ﻘﻂ ‪ ،‬ﻳﻤﻜ ﻨﻚ أن ﺗﺤ ﻮل اﻟﻘﺴ ﻤﺔ إﻟ ﻰ ﻗﺴ ﻤﺔ ﺣﻘ ﻴﻘﺔ ‪ 8.0/3.0‬ﺣﻴﻨ ﺌﺬ ﻓ ﺎن اﻟ ﻨﺎﺗﺞ‬
‫ﺳ ﻴﻜﻮن ‪ 2.667‬ﻟﻬ ﺬا اﻟﺴ ﺒﺐ أدﺧﻠ ﺖ ﻟﻐ ﺔ ‪ C++‬أداة ﺑﺎﻗ ﻲ ا ﻟﻘﺴ ﻤﺔ ‪ %‬وﻳﺴ ﻤﻰ‬
‫‪ Modulus Operator‬وﻳﺴﺘﻌﻤﻞ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪:‬‬
‫‪7%3‬‬
‫ﺗﻌﻄ ﻲ اﻟﺠ ﻮاب ‪ 1‬وﻫ ﻮ ﺑﺎﻗ ﻲ اﻟﻘﺴ ﻤﺔ اﻟﺼ ﺤﻴﺤﺔ ‪ ، 7/3‬وﻣ ﻦ اﻟﺠﺪﻳ ﺮ ﺑﺎﻟﺬﻛﺮ أن ﻛﻼ ﻣﻦ‬
‫ﺑﺎﺳ ﻜﺎل وﻛﻮﺑ ﻮل ﺗﺴ ﺘﻌﻤﻼن ﻣ ﺜﻞ ﻫ ﺬه اﻟﻌﻤﻠ ﻴﺔ ‪ ،‬ﻓﻔ ﻲ ﺑﺎﺳ ﻜﺎل ﺗﻜﺘ ﺐ ﻫ ﺬه اﻟﻌﻤﻠ ﻴﺔ ﻋﻠ ﻰ‬
‫اﻟ ﻨﺤﻮ ‪ ، 7 mod 3‬وﻛﻠﻤ ﺔ ‪ MOD‬ﻫ ﻲ اﺧﺘﺼ ﺎر ‪ ، Modulus‬أﻣ ﺎ ﻓ ﻲ ﻟﻐ ﺔ ‪C++‬‬
‫ﻓﺘﺴﺘﻌﻤﻞ اﻷداة ‪ %‬ﻟﺘﻘﻮم ﺑﻬﺬا اﻟﻌﻤﻞ‪.‬‬

‫اﻷدوات اﻷﺣﺎدﻳﺔ واﻟﺜﻨﺎﺋﻴﺔ ‪Unary and Binary‬‬
‫‪Operators‬‬
‫ﺗﻌ ﺪ ﺟﻤ ﻴﻊ أدوات اﻟﺠﻤ ﻊ واﻟﻄ ﺮح واﻟﻀ ﺮب واﻟﻘﺴ ﻤﺔ وﺑﺎﻗ ﻲ اﻟﻘﺴ ﻤﺔ أدوات ﺛﻨﺎﺋ ﻴﺔ‬
‫‪ binary‬أي أﻧﻬ ﺎ ﺗ ﺄﺧﺬ )ﺗ ﺘﻌﺎﻣﻞ ﻣ ﻊ ( ﻗﻴﻤﺘﻴ ﻦ وﺗﻨ ﺘﺞ ﻗﻴﻤﺔ واﺣﺪة ‪ ،‬ﻓﻤﺜﻼ ﻧﺘﻴﺠﺔ ‪ 2*3‬ﻫﻲ‬
‫اﻟﻘ ﻴﻤﺔ ‪ 6‬وﻫ ﻨﺎك اﻷداة اﻷﺣﺎدﻳ ﺔ – ﻋ ﻨﺪﻣﺎ ﺗ ﺘﻌﺎﻣﻞ ﻣ ﻊ ﻗ ﻴﻤﺔ واﺣ ﺪ ﻓﻤ ﺜﻼ )‪ (-1992‬ﺗﻤ ﺜﻞ‬
‫اﻹﺷ ﺎرة ا ﻟﺴ ﺎﻟﺒﻪ وﻫ ﻲ ﻫ ﻨﺎ أداة أﺣﺎدﻳ ﺔ ‪ ، Unary‬واﻟﻌﻤﻠ ﻴﺔ ﻫ ﻨﺎ ﻟﻴﺴ ﺖ ﻋﻤﻠ ﻴﺔ ﻃ ﺮح ﻛﻤﺎ‬
‫ﻧﻌﻠﻢ‪.‬‬
‫اﻟﺰﻳﺎدة واﻟﻨﻘﺼﺎن ‪Increment and Decrement‬‬

‫ﻣﻦ ﻣﺰاﻳﺎ ﻟﻐﺔ ‪ C++‬أﻧﻬﺎ ﺗﺴﺘﻌﻤﻞ اﻷداﺗﻴﻦ اﻟﺤﺴﺎﺑﻴﺘﻴﻦ ‪ + +‬و ‪ - -‬ﻟﺰﻳﺎدة اﻟﻘﻴﻢ ﺑﻤﻘﺪار ‪1‬‬
‫أو إﻧﻘﺎﺻﻬﺎ ﺑﻤﻘﺪار ‪ ، 1‬واﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻳﺒﻴﻦ ﻃﺮﻳﻘﺔ اﻻﺳﺘﻌﻤﺎل‪:‬‬
‫;‪A++‬‬
‫;‪++a‬‬
‫ﻣﻌﻨﺎه إﺿﺎﻓﺔ ﻗﻴﻤﺔ ‪ 1‬إﻟﻰ ‪ a‬وﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﻬﺎ ﺑﺼﻮره ﻣﻜﺎﻓﺌﺔ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪-:‬‬
‫;‪A=a+1‬‬
‫وﺑﺎﻟﻄﺮﻳﻘﺔ ﻧﻔﺴﻬﺎ ﻳﻤﻜﻦ إﻧﻘﺎص ‪ 1‬ﻣﻦ ﻗﻴﻤﺔ ‪ a‬ﻋﻠﻰ اﻟﻨﺤﻮ‪-:‬‬
‫;‪--a‬‬
‫أو‬
‫;‪a--‬‬
‫;‪A=a-1‬‬
‫وﻫﻮ ﻳﻜﺎﻓﺊ اﻟﺼﻮرة‬
‫ﻟﻜ ﻦ ﻫ ﻨﺎك ﻓ ﺮﻗﺎ ﻓ ﻲ ﺳ ﺮﻋﺔ اﻟﺘﻨﻔ ﻴﺬ ‪ ،‬ﻓﺎﻟﺘﻌﺒ ﻴﺮ ;‪++a‬أﺳ ﺮع ﻣ ﻦ اﻟﺘﻌﺒ ﻴﺮ ;‪ a=a+1‬وﻫ ﺬه‬
‫ﻫﻲ اﻟﻔﺎﺋﺪة ﻣﻦ ﺟﺮاء اﺳﺘﺨﺪام ﻣﺜﻞ ﻫﺬه اﻷدوات ‪.‬‬
‫وﻣﻤ ﺎ ﻳﻨﺒﻐ ﻲ اﻟﺘﻨﺒ ﻴﻪ إﻟ ﻴﻪ ﻫ ﻨﺎ أن ﻫ ﻨﺎك ﻓ ﺮﻗﺎ ﺑﻴ ﻦ ‪ a++‬و ‪ ، ++a‬ﺻ ﺤﻴﺢ أن ﻛ ﻼ ﻣ ﻦ‬
‫اﻟﺘﻌﺒﻴﺮﻳ ﻦ ﻳﺠﻤ ﻊ ‪ 1‬إﻟ ﻰ ‪ ، a‬ﻟﻜ ﻦ ﻋ ﻨﺪ اﺳ ﺘﻌﻤﺎل ‪ ++a‬ﻓ ﻲ ﺗﻌﺒ ﻴﺮ ﻣ ﻦ اﻟﺘﻌﺎﺑ ﻴﺮ ‪ ،‬ﻓ ﺎن ‪a‬‬

‫ﺗ ﺰداد ﻗ ﺒﻞ اﺳ ﺘﺨﺮاج ﻗ ﻴﻤﺔ اﻟﺘﻌﺒ ﻴﺮ ‪ ،‬ﺑﻴ ﻨﻤﺎ ﻓ ﻲ ﺣﺎﻟ ﺔ ‪ a++‬ﺗﺴ ﺘﺨﺮج ﻗ ﻴﻤﺔ اﻟﺘﻌﺒ ﻴﺮ‬
‫ﺑﺎﺳ ﺘﻌﻤﺎل ﻗ ﻴﻤﺔ ‪ a‬اﻟﺤﺎﻟ ﻴﺔ ﻗ ﺒﻞ زﻳﺎدﺗﻬ ﺎ ﺑﻤﻘ ﺪار ‪ ، 1‬وﺑﻌ ﺪ ذﻟ ﻚ ﺗ ﺘﻢ زﻳ ﺎدة ‪ a‬ﺑﻤﻘ ﺪار ‪ 1‬آي‬
‫أن اﻟﻌﻤﻠ ﻴﺔ اﻷوﻟ ﻰ ﺟﻤ ﻊ ﺗﻘﺪﻳ ﻢ ‪ ،‬واﻟﺜﺎﻧ ﻴﺔ ﺟﻤ ﻊ ﺗﺄﺧ ﻴﺮ ‪ ،‬وﻳﻨﻄﺒﻖ ﻫﺬا اﻟﻜﻼم أﻳﻀﺎ ﻋﻠﻰ –‬
‫‪ a‬و ‪. a--‬‬
‫ﻣﺜﺎل‪:‬‬
‫;‪Int x,y,x‬‬
‫;‪X=y=x=0‬‬ ‫أوﻟﻴﺔ ﺟﻤﻊ ‪ 1‬إﻟﻰ ‪ z‬ﺗﺄﺗﻲ‬
‫;‪X=++y + ++z‬‬ ‫ﻣﺘﺎﺧﺮه إذ ﻳﺘﻢ ﺟﻤﻌﻬﺎ‬
‫أوﻻ إﻟﻰ ‪x‬‬
‫;‪X=y++ + z++‬‬
‫;‪X=++y + z++‬‬
‫ﺟﻤﻊ ‪ 1‬إﻟﻰ ‪ y‬ﻣﺆﺟﻞ ﺑﻌﺪ‬
‫إﻋﻄﺎء ﻗﻴﻤﺘﻬﺎ اﻷوﻟﻰ إﻟﻰ‬
‫;‪X=y-- +--z‬‬ ‫‪x‬‬
‫ﻓﻲ ﻫﺬه اﻟﺤﺎﻟﺔ ﺗﻜﻮن ‪x=1 , z=1 , y=1‬‬
‫ﻓﻲ ﻫﺬه اﻟﺤﺎﻟﺔ ﺗﻜﻮن ‪x=2 , y=2 , z=2‬‬

‫ﻻن ‪ ، x‬ﺗﺠﻤﻊ ﻗﻴﻤﺘﻲ ‪ z,y‬ﻗﺒﻞ أن ﺗﺰداد ﻛﻞ‬
‫ﻣﻨﻬﻤﺎ ﺑﻤﻘﺪار ‪1‬‬
‫اﻵن ‪x=3 , y=3 , z=3‬‬

‫ﻻن ‪ x‬ﺗﺠﻤﻊ ‪ y‬ﺑﻌﺪ زﻳﺎدﺗﻬﺎ وﺗﺠﻤﻊ آﺧﺮ ‪ z‬ﻗﺒﻞ أن‬
‫ﺗﺰداد ‪1‬‬
‫اﻵن ‪x=5 , y=2 , z=1‬‬
‫وﺑﺈﻣﻜﺎﻧﻚ ﻛﺘﺎﺑﺔ اﻟﺠﻤﻠﺘﻴﻦ‪:‬‬

‫‪Int x,y,z‬‬
‫‪X=y=z=0‬‬
‫ﻓﻲ ﺟﻤﻠﺔ واﺣﺪ ﻋﻠﻰ اﻟﻨﺤﻮ‪:‬‬

‫‪Int x=y=z=0‬‬

‫أوﻟﻴﺔ اﻟﻌﻤﻠﻴﺎت ﻟﻸدوات اﻟﺤﺴﺎﺑﻴﺔ ‪Precedence of‬‬
‫‪Arithmetic Operations‬‬
‫ﻳﻤﻜ ﻦ اﻟﻘ ﻮل أن أوﻟ ﻴﺔ ﺗﻨﻔ ﻴﺬ اﻟﻌﻤﻠ ﻴﺎت ﻛﻤ ﺎ ﻳﺠ ﺮﻳﻬﺎ ﻣ ﺘﺮﺟﻢ ‪ C++‬ﺑﺎﻟﻨﺴ ﺒﺔ ﻟ ﻸدوات‬
‫اﻟﺤﺴﺎﺑﻴﺔ ﻫﻲ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪:‬‬
‫اﻟﺰﻳﺎدة أو اﻟﻨﻘﺼﺎن‬
‫رﻗﻢ اﻷوﻟﻮﻳﺔ‬ ‫اﻷداة‬
‫‪1‬‬ ‫‪ ++‬أو ‪--‬‬
‫‪2‬‬ ‫‪-‬‬ ‫اﻹﺷﺎرة اﻟﺴﺎﻟﺒﺔ‬
‫‪3‬‬ ‫* أو ‪ /‬أو ‪%‬‬
‫‪4‬‬ ‫‪ +‬أو ‪-‬‬ ‫اﻟﻀﺮب أو اﻟﻘﺴﻤﺔ أو اﻟﺒﺎﻗﻲ‬
‫‪5‬‬ ‫=‬
‫‪6‬‬ ‫‪ ++‬أو ‪) --‬اﻟﻤﺘﺄﺧﺮة ﺑﻌﺪ اﻟﻌﺪد(‬
‫اﻟﺠﺪول‪١-٤‬‬ ‫اﻟﺠﻤﻊ أو اﻟﻄﺮح‬
‫اﻟﻤﺴﺎواة‬
‫زﻳﺎدة أو ﻧﻘﺼﺎن ﺑﻤﻘﺪار ‪1‬‬
‫ﻣﻠﺤﻮﻇﺔ‪:‬‬
‫إذا ﺗﺴ ﺎوت أوﻟﻴ ﺘﺎن ﻣ ﺜﻞ اﻟﺠﻤ ﻊ واﻟﻄ ﺮح ﻓ ﻲ ﺗﻌﺒ ﻴﺮ ‪ ،‬ﻓ ﺘﻘﺪم اﻟﻌﻤﻠ ﻴﺔ اﻷﻗ ﺮب إﻟ ﻰ ﻳﺴ ﺎر‬
‫اﻟﺘﻌﺒ ﻴﺮ ‪ ،‬وﻋ ﻨﺪ اﺳ ﺘﻌﻤﺎل اﻷﻗ ﻮاس ﻷي ﺗﻌﺒ ﻴﺮ ﻓ ﺎن اﻷﻗ ﻮاس ﺗ ﺄﺧﺬ اﻷوﻟﻮﻳ ﺔ اﻷوﻟ ﻰ ﻓ ﻲ‬
‫اﻟﺘﻨﻔ ﻴﺬ ﻗ ﺒﻞ ) اﻟ ﺰﻳﺎدة أو اﻟﻨﻘﺼ ﺎن ( ‪ ،‬ﻛﻤ ﺎ ﻓ ﻲ ﻟﻐ ﺎت اﻟ ﺒﺮﻣﺠﺔ اﻷﺧ ﺮى ‪ ،‬واﻷﻣﺜﻠﺔ اﻵﺗﻴﺔ‬
‫ﺗﺒﻴﻦ ﻣﻔﻬﻮم اﻷوﻟﻮﻳﺔ ) اﻷﺳﺒﻘﻴﺔ (‪-:‬‬
‫‪X + y/z *a‬‬
‫ﻳﺄﺧﺬ ﺗﺴﻠﺴﻞ أوﻟﻮﻳﺎت ﻋﻤﻠﻴﺎﺗﻪ اﻟﺸﻜﻞ واﻟﺨﻄﻮات اﻟﺘﺎﻟﻴﺔ‪-:‬‬

‫‪ -١‬اﻟﻌﻤﻠﻴﺔ اﻷوﻟﻰ‪ :‬اﻟﻘﺴﻤﺔ ‪y / z‬‬
‫‪ -٢‬اﻟﻌﻤﻠﻴﺔ اﻟﺜﺎﻧﻴﺔ‪a * (y/z) :‬‬
‫‪ -٣‬اﻟﻌﻤﻠﻴﺔ اﻟﺜﺎﻟﺜﺔ‪ :‬ﺟﻤﻊ اﻟﻨﺎﺗﺞ ﻓﻲ اﻟﺨﻄﻮة ‪ 2‬إﻟﻰ ‪ x‬ﻓﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ‪:‬‬
‫‪X+ y/ z*z‬‬
‫ﻻﺣ ﻆ أﻧ ﻨﺎ ﺑﺪأﻧ ﺎ ﺑﺈﺟ ﺮاء اﻟﻌﻠﻤ ﻴﺎت اﻟﺤﺴ ﺎﺑﻴﺔ ﻣ ﻦ اﻟﻴﺴ ﺎر إﻟ ﻰ اﻟﻴﻤﻴ ﻦ ‪ ،‬وﺗﻌﻄ ﻰ أﻻ وﻟﻮﻳ ﻪ‬
‫ﻷﻳ ﺔ ﻋﻤﻠ ﻴﺔ ﺣﺴ ﺐ ﻗ ﺎﻋﺪة اﻷوﻟﻮﻳ ﺔ ‪ ،‬ﻓﺠ ﺎءت اﻟﻘﺴ ﻤﺔ ‪ ،‬ﻓ ﻲ اﻟﻤ ﺜﺎل ﻗ ﺒﻞ اﻟﺠﻤﻊ ‪ ،‬ﻛﻤﺎ ﺟﺎء‬
‫اﻟﻀﺮب ﺑﻌﺪ اﻟﻘﺴﻤﺔ وﺗﻼ ذﻟﻚ اﻟﺠﻤﻊ ﻛﺄﺧﺮ ﻋﻤﻠﻴﺔ‪.‬‬

‫اﻷدوات اﻟﻌﻼﻗﻴﺔ واﻟﻤﻨﻄﻘﻴﺔ ‪Relational and Logical‬‬
‫‪Operations‬‬
‫ﻳ ﺮﺟﻊ اﺳ ﻢ اﻷدوات اﻟﻌﻼﻗ ﻴﺔ إﻟ ﻰ اﻟﻌﻤﻠ ﻴﺎت اﻟﻤﺨﺘﺼ ﺔ ﺑﺎﻟﻘ ﻴﻢ اﻟﺘ ﻲ ﺑﻴ ﻨﻬﺎ ﻋﻼﻗ ﺎت وﻫ ﻮ‬
‫أﺟ ﺮاء ﻋﻤﻠ ﻴﺎت ﻣﻘﺎرﻧ ﺔ ﻣﻨﻄﻘ ﻴﺔ ﺑﻴ ﻦ ﻛﻤ ﻴﺎت ﺣﺴ ﺎﺑﻴﺔ أو رﻣ ﺰﻳﺔ ‪ ،‬وﺗﻜ ﻮن ﻧﺘﻴﺠﺘﻪ ﻣﻨﻄﻘﻴﺔ‬
‫وﻫ ﻲ أﻣ ﺎ ﻧﻌ ﻢ )‪ (true‬أو )‪ ، (false‬وﻳﻜ ﺜﺮ اﺳ ﺘﺨﺪام اﻟﺘﻌﺎﺑ ﻴﺮ اﻟﻤﻨﻄﻘ ﻴﺔ ﻓ ﻲ اﻟﺠﻤ ﻞ‬
‫اﻟﺸﺮﻃﻴﺔ ‪ ،‬واﻷﻣﺜﻠﺔ اﻵﺗﻴﺔ ﺗﺒﻴﻦ ﻟﻚ ﻣﺎ ﻫﻮ اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ‪:‬‬
‫اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ‪ x= =y :‬ﺟﻮاب أﻣﺎ ﻧﻌﻢ أو ﻻ ‪.‬‬

‫واﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ‪ matrix > 100.0 :‬ﺟﻮاب أﻣﺎ ﻧﻌﻢ أو ﻻ ‪.‬‬
‫وﻓ ﻲ ﻟﻐ ﺔ ‪ C++‬ﺗﻌ ﺎﻣﻞ اﻟﻨﺘ ﻴﺠﺔ ﻻ )‪ (false‬ﻋﻠ ﻰ أﻧﻬ ﺎ ﺻ ﻔﺮ )‪ (0‬وﺗ ﺄﺧﺬ اﻟﻨﺘ ﻴﺠﺔ ﻧﻌ ﻢ‬
‫)‪ (true‬أﻳﺔ ﻗﻴﻤﺔ ﻏﻴﺮ اﻟﺼﻔﺮ واﻟﻤﺸﻬﻮر أﻧﻬﺎ )‪. (1‬‬
‫وﻳﺒﻴﻦ ﻟﻨﺎ اﻟﺠﺪول اﻟﺘﺎﻟﻲ اﻷدوات اﻟﻌﻼﻗﻴﺔ واﻟﻤﻨﻄﻘﻴﺔ‪:‬‬
‫اﻷدوات اﻟﻌﻼﻗﻴﺔ‬
‫ﻣﻌﻨﺎﻫﺎ‬ ‫اﻷداة‬
‫اﻛﺒﺮ ﻣﻦ‬ ‫>‬
‫اﺻﻐﺮ ﻣﻦ‬ ‫<‬
‫اﻛﺒﺮ ﻣﻦ أو ﻳﺴﺎوي‬ ‫=>‬
‫اﺻﻐﺮ ﻣﻦ أو ﻳﺴﺎوي‬ ‫=<‬
‫ﻳﺴﺎوي‬ ‫==‬
‫ﻻ ﻳﺴﺎوي‬ ‫=!‬
‫اﻟﺠﺪول‪١-٥‬‬
‫اﻷدوات اﻟﻤﻨﻄﻘﻴﺔ‬
‫ﻣﻌﻨﺎﻫﺎ‬ ‫اﻷداة‬
‫‪) And‬ﺣﺮف اﻟﻌﻄﻒ واو(‬ ‫&&‬
‫‪ ) Or‬ﺣﺮف اﻟﻌﻄﻒ أو (‬ ‫||‬
‫‪) Not‬ﻟﻠﻨﻔﻲ( أداة أﺣﺎدﻳﺔ ‪unary‬‬ ‫!‬
‫اﻟﺠﺪول‪١-٦‬‬
‫إﻟﻴﻚ اﻵن ﻫﺬه اﻷﻣﺜﻠﺔ ‪ :‬اﻓﺮض أن ;‪int a=b=3‬‬

‫ﻓﺎن اﻟﺘﻌﺒﻴﺮ ‪ a < 3‬ﻧﺘﻴﺠﺘﻪ ‪ false‬أي ‪0‬‬
‫‪ a<=3‬ﻧﺘﻴﺠﺘﻪ ‪ true‬أي ‪1‬‬ ‫اﻟﺘﻌﺒﻴﺮ‬
‫‪ a>b‬ﻧﺘﻴﺠﺘﻪ ‪ false‬أي ‪0‬‬ ‫اﻟﺘﻌﺒﻴﺮ‬
‫‪ a!=b‬ﻧﺘﻴﺠﺘﻪ ‪ false‬أي ‪0‬‬ ‫اﻟﺘﻌﺒﻴﺮ‬
‫‪ a= = b‬ﻧﺘﻴﺠﺘﻪ ‪ true‬أي ‪1‬‬ ‫اﻟﺘﻌﺒﻴﺮ‬

‫ﺟﺪول اﻟﺼﺪق ﺳﻮف ﻧﺴﻮق ﻫﺬا اﻟﺠﺪول ﻛﺎﻟﺘﺎﻟﻲ‪-:‬‬
‫ﺟﺪول اﻟﻨﻔﻲ‬ ‫ﺟﺪول اﻟﺘﺨﻴﻴﺮ‬ ‫ﺟﺪول اﻟﺠﻤﻊ‬
‫)‪!x (not x‬‬ ‫)‪X||y (x or y‬‬ ‫)‪X && y (x and y‬‬
‫‪x‬‬ ‫‪!y‬‬ ‫‪x‬‬ ‫‪Y‬‬ ‫‪X||y‬‬ ‫‪X‬‬ ‫‪Y‬‬ ‫‪X&&y‬‬
‫‪F‬‬ ‫‪T‬‬ ‫‪F‬‬ ‫‪F‬‬ ‫‪F‬‬ ‫‪F‬‬ ‫‪F‬‬ ‫‪F‬‬
‫‪T‬‬ ‫‪F‬‬ ‫‪F‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫‪F‬‬ ‫‪T‬‬ ‫‪F‬‬
‫‪T‬‬ ‫‪F‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫‪F‬‬ ‫‪F‬‬
‫‪T‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫‪T‬‬
‫اﻟﺠﺪول‪١-٧‬‬
‫!! اﻟﻤﺴﺎﻋﺪة ﻋﻠﻰ ﻓﻬﻢ ﺟﺪاول اﻟﺠﻤﻊ واﻟﺘﺨﻴﻴﺮ واﻟﻨﻔﻲ أﻋﻼه‪-:‬‬
‫ﺟﺪول اﻟﺠﻤﻊ‪:‬‬
‫ﺗﺨ ﻴﻞ أن ‪ F‬ﺗﻤ ﺜﻞ اﻟﺴ ﻢ ‪ ،‬وان ‪ T‬ﺗﻤ ﺜﻞ اﻟﻌﺴ ﻞ ‪ ،‬وﺑﻨﺎء ﻋﻠﻰ ذﻟﻚ ﻓﺎن ‪ F&&T‬ﺗﻌﻨﻲ ﺳﻤﺎ‬
‫ﻣ ﻊ ﺳ ﻢ واﻟﻨﺘ ﻴﺠﺔ ﺳ ﻢ أي ‪ ، F‬ﻛﺬﻟ ﻚ ‪ F&&T‬ﺗﻌﻨ ﻲ ﺧﻠ ﻂ اﻟﺴ ﻢ ﻣ ﻊ اﻟﻌﺴ ﻞ واﻟﻨﺘ ﻴﺠﺔ ﺳ ﻢ‬
‫أي ‪ ، F‬وﻛﺬﻟ ﻚ ‪ T&&F‬ﻳﻨ ﺘﺞ ﻋ ﻨﻬﺎ ‪ F‬أﻣ ﺎ ‪ T&&T‬ﻓﻬ ﻲ ﻋﺴ ﻞ ﻋﻠ ﻰ ﻋﺴ ﻞ أي أن‬
‫اﻟﻨﺘﻴﺠﺔ ‪. T‬‬
‫ﺟﺪول اﻟﺘﺨﻴﻴﺮ‪:‬‬
‫‪ F||F‬ﻓﺎﻟﻨﺘ ﻴﺠﺔ ﻣﻌ ﺮوﻓﻪ ‪ F‬أﻣ ﺎ ﺑﻴ ﻦ اﻟﺴ ﻢ واﻟﻌﺴ ﻞ‬ ‫ﻓﻠ ﻮ ﺧ ﻴﺮت ﺑﻴ ﻦ اﻟﺴ ﻢ ‪ F‬واﻟﺴ ﻢ ‪F‬‬
‫‪ F||T‬ﻓﺎﻟﻨﺘﻴﺠﺔ ﺳﻮف ﺗﻜﻮن ﺑﺎﻟﻄﺒﻊ ﻟﻠﻨﺠﺎة ﻋﺴﻞ ‪ ، T‬وﻧﺘﻴﺠﺔ ‪ T||T‬ﻫﻲ ﻋﺴﻞ ‪...T‬‬

‫اﻷدوات اﻟﺪﻗﻴﻘﺔ ‪Bowties Operators‬‬
‫ﺗﺘﻤ ﻴﺰ ﻟﻐ ﺔ ‪ C++‬ﻋ ﻦ ﺳ ﺎﺋﺮ اﻟﻠﻐ ﺎت اﻟﺮاﻗ ﻴﺔ ﻣ ﺜﻞ ﻓ ﻴﺠﻮال ﺑﻴﺴ ﻚ وﺑﺎﺳ ﻜﺎل أﻧﻬ ﺎ ﺗﺴ ﺘﺨﺪم‬
‫أدوات دﻗ ﻴﻘﺔ ﻋﻠ ﻰ ﻣﺴ ﺘﻮى وﺣ ﺪة اﻟﺘﺨﺰﻳ ﻦ اﻷوﻟ ﻴﺔ ]‪ [Bit‬واﻟﻤﺨﺘﺼ ﺮة ﻣ ﻦ ‪Binary‬‬
‫*‪Digit‬‬
‫ﺳ ﻤﻴﺖ ﻫ ﺬه اﻷدوات ﺑﺎﻟﺪﻗ ﻴﻘﺔ أو أدوات )اﻟﺒ ﺖ( ﻷﻧﻬ ﺎ ﺗ ﺘﻌﺎﻣﻞ ﻣﻊ ]‪ ) [bit‬وﺣﺪة اﻟﺘﺨﺰﻳﻦ‬
‫اﻷوﻟ ﻴﺔ( ﻣﺒﺎﺷ ﺮة ‪ ،‬ﻓﺤﺼ ﺎ ‪ ،‬وﺿ ﺒﻄﺎ ‪ ،‬وإزاﺣ ﺔ ‪ ،‬وﺗﺴ ﺘﻌﻤﻞ ﻫ ﺬه اﻷدوات ﻣﻊ اﻟﻤﻌﻄﻴﺎت‬
‫اﻟﺼﺤﻴﺤﺔ ‪ int‬واﻟﺮﻣﺰﻳﺔ ‪ char‬ﻓﻘﻂ ‪ ،‬وﻻ ﺗﺴﺘﻌﻤﻞ ﻣﻊ ﻏﻴﺮﻫﺎ ﻣﻦ أﻧﻮاع اﻟﻤﻌﻄﻴﺎت‪..‬‬
‫واﻟﺠﺪول اﻟﺘﺎﻟﻲ ﻳﺒﻴﻦ اﻷدوات اﻟﺪﻗﻴﻘﺔ ووﻇﻴﻔﺔ ﻛﻞ ﻣﻨﻬﺎ‪:‬‬

‫ﻋﻤﻠﻬﺎ‬ ‫اﻷداة‬
‫)‪ (not‬آداه أﺣﺎدﻳﺔ‬ ‫~‬
‫)‪ (and‬ﺣﺮف اﻟﻮاو )و(‬ ‫&‬
‫)‪ (or‬ﺣﺮف اﻟﻌﻄﻒ )و(‬ ‫|‬
‫إزاﺣﺔ إﻟﻰ اﻟﻴﺴﺎر‬ ‫>>‬
‫إزاﺣﺔ إﻟﻰ اﻟﻴﻤﻴﻦ‬ ‫<<‬
‫)‪) (xor‬أو( اﻻﺳﺘﺜﻨﺎﺋﻴﺔ‬ ‫^‬
‫اﻟﺠﺪول‪١-٨‬‬
‫وﻛﻐﻴﺮﻫﺎ ﻣﻦ اﻷدوات ‪ ،‬ﻓﺎن اﻷدوات اﻟﺪﻗﻴﻘﺔ ﺗﺘﺒﻊ ﻗﻮاﻋﺪ اﻷوﻟﻴﺔ وﺣﺴﺐ اﻟﺘﺮﺗﻴﺐ‬
‫اﻟﺘﺎﻟﻲ‪:‬‬
‫أوﻟﻮﻳﺘﻬﺎ‬ ‫اﻷداة‬
‫اﻷوﻟﻰ‬ ‫~‬
‫اﻟﺜﺎﻧﻴﺔ‬ ‫<<أو>>‬
‫اﻟﺜﺎﻟﺜﺔ‬ ‫&‬
‫اﻟﺮاﺑﻌﺔ‬ ‫^‬
‫اﻟﺨﺎﻣﺴﺔ‬ ‫|‬
‫اﻟﺠﺪول‪١-٩‬‬

‫أداة اﻟﻨﻔﻲ )~(‬
‫ﺗﻌﻤ ﻞ ﻫ ﺬه اﻷداة ﻋﻠ ﻰ إﺑ ﺪال اﻟﺼ ﻔﺮ )‪ (0‬ﺑﻮاﺣ ﺪ)‪ (1‬أو اﻟﻌﻜ ﺲ ‪ ،‬وﻣﻌ ﻨﻰ ﻫ ﺬا أﻧﻬﺎ ﺗﻀﻊ‬
‫‪ 0‬ﻣﻜ ﺎن ‪ 1‬وﻛﺬﻟ ﻚ ‪ 1‬ﻣﻜ ﺎن ‪ ، 0‬ﻓﻤ ﺜﻼ ﻟ ﻮ ﻛ ﺎن ﻟﺪﻳ ﻨﺎ ﻗ ﻴﻤﺔ ‪ x‬ﻣﻤ ﺜﻠﺔ ﻓ ﻲ اﻟ ﻨﻈﺎم اﻟﻌ ﺪدي‬
‫اﻟﺜﻨﺎﺋﻲ اﻟﺘﺎﻟﻲ )ﻣﻦ ‪ 8‬ﺑﺖ (‪-:‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫ﻗﻴﻤﺔ ‪x‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫ﻗﻴﻤﺔ‪~x‬‬
‫وﻣﻌ ﻨﻰ ~ اﻟﻨﻔ ﻲ )‪ (not‬وﻣﻌ ﻨﻰ اﻟﻨﻔ ﻲ ﻫ ﻨﺎ اﻟﺘﻀﺎد ﺑﻴﻦ ‪ 0‬و ‪ 1‬ﻓﻲ اﻟﻨﻈﺎم اﻟﻌﺪدي اﻟﺜﻨﺎﺋﻲ‬
‫‪ ،‬ﻓﻌ ﻨﺪﻣﺎ ﺗ ﻨﻔﻰ ‪ 0‬ﺗﺜﺒ ﺖ ﺑ ﺪﻻ ﻣ ﻨﻪ ‪ 1‬واﻟﻌﻜ ﺲ ﺻ ﺤﻴﺢ ‪ ،‬وﻫ ﺬا ﻳﻮﺿ ﺤﻪ ﻟﻚ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‬
‫إذ ﺗﻢ )ﻧﻔﻲ( ﻗﻴﻤﺔ ‪ x‬ﺑﺎﻟﺒﺖ ﻟﻴﺼﺒﺢ ‪ ~x‬ﻓﻲ ﺟﻤﻴﻊ ﻣﻜﻮﻧﺎت ﻣﻦ اﻟﺒﺖ‪.‬‬

‫أداة اﻟﺠﻤﻊ &‬
‫اﻟﻤﺜﺎﻟﻲ اﻟﺘﺎﻟﻲ ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺟﻤﻊ اﻟﻘﻴﻢ ﻋﻨﺪ ﺗﻤﺜﻴﻠﻬﺎ ﺑﺎﻟﻨﻈﺎم اﻟﻌﺪدي اﻟﺜﻨﺎﺋﻲ‪:‬‬
‫اﻟﻌﻤﻠﻴﺔ ;‪x&y‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫ﻗﻴﻤﺔ ‪ x‬ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫ﻗﻴﻤﺔ ‪ y‬ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬

‫اﻟﻨﺎﺗﺞ ;‪X&Y‬‬
‫ﺣﻴﺚ ﻳﺠﻤﻊ ‪ 0+0‬وﻳﻌﻄﻲ ‪ ، 0‬وﻳﺠﻤﻊ ‪ 0+1‬ﻟﻴﻌﻄﻲ ‪ 0‬وﻳﺠﻤﻊ ‪ 1+1‬وﻳﻌﻄﻲ ‪1‬‬

‫‪) T Ù T&T F Ù F&T FÙF&F‬اﻧﻈﺮ ﺟﺪاول اﻟﺼﺪق اﻟﺴﺎﺑﻘﺔ(‬
‫أداة اﻻﺧﺘﻴﺎر|‬
‫إذا أردﻧﺎ اﺳﺘﻌﻤﺎل أداة اﻻﺧﺘﻴﺎر ﻣﻊ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻟﻘﻴﻤﺘﻲ ‪ X‬و‪ y‬ﻋﻠﻰ اﻟﻨﺤﻮ ;‪x|y‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪x‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪y‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬

‫اﻟﻨﺎﺗﺞ ;‪x|y‬‬
‫ﺣﻴﺚ اﻻﺧﺘﻴﺎر ﺑﻴﻦ ‪ 0‬و‪ 1‬ﻫﻮ ‪ ، 1‬واﻻﺧﺘﻴﺎر ﺑﻴﻦ ‪ 1‬و‪ 1‬ﻫﻮ ‪ ، 1‬وﺑﻴﻦ ‪ 0‬و‪ 0‬ﻫﻮ ‪. 0‬‬
‫‪ ) T Ù T|F T Ù T|T T Ù F|T‬اﻧﻈﺮ ﺟﺪاول اﻟﺼﺪق اﻟﺴﺎﺑﻘﺔ (‬

‫أداة اﻻﺧﺘﻴﺎر اﻻﺳﺘﺜﻨﺎﺋﻲ ^‬
‫ﺧﺬ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻧﻔﺴﺔ ﻟﺘﺮى ﻛﻴﻒ ﺗﺆﺛﺮ ﻫﺬه اﻷداة‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪x‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪y‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬

‫اﻟﻨﺎﺗﺞ ;‪x^y‬‬
‫ﻻﺣ ﻆ أن اﻻﺧﺘ ﻴﺎر ﺑﻴ ﻦ ‪ 0‬و‪ 0‬ﻧﺘﻴﺠ ﺘﻪ ‪ ، 0‬واﻻﺧﺘ ﻴﺎر ﺑﻴﻦ ‪ 1‬و‪ 0‬ﻧﺘﻴﺠﺘﻪ ‪ ، 1‬وﺑﻴﻦ ‪ 1‬و‪1‬‬
‫ﻧﺘﻴﺠ ﺘﻪ ‪ ، 0‬أن أداة اﻻﺧﺘ ﻴﺎر اﻻﺳ ﺘﺜﻨﺎﺋﻲ ^ )‪ (XOR‬ﺗﺨ ﺘﻠﻒ ﻋ ﻦ أداة اﻻﺧﺘ ﻴﺎر )‪| (OR‬‬
‫ﻓ ﻲ أن اﻷوﻟ ﻰ ﺣﺎﻟ ﺔ ﺧﺎﺻ ﺔ ﻣ ﻦ اﻟﺜﺎﻧ ﻴﺔ إذ ﺗﻜ ﻮن ﻧﺘﻴﺠ ﺘﻬﺎ ‪ (1) true‬ﻋ ﻨﺪﻣﺎ ﻳﻜ ﻮن أﺣ ﺪ‬
‫ﻃﺮﻓ ﻲ اﻻﺧﺘ ﻴﺎر ‪ x‬أو ‪ y‬ﻧﺘﻴﺠ ﺘﻪ ‪ ، true‬وﻣ ﺎ ﻋ ﺪا ذﻟ ﻚ ﻓﻨﺘﻴﺠ ﺘﻬﺎ داﺋﻤ ﺎ ‪ ، (0) false‬ﻛﻤ ﺎ‬
‫ﻻﺣﻈﺖ ﻓﻲ ﻫﺬا اﻟﻤﺜﺎل ‪ ،‬أﻣﺎ ﻓﻲ ﺣﺎﻟﺔ اﻻﺧﺘﻴﺎر اﻟﻌﺎم )‪ (OR‬ﻓﺎن ﻧﺘﻴﺠﺔ ‪ 1|1‬ﻫﻲ ‪.1‬‬

‫أدوات اﻹزاﺣﺔ >> و <<‬
‫ﻗ ﺪ ﺗ ﺒﺪو أدوات اﻹزاﺣ ﺔ ﻏﺮﻳ ﺒﺔ ﻋﻠﻰ اﻟﻤﺒﺮﻣﺞ اﻟﺬي ﻳﺴﺘﺨﺪم ﻟﻐﺎت أﺧﺮى ﻣﺜﻞ ‪ Basic‬و‬
‫‪ .. Pascal‬اﻟ ـﺦ ‪ .‬ﺣﻴ ﺚ ﻳﻨ ﺘﺞ ﻋ ﻦ اﺳ ﺘﻌﻤﺎل إﺣﺪاﻫﻤ ﺎ إزاﺣ ﺔ ﻗ ﻴﻤﺔ اﻟﻤﺘﻐ ﻴﺮ اﻟﺼ ﺤﻴﺢ‬
‫ﺑﺎﻟ ﻨﻈﺎم اﻟﺜﻨﺎﺋ ﻲ )ﺑﺎﻟﺒ ﺖ( ﻳﻤﻴ ﻨﺎ أو ﻳﺴ ﺎرا ﻋ ﺪدا ﻣ ﻦ اﻟﺨﺎﻧ ﺎت ﺣﺴ ﺐ اﻟﻄﻠ ﺐ ‪ ،‬وﺗﻤ ﻼ‬
‫اﻟﺨﺎﻧﺎت اﻟﻤﻔﺮﻏﺔ ﻣﻦ اﻟﺠﻬﺔ اﻟﻤﻮﺟﺒﺔ أﺻﻔﺎرا ‪ ،‬وﻣﻦ اﻟﺠﻬﺔ اﻟﺴﺎﻟﺒﺔ ﺗﻤﻼ آﺣﺎدا‪.‬‬
‫واﻷﻣﺜﻠﺔ اﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻃﺮﻳﻘﺔ اﻻﺳﺘﻌﻤﺎل‪.‬‬

‫اﻟﺠﻤﻠ ﺔ ;‪ x>>2‬ﻋ ﻨﺪ ﺗﻨﻔ ﻴﺬﻫﺎ ﻋﻠ ﻰ ﻗ ﻴﻤﺔ ‪ ) x‬وﻫ ﻲ ‪ 23‬ﺑﺎﻟﻨﻈﺎم اﻟﻌﺸﺮي( ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‬
‫ﻓﺎن اﻟﻌﻤﻠﻴﺔ ﺗﺘﻢ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪:‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪x‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫;‪x>>2‬‬
‫اﻟﻨﺘﻴﺠﺔ ﻣﻦ اﻹزاﺣﺔ ﺑﻤﻘﺪار ﺧﺎﻧﺘﻴﻦ )‪ ٢‬ﺑﺖ ( ﻟﻠﻴﻤﻴﻦ ﺗﺼﺒﺢ ﻗﻴﻤﺘﻬﺎ ‪:‬‬

‫‪ 5‬ﺑﺎﻟﻨﻈﺎم اﻟﻌﺸﺮي‪.‬‬
‫وﻫﺬا ﻳﻌﻨﻲ أن ;‪ 23>>2‬ﺗﻌﻄﻲ اﻟﻨﺘﻴﺠﺔ ‪. 5‬‬
‫ﺣﻴﺚ ‪ 23‬اﻟﻘﻴﻤﺔ اﻟﻤﺰاﺣﺔ‪.‬‬
‫‪ 2‬ﻋﺪد ﺧﺎﻧﺎت اﻹزاﺣﺔ اﻟﻤﻄﻠﻮﺑﺔ ﻟﻠﻴﻤﻴﻦ‪.‬‬
‫ﻻﺣﻆ أن اﻟﺨﺎﻧﺘﻴﻦ اﻟﻤﻔﺮﻏﺘﻴﻦ ﺑﺴﺒﺐ اﻹزاﺣﺔ ﻟﻠﻴﻤﻴﻦ ﻗﺪ ﻣﻠﺌﺘﺎ ﺑﻤﺼﻔﺮﻳﻦ‪.‬‬

‫ﻣﺜﺎل ﻋﻠﻰ إزاﺣﺔ ﻗﻴﻤﺔ ﺳﺎﻟﺒﺔ‪:‬‬
‫;‪Z = - 50<<2‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪Z‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪Z<<3‬‬
‫إزاﺣﺔ )‪٢‬ﺑﺖ( ﻟﻠﻴﺴﺎر‪.‬‬

‫اﻟﺠﺪﻳ ﺪ ﻓ ﻲ ﻫ ﺬا اﻟﻤ ﺜﺎل أن اﻹزاﺣ ﺔ ﻟﻘ ﻴﻤﺔ ﺳ ﺎﻟﺒﺔ ﻳﻨ ﺘﺞ ﻋ ﻦ ﻛ ﻞ ﺧﺎﻧ ﺔ ﻣﻔ ﺮﻏﺔ اﻟﻘ ﻴﻤﺔ ‪1‬‬
‫وﻟﻴﺲ ‪ 0‬ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‪.‬‬

‫أدوات أﺧﺮى ﻟﻢ ﺗﺬﻛﺮ ‪Other Operations‬‬
‫اﻷداة اﻟﺸﺮﻃﻴﺔ ‪the conditional operator‬‬
‫وﻫ ﺬه اﻷداة ﺗﺘﻤ ﻴﺰ ﺑﻬ ﺎ ﻟﻐ ﺔ ‪ c++‬ﻋ ﻦ ﻏ ﻴﺮﻫﺎ ‪ ،‬إذ ﺗﺤ ﻞ ﻣﺤﻞ ﺟﻤﻠﺔ ﺷﺮﻃﻴﺔ ﻣﺸﻬﻮرة ﻓﻲ‬
‫ﺑﻴﺴ ﻚ وﻓﻮرﺗ ﺮان وﺑﺎﺳ ﻜﺎل وﻫ ﻲ ‪ ، if-then-else‬وﺗﻌﺘ ﺒﺮ ﻫ ﺬه اﻷداة أداة ﺛﻼﺛ ﻴﺔ ﻷﻧﻬ ﺎ‬
‫ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﺛﻼث ﻛﻤﻴﺎت ﺣﺴﺐ ﺻﻴﻐﺘﻬﺎ اﻟﻌﺎﻣﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪Expression1 ? Expression2: Expression3‬‬
‫ﻓﻠﻮ ﻛﺎن ﻟﺪﻳﻨﺎ اﻟﺠﻤﻠﺔ اﻟﺸﺮﻃﻴﺔ اﻟﺘﺎﻟﻴﺔ ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل‪:‬‬

‫)‪If (b<c‬‬
‫;‪A=b‬‬
‫‪Else‬‬
‫‪A=c‬‬
‫ﻣﻌ ﻨﺎﻫﺎ‪ :‬اﻧ ﻪ إذا ﺗﺤﻘ ﻖ اﻟﺸ ﺮط )‪ (b<c‬ﻓﻴ ﻨﻔﺬ اﻟﺴ ﻄﺮ ‪ ، a=b‬وإﻻ ﻓ ﺎن ‪ a=c‬وﺑﺎﺳ ﺘﻌﻤﺎل‬
‫اﻷداة اﻟﺸ ﺮﻃﻴﺔ ؟ ﻳﻤﻜﻨ ﻨﺎ أن ﻧﻜﺘ ﺐ ﺑ ﺪﻻ ﻣ ﻦ اﻟﺠﻤﻠ ﺔ اﻟﺸ ﺮﻃﻴﺔ ﻛﻠﻬ ﺎ اﻟﺠﻤﻠ ﺔ اﻟﻤﺨﺘﺼ ﺮة‬
‫اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪A=(b<c) ? b:c‬‬ ‫إذا ﺗﺤﻘﻖ اﻟﺸﺮط ﻓﺎن‬
‫‪A=b‬‬
‫‪A=c‬‬
‫إذا ﻟﻢ ﻳﺘﺤﻘﻖ اﻟﺸﺮط‬
‫ﻓﺎن‬

‫أداة اﻟﻌﻨﻮﻧﺔ )&( و )*( ‪the & and * Pointer‬‬
‫‪Operator‬‬
‫اﻟﻤﺆﺷ ﺮ ‪ Pointer‬ﻫ ﻮ ﻋ ﻨﻮان اﻟﻤﺘﻐ ﻴﺮ اﻟﻤﺆﺷ ﺮ ﻓ ﻲ اﻟﺬاﻛ ﺮة ‪ ،‬وﻟﻠﻤﺘﻐ ﻴﺮ اﻟﻤﺆﺷ ﺮ ﻓﻮاﺋ ﺪ‬
‫ﺟﻤ ﺔ ﻓ ﻲ ﻋﻤﻠ ﻴﺔ اﻟ ﺒﺮﻣﺠﺔ ﻧﺬﻛ ﺮﻫﺎ ﻋ ﻨﺪ اﻟ ﺘﻌﺮض ﻟﻬ ﺎ ﻓ ﻲ اﻟﻔﺼ ﻮل اﻟﻘﺎدﻣ ﺔ ﺑ ﺈذن اﷲ ‪،‬‬
‫وﻳﻜ ﺜﺮ اﺳ ﺘﻌﻤﺎل ﻫﺎﺗﻴ ﻦ اﻟﺪاﻟﺘﻴ ﻦ ﻣ ﻊ اﻟﻤﺘﻐ ﻴﺮات اﻟﻤﺆﺷ ﺮة اﻟﻤﺤﺠ ﻮزة ﻟﻬ ﺎ ﻓ ﻲ أﻣﺎﻛ ﻦ‬
‫ﺧﺎﺻﺔ ﻓﻲ اﻟﺬاﻛﺮة ‪.‬‬
‫وﺗﻌ ﺪ اﻷداة & ﻫ ﻨﺎ أداة أﺣﺎدﻳ ﺔ ﺗ ﺘﻌﺎﻣﻞ ﻣ ﻊ ﻛﻤﻴﺔ واﺣﺪة ﻓﻘﻂ ‪ ،‬ﺣﻴﺚ ﺗﻘﻮم ﺑﺈﻋﻄﺎء ﻋﻨﻮان‬
‫اﻟﻄﺮف اﻷﻳﻤﻦ ﻟﻠﻤﻌﺎدﻟﺔ ‪ ،‬ﻟﻠﻄﺮف اﻷﻳﺴﺮ ﻣﻨﻬﺎ ‪ ،‬ﻓﻤﺜﻼ اﻟﻌﻤﻠﻴﺔ‪:‬‬
‫;‪X=&y‬‬
‫ﺗﻌﻄ ﻲ ﻋ ﻨﻮان ‪ y‬ﻓ ﻲ اﻟﺬاﻛ ﺮة ‪ ،‬ووﺿ ﻌﻪ ﻓ ﻲ ﻣﺨﺰن ‪ ، x‬وﻫﺬه اﻟﺠﻤﻠﺔ ﺗﺨﺘﻠﻒ ﻃﺒﻌﺎ ﻋﻦ‬
‫اﻟﺠﻤﻠ ﺔ اﻟﺤﺴ ﺎﺑﻴﺔ ‪ x=y‬اﻟﺘ ﻲ ﻣﻌ ﻨﺎﻫﺎ وﺿ ﻊ ﻗ ﻴﻤﺔ ‪ y‬ﻓ ﻲ ﻣﺨ ﺰن ‪ x‬أﻣ ﺎ ﻋ ﻨﺪ اﺳﺘﻌﻤﺎل &‬
‫ﻗ ﺒﻞ ‪ y‬ﻓﻤﻌ ﻨﺎﻫﺎ إﻋﻄ ﺎء ﻋ ﻨﻮان ﻣﺨ ﺰن ‪ y‬ﻓ ﻲ اﻟﺬاﻛ ﺮة ﻓﻘ ﻂ ﻟﻠﻤﺘﻐ ﻴﺮ ‪ ، x‬وﻟ ﻴﺲ ﻗ ﻴﻤﺔ ‪y‬‬
‫ﻓﻠ ﻮ ﻛﺎﻧ ﺖ ‪ ، y=10‬ورﻗ ﻢ )ﻋ ﻨﻮان( ﻣﻮﺿ ﻌﻬﺎ ﻓ ﻲ اﻟﺬاﻛ ﺮة ﻫﻮ ‪ ، 120‬ﻓﺎن ‪ x‬ﺗﺄﺧﺬ ﻗﻴﻤﺔ‬
‫‪ 120‬ﻋ ﻨﺪ اﺳ ﺘﻌﻤﺎﻟﻨﺎ & ﻣ ﻊ ‪ y‬وﺑﺎﻟﻨﺴ ﺒﺔ ﻟ ﻸداة اﻟﺜﺎﻧ ﻴﺔ * ﻓﻬ ﻲ أداة أﺣﺎدﻳ ﺔ أﻳﻀ ﺎ ‪،‬‬
‫وﻣﻜﻤﻠﺔ ﻟﻸداة & ‪ ،‬وﻟﺬﻟﻚ ﻟﻮ ﻛﺎن ﻟﺪﻳﻨﺎ اﻟﺠﻤﻠﺔ اﻟﺘﺎﻟﻴﺔ اﻟﺘﻲ ﺗﺴﺘﻌﻤﻞ اﻷداة * ‪.‬‬
‫;‪S=*x‬‬
‫ﻓﺎﻧ ﻪ ﻳﻔﻬ ﻢ ﻣ ﻨﻬﺎ أن ‪ x‬ﺗﺤ ﻮى ﻋ ﻨﻮان )ﻣﻮﻗ ﻊ( اﻟﻤﺘﻐ ﻴﺮ ‪ y‬ﻓ ﻲ اﻟﺬاﻛ ﺮة ‪ ،‬وان ﻫ ﺬه اﻟﺠﻤﻠﺔ‬
‫ﺗﻀ ﻊ ﻓ ﻲ ﻣﺨ ﺰن ‪ s‬ﻗ ﻴﻤﺔ اﻟﻤﺘﻐ ﻴﺮ ‪ ،‬ﺻ ﺎﺣﺐ اﻟﻤﺨﺰن اﻷﺻﻞ ‪ ،‬آي ﻗﻴﻤﺔ ‪ y‬وﻫﻲ ‪ 10‬ﻛﻤﺎ‬
‫ﻓ ﻲ اﻟﻤ ﺜﺎل اﻟﺴ ﺎﺑﻖ ‪ ،‬وﺑﺎﻟﺘﺎﻟ ﻲ ﻓ ﺎن ﻗ ﻴﻤﺔ ‪ 10‬ﺗﺨ ﺰن ﻓ ﻲ ﻣﺨ ﺰن ‪ s‬ﻓ ﻲ اﻟﻤﻮﻗ ﻊ )اﻟﻌ ﻨﻮان(‬
‫‪ 120‬ﻟﺬﻟ ﻚ ﻧ ﺮى أن ﺟﻤﻠ ﺔ ‪ x=*&y‬ﺗﻜﺎﻓ ﺌﻬﺎ اﻟﺠﻤﻠ ﺔ ‪ x=y‬وﻫ ﺬا ﻳﻌﻨ ﻲ أن اﻷداﺗﻴ ﻦ‬
‫ﺗﻌﻤﻼن وﻛﺄن اﻟﻮاﺣﺪة ﻣﻌﻜﻮﺳﺔ ﻟﻸﺧﺮى‬
‫وﻣﻤ ﺎ ﻳﺠ ﺐ اﻻﻧﺘ ﺒﺎه إﻟ ﻴﻪ ‪ ،‬أن اﻷداة * ﺗﺴ ﺘﺨﺪم أﻳﻀ ﺎ ﻟﻌﻤﻠ ﻴﺎت اﻟﻀ ﺮب اﻟﺤﺴ ﺎﺑﻲ ﻛﻤ ﺎ‬
‫ﺗﺴ ﺘﻌﻤﻞ اﻷداة & ﻛ ﺄداة ‪ AND‬دﻗ ﻴﻘﺔ ‪ ،‬وﻟ ﺬا ﻻ ﻳﻠﺘ ﺒﺲ ﻋﻠ ﻴﻚ اﻷﻣ ﺮ ﺑﻴ ﻦ اﻻﺳ ﺘﻌﻤﺎﻟﻴﻦ‬
‫اﻟﻤﺨﺘﻠﻔﻴﻦ‪.‬‬

‫أداة ﺗﻌﻴﻴﻦ اﻟﻄﻮل ‪sizeof‬‬
‫ﺗﻌ ﺪ ﻫ ﺬه اﻷداة أداة أﺣﺎدﻳ ﺔ )‪ ، (unary‬وﺗﺴ ﺘﻌﻤﻞ ﻟﺘﻌﻴﻴ ﻦ ﻃ ﻮل اﻟﻤﺘﻐ ﻴﺮات ) ﺑﺎﻟﺒﺎﻳ ﺖ( ‪،‬‬
‫وﺗﺨ ﺘﻠﻒ أﻃ ﻮال اﻟﻤﺘﻐ ﻴﺮات ﺣﺴ ﺐ أﻧﻮاﻋﻬ ﺎ ‪ ،‬وﻟ ﺬا ﻃﻠ ﺐ ﺗﻌﻴﻴ ﻦ ﻃ ﻮل ﻣﺘﻐ ﻴﺮ ﺑﺎﺳ ﺘﻌﻤﺎل‬
‫‪ ، sizeof‬ﻳﻨﺒﻐﻲ ذﻛﺮ ﻧﻮع ﻫﺬا اﻟﻤﺘﻐﻴﺮ ﺑﻴﻦ ﻗﻮﺳﻲ ‪ ،sizeof‬ﻓﻤﺜﻼ‪:‬‬
‫;‪Int n‬‬
‫;)‪N=sizeof (n‬‬
‫ﺣﻴ ﺚ ﺳ ﺘﻜﻮن ﻧﺘ ﻴﺠﺔ ‪ n‬ﻫ ﻨﺎ ﺗﺴ ﺎوي ‪ 2‬ﺑﺎﻳ ﺖ ‪ ،‬ﻫ ﻲ ﻃ ﻮل اﻟﻤﺘﻐﻴﺮ ‪ n‬اﻟﺼﺤﻴﺢ )‪ (int‬ﻻن‬
‫ﻃﻮل اﻟﺼﺤﻴﺢ ﻋﺎدة ﻫﻮ ‪ 2‬ﺑﺎﻳﺖ ‪ ،‬وﻃﻮل اﻟﺤﻘﻴﻘﻲ ‪ 4‬ﺑﺎﻳﺖ ‪ ،‬ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫;‪Float x‬‬
‫;)‪Z=sizeof (x‬‬
‫ﺣﻴﺚ ﺳﺘﻜﻮن ﻧﺘﻴﺠﺔ ‪ z‬ﻫﻲ ‪ 4‬ﺑﺎﻳﺖ ‪ ،‬وﻫﻲ ﻃﻮل ‪ x‬اﻟﺤﻘﻴﻘﻲ‪.‬‬

‫اﻟﻔﺎﺻﻠﺔ )‪ (,‬ﻛﺄداة ‪The Comma Operator‬‬
‫وﻫ ﻲ أداة اﺳ ﺘﺜﻨﺎﺋﻴﺔ )‪ (binary‬وﺗﺤ ﺘﻞ اﻷوﻟﻮﻳ ﺔ اﻷﺧ ﻴﺮة ﻓ ﻲ ﺳﻠﻢ اﻷداة اﻟﻤﺨﺘﻠﻔﺔ وﺗﺄﺧﺬ‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪Experssion1, Experssion2‬‬
‫ﻓﻌﻨﺪﻣﺎ ﺗﻔﺼﻞ ﻓﺎﺻﻠﺔ ﺑﻴﻦ ﺗﻌﺒﻴﺮﻳﻦ ﻓﺎن ﺗﺴﻠﺴﻞ اﻟﻌﻤﻠﻴﺎت ﻳﺄﺧﺬ اﻟﺘﺮﺗﻴﺐ اﻟﺘﺎﻟﻲ‪:‬‬
‫‪ -١‬ﺗﺴﺘﺨﺮج ﻗﻴﻤﺔ اﻟﺘﻌﺒﻴﺮ اﻷول ) ﻋﻠﻲ ﻳﺴﺎر اﻟﻔﺎﺻﻠﺔ ( ﺛﻢ ﺗﻌﻄﻰ ﻟﻠﺘﻌﺒﻴﺮ اﻟﺜﺎﻧﻲ‪.‬‬
‫‪ -٢‬ﺗﺴ ﺘﺨﺮج ﻗ ﻴﻤﺔ اﻟﺘﻌﺒ ﻴﺮ اﻟﺜﺎﻧ ﻲ ) ﻋﻠ ﻲ ﻳﻤﻴ ﻦ اﻟﻔﺎﺻ ﻠﺔ ( ﻛﻘ ﻴﻤﺔ ﻧﻬﺎﺋ ﻴﺔ ﻟﻠﺘﻌﺒ ﻴﺮ ﻛﻠ ﻪ‬
‫ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫;)‪A=(b=2,b+1‬‬
‫ﺣﻴ ﺚ ﻳﻌﻄ ﻰ اﻟﻤﺘﻐ ﻴﺮ ‪ b‬ﻗ ﻴﻤﺔ ‪ 2‬ﻓ ﻲ اﻟﺘﻌﺒ ﻴﺮ اﻷول ) ﻳﺴ ﺎر اﻟﻔﺎﺻ ﻠﺔ( ‪ ،‬ﺛ ﻢ وﺿ ﻊ ﻫ ﺬه‬
‫اﻟﻘ ﻴﻤﺔ ﻓ ﻲ ‪ b‬اﻷﺧ ﺮى ﻓ ﻲ اﻟﺘﻌﺒ ﻴﺮ اﻟﺜﺎﻧ ﻲ ) ﻳﻤﻴ ﻦ اﻟﻔﺎﺻ ﻠﺔ( ‪ ،‬ﻓﺘﺼ ﺒﺢ ﻗﻴﻤﺔ اﻟﺘﻌﺒﻴﺮ ﻋﻠﻰ‬
‫اﻟﻴﻤﻴﻦ )‪ (b+1‬ﺗﺴﺎوي ‪ 3‬وﺗﻜﻮن ﻫﺬه اﻟﻘﻴﻤﺔ ﻧﺘﻴﺠﺔ اﻟﺘﻌﺒﻴﺮﻳﻦ اﻟﻨﻬﺎﺋﻴﺔ ‪.‬‬
‫ﻣﺜﺎل آﺧﺮ‪:‬‬
‫;‪B=8‬‬
‫;)‪A=(b=b-4,12/b‬‬
‫ﻓ ﻲ ﻫ ﺬا اﻟﻤ ﺜﺎل ﻳ ﺘﻢ إﻋﻄ ﺎء ‪ b‬اﻟﻘ ﻴﻤﺔ ‪ 8‬أوﻻ ‪ ،‬ﺛ ﻢ ﻋ ﻨﺪ ﺗﻨﻔ ﻴﺬ اﻟﺴ ﻄﺮ اﻟﺜﺎﻧ ﻲ ‪ ،‬ﻳﻌﻄ ﻲ ‪b‬‬
‫ﻓ ﻲ اﻟﺘﻌﺒ ﻴﺮ اﻷول داﺧ ﻞ اﻟﻘﻮﺳ ﻴﻦ اﻟﻘ ﻴﻤﺔ )‪ (b-4‬آي )‪ ، (8-4‬وﺗﺴ ﺎوي ‪ ، 4‬وﻫ ﺬه‬
‫ﺗﻌﻄ ﻰ ﻟﻠﺘﻌﺒ ﻴﺮ اﻷﻳﻤ ﻦ ‪ ،‬ﺣﻴ ﺚ ﺗ ﺘﻢ اﻟﻘﺴ ﻤﺔ )‪ (12/b‬آي )‪ (12/4‬ﻓﺘﺼ ﺒﺢ ﻧﺘ ﻴﺠﺔ اﻟﺘﻌﺒ ﻴﺮ‬
‫ﻛﻠﻪ ‪ ، 3‬اﻟﺘﻲ ﺗﻌﻄﻲ ﺑﺎﻟﺘﺎﻟﻲ ﻟﻠﻤﺘﻐﻴﺮ ‪. a‬‬

‫ﺟﻤﻞ اﻟﺘﻌﺮﻳﻒ‬
‫ﺟﻤﻞ اﻟﺘﻌﺮﻳﻒ ﻫﻲ ﺟﻤﻞ ﺗﻘﻮم ﺑﺘﻌﺮﻳﻒ اﻟﻘﻴﻢ‪.‬‬
‫;‪Int a‬‬
‫ﻳﻘﺎﺑﻞ ﻫﺬه اﻟﺠﻤﻠﺔ ﻓﻲ ﻓﻴﺠﻮال ﺑﻴﺴﻚ‬

‫‪Dim a as integer‬‬
‫وﺗﻘﻮم ﺑﺤﺠﺰ ﻣﻜﺎن ﻓﻲ اﻟﺬاﻛﺮة اﻟﻤﺸﺎر إﻟﻴﻪ ‪ ،‬ﺑﺎﻻﺳﻢ ‪ a‬ﻟﺘﺨﺰﻳﻦ ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﺻﺤﻴﺤﺔ‪.‬‬
‫أﻧﻮاع اﻟﺒﻴﺎﻧﺎت اﻟﻤﻤﻜﻦ ﺗﺨﺰﻳﻨﻬﺎ ﻓﻲ اﻟﺬاﻛﺮة اﻟﻤﺴﺘﺨﺪﻣﺔ ﻟـ ‪C++‬‬

‫‪ char .١‬ﻟﺘﺨﺰﻳﻦ رﻣﺰ واﺣﺪ ﻓﻘﻂ‪.‬‬
‫‪ int .٢‬ﻟﺘﺨﺰﻳﻦ ﻋﺪد ﺻﺤﻴﺢ‪.‬‬
‫‪ float .٣‬ﻟﺘﺨﺰﻳﻦ ﻋﺪد ﺣﻘﻴﻘﻲ‪.‬‬
‫‪ double .٤‬ﻟﺘﺨﺰﻳﻦ ﻋﺪد ﺣﻘﻴﻘﻲ ﻛﺒﻴﺮ‪.‬‬
‫‪ void .٥‬ﻟﺘﺨﺰﻳﻦ ﺑﻴﺎﻧﺎت ﺧﺎﻟﻴﺔ‪.‬‬
‫أن ﻣﻌ ﺮﻓﺔ أﻧ ﻮاع اﻟﺒ ﻴﺎﻧﺎت ‪ ،‬وﻛﻴﻔ ﻴﺔ اﺳ ﺘﻌﻤﺎﻟﻬﺎ ‪ ،‬ﺗﻌ ﺪ ﺿ ﺮورﻳﺔ ﻟﻔﻬ ﻢ ﻟﻐ ﺔ ‪c++‬‬
‫ﻓﻼﺳ ﺘﻌﻤﺎل اﻟﻤﺘﻐ ﻴﺮات ‪ ،‬ﻣ ﺜﻼ ‪ ،‬ﻧﺤ ﺘﺎج أن ﻧﻌﻠ ﻦ ﻓ ﻲ ﺑﺪاﻳ ﺔ ﻛ ﻞ ﺑ ﺮﻧﺎﻣﺞ ‪ ،‬أو ﺑﺪاﻳﺔ اﻟﺪوال‬
‫ﻋ ﻦ أﻧ ﻮاع ﻫ ﺬه اﻟﻤﺘﻐ ﻴﺮات ‪ ،‬وﻳ ﺘﻢ اﻟ ﺘﻌﺎﻣﻞ ﻣﻌﻬ ﺎ ‪ ،‬ﺧ ﻼل اﻟ ﺒﺮﻧﺎﻣﺞ ‪ ،‬ﻓ ﻲ ﺿ ﻮء أﻧ ﻮاع‬
‫ﻣﻌﻄﻴﺎﺗﻬﺎ ﻓﻤﺜﻼ اﻹﻋﻼن ﻋﻦ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫;‪Int a,b,x‬‬
‫ﺗﺨ ﺒﺮ ﻣ ﺘﺮﺟﻢ ‪ c++‬أن ﻳ ﺘﻌﺎﻣﻞ ﻣ ﻊ ﻫ ﺬه اﻟﻤﺘﻐ ﻴﺮات ‪ ،‬ﻋﻠ ﻰ أﻧﻬ ﺎ ﻣﺘﻐ ﻴﺮات ﺻ ﺤﻴﺤﺔ‬
‫وﻛﺬﻟﻚ ﺟﻤﻠﺔ اﻹﻋﻼن اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫;‪Float m,y‬‬
‫ﺗﺨﺒﺮ ﻣﺘﺮﺟﻢ ‪ (C++ compiler) c++‬أن ﻫﺬه اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع اﻟﺤﻘﻴﻘﻲ‪.‬‬

‫اﻟﺜﻮاﺑﺖ اﻟﺮﻣﺰﻳﺔ ذات اﻟﺸﺮﻃﺔ اﻟﻤﻌﻜﻮﺳﺔ‬
‫ﺣﻴ ﺚ أﻧ ﻨﺎ ﻻ ﻧﺴ ﺘﻄﻴﻊ اﺳ ﺘﻌﻤﺎل ﺑﻌ ﺾ اﻟ ﺮﻣﻮز اﻟﻤﻮﺟ ﻮدة ﻓ ﻲ ﻟﻮﺣ ﺔ ﻣﻔﺎﺗ ﻴﺢ اﻟﺤﺎﺳ ﺐ‬
‫ﻛﺜﻮاﺑ ﺖ رﻣ ﺰﻳﺔ ‪ ،‬ﻓﻘ ﺪ اﺳ ﺘﺤﺪث ﻟﻐ ﺔ ‪ c++‬ﺷ ﻔﺮات رﻣ ﺰﻳﺔ ﺧﺎﺻ ﺔ ﺗﺴ ﺘﻌﻤﻞ ﺷ ﺮﻃﺔ‬
‫ﻣﻌﻜﻮﺳﺔ ﻟﻬﺎ ‪ ،‬وﻫﺬه اﻟﺸﻔﺮات ﻣﺪوﻧﺔ ﻓﻲ اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪:‬‬
‫اﻟﻘﻴﻤﺔ اﻟﺼﺤﻴﺤﺔ ﻟﻬﺎ‬ ‫ﻣﻌﻨﺎﻫﺎ‬ ‫اﻟﺸﻔﺮة‬

‫‪8‬‬ ‫رﺟﻮع ﺑﻤﻘﺪار ﺧﺎﻧﺔ واﺣﺪة‬ ‫"‪"\b‬‬
‫‪13‬‬ ‫ﺳﻄﺮ ﺟﺪﻳﺪ‬ ‫"‪"\n‬‬
‫‪9‬‬ ‫ﺗﺮﺗﻴﺐ أﻓﻘﻲ‬ ‫"‪"\t‬‬
‫‪0‬‬ ‫ﻟﻠﻘﻴﻤﺔ اﻟﺨﺎﻟﻴﺔ‬ ‫"‪"\0‬‬
‫‪13‬‬ ‫ﻋﻼﻣﺔ رﺟﻮع‬ ‫"‪"\r‬‬
‫‪11‬‬ ‫ﺗﺮﺗﻴﺐ ﻋﻤﻮدي‬ ‫"‪"\v‬‬
‫‪92‬‬ ‫اﻟﺸﺮﻃﺔ اﻟﻤﻌﻜﻮﺳﺔ \‬ ‫"\\"‬
‫‪12‬‬ ‫ﺗﻘﺪﻳﻢ ﺻﻔﺤﺔ‬ ‫"‪"/f‬‬
‫اﻟﺠﺪول‪١-١٠‬‬
‫وﻟﺒﻴﺎن أﻫﻤﻴﺔ ﻫﺬه اﻟﺸﻔﺮات ‪ ،‬ﺧﺬ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫"‪"first line\n second line‬‬
‫ﻟ ﻮ ﻃ ﺒﻊ ﻫ ﺬا اﻟ ﻨﺺ )اﻟﺜﺎﺑ ﺖ اﻟﺮﻣ ﺰي( ﻓﺎﻧ ﻪ ﺳ ﻴﻈﻬﺮ ﻓ ﻲ ﺳ ﻄﺮﻳﻦ ﻣﺘﺘﺎﻟﻴ ﻦ ﻋﻠ ﻰ اﻟ ﻨﺤﻮ‬
‫اﻟﺘﺎﻟﻲ‪:‬‬
‫‪First line‬‬
‫‪Second line‬‬
‫وﻣ ﻦ اﻟﺠﺪﻳ ﺮ ﺑﺎﻟﺬﻛ ﺮ ‪ ،‬أن أﻫ ﻢ ﺗﻄﺒ ﻴﻘﺎت اﻟﻤﻌﻄ ﻴﺎت اﻟﺮﻣ ﺰﻳﺔ واﺳ ﺘﻌﻤﺎﻻﺗﻬﺎ ‪ ،‬ﻫ ﻮ ﻣﻌﺎﻟﺠ ﺔ‬
‫اﻟﻨﺼ ﻮص ‪ ،‬وﻣ ﺎ ﻳﺴ ﺘﺤﻖ اﻟﺘﺴ ﺠﻴﻞ واﻻﻫ ﺘﻤﺎم ‪ ،‬اﻧ ﻪ ﻳﻤﻜ ﻦ إﺟ ﺮاء ﻋﻤﻠ ﻴﺎت ﻋﻠ ﻰ‬
‫اﻟﻤﻌﻄﻴﺎت اﻟﺮﻣﺰﻳﺔ‪.‬‬

‫اﻟﻤﻼﺣﻈﺎت واﻟﺘﻌﻠﻴﻘﺎت ﻓﻲ ‪Comments c++‬‬
‫ﺗﺴﺘﻌﻤﻞ ﺳﺎﺋﺮ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﺟﻤﻼ ﻟﻠﺘﻌﻠﻴﻘﺎت واﻟﻤﻼﺣﻈﺎت ‪ ،‬وﻛﺬﻟﻚ ﻟﻐﺔ ‪ C++‬ﻣﺜﻼ‬
‫اﻟﺠﻤﻠﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪10 rem this is Islam‬‬
‫ﻫﻲ ﺟﻤﻠﺔ ﻣﻼﺣﻆ ﻓﻲ ﻟﻐﺔ ﺑﻴﺴﻚ ‪ ،‬ﺗﻘﺎﺑﻠﻬﺎ ﺟﻤﻠﺔ ﺗﻌﻠﻴﻖ اﻟﺘﺎﻟﻴﺔ ﻓﻲ ﻟﻐﺔ ‪:C++‬‬
‫‪// this is Islam‬‬
‫اﻟﺘﻲ ﺗﻮﺿﺢ ﺑﻌﺪ ﺷﺮﻃﺘﻴﻦ )ﺧﻄﻴﻦ ﻣﺎﺋﻠﻴﻦ(‬

‫وﺗﺴ ﺘﻌﻤﻞ ﺟﻤ ﻞ اﻟﺘﻌﻠ ﻴﻖ ‪ ،‬ﻓ ﻲ أي ﻣﻜ ﺎن ﻣ ﻦ اﻟ ﺒﺮﻧﺎﻣﺞ ﻹﺑﺪاء ﻣﻼﺣﻈﺔ ﻣﺎ ‪ ،‬ﻋﻨﺪ ﺳﻄﺮ ﻣﺎ‬
‫ﻓ ﻲ اﻟ ﺒﺮﻧﺎﻣﺞ ‪ ،‬وﻻ ﺗﻌ ﺪ ﺟﻤﻠ ﺔ ﺗﻨﻔ ﻴﺬﻳﺔ ‪ ،‬ﺑﻤﻌﻨﻰ أﻧﻬﺎ ﻟﻮ ﺣﺬﻓﺖ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪ ،‬ﻻ ﻳﺆﺛﺮ ﻓﻴﻪ‬
‫ذﻟﻚ ﺷﻴﺌﺎ ‪ ،‬وﻋﺎدﺗﺎ ﻣﺎ ﻳﺘﺠﺎﻫﻠﻬﺎ اﻟﻤﺒﺮﻣﺠﻴﻦ ‪.‬‬
‫ﻣﺜﺎل‪ :‬ﻻﺣﻆ ﺟﻤﻞ اﻟﺘﻌﻠﻴﻖ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪this is comment//‬‬
‫‪/*an example on comment in c++ language */‬‬
‫‪/*main() /* start your program‬‬
‫{‬
‫‪int x,y,z; //this line declares type of x,y,z‬‬
‫}‬
‫وﻣﻦ اﻟﺠﺪﻳﺮ ﺑﺎﻟﺬﻛﺮ ﻫﻨﺎ ‪ ،‬ﻣﺎ ﻳﺄﺗﻲ‪:‬‬

‫ﻻ ﻳﺘﺮك أي ﻓﺮاغ ﺑﻴﻦ اﻟﺸﺮﻃﺔ ‪ /‬واﻟﻨﺠﻤﺔ * ﻣﻦ ﺟﻬﺘﻲ ﺟﻤﻠﺔ اﻟﺘﻌﻠﻴﻖ‪.‬‬
‫‪ -١‬ﻳﻘﻮم ﻣﺘﺮﺟﻢ ‪ c++‬ﺑﺈﻫﻤﺎل اﻟﻨﺼﻮص اﻟﻤﺴﺘﻌﻤﻠﺔ ﻓﻲ ﺟﻤﻞ اﻟﺘﻌﻠﻴﻖ ‪ ،‬أي أﻧﻬﺎ ﻻ‬
‫ﺗﻨﻔﺬ ‪ ،‬ﺑﻞ ﻫﻲ ﺟﻤﻞ ﺗﻮﺿﻴﺤﻴﺔ ﺗﻈﻬﺮ ﻣﻊ ﻗﺎﺋﻤﺔ اﻟﺒﺮﻧﺎﻣﺞ أو ﺳﻄﻮرا ﻓﻘﻂ ‪.‬‬
‫‪ -٢‬ﻳﻤﻜﻦ وﺿﻊ ﺟﻤﻠﺔ اﻟﻤﻼﺣﻈﺔ واﻟﺘﻌﻠﻴﻖ ﻓﻲ أي ﻣﻜﺎن ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪ ،‬ﻣﺎ ﻋﺪا‬
‫وﺳﻂ اﺳﻢ ﺗﻌﺮﻳﻔﻲ ‪ ، identifier‬أو ﻛﻠﻤﺔ ﻣﺤﺠﻮزة ‪. keyword‬‬

‫ﺗﺸﻐﻴﻞ ‪visual c++6.0‬‬
‫‪Run visual c++6.0‬‬
‫ﻟﺘﺸﻐﻴﻞ ﺑﺮﻧﺎﻣﺞ ﻓﻴﺠﻮال ﺳﻲ ‪ ++‬ﻧﺘﺒﻊ اﻟﺘﺎﻟﻲ‪:‬‬

‫أﺑﺪا‪ Ù‬اﻟﺒﺮاﻣﺞ‪visualc++6.0 Ù‬‬
‫ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﺳﺘﻈﻬﺮ ﻟﻨﺎ اﻟﺸﺎﺷﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫ﻧﺨﺘﺎر اﻟﻘﺎﺋﻤﺔ ‪ file‬ﻣﻦ ﻫﻨﺎ‬
‫ﻧﺨ ﺘﺎر ﻣ ﻦ ﻫ ﺬه اﻟﺸﺎﺷ ﺔ ﻛﻤ ﺎ ﻫ ﻮ واﺿ ﺢ اﻟﻘﺎﺋﻤ ﺔ ‪ File‬ﺛ ﻢ ﺑﻌ ﺪ ذﻟ ﻚ ﻧﺨ ﺘﺎر ﻣ ﻦ اﻟﻘﺎﺋﻤ ﺔ‬

‫‪ New‬ﻟﺘﻈﻬﺮ ﻟﻨﺎ اﻟﺸﺎﺷﺔ اﻟﺘﺎﻟﻴﺔ‪..‬‬

‫ﻧﻄﺒﻖ ﻣﺎ ﻳﻮﺟﺪ ﺑﺎﻟﺼﻮرة ﺑﺎﻷﺳﻔﻞ ﺛﻢ ﻧﺨﺘﺎر ﻣﻮاﻓﻖ‪..‬‬
‫ﻧﺨﺘﺎر ﻫﻨﺎ‬
‫اﻟﺘﺴﻤﻴﺔ اﻟﺨﺎﺻﺔ ﺑﺎﻟﻤﺸﺮوع‬
‫ﺛﻢ ﻧﻨﻘﺮ ‪ok‬‬

‫ﻧﺨﺘﺎر اﻟﺘﻄﺒﻴﻖ اﻟﻤﻮﺟﻮد ﺑﺎﻷﺳﻔﻞ ﺛﻢ ﻧﺨﺘﺎر إﻧﻬﺎء ﻛﻤﺎ ﻫﻮ ﻣﻮﺿﺢ ﺑﺎﻷﺳﻔﻞ‪..‬‬
‫ﻧﺨﺘﺎر ﻫﺬا اﻟﺘﻄﺒﻴﻖ‬
‫ﺛﻢ ﻧﻨﻘﺮ ‪finish‬‬

‫اﻵن ﺳﺘﻈﻬﺮ ﻟﻨﺎ ﺷﺎﺷﺔ اﻟﻜﻮد وﻧﻼﺣﻆ ﺑﺎﻷﺳﻔﻞ اﻟﺸﺎﺷﺔ‪..‬‬
‫ﺑﻌ ﺪ ذﻟ ﻚ ﻧﺨ ﺘﺎر ﻣ ﻦ اﻟﻘﺎﺋﻤ ﺔ ‪ Build‬ﺛ ﻢ ﻧﺨ ﺘﺎر ‪ Execute .exe‬ﻟﻴﻄ ﺒﻖ ﻟ ﻨﺎ اﻟﻤﺸ ﺮوع ‪..‬‬
‫أو ﺑﺎﻟﻨﻘﺮ ﻣﻦ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ ﻋﻠﻰ اﻟﺰر ‪. F5‬‬

‫ﻃﺒﻌﺎ ﺑﻌﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﺘﻈﻬﺮ ﻟﻨﺎ اﻟﻨﺘﺎﺋﺞ ﻛﻤﺎ ﻓﻲ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬
‫ﻃ ﺒﻌﺎ أﻋﺰاﺋ ﻲ ﻫ ﺬا اﻟ ﺒﺮﻧﺎﻣﺞ اﻟﺼ ﻐﻴﺮ ﻫ ﻮ ﺑ ﺮﻧﺎﻣﺞ ﺗﻼﺣﻈ ﻮن أن اﻟﻜ ﻮد ﺗ ﺒﻌﻪ ﺧ ﺎص ﺑﻠﻐﺔ‬
‫‪ C‬اﻻم وﻟ ﻴﺲ ‪ c++‬ﻟﻜ ﻦ ﻣ ﺎ ﻧﻌﻤ ﻞ ﻋﻠ ﻴﻪ ﻫ ﻮ ﻣ ﺘﺮﺟﻢ ﻳﻘ ﺒﻞ اﻟﻠﻐﺘﻴ ﻦ ﻣﻌ ﺎ واﻟﻤ ﺘﺮﺟﻢ ﻫ ﻮ‬
‫‪ ، Visual C++‬وﻧﻼﺣ ﻆ اﻧ ﻪ ﺗ ﻢ ﻃ ﺒﺎﻋﺔ ﻋ ﺒﺎرة !‪ Hello World‬وﻫ ﻲ ﻧﺘ ﻴﺠﺔ ﺗﻨﻔ ﻴﺬ‬
‫اﻟﺪاﻟﺔ )(‪ printf‬اﻟﻤﻮﺟﻮدة ﻓﻲ ﺳﻄﻮر اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬

‫أﺳﺎﻟﻴﺐ اﻹدﺧﺎل واﻹﺧﺮاج‬
‫‪Input/output Techniques‬‬
‫ﻣﻘﺪﻣﺔ ‪introduction‬‬
‫ﻳﺘ ﻨﺎول ﻫ ﺬا اﻟﺠ ﺰء أﺳ ﺎﻟﻴﺐ إدﺧ ﺎل اﻟﻘ ﻴﻢ اﻟﺤﺴ ﺎﺑﻴﺔ واﻟﺮﻣ ﺰﻳﺔ ‪ ،‬وأﺳ ﺎﻟﻴﺐ إﺧ ﺮاج وﻃﺒﺎﻋﺔ‬
‫ﻧ ﺘﺎﺋﺞ اﻟ ﺒﺮاﻣﺞ واﻟﺘﻌﺎﺑ ﻴﺮ اﻟﺤﺴ ﺎﺑﻴﺔ واﻟﺮﻣ ﺰﻳﺔ ‪ ،‬وﻃ ﺒﺎﻋﺔ اﻟﻤﻌﻄ ﻴﺎت اﻟﻤﺨ ﺘﻠﻔﺔ ﺣﺴ ﺐ‬
‫اﻟﺤﺎﺟﺔ‪.‬‬
‫ﻟﻘ ﺪ ﺗﻌﻮدﻧ ﺎ ﻓ ﻲ ﻟﻐ ﺔ ﺑﻴﺴ ﻚ ‪ ،‬أن ﻧﺴ ﺘﻌﻤﻞ دوال ﻣﺒﻨ ﻴﺔ وﺟﺎﻫ ﺰة ﻋﻨﺪ اﻟﻄﻠﺐ ﻟﻠﻘﻴﺎم ﺑﺎﻹدﺧﺎل‬
‫ﻣ ﺜﻞ )‪ input‬أو ‪ (read‬أو ﺑﺎﻹﺧ ﺮاج ﻣ ﺜﻞ )‪ ، (print‬وﻓ ﻲ ﻫ ﺬا اﻟﺼ ﺪد ‪ ،‬ﻓ ﺎن ﻟﻐ ﺔ‬
‫‪ ، C++‬ﺗ ﺘﻌﺎﻣﻞ ﻣ ﻊ اﻹدﺧ ﺎل واﻹﺧ ﺮاج ‪ ،‬ﺑﻄ ﺮﻳﻘﺔ ﻣﺨ ﺘﻠﻔﺔ‪ ،‬ﺣﻴ ﺚ ﺗﻮﻓ ﺮ اﻟﻠﻐ ﺔ ‪ ،‬ﻋ ﺪدا‬
‫ﻛﺒ ﻴﺮا ﻣ ﻦ دوال اﻹﺧ ﺮاج واﻹدﺧ ﺎل ‪ ،‬ﺣﻴ ﺚ ﻳﻤﻜﻦ ﻟﻠﻤﺒﺮﻣﺞ أن ﻳﺴﺘﺪﻋﻴﻬﺎ ‪ ،‬وﻳﺴﺘﻔﻴﺪ ﻣﻨﻬﺎ‬
‫‪ ،‬ﺣﺴ ﺐ ﻧ ﻮع اﻟﻤﻌﻄ ﻴﺎت واﻟﻤﺘﻐ ﻴﺮات ‪ ،‬ﻛ ﻴﻔﻤﺎ ﻳﻨﺎﺳﺒﻪ ‪ ،‬وﺳﻮف ﻧﻮرد أن ﺷﺎء اﷲ ﻓﻲ ﻫﺬا‬
‫اﻟﻔﺼﻞ أﻫﻢ ﻫﺬه اﻟﺪوال واﺷﻬﺮﻫﺎ ﻟـ ‪. C++‬‬

‫اﻹدﺧﺎل واﻹﺧﺮاج ‪input\output‬‬
‫ﺗﻮﻓ ﺮ ﻟﻐ ﺔ ‪ ، C++‬ﻣﺠﻤﻮﻋ ﺔ ﻣ ﻦ اﻟ ﺪوال واﻟﺮوﺗﻴﻨ ﻴﺎت اﻟﻤﻌ ﺮﻓﺔ ﺿ ﻤﻦ ‪ Iostream‬ﻣ ﺜﻞ‬
‫‪ cout‬ﻟﻺﺧﺮاج و ‪ cin‬ﻟﻺدﺧﺎل وﺳﻮف ﻧﻌﺮف اﻟﻤﻠﻒ ‪iostream.h‬‬
‫اﻟﻤﻠﻒ ‪ Iostream.h‬ﻳﻌﻨﻲ‪:‬‬
‫‪ : io‬ﻣﺨﺘﺼﺮ ﻟـ ‪ input/output‬آي اﻹدﺧﺎل واﻹﺧﺮاج‪.‬‬
‫‪ : Stream‬ﻣﻜﺘﺒﺔ ﻗﻴﺎﺳﻴﺔ ﺧﺎﺻﺔ ﺑﺎﻹﺧﺮاج واﻹدﺧﺎل اﻟــﺦ‪..‬‬
‫‪ header file : H‬آي اﻟﻤﻠﻒ اﻟﺪﻟﻴﻞ‪.‬‬
‫ﻣﺜﺎل‪:١‬‬
‫إذا أردت ﻃﺒﺎﻋﺔ اﻟﻌﺪد ‪ 100‬ﻓﻲ ﻟﻐﺔ ﺑﻴﺴﻚ ﻓﺎﻟﺠﻤﻠﺔ‪:‬‬
‫‪Print 100‬‬
‫ﺗﺆدي ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ ‪ ،‬أﻣﺎ ﻓﻲ ﻟﻐﺔ ‪ C++‬ﻓﺎن اﻟﺪاﻟﺔ اﻟﺘﺎﻟﻴﺔ ﺗﻌﻤﻞ ذﻟﻚ‪:‬‬
‫”‪#include “ stdafx.h‬‬
‫”‪#include “ iostream.h‬‬
‫)( ‪main‬‬
‫{‬
‫;‪cout<<100‬‬
‫;‪return0‬‬
‫}‬
‫ﺗ ﺆدي إﻟ ﻰ ﻃ ﺒﺎﻋﺔ اﻟﻌ ﺪد ‪ 100‬ﺣﻴ ﺚ ‪ cout‬اﺳ ﻢ وﺣ ﺪة اﻹﺧ ﺮاج اﻟﻘﻴﺎﺳ ﻲ واﻷداة<<‬

‫ﺗ ﺆدي إﻟ ﻰ إرﺳ ﺎل اﻟﻌ ﺪد ‪ 100‬إﻟ ﻰ وﺣ ﺪة اﻹﺧ ﺮاج ‪ ،‬أن ﻫ ﺬا اﻷﺳ ﻠﻮب اﻟﺠﺪﻳ ﺪ ﻓ ﻲ‬
‫اﻹﺧﺮاج ﻳﺨﺘﻠﻒ ﻋﻤﺎ ﻓﻲ ﻟﻐﺔ ‪. c‬‬

(‫ﻃﺒﺎﻋﺔ اﻟﻨﺼﻮص )اﻟﺜﻮاﺑﺖ اﻟﺮﻣﺰﻳﺔ‬
:٢‫ﻣﺜﺎل‬
:‫ﺗﺄﻣﻞ ﻗﻄﻌﺔ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ‬
#include “ stdafx.h”
#include “ iostream.h” ‫ﻟﻼﻧﺘﻘﺎل ﻟﺴﻄﺮ ﺟﺪﻳﺪ‬
main ()
{
cout<<“smoking is dangerous \n”;;
return0;
}
‫ ﺑﺪﻻ‬endl ‫ وﻗﺪ ﻳﻤﻜﻦ اﺳﺘﺨﺪام اﻟﺪاﻟﺔ‬، ‫\ إﻳﻌﺎز ﻟﻼﻧﺘﻘﺎل إﻟﻰ ﺳﻄﺮ ﺟﺪﻳﺪ‬n ‫ﺑﻌﺒﺎرة أﺧﺮى‬
:‫\ وﻛﻤﺎ ﻳﻠﻲ‬n ‫ﻣﻦ‬
#include “ iostream.h”
main ()
{
cout<<“ smoking is dangerous”<<endl;
return0;
}
:‫وﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻳﻄﺒﻊ اﻟﻨﺎﺗﺞ اﻟﺘﺎﻟﻲ‬

smoking is dangerous

‫ﻣﺜﺎل ‪:٣‬‬
‫ﻟﻼﺳﺘﻔﺎدة ﻣﻦ إﻣﻜﺎﻧﻴﺎت اﻹﻳﻌﺎز ‪ \n‬ﻓﻲ ﻋﻤﻠﻴﺎت اﻟﻄﺒﺎﻋﺔ ‪:‬ﺗﺄﻣﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;”‪cout<<“matrix‬‬
‫;”‪cout<<“matrix \n‬‬
‫;”‪cout<<“matrix \n\n‬‬
‫;”‪cout<<“matrix \n\n\n‬‬
‫;”‪cout<<“matrix‬‬
‫}‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺗﺮى اﻟﻄﺒﺎﻋﺔ اﻟﺘﺎﻟﻴﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪:‬‬

‫اﻟﺴﻄﺮ اﻷول‪matrixmatrix Ù‬‬
‫اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ‪matrix Ù‬‬
‫اﻟﺴﻄﺮ اﻟﺜﺎﻟﺚ‪ Ù‬ﺳﻄﺮ ﻓﺎرغ‬
‫اﻟﺴﻄﺮ اﻟﺮاﺑﻊ‪matrix Ù‬‬
‫اﻟﺴﻄﺮ اﻟﺨﺎﻣﺲ‪Ù‬ﺳﻄﺮ ﻓﺎرغ‬
‫اﻟﺴﻄﺮ اﻟﺴﺎدس‪Ù‬ﺳﻄﺮ ﻓﺎرغ‬
‫ﻧﻼﺣﻆ ﻓﻲ ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬

‫‪ -١‬اﻧ ﻪ ﻳ ﺘﻢ اﻻﻧ ﺘﻘﺎل ﻣ ﻦ اﻟﺴ ﻄﺮ اﻷول ﺑﻌ ﺪ ﻃ ﺒﺎﻋﺔ ‪ matrix‬إﻟ ﻰ اﻟﺴ ﻄﺮ اﻟﺜﺎﻧ ﻲ ﻟﻌ ﺪم‬
‫وﺟ ﻮد إﻳﻌ ﺎز اﻻﻧ ﺘﻘﺎل ‪ ، \n‬وﻟ ﺬا ﻓ ﺎن ﺟﻤﻠ ﺔ اﻟﻄﺎﺑﻌ ﺔ اﻟﺘﺎﻟ ﻴﺔ ﻇﻬ ﺮت ﻧ ﺘﺎﺋﺠﻬﺎ ﻓ ﻲ ا‬
‫ﻟﺴ ﻄﺮ اﻷول ﻧﻔﺴ ﻪ ‪ ،‬ﻣﺘﺼ ﻠﺔ ﺑﻄﺎﻋ ﺔ ‪ matrix‬اﻷوﻟ ﻰ ‪ ،‬وﻳﻨ ﺘﻘﻞ اﻟﻤﺆﺷ ﺮ اﻟﻀ ﻮﺋﻲ‬
‫إﻟﻰ ﺳﻄﺮ ﺟﺪﻳﺪ ﻟﻮﺟﻮد إﻳﻌﺎز ‪. \n‬‬
‫‪ -٢‬ﻳ ﺘﻢ ﺗﻨﻔ ﻴﺬ ﺟﻤﻠ ﺔ اﻟﻄ ﺒﺎﻋﺔ اﻟﺜﺎﻟ ﺜﺔ ﻓ ﻲ اﻟﺴ ﻄﺮ اﻟﺠﺪﻳ ﺪ )اﻟﺜﺎﻧ ﻲ( ‪ ،‬وﻳ ﺘﻢ اﻻﻧ ﺘﻘﺎل إﻟ ﻰ‬
‫اﻟﺴ ﻄﺮ اﻟ ﺮاﺑﻊ ﻗﻔ ﺰا ﻋ ﻦ اﻟﺴ ﻄﺮ اﻟﺜﺎﻟ ﺚ ‪ ،‬وذﻟ ﻚ ﻟﻮﺟﻮد اﻹﻳﻌﺎز ‪ \n\n‬ﺣﻴﺚ ﻳﻘﻮم ﻛﻞ‬
‫إﻳﻌ ﺎز ‪ \n‬ﺑ ﻨﻘﻞ اﻟﻤﺆﺷ ﺮ اﻟﻀ ﻮﺋﻲ ﺳ ﻄﺮا واﺣ ﺪا ‪ ،‬وﻓ ﻲ اﻟﺴ ﻄﺮ اﻟ ﺮاﺑﻊ ﺗﻄ ﺒﻊ ﺟﻤﻠ ﺔ‬
‫اﻟﻄ ﺒﺎﻋﺔ اﻟ ﺮاﺑﻌﺔ ‪ ،‬وﻳ ﺘﻢ ﺑﻌﺪﻫ ﺎ اﻻﻧ ﺘﻘﺎل إﻟ ﻰ اﻟﺴ ﻄﺮ اﻟﺴ ﺎﺑﻊ ﻓ ﻮرا ﺣﺴ ﺐ اﻹﻳﻌ ﺎز‬
‫‪. \n\n\n‬‬

‫ﻃﺒﺎﻋﺔ اﻟﻘﻴﻢ اﻟﻌﺪدﻳﺔ‬
‫ﻣﺜﺎل‪:٤‬‬
‫ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﺑﻄﺎﻋﺔ اﻟﻌﺪد ‪ 446‬ﻛﻘﻴﻤﺔ ﺻﺤﻴﺤﺔ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺤﺎﺳﻮب‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;‪cout<<446‬‬
‫}‬
‫ﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﻳﻈﻬﺮ ﻟﻨﺎ اﻟﺘﺎﻟﻲ‪:‬‬

‫‪446‬‬
‫ﻣﺜﺎل‪:٥‬‬
‫ﺑﺮﻧﺎﻣﺞ ‪ ، C++‬اﻟﺘﺎﻟﻲ ﻳﻄﺒﻊ اﻟﻘﻴﻤﺔ اﻟﺤﻘﻴﻘﺔ ‪:10.5‬‬
‫)( ‪main‬‬
‫{‬
‫;‪cout<<10.5‬‬
‫}‬
‫ﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﻳﻈﻬﺮ اﻟﺘﺎﻟﻲ‪:‬‬

‫‪10.5‬‬

:٦‫ﻣﺜﺎل‬
:‫ اﻟﺘﺎﻟﻲ‬C++ ‫اﻧﻈﺮ ﻣﺎذا ﻳﻔﻌﻞ ﺑﺮﻧﺎﻣﺞ‬
main ()
{
int a=100;
cout<<a;
return0;
}
:‫ﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﻳﻈﻬﺮ ﻟﻨﺎ اﻟﺘﺎﻟﻲ‬

100
:٧‫ﻣﺜﺎل‬
:‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻗﻴﻤﺔ ﻣﺘﻐﻴﺮ ﺣﻘﻴﻘﻲ‬
main ()
{
float x;
x=4.25
cout<<x;
return0;
}
:‫ﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﺳﻴﻈﻬﺮ ﻟﻨﺎ اﻟﺘﺎﻟﻲ‬

4.25

‫ﻣﺜﺎل‪:٨‬‬
‫إذا ﺗﻄﻠ ﺐ اﻷﻣ ﺮ ﻃ ﺒﺎﻋﺔ اﻟﻤﺘﻐﻴﺮﻳ ﻦ ‪ a‬اﻟﺼ ﺤﻴﺢ ‪ ،‬و ‪ x‬اﻟﺤﻘﻴﻘ ﻲ اﻟﻮاردﻳ ﻦ ﻓ ﻲ اﻟﻤﺜﺎﻟﻴ ﻦ‬
‫اﻟﺴﺎﺑﻘﻴﻦ ‪ ،‬ﻓﻲ ﺑﺮﻧﺎﻣﺞ واﺣﺪ ‪ ،‬ﻓﺎﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻜﻮن ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;‪int=100‬‬
‫‪float x=4.25‬‬
‫;‪cout<<a<<x‬‬
‫}‬
‫وﺳﺘﻈﻬﺮ ﻧﺘﺎﺋﺞ ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻛﻤﺎ ﻃﻠﺒﻨﺎ )اﻟﺼﺤﻴﺢ ﻳﺴﺒﻖ اﻟﺤﻘﻴﻘﻲ( ‪ ،‬ﻫﻜﺬا‪:‬‬
‫‪100‬‬ ‫‪4.25‬‬

‫ﻃـﺒﺎﻋﺔ اﻟﻘـﻴﻢ اﻟﻌﺪدﻳـﺔ واﻟﺮﻣﺰﻳﺔ )اﻟﻨﺼﻮص( ﻓﻲ ﺟﻤﻠﺔ‬
‫واﺣﺪة‬
‫ﻣﺜﺎل‪:٩‬‬
‫ﺳﻮف ﻧﻘﻮم ﻓﻲ ﻫﺬا اﻟﻤﺜﺎل ﺑﻄﺒﺎﻋﺔ ﻗﻴﻢ ﻋﺪدﻳﺔ وﻧﺼﻴﺔ ﻣﻊ اﻟﺒﻌﺾ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;‪int a=100‬‬
‫;‪cout<<“a=”<<a‬‬
‫}‬
‫ﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪A=100‬‬
‫ﻣﺜﺎل‪:١٠‬‬
‫ﻣﺎذا إذا أردﻧﺎ ﻃﺒﺎﻋﺔ ﻋﺪد ﺻﺤﻴﺢ وﺣﻘﻴﻘﻲ ﻣﻊ ﻧﺼﻮص ﺑﻨﻔﺲ اﻟﻮﻗﺖ‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;‪int=100‬‬
‫‪float x=4.25‬‬
‫;‪cout<<“a=”<<a<<“x=”<<x‬‬
‫}‬
‫وﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﺳﻴﻈﻬﺮ ﻟﻨﺎ اﻟﺘﺎﻟﻲ‪:‬‬

‫‪A=100 x=4.25‬‬

:١١‫ﻣﺜﺎل‬
‫ ﻓﺠﻤﻠ ﺔ‬، ‫إذا أردﻧ ﺎ أن ﺗﻈﻬ ﺮ ﻧ ﺘﺎﺋﺞ اﻟﻤ ﺜﺎل اﻟﺴ ﺎﺑﻖ ﻓ ﻲ ﺳ ﻄﺮﻳﻦ ﺑ ﺪﻻ ﻣ ﻦ ﺳ ﻄﺮ واﺣ ﺪ‬
:‫اﻟﻄﺒﺎﻋﺔ ﺳﺘﻜﻮن ﻛﺎﻟﺘﺎﻟﻲ‬
main ()
{
int a=100;
float x=4.25
cout<<“a=”<<a<<“\n”<<“x=”<<x;
return0;
}
:‫وﺗﻜﻮن ﻧﺘﻴﺠﺔ اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺼﻮرة اﻟﺘﺎﻟﻴﺔ‬

A=100
X=4.25

‫اﻹدﺧﺎل ﺑﻠﻐﺔ ‪Streams C++‬‬
‫ﻳﺘ ﻨﺎول ﻫ ﺬا اﻟﻤ ﺒﺪأ ﻣﻌﺎﻟﺠ ﺔ اﻹدﺧ ﺎل ﺣﻴ ﺚ ﻳﻌ ﺪ اﺳ ﺘﺨﺪام ‪ streams‬اﻓﻀ ﻞ ﻣ ﻦ دوال‬
‫اﻹدﺧﺎل ﻟﻠـﻐﺔ ‪. C‬‬
‫وﺻﻴﻐﺔ اﻟﺠﻤﻠﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫;‪Cin>>a‬‬
‫وﻧﺸﺎﻫﺪ أﻧﻬﺎ ﻋﻜﺲ ﻋﻤﻠﻴﺔ اﻹﺧﺮاج ﺣﻴﺚ اﻹﺧﺮاج << أﻣﺎ اﻹدﺧﺎل >> ‪.‬‬
‫وﺗﺴ ﺘﺨﺪم ﻫ ﺬه اﻟﺠﻤﻠ ﺔ ﻹدﺧ ﺎل ﻗ ﻴﻢ ﻋ ﺒﺮ ﻟﻮﺣ ﺔ اﻟﻤﻔﺎﺗ ﻴﺢ ﻟﻠﻤﺘﻐ ﻴﺮات ﻓ ﻲ اﻟﺬاﻛ ﺮة ‪ ،‬وﻳ ﺘﻢ‬
‫ﺗﻌﻴﻴﻦ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﻓﻲ اﻟﺬاﻛﺮة ﺑﺎﺳﺘﺨﺪام ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ ‪.‬‬
‫ﻣﻼﺣﻈﺔ‪/‬‬
‫ﻻ ﻳﺠﻮز أن ﻧﺴﺘﺨﺪم اﻟﻤﺘﻐﻴﺮ ﻗﺒﻞ ﺗﻌﺮﻳﻔﺔ‪.‬‬
‫ﻣﺜﺎل ﺻﺤﻴﺢ‪:‬‬
‫;‪Int x‬‬
‫;‪Cin>>x‬‬
‫ﻣﺜﺎل ﺧﺎﻃﺊ‪:‬‬
‫;‪Cin>>x‬‬
‫ﻣﺜﺎل‪:١٢‬‬
‫ﺳﻮف ﻧﻘﻮم ﺑﺈدﺧﺎل ﻋﺪد ﺻﺤﻴﺢ ﻓﻲ ﻫﺬا اﻟﺘﻄﺒﻴﻖ ﺛﻢ ﻧﻘﻮم ﺑﻄﺒﺎﻋﺘﻪ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;‪int=a‬‬
‫;‪cin>>a‬‬
‫;‪cout<<a‬‬
‫}‬
‫ﻧﻼﺣ ﻆ ﻓ ﻲ ﻫ ﺬا اﻟﻤ ﺜﺎل أﻧ ﻨﺎ ﻗﻤ ﻨﺎ ﺑ ﺘﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ‪ a‬ﺑﺄﻧﻪ ﻋﺪد ﺻﺤﻴﺢ ﺑﻌﺪ ذﻟﻚ ﻋﻨﺪ ﺗﻨﻔﻴﺬ‬
‫اﻟ ﺒﺮﻧﺎﻣﺞ ﺳ ﻴﻄﻠﺐ ﻣ ﻨﺎ إدﺧ ﺎل ﻋ ﺪد ﺳ ﻨﺪﺧﻞ اﻟﻌ ﺪد ‪ 10‬ﻣ ﺜﻼ ﻋ ﻨﺪ ذﻟ ﻚ ﺳ ﻴﻜﻮن اﻟ ﻨﺎﺗﺞ‬
‫ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪10‬‬

‫ﻣﺜﺎل‪:١٣‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻹدﺧﺎل ﻋﻤﺮك ﺛﻢ ﻃﺒﺎﻋﺘﻪ ‪ ،‬وﻃﺒﺎﻋﻪ ﻧﺼﻒ وﺿﻌﻔﻪ؟‬
‫)( ‪main‬‬
‫{‬
‫;‪int a‬‬
‫;‪cin>>a‬‬
‫;‪cout<<a‬‬
‫;‪cout<<a/2‬‬
‫;‪cout<<a*2‬‬
‫}‬
‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﻗﻤﻨﺎ أوﻻ ﺑﺘﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫;‪Int a‬‬
‫ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﻃﻠﺐ ﻣﻨﺎ إدﺧﺎل اﻟﻌﻤﺮ‪:‬‬
‫ﻋﻨﺪ اﻟﻄﻠﺐ ﺳﻨﺪﺧﻞ ﻣﺜﻼ ‪20‬‬
‫‪Cin>>a‬‬
‫وﺑﻌﺪﻫﺎ ﻗﻤﻨﺎ ﺑﻄﺒﺎﻋﺔ اﻟﻌﻤﺮ‪:‬‬
‫;‪Cout<<a‬‬
‫ﺛﻢ ﻗﻤﻨﺎ ﺣﺴﺐ اﻟﻤﻄﻠﻮب ﺑﻄﺒﺎﻋﺔ ﻧﺼﻒ اﻟﻌﻤﺮ‪:‬‬
‫;‪Cout<<a/2‬‬
‫ﺛﻢ ﻗﻤﻨﺎ ﺣﺴﺐ اﻟﻤﻄﻠﻮب اﻷﺧﻴﺮ ﺑﻄﺒﺎﻋﺔ ﺿﻌﻒ اﻟﻌﻤﺮ‪:‬‬
‫;‪Cout<<a*2‬‬
‫ﻟﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ اﻟﻨﻬﺎﺋﻴﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪20 10 40‬‬

‫ﻣﺜﺎل‪:١٤‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻹدﺧﺎل ﻋﺪد ﻣﺎ وﻟﻴﻜﻦ اﻟﻌﺪد ‪ 7‬وﻣﻦ ﺛﻢ ﻃﺒﺎﻋﺔ ﺟﺪول اﻟﻀﺮب ﻟﻪ؟‬
‫)( ‪main‬‬
‫{‬
‫;‪int a‬‬ ‫ﻋﻨﺪ ﻃﻠﺐ إدﺧﺎل ﻗﻴﻤﺔ ﻧﺪﺧﻞ‬
‫;‪cin>>a‬‬ ‫اﻟﺮﻗﻢ ‪ 7‬ﺣﺴﺐ ﻃﻠﺐ اﻟﺴﺆال‪..‬‬
‫;‪cout<<a*1‬‬
‫;‪cout<<a*2‬‬
‫;‪cout<<a*3‬‬
‫;‪cout<<a*4‬‬
‫;‪cout<<a*5‬‬
‫;‪cout<<a*6‬‬
‫;‪cout<<a*7‬‬
‫;‪cout<<a*8‬‬
‫;‪cout<<a*9‬‬
‫;‪cout<<a*10‬‬
‫}‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪7 14 21 28 35 42 49 56 63 70‬‬
‫ﻣﺜﺎل‪:١٥‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻹدﺧﺎل ﺛﻼث ﻋﻼﻣﺎت ﻟﻄﺎﻟﺐ ‪ 40 25 30‬وﻃﺒﺎﻋﺔ ﻣﻌﺪل اﻟﻌﻼﻣﺎت؟‬
‫)( ‪main‬‬ ‫ﻧﺪﺧﻞ ﺣﺴﺐ اﻟﻤﻄﻠﻮب ‪40 25‬‬
‫{‬ ‫‪30‬‬
‫;‪int a,b,c‬‬
‫;‪cin>>a>>b>>c‬‬
‫;‪cout<<(a+b+c)/3‬‬
‫}‬
‫ﻧﻼﺣ ﻆ أن ﻓ ﻲ ﺟﻤ ﻞ اﻹﺧ ﺮاج ﻗﻤ ﻨﺎ ﺑﻜ ﺘﺎﺑﺔ ﻗ ﺎﻋﺪة وﻫﻲ ﺟﻤﻊ اﻟﺜﻼث أﻋﺪاد ﻣﻊ ﺑﻌﻀﻬﺎ ﺛﻢ‬
‫ﻗﺴﻤﺘﻬﺎ ﻋﻠﻰ ﻋﺪدﻫﺎ وﻫﻲ ﻗﺎﻋﺪة ﻣﻌﺮوﻓﺔ ﻹﻇﻬﺎر اﻟﻤﻌﺪل‪..‬‬
‫وﺳﻒ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪31‬‬

:١٦‫ﻣﺜﺎل‬
:‫ وﻣﻦ ﺛﻢ ﻃﺒﺎﻋﺘﻬﺎ‬، ‫ﺳﻨﺤﺎول اﻵن إدﺧﺎل ﺛﻼث ﻗﻴﻢ ﻋﺪدﻳﺔ‬
#include “ iostream.h” 10 ‫ﻟﺘﻜﻦ‬
main ()
{
6.3 ‫ﻟﺘﻜﻦ‬
int a;
float x;
double z; 2001.5 ‫ﻟﺘﻜﻦ‬
cin>>a>>x>>z; // input all data
cout<<endl;
cout<<“\n print the following items”;
cout<<endl;
cout<<a<<“\n”<<x<<“\n”<<z; // output all data
cout<<“\n this is the end”<<endl;
return0;
}
‫ﻧﻼﺣ ﻆ ﻓ ﻲ اﻟﺴ ﺆال أﻋ ﻼه أﻧ ﻨﺎ ﻗﻤﻨﺎ ﺑﺈدﺧﺎل ﺛﻼث ﻗﻴﻢ ﻣﺨﺘﻠﻔﺔ ﻣﻦ ﺣﻴﺚ اﻟﻨﻮع وأﻳﻀﺎ ﻗﻤﻦ‬
:‫ﺑﺎﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻘﺎت وﻫﻲ ﻻ ﺗﺆﺛﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻘﻂ ﻟﻠﺘﻮﺿﻴﺢ وﻫﻲ اﻟﺘﻌﻠﻴﻖ‬
// input all data
// output all data
.. ‫ﻟﻨﻮﺿﺢ ﻟﻠﻤﺴﺘﺨﺪم أﻳﻦ اﻹدﺧﺎل واﻹﺧﺮاج‬
:‫وﺳﻮف ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‬

print the following items
10
6.3
2001.5
this is the end

‫ﺟﻤﻞ اﻟﺘﺤﻜﻢ واﻟﺸﺮط واﻟﺘﻜﺮار‬
‫‪ProgramControl,Conditional&Loop Statements‬‬
‫ﻗ ﺪ ﻧﺤ ﺘﺎج أن ﻧﻨ ﺘﻘﻞ ﻣ ﻦ ﺳ ﻄﺮ إﻟ ﻰ آﺧ ﺮ ﻓ ﻲ ﺑ ﺮﻧﺎﻣﺞ ‪ ، C++‬وﻗ ﺪ ﻧﺤﺘﺎج أن ﻧﻘﻮم ﺑﺘﻨﻔﻴﺬ‬
‫ﺑﻌ ﺾ اﻟﺠﻤ ﻞ ﻋ ﻨﺪ ﺗﺤﻘ ﻖ ﺑﻌ ﺾ اﻟﺸ ﺮوط ‪ ،‬وﻗ ﺪ ﻧﺤ ﺘﺎج أن ﻧﻜ ﺮر ﻋﻤﻠ ﻴﺔ ﻣ ﻦ ﻋﻤﻠ ﻴﺎت‬
‫اﻹدﺧ ﺎل أو اﻹﺧ ﺮاج أو اﻟﺤﺴ ﺎب ﻋ ﺪدا ﻣ ﻦ اﻟﻤ ﺮات ‪ ،‬وﻗ ﺪ ﻧﺤ ﺘﺎج أن ﻧﺒﻨ ﻲ ﺷ ﺒﻜﺔ ﻣ ﻦ‬
‫ﺗﻮزﻳ ﻊ اﻷواﻣ ﺮ ﻋﻠ ﻰ ﻋ ﺪد ﻣ ﻦ ﺳ ﻄﻮر اﻟ ﺒﺮﻧﺎﻣﺞ ‪ ،‬ﺣﺴ ﺐ ﻣﻘﺘﻀ ﻴﺎت ﺑﻌ ﺾ اﻷﺣ ﻮال ‪،‬‬
‫وﺣﺴ ﺒﻤﺎ ﺗﻘﺘﻀ ﻴﻪ ﻃﺒ ﻴﻌﺔ اﻟﻤﺴ ﺄﻟﺔ ‪ ،‬ﻓ ﻲ ﻫ ﺬه اﻟﺤ ﺎﻻت‪ :‬ﻧﺤ ﺘﺎج أن ﻧ ﺘﻌﻠﻢ أﺳ ﺎﻟﻴﺐ اﻟﺸﺮط ‪،‬‬
‫وأﺳ ﺎﻟﻴﺐ اﻟ ﺘﻜﺮار ‪ ،‬وﻛﻴﻔ ﻴﺔ اﻟ ﺘﺤﻜﻢ ﻓ ﻲ ﻣﺴ ﺎر اﻟ ﺒﺮﻧﺎﻣﺞ ‪ ،‬وﺗﻌ ﺪ أﺳ ﺎﻟﻴﺐ اﻟﺸ ﺮط واﻟﺘﺤﻜﻢ‬
‫واﻟﺘﻜﺮار ﺑﻤﺜﺎﺑﺔ اﻟﻘﻠﺐ ﻓﻲ ﺟﺴﻢ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ‪ ،‬وﺑﺪوﻧﻬﺎ ﻻ ﻳﻤﻜﻦ ﺗﻨﻈﻴﻢ آي ﺑﺮﻧﺎﻣﺞ‪.‬‬
‫وﺗﻮﻓ ﺮ ﻟﻐ ﺔ ‪ C++‬ﻟﻠﻤ ﺒﺮﻣﺞ ﻋ ﺪدا ﻣ ﻦ اﻷﺳ ﺎﻟﻴﺐ واﻟ ﺪوال اﻟﻔﻌﺎﻟ ﺔ ‪ ،‬اﻟﻤ ﺘﻌﻠﻘﺔ ﺑﻬﺬا اﻟﺸﺄن ‪،‬‬
‫وﺗﻤ ﺘﺎز ﻫ ﺬه اﻷﺳ ﺎﻟﻴﺐ ﺑﺄﻧﻬ ﺎ أﺳ ﺎﻟﻴﺐ ﺑﻨﺎﺋ ﻴﺔ أو ﺑﻨ ﻴﻮﻳﺔ ‪ structured‬آي ﻳﻤﻜ ﻦ ﺗﻨﻈ ﻴﻢ‬
‫ﻋﻤﻠ ﻴﺎت اﻟ ﺘﺤﻜﻢ واﻟ ﺘﻜﺮار ﻓ ﻴﻬﺎ ‪ ،‬ﺑﺄﺳ ﻠﻮب ذاﺗ ﻲ ﻣ ﻦ ﺑﺪاﻳ ﺔ اﻟﻌﻤﻠ ﻴﺎت وﺣ ﺘﻰ ﻧﻬﺎﻳ ﺘﻬﺎ دون‬
‫ﺗﺪﺧ ﻞ ﻣ ﻦ اﻟﻤ ﺒﺮﻣﺞ أﺛ ﻨﺎء ﻫ ﺬه ا ﻟﻌﻤﻠ ﻴﺎت ‪ ،‬ﻟﻸﺷ ﺮاف ﻋﻠ ﻰ اﻟﺘﻮﺟ ﻴﻪ واﻟﺘﺨﻄ ﻴﻂ ﻟﻜ ﻞ‬
‫ﺧﻄ ﻮه ﻣ ﻦ ﺧﻄ ﻮات اﻟ ﺒﺮﻧﺎﻣﺞ ‪ ،‬وﻳﻌ ﺮف ﺑﻌ ﺾ اﻟﺨ ﺒﺮاء واﻟﻤﺨﺘﺼﻴﻦ اﻟﺒﺮﻣﺠﺔ اﻟﺒﻨﻴﻮﻳﺔ‪:‬‬
‫أﻧﻬ ﺎ اﻟ ﺒﺮﻣﺠﺔ اﻟﺘ ﻲ ﻻ ﺗﺴ ﺘﻌﻤﻞ ﺟﻤﻠ ﺔ اﻻﻧﺘﻘﺎل ‪ ، GOTO‬ﻟﺘﻮﺟﻴﻪ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﻛﻞ ﺧﻄﻮة‬
‫‪ ،‬وﻣ ﻊ ذﻟ ﻚ ﻓ ﺎن ﻟﻐ ﺔ ‪ ، C++‬ﺗﻮﻓ ﺮ ﺟﻤﻠ ﺔ اﻻﻧ ﺘﻘﺎل ﻫ ﺬه ‪ ،‬ﻟﻜ ﻨﻬﺎ ﻻ ﺗﺴ ﺘﻌﻤﻞ إﻻ‬
‫ﻟﻠﻀﺮورة‪.‬‬
‫وﺣﻴ ﺚ أن ﺟ ﻮاب اﻟﺸ ﺮط أﻣ ﺎ أن ﻳﻜ ﻮن ﺻ ﻮاﺑﺎ ‪ true‬أو زاﺋﻔ ﺎ ‪ false‬ﻓ ﺎن ﻟﻐ ﺔ ‪، C++‬‬
‫ﺗﻌﻄ ﻲ اﻟﺤﺎﻟ ﺔ اﻟﺼ ﺎﺋﺒﺔ ﻗ ﻴﻤﺔ ﻋﺪدﻳ ﺔ ﺗﺨ ﺘﻠﻒ ﻋ ﻦ اﻟﺼ ﻔﺮ ‪ ،‬وﺗﻌﻄ ﻲ ﻗ ﻴﻤﺔ ﺻ ﻔﺮ ﻟﻠﺤﺎﻟ ﺔ‬
‫اﻟ ﺰاﺋﻔﺔ ) ﻋ ﻨﺪ ﻋ ﺪم ﺗﺤﻘ ﻖ اﻟﺸ ﺮط أو اﻟﺸ ﺮوط ( وﻟ ﺬا ﻓﺎن ﻟﻐﺔ ‪ C++‬ﺗﻮﻓﺮ ﻣﺮوﻧﺔ ﻛﺒﻴﺮة‬
‫ﻓﻲ اﺳﺘﺨﺪام ﻋﺪد ﻛﺒﻴﺮ ﻣﻦ اﻟﺪوال ‪ ،‬وﻓﻲ ﺗﻮﺟﻴﻪ اﻟﺒﺮﻧﺎﻣﺞ ﺑﻄﺮﻳﻘﺔ ﻓﻌﺎﻟﺔ وﻓﺎﺋﻘﺔ‪.‬‬

‫اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ‬
‫ﺗﺘﻌﺎﻣﻞ ﻟﻐﺔ ‪ C++‬ﻣﻊ ﺛﻼﺛﺔ أﻧﻮاع ﻣﻦ ﺟﻤﻞ اﻟﺸﺮط وﻫﻲ‪:‬‬
‫‪ -١‬ﺟﻤﻠﺔ إذا اﻟﺸﺮﻃﻴﺔ وأﺧﻮاﺗﻬﺎ ‪if statements‬‬
‫‪ -٢‬ﺟﻤﻠﺔ اﻟﺘﻮزﻳﻊ ‪switch statement‬‬
‫‪ -٣‬ﺟﻤﻠﺔ أداة اﻟﺸﺮط ?‬
‫ﺟﻤﻠﺔ اﻟﺸﺮط إذا وأﺧﻮاﺗﻬﺎ ‪if statements‬‬

‫‪ -‬ﺟﻤﻠﺔ اﻟﺸﺮط إذا وأﺧﻮاﺗﻬﺎ ‪if statements‬‬
‫ﺗﺄﺧﺬ ﻫﺬه اﻟﺠﻤﻠﺔ اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‪:‬‬
‫;‪If (condition) statement1‬‬
‫ﺗﻘ ﻮم ﺟﻤﻠ ﺔ إذا اﻟﺸ ﺮﻃﻴﺔ ﻫ ﻨﺎ ‪ ،‬ﺑ ﻨﻘﻞ ﺗﺴﻠﺴ ﻞ ﺗﻨﻔ ﻴﺬ اﻟ ﺒﺮﻧﺎﻣﺞ إﻟ ﻰ اﻟﺠﻤﻠ ﺔ )أو ﺳﻠﺴ ﻠﺔ‬
‫اﻟﺠﻤﻠ ﺔ( ‪ statement1‬ﻋ ﻨﺪﻣﺎ ﻳ ﺘﺤﻘﻖ اﻟﺸ ﺮط )أو اﻟﺸ ﺮوط( ‪ condition‬وﺗﻜ ﻮن‬
‫ﻧﺘﻴﺠ ﺘﻪ ‪ ، true‬وإذا ﻟ ﻢ ﻳ ﺘﺤﻘﻖ اﻟﺸ ﺮط ‪ ،‬أي ﺗﻜ ﻮن اﻟﻨﺘ ﻴﺠﺔ ‪ ، false‬ﻓ ﺎن اﻟﺘﻨﻔ ﻴﺬ ﻳﻨ ﺘﻘﻞ‬
‫ﻓ ﻮرا إﻟ ﻰ اﻟﺠﻤﻠ ﺔ ) أو ﺳﻠﺴ ﻠﺔ اﻟﺠﻤ ﻞ( ‪ statment2‬وﻳﻌ ﺪ اﺳ ﺘﻌﻤﺎل ‪ else‬ﻓ ﻲ ‪C++‬‬
‫اﺧﺘ ﻴﺎرﻳﺎ ‪ ،‬أي ﻳﻤﻜ ﻦ ﺣﺬﻓﻬ ﺎ دون أن ﺗ ﺘﺄﺛﺮ اﻟﺠﻤﻠ ﺔ اﻟﺸ ﺮﻃﻴﺔ ﺗﺮﻛﻴ ﺒﺎ واداء وﻳﻜ ﻮن ﺷ ﻜﻠﻬﺎ‬
‫اﻟﻌﺎم ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪:‬‬
‫;‪If (condition) statement1‬‬
‫;‪Else statment2‬‬
‫وﻓ ﻲ ﻫ ﺬه اﻟﺤﺎﻟ ﺔ ﺳ ﺘﻨﻔﺬ اﻟﺠﻤﻠ ﺔ ‪ statement1‬أن ﺗﺤﻘ ﻖ اﻟﺸ ﺮط ‪ condition‬وإﻻ ﻓ ﺎن‬

‫اﻟﺘﻨﻔﻴﺬ ﻳﻨﺘﻘﻞ إﻟﻰ ﺳﻄﺮ ‪ C++‬اﻟﺘﺎﻟﻲ ﻟﺠﻤﻠﺔ ‪. if‬‬
‫اﻟﺼﻴﻐﺔ اﻷوﻟﻰ‬
‫وﺗﺄﺧﺬ اﻟﺒﻨﻴﺔ اﻟﻌﺎﻣﻠﺔ ‪If (condition) statement1‬‬

‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﺑﻠﻐﺔ ‪ C++‬ﻹﻇﻬﺎر اﻟﻌﺒﺎرة ‪ x is positive‬ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﻌﺮض؟‬
‫)( ‪main‬‬
‫{‬
‫;‪int x=5‬‬
‫)‪if (x>0‬‬
‫;”‪cout<<x<<“ Saudi‬‬
‫}‬
‫ﻓ ﻲ ﻫ ﺬا اﻟﻤ ﺜﺎل ﺳ ﺘﻈﻬﺮ اﻟﺠﻤﻠ ﺔ ‪ Saudi‬ﻋﻠ ﻰ اﻟﺸﺎﺷ ﺔ ﻻن اﻟﺸ ﺮط )‪ (x>0‬ﻣ ﺘﺤﻘﻖ‬

‫ﻓﺎﻟﺨﻤﺴﺔ ﺑﺎﻟﻄﺒﻊ اﻛﺒﺮ ﻣﻦ اﻟﻌﺪد ﺻﻔﺮ ﻓﺎﻟﻨﺘﻴﺠﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪Saudi‬‬
‫ﻣﺜﺎل‪:٢‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ‪ C++‬اﻟﺘﺎﻟﻲ ﻟﻴﺤﺴﺐ اﻟﻘﻴﻤﺔ اﻟﻤﻄﻠﻘﺔ ﻟـ‪ Y‬اﻟﻤﻌﺮﻓﺔ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪:‬‬
‫‪x;x>=0‬‬
‫=|‪Y=|x‬‬
‫‪-x;x<0‬‬
‫)( ‪main‬‬
‫{‬ ‫ﻧﻘﻮم ﺑﺈدﺧﺎل اﻟﻌﺪد ‪10‬‬
‫;‪int x‬‬
‫;‪cin>>x‬‬
‫;‪if (x>=0) cout<<x‬‬
‫;‪else cout<<-x‬‬
‫}‬
‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﺳﻮف ﻧﺪﺧﻞ اﻟﺮﻗﻢ ‪ 10‬ﻟﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ ‪:‬‬

‫‪10‬‬

‫ﻣﺜﺎل‪:٣‬‬
‫ﻗ ﻢ ﺑﺈﻧﺸ ﺎء ﺑ ﺮﻧﺎﻣﺞ ﻹدﺧ ﺎل ﻋﻼﻣ ﺔ ﻃﺎﻟﺐ ﻓﺈذا ﻛﺎﻧﺖ اﻟﻌﻼﻣﺔ اﻛﺒﺮ أو ﺗﺴﺎوي ‪ 90‬ﻓﺎﻟﺘﻘﺪﻳﺮ‬
‫)‪ (A‬أﻣ ﺎ إذا ﻛﺎﻧ ﺖ اﻛ ﺒﺮ أو ﺗﺴ ﺎوي ‪ 80‬ﻓﺎﻟ ﺘﻘﺪﻳﺮ )‪ ( B‬أﻣ ﺎ إذا ﻛﺎﻧ ﺖ اﻛ ﺒﺮ أو ﺗﺴ ﺎوي‬
‫‪ 70‬ﻓﺎﻟ ﺘﻘﺪﻳﺮ )‪ (C‬أﻣ ﺎ إذا ﻛﺎﻧ ﺖ اﻛ ﺒﺮ أو ﺗﺴ ﺎوي ‪ 60‬ﻓﺎﻟ ﺘﻘﺪﻳﺮ )‪( D‬أﻣ ﺎ إذا ﻛﺎﻧ ﺖ اﻛ ﺒﺮ‬
‫أو ﺗﺴﺎوي ‪ 50‬ﻓﺎﻟﺘﻘﺪﻳﺮ )‪ ( E‬ﻣﺎ ﻋﺪا ذﻟﻚ ﻓﺎﻟﺘﻘﺪﻳﺮ)‪(F‬؟‬
‫)( ‪main‬‬ ‫ﺗﻌﺮﻳﻒ اﻟﺪرﺟﺔ‬
‫{‬
‫;‪int mark‬‬
‫;‪char grade‬‬ ‫ﺗﻌﺮﻳﻒ اﻟﺘﻘﺪﻳﺮ‬
‫;‪cin>>mark‬‬
‫)‪if (mark>=90‬‬
‫;'‪grade='a‬‬
‫‪else‬‬ ‫ﺳﻨﺪﺧﻞ ﻣﺜﻼ‬
‫)‪if (mark>=80‬‬ ‫اﻟﺪرﺟﺔ ‪85‬‬
‫;'‪grade='b‬‬
‫‪else‬‬
‫)‪if (mark>=70‬‬
‫;'‪grade='c‬‬
‫‪else‬‬
‫)‪if (mark>=60‬‬
‫;'‪grade='d‬‬
‫‪else‬‬
‫)‪if (mark>=50‬‬
‫;'‪grade='e‬‬
‫‪else‬‬
‫;'‪grade='f‬‬
‫;‪cout<<grade‬‬
‫}‬
‫ﻓ ﻲ اﻟﻤ ﺜﺎل أﻋ ﻼه ﻗﻤ ﻨﺎ ﺑ ﺘﻌﺮﻳﻒ اﻟﻤﺘﻐ ﻴﺮ ‪ mark‬ﺑﺄﻧ ﻪ ﻋ ﺪد ﺻ ﺤﻴﺢ ﺛ ﻢ ﻗﻤ ﻨﺎ ﺑﻌ ﺪ ذﻟ ﻚ‬

‫ﺑﺘﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ‪ grade‬ﺑﺄﻧﻪ ﻗﻴﻤﺔ ﻧﺼﻴﻪ وﻫﻮ اﻟﺘﻘﺪﻳﺮ‪.‬‬
‫ﻃﺒﻌﺎ ﻗﻤﻨﺎ ﺑﺈدﺧﺎل اﻟﺪرﺟﺔ وﻫﻲ ‪ 85‬ﺳﻮف ﺗﻜﻮن اﻟﻌﻼﻣﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪B‬‬

‫اﻟﺼﻴﻐﺔ اﻟﺜﺎﻧﻴﺔ‬
:‫( اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‬if..else)‫ وإﻻ‬.... ‫وﺗﺄﺧﺬ اﻟﺒﻨﻴﺔ اﻟﻌﺎﻣﻠﺔ ﻟﺠﻤﻠﺔ إذا‬
If (condition)
{
statmenet1;
}
else
{
statmenet1;
}
:٤‫ﻣﺜﺎل‬
:‫( أﻋﻼه ﻛﻤﺎ ﻳﻠﻲ‬if..else) ‫( ﻟﻜﻦ ﺑﺎﻟﺸﻜﻞ‬3) ‫ﺳﻮف ﻧﻄﺒﻖ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‬
#include
0 “ stdafx.h”
main ()
{
int mark;
char grade;
cin>>mark; ‫إذا اﻷوﻟﻰ وﺟﻮاﺑﻬﺎ‬
if ( mark>=90){
grade='A';
{
‫إذا اﻟﺜﺎﻧﻴﺔ وﺟﻮاﺑﻬﺎ‬
else
if (mark>=80){
grade='B';
{
‫إذا اﻟﺜﺎﻟﺜﺔ وﺟﻮاﺑﻬﺎ‬
else
if (mark>=70){
grade='C';
{
else ‫إذا اﻟﺮاﺑﻌﺔ وﺟﻮاﺑﻬﺎ‬
if (mark>=60){
grade='D';
{
else
if (mark>=50){ ‫وإﻻ ﻓﺎﻟﻨﺘﻴﺠﺔ اﻟﺒﺎﻗﻴﺔ‬
grade='E'; ‫ﻫﻲ اﻟﺨﺎﻣﺴﺔ‬
}
cout<<grade;
return0; ‫ﻟﻄﺒﺎﻋﺔ اﻟﺘﻘﺪﻳﺮ‬
}

‫اﻛﺘ ﺐ ﺑ ﺮﻧﺎﻣﺠﺎ ﻹدﺧ ﺎل ﻃﻮﻟ ﻚ وﻃ ﻮل زﻣ ﻴﻠﻚ ‪ ،‬وإذا ﻛ ﺎن ﻃﻮﻟ ﻚ اﻛ ﺒﺮ ﻣ ﻦ ﻃﻮل زﻣﻴﻠﻚ‬
‫اﻃﺒﻊ ﻃﻮﻟﻚ ‪ ،‬واﺣﺴﺐ ﻣﻌﺪل اﻷﻃﻮال ‪ ،‬ﺛﻢ اﻃﺒﻌﻪ وأﻻ‬
‫اﻃﺒﻊ ﻃﻮل زﻣﻴﻠﻚ ‪ ،‬واﻃﺒﻊ ﺿﻌﻒ اﻟﻄﻮل وﻧﺼﻒ اﻟﻄﻮل؟‬
‫اﻟﺤـﻞ‪/‬‬
‫ﺳﻨﺮﻣﺰ ﻟﻄﻮﻟﻚ ‪ t1‬وﺳﻨﺮﻣﺰ ﻟﻄﻮل زﻣﻴﻠﻚ ‪t2‬‬
‫)( ‪main‬‬
‫{‬
‫أدﺧﻞ اﻷﻃﻮال‬
‫;‪int t1,t2‬‬
‫;‪cin>>t1>>t2‬‬
‫)‪if (t1>t2‬‬
‫{‬
‫;‪cout<<t1‬‬ ‫ﻃﺒﺎﻋﺔ ﻣﻌﺪل‬
‫;‪cout<<(t1+t2)/2‬‬ ‫اﻷﻃﻮال‬
‫}‬
‫‪else‬‬ ‫وإﻻ‬
‫{‬
‫;‪cout<<t2‬‬ ‫ﻟﻄﺒﺎﻋﺔ ﺿﻌﻒ اﻟﻄﻮل‬
‫;‪cout<<t2*2‬‬
‫;‪cout<<t2/2‬‬
‫}‬ ‫ﻟﻄﺒﺎﻋﺔ ﻧﺼﻒ اﻟﻄﻮل‬
‫}‬

switch statement ‫ﺟﻤﻠﺔ اﻟﺘﻮزﻳﻊ‬
: c++ ‫ اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ ﻓﻲ ﻟﻐﺔ‬Switch ‫ﺗﺄﺧﺬ ﺟﻤﻠﺔ‬
Switch (expression) ‫ﺗﻌﺒﻴﺮ ﻗﻴﻤﺘﻪ ﺻﺤﻴﺤﺔ‬

{
‫ﺟﻤﻠﺔ أو ﺟﻤﻞ ﺗﻨﻔﺬ ﻋﻨﺪﻣﺎ‬
Case constant1: statments1; break; ‫ﺳﺎوي اﻟﺘﻌﺒﻴﺮ ﻗﻴﻤﺔ‬
Case constant2: statments2; break; constant1
......................................................
......................................................
‫ﺟﻤﻠﺔ أو ﺟﻤﻞ ﺗﻨﻔﺬ ﻋﻨﺪﻣﺎ‬
...................................................... ‫ﺳﺎوي اﻟﺘﻌﺒﻴﺮ ﻗﻴﻤﺔ‬
Case constantn: statmentsn; break; constant2
Default; last statements;
}
‫ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﻋﻨﺪ ﻋﺪم ﺗﻨﻔﻴﺬ‬

‫ﺟﻤﻴﻊ اﻟﺤﺎﻻت اﻟﻮاردة‬
Switch ‫أﻋﻼه ﻓﻲ ﺑﻨﻴﺔ‬
void main()
{
int s1;
s1=2;
switch (s1)
{
case 2 :cout<<"y";
break;
case 3: cout<<"x";
break;
case 4: cout<<"m";
break;
default: cout<<"w";
}
}
:‫واﻟﻨﺘﻴﺠﺔ‬
y

‫ﺟﻤﻠﺔ أداة اﻟﺸﺮط ?‬
‫وﻫ ﻲ أداة ﺳ ﺮﻳﻌﺔ ﻣﻜﺎﻓ ﺌﺔ ﻟﺒﻨ ﻴﺔ إذا ‪ ...‬وإﻻ ‪ ،‬وﻗ ﺪ ﻣ ﺮ ﻣﻌ ﻨﺎ ﻛﻴﻔ ﻴﺔ اﺳ ﺘﻌﻤﺎﻟﻬﺎ ﻓ ﻲ أول‬
‫اﻟﻜﺘﺎب وﺳﻮف ﻧﻮرد ﻫﻨﺎ ﺻﻮرﺗﻬﺎ اﻟﻌﺎﻣﺔ‪:‬‬
‫;‪Variable=(condition)? Result:result2‬‬
‫وﻣﻌ ﻨﺎﻫﺎ‪ :‬اﻧ ﻪ ﻳ ﺘﻢ ﺗﻨﻔ ﻴﺬ اﻟﻨﺘ ﻴﺠﺔ اﻷوﻟ ﻰ ‪ result1‬ﻋ ﻨﺪﻣﺎ ﻳﻜ ﻮن ﺟ ﻮاب اﻟﺸ ﺮط‬
‫‪ condition‬ﻣ ﺘﺤﻘﻘﺎ )‪ ، (true‬وإﻻ ﻓﻴ ﺘﻢ ﺗﻨﻔ ﻴﺬ اﻟﻨﺘ ﻴﺠﺔ اﻟﺜﺎﻧ ﻴﺔ ‪ result2‬ﻋ ﻨﺪﻣﺎ ﻳﻜ ﻮن‬
‫ﺟﻮاب اﻟﺸﺮط )‪. (false‬‬
‫ﻣﺜﺎل‪:٧‬‬
‫)(‪void main‬‬
‫{‬
‫;‪int a,b‬‬
‫;‪a=5‬‬
‫;‪if (a>1) b=10‬‬
‫‪else‬‬
‫;‪b=20‬‬
‫;‪cout<<b‬‬
‫}‬
‫وﻣﻌ ﻨﺎﻫﺎ أن ‪ b‬ﺗ ﺄﺧﺬ اﻟﻘ ﻴﻤﺔ ‪ 10‬إذا ﺗﺤﻘ ﻖ اﻟﺸ ﺮط ‪ a>1‬وﺗ ﺄﺧﺬ اﻟﻘ ﻴﻤﺔ ‪ 20‬إذا ﻟ ﻢ ﻳﺘﺤﻘﻖ‬
‫اﻟﺸﺮط ﻧﻔﺴﻪ ‪.‬‬
‫واﻟﻨﺘﻴﺠﺔ‪:‬‬
‫‪10‬‬

‫اﻟﺘﻜﺮار وﺣﻠﻘﺎت اﻟﺘﻜﺮار ‪Repetition and Loops‬‬
‫ﺗﻮﻓ ﺮ ﻟﻐ ﺔ ‪ ، C++‬ﻛﺴ ﺎﺋﺮ ﻟﻐ ﺎت اﻟ ﺒﺮﻣﺠﺔ ‪ ،‬ﻋﺪدا ﻣﻦ أﺳﺎﻟﻴﺐ اﻟﺘﻜﺮار اﻟﻤﺸﺮوط ‪ ،‬وﻏﻴﺮ‬
‫اﻟﻤﺸﺮوط وﻣﻦ ﻫﺬه اﻷﺳﺎﻟﻴﺐ‪:‬‬
‫أﺳﻠﻮب اﻟﺘﻜﺮار ﺑﺎﺳﺘﻌﻤﺎل ﺣﻠﻘﺔ ‪For‬‬

‫ﻳﻤﺘﻠﻚ أﺳﻠﻮب اﻟﺘﻜﺮار ﺑﺎﺳﺘﻌﻤﺎل ‪ for‬ﻗﻮة وﻣﺮوﻧﺔ ‪ ،‬ﻻ ﺗﺘﻮﻓﺮان ﻓﻲ ﻏﻴﺮﻫﺎ ﻣﻦ اﻟﻠﻐﺎت‪.‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ اﻷوﻟﻰ‬

‫;‪For ( initial-value; condition; increment ) statement‬‬
‫اﻟﻘﻴﻤﺔ‬ ‫ﺷﺮط ﻳﻘﻴﺪ‬ ‫اﻟﺰﻳﺎدة‬ ‫ﺟﻤﻠﺔ آو ﻳﺘﻢ‬

‫اﻻﺑﺘﺪاﺋﻴﺔ ﻟﻌﺪاد‬ ‫ﺣﺮﻛﺔ ‪For‬‬ ‫اﻟﻤﻨﺘﻈﻤﺔ‬ ‫ﺗﻜﺮار‬
‫ﺣﻠﻘﺔ ‪For‬‬ ‫وﻏﺎﻟﺒﺎ ﻣﺎ‬ ‫ﻓﻲ اﻟﻌﺪاد‬ ‫ﺗﻨﻔﻴﺬﻫﺎ ﻋﺪد‬
‫ﻳﺤﻮي ﻗﻴﻤﺔ‬ ‫ﻣﺮات ﺗﻜﺮار‬
‫ﻧﻬﺎﺋﻴﺔ‬ ‫‪For‬‬
‫ﺗﻘ ﻮم ﺟﻤﻠ ﺔ ‪ For‬ﻫ ﻨﺎ ﻣﺒ ﺘﺪﺋﺔ ﺑﻘ ﻴﻤﺔ اﻟﻌ ﺪاد اﻻﺑﺘﺪاﺋﻴﺔ ﺑﺘﻨﻔﻴﺬ اﻟﺠﻤﻠﺔ ‪statement1‬أول ﻣﺮة‬
‫‪ ،‬وﻓ ﻲ اﻟﻤ ﺮة اﻟﺘﺎﻟ ﻴﺔ ﺗ ﺰداد اﻟﻘ ﻴﻤﺔ اﻻﺑﺘﺪاﺋ ﻴﺔ ﻟﻠﻌ ﺪاد ﺑﻤﻘ ﺪار اﻟ ﺰﻳﺎدة ﺛ ﻢ ﺗ ﻨﻔﺬ ﺟﻤﻠ ﺔ‬
‫‪ statement1‬ﻣ ﺮة ﺛﺎﻧ ﻴﺔ ‪ ..‬وﻫﻜ ﺬا ﺣ ﺘﻰ ﻳﺴ ﺘﻜﻤﻞ اﻟﺸﺮط‪condition‬أﻣﺮ إﻧﻬﺎء ﻋﻤﻠﻴﺎت‬
‫اﻟ ﺘﻜﺮار واﻟﺨ ﺮوج ﻣ ﻦ ﺣﻠﻘ ﺔ ‪ ، For‬واﻷﻣ ﺜﻠﺔ اﻟﺘﺎﻟ ﻲ ﺗﻮﺿ ﺢ ﻛﻴﻔ ﻴﺔ اﺳ ﺘﻌﻤﺎل ﺣﻠﻘ ﺎت‬
‫اﻟﺘﻜﺮار ﺑﺠﻤﻠﺔ ‪:For‬‬
‫ﻣﺜﺎل‪:٨‬‬
‫)( ‪main‬‬ ‫اﻟﻘﻴﻤﺔ اﻟﺘﻨﺎزﻟﻴﺔ‬
‫{‬ ‫ﻟﻠﻌﺪاد‬
‫;‪char x‬‬
‫)‪for (x=1;x<=10;x=x+1‬‬ ‫اﻟﺰﻳﺎدة ﺑﻤﻘﺪار ‪1‬‬
‫;”‪cout<<“Islam‬‬
‫;‪cout<<endl‬‬
‫;‪return0‬‬ ‫اﻟﺘﻜﺮار إﻟﻰ‬
‫‪10‬‬
‫}‬
‫واﻟﻨﺘﻴﺠﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

Islam Islam Islam Islam Islam Islam Islam Islam Islam Islam
10 Ù 1 ‫ ﻣﺮات ﺑﺪاﻳﺔ ﻣﻦ اﻟﻘﻴﻤﺔ‬10 Islam ‫ﻧﻼﺣﻆ ﻫﻨﺎ اﻧﻪ ﺗﻢ ﺗﻜﺮار ﻛﻠﻤﺔ‬
:٩‫ﻣﺜﺎل‬
‫؟‬10 ‫ إﻟﻰ‬1 ‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻟﻄﺒﺎﻋﺔ ﻗﻴﻤﺔ اﻟﻌﺪاد ﻣﻦ‬
main ()
{
int a;
for (a=1;a<=10;++a)
cout<<a<<endl;
return0;
}
:‫وﺗﻜﻮن ﻧﺘﺎﺋﺞ اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ﻫﻜﺬا‬

1 ‫ اﻻﺑﺘﺪاﺋﻴﺔ‬a ‫ﻗﻴﻤﺔ‬
2
3
4
5
6
7
8
9
10 ‫ اﻟﻨﻬﺎﺋﻴﺔ‬a ‫ﻗﻴﻤﺔ‬

‫ﻣﺜﺎل‪:١٠‬‬
‫اﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻟﻄﺒﺎﻋﺔ اﻷﻋﺪاد اﻟﻔﺮدﻳﺔ ﻣﻦ ‪ 1‬إﻟﻰ ‪15‬؟‬
‫)( ‪main‬‬
‫{‬
‫;‪int a‬‬
‫)‪for (a=1;a<=15;a=a+2‬‬
‫;‪cout<<a<<endl‬‬
‫}‬
‫وﻣ ﻦ اﻟﻤﻼﺣ ﻆ أﻧ ﻨﺎ ﺟﻌﻠ ﻨﺎ ﻗ ﻴﻤﺔ اﻟ ﺰﻳﺎدة ‪ 2‬وﻟ ﻴﺲ ‪ 1‬ﻻﻧ ﻪ ﻃﻠ ﺐ أﻋﺪاد ﻓﺮدﻳﺔ ﺑﺪاﻳﺔ ﺑﺎﻟﻘﻴﻤﺔ‬
‫‪ 1‬وﺣﺘﻰ ‪15‬‬
‫واﻟﻨﺘﻴﺠﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪1‬‬
‫‪3‬‬
‫‪5‬‬
‫‪7‬‬
‫‪9‬‬
‫‪11‬‬
‫‪13‬‬

‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ اﻟﺜﺎﻧﻴﺔ‬
For ( initial-value; condition; increment )
{
‫ﺟﻤﻠﺔ أو اﻛﺜﺮ‬
statement;
}
:‫ﺷﺎﻫﺪ اﻷﻣﺜﻠﺔ اﻟﺘﺎﻟﻴﺔ ﻟﻨﺘﻌﺮف اﻛﺜﺮ ﻋﻠﻰ اﻟﺼﻴﻐﺔ أﻋﻼه‬
:١١‫ﻣﺜﺎل‬
main ()
{ int x,y,z;
y=-4;
for(x=1;x>y;x=x-2)
}
z=x; ‫اﻛﺜﺮ ﻣﻦ ﺟﻤﻠﺔ ﺑﻴﻦ‬
cout<<x<<endl; Block ‫اﻟﻘﻄﻌﺘﻴﻦ‬
{
return0;
}
:‫واﻟﻨﺎﺗﺞ ﺳﻮف ﻳﻜﻮن اﻟﺘﺎﻟﻲ‬

1
-1
-3

:١٢‫ﻣﺜﺎل‬
main ()
{ int a,b,c,x; ‫اﻟﻘﻴﻤﺔ اﻻﺑﺘﺪاﺋﻴﺔ‬
a=6;
b=1;
c=3; :‫واﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‬
for (x=11;(a*c)>(x*b);x--)
{
x=x+3;
‫اﻛﺜﺮ ﻣﻦ ﺟﻤﻠﺔ ﺑﻴﻦ‬
c=c-2;
Block ‫اﻟﻘﻄﻌﺘﻴﻦ‬
cout<<x<<”*”;
}
return0;
}
14*
:١٣‫ﻣﺜﺎل‬
main ()
{ int a,c;
a=1;
c=3;
for (a=c;c;) ‫ﺗﻨﻘﺺ ﻣﻦ ﻗﻴﻤﺔ‬
{ 1 ‫ ﻗﻴﻤﺔ‬C
c--;
cout<<c<<endl;
}
return0;
}
:‫واﻟﻨﺎﺗﺞ‬
2
1
0

‫ﺣﻠﻘــﺎت اﻟــﺘﻜﺮار اﻟﻤــﺘﺪاﺧﻠﺔ ‪Nested (Multiple) for‬‬
‫‪Loops‬‬
‫ﺗﺄﺧﺬ ﺻﻴﻐﺔ ﺣﻠﻘﺎت اﻟﺘﻜﺮار اﻟﻤﺘﺪاﺧﻠﺔ اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‪:‬‬
‫)‪For (...‬‬
‫)‪For (...‬‬
‫)‪For (...‬‬
‫…………………………‪.‬‬
‫…………………………‪.‬‬
‫;‪Statements‬‬
‫ﻓﻠﻮ أﺧﺬﻧﺎ ﺣﺎﻟﺔ ﺣﻠﻘﺘﻴﻦ ﻣﺘﺪاﺧﻠﺘﻴﻦ ﻓﺎﻧﻬﻤﺎ ﺗﻜﺘﺒﺎن ﻋﻠﻰ اﻟﺼﻮرة اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫)‪For(...‬‬
‫)‪For (...‬‬
‫;‪Statements‬‬
‫ﺗﺴﻤﻰ اﻟﺤﻠﻘﺔ‬ ‫ﺗﺴﻤﻰ اﻟﺤﻠﻘﺔ‬

‫اﻟﺪاﺧﻠﻴﺔ ‪inner‬‬ ‫اﻟﺨﺎرﺟﻴﺔ ‪outer‬‬
‫‪loop‬‬ ‫‪loop‬‬
‫ﺟﻤﻠﺔ أو ﺟﻤﻞ ﺗﻜﺮر‬

‫ﺣﺴﺐ أواﻣﺮ‬
‫اﻟﺤﻠﻘﺘﻴﻦ‬
‫وﺗﻜ ﻮن ﻓ ﻲ ﻫ ﺬه اﻟﺤﺎﻟ ﺔ اﻟﺠﻤﻠ ﺔ )أو اﻟﺠﻤ ﻞ( ﺟ ﺰءا ﻣﻜ ﺮرا ﻣﺮﺗ ﺒﻄﺎ ﺑﺎﻟﺤﻠﻘ ﺔ اﻟﺪاﺧﻠ ﻴﺔ ‪،‬‬
‫واﻟﺤﻠﻘﺔ اﻟﺨﺎرﺟﻴﺔ ﺗﺘﻜﺮر ﺣﺴﺐ أواﻣﺮ اﻟﺤﻠﻘﺔ اﻟﺨﺎرﺟﻴﺔ وﻫﻜﺬا ‪...‬‬

‫وﻓﻲ ﺣﺎﻟﺔ اﻟﺜﻼث ﺣﻠﻘﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪ ،‬ﻓﺈﻧﻬﺎ ﺗﻜﺘﺐ ﻋﻠﻰ اﻟﺼﻮرة اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫)‪For (...‬‬
‫)‪For (...‬‬
‫)‪For (...‬‬ ‫ﺟﻤﻠﺔ أو ﺟﻤﻞ ﺗﺘﻜﺮ‬
‫;‪Statement‬‬ ‫ﺣﺴﺐ أواﻣﺮ‬
‫اﻟﺤﻠﻘﺎت اﻟﺜﻼث‬
‫اﻟﺤﻠﻘﺔ اﻟﺨﺎرﺟﻴﺔ‬
‫اﻟﺤﻠﻘﺔ‬
‫اﻟﻮﺳﻄﻲ‬
‫اﻟﺤﻠﻘﺔ‬
‫اﻟﺪاﺧﻠﻴﺔ‬
‫ﻣﺜﺎل‪:١٤‬‬
‫)( ‪main‬‬
‫اﻟﺤﻠﻘﺔ اﻟﺨﺎرﺟﻴﺔ ﺗﺘﻜﺮ ‪3‬‬
‫{‬ ‫ﻣﺮات‬
‫;‪int i,j‬‬
‫)‪for (i=1;i<=3;++i‬‬
‫)‪for (j=1;j<=4;++j‬‬
‫;‪cout<<i*j‬‬
‫;‪return0‬‬ ‫اﻟﺤﻠﻘﺔ اﻟﺪاﺧﻠﻴﺔ ﺗﺘﻜﺮر ‪4‬‬
‫}‬ ‫ﻣﺮات ﻟﻜﻞ ﻗﻴﻤﺔ ﻣﻦ ﻗﻴﻢ ‪ I‬أي‬
‫ﻣﺠﻤﻮع ‪ 12‬ﻣﺮة‬
‫ﻻﺣ ﻆ ﻫ ﻨﺎ أن اﻟﺤﻠﻘ ﺔ اﻟﺪاﺧﻠ ﻴﺔ ﺗ ﺘﻜﺮر ‪ ٤‬ﻣ ﺮات ﻟﻜ ﻞ ﻗ ﻴﻤﺔ ﻣ ﻦ ﻗ ﻴﻢ ‪ ، I‬ﻋ ﺪاد اﻟﺤﻠﻘ ﺔ‬
‫اﻟﺨﺎرﺟ ﻴﺔ ‪ ،‬وﻛﺬﻟ ﻚ ﺟﻤﻠ ﺔ <<‪ ، cout‬وﺑﻤ ﺎ أن ‪ ، I‬ﺗ ﺄﺧﺬ ‪ 3‬ﻗ ﻴﻢ ﻓ ﺎن اﻟﺤﻠﻘ ﺔ اﻟﺪاﺧﻠ ﻴﺔ‬
‫ﺗﺘﻜﺮر ‪ 12‬ﻣﺮة ‪ ،‬أﻣﺎ اﻟﺤﻠﻘﺔ اﻟﺨﺎرﺟﻴﺔ ﻓﺘﻜﺮر ﻧﻔﺴﻬﺎ ﺑﻨﻔﺴﻬﺎ ﻓﺘﺘﻜﺮ ‪ 12‬ﻣﺮة ﻓﻘﻂ‪.‬‬
‫واﻟﻨﺎﺗﺞ‪:‬‬
‫‪1234246836912‬‬

‫ﻣﺜﺎل‪:١٥‬‬
‫”‪#include “ iostream.h‬‬ ‫اﻟﺤﻠﻘﺔ اﻟﺨﺎرﺟﻴﺔ ﻳﺘﻐﻴﺮ ﻋﺪادﻫﺎ‬
‫)( ‪main‬‬ ‫ﺑﻴﻦ ‪ 2‬و ‪ 20‬ﺑﺰﻳﺎدة ﻣﻨﻈﻤﺔ‬
‫{‬ ‫ﻗﺪرﻫﺎ ‪2‬‬
‫;‪int i,j‬‬
‫)‪for (i=2;i<=20;i+=2‬‬
‫)‪for (j=30;j>=3;j-=3‬‬
‫;‪cout<<i<<j<<endl‬‬ ‫اﻟﺤﻠﻘﺔ ا ﻟﺪاﺧﻠﻴﺔ ﻳﺘﻐﻴﺮ ﻋﺪادﻫﺎ ﺑﻴﻦ‬
‫;‪return0‬‬ ‫‪ 30‬و ‪ 3‬ﺑﺰﻳﺎدة ﻣﻨﺘﻈﻤﺔ ﻗﺪرﻫﺎ‪3-‬‬
‫}‬
‫واﻟ ﻨﺎﺗﺞ ﺳ ﻴﻜﻮن ﻛﺒ ﻴﺮ ﻟﺬﻟ ﻚ ﺳ ﺄﻋﻄﻴﻜﻢ ﺟ ﻮاب اﻟﺤ ﻞ ﻟﻠﺴ ﻄﺮ اﻷول واﻟﺴ ﻄﺮ اﻷﺧ ﻴﺮ وﻣ ﺎ‬
‫ﺑﻴﻨﻬﻤﺎ ﻟﻜﻢ‪.‬‬
‫اﻟﺴﻄﺮ اﻷول‪1612 :‬‬
‫اﻟﺴﻄﺮ اﻷﺧﻴﺮ ‪203 :‬‬

‫أﺳﻠﻮب اﻟﺘﻜﺮار ﺑﺎﺳﺘﻌﻤﺎل ﺣﻠﻘﺔ ‪While & Do‬‬
‫أﺳ ﻠﻮب اﻟ ﺘﻜﺮار ﺑﺎﺳ ﺘﻌﻤﺎل ﺣﻠﻘ ﺔ ‪ while‬أﺳ ﻠﻮب آﺧ ﺮ ﻳﻤ ﺎﺛﻞ أﺳ ﻠﻮب ﺣﻠﻘ ﺔ ‪ ، for‬ﻣ ﻊ‬
‫ﺑﻌ ﺾ اﻻﺧ ﺘﻼﻓﺎت اﻟﺒﺴ ﻴﻄﺔ ‪ ،‬وﻫ ﻮ أﺳ ﻠﻮب ﻳ ﺜﺮى ﻟﻐ ﺔ ‪ ، C++‬وﻳ ﺰدﻫﺎ ﻗ ﻮة وﻣ ﺮوﻧﺔ ‪،‬‬
‫واﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻬﺬا اﻷﺳﻠﻮب‪:‬‬
‫;‪While (conditions) statements‬‬
‫ﺷﺮط أو اﻛﺜﺮ ﻳﻨﻈﻢ‬

‫ﻋﻤﻠﻴﺔ اﻟﺘﻜﺮار‬ ‫ﺟﻤﻠﺔ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ‬
‫ﺣﺴﺐ اﻟﺸﺮط‬
‫‪conditions‬‬
‫وﻣﻌﻨﻰ ﺣﻠﻘﺔ اﻟﺘﻜﺮار ‪ while‬ﻫﻮ اﻷﺗﻲ‪:‬‬

‫آي ﻣ ﺎ دام اﻟﺸ ﺮط ) أو اﻟﺸ ﺮوط ( ﻣ ﺘﺤﻘﻘﺎ )وﺟﻮاﺑ ﻪ ‪ ، (true‬ﻓﻴ ﺘﻢ ﺗﻜ ﺮار ﺗﻨﻔﻴﺬ اﻟﺠﻤﻠﺔ أو‬
‫اﻟﺠﻤ ﻞ )‪ ، (statements‬وﻳﻨ ﺘﻘﻞ ﺗﺴﻠﺴ ﻞ ﺗﻨﻔ ﻴﺬ اﻟ ﺒﺮﻧﺎﻣﺞ إﻟ ﻰ اﻟﺠﻤﻠ ﺔ اﻟﺘ ﻲ ﺗﻠ ﻲ ﺣﻠﻘ ﺔ‬
‫‪. while‬‬
‫واﻷﻣﺜﻠﺔ اﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ذﻟﻚ‪:‬‬
‫ﻣﺜﺎل‪:١٦‬‬
‫)( ‪main‬‬
‫;‪{ int a‬‬
‫;‪a=1‬‬
‫)‪while (a<3‬‬ ‫ﻃﺎﻟﻤﺎ اﻟﺸﺮط‬
‫;‪cout<<a++‬‬
‫}‬ ‫اﻟﺰﻳﺎدة ﺑﻤﻘﺪار ‪1‬‬
‫ﺑﻌﺪ ﻃﺒﺎﻋﺔ‬
‫اﻟﻨﺘﻴﺠﺔ‬
‫واﻟﻨﺎﺗﺞ‬
‫ﺳﻮف ﻳﻜﻮن‪:‬‬
‫‪12‬‬

:١٧‫ﻣﺜﺎل‬
main () ‫اﻓﻌﻞ‬
{ int a;
a=1;
do
{ ‫اﻟﺰﻳﺎدة ﺑﻤﻘﺪار‬
cout<<”*”; 1 ‫اﻟﻘﻴﻤﺔ‬
a++;
}
while (a<=4) ‫ اﻗﻞ أو‬a ‫ﻃﺎﻟﻤﺎ‬
return0; 4 ‫ﻳﺴﺎوي اﻟﻘﻴﻤﺔ‬
} ‫ارﺟﻊ اﻟﺘﻜﺮار‬
‫واﻟﻨﺎﺗﺞ‬
****
:١٨‫ﻣﺜﺎل‬
main ()
{ int x,y;
x=2;
y=-2;
do
{ ‫ﻗﻄﻌﺘﻴﻦ أو ﺑﻠﻮك‬
cout<<x<<”-“<<endl; ‫ﻟﻮﺿﻊ اﻟﺠﻤﻞ‬
x--; ‫ﺑﻴﻨﻬﻤﺎ‬
y++;
}
else
cout<<”finish”;
y ‫ ﻻ ﺗﺴﺎوي‬x ‫ﻃﺎﻟﻤﺎ‬
while(x!=y)
‫ﺗﺎﺑﻊ اﻟﺘﻜﺮار أو اﻟﺪوران‬
..‫ﺗﺘﻮﻗﻒ ﻋﻤﻠﻴﺔ اﻟﺘﻜﺮار‬
return0; ‫ ﺛﻢ‬y ‫ ﻣﻊ ﻗﻴﻤﺔ‬x ‫ﻃﺒﻌﺎ ﺳﻴﺘﻢ اﻟﺘﻜﺮار ﺣﺘﻰ ﺗﺘﺴﺎوى ﻗﻴﻤﺔ‬
}
2--21--1

‫ﻣﺜﺎل‪:١٩‬‬
‫اﻛﺘ ﺐ ﺑ ﺮﻧﺎﻣﺠﺎ ﻳﻄﻠ ﺐ ﻣ ﻦ اﻟﻤﺴ ﺘﺨﺪم إدﺧ ﺎل ﻗ ﻴﻤﺔ ﻋﺪدﻳ ﺔ ‪ ،‬وﻃﺎﻟﻤ ﺎ أن اﻟﻘ ﻴﻤﺔ اﻟﻤﺪﺧﻠ ﺔ ‪+‬‬
‫ﻳﻄﺒﻊ * ﻋﻠﻰ ﺳﻄﺮ ﺟﺪﻳﺪ؟‬
‫اﻟﺤـﻞ‪/‬‬
‫)( ‪main‬‬ ‫ﻧﺪﺧﻞ اﻟﺮﻗﻢ‬
‫;‪{ int a‬‬ ‫وﻟﻴﻜﻦ ‪10‬‬
‫;”‪cout<<”please enter a number‬‬
‫;‪cin>>a‬‬
‫)‪while (a>=0‬‬
‫{‬ ‫ﻃﺎﻟﻤﺎ أن اﻟﺮﻗﻢ‬
‫;‪cout<<”*”<<endl‬‬ ‫اﻟﻤﺪﺧﻞ اﻛﺒﺮ أو‬
‫;”‪cout<<” please enter a number‬‬ ‫ﻳﺴﺎوي ‪0‬‬
‫;‪cin>>a‬‬
‫}‬
‫إذا ﺗﺤﻘﻖ‬
‫اﻟﺸﺮط اﻃﺒﻊ‬
‫}‬
‫ﻃﺒﻌﺎ ﻗﻤﻨﺎ ﺑﺈدﺧﺎل اﻟﺮﻗﻢ ‪ 10‬واﻟﻨﺘﻴﺠﺔ ﺳﺘﻜﻮن‪:‬‬

‫*‬
‫ﻻن اﻟﻌ ﺪد ‪ 10‬ﻋ ﺪد ﻣﻮﺟ ﺐ ﻟﻜ ﻦ ﺣ ﺎول أن ﺗﺪﺧ ﻞ ﻋ ﺪد ﺳ ﺎﻟﺐ ﻓﻠ ﻦ ﻳﻄ ﺒﻊ ﻟ ﻚ ﺷ ﻲ ﻟﻌ ﺪم‬

‫ﺗﺤﻘ ﻖ اﻟﺸ ﺮط ‪ ،‬وﻻ ﻧﻨﺴ ﻰ أﺧﻮاﻧ ﻲ أﻧ ﻨﺎ وﺿ ﻌﻨﺎ اﻟﺠﻤ ﻞ أو اﻟﺠﻤﻠ ﺔ اﻟﺨﺎﺻﺔ ﺑﺎﻟﻄﺒﺎﻋﺔ ﺑﻴﻦ‬
‫اﻟﻘﻄ ﻊ ‪ {} Block‬ﻻﻧ ﻪ وﺟ ﺪ اﻛ ﺜﺮ ﻣ ﻦ ﺟﻤﻠ ﺔ ﻟﺬﻟ ﻚ ﻳﺠ ﺐ وﺿ ﻊ اﻟﻘﻄ ﻊ ﻟﻜ ﻦ ﻋ ﻨﺪ ﻋ ﺪم‬
‫وﺟﻮد اﻛﺜﺮ ﻣﻦ ﺳﻄﺮ أو ﺟﻤﻠﻪ ﻛﻤﺜﺎل )‪ (١٢‬ﻓﻼ ﻳﺠﻮز وﺿﻌﻬﺎ‪.‬‬

‫ﺣﻠﻘﺎت ‪ While‬اﻟﻤﺘﺪاﺧﻠﺔ ‪Nested While Loops‬‬
‫ﺗﺸ ﺒﺔ ﺣﻠﻘ ﺎت ‪ While‬اﻟﻤ ﺘﺪاﺧﻠﺔ ﺣﻠﻘ ﺎت ‪ for‬اﻟﻤ ﺘﺪاﺧﻠﺔ ‪ ،‬ﻓﻤ ﺜﻼ ﺧ ﺬ ﺣﻠﻘﺘ ﻲ اﻟ ﺘﻜﺮار‬
‫اﻟﻤﺘﺪاﺧﻠﺘﻴﻦ اﻟﺘﺎﻟﻴﺘﻴﻦ‪:‬‬
‫ﻣﺜﺎل‪:٢٠‬‬
‫)( ‪main‬‬
‫{‬ ‫ﺣﻠﻘﺎت ﺗﻜﺮار ‪3‬‬
‫;‪int i=j=1‬‬ ‫ﻣﺮات‬
‫)‪while (i<=3‬‬
‫{‬
‫)‪while(j<=4‬‬
‫{‬ ‫اﻟﺤﻠﻘﺔ اﻟﺪاﺧﻠﻴﺔ‬
‫;‪cout<<”/n”<<i*j‬‬ ‫ﺗﺘﻜﺮر ‪ 12‬ﻣﺮة‬
‫;‪++j‬‬
‫}‬
‫زﻳﺎدة ﻣﻨﺘﻈﻤﺔ ﻓﻲ‬
‫;‪++i‬‬
‫ﻋﺪاد‪ I‬ﺑﻤﻘﺪار ‪1‬‬
‫;‪j=1‬‬
‫}‬
‫;‪return0‬‬ ‫إﻋﺎدة ﺗﻌﺮﻳﻒ ﻗﻴﻤﺔ ‪ j‬اﻻﺑﺘﺪاﺋﻴﺔ‬
‫}‬ ‫ﻋﻨﺪ ﺑﺪاﻳﺔ ﺣﻠﻘﺔ ‪j‬‬

‫ﺟﻤﻠﺔ اﻹﻳﻘﺎف ‪Break‬‬
‫ﻣ ﻦ اﻻﺳ ﻢ ﻧﺴ ﺘﻄﻴﻊ أن ﻧﻼﺣ ﻆ أن وﻇ ﻴﻔﺔ ‪ Break‬ﻫ ﻲ إﻳﻘ ﺎف ﺑﻨ ﻴﺔ أو ﺣﻠﻘ ﺔ ﺗﻜ ﺮار ﻋ ﻨﺪ‬
‫ﺗﺤﻘ ﻖ ﺷ ﺮط أو ﺷ ﺮوط ﻣﻌﻴ ﻨﺔ ‪ ،‬وﻋ ﻨﺪ ﺗﻨﻔ ﻴﺬﻫﺎ ﻳ ﺘﻢ اﻟﻘﻔ ﺰ إﻟ ﻰ ﺳﻠﺴ ﻠﺔ اﻟﺠﻤ ﻞ اﻟﺘﺎﻟﻴﺔ ﻟﻠﺒﻨﻴﺔ‬
‫أو ﺣﻠﻘ ﺔ اﻟ ﺘﻜﺮار ‪ ،‬وﺗﺴ ﺘﻌﻤﻞ ‪ Break‬أﻳﻀ ﺎ ﻓ ﻲ إﻳﻘ ﺎف ﺣﻠﻘ ﺔ اﻟ ﺘﻜﺮار ﻻﻧﻬﺎﺋ ﻲ ‪ ،‬أو‬
‫اﻟﺨﺮوج ﻣﻨﻬﺎ إﻟﻰ اﻟﺠﻤﻞ اﻟﺘﻲ ﺗﻠﻴﻬﺎ وﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫ﻣﺜﺎل‪:٢١‬‬
‫)( ‪main‬‬
‫{‬
‫;‪int i‬‬
‫)‪for (i=1;i<100;++i‬‬
‫{‬
‫;‪cout<<i‬‬ ‫ﻳﻮﻗﻒ ﺗﻨﻔﻴﺬ ﻫﺬه اﻟﺠﻤﻠﺔ‬
‫;‪if (i= =10) break‬‬ ‫ﺣﻠﻘﺎت اﻟﺘﻜﺮار ﻋﻨﺪﻣﺎ‬
‫}‬ ‫ﻳﺼﺒﺢ ‪i=10‬‬
‫}‬
‫وﻃﺒﻌﺎ ﺳﻴﻘﻮم ﺑﺘﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺣﺘﻰ اﻟﻌﺪد ‪10‬‬

‫واﻟﻨﺘﺎﺋﺞ‪:‬‬
‫‪12345678910‬‬

:٢٢‫ﻣﺜﺎل‬
main ()
{
int number;
for (number=1; number<=100;++ number)
{
if (number%2) // for ood values
break;
else if (number%4)
break;
else if (number%6)
break;
else
cout<< number<<endl;
}
return0;
}

‫ﺟﻤﻠﺔ اﻻﺳﺘﻤﺮار ‪continue‬‬
‫ﺗﻌﻤ ﻞ ﺟﻤﻠ ﺔ اﻻﺳ ﺘﻤﺮار ‪ continue‬ﻋﻠ ﻰ ﺗﺠ ﺎوز ﺗﻨﻔ ﻴﺬ ﺑﻘ ﻴﺔ اﻟﺠﻤ ﻞ ﻓ ﻲ اﻟ ﺘﻜﺮار ﺧ ﻼل‬
‫اﻟﺪورة اﻟﺤﺎﻟﻴﺔ واﻻﻧﺘﻘﺎل إﻟﻰ اﻟﺪورة اﻟﺜﺎﻧﻴﺔ‪:‬‬
‫ﻣﺜﺎل‪:٢٣‬‬
‫)( ‪main‬‬
‫{‬
‫;‪int x,n‬‬
‫‪do‬‬ ‫ﺗﻌﻤﻞ ﻋﻠﻰ ﺗﺠﺎوز ﺗﻨﻔﻴﺬ‬
‫{‬
‫اﻟﺠﻤﻠﺘﻴﻦ اﻟﺘﺎﻟﻴﺘﻴﻦ‬
‫;‪cin>>x>>n‬‬ ‫وﺗﺒﺪاء دورة ﺟﺪﻳﺪة إذا‬
‫;‪if (n<1) continue‬‬ ‫ﺗﺤﻘﻖ اﻟﺸﺮط‬
‫;‪cout<<x‬‬
‫;‪--n‬‬
‫}‬
‫;)‪while (n<1‬‬
‫}‬

:٢٤‫ﻣﺜﺎل‬
‫ ﺑﺪون‬6‫ و‬4 ‫ و‬2 ‫ ﻣﺎ ﻋﺪا اﻷرﻗﺎم اﻟﺘﻲ ﺗﻘﺴﻢ ﻋﻠﻰ‬100 ‫ إﻟﻰ‬1 ‫ﺗﻄﺒﻊ ﺟﻤﻴﻊ اﻷرﻗﺎم ﻣﻦ‬
:‫ﺑﺎق‬
main ()
{
int number;
for (number=1;number<=100;++number)
{
if (number%2)
continue;
else if (number%4)
continue ;
else if (number%6)
continue;
else
cout<<number<<endl;
}
return0;
}
:‫اﻟﻨﺎﺗﺞ‬
12
24
36
48
60
72
84
96

‫ﺟﻤﻠﺔ اﻟﺨﺮوج )(‪exit‬‬
‫ﺗﻌﻤ ﻞ ﻫ ﺬه اﻟﺪاﻟ ﺔ ﻋﻠ ﻰ إﻳﻘ ﺎف ) أو اﻟﺨ ﺮوج ﻣ ﻦ ( اﻟ ﺒﺮﻧﺎﻣﺞ ﻓ ﻲ ﻣﻜﺎن ﻣﻨﻪ ‪ ،‬وﺗﺸﺒﺔ ‪end‬‬
‫ﻓ ﻲ ﻟﻐ ﺔ ﺑﻴﺴ ﻚ ‪ ،‬وﺗﻜ ﻮن ﻗ ﻴﻤﺔ اﻟﺪاﻟ ﺔ ﺻ ﻔﺮا )‪ exit(0‬ﻋ ﻨﺪﻣﺎ ﻳ ﺘﻢ اﻟﺨ ﺮوج ﻣ ﻦ اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﺑ ﻨﺠﺎح وأﻻ ﻓ ﺎن ﻗ ﻴﻤﺔ اﻟﺪاﻟ ﺔ ﺗﻜ ﻮن )‪ exit(1‬وﺗﻮﻗ ﻒ اﻟ ﺒﺮﻧﺎﻣﺞ ﻋ ﻨﺪ وﺟ ﻮد ﺧﻄ ﺄ أو ﻧﺤ ﻮ‬
‫ذﻟ ﻚ ‪ ،‬وﻓ ﻲ ﻫ ﺬه اﻟﺤﺎﻟ ﺔ ‪ ،‬وﺗﻠ ﻚ ﻳﻌ ﻮد اﻟ ﺒﺮﻧﺎﻣﺞ ﺗﻨﻔ ﻴﺬه إﻟ ﻰ ﻧﻈ ﺎم اﻟﺘﺸ ﻐﻴﻞ ‪operating‬‬
‫‪. system‬‬
‫ﻣﺜﺎل‪:٢٥‬‬
‫”‪#include “ iostream.h‬‬ ‫ﻣﺜﺎل‪:٢٣‬‬
‫)( ‪main‬‬
‫{‬
‫;‪chat ma‬‬
‫;‪cin>>ma‬‬
‫;)‪if ( ma != ‘A’) exit(1‬‬
‫;‪cout<<”\n”<<ma‬‬
‫}‬

‫ﺟﻤﻠﺔ اﻻﻧﺘﻘﺎل ‪goto‬‬
‫ﻣ ﻦ اﻟﻤﻌ ﺮوف أن ﻣﻌﻈ ﻢ ﻟﻐ ﺎت اﻟﺒﻨ ﻴﻮﻳﺔ اﻟﺤﺪﻳ ﺜﺔ ‪ ،‬ﺗﺤ ﺮص ‪ ،‬ﻓ ﻲ ﻏﺎﻟ ﺐ اﻷﺣ ﻴﺎن أﻻ‬
‫ﺗﺴ ﺘﻌﻤﻞ ﺟﻤﻠ ﺔ ‪ goto‬ﻣ ﻦ اﺟ ﻞ اﻟﺘﺄﻛ ﻴﺪ ﻋﻠ ﻰ اﻟﻤ ﺒﺮﻣﺞ ‪ ،‬أن ﻳ ﺘﻌﻠﻢ ﺑ ﺮاﻣﺠﻪ ﺑﻄﺮﻳﻘﺔ ﺑﻨﻴﻮﻳﺔ‬
‫‪ structured‬ذاﺗ ﻴﺔ اﻟﻤﺪاﺧ ﻞ واﻟﻤﺨ ﺎرج ‪ ،‬واﻟﻌﻤﻠ ﻴﺎت ‪ ،‬دون ﺗﺪﺧ ﻞ ﻣ ﻦ اﻟﻤ ﺒﺮﻣﺞ ﺑﻘﻮﻟﻪ ‪:‬‬
‫اذﻫ ﺐ ‪ goto‬ﻣ ﻦ ﻫ ﻨﺎ ‪ ،‬أو اذﻫ ﺐ ﻣ ﻦ ﻫ ﻨﺎك آي أن اﻟ ﺒﺮﻧﺎﻣﺞ ﻓ ﻲ ﻫ ﺬه اﻟﺤﺎﻟ ﺔ ﻳﻌﺘﻤﺪ ﻋﻠﻰ‬
‫ﻧﻔﺴﻪ ‪.‬‬
‫ﻣﺜﺎل‪:٢٦‬‬
‫)( ‪main‬‬
‫{‬
‫;‪int x‬‬
‫;‪cin>>x‬‬
‫;‪if (x<10) goto negative‬‬
‫;‪negative: cout<<”value is under 10”<<endl‬‬
‫}‬
‫ﻓ ﻲ ﻫ ﺬا اﻟﺴ ﺆال ﻳﻄﻠ ﺐ ﻣ ﻦ اﻟﻤﺴ ﺘﺨﺪم إدﺧ ﺎل ﻗ ﻴﻤﺔ ﻓ ﺈذا ﻛﺎﻧ ﺖ اﻟﻘ ﻴﻤﺔ اﻗ ﻞ ﻣﻦ ‪ 10‬ﺣﺴﺐ‬
‫اﻟﺸﺮط ﻓﺎﻧﻪ ﻳﻌﺮض ﻟﻚ اﻟﺮﺳﺎﻟﺔ ‪. value is under 10‬‬
‫أﻣ ﺎ إذا ﻛﺎﻧ ﺖ اﻛ ﺒﺮ ﻣ ﻦ اﻟﻌ ﺪد ‪ 10‬ﻓﺎﻧ ﻪ ﻳﻄ ﺒﻊ اﻟﻌ ﺪد ﻣﺒﺎﺷ ﺮة ﻣ ﻦ دون اﻟﺬﻫ ﺎب ﻟﻠﺴ ﻄﺮ‬
‫اﻷﺧﻴﺮ ﻟﺘﺤﻘﻖ اﻟﺸﺮط ‪.‬‬

‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﻗﻤﺔ واﻟﻤﺼﻔﻮﻓﺎت‬
‫‪Arrays and Matrices‬‬
‫أن ﻃ ﺮق اﻟ ﺘﻌﺎﻣﻞ ﻣ ﻊ أﺳ ﻤﺎء اﻟﻤﺘﻐ ﻴﺮات واﻟﺜﻮاﺑ ﺖ اﻟﻌﺪدﻳ ﺔ واﻟﺮﻣ ﺰﻳﺔ ‪ ،‬اﻟﺘ ﻲ وردت ﻓ ﻲ‬
‫اﻟﻔﺼ ﻮل اﻟﺴ ﺎﺑﻘﺔ ‪ ،‬ﺗﻌ ﺪ ﺻ ﺎﻟﺤﺔ ﻟﻠ ﺘﻌﺎﻣﻞ ﻣ ﻊ ﻋ ﺪد ﻣﺤ ﺪود ﻣﻦ ﻫﺬه اﻟﺜﻮاﺑﺖ واﻟﻤﺘﻐﻴﺮات ‪،‬‬
‫ﺳ ﻮاء ﻓ ﻲ ﻋﻤﻠ ﻴﺎت اﻹدﺧ ﺎل واﻹﺧ ﺮاج أو ﻓ ﻲ اﻟﻌﻤﻠ ﻴﺎت اﻟﺤﺴ ﺎﺑﻴﺔ واﻟﻤﻨﻄﻘ ﻴﺔ ‪ ،‬وﻋ ﻨﺪﻣﺎ‬
‫ﻳﺼ ﺒﺢ ﻋ ﺪد اﻟﻤﺘﻐ ﻴﺮات ﻛﺒ ﻴﺮا ﺟ ﺪا ‪ ،‬ﺗﺼ ﺒﺢ ﺗﻠ ﻚ اﻟﻄ ﺮق ﻏ ﻴﺮ ﻋﻤﻠ ﻴﺔ ‪ ،‬ﻓﻤ ﺜﻼ ﻟ ﻮ أردﻧ ﺎ‬
‫إدﺧ ﺎل ﻣﺎﺋ ﺔ ﻗ ﻴﻤﺔ ﻟﻠﻤﺘﻐ ﻴﺮات ‪ .... x2,x1-‬إﻟ ﻲ ‪ ، x100‬ﻓﻜ ﻢ اﻟﺤ ﻴﺰ اﻟﻤﻄﻠ ﻮب ﻣ ﻦ‬
‫اﻟ ﺒﺮﻧﺎﻣﺞ ﻟﻌﻤﻠ ﻴﺎت اﻹدﺧ ﺎل واﻹﺧ ﺮاج واﻟﻌﻤﻠ ﻴﺎت اﻟﺤﺴ ﺎﺑﻴﺔ واﻟﻤﻨﻄﻘ ﻴﺔ ﻟﻬ ﺬه اﻟﻤﺘﻐﻴﺮات ؟‬
‫ﻫ ﺬا ﻣ ﻦ ﺟﻬ ﺔ ‪ ،‬وﻣ ﻦ ﺟﻬ ﺔ أﺧ ﺮى ‪ :‬ﻓﺄﻧ ﻨﺎ ﻧﻮﻓ ﺮ ﻣﺨ ﺰﻧﺎ ﺧﺎﺻ ﺎ ﻟﻜ ﻞ ﻣﺘﻐﻴﺮ ﻧﺘﻌﺎﻣﻞ ﻣﻌﻪ ‪،‬‬
‫أﺛ ﻨﺎء ﺗﻨﻔ ﻴﺬ اﻟ ﺒﺮﻧﺎﻣﺞ ‪ ،‬وﻟﺬﻟ ﻚ ﻟﺤﻔ ﻆ ﻗﻴﻤ ﺘﻪ ﻓ ﻲ ﻣﺨ ﻮن ‪ ،‬وﻣ ﻦ ﺛ ﻢ ﻻﺳ ﺘﻌﻤﺎل ﻗﻴﻤ ﺘﻪ ﻓ ﻲ‬
‫ﻋﻤﻠ ﻴﺎت أﺧ ﺮى ﺗﺎﻟ ﻴﺔ ‪ ،‬وﻣ ﻦ ﻧﺎﺣ ﻴﺔ ﺛﺎﻟ ﺜﺔ ‪ ،‬ﻓ ﺎن ﻣ ﻦ اﻟﺼﻌﻮﺑﺔ ﺑﻤﻜﺎن ‪ ،‬ﺑﻞ ﻣﻦ اﻟﻤﺴﺘﺤﻴﻞ‬
‫اﺳﺘﻌﻤﺎل اﺳﻢ اﻟﻤﺘﻐﻴﺮ اﻟﻌﺪدي أو اﻟﺮﻣﺰي ﻛﻤﺼﻔﻮﻓﺔ ذات ﺑﻌﺪﻳﻦ ‪ ،‬وﺛﻼﺛﺔ أﺑﻌﺎد ‪...‬اﻟـﺦ‬
‫ﻟﻸﺳ ﺒﺎب اﻟ ﺜﻼﺛﺔ اﻟ ﻮاردة أﻋ ﻼه ‪ ،‬ﺟ ﺎءت ﻓﻜ ﺮة اﺳﺘﻌﻤﺎل ﻣﺘﻐﻴﺮ ﺟﻤﺎﻋﻲ ﻳﻀﻢ ﺗﺤﺖ اﺳﻤﻪ‬
‫ﻋ ﺪدا ﻣ ﻦ اﻟﻌﻨﺎﺻ ﺮ ﻳﺴ ﻤﻰ ﺑﺎﻟﻤﺘﻐ ﻴﺮ اﻟﺮﻗﻤ ﻲ ‪ ، subscripted variable‬وﻳ ﺘﻢ ﺗﺮﻗﻤ ﻴﻪ‬
‫ﺑﻴ ﻦ ﻗﻮﺳ ﻴﻦ ﻣﺮﺑﻌﻴ ﻦ ] [ ﻳﻮﺿ ﻊ ﺑﻴ ﻨﻬﻤﺎ ﻗ ﻴﻤﺔ اﻟﻌ ﺪاد اﻟﻤ ﺮﻗﻢ ‪ ، subscript‬وﻗ ﺪ ﻧﺴ ﻤﻴﺔ‬
‫اﻟﺪﻟ ﻴﻞ ‪ index‬أﺣ ﻴﺎﻧﺎ ‪ ،‬وﻳﻤﻜﻨ ﻨﺎ ﺗﺸ ﺒﻴﻪ اﻟﻤﺘﻐ ﻴﺮ اﻟﻤ ﺮﻗﻢ ﺑﻘﺴ ﻢ اﻟﻬ ﺎﺗﻒ ﻟﻤﺆﺳﺴ ﺔ ﻣ ﺎ ‪ ،‬ﻓﻬ ﻮ‬
‫ﻣﻘﺴ ﻢ واﺣ ﺪ ‪ ،‬ﺗ ﻨﻈﻢ ﺗﺤ ﺘﻪ ﻋ ﺪد ﻣ ﻦ اﻷرﻗ ﺎم اﻟﻔﺮﻋﻴﺔ ﻟﻠﻤﻮﻇﻔﻴﻦ وﻛﻞ رﻗﻢ ﻣﻦ ﻫﺬه اﻷرﻗﺎم‬
‫ﻣﺴ ﺘﻘﻞ وﻣﺘﻤ ﻴﺰ ﻋ ﻦ اﻷرﻗ ﺎم اﻟﻔﺮﻋ ﻴﺔ اﻷﺧ ﺮى ‪ ،‬و ﻟﻪ ﻣﺨ ﺰن ﺧ ﺎص ﻓ ﻲ اﻟﺬاﻛ ﺮة ‪ ،‬اﻵن‬
‫اﻧ ﻪ ﻛﻐ ﻴﺮه ﻣ ﻦ اﻷرﻗ ﺎم اﻟﻔﺮﻋ ﻴﺔ ﺗ ﺎﺑﻊ ﻟﻠ ﺮﻗﻢ اﻟﻌ ﺎم ﻟﻤﻘﺴ ﻢ اﻟﻤﺆﺳﺴ ﺔ ‪ ،‬ﻛﻤ ﺎ ﻳﻤﻜ ﻦ ﺗﺸ ﺒﻴﻪ‬
‫اﻟﻤﺘﻐ ﻴﺮ اﻟﻤ ﺮﻗﻢ ﺑﺎﻟﺠ ﻴﺶ اﻟ ﺬي ﻳﻌ ﺎﻣﻞ ﻛﺎﺳ ﻢ ﻣﺘﻐ ﻴﺮ واﺣ ﺪ ‪ ،‬ﻟﻜ ﻦ ﻳﻀ ﻢ ﻋ ﺪدا ﻛﺒ ﻴﺮا ﻣ ﻦ‬
‫اﻟﻌﻨﺎﺻﺮ ‪ ،‬ﻓﻤﺜﻼ اﻟﻌﻨﺎﺻﺮ اﻟﺘﺎﻟﻴﺔ ‪):‬ﻣﻦ اﻟﻴﻤﻴﻦ إﻟﻰ اﻟﻴﺴﺎر(‪:‬‬
‫]‪A[n] ...a[2], a[1], a[0‬‬
‫ﺗﺎﺑﻊ ﻟﻠﻤﺘﻐﻴﺮ اﻟﺠﻤﺎﻋﻲ ] [‪a‬‬
‫وﻛ ﻞ ﻋﻨﺼ ﺮ ﻣ ﻦ ﻫ ﺬه اﻟﻌﻨﺎﺻ ﺮ ﻟﻪ ﻋ ﻨﻮان ﻓ ﻲ اﻟﺬاﻛﺮ ‪ ، address‬ﻓﺎﻟﻌﻨﻮان اﻷول ﻳﻜﻮن‬
‫ﻟﻠﻌﻨﺼﺮ اﻷول واﻟﺜﺎﻧﻲ ﻟﻠﺜﺎﻧﻲ واﻟﺜﺎﻟﺚ ﻟﻠﺜﺎﻟﺚ ‪ ...‬وﻫﻜﺬا‪.‬‬
‫وﻳﺴ ﺘﻌﻤﻞ اﻟﻤﺘﻐ ﻴﺮ اﻟﺠﻤﺎﻋ ﻲ ]اﻟﻤ ﺮﻗﻢ[ أو اﻟﻤﺼ ﻔﻮﻓﺔ ‪ ،‬ﻓ ﻲ ﻟﻐ ﺔ ‪ c++‬وﻏ ﻴﺮﻫﺎ ‪ ،‬ﺣﺠ ﺰ‬
‫ﺟﻤﺎﻋ ﻲ ﻣﺴ ﺒﻖ ﻓ ﻲ اﻟﺬاﻛ ﺮة ﻟﺠﻤ ﻴﻊ ﻋﻨﺎﺻ ﺮه ‪ ،‬ﻓﻠ ﻮ ﻛ ﺎن ﻳﺘ ﺒﻌﻪ ﺧﻤﺴ ﻮن ﻋﻨﺼ ﺮا ‪ ،‬ﻓﺎﻧ ﻪ‬
‫ﻳﺤﺠﺰ ﻟﻪ ‪ 50‬ﻣﺨﺰﻧﺎ ‪ ،‬ﻋﻠﻰ اﻷﻗﻞ ﻓﻲ اﻟﺬاﻛﺮة ‪.‬‬
‫ﻣ ﻦ اﻟﻔﻮاﺋ ﺪ اﻟﻤﻬﻤ ﺔ ﻟﻠﻤﺘﻐ ﻴﺮات اﻟﻤ ﺮﻗﻤﺔ واﻟﻤﺼ ﻔﻮﻓﺎت ‪ :‬ﻫ ﻮ اﺳ ﺘﻌﻤﺎﻟﻬﺎ ﻓ ﻲ اﻟﺘﺮﺗﻴ ﺐ‬
‫اﻟﺘﺼ ﺎﻋﺪي واﻟﺘﻨﺎزﻟ ﻲ ﻟﻠﻌﻨﺎﺻ ﺮ واﻟﻘ ﻴﻢ اﻟﻤﺨ ﺘﻠﻔﺔ ‪ ،‬وﻋﻤﻠ ﻴﺎت ﺗﺮﺗﻴ ﺐ اﻷﺳ ﻤﺎء اﻷﺑﺠ ﺪي‬

‫اﻟﻨﺼ ﻮص اﻟﺮﻣ ﺰﻳﺔ ‪ ،‬وﻓ ﻲ ﻋﻤﻠ ﻴﺎت ﺿ ﺮب اﻟﻤﺼ ﻔﻮﻓﺎت ‪ ،‬وإﻳﺠ ﺎد ﻣﻌﻜ ﻮس اﻟﻤﺼ ﻔﻮﻓﺔ‬
‫وﻋﻤﻠﻴﺎﺗﻬﺎ اﻷﺧﺮى ‪ ،‬وﻓﻲ اﻟﺘﺤﻠﻴﻞ اﻟﻌﺪدي ‪ ...‬اﻟـﺦ‪.‬‬
‫اﻟﻤﺘﻐﻴﺮ اﻟﻤﺮﻗﻢ ) اﻟﻤﺼﻔﻮﻓﺔ ( ذو اﻟﺒﻌﺪ اﻟﻮاﺣﺪ ‪one-dimensional Array‬‬
‫اﻟﻤﺘﻐ ﻴﺮ اﻟﻤ ﺮﻗﻢ ذو اﻟ ﺒﻌﺪ اﻟﻮاﺣ ﺪ ﻫ ﻮ ﻣﺼ ﻔﻮﻓﺔ ذات ﺑﻌﺪ واﺣﺪ أو ﻣﺘﺠﻪ )‪ (vector‬وﻳﻤﺜﻞ‬
‫ﻓﻲ اﻟﺠﺒﺮ ﻋﻠﻰ اﻟﻨﺤﻮ اﻷﻓﻘﻲ ]‪[a1 a2 ...a3‬‬
‫أو اﻟﻌﻤﻮدي‬
‫‪A1‬‬
‫‪A2‬‬
‫‪:‬‬
‫‪:‬‬
‫‪:‬‬
‫‪a3‬‬
‫وﻳﺄﺧﺬ اﻟﻤﺮﻗﻢ اﻟﻤﺘﻐﻴﺮ ﻓﻲ ‪ c++‬اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‪:‬‬

‫;]‪Type-specifier array-name[size‬‬
‫اﻟﻌﺪد ﻣﻦ‬
‫اﻻﺳﻢ اﻟﺠﻤﺎﻋﻲ‬
‫ﻣﺜﻞ ‪double -– int‬‬ ‫اﻟﻌﻨﺎﺻﺮ‬
‫‪char‬‬
‫وﻳ ﺒﺪأ اﻟﻌ ﺪاد اﻟﻤ ﺮﻗﻢ ﻋ ﺎدة ﻣ ﻦ اﻟﺼ ﻔﺮ ‪ ،‬آي أن اﻟﻌﻨﺼ ﺮ اﻷول ﻣ ﻦ اﻟﻤﺼ ﻔﻮﻓﺔ ][‪ a‬ﻫ ﻮ‬
‫]‪ a[0‬واﻟﺜﺎﻧﻲ ]‪ ... a[1‬وﻫﻜﺬا ﻓﻤﺜﻼ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫;]‪Int a[20‬‬
‫اﺳﻤﻬﺎ ‪ ، a‬وﻗﺪ ﺣﺠﺰ ﻟﻬﺎ ‪ 20‬ﻣﻮﻗﻌﺎ ﻟﻌﺸﺮﻳﻦ ﻋﻨﺼﺮا ﻣﻦ اﻟﻨﻮع اﻟﺼﺤﻴﺢ ‪.‬‬
‫واﻟﻤﺼﻔﻮﻓﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫;]‪Char name[15‬‬
‫ﻣﺼﻔﻮﻓﺔ رﻣﺰﻳﺔ ‪ ،‬اﺳﻤﻬﺎ ‪ name‬ﻳﺤﺠﺰ ﻟﻬﺎ ﺧﻤﺴﺔ ﻋﺸﺮ ﻋﻨﺼﺮا ﻣﻦ اﻟﻨﻮع اﻟﺮﻣﺰي‬
‫ﻟﻬﺎ ‪.‬‬
‫وﻫﻜـﺬا‪...‬‬

‫ﻣﺜﺎل ﻋﻠﻰ ﻋﻤﻠﻴﺔ إدﺧﺎل ذاﺗﻲ ﻟﻘﻴﻢ ﻋﻨﺎﺻﺮ ﻣﺘﻐﻴﺮ ﻣﺮﻗﻢ ) ﻣﺼﻔﻮﻓﺔ ( ذي ﺑﻌﺪ واﺣﺪ‬
‫)( ‪main‬‬
‫{‬
‫;]‪int a[20‬‬
‫;‪int I‬‬
‫)‪for (I=0;I<20;++I‬‬
‫;‪a[I]=I+1‬‬
‫}‬ ‫ﻋﺪاد ﻣﺮﻗﻢ‬
‫اﻟﻤﺼﻔﻮﻓﺔ‬
‫ﻓﻲ ﻫﺬه اﻟﺤﺎﻟﺔ ﻳﺘﻢ إدﺧﺎل ﻋﺸﺮﻳﻦ ﻋﻨﺼﺮا ﻣﻦ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪a‬‬
‫‪ A[0]=1‬ﻋﻨﺪﻣﺎ ﻳﻜﻮن ‪I=0‬‬
‫‪ A[1]=2‬ﻋﻨﺪﻣﺎ ﻳﻜﻮن ‪I=1‬‬
‫…‬
‫…‬
‫…‬
‫‪ a[19]=20‬ﻋﻨﺪﻣﺎ ﻳﻜﻮن ‪I=19‬‬

:٢‫ﻣﺜﺎل‬
:‫ وﻋﻤﻠﻴﺎت ﻃﺒﺎﻋﺔ ﻋﻨﺎﺻﺮ ﻣﺼﻔﻮﻓﺔ‬، ‫ وﺣﺴﺎب‬، ‫ﻣﺜﺎل ﻋﻠﻰ ﻋﻤﻠﻴﺎت إدﺧﺎل‬
main ()
{
int x[5], y[5];
int I;
for (I=0;I<5;++I)
{
x[I]=I;
y[I]=I*I;
cout<<endl<<x[I]<<y[I];
}
return0;
}
:‫وﺳﺘﻜﻮن ﻗﻴﻢ اﻟﻨﺘﺎﺋﺞ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‬

0 0
1 1
2 4
3 9
4 16

‫إﻋﻄـﺎء ﻗﻴﻤﺔ أوﻟﻴﺔ ﻟﻠﻤﺼﻔﻮﻓﺔ ذات اﻟﺒﻌﺪ اﻟﻮاﺣﺪ ‪Array‬‬
‫‪Initialization‬‬
‫ﻣﺜﺎل ﻋﻠﻰ إدﺧﺎل ﻋﺪة ﻋﻨﺎﺻﺮ ﻣﻦ ﻣﺼﻔﻮﻓﺔ اﻟﺪرﺟﺎت ][‪grade‬‬
‫}‪Int grade[5]={80,90,54,50,95‬‬
‫وﻣﺜﺎل ﻋﻠﻰ إدﺧﺎل ﻗﻴﻢ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺮﻣﺰﻳﺔ ][‪name‬‬

‫”‪Char name[4]=“nor‬‬
‫ﻻﺣ ﻆ أن اﻟﻤﺘﻐ ﻴﺮ اﻟﻤ ﺮﻗﻢ ][‪ name‬ﻣﻜ ﻮن ﻣ ﻦ أرﺑﻌ ﺔ ﻋﻨﺎﺻ ﺮ ﺑﻴ ﻨﻤﺎ ﺗ ﻢ إﻋﻄ ﺎؤه ﺛﻼﺛ ﺔ‬
‫ﻋﻨﺎﺻﺮ ﻓﻘﻂ واﻟﺴﺒﺐ أن اﻟﻌﻨﺼﺮ اﻟﺮاﺑﻊ ﺑﺎﻟﻨﺴﺒﺔ إﻟﻰ اﻟﻤﻌﻄﻴﺎت اﻟﺮﻣﺰﻳﺔ ﻳﻜﻮن ﺧﺎﻟﻴﺎ‪.‬‬
‫)( ‪main‬‬
‫{‬ ‫ﺗﻢ إﻋﻄﺎء اﻟﻘﻴﻢ ﻣﻦ ﻗﺒﻞ‬
‫}‪int a[6]={40,60,50,70,80,90‬‬ ‫اﻟﻤﺴﺘﺨﺪم ﻣﺴﺒﻘﺎ ﻫﻨﺎ‬
‫;‪int I‬‬
‫)‪for(I=0;I<6;I++‬‬
‫;‪cout<<a[I]<<endl‬‬
‫}‬
‫واﻟﻨﺎﺗﺞ ﻃﺒﻌﺎ ﺳﻴﻜﻮن ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪40‬‬
‫‪60‬‬
‫‪50‬‬
‫‪70‬‬
‫‪80‬‬
‫‪90‬‬

:٤‫ﻣﺜﺎل‬
‫ ﻣ ﻮاد وﻫ ﺬه‬5 ‫ وﻣﻌ ﺪل ﻋﻼﻣ ﺎت اﻟﻄﺎﻟ ﺐ ﻓ ﻲ‬، ‫ﻗ ﻢ ﺑﻜ ﺘﺎﺑﺔ ﺑ ﺮﻧﺎﻣﺞ ﻳﻘ ﻮم ﺑﺈﻳﺠ ﺎد ﻣﺠﻤ ﻮع‬
:‫اﻟﻌﻼﻣﺎت ﻛﺎﻟﺘﺎﻟﻲ‬
87,67,81,90,55
int m,i;
main ()
{
int a[5]={87,67,81,90,55}
int s=0; ‫ﻗﻴﻤﺔ اﻟﻤﻌﺪل‬
for(i=0;i<5;i++) ‫ﻟﺠﻤﻴﻊ اﻟﻌﻼﻣﺎت‬
s=s+m[a];
float avg=s/5;
cout<<avg<<endl;<<s<<endl;
return0;
}
:‫واﻟﻨﺎﺗﺞ ﺳﻴﻜﻮن ﻛﺎﻟﺘﺎﻟﻲ‬

87
735
87 ‫اﻟﻤﻌﺪل‬
735 ‫واﻟﻤﺠﻤﻮع‬

‫ﻋــﻨﻮان ﻋﻨﺎﺻــﺮ اﻟﻤﺼــﻔﻮﻓﺔ ﻓــﻲ اﻟﺬاﻛــﺮة ‪Addressing‬‬
‫‪Array Elements in Memory‬‬
‫ذﻛ ﺮﻧﺎ ﻣ ﻦ ﻗ ﺒﻞ أن آي ﻣﺘﻐ ﻴﺮ أو ﻋﻨﺼﺮ ﻣﻦ ﻣﺘﻐﻴﺮ ذاﺗﻲ ﻣﺮﻗﻢ ‪ ،‬ﻳﺤﺘﻞ ﻣﻮﻗﻌﺎ ﻣﻦ اﻟﺬاﻛﺮة‬
‫ﻳﺴ ﺘﻌﻤﻞ ﻋ ﺎدة ﻣﺆﺷ ﺮا ﻟﻜ ﻞ ﻣﺘﻐ ﻴﺮ أو ﻋﻨﺼ ﺮ ‪ ،‬ﻟ ﻴﻜﻮن دﻟ ﻴﻼ ﻋﻠ ﻰ اﺳ ﺘﻌﻤﺎل ﻫ ﺬه‬
‫اﻟﻤﺘﻐ ﻴﺮات واﻟﻌﻨﺎﺻ ﺮ ﺑﺴ ﻬﻮﻟﺔ وﻳﺴ ﺮ ‪ ،‬واﻟﻤ ﺜﺎل اﻟﺘﺎﻟ ﻲ ﻳﻮﺿ ﺢ ﻫ ﺬه اﻟﻌﻤﻠ ﻴﺔ ﺑﺎﻟﻨﺴ ﺒﺔ‬
‫ﻟﻠﻤﺼﻔﻮﻓﺔ ذات ﺑﻌﺪ واﺣﺪ‪.‬‬
‫;]‪Int x[5‬‬
‫ﻳﻤﻜ ﻦ ﺗﻤﺜ ﻴﻞ ﻋﻨﺎﺻ ﺮ اﻟﻤﺼ ﻔﻮﻓﺔ ‪ x‬اﻟﻤﻌﻠ ﻦ ﻋ ﻨﻬﺎ ‪ ،‬ﻣ ﻊ ﻋﻨﺎوﻳ ﻨﻬﺎ ﺑﺎﻟﺸ ﻜﻞ اﻟﺘﻮﺿ ﻴﺤﻲ‬
‫اﻟﺘﺎﻟﻲ ) ﻣﻦ اﻟﻴﺴﺎر إﻟﻰ اﻟﻴﻤﻴﻦ(‬
‫اﻷول‬ ‫اﻟﺜﺎﻧﻲ‬ ‫اﻟﺜﺎﻟﺚ‬ ‫اﻟﺮاﺑﻊ‬ ‫اﻟﺨﺎﻣﺲ‬
‫]‪X[0‬‬ ‫]‪X[1‬‬ ‫]‪X[2‬‬ ‫]‪X[3‬‬ ‫]‪X[4‬‬
‫‪100‬‬ ‫‪101‬‬ ‫‪102‬‬ ‫‪103‬‬ ‫‪104‬‬
‫ﻋﻨﻮاﻧﻪ ﻓﻲ‬
‫اﻟﺬاﻛﺮة‬
‫اﻟﻌﻨﺼﺮ‬
‫إذا ﻓﺮﺿ ﻨﺎ أن ﻋ ﻨﻮان ﻣﻮﻗ ﻊ اﻟﻌﻨﺼ ﺮ اﻷول ]‪ x[0‬ﻓ ﻲ اﻟﺬاﻛ ﺮة ﻫ ﻮ ‪ ، 100‬ﻓﺎن ﻋﻨﺎوﻳﻦ‬
‫اﻟﻌﻨﺎﺻﺮ اﻷﺧﺮى ﺗﻜﻮن ﻋﻠﻰ اﻟﺘﻮاﻟﻲ ‪104 103 102 101‬‬
‫ﻳﻤﻜ ﻦ ﺗﺸ ﺒﻴﻪ اﻟﻌﻼﻗ ﺔ ﺑﻴ ﻦ ﻗ ﻴﻤﺔ اﻟﻌﻨﺼﺮ ‪ ،‬وﻋﻨﻮاﻧﻪ ‪ ،‬ﺑﺎﻟﻌﻼﻗﺔ ﺑﻴﻦ ﻋﻼﻣﺔ ﻃﺎﻟﺐ ‪ ،‬ورﻗﻤﻪ‬
‫اﻟﺠﺎﻣﻌﻲ ‪ ،‬إذ ﻋﻼﻣﺘﻪ ﻫﻲ ﻗﻴﻤﺔ ﻧﺸﻄﻪ ﻛﻌﻨﺼﺮ ‪ ،‬ﻟﻴﺲ ﻟﻬﺎ ﻋﻼﻗﺔ ﺑﺮﻗﻢ ﻣﻘﻌﺪه اﻟﺠﺎﻣﻌﻲ‪.‬‬

‫اﻟﻤﺼﻔﻮﻓﺔ ذات اﻟﺒﻌﺪﻳﻦ ‪Two-Dimensional Arrays‬‬
‫ﺗﺸ ﺒﺔ اﻟﻤﺼ ﻔﻮﻓﺔ ذات اﻟﺒﻌﺪﻳ ﻦ ﻓ ﻲ ﻃ ﺮﻳﻘﺔ ﺗﻌﺎﻣﻠﻬ ﺎ ‪ ،‬اﻟﻤﺼ ﻔﻮﻓﺔ ذات اﻟ ﺒﻌﺪ اﻟﻮاﺣ ﺪ إﻻ أن‬
‫ﻟﻬ ﺎ ﻋﺪادﻳ ﻦ) ‪ (index2‬دﻟﻴﻠﻴ ﻦ أو ﻣﺮﻗﻤﻴ ﻦ إﺣﺪاﻫﻤ ﺎ ﻋ ﺪاد ﻟﻠﺼ ﻔﻮف ‪ ،‬واﻷﺧ ﺮ ﻋ ﺪاد‬
‫ﻟﻸﻋﻤﺪة وﻳﺄﺧﺬ اﻹﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‪:‬‬
‫;]‪Type-specifier arraey_name [index 1][index 2‬‬
‫اﺳﻢ اﻟﻤﺼﻔﻮﻓﺔ‬ ‫اﻟﺪﻟﻴﻞ اﻷول‬ ‫اﻟﺪﻟﻴﻞ اﻟﺜﺎﻧﻲ‬
‫ﻓﻤﺜﻼ اﻟﻤﺼﻔﻮﻓﺔ ‪:‬‬

‫;]‪Int x[2][3‬‬
‫وﻫ ﻲ ﻣﺼ ﻔﻮﻓﺔ ﺻ ﺤﻴﺤﺔ اﻟﻌﻨﺎﺻ ﺮ ‪ int‬أﺑﻌﺎدﻫ ﺎ ﻫ ﻲ ﻋ ﺪد اﻟﺼ ﻔﻮف=‪ ، 2‬وﻋﺪد اﻷﻋﻤﺪة‬
‫=‪3‬‬
‫ﻻﺣﻆ أن ﻋﺪد اﻟﺼﻔﻮف ﻳﻮﺿﻊ ﺑﻴﻦ ﻗﻮﺳﻴﻦ وﺣﺪه ‪ ،‬وﻛﺬﻟﻚ ﻋﺪاد اﻷﻋﻤﺪة ‪.‬‬

‫ﺷﺎﻫﺪ ﻫﺬا اﻟﻤﺜﺎل اﻟﺬي ﻳﺴﺘﺨﺪم ‪ 5‬ﻃﻼب و ‪ 3‬ﻋﻼﻣﺎت‪:‬‬
‫)( ‪main‬‬
‫{‬
‫;]‪int m[5][3‬‬
‫;‪int I,j‬‬
‫)‪for(I=0;I<5;I++‬‬
‫)‪for(j=0;j>3;j++‬‬
‫;]‪cin>>m[I][j‬‬
‫}‬
‫وﺑﺎﻟﻨﺴ ﺒﺔ ﻟﻌﻨﺎوﻳ ﻦ اﻟﻌﻨﺎﺻ ﺮ اﻟﻤﺼ ﻔﻮﻓﺔ ﻣ ﺘﻌﺪدة اﻷﺑﻌ ﺎد ﻓ ﻲ اﻟﺬاﻛ ﺮة ‪ ،‬ﻻ ﻳﺨ ﺘﻠﻒ ﻋﻤ ﺎ‬
‫ذﻛ ﺮﻧﺎ ﺑﺎﻟﻨﺴ ﺒﺔ ﻟﻠﻤﺼ ﻔﻮﻓﺎت ذات اﻟ ﺒﻌﺪ اﻟﻮاﺣ ﺪ ‪ ،‬وﻟﺬﻟﻚ ﻟﻮ ﻓﺮﺿﻨﺎ ‪ ،‬ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ أن‬
‫اﻟﻌﻨﺼ ﺮ ]‪ x[0,0‬ﻛ ﺎن ﻋ ﻨﻮاﻧﻪ ‪ 100‬ﻣ ﺜﻼ ﻓ ﺎن ﻋﻨﺎوﻳ ﻦ اﻟﻌﻨﺎﺻ ﺮ اﻟﺘﺎﻟ ﻴﺔ‪ :‬ﺣﺴﺐ ﺗﺮﺗﻴﺒﻬﺎ‬
‫اﻟﻤﺬﻛ ﻮر أﻋ ﻼه ﻫ ﻲ ‪ 102-101-100‬ﻟﻌﻨﺎﺻ ﺮ اﻟﺼ ﻒ اﻷول ‪105-104-103‬‬
‫ﻟﻌﻨﺎﺻﺮ اﻟﺼﻒ اﻟﺜﺎﻧﻲ‪.‬‬

‫اﻟﺪوال‬
‫‪Functions‬‬
‫ﻣﻘﺪﻣﺔ ‪Introduction‬‬
‫ﺗﻌ ﺮف اﻟﺪاﻟ ﺔ ) اﻻﻗ ﺘﺮان ( ﻋﻠ ﻰ أﻧﻬ ﺎ ‪ :‬ﺟﻤﻠ ﺔ أو ﻣﺠﻤﻮﻋ ﺔ ﺟﻤ ﻞ أو ﺗﻌﻠﻴﻤﺎت ‪ ،‬ذات ﻛﻴﺎن‬
‫ﺧ ﺎص ‪ ،‬ﺗﻘ ﻮم ﺑﻌﻤﻠ ﻴﺔ أو ﻣﺠﻤﻮﻋ ﺔ ﻋﻤﻠ ﻴﺎت ‪ ،‬ﺳ ﻮاء ﻋﻤﻠ ﻴﺎت إدﺧ ﺎل أو إﺧ ﺮاج أو‬
‫ﻋﻤﻠ ﻴﺎت ﺣﺴ ﺎﺑﻴﺔ أو ﻣﻨﻄﻘ ﻴﺔ ‪ ،‬وﺗﺤ ﺘﻞ اﻟﺪاﻟ ﺔ ﻣﻮﻗﻌﺎ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪ ،‬آي أﻧﻬﺎ ﺟﺰء ﻣﻨﻪ ‪ ،‬أو‬
‫ﻳﻤﻜﻦ اﻟﻘﻮل أن ﺑﺮﻧﺎﻣﺞ ‪ ، c++‬ﻳﺘﻜﻮن ﻣﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺪوال‪.‬‬
‫وﻣﻦ ﻓﻮاﺋﺪ اﻟﺪوال اﻟﺘﺎﻟﻲ‪:‬‬

‫‪ -١‬ﺗﺴ ﺎﻋﺪ اﻟ ﺪوال اﻟﻤﺨ ﺰﻧﺔ ﻓ ﻲ ذاﻛ ﺮة اﻟﺤﺎﺳ ﺐ ﻋﻠ ﻰ اﺧﺘﺼ ﺎر اﻟ ﺒﺮﻧﺎﻣﺞ إذ ﻳﻜ ﺘﻔﻰ‬
‫ﺑﺎﺳﺘﻌﺎدﺗﻬﺎ ﺑﺎﺳﻤﻬﺎ ﻓﻘﻂ ﻟﺘﻘﻮم ﺑﺎﻟﻌﻤﻞ اﻟﻤﻄﻠﻮب‪.‬‬
‫‪ -٢‬ﺗﺴ ﺎﻋﺪ اﻟ ﺪوال اﻟﻤﺨ ﺰﻧﺔ ﻓ ﻲ ﻣﻜﺘ ﺒﺔ اﻟﺤﺎﺳﺐ ‪ ،‬أو اﻟﺘﻲ ﻳﻜﺘﺒﻬﺎ اﻟﻤﺒﺮﻣﺞ ﻋﻠﻰ ﺗﻼﻓﻲ‬
‫ﻋﻤﻠﻴﺎت اﻟﺘﻜﺮار ﻓﻲ ﺧﻄﻮات اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﻲ ﺗﺘﻄﻠﺐ ﻋﻤﻼ ﻃﻮﻳﻼ وﺷﺎﻗﺎ‪.‬‬
‫‪ -٣‬ﺗﺴﺎﻋﺪ اﻟﺪوال اﻟﺠﺎﻫﺰة ﻋﻠﻰ ﺗﺴﻬﻴﻞ ﻋﻤﻠﻴﺔ اﻟﺒﺮﻣﺠﺔ ﻧﻔﺴﻬﺎ‪.‬‬
‫‪ -٤‬ﺗﻮﻓﺮ ﻣﺴﺎﺣﺔ ﻣﻦ اﻟﺬاﻛﺮة اﻟﻤﻄﻠﻮﺑﺔ‪.‬‬
‫‪ -٥‬اﺧﺘﺼﺎر ﻋﻤﻠﻴﺎت زﻣﻦ اﻟﺒﺮﻣﺠﺔ وﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺄﺳﺮع وﻗﺖ ﻣﻤﻜﻦ‪.‬‬
‫وﻟﻠﺘﺪﻟﻴﻞ ﻋﻠﻰ أﻫﻤﻴﺔ اﻟﺪوال ﻓﻲ ﺑﺮﻣﺠﺔ ‪ c++‬ﺧﺬ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬

‫ﻟﻮ أردﻧﺎ ﻛﺘﺎﺑﺔ ﺧﻮارزﻣﻴﺔ ﻟﺨﻄﻮات ﺻﻨﻊ ﻛﺄس ﻣﻦ اﻟﺸﺎي ﻓﺄﻧﻨﺎ ﻧﻜﺘﺐ ﻣﺎ ﻳﺄﺗﻲ‪:‬‬
‫‪ -١‬ﺿﻊ اﻟﻤﺎء ﻓﻲ ﻏﻼﻳﺔ اﻟﺸﺎي‪.‬‬
‫‪ -٢‬ﺳﺨﻦ اﻟﻤﺎء ﺣﺘﻰ ﻳﻐﻠﻰ‪.‬‬
‫‪ -٣‬أﺿﻒ ﺷﺎﻳﺎ إﻟﻰ اﻟﻤﺎء‪.‬‬
‫‪ -٤‬أﺿﻒ ﺳﻜﺮا إﻟﻴﻪ‪.‬‬
‫‪ -٥‬أﻃﻔﺊ اﻟﻨﺎر‪.‬‬
‫‪ -٦‬ﺻﺐ ﺷﺎﻳﺎ ﻓﻲ ﻛﺄس‪.‬‬
‫اﻓ ﺮض اﻵن أﻧ ﻨﺎ ﻧ ﻮد ﻃﻠ ﺐ ﻛ ﺄس ﻣ ﻦ اﻟﺸ ﺎي ﻣ ﻦ ﻣﻘﻬ ﻰ ﻣﺠ ﺎور ‪ :‬أن ﺧﻄ ﻮات‬

‫اﻟﺨﻮارزﻣﻴﺔ اﻟﺘﻲ ﻧﺤﺘﺎﺟﻬﺎ اﻵن ﻫﻲ ﺧﻄﻮه واﺣﺪه ﻓﻘﻂ وﻫﻲ‪:‬‬
‫‪ -١‬اﺳﺘﺪع ﻛﺄس ﻣﻦ اﻟﺸﺎي‪.‬‬
‫ﺗﺨ ﻴﻞ اﻵن ﻛ ﻢ وﻓ ﺮﻧﺎ ﻣ ﻦ اﻟﺨﻄ ﻮات ﻟ ﻮ اﺳ ﺘﻌﻤﻠﻨﺎ اﻟ ﺪوال اﻟﺠﺎﻫ ﺰة ) أو اﻟﺘ ﻲ ﻳﺠﻬ ﺰﻫﺎ‬
‫اﻟﻤ ﺒﺮﻣﺞ ﻣ ﻦ ﻗ ﺒﻞ ( ﺑ ﺪﻻ ﻣ ﻦ ﺧﻄﻮاﺗﻬ ﺎ اﻟﺘﻔﺼ ﻴﻠﻴﺔ وﺑﺨﺎﺻ ﺔ ﻓ ﻲ ﺑﺮﻧﺎﻣﺞ ﻳﺘﻄﻠﺐ ﺣﺴﺎﺑﺎت‬
‫وﻋﻤﻠﻴﺎت ﻛﺜﻴﺮة وﻛﻢ ﻳﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ ﺳﻬﻼ وواﺿﺤﺎ وﻗﺘﺬاك‪.‬‬
‫وﺗﺄﺧﺬ اﻟﺪاﻟﺔ اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ‪:‬‬

‫;‪Type-specified function-name (formal parameters‬‬
‫{‬
‫‪function body‬‬
‫}‬
‫وﻗ ﺪ ذﻛ ﺮﻧﺎ ﻣ ﻦ ﻗ ﺒﻞ أن اﻟﺪاﻟ ﺔ ﻗ ﺪ ﺗﻌ ﺘﻤﺪ ﻋﻠ ﻰ ﻣﺘﻐ ﻴﺮ أو اﻛ ﺜﺮ ‪ ،‬وﻗ ﺪ ﻻ ﺗﻌ ﺘﻤﺪ ﻋﻠ ﻰ آي‬

‫ﻣﺘﻐ ﻴﺮ ‪ ،‬وﻓ ﻲ ﻛ ﻼ اﻟﺤﺎﻟﺘﻴ ﻦ ‪ ،‬ﻳﺴ ﺘﻌﻤﻞ ﺑﻌ ﺪ اﺳ ﻢ اﻟﺪاﻟ ﺔ ﻗﻮﺳ ﻴﻦ )( ﺳ ﻮاء ﻛ ﺎن ﺑﻴ ﻨﻬﻤﺎ‬
‫ﻣﺘﻐﻴﺮات أم ﻻ ‪.‬‬
‫)(‪max1‬‬
‫{‬
‫;”‪cout<<”hello‬‬
‫}‬
‫{‬
‫;)( ‪max1‬‬
‫;)(‪max1‬‬
‫;)(‪max1(); max1‬‬
‫}‬
‫واﻟﻨﺎﺗﺞ‪:‬‬
‫‪hello hello hello hello‬‬
‫ﻃ ﺒﻌﺎ ﻟﻠﻌﻠ ﻢ أﻋﺰاﺋ ﻲ أﻧ ﻨﺎ ﻓ ﻲ ﻫ ﺬا اﻟﻔﺼﻞ اﻟﺪوال ﻧﻼﺣﻆ أن ﺑﺪاﻳﺔ ﻗﺮاءة اﻟﻤﺘﺮﺟﻢ ﻟﻠﺒﺮﻧﺎﻣﺞ‬
‫ﻻ ﺗ ﺒﺪأ ﻣ ﻦ أول اﻟ ﺒﺮﻧﺎﻣﺞ ﻛﺎﻟﻤﻌ ﺘﺎد ﻓﺎﻟﻘ ﺮاءة ﺗ ﺒﺪأ ﻣ ﻦ اﻷﺳ ﻔﻞ آي أﻧﻬﺎ ﺗﺒﺪا ﺑﺎﻟﻤﺎﻳﻦ ‪main‬‬
‫ﺳ ﻮاء ﻛ ﺎن ﻓ ﻲ اﻟﻮﺳ ﻂ أو اﻷﺳ ﻔﻞ ﻓﺄﻧﻬ ﺎ ﺗﻘ ﺮاء أوﻻ اﻟ ـ‪ main‬ﺛ ﻢ ﺗﺒﺤ ﺚ ﻣ ﺎ داﺧﻠ ﻪ وﺗ ﺒﺪا‬
‫ﺑﺎﻟﺒﺤ ﺚ ﻋ ﻦ ﻣﻌ ﻨﻰ اﻟﻜﻠﻤ ﺔ )(‪ max1‬ﻓ ﻲ اﻟﺪاﻟ ﺔ )(‪ max1‬ﻓ ﻲ اﻷﻋﻠ ﻰ ﻟ ﺘﺠﺪ أن ﻫ ﻨﺎك‬
‫ﺟﻤﻠﺔ ﻃﺒﺎﻋﺔ وﻫﻜﺬا ﺗﺘﻜﺮر ﺣﺘﻰ ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻣﺎ ﺑﺪاﺧﻞ اﻟـ‪. main‬‬

‫ﺗﻄﺒﻴﻘﺎت ﻋﻠﻰ اﻟﺪوال‬
‫ﺷﺎﻫﺪ ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ وﺗﺘﺒﻌﻪ أوﻻ ﺑﺎﻟـ‪ main‬واﻧﻈﺮ ﻟﻠﻨﺘﺎﺋﺞ‪:‬‬
‫;‪int x,y‬‬
‫)(‪void max‬‬
‫{‬
‫;‪x=x+y‬‬
‫}‬
‫)(‪void fax‬‬
‫{‬
‫;)(‪max‬‬
‫;)(‪max‬‬
‫{‬
‫{‬
‫;‪y=10; x=0‬‬
‫;)(‪max‬‬
‫;)(‪fax‬‬
‫;‪cout<<x<<y‬‬
‫}‬
‫أﻋﺰاﺋﻲ ﺳﺄﺷﺮح اﻟﻨﺘﺎﺋﺞ ﻗﺒﻞ إﻇﻬﺎرﻫﺎ ﻟﻠﺘﺴﻬﻴﻞ ﻋﻠﻴﻜﻢ ﻓﻲ اﻷﻣﺜﻠﺔ اﻟﻘﺎدﻣﺔ‪:‬‬

‫ﻟﻨﺘﻌﺒﺮ أن ﻫﻨﺎك ﺛﻼث ﻛﻮاﻛﺐ‪:‬‬
‫ﻛﻮاﻛﺐ ‪ main‬اﻟﺮﺋﻴﺴﻲ‬
‫ﻛﻮﻛﺐ ‪fax‬‬
‫ﻛﻮﻛﺐ ‪max‬‬
‫ﻣ ﻦ اﻟﻤﻌ ﺮوف أﻧ ﻨﺎ ﺳ ﻮف ﻧ ﺒﺪا ﺑﻜﻮﻛ ﺐ ‪ main‬ﻟﻨﺸ ﺎﻫﺪ ﻣ ﺎ ﺑﺪاﺧ ﻞ ﻧﺸﺎﻫﺪ أن ﻫﻨﺎك ﻗﻴﻤﺘﻴﻦ‬
‫ﻋﺪدﻳﺘﻴ ﻦ ‪ x y‬ﻟﻜ ﻨﻪ ﻻ ﻳﻌ ﺮﻓﻪ ﻫ ﻞ ﻫ ﻲ أﻋ ﺪاد ﺣﻘﻴﻘ ﻴﺔ أم ﺻ ﺤﻴﺤﻪ ﻟﺬﻟﻚ ﻳﺬﻫﺐ ﻓﻲ اﻷﻋﻠﻰ‬
‫ﻟﻴﺒﺤ ﺚ ﻋ ﻨﻬﺎ ﻓ ﻲ أول اﻟ ﺒﺮﻧﺎﻣﺞ ﻟ ﻴﺠﺪ أﻧﻬ ﺎ أﻋ ﺪاد ﺻ ﺤﻴﺤﺔ ‪ ، int‬ﺛ ﻢ ﺑﻌ ﺪ ذﻟ ﻚ ﻳ ﺮﺟﻊ‬
‫ﻟﻠﻜﻮﻛ ﺐ اﻟﺮﺋﻴﺴ ﻲ ‪ main‬ﻟﻴﺸ ﺎﻫﺪ ﻋ ﺒﺎرة )(‪ max‬ﻓﻴﺬﻫ ﺐ ﻟﻠﺒﺤ ﺚ ﻋ ﻨﻬﺎ ﻓ ﻲ اﻟﻜﻮﻛ ﺐ‬
‫‪ max‬ﻃ ﺒﻌﺎ ﻟ ﻴﺠﺪ ﺑﺪاﺧﻠﻬ ﺎ أن ﻗ ﻴﻤﺔ ‪ x‬ﺗﺴ ﺎوي ‪ x+y‬أي أن ‪ x=0+10‬ﻟﺘﺼ ﺒﺢ ﻗ ﻴﻤﺔ‬
‫‪ x=10‬ﺑﻌ ﺪ ذﻟ ﻚ ﻳﺨ ﺮج ﻣ ﻦ اﻟﻜﻮﻛ ﺐ ‪ max‬وﻳ ﺮﺟﻊ ﻟﻠﻜﻮﻛ ﺐ اﻟﺮﺋﻴﺴ ﻲ ﻟﻴﺸ ﺎﻫﺪ اﻟﻌ ﺒﺎرة‬
‫)(‪ fax‬ﻓﻴﺬﻫ ﺐ ﻟﻠ ﺘﻌﺮف ﻋﻠ ﻴﻬﺎ ﺑﺎﻟﻜﻮﻛ ﺐ )(‪ fax‬وﻳﺸ ﺎﻫﺪ ﺑﺪاﺧﻠﻬ ﺎ ﻋ ﺒﺎرة ‪ max‬ﻟﻴﺬﻫ ﺐ‬
‫ﺑﺬﻟﻚ ﻟﻠﻜﻮﻛﺐ ‪ max‬وﻳﺠﻤﻊ ﻣﻦ ﻣﺮة أﺧﺮى ﻓﺘﺼﺒﺢ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪ X=10+10‬وﺑﺬﻟ ﻚ ﺗﺼ ﺒﺢ ﻗ ﻴﻤﺔ ‪ x=20‬ﺑﻌ ﺪ ذﻟ ﻚ ﻳ ﺮﺟﻊ ﻟﻠﻜﻮﻛ ﺐ ‪ fax‬ﻟﻴﺸ ﺎﻫﺪ ﻋ ﺒﺎرة‬
‫)(‪ max‬ﻓﻴﺬﻫﺐ ﻟﻠﻜﻮﻛﺐ ‪ max‬وﻳﺠﻤﻊ ﻣﺮة أﺧﺮى ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪ X=20+10‬وﺑﺬﻟﻚ ﺗﺼﺒﺢ ﻗﻴﻤﺔ ‪x=30‬‬
‫ﺛﻢ ﺑﻌﺪﻫﺎ ﻳﺮﺟﻊ ﻟﻠﻜﻮﻛﺐ اﻟﺮﺋﻴﺴﻲ ‪ main‬ﻟﻴﺸﺎﻫﺪ ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ واﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪30 10‬‬

:٣‫ﻣﺜﺎل‬
void x1()
{
cout<<”*”;
}
void x2()
{
cout<<”\t”;
}
void yaya()
{
x1();
x2();
x1();
}
void kiki()
{
cout<<”\n”:
}
void main()
{
int I;
for(I=0;I<=3;I++)
{
yaya();
kiki();
}
}
:‫واﻟﻨﺎﺗﺞ ﺳﻴﻜﻮن ﻛﺎﻟﺘﺎﻟﻲ‬

* *
* *
* *
* *

‫ﻗ ﻢ ﺑﻜ ﺘﺎﺑﺔ ﺑ ﺮﻧﺎﻣﺞ ﻳﻘ ﻮم ﺑﻘ ﺮاءة ﻋ ﺪد ﺻ ﺤﻴﺢ وﻣ ﻦ ﺛ ﻢ ﻃﺒﺎﻋﺔ ﻣﺎ إذا ﻛﺎن اﻟﺮﻗﻢ زوﺟﻲ أم‬
‫ﻓﺮدي ﻣﻦ ﺧﻼل داﻟﺔ أو اﻗﺘﺮان؟‬
‫;‪int x‬‬
‫)(‪check‬‬
‫{‬ ‫اﻃﺒﻊ إذا ﻛﺎن زوﺟﻲ‬
‫)‪if ((x%2)==0‬‬
‫;‪cout<<”even”<<endl‬‬
‫‪else‬‬
‫;‪cout<<”ood”<<endl‬‬
‫}‬ ‫اﻃﺒﻊ إذا ﻛﺎن ﻓﺮدي‬
‫)(‪main‬‬
‫{‬
‫;‪cin>>x‬‬
‫;)( ‪check‬‬ ‫ادﺧﻞ اﻟﻘﻴﻤﺔ ‪ 9‬ﻣﺜﻼ‬
‫}‬
‫ﻃﺒﻌﺎ واﻟﻨﺎﺗﺞ ﺳﻴﻜﻮن ﺣﺴﺒﻤﺎ أدﺧﻠﺖ ﻟﻨﺪﺧﻞ ﻣﺜﻼ اﻟﻘﻴﻤﺔ ‪ ..9‬واﻟﻨﺎﺗﺞ ﺳﻴﻜﻮن‪:‬‬
‫‪ood‬‬
‫ﻻن اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ ‪ 9‬ﻋﺪد ﻓﺮدي وﻟﻴﺲ زوﺟﻲ ‪.‬‬

‫ﻗ ﻢ ﺑﻜ ﺘﺎﺑﺔ ﺑ ﺮﻧﺎﻣﺞ ﻳﻘ ﻮم ﺑﺎﺳ ﺘﺨﺮاج اﻛ ﺒﺮ رﻗ ﻢ ﻣ ﺎ ﺑﻴ ﻦ رﻗﻤﻴ ﻦ ﻣﺪﺧﻠﻴ ﻦ ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم‬
‫وذﻟﻚ ﻣﻦ ﺧﻼل داﻟﺔ اﺳﻤﻬﺎ ‪ max‬؟‬
‫;‪int x,y‬‬
‫ﻟﻠﻤﻘﺎرﻧﺔ ﻣﻦ اﻷﻛﺒﺮ‬
‫)(‪max‬‬
‫ﺑﻴﻦ اﻟﻘﻴﻤﺘﻴﻦ‬
‫{‬
‫)‪if (x>y‬‬
‫;‪cout<<x<<endl‬‬
‫‪else‬‬
‫;‪cout<<y<<endl‬‬
‫}‬
‫)(‪main‬‬
‫{‬
‫;‪cin>>x>>y‬‬ ‫ادﺧﻞ اﻟﻘﻴﻤﺘﻴﻦ وﻟﺘﻜﻦ‬
‫;)( ‪max‬‬ ‫اﻟﻘﻴﻤﺔ ‪ 10‬و‪20‬‬
‫{‬
‫}‬
‫واﻟﻨﺎﺗﺞ ﻃﺒﻌﺎ ﺳﻴﻜﻮن‪:‬‬

‫‪20‬‬
‫ﻻن اﻟﻌﺪد اﻟﺬي أدﺧﻠﻨﺎ ‪ 20‬اﻛﺒﺮ ﻣﻦ اﻟﻌﺪد اﻟﺬي أدﺧﻠﻨﺎ ‪ 10‬ﻓﻘﺎم ﺑﻄﺒﺎﻋﺘﻪ ﺣﺴﺐ اﻟﺸﺮط ‪.‬‬

‫ﺗﻘﻨﻴﺔ اﻷﻗﺮاص و دوال اﻟﻤﻠﻔﺎت اﻻﻧﺘﻘﺎﻟﻴﺔ‬
‫‪disk Files‬‬
‫ﻣﻘﺪﻣﺔ ‪Introduction‬‬
‫ﺻ ﻤﻤﺖ ﻫ ﺬه اﻟ ﺪوال ﻟﻠ ﺘﻌﺎﻣﻞ ﻣ ﻊ اﻟﻤﻠﻔ ﺎت اﻻﻧﺘﻘﺎﻟ ﻴﺔ ﻟﻸﻗ ﺮاص ‪Buffered filw‬‬
‫‪ system‬ﻟﻤﻌﺎﻟﺠ ﺔ اﻟﻨﺼ ﻮص ‪ ،‬ﻛﻤ ﺎ ﻛ ﺎن ﻣ ﺘﻮﻓﺮا ﻓ ﻲ ﻟﻐ ﺔ ‪ C++‬اﻟ ﻨﻈﺎم اﻷﺧ ﺮ ﻏ ﻴﺮ‬
‫اﻻﻧﺘﻘﺎﻟ ﻲ ‪ unbuffered‬اﻟﻤﺸ ﺎﺑﻬﺔ ﻟ ﻨﻈﺎم ﻳﻮﻧ ﻴﻜﺲ ﻟﻺدﺧ ﺎل واﻹﺧ ﺮاج ‪UNIX-like‬‬
‫‪ ، I/O‬وﻛ ﺎن اﻟ ﻨﻈﺎم اﻷﺧ ﻴﺮ ﻳﺴ ﺘﻌﻤﻞ ﻟﻠ ﺘﻌﺎﻣﻞ ﻣ ﻊ اﻟﻤﻌﻄ ﻴﺎت ﺑﻨﺴ ﻖ اﻟ ﻨﻈﺎم اﻟﺜﻨﺎﺋ ﻲ‬
‫‪ ، binary system‬أﻻ أن ﻟﺠ ﻨﺔ ‪ C‬ﻓ ﻲ ﻣﻌﻬ ﺪ اﻟﻤﻘﺎﻳ ﻴﺲ اﻷﻣﺮﻳﻜ ﻲ اﻟﻮﻃﻨ ﻲ ﻟﻠﻐ ﺎت‬
‫اﻟ ﺒﺮﻣﺠﺔ ‪ ANISI-C Committee‬ﻗ ﺮرت ﻣﺆﺧ ﺮا اﻻﺳ ﺘﻐﻨﺎء ﻋ ﻦ اﻟ ﻨﻈﺎم ﻏ ﻴﺮ‬
‫اﻻﻧﺘﻘﺎﻟ ﻲ ﻣ ﻦ أﻧﻈﻤ ﺔ اﻟ ﺘﻌﺎﻣﻞ ﻣ ﻊ اﻟﻤﻌﻄ ﻴﺎت اﻟﺜﻨﺎﺋ ﻴﺔ ‪ ،‬ﻓ ﺄوﺟﺪت اﻟ ﺒﺪﻳﻞ ‪ ،‬ﺑﺤﻴ ﺚ ﻳﺼ ﺒﺢ‬
‫ﺑﻤﻘ ﺪور دوال اﻟ ﻨﻈﺎم اﻻﻧﺘﻘﺎﻟ ﻲ اﻟ ﺘﻌﺎﻣﻞ ﻣ ﻊ ﻛ ﻞ ﻣ ﻦ اﻟﻨﺼ ﻮص ‪ text‬واﻟﻤﻌﻄ ﻴﺎت اﻟﺜﻨﺎﺋﻴﺔ‬
‫‪ binary system‬ﻓ ﻲ وﻗ ﺖ واﺣ ﺪ ‪ .‬أي أن آﺧ ﺮ ﺻ ﻮرة )‪ (version‬ﻣ ﻦ ‪ ، C‬ﻳ ﺘﻌﺎﻣﻞ‬
‫ﺑﻨﻈﺎم واﺣﺪ ﻓﻘﻂ ﻫﻮ ﻧﻈﺎم اﻟﻤﻠﻔﺎت اﻻﻧﺘﻘﺎﻟﻴﺔ ‪.‬‬
‫وﻧﺤ ﺘﺎج ﻋ ﻨﺪ اﻟ ﺘﻌﺎﻣﻞ ﻣ ﻊ دوال ﻫ ﺬا اﻟ ﻨﻈﺎم ‪ ،‬أن ﻧﺴﺘﻌﻤﻞ ﻣﻠﻒ اﻟﺪﻟﻴﻞ ﻟﻺدﺧﺎل واﻹﺧﺮاج‬
‫‪ stdio.h‬وﻳﻠﺨﺺ ﻟﻨﺎ اﻟﺠﺪول اﻟﺘﺎﻟﻲ اﺷﻬﺮ ﻫﺬه اﻟﺪوال‪:‬‬
‫وﻇﻴﻔﺘﻬﺎ‬ ‫اﺳﻢ اﻟﺪاﻟﺔ‬

‫ﺗﻔﺘﺢ ﻟﻚ ﻣﻠﻔﺎ‬ ‫)(‪fopen‬‬
‫ﺗﻐﻠﻖ ﻟﻚ ﻣﻠﻔﺎ‬ ‫)(‪fclose‬‬
‫ﺗﺨﺮج ) ﺗﻄﺒﻊ ( ﻟﺒﻨﺔ ) رﻣﺰا ( وﻫﻲ ﻣﺜﻞ ‪char‬‬ ‫)(‪putc‬‬
‫ﺗﺪﺧﻞ ﻟﺒﻨﺔ ) رﻣﺰا ( إﻟﻰ اﻟﻤﻠﻒ ‪ ،‬وﻫﻲ ﻣﺜﻞ ‪char‬‬ ‫)(‪getc‬‬
‫ﺗﺒﺤﺚ ﻟﻚ ﻋﻦ ﺑﻌﺾ اﻟﺮﻣﻮز ) ﻧﺺ( ﻓﻲ اﻟﻤﻠﻒ‬ ‫)(‪fseek‬‬
‫ﻣﺜﻞ وﻇﻴﻔﺔ ‪ printf‬ﻟﻜﻦ ﻟﻠﻤﻠﻔﺎت‬ ‫)(‪fprintf‬‬
‫ﻣﺜﻞ وﻇﻴﻔﺔ ‪ scanf‬ﻟﻜﻦ ﻟﻠﻤﻠﻔﺎت‬ ‫)(‪fscanf‬‬
‫ﺗﻌﻄﻲ اﻟﻨﺘﻴﺠﺔ ‪ true‬ﻋﻨﺪ وﺻﻮل ﻧﻬﺎﻳﺔ اﻟﻤﻠﻒ‬ ‫)(‪feof‬‬
‫ﺗﻌﻄﻲ اﻟﻨﺘﻴﺠﺔ ‪ true‬ﻋﻨﺪ ﺣﺪوث ﺧﻄﺄ‬ ‫)(‪ferror‬‬
‫ﺗﺮﺟﻊ اﻟﻤﻠﻒ إﻟﻰ ﺑﺪاﻳﺘﻪ‬ ‫)(‪rewind‬‬
‫اﻟﺠﺪول ‪٥ -١‬‬

‫داﻟﺔ ﻓﺘﺢ اﻟﻤﻠﻒ )( ‪fopen‬‬
‫”‪#include “stdio.h‬‬
‫)(‪main‬‬ ‫ﻧﻜﺘﺐ آي اﺳﻢ ﻟﻠﺘﺨﺰﻳﻦ‬
‫{‬ ‫ﺑﻤﻮﻗﻊ اﻟﺬاﻛﺮة ﻣﺜﻼ ‪f‬‬
‫;‪FILE *f‬‬
‫;)”‪F=fopen(“C:\\matrix.txt”,”w‬‬
‫;)‪Fclose (f‬‬
‫اﻟﺮﻣﺰ ‪w‬ﻻﺳﺘﺤﺪاث‬
‫;‪return0‬‬ ‫ﻧﺺ ﺟﺪﻳﺪ ﻟﻠﻜﺘﺎﺑﺔ‬
‫}‬ ‫اﺳﻢ اﻟﻤﻠﻒ وﻧﺤﺪد ﻣﻮﻗﻌﻪ) ﻣﺴﺎره(‬
‫ﻓﻲ اﻟﻘﺮص ‪C‬‬
‫ﻧﻼﺣ ﻆ أﻧ ﻨﺎ ﻗﻤ ﻨﺎ ﻓ ﻲ اﻟﺴ ﻄﺮ اﻷول أﻋ ﻼه ﺑﺈﻧﺸ ﺎء ﻣﻮﻗ ﻊ ﻟﻠﻤﻠﻒ ﻓﻲ ذاﻛﺮة اﻟﺤﺎﺳﻮب ﻃﺒﻌﺎ‬

‫ﻧﻜﺘﺐ ‪ FILE‬ﺑﺎﻷﺣﺮف اﻷﺑﺠﺪﻳﺔ اﻟﻜﺒﺮى ﺛﻢ ﺑﻌﺪ ذﻟﻚ * وﺑﻌﺪﻫﺎ ﻧﻄﻠﻖ اﻟﻤﺴﻤﻰ ﻣﺜﻼ ‪f‬‬
‫ﺑﻌ ﺪ ذﻟ ﻚ ﻧﻘ ﻮم ﺑﻌﻤ ﻞ اﻟﺪاﻟ ﺔ اﻟﺨ ﺎص ﺑﻔ ﺘﺢ ﻣﻠ ﻒ ﻓ ﻲ ﻗ ﺮص ‪ disk‬وﺗﻌﻮد ) ﺗﻌﻄﻲ ﻗﻴﻤﺔ (‬

‫ﺑﻤﺆﺷﺮ اﻟﻤﻠﻒ اﻟﻤﻌﺮف ﻟﻪ وﻫﻮ ‪ f‬ﻃﺒﻌﺎ‪.‬‬
‫ﺛ ﻢ ﻧﻘ ﻮم ﺑ ﺘﺤﺪﻳﺪ ﻣﻮﻗ ﻊ اﻟﻤﻠ ﻒ اﻟﻤ ﺮاد إﻧﺸ ﺎءه وﻳﺠﺐ اﻟﺘﺤﺬﻳﺮ ﻫﻨﺎ اﻧﻪ ﻳﺠﺐ ﻋﺪم ﻛﺘﺎﺑﺔ اﺳﻢ‬
‫ﻣﻠ ﻒ ﻣ ﻦ ﻣﻠﻔ ﺎت اﻟ ﻨﻈﺎم ‪ system‬ﻟﺘﺠﻨ ﺐ ﻋ ﺪم ﺣ ﺪوث ﺧﻠﻞ وﻣﺸﺎﻛﻞ ﺑﺎﻟﺠﻬﺎز ﻣﺜﻼ ﻧﻜﺘﺐ‬
‫ﻛﻤ ﺎ أﻋ ﻼه ‪ matrix.txt‬وﻫ ﻮ ﻣﻠ ﻒ ﻧﺼ ﻲ وﻳﺠ ﺐ وﺿ ﻊ اﻟﻌﻼﻣﺘﻴﻦ \\ ﺑﻌﺪ ﻛﺘﺎﺑﺔ اﻟﻘﺮص‬
‫‪ C‬وﻻ ﻳﺼ ﺢ وﺿ ﻊ ﻋﻼﻣ ﺔ واﺣ ﺪه \ ﻓﻘ ﻂ ‪ ،‬ﺑﻌ ﺪ ذﻟ ﻚ ﻧﻜﺘﺐ اﻟﺮﻣﺰ ‪ w‬ﻻﺳﺘﺤﺪاث اﻟﻤﻠﻒ‬
‫اﻟﺠﺪﻳ ﺪ ﺛ ﻢ ﺑﻌ ﺪ ذﻟ ﻚ ﻓ ﻲ اﻟﺴ ﻄﺮ اﻷﺧ ﻴﺮ ﻧﻘ ﻮم ﺑﺈﻏﻼﻗ ﻪ ﺑﺎﻟﺪاﻟ ﺔ )‪ fclose (f‬وﻳﺠ ﺐ ﻛ ﺘﺎﺑﺔ‬
‫ﻫﺬه اﻟﺪاﻟﺔ ﻛﻲ ﻳﺼﺒﺢ اﻟﺒﺮﻧﺎﻣﺞ ﺻﺤﻴﺢ ‪.‬‬
‫اﻵن ﻗ ﻢ ﺑﺘﻨﻔ ﻴﺬ اﻟ ﺒﺮﻧﺎﻣﺞ ﺑﻌ ﺪ ذﻟ ﻚ ﻟ ﻦ ﻳﻈﻬ ﺮ ﻟ ﻚ ﺷ ﻲ ﻗ ﺪ ﺗﺴ ﺘﻐﺮب ﻣ ﺎ اﻟﻔ ﺎﺋﺪة اﻵن اذﻫﺐ‬

‫ﻋﺰﻳﺰي إﻟﻰ اﻟﻘﺮص ‪ C‬وﻫﻮ اﻟﺬي ﻗﻤﺖ ﺑﺈﻧﺸﺎء اﻟﻤﻠﻒ ﻓﻴﻪ ) اﻟﻤﺴﺎر أﻋﻼه(‬
‫وﺷﺎﻫﺪ اﻟﻤﻠﻒ اﻟﺠﺪﻳﺪ‬
‫ﻫﺬا ﻫﻮ اﻟﻤﻠﻒ‬
‫اﻟﺠﺪﻳﺪ‬

‫ﺟﺪول اﻷﻧﻤﺎط ‪ ،‬ﺣﺴﺐ ﻣﺎ ﻗﺮرﺗﻪ ‪ ANSI‬ﻣﺆﺧﺮا‪:‬‬
‫وﻇﻴﻔﺘﻪ‬ ‫رﻣﺰ اﻟﻨﻤﻂ‬

‫ﻟﻔﺘﺢ ﻣﻠﻒ اﻟﻨﺺ ﻟﻠﻘﺮاءة‬ ‫"‪"r‬‬
‫ﻻﺳﺘﺤﺪث ﻣﻠﻒ ﻧﺺ ﻟﻠﻜﺘﺎﺑﺔ‬ ‫"‪"w‬‬
‫ﻟﻺﻟﺤﺎق ﺑﻤﻠﻒ ﻧﺺ‬ ‫"‪"a‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﺛﻨﺎﺋﻲ اﻟﻘﺮاءة‬ ‫"‪"rb‬‬
‫ﻻﺳﺘﺤﺪاث ﻣﻠﻒ ﺛﻨﺎﺋﻲ اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"wb‬‬
‫ﻟﻺﻟﺤﺎق ﺑﻤﻠﻒ ﺛﻨﺎﺋﻲ‬ ‫"‪"ab‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﻧﺺ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"r+‬‬
‫ﻻﺳﺘﺤﺪاث ﻧﺺ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"w+‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﻧﺺ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"a+‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﺛﻨﺎﺋﻲ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"r+b‬‬
‫ﻻﺳﺘﺤﺪاث ﻣﻠﻒ ﺛﻨﺎﺋﻲ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"w+b‬‬
‫ﻟﻔﺘﺢ ﻣﻠﻒ ﺛﻨﺎﺋﻲ ﻟﻠﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ‬ ‫"‪"a+b‬‬
‫اﻟﺠﺪول ‪٥ -٢‬‬
‫ﻧﻼﺣﻆ أن ﻫﺬا اﻟﺠﺪول ﻳﻤﻜﻦ اﺳﺘﻌﻤﺎﻟﻪ ﻟﻜﻞ ﻣﻦ ﻣﻠﻔﺎت اﻟﻨﺺ واﻟﻤﻠﻔﺎت اﻟﺜﻨﺎﺋﻴﺔ‪.‬‬

‫داﻟﺔ اﻟﻜﺘﺎﺑﺔ داﺧﻞ اﻟﻤﻠﻒ )( ‪fprintf‬‬
‫ﻗ ﻢ ﺑﻜ ﺘﺎﺑﺔ اﻟ ﻨﺺ "‪ " welcome to c++‬داﺧ ﻞ اﻟﻤﻠ ﻒ اﻟ ﺬي ﻗﻤ ﻨﺎ ﺑﺈﻧﺸ ﺎﺋﻪ ﻓ ﻲ اﻟﻤ ﺜﺎل‬
‫اﻟﺴﺎﺑﻖ )‪ (1‬وﻫﻮ ﻣﻠﻒ ‪ matrix‬؟‬
‫)(‪main‬‬
‫{‬
‫;)”‪f=fopen(“C:\\matrix.txt”,”w‬‬
‫;)”‪fprintf (f,”welcome to c++‬‬ ‫اﻇﻔﻨﺎ ﻫﺬا اﻟﺴﻄﺮ‬
‫اﻟﺠﺪﻳﺪ ﻟﻠﻄﺒﺎﻋﺔ‬
‫ﺑﺪاﺧﻞ اﻟﻤﻠﻒ‬
‫;‪return 0‬‬
‫}‬
‫ﻻﺣ ﻆ ﻋﺰﻳ ﺰي اﻟﻘ ﺎرئ أﻧ ﻨﺎ ﻗﻤ ﻨﺎ ﺑﻮﺿ ﻊ اﻟﺪاﻟ ﺔ )‪ (fprintf‬وﻫ ﻲ اﻟﺪاﻟ ﺔ اﻟﺨﺎﺻ ﺔ ﺑﺎﻟﻜ ﺘﺎﺑﺔ‬
‫داﺧ ﻞ اﻟﻤﻠﻔ ﺎت ﺑﺈﻣﻜ ﺎﻧﻚ اﻟ ﺮﺟﻮع ﻟﻠﺠ ﺪول ‪ ٥-١‬اﻵن ﻧﻔ ﺬ اﻟ ﺒﺮﻧﺎﻣﺞ وﺑﻌ ﺪ ﺗﻨﻔ ﻴﺬ ارﺟ ﻊ‬
‫ﻟﻠﻤﻠﻒ ﻓﻲ اﻟﻘﺮص ‪ c‬واﻓﺘﺤﻪ ﻟﺘﺸﺎﻫﺪ اﻟﻌﺒﺎرة ‪ welcome to c++‬ﻗﺪ ﻛﺘﺒﺔ ﺑﺪاﺧﻠﻪ‪.‬‬

‫داﻟﺔ إﻏﻼق اﻟﻤﻠﻒ )( ‪fclose‬‬
‫وﺗﻌﻤ ﻞ ﻋﻜ ﺲ اﻟﺪاﻟ ﺔ )(‪ ، fopen‬ﻓ ﺘﻐﻠﻖ اﻟﻤﻠ ﻒ اﻟ ﺬي ﻓﺘﺤ ﻨﺎه ﺑﺎﻟﺪاﻟ ﺔ )(‪ ، fopen‬وﻛ ﻞ‬
‫اﻟﻤﻠﻔ ﺎت اﻟﻤﻄﻠﻮﺑ ﺔ ﻣ ﻨﻚ إﻏﻼﻗﻬ ﺎ ﻗ ﺒﻞ ﻧﻬﺎﻳ ﺔ اﻟ ﺒﺮﻧﺎﻣﺞ ‪ ،‬وﻓ ﻲ ﺣﺎﻟ ﺔ ﻋ ﺪم ﻗﻴﺎﻣ ﻨﺎ ﺑ ﺈﻏﻼق‬
‫اﻟﻤﻠ ﻒ ﻓ ﺎن ﻋ ﺪدا ﻣ ﻦ اﻟﻤﺸ ﻜﻼت ﻗ ﺪ ﺗﻘ ﻊ ‪ ،‬وﻣ ﻨﻬﺎ ﺿ ﻴﺎع ﺑﻌ ﺾ اﻟﻤﻌﻄ ﻴﺎت ‪ ،‬واﺗ ﻼف‬
‫اﻟﻤﻠﻒ ‪ ،‬ووﻗﻮع أﺧﻄﺎء ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫)(‪main‬‬
‫{‬
‫;)”‪f=fopen(“C:\\matrix.txt”,”w‬‬
‫;)”‪fprintf (f,”welcome to c++‬‬
‫)‪fclose (f‬‬
‫;‪return 0‬‬ ‫ﻗﻤﻨﺎ ﺑﺈﻏﻼق اﻟﻤﻠﻒ ﻓﻲ‬

‫}‬ ‫ﻫﺬا اﻟﺴﻄﺮ ﻛﻤﺎ ﺗﻼﺣﻆ‬

‫اﻟﺪاﻟﺘﺎن )(‪putw() getw‬‬
‫ﺗﻘ ﻮم ﻣﻌﻈ ﻢ ﻣ ﺘﺮﺟﻤﺎت ‪ c++‬ﺑﺎﺳ ﺘﻌﻤﺎل ﻫﺎﺗﻴ ﻦ اﻟﺪاﻟﺘﻴ ﻦ اﻹﺿ ﺎﻓﻴﺘﻴﻦ ﻟ ﺘﻘﻮﻣﺎ ﺑﻌﻤﻠﻴﺘ ﻲ‬
‫ﻗ ﺮاءة وﻛ ﺘﺎﺑﺔ اﻷﻋ ﺪاد اﻟﺼ ﺤﻴﺤﺔ ﻣ ﻦ واﻟ ﻲ ﻣﻠﻔ ﺎت اﻷﻗ ﺮاص ‪ ،‬وﻫﺎﺗ ﺎن اﻟﺪاﻟ ﺘﺎن ﻏ ﻴﺮ‬
‫ﻣﻌﺘﻤﺪﻳ ﻦ ﻣ ﻦ ﻗ ﺒﻞ ﻣﻌﻬ ﺪ اﻟﻤﻘﺎﻳ ﻴﺲ اﻟﻮﻃﻨ ﻲ اﻷﻣﺮﻳﻜ ﻲ ‪ ، ANSI‬وﺗﻌﻤ ﻞ ﻫﺎﺗ ﺎن اﻟﺪاﻟ ﺘﺎن‬
‫ﺗﻤﺎﻣ ﺎ ﻛﺎﻟﺪاﻟﺘﻴ ﻦ )(‪ getc‬و )(‪ putc‬واﻟﻔ ﺮق اﻟﻮﺣ ﻴﺪ اﻧﻬﻤ ﺎ ﺗ ﺘﻌﺎﻣﻼن ﻣ ﻊ ﻋ ﺪد ﺻ ﺤﻴﺢ‬
‫ﺑﺪﻻ ﻣﻦ رﻣﺰي‪.‬‬
‫اﻟﺪاﻟﺔ اﻟﺘﺎﻟﻴﺔ ﺗﻘﻮم ﺑﻜﺘﺎﺑﺔ ) ﻃﺒﺎﻋﺔ( اﻟﻌﺪد اﻟﺼﺤﻴﺢ ‪ 1000‬ﻓﻲ ﻣﻠﻒ اﻟﻘﺮص اﻟﻤﺸﺎر إﻟﻴﻪ‬
‫ﺑﻤﺆﺷﺮ اﻟﻤﻠﻒ ‪: f‬‬
‫;)‪Putw (1000,f‬‬
‫اﻟﺪاﻟ ﺔ اﻟﺘﺎﻟ ﻴﺔ ﺗﻘ ﻮم ﺑﻜ ﺘﺎﺑﺔ ﻗ ﻴﻤﺔ اﻟﻤﺘﻐ ﻴﺮ اﻟﺼ ﺤﻴﺢ ‪ x‬ﻓﻲ ﻣﻠﻒ اﻟﻘﺮص اﻟﻤﺸﺎر إﻟﻴﻪ ﺑﻤﺆﺷﺮ‬
‫اﻟﻤﻠﻒ ‪: f‬‬
‫;)‪Putw (x,f‬‬

: f ‫ ﻣﻦ ﻣﻠﻒ ﻣﺸﺎر إﻟﻴﻪ ﺑﻤﺆﺷﺮ اﻟﻤﻠﻒ‬، ‫اﻟﺪاﻟﺔ اﻟﺘﺎﻟﻴﺔ ﺗﻘﻮم ﺑﻘﺮاءة ﻋﺪد ﺻﺤﻴﺢ‬
#include “stdio.h”
main()
{
FILE *f;
int x;
x=getw (f);
printf (“%d”,x);
return 0;
}

‫ﺍﻟﻨﻬﺎﻳﺔ‬


‫اﻟﺴﻼم ﻋﻠﻴﻜﻢ ورﺣﻤﺔاﷲ وﺑﺮآﺎﺗﻪ‪.......‬‬
‫اﻟﺤﻤﺪﷲ واﻟﺼﻼة واﻟﺴﻼم ﻋﻠﻰ اﻓﻀﻞ اﻷﻧﺒﻴﺎء واﻟﻤﺮﺳﻠﻴﻦ ﻗﺪوﺗﻨﺎ وﺣﺒﻴﺒﻨﺎ وﺷﻔﻴﻌﻨﺎ ان ﺷﺎء اﷲ ﻣﺤﻤﺪ ﺑﻦ ﻋﺒﺪ اﷲ‬
‫وﻋﻠﻰ اﻟﻪ وﺻﺤﺒﻪ اﺟﻤﻌﻴﻦ‪.......‬‬
‫ﻧﺒﺪا ان ﺷﺎء اﷲ ﺗﻌﺎﻟﻰ ﺳﻠﺴﻠﻪ دروس ﻟﻐﺔ ﻣﻦ اهﻢ وأروع ﻟﻐﺎت اﻟﺒﺮﻣﺠﻪ اﻻ وهﻲ ﻟﻐﺔ ‪, C++‬ﻓﻲ هﺬﻩ اﻟﺪورة ان‬
‫ﺷﺎء اﷲ ﺳﻨﺒﺪأ ﻓﻲ ﺷﺮح هﺬﻩ اﻟﺪورﻩ ﻣﻦ اﻟﺼﻔﺮ ﺣﺘﻰ ﻳﺘﺴﻨﻰ ﻟﻠﺠﻤﻴﻊ ان ﺷﺎء اﷲ ﻓﻬﻢ هﺬﻩ اﻟﻠﻐﻪ ﺑﻴﺴﺮ وﺳﻬﻮﻟﻪ‬
‫وﺳﻨﺮآﺰ ﻓﻲ ﺷﺮﺣﻨﺎ ﻋﻠﻰ اﻟﻸﻣﺜﻠﻪ اﻟﻌﻤﻠﻴﻪ ﻷن ﺧﻴﺮ ﻃﺮﻳﻘﺔ ﻟﺘﻌﻠﻢ هﺬﻩ اﻟﻠﻐﻪ ﻓﻲ وﺟﻬﺔ هﻮ ﺗﻌﻠﻤﻬﺎ ﻣﻦ ﺧﻼل اﻷﻣﺜﻠﺔ‬
‫اﻟﻌﻤﻠﻴﻪ وﻣﺤﺎوﻟﺔ ﺗﻄﺒﻴﻘﻬﺎ ﻋﻠﻰ اﻟﺒﺮﻧﺎﻣﺞ وﺗﺠﺮﻳﺒﻬﺎ‪.‬وﺗﺴﺘﻄﻴﻊ اﺳﺘﺨﺪام ﺑﺮﻧﺎﻣﺞ ‪ Borland C++‬أو ﺑﺮﻧﺎﻣﺞ ‪Visual‬‬
‫‪ , C++ 6.0‬وﺳﻨﺘﻄﺮف ﺑﺄذن اﷲ اﻟﻰ ﺷﺮح آﻴﻔﻴﺔ اﺳﺘﺨﺪام هﺬﻳﻦ اﻟﺒﺮﻧﺎﻣﺠﻴﻦ ﻟﻴﺘﺴﻨﻰ ﻟﻚ اﻟﻌﻤﻞ ﻋﻠﻴﻬﻢ وﺳﻨﺘﻮﺳﻊ‬
‫ﻓﻲ ﺷﺮح ﺑﺮﻧﺎﻣﺞ ‪ Visual C++ 6.0‬ﺑﻤﺎ اﻧﻪ اﻷﻓﻀﻞ واﻷآﺜﺮ أﻧﺘﺸﺎرا‪.‬‬
‫واﻟﺬي ﻳﺠﻴﺪ ﻟﻐﺔ ال ‪ C‬او ﻟﺪﻳﻪ ﺧﻠﻔﻴﻪ ﻋﻨﻬﺎ ﺳﻴﺴﻬﻞ ﻋﻠﻴﻪ ﺟﺪا ﺗﻌﻠﻢ ﻟﻐﺔ ‪ C++‬ﻓﻬﻤﺎ ﻣﺘﺸﺎﺑﻬﺘﺎن ﺗﻘﺮﻳﺒﺎ‪ .‬وﻓﻲ اﻟﺤﻘﻴﻘﺔ‬
‫هﻤﺎ ﻣﻦ اهﻢ اﻟﻠﻐﺎت وﺑﺎﻟﻨﺴﺒﺔ ﻟﻲ أﻋﺘﺒﺮهﻤﺎ اﻟﻤﺪﺧﻞ ﻟﺘﻌﻠﻢ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﻓﻌﻨﺪﻣﺎ ﺗﺘﻘﻦ ﺗﻌﻠﻢ هﺎﺗﻴﻦ اﻟﻠﻐﺘﻴﻦ او واﺣﺪﻩ‬
‫ﻣﻨﻬﻤﺎ ﺗﻜﻮن ﻗﺪ اآﺘﺴﺒﺖ أﺳﺎﺳﺎ ﻗﻮﻳﺎ ﻓﻲ اﻟﺒﺮﻣﺠﺔ وﻳﺴﻬﻞ ﻋﻠﻴﻚ اﻷﻧﻄﻼق ﺑﻌﺪهﺎ ﻓﻲ ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﻪ ‪.‬وهﻤﺎ اول ﻟﻐﺘﻴﻦ‬
‫ﺗﻌﻠﻤﺘﻬﻤﺎ ﻣﻦ ﻟﻐﺎت اﻟﺒﺮﻣﺠﻪ‪,‬وﺳﻬﻞ ﻋﻠﻲ ﺑﻔﻀﻞ اﷲ ﺗﻌﻠﻢ ﻟﻐﺎت ﺑﺮﻣﺠﺔ اﺧﺮى‪.‬‬
‫اﻟﺪرس اﻷول‪:‬‬
‫ﺑﺴﻢ اﷲ ﻧﺒﺪا أول دروﺳﻨﺎ ﻋﻠﻰ ﺑﺮآﺔ اﷲ وآﻤﺎ اﺗﻔﻘﻨﺎ ﺳﻨﺮآﺰ ﻋﻠﻰ ﻓﻬﻢ هﺬﻩ اﻟﻠﻐﻪ ﻋﻦ ﻃﺮﻳﻖ اﻷﻣﺜﻠﺔ اﻟﻌﻤﻠﻴﻪ‪...‬‬
‫وﺳﻨﺒﺪا ﺑﺄول ﺑﺮﻧﺎﻣﺞ ﺗﺮاﻩ ﻓﻲ ﻋﺎﻟﻢ ال ‪ C‬وال ‪. C++‬‬
‫>‪1. #include <iostream‬‬
‫)(‪2. int main‬‬ ‫‪// function main begins program execution‬‬
‫{ ‪3.‬‬
‫‪4.‬‬ ‫;"‪std::cout << "Welcome to C++!\n‬‬
‫‪5.‬‬ ‫;‪return 0‬‬ ‫‪// indicate that program ended successfully‬‬
‫‪6.‬‬ ‫}‬
‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬
‫اﻟﺴﻄﺮ اﻷول‪:‬‬
‫وهﺬا اﻟﺴﻄﺮ اﺳﺎﺳﻲ ﺟﺪا ﻓﻲ أﻏﻠﺐ اﻟﺒﺮاﻣﺞ وﻳﺠﺐ أن ﺗﻌﻮد ﻧﻔﺴﻚ ﻋﻠﻰ آﺘﺎﺑﺘﻪ ﻋﻨﺪ اﻟﺒﺪء ﻓﻲ آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬وﻳﻌﻨﻲ‬
‫ان ﺑﺮﻧﺎﻣﺠﻚ ﻳﺴﺘﺨﺪم ﻣﻜﺘﺒﺔ ‪ .iostream‬وﻓﻲ ﻟﻐﺔ ‪C++‬اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻤﻜﺘﺒﺎت اﻟﻤﺴﺘﺨﺪﻣﻪ ﺳﻨﺘﻄﺮق اﻟﻴﻬﺎ ﻓﻲ‬
‫ﻣﺮﺣﻠﺔ ﻣﺘﻘﺪﻣﻪ ان ﺷﺎء اﷲ ﻧﺴﺘﺨﺪم آﻞ ﻣﻜﺘﺒﺔ ﻋﻠﻰ ﺣﺴﺐ اﺣﺘﻴﺎﺟﻨﺎ ﻟﻬﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وﻣﻜﺘﺒﺔ ال ‪ iostream‬ﻣﺴﺆﻟﺔ‬
‫ﻋﻦ ﻋﻤﻠﻴﺘﺎن اﻷدﺧﺎل واﻷﺧﺮاج ﻓﻲ ال‪ . C++‬وهﻲ اﺧﺘﺼﺎر ل‪input output stream‬‬
‫وﻳﺘﻤﺜﻼن هﺘﻴﻦ اﻟﻌﻤﻠﻴﺘﻴﻦ ﻓﻲ ‪ cin‬ﻟﻸدﺧﺎل)أي أدﺧﺎل اﻟﻤﻌﻠﻮﻣﻪ او ﺗﺨﺰﻳﻦ اﻟﻘﻴﻤﻪ ﻓﻲ ﻣﺘﻐﻴﺮ ﺑﺄﺳﻢ وﻧﻮع ﺗﻘﻮم‬
‫ﺑﺘﺤﺪﻳﺪﻩ ﻟﻠﺒﺮﻧﺎﻣﺞ(‪ ,‬وال ‪ cout‬ﻟﻸﺧﺮاج )أي اﺧﺮاج اﻟﻤﻌﻠﻮﻣﺔ أو ﻣﺎ ﻧﺮﻳﺪ آﺘﺎﺑﺘﻪ ﻋﻠﻰ اﻟﺸﺎﺷﻪ(‪.‬‬
‫ﺧﻼﺻﺔ هﺬا اﻟﺴﻄﺮ اﻧﻪ ﻳﻘﻮم ﺑﺘﻮﺟﻴﻪ اﻟﻤﺘﺮﺟﻢ ﻟﻴﻘﻮم ﺑﺠﻌﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﺗﻘﻮم ﺑﻜﺘﺎﺑﺘﻪ ﻳﺤﺘﻮي ﻋﻠﻰ ﻣﻜﺘﺒﺔ‬
‫‪.iostream‬‬
‫اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ‪:‬‬
‫ﻣﻼﺣﻈﻪ ﻣﻬﻤﻪ‪ :‬ﺳﺘﻼﺣﻆ أﺣﺘﻮاء اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ ﻋﻠﻰ ‪// function main begins program execution‬‬
‫هﺬﻩ اﻟﻌﺒﺎرﻩ ﻟﻴﺲ ﻟﻬﺎ ﻋﻼﻗﺔ ﺑﺎﻟﺒﺮﻧﺎﻣﺞ ‪,‬ﺗﺴﺘﺨﺪم آﻬﺎﻣﺶ ﻟﻠﺘﻨﻮﻳﻪ اي ان اي ﺷﻲء ﺑﻌﺪ ‪ //‬ﻳﺴﺘﺨﺪم آﺘﻮﺿﻴﺢ ﻳﻜﺘﺒﻪ‬
‫اﻟﻤﺒﺮﻣﺞ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻪ وﻻ ﻳﻨﻈﺮ ﻟﻪ اﻟﻤﺘﺮﺟﻢ ﻋﻨﺪ ﺗﻨﻔﻴﺬ أواﻣﺮ اﻟﺒﺮﻧﺎﻣﺞ او ﻋﻨﺪ ﺗﻨﻔﻴﺬ أﺳﻄﺮ اﻟﺒﺮﻧﺎﻣﺞ ﻓﺠﻤﻴﻊ اﻟﻸﺳﻄﺮ‬
‫او اﻟﻌﺒﺎرات ﺑﻌﺪ ‪ //‬وﻗﺪ ﻟﻮﻧﺘﻬﺎ ﺑﺎﻟﻠﻮن اﻟﺤﻤﺮ ﻟﻴﺴﻬﻞ ﻋﻠﻴﻚ ﺗﻤﻴﺰهﺎ ﻻ ﻳﻀﻊ ﻟﻬﺎ اﻟﻤﺒﺮﻣﺞ اﻋﺘﺒﺎر وﻻ ﻳﺮاهﺎ أﺻﻼ ﻋﻨﺪ‬
‫ﺗﻨﻔﻴﺬ اﺳﻄﺮ اﻟﺒﺮﻧﺎﻣﺞ‪,‬هﻲ ﻓﻘﻂ ﻳﻜﺘﺒﻬﺎ اﻟﻤﺒﺮﻣﺞ ﻟﺘﻮﺿﻴﺢ ﻣﻌﻨﻲ اﻟﺴﻄﺮ او آﺘﺎﺑﺔ ﻣﻼﺣﻈﻪ ﺗﺬآﻴﺮﻳﻪ ﻟﻪ وﻟﻴﺲ‬
‫ﺑﺎﻟﻀﺮورة آﺘﺎﺑﺔ هﺬﻩ اﻟﻤﻼﺣﻈﺎت ﻓﻴﻤﻜﻨﻚ اﻷﺳﺘﻐﻨﺎء ﻋﻦ اﻟﻌﺒﺎرات اﻟﻲ ﺑﺎﻟﻠﻮن اﻟﺤﻤﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﻲ ﺗﺄﺗﻲ ﺑﻌﺪ ‪. //‬‬
‫ﻓﻤﺜﻼ ﻓﻲ اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ ﻣﺎ ﺑﻌﺪ ال ‪ //‬وهﻮ ﻋﺒﺎرة ‪ function main begins program execution‬ﻣﺠﺮد‬
‫ﻣﻼﺣﻈﺔ ﻟﺘﻌﻄﻲ ﻗﺎريء اﻟﺒﺮﻧﺎﻣﺞ ﺗﻨﻮﻳﻪ ﻋﻦ وﻇﻴﻔﺔ )(‪. int main‬‬
‫هﺬا اﻟﺴﻄﺮ ﻳﻤﺜﻞ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﻪ ﻟﻠﺒﺮﻧﺎﻣﺞ وﺟﻤﻴﻊ اﻟﺒﺮاﻣﺞ ﺗﺤﺘﻮي ﻋﻠﻰ داﻟﺔ ال‪, main‬ﻓﺠﻤﻴﻊ اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺳﻴﻘﻮم‬
‫ﺑﻬﺎ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﺳﺘﻘﻮم ﺑﻜﺘﺎﺑﺘﻪ ﻳﺠﺐ ان ﻳﻜﻮن داﺧﻞ هﺬﻩ اﻟﺪاﻟﺔ اﻟﺘﻲ ﻳﺠﺐ ان ﺗﺒﺪﺋﻬﺎ ﺑﻘﻮس } آﻤﺎ ﻓﻲ اﻟﺴﻄﺮ‬
‫اﻟﺜﺎﻟﺚ وﺗﻨﻬﻴﻬﺎ ﺑﻘﻮس { آﻤﺎ ﻓﻲ اﻟﺴﻄﺮ اﻟﺴﺎدس وﻣﺤﺘﻮى ﺑﺮﻧﺎﻣﺠﻚ ﻳﻜﻮن ﺑﻴﻦ هﺬﻳﻦ اﻟﻘﻮﺳﻴﻦ‪.‬‬
‫اﻟﺴﻄﺮ اﻟﺮاﺑﻊ‪:‬‬
‫ﻓﻲ هﺬا اﻟﺴﻄﺮ ﺳﺘﺮى ان هﺬا اﻟﺴﻄﺮ ﻳﺤﺘﻮي ﻓﻲ ﺑﺪاﻳﺘﻪ ﻋﻠﻰ ‪ std::‬ﻃﺒﻌﺎ هﺬﻩ اﻟﺠﻤﻠﻪ ﻧﻘﻮم ﺑﻜﺘﺎﺑﺘﻬﺎ ﻗﺒﻞ ال ‪cin‬‬
‫وال ‪ cout‬وﺗﺴﺘﻄﻴﻊ ﺗﻌﺮﻳﻔﻬﻤﺎ ﻗﺒﻞ ال ‪ main‬وهﺬا اﻷﻓﻀﻞ ﻟﻚ ﻻ ﺗﺤﺘﺎج ﻟﺘﻌﺮﻳﻔﻬﻤﺎ ﻋﻨﺪ آﻞ اﺳﺘﺨﺪام ﻟﻞ ‪cin‬‬
‫وال ‪ cout‬وﺳﻴﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ هﻜﺬا‪.‬‬
‫>‪1. #include <iostream‬‬

‫‪2. using std::cout; // program uses cout‬‬
‫)(‪3. int main‬‬ ‫‪// function main begins program execution‬‬
‫{ ‪4.‬‬
‫‪5.‬‬ ‫;"‪cout << "Welcome to C++!\n‬‬
‫‪6.‬‬ ‫;‪return 0‬‬ ‫‪// indicate that program ended successfully‬‬

‫‪7.‬‬ ‫}‬
‫وﻟﻚ ان ﺗﻼﺣﻆ اﻷﺧﺘﻼف ﺑﻴﻦ اﻟﺒﺮﻧﺎﻣﺠﻴﻦ وأﻧﺼﺤﻚ ﺑﺄﺳﺘﺨﺪام اﻷﺳﻠﻮب اﻟﺜﺎﻧﻲ اﻷآﺜﺮ اﺧﺘﺼﺎرا‪.‬‬
‫ﻧﻌﻮد ﻷﺳﺘﻜﻤﺎل ﺷﺮﺣﻨﺎ وﻻﺣﻆ اﻧﻨﺎ ﻧﺸﺮح اﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﻟﺘﺮﺗﻴﺐ اﻷول اي اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي آﺘﺒﻨﺎﻩ ﻓﻲ ﺑﺪاﻳﺔ ﺷﺮﺣﻨﺎ‪.‬‬
‫ﻓﻲ اﻟﺴﻄﺮ اﻟﺮاﺑﻊ ﻗﻤﻨﺎ ﺑﺄﺳﺘﺨﺪام ال <<‪ cout‬وﻧﺴﺘﺨﺪم هﺬا اﻟﺨﺪﻣﺔ اﺗﻲ ﺗﻮﻓﺮهﺎ ﻣﻜﺘﺒﺔ ال‪ iostream‬آﻤﺎ اﺳﻠﻔﻨﺎ ﻋﻨﺪ‬
‫ﻃﺒﺎﻋﺔ ﻣﻌﻠﻮﻣﺎت او ﻗﻴﻢ ﻋﻠﻰ اﻟﺸﺎﺷﺔ وﺗﻤﻜﻨﻨﺎ هﺬﻩ اﻟﻌﻤﻠﻴﻪ ﻣﻦ اﺧﺮاج اﻟﻤﻌﻠﻮﻣﺎت ﻋﻠﻰ اﻟﺸﺎﺷﻪ وﺗﻜﻮن ﺟﻤﻠﺔ ‪cout‬‬
‫ﻣﺘﺒﻮﻋﻪ ﺑﻤﻌﺎﻣﻠﻴﻦ<< وﺑﻌﺪهﻤﺎ ﻳﺠﺐ وﺿﻊ اﻟﻤﻌﻠﻮﻣﺎت اﻟﻤﺮاد أﺧﺮاﺟﻬﺎ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ﺑﻴﻦ "" أﻣﺎ اذا آﻨﺎ ﻧﺮﻳﺪ ان‬
‫ﻧﻈﻬﺮ ﻗﻴﻤﺔ ﻣﺘﻐﻴﺮ ﻧﻜﺘﺐ أﺳﻢ اﻟﻤﺘﻐﻴﺮ ﺑﺪون "" ﻷﻧﻪ ﻋﻨﺪ وﺿﻊ اي ﺷﻲء ﺑﻴﻦ ال "" ﻳﺘﻢ ﻃﺒﺎﻋﺘﻪ آﻤﺎ هﻮ ﻓﻤﺜﻼ ﻋﻨﺪ‬
‫آﺘﺎﺑﺔ اﻟﺴﻄﺮ ;"‪ cout<<"salam 3alekom‬ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺄﻇﻬﺎر ﻋﻠﻰ اﻟﺸﺎﺷﻪ‪ , salam 3alekom‬وﻣﻌﻨﻰ‬
‫‪ \n‬ﻳﻌﻨﻲ ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﻟﻨﺰول اﻟﻰ ﺳﻄﺮ ﺟﺪﻳﺪ ﺑﻌﺪ آﺘﺎﺑﺔ !‪ Welcome to C++‬ﻋﻠﻰ اﻟﺸﺎﺷﺔ وﻧﻼﺣﻆ ان‬
‫ﺑﺮﻧﺎﻣﺠﻨﺎ ﺳﻴﻘﻮم ﺑﻜﺘﺎﺑﺔ !‪ Welcome to C++‬وهﺬﻩ هﻲ اﻟﻌﻤﻠﻴﺔ اﻟﺘﻲ آﺘﺐ ﻣﻦ اﺟﻠﻬﺎ هﺬا اﻟﺒﺮﻧﺎﻣﺞ اﻟﺒﺴﻴﻂ‬
‫‪.‬وأﺧﻴﺮا ﻧﻨﻬﻲ اﻟﺴﻄﺮ ﺑﻌﻼﻣﺔ اﻟﻔﺎﺻﻠﺔ اﻟﻤﻨﻘﻮﻃﻪ; وﻳﺠﺐ اﻧﻬﺎء آﻞ ﺳﻄﺮ ﺑﻌﻼﻣﺔ اﻟﻔﺎﺻﻠﺔ اﻟﻤﻨﻘﻮﻃﻪ ﻓﻬﻲ ﺗﻌﻄﻲ‬
‫اﻟﻤﺘﺮﺟﻢ ﻣﻌﻨﻰ ﺑﺄن اﻟﺴﻄﺮ ﻗﺪ اﻧﺘﻬﻰ واﻧﺘﻬﺖ اﻷواﻣﺮ ﻟﻬﺬا اﻟﺴﻄﺮ ﻓﻌﻠﻴﻪ اﻟﺬهﺎب ﻟﻠﺴﻄﺮ اﻟﺜﺎﻧﻲ وﺗﻨﻔﻴﺬ اﻷواﻣﺮ ﻓﻴﻪ ‪.‬‬
‫اﻟﺴﻄﺮ اﻟﺨﺎﻣﺲ‪:‬‬
‫هﺬا اﻟﺴﻄﺮ ﻳﺤﺘﻮي ﻋﻠﻰ ;‪ return 0‬وهﺬا اﻟﺴﻄﺮ ﻳﺠﺐ آﺘﺎﺑﺘﻪ ﻋﻨﺪ ﻧﻬﺎﻳﺔ داﻟﺔ ال ‪ main‬ﻓﻬﻮ ﻳﺨﺒﺮﻧﺎ ﺑﺎن اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﻧﻔﺬ ﺑﻨﺠﺎح وﺗﺴﺘﻄﻴﻊ اﺳﺘﺒﺪاﻟﻪ ﺑﻜﺘﺎﺑﺔ )(‪ void main‬ﺑﺪل )(‪ int main‬ﻓﻌﻨﺪ آﺘﺎﺑﺔ ‪ void main‬ﻟﺴﺖ ﺑﺤﺎﺟﺔ‬
‫ﻟﻜﺘﺎﺑﺔ ;‪ return 0‬ﻗﺒﻞ ﻏﻠﻖ داﻟﺔ ال ‪ main‬ﺑــ}‪.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻻﺣﻆ ان ;‪ return 0‬ﺗﺤﺘﻮي ﻋﻠﻰ ﺻﻔﺮ وﻟﻴﺲ ﺣﺮف ال‪, o‬ﻓﻤﻦ أآﺜﺮ اﻷﺧﻄﺎء ﺷﻴﻮﻋﺎ آﺘﺎﺑﺔ ﺣﺮف ال ‪o‬‬
‫ﺑﺪل اﻟﺼﻔﺮ‪.‬‬
‫وﺻﻠﻨﺎ اﺧﻮﺗﻲ وأﺧﻮاﺗﻲ ﻓﻲ اﷲ اﻟﻰ ﻧﻬﺎﻳﺔ اﻟﺪرس اﻷول اﻟﺬي أﺳﺎل اﷲ ان ﻳﻜﻮن واﺿﺤﺎ وﺑﻔﺘﺮض ان ﺗﻜﻮن ﻗﺪ‬
‫ﻓﻬﻤﺖ ﻣﻦ ﺧﻼل هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﺑﻌﺾ اﻷﺳﺎﺳﻴﺎت ﻓﻲ ال ‪ C++‬وﺳﻨﻮاﺻﻞ ﻓﻲ ﺑﻘﻴﺔ اﻟﺪروس ﺷﺮح ﺑﺮاﻣﺞ اآﺜﺮ‬
‫ﺗﻄﻮرا وﺷﺮح ﻣﻔﺎهﻴﻢ واﺳﺎﺳﻴﺎت اﻋﻤﻖ ﻓﻬﺬا اﻟﺪرس ﻋﺒﺎرﻩ ﻋﻦ ﻣﻘﺪﻣﺔ ﺗﺪﺧﻠﻚ اﻟﻰ ﻋﺎﻟﻢ ‪. C++‬‬
‫وﻓﻲ ﻧﻬﺎﻳﺔ اﻟﺪرس ﻧﻘﻮل هﺬا اﺟﺘﻬﺎدﻧﺎ ﻓﺄن اﺧﻄﺎﻧﺎ ﻓﻤﻦ اﻧﻔﺴﻨﺎ وان اﺻﺒﻨﺎ ﻓﻤﻦ اﷲ ﺳﺒﺤﺎﻧﻪ وﺗﻌﺎﻟﻰ‪.....‬‬
‫‪§*)§®¤*~ˆ°‬ﺳﺒﺤﺎﻧﻚ اﻟﻠﻬﻢ وﺑﺤﻤﺪك أﺷﻬﺪ ان ﻻ اﻟﻪ اﻻاﻧﺖ اﺳﺘﻐﻔﺮك وأﺗﻮب أﻟﻴﻚ §*(§®‪°ˆ~*¤‬‬
‫`~'*‪))`~'*¤!||!¤‬آﺎﺗﺒﺔ اﻟﺪرس ‪......‬ﺑﻨﺖ اﻟﻨﻮر‪......‬ﻋﻔﻮا ﻳﻤﻨﻊ اﺟﺮاء اي ﺗﻌﺪﻳﻞ ﻟﻠﻤﻠﻒ ((`~'*‪`~'*¤!||!¤‬‬
‫`~'*‪))`~'*¤!||!¤‬ﻧﺴﺄﻟﻜﻢ دﻋﻮة ﺻﺎدﻗﺔ ﻷﺧﺘﻜﻢ ﻓﻲ ﻇﻬﺮ اﻟﻐﻴﺐ ((`~'*‪`~'*¤!||!¤‬‬

‫اﻟﺴﻼم ﻋﻠﻴﻜﻢ ورﺣﻤﺔ اﷲ وﺑﺮآﺎﺗﻪ‪.........‬‬
‫ﻧﻮاﺻﻞ ﻓﻲ هﺬا اﻟﻤﻮﺿﻮع اﻟﺪرس اﻟﺜﺎﻧﻲ ﻓﻲ دورة ﻟﻐﺔ ال‪ C++‬وﺑﻌﺪ ان اﺧﺬﻧﺎ ﻓﻜﺮة ارﺟﻮ ان ﺗﻜﻮن آﻤﻘﺪﻣﺔ ﺟﻴﺪة‬
‫وواﻓﻴﻪ ﻟﻠﺪﺧﻮل ﻓﻲ ﺗﻔﺎﺻﻴﻞ هﺬﻩ اﻟﻠﻐﺔ‪.‬‬
‫ﻓﻲ هﺬا اﻟﺪرس ﺳﻮف ﻧﻘﻮم ﺑﺎﻟﺘﻌﺮف ﻋﻠﻰ اﻟﻤﺘﻐﻴﺮات )‪, (Variables‬ﺗﺴﻤﻴﺔ اﻟﻤﺘﻐﻴﺮات ‪,‬اﻧﻤﺎط اﻟﻤﺘﻐﻴﺮات واﻧﻮاﻋﻬﺎ‬
‫‪,‬اﻟﺜﻮاﺑﺖ‪,‬اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﻪ)‪,(Arithmetic Operation‬ﻋﻤﻠﻴﺎت اﻟﻤﻘﺎرﻧﻪ)‪.(relation operator‬‬
‫‪ -١‬اﻟﻤﺘﻐﻴﺮات )‪ (Variables‬وﺗﺴﻤﻴﺘﻬﺎ‪.‬‬
‫ﺗﺘﻜﻮن ذاآﺮة اﻟﺤﺎﺳﻮب ﻣﻦ ﺧﺎﻧﺎت اﻣﺎ ان ﻳﻜﻮن ﻓﻲ اﻟﺨﺎﻧﻪ ﺻﻔﺮ او واﺣﺪ ‪ ,‬ﻳﺘﺮﺟﻢ آﻞ ﺷﻲء اﻟﻰ ﻟﻐﺔ‬
‫اﻟﺒﺎﻳﻨﺮى)‪(binary‬وهﺬﻩ اﻟﻠﻐﻪ ﻋﺒﺎرﻩ ﻋﻦ ﺻﻔﺮ ا واﺣﺪ ‪ ٠١٠١٠١٠١‬واﻟﺬاآﺮﻩ ﺗﻨﻘﺴﻢ اﻟﻰ ‪ bytes‬وآﻞ‬
‫‪ bytes=8bit‬وال ‪. bit =one or zero‬ﻓﻌﻨﺪﻣﺎ ﺗﺮﻳﺪ ان ﺗﺪﺧﻞ ﻗﻴﻤﺔ ﺑﺎﻟﺬاآﺮﻩ وﺗﺤﻔﻈﻬﺎ ﻳﺠﺐ ﻋﻠﻴﻚ ان‬
‫ﺗﺤﺠﺰ ﻟﻬﺎ ﻣﺴﺎﺣﺔ ﻓﻲ اﻟﺬاآﺮﻩ وﺗﺴﻤﻴﻬﺎ وﺗﻌﺮف ﻧﻮﻋﻬﺎ وﻣﺴﺎﺣﺘﻬﺎ‪,‬وهﺬا ﻣﺎ ﻳﺠﺐ اﻟﻘﻴﺎم ﺑﻪ ﻓﻲ ﻋﻤﻠﻴﺔ‬
‫اﻷدﺧﺎل اﻟﺘﻲ ﺷﺮﺣﻨﺎهﺎ ﻓﻲ اﻟﺪرس اﻟﺴﺎﺑﻖ‪.‬‬
‫ﻣﺜﺎل‪int box;:‬‬
‫;‪Cin >>box‬‬
‫ﻻ ﺣﻆ هﻨﺎ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻴﺲ آﺎﻣﻼ ﻓﻘﻂ ﻗﻤﺖ ﺑﺄﻗﺘﻄﺎع ﻣﺎ ﻧﺤﺘﺎﺟﻪ ﻟﻔﻬﻢ ﺟﺰﻳﺌﺔ اﻟﻤﺘﻐﻴﺮات وﺗﺴﻤﻴﺘﻬﺎ‪,‬ﻧﻼﺣﻆ ﻓﻲ‬
‫اﻟﺒﺪاﻳﺔ ﻗﻤﻨﺎ ﺑﺘﻌﺮﻳﻒ ﻧﻮع اﻟﻤﺘﻐﻴﺮ اﻟﺬي اﺳﻤﻴﻨﺎﻩ ‪ box‬وﻧﻮﻧﻌﻪ ‪ int‬ﻳﻌﻨﻲ ﻳﺤﺘﻮي ﻋﻠﻰ ارﻗﺎم ﺻﺤﻴﺤﻪ‬
‫وﺳﻨﺪرج آﻞ اﻻﻧﻮاع وﺷﺮح ﻟﻬﺎ وهﻨﺎ ﻟﻢ ﻧﺤﺪد ﻗﻴﻤﺘﺔ ﻟﻨﻨﺎ ﺳﻨﺪﺧﻠﻬﺎ ﻋﻦ ﻃﺮﻳﻖ ال ‪ cin‬وﻟﻮ اﻧﻨﺎ ﺣﺪدﻧﺎ‬
‫ﻗﻴﻤﺘﻬﺎ ﻟﻌﻤﻠﻨﺎ ‪ int box =5‬ﻓﺒﻬﺬﻩ اﻟﻄﺮﻳﻘﻪ ﻗﻤﻨﺎ ﺑﺤﺠﺰ ﻣﺴﺎﺣﻪ اﺳﻤﻬﺎ ‪ box‬وﻧﻮﻋﻬﺎ ‪ int‬ﻳﻌﻨﻲ ﺗﺤﻮي‬
‫ارﻗﺎم ﺻﺤﻴﺤﻪ وﻗﻴﻤﺘﻬﺎ ﺧﻤﺴﻪ هﻨﺎ ﺛﺒﺘﻨﺎ اﻟﻘﻴﻤﻪ ﻋﻠﻰ ﺧﻤﺴﻪ ﻟﻜﻦ ﻓﻲ اﻷﻋﻠﻰ ﻧﺤﻦ ﻟﻢ ﻧﺤﺪد اﻟﻘﻴﻤﻪ وﻗﻤﻨﺎ‬
‫ﺑﺄدﺧﺎل اﻟﻘﻴﻤﻪ ﻓﺎﻟﻘﻴﻤﻪ اﻟﺘﻲ ﺳﻴﺪﺧﻠﻬﺎ اﻟﻤﺴﺘﺨﺪم ﺳﺘﻮﺿﻊ ﻓﻲ اﻟﻤﺴﺎﺣﻪ اﻟﻤﺤﺠﻮزة ﺑﺄﺳﻢ ‪.box‬‬
‫ﻣﻼﺣﻈﻪ‪ :‬ﻋﻨﺪ ﺗﺴﻤﻴﺔ اﻟﻤﺘﻐﻴﺮ ﻻﺑﺄس ﺑﺄﺳﺘﺨﺪام اﻟﺤﺮوف واﻷرﻗﺎم وﻋﻼﻣﺔ _ وﻳﻤﻨﻊ اﺳﺘﺨﺪام @ ‪$,‬‬
‫واﻟﺮﻣﻮز اﻟﺘﻲ ﻋﻠﻰ هﺬﻩ اﻟﺸﺎآﻠﺔ‪.‬‬
‫وﺳﻨﺪرج أآﺜﺮ اﻷﻧﻮاع اﺳﺘﺨﺪاﻣﺎ وﻣﻌﻨﺎهﺎ‪..‬‬
‫ﻣﻼﺣﻈﺎت‬ ‫اﻟﻨﻮع‬
‫ﻳﻌﻨﻲ اﻟﻤﺴﺎﺣﻪ اﻟﻤﺤﺠﻮزة ﺗﺤﻮي ارﻗﺎم ﺻﺤﻴﺤﻪ‪.‬‬ ‫‪int‬‬
‫وﻳﻤﻜﻨﻚ هﻨﺎ اﺳﺘﺨﺪام ;‪long int box‬‬
‫;‪short int box‬‬ ‫أو‬
‫‪long box‬‬ ‫أو‬
‫أو ; ‪short box‬‬
‫ﻳﻌﻨﻲ اﻟﻤﺴﺎﺣﻪ اﻟﻤﺤﺠﻮزة ﺗﺤﻮي أرﻗﺎم ﻋﺸﺮﻳﺔ ﻣﺜﺎل‬ ‫‪float‬‬
‫‪٣٫٥, ١٫٢‬‬
‫ﻳﺤﻮي أﻋﺪاد آﺒﻴﺮﻩ‪.‬‬ ‫‪double‬‬
‫ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﺣ ﺮوف ورﻣ ﻮز وﻻ ﺑ ﺄس ان ﻳﺤ ﻮي‬ ‫‪char‬‬
‫أرﻗﺎم‪.‬‬
‫ﺗﺤﻮي ‪ true‬او ‪false‬‬ ‫‪bool‬‬
‫‪ -٢‬اﻟﺜﻮاﺑﺖ)‪:(constants‬‬
‫ﻋﻨ ﺪﻣﺎ ﺗﺮﻳ ﺪ ﺣﺠ ﺰ ﻣ ﺴﺎﺣﻪ ﻟﻤﺘﻐﻴ ﺮ ﺑﻨ ﻮع ﻣﺤ ﺪد وأﺳ ﻢ ﺗﺨﺘ ﺎرﻩ اﻧ ﺖ وﺗﺮﻳ ﺪ ان ﺗﺠﻌ ﻞ ه ﺬﻩ اﻟﻘﻴﻤ ﻪ ﺛﺎﺑﺘ ﻪ ‪ ,‬ﻓﻌﻠﻴ ﻚ‬
‫ﺑﺄﺿﺎﻓﺔ ‪ const‬ﻗﺒﻞ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ﻓﻴﺼﺒﺢ ;‪ const int box =5‬ﻓﻬﻨﺎ ﺗﻜ ﻮن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ‪ box‬ﺗ ﺴﺎوي‬
‫ﺧﻤﺴﺔ داﺋﻤﺎ‪.‬‬
‫‪ -٣‬اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﻪ)‪(Arithmetic Operation‬‬
‫‪ -١‬ﻋﻤﻠﻴﺔ اﻟﺠﻤﻊ )‪.(+‬‬

‫ﻣﺜﺎل ‪sum=num1 + num2; :‬‬
‫‪ -٢‬ﻋﻤﻠﻴﺔ اﻟﻄﺮح )‪.(-‬‬

‫ﻣﺜﺎل ‪sum=num1 - num2; :‬‬
‫‪ -٣‬ﻋﻜﻠﻴﺔ اﻟﻀﺮب)*(‪.‬‬
‫ﻣﺜﺎل ‪sum=num1* num2; :‬‬
‫‪ -٤‬ﻋﻤﻠﻴﺔ ﺑﺎﻗﻲ اﻟﻘﺴﻤﻪ)‪.(%‬‬

‫ﻣﺜﺎل ‪sum=num1 % num2; :‬‬
‫‪ -٥‬ﻋﻤﻠﻴﺔ اﻟﻘﺴﻤﺔ )‪.(/‬‬

‫ﻣﺜﺎل ‪sum=num1/num2; :‬‬
‫‪ -٣‬ﻋﻤﻠﻴﺎت اﻟﻤﻘﺎرﻧﻪ)‪.(relation operator‬‬
‫‪ (==) -١‬وهﺬﻩ ﻟﻤﻘﺎرﻧﺔ اﻟﻤﺴﺎواة ‪.‬‬

‫ﻣﺜﺎل ‪ :‬اذا ﻗﻠﻨﺎ ‪ num 1 == num2‬ﻧﺤﻦ ﻧﻘﺼﺪ هﻨﺎ ان ‪ num1‬ﻳﺴﺎوي ‪ num2‬واﻧﺘﺒﻪ ان ﺗﺨﻠﻂ ﺑﻴﻦ هﺬﻩ‬
‫اﻟﻌﻤﻠﻴﻪ واﺷﺎرة = ﻓﺄﺷﺎرة ال = ﺗﻌﻨﻲ ان اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﺑﺎﻟﻴﻤﻴﻦ ﺗﻨﺘﻘﻞ اﻟﻰ اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﺑﺎﻟﻴﺴﺎر‬
‫ﻣﺜﻼ‪ num1=num2 :‬ﻳﻌﻨﻲ ﻗﻴﻤﺔ ‪ num2‬ﺗﻨﺴﺦ ﻓﻲ ‪. num1‬‬
‫‪ (!=) -٢‬ﻳﻌﻨﻲ ﻻ ﺗﺴﺎوي‪.‬‬

‫ﻣﺜﺎل ‪ num1 != num2 :‬ﻳﻌﻨﻲ ‪ num1‬ﻻ ﻳﺴﺎوي ‪. num2‬‬
‫‪(>) – ٣‬‬
‫ﻣﺜﺎل ‪ num1>num2 :‬ﻳﻌﻨﻲ ‪ num1‬أآﺒﺮ ﻣﻦ ‪. num2‬‬
‫‪(<) – ٤‬‬
‫ﻣﺜﺎل ‪ num1<num2 :‬ﻳﻌﻨﻲ ‪ num1‬أﺻﻐﺮ ﻣﻦ ‪. num2‬‬
‫‪(>=) - ٥‬‬
‫‪. num2‬‬ ‫ﻣﺜﺎل ‪ num1 >= num2 :‬ﻳﻌﻨﻲ ‪ num1‬أآﺒﺮ ﻣﻦ أو ﻳﺴﺎوي‬
‫‪(<=) - ٦‬‬
‫ﻣﺜﺎل ‪ num1<=num2 :‬ﻳﻌﻨﻲ ‪ num1‬أﺻﻐﺮ ﻣﻦ أو ﻳﺴﺎوي ‪. num2‬‬
‫وهﻨﺎ ﻧﺼﻞ اﻟﻰ ﻧﻬﺎﻳﺔ درﺳﻨﺎ اﻟﻴﻮم وﻟﻜﻦ ﻗﺒﻞ ان ﻧﻨﺘﻬﻲ اﻟﻴﻜﻢ هﺬا اﻟﺴﺆال ﻟﺘﺨﺘﺒﺮوا ﻣﺪى ﻓﻬﻤﻜﻢ ﻟﻤﺎ ﺷﺮﺣﻨﺎ‬
‫وﺳﻨﻘﻮم ﺑﺤﻠﻪ ان ﺷﺎء اﷲ ﺑﺪاﻳﺔ اﻟﺪرس اﻟﻘﺎدم‪....‬وﺳﺎﻗﻮم داﺋﻤﺎ ﺑﻜﺘﺎﺑﺔ اﻟﺴﺆال ﺑﺎﻟﻌﺮﺑﻴﺔ واﻻﻧﻜﻠﻴﺰﻳﺔ‪.‬‬
‫اﻟﺴﺆال‪ :‬آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺠﻤﻊ وﻃﺮح وﻗﺴﻤﺔ ﻋﺪدﻳﻦ ﺻﺤﻴﺤﻴﻦ وآﺘﺎﺑﺔ اﻟﻨﺎﺗﺞ ﻟﻠﻌﻤﻠﻴﺎت اﻟﺜﻼث ﻋﻠﻰ‬
‫اﻟﺸﺎﺷﺔ آﻨﺎﺗﺞ ﻟﻠﺒﺮﻧﺎﻣﺞ‪.‬‬
‫**************************************************************‬
‫‪Questions: write a program which add, subtract and divide two integer numbers‬‬
‫‪and show the result for three arithmetic operations as an output for the program.‬‬

‫ﻧﺒﺪا ﺑﺄذن اﷲ اﻟﺪرس اﻟﺜﺎﻟﺚ وﻗﺪ اﻧﺘﻬﻴﻨﺎ ﻓﻲ اﻟﺪرس اﻟﺴﺎﺑﻖ ﺑﻄﺮح ﺳﺆال ﻓﻲ أﺧﺮ اﻟﺪرس وﺳﻨﺒﺪا هﺬا اﻟﺪرس ﺑﺎﻷﺟﺎﺑﻪ‬
‫ﻋﻦ اﻟﺴﺆال اﻟﺴﺎﺑﻖ وﺳﻨﻄﺮح اﺳﺄﻟﻪ أﺧﺮى واﻷﺟﺎﺑﻪ ﻋﻨﻬﺎ ان ﺷﺎء اﷲ‪,‬ﻣﻼﺣﻈﻪ ﻟﻢ اﻧﻮﻩ ﻟﻬﺎ ﻓﻲ اﻟﺪرس اﻟﺴﺎﺑﻖ ﻻﺣﻆ‬
‫ﻋﻨﺪ ﺗﺴﻤﻴﺔ اﻟﻤﺘﻐﻴﺮات ﻳﺠﺐ ﻣﺮاﻋﺎة أن اﻟﺘﺴﻤﻴﻪ ﺗﻜﻮن ﺣﺴﺎﺳﻪ ﻟﻠﺤﺮوف اﻟﺼﻐﻴﺮﻩ واﻟﻜﺒﻴﺮﻩ ﻳﻌﻨﻲ ﻳﺠﺐ اﻻﻧﺘﺒﺎﻩ ﻋﻨﺪ‬
‫آﺘﺎﺑﺔ اﻷﺳﻢ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ان ﻳﻜﻮن ﻧﻔﺲ اﻷﺳﻢ ﺑﺎﻟﻀﺒﻂ دون اﻟﺘﻐﻴﻴﺮ ﻓﻲ ﺷﻲء‪.‬‬
‫ﺣﺎول ان ﺗﺠﻴﺐ ﻋﻠﻰ اﻷﺳﺄﻟﻪ اﻟﻤﺮﻓﻘﻪ ﺑﻨﻔﺴﻚ أوﻻ ﺛﻢ ﺑﻌﺪهﺎ ﻃﺎﺑﻖ ﺣﻠﻚ ﺑﺎﻟﺤﻞ اﻟﺬي وﺿﻌﺘﻪ ﺣﺘﻰ ﺗﺴﺘﻔﻴﺪ ﻷن‬
‫اﻟﺒﺮﻣﺠﻪ ﻻ ﻳﻤﻜﻨﻚ ﺗﻌﻠﻤﻬﺎ ﻣﻦ ﻏﻴﺮ اﻟﻤﻤﺎرﺳﻪ وﺣﻞ اﻷﺳﺄﻟﻪ ﻓﺒﻤﺠﺮد اﻟﻘﺮﺁءﻩ ﻻ ﻳﻤﻜﻨﻚ ان ﺗﻜﻮن ﻣﺒﺮﻣﺞ‪.‬‬
‫اﻟﺴﺆال‪ :١‬آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺠﻤﻊ وﻃﺮح وﻗﺴﻤﺔ ﻋﺪدﻳﻦ ﺻﺤﻴﺤﻴﻦ وآﺘﺎﺑﺔ اﻟﻨﺎﺗﺞ ﻟﻠﻌﻤﻠﻴﺎت اﻟﺜﻼث ﻋﻠﻰ‬
‫اﻟﺸﺎﺷﺔ آﻨﺎﺗﺞ ﻟﻠﺒﺮﻧﺎﻣﺞ‪.‬‬
‫**************************************************************‬
‫‪Questions1: write a program which add, subtract and divide two integer numbers‬‬
‫‪and show the result for three arithmetic operations as an output for the program.‬‬
‫اﻷﺟﺎﺑﺔ‪:‬‬
‫ﻣﻼﺣﻈﻪ‪ :‬ﺳﻨﻘﻮم ﺑﻜﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ وﺗﻮﺿﻴﺢ اﻟﻔﻜﺮة وﻗﺪ أﺳﻠﻔﻨﺎ ﻓﻲ اﻟﺪرس اﻻول ﺷﺮح ﺗﻔﺼﻴﻠﻲ ﻟﻸﺳﺎﺳﻴﺎت ﻓﺄن‬
‫آﻨﺖ ﻗﺪ ﻧﺴﻴﺘﻬﺎ ﻓﺄرﺟﻊ ﻟﻠﺪرس اﻷول ﺛﻢ واﺻﻞ ﻣﻌﻨﺎ هﻨﺎ‪.‬‬
‫{‬
‫أﺳﻢ اﳌﺴﺎﺣﺔ ﻟﺘﺨﺰﻳﻦ اﻟﺮﻗﻢ اﻷول ‪int integer1; //‬‬
‫أﺳﻢ اﳌﺴﺎﺣﻪ ﻟﺘﺨﺰﻳﻦ اﻟﺮﻗﻢ اﻟﺜﺎﻧﻲ ‪int integer2; //‬‬
‫;‪int sum,sub‬‬ ‫أﺳﻢ اﳌﺴﺎﺣﻪ اﻟﱵ ﺳﻨﺨﺰن ﻓﻴﻬﺎ ﻧﺎﺗﺞ اﳉﻤﻊ واﻟﻄﺮح ﻋﻠﻰ اﻟﺘﻮاﱄ ‪//‬‬
‫ﺟﻌﻠﻨﺎ اﻟﻨﻮع ﻟﻪ ﻟﻌﺪاد ﻋﺸﺮﻳﻪ ﻟﻦ اﻟﻘﺴﻤﺔ ﻻ ﺗﻌﻄﻲ داﺋﻤﺎ اﻋﺪاد ﺻﺤﻴﺤﻪ‪float div; //‬‬
‫رﻗﻢ‪std::cout << "Enter first integer\n";//‬‬ ‫ﻷﻋﻄﺎء اﳌﺴﺘﺨﺪم رﺳﺎﻟﺔ ﻷدﺧﺎل‬

‫;‪std::cin >> integer1‬‬ ‫‪//‬‬ ‫ﻷدﺧﺎل اﻟﺮﻗﻢ ﰲ اﳌﺴﺎﺣﻪ اﶈﺠﻮزة‬
‫ﻷﻋﻄﺎء اﳌﺴﺘﺨﺪم رﺳﺎﻟﺔ ﻷدﺧﺎل رﻗﻢ‪std::cout << "Enter second integer\n"; //‬‬
‫;‪std::cin >> integer2‬‬ ‫ﻷدﺧﺎل اﻟﺮﻗﻢ ﰲ اﳌﺴﺎﺣﻪ اﶈﺠﻮزة ‪//‬‬
‫;‪sum = integer1 + integer2‬‬ ‫ﻟﻠﻘﻴﺎم ﺑﻌﻤﻠﻴﺔ اﳉﻤﻊ ‪//‬‬

‫;‪sub = integer1 - integer2‬‬ ‫ﻟﻠﻘﻴﺎم ﺑﻌﻤﻠﻴﺔ اﻟﻄﺮح‪//‬‬
‫;‪div = integer1 / integer2‬‬ ‫ﻟﻠﻘﻴﺎم ﺑﻌﻤﻠﻴﺔ اﻟﻘﺴﻤﻪ ‪//‬‬
‫ﻟﻄﺒﺎﻋﺔ ﻧﺎﺗﺞ اﳉﻤﻊ‪std::cout << "Sum is " << sum << std::endl; //‬‬
‫ﻟﻄﺒﺎﻋﺔ ﻧﺎﺗﺞ اﻟﻄﺮح ‪std::cout << "sub is " << sub << std::endl; //‬‬
‫ﻟﻄﺒﺎﻋﺔ ﻧﺎﺗﺞ اﻟﻘﺴﻤﺔ ‪std::cout << "div is " << div << std::endl; //‬‬
‫;‪return 0‬‬ ‫‪// indicate that program ended successfully‬‬
‫‪} // end function main‬‬

‫ﻣﻼﺣﻈﻪ‪ :‬اﻟﺬي اﻟﻠﻮن اﻷزرق ﳝﺜﻞ اﻟﻜﻮد وﻣﺎ ﺳﻮاﻩ ﳎﺮد ﻣﻼﺣﻈﺎت‬
‫ﻟﻠﺘﻮﺿﻴﺢ ‪......‬‬
‫اﻟﻨﺎﺗﺞ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ﺳﻴﻜﻮن)‪:(output‬‬

‫‪Enter first integer‬‬
‫‪٤‬‬
‫‪Enter second integer‬‬
‫‪٥‬‬
‫‪Sum is ٩‬‬
‫‪sub is -1‬‬
‫‪div is 0.8‬‬
‫ﺳﺆال ﺁﺧﺮ‪ :‬وﺳﺄﻗﻮم ﺑﻜﺘﺎﺑﺘﻪ ﺑﺎﻟﻌﺮﺑﻴﺔ واﻷﻧﻜﻠﻴﺰﻳﺔ‬
‫‪Questions2 : Write a C++program to read two integers (first and second), and‬‬
‫‪two real numbers (third and fourth), then calculate the value of:‬‬
‫= ‪Result1‬‬ ‫‪7 first^3 + second^2‬‬
‫= ‪Result2‬‬ ‫)‪(third^2 - fourth)^(1/2‬‬

‫‪-----------------------‬‬
‫‪third - fourth‬‬
‫‪Your program should print the values of Result1 and Result2.‬‬
‫‪Note: 2^3 means the number 2 is raised to the power of 3.‬‬
‫اﻟﺴﺆال ‪ :٢‬اﻟﻤﻄﻠﻮب آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﺑﻠﻐﺔ ال ‪ C++‬ﻳﻘﻮم ﺑﺄذﺧﺎل ﻋﺪدان ﺻﺤﻴﺤﺎن وﺁﺧﺮﻳﻦ ﻋﺸﺮﻳﻴﻦ‬ ‫‪-‬‬
‫وﻳﺠﺐ ان ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﻄﺒﻴﻖ اﻟﻤﻌﺎدﻟﻪ اﻻوﻟﻰ ﻋﻠﻰ اﻟﻌﺪدﻳﻦ اﻟﺼﺤﻴﺤﻴﻦ وﺗﻄﺒﻴﻖ اﻟﻤﻌﺎدﻟﺔ اﻟﺜﺎﻧﻴﻪ‬
‫ﻋﻠﻰ اﻟﻌﺪدﻳﻦ اﻟﻌﺸﺮﻳﻴﻦ واﻟﻤﻌﺎدﻟﺘﻴﻦ آﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪Result1 = 7 first^3 + second^2‬‬
‫= ‪Result2‬‬ ‫)‪(third^2 - fourth)^(1/2‬‬

‫‪-----------------------‬‬
‫‪third - fourth‬‬
‫‪ -‬ﻣﻼﺣﻈﻪ ‪ :‬ﻳﺠﺐ ان ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﻄﺒﺎﻋﺔ اﻟﻨﺎﺗﺞ اﻷول واﻟﺜﺎﻧﻲ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ‪ ,‬و ‪ 2^3‬ﺗﻌﻨﻲ اﻟﺮﻗﻢ ‪ ٢‬ﻣﺮﻓﻮع‬
‫ﻟﻠﻘﻮة ‪ ٣‬او ‪ ٢‬أس ‪ ٣‬وﻳﺠﺐ ﻋﻠﻴﻚ ﺗﺤﻮﻳﻞ هﺬﻩ اﻟﻌﺒﺎرة اﻟﻰ ﻟﻐﺔ اﻟﺴﻲ ﺑﻠﺲ‬
:‫ اﻷﺟﺎﺑﺔ‬-
Solution:
#include <iostream>
#include <math.h>
void main ()
{
int first, second, Result1;

float third, fourth, Result2;
cout<<"enter the first number"<<end1;

cin>>first;
cout<<"enter the second number"<<end1;

cin>>second;
Result1 = 7* pow(first,3) + pow(second,2);
Cout<<"the result1 is"<<Result1<<end1;
Cout<<"enter the third number"<<end1;

Cin>>third;
Cout<<"enter the fourth number"<<end1;

Cin>>fourth;
Result2 = pow(pow(third,2) - fourth,1/2)/ (third - fourth);

Cout<<"the result2 is"<<Result2<<end1;
#include <math.h> ‫اﺳﺘﺨﺪﻣﻨﺎ ﰲ اﻟﺒﺪاﻳﺔ‬:‫ﻣﻼﺣﻈﻪ‬

‫ وهﻮ ﺿﻤﻦ هﺬﻩ اﳌﻜﺘﺒﺔ ﻓﻴﺠﺐ ﺗﻌﺮﻳﻔﻬﺎ ﰲ اﻟﺒﺪاﻳﺔ‬pow ‫ﻷﻧﻨﺎ أﺳﺘﺨﺪﻣﻨﺎ‬
‫و ﳌﻌﺮﻓﺔ اﳌﺰﻳﺪ ﻋﻦ اﳌﻜﺘﺒﺎت اﳌﺴﺘﺨﺪﻣﺔ ﰲ اﻟﺴﻲ ﺑﻠﺲ ﺑﻠﺲ ودواﳍﺎ اﻧﺼﺤﻜﻢ ﺑﺰﻳﺎرة‬
/http://www.cplusplus.com ‫هﺬا اﳌﻮﻗﻊ اﻟﺮاﺋﻊ ﻟﻠﺴﻲ ﺑﻠﺲ ﺑﻠﺲ‬
Question 3: write a program in C++ that accept a Fahrenheit

temperature and output the equivalent Celsius temperature.
And the equation as follow:

Celsius=9/5(Fahrenheit-32)
‫ ﻳﻘﻮم ﺑﺄﺧﺬ درﺟﻪ‬C++ ‫ اﳌﻄﻠﻮب آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ﻟﻐﺔ ال‬:٣‫اﻟﺴﺆال‬
‫اﳊﺮارﻩ ﺑﺎﻟﻔﻬﺮﻳﻨﻬﻴﺖ وأﻋﻄﺎء درﺟﻪ اﳊﺮارﻩ ﺑﺎﻟﺴﻴﻠﺴﻴﻮس آﻨﺎﺗﺞ ﻟﻠﱪﻧﺎﻣﺞ وﻃﺒﻌﺎ‬
:‫اﳌﻌﺎدﻟﻪ اﳌﺴﺘﺨﺪﻣﻪ ﻟﻠﺘﺤﻮﻳﻞ ﻣﻦ اﻟﻔﻬﺮﻳﻨﻬﻴﺖ ﻟﻠﺴﻴﻠﻴﺴﻴﻮس آﺎﻟﺘﺎﱄ‬
Celsius=9/5(Fahrenheit-32)
Solution:
#include <iostream>
void main ()
{
float Celsius, Fahrenheit;
cout<<"please enter the temperature in Fahrenheit\n ";

cin>>Fahrenheit;
Celsius=9/5*(Fahrenheit-32)
Cout<<" the temperature in Celsius is "<<Celsius<<end1;
Question 4:write a complete C program that ask the user to enter

three integer number and store them in three variable k,L,and M.The
program should find the value of N according to the following
formula.
N=K+L-3M.
SOLUTION:
#include <iostream>
void main ()
{
int K,L,M,N;
cout<<"please enter the value of K"<<end1;

cin>>K;
cout<<"please enter the value of L"<<end1;
cin>>L;
cout<<"please enter the value of M"<<end1;
cin>>M;
N=K+L-3*M;
cout<<"the value of N is"<<N<<end1;

}
‫هﻨﺎ ﻧﺼﻞ ﻟﻨﻬﺎﻳﺔ درس اﻟﻴﻮم اﲤﲎ ان ﻳﻜﻮن واﺿﺢ وﻣﻔﻴﺪ وﺳﻨﻨﺘﻘﻞ ﺑﺎذن اﷲ ﰲ‬
‫اﻟﺪرس اﻟﻘﺎدم اﱃ ﻣﺮﺣﻠﺔ اآﺜﺮ ﺗﻄﻮرا ﰲ ال ‪ C++‬وأي اﺳﺘﻔﺴﺎر ﻳﺴﺮﻧﻲ اﻻﺟﺎﺑﻪ‬
‫ﻋﻠﻴﻪ‪....‬‬

‫ﻟﻘﺪ اﻧﻬﻴﻨﺎ اﻟﺘﻌﺮف ﻋﻠﻰ ﻟﻐﺔ ال ‪ C++‬وآﺘﺎﺑﺔ ﺑﺮاﻣﺞ ﺑﺴﻴﻄﻪ ﺑﻬﺬﻩ اﻟﻠﻐﺔ اﻟﻘﻮﻳﺔ وﻟﻜﻦ هﻞ ﺗﻌﺘﻘﺪ ان ﻳﻤﻜﻨﻚ ﻣﻮاﺻﻠﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﻬﺬﻩ اﻟﻤﺒﺎديء اﻟﺒﺴﻴﻄﻪ؟ ﻃﺒﻌﺎ ﻻ ﻓﻘﺪ ﻳﻄﻠﺐ ﻣﻨﻚ آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻷدﺧﺎل ﺑﻴﺎﻧﺎت ﻋﺪد آﺒﻴﺮ ﻣﻦ اﻟﻤﻮﻇﻔﻴﻦ‬
‫وﺗﺬآﺮ ان اﻟﻤﺒﺮﻣﺞ اﻟﻨﺎﺟﺢ ﻳﻜﺘﺐ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﻳﻨﻔﺬ اﻟﻤﻬﻤﻪ ﺑﺄﻗﻞ ﺳﻄﻮر ﻣﻤﻜﻨﻪ ﻟﻚ ﻳﻜﻮن ﺑﺮﻧﺎﻣﺞ ﺳﺮﻳﻊ ﻋﻨﺪ‬
‫اﻟﺘﻨﻔﻴﺬ‪,‬ﻃﺒﻌﺎ ﻣﻦ اﻟﻐﻴﺮ ﻋﻤﻠﻲ ﺟﺪا ان ﺗﺪﺧﻞ ﺑﻴﺎﻧﺎت ‪ ١٠٠‬ﻣﻮﻇﻒ ﻣﺜﻼ ب‪ cout ١٠٠‬و‪ . cin ١٠٠‬هﻨﺎ ﺗﺎﺗﻲ‬
‫ﺿﺮورة اﺳﺘﺨﺪام هﺬﻩ اﻟﺠﻤﻞ اﻟﻤﻔﻴﺪﻩ اﻟﺘﻲ ﺳﻨﺘﻄﺮق اﻟﻴﻬﺎ ﻓﻲ دورﺗﻨﺎ‪.‬‬
‫اﻟﻴﻮم ﺑﺄذن اﷲ ﺳﻨﺒﺪأ ﻓﻲ اﻟﺘﻌﺮف ﻋﻠﻰ ﺟﻤﻞ ﻣﻔﻴﺪة ﻓﻲ اﻟﺴﻲ ‪ ++‬وهﻲ اﻟﺘﻲ ﺳﺘﻘﻮدﻧﺎ اﻟﻰ ﺑﺪاﻳﺔ ﺑﺮﻣﺠﺔ ﺟﻴﺪﻩ‪.......‬‬
‫ﺳﻨﺘﻨﺎول ﻓﻲ هﺬﻩ اﻟﺪورﻩ ‪:‬‬
‫‪if ,if/else, else if‬‬ ‫‬

‫‪Switch‬‬ ‫‬
‫‪do while‬‬ ‫‬
‫‪while‬‬ ‫‬
‫‪for‬‬ ‫‬
‫‪break ,continue‬‬ ‫‬
‫‪function‬‬ ‫‬
‫‪arrays‬‬ ‫‬
‫ﻓﻲ اﻟﺪرس اﻟﺮاﺑﻊ ﺳﻨﺘﻨﺎول ﺷﺮح ‪-: if ,if/else, else if‬‬
‫{ )‪if (expression‬‬
‫;‪do the code inside the two brackets‬‬
‫}‬
‫ﻧﺒﺪا ﺑﺎل ‪ -: if‬آﻤﺎ ﺗﺮى هﺬﻩ اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﺔ ﻟﻜﺘﺎﺑﺔ ﺟﻤﻠﺔ ال ‪, if‬ﻳﺤﺘﻮي اﻟﻘﻮس اﻟﺬي ﻳﺄﺗﻲ ﺑﻌﺪ ال ‪ if‬ﻋﻠﻰ‬
‫اﻟﺸﺮط اﻟﺬي ﺑﻤﻮﺟﺒﻪ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺑﺪاﺧﻞ اﻟﻘﻮﺳﻴﻦ} { ‪,‬ﻓﻌﻨﺪ اﻧﻄﺒﺎق اﻟﺸﺮط ﻳﺘﻢ ﺗﻨﻔﻴﺬ ﻣﺎ ﺑﺪاﺧﻞ‬
‫اﻟﻘﻮﺳﻴﻦ} { وﻣﻦ ﺛﻢ اﻻﻧﺘﻘﺎل اﻟﻰ اﻟﻌﻤﻠﻴﺎت اﻟﺘﺎﻟﻴﺔ ان وﺟﺪت وﻧﻘﺼﺪ ﺑﺎﻟﻌﻤﻠﻴﺎت اﻟﺘﺎﻟﻴﻪ اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺗﺄﺗﻲ‬
‫ﺑﻌﺪ ﺗﻨﻔﻴﺬ اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺑﺪاﺧﻞ ﻗﻮﺳﻴﻦ ال ‪ ,if‬اﻣﺎ اذا ﻟﻢ ﻳﺘﺤﻘﻖ اﻟﺸﺮط ﻓﻼ ﻳﻨﻈﺮ ﻻ ﺑﺪاﺧﻞ ال ‪ if‬وﻳﻨﺘﻘﻞ‬
‫ﻣﺒﺎﺷﺮﻩ اﻟﻰ اﻟﻌﻤﻠﻴﺎت اﻟﺘﺎﻟﻴﻪ اﻟﺘﻲ ﺗﻜﻮن ﺧﺎرج ﻧﻄﺎق ال ‪ . if‬وﻧﻨﺘﻘﻞ ﻟﻠﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻟﺘﺘﻤﻜﻦ ﻣﻦ ﻓﻬﻢ اﻟﻤﻮﺿﻮع‬
‫ﺑﺸﻜﻞ أآﺒﺮ‪.‬‬
‫اﻟﺴﺆال‪:‬ﻗﻢ ﺑﻜﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﺑﻠﻐﺔ ال ‪ C++‬ﻳﻘﻮم ﺑﺄدﺧﺎل رﻗﻤﻴﻦ وآﺘﺎﺑﺔ اﻟﻌﻼﻗﺔ ﺑﻴﻨﻬﻤﺎ ‪.‬ﻓﻤﺜﻼ ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﺑﻜﺘﺎﺑﺔ اذا ﻣﺎ آﺎﻧﺎ اﻟﺮﻗﻤﻴﻦ ﻣﺘﺴﺎوﻳﻴﻦ واذا ﻟﻢ ﻳﻜﻮﻧﺎ ﻳﻘﻮم ﺑﻜﺘﺎﺑﺔ ذﻟﻚ وﺗﻮﺿﻴﺢ اي اﻟﻌﺪدﻳﻦ اآﺒﺮ ‪.‬‬
‫‪QUESTIONS: write program using C++ that accept two number and give‬‬
‫‪the relationships they satisfy.‬‬
Answer:-
1. #include <iostream>
2. using std::cout; // program uses cout

3. using std::cin; // program uses cin
4. using std::endl; // program uses endl
5. int main()
6. {
7. int num1; // first number to be read from user
8. int num2; // second number to be read from user
9. cout << "Enter two integers, and I will tell you\n"

10. << "the relationships they satisfy: ";
11. cin >> num1 >> num2; // read two integers
12. if ( num1 == num2 )

13. cout << num1 << " is equal to " << num2 << endl;
14. if ( num1 != num2 )

15. cout << num1 << " is not equal to " << num2 << endl;
16. if ( num1 < num2 )

17. cout << num1 << " is less than " << num2 << endl;
18. if ( num1 > num2 )

19. cout << num1 << " is greater than " << num2 << endl;
20. if ( num1 <= num2 )

21. cout << num1 << " is less than or equal to "
22. << num2 << endl;
23. if ( num1 >= num2 )

24. cout << num1 << " is greater than or equal to "
25. << num2 << endl;
26. return 0; // indicate that program ended successfully
27. } // end function main
‫ ﺑﺎﻟﺘﻔﺼﻴﻞ اﻟﻤﻤﻞ ﻓﻲ‬١١ ‫ اﻟﻰ‬١ ‫ وذﻟﻚ ﻷﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺸﺮح اﻟﺴﻄﻮر ﻣﻦ‬١٢ ‫ﺳﻨﺒﺪأ ﺑﺎﻟﺸﺮح ﻣﻦ اﻟﺴﻄﺮ ال‬
‫ وﻣﻌﻨﺎهﺎ اذا ﺗﺤﻘﻖ ان‬if ( num1 == num2 ) ‫ ﻓﻲ اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ ﻋﺸﺮ‬.‫اﻟﺪورس اﻟﺴﺎﺑﻘﻪ‬
‫ وأآﻴﺪ اﻧﻜﻢ ﻻﺣﻈﺘﻢ ﻋﺪم وﺟﻮد اﻟﻘﻮﺳﻴﻦ} { وهﺬا ﻷﻧﻪ اذا آﺎن‬١٣ ‫ ﻧﻘﻮم ﺑﺘﻄﺒﻴﻖ اﻟﺴﻄﺮ‬num1=num2
‫ ﻻ داﻋﻲ ﻟﻮﺿﻊ هﺬﻳﻦ اﻟﻘﻮﺳﻴﻦ و ﻻ ﻣﺸﻜﻠﺔ اذا وﺿﻌﺘﻬﻤﺎ اﻣﺎ اذا آﺎن‬if ‫ﻟﺪﻳﻨﺎ ﻓﻘﻂ ﺳﻄﺮ واﺣﺪ ﻓﻲ داﺧﻞ ال‬
‫اآﺜﺮ ﻣﻦ ﺳﻄﺮ وﻟﻢ ﺗﻀﻌﻬﻤﺎ داﺧﻞ‬if ‫ﻟﻸن اﻟﻤﺘﺮﺟﻢ اذا اﺣﺘﻮت ال‬, ‫ﻟﺪﻳﻚ اآﺜﺮ ﻣﻦ ﺳﻄﺮ وﺟﺐ ﻋﻠﻴﻚ وﺿﻌﻬﻤﺎ‬
‫ وﻳﺘﻌﺎﻣﻞ ﻣﻌﻬﻤﺎ ﻋﻠﻰ‬if ‫ واﻵﺧﺮﻳﻦ ﻳﺤﺴﺒﻬﻤﺎ ﺧﺎرج ال‬if ‫اﻟﻘﻮﺳﻴﻦ } { ﺳﻴﻘﻮم ﺑﺄﺧﺬ اول ﺳﻄﺮ ﺿﻤﻦ ال‬
.‫هﺬﻩ اﻷﺳﺎس‬
. ‫وﺑﻘﻴﺔ اﻟﺴﻄﻮر ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ﺗﻘﺎرن ﺑﺎﻟﻤﺜﻞ وﻟﻜﻦ ﺑﺄﺧﺘﻼف وﺟﻪ اﻟﻤﻘﺎرﻧﻪ‬
:(‫هﻜﺬا ﺳﻴﻜﻮن اﻟﻨﺎﺗﺞ ﻟﻠﺒﺮﻧﺎﻣﺞ ﺑﻌﺪ ﺗﺠﺮﻳﺒﻪ )اﻟﻨﺎﺗﺞ ﻋﻠﻰ اﻟﺸﺎﺷﻪ‬

Enter two integers, and I will tell you
the relationships they satisfy:
4
5
٤ is not equal to 5
٤ is less than 5
٤ is less than or equal to 5
. if /else ‫وﻧﻨﺘﻘﻞ ﻟﻞ‬.if ‫أرﺟﻮ ان ﺗﻜﻮن ﻗﺪ وﺿﺤﺖ اﻟﺼﻮرة ﺑﺎﻟﻨﺴﺒﺔ ﻟﻞ‬
if/else :‫ﺛﺎﻧﻴﺎ‬
if (expression) {
code inside if;
}
else {
code inside else;
}
‫ وﻣﺎ ﺑﺪاﺧﻠﻬﺎ‬if ‫ ﺑﻤﻔﺮدهﺎ اذا ﻟﻢ ﻳﺘﺤﻘﻖ اﻟﺸﺮط ﻳﺘﺠﺎوز اﻟﻤﺘﺮﺟﻢ ال‬if ‫ﻧﻼﺣﻆ ﻓﻲ اﻟﺴﺎﺑﻖ ﻋﻨﺪ اﺳﺘﺨﺪام ال‬
‫ ﻳﻤﺮ‬if/else ‫ ﻓﻬﻨﺎ آﻤﺎ ﺗﺮون ﺑﺎﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻞ‬else ‫ﻣﻦ آﻮد وﻳﺘﺎﺑﻊ ﻃﺮﻳﻘﻪ اﻣﺎ ﻓﻲ ﺣﺎﻟﺔ وﺟﻮد ال‬
else ‫ واذا ﻟﻢ ﻳﺘﺤﻘﻖ ﻳﻄﺒﻖ ﻣﺎ ﺑﺪاﺧﻞ ال‬if ‫ ﻳﺮى اﻟﺸﺮط اذا ﺗﺤﻘﻖ اﻟﺸﺮط ﻳﻄﺒﻖ ﻣﺎ ﺑﺪاﺧﻞ ال‬if ‫اﻟﻤﺘﺮﺟﻢ ﺑﺎل‬
‫ﺑﺮﻧﺎﻣﺞ ﻳﻄﻠﺐ ﻣﻦ‬: ‫ ﻃﺒﻌﺎ اﻟﻔﺮق ﺑﻬﺬا اﻟﻤﺜﺎل‬if ‫ﻗﺪ ﺗﺴﺎﺋﻠﻮن اذا ﻣﺎ اﻟﻔﺮق ﺑﻴﻨﻪ وﺑﻴﻦ ﻣﺎ ﺳﺒﻖ ﺷﺮﺣﻪ ﻓﻲ ال‬
error ‫ ﻏﻴﺮ ذﻟﻚ ﻧﻄﺒﻊ‬hello ‫ ﻧﻄﺒﻊ ﻋﻠﻰ اﻟﺸﺎﺷﻪ‬٣ ‫ اذا ادﺧﻞ اﻟﻤﺴﺘﺨﺪم رﻗﻢ‬,‫اﻟﻤﺴﺘﺨﺪم ان ﻳﺪﺧﻞ رﻗﻤﺎ‬
‫ ﻏﻴﺮ ذﻟﻚ ﻧﻄﺒﻊ‬, hello ‫ ﻟﻨﻄﺒﻊ‬٣ ‫ ﻟﻠﻤﻘﺎرﻧﻪ اذا آﺎن اﻟﺮﻗﻢ اﻟﺬي ادﺧﻠﻪ اﻟﻤﺴﺘﺨﺪم‬if ‫ﻧﻼﺣﻆ هﻨﺎ اﻧﻨﺎ ﺳﻨﺠﻌﻞ‬.
....‫ وﺳﻴﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ آﺎﻟﺘﺎﻟﻲ‬error ‫ﻧﻄﺒﻊ‬
#include <iostream>
using std::cout; // program uses cout

using std::cin; // program uses cin
// function main begins program execution

int main()
{
int num1; // first number to be read from user
cout << "Enter the integer number \n";

cin >> num1; // read the integer
if ( num1 == 3)
cout<<"hello";
else
cout<<"error";
return 0; // indicate that program ended successful
} // end function main

‫ﻧﻼﺣﻆ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ اذا ادﺧﻞ اﻟﻤﺴﺘﺨﺪم ‪ ٣‬ﺳﻴﻄﺒﻊ ‪ hello‬اﻣﺎ اذا ادﺧﻞ اي رﻗﻢ ﺁﺧﺮ ﻣﻬﻤﺎ آﺎﻧﺖ‬
‫ﻗﻴﻤﺘﻪ وهﺬا ﻣﺎ ﻗﺼﺪﻧﺎﻩ ب ‪ else‬ﺳﻴﻄﺒﻊ ‪ . error‬أرﺟﻮ ان ﻳﻜﻮن اﻟﻤﻌﻨﻰ واﺿﺢ‪.‬‬
‫ﺛﺎﻟﺜﺎ‪else if :‬‬
‫هﺬﻩ اﻟﺠﻤﻠﺔ ﻣﻔﻴﺪﻩ ﺟﺪا ﻓﻬﻲ ﺗﺠﻌﻞ ﺑﺮﻧﺎﻣﺠﻚ اآﺜﺮ ذآﺎء وﺣﻨﻜﻪ واﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻬﺬﻩ اﻟﺠﻤﻠﺔ آﺎﻟﺘﺎﻟﻲ‪-:‬‬
‫{ )‪if (expression‬‬
‫;‪do the code inside if‬‬
‫}‬
‫{ )‪else if (expression‬‬
‫;‪do the code inside else if‬‬

‫}‬
‫{ )‪else if (expression‬‬
‫;‪do the code inside else if‬‬
‫}‬
‫{ ‪else‬‬
‫;‪do the code inside else‬‬
‫}‬
‫هﻨﺎ اﻟﻤﺘﺮﺟﻢ ﺳﻴﻘﻮم ﺑﺘﺎآﺪ ﻣﻦ اﻟﻘﺎﻋﺪة اﻟﺘﻲ ﺑﺪاﺧﻞ ال ‪ if‬اذا ﺗﻄﺒﻘﺖ ﻧﻔﺬهﺎ وﻻ ﻳﻤﺮ ﻋﻠﻰ ﺑﺎﻗﻲ اﻟﺨﻴﺎرات‬
‫اﻟﻤﺘﻤﺜﻠﺔ ﻓﻲ ال ‪ if else‬وال ‪, else‬اذا ﻟﻢ ﺗﻄﺒﻖ اﻟﻘﺎﻋﺪﻩ ﻳﺬهﺐ ﻟﻠﺨﻴﺎر اﻵﺧﺮ ﻓﻲ ال ‪ else if‬واذا ﻟﻢ ﻳﺘﻄﺒﻖ‬
‫ﻳﺬهﺐ ﻟﻠﺬي ﺑﻌﺪﻩ واﺧﻴﺮا اذا ﻟﻢ ﻳﺘﻄﺒﻖ ﺷﻲء ﻳﻨﻔﺬ ال ‪.else‬اي اﻧﻪ اذا ﻃﺒﻖ اﺣﺪ اﻟﺨﻴﺎرات ﻳﺨﺮج ﻣﻦ هﺬﻩ‬
‫اﻟﻤﻘﺎرﻧﻪ وﻃﺒﻌﺎ هﻨﺎ ﻳﺠﺐ ان ﺗﻼﺣﻆ ﻟﻮ اﻧﻚ اﺳﺘﺒﺪﻟﺖ ال ‪ else if‬ب ‪ if‬ﻟﺘﻢ اﻟﻤﺮور ﻋﻠﻰ آﻞ ‪ if‬واﻟﺘﺎآﺪ‬
‫ﻣﻦ ﻗﺎﻋﺪﺗﻬﺎ وﺗﻄﺒﻴﻘﻬﺎ اذا ﺗﺤﻘﻘﺖ اﻟﻘﺎﻋﺪﻩ ﻟﻜﻦ ﻓﻲ ﺣﺎﻟﺔ ال ‪ else if‬ﻳﻤﺮ ﻋﻠﻰ ال ‪ if‬اﻻوﻟﻰ اذا ﺗﺤﻘﻘﺖ‬
‫ﻳﺘﺠﺎوز اﻟﺠﻤﻴﻊ وﻳﺨﺮج ﻟﻤﺎ وراء ال ‪ else‬اﻣﺎ اذا ﻟﻢ ﺗﺘﺤﻘﻖ ﻳﺠﺮب اﻟﺒﻘﻴﺔ وﺑﻤﺠﺮد ﺗﺤﻘﻖ اﺣﺪاهﻢ ﻳﺨﺮج ﻟﺬﻟﻚ‬
‫ﻳﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ اﺳﺮع ﺑﺎل ‪ else if‬ﻓﻼ داﻋﻲ ﻟﻤﻘﺎرﻧﺔ اﻟﺒﻘﻴﺔ ﻣﺎدام ﺗﺤﻘﻖ ﺷﺮط ﻣﻦ اﻟﺸﺮوط واﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬
‫ﻟﺘﻮﺿﻴﺢ اﻟﻤﻮﺿﻮع أآﺜﺮ‪.‬‬
‫ﻻﺣﻆ ﻓﻲ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻳﻤﺮ اﻟﻤﺘﺮﺟﻢ ﻋﻠﻰ ال ) ‪ if (num1 > num2‬اذا ﺗﺤﻘﻖ اﻟﺸﺮط ﻳﻜﺘﺐ اﻟﻌﺒﺎرة‬
‫‪ The number1 is bigger than number2‬وﻳﻨﺘﻘﻞ اﻟﻰ ﻣﺎ ﺑﻌﺪ ال ‪ else‬اي ﻻ ﻳﻘﺎرن اﻟﻤﻘﺎرﻧﺎت‬
‫اﻷﺧﺮى‪,‬اﻣﺎ اذا ﻟﻢ ﻳﺘﺤﻘﻖ ﻳﻨﺘﻘﻞ اﻟﻰ )‪ else if (num2 > num1‬وﻳﻄﺒﻖ ﻋﻠﻴﻪ ﻧﻔﺲ ﻣﺎ ﻗﻠﻨﺎﻩ ﻓﻲ اﻷوﻟﻰ‬
‫وهﻜﺬا اذا ﻟﻢ ﺗﺘﺤﻘﻖ اﻟﻘﺎﻋﺪﻩ ﻓﻴﻬﻢ ﺟﻤﻴﻌﺎ ﻧﺼﻞ اﻟﻰ ال ‪ else‬وﻧﻨﻔﺬ ﻣﺎ ﺑﻬﺎ وﻳﻄﺒﻊ ‪. error‬‬
‫‪1-‬‬ ‫>‪#include <iostream‬‬

‫‪2-‬‬ ‫)(‪int main‬‬
‫‪3-‬‬ ‫{‬
‫‪4-‬‬ ‫;‪int num1,num2‬‬
‫‪5-‬‬ ‫;"‪cout<<"please enter two integer numbers‬‬
‫‪6-‬‬ ‫; ‪cin >> num1 >> num2‬‬
‫{ ) ‪7- if (num1 > num2‬‬
‫; "‪8- cout << "The number1 is bigger than number2‬‬
‫} ‪9-‬‬
‫{ )‪10- else if (num2 > num1‬‬

‫; "‪11- cout << "The number2 is bigger than number1‬‬
‫} ‪12-‬‬
‫{ )‪13- else if ( num2=num1‬‬

‫}; "‪14- cout << "there is no bigger number‬‬
‫} ; "‪15- else { cout << "error‬‬

‫;‪16- return 0‬‬
‫} ‪17-‬‬
‫هﻨﺎ ﻧﺼﻞ ﻟﻨﻬﺎﻳﺔ درس اﻟﻴﻮم اﲤﲎ ان ﻳﻜﻮن واﺿﺢ وﻣﻔﻴﺪ وﺳﻨﻨﺘﻘﻞ ﺑﺎذن اﷲ ﰲ‬
‫اﻟﺪرس اﻟﻘﺎدم اﱃ ﻣﺮﺣﻠﺔ اآﺜﺮ ﺗﻄﻮرا ﰲ ال ‪ C++‬وﺳﻨﻘﻮم ﲝﻞ ﲤﺎرﻳﻦ ﻋﻠﻰ درس‬
‫اﻟﻴﻮم وأي اﺳﺘﻔﺴﺎر ﻳﺴﺮﻧﻲ اﻻﺟﺎﺑﻪ ﻋﻠﻴﻪ‪....‬‬

‫اﺗﻤﻨﻰ ان ﺗﻜﻮﻧﻮا ﺑﺼﺢ ﺟﻴﺪة ‪.....‬ﺑﻌﺪ ان اﻧﺘﻬﻴﻨﺎ ﻣﻦ اﻟﺪرس اﻟﺮاﺑﻊ ﻧﺄﺧﺬ هﺬة اﻟﺘﻤﺎرﻳﻦ ﻟﻨﻌﺰز ﻣﺎ ﺗﻢ دراﺳﺘﻪ وﺑﻌﺪهﺎ‬
‫ﻧﻨﺘﻘﻞ ﻟﻠﺪرس اﻟﺨﺎﻣﺲ‪.....‬‬
‫‪Question1: write a program that reads an integer and determine whether it is odd or‬‬
‫‪even. (Hint: use the modulus operator .an even number is a multiple of two. any‬‬
‫‪multiple of two leaves a reminder of zero when divide by 2).‬‬
‫اﻟﺴﺆال اﻷول‪ :‬ﻗﻢ ﺑﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ﻟﻐﺔ ال‪ C++‬ﻳﻘﻮم ﺑﺄدﺧﺎل ﻋﺪد ﺻﺤﻴﺢ وﺗﺤﺪﻳﺪ اذا آﺎن هﺬا اﻟﻌﺪد‬
‫اﻟﺼﺤﻴﺢ ﻋﺪد ﻓﺮدي ام زوﺟﻲ)ﻣﻼﺣﻈﻪ‪ :‬اﺳﺘﺨﺪم ‪ %‬ﻟﺘﺴﺎﻋﺪك ﻓﻲ اﻟﺤﻞ واي ﻋﺪد زوﺟﻲ ﻳﻘﺴﻢ ﻋﻠﻰ ‪ ٢‬ﻳﻜﻮن‬
‫اﻟﺒﺎﻗﻲ داﺋﻤﺎ ﺻﻔﺮا(‬
‫ﺑﻬﺬﻩ اﻟﻤﻼﺣﻈﻪ اﺻﺒﺤﺖ اﻟﻔﻜﺮة ﺟﺎهﺰة ﻟﻜﻢ ‪........‬‬
‫> ‪#include <iostream.h‬‬
‫) ( ‪int main‬‬
‫{‬
‫; ‪int number‬‬
‫; " ‪cout << " please enter the number :‬‬

‫; ‪cin >>number‬‬
‫) ‪if (number % 2 == 0‬‬

‫; " ‪cout <<" \n The number is even‬‬
‫) ‪else (number % 2 == 1‬‬

‫; " ‪cout << " \n The number is odd‬‬
‫; ‪return 0‬‬
‫}‬
‫‪Questions2 :write a program that inputs one five digit number, separates the number‬‬
‫‪in to individuals digits and prints the digits separated from one another by three‬‬
‫)‪spaces each .(hint :use combinations of integer division and the reminder operation‬‬
‫‪Example: enter a five digit number: 12345‬‬

‫‪1 2 3 4 5‬‬
‫اﻟﺴﺆال اﻟﺜﺎﻧﻲ‪:‬ﻗﻢ ﺑﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ﻟﻐﺔ ال ‪ C++‬ﻳﻘﻮم ﺑﺄدﺧﺎل ﻋﺪد ﻣﻜﻮن ﻣﻦ ﺧﻤﺴﺔ أرﻗﺎم وﻳﻔﺼﻠﻬﻤﺎ وﻳﻄﺒﻊ‬
‫آﻞ ﻋﺪد ﻣﻔﺼﻮل ﻋﻦ اﻟﺬي ﻳﻠﻴﻪ ﺑﺜﻼث ﻣﺴﺎﻓﺎت) ﻣﻼﺣﻈﻪ اﺳﺘﺨﺪم ‪ (% ,/‬واﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻟﻠﺘﻮﺿﻴﺢ‪.....‬‬
Example: enter a five digit number: 12345
1 2 3 4 5
#include <iostream.h >

int main ( )
{
int number,num1,num2,num3,num4,num5 ;
cout << " please enter a number with five digit: " ;
cin >>number ;
number =number%10000;
num1= number/10000;
number =number%1000;
num2= number/1000;
number =number%100;
num3= number/100;
number =number%10;
num4= number/10;
num5= number;
cout<<num1<</t<<num2<</t<<num3<</t<<num4<</t<<num5<<end1;
return 0 ;
:‫اﻟﺪرس اﻟﺨﺎﻣﺲ‬
‫ اﻟﺘﻲ ﺳﺒﻖ ودرﺳﻨﺎهﺎ وﻓﻴﻪ اﺧﺘﻼف ﺑﺴﻴﻂ‬else if ‫ وهﻲ ﻣﺸﺎﺑﻬﺔ ﻟﻞ‬switch ‫ﻧﺘﻨﺎول اﻟﻴﻮم ﻓﻲ درﺳﻨﺎ هﺬا ال‬
switch ‫ﻟﻜﻦ ﻟﺔ ﺗﺄﺛﻴﺮ ﻋﻠﻰ آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ﺳﻨﺘﻄﺮق ﻟﻪ ان ﺷﺎء اﷲ واﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ هﻮ اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻸﺳﺘﺨﺪام ال‬
‫{ )هﻨﺎ ﻳﻜﺘﺐ اﻟﻤﺘﻐﻴﺮ اﻟﻤﺮاد ﻣﻘﺎرﻧﺘﻪ( ‪switch‬‬
‫; ‪: do the following code‬هﻨﺎ ﺗﻜﺘﺐ اﻟﻤﻘﺎرﻧﺔ اﻷوﻟﻰ ‪case‬‬
‫; ‪: do the following code‬هﻨﺎ ﺗﻜﺘﺐ اﻟﻤﻘﺎرﻧﺔ اﻟﺜﺎﻧﻴﺔ ‪case‬‬

‫‪.‬‬
‫‪.‬‬
‫;‪default: do the following code‬‬
‫}‬
‫ﻻﺣﻆ ان اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻞ ‪ switch‬ﻣﻮﺿﺢ ﻋﻠﻴﺔ ﻣﻜﺎن وﺿﻊ اﻟﻤﺘﻐﻴﺮ اﻟﻤﺮاد ﻣﻘﺎرﻧﺘﻪ واﻟﺤﺎﻻت اﻟﺘﻲ ﻳﻘﺎرن ﺑﻪ هﺬا‬
‫اﻟﻤﺘﻐﻴﺮ وﺳﺘﺘﻀﺢ اﻟﻔﻜﺮة اآﺜﺮ ﻋﻨﺪﻣﺎ ﻧﺄﺧﺬ ﻣﺜﺎل ﻋﻤﻠﻲ ﻋﻠﻰ ال ‪ switch‬ﻧﻨﺘﻘﻞ ﻟﻤﺜﺎل ﻋﻤﻠﻲ ‪.....‬‬
‫اﻟﻤﺜﺎل‪ :١‬ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺄدﺧﺎل أرﻗﺎم ﺻﺤﻴﺤﻪ وﻳﻘﻮم ﺑﻄﺒﺎﻋﺘﻬﺎ ﺑﺎﻟﺤﺮوف ‪.‬ﻣﺜﻼ ﻋﻨﺪﻣﺎ ﻳﺪﺧﻞ اﻟﻤﺴﺘﺨﺪم ‪ ١‬ﻳﻘﻮم‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﺑﻄﺒﺎﻋﺔ ‪ .one‬وهﻜﺬا ﻃﺒﻌﺎ ﺳﻨﺠﻌﻠﻪ اﻟﻰ رﻗﻢ ﺧﻤﺴﺔ ﻓﻘﻂ ﻟﺘﻮﺿﻴﺢ ﻓﻜﺮة ﻋﻤﻞ ال ‪. switch‬‬
‫‪1-‬‬ ‫>‪#include <iostream‬‬
‫‪2-‬‬ ‫)(‪int main‬‬
‫‪3-‬‬ ‫{‬
‫‪4-‬‬ ‫;‪int number‬‬
‫‪5-‬‬ ‫; "‪cout << "Enter Number:\t‬‬
‫‪6-‬‬ ‫;‪cin >> number‬‬
‫{ )‪7- switch (number‬‬

‫‪8- case '1':‬‬
‫‪9-‬‬ ‫;"‪cout<<"one‬‬
‫;‪10- break‬‬
‫‪11-case '2':‬‬
‫‪12-‬‬ ‫;"‪cout<<"two‬‬
‫;‪13- break‬‬
‫‪14-case '3':‬‬
‫‪15-‬‬ ‫;"‪cout<<"three‬‬
‫;‪16-break‬‬
‫‪17-case '4':‬‬
‫‪18-‬‬ ‫;"‪cout<<"four‬‬
‫;‪19- break‬‬
‫‪20 case '5':‬‬
‫‪21-‬‬ ‫;"‪cout<<"five‬‬
‫;‪22-break‬‬
‫‪23-default:‬‬
‫‪24-‬‬ ‫;"‪cout<<"error‬‬
‫‪25- } //end the switch‬‬

‫‪26-‬‬ ‫;‪return 0‬‬
‫‪27-‬‬ ‫‪} // end the main‬‬
‫ﺳﻨﺒﺪا ﺷﺮح اﻟﱪﻧﺎﻣﺞ ﻣﻦ اﻟﺴﻄﺮ اﻟﺴﺎﺑﻊ ﻷن اﻟﺴﻄﻮر اﻟﺴﺎﺑﻘﻪ ﰎ ﺷﺮﺣﻬﺎ ﺳﺎﺑﻘﺎ‪,‬ﻻﺣﻆ‬

‫ﺑﻌﺪ ان ادﺧﻞ اﳌﺴﺘﺨﺪم اﻟﺮﻗﻢ وﺧﺰن ﰲ ﻣﺘﻐﲑ اﲰﻪ ‪ number‬هﻨﺎ ﺟﻌﻠﻨﺎ ال ‪number‬‬
‫داﺧﻞ ال ‪ switch‬ﻷﻧﻪ هﻮ اﻟﺬي ﺳﻨﻘﺎرﻧﻪ‪,‬ﺳﻴﻤﺮ اﳌﱰﺟﻢ ﺑﺄول ﺣﺎﻟﺔ وهﻲ '‪case '1‬‬
‫اذا ﺗﻄﺎﺑﻘﺖ ﻗﻴﻤﺔ اﳌﺘﻐﲑ ‪ number‬ﻣﻊ ‪ ١‬ﻓﺄﻧﻪ ﻳﻄﺒﻖ ﻣﺎ ﻳﻨﺪرج ﲢﺖ هﺬا ال ‪case‬‬
‫ﻓﻴﻄﺒﻊ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ‪ one‬وﺑﻌﺪهﺎ ﻳﻨﺘﻘﻞ ال ‪ break‬وهﺬﻩ اﳉﻤﻠﺔ ﲡﻌﻞ اﳌﱰﺟﻢ ﳜﺮج‬
‫ﺧﺎرج ال‪ switch‬وهﺬا ﻣﺎ ﳚﻌﻞ ال ‪ switch‬اآﺜﺮ ﻓﺎﺋﺪﻩ‪.‬ﻓﻠﻮ اﻧﻚ ﱂ ﺗﻀﻊ ﲨﻠﺔ‬
‫‪ break‬ﺑﻌﺪ آﻞ ‪ case‬ﳌﺮ اﳌﱰﺟﻢ ﻋﻠﻰ آﻞ ‪ case‬ﺣﱴ وﻟﻮ وﺟﺪ ﻇﺎﻟﺘﻪ ﰲ ال ‪case‬‬
‫اﻟﺴﺎﺑﻖ وهﺬﻩ ﻃﺒﻌﺎ اﺿﺎﻋﺔ ﻟﻠﻮﻗﺖ ﻧﺎهﻴﻚ اﻧﻪ ﺳﻴﻄﺒﻖ ال ‪ case‬اﻟﺬي ﻳﺘﻄﺎﺑﻖ ﻣﻌﻪ‬
‫ﺑﺎﻷﺿﺎﻓﺔ اﱃ ﺧﻴﺎر ال ‪ default‬ﻷن ال ‪ default‬هﻨﺎ ﻻ ﻳﻌﲏ اﺳﺘﺜﻨﺎءا آﻤﺎ ﺗﻌﲏ‬
‫ال ‪ else‬ﺑﻞ هﻲ ﻋﺎﻣﺔ اي ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬهﺎ ﰲ اﳊﺎﻟﺘﲔ ﻟﺬﻟﻚ اﻧﺼﺤﻜﻢ ﺑﺎﺗﺒﺎع هﺬﻩ‬
‫اﻟﻌﺎدﻩ اﳊﺴﻨﻪ وهﻲ وﺿﻊ ‪ break‬ﺑﻌﺪ آﻞ ‪ case‬آﻤﺎ ﻓﻌﻠﺖ ﰲ اﳌﺜﺎل اﻟﺴﺎﺑﻖ ﲠﺬﻩ‬
‫اﻟﻄﺮﻳﻘﺔ ﻳﻜﻮن ﺑﺮﻧﺎﳎﻚ ﳏﻜﻢ اآﺜﺮ وﺳﻠﻴﻢ ﻣﻦ اﳌﻔﺎﺟﺂت اﻟﻐﲑ ﺳﺎرة ﻃﺒﻌﺎ‪.‬‬
‫ﰲ ﻣﺜﺎﻟﻨﺎ ﻟﻮ ان اﳌﺴﺘﺨﺪم ادﺧﻞ ‪ ٢‬ﳝﺮ اﳌﱰﺟﻢ ﺑﺄول ﺣﺎﻟﺔ وﻃﺒﻌﺎ ال‪ ١‬ﻻ ﻳﺴﺎوي ال‬
‫‪ ٢‬وﻳﺘﺠﻪ ﻟﻠﺤﺎﻟﺔ اﻟﺜﺎﻧﻴﻪ وﻓﻌﻼ ﻳﺘﻄﺎﺑﻘﺎ ﻓﻴﻄﺒﻊ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ‪ two‬وﳜﺮج ﺧﺎرج‬
‫ال ‪ switch‬ﻃﺒﻌﺎ ﻟﻮﺟﻮد ال ‪.break‬‬
‫وﲠﺬا ﻧﻜﻮن اﻬﻧﻴﻨﺎ درس اﻟﻴﻮم وهﻮ ال ‪ switch‬اﲤﲎ ان ﻳﻜﻮن واﺿﺢ‬

‫وﻣﻔﻬﻮم‪..‬وﻋﻠﻴﻜﻢ ﲝﻞ اﻟﺴﺆال اﻟﺘﺎﱄ ﻟﺘﻄﺒﻘﻮا ﻣﺎ درﺳﻨﺎﻩ ﻟﻠﺘﻮ‪....‬‬
‫اﻟﺴﺆال‪ :‬ﻗﻢ ﺑﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ﻟﻐﺔ اﻟﺴﻲ ﺑﻠﺲ ﺑﻠﺲ ﻳﻘﻮم ﺑﻌﻤﻞ ﺁﻟﺔ‬
‫ﺣﺎﺳﺒﺔ ‪,‬ﻳﺴﺘﻘﺒﻞ ﻣﻦ اﳌﺴﺘﺨﺪم رﻗﻤﲔ واﻟﻌﻤﻠﻴﺔ )*‪ (/,+,-,‬وﻳﻘﻮم ﺑﺎﺟﺮاء اﻟﻌﻤﻠﻴﺔ‬
‫اﻟﱵ ﻳﺪﺧﻠﻬﺎ اﳌﺴﺘﺨﺪم ﻋﻠﻰ اﻟﻌﺪدﻳﻦ وﻳﻄﺒﻊ اﻟﻨﺎﺗﺞ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪..‬‬
‫ﺳﲑﻓﻖ اﳊﻞ ﰲ اﻟﺪرس اﻟﻘﺎدم ان ﺷﺎء اﷲ ‪(:‬‬

‫اﻟﺴﻼم ﻋﻠﻴﻜﻢ ورﺣﻤﺔ اﷲ وﺑﺮآﺎﺗﻪ‪.......‬‬
‫آﻴﻒ ﺣﺎﻟﻜﻢ أﺧﻮاﻧﻲ واﺧﻮاﺗﻲ اﺳﺄل اﷲ ان ﺗﻜﻮﻧﻮا ﻓﻲ أﺣﺴﻦ ﺣﺎل‪......‬اﻟﻴﻮم ﺑﻌﺪ ان اﻧﺘﻬﻴﻨﺎ ﻣﻦ ﺟﻤﻠﺔ ال ‪switch‬‬
‫ﻧﻨﺘﻘﻞ ﺑﺄذن اﷲ اﻟﻰ ﻣﻮﺿﻮع ﻣﻬﻢ وﻋﻤﻠﻲ ﺟﺪا‪...‬اﻻ وهﻮ ﺟﻤﻞ اﻟﺘﻜﺮار وﺗﺘﻤﺜﻞ ﻓﻲ ال‪while ,for loop,‬‬
‫‪ do while‬وﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺠﻤﻞ ﺑﺪرﺟﺔ واﺳﻌﻪ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺑﻞ ﻣﻌﻈﻢ اﻟﺒﺮاﻣﺞ ﺗﺤﺘﻮي ﻋﻠﻴﻬﺎ‪.‬‬
‫ﺗﺨﻴﻞ اﻧﻪ ﻃﻠﺐ ﻣﻨﻚ ﻋﻤﻞ ﺑﺮﻧﺎﻣﺞ ﻷدﺧﺎل ﺑﻴﺎﻧﺎت ﻣﻮﻇﻔﻴﻦ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺄدﺧﺎل اﻻﺳﻢ و رﻗﻢ اﻟﺘﺴﻠﺴﻞ‬
‫ﻟﻠﻤﻮﻇﻒ ووﻇﻴﻔﺘﻪ وﻋﺪد ﺳﺎﻋﺎت ﻋﻤﻠﻪ ﻃﺒﻌﺎ هﻨﺎ ﺳﺘﺤﺘﺎج ﺗﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم اﺳﻤﻪ ورﻗﻢ اﻟﺘﺴﻠﺴﻞ اﻟﺘﺎﺑﻊ ﻟﻪ‬
‫ووﻇﻴﻔﺘﻪ و ﻋﺪد ﺳﺎﻋﺎﺗﻪ وهﻨﺎ ﺳﻴﻜﻮن ﺑﺮﻧﺎﻣﺠﻚ ﻳﺤﻮي ارﺑﻊ ‪ cout‬وارﺑﻊ ‪ cin‬ﻟﻜﻞ ﻣﻮﻇﻒ ﺗﺨﻴﻞ ﻟﻮ اﻧﻪ ﻃﻠﺐ‬
‫ﻣﻨﻚ آﺘﺎﺑﺔ هﺬﻩ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻤﺌﺔ ﻣﻮﻇﻒ او اآﺜﺮ ﻃﺒﻌﺎ اﻟﻤﺴﺄﻟﺔ ﻏﻴﺮ ﻣﻘﺒﻮﻟﺔ اذا اﺳﺘﺨﺪﻣﺖ هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻷن اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﺳﻴﻜﻮن ﻃﻮﻳﻞ ﺟﺪا وﻣﻤﻞ ﺟﺪا وﺑﺪون ﻣﻌﻨﻰ ‪,‬ﻓﻬﻨﺎ ﻳﺄﺗﻲ دور ﺟﻤﻞ اﻟﺘﻜﺮار اﻟﺘﻲ ﺳﺘﻨﻘﺬك ﻣﻦ هﺬا اﻟﻤﻮﻗﻒ اﻟﺤﺮج وﻣﻦ‬
‫آﺘﺎﺑﺔ آﻞ هﺬا اﻟﻜﻼم‪.‬وﺳﻨﺸﺮﺣﻬﻢ ان ﺷﺎء اﷲ ﺑﺎﻟﺘﻔﺼﻴﻞ‪.‬‬
‫ﻧﺼﻴﺤﺔ ذهﺒﻴﺔ ‪ :‬اﻟﻤﺒﺮﻣﺞ اﻟﻨﺎﺟﺢ ﺣﻴﻨﻤﺎ ﻳﻜﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﺠﻌﻠﻪ ﻣﺮن ﺑﺤﻴﺚ ﻳﺴﺘﺨﺪم ﻷي اﺳﺘﺨﺪام ﻟﻠﻐﺮض اﻟﺬي اﻧﺸﺄ‬
‫ﻣﻦ اﺟﻠﻪ ﻣﺜﻼ ﻟﻮ ﻃﻠﺐ ﻣﻨﻚ ﻋﻤﻞ ﺑﺮﻧﺎﻣﺞ ﻳﺤﺴﺐ اﻟﻤﺘﻮﺳﻂ ﻃﺒﻌﺎ ﻳﺠﺐ ان ﺗﺠﻌﻠﻪ ﺑﺮﻧﺎﻣﺞ ﻳﺤﺴﺐ اﻟﻤﺘﻮﺳﻂ ﻷي ﻋﺪد‬
‫ﻣﻦ اﻟﺪرﺟﺎت اﻳﺎ آﺎن ﻋﺪدهﺎ وهﻜﺬا ﻟﻚ ﻳﺴﺘﺨﺪم ﻓﻲ اي وﻗﺖ وﺣﺎول ﺗﺨﺘﺎر اﺳﻤﺎء ﻣﺘﻐﻴﺮات واﺿﺤﻪ وذات ﻣﻌﻨﻲ‬
‫اي اذا اردت ان ﺗﺨﺘﺎر ﻣﺘﻐﻴﺮ ﺗﺨﺰن ﻓﻴﻪ اﻟﺪرﺟﺎت اﺟﻌﻞ اﺳﻤﻪ ‪ grade‬اي درﺟﻪ ﻟﻚ ﺗﺘﺬآﺮ هﺪﻓﻪ وﻣﻌﻨﺎﻩ اذا‬
‫رﺟﻌﺖ ﻟﻪ ﺑﻌﺪ زﻣﻦ او اردت ﺗﻄﻮﻳﺮﻩ‪.......‬‬
‫أﻋﺘﺬر ﻋﻠﻰ اﻷﻃﺎﻟﻪ ﻧﻨﺘﻘﻞ ﻣﺒﺎﺷﺮﻩ ﻷول ﺟﻤﻞ اﻟﺘﻜﺮار وهﻲ ال ‪.while‬‬
‫ﺟﻤﻠﺔ ال ‪:while‬‬
‫ﻧﺒﺪا اﻵن ﺑﺎﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻞ ‪.... while‬‬

‫{ )هﻨﺎ ﻳﻜﺘﺐ اﻟﺸﺮط ( ‪while‬‬
‫هﻨﺎ ﺗﻜﺘﺐ اﻟﻜﻮد اﻟﺬي ﺗﺮﻳﺪ ان ﻳﻄﺒﻘﻪ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻨﺪ ﺗﻮﻓﺮ اﻟﺸﺮط ﻓﻴﻪ‬
‫}‬
‫ﻻﺣﻆ ﻋﻨﺪ اﺳﺘﺨﺪام ال ‪ while‬ﻳﺠﺐ ان ﺗﺴﺘﺨﺪم اﻟﺸﻜﻞ اﻟﺴﺎﺑﻖ ‪,‬ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺗﻜﺘﺐ اﻟﺸﺮط ﻟﺪﺧﻮل‬
‫ال ‪ while‬وﻳﺠﺐ ان ﺗﺒﺪأ ال ‪ while‬ﺑﻘﻮس ﻣﻔﺘﻮح وﺗﻨﻬﻴﻬﺎ ﺑﻘﻮس ﻣﻐﻠﻖ آﻤﺎ هﻮ ﻣﻮﺿﺢ ﺑﺎﻟﺼﻮرة‬
‫‪,‬وﺑﻴﻦ ﻗﻮﺳﻴﻦ اﻟﺒﺪاﻳﺔ واﻟﻨﻬﺎﻳﺔ ﺗﻜﺘﺐ اﻟﻜﻮد اﻟﺬي ﺳﻴﻄﺒﻘﻪ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻨﺪ ﺗﻮﻓﺮ اﻟﺸﺮط ﻟﺪﺧﻮل‬
‫ال‪.while‬‬
‫ﻃﺒﻌﺎ ﻟﻚ ﻧﻔﻬﻢ اآﺜﺮ ﻧﻨﺘﻘﻞ ﻟﻤﺜﺎل ﻋﻤﻠﻲ ﺳﺘﻔﻬﻤﻮن ﻣﻨﻪ ان ﺷﺎء اﷲ آﻴﻔﻴﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ال ‪while‬‬
‫أآﺜﺮ‪.‬‬
‫‪-‬اﻟﻤﻄﻠﻮب آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺠﻤﻊ اﻻﻋﺪاد ﻣﻦ ‪ ١‬اﻟﻰ ‪, ١٠‬ﻳﻌﻨﻲ ‪.١٠+.......+٥+٤+٣+٢+١‬‬
‫>‪1-#include <iostream‬‬
‫;‪2-using std::cout‬‬
‫;‪3-using std::endl‬‬
‫)(‪4-int main‬‬
‫{‪5-‬‬
‫‪6-‬‬ ‫;‪int sum=0‬‬
‫‪7-‬‬ ‫;‪int x=1‬‬
‫‪8-‬‬ ‫{ ) ‪while ( x <= 10‬‬
‫‪9-‬‬ ‫;‪sum =sum+x‬‬
‫‪10-‬‬ ‫;‪x=x+1‬‬
‫‪11-‬‬ ‫‪} // end while‬‬
‫‪12-‬‬ ‫;‪cout << "The sum is: " << sum << endl‬‬
‫‪13-‬‬ ‫;‪return 0‬‬
‫‪14-‬‬ ‫‪} // end function main‬‬
‫ﻧﻨﺘﻘﻞ اﻵن ﻟﺸﺮح اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬

‫‪-‬ﻻﺣﻆ ﻓﻲ اﻟﺴﻄﺮ اﻟﺴﺎدس ﻗﻤﻨﺎ ﺑﺤﺠﺰ ﻣﺴﺎﺣﻪ ﻟﻨﺤﻔﻆ ﻓﻴﻬﺎ اﻟﻤﺠﻤﻮع واﺳﻤﻴﻨﺎهﺎ ‪ sum‬وﻧﻮﻋﻬﺎ‬
‫‪ integer‬ﻷن اﻟﻨﺎﺗﺞ ﻣﻊ ﻷﻋﺪاد ﺻﺤﻴﺤﻪ اآﻴﺪ ﻟﻦ ﻳﻜﻮن اﻻ ﻋﺪد ﺻﺤﻴﺢ ‪,‬ﻳﻤﻜﻦ ﺗﺘﺴﺎﺋﻞ ﻟﻤﺎذا ﺟﻌﻠﻨﺎ‬
‫ﻗﻴﻤﺔ ال ‪ sum =0‬هﻨﺎ ﺻﻔﺮﻧﺎ اﻟﺨﺎﻧﻪ اﻟﺘﻲ ﺳﻨﺨﺰن ﻓﻴﻬﺎ اﻟﻤﺠﻤﻮع ﻷﻧﻨﺎ ﻧﺤﺘﺎج ﻟﺤﻔﻆ اﻟﻤﺠﻤﻮع ﺧﺎﻧﻪ‬
‫ﺧﺎﻟﻴﺔ ﻣﻦ اي رﻗﻢ ﻟﻚ ﻧﺤﺼﻞ ﻋﻠﻰ ﻧﺎﺗﺞ ﺻﺤﻴﺢ وﻓﻲ اﻟﻌﺎدﻩ اﻟﺬاآﺮﻩ ﻳﻜﻮن ﻣﻮﺟﻮد ﻓﻴﻬﺎ ‪ ١‬أو ‪ ٠‬ﻟﺬﻟﻚ‬
‫ﻻ ﻧﺮﻳﺪ ان ﻧﺪع اﻟﻤﺴﺄﻟﻪ ﻟﻠﺤﻆ اذا آﺎن ﺻﻔﺮ ﺣﺼﻠﻨﺎ ﻋﻠﻰ ﻧﺎﺗﺞ ﺻﺤﻴﺢ واذا آﺎن ‪ ١‬آﺎن اﻟﻨﺎﺗﺞ ﻏﻴﺮ‬
‫ﺻﺤﻴﺢ ‪.‬ﻧﺼﻔﺮ اﻟﺨﺎﻧﻪ وﻧﻜﻮن ﻓﻲ اﻟﺠﺎﻧﺐ اﻵﻣﻦ‪.‬‬
‫ﺧﺬوا هﺬﻩ اﻟﻌﺎدة اﻟﺤﺴﻨﻪ‪ :‬ﻋﻨﺪﻣﺎ ﺗﺮﻳﺪون ان ﺗﺤﺠﺰوا ﻣﺴﺎﺣﻪ ﻟﺤﻔﻆ اﻟﻨﺎﺗﺞ ﺑﺪاﺧﻠﻬﺎ ﻓﻲ اﻟﺒﺪاﻳﺔ ﻋﻨﺪ‬
‫ﺗﻌﺮﻳﻔﻬﺎ ﻗﻮﻣﻮا ﺑﺘﺼﻔﻴﺮهﺎ آﻤﺎ ﻓﻌﻠﻨﺎ اﻵن‪.‬‬
‫‪ -‬ﻓﻲ اﻟﺴﻄﺮ اﻟﺴﺎﺑﻊ ﻗﻤﻨﺎ ﺑﺤﺠﺰ ﻣﺴﺎﺣﻪ ﻟﻤﺘﻐﻴﺮ اﺳﻤﻴﻨﺎﻩ ‪ x‬وﻧﻮﻋﻪ ﻋﺪد ﺻﺤﻴﺢ‪,‬وهﺬا اﻟﻤﺘﻐﻴﺮ‬
‫ﺳﻴﻜﻮن ﻟﻨﺎ ﺑﻤﺜﺎﺑﺔ اﻟﻤﺆﺷﺮ اﻟﺬي ﻳﺆﺷﺮ ﻋﻠﻰ اﻟﻌﺪد اﻟﺬي ﻧﺼﻞ ﻟﻪ ﺑﻌﺪ ﺟﻤﻊ اي ﻋﺪد وﻃﺒﻌﺎ ﺟﻌﻠﻨﺎ‬
‫ﻗﻴﻤﺘﻪ اﻟﻤﺒﺪﺋﻴﻪ ﺑﻮاﺣﺪ ﻷﻧﻨﺎ ﻧﺮﻳﺪ ﺟﻤﻊ اﻷرﻗﺎم ﻣﻦ واﺣﺪ اﻟﻰ ‪ . ١٠‬وﻟﻮ اردﻧﺎ ﺟﻤﻊ اﻷﻋﺪاد ﻣﻦ ‪ ٣‬اﻟﻰ‬
‫‪ ١٠‬ﻟﺠﻌﻠﻨﺎ ﻗﻴﻤﺘﻪ اﻟﻤﺒﺪﺋﻴﺔ ‪. ٣‬‬
‫‪-‬اﻟﺴﻄﺮ اﻟﺴﺎﺑﻊ‪ :‬هﻨﺎ ﻧﺒﺘﺪي ال ‪ while‬ﻻﺣﻆ ﻳﺒﺪأ اﻟﻤﺘﺮﺟﻢ ﻓﻲ اﻟﺒﺪاﻳﺔ ﺑﺎﻟﺘﺄآﺪ ﻣﻦ اﻟﺸﺮط ‪ ,‬واﻟﺸﺮط‬
‫هﻨﺎ) ‪, (x <= 10‬ﺳﻴﻘﺎرن اﻟﻤﺘﺮﺟﻢ ﻗﻴﻤﺔ ال‪ x‬وهﻲ ﺣﺎﻟﻴﺎ واﺣﺪ وﺳﻴﻨﺘﺞ ان اﻟﺸﺮط ﺗﺤﻘﻖ ﻷن‬
‫اﻟﻮاﺣﺪ أﻗﻞ ﻣﻦ ال ﻋﺸﺮة ‪ .‬ﻓﺴﻴﺪﺧﻞ اﻟﺘﻜﺮار وﻳﻄﺒﻖ اﻟﺴﻄﻮر اﻟﻜﻮدﻳﺔ اﻟﺘﻲ ﺑﺪاﺧﻞ اﻟﻘﻮﺳﻴﻦ‬
‫ﻟﻞ‪. while‬‬
‫‪-‬اﻟﺴﻄﺮ اﻟﺜﺎﻣﻦ ‪ :‬هﻨﺎ ﺳﻴﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺠﻤﻊ اﻟﻌﺪد اﻟﺬي ﺑﺎﻟﺨﺎﻧﻪ اﻟﻤﺴﻤﺎﻩ ‪ x‬ﻣﻊ ﻗﻴﻤﺔ ال ‪sum‬‬
‫وﺳﻴﻨﺘﺞ ‪ ١=١+٠‬وﺳﺘﺘﻐﻴﺮ ﻗﻴﻤﺔ ال ‪ sum‬اﻟﻰ واﺣﺪ ‪.‬‬
‫ﺑﻌﺪهﺎ ﻳﻨﺘﻘﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻠﺴﻄﺮ اﻟﺘﺎﺳﻊ وﻗﻮم ﺑﺰﻳﺎدة ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ x‬ﺑﻤﻘﺪار واﺣﺪ ﺣﺘﻰ ﻧﻨﺘﻘﻞ ﻟﻠﺮﻗﻢ ‪٢‬‬
‫وﻧﻘﻮم ﺑﺠﻤﻌﻪ ﻣﺮة أﺧﺮى ‪.‬ﻻﺣﻆ ﻟﻦ ﻳﺨﺮج اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ ال ‪ while‬اوﻻ ﺳﻴﻘﺎرن اﻟﺸﺮط وﻓﻌﻼ‬
‫ال‪ ٢‬اﻗﻞ ﻣﻦ اﻟﻌﺸﺮة ﻓﺴﻴﺪﺧﻞ اﻟﺘﻜﺮار ﻣﺮة اﺧﺮى وﻳﻄﺒﻖ اﻟﺴﻄﻮر اﻟﺘﻲ ﺑﺪاﺧﻞ ال ‪, while‬ﻓﻴﺠﻤﻊ‬
‫اﻟﻨﺎﺗﺞ وهﻮ اﻵن ﻳﺤﺘﻮي اﻟﻘﻴﻤﺔ واﺣﺪ ﺑﺎﻟﻘﻴﻤﺔ اﻟﺘﻲ ﻓﻲ اﻟﻤﺘﻐﻴﺮ ‪ x‬وﻳﻀﻴﻒ اﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة وهﻲ ‪٣‬‬
‫ﻓﻲ اﻟﻤﺘﻐﻴﺮ ‪ sum‬وﻳﻨﺰل ﻟﻠﺴﻄﺮ اﻟﺬي ﻳﻠﻴﻪ وهﻮ اﻟﺴﻄﺮ اﻟﺘﺎﺳﻊ وﻳﺰﻳﺪ ﻗﻴﻤﺔ ال ‪ x‬ﺑﻤﻘﺪار واﺣﺪ‬
‫ﻓﺘﺼﺒﺢ ﻗﻴﻤﺔ ال ‪ x =3‬ﺛﻢ ﻳﺮﺟﻊ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻞ ‪ while‬وﻳﻘﺎرن اﻟﺸﺮط ﻣﺮة اﺧﺮى وﻓﻌﻼ ﻳﺘﺤﻘﻖ ﻷن‬
‫ال ‪ ٣‬أﻗﻞ ﻣﻦ ‪ ١٠‬وﻳﺪﺧﻞ ﻣﺮة اﺧﺮى داﺧﻞ ال ‪ while‬وﻳﻄﺒﻖ اﻟﺴﻄﻮر اﻟﻜﻮدﻳﺔ اﻟﺘﻲ ﺑﺪاﺧﻞ ال‬
‫‪ while‬وﻳﺴﺘﻤﺮ هﻜﺬا اﻟﻰ ان ﺗﺼﻞ ﻗﻴﻤﺔ ال ‪ x‬اﻟﻰ ﻋﺸﺮة ﻳﻘﺎرﻧﻬﺎ ﺑﺎﻟﺸﺮط ﻓﻴﺘﺤﻘﻖ اﻟﺸﺮط ﻓﻴﻄﺒﻖ‬
‫اﻷﺳﻄﺮ اﻟﻜﻮدﻳﺔ اﻟﺘﻲ ﺑﺪاﺧﻞ ال ‪ while‬هﻨﺎ ﺳﺘﺼﻞ ﻗﻴﻤﺔ ال ‪ sum =45‬ﻳﻀﻴﻒ ﻟﻬﺎ ﻗﻴﻤﺔ ال ‪x‬‬
‫اﻟﺤﺎﻟﻴﺔ وهﻲ ‪ ١٠‬ﻓﻴﺼﺒﺢ ﻟﺪﻳﻨﺎ ‪ ٥٥= ٤٥+١٠‬ﻓﺘﺘﻐﻴﺮ ﻗﻴﻤﺔ ال‪ sum=55‬ﺑﻌﺪهﺎ ﺗﺰﻳﺪ ﻗﻴﻤﺔ ال ‪x‬‬
‫ﻣﻘﺪار واﺣﺪ ﻓﺘﺼﺒﺢ ‪ x=11‬ﻳﺮﺟﻊ اﻟﺒﺮﻧﺎﻣﺞ وﻳﻘﺎرن اﻟﺸﺮط هﻨﺎ ﻻ ﻳﺘﻄﺒﻖ اﻟﺸﺮط ﻗﻴﺨﺮج اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﻣﻦ ال ‪ while‬وﻳﺬهﺐ اﻟﻰ اﻟﺴﻄﺮ ‪ ١٢‬اﻟﻨﺎﺗﺞ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ‪.The sum is:٥٥‬‬
‫وهﻜﺬا ﻳﻨﺘﻬﻲ اﻟﺒﺮﻧﺎﻣﺞ وﺑﻬﺬا اﻟﻨﻤﻂ واﻟﺘﻜﺮار ﺗﻜﻮن ﻃﺮﻳﻘﺔ ﺳﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ال ‪while‬‬
‫اﺗﻤﻨﻰ ان ﺗﻜﻮن ﻗﺪ وﺻﻠﺖ اﻟﻔﻜﺮة وﺳﺄﺳﺮد أﻣﺜﻠﺔ اﺧﺮى ﻟﺘﻮﺿﻴﺢ ﻋﻤﻞ ال ‪ while‬وﻟﻜﻦ ﻟﻦ ﻧﻔﺼﻞ‬
‫ﺳﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ ﺑﻬﺬا اﻟﺘﻔﺼﻴﻞ اﻟﺴﺎﺑﻖ ﻷﻧﻨﺎ ﻗﺪ ﺳﺮدﻧﺎ اﻟﺘﻔﺼﻴﻞ ﻓﻲ اﻟﻤﺜﺎل اﻷول ‪...‬‬
‫ﻣﺜﺎل ‪ :٢‬ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻣﻀﺮوب اﻟﻌﺪد ﻓﻲ ﻧﻔﺴﺔ ﻣﻦ واﺣﺪ اﻟﻰ ﻋﺸﺮة وﻃﺒﺎﻋﺔ ﻣﺠﻤﻮﻋﻬﻢ‪.‬‬
‫ﻣﺜﺎل اﻟﻨﺎﺗﺞ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ﺳﻴﻜﻮن آﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫‪١‬‬
‫‪٤‬‬
‫‪٩‬‬
‫‪١٦‬‬
‫‪٢٥‬‬
‫‪٣٦‬‬
‫‪٤٩‬‬
‫‪٦٤‬‬
‫‪٨١‬‬
‫‪١٠٠‬‬
‫‪The total is :385‬‬
‫اﻟﺤﻞ‪:‬‬
‫;‪using std::cout‬‬
‫;‪using std::endl‬‬
‫{‬
‫;‪int y‬‬ ‫‪// declare y‬‬
‫;‪int x = 1‬‬ ‫‪// initialize x‬‬
‫;‪int total = 0‬‬ ‫‪// initialize total‬‬
‫{ ) ‪while ( x <= 10‬‬ ‫‪//‬‬ ‫‪loop 10 times‬‬

‫;‪y = x * x‬‬ ‫‪//‬‬ ‫‪perform calculation‬‬
‫;‪cout << y << endl‬‬ ‫‪//‬‬ ‫‪output result‬‬
‫;‪total += y‬‬ ‫‪//‬‬ ‫‪add y to total‬‬
‫;‪++x‬‬ ‫‪//‬‬ ‫‪increment counter x‬‬
‫‪} // end while‬‬
‫;‪cout << "Total is " << total << endl‬‬ ‫‪// display result‬‬
‫;‪return 0‬‬ ‫‪// indicate successful termination‬‬
‫ﻣﻼﺣﻈﻪ ‪ :‬اﻟﺘﻌﻠﻴﻘﺎت اﻟﺘﻲ ﺑﻌﺪ ﻋﻼﻣﺔ ‪ //‬ﻣﺠﺮد ﺗﻌﻠﻴﻖ ﻟﻚ اﻧﺖ اي ان اﻟﺒﺮﻧﺎﻣﺞ ﻻ ﻳﻌﻄﻴﻪ اي اهﻤﻴﻪ‬
‫وﻗﺪ وﺿﺤﺖ هﺬﻩ اﻟﻨﻘﻄﻪ ﻓﻲ اﻟﺪروس اﻟﺴﺎﺑﻘﻪ ﻟﻜﻦ اﻋﺎدة هﺬﻩ اﻟﻼﺣﻈﻪ ﻟﻠﺘﻨﺒﻴﺔ ﻻ ﺗﻀﺮ ﺷﻴﺌﺎ‪.‬‬
‫آﻤﺎ ﺗﻌﻮدﻧﺎ اﻟﻴﻜﻢ هﺬا اﻟﺴﺆال اﻟﺬي اﺗﻤﻨﻰ ان ﺗﺤﺎوﻟﻮا ان ﺗﺠﺪوا اﻟﺤﻞ ﻟﻪ وهﻮ ﺳﻬﻞ ﺟﺪا وﺳﺄﺿﻴﻒ‬
‫اﺟﺎﺑﺘﻪ ﻓﻲ اﻟﺪرس اﻟﻘﺎدم ان ﺷﺎء اﷲ‪.‬‬
‫‪ -‬ﻗﻢ ﺑﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ﻟﻐﺔ اﻟﺴﻲ ‪ ++‬ﻳﻘﻮم ﺑﻄﻠﺐ اﻻﺳﺎس واﻻس ﻣﻦ اﻟﻤﺴﺘﺨﺪم واﻳﺠﺎد اﻟﻨﺎﺗﺞ‬
‫‪ .‬ﻣﺜﺎل‬
‫‪Enter base as an integer:‬‬
‫‪٣‬‬
‫‪Enter exponent as an integer‬‬
‫‪٢‬‬
‫‪Power =9‬‬
‫اﻟﺴﺆال ﺳﻬﻞ اﻟﻴﺲ آﺬﻟﻚ ☺‬

‫هﻨﺎ ﻧﺼﻞ اﻟﻰ ﻧﻬﺎﻳﺔ اﻟﺪرس اﻟﻴﻮم وﻓﻲ اﻟﺪرس اﻟﻘﺎدم ﺳﻨﺄﺧﺬ اﻣﺜﻠﺔ اآﺜﺮ ﻋﻠﻰ ال ‪ while‬وﺗﻤﺎرﻳﻦ‬
‫أﻋﻤﻖ ‪.‬ﻓﻴﺠﺐ ان ﺗﺘﻤﻜﻦ ﻣﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﺟﻴﺪا ﻟﻸهﻤﻴﺘﻬﺎ اﻟﺒﺎﻟﻐﺔ ﻓﻲ ﺑﺮﻣﺠﺔ اﻟﺴﻲ ‪.++‬‬

‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﻴﻢ‬
.......‫اﻟﺴﻼم ﻋﻠﻴﻜﻢ ورﺣﻤﺔ اﷲ وﺑﺮآﺎﺗﻪ‬
.......‫وﻋﻠﻰ اﻟﻪ وﺻﺤﺒﻪ اﺟﻤﻌﻴﻦ‬
...... ‫أﺟﻤﻞ ﺗﺤﻴﺔ ﻟﻜﻢ اﺧﻮﺗﻲ واﺧﻮاﺗﻲ ﻓﻲ اﷲ‬

‫وذآﺮﻧﺎ ﻣﺜﺎﻟﻴﻦ ﻋﻠﻴﻬﺎ وﻗﻤﻨﺎ ﺑﻄﺮح ﺳﺆال واﻵن ان ﺷﺎء اﷲ ﻧﻮاﺻﻞ‬while ‫اﺗﻬﻴﻨﺎ ﻓﻲ اﻟﺪرس اﻟﺴﺎﺑﻖ ﻣﻦ ﺷﺮح ال‬
.while ‫ ﺣﻴﺚ ﺳﻨﺘﺪرب ﻋﻠﻰ ﺑﺮاﻣﺞ أآﺜﺮ ﺑﺄﺳﺘﺨﺪام ال‬while ‫اﻟﺠﺰء اﻟﺜﺎﻧﻲ ﻣﻦ درس ال‬
..... ‫ﻧﺒﺪأ ﺑﺤﻞ اﻟﺴﺆال اﻟﺬي ذآﺮﻧﺎﻩ ﻓﻲ اﻟﺪرس اﻟﺴﺎﺑﻖ‬
:١ ‫اﻟﺴﺆال‬
‫ ﻳﻘﻮم ﺑﻄﻠﺐ اﻻﺳﺎس واﻻس ﻣﻦ اﻟﻤﺴﺘﺨﺪم واﻳﺠﺎد اﻟﻨﺎﺗﺞ‬++ ‫ ﻗﻢ ﺑﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ﻟﻐﺔ اﻟﺴﻲ‬-
‫ ﻣﺜﺎل‬.
Enter base as an integer:
٣
Enter exponent as an integer
٢
Power =9
: ‫اﻟﺠﻮاب‬
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
int main()
{
int x; // base
int y; // exponent
int i; // counts from 1 to y
int power; // used to calculate x raised to power y
i = 1; // initialize i to begin counting from 1

power = 1; // initialize power
cout << "Enter base as an integer: "; // prompt for base

cin >> x; // input base
cout << "Enter exponent as an integer: ";

cin >> y; // input exponent
// count from 1 to y and multiply power by x each time

while ( i <= y ) {
power *= x;
++i;
} // end while
cout <<"power="<<power<< endl; // display result

‫ﻣﻼﺣﻈﻪ ‪ :‬اﻟﺘﻌﻠﻴﻘﺎت اﻟﺘﻲ ﺑﻌﺪ ﻋﻼﻣﺔ ‪ //‬ﻣﺠﺮد ﺗﻌﻠﻴﻖ ﻟﻚ اﻧﺖ اي ان اﻟﺒﺮﻧﺎﻣﺞ ﻻ ﻳﻌﻄﻴﻪ اي اهﻤﻴﻪ‬
‫وﻗﺪ وﺿﺤﺖ هﺬﻩ اﻟﻨﻘﻄﻪ ﻓﻲ اﻟﺪروس اﻟﺴﺎﺑﻘﻪ ﻳﻌﻨﻲ ﻟﻴﺴﺖ ﻣﻦ ﺿﻤﻦ اﻟﻜﻮد ﻟﻠﺒﺮﻧﺎﻣﺞ ‪...‬‬
‫ﺗﺴﺘﻄﻴﻊ اﺳﺘﺨﺪام ﺗﻜﺮار داﺧﻞ ﺗﻜﺮار اي ‪ while loop‬داﺧﻞ ‪ while loop‬واﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﺳﻴﻮﺿﺢ‬
‫اﻟﻔﻜﺮﻩ‪.‬واﻳﻀﺎ ﻳﻨﻘﺴﻢ اﻟﺘﻜﺮار ﻓﻲ ال ‪ while‬اﻟﻰ ﻣﺤﺪد )ﺛﺎﺑﺖ ﻟﻌﺪد ﻣﻌﻴﻦ( وﻏﻴﺮ ﻣﺤﺪد ﻳﺤﺪدﻩ اﻟﻤﺴﺘﺨﺪم ﻓﺎﻟﺮﻗﻢ‬
‫ﻟﻠﺘﻜﺮار ﻓﻲ اﻟﻐﻴﺮ اﻟﻤﺤﺪد ﻟﻴﺲ ﺛﺎﺑﺖ ﻳﺘﺤﻜﻢ ﻓﻴﻪ اﻟﻤﺴﺘﺨﺪم وهﺬا اﻷﻓﻀﻞ ﺣﻴﺚ ﻳﻜﻮن اآﺜﺮ ﻣﺮوﻧﻪ ‪.‬وﺳﻨﻮﺿﺢ‬
‫اﻟﺤﺎﻟﺘﻴﻦ ﺳﻨﺒﺪأﺑﺎﻟﻤﺤﺪد وﻣﻦ ﺛﻢ اﻟﻐﻴﺮ ﻣﺤﺪد‪.‬‬
‫اﻟﺴﺆال ‪ )٢‬اﻟﺘﻜﺮار اﻟﻤﺤﺪد( ‪:‬‬
‫ﻣﻄﻠﻮب ﻋﻤﻞ ﺑﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ﻟﻐﺔ اﻟﺴﻲ‪ ++‬ﻳﻘﻮم هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﺑﺤﺴﺎب اﻟﻤﺘﻮﺳﻂ ﻟﺪرﺟﺎت ‪ ٥٠٠‬ﻃﺎﻟﺐ وﻳﺠﺐ‬
‫ﻋﻠﻰ اﻟﺒﺮﻧﺎﻣﺞ ان ﻳﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ادﺧﺎل اﻟﺪرﺟﺎت وﻳﺘﺄآﺪ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ ان اﻟﺪرﺟﻪ اﻟﺘﻲ ﺗﻢ ادﺧﺎﻟﻬﺎ ﺑﻴﻦ‬
‫اﻟﺼﻔﺮ وال‪ ١٠٠‬وﻻ ﺗﺘﺠﺎوز هﺬا اﻟﺤﺪ‪.‬‬
‫;‪using std::cin‬‬
‫{‬
‫;‪Float grade,total=0,avg‬‬
‫;‪int count=1‬‬
‫)‪While(count<=500‬‬
‫{‬
‫;"‪cout<<"please enter the grade‬‬
‫;‪cin>>grade‬‬
‫)‪while(grade<0 || grade>100‬‬
‫{‬
‫;‪Cout<<"sorry you enter invalid grade, enter grade 0-100‬‬

‫;‪Cin>>grade‬‬
‫‪} //second while‬‬
‫;‪total+=grade‬‬
‫;‪count++‬‬
‫‪}//first while‬‬
‫;‪avg=total/500‬‬
‫;‪Cout<<"the avg is "<<avg‬‬
‫اﻟﺸﺮح‪:‬‬
‫ﻧﻼﺣﻆ ﻓﻲ هﺬا اﻟﺴﺆال اﻟﻌﺪد ﻣﺤﺪد ل‪ ٥٠٠‬ﻃﺎﻟﺐ اي ان اﻟﺘﻜﺮار ﺳﻴﻜﻮن ‪ ٥٠٠‬ﻣﺮة ﺳﻨﻘﻮم ﺑﺸﺮح اﻻﺟﺰاء اﻟﺘﻲ‬
‫ﺗﺘﻌﻠﻖ ﺑﺪرﺳﻨﺎ اﻟﻴﻮم واﻟﺒﻘﻴﺔ ﺷﺮﺟﻨﺎهﻢ ﻓﻲ دروس ﺳﺎﺑﻘﻪ‪.‬‬
‫ﻻﺣﻆ ﻓﻲ اﻟﺒﺪاﻳﺔ ﺣﺠﺰﻧﺎ ﺧﺎﻧﺔ ﻟﻤﺘﻐﻴﺮ اﺳﻤﻴﻨﺎﻩ ال ‪ count‬ﻟﻚ ﻳﺴﻴﺮ ﻟﻨﺎ اﻟﻌﺪ ﻓﻔﻲ اﻟﺒﺪاﻳﻪ آﺎﻧﺖ ﻗﻴﻤﺘﻪ واﺣﺪ ﻓﻤﺮ ﻋﻠﻰ‬
‫ال ‪ while‬ﺗﺄآﺪ ﻣﻦ ﺗﺤﻘﻖ اﻟﺸﺮط واﻟﺸﺮط هﻮ ان ﻗﻴﻤﺔ ال ‪ count‬ﻻ ﺗﺰﻳﺪ ﻋﻦ ‪ ٥٠٠‬ﻷﻧﻨﺎ ﻧﺮﻳﺪ اﻟﺘﻜﺮار ‪٥٠٠‬‬
‫ﻣﺮﻩ ﻓﻘﻂ‪,‬ﺑﻌﺪهﺎ ﻳﻄﻠﺐ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ان ﻳﺪﺧﻞ ﻟﻪ اﻟﺪرﺟﻪ وﻣﻦ ﺛﻢ ﻳﻨﺘﻘﻞ اﻟﻰ ال ‪ while‬اﻟﺪاﺧﻠﻴﻪ اﻟﺘﻲ‬
‫ﻳﻘﻮم ﺑﺎﻟﺪﺧﻮل ﻟﻬﺎ اذا ﺗﺤﻘﻖ ﺷﺮﻃﻬﺎ وهﻮ ان ﺗﻜﻮن اﻟﺪرﺟﻪ اﻟﺘﻲ ادﺧﻠﻬﺎ اﻟﻤﺴﺘﺨﺪم اآﺒﺮ ﻣﻦ ﻣﺌﻪ او اﺻﻐﺮ ﻣﻦ‬
‫ﺻﻔﺮ ‪,‬ﻃﺒﻌﺎ اذا ﺗﺤﻘﻖ هﺬا اﻟﺸﺮط هﺬا ﻳﻌﻨﻲ ان اﻟﻤﺴﺘﺨﺪم اﺧﻞ درﺟﻪ ﺧﺎﻃﺌﻪ ﻓﻴﻄﻠﺐ ﻣﻨﻪ اﻟﺒﺮﻧﺎﻣﺞ اﻋﺎدة ادﺧﺎل‬
‫اﻟﺪرﺟﻪ آﻤﺎ ﺗﺮون داﺧﻞ ال ‪ while‬اﻟﺪاﺧﻠﻴﺔ وﻻ ﻳﻨﺘﻘﻞ ﺧﺎرج ال ‪ while‬اﻟﺪاﺧﻠﻴﺔ اﻻ اذا ادﺧﻞ درﺟﻪ ﺻﺤﻴﺤﻪ هﻨﺎ‬
‫ﻧﻀﻤﻦ ان ﺟﻤﻴﻊ اﻟﺪرﺟﺎت ﺻﺤﻴﺤﻪ ‪,‬ﻓﺄذا ادﺧﻞ اﻟﻤﺴﺘﺨﺪم درﺟﻪ ﻓﻲ ﺣﺪود ‪ ١٠٠-٠‬هﻨﺎ ﻳﻨﺘﻘﻞ اﻟﻤﺘﺮﺟﻢ اﻟﻰ ﺟﻤﻊ‬
‫اﻟﺪرﺟﻪ ﻟﻠﺤﺼﻮل ﻋﻠﻰ اﻟﻤﺠﻤﻮع وﻗﺪ ﺷﺮﺣﻨﺎ هﺬا ﺑﺎﻟﺘﻔﺼﻴﻞ ﻓﻲ درس ﺳﺎﺑﻖ وﻣﻦ ﺛﻢ ﻳﺰﻳﺪ ﻗﻴﻤﺔ ال ‪ count‬ﺑﻤﻘﺪار‬
‫واﺣﺪ‪.‬‬
‫رﺑﻤﺎ ﻳﺘﺒﺎدر اﻟﻰ ذهﻨﻜﻢ ﻣﺎ هﺬا ;‪ total+=grade‬ﻃﺒﻌﺎ هﺬا ﻳﺴﺎوي ‪ total=total+grade‬وﻟﻜﻦ اﺧﺘﺼﺎرا‬
‫آﺘﺒﻨﺎهﺎ ﺑﺎﻟﻄﺮﻳﻘﺔ اﻟﺴﺎﺑﻘﻪ واﻳﻀﺎ ;‪ count++‬ﺗﻌﻨﻲ ;‪ count =count+1‬وﻟﻜﻦ اﺧﺘﺼﺮﻧﺎهﺎ ﺑﺎﻟﻄﺮﻳﻖ اﻟﺴﺎﺑﻘﺔ ‪.‬‬
‫دﻋﻮﻧﺎ ﻧﺘﺪرب ﻋﻠﻰ هﺬﻩ اﻻﺧﺘﺼﺎرات‪:‬‬
‫;‪ count--‬ﺗﻌﻨﻲ ;‪count =count-1‬‬

‫‪ Sum*=grade‬ﺗﻌﻨﻲ ;‪sum=sum*grade‬‬
‫أرﺟﻮ ان ﺗﻜﻮن ﻗﺪ وﺿﺤﺖ اﻟﻔﻜﺮﻩ‪.........‬ﻧﻌﻮد اﻟﻰ ﺑﺮﻧﺎﻣﺠﻨﺎ‪.‬‬
‫ﺑﻌﺪ ان ﻳﺠﻤﻊ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺪرﺟﻪ ﻓﻲ ال‪ total‬وﻳﺰﻳﺪ ﻗﻴﻤﺔ ال ‪ count‬ﺑﻤﻘﺪار واﺣﺪ ﻳﻌﻴﺪ هﺬﻩ اﻟﺨﻄﻮات اﻟﻰ ان‬
‫ﻳﺼﺒﺢ ﻣﻘﺎر ال ‪ count=500‬ﻋﻨﺪهﺎ ﻳﺨﺮج ﻣﻦ ال‪ while‬وﻳﺬهﺐ ﻟﻴﻘﻮم ﺑﻘﺴﻢ اﻟﻤﺠﻤﻮع ﻟﻠﺪرﺟﺎت ﻋﻠﻰ ‪٥٠٠‬‬
‫ﻟﻠﺤﺼﻮل ﻋﻠﻰ اﻟﻤﺘﻮﺳﻂ وﻣﻦ ﺛﻢ ﻳﻘﻮم ﺑﻄﺒﺎﻋﺘﻪ ‪...‬‬
‫ﻻﺣﻆ ﺟﻌﻠﻨﺎ اﻟﻌﻤﻠﻴﻪ اﻟﺤﺴﺎﺑﻴﺔ ﻷﻳﺠﺎد اﻟﻤﺘﻮﺳﻂ ﺧﺎرج ال ‪ while‬ﻷﻧﻨﺎ ﻧﺮﻳﺪ اﻟﻤﺠﻤﻮع ﻟﻠﺪرﺟﺎت واذا وﺿﻌﻨﺎ‬
‫اﻟﻌﻤﻠﻴﺔ ﻷﻳﺠﺎد اﻟﻤﺘﻮﺳﻂ ;‪ avg=total/500‬ووﺿﻌﻨﺎ اﻳﻀﺎ ;‪cout<<"the average is "<<avg‬‬
‫هﻨﺎ ﺳﻴﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺄﻳﺠﺎد اﻟﻤﺘﻮﺳﻂ وﻃﺒﺎﻋﺘﻪ ﻓﻲ آﻞ ﻣﺮة ﻳﺪﺧﻞ ﻓﻴﻬﺎ ﻟﻞ ‪ while‬ﻳﻌﻨﻲ ﺧﻤﺴﻤﺎﺋﺔ ﻣﺮة وﻃﺒﻌﺎ هﺬا‬
‫ﻻ ﻳﻌﻄﻴﻨﺎ اﻟﻤﻄﻠﻮب ﻟﺬﻟﻚ وﺿﻌﻨﺎﻩ ﺑﺎﻟﺨﺎرج ﻟﻚ ﻋﻨﺪﻣﺎ ﻳﻨﺘﻬﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ اﻟﺤﺼﻮل ﻋﻠﻰ اﻟﻤﺠﻤﻮع ﻳﻘﻮم ﺑﺄﻳﺠﺎد‬
‫اﻟﻤﺘﻮﺳﻂ وﻃﺒﺎﻋﺘﻪ ‪....‬وهﻨﺎ ﺳﻴﻄﺒﻊ ﻣﺮﻩ واﺣﺪﻩ‪.‬‬
‫اﺗﻤﻨﻰ ان ﺗﻜﻮﻧﻮا ﻗﺪ ﻓﻬﻤﺘﻢ آﻴﻒ ﻳﻜﻮن اﻟﺘﻜﺮار ﻣﺤﺪد وهﻮ ﻳﺘﻤﺜﻞ ﻓﻲ ﺗﺤﺪﻳﺪ ﻗﻴﻤﺔ ﻟﻠﺘﻜﺮار وﻓﻲ ﻣﺜﺎﻟﻨﺎ هﺬا آﺎﻧﺖ‬
‫‪ ٥٠٠‬وﺟﻌﻠﻨﺎ ال ‪ count‬آﻤﺆﺷﺮ ﻳﻌﺪ ﻟﻨﺎ ‪ ٥٠٠‬ﻣﺮة‪.‬‬
‫ﻣﻄﻠﻮب ﻋﻤﻞ ﺑﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ﻟﻐﺔ اﻟﺴﻲ‪ ++‬ﻳﻘﻮم هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﺑﺤﺴﺎب اﻟﻤﺘﻮﺳﻂ ﻟﺪرﺟﺎت ﻋﺪد ﻏﻴﺮ ﻣﺤﺪد ﻣﻦ‬
‫اﻟﻄﻼب ﻳﺘﺤﻜﻢ ﻓﻲ هﺬا اﻟﻌﺪد اﻟﻤﺴﺘﺨﺪم وﻳﺠﺐ ﻋﻠﻰ اﻟﺒﺮﻧﺎﻣﺞ ان ﻳﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ادﺧﺎل اﻟﺪرﺟﺎت وﻳﺘﺄآﺪ‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ ان اﻟﺪرﺟﻪ اﻟﺘﻲ ﺗﻢ ادﺧﺎﻟﻬﺎ ﺑﻴﻦ اﻟﺼﻔﺮ وال‪ ١٠٠‬وﻻ ﺗﺘﺠﺎوز هﺬا اﻟﺤﺪ‪.‬‬
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
int main()
{
Float grade,total=0,avg;
int count=0;
cout<<"please enter the student grade(enter -1 to end)";

cin>>grade;
while(grade!=-1)
{
while(grade<0 || grade>100)
{
Cout<<"sorry you enter invalid grade, enter grade 0-100;

Cin>>grade;
} //second while
total+=grade;
count++;
cout<<"please enter the student grade(enter -1 to end)";

cin>>grade;
}//first while
Arg=total/count;
Cout<<"the avg is "<<avg;
} // end function main
:‫اﻟﺸﺮح‬
‫ﻧﻼﺣﻆ ﻓﻲ هﺬا اﻟﺴﺆال اﻟﺘﻜﺮار ﻏﻴﺮ ﻣﺤﺪد اي ﻳﺪﺧﻞ اﻟﻤﺴﺘﺨﺪم درﺟﺎت اﻟﻰ ان ﻳﻜﺘﻔﻲ وﻳﻄﻠﺐ اﻧﻬﺎء‬
...‫اﻟﺒﺮﻧﺎﻣﺞ‬
‫ ﻷﻧﻬﺎء‬١- ‫ﻓﻲ اﻟﺒﺪاﻳﺔ ﺳﻴﻄﻠﺐ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ادﺧﺎل اول درﺟﺔ أو‬,‫ﺗﺎﺑﻊ ﻣﻌﻲ اﻟﺒﺮﻧﺎﻣﺞ‬
‫أي‬, ١- ‫اﻟﺒﺮﻧﺎﻣﺞ هﻨﺎ ﺟﻌﻠﻨﺎ اﻷﺷﺎرة اﻟﺘﻲ ﻧﻌﺮف اذا اآﺘﻔﻰ اﻟﻤﺴﺘﺨﺪم ﻣﻦ أدﺧﺎل اﻟﺪرﺟﺎت ام ﻻ هﻲ‬
‫ وﺳﻴﻨﺘﻬﻲ اﻟﺒﺮﻧﺎﻣﺞ‬١- ‫ﻋﻨﺪﻣﺎ ﻳﻨﺘﻬﻲ ﻣﻦ ادال اﻟﺪرﺟﺎت وﺗﻈﻬﺮ ﻟﻪ رﺳﺎﻟﻪ ادﺧﺎل اﻟﺪرﺟﻪ ﻳﺪﺧﻞ‬
.‫وﻳﻌﻄﻴﻪ اﻟﻤﺘﻮﺳﻂ‬
‫وأﺧﺘﺮﻧﺎ ‪ ١-‬ﻷن ﻻ ﻳﻤﻜﻦ ان ﺗﻮﺟﺪ درﺟﻪ ﺑﺎل ‪ ١-‬وﺗﺴﺘﻄﻴﻊ اﺧﺘﻴﺎر اي ﺷﻲء ﻣﺎﻋﺪا ان ﻳﻜﻮن ﻣﻦ‬
‫ﺿﻤﻦ اﻟﺪرﺟﺎت ‪.١٠٠-٠‬‬
‫ﺑﻌﺪ ان ﻳﺪﺧﻞ اﻟﻤﺴﺘﺨﺪم درﺟﺔ اﻟﻄﺎﻟﺐ ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ال ‪ while‬ﺑﺎﻟﺘﺄآﺪ ﻣﻦ ان اﻟﺪرﺟﺔ ﻟﻴﺴﺖ‬
‫‪ ١-‬واذا آﺎﻧﺖ ‪ ١-‬ﻳﻘﻒ اﻟﺒﺮﻧﺎﻣﺞ وﻳﻌﻄﻲ اﻟﻤﺘﻮﺳﻂ ‪.‬اذا ﻟﻢ ﺗﻜﻦ ‪ ١-‬ﻳﺪﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ داﺧﻞ ال ‪while‬‬
‫اﻷوﻟﻰ وﻣﻦ ﺛﻢ ﻳﺪﺧﻞ داﺧﻞ ال ‪ while‬اﻟﺜﺎﻧﻴﺔ اﻟﺘﻲ ﺗﺘﺄآﺪ ﻣﻦ ان اﻟﺪرﺟﻪ ﻣﻦ ‪ ١٠٠-٠‬وان ادﺧﻞ‬
‫اﻟﻤﺴﺘﺨﺪم درﺟﻪ ﺧﺎرج هﺬا اﻟﻨﻄﺎق ﻳﺒﻘﻰ اﻟﺒﺮﻧﺎﻣﺞ داﺧﻞ ال ‪ while‬وﻳﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ادﺧﺎل‬
‫درﺟﻪ ﺻﺤﻴﺤﻪ وﻣﻦ ﺛﻢ ﺑﻌﺪ ادﺧﺎل درﺟﺔ ﺻﺤﻴﺤﻪ ﻳﻨﺘﻘﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻰ ﺟﻤﻊ اﻟﺪرﺟﻪ ﻣﻊ اﻟﻤﺠﻤﻮع‬
‫وزﻳﺎدة ال ‪ count‬ﺑﻤﻘﺪار واﺣﺪ‪ .‬ﻗﺪ ﺗﺴﺄل ﻧﻔﺴﻚ هﻨﺎ ﻻ ﻧﺤﺘﺎج ‪ count‬ﻟﺘﺴﻴﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ وﺗﺤﺪﻳﺪ‬
‫ﻗﻴﻤﺔ اﻟﺘﻜﺮار ﻟﻦ اﻟﻌﺪد ﻏﻴﺮ ﻣﺤﺪد واﻟﻤﺴﺘﺨﺪم هﻮ اﻟﺬي ﻳﺤﺪد اﻟﻌﺪد ‪.‬ﻟﻜﻨﻨﺎ وﺿﻌﻨﺎ ال ‪ count‬هﻨﺎ‬
‫ﻷﻧﻨﺎ ﻧﺮﻳﺪ ﻣﻌﺮﻓﺔ آﻢ ﻋﺪد اﻟﺪرﺟﺎت اﻟﺘﻲ ادﺧﻠﺖ ﻷﻧﻨﺎ ﻧﺤﺘﺎج ﻗﻴﻤﺔ ال ‪ count‬ﻟﺤﺴﺎب اﻟﻤﺘﻮﺳﻂ ﻷن‬
‫اﻟﻤﺘﻮﺳﻂ ﻋﺒﺎرﻩ ﻋﻦ ﻣﺠﻤﻮع اﻟﺪرﺟﺎت ﻋﻠﻰ ﻋﺪدهﺎ‪.‬ﻣﺠﻤﻮع اﻟﺪرﺟﺎت ﻧﺤﺼﻞ ﻋﻠﻴﻪ ﻣﻦ ال‪total‬‬
‫وﻋﺪدهﺎ ﻣﻦ ال ‪ count‬ﺑﻌﺪهﺎ وﺿﻌﻨﺎ‬
‫;")‪cout<<"please enter the student grade(enter -1 to end‬‬

‫ﺗﺨﻴﻞ ﻟﻮ اﻧﻨﺎ ﻟﻢ ﻧﻀﻊ هﺬﻩ اﻟﺠﻤﻠﻪ اﺧﺮ ال ‪ while‬اﻷوﻟﻰ ﻟﻜﺎن اﻟﺒﺮﻧﺎﻣﺞ ﺑﻌﺪ ان ﻳﻨﺘﻬﻲ ﻣﻦ زﻳﺎدة‬
‫ال ‪ count‬ﺑﻮاﺣﺪ ﻟﺮﺟﻊ ﻟﻞ ‪ while‬اﻷوﻟﻰ وﻃﺒﻌﺎ ﻗﻴﻤﺘﺔ ال ‪grade‬ﺳﺘﺒﻘﻰ ﻗﻴﻤﺔ ال ‪ grade‬اﻷوﻟﻰ‬
‫وﻟﻦ ﺗﺘﻐﻴﺮ وﺳﻴﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﺗﻜﺮار ﻏﻴﺮ ﻣﻨﺘﻬﻲ ﻣﻤﺎ ﻳﺴﺒﺐ ﻣﺸﻜﻠﺔ آﺒﻴﺮة وﻟﻦ ﻳﻌﻄﻴﻨﺎ اﻟﻤﺘﻮﺳﻂ‬
‫اﺑﺪا‪..‬ﻷﻧﻨﺎ ﻟﻢ ﻧﻌﻄﻲ اﻟﻤﺴﺘﺨﺪم ﻣﺠﺎل ﻷدﺧﺎل درﺟﺔ أﺧﺮى‪.‬‬
‫ﻟﻜﻦ ﻣﻊ وﺿﻊ هﺬﻳﻦ اﻟﺴﻄﺮﻳﻦ ﻳﺴﻄﻠﺐ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ادﺧﺎل درﺟﺔ ﺟﺪﻳﺪﻩ وﻳﺮﺟﻊ‬
‫ﻟﻞ‪ while‬اﻷوﻟﻰ وﻳﺘﺄآﺪ ﻣﺎ اذا آﺎن اﻟﺸﺮط ﺻﺤﻴﺢ وان اﻟﺪرﺟﻪ ﻻ ﺗﺴﺎوي ‪ ١-‬واذا آﺎﻧﺖ ‪١-‬‬
‫ﻳﺘﻮﻗﻒ وﻳﻌﻄﻲ اﻟﻤﺘﻮﺳﻂ‪.‬اﻣﺎ اذا آﺎﻧﺖ ﻻ ﺗﺴﺎوي ‪ ١-‬دﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻰ ال ‪while‬اﻟﺜﺎﻧﻴﺔ وﺗﺄآﺪ ﻣﻦ‬
‫ان اﻟﺪرﺟﻪ ﻓﻲ اﻟﻨﻄﺎق ‪ ١٠٠-٠‬وﺑﻌﺪهﺎ ﺟﻤﻊ اﻟﺪرﺟﻪ اﻟﺠﺪﻳﺪﻩ ﻣﻊ اﻟﻤﺠﻤﻮع اﻟﺴﺎﺑﻖ وزاد ﻗﻴﻤﺔ‬
‫ال ‪ count‬ﺑﻮاﺣﺪ وﻳﻄﻠﺐ اﻟﺒﺮﻧﺎﻣﺞ ﻣﺮة اﺧﺮى ﻣﻦ اﻟﻤﺴﺘﺨﺪم ادﺧﺎل درﺟﺔ ﺟﺪﻳﺪﻩ ﻓﺄذا آﺎﻧﺖ ‪١-‬‬
‫ﺗﻮﻗﻒ واﻋﻄﻰ اﻟﻤﺘﻮﺳﻂ واذا آﺎﻧﺖ ﻏﻴﺮ ذﻟﻚ واﺻﻞ ﻣﺎ ﻗﻠﻨﺎﻩ ﺳﺎﺑﻘﺎ وهﻜﺬا ﻳﺴﺘﻤﺮ اﻟﺒﺮﻧﺎﻣﺞ ﺣﺘﻰ‬
‫ﻳﺪﺧﻞ اﻟﻤﺴﺘﺨﺪم ‪. ١-‬ﻓﻘﻂ ﻋﻨﺪهﺎ ﻳﺘﻮﻗﻒ وﻳﻌﻄﻲ اﻟﻤﺘﻮﺳﻂ واﻻ ﻳﺒﻘﻰ ﻣﺴﺘﻤﺮ ﻓﻲ أﺧﺬ اﻟﺪرﺟﺎت‬
‫وﺟﻤﻌﻬﺎ ‪.‬‬
‫ﺑﻌﺪ ادﺧﺎل ‪ ١-‬ﻳﺨﺮج اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ ال ‪ while‬وﻳﻘﺴﻢ اﻟﻤﺠﻤﻮع ﻟﻠﺪرﺟﺎت ﻋﻠﻰ ﻋﺪدهﺎ اﻟﺬي ﻳﺘﻤﺜﻞ‬
‫ﻓﻲ ال ‪ count‬وﻳﻌﻄﻲ اﻟﻤﺘﻮﺳﻂ وﻳﻄﺒﻌﻪ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪.‬‬
‫اﻟﻔﺮق ﺑﻴﻦ اﻟﻤﺜﺎل اﻷول واﻟﺜﺎﻧﻲ اي ﺑﻴﻦ اﻟﺘﻜﺮار اﻟﻤﺤﺪد واﻟﻐﻴﺮ ﻣﺤﺪد ان ﻓﻲ اﻷول ﻗﻴﻤﺔ اﻟﺘﻜﺮار‬
‫ﺗﺤﺪد ﻓﻲ ال ‪ while‬اﻷوﻟﻰ أﻣﺎ ﻓﻲ اﻟﺜﺎﻧﻲ اﻟﺸﺮط اﻟﺬي ﻳﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ ﻳﻮﺿﻊ ﻓﻲ ال ‪while‬‬
‫اﻷوﻟﻰ وﻃﺒﻌﺎ ﻓﻲ اﻟﺘﻜﺮار اﻟﻐﻴﺮ ﻣﺤﺪد ﻻ ﺗﻨﺴﻰ ﻣﻦ وﺿﺢ ‪ cout‬ﻟﻚ ﺗﺨﺒﺮ اﻟﻤﺴﺘﺨﺪم ﺑﺄدﺧﺎل ﻗﻴﻤﺔ‬
‫ﺟﺪﻳﺪﻩ و‪ cin‬ﻟﻚ ﺗﺤﻔﻆ هﺬﻩ اﻟﻘﻴﻤﺔ ﻓﻲ اﻟﻤﺘﻐﻴﺮ اﻟﻤﺨﺼﺺ ﻟﻬﺎ آﻤﺎ ﻓﻌﻠﻨﺎ ﻓﻲ هﺬﻳﻦ اﻟﺴﻄﺮﻳﻦ‬
‫;")‪cout<<"please enter the student grade(enter -1 to end‬‬
....... ‫أرﺟﻮ ان ﻳﻜﻮن اﻟﻔﺮق واﺿﺢ ﻟﺪﻳﻜﻢ‬
‫اﻵن ﻧﻨﺘﻘﻞ ﳌﺜﺎل ﻗﻤﻨﺎ ﲝﻠﻪ ﺳﺎﺑﻘﺎ ﻟﻜﻦ ﺑﺪون اﺳﺘﺨﺪام اﻟﺘﻜﺮار وآﺎن ﻷدﺧﺎل رﻗﻢ‬
‫واﺣﺪ ﻓﻘﻂ ﻃﺒﻌﺎ آﺎن ﺑﺮﻧﺎﻣﺞ ﻏﲑ ﻣﺮن ﻟﻸﻧﻪ ﺑﻌﺪ ان ﻳﻌﻄﻴﻚ ﻧﺘﻴﺠﺔ ﻋﺪد واﺣﺪ‬
‫ادﺧﻠﺘﻪ ﻳﻨﺘﻬﻲ ﻋﻤﻠﻪ اﻧﻈﺮوا ﻟﻠﱪﻧﺎﻣﺞ ﺑﻌﺪ ﺗﻄﻮﻳﺮﻩ ﺑﺄﺳﺘﺨﺪام اﻟﺘﻜﺮار وﻗﺎرﻧﻮا‬
......‫ﺑﻴﻨﻬﻢ واﻧﻈﺮوا اﻟﻔﺮق‬
Question1: write a program that reads integers and determine whether it is odd or
even. (Hint: use the modulus operator .an even number is a multiple of two. any
multiple of two leaves a reminder of zero when divide by 2).
Make sure to make this program for non fix number.
‫ ﻳﻘﻮم ﺑﺄدﺧﺎل اﻋﺪاد ﺻﺤﻴﺤﻪ وﻓﻲ آﻞ ﻣﺮﻩ ﻳﺪﺧﻞ اﻟﻤﺴﺘﺨﺪم ﻋﺪد‬C++‫ ﻗﻢ ﺑﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﺑﺄﺳﺘﺨﺪام ﻟﻐﺔ ال‬:٣ ‫اﻟﺴﺆال‬
‫ ﻟﺘﺴﺎﻋﺪك ﻓﻲ اﻟﺤﻞ واي ﻋﺪد زوﺟﻲ‬% ‫ اﺳﺘﺨﺪم‬:‫ﻳﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﺤﺪﻳﺪ اذا آﺎن اﻟﻌﺪد ﻓﺮدي او زوﺟﻲ )ﻣﻼﺣﻈﻪ‬
(‫ ﻳﻜﻮن اﻟﺒﺎﻗﻲ داﺋﻤﺎ ﺻﻔﺮا‬٢ ‫ﻳﻘﺴﻢ ﻋﻠﻰ‬
........ ‫ﺑﻬﺬﻩ اﻟﻤﻼﺣﻈﻪ اﺻﺒﺤﺖ اﻟﻔﻜﺮة ﺟﺎهﺰة ﻟﻜﻢ‬
#include <iostream.h >
int main ( )
{
char flag=y
int number ;
while(flag!=n)
{
cout << " please enter the number : " ;
cin >>number ;
if (number % 2 == 0 )
cout <<" \n The number is even " ;
else (number % 2 == 1 )
cout << " \n The number is odd " ;
cout<<"do u want to check another number,y=yes,n=no"<<end1;

cin>>flag;
while(flag!=y && flag !=n)

{
cout<<"sorry rong command";
cout<<"do u want to check another number,y=yes,n=no"<<end1;
cin>>flag;
}
‫; ‪return 0‬‬
‫}‬
‫ﻧﺼﻞ هﻨﺎ ﻟﻨﻬﺎﻳﺔ اﻟﺪرس اﻟﺴﺎﺑﻊ واﻧﻬﺎء دراﺳﺔ ال ‪while‬ارﺟﻮ ان ﺗﻜﻮﻧﻮا ﻗﺪ ﻓﻬﻤﺘﻮهﺎ ﺟﻴﺪا ﻓﻬﻲ ﺟﻤﻠﺔ ﻣﻔﻴﺪﻩ ﺟﺪا‬
‫وﺳﻨﻨﺘﻘﻞ ﻓﻲ اﻟﺪرس اﻟﻘﺎدم ﺑﺄذن اﷲ اﻟﻰ ال‪.. for loop‬‬
‫اﻟﻰ ذﻟﻚ اﻟﺤﻴﻦ دﻣﺘﻢ ﺑﺨﻴﺮ وﻋﺎﻓﻴﻪ واﻟﺴﻼم ﻋﻠﻴﻜﻢ ورﺣﻤﺔ اﷲ وﺑﺮآﺎﺗﻪ‪.‬‬

‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﻴﻢ‬
‫اﻟﺴﻼم ﻋﻠﻴﻜﻢ ورﺣﻤﺔ اﷲ وﺑﺮآﺎﺗﻪ‪.......‬‬
‫أﺟﻤﻞ ﺗﺤﻴﺔ ﻟﻜﻢ اﺧﻮﺗﻲ واﺧﻮاﺗﻲ ﻓﻲ اﷲ ‪......‬‬
‫ﻧﺒﺪأ اﻟﻴﻮم ان ﺷﺎء اﷲ ﺑﺸﺮح ﺟﻤﻠﻪ ﻣﻦ اروع واﺷﻬﺮ ﺟﻤﻞ اﻟﺘﻜﺮار واآﺜﺮهﻢ اﺳﺘﺨﺪاﻣﺎ وهﻲ ال‪.. for loop‬هﻲ‬
‫ﺟﻤﻠﻪ ﺗﺄﺧﺬ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪..‬‬
‫)‪for ( initial value ; condition ; increment or decrement‬‬
‫}‪{ your statment‬‬
‫ﻻﺣﻆ ﻓﻲ اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻞ ‪ for‬ﻳﺘﺨﻠﻞ آﻞ ﺟﺰء ﻋﻼﻣﺔ ; ﻳﺠﺐ ان ﺗﻀﻌﻬﺎ آﻤﺎ وﺿﺤﺘﻬﺎ ﺑﺎﻟﺸﻜﻞ وداﺧﻞ اﻟﻘﻮﺳﻴﻦ‬
‫ﺗﻀﻊ اﻻﺳﻄﺮ اﻟﺘﻲ ﺗﺮﻳﺪ ان ﻳﻨﻔﺬهﺎ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺪﺧﻞ ﻓﻴﻬﺎ اﻟﺘﻜﺮار‪.‬‬
‫‪: (initial value) -١‬هﻨﺎ ﻧﻜﺘﺐ ﻧﻘﻄﺔ اﻟﺒﺪاﻳﺔ اﻟﺘﻲ ﺳﻴﻨﻄﻠﻖ ﻣﻨﻬﺎ اﻟﻌﺪاد ﻓﻲ اﻟﺠﻤﻠﻪ ‪ for‬ﻻﺣﻆ ﻓﻲ هﺬا اﻟﺠﺰء‬
‫ﺗﺴﺘﻄﻴﻊ ان ﺗﻌﺮف اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﺳﺘﺴﺘﺨﺪﻣﻪ آﻌﺪاد وﺗﺴﺘﻄﻴﻊ اﻳﻀﺎ اﻋﻄﺎﺋﻪ ﻗﻴﻤﺔ اﺑﺘﺪاﺋﻴﻪ ﻣﺜﺎل‪int i=0 :‬‬
‫ﻻﺣﻆ ﻓﻲ هﺬا اﻟﻤﺜﺎل ﻋﺮﻓﻨﺎ اﻟﻤﺘﻐﻴﺮ ‪ i‬ﺑﺎﻧﻪ ﻋﺪد ﺻﺤﻴﺢ ‪ int‬واﻳﻀﺎ اﻋﻄﻴﻨﺎﻩ ﻗﻴﻤﻪ اﺑﺘﺪاﺋﻴﻪ وهﻲ ‪.٠‬‬
‫‪ : (condition) -٢‬هﻨﺎ ﺗﻜﺘﺐ اﻟﻘﺎﻋﺪﻩ اﻟﺘﻲ ﻳﺘﻮﻗﻒ ﻋﻨﺪهﺎ اﻟﻌﺪ ﻋﻨﺪ اﻟﻮﺻﻮل ﻟﻬﺎ ﻣﺜﺎل‪ i<=10 :‬وهﻨﺎ ﻳﺘﻮﻗﻒ‬
‫اﻟﻌﺪ ﻋﻨﺪﻣﺎ ﻳﺼﻞ اﻟﻰ ﻋﺪد اآﺒﺮ ﻣﻦ ‪ ١٠‬ﻳﻌﻨﻲ ﻳﺴﺘﻤﺮ ﻓﻲ اﻟﻌﺪ ﻃﺎﻟﻤﺎ ال ‪ i‬اﻗﻞ ﻣﻦ او ﻳﺴﺎوي اﻟﻌﺸﺮﻩ‪.‬‬
‫‪ : (increment or decrement) -٣‬هﻨﺎ ﻧﻜﺘﺐ آﻴﻒ ﻧﺮﻳﺪ ان ﻳﺴﻴﺮ اﻟﻌﺪ ﺗﺼﺎﻋﺪي او ﺗﻨﺎزﻟﻲ اي‬
‫‪ increment or decrement‬ﻣﺜﺎل ‪ i++‬ﻳﺰﻳﺪ ﻗﻴﻤﺔ ال ‪ i‬آﻞ ﻣﺮﻩ ﺑﻤﻘﺪار واﺣﺪ و ‪ i--‬ﻳﻘﻠﻞ ﻗﻴﻤﺔ ال ‪i‬‬
‫ﺑﻤﻘﺪار واﺣﺪ‪.‬‬
‫ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﺳﺘﺘﻀﺢ هﺬﻩ اﻟﺠﻤﻠﻪ اآﺜﺮ ‪:‬‬

‫وﻓﻲ هﺬا اﻟﻤﺜﺎل ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﻄﺎﻋﺔ اﻻﻋﺪاد ﻣﻦ ‪ ١‬اﻟﻰ ‪ ١٠‬ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪١‬‬
‫‪٢‬‬
‫‪٣‬‬
‫‪٤‬‬
‫‪٥‬‬
‫‪٦‬‬
‫‪٧‬‬
‫‪٨‬‬
‫‪٩‬‬
‫‪١٠‬‬
‫واﻻن ﻧﻨﺘﻘﻞ اﻟﻰ اﻟﺒﺮﻧﺎﻣﺞ<<<<<<‬

‫{‬
‫) ‪for ( int counter = 1; counter <= 10; counter++‬‬
‫;‪cout << counter << endl‬‬
‫}‬
‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬

‫آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ﻻ ﺗﺘﺠﺎوز ﺳﻄﻮر ﻗﻠﻴﻠﺔ ﻣﻘﺎرﻧﺔ ﺑﻜﺘﺎﺑﺘﻪ ﺑﺎﺳﺘﺨﺪام ال ‪ while‬واﻟﺒﺮﻧﺎﻣﺞ ﺑﻜﺎﻣﻠﻪ ﻳﺘﻤﺜﻞ ﻓﻲ اﻟﺴﻄﺮ‬
‫اﻟﺘﺎﻟﻲ‬
‫ﻧﻼﺣﻆ آﻤﺎ ﺷﺮﺣﻨﺎ ﻓﻲ اﻟﺒﺪاﻳﺔ اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﺠﻤﻠﺔ ال ‪ for‬ﺳﻨﺴﺘﺨﺪم ﻟﻠﻌﺪ اﻟﻤﺘﻐﻴﺮ ‪ counter‬وﺳﻨﺠﻌﻞ ﻗﻴﻤﺘﻪ اﻻﻳﺘﺪاﺋﻴﺔ‬
‫واﺣﺪ‪, int counter = 1‬وﺑﻌﺪهﺎ ﺟﻌﻠﻨﺎ اﻟﻘﺎﻋﺪﻩ اﻟﺘﻲ ﻳﺘﻮﻗﻒ ﻋﻨﺪهﺎ هﺬا اﻟﻌﺪ ﻋﻨﺪﻣﺎ ﻳﺘﺠﺎوز اﻟﻌﺪ اﻟﺮﻗﻢ ﻋﺸﺮة‬
‫‪,counter <= 10‬وﻃﺒﻌﺎ ﻧﺰﻳﺪ ﻗﻴﻤﺔ ال‪ counter‬ﺑﻤﻘﺪار واﺣﺪ ﻓﻲ آﻞ ﻣﺮﻩ‪.‬‬
‫ﺗﺎﺑﻊ ﻣﻌﻲ ﺳﻴﺒﺪأ اﻟﻌﺪ وﻗﻴﻤﺔ ال ‪ counter =1‬ﻋﻨﺪهﺎ ﻳﺘﺎآﺪ ﻣﻦ اﻟﻘﺎﻋﺪﻩ وﺳﻴﺠﺪ ان ال ‪ counter<10‬وﺳﻴﺰﻳﺪ ﻗﻴﻤﺔ‬
‫ال‪ counter‬ﺑﻤﻘﺪار واﺣﺪ وﻳﻨﺰل ﻟﻠﺴﻄﺮ ;‪ cout << counter << endl‬وﻳﻄﺒﻊ اﻟﺮﻗﻢ ‪ ١‬ﺛﻢ ﻳﺪﺧﻞ اﻟﺘﻜﺮار ﻣﺮﻩ‬
‫اﺧﺮى وﻳﺘﺄآﺪ ان اﻟﺮﻗﻢ ‪ ٢‬أﻗﻞ ﻣﻦ اﻟﻌﺸﺮﻩ وﻳﺰﻳﺪ ال ‪ counter‬ﺑﻤﻘﺪار واﺣﺪ ﺛﻢ ﻳﻄﺒﻊ ‪ ٢‬وﻳﻮاﺻﻞ اﻟﻰ ان ﻳﺼﻞ‬
‫اﻟﻌﺪداﻟﻰ اﻟﺮﻗﻢ ﻋﺸﺮة ﻳﺘﺎآﺪ ﻣﻦ ان ال ‪ counter‬اﻟﺬي وﺻﻠﺖ ﻗﻴﻤﺘﻪ ﻋﺸﺮة أﻗﻞ ﻣﻦ او ﻳﺴﺎوي ‪ , ١٠‬وﻃﺒﻌﺎ هﻨﺎ‬
‫ﻳﺴﺎوي اﻟﻌﺸﺮة ﻳﺰﻳﺪ ال ‪ counter‬ﺑﻤﻘﺪار واﺣﺪ وﻳﻄﺒﻊ اﻟﻌﺸﺮة وﻳﺨﺮج اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ ال‪for‬ﻷن ال ‪counter‬‬
‫اﺻﺒﺤﺖ ﻗﻴﻤﺘﻪ ﺗﺴﺎوي ‪.١١‬وآﻤﺎ ﺗﻼﺣﻈﻮن ﺑﻜﻞ ﺑﺴﺎﻃﻪ ﻳﻨﺘﻬﻲ اﻟﺒﺮﻧﺎﻣﺞ هﻨﺎ ‪,‬اﺿﻨﻜﻢ ﻻﺣﻈﺘﻢ ﺳﻬﻮﻟﺔ واهﻤﻴﺔ اﺳﺘﺨﺪام‬
‫ال‪.for‬‬
‫ﻧﻨﺘﻘﻞ اﻟﻰ ﻣﺜﺎل ﻋﻤﻠﻲ ﺁﺧﺮ ‪:‬‬
‫اﻟﻤﻄﻠﻮب آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﻤﺘﻮﺳﻂ ل‪ ١٠٠‬ﻃﺎﻟﺐ واﻳﺠﺎد اﻗﻞ درﺟﻪ ﺑﻴﻦ اﻟﻄﻼب واﻋﻠﻰ درﺟﻪ‬
‫وﻃﺒﺎﻋﺘﻬﻢ‪:‬‬
‫;‪{float total=0,max=0,min=100,avg‬‬
‫;‪{ cout << "enter the grade" << endl‬‬
‫;‪total=total+grade‬‬
‫)‪if(grade>max‬‬
‫};‪{ max=grade‬‬
‫)‪If(grade<min‬‬
‫};‪{min=grade‬‬
‫}‬
‫;‪Avg=total/100‬‬
‫;`‪Cout>>"the average is ">>avg>>end‬‬
‫;‪Cout>>"the maximum grade is">>max>>end1‬‬
‫;‪Cout>>"the minimum grade is">>min>>end1‬‬
‫}‬
‫ﻧﺄﺧﺬ ﻣﺜﺎل ﺁﺧﺮ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮم ﺑﺠﻤﻊ اﻻﻋﺪاد اﻟﺰوﺟﻴﺔ ﻣﻦ‪ ٠‬اﻟﻰ ال‪-:١٠٠‬‬
‫{‬
‫;‪int sum = 0‬‬
‫) ‪for ( int number = 2; number <= 100; number += 2‬‬

‫;‪sum += number‬‬
‫;‪cout << "Sum is " << sum << endl‬‬

‫}‬
‫هﻨﺎ ﻧﺼﻞ اﻟﻰ ﻧﻬﺎﻳﺔ درس ال ‪ for‬اﻟﺬي اﺗﻤﻨﻰ ان ﻳﻜﻮن درس ﻣﻔﻴﺪ ﻟﻜﻢ ‪........‬اﺗﺮآﻜﻢ ﺑﺮﻋﺎﻳﺔ اﷲ وﺣﻔﻈﻪ ﺣﺘﻰ‬
‫اﻟﺪرس اﻟﻘﺎدم‪...‬‬
‫اﻟﻰ ذﻟﻚ اﻟﺤﻴﻦ دﻣﺘﻢ ﺑﺨﻴﺮ وﻋﺎﻓﻴﻪ واﻟﺴﻼم ﻋﻠﻴﻜﻢ ورﺣﻤﺔ اﷲ وﺑﺮآﺎﺗﻪ‪.‬‬

‫ﺒﺴﻡ ﺍﷲ ﺍﻟﺭﺤﻤﻥ ﺍﻟﺭﺤﻴﻡ‬
‫ﺍﻟﺤﻤﺩ ﷲ ﺭﺏ ﺍﻟﻌﺎﻟﻤﻴﻥ ﺍﻟﻭﺍﺤﺩ ﺍﻷﺤﺩ ﺍﻟﻔﺭﺩ ﺍﻟﺼﻤﺩ ﺍﻟﺫﻱ ﻟﻡ‬
‫ﻴﻠﺩ ﻭﻟﻡ ﻴﻭﻟﺩ ﻭﺍﻟﺫﻱ ﻋﻠﻡ ﺒﺎﻟﻘﻠﻡ ﻋﻠﻡ ﺍﻹﻨﺴﺎﻥ ﻤﺎ ﻟﻡ ﻴﻌﻠﻡ‬
‫ﻭﻨﺼﻠﻲ ﻭﻨﺴﻠﻡ ﻋﻠﻰ ﺍﻟﻤﺒﻌﻭﺙ ﺭﺤﻤﺔ ﻟﻠﻌﺎﻟﻤﻴﻥ ﻤﺤﻤﺩ ﺍﺒﻥ‬
‫ﻋﺒﺩ ﺍﷲ ﺍﻟﺼﺎﺩﻕ ﺍﻵﻤﻴﻥ ﻭﻋﻠﻰ ﺼﺤﺎﺒﺘﻪ ﺍﻷﺨﻴﺎﺭ ﻭﻤﻥ‬
‫ﺒﻌﺩﺓ ﺁﻟﻲ ﻴﻭﻡ ﺍﻟﺫﻴﻥ ﺁﻤﺎ ﺒﻌﺩ‬
‫ﺘﻌﺩ ﻟﻐﺔ ‪ c++‬ﻤﻥ ﺍﻜﺘﺭ ﺍﻟﻠﻐﺎﺕ ﺍﻨﺘﺸﺎﺭﹰﺍ ﻭﺍﺴﺘﺨﺩﺍﻤ ﹰﺎ‬
‫ﻜﻭﻨﻬﺎ ﻤﻨﺎﺴﺒﺔ ﻭﻤﻔﻀﻠﺔ ﻓﻲ ﻜﺜﻴﺭ ﻤﻥ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻤﻬﻤﺔ ﺇﺫ‬
‫ﻨﺴﺘﻁﻴﻊ ﺃﻥ ﻨﻘﻭل ﺃﻨﻬﺎ ﻭﺴﻁ ﺘﻁﻭﻴﺭ ﺍﻟﺒﺭﻤﺠﻴﺎﺕ ﻭ ﺇﻨﺘﺎﺠﻬﺎ‬
‫ﻭﻫﻲ ﻤﺎ ﺘﺯﺍل ﺘﺤﺘل ﻤﻭﻗﻊ ﺍﻟﺼﺩﺍﺭﺓ ﻤﻘﺎﺭﻨﺔ ﻤﻊ ﻏﻴﺭﻫﺎ ﻤﻥ‬
‫ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺇﺫ ﺘﻌﺘﺒﺭ ﻫﻲ ﻟﻐﺔ ﺇﻻﻡ ﻭﻨﻅﺭﺍ ﻟﻬﺫﻩ ﺍﻷﻫﻤﻴﺔ‬
‫ﻭﻋﺩﻡ ﻭﺠﻭﺩ ﻤﺭﺍﺠﻊ ﻋﺭﺒﻴﺔ ﻜﺎﻓﻴﺔ ﺒﺎﻟﻐﺭﺽ ﻓﻘﺩ ﻗﻤﺕ‬
‫ﺒﺘﺄﻟﻴﻑ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺍﻟﺫﻱ ﻗﺩ ﺤﺎﻭﻟﺕ ﺘﻠﺨﻴﺹ ﺍﻟﻔﻜﺭﺓ‬
‫ﻹﺨﻭﺍﻨﻲ ﺍﻟﻁﻼﺏ ﻭﺍﻟﻤﺤﺒﻴﻥ ﻟﻬﺫﻩ ﺍﻟﻠﻐﺔ ﻤﻥ ﺨﻼل ﺩﺭﺍﺴﻲ‬
‫ﺍﻟﺠﺎﻤﻌﻴﺔ ﻭﻤﻥ ﻤﺤﺒﺘﻲ ﻟﻬﺫﻩ ﺍﻟﻠﻐﺔ ﺭﺍﺠﻴ ﹰﺎ ﻤﻥ ﺍﷲ ﺍﻥ‬
‫ﻴﺴﺘﻔﻴﺩﻭﺍ ﺇﺨﻭﺍﻨﻲ ﺍﻟﻤﺴﻠﻤﻴﻥ ﻓﻲ ﻤﺸﺭﻕ ﺍﻷﺭﺽ ﻭﻤﻐﺭﺒﺔ‬
‫ﻭﺇﻋﻁﺎﺌﻲ ﺩﻋﻭﺓ ﺼﺎﻟﺤﺔ ﻓﻲ ﻅﻬﺭ ﺍﻟﻐﻴﺏ ﻤﻥ ﺇﺨﻭﺍﻨﻲ ﺍﻟﺫﻴﻥ‬
‫ﻗﺭﺌﻭﺍ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺭﺍﺠﻴ ﹰﺎ ﻤﻥ ﺍﷲ ﺇﻥ ﻴﻜﻭﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻴﻔﻲ‬
‫ﺒﺎﻟﻐﺭﺽ ﻭﺍﻥ ﻴﻨﺎل ﺇﻋﺠﺎﺒﻜﻡ ﻭﻨﺄﺴﻑ ﻋﻥ ﺃﻱ ﺨﻁﺄ ﺍﻭ‬
‫ﺘﻘﺼﻴﺭ ﻓﺎﻟﻜﻤﺎل ﷲ ﻋﺯ ﻭﺠل ﻭﺼﻠﻰ ﺍﷲ ﻋﻠﻰ ﻤﺤﻤﺩ ﻭﻋﻠﻰ‬
‫ﺁﻟﺔ ﻭﺼﺤﺒﺔ ﺃﺠﻤﻌﻴﻥ ﻭﺃﺨﺭ ﺩﻋﻭﺍﻨﺎ ﺇﻥ ﺍﻟﺤﻤﺩ ﷲ ﺭﺏ‬
‫ﺍﻟﻌﺎﻟﻤﻴﻥ ﻭﻻ ﻋﺩﻭﺍﻥ ﺇﻟﻰ ﻋﻠﻰ ﺍﻟﻅﺎﻟﻤﻴﻥ ﻭﺍﻟﻤﺸﺭﻜﻴﻥ ﻤﻥ‬
‫ﺍﻟﻴﻭﻡ ﺇﻟﻰ ﻴﻭﻡ ﺍﻟﺫﻴﻥ ‪.‬‬
‫ﺍﻹﻫﺪﺍﺀ‬
‫ﺇﻟﻰ ﻣﻦ ﺃﻋﻄﺘﻨﻲ ﺍﻟﺮﻋﺎﻳﺔ ﺩﺍﺋﻤﹸﺎ‬
‫ﺇﻟﻰ ﻣﻦ ﻛﺎﻧﺖ ﺑﺠﻮﺍﺭﻱ ﺩﺍﺋﻤﹸﺎ‬
‫ﺇﻟﻰ ﻣﻦ ﺷﺠﻌﺘﻨﻲ ﺩﺍﺋﻤﺎﹰ‬
‫ﺇﻟﻰ ﺍﻟﺒﺬﺭﺓ ﺍﻟﺘﻲ ﻃﺎﻟﻤﺎ ﺭﻭﺗﻨﻲ ﻷﺻﺒﺢ ﺛﻤﺮﺓ‬
‫ﺃﻣﻲ ﺍﻟﺤﺒﻴﺒﺔ‬
‫ﺇﻟﻰ ﻛﻞ ﻣﺴﻠﻢ ﻭﻣﺴﻠﻤﺔ‬
‫ﺇﻟﻰ ﺍﺭﺽ ﺍﻟﻴﻤﻦ ﺍﻟﺤﺒﻴﺒﺔ‬
‫ﺗﻘﺒﻠﻮﺍ ﻫﺪﻳﺘﻲ‬
‫ﻣﻼﺣﻈﻪ‬
‫• ﻳﻮﺟﺪ ﺑﻌﺾ اﻟﺒﺮاﻣﺞ ﻣﻜﺘﻮﺑﺔ ﺑﻠﻐﺔ اﻟﺴﻲ وذﻟﻚ‬
‫ﻟﺘﺬآﻴﺮ ﺑﻬﺎ ﻣﻦ اﻟﻨﺴﻴﺎن‪.‬‬
‫• اﻟﺨﻄﻮة اﻟﻮﺣﻴﺪة ﻟﺘﻄﻮﻳﺮ هﺬا اﻟﻜﺘﺎب أﺑﺪاء إي‬
‫ﻣﻼﺣﻈﺔ أو اﺳﺘﻔﺴﺎر ﻧﺤﻮ هﺬا اﻟﻜﺘﺎب أو اآﺘﺸﺎف‬
‫ﺁي ﺧﻄﺄ اﻟﺮﺟﺎء أﺑﻼﻏﻴﻲ ﺑﺬاﻟﻚ ﻋﻠﻰ اﻟﺒﺮﻳﺪ‬
‫اﻻﻟﻜﺘﺮوﻧﻲ‬
‫• إﻟﻰ آﻞ ﻃﺎﻟﺐ ﻓﻲ ﻗﺴﻢ اﻟﺤﺎﺳﻮب أي ﺳﺆال ﻋﺠﺰ‬
‫ﻋﻦ ﺣﻠﺔ ﻳﺮﺟﻰ أرﺳﺎﻟﺔ ﻟﻠﺒﺮﻳﺪ اﻻﻟﻜﺘﺮوﻧﻲ‬
‫واﻧﺄ ﺳﺄواﻓﻴﻪ اﻟﺤﻞ إﻧﺸﺎء اﷲ وﺳﺄآﻮن ﺗﺤﺖ اﻟﺨﺪﻣﺔ‬
‫داﺋﻤ ًﺎ‪ ..........................................‬وﺷﻜﺮًا‬
‫اﻟﺴﻴﺮة اﻟﺬاﺗﻴﺔ‬
‫اﻻﺳﻢ‪ :‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﻴﺴﻰ اﻟﺪﺑﻌﻲ‬

‫ﻣﺤﻞ اﻹﻗﺎﻣﺔ‪ :‬اﻟﺠﻤﻬﻮرﻳﺔ‬ ‫اﻟﻌﻤﺮ‪ ٢١ :‬ﺳﻨﺔ‬ ‫اﻟﺠﻨﺴﻴﺔ‪ :‬ﻳﻤﻨﻲ‬
‫اﻟﻴﻤﻦ‬
‫ﻃﺎﻟﺐ ﺟﺎﻣﻌﻲ ‪--------------‬آﻠﻴﺔ ﻋﻠﻮم وهﻨﺪﺳﺔ ﺣﺎﺳﻮب‪ /‬اﻟﻤﺆهﻼت‬
C++
‫א‬
c c++ ‫א‬ : ‫א‬ ‫א‬
C++ ‫א‬ ‫א‬
‫א‬ ‫א‬
C++ ‫א‬ : ‫א‬ ‫א‬

‫א‬ ‫א‬
‫א א‬
‫א‬ ‫א א‬
( preprocessor directives ) ‫א‬
(Comments ) ‫א‬
C++ ‫א‬ ‫א‬
( integer variables) ‫א‬ ‫א א‬ ‫א‬
( char variables ) ‫א א‬ ‫א‬
( escape sequences ) ‫א‬
(floating point variables ) ‫א‬ ‫א א‬ ‫א‬
cin ‫א‬ ‫א א‬
: ‫א‬ ‫א א‬
( Operators ) ‫א‬ ‫א‬
‫א א‬ ‫א‬
‫א‬ ‫א א‬ ‫א‬
( Address of Operator ) ‫א‬ ‫א‬
‫א אא‬ ‫א‬: ‫א‬ ‫א‬

(if statement ) ‫א‬ ‫א‬ ‫א‬
(if ……. else statement ) ‫א‬ ‫א‬ ‫א‬
( if-else- if Ladder ) ‫א‬ ‫א‬ ‫א‬
( switch statement ) ‫א א‬ ‫א‬
‫א‬
‫א‬ ‫א‬ ‫א‬: ‫א א‬ ‫א‬
(for loop ) for ‫א‬
(while loop ) while ‫א‬
do-while ‫א‬ ‫א‬ ‫א‬
‫א‬
(Function & Macro ) ‫א‬ ‫א א‬: ‫א‬ ‫א‬
‫א א א‬
‫א א‬
(main function arguments ) ‫א א א‬
‫א‬ ‫א‬
‫א‬
‫א‬
‫א‬
‫א‬: ‫א‬ ‫א‬
‫א א‬ ‫א‬
‫א‬
‫א‬
‫) ‪( Classes & Objects‬‬ ‫א‬ ‫‪:‬א‬ ‫א‬ ‫א‬

‫א‬
‫א א‬
‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬
‫ﻣﻤﻴﺰات ﻟﻐﺔ ‪ ++C‬ﻋﻦ ﻟﻐﺔ ‪:C‬‬
‫‪++C‬‬ ‫א‬ ‫א‬ ‫‪++C‬‬

‫‪.‬‬ ‫א‬ ‫א א א‬
‫‪:‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪C‬‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫אא‬ ‫‪C++‬‬
‫‪.‬‬
‫א‬ ‫) ‪( class‬‬ ‫א‬ ‫א‬ ‫א א‬
‫א א ‪.‬‬ ‫א‬
‫‪:‬‬ ‫א‬
‫‪،‬‬ ‫א‬ ‫א‬ ‫‪C++‬‬
‫) ‪( public , private , protected‬‬ ‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬
‫א‬
‫‪public‬‬
‫‪protected‬‬
‫‪private‬‬
‫א‬ ، ‫א א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬
:( constructors and destructors ) ‫א‬ ‫א א‬
C ، ‫א‬ ‫א‬
( constructor ) ‫א א‬ ‫א‬ ‫א‬ ++
‫א א‬ . ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א א‬
‫א‬ ‫א‬ ‫א‬ ( destructor ) ‫א א‬ ‫א א א‬

‫א‬ ‫א א‬ ‫א‬ ‫א א‬ ‫א‬
. ‫א א‬ ‫א‬ ‫א‬ ، ‫א‬
‫א א‬ (Ball ) ‫א א‬ ، ‫א א‬ ‫א א‬
.( Ball ) ‫א‬
‫א א‬ ‫א‬ (~) ‫א א‬ ‫א א‬
.( ~Ball ) ‫א‬
: (Inheritance ) ‫א‬
. ‫א‬ ‫א‬ ‫א‬
.
parent ) ‫א‬ ‫א‬ (derived class ) ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ (class
. ‫א א‬ ‫א‬ ‫א‬ ، ‫א‬ ‫א‬
‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א א‬ ‫א‬ ‫‪،‬‬ ‫א א א‬
‫‪.‬‬
‫) ‪:( friend functions‬‬ ‫א א א‬

‫א א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א א‬ ‫א‬ ‫א‬
‫א א‬ ‫‪،‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א א א‬ ‫א‬
‫‪C++‬‬ ‫א‬ ‫א‬
‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬

‫) ‪Procedural programming‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א א‬ ‫( א‬
‫א א‬ ‫‪،‬‬ ‫א א א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א א‬ ‫א‬
‫‪،‬‬ ‫א‬ ‫) ‪( class‬‬ ‫א‬ ‫א‬ ‫א‬

‫‪.‬‬ ‫א‬ ‫א א א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫אא‬
‫א‬ ‫א‬ ‫‪ C++‬א‬ ‫א‬ ‫‪.‬‬ ‫א‬
‫א א‬
‫‪.‬‬
‫‪:‬‬ ‫א‬ ‫א‬

‫) ‪:( classes‬‬ ‫א‬
‫א‬ ‫א‬ ‫א‬
‫‪،‬‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א א ‪،‬‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬
‫‪:‬א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬

‫……‬ ‫‪،‬א א‬ ‫א‬ ‫‪،‬‬ ‫א‬
‫……‬ ‫‪،‬‬ ‫א ‪،‬‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫) ‪:(Objects‬‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬
‫‪.‬‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‪ :‬أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﺔ ﺑﻠﻐﺔ ‪C++‬‬
‫אא‬ ‫‪،‬‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬

‫א ‪.‬‬ ‫א‬ ‫א ‪،‬א‬ ‫‪،‬א‬ ‫א‬ ‫‪:‬‬ ‫א‬
‫‪،‬‬ ‫א‬ ‫‪ ،‬א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫א א ‪.‬‬ ‫‪.‬‬ ‫א‬
‫‪:‬‬ ‫א‬ ‫א‬

‫א‬ ‫א‬
‫{‬
‫;“‪cout << “ Every age has its own language . . .‬‬
‫}‬
‫‪++C‬‬ ‫א‬ ‫א‬ ‫א‬

‫‪.‬‬
‫א א ‪:‬‬
‫א‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬
‫א‬ ‫א‬ ‫) )(‪ ( main‬א א‬ ‫א א א‬
‫א‬ ‫א‬ ‫‪ ،‬א א א‬ ‫א‬
‫‪.‬‬
‫א א א‬ ‫א א ‪،‬‬ ‫א‬ ‫א א‬
‫‪.‬‬ ‫אא‬
‫א א‬ ‫א א א‬ ‫) ‪ ( void‬א‬ ‫א‬ ‫א‬
‫א‬ ‫א א א‬ ‫‪،‬‬
‫‪.‬‬ ‫אא‬
‫‪.‬‬ ‫א‬ ‫"{"‪"}"،‬‬ ‫א א א‬

‫‪.‬‬ ‫א‬ ‫א‬ ‫א א א‬
‫א‬ ‫א א‬
‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫) << ( א‬ ‫) ‪ (cout‬א‬ ‫א‬
‫א‬
‫‪cout‬‬ ‫ﺍﻟﺤﺭﻓﻲ‬
‫<<‬
‫) ‪:( preprocessor directives‬‬ ‫א‬
‫א‬ ‫א א‬ ‫) >‪(#include <iostream.h‬‬ ‫א‬ ‫א‬ ‫א‬
‫א א א‬ ‫א‬
‫‪.‬‬ ‫א‬
‫א‬ ‫) ‪ (#‬א‬ ‫א‬ ‫א‬ ‫א‬
‫א א ‪.‬‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א א‬
‫‪.‬‬
‫) ‪:(Comments‬‬ ‫א‬
‫‪.‬‬ ‫א א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫‪C++‬‬
‫‪.‬‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫" ‪" //‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫" ‪"//‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫" ‪" //‬‬ ‫א‬ ‫א‬
‫א‬ ‫" *‪"*/ " "/‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬
‫א א‬ ‫א‬ ‫א‬ ‫א‬
// this is the first method 1
// this is the
// first method 2
/* this is the second method */ 3

4
/* this is
the second
method*/
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ . ‫א‬
.
‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬
‫א‬ "/* " ‫א‬ ‫א‬
. "*/ " ‫א‬ ‫א‬
C++ ‫א‬ ‫א‬
: ‫א‬ ‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ . ‫א‬ ‫א‬ ‫א א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫‪−‬‬ ‫א‬ ‫‪−‬‬
‫א א ‪.‬‬ ‫א‬ ‫א‬ ‫א‬
‫) ‪(Identifiers‬‬ ‫א‬ ‫א ‪C‬‬ ‫א‬ ‫א‬
‫‪:‬‬ ‫א‬ ‫א‬
‫) ‪( Reserved words‬‬ ‫א‬ ‫א‬ ‫א א‬ ‫‪−١‬‬

‫א‬ ‫א‬ ‫) ‪( main‬‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬
‫) ‪ (A-Z‬א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪−٢‬‬
‫א‬ ‫)‪( ٩−٠‬‬ ‫א‬ ‫‪،‬‬
‫‪.‬‬ ‫א‬ ‫)_(‬ ‫א‬
‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫‪−٣‬‬
‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬
‫)‬ ‫א א‬ ‫‪C‬‬ ‫א‬ ‫א‬ ‫‪ −٤‬א‬
‫) ‪(my_number‬‬ ‫א‬ ‫‪(MY_NUMBER‬‬
‫) ‪.(My_Number‬‬ ‫א‬
‫א ‪:‬‬ ‫א‬ ‫א‬

‫‪C‬‬ ‫א‬ ‫א‬ ‫א א‬ ‫א א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬
) ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ) ‫א א‬ ‫א‬ ( ‫א א‬ ‫א א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ،( ‫א א‬ ‫א‬
) ‫א‬ ‫א‬ (a ) ‫א‬ ‫א‬ ‫א‬

. int ‫א‬ ‫א‬ (integer
‫א‬ ‫א‬ (Real ) ‫א א‬ ‫א‬ (b ) ‫א‬ ‫א‬
. float
، ‫א א‬ ‫א‬ ،
(float int) ‫א‬ ‫א‬ ‫א‬
a,b ‫א‬ ‫א‬ ‫א‬
، ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬
:(Assignment ) ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ (assignment statement ) ‫א‬ ‫א‬
‫א‬ (١٣−٢) ‫א‬
. ‫א‬ ‫א‬ ،
: ( Assignment statment ) ‫א‬

‫א‬
a=1000;
: ‫א‬ ‫א‬ ‫א‬
‫‪"a‬‬ ‫‪١٠٠٠‬‬ ‫א‬ ‫"‬
‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬
‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫‪:‬‬ ‫א‬ ‫א‬
‫" ‪"a‬‬ ‫‪-١‬‬
‫" ‪"b‬‬ ‫א‬ ‫‪2‬‬ ‫" ‪"a‬‬ ‫א‬ ‫‪-٢‬‬
‫" ‪."c‬‬ ‫" ‪"b " ، "a‬‬ ‫‪-٣‬‬
‫א‬ ‫" ‪"c " ، "b‬‬ ‫א‬ ‫אא‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬
‫" ‪"c‬‬ ‫א‬ ‫א‬ ‫א‬
‫‪:‬‬ ‫א‬ ‫א‬

‫‪:‬‬ ‫א‬ ‫‪C++‬‬
‫;‪a = b = c = 24‬‬
‫א ‪:‬‬ ‫א א א‬
‫‪:‬‬ ‫א‬ ‫א‬ ‫א‬
‫; ‪float a = 5.6‬‬
‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬
‫א א ‪.‬‬
‫) ‪:( integer variables‬‬ ‫א‬ ‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬
#include <iostream.h>
void main()
{
int var1; //define var1
int var2; //define var2
var1=20; //assign value to var1

var2=var1+10;
cout<< “var1+10 is ”; //output text

cout<<var2; // output value of var2
"var2 " "var1 " ‫א‬ ‫א‬ ‫אא‬

"integer " ‫א‬ "int " ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א א א‬ ‫א‬ ‫א‬ ،
. ‫א‬ ‫א‬
C ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫אא‬
. ‫א‬ ‫א‬ ‫א‬ ++
‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ، ‫א‬
‫א‬ ‫ א‬، ‫א‬ ‫" א‬٢٠ " ‫א‬ ‫אא‬
، ‫א‬ ‫א‬ ‫א‬ ، ‫א‬ ‫א‬
. ‫א‬ ‫א‬ "١٠ " ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
:( char variables ) ‫א א‬ ‫א‬
‫א‬ ‫ א‬، ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬
char variable_name;
‫א א‬ ، ‫א‬ ‫א א‬ (variable_name )
. ‫א‬ ‫א‬
‫א‬ ‫א‬
variable = ‘A’;
( variable ) (A ) ‫א‬ ‫א‬
: ( escape sequences ) ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫ א‬C++
‫א‬ ‫א‬
main()
{
char var1=’A’;
char var2=’\t’;
char var3=’\n’;
cout << var1;

cout << var2;
cout << var1;
cout << var3;
}
‫) ‪(A‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫אא‬
‫‪.‬‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫) ‪ ( back slash‬א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪ ،‬א‬
‫א‬ ‫א‬ ‫)‪(n‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪،‬‬
‫‪.‬‬
‫א‬ ‫א‬ ‫א‬ ‫) ‪(t‬‬ ‫א‬
‫) ‪.( tab‬‬ ‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬
‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫‪\a‬‬
‫א‬ ‫א‬ ‫)‬ ‫א‬ ‫א‬ ‫‪\b‬‬
‫‪( backspace‬‬
‫‪Enter‬‬ ‫א‬ ‫)‬ ‫א‬ ‫‪\n‬‬
‫(‬
‫א‬ ‫)‬ ‫א‬ ‫‪\t‬‬
‫‪(tab‬‬ ‫א‬
‫) \(‬ ‫א‬ ‫א‬ ‫א‬ ‫\\‬
‫א‬ ‫”\‬
‫א‬ ‫’\‬
‫) ‪(floating point variables‬‬ ‫א‬ ‫א א‬ ‫א‬
‫ﺘﻌﺭﻓﻨﺎ ﻓﻲ ﺠﺯﺀ ﺴﺎﺒﻕ ﻋﻠﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺩﺩﻴﺔ ﺍﻟﺼﺤﻴﺤﺔ‪ ،‬ﻭﻨﻌﻨﻲ ﺒﺎﻟﺼﺤﻴﺤﺔ ﺘﻠﻙ ﺍﻟﺘﻲ‬
‫ﻻ ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﻜﺴﻭﺭ ﺃﻱ ﻻ ﺘﻭﺠﺩ ﺒﻬﺎ ﻋﻼﻤﺔ ﻋﺸﺭﻴﺔ‪.‬ﻭﺍﻵﻥ ﻨﺘﻌﺭﻑ ﻋﻠﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‬
‫ﺍﻟﻌﺩﺩﻴﺔ ﺍﻟﻌﺸﺭﻴﺔ ﺃﻭ ﻜﻤﺎ ﺘﺴﻤﻴﻬﺎ ﺒﻌﺽ ﺍﻟﻜﺘﺏ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺤﻘﻴﻘﻴﺔ ﻭﻫﻲ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺘﻲ‬
‫ﺘﺴﻤﺢ ﻟﻨﺎ ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺘﻲ ﺘﺤﻭﻱ ﺍﻟﻜﺴﻭﺭ ﺃﻭ ﺍﻟﻌﻼﻤﺎﺕ ﺍﻟﻌﺸﺭﻴﺔ‪ ،‬ﻭﻤﻥ ﻫﻨﺎ‬
‫ﺠﺎﺀ ﺍﺴﻤﻬﺎ‪.‬‬
‫‪:‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫{‬
‫;‪float var1‬‬ ‫‪//define var1‬‬
‫;‪float var2‬‬ ‫‪//define var2‬‬
‫;‪var1= 50.79‬‬ ‫‪//assign value to var1‬‬

‫;‪var2= var1 + 56.9‬‬
‫‪cout<< “var1+ 56.9 is ”; //output text‬‬

‫;‪cout<<var2‬‬ ‫‪// output value of var2‬‬
‫}‬
‫א‬ ‫א א‬ ‫א‬ ‫א א‬ ‫א‬

‫) ‪( floating point‬‬ ‫א‬ ‫) ‪(float‬‬ ‫א‬ ‫א א‬
‫‪.‬‬ ‫א א‬ ‫א‬ ‫‪،‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬

‫א‬
‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬
‫‪:c‬‬ ‫א‬ ‫א א‬
‫א‬ ‫א א א ‪printf‬‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ ‫א‬ ‫(‪.‬‬ ‫)‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫‪،‬‬ ‫א‬ ‫א ‪ ،printf‬א‬ ‫א א א‬

‫א‬ ‫א‬ ‫א א‬ ‫" ‪ "f‬א‬ ‫א‬ ‫א א ‪، scanf‬‬
‫" ‪"format‬‬
‫א‬ ‫" ‪" x,y,z‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫‪:‬‬ ‫א‬ ‫א‬ ‫א‬ ‫" ‪"x‬‬ ‫א‬
‫)‪scanf ("%f",&x‬‬
‫" ‪" x,y‬‬ ‫א‬ ‫א "‪"y‬‬ ‫א‬ ‫א‬
‫" ‪"z‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫"‪"z‬א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫"‪"x‬‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ ‫‪، Enter‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫‪Enter‬‬ ‫א‬ ‫"‪"y‬‬ ‫א‬
‫‪:‬‬ ‫א א ‪scanf‬‬ ‫א א‬ ‫א‬ ‫א‬
‫א‬ ‫א א ‪printf‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪-١‬‬
‫"‪."y " "x‬‬ ‫א‬ ‫א‬ ‫" ‪ " %f‬א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫" ‪"y" "x‬‬ ‫א א א‬ ‫‪-٢‬‬
‫א ) ‪( address operator‬‬ ‫א‬ ‫א‬ ‫א‬ ‫)&‪، (x‬‬
‫&‬ ‫א‬ ‫א‬ ‫‪.‬‬ ‫א‬ ‫א א‬
‫) ‪(address-of operator‬‬ ‫א‬ ‫א‬
‫‪:‬‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א ‪ scanf‬א‬ ‫א א ‪printf‬‬
‫א‬
‫(‬ ‫א‬ ‫) א א‬ ‫א‬ ‫א‬
‫א‬ ‫א א‬ ‫א‬ ‫" ‪" %f %f‬‬
‫א א ‪(scanf‬‬ ‫א‬ ‫א‬ ‫"‪)",‬‬ ‫א א‬
‫א א ‪scanf‬‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪.‬‬ ‫א א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א א‬ ‫א‬
‫‪:‬‬ ‫א‬ ‫א‬
‫‪، Enter‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א ؟؟؟‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫‪،‬‬
‫‪:‬‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫‪ cin‬א ‪scanf‬‬ ‫א א‬
‫א א‬ ‫א‬ ‫א‬ ‫‪.‬‬ ‫א‬ ‫א א‬
‫א‬ ‫א‬ ‫‪ printf‬א ‪ cout‬א‬
‫‪:‬‬ ‫א‬
‫‪Please Enter the number‬‬

‫א‬ ‫א‬ ‫א א‬
‫‪.‬‬ ‫א‬
‫‪:‬‬
‫‪،‬‬ ‫א‬ ‫א‬ ‫א א א ‪scanf‬‬
‫א‬ ‫א‬ ‫‪.‬‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬
‫‪:‬‬ ‫א‬
‫א‬ ‫א‬ ‫א‬

‫‪.‬‬ ‫א א‬ ‫א‬ ‫‪.‬‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫)‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫‪( NULL character‬‬
‫א‬ ‫א‬ ‫אא‬

‫‪.‬‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א א‬
string variables ) ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ C ‫א‬ ،(
character ) ‫א‬ ‫א‬

‫א‬ ‫א א‬ ‫א‬ ‫א‬ ( arrays
.
: ‫א‬ ‫א‬
‫א‬ ‫א‬ . ‫א א‬ ‫א‬

. ‫א‬ ‫א‬ ‫א‬ ( size ) ‫א‬
employee_name ) ‫א‬ ‫א‬ ‫א‬

:(
char employee_name[20];
، ‫א‬ ‫א א‬ ‫אא‬
.( NULL ) ‫א‬ ‫א‬ ‫א‬
) ‫א א‬ ‫אא‬ ‫א‬ ، ‫א‬ ‫א‬

‫א א‬ ‫א‬ "b" ، ‫א‬ ‫א‬ "a" ( strcpy ( a,b)
. ‫א‬
‫א‬ "a " ‫א‬ ‫א‬ ‫א‬
‫א א‬ ‫א‬ ‫א‬ " Hello again " ‫א‬
.%s ‫א‬ ‫א א‬ ‫א‬ printf ‫א‬
: ‫אא‬ ‫א‬
#include <string.h>
"string.h " ‫א‬ strcpy ‫א א א‬ ‫א‬ ‫אא‬
، ‫א א‬ " strcpy " ‫א א‬ ‫א‬ ‫א‬
"string header file " ‫א‬ ‫א‬ ‫אא‬
. printf ‫א א‬ ، ‫א‬ ‫א‬ ‫א‬
‫א א‬ ‫א‬ "a" ‫א‬
. ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬
"٠" ‫א‬ ‫א‬ ‫א‬ "[a[20 " ‫א‬
: "١٩ "
a[0], a[1],…………………..,a[19]
‫)א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ١١ ‫א‬ ‫א‬ ‫א‬ (
. ‫א‬ ‫א‬ ‫א‬
: ‫א‬
‫א‬ ‫א‬ scanf ‫א א א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א א א‬ ‫א‬.
: gets ‫א א‬
‫א‬ ‫א א‬ " get string " ‫א‬ ‫א א א א‬
( NULL ) ‫א‬ ‫א‬ ، ‫א‬
: ‫א א‬ . ‫א‬ ‫א‬ ‫א‬
gets(a);
. ‫א‬ "a"
‫"‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫א‪.‬‬ ‫א‬ ‫א‬ ‫‪" employee name‬‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א א ‪scanf‬‬ ‫א‬ ‫א‬

‫‪.Enter‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫‪١٩‬‬ ‫א‬
‫א א ‪: fgets‬‬
‫) ‪.( input device‬‬ ‫א‬ ‫א א‬
‫‪:‬‬ ‫א א‬ ‫(‬ ‫א‬ ‫)‬ ‫א‬
‫;) ‪fgets( a, n, stdin‬‬
‫" ‪"a‬‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫" ‪"n‬א‬
‫(‬ ‫א‬ ‫)‬ ‫א‬ ‫א‬ ‫" ‪ "stdin‬א‬
‫א‬ ‫‪stdin‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬
‫‪:‬‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬

‫) \‪.( n‬‬ ‫א‬ ‫א‬ ‫‪-١‬‬
‫) ‪.( NULL‬‬ ‫א‬ ‫‪ -٢‬א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א א‬
‫‪:‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬
‫א א ‪:puts‬‬
‫‪gets‬‬ ‫א א‬ ‫א א א‬ ‫" ‪" put string‬‬ ‫א א‬ ‫א‬
‫‪:‬‬ ‫א א‬
‫;)‪puts ( a‬‬
‫‪.‬‬ ‫‪،‬‬ ‫‪a‬‬
‫א א א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫‪gets‬‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ ‫א א ‪puts‬‬
‫" \‪"n‬‬ ‫א‬
‫א א ‪:fputs‬‬
‫א‬ ‫א‬ ‫א ‪fgets‬‬ ‫א‬ ‫א א‬

‫א א א א ‪.‬‬ ‫א‬ ‫א‬
‫‪:‬‬ ‫א א‬
‫;) ‪fputs( a, stdout‬‬
‫‪.‬‬ ‫‪a‬‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫" ‪ "stdout‬א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ puts fputs ‫א א‬
cin ‫א‬ ‫א א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
#include<iostream>
void main()
{
int ftemp;
cout << “ Enter temperature in Fahrenheit: “;
cin >> ftemp;
int ctemp= (ftemp-32) * 5/9;
cout<<”The temperature in Celsius is : “ <<ctemp<<”\n”;
}
) ‫א‬ (cin ) ‫א‬ ‫א‬ ‫א‬ ‫אא‬ ‫א‬

. ‫א‬ ‫א‬ ‫<<( א א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫ﻣﺘﻐﻴﺮ‬
cin >>
( Enter ) ‫א א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬
:( Operators ) ‫א‬ ‫א‬
‫א א‬ ‫א‬ ‫א‬ ، ‫א‬ ‫א‬ – – ++C
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬
: ‫א‬ ‫א‬
( Arithmetic Operators ) ‫א א‬ ‫ א‬−١
( Relational operators ) . ‫א א‬ ‫ א‬−٢
(Logical operators ) . ‫א א‬ ‫ א‬−٣
: ‫א א‬ ‫א‬
‫א‬ ‫א א‬ ‫א‬ ، ‫א א‬ ‫א‬ ‫א א‬ ‫ א‬C++
‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬
‫א‬ +
‫א‬ -
‫א‬ *
‫א‬ /
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫א‬
‫א‬ %
‫א‬ --
‫א‬ ++
‫‪.‬‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬
‫‪:‬‬ ‫אא‬ ‫א‬ ‫א‬ ‫א‬
‫‪x %y‬‬
‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫"‪ ،"y‬א‬ ‫"‪"x‬‬ ‫א‬
‫‪10%3‬‬ ‫ﺍﻻﺴﺘﺨﺩﺍﻡ‬
‫‪1‬‬ ‫ﺍﻟﻨﺎﺘﺞ‬
‫‪:‬‬ ‫א‬ ‫א‬
‫א א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א א‬

‫‪.‬‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א ) ‪(1‬‬ ‫)‪(a‬‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫‪:‬‬

‫;‪a = a + 1‬‬
‫א‬ ‫א‬ ‫א‬
‫;‪a++‬‬
‫א‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א ‪١‬‬ ‫)‪(a‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫;‪a = a –1‬‬
‫א‬ ‫א א‬ ‫א‬ ‫א‬
‫;‪a--‬‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫ א‬a ‫א‬ ‫ א‬++a a++ ‫א‬ ‫א‬
‫א‬ ‫א‬
‫ﻭﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻴﻭﻀﺢ ﺫﻟﻙ‬
int main()
{
int myAge = 39;
int yourAge = 39;
cout << "I am: " << myAge << " years
old.\n";
cout << "You are: " << yourAge << " years
old\n";
myAge++;
++yourAge;
cout << "One year passes...\n";
old.\n";
old\n";
cout << "Another year passes\n";
cout << "I am: " << myAge++ << " years
old.\n";
cout << "You are: " << ++yourAge << " years
old\n";
cout << "Let's print it again.\n";
old.\n";
old\n";
return 0;
}
Output: I am 39 years old
You are 39 years old
One year passes
I am 40 years old
Another year passes
I am 40 years old
Let's print it again
I am 41 years old
: ‫א‬ ‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א א‬ ‫א‬

.x>5 5 x−
.y <= 40 ٤٠ y -
.x = = 15 15 x -
.++C ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬
>
>=
<
<=
==
!=
‫‪C‬‬ ‫)=(‬ ‫א‬ ‫)= =(‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫) =(‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪،++‬‬
‫‪،‬‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬
‫א )‪(4‬‬ ‫)‪(x‬‬ ‫א‬ ‫א‬
‫)‬ ‫א א‬ ‫א א‬ ‫א א‬ ‫)‪(9‬‬ ‫) ‪(y‬‬
‫א‬ ‫(‬ ‫א א‬ ‫א א‬ ‫א‬
‫))‪if ((x = = 4) && (y != 9‬‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫) (‬ ‫א ) &&(‬
‫‪.‬‬
‫‪C++‬‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬
‫) (‬ ‫א‬ ‫&&‬
‫א‬
‫) (‬ ‫א‬ ‫||‬
‫א‬
‫א‬
‫א‬ ‫!‬
‫)‬
‫(‬
‫א ) ‪:( Address of Operator‬‬ ‫א‬

‫א‬ ‫א‬
{
int a =11;
cout << &a<<’\n’;

cout << a;
}
‫א‬ ‫א‬ ‫אא‬

0x8f4ffff4
11
‫א‬ ‫א א‬ ‫א‬ ‫א‬ (a) ‫א‬ ‫א‬ ‫א‬
. ‫א א‬ ‫א‬
‫ اﺗﺨﺎذ اﻟﻘﺮارات‬: ‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ‬
‫א א‬ ‫א‬ ‫א‬ ، ‫א א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬
، ‫א אא‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬
‫א‬ C++ ‫א א‬ ‫א‬
. ‫א‬
:(if statement ) ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬
if ( condition )
statement;
‫א‬ ‫א‬ ‫א‬
‫א א א א א‬ ( statement ) ‫א‬ ( condition )
. ‫א‬ ‫א‬
‫א א א א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א א א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬
main()
{ float sum;
cout<< “ Enter the sum “;
cin >> sum;
if(sum>50)
cout<<” The student had passed”;
}
‫א‬ ‫א‬ ‫א‬ ‫אא‬
‫א‬ ‫ ( א‬٥٠ ‫א‬ ) ‫א‬ ‫א‬
، ‫א‬ ‫א‬
(if ……. else statement ) ‫א‬ ‫א‬ ‫א‬

، ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א אא‬ ‫א‬
‫א‬ ‫א‬ ‫ א‬، ‫א א‬ ‫א‬
. ‫אא‬
‫ ؟؟‬٥٠ ‫א‬ ‫א‬ : ‫א‬ ‫א‬
‫א‬ ‫א‬ . ‫א‬ ‫א‬ ‫אא א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ، ‫א‬
‫א‬ ‫א‬ ‫א‬
main()
{
float sum;
cin >> sum;
if(sum>50)
else
cout<<” The student had failed”;
}
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫אא‬
‫א‬
if ( condition)
statement-1;
else
statement-2;
‫א‬ ‫א‬ ‫א‬

‫א‬ ( condition )
. ‫א‬ ‫א‬ ( statement -1 )
. ‫א‬ ‫א‬ ( statement -2)
‫א‬ ‫א‬ ‫א‬ ": ‫א א‬ ‫א‬
" ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
، ‫א א‬ ‫א‬ − ‫א‬ ‫א‬ ‫א א‬ −‫א‬
‫؟‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
، ‫א א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬
if ( condition)
{ statement 1;
statement 2;
statement n;
} else
{ statement 1;
statement 2;
.
.
statement m;
}
‫א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ ‫ א‬، ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ، ‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬
main()
{
float sum;
cin >> sum;
if(sum>50)
{
cout<< “ His points are “<< sum/100;
}
else
{
cout<<” The student had failed”;
cout<<” No points are calculated for failed
student !!”;
}
}
:( if-else- if Ladder ) ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫א א‬ ‫א‬ ‫א‬ − − ‫א‬ ‫א‬
‫א‬ ‫א‬ ، ‫א‬
. ‫א‬ ‫א‬ ‫א‬ . ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
if ( condition –1)
statement –1;
else if ( condition-2)
statement-2;
else if( condition-3)
statement-3;
………..
else
statement-n;
‫א‬ ‫א‬ ‫א‬
( switch statement ) ‫א א‬ ‫א‬
، ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א א‬
. . ‫א‬
‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
switch (variable)
{
case value1;
statement 1;
break;
case value2;
statement 2;
break;
case value 3;
statement 3;
break;
……………
default:
statement;
}
‫א א‬ ‫א‬
‫א‬ ‫א‬ (switch ) ‫א א‬ ‫א‬ ‫א‬

‫א‬ ، ‫א‬ ‫א‬
‫א א‬ ‫א א א‬ ‫א‬ ‫א‬
− ‫א‬ ‫ א‬− ‫א‬ ( case )
. ‫א‬
‫א‬ ‫א‬ ‫( א‬break ) ‫א‬

!!! ‫א‬ ‫א‬
‫א‬ : ‫א‬ ‫א‬ ‫א‬
‫؟؟‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א א‬ ‫א‬ ‫אא א‬ ‫א‬
( break) ‫א‬ ‫ א‬،
‫א‬ ( default) ‫א א‬
. ‫א‬ ‫א‬ ‫א‬
‫א‬
‫א‬ ‫א‬ ‫א‬ *
#include<iostream.h>
Main(){int a;
Cin>>a;
If (a%2=0)
Cout<<"zojee";
Else
Cout<<"frdee";
}
١٠−١ ‫א א‬ ‫א א‬ *
Main(){int a=1,b=0;
Q:If (a%2!=0){cout<<a;b+=a;}
a++;
if (a<=10)goto q;
cout<<"\n"<<b;
}
‫א ؟‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ *

‫؟‬ ‫א‬ ‫א‬ *
‫א א ؟‬ ‫א א‬ ‫א‬ ‫א א‬ ‫א‬ *
‫؟‬ ‫א‬ ‫א‬ *
. ‫א‬ ‫א‬ <+++++

‫ اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﺔ‬:‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‬
++C ، ‫א א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬
.‫א‬ ‫אא‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ،" ‫א‬ ‫א‬ ‫"א‬ ‫א‬
C
.( for loop ) for ‫ א‬−١
.( while loop ) while ‫ א‬−٢
.(do-while loop ) do…. while ‫ א‬−٣
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
.
:(for loop ) for ‫א‬
‫א א‬ ‫א‬ ( ‫א א‬ ) ‫א‬ for ‫א‬
‫א‬ ‫א‬
for ( counter statement ; condition ; step)
for ‫א‬ ‫ א‬١−٦
: ‫א‬
.‫א‬ ‫א א‬ ‫א א‬ : ( counter ) ‫ א א‬−١
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫ א‬:(condition ) ‫ א‬−٢
. ‫א‬
.‫א‬ ‫א א‬ ‫א‬ ‫א‬ : (step) ‫ א‬−٣
: for ‫א א‬ (٢−٦ ) ‫א‬ ‫א‬
main()
{
int counter ;
for ( counter=1;counter<=20;counter++)
cout<<counter;
}
for ‫א א‬ ‫א‬
( for ) for ‫א‬ ‫א‬ ‫א‬

. ‫א‬ ‫א‬ ‫א‬
.‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
.٢٠ ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
١ ‫א‬ ‫א א א‬ ‫אא‬ ، ‫א‬ ‫א‬ ‫א‬
. ‫א‬
.٢٠ ١ ‫א‬ ‫א‬ ‫א‬
:
‫א‬ ، ‫א‬ for ‫א‬ ‫א א‬ ‫ א‬−١
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫ ) א‬for ‫א א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ −٢
‫א א א‬ ‫א‬ (cout << counter; ) ‫א‬ ‫א‬
.
:(while loop ) while ‫א‬
‫א‬ ‫א‬ ‫אא‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
.. ‫א‬ ‫א‬
‫א‬ while ‫א‬ ‫א‬
while ( conditon )
{
statement 1;
statement 2;
.
.
statement n;
}
while ‫א‬ ‫א‬

‫א א‬ ‫א‬ ‫א‬ ‫ א‬،‫א‬ ‫א א‬ ‫א‬ ‫א‬ (condition )
. ‫א‬ ‫א א א‬ ‫א‬
٢٠ ١ ‫א‬ ‫א‬ while ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
main()
{
int counter=1;
while ( counter <=20 )
{
cout<< counter;
counter++;
}
}
while ‫א א‬
:while ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
.while ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ −١
.while ‫א‬ ‫א‬ ‫א א‬ −٢
:do-while ‫א‬ ‫א‬ ‫א‬
‫א‬ ، ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א א‬ ‫א‬
do-while ‫א‬ ‫א‬ ‫א‬ ‫א‬
do
{
statement 1;
statement 2;
.
.
statement n;
}
while ( conditon )
do-while ‫א‬ ‫א‬
‫א‬ ‫א א‬ ‫א‬ do-while ‫א‬ ‫א‬ ‫א‬

!!! ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬
‫א‬ ‫א‬ *
#include<conio.h>
main()
{int i,a,s,d,f;
a=s=0;
clrscr();
cin>>a;
d=f=a;
for ( i=2; i<=6; i++){
if(d<a){
d=a;}
if(f>a){
f=a;}
cin>>a;
}
cout<<d<<" "<<f;
getch();
}
‫א‬ *
#include<conio.h>
main(){
clrscr();
int a,s;long d;d=1;
cin>>a;
for(s=1;s<=a;s++){
d*=a;cout<<d<<"\n";
}
getch();
}
‫א א‬ *
#include<conio.h>
#include<math.h>
main(){
clrscr();
int a,s,d;
‫;‪cin>>a‬‬
‫{)‪for(s=1;s<=a;s++‬‬
‫;‪d=floor(a/s)*s‬‬
‫};‪if(a!=d){goto h‬‬
‫;"‪cout<<s<<"\n‬‬
‫‪h:‬‬
‫}‬
‫;)(‪getch‬‬
‫}‬
‫؟‬ ‫א‬ ‫א‬ ‫*‬
‫‪ //‬؟‬ ‫‪ //‬א‬ ‫* ‪//‬‬
‫‪٥ ٣‬؟‬ ‫א‬ ‫א‬ ‫א‬ ‫* ‪//‬‬
‫‪ ١,١,٢,٣,٥,٨,١٣,٢١,٣٣‬؟‬ ‫א‬ ‫א‬ ‫*‪//‬‬
‫؟‬ ‫‪١٠١/‬‬ ‫‪١١١‬‬ ‫א א‬ ‫א‬ ‫א‬ ‫* ‪//‬‬
‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ‪ :‬اﻟﺪوال و اﻟﻤﺎآﺮو ) ‪(Function & Macro‬‬
‫א א ‪:‬‬
‫א א‬ ‫א‬ ‫א א א‬ ‫א א‬
‫‪.‬‬ ‫א‬
‫‪:‬‬ ‫א א‬ ‫א‬ ‫א א‬
‫א‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫‪−١‬‬
‫‪.‬‬ ‫א א‬ ‫א‬ ‫א א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫‪−٢‬‬
‫א א ‪.‬‬ ‫א‬
‫‪،‬‬ ‫א‬ ‫א א א א‬ ‫א‬ ‫‪−٣‬‬
‫א‬ ‫א‬ ‫א א א‬ ‫א‬ ‫א‬
‫‪.‬‬
‫א‬ ‫א א א‬ ‫א‬ ، ‫א א‬ ‫א א א‬ ‫א‬ ‫א‬
، ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ،
. ‫א א‬ ‫א א‬ ‫א‬ ‫א‬
‫א‬ ‫א א‬ ‫א‬ (١ ) ‫א‬ ‫א‬
void DrawLine(); (1)

void main()
{
cout << “ This is the output of the function : “ << ‘\n’;
DrawLine(); (2)
}
void DrawLine()
{
for (I=1;I<=40;I++) (3)
cout<<’*’;
}
(١)
‫ ( א‬DrawLine ) ‫א א א‬ ‫א‬ ‫אא‬
(*) ‫א‬
) ‫א א‬ ‫א‬ ‫( א‬1) ‫א‬ ‫א‬
‫א א‬ ‫א א‬ ‫א א א‬ ( function declaration
. ‫א‬ ‫א‬
‫א א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫אא‬
. ‫א א א‬ ‫ ( א‬void ) ‫א‬ ‫א א‬ ،
(function calling ) ‫א א‬ (2 ) ‫א‬ ‫א‬
. ‫א א‬ ‫א‬ ‫א א‬
function ) ‫א א‬ (3) ‫א‬ ‫א‬
‫א‬ "{" "}" ‫א א‬ ،(definition
"* " ‫א‬ ‫א א‬ ، ‫א א‬ ‫א‬
. ‫א א‬ ‫א‬ ‫א‬ ‫א‬
: ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ، ‫א‬ ‫א א‬ −١
. ‫א א‬
. ‫א‬ ‫א א‬ ‫א‬ −٢
: ‫א א א‬
: ‫א א‬ ‫א‬ ، ‫א‬ ‫א א‬
‫א‬ ‫א‬ (int functions ) ‫א‬ ‫א‬ −١
.(integer ) ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫ ( א‬float functions ) ‫א‬ ‫א‬ −٢
.( float ) ‫א‬ ‫א‬
‫א‬ ‫א‬ ( string functions ) ‫א‬ −٣
. ‫א‬
) ‫א‬ ‫א‬ ( char functions ) ‫א א‬ −٤
.(char
. (void function ) ‫א‬ −٥
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ (٢ @) ‫א‬ ‫א‬
float sum(float x, float y)
{
float result;
result = x + y;
return result; (1)
};
void main()
{
cout << sum( 4.5 , 8.9 );
}
٢
(main ) ‫א א א‬ (sum) ‫א א‬
‫א‬ ‫א‬ ‫א‬ (sum ) ‫א א‬
.
‫א א‬ (1 ) ‫א‬ ‫א‬ ‫א א‬ ‫א‬

. ‫א א‬ ‫א‬ ( return ) ‫א‬
: ‫א א‬
٢ ‫ ( א‬sum ) ‫א א‬ ‫א‬ ‫א‬ ‫א א‬
‫א‬ ، ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬
‫ ( א‬DrawLine ) ‫א א‬ ‫א‬ ‫א‬
١ ‫א‬ ‫א‬
(main function arguments ) ‫א א א‬
( main ) ‫א א א‬ ‫א‬ ‫א א א‬
‫א‬ ،
‫؟‬ ‫א א א‬
‫א‬ ‫א‬ ‫א א א א‬ ‫א‬ ‫א‬ ‫אא‬ ‫א‬ ‫א‬
‫א‬ ‫א א א‬ ٣
#include < iostream.h >
main (int argc, char*argv[])
{
if(afgc!=3)
{
cout<<” Arguments number error ….”;
exit(1);
}
cout<<”the first argument is”<<argv[1]<<’\n’;
cout<<”the second argument is”<<srgv[2];
}
٣
، ‫א‬ ‫א‬ ‫א‬ (argc ) ‫א א א‬
) ‫ א‬، ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
(argument counter ) ‫א‬ ‫( א‬argc
‫א‬ ‫א‬ ( argv ) ‫א‬ ‫א‬

. ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬
(prog1.exe ) ‫א‬ ‫א‬
: ‫א‬ ‫א‬
C:> prog1 First Second

‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬

argv[0] Prog1
argv[1] First
argv[2] Second
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

.
‫א‬ ( ‫א‬ ‫א‬ ‫א‬ ) ‫א‬
. ‫א‬ ‫א‬
. ‫א‬ ‫א‬
‫א‬
the first argument is First
the second argument is Second
: ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
) ‫א‬ ‫א‬ ‫א‬ ‫אא‬ ، ‫א א‬ ‫א‬
.( ‫א‬ ‫א‬
. ‫א א‬ ‫א‬ ‫א‬
. ‫א א‬ ‫א א‬
C ‫א‬ ‫א א‬ ‫א‬ ،‫א‬ ‫א‬ ‫א‬

. ++
(* ) ‫א א‬
‫א‬
float *ptr;
.ptr ‫ א א‬، ‫א‬
.C++ ‫א‬ ‫א א‬ ‫א‬ ‫א‬
#include "stdio.h"
int main ()
{
int *px;
int a;
01: px = &a; /* 'px' will point on 'a'

*/
02: *px = 10; /* Changes on 'px' will

effect on 'a' */
03: printf("px = %d \n\n", *px);

04: printf("a = %d \n\n", a); /* 'a' and
'px' will have the same value that is 10
*/
05: a = 20; /* Changes on 'a' will

effect on 'px' */
06: printf("px = %d \n\n", *px);

07: printf("a = %d \n\n", a); /* 'a' and
‫‪'px' will have the same value that is 20‬‬
‫‪*/‬‬
‫}‬
‫א ‪.a‬‬ ‫‪px‬‬ ‫‪a‬‬ ‫‪px‬‬ ‫‪١‬‬ ‫א‬
‫‪px‬‬ ‫א‬ ‫‪١٠‬‬ ‫‪px‬‬ ‫‪٢‬‬ ‫א‬

‫‪:‬‬ ‫אא‬ ‫א‬ ‫‪ px‬א‬ ‫א‬ ‫א א א‬
‫‪" ١٠‬‬ ‫א‬ ‫אא א‬ ‫‪px‬‬ ‫א‬ ‫א א‬ ‫א‬ ‫"‬

‫‪a‬‬ ‫א‬ ‫אא‬ ‫‪ (١‬א‬ ‫א‬ ‫א ‪)a‬‬ ‫א‬ ‫אא‬
‫א ‪printf‬‬ ‫‪٣‬‬ ‫‪ ٤ ٣‬א‬ ‫א‬ ‫אא‬
‫‪a‬‬ ‫א‬ ‫‪٤‬‬ ‫א‬ ‫‪px‬‬ ‫א‬ ‫א א‬ ‫א‬
‫‪.١٠‬‬ ‫א‬ ‫א‬ ‫‪ ١٠‬א‬ ‫א‬
‫‪.٢٠‬‬ ‫‪a‬א‬ ‫‪٥‬‬ ‫א‬
‫‪px‬‬ ‫א‬ ‫א א א‬ ‫א‬ ‫א‬ ‫א ‪printf‬‬ ‫‪٦‬‬ ‫א‬

‫‪٧‬‬ ‫א‬ ‫‪،( ١‬‬ ‫א‬ ‫א ‪)a‬‬ ‫‪px‬‬ ‫א‬ ‫א א א‬
‫‪a‬‬ ‫א‬ ‫‪px‬‬ ‫א‬ ‫‪،‬‬ ‫‪٢٠‬‬ ‫א‬ ‫א‬ ‫‪a‬‬
‫‪.‬‬
‫א‬ ‫א ‪،‬‬ ‫א‬ ‫‪٩٠٪‬‬ ‫אא‬ ‫א‬ ‫אא‬

‫‪.(:‬‬ ‫א‬ ‫א‬
‫א א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬
‫‪:‬‬ ‫א‬ ‫א‬
‫;‪int *p1, *p2‬‬

‫;‪int a = 5‬‬
‫‪:‬‬ ‫אא‬ ‫‪a‬‬ ‫‪p1‬‬
‫;‪p1 = &a‬‬
‫א ‪(a‬‬ ‫‪p1‬‬ ‫)‬
‫؟!؟‬ ‫‪p1‬‬ ‫‪p2‬‬ ‫א‬
‫א‬ ‫א‬ ‫א ‪ ،a‬א‬ ‫א‬ ‫א ‪ p1‬א‬ ‫‪p2‬‬ ‫א‬

‫‪: P1‬‬ ‫‪p2‬‬
‫;‪p2 = p1‬‬
‫א ‪. p1‬‬ ‫א ‪p2‬‬
‫‪:‬‬ ‫א‬
‫‪*p1, *p2, a‬‬
‫‪:‬‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‪،‬‬ ‫‪++‬‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫‪++‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א ‪،‬‬
‫‪:‬‬ ‫א‬ ‫א‬ ‫‪،‬‬
‫‪(r = *(x+1‬؛‬ ‫;]‪r = x[1‬‬

‫א‬ ‫א‬ ‫א‬ ‫א א‬
: ‫א‬
ptr = x;
ptr = &x[0];
x ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

x[0] x ‫א‬ ‫א‬ ‫א‬
.
: ‫אא‬
#include "stdio.h"
int main ()
{
int x[] = {0, 1, 2, 3, 4, 5, 6, 7, 8,
9};
int i;
printf("Arrays As Pointers:\n");
for( i = 0 ; i < 10 ; i++)
{
printf("*(x + %d) = %d\n", i, *(x + i));
}
printf("\n\nArrays As Arrays:\n");
for( i = 0 ; i < 10 ; i++)
{
printf("x[%d] = %d\n", i, x[i]);
}
printf("\n\n\n");
return 0;
}
‫א‬ ‫א‬ ‫אא‬

. ‫א‬
: ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬

.
char ‫א‬ ‫אא‬ ‫א‬

: string
char *names[4];
. string name ‫א‬
: ‫אא‬ ‫א‬
char *name[4] = { "Talal", "Abdullah",

"Thamer", "Mohammad" };
name[0] ===> "Talal"
name[1] ===> "Abdullah"
name[2] ===> "Thamer"
name[3] ===> "Mohammad"
. ‫א‬
:(Structures ) ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ( fields ) ‫א‬

‫א‬ ‫א‬ ، ‫א‬
. ‫א‬ ، ‫א‬
: ‫א‬
، ++ struct ‫א‬ ‫א‬
: ‫א‬
( ‫א‬ struct (
}
‫א‬
‫{؛‬
. ‫א‬ ‫א‬ ‫אא‬ ‫א‬ −
‫* א‬char data ‫א‬ ‫א‬
int
: ‫א‬ ‫א‬
struct data
{
char namr[30];
int age;
};
) ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א א‬ (stucture_name

. ‫א‬ ..…،field1, field2 ‫א‬ ‫א‬
‫א‬ ‫אא‬ ‫א‬
‫א‬ ‫א‬
( ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
)structure1 ) ‫א‬ (var1
struct structure1
{
type field1;
type field2;
…
} var1;
. ‫א‬ ‫אא‬ ‫א‬ ‫א‬

‫؟؟‬ ‫א‬ ‫א‬
(.) ‫א‬ ‫א‬ ، ‫א‬
(Mohammed) ‫א‬ (Student ) ‫א‬ ‫א‬
(name ) ‫א‬
struct Student
{
char* name;
int number;
};
main()
{
Student Sdt1;
Std1.name=”Mohammed”;
Cout << Std1.name;
}
‫א‬ "Mohammed " ‫א‬ ‫א‬ ‫א‬ ‫א‬

.(Std1 ) ‫א‬ (name) ‫א‬
: ‫א‬
‫א‬ ‫א‬ ‫א‬ ، ‫א א א‬ ‫א א‬

: ‫א‬ ‫א‬ ‫א‬
structure_name var[NUM] ;
: ‫א‬ ‫א‬
typedef struct
{
char name[30];
int age;
}data;
: data ‫א‬ ‫א‬
data student[100] ;
. ١٠٠ ‫א‬
‫א‬ data ‫א‬ student ‫א‬
data student ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ١٠٠
: ‫א‬ ‫א‬ ‫א‬
student[indix].name & student[indix].age …
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

. ‫א‬ ‫א‬ Data Structure ‫א‬
: ‫א‬ ‫א‬ ‫א‬
‫ א‬، ‫א א א‬ ‫א‬ ‫א‬

: ‫ ( א‬Pointer ) ‫א‬
typedef struct
{
char name[30];
int age;
}data;
: ‫א‬
data *s ;
: ‫א‬ ‫א‬
#include<stdio.h>
#include <conio.h>
typedef struct
{
char name[30];
int age;
}data;
int main()
{
data *s, std;
s = &std; // Assign std to s
strcpy(std.name,"Talal");
std.age = 20;
printf("std.name = %s, std.age =

%d\n\n",std.name, std.age);
printf("s->name = %s, s->age = %d\n\n",s-
>name, s->age);
return 0;
}
‫ ؟! א ؟‬s ‫א א‬ ‫א‬ '<−' ‫א‬ ‫א‬

‫א‬ ++ ‫א‬ ‫א‬ ‫א‬ : ‫א‬ ‫א‬
‫א‬ ++ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ، '.' ‫א‬
. ‫א‬ ‫א‬ ‫א‬
'.' <− ‫א‬ ++ ‫א‬
:‫א‬
s->name (*s).name
.(: '<−' ‫א‬
: ‫א א‬ ‫•א‬
‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א א‬

. ‫א א‬ ‫א‬ ‫א א‬
‫ א‬main ‫ א‬main ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬
: ‫א א‬ ‫א‬ −
، ، : ‫אא‬ ‫א א‬ ‫א‬ ‫א‬
...
:‫א‬ ‫א א‬ ‫אא‬
//----------------------------------------------------------
#include<stdio.h>
#include <conio.h>
//----------------------------------------------------------
typedef struct
{
char name[30];
int age;
}data;
//----------------------------------------------------------
void display(data r);
//----------------------------------------------------------
main()
{
data std;
strcpy(std.name,"Talal");
std.age = 20;
display(std);
}
//----------------------------------------------------------
void display(data r)
{
printf("(r.name) = %s,\n(r.age) =
%d\n\n",r.name, r.age);
}
//----------------------------------------------------------
: ‫א א‬ ‫אא‬
void display(data r) ;
. data r ‫א‬ display ‫א‬

: ‫א‬ ‫א א‬
display( std ) ;
. display ‫א א‬ ‫א‬ ‫א‬
: main ‫א‬ ‫א א‬ ‫א‬
#include<stdio.h>
#include <conio.h>
typedef struct
{
char name[30];
int age;
}data;
void assign(data *r);
main()
{
data std;
assign(&std);
printf("std.name = %s,\nstd.age =
}
void assign(data *r)

{
strcpy(r->name,"Talal");
r->age = 20;
}
:‫א‬ ( ‫א א )א‬ ‫אא‬
void assign(data *r) ;
. ‫א‬ ( ) r r
: ‫א‬
assign( &std ) ;
‫א‬ ‫א א‬ assign ‫א א‬
.
) ‫ א א‬r age<−r name<−r assign ‫א א‬ ‫א‬
. ( '.' <− ‫א‬ ‫א‬
: ‫א א‬ −
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬
. ‫א‬ ‫א‬ ‫א‬
:‫א‬ ‫א‬
include<stdio.h> #
#include <conio.h>
typedef struct
{
char name[30];
int age;
}data;
data assign(void);
main()
{
data std;
std = assign();
printf("std.name = %s,\nstd.age =
}
data assign(void)
{
data r;
strcpy(r.name,"Talal");
r.age = 20;
return r;
}
: ‫א א‬
data assign(void) ;
‫א א‬ ‫א‬ ‫א‬ assign ‫א א‬

. data
:‫א‬ ‫א א‬
std = assign() ;
. std ‫א‬ ‫א א‬ ‫א‬ ‫א‬

data r ‫א‬ assign ‫א א‬
‫א‬ ‫א א‬ ‫אא‬
return r ;
: ‫א‬ •
. ‫א‬ ‫א‬ ‫א‬

: ‫א‬ ‫א‬
typedef struct
{
char name[30];
int age;
}data;
:‫א‬
data a, b ;
: ‫א‬ a ‫א‬
strcpy( a.name, "talal" ) ;

a.age = 20 ;
: ‫א‬ a ‫א‬ b ‫א א‬
b=a;
: ‫א‬ ‫א‬ ‫א‬ ‫א‬ •
: ‫א‬ ‫א‬
typedef struct
{
char name[30];
int age;
}data, MyData ;
. MyData data ‫א‬ ‫א‬ ‫א‬ ‫א‬

:
MyData student ;
data student ;
. ‫א‬
‫א‬ ‫א‬ ، ‫א‬ ‫א‬ ‫א‬
:
struct
{
‫א‬
‫؛‬ ‫א‬ {
١٠٠ ‫א‬ ١٠٠ ‫א‬ ‫א‬

:‫א‬ ‫א‬
struct
{
char name[30] ;
int age ;
} student;
: student ‫א‬
student. name & student. age

‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
:
( ‫א‬ struct (
}
‫א‬
‫א (؛‬ ‫{)א‬
:‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
struct data
{
char name[30] ;
int age ;
} student;
‫א‬ data student

:
struct data VAR ;
. student
: **
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א א א‬
: ‫א‬ ‫א‬
typedef struct
{
char name[30];
int age;
}data;
: ‫א‬ ‫א‬
data VAR ;
struct data
{
char name[30] ;
int age ;
};
: ‫א‬
struct data VAR ;
: ‫א‬
‫א‬ ‫א‬ ‫ א‬، ‫א‬ ‫א‬ ‫א‬
‫א‬
#define SQUARE(A) A*A
main()
{
int x;
cout<< “ Please enter a number to calculate it’s square “;
cin >> x;
cout << “ The square of “<< x << “is :” << SQUARE(x);
}
، ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫) א‬ ‫א‬ ‫א‬ ‫א‬

(
. ‫א‬ ‫א‬ ‫א א‬ ‫א‬
: ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
(Editors ) ‫א א‬ ‫א‬ ‫א‬ −١
".cpp " ‫א‬ ‫א‬ ( coding ) ‫א‬ ‫א‬
.(source file ) ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ( compilation ) ‫א‬ −٢
. "OBJ " ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ (Linking ) ‫א‬ ‫א‬ −٣
‫א‬ ‫א‬ ‫א‬ ‫ א‬."EXE" ‫א‬ ‫א‬ ‫א‬
. ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ، ‫א‬
. ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬

( (SQUARE(A ) ‫א‬ ‫א‬ ) ‫א‬
. ‫א א‬ ‫א‬
. ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א א‬

.‫א א א‬
‫א‬
‫א‬ ‫*א‬
int addition (int a, int b)
{
int r;
r=a+b;
return (r);
}
int main ()
{ int z,b,n;
Cin>>b,n;
z = addition (b,n);
cout << "The result is " << z;
return 0;
}
‫*א‬
void dummyfunction (void)
{
cout << "I'm a function!";
}
int main ()
{
dummyfunction ();
return 0;
}
‫א‬ ‫א‬ ‫*א‬
long factorial (long a)
{
if (a > 1)
return (a * factorial (a-1));
else
return (1);
}
int main ()
{
long l;
cout << "Type a number: ";
cin >> l;
cout << "!" << l << " = " << factorial (l);
return 0;
}
‫؟‬ ‫א‬ ‫*א‬
‫ ؟‬١,٣,٧,١٥,٣١,٦٣,١٢٧ ‫א‬ ‫ א‬// //*
* * ***** ‫א‬ ‫א‬ //*
*** *** ***
***** ***** *
***
*
‫א‬ ‫א‬ *
int main ()
{
int value1 = 5, value2 = 15;
int * mypointer;
mypointer = &value1;
*mypointer = 10;
mypointer = &value2;
*mypointer = 20;
cout << "value1==" << value1 << "/ value2==" <<
value2;
return 0;
} value1==10 / value2==20
‫א‬ ‫א‬ *
int main ()
{
int numbers[5];
int * p;
p = numbers; *p = 10;
p++; *p = 20;
p = &numbers[2]; *p = 30;
p = numbers + 3; *p = 40;
p = numbers; *(p+4) = 50;
for (int n=0; n<5; n++)
cout << numbers[n] << ", ";
return 0;
}
10, 20, 30, 40, 50,
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫*א‬
‫؟‬ ‫א‬
‫؟‬ ‫א‬ ‫א‬ ‫*א‬
‫א א‬ ‫א‬ ‫*א‬
‫א‬ ‫ א‬−
‫؟‬ ‫א א‬ ‫א‬ ‫א‬ -
‫א א‬ *
#include <string.h> Enter title: Alien
Enter year: 1979
#include <stdlib.h> My favourite movie is:
2001 A Space Odyssey (1968)
And yours:
struct movies_t { Alien (1979)
char title [50];

int year;
} mine, yours;
void printmovie (movies_t movie);
int main ()
{
char buffer [50];
strcpy (mine.title, "2001 A Space Odyssey");

mine.year = 1968;
cout << "Enter title: ";

cin.getline (yours.title,50);
cout << "Enter year: ";
cin.getline (buffer,50);
yours.year = atoi (buffer);
cout << "My favourite movie is:\n ";
printmovie (mine);
cout << "And yours:\n ";
printmovie (yours);
return 0;
}
void printmovie (movies_t movie)

{
cout << movie.title;
cout << " (" << movie.year << ")\n";
}
‫א א‬ *
#inculde<iostream.h>
#include<string.h>
Typ struct{
Char name[30];
Int age;
}
Data;
Int main(){
Data*s,std;
S=&std;
Strcpy(std.name,''ammar aldopaee');
Std.age=20;
Cout<<std.name;
Cout<<std.age;
Cout<<s->name;
Return();
}
‫اﻟﻤﺼﻔﻮﻓﺎت‬: ‫اﻟﻔﺼﻞ اﻟﺴﺎدس‬

‫א‬ ، ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬
. ‫א א‬ ‫ א‬، ‫א א‬ ‫א א‬ ‫א‬ ‫א‬
‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א א‬ ‫א א‬ ‫א‬

‫א‬ ‫א‬
. ‫א‬ C++
‫א‬ ‫א‬ ‫א‬ ‫א‬
A= [ 2 3 4 5 6]
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
.٢ [A[0 ‫א‬ ‫א‬
…‫א‬ ، A[2] = 4 ، A[1] = 3
‫א‬
int billy [] = {16, 2, 77, 40, 12071};

int n, result=0;
int main ()
{
for ( n=0 ; n<5 ; n++ )
{
result += billy[n];
}
cout << result;
return 0;
}
12206
‫ א‬C++ ‫א‬ ‫א‬

. ‫א‬ ‫א‬ ‫א‬
A ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

main()
{
1: int A[4];
for(int I=0 ; I<4 ; I++)

{
cout<<” Please enter the value of the element A[“ << I
<< ”]”;
cin >> A[I];
}
for(int I=0 ; I<4 ; I++)

{
cout<<” The value of the element A[“ << I << ”] is”
<< A[I];
}
}
‫א‬
) ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ 1 ‫א‬ ‫א‬
. ‫א‬ (int
‫א א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬
‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪ for‬א‬ ‫א‬

‫‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬
‫א‪.‬‬ ‫א‬ ‫א‬ ‫א‬ ‫‪ for‬א‬ ‫א‬

‫א‬
‫‪.‬‬ ‫‪،‬‬ ‫א‬ ‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬
‫‪12‬‬ ‫‪23‬‬ ‫‪15‬‬
‫‪89‬‬ ‫‪35‬‬ ‫=‪25 B‬‬
‫‪90‬‬ ‫‪80‬‬ ‫‪16‬‬
‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪١٢‬‬
‫א ‪.‬‬ ‫א‬ ‫א‬ ‫‪.B[0][0]=12‬‬
‫‪ ،‬א‬ ‫א‬ ‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬
‫א‬ ‫א‬
‫‪.B‬‬
‫‪B[1][2] = 35‬‬
‫‪B[2][1] = 80‬‬
B[0][2] = 15
B[2][2] = 16
‫א‬ ‫א א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
70 52 68 ‫א‬ ‫א‬
90 92 82 ‫א‬ ‫א‬
83 85 85 ‫א‬ ‫א‬
، ‫א‬ ‫אא‬ ‫א‬ ‫א‬
، ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ، ‫א‬
main()
{
float Degrees[3][3]; // Array declaration
// Array Element entry
for (int I=0 ; I<3 ; I++)

{
for(int J=0 ; J<3 ; J++)
{
cout<<” Enter the result of subject ” << I << “for
student “<< J;
cin >> Degrees[I][J] ;
}
};
// Array elements display
for (int I=0 ; I<3 ; I++)
{
for(int J=0 ; J<3 ; J++)
{
cout<<” the result of subject ” << I << “for student “<< J
<<”is”;
cout<< Degrees[I][J] ;
}
};
}
‫א‬ for ‫א‬ ‫א‬ ‫א‬

‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א א‬ ‫א א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬
‫א‬ ‫א‬ *
#include<conio.h> 1
main(){ 212
clrscr(); 32123
int s,d,a,b,m,c,x; 4321234
cin>>s;x=s;
for(d=1;d<=s;d++){
for(m=x;m>=1;m--){cout<<" ";}
x-=1;
if (d>=2){
for(c=d;c>=2;c--){
cout<<c;
}}
for(a=1;a<=d;a++){
cout<<a;}
cout<<"\n";
}
‫א‬ ‫א‬ *
#include<conio.h>
main(){int a,b,i,j;
clrscr();a=4;
int
x[5][5]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20
,21,22,23,24,25};
for(i=0;i<5;i++){
for(j=0;j<5;j++){
if(i==j){b=x[i][j];x[i][j]=x[i][a];x[i][a]=b;}
} a-=1;
}
for(i=0;i<5;i++){
for(j=0;j<5;j++){
cout<<x[i][j]<<" ";
}
cout<<"\n";
}
getch();
}
‫א‬ ‫א‬ ‫א א‬ ‫א‬ *
#include<conio.h>
main(){int a,b,i,j;
clrscr();a=4;
int
x[5][5]={11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,
27,28,29,30,31,32,33,34,35};
for(i=0;i<5;i++){
for(j=0;j<5;j++){
if(i>j){b+=x[i][j];}
}
}
for(i=0;i<5;i++){
for(j=0;j<5;j++){
cout<<x[i][j]<<" ";
}
cout<<"\n";
} cout<<b;
getch();
}
‫؟‬ ‫א אא‬ ‫א‬ ‫א‬ ‫*א‬
‫؟‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫*א‬
‫؟‬ ‫א‬ ‫א‬ ‫*א‬
‫؟‬ ‫א‬ ‫*א‬
( Classes & Objects ) ‫ اﻟﻔﺼﺎﺋﻞ واﻟﻜﺎﺋﻨﺎت‬: ‫اﻟﻔﺼﻞ اﻟﺴﺎﺑﻊ‬
‫א‬ ‫א‬ ‫א‬ ‫אא‬
. ‫א‬ ‫א‬
(١ ) ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬
class class_name{
private:
private data and functions
public :
public data and functions
}
‫א‬ ‫א‬ ‫א‬١
: ‫א‬ ‫א‬
‫א‬ (class_name ) ‫א א‬ ( class ) ‫א‬ ‫א‬:

: ‫א‬ ‫א‬
( Reserved words ) ‫א‬ ‫א‬ ‫א א‬ −

‫א‬ ‫א‬ ‫א‬ ( main ) ‫א‬ ‫א‬
. ‫א‬ ‫א‬
‫( א‬A-Z ) ‫א‬ ‫א‬ ‫א‬ −

_) ‫א‬ ‫א‬ (0-9 ) ‫א‬ ،
. ‫א‬ (
، ‫א‬ ‫א‬ ‫א‬ ، ‫א‬ −
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ‫א‬
) ‫א א‬ ++C ‫א‬ ‫א‬ ‫א‬−

) ‫א‬ (my_class ) ‫א‬ (MY_CLASS
.(My_Class
( private ) ‫א‬ ‫א‬ ، ‫א‬ :

. ‫א א א‬ ‫א‬ ‫א‬
( public ) ‫א‬ ‫א‬ ‫א‬ ‫אא‬ ، :

. ‫א‬
. ‫א א‬ ‫א‬ (٢ ) ‫א‬ ‫א‬ ‫א‬

01: #include <iostream.h>
02: class smallobj // class name
03:{
04: private:
05: int somedata; //class data
06: public:
07: void setdata (int d); // member function to set data
08: {somedata= d;}
09: void showdata() // mamber function to display data
10: { cout << “ \n Data is “ << somedata;}
11:};
12: void main()

13:{
14: smallobj s1,s2; // define two objects of the class
15: s1.setdata(1096); //call member function to set data

‫‪16:‬‬ ‫;)‪s2.setdata(200‬‬
‫;)(‪17: s1.showdata‬‬
‫;)(‪18: s2.showdata‬‬
‫}‪19:‬‬
‫‪٢‬‬
‫א‬ ‫א‬ ‫אא‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א א א‬ ‫א‬
‫‪:‬‬ ‫א‬
‫א‬ ‫א‬ ‫)‪( smallobj‬‬ ‫א‬ ‫‪: 02‬‬ ‫א‬

‫‪.C‬‬ ‫א‬ ‫" ‪، "//‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫‪:05 04‬‬ ‫א‬
‫‪،‬‬ ‫א‬ ‫א‬ ‫‪:06‬‬ ‫א‬

‫‪.‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א א‬ ‫‪10 07‬‬ ‫א‬

‫א‬ ‫א‬ ‫‪10‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫‪.C‬‬
‫א )(‪. main‬‬ ‫א‬ ‫‪12‬‬ ‫א‬ ‫א‬
‫א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫‪14‬‬ ‫א‬

‫‪.‬‬ ‫א א‬ ‫א‬
‫‪،‬‬ ‫א‬ ‫א א ) )(‪( setdata‬‬ ‫‪15‬‬ ‫א‬
‫) ‪ (.‬א א א‬ ‫א א‬ ‫) ‪،(.‬‬ ‫א א‬ ‫א‬
‫א א א ‪.‬‬ ‫א א‬
‫)‬ ‫א‬ ‫א א ) ‪( ()showdata‬‬ ‫א‬ ‫‪١٨ 17‬‬ ‫א‬
‫‪.(s1,s2‬‬
‫‪:‬‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫" א‬ ‫א‬ ‫"‬
‫א א‬ ‫)א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬
‫(‬
‫א‬ ‫א‬ ‫א‬ ‫א‬
‫א‬
‫א‬
‫‪public‬‬
‫א א‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬
‫א‬ ‫‪،‬‬ ‫א‬ ‫‪protected‬‬
‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫‪private‬‬
‫א א‬
‫‪:‬‬ ‫א א‬
‫א א‬ ‫‪،‬‬ ‫א‬ ‫א‬ ‫א א‬
‫‪.‬‬ ‫א‬ ‫א‬
‫‪.‬‬ ‫א‬ ‫א‬ ‫א א‬
‫א א‬ ‫א‬ ‫א‬
(a,b) ‫א‬ ‫א‬ ‫א‬
# include “iostream.h”
class MyClass
{
int a,b;
public:
MyClass (int i, int j)
{
a=i;
b=j;
}
void Show()
{
cout << a<< “ “<<b;
}
};
void main()
{
MyClass C1(2,6);
C1.Show();
}
( MyClass ) ‫א‬ ‫א‬ ‫א‬ ‫אא‬

. ‫א א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א א‬ ‫א‬
. ‫( א‬a,b )
( a,b ) ‫א‬ ‫ ( א‬Show() ) ‫א‬ ‫א‬
( C1 ) ‫א‬ ‫א‬ ‫א‬ ‫א‬
: ‫א‬
‫א‬ ، ‫א‬ ‫א‬ ‫א‬
. ‫א‬ ‫א א‬ ‫א א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬ C++
. ‫א א‬ ‫א‬ ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬
class Date
{ public:
int day,month,year;
set_date(int d, int m, int y)
{day=d; month=m; yaer=y;}
};
main()
{
Date date_array[3];
date_array[0].set_date(2,3,1990);
}
‫א‬ ‫א‬ ( Date ) ‫אא‬

. ‫א א א‬
، ‫א‬ ‫א‬ ‫א‬
‫א‬ ( set_date ) ‫א א‬ ‫א‬ ‫א‬ ‫א‬
. ‫א‬
‫א‬ ‫א‬ ‫א‬ ‫א‬
‫) א‬ ‫א‬ ‫א‬ ( pointers ) ‫א‬ ‫א‬
. ‫א‬ ‫א‬ ‫א א‬ ‫א‬ ‫א‬ ( ‫א‬
‫א‬ ، ‫א‬ ‫א‬ ‫א א‬ ‫ א‬C++
) ‫א‬ ‫א‬ ‫א‬ ‫ ( א‬Date ) ‫א‬
‫א‬ ( ‫؛‬Date *dptr
class Date
{ public:
int day,month,year;
set_date(int d, int m, int y)
{day=d; month=m; yaer=y;}
};
main()
{
Date *dptr;
Date date;
Dptr -> day=3;
Date.day=4;
}
، (dptr ) ( date ) ‫א‬ ‫אא‬

‫א‬ ( -> ) ‫א‬ ‫א‬
.( date ) ‫א‬ (. ) ‫א‬ ‫א‬ ( day ) ‫א‬
. ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬ ‫א‬

‫ﺍﺧﺘﺒﺎﺭ ﺗﺠﺮﻳﺒﻲ‬
‫‪/١‬ﺃﻭﺟﺪ ﺍﻟﻤﺘﺴﻠﺴﻼﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
‫*ﺃﻭﺟﺪ ﻫﺬﻩ ﺍﻟﺴﻠﺴﻠﺔ ﺑﺪﻭﻥ ﺍﺳﺘﺨﺪﺍﻡ ﻋﺪﺍﺩ ﻣﺠﻤﻊ ﻟﻠﺮﻗﻢ ‪ ٤‬ﻣﺜﻞ ‪c+=4‬‬
‫‪1 5 9 13 17 21 25‬‬
‫* ‪1 5 9 17 3 36 4 20 81‬‬
‫* ‪2 6 12 20 30 42 56 72‬‬
‫* ‪1 3 7 15 31 63 127‬‬
‫* ‪1 3 6 18 24 30 36‬‬
‫‪/٢‬ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﺴﺘﻘﺒﻞ ﻋﺪﺩ ﻭﻳﻘﻮﻡ ﺑﺎﻷﻋﻤﺎﻝ ﺍﻟﺘﺎﻟﻴﺔ ‪N=245496‬‬

‫‪A=30‬‬ ‫ﻣﺠﻤﻮﻋﻬﻢ‬
‫‪B=5‬‬ ‫ﻣﺘﻮﺳﻂ ﺍﻷﻋﺪﺍﺩ‬
‫‪C=6‬‬ ‫ﻋﺪﺩﻫﻢ‬
‫‪D=2‬‬ ‫ﺃﺻﻐﺮﻫﻢ‬
‫‪E=4‬‬ ‫ﺍﻟﻌﺪﺩ ﺍﻟﻤﻜﺮﺭ‬
‫‪H=9‬‬ ‫ﺃﻛﺒﺮﻫﻢ‬
‫‪/٣‬ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻄﺒﻊ ﺍﻟﻌﻨﺼﺮ ﺍﻻﻛﺘﺮ ﺗﻜﺮﺍﺭﺍ ؟‬

‫‪/٤‬ﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﺑﻮﺍﺳﻄﺔ ﺩﺍﻟﺔ ﺗﺄﺧﺬ ﻗﻴﻤﺘﻴﻦ ﻣﻦ ﻧﻮﻉ ﺃﺗﺘﺠﺮ ﻭﺗﺮﺩ ﻟﻠﺒﺮﻧﺎﻣﺞ‬
‫ﺍﻟﺮﺋﻴﺴﻲ ﺃﺭﺑﻌﺔ ﻧﻮﺍﺗﺞ ‪.....‬ﺟﻤﻌﻬﻢ‪.‬ﺿﺮﺑﻬﻢ‪.‬ﻃﺮﺣﻬﻢ‪.‬ﺑﺎﻗﻲ ﺍﻟﻘﺴﻤﺔ ؟‬
‫‪/٥‬ﺩﺍﻟﺔ ﺗﻌﻤﻞ ﻋﻠﻰ ﺗﺮﺗﻴﺐ ﻣﺼﻔﻮﻓﺔ ﻭﻗﺖ ﺍﻹﺩﺧﺎﻝ ﻭﻻ ﺗﻘﺒﻞ ﺍﻷﻋﺪﺍﺩ ﺍﻟﻤﻜﺮﺭﺓ ؟‬
‫‪ /٦‬ﺩﺍﻟﺔ ﺑﻮﺍﺳﻄﺔ ﻣﺆﺷﺮ ﺗﺪﺧﻞ ‪ n‬ﻣﻦ ﺍﻷﻋﺪﺍﺩ ﻭﺗﻄﺒﻊ ﺍﻟﻌﻨﺎﺻﺮ ﺍﻟﻐﻴﺮ ﻣﺘﻜﺮﺭﺓ ؟‬
‫‪/٧‬ﺑﺮﻧﺎﻣﺞ ﻳﺒﺤﺚ ﻋﻦ ﺍﻛﺒﺮ ﻋﻨﺼﺮ ﻭﻳﺒﺪﻟﻪ ﻣﻊ ﺃﻭﻝ ﻋﺪﺩ ﺯﻭﺟﻲ ؟‬
‫‪/٨‬ﻣﺼﻔﻮﻓﺔ ﺛﻨﺎﺋﻴﺔ ﺍﻟﺒﻌﺪ ﺗﻌﺮﻑ ﺑﺎﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﺗﺴﺘﺪﻋﻴﻬﺎ ﺩﺍﻟﺔ ﻓﺮﻋﻴﺔ‬

‫ﺑﻮﺍﺳﻄﺔ ﻣﺆﺷﺮ ﻟﻴﻐﻴﺮ ﻋﻨﺎﺻﺮ ﺍﻟﺼﻒ ﺍﻟﺜﺎﻧﻲ ﻓﻘﻂ ﻭﺗﻄﺒﻊ ﺍﻟﻤﺼﻔﻮﻓﺔ ؟‬
‫‪/٩‬ﺑﻮﺍﺳﻄﺔ ﺩﺍﻟﺔ ﻭﺍﺣﺪﺓ ﻓﻘﻂ ﺍﻋﻤﻞ ﺑﺮﻧﺎﻣﺞ ﺑﺈﺩﺧﺎﻝ ﻋﻨﺎﺻﺮ ﻟﻤﺼﻔﻮﻓﺔ ﻭﺗﺒﺪﻳﻞ‬
‫ﺍﻷﻋﺪﺍﺩ ﺍﻟﻔﺮﺩﻳﺔ ﻣﻜﺎﻥ ﺍﻟﺰﻭﺟﻴﺔ ﻭﻃﺒﺎﻋﺔ ﺍﻟﻤﺼﻔﻮﻓﺔ ؟‬
‫‪ /١٠‬ﺃﻧﺸﺊ ﺍﻷﺷﻜﺎﻝ ﺍﻟﺘﺎﻟﻴﺔ‬
‫‪1111111111‬‬
‫‪11111111111111111‬‬
‫‪1222222221‬‬
‫‪122222222222221‬‬
‫‪1233333321‬‬
‫‪123333333321‬‬
‫‪1234444321‬‬
‫‪123444321‬‬
‫‪1234554321‬‬
‫‪1234321‬‬
‫‪1234444321‬‬
‫‪12321‬‬
‫‪1233333321‬‬
‫‪121‬‬
‫‪1222222221‬‬
‫‪1 n=4‬‬
‫‪1111111111 n=10‬‬
‫*‬ ‫*‬
‫**‬ ‫**‬
‫***‬ ‫***‬
‫****‬ ‫****‬
‫***** *****‬
‫***********‬
‫***** *****‬
‫****‬ ‫****‬
‫***‬ ‫***‬
‫**‬ ‫**‬
‫*‬ ‫*‬
‫ﺍﻟﺨﺎﺗﻤﺔ‬
‫ﺇﻟﻰ ﻛﻞ ﻣﻦ ﺍﻧﺘﻔﻊ ﺑﻬﺪﻯ ﺍﻟﻜﺘﺎﺏ‬
‫ﺇﻟﻰ ﻛﻞ ﻣﺴﻠﻢ ﻭﻣﺴﻠﻤﺔ‬
‫ﺇﻟﻰ ﻛﻞ ﻣﻦ ﻳﺸﻬﺪ ﺃﻥ ﻹﻟﻪ ﺇﻻ ﺍﷲ ﻣﺤﻤﺪ‬
‫ﺭﺳﻮﻝ ﺍﷲ‬
‫ﺍﺭﺟﻮﺍ ﺍﻟﺪﻋﺎﺀ ﻟﻲ ﻭﻟﻤﻦ ﻳﺼﻠﻲ ﻋﻠﻰ ﺍﻟﻨﺒﻲ‬
‫ﺍﻷﻣﻲ‬
‫ﺻﻠﻮﺍﺕ ﺍﷲ ﻭﺳﻼﻣﻪ ﻋﻠﻴﻚ ﻳﺎ ﺣﺒﻴﺒﻲ ﻣﺤﻤﺪ‬
‫ﺍﺑﻦ ﻋﺒﺪ ﷲ‬
‫ﻭﺍﻟﺤﻤﺪ ﷲ‪.‬‬
‫اﻟﻤﺮاﺟﻊ‬
‫آﻴﻒ ﺗﺒﺮﻣﺞ ﺑﻠﻐﺔ اﻟﺴﻲ ‪........ ++‬د‪/‬ﺻﻼح‬
‫اﻟﻮﻩ ﺟﻲ‬
‫اﻟﻤﺮﺟﻊ اﻟﺸﺎﻣﻞ ﻓﻲ ﺑﺮﻣﺠﺔ اﻟﺴﻲ‪.........‬ﻋﻮض‬
‫ﻣﻨﺼﻮر‬
‫ﺑﻌﺾ ﺻﻔﺤﺎت اﻟﻮﻳﺐ‬

المرجع الشامل فى ال ++VC

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

المرجع الشامل فى ال ++VC

Uploaded by

Copyright:

Available Formats

‫ﻃﺮﻳﻖ اﻟﺒﺮﻣﺠﺔ‬

‫هﺎﻧﻲ اﻷﺗﺎﺳﻲ – اﻟﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ‬

‫‪ 1.2‬ﺗﺮﺟﻤﺔ وﺑﻨﺎء اﻟﻤﺸﺮوع‬

‫ﺷﻜﻞ ‪5- 1‬‬

‫‪8‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 1.3‬اﻷهﻢ ﻣﻦ ﺗﻌﻠﻢ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ‬

‫)‪PROGRAM 1.2 (b‬‬

‫;‪sum = 10 + 20‬‬ ‫‪// Store 10 + 20 in sum‬‬

‫;)‪return (0‬‬ ‫‪// End the program‬‬

‫‪9‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪10‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫اﻷﻧﻮاع واﻟﻌﻮاﻣﻞ واﻟﺘﻌﺎﺑﻴﺮ – ‪Types, Operators, and Expressions‬‬

‫‪ 2.1‬اﻟﺜﻮاﺑﺖ اﻟﺼﺤﻴﺤﺔ – ‪Integer Constants‬‬

‫‪ 2.2‬اﻟﺜﻮاﺑﺖ ﻟﻸﻋﺪاد اﻟﺤﻘﻴﻘﺔ – ‪Floating point Constants‬‬

‫‪11‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 2.3‬ﺛﻮاﺑﺖ اﻟﻤﺤﺎرف – ‪Character constants‬‬

‫‪ 2.4‬ﺛﻮاﺑﺖ اﻟﺴﻼﺳﻞ اﻟﻨﺼﻴﺔ – ‪String constants‬‬

‫‪12‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫\ ‪“This string extends‬‬

‫‪h‬‬ ‫‪e‬‬ ‫‪l‬‬ ‫‪l‬‬ ‫‪o‬‬ ‫‪\0‬‬

‫ﺷﻜﻞ ‪6- 2‬‬

‫‪13‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪asm‬‬ ‫‪auto‬‬ ‫‪bad_cast‬‬ ‫‪bad_typeid‬‬

‫‪ 2.6‬ﺗﻌﺮﻳﻒ اﻟﻤﺘﺤﻮﻻت – ‪Variable definition‬‬

‫‪14‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪int‬‬ ‫‪day, month, year,‬‬

‫‪x‬‬ ‫‪25 1234‬‬

‫ﺷﻜﻞ ‪7- 2‬‬

‫‪15‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪16‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪Type Name‬‬ ‫‪Bytes‬‬ ‫‪Other Names‬‬ ‫‪Range of Values‬‬

‫‪17‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 2.8‬اﻟﺘﻌﺎﺑﻴﺮ اﻟﺤﺴﺎﺑﻴﺔ – ‪Arithmetic expressions‬‬

‫‪18‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 2.9‬اﻟﺘﺤﻮﻳﻞ ﺑﻴﻦ اﻷﻧﻮاع – ‪Type conversions‬‬

‫‪19‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 2.10‬ﻣﻌﺎﻣﻞ اﻻﻟﺤﺎق – ‪The assignment operator‬‬

‫‪20‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 2.11‬ﻣﻌﺎﻣﻼت اﻻﻟﺤﺎق اﻟﻤﺮآﺒﺔ – ‪The compound assignment operator‬‬

‫‪ 2.12‬ﻣﻌﺎﻣﻼ اﻟﺰﻳﺎدة واﻟﻨﻘﺼﺎن – ‪The increment and decrement operators‬‬

‫‪21‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 2.13‬ﻣﻌﺎﻣﻞ اﻟﺘﺤﻮﻳﻞ – ‪The type cast operator‬‬

‫‪22‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 2.14‬ﻣﻌﺎﻣﻞ اﻟﻔﺎﺻﻠﺔ – ‪The comma operator‬‬

‫أوﻟﻮﻳﺎت اﻟﻤﻌﺎﻣﻼت اﻟﻤﺬآﻮرة ﻓﻲ هﺬا اﻟﺪرس ‪:‬‬

‫‪23‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫ﻣﺒﺎدئ اﻻدﺧﺎل واﻻﺧﺮاج – ‪Simple Input and Output‬‬

‫‪ 3.2‬اﻻﺧﺮاج ﻏﻴﺮ اﻟﻤﻨﺴﻖ – ‪Unformatted output‬‬

‫‪24‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 3.3‬اﻻدﺧﺎل ﻏﻴﺮ اﻟﻤﻨﺴﻖ – ‪Unformatted input‬‬

‫‪ 3.4‬ﺗﻨﺴﻴﻖ اﻟﺨﺮج – ‪Manipulating the output‬‬

‫‪25‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪ 3.5‬اﻟﺘﺎﺑﻌﻴﻦ ‪ get‬و ‪The functions get and put – put‬‬

‫‪26‬‬ ‫ﺣﻘﻮق اﻟﻨﺸﺮ ﻣﺤﻔﻮﻇﺔ ﻟﻠﻔﺮﻳﻖ اﻟﻌﺮﺑﻲ ﻟﻠﺒﺮﻣﺠﺔ ‪(http://www.arabteam2000.com) 2001‬‬

‫‪PDF created with pdfFactory Pro trial version www.pdffactory.com‬‬

‫‪PDF created with pdfFactory Pro trial version www.pdffactory.com‬‬

‫‪PDF created with pdfFactory Pro trial version www.pdffactory.com‬‬

‫‪PDF created with pdfFactory Pro trial version www.pdffactory.com‬‬

‫‪PDF created with pdfFactory Pro trial version www.pdffactory.com‬‬

‫‪PDF created with pdfFactory Pro trial version www.pdffactory.com‬‬

‫رﻣﻮز ﻟﻐﺔ ‪C++‬‬

‫*ﻛﻠﻤﺎت ﻟﻐﺔ ‪C++‬‬

‫وﺗﻄﻠﻖ اﻷﺳﻤﺎء اﻟﺘﻌﺮﻳﻔﻴﺔ ﻋﻠﻰ‪-:‬‬

‫‪PDF created with pdfFactory Pro trial version www.pdffactory.com‬‬