كتاب خطوة بخطوة لتعلم لغة سي وسي بلاس

					                                                                            ‫ﻋن اﻟﻛﺗﺎب‬
‫ﯾﺗﻧﺎول ھذا اﻟﻛﺗﺎب ﻟﻐﺔ )++‪ (c,c‬ﺑﺄﺳﻠوب ﺗدرﯾﺳﻲ وﺑﺷﻛل ﺗﻔﺻﯾﻠﻲ ﺟدا ﺣﯾث ﯾﺳﺗطﯾﻊ ﻣﻧﮫ اﻟﻣﺑﺗدأ ﺟدا اﻟﺑدء‬
      ‫ﺑﺗﻌﻠم ھذه اﻟﻠﻐﺔ وﻛﺗﺎﺑﺔ اﻟﺑراﻣﺞ واﻟﻣطور ﯾطور ﻗدراﺗﮫ أﻛﺛر وﺗﺟد اﻧﮫ ﻋﻧد ﻛﺗﺎﺑﺔ أي ﺑرﻧﺎﻣﺞ ﺳﯾوﺿﺢ ﻟك‬
 ‫اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ وﻛﯾف ﺣدﺛت ﺣﺗﻰ ﯾﺳﺗطﯾﻊ اﻟﻘﺎرئ ﻓﮭم ﺟﻣﯾﻊ اﻻﻛواد اﻟﺑرﻣﺟﯾﺔ وﯾﻛون ﻋﻠﻰ ﺗواﺻل ﻣﻊ‬
                                                                                            ‫اﻟﻛﺗﺎب‬
  ‫اھدي ھذا اﻟﻛﺗﺎب إﻟﻰ أﻣﻲ وﻣن ﻏﯾر أﻣﻲ ﯾﺳﺗﺣق ھذا اﻹھداء ﻓﻠك ﯾﺎ أﻣﻲ اھدي ھذا اﻟﻛﺗﺎب‬
‫ﯾﺎ أطﯾب ﻣن رأت ﻋﯾﻧﺎي ﻓﻲ اﻟدﻧﯾﺎ ﻓﺟزأك ﷲ ﻋﻧﻲ وأﺧوﺗﻲ ﺧﯾر اﻟﺟزاء أطﺎل ﷲ ﻟﻧﺎ ﺑﻌﻣرك‬




                                                                           ‫اﻟﻣؤﻟف :‬
                                                                ‫ﺣﺳﯾن اﺣﻣد طﺎﻟب اﻟرﺑﯾﻌﻲ‬

                                                                     ‫اﻟﻌراق/ ﺟﺎﻣﻌﺔ دﯾﺎﻟﻰ‬

                                                             ‫ھﻧدﺳﺔ اﻟﺣﺎﺳﺑﺎت واﻟﺑرﻣﺟﯾﺎت‬

                                                                ‫اﻟﻣرﺣﻠﺔ اﻟراﺑﻌﺔ )٢١٠٢(‬

                                                                                 ‫اﻟﻣدوﻧﺔ‬
                                                     ‫/‪http://hussienahmmed.blogspot.com‬‬

                                                                        ‫اﻟﺑرﯾد اﻻﻟﻛﺗروﻧﻲ‬
                                                                ‫‪hussien89aa@yahoo.com‬‬

                                                                                 ‫ھﺎﺗف‬
                                                                  ‫٦٥٣١٥٥٣٠٧٧٤٦٩+‬
                    ‫اﻟﻣﺣﺗوﯾﺎت‬

‫اﻟﻔﺻل اﻷول : اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬

                         ‫- اﻟﺗﻌرف ﻋﻠﻰ اﻟﺑرﻧﺎﻣﺞ اﻟﻣﺳﺗﺧدم ﻓﻲ ﺗﻧﻔﯾذ اﻟﺑراﻣﺞ:‬     ‫‪‬‬
                                            ‫٢.١- اﻟﮭﯾﻛﻠﯾﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺑرﻧﺎﻣﺞ :‬   ‫‪‬‬
                                                          ‫٣.١- اﻟﻣﺗﻐﯾرات :‬    ‫‪‬‬
                                                      ‫٤.١- دوال اﻹﺧراج :‬      ‫‪‬‬
                                                      ‫٥.١ - دوال اﻹدﺧﺎل :‬     ‫‪‬‬
               ‫٦.١- اﻟﻌﻣﻠﯾﺎت اﻟﺣﺳﺎﺑﯾﺔ وطرق ﺗﻣﺛﯾﻠﮭﺎ وأوﻟوﯾﺎﺗﮭﺎ )اﻷﺳﺑﻘﯾﺔ(:‬      ‫‪‬‬
                                             ‫٧.١- ﺗﻣﺛﯾل اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ:‬    ‫‪‬‬
                                          ‫٨.١- اﻷﺳﺑﻘﯾﺎت وطرق ﻣﻌﺎﻣﻠﺗﮭﺎ :‬       ‫‪‬‬
                                                      ‫٩.١- إﺿﺎﻓﺔ ﺗﻌﻠﯾﻘﺎت:‬     ‫‪‬‬
                                          ‫٠١.١- ﻣؤﺛرات اﻟزﯾﺎدة واﻟﻧﻘﺻﺎن:‬      ‫‪‬‬
      ‫١١.١- ﺑﻌض دوال اﻹدﺧﺎل واﻹﺧراج ﻓﻲ ﻟﻐﺔ )‪ (C‬ﻓﻲ ﻣﻛﺗﺑﺔ >‪<stdio.h‬‬             ‫‪‬‬
                       ‫٢١.١- ﺑﻌض دوال اﻹدﺧﺎل ﻓﻲ ﻣﻛﺗﺑﺔ >‪<conio.h‬‬               ‫‪‬‬
                               ‫٣١.١- دوال اﻟرﯾﺎﺿﯾﺔ ﻓﻲ ﻣﻛﺗﺑﺔ >‪<math.h‬‬          ‫‪‬‬
                                   ‫٤١.١- دوال اﻟﺗﺣوﯾل )‪(int,char,sizeof‬‬       ‫‪‬‬
                               ‫٥١.١- ﻣﺎذا اﻛﺗﺷﻔت ﺑﻌد ان اﻧﺗﮭﯾﻧﺎ ﻣن اﻟﻔﺻل‬      ‫‪‬‬


      ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ: اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ)‪(if ,Switch‬‬

                                                ‫١.٢- ﻋﺑﺎرة )‪ (if‬اﻟﺷرطﯾﺔ اﻻﻋﺗﯾﺎدﯾﺔ:‬    ‫‪‬‬
                                                  ‫٢.٢- ﻋﺑﺎرة )‪ (if--else‬اﻟﺷرطﯾﺔ :‬     ‫‪‬‬
                                                  ‫٣.٢- اﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬   ‫‪‬‬
                                              ‫٤.٢- ﻋﺑﺎرة )‪ (if—else if‬اﻟﺷرطﯾﺔ :‬       ‫‪‬‬
                                         ‫٥.٢- ﻋﺑﺎرة )‪ (Switch—Case‬اﻟﺷرطﯾﺔ :‬           ‫‪‬‬
‫اﻟﻔﺻل اﻟﺛﺎﻟث: ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار)‪(For , While , Do—While‬‬

                            ‫١.٣- ﻋﺑﺎرة )‪ ( For--Loop‬اﻟﺗﻛرارﯾﺔ اﻻﻋﺗﯾﺎدﯾﺔ:‬         ‫‪‬‬
                            ‫٢.٣- ﻋﺑﺎرة )‪ ( For--Loop‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬        ‫‪‬‬
                                                      ‫٣.٣- ﻋﺑﺎرة )‪: ( Break‬‬      ‫‪‬‬
                                                  ‫٤.٣- ﻋﺑﺎرة )‪: ( continue‬‬       ‫‪‬‬
                                                        ‫٥.٣- ﻋﺑﺎرة )‪: (go to‬‬     ‫‪‬‬
                                            ‫٦.٣- ﻋﺑﺎرة )‪ ( While‬اﻟﺗﻛرارﯾﺔ :‬      ‫‪‬‬
                                  ‫٧.٣- ﻋﺑﺎرة )‪ ( While‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬      ‫‪‬‬
                                      ‫٨.٣- ﻋﺑﺎرة )‪ (Do-- While‬اﻟﺗﻛرارﯾﺔ :‬        ‫‪‬‬
                             ‫٩.٣- ﻋﺑﺎرة )‪ (do-- While‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ:‬        ‫‪‬‬
                   ‫٠١.٣- اﻟﻔرق ﺑﯾن دوال اﻟﺗﻛرار )‪..(for,while,do—while‬؟‬          ‫‪‬‬




                    ‫اﻟﻔﺻل اﻟراﺑﻊ: اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ )‪(Array‬‬

                                             ‫١.٤- اﻟﻣﺻﻔوﻓﺎت اﻷﺣﺎدﯾﺔ اﻷﺑﻌﺎد :‬     ‫‪‬‬
                                               ‫٢.٤- ﺗرﺗﯾب ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺎت:‬       ‫‪‬‬
                                                ‫٣.٤- اﻟﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ اﻷﺑﻌﺎد:‬    ‫‪‬‬
                                         ‫٤.٤- ﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ اﻷﺑﻌﺎد:‬     ‫‪‬‬
                                                     ‫٥.٤- اﻟﻧﺻوص )‪:(string‬‬       ‫‪‬‬



                               ‫اﻟﻔﺻل اﻟﺧﺎﻣس: اﻟدوال ) ‪(Function‬‬

                                                  ‫١.٥- اﻟدوال )‪:(Function‬‬        ‫‪‬‬
                                    ‫٢.٥- دوال )‪ (function‬ﺑدون ﻗﯾﻣﺔ ﻣﻌﺎدة :‬       ‫‪‬‬
                                       ‫٣.٥- اﻹرﺳﺎل ﺑﺎﻟﻘﯾﻣﺔ واﻹرﺳﺎل ﺑﺎﻟﻣرﺟﻊ:‬      ‫‪‬‬
                                                           ‫٤.٥- اﻟدوال اﻟزاﺋدة‬   ‫‪‬‬
                                 ‫٥.٥- اﺳﺗدﻋﺎء اﻟداﻟﺔ ﻟﻧﻔﺳﮭﺎ )‪:(Recursively‬‬       ‫‪‬‬
                                                    ‫٦.٥- اﻟﻣﺻﻔوﻓﺎت واﻟدوال:‬      ‫‪‬‬
                      ‫اﻟﻔﺻل اﻟﺳﺎدس: اﻟﻣؤﺷرات ) ‪(pointer‬‬

                                                   ‫١.٦- اﻟﻣؤﺷرات:‬        ‫‪‬‬
                                        ‫٢.٦- اﻟﻣؤﺷرات واﻟﻣﺗﻐﯾرات:‬        ‫‪‬‬
                                             ‫٣.٦- اﻟداﻟﺔ )‪: (NEW‬‬         ‫‪‬‬
                                       ‫٤.٦- اﻟﻣؤﺷرات واﻟﻣﺻﻔوﻓﺎت:‬         ‫‪‬‬
                                 ‫٥.٦- اﻟﻣؤﺷرات واﻟدوال )‪(function‬‬        ‫‪‬‬




                     ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ: اﻟﺗراﻛﯾب )‪(Structures‬‬

                                   ‫١.٧- اﻟﺗراﻛﯾب )‪(Structures‬‬            ‫‪‬‬
              ‫٢.٧- اﻟﺗراﻛﯾب اﻟﻣﺗداﺧﻠﺔ ) ‪(Structure in Structure‬‬          ‫‪‬‬
                            ‫٣.٧- ﻣﺻﻔوﻓﺔ ﺗراﻛﯾب ) ‪(Structures‬‬             ‫‪‬‬
                    ‫٤.٧- ﻣﺻﻔوﻓﺔ ﺗراﻛﯾب ) ‪ (Structures‬ﻣﺗداﺧﻠﺔ‬             ‫‪‬‬


                                    ‫اﻟﻔﺻل اﻟﺛﺎﻣن:اﻟﻣﻠﻔﺎت )‪(File‬‬

                                                 ‫١.٨- اﻟﻣﻠﻔﺎت )‪:(File‬‬    ‫‪‬‬
                                     ‫٢.٨- اﻟﻛﺗﺎﺑﺔ ﻓﻲ اﻟﻣﻠﻔﺎت اﻟﻧﺻﯾﺔ:‬     ‫‪‬‬
                                     ‫٣.٨- اﻟﻘراءة ﻣن اﻟﻣﻠﻔﺎت اﻟﻧﺻﯾﺔ:‬     ‫‪‬‬
                                     ‫٤.٨- اﻟﻛﺗﺎﺑﺔ ﻓﻲ اﻟﻣﻠﻔﺎت اﻟﺛﻧﺎﺋﯾﺔ:‬   ‫‪‬‬
                                     ‫٥.٨- اﻟﻘراءة ﻣن اﻟﻣﻠﻔﺎت اﻟﺛﻧﺎﺋﯾﺔ:‬   ‫‪‬‬
                            ‫٦.٨- اﻟداﻟﺔ )‪ (seek‬ﻟﻠﺗﺣرك داﺧل اﻟﻣﻠﻔﺎت:‬      ‫‪‬‬




                                                                 ‫اﻟﻣﻠﺣﻘﺎت‬

                                                          ‫‪ ‬اﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬
‫‪ ‬ﺑرﻧﺎﻣﺞ ﺗﻌﻠﯾﻣﻲ ﻷﺧﺗﺑﺎر ﻗدراﺗك اﻟﺑرﻣﺟﯾﺔ وﺗﻧﻣﯾﺔ اﻻﻓﻛﺎر ﺗﺟده ﻣرﻓق ﻣﻊ اﻟﻛﺗﺎب‬
             ‫ﻛﺛﯾرا ﻣﻧﺎ ﻣن ﯾﺟد ﺻﻌوﺑﺔ ﻓﻲ ﻛﺗﺎﺑﺔ اﻟﺑراﻣﺞ أو اﻧﮫ ﯾﻌرف ﻛل ﺷﻲء وﻓﺎھم ﻟﻛل ﻣﻛوﻧﺎت ﺗﻠﻛم‬

            ‫اﻟﻠﻐﺔ وﻟﻛن ﻻ ﯾﻌرف ﻛﯾف ﯾرﺑط ﺑﯾن ﺗﻠﻛم اﻟﻣﺣﺗوﯾﺎت ﻛﺗﻠك اﻟﺗﻲ ﺗﻌرف ﻣﻛوﻧﺎت ﻛل أﻛﻠﺔ وﻛﯾﻔﯾﺔ‬

                ‫ﺗﻛوﯾﻧﮭﺎ ﻟﻛﻧﮭﺎ ﻻ ﺗﺟﯾد اﻟطﺑﺦ اﻋﻠم أن اﻟﻛﺛﯾر ﻣﻧﻣن ﺳﯾﻘرأ ھذه اﻷﺳطر ﯾﺟد أﻧﮭﺎ ﺗطﺑق ﻋﻠﯾﮫ‬

                                                 ‫وﻻ ﻋﺟب ﻓﺎﻧﺎ ﻛﻧت ﻛذاﻟك ﯾوﻣﺎ ﻣﺎ إذن ﻓﺄﯾن اﻟﺣل ..؟‬

        ‫ﻣﺎدﻣﻧﺎ ﻗرﯾﺑﯾن ﻣن اﻟطﺑﺦ ﻛﺎﻧت أﻣﻲ إذا أرادت أن ﺗﺣﺿر أﻛﻠﺔ )اﻟدوﻟﻣﺔ( ﻛﺎﻧت ﺗﺣﺿر أوﻻ ﻣﻛوﻧﺎت‬

                  ‫ھذه اﻟطﺑﺧﺔ وھﻲ اﻟﺑﺻل وورق اﻟﻌﻧب واﻟرز وﻣﺎ إﻟﻰ ذاﻟك وﺑﻌد أن ﺗﻧﺗﮭﻲ ﻣن ﺗﺣﺿﯾر‬

                                            ‫ﻛل ﺗﻠﻛم اﻷدوات ﺗﺑدأ ﺑﺗﻛوﯾن ھذه اﻷﻛﻠﺔ ﻓطﺎﺑت ﯾدﯾك ﯾﺎ أﻣﺎه‬
                                                    ‫ُ‬
           ‫ﻓﺎﻟﺑرﻣﺟﺔ ﻣﺷﺎﺑﮭﺔ ﺗﻣﺎﻣﺎ ﻟﺻﻧﺎﻋﺔ أﻛﻠﺔ ﻣﺎ ﻓﻌﻧدﻣﺎ ﻧﺳﺎل ﺳؤال ﺑداﯾﺔ ﻧﺣﻠل اﻟﺳؤال وﻧﺣﺿر ﻣﺗطﻠﺑﺎﺗﮫ‬

        ‫ﺗم ﻧﻘوم ﺑرﺑط ھذه اﻟﻣﺗطﻠﺑﺎت ﻣﻊ ﺑﻌﺿﮭﺎ وﻧﻛون ﺑرﻧﺎﻣﺟﺎ أي ﺷﻲء ﺷﺑﯾﮫ ﺑﺎﻟﺧوارزﻣﯾﺔ ﻟﻛل ﺣل ﻓﻌﻠﻰ‬

        ‫ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو ﺟﺎءﻧﺎ ﺳؤال ﯾطﻠب ﻓﯾﮫ ﺟﻣﻊ ﻋددﯾن ﯾدﺧﻠﮭﻣﺎ اﻟﻣﺳﺗﺧدم ﻓﺑداﯾﺔ اﻟﺗﺣﻠﯾل ﻣن اﻟﺳؤال ﻧﻔﮭم‬
  ‫ﯾدﺧل ﻋددﯾن ﻟذاﻟك ﻧﺣﺗﺎج إﻟﻰ ﻣﺗﻐﯾرﯾن ﻛل ﻣﺗﻐﯾر ﯾﻣﺛل ﻋدد ﻣﻌﯾن ﻣن اﻟذي ﺳوف ﻧدﺧﻠﮫ وﺑﻣﺎ اﻧﮫ‬           ‫اﻧﮫ‬

             ‫ﻗﺎل ﯾدﺧﻠﮭﻣﺎ اﻟﻣﺳﺗﺧدم ﯾﺟب أن ﻧﻌﻣل داﻟﺔ إدﺧﺎل ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ إﻟﻰ ھذان اﻟﻣﺗﻐﯾران ﺗم ﯾﺄﺗﻲ‬

          ‫ﺑﻌدھﻣﺎ ﻣن ﻣﺗطﻠﺑﺎت اﻟﺳؤال ﺟﻣﻊ أي ﻻﺑد ﻣن وﺟود وﺗﻌرﯾف ﻣﺗﻐﯾر ﺛﺎﻟث ﻧﺧزن ﻓﯾﮫ ﻧﺗﯾﺟﺔ اﻟﺟﻣﻊ‬

          ‫اﻟﺗﻲ ﺳوف ﻧﻘوم ﺑﮭﺎ ﺛم ﻧطﺑﻊ ھذه اﻟﻧﺗﯾﺟﺔ. أﻻن ﺑﻌد ﺗﺣﻠﯾل اﻟﻣﺗطﻠﺑﺎت ﻧﺳﻠﺳل اﻟﺧطوات ﻋﻠﻰ ورﻗﺔ‬

                                                              ‫ﺑﺷﻛل ﻣﺷﺎﺑﮫ ﻟﻛﺗﺎﺑﺔ اﻟﺑرﻧﺎﻣﺞ ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

‫>‪#include<iostream.h‬‬
                                                                         ‫١.ﺗﻌرﯾف ﻣﺗﻐﯾرات )‪(a,b,c‬‬
    ‫)(‪mian‬‬
                                                                      ‫٢.ﻧدﺧل )‪ (a,b‬ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
‫{‬
‫;‪1.int a,b,c‬‬                                                          ‫٣.ﻧﺟﻣﻌﮭم )‪.٤ (c=a+b‬ﻧطﺑﻌﮭم‬
‫;‪2.cin>>a>>b‬‬
‫;‪3.c=a+b‬‬                                                        ‫أﻻن ﻧﺣول ھذه اﻟﻣﺗطﻠﺑﺎت إﻟﻰ ﺑرﻧﺎﻣﺞ‬
‫};‪4.cout<<c‬‬
                                                     ‫ﻛﻣﺎ ﻻﺣظت ﻛﯾف ﻛوﻧﺎ اﻟﺑرﻧﺎﻣﺞ وﺻﺣﯾﺢ %001‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                        ‫اﻟﻔﺻل اﻷول‬




              ‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬

                    ‫١.١ - اﻟﺗﻌرف ﻋﻠﻰ اﻟﺑرﻧﺎﻣﺞ اﻟﻣﺳﺗﺧدم ﻓﻲ ﺗﻧﻔﯾذ اﻟﺑراﻣﺞ:‬
                                            ‫٢.١- اﻟﮭﯾﻛﻠﯾﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺑرﻧﺎﻣﺞ :‬
                                                          ‫٣.١- اﻟﻣﺗﻐﯾرات :‬
                                                      ‫٤.١- دوال اﻹﺧراج :‬
                                                      ‫٥.١ - دوال اﻹدﺧﺎل :‬
              ‫٦.١- اﻟﻌﻣﻠﯾﺎت اﻟﺣﺳﺎﺑﯾﺔ وطرق ﺗﻣﺛﯾﻠﮭﺎ وأوﻟوﯾﺎﺗﮭﺎ )اﻷﺳﺑﻘﯾﺔ(:‬
                                             ‫٧.١- ﺗﻣﺛﯾل اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ:‬
                                          ‫٨.١- اﻷﺳﺑﻘﯾﺎت وطرق ﻣﻌﺎﻣﻠﺗﮭﺎ :‬
                                                      ‫٩.١- إﺿﺎﻓﺔ ﺗﻌﻠﯾﻘﺎت:‬
                                          ‫٠١.١- ﻣؤﺛرات اﻟزﯾﺎدة واﻟﻧﻘﺻﺎن:‬
      ‫١١.١- ﺑﻌض دوال اﻹدﺧﺎل واﻹﺧراج ﻓﻲ ﻟﻐﺔ )‪ (C‬ﻓﻲ ﻣﻛﺗﺑﺔ >‪<stdio.h‬‬
                      ‫٢١.١- ﺑﻌض دوال اﻹدﺧﺎل ﻓﻲ ﻣﻛﺗﺑﺔ >‪<conio.h‬‬
                               ‫٣١.١- دوال اﻟرﯾﺎﺿﯾﺔ ﻓﻲ ﻣﻛﺗﺑﺔ >‪<math.h‬‬
                                   ‫٤١.١- دوال اﻟﺗﺣوﯾل )‪(int,char,sizeof‬‬
                               ‫٥١.١- ﻣﺎذا اﻛﺗﺷﻔت ﺑﻌد ان اﻧﺗﮭﯾﻧﺎ ﻣن اﻟﻔﺻل‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                       ‫اﻟﻔﺻل اﻷول‬




                                                                      ‫ﻣدﺧل اﻟﻰ ﻋﺎﻟم اﻟﺑرﻣﺟﺔ‬
                                                      ‫ﻗﺑل ان ﻧدﺧل ﻓﻲ اﻟﻣواﺿﯾﻊ اﻟﺑرﻣﺟﯾﺔ وﻛﯾﻔﯾﺔ ﻛﺗﺎﺑﺔ اﻟﺑرﻣﺟﺔ‬
                                                    ‫دﻋﻧﺎ ﻧوﺿﺢ ﻣﺎھﻲ اﻟﺑرﻣﺟﺔ وﻣﺎھﻲ اﻟﻠﻐﺎت وﻛﯾف ﻧﺳﺗﻔﺎد ﻣﻧﮭﺎ‬
    ‫طﺑﻌﺎ ﻋﻧد ظﮭور اﻟﺣﺎﺳوب اﺻﺑﺢ اﻏﻠب اﻟﻧﺎس ﺑﺣﺎﺟﺔ اﻟﻰ ﺑراﻣﺞ ﺗﻼﺋم ﺣﺎﺟﺎﺗﮭم وﺻﺎر ﺑﺎﻟﺿرورة اﻟﻰ ﺗوﻓر ﻟﻐﺎت‬
                     ‫ﯾﺳﺗﺧدﻣﮭﺎ اﻟﻣﺑرﻣﺟون ﻟﺑرﻣﺟﺔ ﺗطﺑﯾﻘﺎت ﺗﻼﺋم اﺣﺗﯾﺎﺟﺎت اﻟﻧﺎس وﺗﺳﮭﯾل اﻻﻣور ﻓﻲ اﻟﺣﯾﺎة اﻟﻌﻣﻠﯾﺔ‬
     ‫ﻓظﮭرت ﻋدد ﻛﺑﯾر ﻣن اﻟﻠﻐﺎت ﻣﻧﮭﺎ ﻟﻼﻟﻌﺎب واﺧرى ﻟﻘواﻋد اﻟﺑﯾﺎﻧﺎت واﺧرى اﻟﻰ ﺑرﻣﺟﺔ ﺻﻔﺣﺎت اﻟوﯾب واﺧرى‬
              ‫ﻟﺑرﻣﺟﺔ ﺗطﺑﯾﻘﺎت ﻟﻠﻣﺳﺗﺧدﻣﯾن واﺻﺑﺢ اﻟﻣﺑرﻣﺞ ﻓﻲ ﺧﯾرة ﻣن اﻣره ﯾﺑرﻣﺞ ﺑﺎي ﻟﻐﺔ ﺗﻼﺋم طﻠب اﻟﻣﺳﺗﺧدم‬
   ‫اذن اﻟﻠﻐﺎت اﻟﺑرﻣﺟﯾﺔ ﺗﻣﻛﻧﻧﺎ ﻣن ﺣل ﻋدد ﻛﺑﯾر ﻣن اﻟﻣﺷﺎﻛل اﻟﺗﻲ ﯾﻌﺟز ﻋﻘﻠﻧﺎ ﻋن ﺣﻠﮭﺎ وﺗﺳﮭﯾل اﻣور اﻟﺣﯾﺎة وﺑﺳرﻋﺔ‬
   ‫ﻋﺎﻟﯾﺔ ﻟذاﻟك ﻻ ﺗﺟﻌﻠﮭﺎ ﺗﻔوﺗك ﻓﮭﻲ ﺳﮭﻠﺔ وﺟﻣﯾﻠﺔ .وﻣﺎ ﺳﻧدرﺳﺔ وﻧﺗﻌﻠﻣﮫ ﻓﻲ ھذا اﻟﻛﺗﺎب ھﻲ ﻟﻐﺔ ﺳﻲ وﺳﻲ ﺑﻼس اﻟﺗﻲ‬
                         ‫ﺗدرس ﻓﻲ اﻏﻠب اﻟدول واﻟﺟﺎﻣﻌﺎت اﻟﻌرﺑﯾﺔ واﻟﻐرﺑﯾﺔ واﻟﺛﻲ ھﻲ اﺳﺎس اﻏﻠب اﻟﻠﻐﺎت اﻟﺣدﯾﺛﺔ.‬


                                  ‫١.١ - اﻟﺗﻌرف ﻋﻠﻰ اﻟﺑرﻧﺎﻣﺞ اﻟﻣﺳﺗﺧدم ﻓﻲ ﺗﻧﻔﯾذ اﻟﺑراﻣﺞ:‬
     ‫ﻣﺎ ﺳﻧﺳﺗﺧدﻣﮫ ﻓﻲ ھذا اﻟﻛﺗﺎب ﻟﺗطﺑﯾق اﻟﺑراﻣﺞ واﻻﻣﺛﻠﺔ اﻟﻣﺣﻠوﻟﺔ ھو ﺑرﻧﺎﻣﺞ )5.4 ++‪ (Turbo C‬وﻻ ﯾﺧﺗﻠف ھذا‬
  ‫اﻟﻣﻧﺗﺞ ﻛﺛﯾرا ﻋن ﺑﻘﯾﺔ اﻻﺻدارات ﻟﻛن ﺣﺗﻰ ﯾﻛون اﻟﻘﺎرئ ﻋﻠﻰ ﻣﻌرﻓﺔ ﺑﺎﻟﺑرﻧﺎﻣﺞ اﻟذي ﺳﻧﺗﻌﺎﻣل ﻣﻌﮫ وھو ﻣﺗوﻓر ﻓﻲ‬
                                                         ‫ﺷﺑﻛﺎت اﻟوﯾب ﺗﺳﺗطﯾﻊ ﺗﻧزﯾﻠﮫ ﻣن اي ﻣوﻗﻊ وﺗﻧﺻﯾﺑﮫ..!‬
                                    ‫ﻛﯾف ﯾﺗم اﻟﺗﻌﺎﻣل ﻣﻊ ﻧﺳﺧﺔ)5.4 ++‪ (Turbo C‬وﻛﺗﺎﺑﮫ اﻟﺑراﻣﺞ وﺗﻧﻔﯾذھﺎ .؟‬
                                ‫ﺑﻌد ﺗﻧﺻﯾب اﻟﺑرﻧﺎﻣﺞ وﺗﺷﻐﯾﻠﮫ ﺳﺗﻔﺗﺢ اﻟﻧﺎﻓذة اﻟﺗﺎﻟﯾﺔ وھﻲ اﻟﻧﺎﻓذة اﻻﺳﺎﺳﯾﺔ ﻟﻠﺑرﻧﺎﻣﺞ‬




  ‫‪ ‬ھذه اﻟﻧﺎﻓذة ﻧﻛﺗب ﺑﮭﺎ ﺑرﻧﺎﻣﺟﻧﺎ اﻟذي ﻧرﯾد ﺗﻧﻔﯾذه واﻟﺣﺻول ﻋﻠﻰ ﻧﺗﺎﺋﺞ و ﻣﺎ ﺳﻧﻛﺗﺑﮫ ﻓﻲ ھذا اﻟﻛﺗﺎب ﻣن اﻛواد‬
    ‫ﺟﻣﯾﻌﮭﺎ ﺳوف ﺗﻛﺗب ﻓﻲ ھذه اﻟﻧﺎﻓذة . وﻧﺳﺗطﯾﻊ ﻓﺗﺢ ﻧﺎﻓذة ﺟدﯾدة ﻣن ﻗﺎﺋﻣﺔ ‪ File‬وﻧﺧﺗﺎر ‪ new‬ﺳوف ﯾﻔﺗﺢ‬
                                                                       ‫ﻧﺎﻓذة ﺟدﯾدة ﻟﻛﺗﺎﺑﺔ ﺑرﻧﺎﻣﺞ ﺟدﯾد‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                      ‫اﻟﻔﺻل اﻷول‬




  ‫‪ ‬وﻧﺎﻓذة )‪ (Message‬ﺗﺑﯾن ﻟﻧﺎ ﻣواﺿﻊ اﻟﺧطﺎء داﺧل اﻟﺑرﻧﺎﻣﺞ اﻟذي ﻧﻘوم ﺑﻛﺗﺎﺑﺗﮫ ﺣﯾث ﯾﺑﯾن ﻟك اﻟﺧطﺎء ﺣﺻل‬
                                                                 ‫ﻓﻲ اي ﺧطوة ﺣﺗﻰ ﺗﺟده وﺗﺻﺣﺣﮫ‬




    ‫اذا ﻟم ﺗظﮭر ھذه اﻟﻧﺎﻓذة ﻧﻘوم ﺑﺎظﮭﺎرھﺎ ﻣن ﻗﺎﺋﻣﺔ ‪ View‬ﻧﺧﺗﺎر ‪ message‬وﺳوف ﺗظﮭر وھﻲ ﻣﮭﻣﺔ ﺟدا ﻟﻣﻌرﻓﺔ‬
                                                                                     ‫ﻣواﺿﻊ اﻟﺧطﺎء‬


 ‫‪ ‬ﺑﻌد ﻛﺗﺎﺑﺔ اﻟﺑرﻧﺎﻣﺞ ﻧﻘوم ﺑﺗﻧﻔﯾذه ﻟﻠﺣﺻول ﻋﻠﻰ ﻧﺗﺎﺋﺞ او ادﺧﺎل ﻣﻌطﯾﺎت ﺑﺎﻟظﻐط ﻋﻠﻰ ﻗﺎﺋﻣﺔ ‪ Debug‬واﺧﺗﯾﺎر‬
                                                              ‫‪ Run‬ﺳوف ﯾﻘوم ﺑﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ‬




                          ‫‪ ‬ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﺗﻛون ﺑﺷﻛل اﻟﺗﺎﻟﻲ وﻣﻧﮭﺎ ﻧﺣﺻل ﻋﻠﻰ ﻧﺗﺎﺋﺞ او ﻧدﺧل ﻣﻌطﯾﺎت اﻟﺑرﻧﺎﻣﺞ‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                           ‫اﻟﻔﺻل اﻷول‬




                                                                  ‫٢.١- اﻟﮭﯾﻛﻠﯾﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺑرﻧﺎﻣﺞ :‬
      ‫ﻟﻠﺑرﻧﺎﻣﺞ ﻓﻲ ﻟﻐﺔ ) ++‪ (c , c‬ﺷﻛل ﻋﺎم ﻋﻧد ﻛﺗﺎﺑﺗﮫ وھو ﺛﺎﺑت ﺗﻘرﯾﺑﺎ ﻓﻲ أﺟزاﺋﮫ اﻟرﺋﯾﺳﯾﺔ ﻓﻲ ﻛل اﻟﺑراﻣﺞ وﺗﻛون‬
                                                                                    ‫طرﯾﻘﺔ ﻛﺗﺎﺑﺗﮫ ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬



             ‫++‪C‬‬                                                                             ‫اﻟﻛود ﺑﻠﻐﺔ‬
           ‫ﻣﻧطﻘﺔ اﻟﺗﻌرﯾﻔﺎت اﻟﻌﺎﻣﺔ واﺳﺗدﻋﺎء ﻣﻛﺎﺗب ﻟﻠﺑرﻧﺎﻣﺞ‬
           ‫>‪# include<iostream.h‬‬
           ‫اﻟداﻟﺔ اﻟﺗﻲ ﺗﻛﺗب ﺑداﺧﻠﮭﺎ اﻛواد اﻟﺑرﻧﺎﻣﺞ‬
           ‫)(‪Main‬‬
           ‫{‬
           ‫ﺳﺎﺣﺔ اﻻﻛواد أو ﻣﻧطﻘﺔ ﻛﺗﺎﺑﺔ اﻛواد اﻟﺑرﻧﺎﻣﺞ واﻟﻘراءة واﻟطﺑﺎﻋﺔ‬
           ‫}‬

           ‫‪C‬‬                                                                                 ‫اﻟﻛود ﺑﻠﻐﺔ‬
           ‫ﻣﻧطﻘﺔ اﻟﺗﻌرﯾﻔﺎت اﻟﻌﺎﻣﺔ واﺳﺗدﻋﺎء ﻣﻛﺎﺗب ﻟﻠﺑرﻧﺎﻣﺞ‬
           ‫>‪# include<stdio.h‬‬
           ‫اﻟداﻟﺔ اﻟﺗﻲ ﺗﻛﺗب ﺑداﺧﻠﮭﺎ اﻛواد اﻟﺑرﻧﺎﻣﺞ‬
           ‫)(‪Main‬‬
           ‫{‬
           ‫ﺳﺎﺣﺔ اﻻﻛواد أو ﻣﻧطﻘﺔ ﻛﺗﺎﺑﺔ اﻛواد اﻟﺑرﻧﺎﻣﺞ واﻟﻘراءة واﻟطﺑﺎﻋﺔ‬
           ‫}‬


    ‫‪ ‬ﻣﻧطﻘﺔ اﻟﺗﻌرﯾﻔﺎت اﻟﻌﺎﻣﺔ واﺳﺗدﻋﺎء ﻣﻛﺎﺗب ﻟﻠﺑرﻧﺎﻣﺞ: ﻓﻲ ھذا اﻟﻣﻛﺎن ﯾﺗم ﻛﺗﺎﺑﺔ ﺟﻣﯾﻊ اﻟﻣﻛﺎﺗب اﻟﺗﻲ ﺳﻧﺣﺗﺎج‬
   ‫إﻟﯾﮭﺎ داﺧل اﻟﺑرﻧﺎﻣﺞ وﻛذاﻟك اﻟﻣﺗﻐﯾرات اﻟﺗﻲ ﺗﻌرف ﺑﺷﻛل ﻋﺎم ﻟﻛل اﻟﺑرﻧﺎﻣﺞ واﻟﺳﺟﻼت واﻟدوال ﻋﻠﻰ ﺳﺑﯾل‬
        ‫اﻟﻣﺛﺎل داﻟﺔ اﻟﻘراءة واﻟطﺑﺎﻋﺔ )‪ (scanf ,printf‬ﻓﻲ ﻟﻐﺔ ‪ C‬ﺗﻘﻊ ﺿﻣن اﻟﻣﻛﺗﺑﺔ >‪ <stdio.h‬ﻟذاﻟك ﯾﺟب‬
          ‫اﺳﺗدﻋﺎء ھذه اﻟﻣﻛﺗﺑﺔ ﻟﻛﻲ ﺗﻌﻣل ھذه اﻟدوال وداﻟﺔ )‪ (cout , cin‬ﺗﻘﻊ ﺿﻣن ﻣﻛﺗﺑﺔ >‪.<iostream.h‬‬


                    ‫‪ ‬داﻟﺔ )‪:(main‬ھﺬه اﻟﺪاﻟﺔ ﯾﺴﻠﻢ ﻧﻈﺎم اﻟﺘﺸﻐﯿﻞ اﻟﻌﻤﻞ ﻟﮭﺎ وﻋﻨﺪﻣﺎ ﻧﻨﺘﮭﻲ وظﯿﻔﺘﮭﺎ ﺗﺮﺟﻊ ﻟﮫ ﻗﯿﻤﺔ‬


                  ‫‪ ‬ﺳﺎﺣﺔ ﻛﺗﺑﺔ اﻷﻛواد: ھﻲ اﻟﻣﻧطﻘﺔ اﻟﺗﻲ ﯾﺗم ﺑداﺧﻠﮭﺎ ﻛﺗﺎﺑﺔ اﻷﻛواد اﻟﺑرﻣﺟﯾﺔ وﺗﻌرﯾﻔﺎت وﻏﯾرھﺎ‬



      ‫ﯾﺟب وﺿﻊ ﻓﺎرزة ﻣﻧﻘوطﺔ ﻓﻲ ﻧﮭﺎﯾﺔ أي ﺗﻌﺑﯾر ﻣﺑرﻣﺞ ﻣن ﻗﺑل اﻟﻣﺳﺗﺧدم ﻟﻠدﻻﻟﺔ ﻋﻠﻰ أن اﻟﺗﻌﺑﯾر اﻧﺗﮭﻰ .‬          ‫‪‬‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                            ‫اﻟﻔﺻل اﻷول‬




                                                                                        ‫٣.١- اﻟﻣﺗﻐﯾرات :‬
 ‫ھﻲ ﻣواﻗﻊ ﻓﻲ اﻟذاﻛرة ﺗﺧزن ﻓﯾﮭﺎ ﻗﯾم ﻣﻌﯾﻧﺔ ﻗد ﺗﺗﻐﯾر أﺛﻧﺎء اﻟﺑرﻧﺎﻣﺞ أو ﻗد ﺗﺑﻘﻰ ﺛﺎﺑﺗﺔ. وأﺳﻣﺎء اﻟﻣﺗﻐﯾرات ﺗﻛون ﻣﻔﺗوﺣﺔ‬
   ‫ﺣﺳب اﻟرأي اﻟﺷﺧﺻﻲ اﻟﻣﺑرﻣﺞ ﻣﻣﻛن أن ﯾﺳﻣﯾﮭﺎ إي اﺳم ﻟﻛن ﯾﺟب أن ﻻ ﯾﻛون اﻻﺳم ﻣن اﻷﺳﻣﺎء اﻟﻣﺣﺟوزة ﻣﺛل‬
 ‫)‪ ( if,for,while‬أو أي أﺳم أﺧر ﻣﺣﺟوز ﻣن ﻗﺑل اﻟﻣﺗرﺟم ورﻏم أن ﺗﺳﻣﯾﺔ اﻟﻣﺗﻐﯾرات ﻣﻔﺗوﺣﺔ ﻟﻛن ﯾﻔﺿل أن ﺗﻛون‬
    ‫ﺗﺳﻣﯾﺔ اﻟﻣﺗﻐﯾر داﻟﺔ ﻋﻠﯾﮫ ﻣﺛﻼ ﻟو ﻛﺎن اﻟﻣﺗﻐﯾر ﯾدل ﻋﻠﻰ اﻟوﻗت ﻓﯾﻔﺿل ﺗﺳﻣﯾﺗﮫ )‪ (time‬ﺣﺗﻰ ﺗﻛون اﻛوادك واﺿﺣﺔ‬
                         ‫وﺣﺗﻰ ﻻ ﯾﻛون ﺑرﻧﺎﻣﺟك ﻣﺗﺷﺎﺑك ﻛﻣﻌﻛروﻧﺔ اﻻﺳﺑﻛﺗﻲ ﻻ ﯾﻌرف اﻟﻘﺎرئ ﺑداﯾﺗﮫ ﻣن ﻧﮭﺎﯾﺗﮫ.‬

       ‫‪ ‬اﻟﻣﺗﻐﯾر اﻟذي ﯾﺗم ﺗﻌرﯾﻔﮫ داﺧل اﻟﺑرﻧﺎﻣﺞ ﯾﺟب ﺗﺣدﯾد ﻧوﻋﮫ.ھﻧﺎك ﻋدة أﻧواع ﻣن اﻟﻣﺗﻐﯾرات ﯾﻣﻛن ﺗﻌرﯾف‬
                                                                      ‫اﻟﻣﺗﻐﯾرات اﻟﺟدﯾدة ﺑﮭﺎ وھﻲ‬

                                                                      ‫اﺳﺗﺧداﻣﮫ‬                     ‫ﺗﻌرﯾف اﻟﻣﺗﻐﯾر‬
                    ‫ﯾﺳﺗﺧدم ﻟﺗﻌرﯾف اﻟﻣﺗﻐﯾر ﻣن ﻧوع ‪ integer‬أي رﻗﻣﻲ ﻣﺛﻼ )5=‪(int x‬‬                          ‫;‪Int var‬‬
                       ‫ﯾﺳﺗﺧدم ﻟﺗﻌرﯾف اﻟﻣﺗﻐﯾر ﻣن ﻧوع ﻛﺳري ﻣﺛﻼ );4.5=‪(Float var‬‬                        ‫;‪Float var‬‬
                          ‫ﯾﺳﺗﺧدم ﻟﺗﻌرﯾف اﻟﻣﺗﻐﯾر ﻣن ﻧوع ﺣرﻓﻲ ﻣﺛﻼ );'‪(Char var='a‬‬                      ‫;‪Char var‬‬
                                  ‫ﯾﺳﺗﺧدم ﻟﺗﻌرﯾف اﻟﻣﺗﻐﯾر ﻣن ﻧوع ‪ Double‬أي ﺣﻘﯾﻘﻲ‬                     ‫;‪Double var‬‬
                            ‫ﯾﺳﺗﺧدم ﻟﺗﻌرﯾف اﻟﻣﺗﻐﯾر ﻣن ﻧوع ‪ Void‬أي ﻻ ﯾرﺟﻊ أي ﻗﯾﻣﺔ‬                      ‫;‪Void var‬‬

       ‫‪ ‬ﻓﻣﺛﻼ ﻟو ﻛﺎن اﻟﻣﺗﻐﯾر ) ‪ ( x‬ﯾﺣوي ﻗﯾﻣﺔ ﻣﺗﻐﯾر رﻗﻣﻲ ﺑدون ﻓﺎرزة ﺑﻌد اﻟﺻﻔر ﻓﯾﺟب ﺗﻌرﯾﻔﮫ ﺗﺣت اﻟداﻟﺔ‬
                                                      ‫)(‪ main‬ﺑﺄﻧﮫ ﻣﺗﻐﯾر ﻣن ﻧوع )‪ (integer‬ھﻛذا‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                            ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪# include<iostream.h‬‬                                      ‫>‪# include<stdio.h‬‬
 ‫)(‪Main‬‬                                                     ‫)(‪Main‬‬
 ‫{‬                                                          ‫{‬
 ‫ھﻧﺎ ﺗﻌرف اﻟﻣﺗﻐﯾرات//‬                                       ‫ھﻧﺎ ﺗﻌرف اﻟﻣﺗﻐﯾرات//‬
 ‫;‪int x‬‬                                                     ‫;‪int x‬‬
 ‫}‬                                                          ‫}‬
                                                                         ‫وﯾﺧزن اﻟﻣﺗﻐﯾر )‪ (x‬ﻓﻲ اﻟذاﻛرة ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬
                                                            ‫اﻟذاﻛرة‬

       ‫ﻣوﻗﻊ ﺗﺧزﯾن اﻟﻣﺗﻐﯾر ﻓﻲ‬
                      ‫اﻟذاﻛرة‬

                                                      ‫‪x‬‬


                      ‫‪ ‬ﻛل ﻣوﻗﻊ ﻓﻲ اﻟذاﻛرة ﯾﻛون ﻣرﻗم ﺑرﻗم ﻣﻌﯾن ﯾﺧﺗﻠف رﻗﻣﮫ ﻋن ﻏﯾره ﻣن اﻟﻣواﻗﻊ‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                           ‫اﻟﻔﺻل اﻷول‬




                                             ‫‪ ‬ﯾﻣﻛن ﺗﻌرﯾف أﻛﺛر ﻣن ﻣﺗﻐﯾر ﻓﻲ ﺳطر واﺣد ﺑوﺿﻊ ﻓﺎرزة ﺑﯾﻧﮭم‬

                                                                                                 ‫اﻟﻛو د‬
           ‫;‪char x,y,z‬‬




                      ‫‪ ‬اﻟﻣﺗﻐﯾرات )‪ (x,y,z‬ھﻲ ﻣﺗﻐﯾرات ﺗﺳﺗطﯾﻊ أن ﺗﺧزن ﻓﻲ داﺧﻠﮭﺎ ﺣرف واﺣد ﻓﻘط‬

                                                 ‫‪ ‬ﯾﻣﻛن أن ﯾﺳﻧد اﻟﻣﺗﻐﯾر ﺑﻘﯾﻣﺔ ﻣﺑﺎﺷرة إﺛﻧﺎء وﻗت اﻟﺗﻌرﯾف ھﻛذا‬

                                                                                                 ‫اﻟﻛو د‬
           ‫;5=‪int x‬‬


                                                                          ‫5=‪X‬‬

                                       ‫‪ ‬ﻗد ﯾﺳﻧد اﻟﻣﺗﻐﯾر ﺑﻘﯾﻣﺔ ﻣﻌﯾﻧﺔ ﺑﻌد اﻟﺗﻌرﯾف ﻓﻲ أي ﻣﻛﺎن ﻓﻲ اﻟﺑرﻧﺎﻣﺞ .‬

                                                                                                 ‫اﻟﻛو د‬
           ‫;‪char symbol‬‬
           ‫;'‪symbol ='a‬‬

                                                                                ‫'‪symbol ='a‬‬

                                          ‫‪ ‬اﻟﻣﺗﻐﯾر )‪ (symbol‬ﺗم ﺗﺧزﯾن اﻟﺣرف ‪ a‬ﻓﻲ داﺧﻠﮫ .‬
            ‫‪ ‬اﻟﺣروف ﻋﻧدﻣﺎ ﺗﺧزن ﺗﺿﻊ ﺑﯾن ﻋﻼﻣﺔ ﺗﻧﺻﯾﺻﯾﺔ واﺣد دﻻﻟﺔ ﻋﻠﻰ اﻧﮭﺎ ﺣرف واﺣد ﻓﻘط‬

                                                                        ‫‪ ‬ﻗد ﻧﺳﻧد ﻗﯾﻣﺔ ﻣﺗﻐﯾر إﻟﻰ ﻣﺗﻐﯾر أﺧر‬
                                                                                                 ‫اﻟﻛو د‬
            ‫;‪int first ,second‬‬
            ‫;15= ‪first‬‬
            ‫; ‪second= first‬‬
                         ‫‪ ‬أﺻﺑﺢ اﻟﻣﺗﻐﯾر ‪ second‬ﯾﺣوي ﻧﻔس ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ first‬ﻓﻲ اﻟﺧطوة رﻗم )٣(‬


                           ‫‪ ‬أو ﻗد ﯾﺳﻧد اﻟﻣﺗﻐﯾر ﺑﻘﯾﻣﺔ ﻓﻲ وﻗت اﻹدﺧﺎل ﻣن ﻟوﺣﺔ اﻟﻣﻔﺎﺗﯾﺢ )ﺳﻧﺗطرق ﻋﻠﯾﮫ ﻻﺣﻘﺎ(‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                       ‫اﻟﻔﺻل اﻷول‬




                        ‫إﺳﻧﺎد ﻗﯾم ﻟﻠﻣﺗﻐﯾرات: ﺗﻛون طرﯾﻘﺔ إﺳﻧﺎد إي ﻗﯾﻣﺔ أو ﺗﻌﺑﯾر رﯾﺎﺿﻲ إﻟﻰ ﻣﺗﻐﯾر ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬


                                       ‫ﻣﺗﻐﯾر أو ﺗﻌﺑﯾر رﯾﺎﺿﻲ=اﺳم اﻟﻣﺗﻐﯾر‬

                             ‫‪ ‬ﻓﻲ اﻟطرف اﻷﯾﻣن ﻣن اﻟﻣﺳﺎواة ﯾوﺟد ﻓﻘط اﺳم اﻟﻣﺗﻐﯾر اﻟذي ﻧرﯾد إﺳﻧﺎد ﻗﯾم إﻟﯾﮫ‬
                     ‫‪ ‬ﻓﻲ اﻟطرف اﻷﯾﺳر ﻣن اﻟﻣﺳﺎواة ﻧﺳﺗطﯾﻊ ﻛﺗﺎﺑﺔ إي ﺗﻌﺑﯾر رﯾﺎﺿﻲ أو ﻣﺗﻐﯾر أو ﻗﯾﻣﺔ ﻣﻌﯾﻧﺔ‬

                                                      ‫ﻣﺛﺎل : إﺳﻧﺎد ﻗﯾﻣﺔ ﺗﻌﺑﯾر رﯾﺎﺿﻲ إﻟﻰ ﻣﺗﻐﯾر )ﺑطرﯾﻘﺔ ﺻﺣﯾﺣﺔ(‬
                                                                                               ‫اﻟﻛو د‬
           ‫;5=‪1.int y, x‬‬
           ‫;3+‪2.y=x‬‬

            ‫‪ ‬ﻓﻲ اﻟﺧطوة رﻗم )٢( أﺳﻧدﻧﺎ اﻟﻘﯾﻣﺔ اﻟﻧﺎﺗﺟﺔ ﻣن ﺗﻌﺑﯾر رﯾﺎﺿﻲ وھو )3+‪ (x‬إﻟﻰ اﻟﻣﺗﻐﯾر )‪(y‬‬



                                                      ‫+‬




         ‫‪ ‬ﻟو ﺗﻼﺣظ أن اﻟطرف اﻷﯾﻣن ﻣﻛون ﻣن ﻣﺗﻐﯾر ﻓﻘط واﻟطرف اﻷﯾﺳر ﻣﻛون ﻣن ﺗﻌﺑﯾر رﯾﺎﺿﻲ‬

                                                       ‫ﻣﺛﺎل : إﺳﻧﺎد ﻗﯾﻣﺔ ﺗﻌﺑﯾر رﯾﺎﺿﻲ إﻟﻰ ﻣﺗﻐﯾر )ﺑطرﯾﻘﺔ ﺧﺎطﺋﺔ(‬
                                                                                               ‫اﻟﻛو د‬
           ‫;5=‪1.int y, x‬‬
           ‫;3+‪2.y+2=x‬‬

     ‫‪ ‬ﻓﻲ اﻟﺧطوة رﻗم )٢( أﺳﻧدﻧﺎ اﻟﻘﯾﻣﺔ اﻟﻧﺎﺗﺟﺔ ﻣن ﺗﻌﺑﯾر رﯾﺎﺿﻲ وھو )3+‪ (x‬إﻟﻰ ﺗﻌﺑﯾر رﯾﺎﺿﻲ أﺧر‬
                                                     ‫وھذه اﻟﺷﻲء ﺧﺎطﺊ وﻻ ﯾﻘﺑﻠﮫ اﻟﻣﺗرﺟم‬



                                                      ‫+‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                           ‫اﻟﻔﺻل اﻷول‬




   ‫اﻟﻣﺗﻐﯾرات اﻟﺛﺎﺑﺗﺔ: ھﻲ ﻣﺗﻐﯾرات ﺗﺑﻘﻰ ﻗﯾﻣﺗﮭﺎ ﺛﺎﺑﺗﺔ إﺛﻧﺎء ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ وﻻ ﺗﺗﻐﯾر أﺑدا وﺗﻌرف ﺑوﺿﻊ ﻛﻠﻣﺔ )‪(const‬‬
   ‫ﻗﺑل ﺗﻌرﯾف ﻧوع اﻟﻣﺗﻐﯾر. وﻓﺎﺋدﺗﮭﺎ ﻧﺳﺗﺧدﻣﮭﺎ ﻟﻠﻣﺗﻐﯾرات اﻟﺗﻲ ﻻ ﻧرﯾد أن ﺗﺗﻐﯾر ﻗﯾﻣﺗﮭﺎ إﺛﻧﺎء ﻋﻣل اﻟﺑرﻧﺎﻣﺞ أﺑدا. ﻣﺛﻼ‬
     ‫ﻗﯾﻣﺔ ) 41.3=‪ (pi‬ھذه ﻗﯾﻣﺔ رﯾﺎﺿﯾﺔ وﻻ ﺗﺗﻐﯾر اﺑد ﻣﮭﻣﺎ ﺣدث وداﺋﻣﺎ ﻧﺣﺗﺎﺟﮭﺎ ﻓﻲ اﻟﺑراﻣﺞ اﻟرﯾﺎﺿﯾﺔ ﻟذاﻟك ﻧﻌرﻓﮭﺎ‬
           ‫)‪ (const‬وﻧﻌطﯾﮭﺎ ﻗﯾﻣﺔ )41.3( ﺳﻧﺿﻣن ﻷﻧﻔﺳﻧﺎ أﻧﮭﺎ ﻻ ﺗﺗﻐﯾر ﻣﮭﻣﺎ ﺣدث وأﯾﻧﻣﺎ ﻧﺣﺗﺎﺟﮭﺎ ﻧﻛﺗب ﻓﻘط ) ‪(pi‬‬

                                                                                                  ‫اﻟﻛو د‬
           ‫;41.3=‪const float pi‬‬

                                                                                                                 ‫ﻣﮭم‬

                                     ‫اﺣد أﻛﺛر اﻷﺳﺋﻠﺔ أھﻣﯾﺔ وھﻲ ﻛﯾﻔﯾﺔ ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ ﻓﻲ ﻟﻐﺎت اﻟﺑرﻣﺟﺔ ؟‬
      ‫ھذا اﻟﺳؤال ﻗﺎﺗل ﻛﺎﻟﺳﯾف إذا ﻟم ﺗﻔﮭﻣﮫ ﻟن ﺗﻔﮭم ﺷﻲء ﻣن ﻻﺣﻘﯾﮫ. وﯾﺑدءا ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ ﻣن اﻟداﻟﺔ )(‪ main‬ﯾﻧﻔذ‬
     ‫اﻟﺑرﻧﺎﻣﺞ ﺳطر ﺛم ﯾﻧﺗﻘل إﻟﻰ اﻟﺳطر اﻟذي ﯾﻠﯾﮫ )ﻻﺣظ ﺗﺳﻠﺳل اﻟﺗرﻗﯾم ﻓﻲ اﻟﻣﺛﺎل( وﯾﺳﺗﻣر ھﻛذا ﺣﺗﻰ ﯾﺻل إﻟﻰ ﻧﮭﺎﯾﺔ‬
                               ‫اﻟﺑرﻧﺎﻣﺞ وأي ﻣﻛﺗﺑﺔ ﯾﺣﺗﺎﺟﮭﺎ أو أي داﻟﺔ ﯾﺣﺗﺎﺟﮭﺎ ﯾﺗﺟﮫ ﻟﯾﺑﺣث ﻋﻧﮭﺎ ﺧرج ھذه اﻟداﻟﺔ‬
                                                                           ‫ﻛﯾﻔﯾﺔ ﺗﺳﻠﺳل ﺗﻧﻔﯾذ ﺧطوات اﻟﺑرﻧﺎﻣﺞ‬
        ‫‪# include<iostream.h> //or #include <stdio.h> for user of C language‬‬
        ‫)(‪Change_position‬‬
        ‫{‬
        ‫.6‬
        ‫.7‬
        ‫.8‬
          ‫ﻋﻧدﻣﺎ اﻧﺗﮭﻰ ﻣن ﺗﻧﻔﯾذ ﻣﺎ ﻣوﺟود ﻓﻲ اﻟداﻟﺔ ﯾﻌود إﻟﻰ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ ﺟﺎﻋﻼ ﺧطوة اﻟﺗﻧﻔﯾذ اﻟﺗﺎﻟﯾﺔ‬
                                                               ‫ﺑﻌد ھﻲ )٨( وھﻲ )٩( وﯾﺳﺗﻣر اﻟﺑرﻧﺎﻣﺞ‬
        ‫}‬
        ‫ﻣن ھﻧﺎ ﯾﺑدأ ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ ﺧطوة ﺑﺧطوة )ھذه أول ﺧطوة(‬
        ‫)(‪Main‬‬
        ‫{‬
        ‫اﻟﺧطوات اﻟﻣوﺟودة ﺿﻣن ھذه اﻟداﻟﺔ ﯾﻧﻔذھﺎ ﺗﺑﺎﻋﺎ)ھذه اﻷرﻗﺎم ھﻲ اﺳطر ﺑرﻣﺟﯾﺔ (‬             ‫ﻣﮭم‬
        ‫.1‬
        ‫.2‬
        ‫.3‬
        ‫.4‬
        ‫ﻻﺣظ ﻓﻲ اﻟﺳطر اﻟﺧﺎﻣس اﺣﺗﺎج داﻟﺔ ﺗﻘﻊ ﺧﺎرج ‪ Main‬ﻧﻘل ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ ﻟﮭﺎ أﺻﺑﺢ اﻟﺧطوة)٦(‬
        ‫ﻋﻧدھﺎ‬
        ‫)(‪5.Change_posi on‬‬
        ‫.9‬
        ‫01‬
        ‫.11‬
        ‫}‬


   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                             ‫اﻟﻔﺻل اﻷول‬

                                                                                                                  ‫ﻣﮭم‬
          ‫ﻣﺎذا ﯾﺣدث ﻟو ﺳﺎوﯾﻧﺎ ﻣﺗﻐﯾر ﻣن ﻧوع ‪ integer‬ﺑﺄﺧر ﻣن ﻧوع ‪ float‬ﻛل اﻟذي ﯾﺣﺻل‬
                ‫ھو أن اﻟﻣﺗﻐﯾر ‪ integer‬ﺳوف ﯾﺄﺧذ اﻟرﻗم ﻓﻘط اﻟﻘﺑل اﻟﺻﻔر وﯾﮭﻣل اﻟذي ﺑﻌده‬


                            ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﺗﺣﻣﯾل ﻗﯾﻣﺔ ﻣﺗﻐﯾر ﻣن ﻧوع ‪ float‬إﻟﻰ ﻣﺗﻐﯾر ﻣن ﻧوع ‪integer‬‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬     ‫‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                        ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                      ‫)(‪main‬‬
 ‫{‬                                                           ‫{‬
 ‫;‪int fixOnly‬‬                                                ‫;‪int fixOnly‬‬
 ‫;5.3=‪float fixAndPint‬‬                                          ‫;5.3=‪float fixAndPint‬‬
 ‫;‪fixOnly =fixAndPint‬‬                                        ‫;‪fixOnly =fixAndPint‬‬
 ‫;‪cout<<fixOnly‬‬                                              ‫;)‪printf("%d",fixOnly‬‬
 ‫}‬                                                           ‫}‬
                                                                                                 ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬

                                                            ‫١.ﻓﻲ اﻟﺳطر اﻷول اﺳﺗدﻋﯾﻧﺎ ﻣﻛﺗﺑﺔ اﻟﺗﻌﺎرﯾف اﻟﺗﻲ ﺗﺧص اﻟﻠﻐﺔ‬

                    ‫٢.ﻓﻲ اﻟﺳطر اﻟﺛﺎﻧﻲ داﻟﺔ ‪ Main‬اﻟﺗﻲ وﺻﻔﻧﺎھﺎ ﺳﺎﺑﻘﺎ وﻓﻲ اﻟﺳطر اﻟﺛﺎﻟث ﻓﺗﺣﻧﺎ ﻗوس ﺑداﯾﺔ اﻟﺑرﻧﺎﻣﺞ‬

                                                       ‫٣.ﻓﻲ اﻟﺳطر اﻟراﺑﻊ ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ‪ fixOnly‬ﻣن ﻧوع ‪integer‬‬

                      ‫٤.ﻓﻲ اﻟﺳطر اﻟﺧﺎﻣس ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ‪ float fixAndPint‬ﻣن ﻧوع ‪ float‬وأﺳﻧدﻧﺎ ﻟﮫ ﻗﯾﻣﺔ ٥.٣‬

   ‫٥.ﻓﻲ اﻟﺳطر اﻟﺳﺎدس ﺳﺎوﯾﻧﺎ اﻟﻣﺗﻐﯾر ‪ fixOnly‬ﻣن ﻧوع ‪ integer‬ﺑﺎﻟﻣﺗﻐﯾر ‪ float fixAndPint‬ﻣن ﻧوع ‪float‬‬
      ‫ﻓﺄﺻﺑﺢ اﻟﻣﺗﻐﯾر ‪ fixOnly‬ﻣن ﻧوع ‪ integer‬ﯾﺣﻣل ﻓﻘط ﻗﯾﻣﺔ اﻟﺟزء اﻟﺻﺣﯾﺢ ﻟﻠﻣﺗﻐﯾر ‪ fixAndPint‬ﻣن ﻧوع‬
                                                                                            ‫‪float‬‬

                                  ‫واﻟﺳطر اﻟﺛﺎﻣن أﻏﻠﻘﻧﺎ اﻟﺑرﻧﺎﻣﺞ‬       ‫٦.ﻓﻲ اﻟﺳطر اﻟﺳﺎﺑﻊ طﺑﻌﻧﺎ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪fixOnly‬‬



  ‫‪ ‬ﻧﻼﺣظ إن اﻟﻣﺗﻐﯾر ‪ fixOnly‬ﺳوف ﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ )٣( ﻓﻘط رﻏم اﻟذي ﺳﺎوﯾﻧﺎه ﻓﯾﮫ ھو )٥.٣( واﻟذي ﺳﯾظﮭر‬
                                                                           ‫ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھوا )٣(‬
   ‫‪ ‬ﻧﻼﺣظ وﺟود )‪ (cout,printf‬ھذه اﻟدوال ﺗﺳﺗﺧدم ﻟﻌرض اﻟﻧﺎﺗﺞ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻟﻠﻣﺳﺗﺧدم وﺗﺳﻣﻰ دوال‬
                                                                     ‫اﻹﺧراج وھذه ﻣﺎ ﺳﻧﺗﻧﺎوﻟﮫ أﻻن.‬


   ‫‪ ‬ﻓﻲ داﻟﺔ اﻟطﺑﺎﻋﺔ ﻓﻲ ﻟﻐﺔ ‪ C‬اﺳﺗﺧدﻣﻧﺎ اﻟرﻣز "‪ "%d‬ﻻن ﻣﺎ ﺳﻧطﺑﻌﮫ ھو ﻣﺗﻐﯾر ﻣن ﻧوع ‪ integer‬وھذه ﻣﺎ‬
                                                                    ‫ﺳﺗﻔﮭﻣﮫ ﻣن اﻟﺟدول رﻗم ١.‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                             ‫اﻟﻔﺻل اﻷول‬




                                                                                   ‫٤.١- دوال اﻹﺧراج :‬
                   ‫ھﻲ دوال ﺗﺳﺗﺧدم ﻟﻌرض ﻧواﺗﺞ اﻟﻌﻣﻠﯾﺎت اﻟﺗﻲ ﻧرﯾدھﺎ أﻣﺎم اﻟﻣﺳﺗﺧدم ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ واﻟدوال ھﻲ.‬

             ‫++‪C‬‬                                                                     ‫اﻟداﻟﺔ اﻟﻣﺳﺗﺧدﻣﺔ ﻓﻲ ﻟﻐﺔ‬
             ‫;‪cout>>var‬‬

              ‫‪C‬‬                                                                      ‫اﻟداﻟﺔ اﻟﻣﺳﺗﺧدﻣﺔ ﻓﻲ ﻟﻐﺔ‬
             ‫;)‪printf("%symbleToVar",var‬‬

‫‪ ‬أي ﻟﻛل ﻟﻐﺔ ﻟﮭﺎ دوال ﺧﺎﺻﺔ ﻓﻲ اﻹدﺧﺎل وھو اﻻﺧﺗﻼف اﻷﻛﺛر ﺷﯾوﻋﺎ ﺑﯾن ھﺎﺗﯾن اﻟﻠﻐﺗﯾن ھﻲ ودوال اﻹدﺧﺎل‬
                                                        ‫أﻣﺎ ﺑﻘﯾﺔ اﻟدوال ﻓﺗﺗﺷﺎﺑﮫ ﻛﺛﯾرا ﺟدا ﻓﻲ ﻣﺎ ﺑﯾﻧﮭﺎ.‬
                                                 ‫‪ (var) ‬ھو اﺳم اﻟﻣﺗﻐﯾر اﻟذي ﺳوف ﻧﻘوم ﺑطﺑﺎﻋﺔ ﻗﯾﻣﺗﮫ‬
       ‫‪ (symbleToVar) ‬ھﻲ رﻣﻮز ﺗﺴﺘﺨﺪم ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ ﻧﻮع اﻟﻤﺘﻐﯿﺮ اﻟﻤﺮاد طﺒﺎﻋﺘﮫ وھﺬا ﺟﺪول ﺑﺎﻟﺮﻣﻮز‬

                       ‫ﺟدول )١(‬     ‫)ھذا اﻟﺟدول ﻓﻘط ﻣوﺟود ﺑﻠﻐﺔ ‪(C‬‬    ‫وﺻﻔﮫ‬                                ‫اﻟرﻣز‬
                                             ‫اﻟﻣﺗﻐﯾر ‪ var‬ﻋﺒﺎرة ﻋﻦ ﻣﺘﻐﯿﺮ رﻗﻤﻲ‬                ‫;)‪printf ("%d",var‬‬
                                            ‫اﻟﻣﺗﻐﯾر ‪ var‬ﻋﺒﺎرة ﻋﻦ ﻣﺘﻐﯿﺮ ﻛﺴﺮي‬                 ‫;)‪printf ("%f",var‬‬
                                                  ‫اﻟﻣﺗﻐﯾر ‪ var‬ﻋﺒﺎرة ﻋﻦ ﺣﺮف‬                  ‫;)‪printf ("%c",var‬‬
                              ‫اﻟﻣﺗﻐﯾر ‪ var‬ﻋﺒﺎرة ﻋﻦ ﺳﻠﺴﻠﺔ )ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺤﺮوف(‬                 ‫;)‪printf ("%s",var‬‬


                                              ‫ﻣﺜﺎل: ﻟﻮ أردﻧﺎ طﺒﺎﻋﺔ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ )3‪ (data‬وھﻮ ﻣﻦ ﻧﻮع ‪integer‬‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫;3‪cout<< data‬‬                                              ‫;)3‪Printf("%d", data‬‬




               ‫‪ ‬اﺳﺗﺧدﻣﻧﺎ اﻟرﻣز )"‪ (" %d‬ﻓﻲ ﻟﻐﺔ )‪ (C‬ﻻن اﻟﻣﺗﻐﯾر اﻟذي ﺳﻧطﺑﻊ ﻗﯾﻣﺗﮫ ھو ﻣن ﻧوع ‪integer‬‬

                                                                                             ‫ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﻚ اﻷول:‬
                        ‫ﻣﺜﺎل : ﻟﻮ أردﻧﺎ طﺒﺎﻋﺔ )‪ (hi hussien ahammed taleb‬أﻣﺎم اﻟﻤﺴﺘﺨﺪم ﻓﯿﻜﻮن اﻟﻜﻮد ﻛﺎﻟﺘﺎﻟﻲ‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                     ‫)(‪main‬‬
 ‫{‬                                                          ‫{‬
 ‫;"‪cout<<" hi hussien ahammed taleb‬‬                         ‫;)"‪printf(" hi hussien ahammed taleb‬‬
 ‫}‬                                                          ‫}‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                               ‫اﻟﻔﺻل اﻷول‬




               ‫أﻻن ﻟﻨﻨﻔﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ )9‪ (ctrl+f‬أو )‪ (run‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ ﺳﯿﻈﮭﺮ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ﻓﻲ ﺷﺎﺷﺔ اﻟﺘﻨﻔﯿﺬ‬



                                                                                                                  ‫ﻣﮭم‬



                         ‫ﻧﻼﺣﻆ :أي ﺟﻤﻠﺔ ﻧﺼﯿﺔ ﯾﺠﺐ وﺿﻌﮭﺎ ﺑﯿﻦ ﻋﻼﻣﺘﻲ ﺗﻨﺼﯿﺺ ﻋﻨﺪ طﺒﺎﻋﺘﮭﺎ ﻓﻲ دوال اﻟﻄﺒﺎﻋﺔ.‬
 ‫‪ ‬ﻟﻮ أردﻧﺎ وﺿﻊ ﻛﻞ ﻛﻠﻤﺔ ﻓﻲ ﺳﻄﺮ ﻓﻘﻂ ﻧﺴﺘﺨﺪم اﻟﻘﺎﻟﺐ "‪ "\n‬ﺑﯿﻦ ﻛﻞ ﻛﻠﻤﺔ ﺣﯿﺚ ﯾﻘﻮم ھﺬه اﻟﻘﺎﻟﺐ ﺑﺈﻧﺰال اﻟﻤﺆﺷﺮ‬
      ‫ﻓﻲ ﺷﺎﺷﺔ اﻟﺘﻨﻔﯿﺬ إﻟﻰ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ وﻟﺬاﻟﻚ ﻣﺎ ﯾﺘﻢ طﺒﺎﻋﺘﮫ ﺑﻌﺪه ﯾﻄﺒﻊ ﻓﻲ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ اﻟﺬي ﻋﻠﯿﮫ اﻟﻤﺆﺷﺮ‬
 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                     ‫)(‪main‬‬
 ‫{‬                                                          ‫{‬
 ‫;"‪cout<<" hi\nhussien\nahammed\ntaleb‬‬                      ‫;)"‪Printf(" hi\nhussien\nahammed\ntaleb‬‬
 ‫}‬                                                          ‫}‬


                                                                ‫أﻻن ﻟﻨﻨﻔﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﯿﻄﺒﻊ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ﻓﻲ ﺷﺎﺷﺔ اﻟﺘﻨﻔﯿﺬ‬


                                                ‫ﻟﻮ ﺗﻼﺣﻆ ﻛﻞ )"‪ ("\n‬ﯾﻘﻮم ﺑﺈﻧﺰال ﻣﺆﺷﺮ اﻟﻄﺒﺎﻋﺔ إﻟﻰ ﺳﻄﺮ ﺟﺪﯾﺪ ﻟﯿﻄﺒﻊ‬
                                                                             ‫ﻣﺎ ﺑﻌﺪه ﻣﻦ ﻛﻠﻤﺎت ﻓﻲ اﻟﺴﻄﺮ اﻟﺠﺪﯾﺪ‬


  ‫‪ ‬ھﻨﺎك ﺑﻌﺾ اﻟﺮﻣﻮز اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻓﻲ دوال اﻟﻄﺒﺎﻋﺔ ﻟﺘﺮﺗﯿﺐ ﺷﺎﺷﺔ اﻟﻄﺒﺎﻋﺔ أﻣﺎم اﻟﻤﺴﺘﺨﺪم ﺑﻄﺮق ﻣﺨﺘﻠﻔﺔ ﻓﻤﻨﮭﺎ‬
                           ‫ﻣﻦ ﯾﻀﯿﻒ ﻓﺮاﻏﺎت وﻣﻨﮭﺎ ﻣﻦ ﯾﺮﺗﺐ ﻋﻤﻮدي وﻏﯿﺮھﺎ وھﺬا ﺟﺪول ﺑﺘﻠﻚ اﻟﺮﻣﻮز‬

                   ‫ﺑﻌﺾ اﻟﻌﻼﻣﺎت اﻟﻤﮭﻤﺔ ﻓﻲ اﻟﻄﺒﺎﻋﺔ وﺗﺮﺗﯿﺐ اﻟﺸﺎﺷﺔ أﻣﺎم اﻟﻤﺴﺘﺨﺪم )ھﺬه اﻟﻌﻼﻣﺎت ﻣﮭﻤﺔ ﻓﻲ اﻟﻄﺒﺎﻋﺔ(‬

                                                                                   ‫وظﯿﻔﺘﮫ‬                       ‫اﻟﺮﻣﺰ‬
                                                                             ‫ﺗﺮﺗﯿﺐ ﻋﻤﻮدي‬                          ‫‪\v‬‬
                                                                               ‫ﺗﺮﺗﯿﺐ أﻓﻘﻲ‬                         ‫‪\h‬‬
                                                                 ‫أﻧﺰال اﻟﻤﺆﺷﺮ إﻟﻰ ﺳﻄﺮ ﺟﺪﯾﺪ‬                        ‫‪\n‬‬
                                        ‫وﺿﻊ أرﺑﻊ ﻓﺮاﻏﺎت ﺧﻠﻒ اﻟﻌﻨﺼﺮ اﻟﺘﻲ ﺗﻤﺖ طﺒﺎﻋﺘﮫ ﺣﺎﻟﯿﺎ‬                           ‫‪\t‬‬


  ‫ﻓﻲ ﻧﻔﺲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻟﻮ أردﻧﺎ أن ﯾﻄﺒﻊ ﺑﯿﻦ ﻛﻞ ﻛﻠﻤﺔ وأﺧﺮى أرﺑﻊ ﻓﺮاﻏﺎت ﻓﻘﻂ ﻧﺒﺪل "‪ "\n‬ب "‪ "\t‬ﻓﻲ داﻟﺔ اﻟﻄﺒﺎﻋﺔ‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫;"‪cout<<" hi\t hussien\t ahammed\t taleb‬‬                   ‫;)"‪Printf(" hi\t hussien\t ahammed\t taleb‬‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                                         ‫اﻟﻔﺻل اﻷول‬




                                                        ‫ﻣﺜﺎل:إذا أردﻧﺎ طﺒﺎﻋﺔ ﻗﯿﻤﺔ ﻣﺘﻐﯿﺮ ﺗﻢ إﺳﻨﺎد ﻗﯿﻤﺔ إﻟﯿﮫ وﻗﺖ ﺗﻌﺮﯾﻔﮫ .‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                        ‫>‪#include<stdio.h‬‬
 ‫)(‪Main‬‬                                                      ‫)(‪Main‬‬
 ‫{‬                                                           ‫{‬
 ‫;5.3=‪float fixAndPint‬‬                                         ‫;5.3=‪float fixAndPint‬‬
 ‫; ‪cout<< fixAndPint‬‬                                         ‫; )‪printf("%f", fixAndPint‬‬
 ‫}‬                                                           ‫}‬


       ‫١.ﺑﻤﺎ أن اﻟﻤﺘﻐﯿﺮ ﻣﻦ ﻧﻮع )‪ (float‬ﻻﺣﻈﻨﺎ وﺟﻮد "‪ "%f‬ﻓﻲ ﻟﻐﺔ )‪ (C‬دﻻﻟﺔ ﻋﻠﻰ أن اﻟﻤﻐﯿﺮ ﻛﺴﺮي اﻟﺬي ﺳﻮف ﯾﺘﻢ‬
                                                                                               ‫طﺒﺎﻋﺘﮫ‬

                                                      ‫٢.اﻟﻨﺎﺗﺞ ﻓﻲ ﺷﺎﺷﺔ اﻟﺘﻨﻔﯿﺬ ﻟﮭﺬا اﻟﺒﺮﻧﺎﻣﺞ ﯾﻜﻮن ﻓﻘﻂ )5.3( ﻻﺷﻲء أﺧﺮ‬

                                                                      ‫ﻟﻮ أردﻧﺎ أن ﯾﻌﺮض ﻓﻲ ﺷﺎﺷﺔ اﻟﺘﻨﻔﯿﺬ ھﻜﺬا‬             ‫‪‬‬

           ‫$ 5.3=‪Number_is‬‬
                 ‫ﻓﻲ ﻟﻐﺔ ++‪ C‬اﻟﻤﻮﺿﻮع ﺳﮭﻞ ﻓﻘﻂ ﻧﻄﺒﻊ )=‪ (Number_is‬ﺑﺸﻜﻞ ﺳﻠﺴﻠﺔ ﻗﺒﻞ اﻟﻤﺘﻐﯿﺮ) ‪(fixAndPint‬‬
                                               ‫وﻧطﺑﻊ) $( ﺑﻌد اﻟﻣﺗﻐﯾر أﯾﺿﺎ ﺑﺷﻛل ﺳﻠﺳﻠﺔ وﺑﮭذا ﯾﺻﺑﺢ اﻟﻛود ھﻛذا‬

             ‫++‪C‬‬                                                                                        ‫اﻟﻛود ﺑﻠﻐﺔ‬
            ‫>‪#include<iostream.h‬‬
            ‫)(‪Main‬‬
            ‫;5.3=‪{float fixAndPint‬‬                                                                                               ‫ﻣﮭم‬
            ‫}; "$"<<‪cout<<" Number_is="<< fixAndPint‬‬

 ‫إﻣﺎ ﻓﻲ ﻟﻐﺔ )‪ (C‬ﻓﺄن إي ﺳﻠﺴﻠﺔ ﻗﺒﻞ )"‪("%symbleToVar‬اﻟﺨﺎص ﺑﺎﻟﻤﺘﻐﯿﺮ ﯾﻄﺒﻊ ﻗﺒﻞ اﻟﻤﺘﻐﯿﺮ ﻓﻲ ﺷﺎﺷﺔ اﻟﺘﻨﻔﯿﺬ وأي‬
                                                                            ‫ﺳﻠﺴﻠﺔ ﺑﻌﺪه ﺗﻄﺒﻊ ﺑﻌﺪ اﻟﻤﺘﻐﯿﺮ‬

             ‫‪C‬‬                                                                            ‫اﻟداﻟﺔ اﻟﻣﺳﺗﺧدﻣﺔ ﻓﻲ ﻟﻐﺔ‬
            ‫;)‪printf("%symbleToVar",var‬‬


   ‫وﻧﻌﻠﻢ اﻧﮫ ﻛﻞ ﻣﺘﻐﯿﺮ ﻋﻨﺪ طﺒﺎﻋﺘﮫ ﻟﮫ )‪ (symbleToVar‬ﺧﺎص ﺑﮫ ﺣﺴﺐ ﻧﻮﻋﮫ. )وﺑﮭﺬه ﯾﺼﺒﺢ اﻟﻜﻮد ﺑﻠﻐﺔ )‪ (C‬ھﻜﺬا(‬

             ‫‪C‬‬                                                                                          ‫اﻟﻛود ﺑﻠﻐﺔ‬
            ‫>‪#include<stdio.h‬‬
            ‫)(‪Main‬‬
            ‫;5.3=‪{float fixAndPint‬‬
            ‫}; )‪printf(" Number_is=%f$", fixAndPint‬‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                         ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                        ‫اﻟﻔﺻل اﻷول‬




                                                                                  ‫٥.١ - دوال اﻹدﺧﺎل :‬
  ‫ﺗﺳﺗﺧدم دوال اﻹدﺧﺎل ﻹدﺧﺎل ﻣﻌﻠوﻣﺎت ﻣن ﻗﺑل اﻟﻣﺳﺗﺧدم ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ او إﺳﻧﺎد ﻗﯾم إﻟﻰ اﻟﻣﺗﻐﯾرات اﻟﻣﻌرﻓﺔ داﺧل‬
                           ‫اﻟﺑرﻧﺎﻣﺞ ﻣن ﺧﻼل إدﺧﺎل اﻟﻣﺳﺗﺧدم ﻟﻘﯾﻣﮭﺎ ﻟﻐرض ﻣﻌﺎﻟﺟﺗﮭﺎ اﻟﻘﯾﺎم ﺑﺎﻟﻌﻣﻠﯾﺎت اﻟﻣطﻠوﺑﺔ.‬

               ‫++‪C‬‬                                                                            ‫اﻟﻛود ﺑﻠﻐﺔ‬
             ‫;‪cin>>var‬‬

              ‫‪C‬‬                                                                               ‫اﻟﻛود ﺑﻠﻐﺔ‬
             ‫;)‪scanf("%symbleToVar",&var‬‬


                                              ‫‪ (var) ‬ھو ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر اﻟذي ﺳوف ﯾﻘوم اﻟﻣﺳﺗﺧدم ﺑﺎدﺧﺎﻟﮫ.‬
               ‫‪ (symbleToVar) ‬ھﻲ رﻣﻮز ﺗﺴﺘﺨﺪم ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ ﻧﻮع اﻟﻤﺘﻐﯿﺮ اﻟﻤﺪﺧﻞ وھﺬا ﺟﺪول ﺑﺎﻟﺮﻣﻮز.‬

                        ‫ﺟدول )٢(‬       ‫)ھذا اﻟﺟدول ﻓﻘط ﻣوﺟود ﺑﻠﻐﺔ ‪(C‬‬    ‫وﺻﻔﮫ‬                         ‫اﻟرﻣز‬
                                                ‫اﻟﻣﺗﻐﯾر ‪ var‬ﻋﺒﺎرة ﻋﻦ ﻣﺘﻐﯿﺮ رﻗﻤﻲ‬         ‫;)‪scanf("%d",&var‬‬
                                               ‫اﻟﻣﺗﻐﯾر ‪ var‬ﻋﺒﺎرة ﻋﻦ ﻣﺘﻐﯿﺮ ﻛﺴﺮي‬           ‫;)‪scanf("%f",&var‬‬
                                                     ‫اﻟﻣﺗﻐﯾر ‪ var‬ﻋﺒﺎرة ﻋﻦ ﺣﺮف‬           ‫;)‪scanf("%c",&var‬‬
                                                     ‫اﻟﻣﺗﻐﯾر ‪ var‬ﻋﺒﺎرة ﻋﻦ ﺳﻠﺴﻠﺔ‬         ‫;)‪scanf("%s",&var‬‬

                                                              ‫ﻧﺳﺗطﯾﻊ إدﺧﺎل أﻛﺛر ﻣن ﻣﺗﻐﯾر ﻓﻲ داﻟﺔ إدﺧﺎل واﺣدة‬

               ‫++‪C‬‬                                                                            ‫اﻟﻛود ﺑﻠﻐﺔ‬
             ‫;2‪cin>>var1>>var‬‬


              ‫‪C‬‬                                                                               ‫اﻟﻛود ﺑﻠﻐﺔ‬
             ‫;)2‪scanf("%symbleToVar %symbleToVar ",&var1,&var‬‬

                             ‫‪ ‬ﻛﻣﺎ ﻣﺑﯾن ﺑﺎﻟرﺳم اﻟﻣؤﺷر ﺑﺎﻷﺳﮭم ﻛل ﻣﺗﻐﯾر وﻟﮫ )‪ (%symbleToVar‬ﺧﺎص ﺑﮫ‬
  ‫ﻣﮭم‬



   ‫ﻣﺛﺎل: إذا ﻛﺎن ﻟدﯾﻧﺎ اﻟﻣﺗﻐﯾر )‪ (x‬ﻣن ﻧوع )‪ (float‬وأردﻧﺎ إدﺧﺎل ﻗﯾﻣﮫ ﻟﮫ ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﺳﯾﻛون اﻟﻛود ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

              ‫++‪C‬‬                                                                             ‫اﻟﻛود ﺑﻠﻐﺔ‬
             ‫;‪cin>> x‬‬

              ‫‪C‬‬                                                                               ‫اﻟﻛود ﺑﻠﻐﺔ‬
             ‫;)‪scanf("%f",& x‬‬
                      ‫‪ ‬اﺳﺗﺧدﻣﻧﺎ اﻟرﻣز )"‪ (" %f‬ﻓﻲ ﻟﻐﺔ )‪ (C‬ﻻن اﻟﻣﺗﻐﯾر اﻟذي ﺳﻧطﺑﻊ ﻗﯾﻣﺗﮫ ﻣن ﻧوع )‪(float‬‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                                        ‫اﻟﻔﺻل اﻷول‬




    ‫ﻣﺛﺎل: ﻟو أردﻧﺎ أن ﯾﻘوم اﻟﻣﺳﺗﺧدم ﺑﺈدﺧﺎل ﺣرف وﯾطﺑﻊ اﻟﺣرف أﻣﺎﻣﮫ ﺑﯾن ﻗوﺳﯾن إي ﻟو ادﺧل ‪ a‬ﺳوف ﯾطﺑﻊ ﻓﻲ‬
                                                                                   ‫ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ )‪(a‬‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                     ‫)(‪main‬‬
 ‫{‬                                                          ‫{‬
 ‫;‪1.char enterchar‬‬                                          ‫;‪1.char enterchar‬‬
 ‫;‪2.cin>> enterchar‬‬                                         ‫;) ‪2.scanf("%c",& enterchar‬‬
 ‫; ")"<< ‪3.cout<<" ("<< enterchar‬‬                           ‫; )‪3.prin (" (%c)", enterchar‬‬
 ‫}‬                                                          ‫}‬


                                                                                                        ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                                                       ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ﻣن ﻧوع ﺣرﻓﻲ‬

        ‫٢. ﺧطوة رﻗم )٢( ﻗﻣﻧﺎ ﺑﺈدﺧﺎل ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وﯾدﺧل ﻓﻘط ﺣرف واﺣد .ﺑﻣﺎ اﻧﮫ اﻟﻣﺗﻐﯾر ﻣن ﻧوع‬
                                                        ‫‪ character‬ﻓﻲ ﻟﻐﺔ )‪ (C‬ﯾﻘرئ وﯾطﺑﻊ ﺑدﻻﻟﺔ "‪"%C‬‬

                  ‫٣.ﺧطوة رﻗم )٣( ﻗﻣﻧﺎ ﺑطﺑﺎﻋﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر اﻟﺗﻲ أدﺧﻠت ﻓﻲ ﺧطوة رﻗم )٢( ﺑﯾن ﻗوﺳﯾن‬
                                                                                ‫ﻣﺎ ﺳﯾظﮭر ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھو‬




                                                                                                                            ‫ﻣﮭم‬


 ‫أﺑدال ﺑﯾن ﻗﯾم ﻣﺗﻐﯾرﯾن: ﻹﺑدال ﺑﯾن ﻗﯾﻣﺔ ﻣﺗﻐﯾرﯾن ﻧﺣﺗﺎج إﻟﻰ ﻣﺗﻐﯾر ﺛﺎﻟث ﻣن ﻧﻔس ﻧوع اﻟﻣﺗﻐﯾرﯾن ﺣﺗﻰ ﻧﺧزن ﺑﮫ ﻧﺗﯾﺟﺔ‬
       ‫ِ‬
                 ‫اﺣد اﻟﻣﺗﻐﯾرﯾن ﺛم ﻧﺑدل ﻻن ﻓﻲ ﺣﺎل ﻋدم وﺟود ﻣﺗﻐﯾر ﺛﺎﻟث ﻻ ﻧﺳﺗطﯾﻊ اﻹﺑدال ﺳﺗﺿﯾﻊ اﺣد اﻟﻘﯾﻣﺗﯾن‬

                                                                      ‫ﻣﺛﺎل : أﺑدال ﺑﯾن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (a‬واﻟﻣﺗﻐﯾر )‪(b‬‬


                                                                      ‫ﻛود اﻹﺑدال ﺑﯾن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (a‬واﻟﻣﺗﻐﯾر )‪(b‬‬
           ‫;‪int a=12,b=30,c‬‬     ‫03=‪//a=12 , b‬‬
            ‫;‪c=a‬‬         ‫ﻧﺧزن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ a‬ﻓﻲ ﻣﺗﻐﯾر ﺛﺎﻟث )‪// (c‬‬
            ‫;‪a=b‬‬       ‫ﻧﺿﻊ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ b‬ﻓﻲ اﻟﻣﺗﻐﯾر ‪//a=30, a‬‬
            ‫;‪b=c‬‬    ‫ﻧﺿﻊ اﻟﻘﯾﻣﺔ اﻟﻣﺧزﻧﺔ ﻓﻲ اﻟﻣﺗﻐﯾر اﻟﺛﺎﻟث وھﻲ ﻗﯾﻣﺔ ‪ a‬ﻓﻲ اﻟﻣﺗﻐﯾر ‪// b=12, b‬‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                         ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                     ‫اﻟﻔﺻل اﻷول‬




                         ‫٦.١- اﻟﻌﻣﻠﯾﺎت اﻟﺣﺳﺎﺑﯾﺔ وطرق ﺗﻣﺛﯾﻠﮭﺎ وأوﻟوﯾﺎﺗﮭﺎ )اﻷﺳﺑﻘﯾﺔ(:‬
                                 ‫اﻟرﯾﺎﺿﯾﺔ:ﺗﺳﺗﺧدم ﻻﺟراء اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ ﻋﻠﻰ اﻟﻣﺗﻐﯾرات واﻻرﻗﺎم‬   ‫اﻟﻌﻣﻠﯾﺎت‬
                      ‫اﻷﺳﺑﻘﯾﺔ‬                                ‫اﻟوظﯾﻔﺔ‬                            ‫اﻟرﻣز‬
                           ‫١‬                        ‫اﻟزﯾﺎدة واﻟﻧﻘﺻﺎن‬                        ‫++ أو--‬
                           ‫٢‬                          ‫اﻹﺷﺎرة اﻟﺳﺎﻟﺑﺔ‬                               ‫-‬
                           ‫٣‬               ‫اﻟﺿرب واﻟﻘﺳﻣﺔ وﺑﺎﻗﯾﮭﺎ‬                     ‫*أو / أو %‬
                           ‫٤‬                        ‫اﻟﺟﻣﻊ أو اﻟطرح‬                            ‫+ أو -‬
                           ‫٥‬                                 ‫اﻟﺗﺳﺎوي‬                               ‫=‬
                           ‫٦‬                   ‫زﯾﺎدة أو ﻧﻘﺻﺎن ﻟﻠﻌدد‬      ‫++ أو – اﻟﻣﺗﺄﺧرة ﺑﻌد اﻟرﻣز‬


             ‫‪:Bowties‬ﺗﺳﺗﺧدم ﻻﺟراء اﻟﻌﻣﻠﯾﺎت اﻟﻣﻧطﻘﯾﺔ ﻋﻠﻰ اﻟﻣﺗﻐﯾرات واﻻرﻗﺎم واﻟﺗﻌﺎﺑﯾر اﻟرﯾﺎﺿﯾﺔ‬     ‫اﻷدوات‬
                      ‫اﻷﺳﺑﻘﯾﺔ‬                             ‫اﻟوظﯾﻔﺔ‬                                  ‫اﻟرﻣز‬
                           ‫١‬                           ‫إﺷﺎرة اﻟﻧﻔﻲ‬                  ‫~‬
                           ‫٢‬              ‫إزاﺣﺔ ﻟﻠﻌدد ﯾﻣﯾن أو ﯾﺳﺎر‬               ‫<< أو >>‬
                           ‫٣‬                         ‫ﻋﻣﻠﯾﺔ )‪(and‬‬                   ‫&‬
                           ‫٤‬                           ‫اﻟرﻓﻊ ﻟﻘوى‬                   ‫^‬
                           ‫٥‬                           ‫ﻋﻣﻠﯾﺔ )‪(or‬‬                   ‫|‬

                                    ‫اﻟﻣﻧطﻘﯾﺔ: ﺗﺳﺗﺧدم ﻣﻊ اﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ ﻛﺷروط ﺗﺣﻘق اوﻋدم ﺗﺣﻘق‬   ‫اﻷدوات‬
                      ‫اﻷﺳﺑﻘﯾﺔ‬                                 ‫اﻟوظﯾﻔﺔ‬                              ‫اﻟرﻣز‬
                           ‫١‬                                     ‫اﻟﻧﻔﻲ‬                                 ‫!‬
                           ‫٢‬                      ‫ﻋﻣﻠﯾﺔ ﻣﻧطﻘﯾﺔ )‪(and‬‬                                ‫&&‬
                           ‫٣‬                        ‫ﻋﻣﻠﯾﺔ ﻣﻧطﻘﯾﺔ )‪(or‬‬                              ‫||‬
 ‫‪ ‬ﺗﻛون ﻧواﺗﺞ اﻷدوات اﻟﻣﻧطﻘﯾﺔ وﻣﻘﺎرﻧﺎﺗﮭﺎ إﻣﺎ )‪ (True‬أو )‪ (False‬أي أﻣﺎ واﺣد أو ﺻﻔر .إذا ﻛﺎن اﺣد طرﻓﻲ‬
                                  ‫اﻟﻣﻘﺎرﻧﺔ رﻗم ﻏﯾر اﻟﺻﻔر ﻣﺛﻼ ﺳﺑﻌﺔ ﻓﺄي رﻗم ﻏﯾر اﻟﺻﻔر ﯾﻌﺗﺑره واﺣد‬
               ‫وأدوات )‪(Bowties‬‬          ‫‪ ‬ﺗﺳﺗﺧدم اﻷدوات اﻟﻣﻧطﻘﯾﺔ ﻛﺷروط ﻣﻘﺎرﻧﮫ ﻓﻲ اﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ ھﻲ‬
      ‫‪ ‬ﻓﻲ اﻷﺳﺑﻘﯾﺎت اﻟرﻗم اﻷﻗل أﻋﻠﻰ أﺳﺑﻘﯾﺔ ﻣﺛﻼ أﺳﺑﻘﯾﺔ اﻟﺿرب أﻋﻠﻰ ﻣن أﺳﺑﻘﯾﺔ اﻟﺟﻣﻊ ﻷن رﻗم اﻟﺿرب ﻓﻲ‬
                                                   ‫ﺟدول اﻷﺳﺑﻘﯾﺔ ھو )٣( و رﻗم اﻟﺟﻣﻊ ھو )٤(‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                         ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                             ‫اﻟﻔﺻل اﻷول‬




                                                                       ‫٧.١- ﺗﻣﺛﯾل اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ:‬
 ‫ﺗﻣﺛل اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ ﺑرﻣﺟﯾﺎ ﺑطرﯾﻘﺔ ﻣﺷﺎﺑﮫ ﻟطرﯾﻘﺔ ﺗﻣﺛﯾﻠﮭﺎ رﯾﺎﺿﯾﺎ ﻣﻊ ﺗﻐﯾر طﻔﯾف ﺑﺎﻟرﻣوز اﻟرﯾﺎﺿﯾﺔ ﻟﻣﺎ ﯾﻛﺎﻓﺋﮭﺎ‬
                             ‫ﻣن اﻟرﻣوز اﻟﺑرﻣﺟﯾﺔ وﻻﺣظ ھذا اﻟﺟدول اﻟﺗوﺿﯾﺣﻲ ﻟﻠﻌﻣﻠﯾﺎت وﺗﻣﺛﯾﻠﮭﺎ رﯾﺎﺿﯾﺎ وﺑرﻣﺟﯾﺎ‬



                            ‫اﻟﻣﺛﺎل اﻟﺗﺎﻟﻲ ﻋﻠﻰ أﺳﺎس ﻋﻧدﻧﺎ ﻣﺗﻐﯾران ھﻣﺎ )‪ (a,b‬وﻧﺎﺗﺞ اﻟﻌﻣﻠﯾﺔ اﻟرﯾﺎﺿﯾﺔ ﯾﺧزن ﻓﻲ )‪(c‬‬

                     ‫ﺗﻤﺜﯿﻠﮫ ﺑﺮﻣﺠﯿﺎ‬                               ‫ﺗﻤﺜﯿﻠﮫ رﯾﺎﺿﯿﺎ‬               ‫اﻟﺮﻣﺰ و اﻟﻮظﯿﻔﺔ‬
                         ‫;‪C=a+b‬‬                             ‫‪C=a+b‬‬                                 ‫اﻟﺠﻤﻊ)+(‬
                          ‫;‪C=a-b‬‬                            ‫‪C=a-b‬‬                                  ‫اﻟﻄﺮح)-(‬
                         ‫;‪C=a/b‬‬                                                                  ‫اﻟﻘﺴﻤﺔ)/(‬
                          ‫;‪C=a*b‬‬                         ‫‪C=a*b‬‬                                 ‫اﻟﻀﺮب)*(‬
                          ‫;‪C=a%b‬‬                       ‫‪C=a mod b‬‬                           ‫ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ)%(‬

       ‫‪ ‬ﻻﺣظ أن اﻟﺗﻣﺛﯾل اﻟﺑرﻣﺟﻲ ﻣﺷﺎﺑﮫ ﺗﻘرﯾﺑﺎ ﻟﻠﺗﻣﺛﯾل اﻟرﯾﺎﺿﻲ ﻣﻊ أﺑدال ﺑﻌض اﻟرﻣوز ﺑﻣﺎ ﯾﻛﺎﻓﺋﮭﺎ‬
                      ‫ووﺿﻊ ﻓﺎرزة ﻣﻧﻘوطﺔ ﻓﻲ ﻧﮭﺎﯾﺔ اﻟﺗﻌﺑﯾر )ﺷﺎھد ﺳؤال رﻗم ٠٩ ﺑﺎﻻﻣﺛﻠﺔ اﻟﻣرﻓﻘﺔ( .‬


  ‫ﻣﺛﺎل:ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻣﺗﻐﯾرﯾن ﻣن ﻧوع )‪ (integer‬وﻛﻼھﻣﺎ ﯾﺣﻣل ﻗﯾﻣﺔ ﻣﻌﯾﻧﺔ ﯾدﺧل ﻗﯾﻣﮭم اﻟﻣﺳﺗﺧدم ﻣن‬
                                                           ‫ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻗم ﺑﻌﻣﻠﯾﺔ ﺟﻣﻊ ﻟﮭﻣﺎ.‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪1.#include<iostream.h‬‬                                     ‫>‪1.#include<stdio.h‬‬
 ‫)(‪2.main‬‬                                                   ‫)(‪2.main‬‬
 ‫;‪3.{ int first, seconds, sum‬‬                                ‫;‪3.{ int first, seconds, sum‬‬
 ‫;‪4.cin>> first‬‬                                              ‫;)‪4.scanf("%d", &first‬‬
 ‫;"‪5. cout<<"+\n‬‬                                            ‫;)"‪5. prin ("+\n‬‬
 ‫;‪6. cin>> seconds‬‬                                          ‫;)‪6. scanf("%d", & seconds‬‬
 ‫;‪7.sum= first+ seconds‬‬                                      ‫;‪7.sum= first+ seconds‬‬
 ‫; ‪8.cout<<"---------\nsum="<< sum‬‬                          ‫; ) ‪8.prin ("---------\nsum=%d", sum‬‬
 ‫} .9‬                                                       ‫} .9‬
                                                                                               ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

            ‫١.ﺧطوة رﻗم )١( ھﻲ ﺗﻌرﯾف ﻟﻠﻣﻛﺗﺑﺔ اﻟﺧﺎﺻﺔ ﺑدوال اﻹدﺧﺎل واﻹﺧراج.ﺧطوة رﻗم )٢( ھﻲ داﻟﺔ )(‪main‬‬

        ‫٢.ﺧطوة رﻗم )٣( ﻓﺗﺣﻧﺎ ﻗوس ﺑداﯾﺔ اﻟﺑرﻧﺎﻣﺞ. ﻋرﻓﻧﺎ اﻟﻣﺗﻐﯾر اﻷول .و ﻋرﻓﻧﺎ اﻟﻣﺗﻐﯾر اﻟﺛﺎﻧﻲ وﻋرﻓﻧﺎ ﻣﺗﻐﯾر اﻟﺟﻣﻊ‬


   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                        ‫اﻟﻔﺻل اﻷول‬




  ‫٣.ﺧطوة رﻗم )٤( ﻗرﺋﻧﺎ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر اﻷول ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ.وﺧطوة رﻗم )٥( طﺑﻌﻧﺎ ﻋﻼﻣﺔ اﻟﺟﻣﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
                                ‫ﻟزﯾﺎدة ﺟﻣﺎﻟﯾﺔ اﻟﺑرﻧﺎﻣﺞ. .ﺧطوة رﻗم )٦( ﻗرﺋﻧﺎ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر اﻟﺛﺎﻧﻲ ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

 ‫٤. ﺧطوة رﻗم )٧( ﻗﻣﻧﺎ ﺑﺟﻣﻊ اﻟﻣﺗﻐﯾر) ‪ ( first‬واﻟﻣﺗﻐﯾر) ‪ (seconds‬ﺑداﺧل ﻣﺗﻐﯾر أﺧر اﺳﻣﮫ )‪ (Sum‬وطﺑﻌﻧﺎ ﻗﯾﻣﺔ‬
  ‫ھذه اﻟﻣﺗﻐﯾر ﻓﻲ ﺧطوة رﻗم )٨( وﻋرﻓﻧﺎ اﻟﻣﺗﻐﯾر )‪ (Sum‬ﻣن ﻧوع )‪ (integer‬وھو ﻋﻠﻰ أﺳﺎس ﺟﻣﻊ ﻋددﯾن ﻣن‬
‫ﻧوع )‪ (integer‬ﯾﻛون اﻟﻧﺎﺗﺞ ﻣن ﻧوع )‪ (integer‬وﻟو ﻛﺎن اﺣد اﻟﻌددان ﻏﯾر )‪ (integer‬ﻟﻛﺎن ﯾﺟب ﺗﻌرﯾف ‪Sum‬‬
    ‫ﺑطرﯾﻘﺔ ﺑﻼﺋم ﻛﻲ ﯾﺣﻣل ﻧﺗﯾﺟﺔ ﺟﻣﻊ ھذان اﻟﻌددان إي ﻟو ﻛﺎن اﺣدھﻣﺎ ﻛﺳري ﻟﻛﺎن ﯾﺟب ﺗﻌرﯾﻔﮫ ﻣن ﻧوع )‪(float‬‬

                                                                    ‫٥.ﺧطوة رﻗم )٩( ﻗﻣﻧﺎ ﺑﺈﻏﻼق ﻗوس اﻟﺑرﻧﺎﻣﺞ‬

                                                                       ‫ﻣﺎ ﺳﯾظﮭر ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھو.‬


‫‪ ‬وﻧﺳﺗطﯾﻊ إﺟراء ﺑﻘﯾﺔ اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ ﻋﻠﻰ اﻟﻣﺗﻐﯾرﯾن ﺑﻧﻔس اﻟطرﯾﻘﺔ ﻓﻘط ﻧﺑدل إﺷﺎرة اﻟﺟﻣﻊ ﻓﻲ اﻟﺧطوة رﻗم‬
                                                      ‫)٧( إﻟﻰ إﺷﺎرة ﺿرب أو طرح أو ﻗﺳﻣﺔ ؟إي ان‬
                              ‫‪ ‬ﻟو أردﻧﺎ أﺟراء ﻋﻣﻠﯾﺔ طرح ﻟﻠرﻗﻣﯾن اﻟﻣدﺧﻠﯾن ﻓﻘط ﻧﻐﯾر ﺧطوة رﻗم )٧( إﻟﻰ‬
                                                                                                 ‫ﻛود‬
           ‫;‪7.sum= first- seconds‬‬

                                                       ‫ﻣﻊ ﺗﻐﯾر رﻣز اﻟﺟﻣﻊ ﻓﻲ ﺧطوة رﻗم )٥( إﻟﻰ رﻣز اﻟطرح‬

                                 ‫‪ ‬ﻟو أردﻧﺎ أﺟراء ﻋﻣﻠﯾﺔ ﺿرب ﻟﻠرﻗﻣﯾن اﻟﻣدﺧﻠﯾن ﻓﻘط ﻧﻐﯾر ﺧطوة رﻗم )٧( إﻟﻰ‬
                                                                                                 ‫ﻛود‬
           ‫;‪7.sum= first* seconds‬‬

                                                      ‫ﻣﻊ ﺗﻐﯾر رﻣز اﻟﺟﻣﻊ ﻓﻲ ﺧطوة رﻗم )٥( إﻟﻰ رﻣز اﻟﺿرب‬

                                  ‫‪ ‬ﻟو أردﻧﺎ أﺟراء ﻋﻣﻠﯾﺔ ﻗﺳﻣﺔ ﻟﻠرﻗﻣﯾن اﻟﻣدﺧﻠﯾن ﻓﻘط ﻧﻐﯾر ﺧطوة رﻗم )٧( إﻟﻰ‬
                                                                                                 ‫ﻛود‬
           ‫;‪7.sum= first/ seconds‬‬

                                                       ‫ﻣﻊ ﺗﻐﯾر رﻣز اﻟﺟﻣﻊ ﻓﻲ ﺧطوة رﻗم )٥( إﻟﻰ رﻣز اﻟﻘﺳﻣﺔ‬

     ‫‪ ‬ﻓﻲ ﻋﻣﻠﯾﺔ اﻟﻘﺳﻣﺔ ﯾﺗم ﺗﻌرﯾف اﻟﻣﺗﻐﯾر )‪ (div‬ﺑدل اﻟﻣﺗﻐﯾر )‪ (sum‬ﻋﻠﻰ اﻧﮫ ﻣﺗﻐﯾر ﻛﺳري ﻻن‬
                                     ‫ﻋﻣﻠﯾﺔ ﻗﺳﻣﺔ إي ﻋددﯾن ﻗد ﯾﻧﺗﺞ ﻋﻧﮭﺎ رﻗم ﺑﻌد اﻟﻔﺎرزة‬

             ‫ﻛﻣﺎ ﻻﺣظﻧﺎ أن اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ ﺑرﻣﺟﯾﺎ ﺗﻣﺛل ﻧﻔس اﻟطرﯾﻘﺔ اﻻﻋﺗﯾﺎدﯾﺔ ﻟﻛن ﺑرﻣوز أﺧرى داﻟﺔ ﻋن‬
                                                                         ‫ﻧوع اﻟﻌﻣﻠﯾﺔ ﻓﻲ ﺑﻌض اﻟﺣﺎﻻت‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                        ‫اﻟﻔﺻل اﻷول‬




    ‫اﯾﺟﺎد ﺑﺎﻗﻲ اﻟﻘﺳﻣﺔ: ﺑﺎﻗﻲ اﻟﻘﺳﻣﺔ ھو ﻣﺎ ﺗﺑﻘﻰ ﻣن ﻗﺳﻣﺔ ﻋددﯾﯾن و ﯾﺳﺗﺧدم اﻟرﻣز % ﻟﻠدﻻﻟﺔ ﻋﻠﻰ‬ ‫ِ‬
                                                                             ‫ﺑﺎﻗﻲ اﻟﻘﺳﻣﺔ .‬

                                                                             ‫ﺑﺎﻗﻲ ﻗﺳﻣﺔ اﻹﻋداد اﻟﺗﺎﻟﯾﺔ‬
     ‫1=2%3‬
     ‫0=2%6‬
     ‫0=3%9‬
                                                                                                     ‫ﻣﮭم‬

     ‫2=8%01‬
                             ‫ﻻﺣظ أن إذا ﻛﺎن اﻟرﻗم اﻷول اﻗل ﻣن اﻟﺛﺎﻧﻲ ﻓﻼ ﯾﺗﻘﺳم ﻋﻠﯾﮫ أﺻﻼ ﻛﻠﮫ ﯾﺑﻘﻰ ﻛﺑﺎﻗﻲ ﻗﺳﻣﺔ‬

     ‫9=21%9‬
     ‫7=8%7‬


                  ‫‪ ‬ﻟو أردﻧﺎ أﯾﺟﺎد ﺑﺎﻗﻲ ﻗﺳﻣﺔ ﻟﻠرﻗﻣﯾن اﻟﻣدﺧﻠﯾن ﻓﻲ اﻟﻣﺛﺎل اﻟﺳﺎﺑق ﻓﻘط ﻧﻐﯾر ﺧطوة رﻗم )٧( إﻟﻰ‬
                                                                                               ‫ﻛود‬
           ‫;‪7.sum= first % seconds‬‬


‫اﻟﻌﻼﺋﻘﯾﺔ: ھﻲ رﻣوز ﺗﺳﺗﺧدم ﻟﻣﻌرﻓﺔ اﻟﻌﻼﻗﺔ ﺑﯾن ﺗﻌﺑﯾرﯾن او ﻣﺗﻐﯾرﯾن إي ھل ﯾﺳﺎوﯾﮫ أو أﻛﺑر ﻣﻧﮫ أو ﻻ‬          ‫اﻟرﻣوز‬
                        ‫ﯾﺳﺎوي أو اﺻﻐر ﻣﻧﮫ وھذا ﺟدول ﺑﮭذه اﻟرﻣوز وﺗﻛون ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ إﻣﺎ )‪ (True‬او )‪(False‬‬

                              ‫ﻣﺛﺎل‬                                  ‫اﻟوظﯾﻔﺔ‬                           ‫اﻟرﻣز‬
                            ‫)‪(a>b‬‬                                ‫ﻋﻼﻣﺔ اﻛﺑر‬                     ‫>‬
                          ‫)‪(a>=b‬‬                        ‫ﻋﻼﻣﺔ اﻛﺑر أو ﯾﺳﺎوي‬                    ‫=>‬
                            ‫)‪(a<b‬‬                               ‫ﻋﻼﻣﺔ أﺻﻐر‬                    ‫<‬
                          ‫)‪(a<=b‬‬                       ‫ﻋﻼﻣﺔ أﺻﻐر أو ﯾﺳﺎوي‬                     ‫=<‬
                          ‫)‪(a==b‬‬                              ‫ﻋﻼﻣﺔ اﻟﯾﺳﺎوي‬                    ‫==‬
                           ‫)‪(a!=b‬‬                            ‫ﻋﻼﻣﺔ ﻻ ﯾﺳﺎوي‬                     ‫=!‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                     ‫اﻟﻔﺻل اﻷول‬


                                                ‫ﻣﮭم‬

                                                                 ‫٨.١- اﻷﺳﺑﻘﯾﺎت وطرق ﻣﻌﺎﻣﻠﺗﮭﺎ :‬
‫ﻓﻲ ﺟداول اﻟرﻣوز وﺿﻌﻧﺎ أﻣﺎم ﻛل رﻣز اﻷﺳﺑﻘﯾﺔ اﻟﺧﺎﺻﺔ ؟ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل إذا ﺟﺎءت ﻋﻣﻠﯾﺔ ﺿرب و‬
  ‫ﻋﻣﻠﯾﺔ ﺟﻣﻊ ﻓﻲ ﺗﻌﺑﯾر واﺣد ﻓﯾﻛون ﻟﻠﺿرب أﺳﺑﻘﯾﺔ ﻋﻠﻰ اﻟﺟﻣﻊ )ﻷن أﺳﺑﻘﯾﺗﮫ اﻟﺿرب ھﻲ )٣( وأﺳﺑﻘﯾﺔ‬
  ‫اﻟﺟﻣﻊ ھﻲ )٤( إي اﻟﺿرب أﻋﻠﻰ أﺳﺑﻘﯾﺔ )اﻟرﻗم اﻷﻗل أﻋﻠﻰ أﺳﺑﻘﯾﺔ ﻣن ﺟدول اﻻﺳﺑﻘﯾﺎت( وﯾﻧﻔذ ﻗﺑﻠﮫ‬
 ‫وھذا ھو ﻣن أﺻول ﻋﻣل اﻟﻣﺗرﺟم ﻟذاﻟك ﯾﺟب ﻓﮭم اﻷﺳﺑﻘﯾﺎت ﺣﺗﻰ ﻻ ﺗﺧطﺊ ﻓﻲ طرﯾﻘﺔ ﺗﺣﻠﯾل اﻟﺗﻌﺑﯾر‬
                                                                        ‫اﻟرﯾﺎﺿﻲ ﻷي ﻣﺳﺋﻠﺔ‬
                                         ‫ﺷﺎھد ﺗﻐﻠب اﻷﺳﺑﻘﯾﺎت ﻓﻲ اﻟﻣﺛﺎل اﻟﺗﺎﻟﻲ ھو )‪.(a-b/d‬؟‬

                                                                                                      ‫ﻣﺛﺎل‬
                                  ‫ﯾﺑدأ اﻟﻣﺗرﺟم ﺗﻧﻔﯾذ اﻟﻌﻣﻠﯾﺎت ﻣن اﻟﯾﺳﺎر إﻟﻰ اﻟﯾﻣﯾن‬


                                          ‫‪Reslt=a – c / d‬‬
                      ‫ﯾﺑدءا ﺑﻣﻘﺎرﻧﺔ ﻛل ﻋﻣﻠﯾﺗﯾن رﯾﺎﺿﯾﺗﯾن ﻣﻌﺎ وأﯾﮭﻣﺎ ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﺗﻧﻔذ اوﻷ‬

                              ‫إذا ﻛﺎن )2=‪ (a=5,c=10,d‬ﻓﯾﻛون ﺗﺳﻠﺳل ﺗﻧﻔﯾذ اﻟﺧطوات‬

   ‫.1‬                                    ‫2 / 01 – 5=‪Reslt‬‬

     ‫ﻋﻧد ﻣﻘﺎرﻧﺔ ﻋﻣﻠﯾﺔ اﻟﻘﺳﻣﺔ و اﻟطرح ﻓوﺟد اﻧﮫ اﻟﻘﺳﻣﺔ ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﻣن اﻟطرح ﻟذاﻟك ﺳﺗﻧﻔذ اﻟﻘﺳﻣﺔ أوﻻ‬
                                            ‫ﻓﯾﻘﺳم )5=2/01(‬

   ‫.2‬                                          ‫5 – 5=‪Reslt‬‬

      ‫ﺗﻧﻔذ ﻋﻣﻠﯾﺔ اﻟطرح ﺑﺷﻛل اﻋﺗﯾﺎدي ﻷﻧﮭﺎ أﺧر ﻋﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ ﻣﺗﺑﻘﯾﺔ ﻗﺑل اﻟﻣﺳﺎواة وﯾﻛون اﻟﻧﺎﺗﺞ ھوا ﺻﻔر‬
                               ‫وأﺧر ﻋﻣﻠﯾﺔ ﺳﺗﻧﻔذ ھﻲ اﻟﻣﺳﺎواة ﻓﺗﺻﺑﺢ ﻗﯾﻣﺔ‬
                                                 ‫(‬    ‫)0=‪Reslt‬‬
    ‫ﻟو ﻻﺣظﻧﺎ ﻛﯾف ﺗﻐﻠﺑت ﻋﻣﻠﯾﺔ اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﻋﻣﻠﯾﺔ اﻟطرح ﻓﻲ اﻟﻣﺛﺎل ورﺑﻣﺎ ﻧﺣن ﻛﻧﺎ ﻧرﯾد أن ﺗﻧﻔذ ﻋﻣﻠﯾﺔ اﻟطرح‬
    ‫أوﻻ ﻟﻛن اﻟﻣﺗرﺟم ﻧﻔذ ﺣﺳب اﻻﺳﺑﻘﯾﺔ ﻟذاﻟك ﯾﺟب ﻣراﻋﺎة اﻟﺗﻌﺑﯾر واﻻﺳﺑﻘﯾﺎت واﺳﺗﺧدام اﻻﻗواس ﻟﻠﺗﺧﻠص ﻣن‬
                                                     ‫اﻻﺳﺑﻘﯾﺔ اﻻﻋﻠﻰ ﻻن اﻻﻗواس اﻋﻠﻰ اﺳﺑﻘﯾﺔ ﻣن اﻟﺟﻣﯾﻊ.‬
       ‫ﻣﻼﺣظﺔ ﻣﮭﻣﺔ: ﻋﻧد ﻣﻘﺎرﻧﺔ ﻋﻣﻠﯾﺗﺎن وﯾﺟد أن اﻻﺳﺑﻘﯾﺗﺎن ﻣﺗﺳﺎوﯾﺗﺎن ﺳﯾﻧﻔذ ﻣن اﻟﯾﺳﺎر إﻟﻰ اﻟﯾﻣﯾن أول‬
                                                                          ‫ﻋﻣﻠﯾﺔ ﺗﻘﻊ ﻓﻲ اﻟﯾﺳﺎر ﺗﻧﻔذ أوﻻ‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                     ‫اﻟﻔﺻل اﻷول‬



                                                                                                         ‫ﻣﺛﺎل‬
 ‫‪Reslt=a * c +d‬‬
                     ‫ﻓﻲ ھذا اﻟﻣﺛﺎل ﻧﺣن ﻧﻘﺻد ﻓﻲ ﺗﻌﺑﯾرﻧﺎ أن )‪ (c,d‬ﯾﺟﻣﻌون أوﻻ ﺗم ﺗﺿرب اﻟﻧﺗﯾﺟﺔ ﻓﻲ ) ‪(a‬‬
    ‫ﻟﻛن اﻟواﻗﻊ ﻏﯾر ذاﻟك ﺣﺳب اﻷﺳﺑﻘﯾﺎت أن اﻟﺿرب ﻟﮫ أﺳﺑﻘﯾﺔ اﻋﻠﻰ اﻟﺟﻣﻊ ﻟذاﻟك ﺳوف ﯾﺿرب )‪ (a,c‬وﺗﺟﻣﻊ‬
           ‫اﻟﻧﺗﯾﺟﺔ ﻣﻊ ) ‪ (d‬وﯾﻛون اﻟﻧﺎﺗﺞ ﻏﯾر ﺻﺎﺋب...........!ﻻﺣظ ﺗﺳﻠﺳل اﻟﻌﻣﻠﯾﺎت اﻟﻧﺎﺗﺟﺔ ﻋن ھذا اﻟﺗﻌﺑﯾر‬

                                       ‫ﯾﺑدأ ﺗﻧﻔﯾذ اﻟﻌﻣﻠﯾﺎت ﻣن اﻟﯾﺳﺎر إﻟﻰ اﻟﯾﻣﯾن‬


                                          ‫‪Reslt=a * c + d‬‬

                      ‫ﯾﺑدءا ﺑﻣﻘﺎرﻧﺔ ﻛل ﻋﻣﻠﯾﺗﯾن رﯾﺎﺿﯾﺗﯾن ﻣﻌﺎ وأﯾﮭﻣﺎ ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﺗﻧﻔذ اوﻷ‬

                              ‫إذا ﻛﺎن )5=‪ (a=5,c=10,d‬ﻓﯾﻛون ﺗﺳﻠﺳل ﺗﻧﻔﯾذ اﻟﺧطوات‬

 ‫.1‬                                   ‫5+ 01 * 5=‪Reslt‬‬

 ‫ﻋﻧد ﻣﻘﺎرﻧﺔ ﻋﻣﻠﯾﺔ اﻟﺟﻣﻊ واﻟﺿرب ﻓوﺟد اﻧﮫ اﻟﺿرب ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﻣن اﻟﺟﻣﻊ ﻟذاﻟك ﺳﺗﻧﻔذ اﻟﺿرب أوﻻ ﻓﯾﺿرب‬
                                           ‫)05=01*5(‬

 ‫.2‬                                         ‫5 + 05=‪Reslt‬‬

    ‫ﺗﻧﻔذ ﻋﻣﻠﯾﺔ اﻟﺟﻣﻊ ﺑﺷﻛل اﻋﺗﯾﺎدي ﻷﻧﮭﺎ أﺧر ﻋﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ ﻣﺗﺑﻘﯾﺔ ﻗﺑل اﻟﻣﺳﺎواة وﯾﻛون اﻟﻧﺎﺗﺞ ھو )55( وأﺧر‬
                                  ‫ﻋﻣﻠﯾﺔ ﺳﺗﻧﻔذ ھﻲ اﻟﻣﺳﺎواة ﻓﺗﺻﺑﺢ ﻗﯾﻣﺔ‬
                                               ‫(‬   ‫)55=‪Reslt‬‬

                                                                                                  ‫ﻣﮭم‬




   ‫رﯾﺎﺿﯾﺎ ﻟﺣل ھذه اﻟﻣﺷﻛﻠﺔ ﻧﺿﻊ أﻗواس ﺣول اﻟﻌﻣﻠﯾﺎت اﻟﺗﻲ ﻟﮭﺎ أﺳﺑﻘﯾﺔ اﻗل وﻧرﯾدھﺎ أن ﺗﻧﻔذ أوﻻ وھو ﺑﺎﻟﺿﺑط‬
  ‫ﻣﺎ ﻧﻌﻣﻠﮫ ﺑرﻣﺟﯾﺎ أﯾﺿﺎ ﻧﺳﺗﺧدم أﻗواس )ﻻن اﻷﻗواس ﻟﮭﺎ أﺳﺑﻘﯾﺔ اﻋﻠﻰ ﺟﻣﯾﻊ ﺑﺎﻗﻲ اﻟﻌﻣﻠﯾﺎت( ﻟذاﻟك ﺳوف ﯾﻧﻔذ‬
                                         ‫ﻣﺎ ﻓﻲ داﺧﻠﮭﺎ ﺗم ﯾﺗﻌﺎﻣل ﻣﻊ اﻟﺧﺎرج اﻟﻘوس وﺗﻛون اﻟﻧﺗﯾﺟﺔ ﺻﺎﺋﺑﺔ؟‬
                                                                           ‫وﯾﺻﺑﺢ ﺷﻛل اﻟﻣﺛﺎل اﻟﺳﺎﺑق‬
 ‫)‪Reslt=a *( c +d‬‬


   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                          ‫اﻟﻔﺻل اﻷول‬




                                                                                         ‫وﯾﻛﺗب ﺑرﻣﺟﯾﺎ ھﻛذا‬
 ‫;)‪Reslt=a *( c +d‬‬
                                                                           ‫ﻻﺣظ ﺗﺳﻠﺳل اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ أﻻن‬

                                       ‫ﯾﺑدأ ﺗﻧﻔﯾذ اﻟﻌﻣﻠﯾﺎت ﻣن اﻟﯾﺳﺎر إﻟﻰ اﻟﯾﻣﯾن‬


                                     ‫)‪Reslt=a * ( c + d‬‬

                      ‫ﯾﺑدءا ﺑﻣﻘﺎرﻧﺔ ﻛل ﻋﻣﻠﯾﺗﯾن رﯾﺎﺿﯾﺗﯾن ﻣﻌﺎ وأﯾﮭﻣﺎ ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﺗﻧﻔذ اوﻷ‬

                              ‫إذا ﻛﺎن )5=‪ (a=5,c=10,d‬ﻓﯾﻛون ﺗﺳﻠﺳل ﺗﻧﻔﯾذ اﻟﺧطوات‬

 ‫.1‬                                   ‫)5 + 01( * 5=‪Reslt‬‬

  ‫ﻋﻧد ﻣﻘﺎرﻧﺔ ﻋﻣﻠﯾﺔ اﻟﺿرب واﻷﻗواس ﻓوﺟد اﻧﮫ اﻷﻗواس ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﻣن اﻟﺿرب ﻟذاﻟك ﺳﺗﻧﻔذ ﻣﺎﺑﯾن اﻷﻗواس‬
                                       ‫أوﻻ ﻓﯾﺟﻣﻊ )21=2*01(‬

 ‫.2‬                                         ‫51 * 5=‪Reslt‬‬

   ‫ﺗﻧﻔذ ﻋﻣﻠﯾﺔ اﻟﺿرب ﺑﺷﻛل اﻋﺗﯾﺎدي ﻷﻧﮭﺎ أﺧر ﻋﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ ﻣﺗﺑﻘﯾﺔ ﻗﺑل اﻟﻣﺳﺎواة وﯾﻛون اﻟﻧﺎﺗﺞ ھو )57( وأﺧر‬
                                  ‫ﻋﻣﻠﯾﺔ ﺳﺗﻧﻔذ ھﻲ اﻟﻣﺳﺎواة ﻓﺗﺻﺑﺢ ﻗﯾﻣﺔ‬
                                                 ‫57=‪Reslt‬‬
                                                                 ‫ھل ﻻﺣظت ﻛم ھﻧﺎك اﺧﺗﻼف ﺑﯾن اﻟﻧﺗﯾﺟﺗﯾن........؟‬

     ‫ﻣﻼﺣظﺔ:إذا ﻛﺎن ﻣﺎ ﺑﯾن اﻷﻗواس أﻛﺛر ﻣن ﻋﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ اﯾﺿﺎ داﺧل اﻷﻗواس ﺗﻌﻣل اﻷﺳﺑﻘﯾﺎت ﻓﺄﯾﮭﻣﺎ ﻟﮫ اﺳﺑﻘﯾﺔ‬
                                                            ‫أﻋﻠﻰ ﯾﻧﻔذ أوﻻ ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو ﻛﺎن اﻟﻣﺛﺎل‬
                                      ‫)‪Reslt=a* ( c + d/f‬‬
                                                                              ‫ﺗﺳﻠﺳل ﺗﻧﻔﯾذ اﻟﻌﻣﻠﯾﺎت ھﻲ‬
             ‫١.ﯾﻘﺳم )‪ (d/f‬ﻻﻧﺔ اول ﻣﺎﺳﯾﻧﻔد ﻣﺎﺑﯾن اﻻﻗواس وﯾﻘﺎرن ﻗﺳﻣﺔ ﻣﻊ ﺟﻣﻊ ووﺟد ان اﻟﻘﺳﻣﺔ اﻋﻠﻰ اﺳﺑﻘﯾﺔ‬
                                                                         ‫٢.وﯾﺟﻣﻊ ﻧﺎﺗﺞ اﻟﻘﺳﻣﺔ ﻣﻊ )‪(c‬‬
                                                           ‫٣.وﯾﺿرب ﻧﺎﺗﺞ اﻟﺟدﯾد ﻟﻣﺎﺑﯾن اﻻﻗواس ﻣﻊ )‪(a‬‬
                                                                             ‫٤.ﯾﺳﺎوي اﻟﻧﺗﯾﺟﺔ ب ‪reslt‬‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                     ‫اﻟﻔﺻل اﻷول‬

                                                                                                         ‫ﻣﺛﺎل‬




                           ‫وﻧﺣن ﻧرﯾد أن ﻧﻘﺻد ﻓﻲ ﺗﻌﺑﯾرﻧﺎ أن )‪ (5,A‬ﯾﺟﻣﻌون أوﻻ ﺗم ﺗﻘﺳم اﻟﻧﺗﯾﺟﺔ ﻋﻠﻲ ) ‪(d‬‬
 ‫ﻟﻛن اﻟواﻗﻊ ﻏﯾر ﺣﺳب اﻷﺳﺑﻘﯾﺎت أن اﻟﻘﺳﻣﺔ ﻟﮭﺎ أﺳﺑﻘﯾﺔ ﻋﻠﻰ اﻟﺟﻣﻊ ﻟذاﻟك ﺳﺗﻧﻔذ اﻟﻘﺳﻣﺔ اوﻻ إي ﯾﻘﺳم )‪(5/D‬‬
                                            ‫وﺗﺟﻣﻊ اﻟﻧﺗﯾﺟﺔ ﻣﻊ ) ‪ (A‬وﯾﻛون اﻟﻧﺎﺗﺞ ﻏﯾر ﺻﺎﺋب...........!‬
                      ‫ﻻﺣظ ﺗﺳﻠﺳل اﻟﻌﻣﻠﯾﺎت ﺑدون أﻗواس وﺣﺳب اﻟﺗﻌﺑﯾر) ‪( Y= 5+A /D - B/C‬‬
                                            ‫‪y=5+A/d-b/c‬‬

                      ‫ﯾﺑدءا ﺑﻣﻘﺎرﻧﺔ ﻛل ﻋﻣﻠﯾﺗﯾن رﯾﺎﺿﯾﺗﯾن ﻣﻌﺎ وأﯾﮭﻣﺎ ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﺗﻧﻔذ اوﻷ‬

                           ‫إذا ﻛﺎن ) 4=‪ (c=2,A=4,b=4,d‬ﻓﯾﻛون ﺗﺳﻠﺳل ﺗﻧﻔﯾذ اﻟﺧطوات‬

 ‫.1‬                                   ‫2 / 4 – 4 / 4 + 5=‪y‬‬


     ‫ﻋﻧد ﻣﻘﺎرﻧﺔ ﻋﻣﻠﯾﺔ اﻟﺟﻣﻊ واﻟﻘﺳﻣﺔ ﻓوﺟد اﻧﮫ اﻟﻘﺳﻣﺔ ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﻣن اﻟﺟﻣﻊ ﻟذاﻟك ﺳﻧﻘﺳم أوﻻ ﻓﯾﻘﺳم‬
                                             ‫)1=4/4(‬



 ‫.2‬                                   ‫2 / 4 – 1 + 5=‪y‬‬


  ‫ﻋﻧد ﻣﻘﺎرﻧﺔ ﻋﻣﻠﯾﺔ اﻟﺟﻣﻊ ﻣﻊ اﻟطرح وﺟد أن اﻻﺳﺑﻘﯾﺗﺎن ﻣﺗﺳﺎوﯾﺗﺎن ﻟذاﻟك ﺳﻧﻔذ ﻣن اﻟﯾﺳﺎر إﻟﻰ اﻟﯾﻣﯾن وﻣن اﻟﯾﺳﺎر‬
                          ‫أول ﻋﻣﻠﯾﺔ ﺗﻘﻊ ھﻲ اﻟﺟﻣﻊ ﻟذاﻟك ﺳﯾﻧﻔذ اﻟﺟﻣﻊ أوﻻ)6=1+5(‬




 ‫.3‬                                   ‫2 / 4 – 6=‪y‬‬


         ‫ﻋﻧد ﻣﻘﺎرﻧﺔ ﻋﻣﻠﯾﺔ اﻟﻘﺳﻣﺔ ﻣﻊ اﻟطرح وﺟد أن اﻷﺳﺑﻘﯾﺔ اﻟﻘﺳﻣﺔ أﻋﻠﻰ ﻟذاﻟك ﺳﻧﻔذ اﻟﻘﺳﻣﺔ أوﻻ)2=2/4(‬


   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                         ‫اﻟﻔﺻل اﻷول‬




 ‫.4‬                                   ‫2 – 6=‪y‬‬

    ‫ﺗﻧﻔذ ﻋﻣﻠﯾﺔ اﻟطرح ﺑﺷﻛل اﻋﺗﯾﺎدي ﻷﻧﮭﺎ أﺧر ﻋﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ ﻣﺗﺑﻘﯾﺔ ﻗﺑل اﻟﻣﺳﺎواة وﯾﻛون اﻟﻧﺎﺗﺞ ھو )4( وأﺧر‬
                                  ‫ﻋﻣﻠﯾﺔ ﺳﺗﻧﻔذ ھﻲ اﻟﻣﺳﺎواة ﻓﺗﺻﺑﺢ ﻗﯾﻣﺔ‬


                                                      ‫4=‪y‬‬

   ‫رﯾﺎﺿﯾﺎ ﻟﺣل ھذه اﻟﻣﺷﻛﻠﺔ ﻧﺿﻊ أﻗواس ﺣول اﻟﻌﻣﻠﯾﺎت اﻟﺗﻲ ﻟﮭﺎ أﺳﺑﻘﯾﺔ اﻗل وﻧرﯾدھﺎ أن ﺗﻧﻔذ أوﻻ وھو ﺑﺎﻟﺿﺑط‬
   ‫ﻣﺎ ﻧﻌﻣﻠﮫ ﺑرﻣﺟﯾﺎ أﯾﺿﺎ ﻧﺳﺗﺧدم أﻗواس ﺣول ﻋﻣﻠﯾﺔ اﻟﺟﻣﻊ ﻟذاﻟك ﺳوف ﯾﻧﻔذ اﻟﺟﻣﻊ ﺗم ﯾﻘﺳم اﻟﻧﺗﯾﺟﺔ ﻋﻠﻰ)‪(D‬‬
     ‫وﺑﻣﺎ أن اﻟﻧﺎﺗﺞ ﻣطروح ﻣن ﻋﻣﻠﯾﺔ ﻗﺳﻣﺔ ﺳوف ﯾﻧﻔذ اﻟﻘﺳﻣﺔ ‪ B‬ﻋﻠﻰ ‪ C‬وﯾطرح اﻟﻧﺗﯾﺟﺗﯾن وﺗﻛون اﻟﻧﺗﯾﺟﺔ‬
                                                                                             ‫ﺻﺎﺋﺑﺔ؟‬

                                                                                        ‫وﯾﻛﺗب ﺑرﻣﺟﯾﺎ ھﻛذا‬
 ‫; ‪Y= (5+A)/D - B/C‬‬

                                                             ‫ﻻﺣظ ﺗﺳﻠﺳل اﻟﻌﻣﻠﯾﺎت ﺑوﺟود أﻗواس وﺣﺳب اﻟﺗﻌﺑﯾر‬


                                          ‫‪y=(5+A)/d-b/c‬‬

                       ‫ﯾﺑدأ ﺑﻣﻘﺎرﻧﺔ ﻛل ﻋﻣﻠﯾﺗﯾن رﯾﺎﺿﯾﺗﯾن ﻣﻌﺎ وأﯾﮭﻣﺎ ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﺗﻧﻔذ اوﻷ‬

                           ‫إذا ﻛﺎن ) 4=‪ (c=2,A=4,b=4,d‬ﻓﯾﻛون ﺗﺳﻠﺳل ﺗﻧﻔﯾذ اﻟﺧطوات‬

 ‫.1‬                                   ‫2 / 4 – 4 / )4 + 5(=‪y‬‬


   ‫ﻋﻧد ﻣﻘﺎرﻧﺔ اﻷﻗواس واﻟﻘﺳﻣﺔ ﻓوﺟد اﻧﮫ اﻷﻗواس ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﻣن اﻟﺟﻣﻊ ﻟذاﻟك ﺳﯾﻧﻔذ ﻣﺎ ﺑﯾن اﻷﻗواس أوﻻ‬
                                         ‫أوﻻ ﻓﯾﺟﻣﻊ )9=4+5(‬


   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                        ‫اﻟﻔﺻل اﻷول‬




 ‫.2‬                                   ‫2 / 4 – 4/9=‪y‬‬


               ‫ﻋﻧد ﻣﻘﺎرﻧﺔ ﻋﻣﻠﯾﺔ اﻟﻘﺳﻣﺔ ﻣﻊ اﻟطرح وﺟد أن اﻟﻘﺳﻣﺔ أﻋﻠﻰ ﻓﺳﺗﻧﻔذ أوﻻ )52.2=4/9(‬

 ‫.3‬                                   ‫2 / 4 – 52.2=‪y‬‬


         ‫ﻋﻧد ﻣﻘﺎرﻧﺔ ﻋﻣﻠﯾﺔ اﻟﻘﺳﻣﺔ ﻣﻊ اﻟطرح وﺟد أن اﻷﺳﺑﻘﯾﺔ اﻟﻘﺳﻣﺔ أﻋﻠﻰ ﻟذاﻟك ﺳﻧﻔذ اﻟﻘﺳﻣﺔ أوﻻ)2=2/4(‬

 ‫.4‬                                   ‫2 – 52.2=‪y‬‬


                                                         ‫أﻻن ﺗﻧﻔذ ﻋﻣﻠﯾﺔ اﻟطرح ﺑﺷﻛل اﻋﺗﯾﺎدي واﻟﻧﺗﯾﺟﺔ ﺗﺻﺑﺢ‬


                                                      ‫52.0 =‪y‬‬




                                                            ‫أﻻن اﻷﺳﺑﻘﯾﺎت أﺻﺑﺣت واﺿﺣﺔ وﻟﻣﻌﻠوﻣﺎﺗك..؟‬
                                                    ‫١.ﯾﺑدأ ﺗﻧﻔﯾذ اﻟﻌﻣﻠﯾﺎت ﻣن اﻟﯾﺳﺎر إﻟﻰ اﻟﯾﻣﯾن‬       ‫‪‬‬
                                ‫٢.ﯾﻘﺎرن ﻛل ﻋﻣﻠﯾﺗﯾن ﻣﻌﺎ اﻟﻌﻣﻠﯾﺔ اﻟﺗﻲ ﻟﮭﺎ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﺗﻧﻔذ أوﻻ‬         ‫‪‬‬
                                       ‫٣.إذا ﺗﺳﺎوت اﺳﺑﻘﯾﺗﺎن ﯾﺑدأ ﺑﺎﻟﺗﻧﻔﯾذ ﻣن اﻟﯾﺳﺎر إﻟﻰ اﻟﯾﻣﯾن‬       ‫‪‬‬
    ‫١.ﻣﺎ ﺑﯾن اﻷﻗواس ﯾﻧﻔذ أوﻻ ﻷﻧﮫ أﻋﻠﻰ أﺳﺑﻘﯾﺔ ﻣن ﻏﯾره )وﻣﺎ ﻓﻲ داﺧل ﻣﺎ ﺑﯾن اﻷﻗواس إي إذا‬               ‫‪‬‬
            ‫ﻛﺎن أﻛﺛر ﻣن ﻋﻣﻠﯾﺔ ﺑﯾن اﻷﻗواس ﺗﻌﺎﻣل ﺣﺳب اﻷﺳﺑﻘﯾﺔ اﻟذي أﺳﺑﻘﯾﺗﮫ أﻋﻠﻰ ﯾﻧﻔذ أوﻻ(‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                           ‫اﻟﻔﺻل اﻷول‬




      ‫‪ ‬ﻣﻼﺣظﺔ: اﻷﺳﺑﻘﯾﺎت ﺑﺎﻟﻧﺳﺑﺔ ﻟﻸدوات ‪ Bowties‬واﻷدوات اﻟﻣﻧطﻘﯾﺔ ھﻲ ﻧﻔس طرﯾﻘﺔ ﻓﻲ‬
                              ‫اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ أﯾﺿﺎ اﻟذي ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﯾﻧﻔذ أوﻻ‬



                                                                                                      ‫ﻣﺛﺎل‬
           ‫‪True && False || True‬‬
                                                                 ‫ﺟد اﻟﻧﺗﯾﺟﺔ..............................؟‬

                                           ‫‪True && False || True‬‬

           ‫.1‬

             ‫ﻧﻌﻠم اﻧﮫ ‪ and‬ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﻣن ‪ or‬ﻟذاﻟك ﺳﯾﻧﻔذه أوﻻ)‪(True And False=False‬‬

                                                 ‫‪False || True‬‬

           ‫.2‬
                           ‫أﻻن ﻋﻣﻠﯾﺔ ‪ or‬ﺑﺷﻛل اﻋﺗﯾﺎدي )‪( False or True=True‬‬
                                          ‫ﻓﺎﻟﻧﺎﺗﺞ ﯾﻛون )‪(True‬‬

                                                      ‫ﻧﻔس اﻟطرﯾﻘﺔ ﺑﺎﻟﻧﺳﺑﺔ ﻟﺑﺎﻗﻲ اﻷدوات ﺗﻧﻔذ ﺣﺳب اﻷﺳﺑﻘﯾﺔ‬


                                                                         ‫ﺟدول اﻟﺣﻘﯾﻘﺔ )‪(AND,OR,NOT‬‬
                  ‫‪A‬‬           ‫|‬        ‫‪B‬‬               ‫‪AND‬‬               ‫‪OR‬‬            ‫‪ NOT‬ﻓﻘط ل )‪(A‬‬
                ‫‪False‬‬                ‫‪False‬‬             ‫‪False‬‬            ‫‪False‬‬               ‫‪True‬‬
                ‫‪False‬‬                ‫‪True‬‬              ‫‪False‬‬            ‫‪True‬‬                ‫‪True‬‬
                ‫‪True‬‬                 ‫‪False‬‬             ‫‪False‬‬            ‫‪True‬‬                ‫‪False‬‬
                ‫‪True‬‬                 ‫‪True‬‬              ‫‪True‬‬             ‫‪True‬‬                ‫‪False‬‬

                                                                                                             ‫ﻣﮭم‬


                              ‫‪ ‬ﻓﻲ ﻋﻣﻠﯾﺎت اﻟﻣﻘﺎرﻧﺔ إي رﻗم ﻏﯾر اﻟﺻﻔر ﯾﻌﺗﺑره واﺣد ﺳوا ﻛﺎن ﻣوﺟب او ﺳﺎﻟب‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                        ‫اﻟﻔﺻل اﻷول‬



                                                                                          ‫ﻣﮭم ﺟدا‬       ‫ﻣﺛﺎل‬
    ‫)2%4( || )2*4( && )2+3(‬
                                                                   ‫ﺟد اﻟﻧﺗﯾﺟﺔ..............................؟‬

                                         ‫)2%4( || )2*4( && )2+3(‬

    ‫.1‬
         ‫ﺑﻣﺎ اﻧﮫ ﻣوﺟود ﺗﻌﺎﺑﯾر رﯾﺎﺿﯾﺔ وﻋﻣﻠﯾﺎت ﻣﻧطﻘﯾﺔ ﺳﯾﻧﻔذ اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ اﻟﺗﻲ ﺑﯾن اﻷﻗواس أوﻻ‬
         ‫أول ﻋﻣﻠﯾﺔ ﺳﯾﻧﻔذھﺎ ھﻲ اﻟﺿرب ﻻن أﺳﺑﻘﯾﺗﮭﺎ أﻋﻠﻰ ﻣن اﻟﺟﻣﻊ وﺑﺎﻗﻲ اﻟﻘﺳﻣﺔ ھﻲ )2*4( وﺗﺳﺎوي‬
                                                  ‫ﺛﻣﺎﻧﯾﺔ‬

                                           ‫)2%4( || 8 && )2+3(‬

    ‫.2‬
                 ‫ﺳﯾﻧﻔذ ﺑﺎﻗﻲ اﻟﻘﺳﻣﺔ ﻷن أﺳﺑﻘﯾﺗﮫ أﻋﻠﻰ ﻣن اﻟﺟﻣﻊ وﺑﺎﻗﻲ ﻗﺳﻣﺔ)2%4( ھو ﺻﻔر‬

                                              ‫0 || 8 && )2+3(‬

    ‫.3‬
                                    ‫ﺳﯾﻧﻔذ ﻋﻣﻠﯾﺔ اﻟﺟﻣﻊ )3+2( ﯾﺳﺎوي ﺧﻣﺳﺔ‬

                                                 ‫0 || 8 && 5‬                                      ‫ﻣﮭم‬


    ‫.4‬
         ‫اﻵن ﯾﻘﺎرن ﻋﻣﻠﯾﺔ )‪ (and‬وﻋﻣﻠﯾﺔ )‪ (or‬ﻧﻌﻠم اﻧﮫ ‪ and‬ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﻣن ‪ or‬ﻟذاﻟك ﺳﯾﻧﻔذه أوﻻ‬
         ‫ﻓﻲ ﻋﻣﻠﯾﺎت اﻟﻣﻘﺎرﻧﺔ إي رﻗم ﻏﯾر اﻟﺻﻔر ﯾﻌﺗﺑره واﺣد ﺳوا ﻛﺎن ﻣوﺟب أو ﺳﺎﻟب إذن ﺗﻛون اﻟﻣﻘﺎرﻧﺔ‬
                                               ‫ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬
                                                ‫)8 && 5(‬
                                              ‫)1=1 && 1(‬
                                             ‫اﻟﻧﺗﯾﺟﺔ ھﻲ واﺣد‬

                                                      ‫0 || 1‬


    ‫.5‬
                       ‫أﺧر ﻋﻣﻠﯾﺔ ﻣﻘﺎرﻧﺔ ھﻲ )‪ (or‬ﺑﯾن اﻟواﺣد واﻟﺻﻔر واﻟﻧﺗﯾﺟﺔ ھﻲ واﺣد‬
                                               ‫1=)0||1(‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                     ‫اﻟﻔﺻل اﻷول‬




                                                                         ‫ﻣﺎ اﻟﻔرق ﺑﯾن && و & أو || و |‬
              ‫اﻟﻔرق ﯾﻘﻊ ﺑﯾن && و & : اﻧﮫ )&&( ﯾﻣﺛل ﻋﻣﻠﯾﺔ ﻣﻧطﻘﯾﺔ ﺑﯾن ﻣوﻗﻌﯾن ﻓﻲ اﻟذاﻛرة إذا ﺻﺢ اﻟﺗﻌﺑﯾر أو‬
          ‫ﻣﺗﻐﯾرﯾن ﺑﺷﻛل ﻛﺎﻣل وﻟﯾس ﺑﺷﻛل ﺟزﺋﻲ أو ﺗﻌﺑﯾرﯾن ﻧﺗﺎﺋﺟﮭﻣﺎ )‪ True‬أو ‪ (False‬وﺗﻛون ﻧﺗﺎﺋﺞ إي ﻋﻣﻠﯾﺔ‬
           ‫ﻓﯾﮭﺎ )&& أو ||( إﻣﺎ ‪ True‬أو ‪ . False‬أي ان اﻟﻣﻘﺎرﻧﺔ ﺗﻛون ﺑﯾن )‪ True‬أو ‪ (False‬ﺑطرﻓﻲ )&&(.‬
                                                                                                    ‫ﻣﺛﻼ:‬
        ‫;5=‪Int a‬‬
        ‫;7=‪Int b‬‬
        ‫)0>‪(A >0) &&(b‬‬
        ‫‪(True) && (True) True‬‬
           ‫ﯾﻛون اﻟﻧﺎﺗﺞ ھوا ‪ True‬ﻻن اﻟﻣﺗﻐﯾران ﻛﻼھﻣﺎ أﻋﻠﻰ ﻣن ﺻﻔر .اي ﻋﻧدﻣﺎ ﻗﺎرن )0>‪ (A‬ﻛﺎﻧت اﻟﻧﺗﯾﺟﺔ ﻧﻌم‬
             ‫اﻛﺑر ﻣن اﻟﺻﻔر إي)‪ (True‬وﻋﻧدﻣﺎ ﻗﺎرن )0>‪ (b‬ﻛﺎﻧت اﻟﻧﺗﯾﺟﺔ أﯾﺿﺎ )‪ (True‬وﻋﻧدﻣﺎ ﻋﻣل )‪ (and‬ﺑﯾن‬
                                                                     ‫اﻟﻧﺗﯾﺟﺗﯾن ﻛﺎﻧت اﻟﻧﺗﯾﺟﺔ )‪ (True‬إي واﺣد‬
                          ‫‪ * ‬ﻓﻠو ﻛﺗﺑﻧﺎ اﻟﻛود اﻟﺗﺎﻟﻲ )‪ (a && b‬ﻓﺳﯾﻘﺎرن )1= 1 && 1( ﺗﻛون اﻟﻧﺗﯾﺟﺔ واﺣد‬

          ‫إﻣﺎ )&( ﻓﯾﻣﺛل ﻋﻣﻠﯾﺔ ﻣﻧطﻘﯾﺔ ﺑﯾن ﻛل ﺑت ﻣﻊ اﻟﺑت اﻟذي ﯾﻘﺎﺑﻠﮫ ﻓﻲ اﻟﻣﺗﻐﯾر اﻟﻣﻘﺎﺑل وﻟﯾس ﻣﻊ اﻟﻣﺗﻐﯾر ﻛﺎﻣﻼ‬
                                               ‫ﻟذاﻟك ﺗﺳﻣﻰ ‪. Bowties‬وﻧﺎﺗﺞ اﻟﻌﻣﻠﯾﺔ ﻣﻣﻛن أن ﯾﻛون إي رﻗم‬
                                                                                           ‫ﻟﻧﻌد ﻧﻔس اﻟﻣﺛﺎل:-‬
        ‫;5=‪Int a‬‬
        ‫;7=‪Int b‬‬
        ‫)‪(A & b‬‬
                       ‫ﻣﺎذا ﺳﯾﺣﺻل؟ ﺳوف ﯾﺣول )٥ و ٧( إﻟﻰ ﻣﺎ ﯾﻘﺎﺑﻠﮭﻣﺎ ب ‪ Binary‬ﺛم ﯾﻌﻣل ﺑﯾﻧﮭم ﻋﻣﻠﯾﺔ ‪and‬‬
        ‫7 ‪0111 ‬‬
        ‫5 ‪0101 ‬‬
        ‫5‪0101 ‬‬
                 ‫ﻧﻼﺣظ أن ﻧﺎﺗﺞ ھذه اﻟﻌﻣﻠﯾﺔ ھوا ) 5 ( وﻟﯾس )‪ True‬أو ‪ (False‬إي ﻣﻣﻛن أن ﯾﻛون اﻟﻧﺎﺗﺞ إي رﻗم‬
                                                                                  ‫وﻛذاﻟك ﺑﺎﻟﻧﺳﺑﺔ ل )|| و |(‬



 ‫٩.١- إﺿﺎﻓﺔ ﺗﻌﻠﯾﻘﺎت: اﻟﺗﻌﻠﯾﻘﺎت ﻣﮭﻣﺔ ﺟدا ﺑﺟﺎﻧب اﻷﺳطر اﻟﺑرﻣﺟﯾﺔ ﺣﺗﻰ ﻓﻲ ﻣﺎ ﺑﻌد إذا أردﻧﺎ ﻓﮭم اﻟﺑرﻧﺎﻣﺞ‬
                                 ‫اﻟذي ﻛﺗﺑﻧﺎه ﻓﻲ وﻗت ﻣﺿﻰ ﻣﺟرد ﻧﻘرء اﻟﺗﻌﻠﯾﻘﺎت ﺑﺟﺎﻧب اﻷﺳطر ﻧﻔﮭم ﻣﺎ ﯾﻌﻧﻲ اﻟﻛود‬
                                                          ‫/ * ﺗﻌﻠﯾق * /‬          ‫ﻓﻲ ﻟﻐﺔ )‪ ( C‬ﻧﺿﻊ اﻟﺗﻌﻠﯾق ﺑﯾن‬
                                                             ‫ﺗﻌﻠﯾق //‬        ‫وﻓﻲ ﻟﻐﺔ )++‪ (C‬ﻧﺿﻊ اﻟﺗﻌﻠﯾق ﺑﻌد‬

           ‫++‪C‬‬                                                                           ‫ﻟﻛود ﺑﻠﻐﺔ‬
           ‫‪#include<iostream.h> // declaration of Lab we will use it‬‬


             ‫‪C‬‬                                                                             ‫ﻟﻛود ﺑﻠﻐﺔ‬
           ‫/*‪#include<stdio.h> /* declaration of Lab we will use it‬‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                          ‫اﻟﻔﺻل اﻷول‬



         ‫ﻣﮭم ﺟدا‬                                               ‫ﻋﻠﻰ اﻟﻔرق ﺑﯾن && و & أو || و |‬             ‫ﻣﺛﺎل‬
    ‫)2<4( || )2&4( && )2|3(‬
                                                                     ‫ﺟد اﻟﻧﺗﯾﺟﺔ..............................؟‬

                                          ‫)2<4( || )2&4( && )2|3(‬

    ‫.1‬
                ‫ﺑﻣﺎ اﻧﮫ ﻣوﺟود ﺗﻌﺎﺑﯾر وﻋﻣﻠﯾﺎت ﻣﻧطﻘﯾﺔ ﺳﯾﻧﻔذ اﻟﻌﻣﻠﯾﺎت اﻟﺗﻲ ﺑﯾن اﻷﻗواس أوﻻ‬
             ‫أول ﻋﻣﻠﯾﺔ ﺳﯾﻧﻔذھﺎ ھﻲ )&( )2&4( ﯾﺣوﻟﮭﺎ اﻟﻰ اﻟﺑﺎﯾﻧري وﯾﻌﻣل ﺑﯾن اﻟﺑﺗﺎت )‪(and‬‬
                                      ‫)0000(=)0100(&)0010(‬
                                             ‫اﻟﻧﺗﯾﺟﺔ ھﻲ ﺻﻔر‬

                                            ‫)2<4( || 0 && )2|3(‬

    ‫.2‬
              ‫ﺳﯾﻧﻔذ ﻋﻣﻠﯾﺔ اﻷﺻﻐر وان اﻻﺛﻧﺎن ﻟﯾس اﺻﻐر ﻣن أرﺑﻌﺔ ﻓﺗﻛون اﻟﻧﺗﯾﺟﺔ ‪ False‬اي ﺻﻔر‬

                                              ‫0 || 0 && )2|3(‬

    ‫.3‬
                 ‫ﺳﯾﻧﻔذ ﻋﻣﻠﯾﺔ ‪ or‬ﺑﯾن ﺛﻼﺛﺔ واﺛﻧﺎن ﯾﺣوﻟﮭﺎ إﻟﻰ اﻟﺑﺎﯾﻧري وﯾﻌﻣل ﺑﯾن اﻟﺑﺗﺎت ‪or‬‬
                                       ‫)1100(=)0100(|)1100(‬
                                              ‫اﻟﻧﺗﯾﺟﺔ ھﻲ ﺛﻼﺛﺔ‬

                                                 ‫0 || 0 && 3‬                                        ‫ﻣﮭم‬


    ‫.4‬
         ‫اﻵن ﯾﻘﺎرن ﻋﻣﻠﯾﺔ )‪ (and‬وﻋﻣﻠﯾﺔ )‪ (or‬ﻧﻌﻠم اﻧﮫ ‪ and‬ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﻣن ‪ or‬ﻟذاﻟك ﺳﯾﻧﻔذه أوﻻ‬
         ‫ﻓﻲ ﻋﻣﻠﯾﺎت اﻟﻣﻘﺎرﻧﺔ إي رﻗم ﻏﯾر اﻟﺻﻔر ﯾﻌﺗﺑره واﺣد ﺳوا ﻛﺎن ﻣوﺟب أو ﺳﺎﻟب إذن ﺗﻛون اﻟﻣﻘﺎرﻧﺔ‬
                                               ‫ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬
                                                ‫)0 && 1(‬
                                              ‫)0=0 && 1(‬
                                             ‫اﻟﻧﺗﯾﺟﺔ ھﻲ واﺣد‬

                                                      ‫0 || 0‬


    ‫.5‬
                       ‫أﺧر ﻋﻣﻠﯾﺔ ﻣﻘﺎرﻧﺔ ھﻲ )‪ (or‬ﺑﯾن اﻟﺻﻔر واﻟﺻﻔر واﻟﻧﺗﯾﺟﺔ ھﻲ ﺻﻔر‬
                                              ‫0=)0||0(‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                        ‫اﻟﻔﺻل اﻷول‬




  ‫٠١.١- ﻣؤﺛرات اﻟزﯾﺎدة واﻟﻧﻘﺻﺎن:ھﻲ ﻣﺗﻐﯾرات ﺗﻌرف داﺧل اﻟﺑرﻧﺎﻣﺞ ﺑﻘﯾﻣﺔ ﻣﻌﯾﻧﺔ ﺗم ﺗﺗﻐﯾر‬
  ‫ﻗﯾﻣﺗﮭﺎ أﺛﻧﺎء ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ ﻛﺄن ﻧﺟﻌﻠﮭﺎ ﺗزداد ﺑﻣﻘدار واﺣد او اي إي ﻣﻘدار ﻣﻌﯾن وھﻲ ﻋﻠﻰ ﻧوﻋﯾﯾن..؟‬
                                ‫ﻣؤﺛرات اﻟزﯾﺎدة:ھﻲ ﻣﺗﻐﯾرات ﻣن اﺳﻣﮭﺎ ﺗزداد ﺑﻣﻘدار ﻣﻌﯾﯾن وﺷﻛﻠﮭﺎ‬

                                                                                                   ‫ﺗوﺿﯾﺢ‬
     ‫;1+‪a =a‬‬
         ‫ﻣﻌﻧﺎه اﻟﻣﺗﻐﯾر ) ‪ (a‬ازداد ﺑﻣﻘدار واﺣد )إي ﺟﻣﻊ ﻗﯾﻣﺗﮫ اﻟﺳﺎﺑﻘﺔ ﻣﻊ )١ ( اي ﻟو ﻛﺎن ﻗﯾﻣﺗﮫ ﻣﺛﻼ ٢‬
                                                                                           ‫ﯾﺻﺑﺢ ٣ (‬
           ‫-------------------------------------ﻣﺛﺎل ﺗوﺿﯾﺣﻲ----------------------------------‬
     ‫0=‪Int a‬‬
     ‫ﻋرﻓﻧﺎ اﻟﻣﺗﻐﯾر وأﻋطﯾﻧﺎ ﻗﯾﻣﺗﮫ 0=‪a‬‬
     ‫;1+‪a =a‬‬
     ‫ﺟﻣﻌت ﻗﯾﻣﺗﮫ اﻟﺳﺎﺑﻘﺔ وھﻲ ﺻﻔر ﻣﻊ اﻟواﺣد وأﺻﺑﺣت ﻗﯾﻣﺗﮫ 1=‪a‬‬
     ‫;1+‪a =a‬‬
     ‫ﺟﻣﻌت ﻗﯾﻣﺗﮫ اﻟﺳﺎﺑﻘﺔ وھﻲ واﺣد ﻣﻊ اﻟواﺣد و أﺻﺑﺣت ﻗﯾﻣﺗﮫ 2=‪a‬‬
     ‫;5+‪a=a‬‬
     ‫ﺟﻣﻌت ﻗﯾﻣﺗﮫ اﻟﺳﺎﺑﻘﺔ وھﻲ اﺛﻧﺎن ﻣﻊ ﺧﻣﺳﺔ و أﺻﺑﺣت ﻗﯾﻣﺗﮫ 7=‪a‬‬
             ‫--------------------------------------------------------------------------------‬
          ‫ﻻﺣظت ﻛﯾف ﺗﻐﯾرت ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ a‬ﻣن اﻟﺻﻔر إﻟﻰ اﻟواﺣد ﺛم إﻟﻰ اﻻﺛﻧﺎن ﺑﻣﺟرد ﻛﺗﺎﺑﮫ ھذا اﻟﺗﻌﺑﯾر‬
                                                          ‫ھﻧﺎك طرﯾﻘﺔ أﺧرى ﻟﺗﻣﺛﯾل ﻣؤﺛرات اﻟزﯾﺎدة وھﻲ‬

     ‫ﺑدﻻ أن ﻧﻛﺗب );1+‪(a=a‬‬                     ‫ﻧﻛﺗب ++‪a‬‬
                                               ‫أو 1=+‪a‬‬
                                                  ‫‪++ a‬‬
                                           ‫وﺗدل اﻟرﻣوز اﻟﺳﺎﺑﻘﺔ اي أن اﻟﻣﺗﻐﯾر ‪ a‬ﻗد ازداد ﺑﻣﻘدار واﺣد.‬
                 ‫ﻟو أردﻧﺎ أن ﯾزداد اﻟﻣﺗﻐﯾر ﻗﯾﻣﺔ ﻏﯾر اﻟواﺣد ﻗد ﯾﻛون ٥ أو إي رﻗم أﺧر ﻓﻧﻛﺗب اﻟﺷﻛل اﻟﺗﺎﻟﻲ‬

     ‫ﺑدﻻ أن ﻧﻛﺗب );5+‪(a=a‬‬                         ‫ﻧﻛﺗب 5=+‪a‬‬

          ‫------------------------- ﯾﺻﺑﺢ اﻟﻣﺛﺎل ﺗوﺿﯾﺣﻲ ﺑﺎﻟرﻣوز اﻟﺑرﻣﺟﯾﺔ----------------------‬
     ‫0=‪Int a‬‬
     ‫ﻋرﻓﻧﺎ اﻟﻣﺗﻐﯾر وأﻋطﯾﻧﺎ ﻗﯾﻣﺗﮫ 0=‪a‬‬
     ‫;++ ‪a‬‬
     ‫أﺻﺑﺣت ﻗﯾﻣﺗﮫ 1=‪a‬‬
     ‫;1=+ ‪a‬‬
     ‫أﺻﺑﺣت ﻗﯾﻣﺗﮫ 2=‪a‬‬
     ‫;5 =+‪a‬‬
     ‫أﺻﺑﺣت ﻗﯾﻣﺗﮫ 7=‪a‬‬
             ‫--------------------------------------------------------------------------------‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                          ‫اﻟﻔﺻل اﻷول‬

                                                                                                               ‫ﻣﮭم‬


                                                                           ‫ﻣﺎ اﻟﻔرق ﺑﯾن )‪.. (a++ ,++a‬؟‬
     ‫اﻻﺧﺗﻼف ھوا اﻧﮫ )++‪ (a‬ﻣﻌﻧﺎه ﻧﻔذ اﻟﺧطوة اﻟﺣﺎﻟﯾﺔ ﻋﻠﻰ ﻗﯾﻣﺗك اﻟﺳﺎﺑﻘﺔ ﺗم ﻏﯾر ﻗﯾﻣﺗك ﺑﻌد أن‬
    ‫ﺗﻧﻔذ اﻟﺧطوة اﻟﺣﺎﻟﯾﺔ )ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻗد ﺗﻛون ﻗﯾﻣﺔ اﻟزﯾﺎدة ھﻲ واﺣد وﻗﯾﻣﺗﮫ ﻓﻲ اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ‬
    ‫)٢( ﯾﻧﻔذ اﻟﺧطوة اﻟﺗﻲ ھوا ﺑﮭﺎ ﻋﻠﻰ اﻧﮫ )٢( وﻋﻧدﻣﺎ ﯾﻧﺗﻘل إﻟﻰ اﻟﺧطوة أﻻﺣﻘﺔ ﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ )٣( .‬


           ‫اﻟﻣﺗﻐﯾر ﺑﻘﯾﻣﺔ ٢ ﻗﺑل اﻟزﯾﺎدة ;2=‪1.a‬‬
           ‫ﯾﺑﻘﻰ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻓﻲ ھذه اﻟﺧطوة ٢ وﯾﺻﺑﺢ ﺛﻼﺛﺔ ﻋﻠﻰ اﻟﺧطوة اﻟﻘﺎدﻣﺔ ;++‪2.a‬‬
           ‫أﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﺛﻼﺛﺔ .3‬

    ‫‪ ‬ﻛﺄﻧﻧﺎ ﻧﻘول أن إﺷﺎرﺗﻲ اﻟﺟﻣﻊ ﺑﻌد اﻟﻣﺗﻐﯾر ﻣﺛﻼ )++‪ (a‬ﻻ ﺗؤﺛر ﺑزﯾﺎدﺗﮭﺎ ﻋﻠﻰ اﻟﺧطوة اﻟﻣوﺟود‬
                         ‫ﺑﮭﺎ )ﻛﻣﺎ ﻓﻲ ھذه اﻟﻣﺛﺎل ﺧطوة رﻗم ٢( أﻧﻣﺎ ﺗؤﺛر ﻋﻠﻰ اﻟﺧطوة أﻻﺣﻘﺔ‬
           ‫إﻣﺎ )‪ (++a‬ﻣﻌﻧﺎه ﻏﯾر ﻗﯾﻣﺗك اﻟﺳﺎﺑﻘﺔ أوﻻ ﺗم ﻧﻔذ اﻟﺧطوة اﻟﺗﻲ أﻧت ﺑﮭﺎ ﻟذاﻟك ﻧراه ﻓﻲ ﺟدول‬
                             ‫اﻷﺳﺑﻘﯾﺎت ﻣﻘدم ﻋﻠﻰ ﺑﺎﻗﻲ اﻟﻌﻣﻠﯾﺎت ﻓﻲ أﺳﺑﻘﯾﺗﮫ .ﻟو أﻋدﻧﺎ اﻟﻣﺛﺎل اﻟﺳﺎﺑق‬


           ‫اﻟﻣﺗﻐﯾر ﺑﻘﯾﻣﺔ ٢ ﻗﺑل اﻟزﯾﺎدة ;2=‪1.a‬‬
           ‫ﯾﺻﺑﺢ ﻗﯾﻣﺗﮫ ﺛﻼﺛﺔ ﻓﻲ ھذه اﻟﺧطوة ;‪2.++a‬‬


                    ‫ﻣﺛﺎل:ﯾﺑﯾن ﻛﯾﻔﯾﺔ ﺗﺄﺛر ﺑﻣﻘدار اﻟﺗﻐﯾر ﻓﻲ اﻟﺧطوة اﻟﻣوﺟود ﻓﯾﮭﺎ واﻟﺧطوة اﻟﺗﻲ ﺗﻠﯾﮭﺎ .؟‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪1.#include<iostream.h‬‬                                     ‫>‪1.#include<stdio.h‬‬
 ‫)(‪2.main‬‬                                                   ‫)(‪2.main‬‬
 ‫{.3‬                                                        ‫{.3‬
 ‫;2=‪4.int a‬‬                                                 ‫;2=‪4.int a‬‬
 ‫;‪5.int item‬‬                                                ‫;‪5.int item‬‬
 ‫;++‪6.item=3+a‬‬                                              ‫;++‪6.item=3+a‬‬
 ‫; ‪7.cout<<"FirstTry="<< item‬‬                               ‫;)‪7.prin ("FirstTry=%d", item‬‬
 ‫;‪8.item=3+ a‬‬                                               ‫‪8.item=3+ a‬‬
 ‫; ‪9.cout<<"\nSecondTry="<< item‬‬                            ‫; )‪9.prin ("\nSecondTry=%d", item‬‬
 ‫}.01‬                                                       ‫}.01‬

                                                                                                  ‫ﺗوﺿﯾﺢ....؟‬
  ‫١.ﻓﻲ اﻟﺳطر اﻟرﺑﻊ ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (a‬وأﻋطﯾﻧﺎه ﻗﯾﻣﺔ ﺑداﺋﯾﺔ وھﻲ ٢ وﻓﻲ اﻟﺳطر اﻟﺧﺎﻣس ﻋرﻓﻧﺎ ﻣﺗﻐﯾر‬
                                                                   ‫‪ item‬وﻟم ﻧﻌطﮫ إي ﻗﯾﻣﺔ‬


   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                             ‫اﻟﻔﺻل اﻷول‬




 ‫٢.ﻓﻲ اﻟﺳطر اﻟﺳﺎدس ﺣدﺛت ﻋﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ ﺟﻣﻌت ﺑﯾن )٣( وﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪( a‬ﻣﺗﺄﺛرا ﺑزﯾﺎدة ﻟﻛن ﻛﻣﺎ‬
‫ﺑﯾﻧﺎ ﺳﺎﺑﻘﺎ أن ھذه اﻟزﯾﺎدة اﻟﺟدﯾدة ﻻ ﺗؤﺛر ﻋﻠﻰ ﻧﺗﺎﺋﺞ اﻟﺧطوة اﻟﻣوﺟود ﻓﯾﮭﺎ إﻧﻣﺎ ﺗؤﺛر ﻋﻠﻰ ﻧﺗﺎﺋﺞ اﻟﺧطوة‬
‫اﻟﺗﻲ ﺗﻠﯾﮫ . ﻟذاﻟك ﯾﺑﻘﻰ اﻟﻣﺗﻐﯾر ) ‪ (a‬ﻣﺣﺗﻔظﺎ ﺑﻘﯾﻣﺗﮫ ﻓﻲ ھذه اﻟﺧطوة اﻟﺳﺎدﺳﺔ ﻋﻠﻰ ﻗﯾﻣﺗﮫ اﻟﺑداﺋﯾﺔ)أو ﻣﻘدار‬
                   ‫ﻗﯾﻣﺗﮫ ﻗﺑل اﻟﺧطوة اﻟﺳﺎدﺳﺔ وھﻲ ٢ (ﻟذاﻟك ﻧﺎﺗﺞ ﺟﻣﻊ )٢+٣( ھو ﺧﻣﺳﺔ وھو ﻣﺎ ظﮭر‬
                                                                                 ‫ﺗﻣﺛﯾل رﯾﺎﺿﻲ‬
           ‫;++‪6.item=3+ a‬‬
           ‫2+3=‪Item‬‬
           ‫5=‪Item‬‬

                 ‫‪ ‬وأﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر) 3=‪ (a‬ﺑﻌد أن ﻧﻔذ اﻟﺧطوة رﻗم )٦( ﻷﻧﮫ ازداد ﺑﻣﻘدار واﺣد‬

                                                                       ‫ﻟو ﻛﺎﻧت اﻟﺧطوة اﻟﺳﺎدﺳﺔ ھﻲ‬
                                                                                       ‫اﻟﻛود‬
           ‫;‪6.item=3+ ++a‬‬


    ‫‪ ‬ﻟﻛﺎن اﻟﻣﺗﻐﯾر )‪ (a‬ﺗﻐﯾرت ﻗﯾﻣﺗﮫ إﻟﻰ ٣ ﻗﺑل ﺗﻧﻔﯾذ اﻟﺧطوة رﻗم )٦( ﻣؤﺛرا ﺑﻘﯾﻣﺗﮫ اﻟﺟدﯾدة ﻋﻠﻰ‬
                  ‫اﻟﺧطوة اﻟﺗﻲ ھو ﺑﮭﺎ وﺗﺻﺑﺢ اﻟﻧﺗﯾﺟﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ (٣+٣) item‬وھﻲ ٦‬
 ‫‪ ‬ﻟو ﻧﻼﺣظ ﻓﻲ ﻛﻼ اﻟﺣﺎﻟﺗﯾن أﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )3=‪ (a‬ﻟﻛن اﺧﺗﻠﻔﺎ ﻓﻲ ﺗﺄﺛﯾرھﻣﺎ ﻓﻲ اﻟﺗﻲ ھﻣﺎ ﺑﮭﺎ‬
               ‫ﻣﮭم‬          ‫٣.اﻟﺳطر اﻟﺳﺎﺑﻊ طﺑﻌﻧﺎ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ item‬وھﻲ ﻛﻣﺎ ﺗظﮭر ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ٥‬

 ‫٤.اﻟﺳطر اﻟﺛﺎﻣن ﻗﻣﻧﺎ ﺑﻌﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ ﺟدﯾدة ﺟﻣﻌت ﺑﯾن ٣ وﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ a‬ﺑدون إي ﺗﻐﯾر ﻓﻲ ﻣﻘدار‬
‫ﻗﯾﻣﺔ ھذه اﻟﻣﺗﻐﯾر ﻟﻛن رﻏم ذاﻟك ﻛﺎﻧت اﻟﻧﺗﯾﺟﺔ ٦ وذاﻟك ﻻن اﻟﻣﺗﻐﯾر ‪ a‬ﺗﻐﯾرت ﻗﯾﻣﺗﮫ ﻓﻲ اﻟﺳطر اﻟﺳﺎدس‬
       ‫إﻟﻰ ﺛﻼﺛﺔ ﻟﻛﻧﮫ ﺑﻘﺎ ﻣﺣﺗﻔظﺎ ﺑﻘﯾﻣﺗﮫ ﻟم ﯾؤﺛر ﻓﻲ اﻟﺧطوة اﻟﺗﻲ ھو ﺑﮭﺎ إﻧﻣﺎ اﺛر ﻓﻲ اﻟﺧطوة اﻟﺗﻲ ﺗﻠﯾﮫ‬
                                                                     ‫ﻓﺄﺻﺑﺣت اﻟﻧﺗﯾﺟﺔ ٦ وﻟﯾس ٥‬

                                                                                 ‫ﺗﻣﺛﯾل رﯾﺎﺿﻲ‬
           ‫‪8.item=3+ a‬‬
            ‫3+3=‪Item‬‬
           ‫6=‪Item‬‬



                                                                                ‫ﻧﺎﺗﺞ ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                           ‫اﻟﻔﺻل اﻷول‬

              ‫ﻣﺛﺎل ﺗﺗﺑﻌﻲ ﯾﺑﯾن أﻧواع ﺗﻐﯾر ﻣﻘدار ﻗﯾم اﻟﻣﺗﻐﯾرات ﺑﻌﻣﻠﯾﺎت اﻟزﯾﺎدة واﻟﻧﻘﺻﺎن )ﻣﮭم ﺟدا(‬
   ‫)(‪main‬‬
   ‫{‬
  ‫;2=‪1. int a‬‬
  ‫;0=‪2.int b‬‬
   ‫;0=‪3.int item‬‬
  ‫ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)0=‪(a=2,b=0,item‬‬
  ‫;++‪4. item=1+a‬‬
     ‫//ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)3=‪ (a=3,b=0,item‬وذاﻟك ﻻن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ a‬ﺗﺑﻘﻰ ﺛﺎﺑﺗﺔ ﻓﻲ‬
                                        ‫اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ﻋﻠﻰ ﻗﯾﻣﮭﺎ ﻓﻲ )اﻟﺧطوة ١( وﺗﺗﻐﯾر ﺑﻌد )اﻟﺧطوة ٤( إﻟﻰ ٣‬
  ‫;‪5.++a‬‬
              ‫//ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)3=‪ (a=4,b=0,item‬ﻻن ﺟﻣﯾﻊ اﻟﻣﺗﻐﯾرات ﻻ ﺗﺗﺋﺛر ﻓﻲ‬
                ‫)اﻟﺧطوة٥( ﻓﻘط اﻟﻣﺗﻐﯾر ‪ a‬ﯾﺗﺄﺛر ﻟﯾﺻﺑﺢ ٤)اﻟﻣﺗﻐﯾرات اﻟﺗﻲ ﻻ ﺗﺗﺄﺛر ﺑﺎﻟﺧطوة ﺗﺑﻘﻰ ﻣﺣﺗﻔظﺔ ﺑﻘﯾﻣﮭﺎ اﻟﺳﺎﺑﻘﺔ(‬
  ‫‪6.Item=item + ++b‬‬
          ‫//ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)4=‪ (a=4,b=1,item‬ﻻن اﻟﻣﺗﻐﯾر ‪ b‬ﯾﺗﻐﯾر ال ١ ﻣؤﺛرا ﻓﻲ‬
                           ‫اﻟﺧطوة اﻟﺗﻲ ھو ﻓﯾﮭﺎ وﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ item‬ﺗﺟﻣﻊ ﻣﻊ ﻗﯾﻣﺗﮭﺎ اﻟﺳﺎﺑﻘﺔ ﻣﻊ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪b‬‬
  ‫;++‪7.a‬‬
              ‫//ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)4=‪ (a=5,b=1,item‬ﻻن ﺟﻣﯾﻊ اﻟﻣﺗﻐﯾرات ﻻ ﺗﺗﺄﺛر ﻓﻲ‬
    ‫)اﻟﺧطوة٧( ﻓﻘط اﻟﻣﺗﻐﯾر ‪ a‬ﯾﺗﺄﺛر ﺑﺗﻐﯾر ﻣﻘداره واﺣد ﻟﯾﺻﺑﺢ ٥)اﻟﻣﺗﻐﯾرات اﻟﺗﻲ ﻻ ﺗﺗﺄﺛر ﺑﺎﻟﺧطوة ﺗﺑﻘﻰ ﻣﺣﺗﻔظﺔ ﺑﻘﯾﻣﮭﺎ‬
                                                                                                         ‫اﻟﺳﺎﺑﻘﺔ(‬
  ‫;‪8.++b‬‬
               ‫//ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)4=‪ (a=5,b=2,item‬ﻻن ﺟﻣﯾﻊ اﻟﻣﺗﻐﯾرات ﻻ ﺗﺗﺄﺛر ﻓﻲ‬
                                                                                                      ‫)اﻟﺧطوة٨(‬
        ‫ﻓﻘط اﻟﻣﺗﻐﯾر ‪ b‬ﯾﺗﺄﺛر ﺑﺗﻐﯾر ﻣﻘداره واﺣد ﻟﯾﺻﺑﺢ 2 )اﻟﻣﺗﻐﯾرات اﻟﺗﻲ ﻻ ﺗﺗﺄﺛر ﺑﺎﻟﺧطوة ﺗﺑﻘﻰ ﻣﺣﺗﻔظﺔ ﺑﻘﯾﻣﮭﺎ اﻟﺳﺎﺑﻘﺔ(‬
  ‫;++‪9.item=item + a++ - b‬‬
    ‫//ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)7=‪ (a=6,b=3,item‬اﻟﻣﺗﻐﯾران )‪ (a,b‬ﯾﺗﻐﯾران وﯾزدادان ﺑﻣﻘدار‬
     ‫واﺣد ﻟﻛن ﻻ ﯾؤﺛران ﻋﻠﻰ اﻟﺧطوة اﻟﺗﻲ ھﻣﺎ ﺑﮭﺎ واﻟﻣﺗﻐﯾر ‪ item‬ﯾﺟﻣﻊ ﻗﯾﻣﺗﮫ ‪ a‬اﻟﺳﺎﺑﻘﺔ وﯾطرح ﻣن ‪ b‬اﻟﺳﺎﺑﻘﺔ‬
  ‫;‪10.item=item + a++ - ++b‬‬
   ‫//ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)9=‪(a=7,b=4,item‬اﻟﻣﺗﻐﯾر ‪b‬ﯾزادا وﯾؤﺛر ﻓﻲ اﻟﺧطوة اﻟﺗﻲ ھوا‬
   ‫ﺑﮭﺎ إﻣﺎ ‪ a‬ﯾزداد ﻟﻛن ﻻ ﯾؤﺛر ﺑﺎﻟﺧطوة اﻟﺗﻲ ھوا ﺑﮭﺎ واﻟﻣﺗﻐﯾر ‪ item‬ﯾﺟﻣﻊ ﻗﯾﻣﺗﮫ اﻟﺳﺎﺑﻘﺔ ﻣﻊ ‪ a‬وﯾطرﺣﮭﺎ ﻣن ‪b‬‬
  ‫;‪11.item=++b‬‬
  ‫//ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)5=‪ (a=7,b=5,item‬اﻟﻣﺗﻐﯾر ‪a‬ﯾﺑﻘﻰ ﺛﺎﺑت اﻟﻣﺗﻐﯾر ‪b‬ﯾزداد ﺑﻣﻘدار‬
                                       ‫واﺣد وﯾؤﺛر ﻓﻲ اﻟﺧطوة اﻟﺗﻲ ھوا ﺑﮭﺎ واﻟﻣﺗﻐﯾر ‪item‬ﯾﺄﺧذ ﻗﯾﻣﺔ ال ‪b‬اﻟﺟدﯾدة‬
  ‫;5=+‪12.item‬‬
        ‫//ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)01=‪ (a=7,b=5,item‬ﻓﻘط ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪item‬ﺗﺗﻐﯾر ﻟﺗﺟﻣﻊ‬
                                                                                        ‫ﻗﯾﻣﺗﮭﺎ اﻟﺳﺎﺑﻘﺔ ﻣﻊ اﻟرﻗم ٥‬
  ‫;5+‪13.b=b‬‬
      ‫// ﻗﯾم اﻟﻣﺗﻐﯾرات ﻓﻲ ﺑﻌد اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ھﻲ)01=‪ (a=7,b=10,item‬ﻓﻘط ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ b‬ﺗﺗﻐﯾر ﻟﺗﺟﻣﻊ‬
                                                                                       ‫ﻗﯾﻣﺗﮭﺎ اﻟﺳﺎﺑﻘﺔ ﻣﻊ اﻟرﻗم ٥‬
  ‫}‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                      ‫اﻟﻔﺻل اﻷول‬




                                      ‫ﻣؤﺛرات اﻟﻧﻘﺻﺎن: ھو ﻧﻘﺻﺎن ﻣن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﺑﻣﻘدار واﺣد أو أﻛﺛر‬

                                                                                                 ‫ﺗوﺿﯾﺢ‬
     ‫;1-‪a =a‬‬
                         ‫ﻣﻌﻧﺎه اﻟﻣﺗﻐﯾر ) ‪ (a‬ﻧﻘص ﺑﻣﻘدار واﺣد )إي طرح ﻣن ﻗﯾﻣﺗﮫ اﻟﺳﺎﺑﻘﺔ ﺑﻣﻘدار )١ (‬
                                                              ‫ا ي ﻟو ﻛﺎن ﻗﯾﻣﺗﮫ ﻣﺛﻼ ٢ ﯾﺻﺑﺢ ١ (‬
           ‫-------------------------------------ﻣﺛﺎل ﺗوﺿﯾﺣﻲ----------------------------------‬
     ‫2=‪Int a‬‬
     ‫ﻋرﻓﻧﺎ اﻟﻣﺗﻐﯾر وأﻋطﯾﻧﺎ ﻗﯾﻣﺗﮫ 0=‪a‬‬
     ‫;1-‪a =a‬‬
     ‫طرﺣت ﻣن ﻗﯾﻣﺗﮫ اﻟﺳﺎﺑﻘﺔ وھﻲ اﺛﻧﺎن ﻣﻘدار اﻟواﺣد وأﺻﺑﺣت ﻗﯾﻣﺗﮫ 1=‪a‬‬
     ‫;1-‪a =a‬‬
     ‫طرﺣت ﻣن ﻗﯾﻣﺗﮫ اﻟﺳﺎﺑﻘﺔ وھﻲ واﺣد ﻣﻘدار اﻟواﺣد و أﺻﺑﺣت ﻗﯾﻣﺗﮫ 0=‪a‬‬
     ‫;5-‪a=a‬‬
     ‫طرﺣت ﻣن ﻗﯾﻣﺗﮫ اﻟﺳﺎﺑﻘﺔ وھﻲ ﺻﻔر ﻣﻘدار ﺧﻣﺳﺔ و أﺻﺑﺣت ﻗﯾﻣﺗﮫ 5-=‪a‬‬
              ‫--------------------------------------------------------------------------------‬
       ‫ﻻﺣظت ﻛﯾف ﺗﻐﯾرت ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ a‬ﻣن اﻻﺛﻧﺎن إﻟﻰ اﻟواﺣد إﻟﻰ اﻟﺻﻔر إﻟﻰ ﺳﺎﻟب ﺧﻣﺳﺔ ﺑﻣﺟرد ﻛﺗﺎﺑﮫ‬
                                            ‫ھذا اﻟﺗﻌﺑﯾر .ھﻧﺎك طرﯾﻘﺔ أﺧرى ﻟﺗﻣﺛﯾل ﻣؤﺛرات اﻟﻧﻘﺻﺎن وھﻲ‬

     ‫ﺑدﻻ أن ﻧﻛﺗب );1-‪(a=a‬‬                    ‫ﻧﻛﺗب --‪a‬‬
                                              ‫أو 1= - ‪a‬‬
                                                    ‫‪--a‬‬
                                          ‫وﺗدل اﻟرﻣوز اﻟﺳﺎﺑﻘﺔ ﻋﻠﻰ أن اﻟﻣﺗﻐﯾر ‪ a‬ﻗد ﻧﻘص ﺑﻣﻘدار واﺣد.‬
                             ‫ﻟو أردﻧﺎ أن ﯾﻧﻘص اﻟﻣﺗﻐﯾر ﻗﯾﻣﺔ ﻏﯾر اﻟواﺣد ﻗد ﯾﻛون ٥ أو إي رﻗم أﺧر ﻓﻧﻛﺗب‬

     ‫ﺑدﻻ أن ﻧﻛﺗب );5-‪(a=a‬‬                         ‫ﻧﻛﺗب 5=-‪a‬‬

           ‫------------------------- ﯾﺻﺑﺢ اﻟﻣﺛﺎل ﺗوﺿﯾﺣﻲ ﺑﺎﻟرﻣوز اﻟﺑرﻣﺟﯾﺔ----------------------‬
     ‫2=‪Int a‬‬
     ‫ﻋرﻓﻧﺎ اﻟﻣﺗﻐﯾر وأﻋطﯾﻧﺎ ﻗﯾﻣﺗﮫ 0=‪a‬‬
     ‫;-- ‪a‬‬
     ‫أﺻﺑﺣت ﻗﯾﻣﺗﮫ 1-=‪a‬‬
     ‫;0=- ‪a‬‬
     ‫أﺻﺑﺣت ﻗﯾﻣﺗﮫ 1-=‪a‬‬
     ‫;5- =-‪a‬‬
     ‫أﺻﺑﺣت ﻗﯾﻣﺗﮫ 6-=‪a‬‬
              ‫--------------------------------------------------------------------------------‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                          ‫اﻟﻔﺻل اﻷول‬




                                                                             ‫ﻣﺎ اﻟﻔرق ﺑﯾن )‪.. (a-- ,--a‬؟‬
    ‫اﻻﺧﺗﻼف ھوا اﻧﮫ )--‪ (a‬ﻣﻌﻧﺎه ﻧﻔذ اﻟﺧطوة اﻟﺗﻲ أﻧت ﺑﮭﺎ ﻋﻠﻰ ﻗﯾﻣﺗك اﻟﺳﺎﺑﻘﺔ ﺛم ﻏﯾر ﻗﯾﻣﺗك )ﻛﺄن‬
    ‫ﯾﻛون ﻗﯾﻣﺔ اﻟﻧﻘﺻﺎن ھﻲ واﺣد وﻗﯾﻣﺗﮫ ﻓﻲ اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ ٢ ﯾﻧﻔذ اﻟﺧطوة اﻟﺗﻲ ھوا ﺑﮭﺎ ﻋﻠﻰ اﻧﮫ ٢‬
                                                 ‫وﻋﻧدﻣﺎ ﯾﻧﺗﻘل إﻟﻰ اﻟﺧطوة أﻻﺣﻘﺔ ﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ ١(‬


           ‫اﻟﻣﺗﻐﯾر ﺑﻘﯾﻣﺔ ٢ ﻗﺑل اﻟﻧﻘﺻﺎن ;2=‪1.a‬‬
           ‫ﯾﺑﻘﻰ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻓﻲ ھذه اﻟﺧطوة ٢ وﯾﺻﺑﺢ واﺣد ﻋﻠﻰ اﻟﺧطوة اﻟﻘﺎدﻣﺔ ;--‪2.a‬‬
           ‫أﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر واﺣد .3‬

‫إﻣﺎ )‪ (--a‬ﻣﻌﻧﺎه ﻏﯾر ﻗﯾﻣﺗك اﻟﺳﺎﺑﻘﺔ أوﻻ ﺗم ﻧﻔذ اﻟﺧطوة اﻟﺗﻲ أﻧت ﺑﮭﺎ ﻟذاﻟك ﻧراه ﻓﻲ ﺟدول اﻷﺳﺑﻘﯾﺎت‬
                                      ‫ﻣﻘدم ﻋﻠﻰ ﺑﺎﻗﻲ اﻟﻌﻣﻠﯾﺎت ﻓﻲ أﺳﺑﻘﯾﺗﮫ . ﻟﻧﻌد اﻟﻣﺛﺎل اﻟﺳﺎﺑق‬


           ‫اﻟﻣﺗﻐﯾر ﺑﻘﯾﻣﺔ ٢ ﻗﺑل اﻟﻧﻘﺻﺎن ;2=‪1.a‬‬
           ‫ﯾﺻﺑﺢ ﻗﯾﻣﺗﮫ واﺣد ﻓﻲ ھذه اﻟﺧطوة ;‪2.--a‬‬




                   ‫ﻣﺛﺎل:ﯾﺑﯾن ﻛﯾﻔﯾﺔ ﺗﺄﺛر ﺑﻣﻘدار اﻟﺗﻐﯾر ﻓﻲ اﻟﺧطوة اﻟﻣوﺟود ﻓﯾﮭﺎ واﻟﺧطوة اﻟﺗﻲ ﺗﻠﯾﮭﺎ ..؟‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                          ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪1.#include<iostream.h‬‬                                     ‫>‪1.#include<stdio.h‬‬
 ‫)(‪2.main‬‬                                                   ‫)(‪2.main‬‬
 ‫{.3‬                                                        ‫{.3‬
 ‫;2=‪4.int a‬‬                                                 ‫;2=‪4.int a‬‬
 ‫;‪5.int item‬‬                                                ‫;‪5.int item‬‬
 ‫;--‪6.item=3+a‬‬                                              ‫;--‪6.item=3+a‬‬
 ‫; ‪7.cout<<"FirstTry="<< item‬‬                               ‫; )‪7.prin ("FirstTry=%d", item‬‬
 ‫;‪8.item=3+ a‬‬                                               ‫;‪8.item=3+ a‬‬
 ‫; ‪9.cout<<"\nSecondTry="<< item‬‬                            ‫; )‪9.prin ("\nSecondTry=%d", item‬‬
 ‫}.01‬                                                       ‫}.01‬

                                                                                                  ‫ﺗوﺿﯾﺢ....؟‬
  ‫١.ﻓﻲ اﻟﺳطر اﻟرﺑﻊ ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (a‬وأﻋطﯾﻧﺎه ﻗﯾﻣﺔ ﺑداﺋﯾﺔ وھﻲ ٢ وﻓﻲ اﻟﺳطر اﻟﺧﺎﻣس ﻋرﻓﻧﺎ ﻣﺗﻐﯾر‬
                                                                   ‫‪ item‬وﻟم ﻧﻌطﮫ إي ﻗﯾﻣﺔ‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                            ‫اﻟﻔﺻل اﻷول‬




   ‫٢.ﻓﻲ اﻟﺳطر اﻟﺳﺎدس ﺣدﺛت ﻋﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ ﺟﻣﻌت ﺑﯾن )٣( وﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ ( a‬ﻣﺗﺄﺛرا ﺑﻧﻘﺻﺎن ﻟﻛن‬
   ‫ﻛﻣﺎ ﺑﯾﻧﺎ ﺳﺎﺑﻘﺎ أن ھذه اﻟﻧﻘﺻﺎن اﻟﺟدﯾد ﻻ ﺗؤﺛر ﻋﻠﻰ ﻧﺗﺎﺋﺞ اﻟﺧطوة اﻟﻣوﺟود ﻓﯾﮭﺎ إﻧﻣﺎ ﺗؤﺛر ﻋﻠﻰ ﻧﺗﺎﺋﺞ‬
         ‫اﻟﺧطوة اﻟﺗﻲ ﺗﻠﯾﮫ . ﻟذاﻟك ﯾﺑﻘﻰ اﻟﻣﺗﻐﯾر ) ‪ (a‬ﻣﺣﺗﻔظﺎ ﺑﻘﯾﻣﺗﮫ ﻓﻲ ھذه اﻟﺧطوة اﻟﺳﺎدﺳﺔ ﻋﻠﻰ ﻗﯾﻣﺗﮫ‬
  ‫اﻟﺑداﺋﯾﺔ)أو ﻣﻘدار ﻗﯾﻣﺗﮫ ﻗﺑل اﻟﺧطوة اﻟﺳﺎدﺳﺔ وھﻲ ٢ (ﻟذاﻟك ﻧﺎﺗﺞ ﺟﻣﻊ )٢+٣( ھو ﺧﻣﺳﺔ وھو ﻣﺎ ظﮭر‬
                                                                                ‫ﺗﻣﺛﯾل رﯾﺎﺿﻲ‬
           ‫;--‪6.item=3+ a‬‬
           ‫2+3=‪Item‬‬
           ‫5=‪Item‬‬

               ‫‪ ‬وأﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر) 1=‪ (a‬ﺑﻌد أن ﻧﻔذ اﻟﺧطوة رﻗم )٦( ﻷﻧﮫ ﺗﻧﺎﻗص ﺑﻣﻘدار واﺣد‬

                                                                       ‫ﻟو ﻛﺎﻧت اﻟﺧطوة اﻟﺳﺎدﺳﺔ ھﻲ‬
                                                                                      ‫اﻟﻛود‬
           ‫;‪6.item=3+ --a‬‬


‫‪ ‬ﻟﻛﺎن اﻟﻣﺗﻐﯾر )‪ (a‬ﺗﻐﯾرت ﻗﯾﻣﺗﮫ إﻟﻰ واﺣد ﻗﺑل ﺗﻧﻔﯾذ اﻟﺧطوة رﻗم )٦( ﻣؤﺛرا ﺑﻘﯾﻣﺗﮫ اﻟﺟدﯾدة ﻋﻠﻰ‬
                 ‫اﻟﺧطوة اﻟﺗﻲ ھو ﺑﮭﺎ وﺗﺻﺑﺢ اﻟﻧﺗﯾﺟﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ (٣+١) item‬وھﻲ ٤‬
‫‪ ‬ﻟو ﻧﻼﺣظ ﻓﻲ ﻛﻼ اﻟﺣﺎﻟﺗﯾن أﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )1=‪ (a‬ﻟﻛن اﺧﺗﻠﻔﺎ ﻓﻲ ﺗﺄﺛﯾرھﻣﺎ ﻓﻲ اﻟﺗﻲ ھﻣﺎ ﺑﮭﺎ‬
               ‫ﻣﮭم‬          ‫٣.اﻟﺳطر اﻟﺳﺎﺑﻊ طﺑﻌﻧﺎ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ item‬وھﻲ ﻛﻣﺎ ﺗظﮭر ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ٥‬

   ‫٤.اﻟﺳطر اﻟﺛﺎﻣن ﻗﻣﻧﺎ ﺑﻌﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ ﺟدﯾدة ﺟﻣﻌت ﺑﯾن ٣ وﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ a‬ﺑدون إي ﺗﻐﯾر ﻓﻲ ﻣﻘدار‬
      ‫ﻗﯾﻣﺔ ھذه اﻟﻣﺗﻐﯾر ﻟﻛن رﻏم ذاﻟك ﻛﺎﻧت اﻟﻧﺗﯾﺟﺔ )4( وذاﻟك ﻻن اﻟﻣﺗﻐﯾر ‪ a‬ﺗﻐﯾرت ﻗﯾﻣﺗﮫ ﻓﻲ اﻟﺳطر‬
‫اﻟﺳﺎدس إﻟﻰ واﺣد ﻟﻛﻧﮫ ﺑﻘﺎ ﻣﺣﺗﻔظﺎ ﺑﻘﯾﻣﺗﮫ ﻟم ﯾؤﺛر ﻓﻲ اﻟﺧطوة اﻟﺗﻲ ھوا ﺑﮭﺎ إﻧﻣﺎ اﺛر ﻓﻲ اﻟﺧطوة اﻟﺗﻲ ﺗﻠﯾﮫ‬
                                                                        ‫ﻓﺄﺻﺑﺣت اﻟﻧﺗﯾﺟﺔ ٤ وﻟﯾس ٥‬

                                                                                ‫ﺗﻣﺛﯾل رﯾﺎﺿﻲ‬
           ‫‪8.item=3+ a‬‬
            ‫1+3=‪Item‬‬
           ‫4=‪Item‬‬


                          ‫5=‪FirstTry‬‬                                           ‫ﻧﺎﺗﺞ ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ‬
                          ‫4=‪SecondTry‬‬



   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                               ‫اﻟﻔﺻل اﻷول‬




       ‫١١.١- ﺑﻌض دوال اﻹدﺧﺎل واﻹﺧراج ﻓﻲ ﻟﻐﺔ )‪ (C‬ﻓﻲ ﻣﻛﺗﺑﺔ >‪<stdio.h‬‬
        ‫1.)‪ (getchar‬ﺗﺄﺧذ ھذه اﻟداﻟﺔ ﺣرف واﺣد ﯾدﺧﻠﮫ اﻟﻣﺳﺗﺧدم ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وﯾظﮭر ھذا اﻟﺣرف أﻣﺎم اﻟﻣﺳﺗﺧدم.‬
                                                     ‫ﻧﺿﻐط ﻣﻔﺗﺎح )‪ (enter‬ﺑﻌد إدﺧﺎل اﻟﺣرف ﻟﻛﻲ ﯾﻧﻔذ اﻟﺧطوة.‬

                 ‫2.)‪ (putchar‬ﯾطﺑﻊ ﺣرف واﺣد ﻓﻘط ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ )ھذا ﻣﺛﺎل ﻋﻠﻰ ﻛﯾﻔﯾﺔ اﺳﺗﺧدام ھﺎﺗﺎن اﻟداﻟﺗﺎن(.‬

             ‫‪C‬‬                                                                                 ‫اﻟﻛود ﺑﻠﻐﺔ‬
            ‫>‪1.#include<stdio.h‬‬
            ‫{)(‪2.main‬‬
            ‫;‪4.char symbol‬‬
            ‫;‪5. symbol=getchar‬‬
            ‫;)‪6. Putchar( symbol‬‬
            ‫}‬




                                      ‫٢١.١- ﺑﻌض دوال اﻹدﺧﺎل ﻓﻲ ﻣﻛﺗﺑﺔ >‪<conio.h‬‬
 ‫1.)‪ (getch‬ﺗﻘرء ھذه اﻟداﻟﺔ ﺣرف واﺣد ﯾدﺧﻠﮫ اﻟﻣﺳﺗﺧدم ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وﻻ ﯾظﮭر ھذا اﻟﺣرف أﻣﺎم اﻟﻣﺳﺗﺧدم )ﻛﻣﺎ‬
  ‫ﻛﺎن ﯾظﮭر ﻓﻲ دوال اﻹدﺧﺎل اﻷﺧرى(. وﻻ ﻧﺿﻐط ﻣﻔﺗﺎح )‪ (enter‬ﺑﻌد إدﺧﺎل اﻟﺣرف ﻓﻘط ﻧﻛﺗب اﻟﺣرف وھو ﯾﻧﻔذ.‬

                   ‫ھذا ﻣﺛﺎل ﻋﻠﻰ ﻛﯾﻔﯾﺔ اﺳﺗﺧدام ھذه اﻟداﻟﺔ )ﯾﺟب ﺗﺿﻣﯾن اﻟﻣﻛﺗﺑﺔ ‪ conio‬ﻓﻲ اﻟﺣل ﻷﻧﻧﺎ ﻧﺳﺗﺧدم دواﻟﮭﺎ(‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
  ‫>‪#include<conio.h‬‬                                         ‫>‪#include<conio.h‬‬
 ‫{)(‪main‬‬                                                    ‫{)(‪main‬‬
 ‫;‪char symbol‬‬                                               ‫;‪char symbol‬‬
  ‫;)(‪symbol=getch‬‬                                           ‫;)(‪symbol=getch‬‬
 ‫;‪cout<<"The symbol your enter is=" << symbol‬‬               ‫;)‪Printf("The symbol your enter is=%c", symbol‬‬
 ‫}‬                                                          ‫}‬


       ‫ﻻﺣظ ﻣﺎ ﺳﯾظﮭر ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻋﻧد اﻟﺿﻐط ﻋﻠﻰ ﺣرف )‪ (w‬ﻣن ﻟوﺣﺔ اﻟﻣﻔﺎﺗﯾﺢ ﺑدون ﺿﻐط ﻣﻔﺗﺎح )‪.(enter‬ﻟم‬
                                                      ‫ﯾظﮭر اﻟﺣرف اﻟذي أدﺧﻠﺗﮫ إﻧﻣﺎ ﻓﻘط ﻧﻔذ وظﮭرت اﻟرﺳﺎﻟﺔ‬




     ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                                  ‫اﻟﻔﺻل اﻷول‬




 ‫2.)‪ (getche‬ﺗﻘرء ھذه اﻟداﻟﺔ ﺣرف واﺣد ﯾدﺧﻠﮫ اﻟﻣﺳﺗﺧدم ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ و ﯾظﮭر ھذا اﻟﺣرف أﻣﺎم اﻟﻣﺳﺗﺧدم .وﻻ‬
                                        ‫ﻧﺿﻐط ﻣﻔﺗﺎح )‪ (enter‬ﺑﻌد إدﺧﺎل اﻟﺣرف ﻓﻘط ﻧﻛﺗب اﻟﺣرف وھو ﯾﻧﻔذ.‬

                                                                              ‫ھذا ﻣﺛﺎل ﻋﻠﻰ ﻛﯾﻔﯾﺔ اﺳﺗﺧدام ھذه اﻟداﻟﺔ‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
  ‫>‪#include<conio.h‬‬                                         ‫>‪#include<conio.h‬‬
 ‫{)(‪main‬‬                                                    ‫{)(‪main‬‬
 ‫;‪char symbol‬‬                                               ‫;‪char symbol‬‬
  ‫;)(‪symbol=getche‬‬                                          ‫;)(‪symbol=getche‬‬
 ‫;‪cout<<"\nThe symbol your enter is=" << symbol‬‬             ‫;)‪Printf("\nThe symbol your enter is=%c", symbol‬‬
 ‫}‬                                                          ‫}‬


         ‫ﻻﺣظ ﻣﺎ ﺳﯾظﮭر ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻋﻧد اﻟﺿﻐط ﻋﻠﻰ ﺣرف )‪ (w‬ﻣن ﻟوﺣﺔ اﻟﻣﻔﺎﺗﯾﺢ ﺑدون ﺿﻐط ﻣﻔﺗﺎح )‪(enter‬‬




                                                  ‫٣١.١- دوال اﻟرﯾﺎﺿﯾﺔ ﻓﻲ ﻣﻛﺗﺑﺔ >‪<math.h‬‬

     ‫ﺗﺳﺗﺧدم دوال ھذه اﻟﻣﻛﺗﺑﺔ ﻓﻲ ﺣل اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ ﻛﺈﯾﺟﺎد ﺟﯾب أو ﺟﯾب ﺗﻣﺎم أو ﻗﯾﻣﺔ ﻣطﻠﻘﺔ وﻏﯾرھﺎ ﻣن اﻟدوال‬
                                                         ‫ﻟﺗﺳﮭﯾل ﻋﻣﻠﯾﺔ ﺣﺳﺎب ھذه اﻟﻘﯾم وھذا ﺷرح ﻟﺑﻌض دواﻟﮭﺎ‬

      ‫1.)‪ (sin‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻹﯾﺟﺎد ﺟﯾب اﻟزاوﯾﺔ ﺑﺎﻟﻧظﺎم ال )‪ (rad‬ﻟذاﻟك ﻹﯾﺟﺎد ﺟﯾب اﻟزاوﯾﺔ ﺑﺎﻟﻧظﺎم )‪ (deg‬ﻓﻘط‬
                                                                              ‫ﻧﺿرب ﻗﯾﻣﺔ اﻟزاوﯾﺔ ب 081/‪pi‬‬

                                                                               ‫اﻟﻛود )إﯾﺟﺎد ﺟﯾب اﻟزاوﯾﺔ ٠٩ (‬
            ‫;‪Float x‬‬
            ‫;) )081/41.3(*09(‪X=sin‬‬




     ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                         ‫اﻟﻔﺻل اﻷول‬




   ‫2.)‪ (cos‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻹﯾﺟﺎد ﺟﯾب ﺗﻣﺎم اﻟزاوﯾﺔ ﺑﺎﻟﻧظﺎم ال )‪ (rad‬ﻟذاﻟك ﻹﯾﺟﺎد ﺟﯾب اﻟزاوﯾﺔ ﺑﺎﻟﻧظﺎم )‪(deg‬‬
                                                                        ‫ﻓﻘط ﻧﺿرب ﻗﯾﻣﺔ اﻟزاوﯾﺔ ب 081/‪pi‬‬

                                                                      ‫اﻟﻛود )إﯾﺟﺎد ﺟﯾب ﺗﻣﺎم اﻟزاوﯾﺔ ٠٩ (‬
           ‫;‪Float x‬‬
           ‫;))081/41.3(*09(‪X=cos‬‬

  ‫ﻹﯾﺟﺎد ﺑﻘﯾﺔ اﻟدوال اﻟﻣﺛﻠﺛﯾﺔ ﺟﻣﯾﻌﮭﺎ ﺗﻛون ﻣﺷﺗﻘﺔ ﻣن ﺟﯾب وﺟﯾب ﺗﻣﺎم .إي إﻧﻧﺎ ﻧﺣول إي داﻟﺔ ﻣﺛﻠﺛﯾﮫ إﻟﻰ ﺟﯾب أو ﺟﯾب‬
                                                                         ‫ﺗﻣﺎم ﺣﺳب ﺗﺣوﯾﻠﮭﺎ ﺑﺎﻟدوال اﻟﻣﺛﻠﺛﯾﺔ .‬
                                                ‫ﻣﺛﻼ ﻹﯾﺟﺎد اﻟﺿل اﻟزاوﯾﺔ ﻓﻘط ﻧﻘﺳم ﺟﯾب ﻋﻠﻰ ﺟﯾب ﺗﻣﺎم اﻟزاوﯾﺔ‬

                                                                          ‫ﻋﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ ﻹﯾﺟﺎد ﺿل ٠٩‬
           ‫;‪Float Tanx‬‬
           ‫;))081/41.3(*09(‪Tanx =sin (90*(3.14/180) ) / cos‬‬

                                                                 ‫وﻛذاﻟك ﺑﻘﯾﺔ اﻟدوال اﻟﻣﺛﻠﺛﯾﺔ ﺑﻧﻔس اﻟطرﯾﻘﺔ‬

        ‫3.)‪ (pow‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻹﯾﺟﺎد ﻗﯾﻣﺔ رﻗم ﻣرﻓوع إﻟﻰ أس )ﻣﺛﻼ 9=2^3( .طرﯾﻘﺔ ﺗﻣﺛﯾل ھذه اﻟداﻟﺔ‬
‫;)‪X=pow(number,hispower‬‬
                                             ‫ﺣﯾث أن ‪ number‬ھو اﻟرﻗم و ‪ hispower‬ھو اﻷس اﻟﻣرﻓوع ﻟﮫ‬
                  ‫ﻣﺛﺎل: ﻟو ﻛﺎن ﻟدﯾﻧﺎ )9^3(إي ﺛﻼﺛﺔ ﻣرﻓوع ﻷس ﺗﺳﻌﺔ ﻓﯾﻛﺗب ﺑرﻣﺟﯾﺎ ﺑﺎﺳﺗﺧدام ھذه اﻟداﻟﺔ ھﻛذا‬

                                                                                                   ‫اﻟﻛود‬
           ‫;)9,3(‪X=pow‬‬



                                                                              ‫4.)‪ (abs‬ھﻲ اﻟﻘﯾﻣﺔ اﻟﻣطﻠﻘﺔ ﻟﻠرﻗم‬

                                                                                                   ‫اﻟﻛود‬
           ‫3=‪X=abs(-3); // x‬‬

                                                                  ‫5.)‪ (sqrt‬ھﻲ داﻟﺔ ﺗﺳﺗﺧدم ﻹﯾﺟﺎد ﺟذر اﻟرﻗم‬

                                                                                                   ‫اﻟﻛود‬
           ‫5=‪X=sqrt(25); // x‬‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                                                     ‫اﻟﻔﺻل اﻷول‬




                                                        ‫٤١.١- دوال اﻟﺗﺣوﯾل )‪(int,char,sizeof‬‬
                    ‫1.)‪ (size of‬ﺗﺟد ھذه اﻟداﻟﺔ اﻟﺣﺟم اﻟذي ﯾﺷﻐﻠﮫ اﻟﻣﺗﻐﯾر ﻓﻲ اﻟذاﻛرة .ﻋدد اﻟﺑﺎﯾﺗﺎت اﻟﺗﻲ ﯾﺣﺟزھﺎ ﻟﮫ.‬

                                                                                                          ‫اﻟﻛود‬
           ‫‪X=sizeof(int); // 2 byte is the size of integer‬‬

‫2.)‪ (int‬ﺗﺣول ھذه اﻟداﻟﺔ اﻟﻣﺗﻐﯾرات ﻣن أﻧواع أﺧرى إﻟﻰ ﻣﺗﻐﯾر ﻣن ﻧوع ‪ .integer‬وأﯾﺿﺎ ﺗﺟد ﻗﯾﻣﺔ )‪ (ASCii‬ﻟﻠﺣرف.‬
   ‫اﻻﺳﻛﻲ ﻛود: ﻛل ﺣرف ﻣن اﻷﺣرف اﻻﻧﻛﻠﯾزﯾﺔ ﻟﮫ أﺳﻛﻲ ﻛود ﺧﺎص ﺑﮫ ﯾﺧﺗﻠف ﻋن ﻏﯾره ﻣن اﻷﺣرف ﻣﺛﻼ أﺳﻛﻲ‬
 ‫ﻛود اﻟﺣرف )‪ (a‬ﺻﻐﯾرة ھو )٧٩( وﯾﺧﺗﻠف ﻋن أﺳﻛﻲ ﻛود )‪ (A‬ﻛﺑﯾرة اﻟذي ھوا )٥٦(. وﺗرﺗﯾب أﺳﻛﻲ ﻛود اﻷﺣرف‬
                        ‫ﺑﺎﻟﺗﺳﻠﺳل إي أن أﺳﻛﻲ ﻛود )‪ (b‬ھو )٨٩( وﯾزداد ﺑﺎﻟﺗﺗﺎﻟﻲ)-----101=‪(c=99,d=100,e‬‬

                                                             ‫اﻟﻛود )ﺗﺣوﯾل ﻣﺗﻐﯾر ﻛﺳري إﻟﻰ ﻣﺗﻐﯾر ﻣن ﻧوع ‪( integer‬‬
           ‫;‪Int x‬‬
           ‫3=‪x=int(3.5); // x‬‬
                                                                             ‫اﻟﻛود )اﻟﺣﺻول ﻋﻠﻰ أﺳﻛﻲ ﻛود اﻟﺣرف(‬
           ‫;‪Int x‬‬
           ‫79=‪x=int('a'); // x‬‬

                                               ‫3.)‪ (char‬ﺗﺣول ھذه اﻟداﻟﺔ اﻟرﻗم إﻟﻰ ﻗﯾﻣﺔ اﻷس ﻛﻲ ﻛود اﻟﺧﺎﺻﺔ ﺑﮫ.‬

                                                                        ‫اﻟﻛود )اﻟﺣﺻول ﻋﻠﻰ اﻟﺣرف ﻣن أﺳﻛﻲ ﻛود(‬
           ‫;‪char x‬‬
           ‫‪x=char(97); // x=a‬‬
                                                                                                        ‫ﻣﺛﺎل :‬
                                                                ‫ﺑرﻧﺎﻣﺞ ﻧدﺧل ﺣرف أو رﻣز وﯾﻌطﯾك اﻻﺳﻛﻲ ﻛود ﻟﮫ ..؟‬
 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
 ‫>‪#include<conio.h‬‬                                          ‫>‪#include<conio.h‬‬
 ‫{)(‪main‬‬                                                    ‫{)(‪main‬‬
 ‫;‪1.char symbol‬‬                                             ‫;‪1.char symbol‬‬
 ‫;)(‪2.symbol=getche‬‬                                         ‫;)(‪2.symbol=getche‬‬
 ‫};)‪3.cout<<"\n ASCii=" << int(symbol‬‬                       ‫};)‪3.prin ("\nASCii=%d", symbol‬‬
‫ﺗوﺿﯾﺢ اﻟﻣﺛﺎل: ﻓﻲ اﻟﺣل ﺑﻠﻐﺔ )‪ (c‬ﻓﻘط ﻓﻲ ﺧطوة رﻗم )٣( وﺿﻌﻧﺎ رﻣز اﻟطﺑﺎﻋﺔ )‪ (%d‬ﺣﺗﻰ ﯾطﺑﻊ اﺳﻛﻲ ﻛود اﻟﺣرف‬
‫وﻟﯾس اﻟﺣرف ﻧﻔﺳﮫ. ﯾﺧﺗﻠف اﻟﺣرف اﻟﻛﺑﯾر ﻋن اﻟﺣرف اﻟﺻﻐﯾر ب )٢٣( رﻗم إي أﺳﻛﻲ ﻛود )‪ (a‬ﺻﻐﯾرة ھو )٧٩(‬
                            ‫و )‪ (A‬ﻛﺑﯾرة ھو )٥٦( ﻟﻠﺗﺣوﯾل ﻣن ﻛﺑﯾر إﻟﻰ ﺻﻐﯾر ﻧزﯾد ٢٣ واﻟﻌﻛس ﻧطرح ٢٣‬

                                                       ‫اﻟﻛود )ﺗﺣوﯾل ﺣرف ﺻﻐﯾر إﻟﻰ ﺣرف ﻛﺑﯾر ﻣﺛﻼ )‪ (a‬أﺻﺑﺢ )‪(A‬‬
           ‫;'‪char x='a‬‬
           ‫‪x=char(int('a')-32) // x=A‬‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                       ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗﻌرف ﻋﻠﻰ أﺳﺎﺳﯾﺎت اﻟﻠﻐﺔ وطرﯾﻘﺔ ﻛﺗﺎﺑﺔ أول ﺑرﻧﺎﻣﺞ ﻟك‬                                             ‫اﻟﻔﺻل اﻷول‬




                                                      ‫٥١.١- ﻣﺎذا اﻛﺗﺷﻔت ﺑﻌد ان اﻧﺗﮭﯾﻧﺎ ﻣن اﻟﻔﺻل‬

      ‫أن ﻟﻐﺔ ) ‪ (C‬وﻟﻐﺔ )++‪ (C‬ﺗﺗﺷﺎﺑﮭﺎن ﻓﻲ اﻏﻠب ﺗﻌﺎﺑﯾرھﻣﺎ اﻟرﯾﺎﺿﯾﺔ وأﻛﺛر اﻻﺧﺗﻼﻓﺎت ﺑﯾﻧﮭﻣﺎ ھﻲ‬
‫اﻟﻣﻛﺗﺑﺎت ودوال اﻹدﺧﺎل ودوال اﻹﺧراج أي ﻟو أﺑدﻟت ﻓﻘط )اﺳم اﻟﻣﻛﺗﺑﺔ ودوال اﻹدﺧﺎل ودوال اﻹﺧراج‬
                         ‫ﺗﺳﺗطﯾﻊ ﺗﺣوﯾل اﻟﺑرﻧﺎﻣﺞ ﻣن ﻟﻐﺔ ) ‪ (C‬إﻟﻰ ﻟﻐﺔ )++‪ (C‬واﻟﻌﻛس ﺻﺣﯾﺢ‬



                                                                                 ‫ودوال اﻹﺧﻼف ھﻲ‬
                 ‫وﻟﻐﺔ )++‪(C‬‬                                     ‫ﻟﻐﺔ ) ‪(C‬‬               ‫اﻻﺧﺗﻼﻓﺎت‬
        ‫>‪#include<iostream.h‬‬                           ‫>‪#include<stdio.h‬‬                  ‫اﻟﻣﻛﺗﺑﺔ‬
        ‫‪cin‬‬                                            ‫‪scanf‬‬                         ‫دوال اﻹدﺧﺎل‬
        ‫‪Cout‬‬                                           ‫‪printf‬‬                        ‫دوال اﻹﺧراج‬


             ‫وﻓﻲ ﺑﻌض اﻷﻣﺛﻠﺔ ﺳوف ﻻ اﻛﺗﺑﮭﺎ ﺑﺎﻟﻐﺗﯾن ﻋﻠﻰ ﺣدة اﻛﺗب ﺑﻠﻐﺔ واﺣدة وأﻧت ﺗﺳﺗطﯾﻊ اﻟﺗﺣوﯾل‬
                         ‫وإذا ﻛﺎن ھﻧﺎك أﻛﺛر ﻣن ھذه اﻻﺧﺗﻼﻓﺎت اﻟﺛﻼث أﻧﺎ ﺳوف اﻛﺗب اﻟﺑرﻧﺎﻣﺞ ﺑﻠﻐﺗﯾن‬




   ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                           ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




 ‫)‪(Control Structures‬‬                      ‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ‬

                                                    ‫١.٢- ﻋﺑﺎرة )‪ (if‬اﻟﺷرطﯾﺔ اﻻﻋﺗﯾﺎدﯾﺔ:‬
                                                      ‫٢.٢- ﻋﺑﺎرة )‪ (if--else‬اﻟﺷرطﯾﺔ :‬
                                                      ‫٣.٢- اﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬
                                                   ‫٤.٢- ﻋﺑﺎرة )‪ (if—else if‬اﻟﺷرطﯾﺔ :‬
                                               ‫٥.٢- ﻋﺑﺎرة )‪ (Switch—Case‬اﻟﺷرطﯾﺔ :‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                 ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                                                     ‫١.٢- ﻋﺑﺎرة )‪ (if‬اﻟﺷرطﯾﺔ اﻻﻋﺗﯾﺎدﯾﺔ:‬
‫ھﻲ ﻋﺑﺎرة أو ﺟﻣﻠﺔ ﻻ ﯾﻧﻔذ ﻣﺎ ﻓﻲ داﺧﻠﮭﺎ ) إي ‪ statement‬اﻟﻣوﺟود ﺑﯾن ﻗوﺳﯾن اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ( إﻻ ﺑﺗﺣﻘق اﻟﺷرط‬
 ‫اﻟﻣوﺟود ﺑﻌد ﻋﺑﺎرة ‪ if‬وھو )‪ (condition‬أي ﯾﺟب أن ﺗﻛون ﻧﺗﯾﺟﺔ ﻣﻘﺎرﻧﺔ ﺷروط ھﻲ ) ‪ ( True‬ﺣﺗﻰ ﯾﻧﻔذ‬
                                                                         ‫ﻣﺎﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ.‬
                                                                  ‫ﺷﻛل ﻋﺑﺎرة ‪ if‬اﻟﺷرطﯾﺔ ﺑطرﯾﻘﺔ اﻋﺗﯾﺎدﯾﺔ‬
          ‫) ‪If ( condition‬‬
          ‫{‬
          ‫‪statement‬‬

          ‫}‬

      ‫أي أن ﺣﺳب ﻣﺧطط اﻟﻔﺻل اﻷول اﻟﺧﺎص ﺑﺗﺳﻠﺳل ﺗﻧﻔﯾذ ﺧطوات اﻟﺑرﻧﺎﻣﺞ ﺑﺎﻟﺗﺗﺎﺑﻊ .ﻓﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪(if‬‬

    ‫‪ ‬إذا ﻟم ﯾﺣﻘق اﻟﺷرط )‪ (condition‬أي ﻛﺎﻧت ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ھﻲ )‪ (False‬ﺳوف ﯾﻌﺑر ﺟﻣﯾﻊ اﻟﺧطوات‬
‫اﻟﻣوﺟودة ﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪ (if‬وﻻ ﯾﻧﻔذھﺎ ) وﻋرﻓﻧﺎ ﻓﻲ اﻟﻔﺻل اﻷول ﻛﯾف ﺗﻛون ﻣﻘﺎرﻧﺔ اﻟﺷروط(‬
   ‫‪ ‬وإذا ﺗﺣﻘق اﻟﺷرط )‪ ( condition‬أي ﻛﺎﻧت ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ھﻲ ) ‪ ( True‬ﯾﻧﻔذ اﻟﺧطوات اﻟﻣوﺟودة ﺑﯾن‬
                   ‫ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪ (if‬ﺑﺷﻛل اﻋﺗﯾﺎدي ﻻﺣظ اﻟﻣﺧطط اﻟﺗوﺿﯾﺣﻲ ﻟﺳﯾر اﻟﺑرﻧﺎﻣﺞ‬

                                                                                                                 ‫ﻣﮭم‬

 ‫‪ ‬إذا ﻟم ﻧﺿﻊ أﻗوس ﺧﻠف اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ ﻣﻌﻧﺎه ﯾﺗﺑﻌﮭﺎ ﻓﻘط اﻟﺳطر اﻟذي ﯾﻠﯾﮭﺎ أﻣﺎ إذا وﺿﻌﻧﺎ أﻗواس ﺧﻠﻔﮭﺎ ﻓﻛل‬
            ‫اﻟذي ﺑﯾن اﻟﻘوﺳﯾن ﯾﻛون ﺗﺎﺑﻊ ﻟﻠﻌﺑﺎرة اﻟﺷرطﯾﺔ ﺗﻧﻔذ إذا ﺗﺣﻘق اﻟﺷرط وﻻ ﺗﻧﻔذ إذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط‬

 ‫‪ ‬ﺑرﻧﺎﻣﺞ ﯾدﺧل اﻟﻣﺳﺗﺧدم ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وإذا ﻛﺎن اﻟرﻗم اﻛﺑر ﻣن ﺧﻣﺳﺔ ﯾﻌطﯾﮫ رﺳﺎﻟﺔ اﻧﮫ اﻛﺑر ﻣن ﺧﻣﺳﺔ‬

         ‫++‪C‬‬                                                                                    ‫اﻟﻛود ﺑﻠﻐﺔ‬
       ‫>‪include<iostream.h‬‬

       ‫ﻣن ھﻧﺎ ﯾﺑدأ ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ ﺧطوة ﺑﺧطوة )ھذه أول ﺧطوة(‬
       ‫)(‪Main‬‬
       ‫{‬
       ‫اﻟﺧطوات اﻟﻣوﺟودة ﺿﻣن ھذه اﻟداﻟﺔ ﯾﻧﻔذھﺎ ﺗﺑﺎﻋﺎ‬
       ‫;‪1.int a‬‬
       ‫;‪2.cin>>a‬‬
       ‫) 5>‪If ( a‬‬
       ‫;"5 ‪{3.cout<<"is greter than‬‬
       ‫}‬
       ‫;2+‪4. a=a‬‬
       ‫}; ‪5.cout<<"a="<<a‬‬


‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                              ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




          ‫‪C‬‬                                                                                  ‫اﻟﻛود ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫ﻣن ھﻧﺎ ﯾﺑدأ ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ ﺧطوة ﺑﺧطوة )ھذه أول ﺧطوة(‬
        ‫)(‪main‬‬
        ‫{‬
        ‫اﻟﺧطوات اﻟﻣوﺟودة ﺿﻣن ھذه اﻟداﻟﺔ ﯾﻧﻔذھﺎ ﺗﺑﺎﻋﺎ‬
        ‫;‪1.int a‬‬
        ‫;)‪2.scanf("%d",&a‬‬
        ‫) 5>‪If ( a‬‬
        ‫;)"5 ‪{3.prin ("is greter than‬‬
        ‫}‬
        ‫;2+‪4. a=a‬‬
        ‫;)‪5.prin ("a=%d",a‬‬
        ‫}‬
                                                                                                              ‫ﻣﮭم‬


                                                                                           ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                                        ‫١.ﯾﺑدأ اﻟﺑرﻧﺎﻣﺞ ﺑﺗﻧﻔﯾذ ﺧطوة رﻗم )١( ﺑﺗﻌرﯾف ﻣﺗﻐﯾر )‪ (a‬ﻣن ﻧوع ‪integer‬‬
                    ‫٢.ﺛم ﯾﻧﻔذ ﺧطوة رﻗم ) ٢ ( وﯾطﻠب ﻓﯾﮭﺎ ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر )‪ (a‬ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
                                                                               ‫٣.ﺗم ﯾﺗﺣﻘق ﻣن اﻟﺧطوة رﻗم )٣(‬
     ‫‪ ‬إذا ﻛﺎن اﻟرﻗم اﻟذي ادﺧﻠﮫ اﻟﻣﺳﺗﺧدم ﯾﺣﻘق اﻟﺷرط ﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪) (if‬إي اﻟرﻗم اﻛﺑر ﻣن‬
                        ‫ﺧﻣﺳﺔ إي اﻧﮫ ﺳوف ﺗﻛون ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ )‪ (condition‬ھﻲ )‪( (True‬وﻣﺛﻼ‬
                             ‫‪ ‬ﻟﻧﻔرض اﻧﮫ أدﺧل اﻟرﻗم ٦ ﻓﺗﻛون اﻟﻣﻘﺎرﻧﺔ ھﻛذا.‬
‫‪(a>5)(6>5)True‬‬
      ‫ﺳوف ﯾﻧﻔذ ﻣﺎ ﻣوﺟود ﻓﻲ ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪ (if‬إي ﺳﯾﻧﻔذ اﻟﺧطوة رﻗم ) ٣ ( ﺛم ﯾﻧﻔذ ﺧطوة رﻗم ) ٤ (‬
                                                                  ‫وﺛم ) ٥ ( ﻓﺗﻛون ﺗﺳﻠﺳل ﺗﻧﻔﯾذ ﺧطوات اﻟﺑرﻧﺎﻣﺞ‬
‫2 1‬          ‫3‬      ‫4‬          ‫5‬

                                                                                                              ‫ﻣﮭم‬
 ‫‪ ‬وإذا ﻛﺎن اﻟرﻗم ﻻ ﯾﺣﻘق اﻟﺷرط ﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪) (if‬إي اﻟرﻗم اﺻﻐر أو ﯾﺳﺎوي ﺧﻣﺳﺔ إي اﻧﮫ‬
                                 ‫ﺳوف ﺗﻛون ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ )‪ (condition‬ھﻲ )‪ ( (False‬وﻣﺛﻼ‬
                        ‫‪ ‬ﻟﻧﻔرض اﻧﮫ أدﺧل اﻟرﻗم 2 ﻓﺗﻛون اﻟﻣﻘﺎرﻧﺔ ھﻛذا.‬
‫‪(a>5)(2>5)False‬‬

  ‫ﺳوف ﻻ ﯾﻧﻔذ ﻣﺎ ﻣوﺟود ﻓﻲ ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪ (if‬إي ﻻ ﯾﻧﻔذ اﻟﺧطوة رﻗم )٣ ( إﻧﻣﺎ ﯾﻧﺗﻘل إﻟﻰ ﻣﺎ ﺑﻌد اﻟﻘوس‬
    ‫اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ ﻟﯾﻧﻔذه أي ﺳﯾﻧﻔذ ﺑﻌد اﻟﺧطوة ) ٢ ( ﻣﺑﺎﺷرة اﻟﺧطوة رﻗم ) ٤ ( وﺛم ) ٥( ﻓﺗﺳﻠﺳل ﺗﻧﻔﯾذ ﺧطوات‬
‫1‬   ‫2‬        ‫4‬      ‫5‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                              ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                            ‫اﻟﻌﻼﻗﺎت اﻟﺗﻲ ﺗﺳﺗﺧدم ﻛﺷروط )‪ (condition‬ﻓﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪ (if‬ھﻲ‬
                                                ‫طﺮﯾﻘﺔ ﺗﻤﺜﯿﻠﮫ ﻓﻲ ‪ if‬اﻟﺸﺮطﯿﺔ‬                  ‫اﻟﻮظﯿﻔﺔ‬      ‫اﻟﺮﻣﺰ‬
  ‫)‪ if(a>b‬ﻣﻘﺎرﻧﺔ ﺑﯾن ﻣﺗﻐﯾرﯾن )‪ (a,b‬ﯾﻧﻔذ اﻟﺟﻣﻠﺔ اﻟﺗﺎﺑﻌﺔ ﻟﻌﺑﺎرة ‪ if‬إذا ﻛﺎن ‪a‬‬              ‫ﻋﻼﻣﺔ اﻷﻛﺑر‬        ‫>‬
                                                                 ‫اﻛﺑر ﻣن ‪b‬‬
                 ‫)‪ if(a<b‬ﯾﻧﻔذ اﻟﺟﻣﻠﺔ اﻟﺗﺎﺑﻌﺔ ﻟﻌﺑﺎرة ‪ if‬إذا ﻛﺎن ‪ a‬اﺻﻐر ﻣن ‪b‬‬           ‫ﻋﻼﻣﺔ اﻷﺻﻐر‬           ‫<‬
          ‫)‪ if(a>=b‬ﯾﻧﻔذ اﻟﺟﻣﻠﺔ اﻟﺗﺎﺑﻌﺔ ﻟﻌﺑﺎرة ‪ if‬إذا ﻛﺎن ‪ a‬اﻛﺑر أو ﯾﺳﺎوي ‪b‬‬     ‫ﻋﻼﻣﺔ اﻛﺑر أو ﯾﺳﺎوي‬        ‫=>‬
    ‫)‪ if(a<=b‬ﯾﻧﻔذ اﻟﺟﻣﻠﺔ اﻟﺗﺎﺑﻌﺔ ﻟﻌﺑﺎرة ‪ if‬إذا ﻛﺎن ‪ a‬اﺻﻐر أو ﯾﺳﺎوي ﻣن ‪b‬‬       ‫ﻋﻼﻣﺔ اﺻﻐر أو ﯾﺳﺎوي‬         ‫=<‬
               ‫)‪ if(a==b‬ﯾﻧﻔذ اﻟﺟﻣﻠﺔ اﻟﺗﺎﺑﻌﺔ ﻟﻌﺑﺎرة ‪ if‬إذا ﻛﺎن ‪ a‬ﯾﺳﺎوي ﻣن ‪b‬‬           ‫ﻋﻼﻣﺔ اﻟﺗﺳﺎوي‬        ‫==‬
            ‫)‪ if(a!=b‬ﯾﻧﻔذ اﻟﺟﻣﻠﺔ اﻟﺗﺎﺑﻌﺔ ﻟﻌﺑﺎرة ‪ if‬إذا ﻛﺎن ‪ a‬ﻻ ﯾﺳﺎوي ﻣن ‪b‬‬           ‫ﻋﻼﻣﺔ ﻻ ﯾﺳﺎوي‬         ‫=!‬
     ‫))‪ If((a>b)&&(a>c‬ﯾﻧﻔذ اﻟﺟﻣﻠﺔ اﻟﺗﺎﺑﻌﺔ ﻟﻌﺑﺎرة ‪ if‬إذا ﻛﺎن ‪ a‬اﻛﺑر ﻣن ‪b‬‬        ‫ﺟﻣﻊ ﺷرطﯾن ب ‪and‬‬           ‫&&‬
      ‫وأﯾﺿﺎ ﯾﻛون ‪ a‬اﻛﺑر ﻣن ‪ C‬إي ﯾﺟب أن ﯾﺗﺣﻘق اﻟﺷرطﺎن ﺣﺗﻰ ﺗﻧﻔذ اﻟﺟﻣﻠﺔ‬
‫)‪ If((a>b)||(a>c‬ﯾﻧﻔذ اﻟﺟﻣﻠﺔ اﻟﺗﺎﺑﻌﺔ ﻟﻌﺑﺎرة ‪ if‬إذا ﻛﺎن ‪ a‬اﻛﺑر ﻣن ‪ b‬أو ﯾﻛون‬        ‫ﺟﻣﻊ ﺷرطﯾن ب ‪OR‬‬           ‫||‬
                ‫‪ a‬اﻛﺑر ﻣن ‪ C‬إي إذا ﺗﺣﻘق واﺣد ﻣن ھذان اﻟﺷرطﺎن ﺗﻧﻔذ اﻟﺟﻣﻠﺔ‬


         ‫‪ ‬ﺣﯾث أن )=!,==,=<,=>,<,>( ﺗﺳﺗﺧدم ﻛﻌﻼﻗﺔ ﺑﯾن ﻣﺗﻐﯾرﯾن أو ﻗﯾﻣﺗﯾن أو ﻣﺗﻐﯾر وﺗﻌﺑﯾر رﯾﺎﺿﻲ‬
                                                         ‫‪ ‬ﺷﻛل ﺗﻣﺛﯾل اﻟﺷروط ﻓﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪(if‬‬

          ‫ﻣﺘﻐﯿﺮ أو ﻗﯿﻤﺔ وﺗﻌﺒﯿﺮ رﯾﺎﺿﻲ )0==2/‪If(a‬‬         ‫)0==‪If(a‬‬             ‫ﻣﺘﻐﯿﺮ وﻗﯿﻤﺔ أو ﻣﺘﻐﯿﺮ وأﺧﺮ‬



                  ‫‪ ‬اﻟﺗﻌﺑﯾر اﻟرﯾﺎﺿﻲ ﻣﻣﻛن أن ﯾﻛون إي ﻋﻣﻠﯾﺎت رﯾﺎﺿﯾﺔ وﻧﺗﯾﺟﺔ اﻟﺗﻌﺑﯾر ﺗدﺧل ﻓﻲ اﻟﻣﻘﺎرﻧﺔ‬
     ‫‪ (&&,||) ‬ﺗﺳﺗﺧدم ﻋﻼﻗﺔ ﺑﯾن ﻣﺟﻣوﻋﺗﯾن ﻛل ﻣﺗﻐﯾرﯾن ﻋﻠﻰ ﺣدة ) وان ‪ And‬ﻟﮫ أﺳﺑﻘﯾﺔ ﻋﻠﻰ ‪( OR‬‬

                                                           ‫‪ ‬ﻣﺎ ھﻲ ﻧﺗﺎﺋﺞ ﻣﻘﺎرﻧﺔ اﻟﻌﻣﻠﯾﺎت اﻟﺗﺎﻟﯾﺔ‬
‫‪(3>2) True‬‬
‫‪(5!=7)True‬‬
‫‪(23>=120) False‬‬
‫‪(21 <11) False‬‬
‫‪( 4==2)False‬‬
‫‪(43<=76) True‬‬
‫‪((3+2)>4) (5>4)True‬‬

‫وأن اﻟﺷروط داﺧل اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ ھﻲ أﯾﺿﺎ ﺗﻧﻔذ ﺣﺳب اﻷﺳﺑﻘﯾﺎت أي أن أي ﺷرط أﺳﺑﻘﯾﺗﮫ أﻋﻠﻰ ﯾﻧﻔذ أوﻻ وھذا ﻣﺎ‬
                                               ‫ﺷرح ﻋﻧﮫ ﻣﻔﺻﻼ ﻓﻲ اﻟﻔﺻل اﻷول ﻓﻲ اﻷﻣﺛﻠﺔ ﻋﻠﻰ اﻷﺳﺑﻘﯾﺎت .‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                         ‫ﺑﻌض اﻷﻣﺛﻠﺔ اﻟﺗوﺿﯾﺣﯾﺔ ﻋﻠﻰ طرﯾﻘﺔ اﺳﺗﺧدام اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )‪:(if‬‬
‫ﻣﺛﺎل١: ﻟو ﻛﺎن ﻋﻧدﻧﺎ ﻣﺗﻐﯾران )‪ ( a , b‬ﯾدﺧل اﻟﻣﺳﺗﺧدم ﻗﯾﻣﮭﻣﺎ ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وﻛﺎن اﻟﻣطﻠوب طﺑﻊ رﺳﺎﺋل ﺗﺑﯾن ﻣﺗﻰ‬
   ‫ﻛﺎن ) ‪ a‬اﻛﺑر ﻣن ‪ a ،، b‬اﻛﺑر أو ﯾﺳﺎوي ‪ a ,, b‬اﺻﻐر ﻣن ‪a ,, b‬اﺻﻐر أو ﯾﺳﺎوي ‪ a ,, b‬ﯾﺳﺎوي ‪ a ,, b‬ﻻ ﯾﺳﺎوي ‪. (b‬؟‬

‫ﺗﺣﻠﯾل اﻟﺳؤال: ﯾوﺟد ﻣﺗﻐﯾران ﯾﺟب ﺗﻌرﯾﻔﮭﻣﺎ ﻓﻲ ﺑداﯾﺔ اﻟﺑرﻧﺎﻣﺞ وﻗراءﺗﮭﻣﺎ ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وﺑﻌدھﺎ اﻟﺗﺣﻘق ﻣن اﻟﺷروط‬
                                               ‫اﻟﻣوﺟود ﻓﻲ اﻟﺳؤال ﻋﻠﻰ ھﺎذان اﻟﻣﺗﻐﯾران وطﺑﻊ رﺳﺎﺋل ﻟﻛل ﺷرط‬

 ‫++‪c‬‬                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                          ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                              ‫)(‪main‬‬
 ‫{‬                                                   ‫{‬
 ‫;‪1.int a,b‬‬                                          ‫;‪1.int a,b‬‬
 ‫;‪2.cin>>a>>b‬‬                                        ‫;)‪2.scanf("%d%d",&a,&b‬‬
 ‫) ‪if ( a>b‬‬                                          ‫) ‪if ( a>b‬‬
 ‫;"‪3.cout<<"a is large than b‬‬                        ‫;)"‪3.prin ("a is large than b‬‬
   ‫) ‪if ( a>=b‬‬                                         ‫) ‪if ( a>=b‬‬
 ‫;"‪4.cout<<"\na is large than or equal b‬‬             ‫;)"‪4. prin ("\na is large than or equal b‬‬
 ‫) ‪if ( a<b‬‬                                          ‫) ‪if ( a<b‬‬
 ‫;"‪5.cout<<"\na is less than b‬‬                       ‫;)"‪5. prin ("\na is less than b‬‬
 ‫) ‪if ( a<=b‬‬                                         ‫) ‪if ( a<=b‬‬
 ‫;"‪6.cout<<"\na is less than or equal b‬‬              ‫;)"‪6. prin ("\na is less than or equal b‬‬
 ‫) ‪If ( a==b‬‬                                         ‫) ‪if ( a==b‬‬
 ‫;"‪7.cout<<"\na is equal than b‬‬                      ‫;)"‪7. prin ("\na is equal than b‬‬
 ‫) ‪if ( a!=b‬‬                                         ‫) ‪if ( a!=b‬‬
 ‫;"‪8.cout<<"\na is not equal than b‬‬                  ‫;)"‪8. prin ("\na is not equal than b‬‬
 ‫}‬                                                   ‫}‬
                                                                                            ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬
                                                         ‫١.ﺗﻧﻔذ أوﻻ ﺧطوة رﻗم )١( ھﻲ ﺗﻌرﯾف ﻟﻠﻣﺗﻐﯾرات )‪(a,b‬‬
                                 ‫٢.ﺛم ﺗﻧﻔذ ﺧطوة رﻗم )٢(ھﻲ ﻗراءة ﻟﻠﻣﺗﻐﯾرات اﻟﺗﻲ ﺳﺗدﺧل ﻗﯾﻣﮭﺎ ﻣن ﻗﺑل اﻟﻣﺳﺗﺧدم‬
                                                          ‫أﻻن ﻟﻧﺧﺗﺑر أن ﻧدﺧل ﻗﯾم ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وﻧرى اﻟﻧﺗﺎﺋﺞ‬
                   ‫‪ ‬ﻟو أدﺧﻠﻧﺎ )2=‪ (a=3,b‬ﻛﻣﺎ ﻻﺣظت ﻗد ﺗﻧﻔذه اﻟﺧطوات رﻗم )8,4,3( ﻷن ﺷروطﮭﺎ ﺗﺣﻘﻘت‬
                                                                                             ‫وذاﻟك ﻷﻧﮫ‬
    ‫١.اﻟﺷرط اﻟﺗﺎﺑﻊ ﻟﻠﺧطوة رﻗم ) ٣ ( ھوا أن ﯾﻛون ﻗﯾﻣﺔ ‪ a‬اﻛﺑر ﻣن ﻗﯾﻣﺔ ‪ b‬وﻓﻌﻼ أن ﻗﯾﻣﺔ ‪ a‬اﻟﺗﻲ أدﺧﻠﻧﺎھﺎ‬
                                    ‫ﻛﺎﻧت ٣ وﻗﯾﻣﺔ 2=‪ b‬ﻟذاﻟك ﻧﻔذ اﻟﺧطوة اﻟﺛﺎﻟﺛﺔ ﻻﺣظ اﻟﺗﺣﻘق ﻣن اﻟﺷرط‬
                                      ‫‪(a>b)(3>2)True‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                          ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




      ‫٢.اﻟﺷرط اﻟﺗﺎﺑﻊ ﻟﻠﺧطوة رﻗم )٤( ھو أن ﯾﻛون ﻗﯾﻣﺔ ‪ a‬اﻛﺑر أو ﯾﺳﺎوي ﻗﯾﻣﺔ ‪ b‬وﻓﻌﻼ أن ﻗﯾﻣﺔ ‪ a‬اﻟﺗﻲ‬
                                                                                                         ‫ﻣﮭم‬
                                             ‫أدﺧﻠﻧﺎھﺎ ﻛﺎﻧت ٣ أي ﻛﺎﻧت اﻛﺑر 2=‪ b‬ﻟذاﻟك ﻧﻔذ اﻟﺧطوة )٤(‬
                         ‫* وﺷرط)=>( ﯾﺗﺣﻘق إذا ﻛﺎن اﻟرﻗم اﻛﺑر ﻣﻧﮫ أو ﯾﺳﺎوﯾﮫ ﯾﻧﻔذ ﻋﺑﺎرة اﻟﺗﺎﺑﻌﺔ ﻟﻠﺷرط‬
                                   ‫‪(a>=b)(3>2)True‬‬

  ‫٣.اﻟﺷرط اﻟﺗﺎﺑﻊ ﻟﻠﺧطوة رﻗم )٨( ھوا أن ﯾﻛون ﻗﯾﻣﺔ ‪ a‬ﻻ ﯾﺳﺎوي ﻗﯾﻣﺔ ‪ b‬وﻓﻌﻼ أن ﻗﯾﻣﺔ ‪ a‬اﻟﺗﻲ أدﺧﻠﻧﺎھﺎ‬
                                                                                                         ‫ﻣﮭم‬
                                    ‫ﻛﺎﻧت ٣ وﻗﯾﻣﺔ 2=‪ b‬أي ﻛﺎﻧت ﻻ ﺗﺳﺎوي ﻟذاﻟك ﻧﻔذ اﻟﺧطوة رﻗم )٨(‬

                                                    ‫*** وﺑﻘﯾﺔ اﻟﺧطوات ﻟم ﺗﻧﻔذ ﻷﻧﮭﺎ ﻟم ﺗﺗﺣﻘق ﺷروطﮭﺎ‬

                                                    ‫ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟﻣﺎذا ﻟم ﺗﻧﻔذ اﻟﺧطوة رﻗم )٥( .؟‬
           ‫ﻷن ﺷرطﮭﺎ أن ﯾﻛون ‪ a‬اﺻﻐر ﻣن ﻗﯾﻣﺔ ‪ b‬وان ھذا اﻟﺷرط ﻻ ﯾﺗﺣﻘق ﻷن ﻗﯾﻣﺔ ‪ a‬اﻛﺑر ﻣن ﻗﯾﻣﺔ ‪b‬‬
                                    ‫‪(a<b)(3<2)False‬‬
                   ‫ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ھﻲ )‪ (false‬ﻟذاﻟك ﺳوف ﻻ ﯾﻧﻔذ اﻟﺧطوة اﻟﺗﻲ ﺗﺗﺑﻌﮫ ﻻن اﻟﺷرط ﻟم ﯾﺗﺣﻘق‬

                 ‫‪ ‬ﻟو أدﺧﻠﻧﺎ )6=‪ (a=3,b‬ﻛﻣﺎ ﻻﺣظت ﻗد ﺗﺣﻘﻘت اﻟﺧطوات رﻗم )8,6,5( ﻷن ﺷروطﮭﺎ ﺗﺣﻘﻘت‬
                                                                                            ‫وذاﻟك ﻷﻧﮫ‬
                                        ‫١.اﻟﺷرط اﻟﺗﺎﺑﻊ ﻟﻠﺧطوة ٥ ھوا أن ﯾﻛون ﻗﯾﻣﺔ ‪ a‬اﺻﻐر ﻣن ﻗﯾﻣﺔ ‪b‬‬
                                     ‫وﻓﻌﻼ أن ﻗﯾﻣﺔ ‪ a‬اﻟﺗﻲ أدﺧﻠﻧﺎھﺎ ﻛﺎﻧت ٣ وﻗﯾﻣﺔ 6=‪ b‬ﻟذاﻟك ﻧﻔذ اﻟﺧطوة‬
                                                                                             ‫رﻗم )٥(‬
                                       ‫‪(a<b)(3<6)True‬‬
  ‫٢.اﻟﺷرط اﻟﺗﺎﺑﻊ ﻟﻠﺧطوة 6 ھوا أن ﯾﻛون ﻗﯾﻣﺔ ‪ a‬اﺻﻐر أو ﯾﺳﺎوي ﻗﯾﻣﺔ ‪ b‬وﻓﻌﻼ أن ﻗﯾﻣﺔ ‪ a‬اﻟﺗﻲ أدﺧﻠﻧﺎھﺎ‬
                                                                                                         ‫ﻣﮭم‬
                                                        ‫ﻛﺎﻧت ٣ أي ﻛﺎﻧت اﺻﻐر 6=‪ b‬ﻟذاﻟك ﻧﻔذ اﻟﺧطوة 6‬
                         ‫* وﺷرط)=<( ﯾﺗﺣﻘق إذا ﻛﺎن اﻟرﻗم اﺻﻐر ﻣﻧﮫ أو ﯾﺳﺎوﯾﮫ ﯾﻧﻔذ ﻋﺑﺎرة اﻟﺗﺎﺑﻌﺔ ﻟﻠﺷرط‬
                                     ‫‪(a<=b)(3<=6)True‬‬
  ‫٣.اﻟﺷرط اﻟﺗﺎﺑﻊ ﻟﻠﺧطوة ٨ ھوا أن ﯾﻛون ﻗﯾﻣﺔ ‪ a‬ﻻ ﯾﺳﺎوي ﻗﯾﻣﺔ ‪ b‬وﻓﻌﻼ أن ﻗﯾﻣﺔ ‪ a‬اﻟﺗﻲ أدﺧﻠﻧﺎھﺎ ﻛﺎﻧت ٣‬
                                                      ‫وﻗﯾﻣﺔ 6=‪b‬أي ﻛﺎﻧت ﻻ ﺗﺳﺎوي ﻟذاﻟك ﻧﻔذ اﻟﺧطوة ٨‬        ‫ﻣﮭم‬
                                      ‫‪(a!=b)(3!=6)True‬‬
                                                       ‫*** وﺑﻘﯾﺔ اﻟﺧطوات ﻟم ﺗﻧﻔذ ﻷﻧﮭﺎ ﻟم ﺗﺗﺣﻘق ﺷروطﮭﺎ‬

                                    ‫‪ ‬ﻟو أدﺧﻠﻧﺎ )3=‪ (a=3,b‬ﻛﻣﺎ ﻻﺣظت ﻗد ﺗﺣﻘﻘت اﻟﺧطوات رﻗم )7,6,4(‬
                                                                                          ‫وذاﻟك ﻷﻧﮫ‬
                                          ‫١.اﻟﺷرط اﻟﺗﺎﺑﻊ ﻟﻠﺧطوة ٤ ھوا أن ﯾﻛون ﻗﯾﻣﺔ ‪ a‬اﻛﺑر أو ﯾﺳﺎوي‬
                                           ‫ﻗﯾﻣﺔ ‪ b‬وﻓﻌﻼ أن ﻗﯾﻣﺔ ‪ a‬اﻟﺗﻲ أدﺧﻠﻧﺎھﺎ ﻛﺎﻧت ٣ وﻗﯾﻣﺔ وﻛﺎﻧﺗﺎ‬
                                                                    ‫ﻣﺗﺳﺎوﯾﺗﺎن 3=‪ b‬ﻟذاﻟك ﻧﻔذ اﻟﺧطوة ٤‬
                                     ‫‪(a>=b)(3>=3)True‬‬


‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                            ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




  ‫٢.اﻟﺷرط اﻟﺗﺎﺑﻊ ﻟﻠﺧطوة 6 ھوا أن ﯾﻛون ﻗﯾﻣﺔ ‪ a‬اﺻﻐر أو ﯾﺳﺎوي ﻗﯾﻣﺔ ‪ b‬وﻓﻌﻼ أن ﻗﯾﻣﺔ ‪ a‬اﻟﺗﻲ أدﺧﻠﻧﺎھﺎ‬             ‫ﻣﮭم‬
                                                       ‫ﻛﺎﻧت ٣ أي ﻛﺎﻧت ﺗﺳﺎوي 3=‪ b‬ﻟذاﻟك ﻧﻔذ اﻟﺧطوة 6‬
                         ‫* وﺷرط)=<( ﯾﺗﺣﻘق إذا ﻛﺎن اﻟرﻗم اﺻﻐر ﻣﻧﮫ أو ﯾﺳﺎوﯾﮫ ﯾﻧﻔذ ﻋﺑﺎرة اﻟﺗﺎﺑﻌﺔ ﻟﻠﺷرط‬
                                     ‫‪(a<=b)(3<=3)True‬‬

‫٢.اﻟﺷرط اﻟﺗﺎﺑﻊ ﻟﻠﺧطوة ٧ ھوا أن ﯾﻛون ﻗﯾﻣﺔ ‪ a‬ﺗﺳﺎوي ﻗﯾﻣﺔ ‪ b‬وﻓﻌﻼ أن ﻗﯾﻣﺔ ‪ a‬اﻟﺗﻲ أدﺧﻠﻧﺎھﺎ ﻛﺎﻧت ٣ أي‬
                                                           ‫ﻛﺎﻧت ﺗﺳﺎوي 3=‪ b‬ﻟذاﻟك ﻧﻔذ اﻟﺧطوة ٧‬
                                  ‫‪(a==b)(3==3)True‬‬
                                                 ‫*** وﺑﻘﯾﺔ اﻟﺧطوات ﻟم ﺗﻧﻔذ ﻷﻧﮭﺎ ﻟم ﺗﺗﺣﻘق ﺷروطﮭﺎ‬            ‫ﻣﮭم‬




      ‫ﻛﻣﺎ ﻻﺣظت ﻓﻲ اﻟﻣﺛﺎل ﻟم ﻧﺿﻊ أﻗواس ﻟﻸﺳطر اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺗﺗﺑﻊ ﻛل ﻋﺑﺎرة ‪ if‬ﻻن ﻛل ﻋﺑﺎرة‬
           ‫ﻟم ﯾﺗﺑﻌﮭﺎ أﻛﺛر ﻣن ﺳطر ﺑرﻣﺟﻲ واﺣد وﻛﻣﺎ ﻗﻠﻧﺎ ﺳﺎﺑﻘﺎ إذا ﻛﺎﻧت ﻋﺑﺎرة اﻟﺷرط ﯾﺗﺑﻌﮭﺎ ﺳطر‬
                            ‫ﺑرﻣﺟﻲ واﺣد ﻻ ﺣﺎﺟﺔ ﻟوﺿﻊ أﻗواس وإذا أﻛﺛر ﻣن ﺳطر ﻧﺿﻊ أﻗواس‬

   ‫ﻣﺛﺎل٢: ﺑرﻧﺎﻣﺞ ﻧدﺧل رﻗم وﯾطﺑﻊ رﺳﺎﻟﺔ إذا ﻛﺎن اﻟرﻗم ﺑﯾن) ٥—٠٠١ ( إذا ﻛﺎن اﻟرﻗم ﺿﻣن ھذه اﻟﻔﺗرة وإذا ﺧﺎرج‬
                                                                                ‫اﻟﻔﺗرة ﻻ ﻧطﺑﻊ أي ﺷﻲء .؟‬

                                                                                                       ‫ﺗﺣﻠﯾل:‬

‫١.ﻟدﯾﻧﺎ رﻗم ﻧدﺧﻠﮫ ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻟذاﻟك ﻧﺣن ﺑﺣﺎﺟﺔ ﺗﻌرﯾف ﻣﺗﻐﯾر ﯾﺧص اﻟرﻗم وداﻟﺔ ﻹدﺧﺎﻟﮫ ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وﻟﯾﻛن‬
                                                                                       ‫اﺳم اﻟﻣﺗﻐﯾر ھو )‪(a‬‬

     ‫٢.ﻟدﯾﻧﺎ ﺷرط أن ﯾﻘﻊ ﺿﻣن ﻓﺗرة)٥—٠٠١( ﻓﻲ ﻣﺛل ھذه اﻷﺳﺋﻠﺔ ﻧﺣن ﺑﺣﺎﺟﺔ إﻟﻰ دﻣﺞ أﻛﺛر ﻣن ﺷرط ﻓﻲ ﻋﺑﺎرة‬
                              ‫ﺷرطﯾﺔ واﺣد ﻛﺄن ﻧﻘول ﻟﮫ ﻓﻲ اﻟﺷرط أن ﯾﻛون اﻟرﻗم ﺧﻣﺳﺔ و واﺻﻐر ﻣن ﻣﺋﺔ‬

                                                                             ‫ﺷرط اﻛﺑر ﻣن ﺧﻣﺳﺔ ﺑﺳﯾط وھو‬

                                                                                               ‫اﻟﻛود‬
       ‫) 5 > ‪If ( a‬‬
                                                                  ‫وﺷرط اﺻﻐر ﻣن ﻣﺋﺔ أﯾﺿﺎ ﺑﺳﯾط وھو‬

                                                                                               ‫اﻟﻛود‬
       ‫) 001 < ‪If ( a‬‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                         ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




  ‫ﻟﻛن ﻓﻲ اﻟﺳؤال ﯾﻘول ﺿﻣن اﻟﻔﺗرة وﻟﯾس اﻛﺑر ﻣن ﺧﻣﺳﺔ ﻋﻠﻰ ﺣدة واﺻﻐر ﻣن ﻣﺋﺔ ﻋﻠﻰ ﺣدة إذن ﻛﯾف ﻧدﻣﺞ ھﺎذان‬
    ‫اﻟﺷرطﺎن.؟ ﺑﻣﺎ اﻧﮫ ﻗﺎل اﻛﺑر ﻣن ﺧﻣﺳﺔ واﺻﻐر ﻣن ﻣﺋﺔ واﺳﺗﺧدم ﻋﺑﺎرة )و( ﻣﻌﻧﺎ ﺗوﺟد ﻋﻣﻠﯾﺔ )‪ (and‬ﺑﯾن ھذان‬
                                     ‫اﻟﺷرطﺎن أي ﻻ ﺗﻧﻔذ ھذه اﻟﺟﻣﻠﺔ اﻟﺷرطﯾﺔ إﻻ ﺑﺗﺣﻘق ھذان اﻟﺷرطﺎن ھﻛذا‬

                                                                                                            ‫اﻟﻛود‬
       ‫) )001<‪If ( ( a>5 )&&(a‬‬                                                                                           ‫ﻣﮭم‬
‫*وراﺟﻊ ﺟدول )‪ (and‬ﻟﻔﮭم اﻟﻔﻛرة أﻛﺛر ﻷﻧﮫ ﻟو ﻗﻠﻧﺎ ﻋﻣﻠﯾﺔ ‪ OR‬ﺑﯾن اﻟﺷرطﯾﯾن ﻟﻛﺎن ھﻧﺎك اﺧﺗﻼف ﻛﺑﯾر ﻓﻲ اﻟﺣل أي‬
 ‫ﻟو ﺗﺣﻘق اﺣد اﻟﺷرطﺎن ﻓﻲ ﺟﻣﻠﺔ ‪ OR‬ﺗﻧﻔذ ﻋﺑﺎرة ‪ if‬إﻣﺎ ‪ and‬اﻟﺟﻣﻠﺔ ﻻ ﺗﻧﻔذ إﻻ ﺑﺗﺣﻘق اﻟﺷرطﯾﯾن. ﻟﯾﺻﺑﺢ اﻟﺣل ھﻛذا‬

‫++‪c‬‬                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
‫>‪#include<iostream.h‬‬                                     ‫>‪#include<stdio.h‬‬
‫)(‪main‬‬                                                   ‫)(‪main‬‬
‫;‪1.{int a‬‬                                                ‫;‪1.{int a‬‬
‫;‪2.cin>>a‬‬                                                ‫;)‪2.scanf("%d",&a‬‬
‫) )001<‪3.if ( ( a>5 )&&(a‬‬                                ‫) )001<‪3.if ( ( a>5 )&&(a‬‬
‫;"‪4.cout<<"the number in this range‬‬                      ‫;)"‪4.printf("the number in this range‬‬
‫}‬                                                        ‫}‬

                                                                                                   ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬

                                 ‫ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ﻣن ﻧوع ‪ integer‬ﻟﻛﻲ ﻧﺣﻣﻠﮫ ﺑﺎﻟﻘﯾﻣﺔ اﻟﻣدﺧﻠﺔ‬                  ‫١.‬
                                                   ‫ﺧطوة رﻗم )٢( ھﻲ إدﺧﺎل ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر ﻣن ﻗﺑل اﻟﻣﺳﺗﺧدم‬               ‫٢.‬
                                                              ‫ﺧطوة رﻗم )٣( ھو ﻋﻣﻠﯾﺔ اﻟﺗﺣﻘق ﻣن اﻟﺷرط‬                 ‫٣.‬
                                             ‫ﻓﻠو ادﺧل اﻟﻣﺳﺗﺧدم اﻟرﻗم ) 05( ﻓﺗﻛون اﻟﻣﻘﺎرﻧﺔ ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬               ‫‪‬‬

                                                 ‫05=‪a‬‬              ‫ﺗوﺿﯾﺢ ﺗﻧﻔﯾذ اﻟﺷرط داﺧل اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ إذا ﻛﺎن‬
                                             ‫)001<‪( a>5 )&&(a‬‬
                            ‫إذا ﻛﺎن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )05=‪ (a‬ﻓﯾﻛون اﻟﺷرط ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
                                           ‫)001<05(&&) 5>05 (‬

                           ‫أوﻻ ﺳﯾﻧﻔذ اﻟﻌﻣﻠﯾﺎت ﻣﺎﺑﯾن اﻷﻗواس أو ﻋﻣﻠﯾﺔ ھل ٠٥ اﻛﺑر‬
                                  ‫ﻣن ٥ ﻧﻌم ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ﺗﻛون واﺣد )١(‬
       ‫.1‬
                                               ‫)001<05(&& 1‬

                                ‫ﺛم ﯾﻧﻔذ ﻋﻣﻠﯾﺔ اﻷﺻﻐر ھل أن ٠٥ اﺻﻐر ﻣن ٠٠١‬
                                    ‫ﻧﻌم ﻟذاﻟك اﻟﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ھﻲ واﺣد‬
       ‫.2‬
                                             ‫1=1 && 1‬
                    ‫ﻋﻣﻠﯾﺔ ‪ and‬ﺑﯾن واﺣد وواﺣد اﻟﻧﺗﯾﺟﺔ واﺣد إي )‪ (True‬إي ﯾﺗﺣﻘق اﻟﺷرط‬



‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                       ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                                               ‫‪ ‬ﻓﻠو ادﺧل اﻟﻣﺳﺗﺧدم اﻟرﻗم )٠٥١( ﻓﺗﻛون اﻟﻣﻘﺎرﻧﺔ ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                  ‫051=‪a‬‬           ‫ﺗوﺿﯾﺢ ﺗﻧﻔﯾذ اﻟﺷرط داﺧل اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ إذا ﻛﺎن‬
                                                ‫)001<‪( a>5 )&&(a‬‬

                           ‫إذا ﻛﺎن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )051=‪ (a‬ﻓﯾﻛون اﻟﺷرط ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
                                          ‫)001<051(&&) 5>051 (‬

                          ‫أوﻻ ﺳﯾﻧﻔذ اﻟﻌﻣﻠﯾﺎت ﻣﺎﺑﯾن اﻷﻗواس أو ﻋﻣﻠﯾﺔ ھل ٠٥١ اﻛﺑر‬
                                 ‫ﻣن ٥ ﻧﻌم ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ﺗﻛون واﺣد )١(‬
       ‫.1‬
                                                 ‫)001<051(&& 1‬

                               ‫ﺛم ﯾﻧﻔذ ﻋﻣﻠﯾﺔ اﻷﺻﻐر ھل أن ٠٥١ اﺻﻐر ﻣن ٠٠١‬
                                    ‫ﻛﻼ ﻟذاﻟك اﻟﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ھﻲ ﺻﻔر‬
       ‫.2‬
                                             ‫0=0 && 1‬
                   ‫ﻋﻣﻠﯾﺔ ‪ and‬ﺑﯾن واﺣد وﺻﻔر اﻟﻧﺗﯾﺟﺔ ﺻﻔر إي )‪ (False‬إي ﻻ ﯾﺗﺣﻘق اﻟﺷرط‬


    ‫ﻣﺛﺎل٣:اﻟﺷرط اﻟﻣطﻠوب ھوا أن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (c‬ﯾﺟب أن ﺗﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﺛﻼﺛﺔ وﻋﻠﻰ ﺳﺗﺔ أو ﺗﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ‬
                                                                                    ‫ﺗﺳﻌﺔ ﻟﯾﺣﻘق اﻟﺷرط .؟‬

‫اﻟﺗﺣﻠﯾل.اﻟﺷرطﺎن اﻷوﻻن أن ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ)٣ و ٦( إي ﻧﺎﺗﺞ ﺑﺎﻗﻲ ﻗﺳﻣﺗﮭﻣﺎ ھو ﺻﻔر واﻟﻰ ﺟﺎﻧب ھذان اﻟﺷرطﺎن أن‬
   ‫ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﺗﺳﻌﺔ إي إﻣﺎ ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ )٣ و٦( أو ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ ٩ إي ﯾوﺟد ﺑﯾن ﺷرطﺎ ﺗﺣﻘق ﻗﺑول‬
  ‫اﻟﻘﺳﻣﺔ ﻋﻠﻰ )٣ و٦( ﻋﻣﻠﯾﺔ ‪ and‬ﻷﻧﮫ واﺟب ﺗﺣﻘﻘﮭﻣﺎ ﻣﻌﺎ وﻧﺎﺟﺗﮭﻣﺎ داﺧل ﻋﻠﻰ ﻋﻣﻠﯾﺔ ‪ OR‬ﻣﻊ ﺷرط ﻗﺑول اﻟﻘﺳﻣﺔ‬
                                                                                              ‫ﻋﻠﻰ ٩‬

                                                                                                           ‫اﻟﻛود‬
       ‫) )0==9 %‪If ( ( ( c%3==0 )&&(c%6==0) ) || (c‬‬
                                                                                                                       ‫ﻣﮭم‬



 ‫*إذا ﻟم ﻧﺿﻊ أﻗواس ﺣول اﻟﻌﻣﻠﯾﺎت اﻟﻣطﻠوب ﺗﺣﻘﻘﮭﻣﺎ ﻣﻌﺎ ﻗد ﻻ ﯾﺣﻘق اﻟﻣطﻠوب ﻷﻧﮫ ﺗﺣﻛﻣﮫ اﻷﺳﺑﻘﯾﺔ اﻟﺷرط اﻟذي‬
                                                                              ‫ﻟﮫ أﺳﺑﻘﯾﺔ أﻋﻠﻰ ﯾﻧﻔذ أوﻻ‬



   ‫ﻟو ﻋدﻧﺎ إﻟﻰ ﻧﻔس اﻟﺷرط اﻟﺳﺎﺑق وﻓرﺿﻧﺎ أن ﺑﯾن ﺷرط ﻗﺑول اﻟﻘﺳﻣﺔ ﻋﻠﻰ )٣ و٦ ( ﯾوﺟد ﻋﻣﻠﯾﺔ ‪ OR‬وﻟﯾس‬
   ‫ﻋﻣﻠﯾﺔ ‪ AND‬وواﺟب ﺗﺣﻘق اﺣدھﻣﺎ واﻟﻧﺎﺗﺞ ﻟﮭﻣﺎ ﯾدﺧل ﻋﻠﻰ ‪ AND‬ﻣﻊ ﺷرط ﺗﺣﻘق اﻟﻘﺑول اﻟﻘﺳﻣﺔ ﻋﻠﻰ ٩‬
                             ‫وﻟﯾس ‪) OR‬وﻟم ﻧﺿﻊ أﻗواس ﺣول ﺷرطﯾﯾن ﺗﺣﻘق ﻗﺑول اﻟﻘﺳﻣﺔ ﻋﻠﻰ ٣ أو ٦ (‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                      ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                          ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                                                                                     ‫اﻧظر ﻣﺎذا ﺳﯾﻧﺗﺞ‬

                                                                                              ‫اﻟﻛود‬
       ‫( ‪If‬‬                ‫0==6%‪(c‬‬
               ‫) )0==9 %‪( c%3==0 )||(c%6==0 ) && (c‬‬


 ‫ﻓﺎﻟذي ﯾﻧﺗﺞ ﺳوف ﺗﺣدث ﻋﻣﻠﯾﺔ ‪ AND‬ﻗﺑل ﻋﻣﻠﯾﺔ ‪ OR‬ﻻن أﺳﺑﻘﯾﺗﮭﺎ أﻋﻠﻰ ﻣﻧﮫ وﯾﺻﺑﺢ اﻟﺳؤال ﻛﺄﻧﻧﺎ ﻧﻘول ﯾﺟب‬
   ‫أن ﯾﺗﺣﻘق ﻗﺑول اﻟﻘﺳﻣﺔ ﻋﻠﻰ ٩ ﻣﻊ ﻗﺑول اﻟﻘﺳﻣﺔ ﻋﻠﻰ ٦ ﻣﻌﺎ وﻧﺎﺟﺗﮭﻣﺎ داﺧل ﻋﻠﻰ ﻋﻣﻠﯾﺔ ‪ OR‬ﻣﻊ ﺷرط ﻗﺑول‬
     ‫اﻟﻘﺳﻣﺔ ﻋﻠﻰ ٣ وﯾﻘﻠب ﺣل اﻟﺳؤال وﯾﻛون اﻟﺟواب ﺧﺎطﺋﺎ ﻟذاﻟك ﺗﺟﻧب ﻟﻣﺛل ھذه اﻟﻣﺷﺎﻛل ﺿﻊ أﻗواس ﺣول‬
                                ‫اﻟﺷروط اﻟﺗﻲ ﯾﺟب ﺗﺣﻘﻘﮭﺎ ﻣﻌﺎ ﻟﺗﺟﻧب ﻣﺷﺎﻛل اﻷﺳﺑﻘﯾﺎت ﻛﻣﺎ ﻓﻲ اﻟﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                                              ‫اﻟﻛود‬
                          ‫0==6%‪(c‬‬
       ‫) )0==9 %‪If ( ( ( c%3==0 )||(c%6==0 ) ) && (c‬‬




                                                                                                        ‫ﻣﮭم‬


                        ‫ﻟﻣﺎذا ﻧﺳﺗﺧدم ﺑﯾن أﻛﺛر ﻣن ﺷرط ‪ and‬أو ‪ OR‬ﻟﻣﺎذا ﻻ ﻧﺟﻣﻊ أﻛﺛر ﻣن ﺷرط ﻣﻌﺎ؟‬

                               ‫اﻹﺟﺎﺑﺔ : ﺷﺎھد اﻟﻣﺛﺎل اﻟﺗﺎﻟﻲ اﻟذي ﻧﺳﺗﺧدم ﻓﯾﮫ أﻛﺛر ﻣن ﺷرط ﺑدون ) ‪ and‬أو ‪( OR‬‬

                                                                                              ‫اﻟﻛود‬
       ‫;6=‪int a‬‬
       ‫)3>‪if ( 5<a‬‬




‫ﻓﺎﻟذي ﺳوف ﯾﺣدث ﻛﻣﺎ ﺗﺷﺎھد ﻓﻲ اﻟﻣﺧطط اﻧﮫ ﺳﯾﻘﺎرن ﻗﯾﻣﺔ )‪ ( a‬ﻣﻊ )٥( ووﺟد اﻧﮫ ﻗﯾﻣﺗﮫ اﻛﺑر )‪ (5<a=True‬ﺛم‬
  ‫ﺳﯾﻘﺎرن ﻧﺗﯾﺟﺔ ﻣﻘﺎرﻧﺔ وھﻲ )‪ (True‬ﻣﻊ ﻗﯾﻣﺔ ) ٣ ( وﺑرﻣﺟﯾﺎ ﻗﯾﻣﺔ )0=‪ (True=1,False‬إي ﺳﯾﻘﺎرن ﻗﯾﻣﺔ ) ١(‬
                     ‫ﻣﻊ ) ٣( ووﺟد اﻧﮫ ﻗﯾﻣﺔ واﺣد اﻗل )‪ (1>3=False‬وأﺻﺑﺣت اﻟﻧﺗﯾﺟﺔ ﺧﺎطﺋﺔ وﻟﯾﺳت ﺻﺎﺋﺑﺔ‬

   ‫ورﻏم أﻧﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (a‬ھو اﻛﺑر ﻣن ) ٣( واﻛﺑر ﻣن )٥ ( ﻟﻛن ﻓﻲ اﻟﺑرﻣﺟﺔ ﻋﻧد ﻣﻘﺎرﻧﺔ ﻣﺗﻐﯾرﯾن أو ﻗﯾﻣﺗﯾن‬
 ‫ﯾﻌطﯾك ﻧﺗﯾﺟﺔ ﻣﻘﺎرﻧﺔ وﻧﺗﺎﺋﺞ اﻟﻣﻘﺎرﻧﺔ إﻣﺎ ﺗﻛون )‪ True‬أو ‪ ( False‬وﻋﻧد ﻣﻘﺎرﻧﺔ ﻧﺗﯾﺟﺔ ﻣﻘﺎرﻧﺔ ﻣﻊ ﻋدد ﺗﻛون ﻧﺗﺎﺋﺞ‬
                                                                                             ‫ﻏﯾر ﺻﺣﯾﺣﺔ‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                                                            ‫وھذا ﺗوﺿﯾﺢ ﻟﻣﺎ ﺳﯾﺟري ﻣن ﻋﻣﻠﯾﺎت ﻣﻊ ھذا اﻟﺷرط‬

                                                                                        ‫ﺗوﺿﯾﺢ ﺗﻧﻔﯾذ اﻟﺷرط‬
                                                 ‫3 > ‪5<a‬‬
                            ‫إذا ﻛﺎن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )6=‪ (a‬ﻓﯾﻛون اﻟﺷرط ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
                                                ‫3 > 6 <5‬

                      ‫ﺑﻣﺎ أن اﻷﺳﺑﻘﯾﺎت ﻣﺗﺳﺎوﯾﺔ ﺳﯾﺑدأ ﺑﺗﻧﻔﯾذ اﻟﻌﻣﻠﯾﺎت ﻣن اﻟﯾﺳﺎر إﻟﻰ اﻟﯾﻣﯾن‬
                       ‫ﻓﯾﻘﺎرن ھل ٦ اﻛﺑر ﻣن ٥ ﻧﻌم ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ھﻲ)‪ (True‬أي واﺣد‬
       ‫.1‬
                                                    ‫3> 1‬

            ‫ﺳﯾﺗﺣﻘق ﻣن اﻟﺷرط اﻟﺗﺎﻟﻲ ھل اﻟواﺣد اﻛﺑر ﻣن ﺛﻼﺛﺔ ﻛﻼ ﻓﺗﻛون ﻧﺗﯾﺟﺔ ھﻲ )‪ (false‬إي ﺻﻔر‬
         ‫.2‬                                   ‫0=3>1‬


‫ﻟذاﻟك ﻓﺎﻟﺣل اﻟﺻﺣﯾﺢ ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد ﺗﺣﻘق اﻟﺷرطﺎن ﻣﻌﺎ ﻧﺳﺗﺧدم ﺑﯾﻧﮭم ﻋﻣﻠﯾﺔ ‪ and‬ﻛﺄن ﻧﻘول ﯾﺟب أن ﺗﻛون ﻗﯾﻣﺔ ) ‪(a‬‬
                                                                          ‫اﻛﺑر ﻣن ) ٣( واﻛﺑر ﻣن )٥ (.‬

                                                                                                    ‫اﻟﻛود‬
       ‫;6=‪int a‬‬
       ‫) )3>‪if ( ( 5<a) && (a‬‬


                                               ‫ﻟو رﺳﻣﻧﺎ اﻟﻣﺧطط اﻟﺗوﺿﯾﺣﻲ ﻟﻠﻣﺛﺎل ﺑﻌد اﻟﺗﻌدﯾل ﯾﻛون ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                                        ‫ﺗوﺿﯾﺢ ﺗﻧﻔﯾذ اﻟﺷرط‬
                                            ‫)3>‪( 5<a) && (a‬‬
                            ‫إذا ﻛﺎن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )6=‪ (a‬ﻓﯾﻛون اﻟﺷرط ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
                                            ‫)3>6( && )6<5 (‬

                        ‫ﺳﯾﺑدأ أوﻻ ﺑﺗﻧﻔﯾذ ﻣﺎ ﺑﯾن اﻷﻗواس ﺑﻣﺎ أن اﻷﺳﺑﻘﯾﺎت ﻣﺗﺳﺎوﯾﺔ ﺳﯾﺑدأ‬
                       ‫ﺑﺗﻧﻔﯾذ اﻟﻌﻣﻠﯾﺎت ﻣن اﻟﯾﺳﺎر إﻟﻰ اﻟﯾﻣﯾن ﻓﯾﻘﺎرن ھل ٦ اﻛﺑر ﻣن ٥ ﻧﻌم‬
                                     ‫ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ھﻲ)‪ (True‬أي واﺣد‬
       ‫.1‬
                                                ‫)3>6( && 1‬

                       ‫ﺳﯾﺗﺣﻘق ﻣن اﻟﺷرط اﻟﺗﺎﻟﻲ ھل اﻟﺳﺗﺔ اﻛﺑر ﻣن ﺛﻼﺛﺔ ﻛﻼ ﻓﺗﻛون ﻧﺗﯾﺟﺔ‬
                                           ‫ھﻲ)‪ (True‬أي واﺣد‬
         ‫.2‬                                      ‫1=1 && 1‬
                        ‫ﻋﻣﻠﯾﺔ )‪ (and‬ﺑﯾن واﺣد و واﺣد ھﻲ واﺣد ﻓﺎﻟﻧﺗﯾﺟﺔ ھﻲ )‪(True‬‬


‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                               ‫ﻣﺛﺎل٤:ﺑﯾن ﺑﻌد ﺗﺗﺑﻊ ھذا اﻟﺑرﻧﺎﻣﺞ ﻣﺎ ھﻲ ﻗﯾم )‪ ( a ,b‬اﻟﺗﻲ ﺳﺗطﺑﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ .؟‬

‫++‪c‬‬                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                            ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
‫>‪#include<iostream.h‬‬                                      ‫>‪#include<stdio.h‬‬
‫)(‪main‬‬                                                    ‫)(‪main‬‬
‫{‬                                                         ‫{‬
‫;5=‪1.int a‬‬                                                ‫;5=‪1.int a‬‬
‫;7=‪2.int b‬‬                                                ‫;7=‪2.int b‬‬
‫) 1==2% ‪If ( b‬‬                                            ‫) 1==2% ‪If ( b‬‬
‫{‬                                                         ‫{‬
‫;6+‪3.a=a‬‬                                                  ‫;6+‪3.a=a‬‬
‫4+‪4.b=b‬‬                                                   ‫4+‪4.b=b‬‬
‫}‬                                                         ‫}‬
‫;3+‪5.a=a‬‬                                                  ‫;3+‪5.a=a‬‬
‫2+‪6.b=b‬‬                                                   ‫2+‪6.b=b‬‬
‫};‪7.cout<<"a="<<a<<"\t b="<<b‬‬                             ‫};)‪7.prin ("a=%d \t b=%d",a, b‬‬



                                                                                           ‫ﺗﺗﺑﻊ ﺧطوات اﻟﺑرﻧﺎﻣﺞ:‬

                                                                         ‫١. ﺧطوة رﻗم )١( أﺻﺑﺢ ﻗﯾﻣﺔ )5=‪(a‬‬
‫٢. ﺧطوة رﻗم )٢( أﺻﺑﺢ ﻗﯾﻣﺔ )7=‪ (b‬وﻗﯾﻣﺔ )‪ (a‬ﺑﻘت ﺛﺎﺑﺗﺔ ﻟم ﺗﺗﻐﯾر ﻣﺣﺗﻔظﺔ ﺑﻘﯾﻣﺗﮭﺎ ﻓﻲ اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ )5=‪(a‬‬

‫٣. ﻗﺑل ﺧطوة رﻗم )٣( ﯾوﺟد ﺷرط ﻟﺗﻧﻔﯾذ ﻣﺎﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ وھو أن ﯾﻛون ﺑﺎﻗﻲ ﻗﺳﻣﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪b‬‬
   ‫ﻋﻠﻰ )٢( ﺗﺳﺎوي واﺣد أن ﯾﻛون رﻗم ﻓردي وﻓﻌﻼ ﺑﺎﻗﻲ ﻗﺳﻣﺗﮫ )٧( ﻋﻠﻰ )٢( ھو واﺣد ﻟذاﻟك ﺳﯾﻧﻔذ اﻟﺧطوة‬
                                                                    ‫رﻗم )٣و٤( وﺗﻛون اﻟﻣﻘﺎرﻧﺔ ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬
                               ‫‪(b%2==1)(7%2==1) (1==1)True‬‬

‫‪ ‬ﻓﻲ اﻟﺧطوة رﻗم )٣( أﺻﺑﺢ ﻗﯾﻣﺔ )‪ (a‬ھﻲ )11=6+5=‪ ( a‬وﻗﯾﻣﺔ )‪ (b‬ﺑﻘت ﺛﺎﺑﺗﺔ ﻟم ﺗﺗﻐﯾر )7=‪(b‬‬
    ‫‪ ‬ﺧطوة رﻗم )٤( أﺻﺑﺢ ﻗﯾﻣﺔ )‪ (b‬ھﻲ )11=4+7=‪ ( b‬وﻗﯾﻣﺔ )‪ (a‬ﺑﻘت ﺛﺎﺑﺗﺔ ﻟم ﺗﺗﻐﯾر )11=‪(a‬‬
          ‫٤. ﺧطوة رﻗم )٥( أﺻﺑﺢ ﻗﯾﻣﺔ )‪ (a‬ھﻲ )41=3+11=‪ ( a‬وﻗﯾﻣﺔ )‪ (b‬ﺑﻘت ﺛﺎﺑﺗﺔ ﻟم ﺗﺗﻐﯾر )11=‪(b‬‬
           ‫٥. ﺧطوة رﻗم )٦( أﺻﺑﺢ ﻗﯾﻣﺔ )‪ (b‬ھﻲ )31=2+11=‪ ( b‬وﻗﯾﻣﺔ )‪ (a‬ﺑﻘت ﺛﺎﺑﺗﺔ ﻟم ﺗﺗﻐﯾر )41=‪(a‬‬


        ‫واﻟﻧﺗﯾﺟﺔ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھﻲ‬
        ‫41=‪a‬‬      ‫31=‪b‬‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                          ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




‫ﻣﺛﺎل٥:ﻧﻔس اﻟﻣﺛﺎل اﻟﺳﺎﺑق ﻓﻘط ﻏﯾر ﻗﯾﻣﺔ ) ‪ ( b‬ﻓﻲ اﻟﺧطوة )٢( إﻟﻰ رﻗم )٤( إي )4=‪ (b‬وﻟﻧﺗﺗﺑﻊ اﻟﺑرﻧﺎﻣﺞ اﻟﺟدﯾد ؟‬

 ‫++‪c‬‬                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                    ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                  ‫)(‪main‬‬
 ‫{‬                                                       ‫{‬
 ‫;5=‪1.int a‬‬                                              ‫;5=‪1.int a‬‬
 ‫;4=‪2.int b‬‬                                              ‫;4=‪2.int b‬‬
 ‫) 1==2% ‪If ( b‬‬                                          ‫) 1==2% ‪If ( b‬‬
 ‫{‬                                                       ‫{‬
 ‫;6+‪3.a=a‬‬                                                ‫;6+‪3.a=a‬‬
 ‫4+‪4.b=b‬‬                                                 ‫4+‪4.b=b‬‬
 ‫}‬                                                       ‫}‬
 ‫;3+‪5.a=a‬‬                                                ‫;3+‪5.a=a‬‬
 ‫2+‪6.b=b‬‬                                                 ‫2+‪6.b=b‬‬
 ‫};‪7.cout<<"a="<<a<<"\t b="<<b‬‬                           ‫};)‪7.prin ("a=%d \t b=%d",a, b‬‬



                                                                    ‫١. ﺧطوة رﻗم )١( أﺻﺑﺢ ﻗﯾﻣﺔ )5=‪(a‬‬
      ‫٢. ﺧطوة رﻗم )٢( أﺻﺑﺢ ﻗﯾﻣﺔ )4=‪ (b‬وﻗﯾﻣﺔ )‪ (a‬ﺑﻘت ﺛﺎﺑﺗﺔ ﻟم ﺗﺗﻐﯾر ﻣﺣﺗﻔظﺔ ﺑﻘﯾﻣﺗﮭﺎ ﻓﻲ اﻟﺧطوة اﻟﺳﺎﺑﻘﺔ‬         ‫ﻣﮭم‬
                                                                                           ‫)5=‪(a‬‬
  ‫٣. ﻗﺑل اﻟﺧطوة رﻗم )٣( ﯾوﺟد ﺷرط ﻟﺗﻧﻔﯾذ ﻣﺎﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ وھو أن ﯾﻛون ﺑﺎﻗﻲ ﻗﺳﻣﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر‬
‫‪ b‬ﻋﻠﻰ )٢( ﺗﺳﺎوي واﺣد أن ﯾﻛون رﻗم ﻓردي وان ﺑﺎﻗﻲ ﻗﺳﻣﺗﮫ ﻋﻠﻰ )٢( ھو ﺻﻔر ﻟذاﻟك ﺳوف ﻻ ﯾﻧﻔذ اﻟﺧطوة‬
                                     ‫رﻗم )٣و٤( وﯾﻧﺗﻘل إﻟﻰ ﺧطوة رﻗم )٥( وﺗﻛون اﻟﻣﻘﺎرﻧﺔ ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

                               ‫‪(b%2==1)(4%2==1) (0==1)False‬‬

             ‫٤. ﺧطوة رﻗم )٥( أﺻﺑﺢ ﻗﯾﻣﺔ )‪ (a‬ھﻲ )8=3+5=‪ ( a‬وﻗﯾﻣﺔ )‪ (b‬ﺑﻘت ﺛﺎﺑﺗﺔ ﻟم ﺗﺗﻐﯾر )4=‪(b‬‬
              ‫٥. ﺧطوة رﻗم )٦( أﺻﺑﺢ ﻗﯾﻣﺔ )‪ (b‬ھﻲ )6=2+4=‪ ( b‬وﻗﯾﻣﺔ )‪ (a‬ﺑﻘت ﺛﺎﺑﺗﺔ ﻟم ﺗﺗﻐﯾر )8=‪(a‬‬

      ‫واﻟﻧﺗﯾﺟﺔ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھﻲ‬
      ‫8=‪a‬‬      ‫6=‪b‬‬                                                                                       ‫ﻣﮭم‬


    ‫ﻓﻲ ﻟﻐﺔ )++‪ (C‬ﺗﻣﻛﻧك ﻣن ﺗﻌرﯾف ﻣﺗﻐﯾرات أﯾﻧﻣﺎ ﺗﺷﺎء ﻓﻲ اﻟﺑرﻧﺎﻣﺞ ﻓﻠو ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ‬
                             ‫ﯾﻛون ﻏﯾر ﻣﻌرف ﺑﺎﻟﻧﺳﺑﺔ ﻟﻣن ھم ﺧﺎرج ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ ﻓﻘط ﻣﻌرف ﺑﺎﻟداﺧل‬

                                                                                              ‫اﻟﻛود‬
       ‫)3>‪If ( True‬‬
         ‫};5=‪{int x‬‬
          ‫// ;3=‪x‬‬   ‫ﺳوف ﯾﻌﺗرض اﻟﻣﺗرﺟم ﻋﻠﻰ ھذا اﻟﺳطر وﯾﻌﺗﺑر )‪ (x‬ﻏﯾر ﻣﻌرف‬
                                             ‫إي أن اﻟﻣﺗﻐﯾر ﻧﻧﺗﮭﻲ ﺣﯾﺎﺗﮫ ﻋﻧد اﻟﺧروج ﻣن اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                         ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                                                         ‫٢.٢- ﻋﺑﺎرة )‪ (if--else‬اﻟﺷرطﯾﺔ:‬
   ‫ھﻲ ﻋﺑﺎرة ﺷرطﯾﺔ ﻣﻛوﻧﺔ ﻣن ﺟزﺋﯾﯾن ﻣن اﻻﻛواد اﻟﺑرﻣﺟﯾﺔ اﻟذي ﻧرﯾده أن ﯾﻧﻔذ ﺑﺗﺣﻘق ﺷرط )‪ (condition‬ﻧﺿﻌﮫ‬
                   ‫داﺧل ﻗوﺳﻲ )‪ (if‬واﻟذي ﻧرﯾده أن ﯾﻧﻔذ ﻓﻲ ﺣﺎﻟﺔ ﻋدم ﺗﺣﻘق اﻟﺷرط ﻧﺿﻌﮫ ﺑﯾن ﻗوﺳﻲ )‪(else‬‬
                                                                      ‫ﺷﻛل ﻋﺑﺎرة ‪ if --else‬اﻟﺷرطﯾﺔ‬
          ‫) ‪If ( condition‬‬
          ‫{‬
          ‫1‪Statement‬‬
          ‫}‬
          ‫‪else‬‬
          ‫{‬
          ‫2‪Statement‬‬
          ‫}‬

                                     ‫‪ ‬إي ﺑﺗوﺿﯾﺢ أﻛﺛر إذا ﺗﺣﻘق )‪ (condition‬ﯾﻧﻔذ 1‪، Statement‬‬
      ‫وذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط ﺳﯾﻧﻔذ ﺗﻠﻘﺎﺋﯾﺎ‬
                                                                                 ‫2‪Statement‬‬
                 ‫‪ ‬إي إﻣﺎ ﯾﻧﻔذ اﻷﺳطر اﻟﺑرﻣﺟﯾﺔ ﺑﯾن ﻗوﺳﻲ )‪ (If‬أو ﯾﻧﻔذ اﻷﺳطر اﻟﺑرﻣﺟﯾﺔ ﺑﯾن ﻗوﺳﻲ )‪(else‬‬



                                                                          ‫ﻟﻠﺗوﺿﯾﺢ إذا ﻛﺎن اﻟﺷرط ھو‬
                                                                      ‫ﺷﻛل ﻋﺑﺎرة ‪ if --else‬اﻟﺷرطﯾﺔ‬
          ‫) 0==2%‪If ( input_Numner‬‬
          ‫{‬
          ‫1‪Statement‬‬
          ‫}‬
          ‫‪else‬‬
          ‫{‬
          ‫2‪Statement‬‬
          ‫}‬

‫وﻣن اﻟﺷرط اﻟﻣوﺟود )) 0==2%‪ (If ( input_Numner‬إي ﻣﺗﻰ ﻣﺎ ﻛﺎن )‪ (input_Numner‬ﺑﺎﻗﻲ ﻗﺳﻣﺗﮫ ﻋﻠﻰ )٢(‬
                                                                ‫ھو ﺻﻔر ﺳوف ﯾﻧﻔذ 1‪Statement‬‬

      ‫وﺧﻼﻓﮫ إي إذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط إي إذا ﻛﺎن )‪ (input_Numner‬ﺑﺎﻗﻲ ﻗﺳﻣﺗﮫ ﻋﻠﻰ )٢( ﻻ ﯾﺳﺎوي ﺻﻔر ﺳوف‬
                                                                            ‫ﯾﻧﻔذ 2‪Statement‬‬

       ‫‪ (Statement2 ،Statement1 ) ‬ﻗد ﺗﻛون ﺳطر ﺑرﻣﺟﻲ واﺣد أو أﻛﺛر ﻣن ﺳطر ﻓﺗوﺿﻊ ﺑﯾن ﻗوﺳﯾن‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                         ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




    ‫ﻣﺛﺎل ﺗوﺿﯾﺣﻲ ﻋن ﺧطوات ﺳﯾر اﻟﺑرﻧﺎﻣﺞ ﻓﻲ وﺟود ﻋﺑﺎرة ﺷرطﯾﺔ )‪. (if—else‬وھو ﺑرﻧﺎﻣﺞ ﺗدﺧل رﻗم ﻣن ﺷﺎﺷﺔ‬
                           ‫اﻟﺗﻧﻔﯾذ وﯾﺑﯾن ﻟك ھل اﻟرﻗم ﻣوﺟب أم ﺳﺎﻟب )إي ھل ھوا اﻛﺑر ﻣن اﻟﺻﻔر أو اﺻﻐر ﻣﻧﮫ(‬

‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
‫)(‪main‬‬                                                     ‫)(‪main‬‬
‫;‪{1.int a‬‬                                                  ‫;‪{1.int a‬‬
‫; ‪2cin>>a‬‬                                                  ‫;)‪2.scanf("%d",&a‬‬
‫) 0>‪If ( a‬‬                                                 ‫) 0>‪If ( a‬‬
‫;)"‪3. prin ("is greater than 1 is posi ve‬‬                  ‫;)" ‪3. prin (" is greater than 1 is posi ve‬‬
‫‪else‬‬                                                       ‫‪else‬‬
‫;)"‪4. prin ("is less than 1 is nega ve‬‬                     ‫;)" ‪4. prin (" is less than 1 is nega ve‬‬
‫;6+‪5. a=a‬‬                                                  ‫;6+‪5. a=a‬‬
‫}.6‬                                                        ‫}.6‬


                                                                                               ‫ﺗﺗﺑﻊ ﺧطوات اﻟﺑرﻧﺎﻣﺞ:-‬

                                                            ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر )‪ (a‬ﻣن ﻧوع ‪integer‬‬

                                      ‫٢.ﺧطوة رﻗم )٢( ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر )‪ (a‬ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
                                                                                                                         ‫ﻣﮭم‬
                                                                                 ‫٣.أﻻن ﻧﺄﺗﻲ إﻟﻰ ﺷرط اﻟﺗﺣﻘق‬

      ‫‪ ‬إذا ادﺧل اﻟﻣﺳﺗﺧدم إي رﻗم اﻛﺑر ﻣن ﺻﻔر ﺳوف ﯾﺣﻘق ﺷرط )‪ (if‬و ﯾﻧﻔذ اﻟﺳطر )٣( وﯾطﺑﻊ ھذه اﻟرﺳﺎﻟﺔ‬

‫‪is greater than 1 is posi ve‬‬
 ‫‪is greater than 1 is posi ve‬‬
        ‫وﯾطﻔر اﻟﺳطر )٤( )ﻷﻧﮫ ﯾﺗﺣﻘق إذا ﻟم ﯾﻧﻔذ اﻟﺷرط( ﺗم ﯾﻧﻔذ اﻟﺳطر )٥( ﺗم اﻟﺳطر )٦( إي ﯾﻛون ﺗﺳﻠﺳل ﺗﻧﻔﯾذ‬
                                                                                      ‫ﺧطوات اﻟﺑرﻧﺎﻣﺞ اﻟﻛﻠﯾﺔ‬

‫1‬      ‫2‬     ‫3‬           ‫5‬        ‫6‬
      ‫‪ ‬إذا ادﺧل اﻟﻣﺳﺗﺧدم إي رﻗم اﺻﻐر ﻣن ﺻﻔر ﺳوف ﻻ ﯾﺣﻘق ﺷرط )‪ (if‬وﻟذاﻟك ﯾﻧﺗﻘل إﻟﻰ )‪ (else‬و ﯾﻧﻔذ‬
                                                      ‫اﻟﺳطر )٤( وﯾطﺑﻊ ھذه اﻟرﺳﺎﻟﺔ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
 ‫‪is less than 1 is nega ve‬‬
‫‪is less than 1 is nega ve‬‬

                                  ‫ﺗم ﯾﻧﻔذ اﻟﺳطر )٥( ﺗم اﻟﺳطر )٦( إي ﯾﻛون ﺗﺳﻠﺳل ﺗﻧﻔﯾذ ﺧطوات اﻟﺑرﻧﺎﻣﺞ اﻟﻛﻠﯾﺔ‬

‫1‬      ‫2‬            ‫4‬         ‫5‬        ‫6‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                          ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬

                                                                                                            ‫ﻣﮭم‬


                                                          ‫٣.٢- اﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬
     ‫ﺑﻌد أن ﺗﻌرﻓﻧﺎ ﻋن )‪ (if –else‬وﻋﺑﺎرة ) ‪ (if‬اﻟﺷرطﯾﺔ .ﻓﻲ ﺑﻌض اﻟﺑراﻣﺞ ﻗد ﻧﺣﺗﺎج إﻟﻰ اﻟﻧوﻋﺎن ﻣﻌﺎ ﺑﺷﻛل‬
    ‫ﻣﺗداﺧل أو ﻣﻧﻔﺻل ﺣﺳب اﻟﺣﺎﺟﺔ وﯾﺑﻘﻰ ﻟﻛل ﻋﺑﺎرة طرﯾﻘﺗﮭﺎ ﻧﻔﺳﮭﺎ ﻓﻲ اﻟﻣﻌﺎﻟﺟﺔ وﻟﻛﻧﮭﺎ ﺗدﺧل ﺿﻣن ﻋﺑﺎرة أﺧرى‬
 ‫)إي ﻻ ﺗﻧﻔذ إﻻ ﺑﺗﻧﻔﯾذ اﻟﻌﺑﺎرة إﻻم(ﻛﮭذا اﻟﻣﺛﺎل ﺣﯾث وﻗﻌت ﻋﺑﺎرة )‪ (if –else‬ﺿﻣن ﻋﺑﺎرة ) ‪ (if‬ووﺿﻌﻧﺎھﺎ ﺑﯾن‬
                                                              ‫أﻗواس ﻟﻛﻲ ﺗﺑﯾن أﻧﮭﺎ ﺗﺎﺑﻌﺔ إﻟﻰ ) ‪ ( if‬إﻻم.‬

                                                                                              ‫اﻟﻛود‬
         ‫)0 > ‪if (input_Try‬‬
       ‫{‬
       ‫)5 > ‪if (input_Try‬‬
        ‫;"5 ‪1.cout<<"the number is greater than‬‬
       ‫‪else‬‬
        ‫;"5 ‪2.out<<" the number is less than‬‬
       ‫}‬
       ‫.3‬

   ‫‪ ‬وان ﻋﺑﺎرة )‪ (if –else‬ﻻ ﺗﻧﻔذ ﻣطﻠﻘﺎ وﻻ ﯾﻣر ﻋﻠﯾﮭﺎ اﻟﻣﺗرﺟم إﻻ ﺑﺗﺣﻘق ﺷرط اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ إﻻم وھﻲ‬
                           ‫)0 > ‪ if (input_Try‬إي أن ﯾﻛون اﻟرﻗم اﻟﻣدﺧل )‪ (input_Try‬اﻛﺑر ﻣن ﺻﻔر‬
 ‫‪ ‬إذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ﻓﻌﻼ اﻛﺑر ﻣن ﺻﻔر ﺳوف ﯾﻣر ﻋﻠﻰ ﻋﺑﺎرة )‪ (if –else‬اﻟداﺧﻠﯾﺔ وإﻣﺎ ﯾﻧﻔذ اﻟﺧطوة رﻗم‬
                                                                           ‫)١( أو اﻟﺧطوة رﻗم )٢(‬
   ‫‪ ‬وإذا ﻟم ﯾﻛن اﻛﺑر ﻣن ﺻﻔر ﻻ ﯾﻣر أﺻﻼ ﻋﻠﻰ ﻋﺑﺎرة )‪ (if –else‬اﻟداﺧﻠﯾﺔ وﯾﺗﺟﮫ ﻧﺣو اﻟﺧطوة )٣( ﻟﯾﻧﻔذھﺎ‬
‫ﻻن ﻋﺑﺎرة )‪ (if –else‬اﻟداﺧﻠﯾﺔ واﻗﻌﺔ ﺿﻣن ﻋﺑﺎرة اﻟﺷرطﯾﺔ )0 > ‪ if (input_Try‬وﺑﻣﺎ أن ﺷرطﮭﺎ ﻟم ﯾﺗﺣﻘق‬
                                                        ‫ﻟذاﻟك ﺳوف ﻻ ﯾﻧﻔذ ﻣﺎ ھو ﻣوﺟود داﺧل ﻗوﺳﯾﮭﺎ‬

                                                                                                      ‫ﻣﮭم‬

 ‫‪ ‬إذا ﺟﺎء ﻟدﯾﻧﺎ أﻛﺛر ﻣن )‪ (if‬وأﻛﺛر ﻣن ) ‪ ( else‬ﻓﻛﯾف ﻧﻌرف أن ھذه ) ‪ ( if –else‬ﺗﻧﻔﻲ اﻟﻌﺑﺎرة‬
                                                 ‫اﻟﺷرطﯾﺔ )‪ (if‬اﻷوﻟﻰ أم اﻟﺛﺎﻧﯾﺔ أم ﻏﯾرھﻣﺎ..؟‬

                                  ‫ﺑﻛل ﺳﮭوﻟﺔ ﻛل )‪ (else‬ﺗﻧﻔﻲ اﻗرب ﻋﺑﺎرة )‪ (if‬اﻟﺷرطﯾﺔ ﻋﻠﯾﮭﺎ.‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




  ‫ﻣﺛﺎل: ﻣﻘﺎرﻧﺔ ﺑﯾن ﻣﺛﺎﻟﯾﯾن اﺣدھﻣﺎ ﯾﺳﺗﺧدم اﻟﻌﺑﺎرة اﻟﻣﺗداﺧﻠﺔ وأﺧر اﻟﺑواﺑﺎت ﻟﺗﺣﻘق ﺷرط أن ﯾﻛون اﻟرﻗم ﯾﻘﺑل اﻟﻘﺳﻣﺔ‬
           ‫ﻋﻠﻰ ﺛﻼﺛﺔ وﻻ ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﺗﺳﻌﺔ وﺷرط أﺧر أن ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﺛﻼﺛﺔ وﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﺗﺳﻌﺔ .؟‬

        ‫ﺑدون اﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ اﻟﻣﺗداﺧﻠﺔ‬     ‫++‪c‬‬   ‫اﻟﻛود ﺑﻠﻐﺔ‬            ‫ﺑﺎﺳﺗﺧدام اﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ اﻟﻣﺗداﺧﻠﺔ‬     ‫++‪c‬‬    ‫اﻟﻛود ﺑﻠﻐﺔ‬
‫>‪#include<iostream.h‬‬                                           ‫>‪#include<iostream.h‬‬
‫)(‪main‬‬                                                         ‫)(‪main‬‬
‫{‬                                                              ‫{‬
‫;08=‪int Number‬‬                                                 ‫;08=‪int Number‬‬
  ‫))0=! 9 % ‪If (( Number % 3==0)&&( Number‬‬                       ‫)0==3 % ‪If (( Number‬‬
‫;"9 ‪cout<<"the number is donot aceept mod to‬‬                   ‫{‬
‫))0== 9 % ‪If (( Number % 3==0)&&( Number‬‬                       ‫))0=! 9 % ‪if( Number‬‬
 ‫;"9 ‪cout<<" the number is aceept mod to‬‬                       ‫;"9 ‪cout<<"the number is donot aceept mod to‬‬
‫}‬                                                              ‫‪else‬‬
                                                               ‫;"9 ‪cout<<" the number is aceept mod to‬‬
                                                               ‫}‬
                                                               ‫}‬


          ‫ﺑدون اﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ اﻟﻣﺗداﺧﻠﺔ‬     ‫‪c‬‬   ‫اﻟﻛود ﺑﻠﻐﺔ‬              ‫ﺑﺎﺳﺗﺧدام اﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ اﻟﻣﺗداﺧﻠﺔ‬     ‫‪c‬‬    ‫اﻟﻛود ﺑﻠﻐﺔ‬
‫>‪#include<stdio.h‬‬                                              ‫>‪#include<stdio.h‬‬
‫)(‪main‬‬                                                         ‫)(‪main‬‬
‫{‬                                                              ‫{‬
‫;08=‪int Number‬‬                                                 ‫;08=‪int Number‬‬
  ‫))0=! 9 % ‪If (( Number % 3==0)&&( Number‬‬                       ‫)0==3 % ‪If (( Number‬‬
‫;)"9 ‪printf("the number is donot aceept mod to‬‬                 ‫{‬
‫))0== 9 % ‪If (( Number % 3==0)&&( Number‬‬                       ‫))0=! 9 % ‪if( Number‬‬
  ‫;)"9 ‪printf(" the number is aceept mod to‬‬                    ‫;)"9 ‪prin ("the number is donot aceept mod to‬‬
‫}‬                                                              ‫‪else‬‬
                                                               ‫;)"9 ‪prin (" the number is aceept mod to‬‬
                                                               ‫}‬
                                                               ‫}‬



    ‫ﻟو ﺗﻼﺣظ أن اﻟﻣﺛﺎﻻن ﯾﻌطﯾﺎن ﻧﻔس اﻟﻧﺗﯾﺟﺔ ﻟﻛن ﺑﺎﺳﺗﺧدام اﻟﻌﺑﺎرات اﻟﻣﺗداﺧﻠﺔ ﺗﻛون اﻻﻛواد اﻟﺑرﻣﺟﯾﺔ أﻛﺛر ﺳﮭوﻟﺔ‬
‫ووﺿوح ﻟﻠﻣﺑرﻣﺞ .وﻓﻲ ﺑﻌض اﻷﺣﯾﺎن ﻣﻊ ﺑﻌض اﻷﺳﺋﻠﺔ ﻻ ﻧﺳﺗطﯾﻊ اﺳﺗﺧدام اﻟطرﯾﻘﺔ اﻷوﻟﻰ ﻷﻧك ﺗﺟد ﻧﻔﺳك ﻣﺣﻛوﻣﺎ‬
                                                                 ‫ﺑﺎﺳﺗﺧدام اﻟطرﯾﻘﺔ اﻟﺛﺎﻧﯾﺔ ﻻن ﺑﮭﺎ ﻣروﻧﺔ أﻛﺛر‬

                                                                                                                              ‫ﻣﮭم‬

   ‫وإذا وﻗﻊ ﻋﺑﺎرﺗﻲ )‪ (if‬ﻣﺗﺗﺎﻟﯾﺗﯾن وﯾﻠﯾﮭﻣﺎ ﻋﺑﺎرﺗﻲ ل )‪ (else‬ﻣﺗﺗﺎﻟﯾﺗﯾن ﻓﺳﺗﻧﻔﻲ ال )‪ (else‬اﻷوﻟﻰ اﻗرب ﻋﺑﺎرة‬
‫)‪ (if‬ﻋﻠﯾﮭﺎ إي ﻋﺑﺎرة )‪ (if‬اﻟﺛﺎﻧﯾﺔ وﺳﺗﻧﻔﻲ ال )‪ (else‬اﻟﺛﺎﻧﯾﺔ اﻗرب ﻋﺑﺎرة )‪ (if‬ﻋﻠﯾﮭﺎ وﺑﻣﺎ أن ﻋﺑﺎرة)‪ (if‬اﻟﺛﺎﻧﯾﺔ‬
        ‫ﻧﻔﺗﮭﺎ )‪ (else‬اﻷوﻟﻰ ﻓﺳﯾﻛون ﻋﺑﺎرة )‪ (if‬اﻷوﻟﻰ ھﻲ ﺗﺧص ال )‪ (else‬اﻟﺛﺎﻧﯾﺔ ﺷﺎھد اﻟﻣﺛﺎل ﻟﻔﮭم اﻟﺷرح.‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                           ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




‫ﻣﺛﺎل: ﺗﺗﺑﻊ ﺧطوات اﻟﺣل ﻓﻲ اﻟﺑرﻧﺎﻣﺞ اﻟﺗﺎﻟﻲ إذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ )4=‪input_Try=7 , input_Try‬‬
                  ‫3- =‪ (input_Try‬وطﻠب اﻟﻣﺛﺎل ھو طﺑﺎﻋﺔ ھل اﻷﻋداد ﻓردﯾﺔ أو زوﺟﯾﺔ ﻟﻛن ﻓﻘط اﻷرﻗﺎم اﻟﻣوﺟﺑﺔ‬

       ‫++‪C‬‬                                                                        ‫اﻟﻛود ﺑﻠﻐﺔ‬
       ‫>‪#include<iostream.h‬‬
       ‫)(‪Main‬‬
       ‫{‬
       ‫;‪1.int input_Try‬‬
       ‫;‪2.cin>> input_Try‬‬
       ‫)0 > ‪if (input_Try‬‬           ‫ﻧﻼﺣﻆ أن )‪ ( else‬اﻷﺧﯿﺮة ﺗﻜﻮن ﻣﺨﺎﻟﻔﺔ ﻟﻞ )‪ (if‬اﻷوﻟﻰ‬
       ‫)0==2% ‪if (input_Try‬‬
       ‫;"‪3.cout<<"the number is positive even‬‬
       ‫‪else‬‬
       ‫;"‪4.cout<<" the number is positive Odd‬‬
       ‫‪else‬‬
       ‫;"‪5.cout<<"the number is less than zero‬‬
       ‫}‬


       ‫‪C‬‬                                                                           ‫اﻟﻛود ﺑﻠﻐﺔ‬
       ‫>‪#include<stdio.h‬‬
       ‫)(‪Main‬‬
       ‫{‬
       ‫;‪1.int input_Try‬‬
       ‫;)‪2.scanf("%d", input_Try‬‬
       ‫)0>‪if (input_Try‬‬             ‫ﻧﻼﺣﻆ أن )‪ ( else‬اﻷﺧﯿﺮة ﺗﻜﻮن ﻣﺨﺎﻟﻔﺔ ﻟﻞ )‪ (if‬اﻷوﻟﻰ‬
       ‫)0==2% ‪if (input_Try‬‬
       ‫;)" ‪3.printf(" the number is positive even‬‬
       ‫‪else‬‬
       ‫;)" ‪4. printf(" the number is positive Odd‬‬
       ‫‪else‬‬
       ‫)"‪5. printf("the number is less than zero‬‬
       ‫}‬
                                                                                 ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                                       ‫١. ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر اﺳﻣﮫ ‪input_Try‬‬
                   ‫٢. ﺧطوة رﻗم )٢( ﺗم طﻠب إدﺧﺎل ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﺛم ﯾﺗﺣﻘق ﻣن اﻟﺷروط اﻟﺗﺎﻟﯾﺔ‬
                                                    ‫‪ ‬إذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ 3- =‪input_Try‬‬

 ‫ﺳﯾﺗم اﻟﺗﺣﻘق ﻣن اﻟﺷرط )0>‪ if (input_Try‬وان ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ‪ input_Try‬ھﻲ )3-( أي اﻗل ﻣن ﺻﻔر أي ﻟم‬
           ‫ﯾﺣﻘق اﻟﺷرط ﻟذاﻟك ﺳﯾﺗﺟﮫ إﻟﻰ ﻋﺑﺎرة )‪ (else‬اﻟﺛﺎﻧﯾﺔ وﯾﻧﻔذ اﻟﺧطوة رﻗم )٥( وﯾطﺑﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

 ‫‪the number is less than zero‬‬

‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                          ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬



                                                                                                        ‫ﻣﮭم‬


                                                              ‫ﻟﻣﺎذا ﻟم ﯾﻧﻔذ ﺧطوة رﻗم )٣( وﺧطوة رﻗم )٤( ..؟‬

  ‫ﻛﻣﺎ ﻗﻠﻧﺎ ﺳﺎﺑﻘﺎ ﻛل ﻋﺑﺎرة ﺷرطﯾﺔ )‪ (if‬ﯾﺗﺑﻌﮭﺎ ﺳطر واﺣد إذا ﻟم ﻧﺿﻊ أﻗواس وإذا أﻛﺛر ﻣن ﺳطر ﯾﺗﺑﻊ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ‬
‫اﻟﺗﻲ ﻧﺿﻊ أﻗواس ﺣول اﻟذي ﯾﺗﺑﻌﮭﺎ وﺑﻣﺎ اﻧﮫ ھﻧﺎ ﻻ ﯾوﺟد أﻗواس ﻣﻌﻧﺎه اﻟذي ﺳﯾﺗﺑﻊ اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ )0>‪if (input_Try‬‬
      ‫ھﻮا ﻓﻘﻂ اﻟﺴﻄﺮ اﻟﺬي ﯾﻠﯿﮫ وھﻮ )0==2% ‪ if (input_Try‬وھﺬا اﻟﺴﻄﺮ أﯾﻀﺎ ﯾﺘﺒﻌﮫ ﺳﻄﺮ واﺣﺪ وﯾﻮﺟﺪ ﻋﺒﺎرة‬
 ‫‪ else‬ﻟﮫ إي )ﻛﺄﻧﻨﺎ ﻧﻘﻮل إذا ﺗﺤﻘﻖ اﻟﺸﺮط اﻷول وﻛﺎن اﻟرﻗم اﻛﺑر ﻣن ﺻﻔر ﺗوﺟد ﻋﺑﺎرة ﺷرطﯾﺔ ﺗﺗﺣﻘق ﻣﻧﮫ إذا ﻛﺎن‬
                 ‫اﻟرﻗم ﻓردي أم زوﺟﻲ ﻟﻛن اﻟﻣوﺟب ﻓﻘط ﯾﻣر ﻋﻠﻰ ﻋﺑﺎرة )‪ (if—else‬ﻷﻧﮭﺎ ﻗﯾدت ﺑﺎﻟﺷرط اﻟذي ﻗﺑﻠﮭﺎ(‬


                                                  ‫‪ ‬إذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ 7=‪input_Try‬‬

    ‫ﺳﯾﺗم اﻟﺗﺣﻘق ﻣن اﻟﺷرط )0>‪ if (input_Try‬وان ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ‪ input_Try‬ھو )٧( إي اﻛﺑر ﻣن ﺻﻔر إي‬
                    ‫ﺣﻘق اﻟﺷرط ﻟذاﻟك ﺳﯾﺗﺟﮫ إﻟﻰ ﻋﺑﺎرة )0==2% ‪ if (input_Try‬اﻟﺗﻲ ﺗﻠﻲ ﺷرط اﻟﺗﺣﻘق‬
        ‫وھذه اﻟﻌﺑﺎرة ﺗﺗﺣﻘق ﻓﻲ ﻣﺎ إذا ﻛﺎن اﻟرﻗم .زوﺟﻲ وﻓﻌﻼ اﻟرﻗم ٧ ھو زوﺟﻲ ﻟذاﻟك وﯾﻧﻔذ اﻟﺧطوة رﻗم )٣(‬
                                                                               ‫وﯾطﺑﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
    ‫‪the number is positive even‬‬



    ‫وﻻ ﯾﻧﻔذ اﻟﺧطوة )٤( ﻻن اﻟﺷرط )0==2% ‪ if (input_Try‬ﺗﺣﻘق وأﯾﺿﺎ ﻻ ﯾﻧﻔذ اﻟﺧطوة رﻗم )٥( ﻻن ﺷرط‬

                                                                                ‫)0>‪ if (input_Try‬ﺗﺤﻘﻖ‬



                                                  ‫‪ ‬إذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ 4=‪input_Try‬‬

    ‫ﺳﯾﺗم اﻟﺗﺣﻘق ﻣن اﻟﺷرط )0>‪ if (input_Try‬وان ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ‪ input_Try‬ھﻲ )٤( أي اﻛﺑر ﻣن ﺻﻔر أي‬
                    ‫ﺣﻘق اﻟﺷرط ﻟذاﻟك ﺳﯾﺗﺟﮫ إﻟﻰ ﻋﺑﺎرة )0==2% ‪ if (input_Try‬اﻟﺗﻲ ﺗﻠﻲ ﺷرط اﻟﺗﺣﻘق‬
 ‫وھذه اﻟﻌﺑﺎرة ﺗﺗﺣﻘق ﻓﻲ ﻣﺎ إذا ﻛﺎن اﻟرﻗم زوﺟﻲ وان اﻟرﻗم ٤ ھو رﻗم ﻓردي ﻟذاﻟك ﻻ ﯾﺗﺣﻘق اﻟﺷرط وﯾﻧﻔذ ﻋﺑﺎرة‬
                                                  ‫‪ else‬وﯾﻧﻔذ اﻟﺧطوة رﻗم )٤( وﯾطﺑﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

 ‫‪the number is positive Odd‬‬


                                                ‫ﻻ ﯾﻧﻔذ اﻟﺧطوة رﻗم )٥( ﻻن ﺷرط )0>‪ if (input_Try‬ﺗﺤﻘﻖ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                 ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                                                       ‫٤.٢- ﻋﺑﺎرة )‪ (if—else if‬اﻟﺷرطﯾﺔ :‬
 ‫ھﻲ ﻣﺟﻣوﻋﺔ ﻋﺑﺎرات ﺷرطﯾﺔ ﻣﺗﺧﺎﻟﻔﺔ ﻓﻲ ﺷروطﮭﺎ . أي ﺗﻛون واﺣدة ﻣﺧﺎﻟﻔﺔ إﻟﻰ اﻷﺧرى ﻓﻲ ﺷرطﮭﺎ . وﯾﺗم اﻟﺗﺣﻘق‬
  ‫ﻣن اﻟﺷروط وﻗت اﻟﺗﻧﻔﯾذ إذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط اﻷول ﯾﻧﺗﻘل إﻟﻰ )‪ (else if‬اﻟﺛﺎﻧﯾﺔ وإذا ﻟم ﺗﺗﺣﻘق ﯾﻧﺗﻘل إﻟﻰ اﻟﺛﺎﻟﺛﺔ ﺣﺗﻰ‬
               ‫أﺧﯾرا ﯾﺻل إﻟﻰ اﻟﺷرط اﻟذي ﯾﺗﺣﻘق وإذا ﺗﺣﻘق واﺣد ﻣن )‪ (if‬ﺳوف ﯾﻧﻔذ ﻣﺎ ﻓﻲ داﺧﻠﮭﺎ وﺑﮭﻣل اﻟﺑﻘﯾﺔ .‬

                                                                                                      ‫اﻟﺷﻛل اﻟﻌﺎم‬
                                                                           ‫ﺷﻛل ﻋﺑﺎرة ‪ if –else if‬اﻟﺷرطﯾﺔ‬
          ‫) 1‪If ( condi on‬‬
          ‫{‬
          ‫1‪Statement‬‬
          ‫}‬
           ‫‪ else if‬ﯾﻛون ﻏﯾر ﻣﺣدد ﯾﺣددھﺎ اﻟﻣﺳﺗﺧدم ﺣﺳب ﺣﺎﺟﺗﮫ 2‪else if( condi on‬‬                   ‫ﻋدد‬
          ‫//)‬
          ‫{‬
          ‫2‪Statement‬‬
          ‫}‬
          ‫) 3‪Else if( condi on‬‬
          ‫{‬
          ‫3‪Statement‬‬
          ‫}‬
          ‫ﻧﺳﺗطﯾﻊ أن ﻧﺿﻊ ‪ else‬أو ﻧﺣذﻓﮭﺎ إذا ﻟم ﻧﺣﺗﺎج إﻟﯾﮭﺎ // ‪else‬‬
          ‫{‬
          ‫4‪Statement‬‬
          ‫}‬                                                                                                     ‫ﻣﮭم‬
          ‫ﺧطوات ﺑرﻣﺟﯾﺔ أﺧرى // ﺧطوة ﺟدﯾدة‬

                 ‫إذا ﺗﺣﻘق 1‪ condition‬ﺳوف ﯾﻧﻔذ 1‪ Statement‬وﯾﻧﺗﻘل ﺑﻌدھﺎ إﻟﻰ "ﺧطوة ﺟدﯾدة"‬                     ‫‪‬‬
‫إذا ﻟم ﯾﺗﺣﻘق 1‪ condition‬ﺳوف ﯾﻧﺗﻘل إﻟﻰ 2‪ condition‬وإذا ﺗﺣﻘق اﻟﺷرط ﺳوف ﯾﻧﻔذ 2‪Statement‬‬                       ‫‪‬‬
                                                                   ‫ﺑﻌدھﺎ إﻟﻰ "ﺧطوة ﺟدﯾدة"‬
‫إذا ﻟم ﯾﺗﺣﻘق 1‪ condition‬ﺳوف ﯾﻧﺗﻘل إﻟﻰ 2‪ condition‬وإذا ﺗﺣﻘق اﻟﺷرط ﺳوف ﯾﻧﻔذ 2‪Statement‬‬                       ‫‪‬‬
                                                                   ‫ﺑﻌدھﺎ إﻟﻰ "ﺧطوة ﺟدﯾدة"‬
  ‫إذا ﻟم ﯾﺗﺣﻘق 1‪ condition‬ﺳوف ﯾﻧﺗﻘل إﻟﻰ 2‪ condition‬وإذا ﻟم ﯾﺗﺣﻘق 2‪ condition‬ﺳوف ﯾﻧﺗﻘل‬                      ‫‪‬‬
                ‫إﻟﻰ 3‪ condition‬وإذا ﺗﺣﻘق اﻟﺷرط ﺳﯾﻧﻔذ 3‪ Statement‬ﺑﻌدھﺎ إﻟﻰ "ﺧطوة ﺟدﯾدة"‬

    ‫‪ ‬وإذا ﻟم ﯾﺗﺣﻘق إي ﻣن ‪ conditions‬ﺳوف ﯾﻧﻔذ ﻣﺎ ﻣوﺟود ﻓﻲ ‪ else‬وﺑﻌدھﺎ ﯾﻧﺗﻘل إﻟﻰ" ﺧطوة ﺟدﯾدة"‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




 ‫ﻣﺛﺎل:ﺑرﻧﺎﻣﺞ ﺗدﺧل رﻗم وﯾﺑﯾن ﻟﻛل ھل اﻟرﻗم)ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ ٣ أم ﻋﻠﻰ ٥ أم ﻋﻠﻰ ٧ أم ﻏﯾر ذاﻟك وﯾطﺑﻊ رﺳﺎﻟﺔ ﻓﻲ‬
                                ‫ﻛل ﺣﺎﻟﺔ( ﻓﻲ ﺣﺎل إذا ﻗﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ ٧ ﯾﺟﻣﻊ ﻣﻊ اﻟرﻗم اﻟﻣدﺧل ﻗﯾﻣﺔ ٢ وﯾطﺑﻌﮫ‬

‫++‪c‬‬                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
‫>‪#include<iostream.h‬‬                                    ‫>‪#include<stdio.h‬‬
‫)(‪main‬‬                                                  ‫)(‪main‬‬
‫{‬                                                       ‫{‬
‫;‪1.int number_enter‬‬                                     ‫;‪1.int number_enter‬‬
‫;‪2.cin>> number_enter‬‬                                   ‫;) ‪2.scanf("%d",& number_enter‬‬
‫)0==3 % ‪if ( number_enter‬‬                               ‫)0==3 % ‪if ( number_enter‬‬
‫; "3 ‪3.cout<<"Acept Devide to‬‬                           ‫;)"3 ‪3.prin ("Acept Devide to‬‬
‫)0==5 % ‪else if (number_enter‬‬                           ‫)0==5 % ‪else if (number_enter‬‬
‫; "5 ‪4. cout<<" Acept Devide to‬‬                         ‫;)"5 ‪4.prin (" Acept Devide to‬‬
‫)0==7 % ‪else if (number_enter‬‬                           ‫)0==7 % ‪else if (number_enter‬‬
‫{‬                                                       ‫{‬
‫;2+‪5.number_enter= number_enter‬‬                         ‫;2+‪5.number_enter= number_enter‬‬
‫;‪6. cout<<" Acept Devide to 7=" << number_enter‬‬         ‫;)‪6.prin (" Acept Devide to 7=%d", number_enter‬‬
‫}‬                                                       ‫}‬
‫‪else‬‬                                                    ‫‪else‬‬
‫; "‪7. cout<<"Donot True any of condi ons‬‬                ‫;)"‪7.prin ("Donot True any of condi ons‬‬
‫}‬                                                       ‫}‬
                                                                            ‫ﺗﺗﺑﻊ ﺧطوات اﻟﺑرﻧﺎﻣﺞ ﻣﻊ اﻟﺗوﺿﯾﺢ:‬

                                                                            ‫١.ﺧطوة رﻗم )١( ﺗﻧﻔذ ﺑﺷﻛل اﻋﺗﯾﺎدي‬

  ‫٢.ﺧطوة رﻗم )٢( ﺗﻧﻔذ ﺑﺷﻛل اﻋﺗﯾﺎدي وﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر )‪ ( number_enter‬ﻣن ﺷﺎﺷﺔ‬
                     ‫اﻟﺗﻧﻔﯾذ ﻟﻧﻔرض إﻧﻧﺎ أدﺧﻠﻧﺎ )‪ (number_enter‬ﻣرة )٦ و٤١و٥١و٠٢ و ٩١(‬

                                                                                             ‫ﻟﻧﺗﺗﺑﻊ اﻟﻘﯾم اﻟﻣدﺧﻠﺔ‬

                                                                       ‫‪ ‬إذا ﻛﺎن 6=‪number_enter‬‬

   ‫ﺳوف ﯾﻧﻔذ اﻟﺧطوة رﻗم )٣( وﯾﻧﺗﮭﻲ اﻟﺑرﻧﺎﻣﺞ )ﺣﺳب ﺷرح ﻋن اﻟداﻟﺔ)‪ (if—else if‬إذا ﺗﺣﻘق اﺣد اﻟﺷروط ﻓﻲ اﺣد‬
   ‫اﻟﻌﺑﺎرات ﺗﻧﻔذ ﻣﺎ ﻓﻲ داﺧﻠﮫ وﺗﺗﺟﮫ إﻟﻰ ﻣﺎ ﺑﻌد ‪ else‬اﻟﻧﮭﺎﺋﯾﺔ ﻟﺗﻧﻔذه وﺑﻣﺎ اﻧﮫ ﻻ ﯾوﺟد ﺷﻲ ﺑﻌد ‪ else‬ﯾوﺟد ﻓﻘط ﻗوس‬
                                ‫ﻧﮭﺎﯾﺔ اﻟﺑرﻧﺎﻣﺞ ﻟذاﻟك ﺳﺗﻧﮭﻲ اﻟﺑرﻧﺎﻣﺞ( طﺎﺑﻌﺎ ﻟﻠرﺳﺎﻟﺔ اﻟﺗﺎﻟﯾﺔ ﺗم وﯾﻧﺗﮭﻲ اﻟﺑرﻧﺎﻣﺞ‬


      ‫3 ‪Acept Devide to‬‬


                                                                      ‫‪ ‬إذا ﻛﺎن 41=‪number_enter‬‬

                           ‫طﺎﺑﻌﺎ ﻟﻠرﺳﺎﻟﺔ اﻟﺗﺎﻟﯾﺔ ﺗم وﯾﻧﺗﮭﻲ اﻟﺑرﻧﺎﻣﺞ‬   ‫ﺳوف ﯾﻧﻔذ اﻟﺧطوة رﻗم )5( وﺧطوة رﻗم )6(‬

    ‫9=7 ‪Acept Devide to‬‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                              ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬

                                                                                                             ‫ﻣﮭم‬

                                                              ‫إذا ﻛﺎن 51=‪number_enter‬‬              ‫‪‬‬

       ‫ﺳوف ﯾﻧﻔذ اﻟﺧطوة رﻗم )3( وﻻ ﯾﻧﻔذ وﺧطوة رﻗم )٤( رﻏم ﻗﺑوﻟﮫ اﻟﻘﺳﻣﺔ ﻋﻠﻰ ) ٥ ( ﻷﻧﮫ ﺑرﻣﺟﯾﺎ ﻋﻧدﻣﺎ ﯾﺑدأ‬
‫اﻟﺑرﻧﺎﻣﺞ ﺑﺎﻟﺗﺣﻘق ﻣن اﻟﺷروط ﯾﺑدأ ﺑﺎﻟﺗﺣﻘق ﺑﺎﻟﺗﺳﻠﺳل ﺧطوة ﺑﺧطوة ﺣﺳب اﻟﺗرﺗﯾب وﻧﺣن واﺿﻌﯾن ﺷرط ﻗﺑول اﻟﻘﺳﻣﺔ‬
  ‫ﻋﻠﻰ ﺛﻼﺛﺔ ﻗﺑل ﺷرط ﻗﺑول اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﺧﻣﺳﺔ وﻋﻧدﻣﺎ ﯾﻣر اﻟﺑرﻧﺎﻣﺞ ﻋﻠﻰ اﻟﺷرط اﻷول وﺣﻘﻘﮫ ﻻ ﯾﻣر ﻋﻠﻰ اﻟﺷرط‬
‫اﻟﺛﺎﻧﻲ ﺑل ﯾﺗﺟﮫ إﻟﻰ ﻣﺎ ﺑﻌد )‪ .(else‬ﻟو ﻛﻧﺎ واﺿﻌﯾن ﺷرط ﻗﺑول اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﺧﻣﺳﺔ ﻗﺑل ﺷرط ﻗﺑول اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﺛﻼﺛﺔ‬
                                                 ‫ﻟﺗﻧﻔذ ﺧطوة رﻗم )٤(. ﻟذاﻟك ﺳﯾطﺑﻊ اﻟﺑرﻧﺎﻣﺞ أﻻن ھذه اﻟرﺳﺎﻟﺔ‬

      ‫3 ‪Acept Devide to‬‬



                                                                 ‫‪ ‬إذا ﻛﺎن 02=‪number_enter‬‬

                                               ‫ﺳوف ﯾﻧﻔذ اﻟﺧطوة رﻗم )٤( طﺎﺑﻌﺎ ﻟﻠرﺳﺎﻟﺔ اﻟﺗﺎﻟﯾﺔ ﺗم وﯾﻧﺗﮭﻲ اﻟﺑرﻧﺎﻣﺞ‬


      ‫5 ‪Acept Devide to‬‬




                                                                 ‫‪ ‬إذا ﻛﺎن 91=‪number_enter‬‬

      ‫ﺳوف ﻟن ﯾﺣﻘق إي ﻣن اﻟﺷروط اﻟﺳﺎﺑﻘﺔ ﻟذاﻟك ﺳﯾﺗﺟﮫ إﻟﻰ )‪ (else‬ﯾﻧﻔذ اﻟﺧطوة رﻗم )٧( طﺎﺑﻌﺎ ﻟﻠرﺳﺎﻟﺔ اﻟﺗﺎﻟﯾﺔ ﺗم‬
                                                                                              ‫وﯾﻧﺗﮭﻲ اﻟﺑرﻧﺎﻣﺞ‬


      ‫‪Donot True any of conditions‬‬




                      ‫‪ ‬ﺧطوة رﻗم )٥ و٦( وﺿﻌت ﺑﯾن ﻗوﺳﯾن ﻟﻠدﻻﻟﺔ ﻋﻠﻰ أﻧﮭﻣﺎ ﺗﺎﺑﻌﺗﺎن ﻟﻌﺑﺎرة )‪(else‬‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(if ,Switch) ‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ‬                                                                       ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﯾﻘﻮم ﺑﻄﺒﺎﻋﺔ أﯾﺎم اﻷﺳﺒﻮع ﺑﺤﯿﺚ إذا ﺿﻐﻄﻨﺎ) ١ ( ﯾﻈﮭﺮ ﯾﻮم اﻷﺣﺪ ﻓﻲ ﺷﺎﺷﺔ اﻟﺘﻨﻔﯿﺬ واﻟﺒﻘﯿﺔ ﺑﺎﻟﺘﺴﻠﺴﻞ إﻟﻰ‬
                                                                                        ‫) ٧( ﯾﻤﺜﻞ اﻟﺴﺒﺖ .؟‬

    ‫ﺗﺣﻠﯾل اﻟﻣﺗطﻠﺑﺎت:ﺑﻣﺎ اﻧﮫ ﯾوﺟد ﻟدﯾﻧﺎ ﺳﺑﻌﺔ أﯾﺎم ﻓوﺿﻊ ﻛل ﯾوم ﻋﻠﻰ ﺣدة ﺑﻌﺑﺎرة ﺷرطﯾﺔ ﯾﻌﻘد اﻟﺑرﻧﺎﻣﺞ ﺷﯾﺊ ﻣﺎ ﻟذال‬
                               ‫( ﻟﺗﺳﮭﯾل اﻷﻣر ﻗﻠﯾﻼ ﺷﺎھد اﻟﻣﺛﺎل ﺑﺳﯾط ﺟدا‬if—else if) ‫ﺳﻧﺳﺗﺧدم اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ‬

       C ++                                                                                           ‫اﻟﻛود ﺑﻠﻐﺔ‬
       #include<iostream.h>
       main()
       {int Day_Number;
       cin>> Day_Number ;
       if ( Day_Number==1)
       cout<<"sunday" ;
       else if ( Day_Number==2)
         cout<<"monday" ;
       else if ( Day_Number==3)
         cout<<"Tuerday" ;
       else if ( Day_Number==4)
       cout<<"wednesday" ;
       else if ( Day_Number==5)
        cout<<"thursday" ;
       else if ( Day_Number==6)
         cout<<"fridaay" ;
       else if ( Day_Number==7)
         cout<<"saturday" ;
       else
         cout<<"error" ; }


        C                                                                                             ‫اﻟﻛود ﺑﻠﻐﺔ‬
       #include<stdio.h>
       main()
       {int Day_Number;
       scanf("%d",& Day_Number );
       if ( Day_Number==1)
       printf("sunday");
       else if ( Day_Number==2)
        printf("monday");
       else if ( Day_Number==3)
        printf("Tuerday");
       else if ( Day_Number==4)
        printf("wednesday");
       else if ( Day_Number==5)
       printf("thursday");
       else if ( Day_Number==6)
        printf("fridaay");
       else if ( Day_Number==7)
        printf("saturday");
       else
        printf("error"); }

                                                 ‫ﺷﺎھد ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻋﻧدﻣﺎ أدﺧﻠﻧﺎ اﻟرﻗم )٥( ظﮭر اﻟﯾوم‬

                                                                   (Thursday) ‫اﻟﻣﻘﺎﺑل ﻟﮫ وھو‬


‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                    C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                                  ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                                               ‫٥.٢- ﻋﺑﺎرة )‪ (Switch—Case‬اﻟﺷرطﯾﺔ :‬
  ‫ھﻲ ﻣﺟﻣوﻋﺔ ﻋﺑﺎرات ﺷرطﯾﺔ )‪ (Case‬وﯾﻘﺎرن اﻟﻘﯾﻣﺔ ﻋﻧد ﻛل )‪ (Case‬ﻣﻊ اﻟﻣﺗﻐﯾر ﻓﻲ )‪ . (switch‬وﯾﺗم اﻟﺗﺣﻘق‬
  ‫ﻣن اﻟﺷروط وﻗت اﻟﺗﻧﻔﯾذ ﻓﺈذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط اﻷول ﯾﻧﺗﻘل إﻟﻰ )‪ (Case‬اﻟﺛﺎﻧﯾﺔ ﻓﺈذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط اﻟﺛﺎﻧﻲ ﯾﻧﺗﻘل إﻟﻰ‬
   ‫)‪ (Case‬اﻟﺛﺎﻟﺛﺔ ﺣﺗﻰ أﺧﯾرا ﯾﺻل إﻟﻰ اﻟﺷرط اﻟذي ﯾﺗﺣﻘق وإذا ﺗﺣﻘق واﺣد ﻣن )‪ (Case‬ﺳوف ﯾﻧﻔذ ﻣﺎ ﻓﻲ داﺧﻠﮭﺎ‬
‫وﺑﮭﻣل اﻟﺑﻘﯾﺔ وإذا ﻟم ﯾﻧﻔذ إي واﺣد ﻣﻧﮭن ﺳوف ﯾﺗﺟﮫ ﻟﯾﻧﻔذ ﻣﺎ ﻓﻲ داﺧل )‪ .(default‬وﺗﻛون ﻣﺷﺎﺑﮫ ﻛﺛﯾرا ﺟدا )‪(if else if‬‬

                                                                                                     ‫اﻟﺷﻛل اﻟﻌﺎم‬
                                                                           ‫ﺷﻛل ﻋﺑﺎرة ‪ if --elseif‬اﻟﺷرطﯾﺔ‬
          ‫) ‪Switch(Truth of Case‬‬
          ‫ﻋدد ال ‪ Case‬ﯾﻛون ﻏﯾر ﻣﺣدد ﯾﺣددھﺎ اﻟﻣﺳﺗﺧدم ﺣﺳب ﺣﺎﺣﺗﮫ// :1‪{ Case condi on‬‬
          ‫{‬
          ‫1‪Statement‬‬
          ‫;‪} Break‬‬
            ‫2‪Case condi on‬‬
          ‫{‬
          ‫2‪Statement‬‬
          ‫;‪} Break‬‬
          ‫:3‪Case condi on‬‬
          ‫{‬
          ‫3‪Statement‬‬
          ‫;‪} Break‬‬
           ‫ﻧﺳﺗطﯾﻊ أن ﻧﺿﻊ ‪ default‬أو ﻧﺣذﻓﮭﺎ إذا ﻟم ﻧﺣﺗﺎﺟﮭﺎ // :‪default‬‬
          ‫4‪{ Statement‬‬          ‫}‬           ‫}‬                                                                    ‫ﻣﮭم‬
          ‫ﺧطوات ﺑرﻣﺟﯾﺔ أﺧرى // ﺧطوة ﺟدﯾدة‬

    ‫)‪:(Truth of Case‬ھو اﻟﻣﺗﻐﯾر أو ﻋﻣﻠﯾﺔ رﯾﺎﺿﯾﺔ اﻟذي ﯾﻧﺗﺞ ﻋﻧﮭﺎ ﻗﯾﻣﺔ ﻣﻌﯾﻧﮫ ﺗﺗم ﻣﻘﺎرﻧﮫ ھذه اﻟﻘﯾﻣﺔ ﻣﻊ ﻛل‬
              ‫‪ condition‬ﻣوﺟودة ﻓﻲ ﻛل ‪ Case‬وأﯾﮭﺎ ﯾﺣﻘق اﻟﺷرط ﯾﻧﻔذ اﻟﺑرﻧﺎﻣﺞ )‪ (Statement‬اﻟﺧﺎص ﺑﮫ.‬
 ‫ﺷﺎھد ھذا اﻟﺗوﺿﯾﺢ ﻓﻲ اﻟﻣﺛﺎل ﻟﺗوﺿﯾﺢ اﻟﺻورة إذا ﻛﺎن ﻟدﯾﻧﺎ ﻣﺗﻐﯾر اﺳﻣﮫ ‪ Number‬وﺗﺮﯾﺪ ﻟﯿﻨﻔﺬ اﺣﺪ اﻟﺸﺮوط أن‬
                                                             ‫ﯾﻜﻮن ﻗﯿﻤﺘﮫ )١٥( ﺗﻜﺘﺐ ھﻜﺬا ﻓﻲ ﺟﻣل ﺷرطﯾﺔ‬
                                                                                                      ‫اﻟﻛود‬
        ‫)15==‪if ( Day_Number‬‬
        ‫‪//do some thing‬‬



                                                                         ‫ﻓﻲ ﺣﺎﻟﺔ ‪ Switch--Case‬ﻧﻛﺗﺑﮭﺎ ھﻛذا‬

                                                                                                      ‫اﻟﻛود‬
        ‫)‪Switch(Day_Number‬‬
        ‫‪Case 51: //do some thing‬‬
        ‫;‪Break‬‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(if ,Switch) ‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ‬                                                        ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




                 ‫( ﻛﺣﺎل اﻟﺟﻣل اﻟﺷرطﯾﺔ إي إذا ﻛﻧﺎ ﻧﻘﺎرن ﻣﻊ ﺣرف ﻧﺿﻌﮫ ھﻛذا‬Switch—Case) ‫ ﺣﺎل‬

                                                                                            ‫اﻟﻛود‬
       Switch(Capatat_symbol)
       Case 'a': //do some thing
       Break;



   ‫( ھﻲ أي ﻋدد ﻣن اﻻﻛواد اﻟﺑرﻣﺟﯾﺔ ﯾﻣﻛن ﻛﺗﺎﺑﺗﮭﺎ وﺣﺳب اﻟﺣﺎﺟﺔ وﺗذﻛر إذا أردﻧﺎ أن‬do some thing) ‫ﺣﯾث أن‬
                 .(Break) ‫( ﯾﺟب أن ﻧﺿﻌﮭﺎ داﺧل ﻗوﺳﯾن وﺑﻌدھﺎ ﻧﻛﺗب‬Case) ‫ﻧﻛﺗب أﻛﺛر ﻣن ﺳطر ﺑرﻣﺟﻲ داﺧل‬

              "‫ وﯾﻧﺗﻘل ﺑﻌدھﺎ إﻟﻰ "ﺧطوة ﺟدﯾدة‬Statement1 ‫ ﺳوف ﯾﻧﻔذ‬condi on1 ‫إي أن إذا ﺗﺣﻘق‬            
  Statement2 ‫ وإذا ﺗﺣﻘق اﻟﺷرط ﺳوف ﯾﻧﻔذ‬condi on2 ‫ ﺳوف ﯾﻧﺗﻘل إﻟﻰ‬condi on1 ‫إذا ﻟم ﯾﺗﺣﻘق‬                
                                                                         "‫ﺑﻌدھﺎ إﻟﻰ "ﺧطوة ﺟدﯾدة‬
  "‫ وﺑﻌدھﺎ ﯾﻧﺗﻘل إﻟﻰ" ﺧطوة ﺟدﯾدة‬default ‫ ﺳوف ﯾﻧﻔذ ﻣﺎ ﻣوﺟود ﻓﻲ‬conditions ‫وإذا ﻟم ﯾﺗﺣﻘق إي ﻣن‬         
         ‫( ھذا ﺷﻲء ﺛﺎﺑت ﻓﻲ ھﯾﻛﻠﯾﺔ ھذه اﻟداﻟﺔ ﻟﻛﻲ ﯾﺧرج ﻣن‬case) ‫( ﻓﻲ ﻧﮭﺎﯾﺔ ﻛل‬Break) ‫ﻧﻼﺣظ وﺟود‬         
                                                                 ‫( ﺑﻌد ﺗﺣﻘق اﺣد اﻟﺷروط‬switch)

  ‫ﻣﺛﺎل: ﻟدﯾﻧﺎ اﻟﻣﻌوﻣﺎت اﻟﺗﺎﻟﯾﺔ ﻋن ھؤﻻء اﻷﺷﺧﺎص ﻧرﯾد ﻣﺟرد ﻛﺗﺎﺑﺔ أول ﺣرف ﻣن اﺳم اﻟﺷﺧص ﯾﻌطﯾك اﻟﻣﻌﻠوﻣﺎت‬
                                                                                     ‫اﻟﻛﺎﻣﻠﺔ ﻋﻧﮫ‬

1.Ali: his names Ali kammel,20 Year old, third stage
1.Salem: his names Salem kammel,18 Year old, third stage
1.Hussien: his names Hussien Ahmmed Taleb,21 Year old, third stage eng.Computer



         C ++                                                                                ‫اﻟﻛود ﺑﻠﻐﺔ‬
   #include<iostream.h>
   main()
   {1.char index_of_Name;
   2.Cout<<"Enter First Chat of Student name: ";
   3.Cin>> index_of_Name ;
   4.switch( index_of_Name ) {
   5.case 'A':
   6.Cout<<" his names Ali kammel,20 Year old, third stage " ;
   7.break;
   8.case 'S':
    9.Cout<<" his names Salem kammel,18 Year old, third stage " ;
   10.break;
   11.case 'H':
    12.Cout<<" his names Hussien Ahmmed Taleb,21 Year old, third stage eng.Computer " ;
   13.break;
   14.default:
    15.Cout<<"You Not have saved names in this index" ; }}




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                         C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ )‪(if ,Switch‬‬                                                         ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




         ‫‪C‬‬                                                                                    ‫اﻟﻛود ﺑﻠﻐﺔ‬
  ‫>‪#include<stdio.h‬‬
  ‫)(‪main‬‬
  ‫;‪{1.char index_of_Name‬‬
  ‫;)" :‪2.printf("Enter First Chat of Student name‬‬
  ‫; )‪3.scanf("%c", index_of_Name‬‬
  ‫{ ) ‪4.switch( index_of_Name‬‬
  ‫:'‪5.case 'A‬‬
  ‫; )" ‪6. printf(" his names Ali kammel,20 Year old, third stage‬‬
  ‫;‪7.break‬‬
  ‫:'‪8.case 'S‬‬
  ‫; )" ‪9. printf(" his names Salem kammel,18 Year old, third stage‬‬
  ‫;‪10.break‬‬
  ‫:'‪11.case 'H‬‬
  ‫; )" ‪12. printf(" his names Hussien Ahmmed Taleb,21 Year old, third stage eng.Computer‬‬
  ‫;‪13.break‬‬
  ‫:‪14.default‬‬
  ‫}} ; )"‪15. printf("You Not have saved names in this index‬‬



                                      ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر اﺳﻣﮫ )‪ (index_of_Name‬ﻣﻦ ﻧﻮع ﺣﺮﻓﻲ‬

‫٢.ﺧطوة رﻗم )٢( طﺑﻊ رﺳﺎﻟﺔ ﻟﻠﻣﺳﺗﺧدم ﺗطﻠب ﻣﻧﮫ إدﺧﺎل أول ﺣرف ﻣن اﺳم اﻟﺷﺧص ھذه اﻟرﺳﺎﺋل ﻣﮭﻣﺔ ﺟدا ﻟواﺟﮫ‬
     ‫ﺑرﻧﺎﻣﺟك ﺣﺗﻰ ﯾﻌﻠم اﻟﻣﺳﺗﺧدم ﻛﯾف ﯾﺗﻌﺎﻣل ﻣﻊ ﺑرﻧﺎﻣﺟك ﻣﺎ ھو اﻟﻣطﻠوب ﻣﻧﮫ وﻣﺎذا ﯾدﺧل ﻓداﺋﻣﺎ ﺣﺎول أن ﯾﻛون‬
                                                                  ‫ﺑرﻧﺎﻣﺟك واﺿﺢ ﻟﻠﻣﺳﺗﺧدم ﺑﮭذه اﻟرﺳﺎﺋل‬
     ‫٣.ﺧطوة رﻗم)٣( ﻗﻣﻧﺎ ﺑﻘراءة ﺣرف ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ، ﺧطوة )٤( أدﺧﻠﻧﺎ اﻟﺣرف اﻟذي ادﺧﻠﮫ اﻟﻣﺳﺗﺧدم ﻓﻲ ﻗﺎﺋﻣﺔ‬
                                                                                ‫اﻟﺧﯾﺎرات وھﻲ )‪(switch‬‬

‫٤.ﺧطوة رﻗم )٥( ﺗﺣوي ﺣﺎﻟﺔ ﺷرطﯾﺔ ﻷول ﺣرف ﻣن اﺳم اﻟﺷﺧص )‪ (Ail‬وﺗﻼﺣظ اﻷﺣرف ﻓﻲ اﻟﻣﻘﺎرﻧﺔ ﺗوﺿﻊ ﺑﯾن‬
                                                     ‫ﻋﻼﻣﺔ ﺗﻧﺻﯾﺻﯾﺔ واﺣدة ﻣن اﻟﺟﺎﻧﺑﯾن ھﻛذا )'‪('A‬‬

   ‫٥.ﺧطوة رﻗم )٦( ﺗطﺑﻊ ﺳﺟل ھذا اﻟﺷﺧص إذا ﻛﺎن ھوا اﻟﻣطﻠوب ، وﺧطوة رﻗم )٧( ﺗوﻗف ال ‪ case‬ﻟﮭذه اﻟﺣﺎﻟﺔ‬



                                                                              ‫وﺑﻘﯾﺔ اﻟﺧطوات ﻧﻔس اﻟﺷﻲء‬



                                                     ‫ﻻﺣظ ﻋﻧدﻣﺎ أدﺧﻠﻧﺎ ﺣرف ) ‪(H‬ﻣﺎذا ظﮭر ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(if ,Switch) ‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ‬                                                         ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬




       ‫( اﻟﺧﺎص ﺑطﺑﺎﻋﺔ أﯾﺎم اﻷﺳﺑوع ﺣﺳب اﻟرﻗم ﻧﺣﻠﮫ ﺑﺎﺳﺗﺧدام‬if –else if) ‫ﻣﺛﺎل: ﻧﻔس اﻟﻣﺛﺎل اﻟﺳﺎﺑق ﻓﻲ ﻣوﺿوع‬
                                                      ‫( ﻗﺎرﻧﮫ ﺑﺎﻟﻣﺛﺎل اﻟﺳﺎﺑق وﺷﺎھد اﻟﻔرق‬switch—case)

        C ++                                                                            ‫اﻟﻛود ﺑﻠﻐﺔ‬
       #include<iostream.h>
       main()
       {int Day_Number ;
       Cin>> Day_Number ;
       switch( Day_Number ) {
       case 1:cout<<"sunday" ;
       break;
       case 2: cout<<"monday" ;
       break;
       case 3: cout<<"Tuerday" ;
       break;
       case 4: cout<<"wednesday" ;
       break;
       case 5: cout<<"thursday" ;
       break;
       case 6: cout<<"fridaay" ;
       break;
       case 7: cout<<"saturday" ;
       break;
       default: cout<<"error" ; }
       }




        C                                                                               ‫اﻟﻛود ﺑﻠﻐﺔ‬
       #include<stdio.h>
       main()
       {int Day_Number ;
       scanf("%d",& Day_Number );
       switch( Day_Number ) {
       case 1: printf("sunday");
       break;
       case 2:printf("monday");
       break;
       case 3:printf("Tuerday");
       break;
       case 4:printf("wednesday");
       break;
       case 5:printf("thursday");
       break;
       case 6:printf("fridaay");
       break;
       case 7:printf("saturday");
       break;
       default: printf("error"); }
       }




      (Thursday)‫ﺷﺎھد ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻋﻧدﻣﺎ أدﺧﻠﻧﺎ اﻟرﻗم )٥( ظﮭر اﻟﯾوم اﻟﻣﻘﺎﺑل ﻟﮫ وھو‬



‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                         C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
(if ,Switch) ‫اﻟﺟﻣل اﻟﺷرطﯾﺔ واﻟﻌﺑﺎرات اﻟﺷرطﯾﺔ‬                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻧﻲ‬

                                                                                                            ‫ﻣﮭم‬


                                                               !.. Switch ‫وﺿﻊ ﻋﺑﺎرات ﺷرطﯾﺔ داﺧل ﺟﻣل‬

             ‫ ﺣﺎﻟﮭﺎ ﻛﺣﺎل إي ﻛود ﺑرﻣﺟﻲ أﺧر‬case ‫( اﻟﺷرطﯾﺔ ﺑﻣﺧﺗﻠف أﻧواﻋﮭﺎ داﺧل ﻛل‬if ) ‫ﯾﻣﻛن وﺿﻊ ﻋﺑﺎرات‬
 ‫ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﺗدﺧل رﻗم ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﺛم ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل رﻗم اﻟﻌﻣﻠﯾﺔ اﻟﺗﻲ ﯾرﯾد أن ﯾؤدﯾﮭﺎ‬
‫ﻋﻠﻰ ھذه اﻟرﻗم إذا ادﺧل اﻟﻣﺳﺗﺧدم رﻗم واﺣد ﺳوف ﯾﺑﯾن ﻟﮫ ھل اﻟرﻗم ﻓردي أم زوﺟﻲ وإذا ادﺧل رﻗم اﺛﻧﺎن ﯾﺑﯾن ﻟﮫ ھل‬
                                                                             ‫اﻟرﻗم اﻛﺑر ﻣن ﺻﻔر أو اﺻﻐر ﻣﻧﮫ‬
       C++                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
       #include<iostream.h>
       main()
       {int   Number,Chose_check ;
       Cout<<"enter your number: ";
       Cin>> Number ;
       Cout<<"enter Your Selected check (1) or 2:" ;
       Cin>> Chose_check ;
       switch( Chose_check ) {
       case 1:{
       if ( Number % 2== 0)
       cout<<"the number is even";
       else
       cout<<"the number is odd";}
       break;
       case 2:{
       if ( Number >0)
       cout<<"the number is more than zero";
       else
       cout<<"the number is less than zero";}
       break;
       default: cout<<"Error Choice";}}



        C                                                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
       #include<stdio.h>
       main()
       {int   Number,Chose_check ;
       Printf("enter your number: ");
       Scanf("%d",&Number) ;
       Printf("enter Your Selected check (1) or 2:") ;
       Scanf("%d", &Chose_check) ;
       switch( Chose_check ) {
       case 1:{
       if ( Number % 2== 0)
       Printf("the number is even");
       else
       Printf("the number is odd");}
       break;
       case 2:{
       if ( Number >0)
       Printf("the number is more than zero");
       else
       Printf("the number is less than zero");}
       break;
       default: Printf("Error Choice");}}
                                                                                          ‫ﺷﺎھد ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                   ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                           ‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬

                                 ‫١.٣- ﻋﺑﺎرة )‪ ( For--Loop‬اﻟﺗﻛرارﯾﺔ اﻻﻋﺗﯾﺎدﯾﺔ:‬
                                 ‫٢.٣- ﻋﺑﺎرة )‪ ( For--Loop‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬
                                                       ‫٣.٣- ﻋﺑﺎرة )‪: ( Break‬‬
                                                   ‫٤.٣- ﻋﺑﺎرة )‪: ( continue‬‬
                                                         ‫٥.٣- ﻋﺑﺎرة )‪: (go to‬‬
                                              ‫٦.٣- ﻋﺑﺎرة )‪ ( While‬اﻟﺗﻛرارﯾﺔ :‬
                                      ‫٧.٣- ﻋﺑﺎرة )‪ ( While‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬
                                         ‫٨.٣- ﻋﺑﺎرة )‪ (Do-- While‬اﻟﺗﻛرارﯾﺔ :‬
                                 ‫٩.٣- ﻋﺑﺎرة )‪ (do-- While‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ:‬
                        ‫٠١.٣- اﻟﻔرق ﺑﯾن دوال اﻟﺗﻛرار )‪..(for,while,do—while‬؟‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                              ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                     ‫١.٣- ﻋﺑﺎرة )‪ ( For--Loop‬اﻟﺗﻛرارﯾﺔ اﻻﻋﺗﯾﺎدﯾﺔ :‬
     ‫ﻓﻲ اﻟﻔﺻﻠﯾﯾن اﻟﺳﺎﺑﻘﯾن ﺗﻌﻠﻣﻧﺎ أن اﻟﺑرﻧﺎﻣﺞ ﯾﺑدأ ﺑﺎﻟﺗﻧﻔﯾذ ﺧطوة ﺧطوة دون ﺗﻛرار إي ﺧطوة إﻟﻰ أن ﯾﺻل إﻟﻲ ﻧﮭﺎﯾﺔ‬
    ‫اﻟﺑرﻧﺎﻣﺞ وﻋﻣﻠﻧﺎ ﻓﻲ ﺣﺎل وﺟود ﺟﻣل )‪ (if‬اﻟﺷرطﯾﺔ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ ﻗد ﯾﻛون ﺑﺳﺑﺑﮭﺎ ھﻧﺎك اﺳﺗﺛﻧﺎء ﺑﻌض اﻟﺧطوات ﻣن‬
 ‫اﻟﺗﻧﻔﯾذ إذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط .واﻟﺳؤال ھﻧﺎ ﻣﺎذا ﻟو أردﻧﺎ ﺗﻛرار ﺧطوة أو أﻛﺛر ﻣن ﺧطوة ﻷﻛﺛر ﻣن ﻣرة ﻟﺳﺑب ﻣﺎ ﻛﯾف‬
 ‫ﻧﻌﻣل ذاﻟك وھذا ﻣﺎ ﺗؤدﯾﮫ اﻟدوال اﻟﺗﻛرارﯾﺔ وﻣﻧﮭﺎ ﻋﺑﺎرة )‪ (For‬ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﺳﺗﺧدم ﻟﺗﻛرار ﺧطوة ﻓﻲ ﺣﺎﻟﺔ ﻟم‬
 ‫ﻧﺿﻊ أﻗواس أو ﻣﺟﻣوﻋﺔ ﺧطوات ﻓﻲ ﺣﺎل ﺣﺻرھﺎ ﺑﯾن ﻗوﺳﻲ ﻟﻌدد ﻣﻌﯾن ﻣن اﻟﻣرات ﯾﺣددھﺎ اﻟﻣﺑرﻣﺞ .وﺷﻛﻠﮭﺎ اﻟﻌﺎم‬

                                                                                       ‫ھﯾﻛﻠﯾﺔ ‪For--Loop‬‬
        ‫)‪for (Initializing; Boolean_Expression; Update‬‬
        ‫{‬
        ‫‪statement‬‬
        ‫}‬
                      ‫‪ :(Initializing) ‬ھﻲ اﻟﻘﯾﻣﺔ اﻟﺑداﺋﯾﺔ اﻟﻣﻌطﺎة ﻟﻠﻣﺗﻐﯾر اﻟﺗﻲ ﻣﻧﮭﺎ ﺳﯾﺑدأ اﻟﻌد. )ﻣﺛﻼ 0=‪(i‬‬
 ‫‪ :(Boolean_Expression) ‬ھو ﺷرط اﻟﺗوﻗف اﻟذي ﻋﻧدﻣﺎ ﺗﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻏﯾر ﻣﺣﻘﻘﺔ ﻟﺷرط اﻟﺗوﻗف‬
                                                                           ‫ﺳوف ﯾﺧرج ﻣن ﻋﺑﺎرة )‪. (for‬‬
 ‫ﺑﻣﻌﻧﻰ أﺧر ﻣﺎدام ﻧﺗﯾﺟﺔ اﺧﺗﺑﺎر )‪ (Boolean_Expression‬ھﻲ )‪ (True‬اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﺗﺳﺗﻣر ﺑﺎﻟﺗﻛرار‬
‫وﻣﺗﻰ أﺻﺑﺢ )‪ (False‬ﯾﺧرج ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ. ﻣﺛﻼ ) 5<‪ ( i‬ھو ﺷرط اﻟﺗوﻗف ﻣﺛﻼ ﯾﺑدأ اﻟﻌد ﻣن اﻟواﺣد‬
                                                      ‫ﺳﯾﺗوﻗف إذا أﺻﺑﺢ )5=‪ (i‬ﻷﻧﮫ ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ )‪(False‬‬
 ‫‪:(Update) ‬ھﻲ ﻣﻘدار اﻟزﯾﺎدة أو اﻟﻧﻘﺻﺎن ﻓﻲ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻓﻲ ﻛل دورة )‪ .(loop‬ﻣﺛﻼ )++‪ ( i‬أو )--‪ (i‬وﻻ‬
   ‫ﯾﺧﺗﻠف إذا ﻛﺎن اﻟﺷرط )--‪ (i++ or ++i , --i or i‬ﻷﻧﮫ ﻓﻲ ﻛل اﻟﺣﺎﻻت ﻻ ﺗزداد ﻗﯾﻣﺔ اﻟﻌداد إﻻ ﺑﻌد ﺗﻧﻔﯾذ‬
                    ‫اﻟﺟﻣل ﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻣؤﺛرا ﻋﻠﻰ ﺷرط اﻟﺗﻛرار ﻓﻲ اﻟدورة اﻟﺟدﯾدة اﻟﺗﻲ ﺗﻠﯾﮫ‬

   ‫‪ :(statement) ‬ھﻲ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺳﺗﻧﻔذ ﻋدد ﻣن اﻟﻣرات .إذا ﻛﺎﻧت ﻋﺑﺎرة ﻋن ﺧطوة ﺑرﻣﺟﯾﺔ‬
          ‫واﺣدة ﻓﻠﯾس ﺑﺣﺎﺟﺔ ﻟوﺿﻌﮭﺎ داﺧل أﻗواس وإذا ﻛﺎﻧت أﻛﺛر ﻣن ﺧطوة ﯾﺟب وﺿﻌﮭﺎ داﺧل أﻗواس.‬
                                                                                                             ‫ﻣﮭم‬


                                                                    ‫ﻛﯾف ﺗﻌﻣل ﻋﺑﺎرة )‪ (For‬اﻟﺗﻛرارﯾﺔ........؟‬

   ‫أن اﻟﻣﺗﻐﯾر ﯾﺑدأ ﺑﻘﯾﻣﺔ ﺑداﺋﯾﺔ )‪ (Initializing‬وﯾﺳﺗﻣر ﺑﺎﻟزﯾﺎدة أو اﻟﻧﻘﺻﺎن ﺣﺳب )‪ (Update‬إي ﻗد ﯾزداد أو ﯾﻧﻘص‬
 ‫ﺑﻣﻘدار واﺣد أو أﻛﺛر ﻣن واﺣد وﻣﺗﻰ ﻣﺎ أﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻏﯾر ﻣﺣﻘﻘﺔ ﻟﻠﺷرط )‪ (Boolean_Expression‬ﯾﺧرج‬
  ‫ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ إﻟﻰ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺗﻠﯾﮫ. وإذا ﻛﺎﻧت ﻣﺣﻘﻘﺔ ﻟﻠﺷرط ﯾﻧﻔذ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ داﺧل‬
                                                                                           ‫اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ‬

                                             ‫‪ ‬ﻹدﺧﺎل )‪ (for‬ﻓﻲ دوارة ﻻﻧﮭﺎﺋﯾﺔ ﻧﻛﺗب );;(‪ for‬ﻓﻘط .‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                          ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                        ‫ﻣﺛﺎل: ﻟو أردﻧﺎ ﻋداد ﯾﻌد ﻣن )0( إﻟﻰ )4( إي ﯾطﺑﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻣن )4 3 2 1 0( .؟‬
 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                   ‫>‪#Include<stdio.h‬‬
 ‫)(‪main‬‬                                                 ‫)(‪main‬‬
 ‫;‪{1.int i‬‬                                              ‫;‪{1.int i‬‬
 ‫)++‪2.for (i=0; i<5; i‬‬                                  ‫)++‪2.for (i=0; i<5; i‬‬
 ‫;"‪3.cout<<i<<"\t‬‬                                       ‫;)‪3.prin ("%d\t",i‬‬
 ‫}‬                                                      ‫}‬
                                                                                        ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬

                                                        ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (i‬ﻣن ﻧوع ‪integer‬‬
   ‫٢.ﺧطوة رﻗم )٢(ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد اﻟﻌد ﻣن اﻟﺻﻔر ﻓﺄﻋطﯾﻧﺎ اﻟﻘﯾم اﻟﺑداﺋﯾﺔ ﺻﻔر .واﻟﻌد ﯾﺻل إﻟﻰ ٤‬
    ‫ﻣﻌﻧﺎه ﺷرط اﻟﺗوﻗف أن ﯾﻛون اﻗل ﻣن ﺧﻣﺳﺔ ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد أن ﯾﻌد ﺧﻣس ﻋدات ﺑﯾن ﺻﻔر واﻷرﺑﻌﺔ ﻟذاﻟك ﯾﺟب أن‬
   ‫ﯾﻛون ﻣﻘدار اﻟزﯾﺎدة واﺣد ﻟﯾﻌد )4,3,2,1, 0( .ﻻن ﻟو ﺟﻌﻠﻧﺎ ﻣﻘدار اﻟزﯾﺎدة ٢ ﻣﺛﻼ ﻓﺳﯾﻌد اﻟﻌداد ﺛﻼث ﻣرات وﺑﺷﻛل‬
                                                     ‫اﻟﺗﺎﻟﻲ)4,2,0( ﻟذاﻟك ﯾﺟب اﻟﺗرﻛﯾز ﻓﻲ ھذه اﻟﻣواﺿﯾﻊ ﺟﯾدا‬
                                               ‫اﻟﻘﯾﻣﺔ اﻟﺑداﺋﯾﺔ‬                                           ‫ﻣﮭم‬
                                               ‫ﻟﻠﻌداد )0=‪(i‬‬

                                                 ‫ﺷرط اﻟﺗﺣﻘق)5<‪(i‬‬




                                                   ‫طﺑﺎﻋﺔ اﻟﻘﯾﻣﺔ‬


                                                  ‫زﯾﺎدة ﻗﯾﻣﺔ اﻟﻌداد‬
                                                 ‫)++‪ (i‬ﺑﻌد ﺗﻧﻔﯾذ ﻣﺎ‬
                                                 ‫ﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة‬
                                                      ‫اﻟﺗﻛرارﯾﺔ‬


                                                  ‫ﺧروج ﻣن ﺟﻣﻠﺔ‬
                                                      ‫اﻟﺗﻛرار‬


 ‫ﻟو ﺗﻼﺣظ اﻟﻣﺧطط اﻟﺧﺎص ﺑﺎﻟﺑرﻧﺎﻣﺞ ﻋﻧدﻣﺎ ﯾﺣﻘق اﻟﺷرط ﯾﺗﺟﮫ ﻟﺧطوة اﻟطﺑﺎﻋﺔ وإذا ﻟم ﯾﺣﻘق ﯾﺧرج ﻣن ﺟﻣﻠﺔ ﺗﻛرار‬

  ‫٣.ﺧطوة رﻗم )٣( ھﻲ طﺑﺎﻋﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻋﻧد ﻛل ) ‪ ( loop‬وﺑﻣﺎ أن اﻟذي ﯾﺗﺑﻊ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﺳطر واﺣد ﻓﻠﯾس‬
                                                                     ‫ﺑﺣﺎﺟﺔ ﻟوﺿﻌﮫ ﺑﯾن ﻗوﺳﯾن ﺗﺿﻣﯾن) }{( .‬

                                                                                   ‫ﺳﯾطﺑﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

      ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات: ﺗﻧﻔذ ﺧطوة رﻗم )١( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٢( وﺧطوة رﻗم )٣( ﺧﻣس‬
                                                                            ‫ﻣرات ﺑﻘدر ﻋدات اﻟﻌداد‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                              ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                      ‫ﻣﺛﺎل: ﻟو أردﻧﺎ ﻋداد ﯾﻌد ﻣن )4( إﻟﻰ )0( إي ﯾطﺑﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ )0 1 2 3 4 ( .؟‬

‫ﺗﺣﻠﯾل:ﺣﻠﮭﺎ ﻧﻔس ﺣل اﻟﺳؤال اﻟﺳﺎﺑق ﻓﻘط ﻧﻘﻠب اﻟﻌداد إي ﻧﺟﻌل ﻗﯾﻣﺗﮫ اﻟﺑداﺋﯾﺔ ھﻲ ٤ وﺷرط اﻟﺗوﻗف اﻛﺑر أو ﯾﺳﺎوي‬
                                                                      ‫ﺻﻔر وﯾﺗﻧﺎﻗص ﺑﻣﻘدار واﺣد ﻛل ﻋدة‬



        ‫++‪C‬‬                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i‬‬
        ‫)--‪2.for (i=4; i>=0; i‬‬
        ‫;"‪3.cout<<i<<"\t‬‬
        ‫}‬


         ‫‪C‬‬                                                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#Include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i‬‬
        ‫)--‪2. for (i=4; i>=0; i‬‬
        ‫;)‪3.printf("%d\t",i‬‬
        ‫}‬



                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬

                                                         ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (i‬ﻣن ﻧوع ‪integer‬‬

     ‫٢.ﺧطوة رﻗم )٢(ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد اﻟﻌد ﻣن اﻷرﺑﻌﺔ ﻓﺄﻋطﯾﻧﺎ اﻟﻘﯾم اﻟﺑداﺋﯾﺔ أرﺑﻌﺔ .واﻟﻌد ﯾﺻل إﻟﻰ‬
‫اﻟﺻﻔر ﻣﻌﻧﺎه ﺷرط اﻟﺗوﻗف أن ﯾﻛون اﻛﺑر أو ﯾﺳﺎوي ﺻﻔر ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد أن ﯾﻌد ﺧﻣس ﻋدات ﺑﯾن ﺻﻔر واﻷرﺑﻌﺔ ﻟذاﻟك‬
‫ﯾﺟب أن ﯾﻛون ﻣﻘدار ﻧﻘﺻﺎن واﺣد ﻟﯾﻌد )0,1,2,3,4( .ﻻن ﻟو ﺟﻌﻠﻧﺎ ﻣﻘدار اﻟﻧﻘﺻﺎن ٢ ﻣﺛﻼ ﻓﺳﯾﻌد اﻟﻌداد ﺛﻼث ﻣرات‬
                                                         ‫ﻣرة)0,2,4( ﻟذاﻟك ﯾﺟب اﻟﺗرﻛﯾز ﻓﻲ ھذه اﻟﻣواﺿﯾﻊ ﺟﯾدا‬


                                                                                     ‫ﺳﯾطﺑﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




                                                                                  ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:‬

         ‫ﺗﻧﻔذ ﺧطوة رﻗم )١( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٢( وﺧطوة رﻗم )٣( ﺧﻣس ﻣرات ﺑﻘدر ﻋدات اﻟﻌداد‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                 ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                            ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﺟﻣﻊ اﻹﻋداد اﻟﻔردﯾﺔ ﺑﯾن ) 001—0(‬

  ‫ﺗﺣﻠﯾل: ﻧرى اﻧﮫ ﯾرﯾد اﻹﻋداد اﻟﻔردﯾﺔ ﻓﻘط ﻟذاﻟك ﯾﺟب أن ﻧﺗﺟﺎوز اﻹﻋداد اﻟزوﺟﯾﺔ .ﻧﻛون ﻋداد ﯾﻌد ﻣن اﻟواﺣد وﺷرط‬
 ‫اﻟﺗوﻗف ﻋﻧد اﻟﻣﺋﺔ وﻣﻘدار اﻟزﯾﺎدة ﻓﻲ )٢( ﺣﺗﻰ ﻧﺟﻣﻊ ﻓﻘط اﻹﻋداد اﻟﻔردﯾﺔ ) اﻟﻌداد أوﻻ ﯾﻌد اﻟرﻗم واﺣد وإذا أﺿﻔﻧﺎ إﻟﯾﮫ‬
                 ‫)٢( ﯾﻌد اﻟرﻗم ﺛﻼﺛﺔ وإذا أﺿﻔﻧﺎ )٢( ﯾﻌد ﺧﻣﺳﺔ وإذا أﺿﻔﻧﺎ )٢( ﯾﻌد اﻟرﻗم ﺳﺑﻌﺔ وﯾﺳﺗﻣر إﻟﻰ )٩٩( (‬

        ‫++‪C‬‬                                                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int n‬‬
        ‫;0=‪2.int sum‬‬
        ‫)2+‪3.for (n=1; n<100; n=n‬‬
        ‫; ‪4. sum += n‬‬
        ‫;‪5.Cout<<"sum="<<sum‬‬
        ‫}‬


        ‫‪C‬‬                                                                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int n‬‬
        ‫;0=‪2.int sum‬‬
        ‫)2+‪3.for (n=1; n<100; n=n‬‬
        ‫; ‪4. sum += n‬‬                                                                                            ‫ﻣﮭم‬
        ‫;)‪5.printf("sum=%d",sum‬‬
        ‫}‬
                                                                                              ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                           ‫١. ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ) ‪ (n‬ﻣن ﻧوع )‪ (integer‬ﻟﯾﻛون ﻋداد ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ‬
‫٢. ﺧطوة رﻗم )٢( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (sum‬ﻣن ﻧوع )‪ (integer‬وأﻋطﯾﻧﺎه ﻗﯾﻣﺔ ﺑداﺋﯾﺔ وھﻲ ﺻﻔر ﻷﻧﻧﺎ ﺳﻧﺟﻣﻊ واﻟﻧﺿﯾر‬
                             ‫اﻟﺟﻣﻌﻲ ھو ﺻﻔر ﺣﺗﻰ ﻋﻧدﻣﺎ ﻧﺟﻣﻌﮫ ﻣﻊ أول ﻗﯾﻣﺔ وھﻲ واﺣد ﺳﯾﺟﻣﻊ واﺣد ﻣﻊ اﻟﺻﻔر‬
   ‫اﻟﺗﺑﺎس:ﻗد ﯾﺳﺄل ﺳﺎﺋل ﻟﻣﺎ ﻻ ﻧﺟﻣﻌﮫ ﻣﺑﺎﺷر إي ﻻ ﻧﺻﻔر ﻗﯾﻣﺔ )‪ (sum‬ھذا ﺷﻲء ﺧﺎطﺊ ﻷﻧﮫ ﻛﻣﺎ ﻧﻌﻠم أن اﻟﻣﺗﻐﯾرات‬
     ‫ﻋﻧد ﺗﻌرﯾﻔﮭﺎ ﺗﺣﺟز ﻣﻛﺎن ﻓﻲ اﻟذاﻛرة ﻟﻛن ﻻ ﯾﺧزن ﻓﻲ ذاﻟك اﻟﻣﻛﺎن ﻗﯾﻣﺔ ﯾﺑﻘﻰ ﻓﺎرغ ﻟذاﻟك ﻟو ﺟﻣﻌﻧﺎه ﺑدون ﺗﺻﻔﯾر‬
  ‫ﻟﺟﻣﻊ ﻗﯾﻣﺔ أول ﻋدد ﻓردي ﻣﻊ ﻋﻧوان اﻟﻣوﻗﻊ وﻟﯾس ﻗﯾﻣﺔ اﻟﻣﺧزﻧﺔ ﻓﻲ اﻟﻣوﻗﻊ ﻻن اﻟﻣوﻗﻊ ﻟﯾس ﻓﯾﮫ إي ﻗﯾﻣﺔ ﻟذاﻟك‬
                                                                          ‫ﯾﺟب وﺿﻊ ﻗﯾﻣﺔ ﻓﻲ اﻟﻣوﻗﻊ وھﻲ ﺻﻔر‬
        ‫٣. ﺧطوة رﻗم )٣( ﻛوﻧﺎ ﻋداد ﯾﻌد ﻣن اﻟواﺣد إﻟﻰ ٩٩)ﻻن ﻋﻧدﻣﺎ ﯾﺻﺑﺢ ١٠١ ﯾﻛون أﻋﻠﻰ ﻣن ٠٠١ ﻓﻼ ﯾﻧﻔذه(‬
       ‫٤. ﺧطوة رﻗم )٤( ﺟﻣﻌﻧﺎ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬ﻣﻊ ﻗﯾﻣﺔ اﻟﻌداد ﻋﻧد ﻛل ﻋدة. إي ﻋﻧدﻣﺎ ﯾﻛون ) 1=‪ (n‬ﺳﯾﺟﻣﻊ‬
   ‫)1+0=‪ (sum‬وﻋﻧدﻣﺎ ﯾﺻﺑﺢ ) 3=‪ (n‬ﺳﯾﺟﻣﻊ ﻗﯾﻣﺔ )‪ (sum‬اﻟﺳﺎﺑﻘﺔ وھﻲ أﺻﺑﺣت واﺣد ﻣﻊ ﺛﻼﺛﺔ )3+1=‪(sum‬‬
 ‫وﻋﻧدﻣﺎ ﯾﺻﺑﺢ ) 5=‪ (n‬ﺳﯾﺟﻣﻊ ﻗﯾﻣﺔ )‪ (sum‬اﻟﺳﺎﺑﻘﺔ وھﻲ أﺻﺑﺣت أرﺑﻌﺔ ﻣﻊ ﺛﻼﺛﺔ )5+4=‪ (sum‬وﯾﺳﺗﻣر. وﻧﻼﺣظ‬
               ‫إﻧﻧﺎ ﻟم ﻧﺣﯾط ﺧطوة راﺑﻌﺔ ﺑﯾن ﻗوﺳﻲ ﻻن ﻋﺑﺎرة اﻟﺗﻛرار ﺗﺗﺑﻌﮭﺎ ﺧطوة واﺣد ﻓﻠﯾس ﺑﺎﻟﺣﺎﺟﺔ ﻟوﺿﻊ أﻗواس‬
                                                          ‫٥. ﺧطوة رﻗم )٥( طﺑﺎﻋﺔ اﻟﻧﺎﺗﺞ اﻟﺟﻣﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
  ‫0052=‪Sum‬‬
  ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:ﺗﻧﻔذ ﺧطوة رﻗم )١و٢( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٣( وﺧطوة رﻗم )٤( ﺧﻣﺳﯾن‬
                    ‫ﻣرة ﻻن اﻹﻋداد اﻟﻔردﯾﺔ ﺑﯾن)001—0( ھﻲ ﺧﻣﺳﯾن رﻗم وﺗﻧﻔذ ﺧطوة رﻗم)٥( ﻣرة واﺣدة‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                         ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﯾدﺧل اﻟﻣﺳﺗﺧدم درﺟﺎت ٠١ ﻣواد وﺗﻘوم ﺑﺣﺳﺎب اﻟﻣﻌدل ﻟﮫ‬

   ‫ﺗﺣﻠﯾل: ﺑﻣﺎ اﻧﮫ ﯾرﯾد ﺣﺳﺎب اﻟﻣﻌدل ﻣن ﻋﺷر درﺟﺎت ﻓﯾﺟب ﺟﻣﻊ ھذه اﻟدرﺟﺎت وﻗﺳﻣﺗﮭﺎ ﻋﻠﻰ ﻋﺷرة ﻟﻠﺣﺻول ﻋﻠﻰ‬
   ‫اﻟﻣﻌدل وﺑﻣﺎ أن ﯾدﺧﻠﮭﺎ اﻟﻣﺳﺗﺧدم وﺑﻣﺎ إﻧﮭن ﻋﺷر درﺟﺎت ﻓﯾﺻﻌب إدﺧﺎﻟﮭﺎ ﻛل واﺣد ﻋﻠﻰ ﺣدة ﻟذاﻟك ﻧﺳﺗﺧدم ﻋﺑﺎرة‬
    ‫) ‪ (For‬اﻟﺗﻛرارﯾﺔ ﺗﺗﻛرر ﻋﺷر ﻣرات وﻧﺿﻊ ﺗﺣﺗﮭﺎ ﺟﻣﻠﺔ اﻟﻘراءة )ﺣﯾث ﻋﻧد ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﯾطﻠب ﻣﻧك‬
                 ‫إدﺧﺎل درﺟﺔ وﯾﺟﻣﻊ اﻟدرﺟﺎت اﻟﻣدﺧﻠﺔ ﻋﻧد ﻛل إدﺧﺎل وﻧﺎﺗﺞ اﻟﺟﻣﻊ ﯾﻘﺳم ﺑﻌد اﻹدﺧﺎل ﻋﻠﻰ ﻋﺷرة‬

        ‫++‪C‬‬                                                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int n,aveg,input_number‬‬
        ‫;0=‪2.int sum‬‬
        ‫{ )++‪3.for (n=0; n<10; n‬‬
        ‫;‪4. cin>> input_number‬‬
        ‫}; ‪5. sum += input_number‬‬
        ‫;01/‪6. aveg=sum‬‬
        ‫; ‪7.Cout<<" aveg ="<< aveg‬‬
        ‫}‬


        ‫‪C‬‬                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int n,aveg,input_number‬‬
        ‫;0=‪2.int sum‬‬
        ‫{ )++‪3.for (n=0; n<10; n‬‬
        ‫;)‪4. scanf("%d", &input_number‬‬
        ‫}; ‪5. sum += input_number‬‬
        ‫;01/‪6. aveg=sum‬‬
        ‫;) ‪7. printf(" aveg =%d", aveg‬‬
        ‫}‬
                                                                                                        ‫ﺗﺣﻠﯾل:‬

   ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ) ‪ (n‬ﻟﯾﻛون ﻋداد ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ وﻣﺗﻐﯾر ﺣﺳﺎب اﻟﻣﻌدل وﻣﺗﻐﯾر إدﺧﺎل اﻟدرﺟﺎت‬
 ‫٢.ﺧطوة رﻗم )٢( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (sum‬ﻣن ﻧوع )‪ (integer‬وأﻋطﯾﻧﺎه ﻗﯾﻣﺔ ﺑداﺋﯾﺔ وھﻲ ﺻﻔر ﻷﻧﻧﺎ ﺳﻧﺟﻣﻊ واﻟﻧﺿﯾر‬
                                                                                           ‫اﻟﺟﻣﻌﻲ ھو ﺻﻔر‬
     ‫٣. ﺧطوة رﻗم )٣( ھﻲ ﺟﻣﻠﺔ ﺗﻛرارﯾﺔ ﻣطﻠوب ﻣﻧﮭﺎ ﺗﻛرر اﻟﺧطوة رﻗم )٤( وﺧطوة رﻗم )٥( ﻋﺷر ﻣرات وﺑﻣﺎ اﻧﮫ‬
                               ‫ﻣطﻠوب أن ﯾﻛرر أﻛﺛر ﻣن ﺳطر ﺑرﻣﺟﻲ ﯾﺟب وﺿﻌﮭﻣﺎ ﺑﯾن ﻗوﺳﻲ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ‬
              ‫٤.ﺧطوة رﻗم )٤( ھﻲ داﻟﺔ إدﺧﺎل ﻋﻧد ﻛل ﻋدة ﻟﻠﺟﻣﻠﺔ اﻟﺗﻛرارﯾﺔ ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل درﺟﺔ ﺟدﯾدة‬
  ‫٥. ﺧطوة رﻗم )٥( ﯾﻘوم ﺑﺟﻣﻊ اﻟدرﺟﺎت اﻟﻣدﺧﻠﺔ ﻋﻧد ﻛل إدﺧﺎل ﯾﺟﻣﻊ اﻟدرﺟﺔ اﻟﺟدﯾدة ﻣﻊ ﻧﺎﺗﺞ ﺟﻣﻊ اﻟدرﺟﺎت اﻟﺳﺎﺑﻘﺔ‬
                          ‫٦.ﺧطوة رﻗم )٦( ﯾﻘوم ﺑﺣﺳﺎب اﻟﻣﻌدل ﺣﯾث ﯾﻘﺳم ﻧﺎﺗﺞ ﺟﻣﻊ اﻟدرﺟﺎت اﻟﻣدﺧﻠﺔ ﻋﻠﻰ ﻋﺷرة‬
                                                                        ‫٧.ﺧطوة رﻗم )٧( ﯾﻘوم ﺑطﺑﺎﻋﺔ اﻟﻣﻌدل‬

 ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:ﺗﻧﻔذ ﺧطوة رﻗم )١و٢( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٣و ٤و٥( ﻋﺷر ﻣرات وﺗﻧﻔذ‬
                                                                     ‫ﺧطوة رﻗم)٦ و٧( ﻣرة واﺣدة‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                 ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                              ‫ﻣﺛﺎل: ﻟﻣﻌرﻓﺔ ھل اﻟﻌدد اﻟذي أدﺧﻠﺗﮫ ﻋدد أوﻟﻲ أم ﻻ‬

     ‫ﺗﺣﻠﯾل: اﻟﻌدد اﻷوﻟﻲ ھو اﻟﻌدد اﻟذي ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﻧﻔﺳﮫ وﻋﻠﻰ واﺣد ﻓﻘط )إذا ﻗﺑل اﻟرﻗم اﻟﻘﺳﻣﺔ ﻋﻠﻰ ﻏﯾر ھذان‬
  ‫اﻟرﻗﻣﺎن ﻓﮭو ﻋدد ﻏﯾر أوﻟﻲ( .وﻟﺣل ھذا اﻟﺳؤال ﻧﻛون ﻋداد ﯾﻌد ﻣن اﻻﺛﻧﺎن إﻟﻰ اﻗل ﻣن اﻟرﻗم اﻟﻣدﺧل ﺑواﺣد )ﻣﺛﻼ‬
 ‫إذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ١٢ ﻧﻛون ﻋدد ﯾﻌد ﻣن ٢ إﻟﻰ ٠٢( وإذا ﻗﺑل اﻟرﻗم اﻟﻣدﺧل اﻟﻘﺳﻣﺔ ﻋﻠﻰ إي ﻣن أرﻗﺎم اﻟﻌداد اﻟﺗﻲ‬
 ‫ﺳﯾﻌدھﺎ وھﻲ اﻟﻣﺣﺻورة ﺑﯾن اﺛﻧﺎن واﻗل ﻣن اﻟرﻗم ﺑواﺣد ﻓﯾﻛون ﻋدد ﻏﯾر أوﻟﻲ وإذا ﻟم ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ إي ﻣن ھذه‬
                                                                                      ‫اﻹﻋداد ﻓﮭو ﻋدد أوﻟﻲ .‬
        ‫++‪C‬‬                                                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,input_number‬‬
        ‫;0=‪2.int booleanx‬‬
        ‫;‪3.cin>> input_number‬‬
        ‫)++‪4.for(i=2;i< input_number ;i‬‬
        ‫)0==‪5.if( input_number%i‬‬
        ‫;1=‪6.booleanx‬‬
        ‫)1==‪7.if (booleanx‬‬
        ‫; "‪8.cout<<"The Number is no prime‬‬
        ‫‪9.else‬‬
        ‫} ; "‪10.cout<<" The Number is prime‬‬


         ‫‪C‬‬                                                                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,input_number‬‬
        ‫;0=‪2.int booleanx‬‬
        ‫;)‪3.scanf("%d",& input_number‬‬
        ‫)++‪4.for(i=2;i< input_number ;i‬‬
        ‫)0==‪5.if( input_number%i‬‬
        ‫;1=‪6.booleanx‬‬
        ‫)1==‪7.if (booleanx‬‬
        ‫; )"‪8.prin ("The Number is no prime‬‬
        ‫‪9.else‬‬
        ‫} ;) "‪10.prin (" The Number is prime‬‬

                                                                                              ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                                                       ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر ﻟﻠﻌداد وأﺧر ﻟﻠرﻗم اﻟﻣدﺧل‬
 ‫٢.ﺧطوة رﻗم )٢( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر واﻋﺗﺑر ﻛﻣﺗﻐﯾر ﻣﻧطﻘﻲ وأﻋطﯾﺔ ﻗﯾﻣﺔ ﺻﻔر إذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل أوﻟﻲ ﯾﺑﻘﻰ ﺻﻔر‬
  ‫ﺣﺗﻰ ﻧﮭﺎﯾﺔ اﻟﺑرﻧﺎﻣﺞ وإذا ﻛﺎن ﻏﯾر أوﻟﻲ ﯾﺗﻐﯾر ﻓﻲ ﺧطوة رﻗم )٦( إﻟﻰ واﺣد ﻟﻠدﻻﻟﺔ ﻋﻠﻰ أن اﻟرﻗم اﻟذي ﺗم إدﺧﺎﻟﮫ رﻗم‬
   ‫ﻏﯾر أوﻟﻲ ﺣﺗﻰ ﻓﻲ ﻧﮭﺎﯾﺔ اﻟﺑرﻧﺎﻣﺞ وﺑﺎﻟﺗﺣدﯾد ﻓﻲ ﺧطوة رﻗم )٧( ﻧﺗﺄﻛد ﻣن ﻗﯾﻣﺔ ھذا اﻟﻣﺗﻐﯾر إذا ﺑﻘﻰ ﺻﻔر ﻓﻛﺎن اﻟرﻗم‬
                                                       ‫اﻟﻣدﺧل أوﻟﻲ وإذا ﺗﻐﯾر إﻟﻰ واﺣد ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ﻏﯾر أوﻟﻲ‬
                                      ‫٣.ﺧطوة رﻗم )٣(ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل اﻟرﻗم ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻟﻠﺗﺣﻘق ﻣﻧﮫ‬
                          ‫٤.ﺧطوة رﻗم )٤( ﻋداد ﯾﻌد ﻣن اﻻﺛﻧﺎن إﻟﻰ اﻗل ﻣن اﻟرﻗم اﻟﻣدﺧل ﺑواﺣد وﯾزداد ﺑﻣﻘدار واﺣد‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                 ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




    ‫٥.ﺧطوة رﻗم )٥( ﻧﺗﺣﻘق ھل ﯾﻘﺑل اﻟرﻗم اﻟﻣدﺧل اﻟﻘﺳﻣﺔ ﻋﻠﻰ أي رﻗم ﻣن اﻷرﻗﺎم اﻟﺗﻲ ﺳﯾﻌدھﺎ اﻟﻌداد إذا ﻗﺑل اﻟﻘﺳﻣﺔ‬
                                                          ‫ﻧﻐﯾر ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر اﻟﻣﻧطﻘﻲ إﻟﻰ واﺣد ﻓﻲ ﺧطوة رﻗم )٦(‬
  ‫٦.ﺧطوة رﻗم )٧( ﺑﻌد أن ﯾﻧﺗﮭﻲ اﻟﻌداد ﻣن اﻟﻌد ﺳﯾﺗﺟﮫ اﻟﺑرﻧﺎﻣﺞ إﻟﻰ ھذه اﻟﺧطوة وﻧﺗﺄﻛد ﻣن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر اﻟﻣﻧطﻘﻲ إذا‬
                                                                    ‫ﺗﻐﯾرت إﻟﻰ واﺣد ﻧطﺑﻊ رﺳﺎﻟﺔ أن ﻋدد ﻏﯾر أوﻟﻲ‬
                                                   ‫وإذا ﺑﻘﯾت ﺻﻔر ﻧطﺑﻊ رﺳﺎﻟﺔ أن اﻟرﻗم اﻟذي ﺗم إدﺧﺎﻟﮫ ھو ﻋدد أوﻟﻲ‬
                                           ‫ﺑﻌد أن ﻧﻔذﻧﺎ اﻟﺑرﻧﺎﻣﺞ وأدﺧﻠﻧﺎ اﻟرﻗم ٣١ اﻧظر ﻣﺎذا ظﮭر ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




                                        ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:ﺗﻧﻔذ ﺧطوة رﻗم )١و٢ و٣( ﻣرة واﺣدة ﻓﻘط.‬
 ‫ﻓﺈذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ﻣﺛﻼ ٧ ﺳﺗﻧﻔذ ﺧطوة رﻗم)٤( ﺛﻼث ﻣرات ﻷﻧﮭﺎ ﺳﺗﻌد )4, 3 , 2( وﺳوف ﻻ ﺗﻧﻔذ ﺧطوة رﻗم‬
 ‫)٥ و٦( ﻻن إذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ٧ ﻓﮭو ﻻ ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ)٢ أو ٣ أو ٤( وﺑﻣﺎ اﻧﮫ ﻟم ﯾﻘﺑل اﻟﻘﺳﻣﺔ ﻋﻠﻰ إي ﻣن‬
 ‫ھذه اﻷرﻗﺎم ﺳﺗﺑﻘﻰ ﻗﯾﻣﺔ )0=‪ (booleanx‬ﺛﺎﺑﺗﺔ ﻋﻠﻰ ﻗﯾﻣﺗﮭﺎ اﻷوﻟﯾﺔ ﻟذاﻟك ﺧطوة رﻗم )٧ و ٨( ﻻ ﺗﻧﻔذ ﻻن ﺷرطﮭﺎ ﻟم‬
                                                                  ‫ﯾﺗﺣﻘق ﻟذاﻟك ﺳﺗﻧﻔذ ﺧطوة رﻗم )٩ و٠١(‬

                                                                      ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻹﯾﺟﺎد ﻣﻔﻛوك اﻹﻋداد.؟‬
                ‫ﺗﺣﻠﯾل :اﻟﻣﻔﻛوك ھو ﻋﻣﻠﯾﺔ ﺿرب اﻟﻌدد ﺑﺎﻹﻋداد اﻟﺗﻲ ھﻲ اﻗل ﻣﻧﮫ وﺻوﻻ إﻟﻰ اﻟواﺣد )ﻣﺛﻼ ﻣﻔﻛوك ٦‬
   ‫ھو)1*2*3*4*5*6=!6(( . إي أن ))1-‪ (n!=n*(n‬وﺑرﻣﺟﯾﺎ ﻟﺣل ھذا اﻟﺳؤال ﻧﻛون ﻋدد ﯾﺑدأ ﻣن اﻟواﺣد وﯾﻧﺗﮭﻲ‬
                                ‫ﺑﺎﻟرﻗم اﻟﻣدﺧل وﻧﺿرب ﻗﯾم اﻟﻌداد واﺣدة ﺑﺎﻷﺧرى إﻟﻰ اﻟﻧﮭﺎﯾﺔ ﻧﺣﺻل ﻋﻠﻰ اﻟﻣﻔﻛوك‬

        ‫++‪C‬‬                                                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,number‬‬
        ‫;1=‪2.int fact‬‬
        ‫; ‪3.cin>> number‬‬
        ‫)++‪4.for(i=1;i<= number ;i‬‬
        ‫;‪5.fact = fact *i‬‬
        ‫}; ‪6.cout<<"factoral= "<< fact‬‬


        ‫‪C‬‬                                                                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,number‬‬
        ‫;1=‪2.int fact‬‬
        ‫;) ‪3.scanf("%d",& number‬‬
        ‫)++‪4.for(i=1;i<= number ;i‬‬
        ‫;‪5.fact = fact *i‬‬
        ‫};) ‪6.printf("factoral=%d", fact‬‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                   ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                                                ‫ﺗوﺿﯾﺢ ﺧطوات :‬

      ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر )‪ (i‬ﻛﻌداد ﻟﻌﺑﺎرة اﻟﺗﻛرار وﻣﺗﻐﯾر أﺧر ﯾﺣﻣل ﻗﯾﻣﺔ اﻟرﻗم اﻟﻣراد إﯾﺟﺎد ﻣﻔﻛوﻛﺔ‬

             ‫٢.ﺧطوة رﻗم )٢( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر)‪ (fact‬ﻛﻧﺿﯾر ﺿرﺑﻲ ﯾﺿرب ﻓﻲ أﺟزاء اﻟرﻗم اﻟﻣراد إﯾﺟﺎد ﻣﻔﻛوﻛﺔ‬

                                          ‫٣.ﺧطوة رﻗم )٣( ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل اﻟرﻗم اﻟﻣراد إﯾﺟﺎد ﻣﻔﻛوﻛﺔ‬

 ‫٤.ﺧطوة رﻗم )٤( ﻋداد ﯾﻌد ﻣن اﻟواﺣد وﺣﺗﻰ اﻟرﻗم اﻟذي ﺗم إدﺧﺎﻟﮫ ﻛﺎن ﯾﻛون إﻧﻧﺎ أدﺧﻠﻧﺎ رﻗم ٥ ﺳﯾﻌد )5,4,3,2, 1(‬

       ‫٥.ﺧطوة رﻗم )٥(ھﻧﺎ ﻧﺿرب ﻛل ﻗﯾﻣﺔ ﺟدﯾدة ﯾﻌدھﺎ اﻟﻌداد ﺑﺎﻟﻘﯾم اﻟﺳﺎﺑﻘﺔ ﻛﺎن ﻣﺛﻼ إﻧﻧﺎ أدﺧﻠﻧﺎ رﻗم ٣ ﻧرﯾد إﯾﺟﺎد‬
      ‫ﻣﻔﻛوﻛﮫ ﺳﯾﺿرب أوﻻ واﺣد ﻓﻲ ﻗﯾﻣﺔ )‪ (fact‬ﻟﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ )1=1*1=‪ (fact‬ﺛم ﺳﯾﺿرب ٢ ﻓﻲ ﻗﯾﻣﺔ )1=‪(fact‬‬
     ‫اﻟﺟدﯾدة ﻟﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ )2=2*1=‪ (fact‬ﺛم ﺳﯾﺿرب ٣ ﻓﻲ ﻗﯾﻣﺔ )2=‪ (fact‬اﻟﺟدﯾدة ﻟﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ )6=3*2=‪(fact‬‬

                                                    ‫ﺗوﺿﯾﺢ ﺧطوات اﻟﻣﻔﻛوك اﻟﺧطوة )٤ و٥( إذا ﻛﺎن اﻟرﻗم اﻟﻣدﺧل ٣‬
         ‫1=‪i‬‬
        ‫‪Fact=1*i‬‬
        ‫1=1*1=‪Fact‬‬
        ‫2=‪i‬‬
        ‫‪Fact=1*i‬‬
        ‫2=2*1=‪Fact‬‬
        ‫3=‪i‬‬
        ‫‪Fact=2*i‬‬
        ‫6=3*2=‪Fact‬‬


                                                             ‫٥.ﺧطوة رﻗم )٦( ﺳﯾطﺑﻊ اﻟﻣﻔﻛوك ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

                                                                                   ‫ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ إذا أدﺧﻠﻧﺎ اﻟرﻗم ٦‬




                                         ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:ﺗﻧﻔذ ﺧطوة رﻗم )١و٢ و ٣( ﻣرة واﺣدة ﻓﻘط.‬

   ‫إذا ﻛﺎن اﻟرﻗم اﻟﻣراد إﯾﺟﺎد ﻣﻔﻛوﻛﺔ ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ھو ٣ ﺳﺗﻧﻔذ ﺧطوة رﻗم )٤و٥( ﺛﻼث ﻣرات وﺗﻧﻔذ ﺧطوة‬
                                                                               ‫رﻗم)٦( ﻣرة واﺣدة‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                               ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟﻣﺗﺳﻠﺳﻠﺔ اﻟﺗﺎﻟﯾﺔ )1234567654321(‬

   ‫ﺗﺣﻠﯾل:ﻧرى ﻣن اﻟﺳﻠﺳﻠﺔ أﻧﮭﺎ ﺗﺻل إﻟﻰ ) ٧( وﺗﻌود ﺑﺎﻟﺗﻧﺎﻗص ﻓﻠﺣل ھذا اﻟﻣﺛﺎل ﻧﻛون ﻋداد ﯾﻌد ﻣن اﻟواﺣد إﻟﻰ اﻟﺳﺗﺔ‬
      ‫وإذا ﺗﺟﺎوز اﻟﺳﺗﺔ ﯾﺧرج ﻣن اﻟﺟﻣﻠﺔ اﻟﺗﻛرارﯾﺔ وﻧﺄﺧذ ﻗﯾﻣﺗﮫ اﻟﺟدﯾدة وﻧﺳﻧدھﺎ ﻟﻌداد أﺧر ﯾﺑدأ ﻣﻧﮭﺎ وﯾﻧﺗﮭﻲ ﺑﺎﻟواﺣد‬

        ‫++‪C‬‬                                                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include <iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,j‬‬
        ‫)++‪2.for(i=1;i<7;i‬‬
        ‫;‪3.cout<<i‬‬
        ‫)--‪4.for(j=i;j>0;j‬‬
        ‫} ;‪5.cout<<j‬‬


         ‫‪C‬‬                                                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include <stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,j‬‬
        ‫)++‪2.for(i=1;i<7;i‬‬
        ‫;)‪3.prin ("%d",i‬‬
        ‫)--‪4.for(j=i;j>0;j‬‬
        ‫};)‪5.prin ("%d",j‬‬


                                                                                              ‫ﺗﺣﻠﯾل اﻟﺧطوات:‬

                                                           ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾرﯾن ﻟﻧﺳﺗﺧدﻣﮭﺎ ﻛﻌدادات‬

  ‫٢.ﺧطوة رﻗم)٢( ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﻌد ﻣن )١( إﻟﻰ )٦( وﺗطﺑﻊ ﻗﯾم اﻟﻌداد ﻓﻲ ﺧطوة رﻗم )٣( اﻟﺗﻲ ﺗﻛون ﺗﺎﺑﻌﺔ ﻟﻠﻌﺑﺎرة‬
                                                                                                  ‫اﻟﺗﻛرارﯾﺔ‬

 ‫٣.ﺧطوة رﻗم )٤( ﻋداد ﺟدﯾد ﯾﻌد ﻣن أﺧر ﻗﯾﻣﺔ وﺻل إﻟﯾﮭﺎ اﻟﻌداد اﻷول وﻧﺣن ﻧﻌﻠم أن ﺷرط اﻟﻌداد اﻷول ﺑﺎﻻﺳﺗﻣرار‬
  ‫أن ﯾﻛون ﻗﯾﻣﺔ )‪ (i‬اﻗل ﻣن ﺳﺑﻌﺔ وﻋﻧدﻣﺎ أﺻﺑﺢ ﻗﯾﻣﺗﮫ ﺳﺑﻌﺔ ﺧرج ﻣن اﻟﺟﻣﻠﺔ اﻟﺗﻛرارﯾﺔ إي أن ﻗﯾﻣﺔ )7=‪ (i‬ﻓﻲ اﻟﺧطوة‬
   ‫رﻗم )٤( ﻟذاﻟك ﺳﯾﻌد ھذا اﻟﻌداد ﻣن اﻟﺳﺑﻌﺔ وﯾﺗﻧﺎﻗص إﻟﻰ اﻟواﺣد ﻻن ﺷرط ﺗوﻗف أن ﯾﻛون اﻛﺑر ﻣن ﺻﻔر)إي ﻋﻧدﻣﺎ‬
   ‫ﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ ﺻﻔر ﯾﺧرج ﻣن اﻟﺟﻣﻠﺔ اﻟﺗﻛرارﯾﺔ( .وﯾطﺑﻊ ﻗﯾم اﻟﻌداد ﻓﻲ ﺧطوة رﻗم )٥( ﻷﻧﮭﺎ ﺗﺎﺑﻌﺔ ﻟﻠﺧطوة رﻗم )٤(‬


      ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:ﺗﻧﻔذ ﺧطوة رﻗم )١( ﻣرة واﺣدة ﻓﻘط. ﺳﺗﻧﻔذ ﺧطوة رﻗم )٢و٣( ﺳت ﻣرات وﺗﻧﻔذ‬
                                                                     ‫ﺧطوة رﻗم)٤و ٥( ﺳﺑﻊ ﻣرات.‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                               ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                         ‫٢.٣- ﻋﺑﺎرة )‪ ( For--Loop‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬
     ‫ﺷرﺣﻧﺎ ﺳﺎﺑﻘﺎ ﻋﻠﻰ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻻﻋﺗﯾﺎدﯾﺔ اﻟﺗﻲ ﻧﺣﺗﺎﺟﮭﺎ ﻟﺗﻛرار ﺳطر ﺑرﻣﺟﻲ واﺣد أو ﻋدة اﺳطر ﻟﻐرض ﻣﺎ.‬
    ‫إﻣﺎ ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرار ﺳوف ﻻ ﺗﻛرر ﻓﻘط اﺳطر ﺑرﻣﺟﯾﺔ إﻧﻣﺎ ﺗﻛرر ﻋﺑﺎرات )‪ (for‬ﺗﻛرارﯾﺔ أﺧرى )أو ﻋﺑﺎرات‬
      ‫ﺗﻛرارﯾﺔ أﺧرى ك ‪ (while ,do—while‬ﺗوﺟد ﻓﻲ داﺧﻠﮭﺎ إي ﻓﻲ ﻛل ﻋدة )‪ (for‬إﻻم ﺳﺗﻌد )‪ (for‬اﻟداﺧﻠﯾﺔ‬
   ‫ﺟﻣﯾﻊ ﻋداﺗﮭﺎ.ﺣﺎﻟﮭﺎ ﻛﺣﺎل إي ﺧطوة ﺑرﻣﺟﯾﺔ داﺧل ﻋﺑﺎرة ﺗﻛرارﯾﺔ وﺑﻣﺎ أن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ ﯾﻣر ﻋﻠﯾﮭﺎ ﻋﻧد‬
       ‫ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ إﻻم ﻟذاﻟك ﻓﻲ ﻛل ﻋدة ﻟﻼم ﺗﻌد اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ ﺟﻣﯾﻊ ﻋداﺗﮭﺎ اﻟﻣﻣﻛﻧﺔ ﺣﺳب‬
                                                                                                      ‫ﺷرطﮭﺎ .‬

                                                                                       ‫ھﯾﻛﻠﯾﺔ ‪For--Loop‬‬
        ‫)1‪for (Initializing1; Boolean_Expression1; Update‬‬
        ‫{‬
        ‫)2‪for (Initializing2; Boolean_Expression2; Update‬‬
        ‫{‬
        ‫‪statement‬‬
        ‫}‬
        ‫}‬


                                                                       ‫ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو ﻛﺎن ﻟدﯾﻧﺎ ھذا اﻟﺗداﺧل‬

                                                                                                    ‫ﻣﺛﺎل‬
        ‫)++‪1. for (j=0; j<5; j‬‬
        ‫{‬
        ‫)++‪2. for (i=0; i<5; i‬‬
        ‫{‬
        ‫2‪3.Statement‬‬                                                                                           ‫ﻣﮭم‬
        ‫}‬
        ‫1‪4.Statement‬‬
        ‫}.5‬
     ‫ﻓﻔﻲ ﻛل ﻋدة ﺑﺎﻟﻧﺳﺑﺔ )‪ (for‬ﻓﻲ ﺧطوة رﻗم )١( ﺗﻌد )‪ (for‬ﻓﻲ ﺧطوة رﻗم )٢( ﻣن اﻟﺻﻔر إﻟﻰ اﻷرﺑﻌﺔ وﺗﻧﻔذ‬
                                 ‫)2‪ (Statement‬ﺧﻣس ﻣرات وﺑﻌدھﺎ ﯾﻧﻔذ )1‪ (Statement‬ﻣرة واﺣدة ﻟﻛل ﻋدة .‬
     ‫ﻷن ﻋﻧدﻣﺎ ﯾﺑدأ اﻟﻌداد اﻟﺧﺎرﺟﻲ ﺑﺎﻟﻌد )0=‪ (j‬ﺳﯾﻧﻔذ ﻣﺎ ﻣوﺟود داﺧل ﻗوﺳﯾﮫ ﺑﺎﻟﺗﺳﻠﺳل ﺧطوة ﺧطوة وھﻲ اﻟﺧطوات‬
      ‫رﻗم)٢و٣و٤(. أوﻻ ﺳﯾﻧﻔذ ﺧطوة رﻗم )٢( وﺑﻣﺎ أن ﺧطوة رﻗم )٢( أﯾﺿﺎ ﻋداد ﺳﯾﺑدأ ھذا اﻟﻌداد اﻟداﺧﻠﻲ ﺑﺎﻟﻌد ﻣن‬
   ‫اﻟﺻﻔر إﻟﻰ ﺧﻣﺳﺔ وﻛل ﻋدة ﯾﻧﻔذ ﺧطوة رﻗم )٣( وھﻲ )2‪ (Statement‬ﻷﻧﮭﺎ واﻗﻌﺔ ﺿﻣن ﻗوﺳﯾن ﺧطوة رﻗم )٢(‬
   ‫وﻋﻧدﻣﺎ ﯾﻧﺗﮭﻲ اﻟﻌداد اﻟداﺧﻠﻲ ﻣن ﻋداﺗﮫ ﺳﯾﻧﺗﻘل ﻟﯾﻧﻔذ ﻣﺎ ﺑﻌد ﻗوﺳﻲ اﻟﻌداد ﻓﻲ ﺧطوة )٢( وھﻲ اﻟﺧطوة رﻗم)٤( ﺳﯾﻧﻔذ‬
        ‫)1‪ (Statement‬ﻣرة واﺣدة ﺗم ﯾﺻل ﻓﻲ ﺧطوة رﻗم )٥( إﻟﻰ ﻧﮭﺎﯾﺔ ﻗوس)ﻗوس اﻹﻏﻼق( اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ‬
       ‫اﻟﺧﺎرﺟﯾﺔ ﻓﻲ ﺧطوة رﻗم )١( وﺑﻣﺎ اﻧﮫ وﺻل إﻟﻰ ﻧﮭﺎﯾﺔ ﻗوس اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟﺧﺎرﺟﯾﺔ ﺳﯾﻌود اﻟﻰ اﻟﺧطوة‬



    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                     ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




    ‫رﻗم )١( وﯾزﯾد ﻗﯾﻣﺔ اﻟﻌداد )‪ (j‬ﺑﻣﻘدار واﺣد ﻟﯾﻧﻔذ ﻣﺎ ھو ﻣوﺟود ﺑﯾن ﻗوﺳﻲ ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻣن ﺟدﯾد ﻣﺎ دام‬
                                                                                            ‫ﺷرط ﺗوﻗﻔﮭﺎ ﻟم ﯾﺗﺣﻘق ﺑﻌد‬
                                                ‫‪ ‬إي أن إذا ﻛﺎن )0= ‪ (j‬ﺳﯾﻌد )‪( i‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0(‬
                                                    ‫‪ ‬إذا أﺻﺑﺢ )1= ‪ (j‬ﺳﯾﻌد )‪ ( i‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0(‬
                                                    ‫‪ ‬إذا أﺻﺑﺢ )2= ‪ (j‬ﺳﯾﻌد )‪ ( i‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0(‬
                                                    ‫‪ ‬إذا أﺻﺑﺢ )3= ‪ (j‬ﺳﯾﻌد )‪ (i‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0(‬
                                                    ‫‪ ‬إذا أﺻﺑﺢ )4= ‪ (j‬ﺳﯾﻌد )‪ (i‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0(‬




                                                           ‫اﻟﺗﻧﻔﯾذ اﻟداﺧﻠﻲ ﻟﻠﺧطوة رﻗم ٢ واﻟﺳطر اﻟذي ﯾﺗﺑﻌﮫ‬




                     ‫ﺧطوة رﻗم ٤‬




                                         ‫ﻣﺧطط ﺳﯾر اﻟﻌﻣﻠﯾﺎت اﻟﻣﺛﺎل‬



 ‫ﺗﺑﻘﻰ اﻟﻣﺑﺎدئ ﺛﺎﺑﺗﺔ ﻛل ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﯾﺗﺑﻌﮭﺎ ﺳطر ﺑرﻣﺟﻲ واﺣد إذا ﻟم ﻧﺳﺗﺧدم أﻗواس وإذا وﺿﻌﻧﺎ أﻗواس ﻛل‬              ‫‪‬‬
                                                      ‫اﻟذي داﺧل اﻷﻗواس ھو ﺗﺎﺑﻊ ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ.‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                 ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﺟدول ﺿرب ﻣن )١( إﻟﻰ )٠١( .؟‬

    ‫ﺗﺣﻠﯾل : ﻟو ﻧرﻛز ﻓﻲ اﻟﺳؤال ﻧراه ﯾرﯾد ﺟدول ﺿرب وﺟدول اﻟﺿرب ﻣﻛون ﻣن ﺿرب رﻗﻣﯾﯾن ﻓﻌﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل‬
 ‫ﺟدول ﺿرب ١ ﯾﺿرب رﻗم واﺣد ﺑﺎﻷرﻗﺎم ﻣن واﺣد إﻟﻰ اﻟﻌﺷرة وﺟدول ﺿرب ٢ ﯾﺿرب اﻻﺛﻧﺎن ﺑﺎﻷرﻗﺎم ﻣن واﺣد‬
   ‫إﻟﻰ ﻋﺷرة وﯾﺳﺗﻣر.....! أي إﻧﻧﺎ ﺳﻧﺣﺗﺎج إﻟﻰ ﻋﺑﺎرﺗﯾن ﺗﻛرارﯾﺗﯾن ﻋﺑﺎرة ﺧﺎرﺟﯾﺔ ﺗﺧص ﺟدول ﺿرب اﻟرﻗم وأرﻗﺎم‬
                                                   ‫داﺧﻠﯾﺔ ﺗﺿرب ھذه اﻟرﻗم ﺑﺎﻷرﻗﺎم ﻣن واﺣد إﻟﻰ ﻋﺷرة.‬

        ‫++‪C‬‬                                                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,j‬‬
        ‫)++‪2.for (i=1; i<=10; i‬‬
        ‫;"‪{3.cout<<"Multiply tabel for("<<i<<").\n-------------------------------\n‬‬
        ‫)++‪4.for (j=1; j<=10; j‬‬
        ‫;"‪5.Cout<< j<<" * " <<i<<"="<<i*j<<"\n‬‬
        ‫};"‪6.Cout<<"\n‬‬
        ‫}‬


        ‫‪C‬‬                                                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,j‬‬
        ‫)++‪2.for (i=1; i<=10; i‬‬
        ‫;)‪{3.prin ("Mul ply tabel for(%d).\n-------------------------------\n", i‬‬
        ‫)++‪4.for (j=1; j<=10; j‬‬
        ‫;)‪5.prin ("%d * %d=%d\n",i, j, i*j‬‬
        ‫};)"‪6. printf("\n‬‬
        ‫}‬




                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

      ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾرﯾن اﻟﻣﺗﻐﯾر )‪ (i‬ھو ﺟدول ﺿرب اﻟرﻗم )ﻛﺎن ﯾﻛون ﺟدول ﺿرب ﺛﻼﺛﺔ ﻣﺛﻼ(‬
                                      ‫واﻟﻣﺗﻐﯾر )‪ (j‬ھوا ﯾﺿرب ﺑﺎﻟﻣﺗﻐﯾر اﻷول اﻷرﻗﺎم ﻣن واﺣد إﻟﻰ اﻟﻌﺷرة‬

    ‫٢.ﺧطوة رﻗم )٢( ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﻌد ﻣن )١( إﻟﻰ )٠١( وﻓﻲ ﻛل ﻋدة ﻟﮭﺎ ﺗﺗﻛرر اﻟﺧطوات رﻗم)٣ و٤و٥و٦(‬
     ‫وﻻﺣظ وﺿﻌﻧﺎ ھذه اﻟﺧطوات ﺑﯾن ﻗوﺳﯾن ﻷﻧﮭﺎ أﻛﺛر ﻣن ﺧطوة وﻧرﯾد أن ﻧﺗﺑﻌﮭﺎ ﻟﮭذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻟذاﻟك ﯾﺟب‬
                                                                                          ‫وﺿﻌﮭﺎ ﺑﯾن ﻗوﺳﯾن‬

    ‫٣.ﺧطوة رﻗم )٣( ھﻲ رﺳﺎﻟﺔ ﺗظﮭر ﺑداﯾﺔ ﻛل ﺟدول ﺗﺑﯾن ﻟﻠﻣﺳﺗﺧدم اﻧﮫ ھذا اﻟﺟدول ھو ﻟﻠرﻗم اﻟﻣﻌﯾن وھﻲ ﺑﺿﺑط‬
  ‫اﻟرﺳﺎﻟﺔ اﻟﻣوﺟودة ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻓﻲ اﻷﺳﻔل وﻣؤﺷر ﻋﻠﯾﮭﺎ ب )" ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٣("( وﻛﻣﺎ ﺗﻼﺣظ أن ﻓﻲ‬
            ‫ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟﺧطوة رﻗم )٢( ﺗﺗﻛرر اﻟﺧطوة رﻗم )٣( ﻣرة واﺣدة ﻟﺗظﮭر ﺑداﯾﺔ ﻛل ﺟدول‬



    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                         ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                  ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




   ‫٤.ﺧطوة رﻗم )٤( ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ داﺧﻠﯾﺔ وﻓﻲ ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ اﻟﺧطوة رﻗم )٢( ﺗﻌﻣل ھذه اﻟﻌﺑﺎرة‬
    ‫ﺑﺎﻟﻌد ﻣن )١( إﻟﻰ )٠١( ﻟﻛﻲ ﻧﺿرب ﻛل رﻗم ﻣن اﻷرﻗﺎم اﻟﺗﻲ ﺗﻌدھﺎ اﻟﺧطوة رﻗم )٢( ﺑﺎﻷرﻗﺎم ﻣن )١( إﻟﻰ )٠١(‬
                                                 ‫وھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﯾﺗﺑﻌﮭﺎ ﺳطر واﺣد ﻓﻘط ﻟﻌدم وﺟود أﻗواس‬

‫٥. ﺧطوة رﻗم )٥( ھﻲ ﻋﻣﻠﯾﺔ طﺑﺎﻋﺔ ﻛل ﻗﯾﻣﺔ ﻣن اﻟﺗﻲ ﺗﻌدھﺎ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ اﻟﺧطوة رﻗم )٢( ﺑﺎﻷرﻗﺎم ﻣن )١(‬
 ‫إﻟﻰ )٠١( اﻟﺗﻲ ﺗﻌدھﺎ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ ﺧطوة رﻗم )٤( وھذه ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ ھﻲ ﺗﺎﺑﻌﺔ ﻟﮭذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ وﻣﺎ‬
    ‫ﺗﻧﺗﺟﮫ ھذه ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ ﺷﺎھده ﺑﺎﻟرﺳﺎﻟﺔ اﻟﻣوﺟودة ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻓﻲ اﻷﺳﻔل وﻣؤﺷر ﻋﻠﯾﮭﺎ ب )" ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ‬
                                                                                                ‫اﻟﺧطوة )٥("(‬

     ‫٦. ﺧطوة رﻗم )٦( ھﻲ ﻋﻣﻠﯾﺔ طﺑﺎﻋﺔ ﺳطر ﺟدﯾد ﺑﻌد ﻛل ﺟدول ﺿرب وﻻﺣظﮭﺎ ھﻲ ﺗﺎﺑﻌﺔ ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ‬
   ‫ﺧطوة رﻗم)٢( وﻣﺎ ﺗﻧﺗﺟﮫ ھذه ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ ﺷﺎھده ﺑﺎﻟرﺳﺎﻟﺔ اﻟﻣوﺟودة ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻓﻲ اﻷﺳﻔل وﻣؤﺷر ﻋﻠﯾﮭﺎ ب‬
                                                                             ‫)" ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٦("(‬

                                                                         ‫ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٣(‬




                                                                              ‫ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٥(‬




                                                                               ‫ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٦(‬




                                                                                                                ‫ﻣﮭم‬



                               ‫ﻛﯾف ﻧﻌرف أن اﻟﺧطوة رﻗم )٦( ھﻲ ﺗﺎﺑﻌﮫ ﻟﻠﺧطوة رﻗم )٢( وﻟﯾس ﻟﻠﺧطوة رﻗم )٤(..؟‬

‫ﻛﻣﺎ ﺗﻼﺣظ أن ﺧطوة رﻗم )٢( ﺗﺣﺻر ﺑﯾن ﻗوﺳﯾﮭﺎ ﺧطوات رﻗم)٣و٤و٥و٦( وﻧﻼﺣظ أن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ اﻟﺧطوة‬
   ‫رﻗم )٤( ﺗﺗﺑﻌﮭﺎ ﻓﻘط ﺳطر واﺣد ﻷﻧﻧﺎ ﻟم ﻧﺿﻊ أﻗواس ﺧﻠﻔﮭﺎ أي إﻧﻧﺎ ﻧﻘﺻد ﻓﻘط اﻟﺳطر اﻟذي ﯾﻠﯾﮭﺎ ھو ﺗﺎﺑﻊ ﻟﮭﺎ ﻓﺗﺑﻘﻰ‬
                                          ‫اﻟﺧطوة رﻗم )٦( وﺑﻣﺎ أﻧﮭﺎ داﺧل ﻗوﺳﯾن اﻟﺧطوة رﻗم )٢( ﻓﮭﻲ ﺗﺎﺑﻌﺔ ﻟﮭﺎ.‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                             ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﯾطﺑﻊ اﻟﺷﻛل اﻟﺗﺎﻟﻲ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ .؟‬




   ‫ﺗﺣﻠﯾل: ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻧر اﻧﮫ ﯾﻌد )١( ﺛم )٢١( ﺛم )٣٢١( وﯾﺳﺗﻣر ﻧرى أن ﺗﻛوﯾن رﺳم ﺑﮭذا اﻟﺷﻛل ﯾﺳﺗﺣﯾل دون‬
‫اﺳﺗﺧدام ﻋﺑﺎرات اﻟﺗﻛرار اﻟﻣﺗداﺧﻠﺔ.ﻓﻣﺎ ﻧﺣﺗﺎﺟﮫ ھﻧﺎ ھو ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺧﺎرﺟﯾﺔ ﺗﻌد ﻣن ٢ إﻟﻰ ٦ )أي ﺗﻌد ﺧﻣس ﻋدات‬
 ‫ﺑﻘدر ﻋدد اﻷﺳطر ﺗﻌد)6,5,4,3,2( ( وﻋﺑﺎرة ﺗﻛرارﯾﺔ داﺧﻠﯾﺔ ﺗﺑدأ ﺑﺎﻟﻌد ﻣن اﻟواﺣد وﺷرط ﺗوﻗﻔﮭﺎ اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻌداد‬
 ‫اﻟﺧﺎرﺟﻲ ﻟﻛل ﻋدة ﻣﺛﻼ ﻓﻲ اﻟﻌدة اﻷوﻟﻰ ﺗﻛون ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )2=‪ (i‬ﻓﻲ اﻟﻌداد اﻟﺧﺎرﺟﻲ ﺳﯾﻌد اﻟﻌداد اﻟداﺧﻠﻲ ﻣن واﺣد‬
 ‫إﻟﻰ اﻗل ﻣن )٢( أي ﺳﯾﻌد ) 1( وﻓﻲ اﻟﻌدة اﻟﺛﺎﻧﯾﺔ ﺗﻛون ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )3=‪ (i‬ﻓﻲ اﻟﻌداد اﻟﺧﺎرﺟﻲ ﺳﯾﻌد اﻟﻌداد اﻟداﺧﻠﻲ‬
                                                  ‫ﻣن واﺣد إﻟﻰ اﻗل ﻣن )٣( أي ﺳﯾﻌد ) 21( وﯾﺳﺗﻣر إﻟﻰ ﻧﮭﺎﯾﺔ .‬

        ‫++ ‪C‬‬                                                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,j‬‬
        ‫)++‪2.for (i=2; i<7; i‬‬
        ‫)++‪{3.for (j=1; j<i; j‬‬
        ‫; ‪4.cout<<j‬‬
        ‫}; "‪5.cout<<"\n‬‬
        ‫}‬


        ‫‪C‬‬                                                                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i,j‬‬
        ‫)++‪2.for (i=2; i<7; i‬‬
        ‫)++‪{3.for (j=1; j<i; j‬‬
        ‫;)‪4.prin ("%d",j‬‬
        ‫};)"‪5. printf("\n‬‬
        ‫}‬
                                                                                            ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾرﯾن ﻟﻠﻌدادات .وﻓﻲ ﺧطوة رﻗم )٢( ﻋداد ﺧﺎرﺟﻲ ﯾﻌد ﻣن ٢ إﻟﻰ ٦ وﺗﺗﺑﻌﮫ اﻟﺧطوات‬
                               ‫اﻟﺑرﻣﺟﯾﺔ رﻗم) ٣ و٤و٥( ﻷﻧﮭﺎ داﺧل ﻗوﺳﯾﮫ ﻓﻔﻲ ﻛل ﻋدة ﻟﮫ ﺗﺣدث ھذه اﻟﺧطوات‬

‫٢.ﺧطوة رﻗم )٣( ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ داﺧﻠﯾﺔ ﺗﺑدأ ﺑﺎﻟﻌد ﻣن اﻟواﺣد إﻟﻰ اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻌداد اﻟﺧﺎرﺟﻲ أي إذا ﻋد اﻟﻌداد‬
‫اﻟﺧﺎرﺟﻲ ٢ ﺗﻌد ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ )1( وإذا ﻋد اﻟﻌداد اﻟﺧﺎرﺟﻲ ٣ ﺗﻌد ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ )21( وإذا ﻋد اﻟﻌداد‬
‫اﻟﺧﺎرﺟﻲ ٤ ﺗﻌد ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ )321( وإذا ﻋد اﻟﻌداد اﻟﺧﺎرﺟﻲ ٥ ﺗﻌد ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ) 4321( وﯾﺳﺗﻣر‬

  ‫٣.ﺧطوة رﻗم )٤( ﺗﺎﺑﻌﺔ ﻟﻠﺧطوة رﻗم )٣( ﺣﺗﻰ ﺗطﺑﻊ ﻗﯾم اﻟﻌداد وﺧطوة رﻗم )٥( ﺗﺎﺑﻌﺔ ﻟﻠﺧطوة رﻗم )٢( ﺣﺗﻰ ﺑﻌد ﻛل‬
   ‫طﺑﺎﻋﺔ ﯾﻧزل اﻟﻣؤﺷر إﻟﻰ ﺳطر ﺟدﯾد ﻟﻛﻲ ﯾطﺑﻊ اﻟﻌﺑﺎرة اﻟﺟدﯾدة ﻋﻠﻰ ﺳطر أﺧر. ﺟرب اﺣذﻓﮭﺎ وﺷﺎھد ﻣﺎذا ﺳﯾﺣدث‬



    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                              ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                            ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﯾطﺑﻊ اﻟﺷﻛل اﻟﺗﺎﻟﻲ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ .؟‬




     ‫ﺗﺣﻠﯾل:ھذا اﻟﻣﺛﺎل ﺳﮭل ﻟو رﻛزت ﻓﯾﮫ اﻧﮫ ﯾطﺑﻊ ﻧﺟﻣﺔ وﯾﻧزل ﺳطر ﺛم ﯾطﺑﻊ ﻓراغ وﻧﺟﻣﺔ ﺛم ﯾﻧزل ﺳطر ﺛم ﻓراﻏﺎن‬
‫وﻧﺟﻣﺔ وﯾﻧزل ﺳطر ﺛم ﺛﻼث ﻓراﻏﺎت وﻧﺟﻣﺔ وﯾﻧزل ﺳطر وﯾﺳﺗﻣر ﺑزﯾﺎدة ﻋدد اﻟﻔراﻏﺎت. ﻣﻘدﻣﺎ اﻧﮫ ﯾﺣﺗﺎج إﻟﻰ ﻋدادان‬
‫ﺣﺗﻰ ﯾﻛوﻧﺎ اﻟﺷﻛل اﻟﻣطﻠوب اﻟﻌداد اﻷول ﯾﻌد ﻣن اﻟواﺣد إﻟﻰ اﻟﺧﻣﺳﺔ )ﻷﻧﮭﺎ ﺧﻣس ﻧﺟﻣﺎت( وأﺧر داﺧﻠﻲ ﯾﻌد ﻣن واﺣد‬
                                                      ‫إﻟﻰ اﻗل ﻣن اﻟﻌداد اﻟﺧﺎرﺟﻲ ﻟﯾوﺿﻊ ﻓراﻏﺎت ﻗﺑل اﻟﻧﺟﻣﺎت‬

        ‫++ ‪C‬‬                                                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫; ‪{1.int star , empty‬‬
        ‫)++ ‪2.for(star=1; star <=5; star‬‬
        ‫)++ ‪{3.for( empty =1; empty < star ; empty‬‬
        ‫; " "<<‪4.cout‬‬
        ‫}; "‪5.cout<<"*\n‬‬
        ‫}‬


        ‫‪C‬‬                                                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int star ,empty‬‬
        ‫)++ ‪2.for(star=1; star <=5; star‬‬
        ‫)++ ‪{3.for(empty =1; empty < star ; empty‬‬
        ‫;) " "( ‪4.prin‬‬
        ‫}; )"‪5.prin ("*\n‬‬
        ‫}‬
                                                                                           ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

 ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾرﯾن ﻟﻠﻌدادات اﻷول اﺳم )‪ (star‬ﻟﻠﻧﺟﻣﺎت وأﺧر اﺳﻣﮫ )‪ (empty‬ﻟطﺑﺎﻋﺔ اﻟﻔراﻏﺎت‬
  ‫وﻓﻲ ﺧطوة رﻗم )٢( ﻋداد ﺧﺎرﺟﻲ ﯾﻌد ﻣن ١ إﻟﻰ ٥ وﺗﺗﺑﻌﮫ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ رﻗم ) ٣ و٤و٥( ﻷﻧﮭﺎ داﺧل ﻗوﺳﯾﮫ‬
                                                                    ‫ﻓﻔﻲ ﻛل ﻋدة ﻟﮫ ﺗﺣدث ھذه اﻟﺧطوات‬

 ‫٢.ﺧطوة رﻗم )٣( ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ داﺧﻠﯾﺔ ﺗﺑدأ ﺑﺎﻟﻌد ﻣن اﻟواﺣد إﻟﻰ اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻌداد اﻟﺧﺎرﺟﻲ أي إذا ﻋد اﻟﻌداد‬
‫اﻟﺧﺎرﺟﻲ )١( ﻻ ﺗﻌد ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻷﻧﮭﺎ ﻻ ﯾﺗﺣﻘق ﺷرطﮭﺎ وﻻ ﺗﻧﻔذ وﺧطوة رﻗم )٤( اﻟﺗﺎﺑﻌﺔ ﻟﮭﺎ ﻻ ﺗﻧﻔذ أﯾﺿﺎ‬
‫ﺗﻧﻔذ اﻟﺧطوة رﻗم )٥( ﻓﻘط ﻟﯾطﺑﻊ ﻧﺟﻣﺔ وﯾﻧزل ﺳطر. وإذا ﻋد اﻟﻌداد اﻟﺧﺎرﺟﻲ ٢ ﺗﻌد ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ )1( وﺗﻧﻔذ‬
         ‫ﺧطوة رﻗم)٤( ﻣرة واﺣدة طﺎﺑﻌﺔ ﻓراغ واﺣد ﺛم ﺗﻧﻔذ ﺧطوة رﻗم )٥( طﺎﺑﻌﺔ ﻧﺟﻣﺔ وﺗﻧزل ﺳطر. وإذا ﻋد اﻟﻌداد‬
 ‫اﻟﺧﺎرﺟﻲ ٢ ﺗﻌد ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ )2,1( وﺗﻧﻔذ ﺧطوة رﻗم )٤( ﻣرﺗﺎن طﺎﺑﻌﺔ ﻓراﻏﺎن ﺛم ﺗﻧﻔذ ﺧطوة رﻗم )٥(‬
     ‫طﺎﺑﻌﺔ ﻧﺟﻣﺔ وﺗﻧزل ﺳطر . وإذا ﻋد اﻟﻌداد اﻟﺧﺎرﺟﻲ ٣ ﺗﻌد ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ) 3,2,1( وﺗﻧﻔذ ﺧطوة رﻗم)٤(‬
               ‫ﺛﻼث ﻣرات طﺎﺑﻌﺔ ﺛﻼث ﻓراﻏﺎت ﺛم ﺗﻧﻔذ ﺧطوة رﻗم )٥( طﺎﺑﻌﺔ ﻧﺟﻣﺔ وﺗﻧزل ﺳطر وﯾﺳﺗﻣر إﻟﻰ اﻟﻧﮭﺎﯾﺔ.‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                        ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




         ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﯾﻛون ﺷﻛل ﻧﻘﺎط ﻛﻣﺎ ﻓﻲ اﻟرﺳم )ھذه اﻟﻧﻘﺎط ھﻲ ﻣواﻗﻊ ﻋﻧﺎﺻر ا ﻟﻣﺻﻔوﻓﺔ ذات ﺑﻌدﯾن ٥* ٥(‬




        ‫++‪C‬‬                                                                          ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{ int i,j‬‬
        ‫)++‪for (i=0; i<5; i‬‬
        ‫{‬
        ‫)++‪for (j=0; j<5; j‬‬
        ‫;" )" << ‪cout<<"("<< i<<" , " <<j‬‬
         ‫};"‪Cout<<"\n‬‬
        ‫}‬


         ‫‪C‬‬                                                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{ int i,j‬‬
        ‫)++‪for (i=0; i<5; i‬‬
        ‫{‬
         ‫)++‪for (j=0; j<5; j‬‬
          ‫;)‪printf("( %d , %d ) ",i,j‬‬
         ‫};)"‪printf("\n‬‬
        ‫}‬




  ‫اﻟﻣﺛﺎل واﺿﺢ ﻓﻠﯾس ﺑﺣﺎﺟﺔ إﻟﻰ ﺗوﺿﯾﺢ ووﺿﻌﻧﺎ ھذه اﻟﺷﻛل اﻟﻣطﻠوب ﻓﻲ اﻟرﺳم ﻛﻣﻘدﻣﺔ‬
‫ﻟﻠﻣﺻﻔوﻓﺎت وطرﯾﻘﺔ ﺗﻣﺛﯾﻠﮭﺎ ﺣﯾث ھذه اﻟﻧﻘﺎط ﻣواﻗﻊ ﻓﻲ اﻟذاﻛرة ﺣﯾث أول ﻣوﻗﻊ ھو )0,0(‬
                                                                  ‫وﯾﺳﺗﻣر....... .‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                  ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                         ‫٣.٣- ﻋﺑﺎرة )‪: ( Break‬‬
     ‫ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻟﻠﺗوﻗف ﻋن اﻟﻌﺑﺎرات اﻟﺗﻛرارﯾﺔ ﻋﻧد ﺷرط ﻣﻌﯾن واﻻﻧﺗﻘﺎل إﻟﻰ ﻣﺎ ﺑﻌد اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ )ﻻﺣظ‬
‫ﺷﻛل اﻟﺳﮭم إﻟﻰ أﯾن ﯾﻧﺗﻘل(.أي اﻧﮫ ﻓﻘط ﯾﺧرج ﻣن ﻋﺑﺎرة اﻟﺗﻛرار اﻟﻣوﺟود ھو ﻓﯾﮭﺎ وﯾﻧﺗﻘل ﻟﯾﻧﻔذ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ‬
                                                                                                          ‫ﺗﻠﯾﮫ‬

                                                                            ‫ﻣوﻗﻊ ﻋﺑﺎرة )‪ (Break‬ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬
        ‫)1‪for (Initializing1; Boolean_Expression1; Update‬‬
        ‫{‬
        ‫)‪If (condition‬‬
        ‫;‪Break‬‬
        ‫;‪Statement‬‬
        ‫}‬


     ‫ﻣﺛﺎل: ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﻌد ﻣن )002—1( وﻧرﯾدھﺎ ﻋﻧدﻣﺎ ﯾﺻل اﻟﻌداد إﻟﻰ )57( ﯾﺧرج اﻟﺑرﻧﺎﻣﺞ ﻣن‬
                                                                       ‫اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ إﻟﯾك ھذا اﻟﻣﺛﺎل.‬

        ‫++ ‪C‬‬                                                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i‬‬
        ‫)++‪2.for (i=1; i<200; i‬‬
        ‫)57==‪{3.If (i‬‬
        ‫;‪4.break‬‬
        ‫}; "‪5.cout<<i<<"\t‬‬
        ‫;"57 ‪6.cout<<"\nis finished print to‬‬
        ‫}‬



        ‫‪C‬‬                                                                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i‬‬
        ‫)++‪2.for (i=1; i<200; i‬‬
        ‫)57==‪{3.If (i‬‬
        ‫;‪4.break‬‬
        ‫};)‪5.printf("%d\t",i‬‬
        ‫;)"57 ‪6.printf ("\nis finished print to‬‬
        ‫}‬
                                                                                             ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                                                 ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر ﻟﯾﻛون ﻋداد‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                      ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                       ‫٢.ﺧطوة رﻗم )٢( ﻋداد ﯾﻌد ﻣن )١( إﻟﻰ )٠٠٢( وﯾﻛرر ﻓﻲ داﺧﻠﮫ اﻟﺧطوات رﻗم )٣ و٤ و ٥(‬

       ‫٣.ﺧطوة رﻗم )٣( ھو ﺷرط ﻟﻠﺗوﻗف أي ﻋﻧدﻣﺎ ﺗﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻌداد ھﻲ )٥٧( ﯾﻧﻔذ اﻟﺧطوة رﻗم )٤( واﻟﺗﻲ ﺗﺳﺑب‬
          ‫ﺑﺎﻟﺧروج ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ واﻻﻧﺗﻘﺎل إﻟﻰ ﻣﺎ ﺑﻌدھﺎ وھﻲ ﺧطوة رﻗم )٦( ﻛﻣﺎ ﺗﻼﺣظ ﻓﻲ اﻟرﺳم ﺑﺎﻷﺳﮭم.‬
                                                                                                                      ‫ﻣﮭم‬


     ‫٤.ﺧطوة رﻗم )٥( ﺗﺗم طﺑﺎﻋﺔ ﻗﯾﻣﺔ اﻟﻌداد ﻋﻧد ﻛل دورة وﺗﻼﺣظ أن اﻟﻌداد ﺳوف ﻻ ﯾﺻل ﻓﻲ ﻋده إﻟﻰ )٠٠٢( إﻧﻣﺎ‬
          ‫ﯾﺻل إﻟﻰ )٤٧( ﻓﻲ اﻟطﺑﺎﻋﺔ وﯾﻧﻘطﻊ ﻷﻧﮫ ﺧطوة رﻗم )٤( ﺗﻘطﻊ ﺗﻧﻔﯾذ اﻟﺟﻣل اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺗﻠﯾﮭﺎ داﺧل اﻟﻌﺑﺎرة‬
                                                         ‫اﻟﺗﻛرارﯾﺔ ﻋﻧدﻣﺎ ﯾﺻل اﻟﻌداد إﻟﻰ )٥٧( وﺷﺎھد ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ.‬

                  ‫٥.ﺧطوة رﻗم )٦( ﺗطﺑﻊ رﺳﺎﻟﺔ ﺑﻌد اﻟﺧروج ﻣن اﻟﺟﻣﻠﺔ اﻟﺗﻛرارﯾﺔ وﺷﺎھدھﺎ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﺑﺎﻷﺳﻔل‬




                                                         ‫ﺗﻼﺣظ ﻗطﻌت طﺑﺎﻋﺔ اﻟﻌداد ﻋﻧد ٤٧ وطﺑﻊ‬
                                                            ‫ﺑﻌدھﺎ رﺳﺎﻟﺔ اﻟﺧطوة اﻟﺑرﻣﺟﯾﺔ رﻗم )٦(‬

                                                        ‫اﺳﺗﺧدام ) ‪ (Break‬داﺧل اﻟﻌﺑﺎرات اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ..؟‬

                                                                                 ‫ﻣوﻗﻊ ﻋﺑﺎرة )‪ (Break‬ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬
       ‫)1‪for (Initializing1; Boolean_Expression1; Update‬‬
       ‫{‬
       ‫)2‪for (Initializing2; Boolean_Expression2; Update‬‬
       ‫{‬
       ‫)‪If (condition‬‬
       ‫;‪Break‬‬
       ‫;2‪Statement‬‬
       ‫}‬
       ‫;1‪Statement‬‬
       ‫}‬
     ‫ﻻﺣظ ﻛﻠﻣﺎ ﯾﺗﺣﻘق اﻟﺷرط داﺧل اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ ﯾﻧﺗﻘل ﻟﯾﻧﻔذ ال )1‪ (Statement‬اﻟﻣوﺟود داﺧل اﻟﻌﺑﺎرة‬
                                                ‫اﻟﺗﻛرارﯾﺔ اﻟﺧﺎرﺟﯾﺔ. أي ﯾﺧرج ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ .‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                            ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




  ‫‪ ‬ﺗطرﻗﻧﺎ ﻓﻲ ﻣﺎ ﻣﺿﻰ ﻋﻠﻰ ﻣﻼﺣظﺔ ﺗﻘول ) ﻹدﺧﺎل )‪ (for‬ﻓﻲ دوارة ﻻﻧﮭﺎﺋﯾﺔ ﻧﻛﺗب );;(‪ for‬ﻓﻘط ( ﻟﻛن ﻟم‬
‫ﻧﺑﯾن ﻣﺎ ھﻲ وﻛﯾف ﺗﺳﺗﺧدم .اﻟﻌدادات اﻟﺗﻲ اﺳﺗﺧدﻣﻧﺎھﺎ ﺣﺗﻰ أﻻن ھﻲ ﻣﺣدودة ﺗﻌد إﻟﻰ رﻗم ﻣﻌﯾن وﺗﺗوﻗف ﻣﺎذا‬
 ‫ﻟو أردﻧﺎ أن ﻻ ﯾﺗوﻗف اﻟﻌداد أﺑدا أو أردﻧﺎ ﻻ ﯾﺗوﻗف إﻻ ﺑﺷرط ﻣﻌﯾن ﻣﺛﻼ ﺑرﻧﺎﻣﺞ رﻗم ﺳري ﺳﯾﺿل ﯾطﻠب ﻣن‬
     ‫اﻟﻣﺳﺗﺧدم إدﺧﺎل اﻟرﻗم اﻟﺳري إﻟﻰ أن ﯾدﺧل اﻟرﻗم ﺻﺣﯾﺢ ﺑﻌدھﺎ ﯾﺧرج ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ وھذا اﺑﺳط‬
                                                                  ‫ﻣﺛﺎل ﻋﻠﻰ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﻻﻧﮭﺎﺋﯾﺔ‬



                     ‫ﻣﺛﺎل:ﺑرﻧﺎﻣﺞ إدﺧﺎل اﻟرﻗم اﻟﺳري وﯾﺳﺗﻣر ﺑطﻠب اﻟرﻗم ﻣن اﻟﻣﺳﺗﺧدم إﻟﻰ أن ﯾدﺧل اﻟرﻗم اﻟﺻﺣﯾﺢ‬

        ‫++ ‪C‬‬                                                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{ int password‬‬
         ‫);;( ‪for‬‬
        ‫;"‪{ cout<<"enter password\n‬‬
        ‫;‪Cin>> password‬‬
         ‫)4321==‪if (password‬‬
         ‫;"‪{cout<<"password is correct‬‬
         ‫};‪break‬‬
         ‫‪else‬‬
         ‫}};"‪cout<<"password is error try agin\n‬‬


        ‫++ ‪C‬‬                                                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{ int password‬‬
         ‫);;( ‪for‬‬
        ‫;)"‪{ printf("enter password\n‬‬
        ‫;)‪Scanf("%d",&password‬‬
         ‫)4321==‪if (password‬‬
         ‫;)"‪{ printf("password is correct‬‬
         ‫};‪break‬‬
         ‫‪else‬‬
          ‫}};)"…‪printf("password is error try agin\n‬‬


                                                                                               ‫ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                  ‫٤.٣- ﻋﺑﺎرة )‪: ( continue‬‬
    ‫ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻹھﻣﺎل اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺗﻠﯾﮭﺎ واﻻﻧﺗﻘﺎل إﻟﻰ ﻋﺑﺎرة اﻟﺗﻛرار وﻋد ﻋدة ﺟدﯾدة ﺣﺳب ﺷرط‬
   ‫ﻋﺑﺎرة اﻟﺗﻛرار إذا ﻛﺎﻧت ﺗﻘﺑل ﻋدة ﺟدﯾدة )ﻻﺣظ ﺷﻛل اﻟﺳﮭم إﻟﻰ أﯾن ﯾﻧﺗﻘل(.أي اﻧﮫ ﻓﻘط ﺑﮭﻣل ال ) ‪(Statement‬‬
                                                          ‫وﯾﻧﺗﻘل إﻟﻰ ﻋﺑﺎرة اﻟﺗﻛرار ﻟﺑﯾداء ﻋدة ﺟدﯾدة اﻋﺗﯾﺎدﯾﺔ‬

                                                                       ‫ﻣوﻗﻊ ﻋﺑﺎرة )‪ (continue‬ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬
        ‫)1‪for (Initializing1; Boolean_Expression1; Update‬‬
        ‫{‬
        ‫)‪If (condition‬‬
        ‫;‪continue‬‬
        ‫;‪Statement‬‬
        ‫}‬



‫ﻣﺛﺎل: ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﻌد ﻣن )002—1( وﻧرﯾدھﺎ ﻋﻧدﻣﺎ ﯾﺻل اﻟﻌداد إﻟﻰ )57( ﺑﮭﻣل اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ‬
                                                        ‫اﻟﺗﻲ ﺗﻠﯾﮫ داﺧل ﻋﺑﺎرة اﻟﺗﻛرار أي ﻻ ﯾطﺑﻊ رﻗم )٥٧(.‬

        ‫++ ‪C‬‬                                                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i‬‬
        ‫)++‪2.for (i=1; i<200; i‬‬
        ‫)57==‪{3.If (i‬‬
        ‫;‪4.con nue‬‬
        ‫}; "‪5.cout<<i<<"\t‬‬
        ‫;"‪6.cout<<"\nis finished print to200 execpt 75 is not print‬‬
        ‫}‬



        ‫‪C‬‬                                                                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i‬‬
        ‫)++‪2.for (i=1; i<200; i‬‬
        ‫)57==‪{3.If (i‬‬
        ‫;‪4.con nue‬‬
        ‫}; )‪5.printf("%d\t",i‬‬
        ‫;)"‪6. printf("\nis finished print to200 execpt 75 is not print‬‬
        ‫}‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                     ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                                                     ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                                                   ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر ﻟﯾﻛون ﻋداد‬

                       ‫٢.ﺧطوة رﻗم )٢( ﻋداد ﯾﻌد ﻣن )١( إﻟﻰ )٠٠٢( وﯾﻛرر ﻓﻲ داﺧﻠﮫ اﻟﺧطوات رﻗم )٣ و٤ و ٥(‬

        ‫٣.ﺧطوة رﻗم )٣( ھوا ﺗﺣﻘق ﻣن ﺷرط ﻣﺗﻰ أﺻﺑﺢ رﻗم اﻟﻌداد )٥٧( ﺳﯾﻧﻔذ ﺧطوة رﻗم )٤( و ﺳﯾﮭﻣل اﻟﺧطوات‬
                           ‫اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺗﻠﯾﮫ ﺳﯾﮭﻣل ﺧطوة رﻗم )٥( أي ﺳوف ﻻ ﯾطﺑﻊ رﻗم اﻟﻌداد ﻋﻧد ھذه اﻟﻌدة‬

               ‫٤.ﺧطوة رﻗم )٥( ﻧطﺑﻊ ﻗﯾﻣﺔ اﻟﻌداد ﻋﻧد ﻛل ﻋدة ﻋدا ﻋﻧدﻣﺎ ﺗﻛون ﻗﯾﻣﺗﮫ )٥٧( ﻷﻧﮫ ﺳﯾﮭﻣل ھذه اﻟﺧطوة‬

                                             ‫٥.ﺧطوة رﻗم )٦( طﺑﺎﻋﺔ رﺳﺎﻟﺔ ﺑﻌد اﻻﻧﺗﮭﺎء ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ .‬



                                                                                                     ‫ﺷﺎھد ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




                                               ‫ﻟم ﯾﺗم طﺑﺎﻋﺔ رﻗم ٥٧ طﺑﻊ رﻗم ٤٧ وﺑﻌدھﺎ طﺑﻊ رﻗم ٦٧‬
                                               ‫ﻷﻧﮫ ﻋﻧدﻣﺎ أﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻌداد ٥٧ ﺗﺣﻘق ﺷرط ﺧطوة )٣(‬
                                             ‫وھﻣل اﻟﺧطوات اﻟﺗﻲ ﺗﻠﯾﮫ ﺑﻣﺎ ﻓﯾﮫ ﺧطوة اﻟطﺑﺎﻋﺔ ھﻣﻠت ﻓﻠم‬
                                                                                        ‫ﯾطﺑﻊ اﻟرﻗم‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                  ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                            ‫٥.٣- ﻋﺑﺎرة )‪: (go to‬‬
 ‫ﺗؤدي ھذه اﻟﻌﺑﺎرة إﻟﻰ اﻧﺗﻘﺎل ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ إﻟﻰ ﺳطر ﻣﻌﯾن ﻓﻘط ﻧﻌﻧون اﻟﺳطر ﺑﺄي اﺳم وﻧﺿﻊ ﺑﻌده ): ( وھﯾﻛﻠﯾﺔ ھذه‬
                                                                                                   ‫اﻟداﻟﺔ ھﻲ.‬

                                                                               ‫ھﯾﻛﻠﯾﺔ )‪ ( go to‬ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬
        ‫)(‪Main‬‬
        ‫;1‪{Statement‬‬
        ‫)‪If (condition‬‬
        ‫;‪goto Npoint‬‬
        ‫;2‪Statement‬‬
          ‫;3‪Statement‬‬
        ‫;4‪Statement‬‬
        ‫:‪Npoint‬‬
        ‫};5‪Statement‬‬


 ‫ﻧﻼﺣظ ﻣن اﻟﮭﯾﻛﻠﯾﺔ اﻧﮫ إذا ﺗﺣﻘق ﺷرط ﻣﻌﯾن )وﺣﺗﻰ ﻧﺳﺗطﯾﻊ أن ﻧﺿﻌﮭﺎ ﺑدون ﺷرط ﻟﺗﻧﻔذ( ﺳوف ﯾﻧﺗﻘل اﻟﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ‬
                     ‫ﻟﯾﻧﻔذ ال )5‪ (Statement‬ھﺎﻣﻼ أو ﺗﺎرﻛﺎ ال )4‪ Statement‬و3‪(Statement2 Statement‬‬

                ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻋداد ﯾﻌد ﻣن )41—0( وﺑﺎﺳﺗﺧدام ﺗﻛرار اﻟﺟﻣل اﻟﺑرﻣﺟﯾﺔ أي ﺑﺎﺳﺗﺧدام إﯾﻌﺎز )‪(go to‬‬

        ‫++ ‪C‬‬                                                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;0=1‪{1. int count‬‬
          ‫:‪2.mpointn‬‬
                 ‫;"‪3.cout<< count1<<"\t‬‬
                 ‫;1+1‪4.count1=count‬‬
                 ‫)51=!1‪5.if (count‬‬
         ‫;‪6.goto mpointn‬‬
        ‫}‬



         ‫‪C‬‬                                                                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;0=1‪{1. int count‬‬
         ‫:‪2.mpointn‬‬
                 ‫;)1‪3.prin ("%d\t", count‬‬
                 ‫;1+1‪4.count1=count‬‬
                 ‫)51=!1‪5.if (count‬‬
         ‫};‪6.goto mpointn‬‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                               ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                                           ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                    ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر ﻟﻠﻌداد اﻟﺗﻲ ﺳﯾﺗم طﺑﺎﻋﺔ ﻗﯾﻣﺗﮫ ﻋﻧد ﻛل ﻋدة‬

  ‫٢. ﺧطوة رﻗم )٢(ھﻲ ﻧﻘطﺔ ﺗﻌرﻓﮭﺎ ﺟﻣﻠﺔ )‪ (goto‬ﻧﻛﺗﺑﮭﺎ ھﻛذا ﺣﺗﻰ ﻋﻧدﻣﺎ ﻧرﯾد اﻟرﺟوع ﻟﮭﺎ ﻓﻘط ﻧﻛﺗب )‪ (goto‬إﻟﻰ‬
                                              ‫اﻟﻧﻘطﺔ اﻟﺗﻲ ﻧود اﻟرﺟوع إﻟﯾﮭﺎ.وﺗﺳﻣﯾﺔ اﻟﻧﻘطﺔ ﻣﻣﻛن ﯾﻛون أي اﺳم‬

                                                                          ‫٣.ﺧطوة رﻗم )٣( ﺗطﺑﻊ ﻗﯾﻣﺔ اﻟﻌداد‬

                                                              ‫٤.ﺧطوة رﻗم )٤( زﯾﺎدة ﻗﯾﻣﺔ اﻟﻌداد ﺑﻣﻘدار واﺣد‬

    ‫٥.ﺧطوة رﻗم )٥( ﺷرط اﻟﺗﺣﻘق ﯾﺗﺣﻘق ﻣﺎدام ﻗﯾﻣﺔ اﻟﻌداد ﻟم ﺗﺻل إﻟﻰ )٥١( ﯾرﺟﻊ إﻟﻰ اﻟﻧﻘطﺔ اﻟﺗﻲ ﻓﻲ اﻟﺧطوة رﻗم‬
                                                                             ‫)٢( وﯾﻧﻔذ اﻟﺧطوات ﺑﺷﻛل ﻣﺗﺗﺎﻟﻲ‬


                                                                                       ‫ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻟﻠﺑرﻧﺎﻣﺞ.‬




                                            ‫ﻟﯾس ﻓﻘط ﻧﺳﺗطﯾﻊ إھﻣﺎل اﻟﺧطوات ﺑل ﻧﺳﺗطﯾﻊ ﺗﻛرار اﻟﺧطوات أﯾﺿﺎ‬

                                                                             ‫ھﯾﻛﻠﯾﺔ )‪ ( go to‬ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬
        ‫)(‪Main‬‬
        ‫;1‪{Statement‬‬
        ‫:‪Npoint‬‬
        ‫;2‪Statement‬‬
          ‫;3‪Statement‬‬
        ‫;4‪Statement‬‬
        ‫)‪If (condition‬‬
        ‫;‪goto npoint‬‬
        ‫};5‪Statement‬‬


                                          ‫ﺳوف ﯾﺗم ﺗﻛرار )4‪ Statement‬و3‪(Statement2 Statement‬‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                 ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                             ‫٦.٣- ﻋﺑﺎرة )‪ ( While‬اﻟﺗﻛرارﯾﺔ :‬
‫ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﺳﺗﺧدم ﻟﺗﻛرار ﺧطوات ﺑرﻣﺟﯾﺔ اﻟﻣﺣﺻورة ﺑﯾن ﻗوﺳﯾﮭﺎ ﻟﻌدد ﻣن اﻟﻣرات ﺗﻛون ﻣﺷﺎﺑﮫ ﺗﻣﺎﻣﺎ ﻟﻌﺑﺎرة‬
                 ‫اﻟﺗﻛرار )‪ .(For‬وﺗﺳﺗطﯾﻊ اﻟﻣﻘﺎرﻧﺔ ﺑﯾن ھﯾﻛﻠﯾﺔ ھﺎﺗﺎن اﻟﻌﺑﺎرﺗﺎن اﻟﺗﻛرارﯾﺗﺎن وﺳوف ﺗﺟد اﻟﺗﺷﺎﺑﮫ ﺑﯾﻧﮭﻣﺎ‬

                                                                                      ‫ھﯾﻛﻠﯾﺔ ‪while--Loop‬‬
         ‫‪Initializing‬‬
        ‫)‪while ( Boolean_Expression‬‬
        ‫{‬
        ‫;‪Statement‬‬
        ‫‪Update‬‬
        ‫}‬


                      ‫)‪ :(Initializing‬ھﻲ اﻟﻘﯾﻣﺔ اﻟﺑداﺋﯾﺔ اﻟﻣﻌطﺎة ﻟﻠﻣﺗﻐﯾر اﻟﺗﻲ ﻣﻧﮭﺎ ﺳﯾﺑدأ اﻟﻌد. )ﻣﺛﻼ 0=‪(i‬‬     ‫‪‬‬
‫)‪ :(Boolean_Expression‬ھو ﺷرط اﻟﺗوﻗف اﻟذي ﻋﻧدﻣﺎ ﺗﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻏﯾر ﻣﺣﻘﻘﺔ ﻟﺷرط اﻟﺗوﻗف‬                       ‫‪‬‬
     ‫ﺳوف ﯾﺧرج ﻣن ﻋﺑﺎرة )‪ (while‬ﺑﻣﻌﻧﻰ أﺧر ﻣﺎدام ﻧﺗﯾﺟﺔ اﺧﺗﺑﺎره ال )‪ (Boolean_Expression‬ھﻲ‬
‫)‪ (True‬اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﺗﺳﺗﻣر ﺑﺗﻧﻔﯾذ ﻣﺎﺑﯾن ﻗوﺳﯾﮭﺎ وﻣﺗﻰ ﻣﺎ أﺻﺑﺢ )‪ (False‬ﯾﺧرج ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ.‬
                                                   ‫ﻣﺛﻼ ) 5<‪ ((i‬ھوا ﺷرط اﻟﺗوﻗف وﯾﺑدأ اﻟﻌد ﻣن اﻟواﺣد‬
    ‫)‪ :(Update‬ھﻲ ﻣﻘدار اﻟزﯾﺎدة أو اﻟﻧﻘﺻﺎن ﻓﻲ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻓﻲ ﻛل دورة )‪ .(loop‬ﻣﺛﻼ )++‪ ( i‬أو )--‪(i‬‬             ‫‪‬‬
   ‫)‪ :(statement‬ھﻲ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺳﺗﻧﻔذ ﻋدد ﻣن اﻟﻣرات .إذا ﻛﺎﻧت ﻋﺑﺎرة ﻋن ﺧطوة ﺑرﻣﺟﯾﺔ‬                  ‫‪‬‬
                                                                                                                 ‫ﻣﮭم‬
             ‫واﺣدة ﻓﻠﯾس ﺑﺣﺎﺟﺔ ﻟوﺿﻌﮭﺎ داﺧل أﻗواس وإذا ﻛﺎﻧت أﻛﺛر ﻣن ﺧطوة ﯾﺟب وﺿﻌﮭﺎ داﺧل أﻗواس.‬

                                                                 ‫ﻛﯾف ﺗﻌﻣل ﻋﺑﺎرة ال )‪ (while‬اﻟﺗﻛرارﯾﺔ........؟‬

  ‫أن اﻟﻣﺗﻐﯾر ﯾﺑدأ ﺑﻘﯾﻣﺔ ﺑداﺋﯾﺔ )‪ (Initializing‬وﯾﺳﺗﻣر ﺑﺎﻟزﯾﺎدة أو اﻟﻧﻘﺻﺎن ﺣﺳب )‪ (Update‬أي ﻗد ﯾزداد أو ﯾﻧﻘص‬
 ‫ﺑﻣﻘدار واﺣد أو أﻛﺛر ﻣن واﺣد وﻣﺗﻰ ﻣﺎ أﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻏﯾر ﻣﺣﻘﻘﺔ ﻟﻠﺷرط )‪ (Boolean_Expression‬ﯾﺧرج‬
  ‫ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ إﻟﻰ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺗﻠﯾﮫ وإذا ﻛﺎﻧت ﻣﺣﻘﻘﺔ ﻟﻠﺷرط ﯾﻧﻔذ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ داﺧل‬
                                                                                         ‫اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ .‬
                                        ‫‪ ‬ﻹدﺧﺎل )‪ (while‬ﻓﻲ دوارة ﻻﻧﮭﺎﺋﯾﺔ ﻧﻛﺗب )1(‪ while‬ﻓﻘط .‬
                            ‫ﻣﺛﺎل: ﻟو أردﻧﺎ ﻋداد ﯾﻌد ﻣن )0( إﻟﻰ )4( أي ﯾطﺑﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻣن )0 إﻟﻰ 4(‬
        ‫++‪C‬‬                                                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;0=‪{1.int i‬‬
        ‫)5<‪2.while( i‬‬
        ‫;"‪{3.cout<<i<<"\t‬‬
        ‫};++‪4.i‬‬
        ‫}‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                            ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




         ‫‪C‬‬                                                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#Include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;0=‪{1.int i‬‬
        ‫)5<‪2. while( i‬‬
        ‫;)‪{3.printf("%d\t",i‬‬
        ‫};++‪4.i‬‬
        ‫}‬
                                                                                        ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬

     ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (i‬ﻣن ﻧوع ‪ .integer‬ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد اﻟﻌد ﻣن اﻟﺻﻔر ﻓﺄﻋطﯾﻧﺎ اﻟﻘﯾم اﻟﺑداﺋﯾﺔ ﺻﻔر‬
   ‫٢.ﺧطوة رﻗم )٢(ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺑﻣﺎ أن اﻟﻌد ﯾﺻل إﻟﻰ ٤ ﻣﻌﻧﺎه ﺷرط اﻟﺗوﻗف أن ﯾﻛون اﻗل ﻣن ﺧﻣﺳﺔ ﺑﻣﺎ إﻧﻧﺎ‬
   ‫ﻧرﯾد أن ﯾﻌد ﺧﻣس ﻋدات ﺑﯾن ﺻﻔر واﻷرﺑﻌﺔ ﻟذاﻟك ﯾﺟب أن ﯾﻛون ﻣﻘدار اﻟزﯾﺎدة واﺣد ﻟﯾﻌد )4,3,2,1, 0( .ﻻن ﻟو‬
     ‫ﺟﻌﻠﻧﺎ ﻣﻘدار اﻟزﯾﺎدة ٢ ﻣﺛﻼ ﻓﺳﯾﻌد اﻟﻌداد ﺛﻼث ﻣرات ﻣرة )4,2,0( ﻟذاﻟك ﯾﺟب اﻟﺗرﻛﯾز ﻓﻲ ھذه اﻟﻣواﺿﯾﻊ ﺟﯾدا.‬
                                             ‫اﻟﻘﯾﻣﺔ اﻟﺑداﺋﯾﺔ‬
                                             ‫ﻟﻠﻌداد )0=‪(i‬‬                                                  ‫ﻣﮭم‬



                                                 ‫ﺷرط‬
                                              ‫اﻟﺗﺣﻘق)5<‪(i‬‬


                                              ‫طﺑﺎﻋﺔ اﻟﻘﯾﻣﺔ‬

                                               ‫زﯾﺎدة ﻗﯾﻣﺔ‬
                                              ‫اﻟﻌداد )++‪(i‬‬

                                              ‫ﺧروج ﻣن‬
                                             ‫ﺟﻣﻠﺔ اﻟﺗﻛرار‬
 ‫ﻟو ﺗﻼﺣظ اﻟﻣﺧطط اﻟﺧﺎص ﺑﺎﻟﺑرﻧﺎﻣﺞ ﻋﻧدﻣﺎ ﯾﺣﻘق اﻟﺷرط ﯾﺗﺟﮫ ﻟﺧطوة اﻟطﺑﺎﻋﺔ وإذا ﻟم ﯾﺣﻘق ﯾﺧرج ﻣن ﺟﻣﻠﺔ ﺗﻛرار‬

                                                  ‫٣.ﺧطوة رﻗم )٣( ھﻲ طﺑﺎﻋﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻋﻧد ﻛل ) ‪. ( loop‬‬
‫٤. ﺧطوة رﻗم )٤( ھو ﻋداد ﯾزداد ﺑﻣﻘدار واﺣد ﻋﻧد ﻛل ﻋدة وﻻ ﯾﻔرق إذا ﻛﺗﺑﻧﺎ ) ++‪ i‬أو ‪ (++i‬ﻻن اﻟرﺟوع ﻟﻠﺧطوة‬
  ‫)٢( وﺗﻧﻔﯾذھﺎ ﯾﻌﺗﺑر ﺧطوة ﻣﻧﻔﺻﻠﺔ ﻋن ﺧطوة اﻟزﯾﺎدة ﻟذا ﻋﻠﻰ ﺣدة ﻓﻔﻲ ﻛﻼ اﻟﺣﺎﻟﺗﯾن ﯾزداد ﻗﯾﻣﺔ اﻟﻌداد ﻗﺑل ﺗﻧﻔﯾذ‬
                                                              ‫ﺧطوة ﺗﺣﻘق ﻣن اﻟﺷرط ) إذا ﻛﺎن اﻗل ﻣن ﺧﻣﺳﺔ(.‬


                                                   ‫*ﻗﺎرن ھذا اﻟﻣﺛﺎل ﺑﺎﻟﻣﺛﺎل اﻟﻣﺷﺎﺑﮫ ﻟﮫ ب)‪ (For‬وﺷﺎھد اﻟﻔرق‬

‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:ﺗﻧﻔذ ﺧطوة رﻗم )١( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٣( وﺧطوة رﻗم )٤( ﺧﻣس ﻣرات‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                       ‫ﻣﺛﺎل: ﻟو أردﻧﺎ ﻋداد ﯾﻌد ﻣن )4( إﻟﻰ )0( أي ﯾطﺑﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ )0 1 2 3 4 (‬

‫ﺗﺣﻠﯾل:ﺣﻠﮭﺎ ﻧﻔس ﺣل اﻟﺳؤال اﻟﺳﺎﺑق ﻓﻘط ﻧﻘﻠب اﻟﻌداد أي ﻧﺟﻌل ﻗﯾﻣﺗﮫ اﻟﺑداﺋﯾﺔ ھﻲ ٤ وﺷرط اﻟﺗوﻗف اﻛﺑر أو ﯾﺳﺎوي‬
                                                                      ‫ﺻﻔر وﯾﺗﻧﺎﻗص ﺑﻣﻘدار واﺣد ﻛل ﻋدة‬



        ‫++‪C‬‬                                                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;4=‪{1.int i‬‬
        ‫)0=>‪2.while( i‬‬
        ‫;"‪{3.cout<<i<<"\t‬‬
        ‫};--‪4.i‬‬
        ‫}‬


         ‫‪C‬‬                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;4=‪{1.int i‬‬
        ‫)0=>‪2. while( i‬‬
        ‫;)‪{3.printf("%d\t",i‬‬
        ‫};--‪4.i‬‬
        ‫}‬



                                                                                         ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬

                               ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (i‬ﻣن ﻧوع ‪ integer‬ﻓﺄﻋطﯾﻧﺎه اﻟﻘﯾم اﻟﺑداﺋﯾﺔ أرﺑﻌﺔ‬

    ‫٢.ﺧطوة رﻗم )٢(ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد اﻟﻌد ﻣن اﻷرﺑﻌﺔ ﻓﺄﻋطﯾﻧﺎ اﻟﻘﯾم اﻟﺑداﺋﯾﺔ أرﺑﻌﺔ .واﻟﻌد ﯾﺻل إﻟﻰ‬
  ‫اﻟﺻﻔر ﻣﻌﻧﺎه ﺷرط اﻟﺗوﻗف أن ﯾﻛون اﻛﺑر أو ﯾﺳﺎوي ﺻﻔر ) )0=>‪ ( while(i‬ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد أن ﯾﻌد ﺧﻣس ﻋدات ﺑﯾن‬
    ‫ﺻﻔر واﻷرﺑﻌﺔ ﻟذاﻟك ﯾﺟب أن ﯾﻛون ﻣﻘدار ﻧﻘﺻﺎن واﺣد ﻟﯾﻌد )0,1,2,3,4( .ﻻن ﻟو ﺟﻌﻠﻧﺎ ﻣﻘدار اﻟﻧﻘﺻﺎن ٢ ﻣﺛﻼ‬
                               ‫ﻓﺳﯾﻌد اﻟﻌداد ﺛﻼث ﻣرات ﻣرة )0,2,4( ﻟذاﻟك ﯾﺟب اﻟﺗرﻛﯾز ﻓﻲ ھذه اﻟﻣواﺿﯾﻊ ﺟﯾدا‬
            ‫٣.ﺧطوة رﻗم )٣( طﺑﺎﻋﺔ ﻗﯾﻣﺔ ﻋداد .وﺧطوة رﻗم )٤( ﻋداد اﻟﻧﻘﺻﺎن ﯾﺗﻧﺎﻗص ﺑﻣﻘدار واﺣد ﻋﻧد ﻛل ﻋدة‬

                                                                                    ‫ﺳﯾطﺑﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




                                                                                  ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:‬

         ‫ﺗﻧﻔذ ﺧطوة رﻗم )١( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٣( وﺧطوة رﻗم )٤( ﺧﻣس ﻣرات ﺑﻘدر ﻋدات اﻟﻌداد‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                         ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                            ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                         ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﺟﻣﻊ اﻹﻋداد اﻟﻔردﯾﺔ ﺑﯾن ) 001—0(‬

    ‫ﺗﺣﻠﯾل: ﻧرى اﻧﮫ ﯾرﯾد اﻹﻋداد اﻟﻔردﯾﺔ ﻓﻘط ﻟذاﻟك ﯾﺟب أن ﻧطﻔر اﻹﻋداد اﻟزوﺟﯾﺔ .ﻧﻛون ﻋداد ﯾﻌد ﻣن اﻟواﺣد وﺷرط‬
                                      ‫اﻟﺗوﻗف ﻋﻧد اﻟﻣﺎﺋﺔ وﻣﻘدار اﻟزﯾﺎدة ﻓﻲ )٢( ﺣﺗﻰ ﻧﺟﻣﻊ ﻓﻘط اﻹﻋداد اﻟﻔردﯾﺔ‬

        ‫++‪C‬‬                                                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;1=‪{1.int n‬‬
        ‫;0=‪2.int sum‬‬
        ‫)001<‪3.while( n‬‬
        ‫; ‪{4. sum += n‬‬
        ‫};2+‪5. n=n‬‬
        ‫};‪6.Cout<<"sum="<<sum‬‬


        ‫‪C‬‬                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;1=‪{1.int n‬‬
        ‫;0=‪2.int sum‬‬
        ‫)001<‪3.while( n‬‬
        ‫; ‪{4. sum += n‬‬                                                                                       ‫ﻣﮭم‬
        ‫};2+‪5. n=n‬‬
        ‫};)‪6.printf("sum=%d",sum‬‬
                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
   ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ) ‪ (n‬ﻣن ﻧوع )‪ (integer‬ﻟﯾﻛون ﻋداد ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ وﻗﯾﻣﺗﮫ اﻻﺑﺗداﺋﯾﺔ ھﻲ واﺣد‬

 ‫٢.ﺧطوة رﻗم )٢( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (sum‬ﻣن ﻧوع )‪ (integer‬وأﻋطﯾﻧﺎه ﻗﯾﻣﺔ ﺑداﺋﯾﺔ وھﻲ ﺻﻔر ﻷﻧﻧﺎ ﺳﻧﺟﻣﻊ واﻟﻧﺿﯾر‬
                          ‫اﻟﺟﻣﻌﻲ ھو ﺻﻔر ﺣﺗﻰ ﻋﻧدﻣﺎ ﻧﺟﻣﻌﮫ ﻣﻊ أول ﻗﯾﻣﺔ وھﻲ واﺣد ﺳﯾﺟﻣﻊ واﺣد ﻣﻊ اﻟﺻﻔر‬

           ‫٣.ﺧطوة رﻗم )٣( ﻛوﻧﺎ ﻋداد ﯾﺗوﻗف ﻋﻧد ٩٩ )001<‪ (while(n‬وﯾﺑدأ اﻟﻌد ﻣن اﻟواﺣد ﻷﻧﮫ أول ﻋدد ﻓردي‬

       ‫٤.ﺧطوة رﻗم )٤( ﺟﻣﻌﻧﺎ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬ﻣﻊ ﻗﯾﻣﺔ اﻟﻌداد ﻋﻧد ﻛل ﻋدة. أي ﻋﻧدﻣﺎ ﯾﻛون ) 1=‪ (n‬ﺳﯾﺟﻣﻊ‬
    ‫)1+0=‪ (sum‬وﻋﻧدﻣﺎ ﯾﺻﺑﺢ ) 3=‪ (n‬ﺳﯾﺟﻣﻊ ﻗﯾﻣﺔ )‪ (sum‬اﻟﺳﺎﺑﻘﺔ وھﻲ أﺻﺑﺣت واﺣد ﻣﻊ ﺛﻼﺛﺔ )3+1=‪(sum‬‬
        ‫وﻋﻧدﻣﺎ ﯾﺻﺑﺢ ) 5=‪ (n‬ﺳﯾﺟﻣﻊ ﻗﯾﻣﺔ )‪ (sum‬اﻟﺳﺎﺑﻘﺔ وھﻲ أﺻﺑﺣت أرﺑﻌﺔ ﻣﻊ ﺛﻼﺛﺔ )5+4=‪ (sum‬وﯾﺳﺗﻣر.‬

                                   ‫٥.ﺧطوة رﻗم )٥( ھو زﯾﺎدة ﻟﻠﻌداد ﺑﻣﻘدار اﺛﻧﺎن ﺣﺗﻰ ﻓﻘط ﻧﺟﻣﻊ اﻹﻋداد اﻟﻔردﯾﺔ‬
                                                        ‫٦.ﺧطوة رﻗم )٦( طﺑﺎﻋﺔ اﻟﻧﺎﺗﺞ اﻟﺟﻣﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
   ‫0052=‪Sum‬‬
  ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:ﺗﻧﻔذ ﺧطوة رﻗم )١و٢( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٤( وﺧطوة رﻗم )٥( ﺧﻣﺳﯾن‬
                    ‫ﻣرة ﻻن اﻹﻋداد اﻟﻔردﯾﺔ ﺑﯾن)001—0( ھﻲ ﺧﻣﺳﯾن رﻗم وﺗﻧﻔذ ﺧطوة رﻗم)٦( ﻣرة واﺣدة‬



    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                               ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                         ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﯾدﺧل اﻟﻣﺳﺗﺧدم درﺟﺎت ٠١ ﻣواد وﺗﻘوم ﺑﺣﺳﺎب اﻟﻣﻌدل ﻟﮫ‬

  ‫ﺗﺣﻠﯾل: ﺑﻣﺎ اﻧﮫ ﯾرﯾد ﺣﺳﺎب اﻟﻣﻌدل ﻣن ﻋﺷر درﺟﺎت ﻓﯾﺟب ﺟﻣﻊ ھذه اﻟدرﺟﺎت وﻗﺳﻣﺗﮭﺎ ﻋﻠﻰ ﻋﺷرة ﻟﻠﺣﺻول ﻋﻠﻰ‬
   ‫اﻟﻣﻌدل وﺑﻣﺎ اﻧﮫ ﯾﻘول ﯾدﺧﻠﮭﺎ اﻟﻣﺳﺗﺧدم وﺑﻣﺎ إﻧﮭن ﻋﺷر درﺟﺎت ﻓﯾﺻﻌب إدﺧﺎﻟﮭﺎ ﻛل واﺣد ﻋﻠﻰ ﺣدة ﻟذاﻟك ﻧﺳﺗﺧدم‬
‫ﻋﺑﺎرة ) ‪ (while‬اﻟﺗﻛرارﯾﺔ ﺗﺗﻛرر ﻋﺷر ﻣرات وﻧﺿﻊ ﺗﺣﺗﮭﺎ ﺟﻣﻠﺔ اﻟﻘراءة )ﺣﯾث ﻋﻧد ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﯾطﻠب‬
              ‫ﻣﻧك إدﺧﺎل درﺟﺔ وﯾﺟﻣﻊ اﻟدرﺟﺎت اﻟﻣدﺧﻠﺔ ﻋﻧد ﻛل إدﺧﺎل وﻧﺎﺗﺞ اﻟﺟﻣﻊ ﯾﻘﺳم ﺑﻌد اﻹدﺧﺎل ﻋﻠﻰ ﻋﺷرة‬

        ‫++‪C‬‬                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int aveg,input_number‬‬
        ‫;0=‪2.int sum=0,n‬‬
        ‫{ )01<‪3.while(n‬‬
        ‫;‪4. cin>> input_number‬‬
        ‫; ‪5. sum += input_number‬‬
        ‫};++‪6.n‬‬
        ‫;01/‪7. aveg=sum‬‬
        ‫; ‪8.Cout<<" aveg ="<< aveg‬‬
        ‫}‬


        ‫‪C‬‬                                                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int aveg,input_number‬‬
        ‫;0=‪2.int sum=0,n‬‬
        ‫{ )01<‪3.while(n‬‬
        ‫;)‪4. scanf("%d", &input_number‬‬
        ‫; ‪5. sum += input_number‬‬
        ‫};++‪6.n‬‬
        ‫;01/‪7. aveg=sum‬‬
        ‫;) ‪8. printf(" aveg =%d", aveg‬‬
        ‫}‬
                                                                                                          ‫ﺗﺣﻠﯾل:‬

                                      ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ﻣﺗﻐﯾر ﺣﺳﺎب اﻟﻣﻌدل وﻣﺗﻐﯾر إدﺧﺎل اﻟدرﺟﺎت‬
 ‫٢.ﺧطوة رﻗم )٢( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (sum‬ﻣن ﻧوع )‪ (integer‬وأﻋطﯾﻧﺎه ﻗﯾﻣﺔ ﺑداﺋﯾﺔ وھﻲ ﺻﻔر ﻷﻧﻧﺎ ﺳﻧﺟﻣﻊ واﻟﻧﺿﯾر‬
                 ‫اﻟﺟﻣﻌﻲ ھو ﺻﻔر وﻋرﻓﻧﺎ اﻟﻣﺗﻐﯾر ) ‪ (n‬ﻟﯾﻛون ﻋداد ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ وأﻋطﯾﻧﺎ ﻗﯾﻣﺗﮫ اﻻﺑﺗداﺋﯾﺔ ﺻﻔر‬
                   ‫٣. ﺧطوة رﻗم )٣( ھﻲ ﺟﻣﻠﺔ ﺗﻛرارﯾﺔ ﻣطﻠوب ﻣﻧﮭﺎ ﺗﻛرر اﻟﺧطوة رﻗم )٤و ٥ و ٦( ﻋﺷر ﻣرات‬
             ‫٤.ﺧطوة رﻗم )٤( ھﻲ داﻟﺔ إدﺧﺎل ﻋﻧد ﻛل ﻋدة ﻟﻠﺟﻣﻠﺔ اﻟﺗﻛرارﯾﺔ ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل درﺟﺔ ﺟدﯾدة‬
  ‫٥. ﺧطوة رﻗم )٥( ﯾﻘوم ﺑﺟﻣﻊ اﻟدرﺟﺎت اﻟﻣدﺧﻠﺔ ﻋﻧد ﻛل إدﺧﺎل ﯾﺟﻣﻊ اﻟدرﺟﺔ اﻟﺟدﯾدة ﻣﻊ ﻧﺎﺗﺞ ﺟﻣﻊ اﻟدرﺟﺎت اﻟﺳﺎﺑﻘﺔ‬
                                       ‫٦.ﺧطوة رﻗم )٦( ھو ﻋداد اﻟﺟﻣﻠﺔ اﻟﺗﻛرارﯾﺔ ﯾزداد ﺑﻣﻘدار واﺣد ﻋﻧد ﻛل ﻋدة.‬
                          ‫٧.ﺧطوة رﻗم )٧( ﯾﻘوم ﺑﺣﺳﺎب اﻟﻣﻌدل ﺣﯾث ﯾﻘﺳم ﻧﺎﺗﺞ ﺟﻣﻊ اﻟدرﺟﺎت اﻟﻣدﺧﻠﺔ ﻋﻠﻰ ﻋﺷرة‬
                                                                          ‫٨.ﺧطوة رﻗم )٧٨( ﯾﻘوم ﺑطﺑﺎﻋﺔ اﻟﻣﻌدل‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                            ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                     ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﯾدﺧل اﻟﻣﺳﺗﺧدم اي رﻗم وﯾﻘوم اﻟﺑرﻧﺎﻣﺞ ﺑﺣﺳﺎب ﻋدد ﻣراﺗب اﻟرﻗم وﻣﺟﻣوع ارﻗﺎﻣﮫ‬

                ‫ﻣﺗﻼ اذا ادﺧل اﻟﻣﺳﺗﺧدم ٢٣٢١ ﻓﻌدد ﻣراﺗب اﻟرﻗم ھﻲ ارﺑﻌﺔ )٤( وﻣﺟﻣوع ارﻗﺎﻣﮫ )١+٢+٣+٢=٨(‬

  ‫ﺗﺣﻠﯾل: ﺗﻛﻣن ﻓﻛرة ھذا اﻟﺳؤال ﻓﻲ اﻟﻣراﺗب اي ﻟو ﺟﻣﻌﻧﺎ ﺑﺎﻗﻲ ﻗﺳﻣﺔ اﻟرﻗم ﻋﻠﻰ ﻋﺷرة ﻛل ﻣرة ﺳﻧﺣﺻل ﻓﻲ اﻟﻧﮭﺎﯾﺔ‬
 ‫ﻋﻠﻰ ﻣﺟﻣوع ﻣراﺗﺑﮫ ﻣﻊ اﻟﻌﻠم ﻓﻲ ﻛل ﺧطوة ﻧﻘﺳﻣﮫ ﻋﻠﻰ ﻋﺷرة ﺣﺗﻰ ﯾﻔﻘد ﻗﯾﻣﺔ ﻋﺷر ﻣن ﻣﻘداره اﻟﺣﻘﯾﻘﻲ ﻻﻧﮫ ﺳﯾﻔﺻل‬
                                                                                      ‫اﻟرﻗم ﻣرﺗﺑﮫ ﻣرﺗﺑﮫ‬

        ‫++‪C‬‬                                                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#Include <iostream.h‬‬
        ‫{)( ‪Main‬‬
        ‫;0=‪int sumDigiat=0,enter,NumberDigite‬‬
        ‫;‪cin>>enter‬‬
        ‫)0 =! ‪while(enter‬‬
        ‫{‬
        ‫;01%‪sumDigiat+=enter‬‬
        ‫;01/‪enter=enter‬‬
        ‫;++‪NumberDigite‬‬
        ‫}‬

        ‫;‪cout<<sumDigiat<<"\n"<<NumberDigite‬‬
        ‫}‬


        ‫‪C‬‬                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
         ‫{‬
        ‫;0=‪int sumDigiat=0,enter,NumberDigite‬‬
        ‫;)‪scanf("%d", & enter‬‬
        ‫)0 =! ‪while(enter‬‬
        ‫{‬
        ‫;01%‪sumDigiat+=enter‬‬
        ‫;01/‪enter=enter‬‬
        ‫;++‪NumberDigite‬‬
        ‫}‬

        ‫;) ‪printf(" %d\n%d", sumDigiat, NumberDigite‬‬
        ‫}‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                               ‫٧.٣- ﻋﺑﺎرة )‪ ( While‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬
    ‫وﺗﻛون ﻣﺷﺎﺑﮫ ﺗﻣﺎﻣﺎ ﻟﻌﺑﺎرات )‪ (for‬اﻟﺗﻛرارﯾﺔ. ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرار ﺳوف ﻻ ﺗﻛرر ﻓﻘط اﺳطر ﺑرﻣﺟﯾﺔ إﻧﻣﺎ ﺗﻛرر‬
    ‫ﻋﺑﺎرات )‪ (while‬ﺗﻛرارﯾﺔ أﺧرى )أو ﻋﺑﺎرات ﺗﻛرارﯾﺔ أﺧرى ك ‪ (for,do—while‬ﺗوﺟد ﻓﻲ داﺧﻠﮭﺎ أي ﻓﻲ ﻛل‬
  ‫ﻋدة ﻟل )‪ (while‬إﻻم ﺳﺗﻌد )‪ (while‬اﻟداﺧﻠﯾﺔ ﺟﻣﯾﻊ ﻋداﺗﮭﺎ.ﺣﺎﻟﮭﺎ ﻛﺣﺎل أي ﺧطوة ﺑرﻣﺟﯾﺔ داﺧل ﻋﺑﺎرة ﺗﻛرارﯾﺔ‬
   ‫وﺑﻣﺎ أن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ ﯾﻣر ﻋﻠﯾﮭﺎ ﻋﻧد ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ إﻻم ﻟذاﻟك ﻓﻲ ﻛل ﻋدة ﻟﻼم ﺗﻌد اﻟﻌﺑﺎرة‬
                                                           ‫اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ ﺟﻣﯾﻊ ﻋداﺗﮭﺎ اﻟﻣﻣﻛﻧﺔ ﺣﺳب ﺷرطﮭﺎ .‬

                                                                                      ‫ھﯾﻛﻠﯾﺔ ‪while--Loop‬‬
         ‫;1‪Initializing‬‬
        ‫)1‪While(Boolean_Expression‬‬
        ‫;2‪{ Ini alizing‬‬
        ‫)2‪While(Boolean_Expression‬‬
        ‫{‬
        ‫;‪Statement‬‬
        ‫;2‪Update‬‬
        ‫}‬
        ‫} ;1‪Update‬‬


                                                                        ‫ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو ﻛﺎن ﻟدﯾﻧﺎ ھذا اﻟﺗداﺧل‬

                                                                                                     ‫ﻣﺛﺎل‬
         ‫;0=‪i‬‬
        ‫)5<‪while( i‬‬
        ‫;0=‪{ j‬‬
        ‫)5<‪While(j‬‬
        ‫{‬
        ‫‪statement‬‬
        ‫};++‪j‬‬
        ‫};++‪i‬‬                                                                                                  ‫ﻣﮭم‬



‫ﻓﻔﻲ ﻛل ﻋدة ﺑﺎﻟﻧﺳﺑﺔ ﻟل )‪ (While‬اﻟﺧﺎرﺟﯾﺔ ﺗﻌد ال )‪ (While‬اﻟداﺧﻠﯾﺔ ﺧﻣس ﻣرات وﺗﻧﻔذ )‪ ( statement‬ﺧﻣس‬
     ‫ﻣرات أي أن إذا ﻛﺎن )0=‪ (i‬ﺳﯾﻌد ال )‪( j‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0( و إذا أﺻﺑﺢ )1=‪ (i‬ﺳﯾﻌد ال )‪ ( j‬ﻗﯾﻣﮫ وھﻲ‬
‫)4,3,2,1,0( و إذا أﺻﺑﺢ )2=‪ (i‬ﺳﯾﻌد ال )‪ ( j‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0( و إذا أﺻﺑﺢ )3=‪ (i‬ﺳﯾﻌد ال )‪ ( j‬ﻗﯾﻣﮫ وھﻲ‬
                                       ‫)4,3,2,1,0( و إذا أﺻﺑﺢ )4=‪ (i‬ﺳﯾﻌد ال )‪ ( j‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0(‬

 ‫**ﺗﺑﻘﻰ اﻟﻣﺑﺎدئ ﺛﺎﺑﺗﺔ ﻛل ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﯾﺗﺑﻌﮭﺎ ﺳطر ﺑرﻣﺟﻲ واﺣد إذا ﻟم ﻧﺳﺗﺧدم أﻗواس وإذا وﺿﻌﻧﺎ أﻗواس ﻛل اﻟذي‬
                                                                  ‫داﺧل اﻷﻗواس ھو ﺗﺎﺑﻊ ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ.‬



    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                 ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﺟدول ﺿرب ﻣن )١( إﻟﻰ )٠١( .؟‬

                        ‫ﺗﺣﻠﯾل :)اﻟﻣﺛﺎل ﻧﻔﺳﮫ ﻣوﺟود ﻓﻲ ﻋﺑﺎرة )‪ (for‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ ﺳﺗﺟد ﺗﺣﻠﯾل ﺑﺷﻛل ﻣﻔﺻل.(‬

        ‫++‪C‬‬                                                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i=1,j‬‬
        ‫{ )01=<‪2.while( i‬‬
        ‫;"‪3.cout<<"Multiply tabel for("<<i<<").\n-------------------------------\n‬‬
        ‫;1=‪4. j‬‬
        ‫{ )01=<‪5.while( j‬‬
        ‫;"‪6.cout<< j<<" * " <<i<<"="<<i*j<<"\n‬‬
        ‫};++‪7.j‬‬
        ‫;"‪8.cout<<"\n‬‬
        ‫};++‪9.i‬‬
        ‫}‬


        ‫‪C‬‬                                                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i=1,j‬‬
        ‫{ )01=<‪2.while( i‬‬
        ‫;)‪3.prin ("Mul ply tabel for(%d).\n-------------------------------\n", i‬‬
        ‫;1=‪4. j‬‬
        ‫{ )01=<‪5.while( j‬‬
        ‫;)‪6.prin ("%d * %d=%d\n",i, j, i*j‬‬
        ‫};++‪7.j‬‬
        ‫;)"‪8.prin ("\n‬‬
        ‫};++‪9.i‬‬
        ‫}‬
                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

      ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾرﯾن اﻟﻣﺗﻐﯾر )‪ (i‬ھو ﺟدول ﺿرب اﻟرﻗم )ﻛﺎن ﯾﻛون ﺟدول ﺿرب ﺛﻼﺛﺔ ﻣﺛﻼ(‬
                                      ‫واﻟﻣﺗﻐﯾر )‪ (j‬ھوا ﯾﺿرب ﺑﺎﻟﻣﺗﻐﯾر اﻷول اﻷرﻗﺎم ﻣن واﺣد إﻟﻰ اﻟﻌﺷرة‬

      ‫٢.ﺧطوة رﻗم )٢( ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﻌد ﻣن )١( إﻟﻰ )٠١( وﻓﻲ ﻛل ﻋدة ﻟﮭﺎ ﺗﺗﻛرر اﻟﺧطوات رﻗم )٣ إﻟﻰ ٩(‬

    ‫٣.ﺧطوة رﻗم )٣( ھﻲ رﺳﺎﻟﺔ ﺗظﮭر ﺑداﯾﺔ ﻛل ﺟدول ﺗﺑﯾن ﻟﻠﻣﺳﺗﺧدم اﻧﮫ ھذا اﻟﺟدول ھو ﻟﻠرﻗم اﻟﻣﻌﯾن وھﻲ ﺑﺿﺑط‬
  ‫اﻟرﺳﺎﻟﺔ اﻟﻣوﺟودة ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻓﻲ اﻷﺳﻔل وﻣؤﺷر ﻋﻠﯾﮭﺎ ب )" ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٣("( وﻛﻣﺎ ﺗﻼﺣظ أن ﻓﻲ‬
            ‫ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟﺧطوة رﻗم )٢( ﺗﺗﻛرر اﻟﺧطوة رﻗم )٣( ﻣرة واﺣدة ﻟﺗظﮭر ﺑداﯾﺔ ﻛل ﺟدول‬

 ‫٤.ﺧطوة رﻗم )٤( ھﻲ ﻋﻣﻠﯾﺔ وﺿﻊ ﻗﯾﻣﺔ اﺑﺗداﺋﯾﺔ ﻟل )‪ (while‬اﻟداﺧﻠﯾﺔ ﻋﻧد ﻛل ﻋدة ﻟل )‪ (while‬ﻓﻲ ﺧطوة رﻗم )٢(‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                  ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




  ‫٥.ﺧطوة رﻗم )٥( ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ داﺧﻠﯾﺔ وﻓﻲ ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ اﻟﺧطوة رﻗم )٢( ﺗﻌﻣل ھذه اﻟﻌﺑﺎرة‬
   ‫ﺑﺎﻟﻌد ﻣن )١( إﻟﻰ )٠١( ﻟﻛﻲ ﻧﺿرب ﻛل رﻗم ﻣن اﻷرﻗﺎم اﻟﺗﻲ ﺗﻌدھﺎ اﻟﺧطوة رﻗم )٢( ﺑﺎﻷرﻗﺎم ﻣن )١( إﻟﻰ )٠١(‬
                                                            ‫وھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﯾﺗﺑﻌﮭﺎ ﺧطوات رﻗم )٦ و ٧(‬

‫٦. ﺧطوة رﻗم )٦( ھﻲ ﻋﻣﻠﯾﺔ طﺑﺎﻋﺔ ﻛل ﻗﯾﻣﺔ ﻣن اﻟﺗﻲ ﺗﻌدھﺎ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ اﻟﺧطوة رﻗم )٢( ﺑﺎﻷرﻗﺎم ﻣن )١(‬
 ‫إﻟﻰ )٠١( اﻟﺗﻲ ﺗﻌدھﺎ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ ﺧطوة رﻗم )٥( وھذه ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ ھﻲ ﺗﺎﺑﻌﺔ ﻟﮭذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ وﻣﺎ‬
    ‫ﺗﻧﺗﺟﮫ ھذه ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ ﺷﺎھده ﺑﺎﻟرﺳﺎﻟﺔ اﻟﻣوﺟودة ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻓﻲ اﻷﺳﻔل وﻣؤﺷر ﻋﻠﯾﮭﺎ ب )" ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ‬
                                                                                                ‫اﻟﺧطوة )٥("(‬

                                              ‫٧.ھو ﻋداد ﺧﺎص ﺑﺎﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ ﯾﻌد ﻣن )١( إﻟﻰ )٠١(‬

     ‫٨. ﺧطوة رﻗم )٨( ھﻲ ﻋﻣﻠﯾﺔ طﺑﺎﻋﺔ ﺳطر ﺟدﯾد ﺑﻌد ﻛل ﺟدول ﺿرب وﻻﺣظﮭﺎ ھﻲ ﺗﺎﺑﻌﺔ ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ‬
   ‫ﺧطوة رﻗم)٢( وﻣﺎ ﺗﻧﺗﺟﮫ ھذه ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ ﺷﺎھده ﺑﺎﻟرﺳﺎﻟﺔ اﻟﻣوﺟودة ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻓﻲ اﻷﺳﻔل وﻣؤﺷر ﻋﻠﯾﮭﺎ ب‬
                                                                             ‫)" ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٦("(‬

                                            ‫٩. ھو ﻋداد ﺧﺎص ﺑﺎﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟﺧﺎرﺟﯾﺔ ﯾﻌد ﻣن )١( إﻟﻰ )٠١(‬

                                                                         ‫ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٣(‬




                                                                              ‫ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٥(‬




                                                                               ‫ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٦(‬




                                                                                                                ‫ﻣﮭم‬



                               ‫ﻛﯾف ﻧﻌرف أن اﻟﺧطوة رﻗم )٨( ھﻲ ﺗﺎﺑﻌﮫ ﻟﻠﺧطوة رﻗم )٢( وﻟﯾس ﻟﻠﺧطوة رﻗم )٥(..؟‬

  ‫ﻛﻣﺎ ﺗﻼﺣظ أن ﺧطوة رﻗم )٢( ﺗﺣﺻر ﺑﯾن ﻗوﺳﯾﮭﺎ ﺧطوات رﻗم)٣ إﻟﻰ ٩( وﻧﻼﺣظ أن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ اﻟﺧطوة‬
    ‫رﻗم )٥( ﺗﺗﺑﻌﮭﺎ ﻓﻘط ﺧطوة رﻗم )٦ و٧( ﻓﺗﺑﻘﻰ اﻟﺧطوة رﻗم )٦( ﺧﺎرج ﻗوس اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ وﺑﻣﺎ أﻧﮭﺎ‬
                                                                  ‫داﺧل ﻗوﺳﯾن اﻟﺧطوة رﻗم )٢( ﻓﮭﻲ ﺗﺎﺑﻌﺔ ﻟﮭﺎ.‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                 ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                    ‫٨.٣- ﻋﺑﺎرة )‪ (Do-- While‬اﻟﺗﻛرارﯾﺔ :‬
‫ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﺳﺗﺧدم ﻟﺗﻛرار ﺧطوات ﺑرﻣﺟﯾﺔ اﻟﻣﺣﺻورة ﺑﯾن ﻗوﺳﯾﮭﺎ ﻟﻌدد ﻣن اﻟﻣرات ﺗﻛون ﻣﺷﺎﺑﮫ ﻛﺛﯾرا ﻟﻌﺑﺎرة‬
  ‫اﻟﺗﻛرار )‪ (For‬و)‪ . (while‬ﻓﻘط اﻻﺧﺗﻼف ﺑﯾﻧﮭﺎ وﺑﯾﻧﮭم أن ﻋﺑﺎرة )‪ (Do—While‬اﻟﺗﻛرارﯾﺔ ﺗﻧﻔذ ﻣﺎ ﺑﯾن ﻗوﺳﯾﮭﺎ‬
                          ‫ﺛم ﯾﺗﺣﻘق ﻣن اﻟﺷرط أﻣﺎ )‪ (For‬و )‪ (while‬ﯾﺗﺣﻘق ﻣن اﻟﺷرط ﺛم ﺗﻧﻔذ ﻣﺎ ﺑﯾن ﻗوﺳﯾﮭﺎ.‬

                                                                                ‫ھﯾﻛﻠﯾﺔ ‪Do-- while—Loop‬‬
         ‫‪Initializing‬‬
        ‫{ ‪do‬‬
        ‫;‪Statement‬‬
        ‫‪Update‬‬
        ‫;)‪} while ( Boolean_Expression‬‬


                      ‫)‪ :(Initializing‬ھﻲ اﻟﻘﯾﻣﺔ اﻟﺑداﺋﯾﺔ اﻟﻣﻌطﺎة ﻟﻠﻣﺗﻐﯾر اﻟﺗﻲ ﻣﻧﮭﺎ ﺳﯾﺑدأ اﻟﻌد. )ﻣﺛﻼ 0=‪(i‬‬     ‫‪‬‬
‫)‪ :(Boolean_Expression‬ھو ﺷرط اﻟﺗوﻗف اﻟذي ﻋﻧدﻣﺎ ﺗﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻏﯾر ﻣﺣﻘﻘﺔ ﻟﺷرط اﻟﺗوﻗف‬                       ‫‪‬‬
     ‫ﺳوف ﯾﺧرج ﻣن ﻋﺑﺎرة )‪ (while‬ﺑﻣﻌﻧﻰ أﺧر ﻣﺎدام ﻧﺗﯾﺟﺔ اﺧﺗﺑﺎره ال )‪ (Boolean_Expression‬ھﻲ‬
‫)‪ (True‬اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﺗﺳﺗﻣر ﺑﺗﻧﻔﯾذ ﻣﺎﺑﯾن ﻗوﺳﯾﮭﺎ وﻣﺗﻰ ﻣﺎ أﺻﺑﺢ )‪ (False‬ﯾﺧرج ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ.‬
                                                   ‫ﻣﺛﻼ ) 5<‪ ((i‬ھوا ﺷرط اﻟﺗوﻗف وﯾﺑدأ اﻟﻌد ﻣن اﻟواﺣد‬
    ‫)‪ :(Update‬ھﻲ ﻣﻘدار اﻟزﯾﺎدة أو اﻟﻧﻘﺻﺎن ﻓﻲ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻓﻲ ﻛل دورة )‪ .(loop‬ﻣﺛﻼ )++‪ ( i‬أو )--‪(i‬‬             ‫‪‬‬
   ‫)‪ :(statement‬ھﻲ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺳﺗﻧﻔذ ﻋدد ﻣن اﻟﻣرات .إذا ﻛﺎﻧت ﻋﺑﺎرة ﻋن ﺧطوة ﺑرﻣﺟﯾﺔ‬                  ‫‪‬‬
                                                                                                                 ‫ﻣﮭم‬
             ‫واﺣدة ﻓﻠﯾس ﺑﺣﺎﺟﺔ ﻟوﺿﻌﮭﺎ داﺧل أﻗواس وإذا ﻛﺎﻧت أﻛﺛر ﻣن ﺧطوة ﯾﺟب وﺿﻌﮭﺎ داﺧل أﻗواس.‬

                                                          ‫ﻛﯾف ﺗﻌﻣل ﻋﺑﺎرة ال )‪ ( do --while‬اﻟﺗﻛرارﯾﺔ........؟‬

  ‫أن اﻟﻣﺗﻐﯾر ﯾﺑدأ ﺑﻘﯾﻣﺔ ﺑداﺋﯾﺔ )‪ (Initializing‬وﯾﺳﺗﻣر ﺑﺎﻟزﯾﺎدة أو اﻟﻧﻘﺻﺎن ﺣﺳب )‪ (Update‬أي ﻗد ﯾزداد أو ﯾﻧﻘص‬
 ‫ﺑﻣﻘدار واﺣد أو أﻛﺛر ﻣن واﺣد وﻣﺗﻰ ﻣﺎ أﺻﺑﺢ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻏﯾر ﻣﺣﻘﻘﺔ ﻟﻠﺷرط )‪ (Boolean_Expression‬ﯾﺧرج‬
  ‫ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ إﻟﻰ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ ﺗﻠﯾﮫ وإذا ﻛﺎﻧت ﻣﺣﻘﻘﺔ ﻟﻠﺷرط ﯾﻧﻔذ اﻟﺧطوات اﻟﺑرﻣﺟﯾﺔ اﻟﺗﻲ داﺧل‬
                                                                               ‫اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻣن ﺟدﯾد.‬
                           ‫‪ ‬ﻹدﺧﺎل )‪ (do--while‬ﻓﻲ دوارة ﻻﻧﮭﺎﺋﯾﺔ ﻧﻛﺗب )1(‪ do -- while‬ﻓﻘط .‬
                            ‫ﻣﺛﺎل: ﻟو أردﻧﺎ ﻋداد ﯾﻌد ﻣن )0( إﻟﻰ )4( أي ﯾطﺑﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻣن )0 إﻟﻰ 4(‬
        ‫++‪C‬‬                                                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;0=‪{1.int i‬‬
        ‫{ ‪2.do‬‬
         ‫;"‪3.cout<<i<<"\t‬‬
        ‫};++‪4. i‬‬
        ‫;)5<‪5. while( i‬‬
        ‫}‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                              ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




         ‫‪C‬‬                                                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;0=‪{1.int i‬‬
        ‫{ ‪2.do‬‬
         ‫;)‪3.printf("%d\t",i‬‬
        ‫};++‪4. i‬‬
        ‫;)5<‪5. while( i‬‬
         ‫}‬
                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬

     ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (i‬ﻣن ﻧوع ‪ .integer‬ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد اﻟﻌد ﻣن اﻟﺻﻔر ﻓﺄﻋطﯾﻧﺎ اﻟﻘﯾم اﻟﺑداﺋﯾﺔ ﺻﻔر‬
     ‫٢.ﺧطوة رﻗم )٢( ﺗﻣﺗد إﻟﻰ ﺧطوة رﻗم )٥( ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺑﻣﺎ أن اﻟﻌد ﯾﺻل إﻟﻰ ٤ ﻣﻌﻧﺎه ﺷرط اﻟﺗوﻗف أن‬
  ‫ﯾﻛون اﻗل ﻣن ﺧﻣﺳﺔ ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد أن ﯾﻌد ﺧﻣس ﻋدات ﺑﯾن ﺻﻔر واﻷرﺑﻌﺔ ﻟذاﻟك ﯾﺟب أن ﯾﻛون ﻣﻘدار اﻟزﯾﺎدة واﺣد‬
  ‫ﻟﯾﻌد )4,3,2,1, 0( .ﻻن ﻟو ﺟﻌﻠﻧﺎ ﻣﻘدار اﻟزﯾﺎدة ٢ ﻣﺛﻼ ﻓﺳﯾﻌد اﻟﻌداد ﺛﻼث ﻣرات ﻣرة )4,2,0( ﻟذاﻟك ﯾﺟب اﻟﺗرﻛﯾز‬
                                                                                       ‫ﻓﻲ ھذه اﻟﻣواﺿﯾﻊ ﺟﯾدا.‬
                                              ‫اﻟﻘﯾﻣﺔ اﻟﺑداﺋﯾﺔ‬
                                              ‫ﻟﻠﻌداد )0=‪(i‬‬                                                   ‫ﻣﮭم‬




                                               ‫طﺑﺎﻋﺔ اﻟﻘﯾﻣﺔ‬


                                                ‫زﯾﺎدة ﻗﯾﻣﺔ‬
                                               ‫اﻟﻌداد )++‪(i‬‬

                                                  ‫ﺷرط‬
                                               ‫اﻟﺗﺣﻘق)5<‪(i‬‬

                                               ‫ﺧروج ﻣن‬
                                              ‫ﺟﻣﻠﺔ اﻟﺗﻛرار‬
 ‫ﻟو ﺗﻼﺣظ اﻟﻣﺧطط اﻟﺧﺎص ﺑﺎﻟﺑرﻧﺎﻣﺞ ﻋﻧدﻣﺎ ﯾﺣﻘق اﻟﺷرط ﯾﺗﺟﮫ ﻟﺧطوة اﻟطﺑﺎﻋﺔ وإذا ﻟم ﯾﺣﻘق ﯾﺧرج ﻣن ﺟﻣﻠﺔ ﺗﻛرار‬

    ‫٣.ﺧطوة رﻗم )٣( ھﻲ طﺑﺎﻋﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻋﻧد ﻛل ﻋدة .ﺧطوة رﻗم )٤( ھو ﻋداد ﯾزداد ﺑﻣﻘدار واﺣد ﻋﻧد ﻛل ﻋدة‬
                                       ‫* ﻗﺎرن ھذا اﻟﻣﺛﺎل ﺑﺎﻟﻣﺛﺎل اﻟﻣﺷﺎﺑﮫ ﻟﮫ ب)‪ ( while , For‬وﺷﺎھد اﻟﻔرق .‬




‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:ﺗﻧﻔذ ﺧطوة رﻗم )١( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٣( وﺧطوة رﻗم )٤( ﺧﻣس ﻣرات‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                        ‫ﻣﺛﺎل: ﻟو أردﻧﺎ ﻋداد ﯾﻌد ﻣن )4( إﻟﻰ )0( أي ﯾطﺑﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ )0 1 2 3 4 (‬

‫ﺗﺣﻠﯾل:ﺣﻠﮭﺎ ﻧﻔس ﺣل اﻟﺳؤال اﻟﺳﺎﺑق ﻓﻘط ﻧﻘﻠب اﻟﻌداد أي ﻧﺟﻌل ﻗﯾﻣﺗﮫ اﻟﺑداﺋﯾﺔ ھﻲ ٤ وﺷرط اﻟﺗوﻗف اﻛﺑر أو ﯾﺳﺎوي‬
                                                                      ‫ﺻﻔر وﯾﺗﻧﺎﻗص ﺑﻣﻘدار واﺣد ﻛل ﻋدة‬



        ‫++‪C‬‬                                                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;4=‪{1.int i‬‬
        ‫‪2.do‬‬
        ‫;"‪{3.cout<<i<<"\t‬‬
        ‫};--‪4.i‬‬
        ‫;)0=>‪5. while( i‬‬
        ‫}‬


         ‫‪C‬‬                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;4=‪{1.int i‬‬
        ‫‪2.do‬‬
         ‫;)‪3.printf("%d\t",i‬‬
        ‫};--‪4.i‬‬
        ‫;)0=>‪5.while( i‬‬
        ‫}‬



                                                                                         ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬

                               ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (i‬ﻣن ﻧوع ‪ integer‬ﻓﺄﻋطﯾﻧﺎه اﻟﻘﯾم اﻟﺑداﺋﯾﺔ أرﺑﻌﺔ‬

    ‫٢.ﺧطوة رﻗم )٢(ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد اﻟﻌد ﻣن اﻷرﺑﻌﺔ ﻓﺄﻋطﯾﻧﺎ اﻟﻘﯾم اﻟﺑداﺋﯾﺔ أرﺑﻌﺔ .واﻟﻌد ﯾﺻل إﻟﻰ‬
  ‫اﻟﺻﻔر ﻣﻌﻧﺎه ﺷرط اﻟﺗوﻗف أن ﯾﻛون اﻛﺑر أو ﯾﺳﺎوي ﺻﻔر ) )0=>‪ ( while(i‬ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد أن ﯾﻌد ﺧﻣس ﻋدات ﺑﯾن‬
    ‫ﺻﻔر واﻷرﺑﻌﺔ ﻟذاﻟك ﯾﺟب أن ﯾﻛون ﻣﻘدار ﻧﻘﺻﺎن واﺣد ﻟﯾﻌد )0,1,2,3,4( .ﻻن ﻟو ﺟﻌﻠﻧﺎ ﻣﻘدار اﻟﻧﻘﺻﺎن ٢ ﻣﺛﻼ‬
                               ‫ﻓﺳﯾﻌد اﻟﻌداد ﺛﻼث ﻣرات ﻣرة )0,2,4( ﻟذاﻟك ﯾﺟب اﻟﺗرﻛﯾز ﻓﻲ ھذه اﻟﻣواﺿﯾﻊ ﺟﯾدا‬
   ‫٣.ﺧطوة رﻗم )٣( ھﻲ طﺑﺎﻋﺔ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻋﻧد ﻛل ﻋدة .ﺧطوة رﻗم )٤( ھو ﻋداد ﯾﻧﻘص ﺑﻣﻘدار واﺣد ﻋﻧد ﻛل ﻋدة‬

                                                                                    ‫ﺳﯾطﺑﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬


                                                                                  ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:‬

         ‫ﺗﻧﻔذ ﺧطوة رﻗم )١( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٣( وﺧطوة رﻗم )٤( ﺧﻣس ﻣرات ﺑﻘدر ﻋدات اﻟﻌداد‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                         ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                            ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                         ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﺟﻣﻊ اﻹﻋداد اﻟﻔردﯾﺔ ﺑﯾن ) 001—0(‬

    ‫ﺗﺣﻠﯾل: ﻧرى اﻧﮫ ﯾرﯾد اﻹﻋداد اﻟﻔردﯾﺔ ﻓﻘط ﻟذاﻟك ﯾﺟب أن ﻧطﻔر اﻹﻋداد اﻟزوﺟﯾﺔ .ﻧﻛون ﻋداد ﯾﻌد ﻣن اﻟواﺣد وﺷرط‬
                                      ‫اﻟﺗوﻗف ﻋﻧد اﻟﻣﺎﺋﺔ وﻣﻘدار اﻟزﯾﺎدة ﻓﻲ )٢( ﺣﺗﻰ ﻧﺟﻣﻊ ﻓﻘط اﻹﻋداد اﻟﻔردﯾﺔ‬

        ‫++‪C‬‬                                                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;1=‪{1.int n‬‬
        ‫;0=‪2.int sum‬‬
        ‫‪3.do‬‬
        ‫; ‪{4. sum += n‬‬
        ‫;)001<‪5. n=n+2;} while( n‬‬
        ‫};‪6.Cout<<"sum="<<sum‬‬


        ‫‪C‬‬                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;1=‪{1.int n‬‬
        ‫;0=‪2.int sum‬‬
        ‫‪3.do‬‬
        ‫; ‪{4. sum += n‬‬                                                                                      ‫ﻣﮭم‬
        ‫;)001<‪5. n=n+2;} while( n‬‬
        ‫};)‪6.printf("sum=%d",sum‬‬
                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
   ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ) ‪ (n‬ﻣن ﻧوع )‪ (integer‬ﻟﯾﻛون ﻋداد ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ وﻗﯾﻣﺗﮫ اﻻﺑﺗداﺋﯾﺔ ھﻲ واﺣد‬

 ‫٢.ﺧطوة رﻗم )٢( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر )‪ (sum‬ﻣن ﻧوع )‪ (integer‬وأﻋطﯾﻧﺎه ﻗﯾﻣﺔ ﺑداﺋﯾﺔ وھﻲ ﺻﻔر ﻷﻧﻧﺎ ﺳﻧﺟﻣﻊ واﻟﻧﺿﯾر‬
                          ‫اﻟﺟﻣﻌﻲ ھو ﺻﻔر ﺣﺗﻰ ﻋﻧدﻣﺎ ﻧﺟﻣﻌﮫ ﻣﻊ أول ﻗﯾﻣﺔ وھﻲ واﺣد ﺳﯾﺟﻣﻊ واﺣد ﻣﻊ اﻟﺻﻔر‬

     ‫٣.ﺧطوة رﻗم )٣( ﺟﻣﻠﺔ ﺗﻛرارﯾﺔ ) )001<‪ (do-- while(n‬وﯾﺑدأ اﻟﻌد ﻣن اﻟواﺣد ﻷﻧﮫ أول ﻋدد ﻓردي إﻟﻰ ٩٩‬

       ‫٤.ﺧطوة رﻗم )٤( ﺟﻣﻌﻧﺎ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬ﻣﻊ ﻗﯾﻣﺔ اﻟﻌداد ﻋﻧد ﻛل ﻋدة. أي ﻋﻧدﻣﺎ ﯾﻛون ) 1=‪ (n‬ﺳﯾﺟﻣﻊ‬
    ‫)1+0=‪ (sum‬وﻋﻧدﻣﺎ ﯾﺻﺑﺢ ) 3=‪ (n‬ﺳﯾﺟﻣﻊ ﻗﯾﻣﺔ )‪ (sum‬اﻟﺳﺎﺑﻘﺔ وھﻲ أﺻﺑﺣت واﺣد ﻣﻊ ﺛﻼﺛﺔ )3+1=‪(sum‬‬
        ‫وﻋﻧدﻣﺎ ﯾﺻﺑﺢ ) 5=‪ (n‬ﺳﯾﺟﻣﻊ ﻗﯾﻣﺔ )‪ (sum‬اﻟﺳﺎﺑﻘﺔ وھﻲ أﺻﺑﺣت أرﺑﻌﺔ ﻣﻊ ﺛﻼﺛﺔ )5+4=‪ (sum‬وﯾﺳﺗﻣر.‬

 ‫٥.ﺧطوة رﻗم )٥( ھو زﯾﺎدة ﻟﻠﻌداد ﺑﻣﻘدار اﺛﻧﺎن ﺣﺗﻰ ﻓﻘط ﻧﺟﻣﻊ اﻹﻋداد اﻟﻔردﯾﺔ وإذا ﺗﺟﺎوز اﻟﺷرط ﯾﺧرج ﻣن ﺗﻛرار‬
                                                     ‫٦.ﺧطوة رﻗم )٦( طﺑﺎﻋﺔ اﻟﻧﺎﺗﺞ اﻟﺟﻣﻊ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
   ‫0052=‪Sum‬‬
  ‫ﻋدد ﻣرات ﺗﻧﻔﯾذ اﻟﺧطوات:ﺗﻧﻔذ ﺧطوة رﻗم )١و٢( ﻣرة واﺣدة ﻓﻘط.وﺗﻧﻔذ ﺧطوة رﻗم)٤( وﺧطوة رﻗم )٥( ﺧﻣﺳﯾن‬
                    ‫ﻣرة ﻻن اﻹﻋداد اﻟﻔردﯾﺔ ﺑﯾن)001—0( ھﻲ ﺧﻣﺳﯾن رﻗم وﺗﻧﻔذ ﺧطوة رﻗم)٦( ﻣرة واﺣدة‬



    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                       ‫٩.٣- ﻋﺑﺎرة )‪ (do-- While‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ :‬
 ‫وﺗﻛون ﻣﺷﺎﺑﮫ ﻟﻌﺑﺎرات ) ‪ while‬و ‪ (for‬اﻟﺗﻛرارﯾﺔ ﺗﻘرﯾﺑﺎ. ھذه اﻟﻌﺑﺎرة اﻟﺗﻛرار ﺳوف ﻻ ﺗﻛرر ﻓﻘط اﺳطر ﺑرﻣﺟﯾﺔ‬
     ‫إﻧﻣﺎ ﺗﻛرر ﻋﺑﺎرات ﺗﻛرارﯾﺔ أﺧرى ﺗوﺟد ﻓﻲ داﺧﻠﮭﺎ )‪ . ( while , for , do—while‬أي ﻓﻲ ﻛل ﻋدة ﻟل‬
  ‫)‪ (do-while‬إﻻم ﺳﺗﻌد )‪ (do-while‬اﻟداﺧﻠﯾﺔ ﺟﻣﯾﻊ ﻋداﺗﮭﺎ.ﺣﺎﻟﮭﺎ ﻛﺣﺎل أي ﺧطوة ﺑرﻣﺟﯾﺔ داﺧل ﻋﺑﺎرة ﺗﻛرارﯾﺔ‬
   ‫وﺑﻣﺎ أن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ ﯾﻣر ﻋﻠﯾﮭﺎ ﻋﻧد ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ إﻻم ﻟذاﻟك ﻓﻲ ﻛل ﻋدة ﻟﻼم ﺗﻌد اﻟﻌﺑﺎرة‬
                                                           ‫اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ ﺟﻣﯾﻊ ﻋداﺗﮭﺎ اﻟﻣﻣﻛﻧﺔ ﺣﺳب ﺷرطﮭﺎ .‬

                                                                                        ‫ھﯾﻛﻠﯾﺔ ‪do--while‬‬
         ‫;1‪Initializing‬‬
        ‫‪do‬‬
        ‫;2‪{ Ini alizing‬‬
        ‫‪do‬‬
        ‫{‬
        ‫;‪Statement‬‬
        ‫;2‪Update‬‬
        ‫; )2‪} While(Boolean_Expression‬‬
        ‫;1‪Update‬‬
        ‫;)1‪} While(Boolean_Expression‬‬


                                                                        ‫ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو ﻛﺎن ﻟدﯾﻧﺎ ھذا اﻟﺗداﺧل‬

                                                                                                     ‫ﻣﺛﺎل‬
        ‫;0=‪i‬‬
       ‫‪do‬‬
       ‫;0=‪{ j‬‬
       ‫‪do‬‬
       ‫{‬
       ‫‪statement‬‬                                                                                       ‫ﻣﮭم‬
       ‫; )5<‪j++;} While(j‬‬
       ‫;)5<‪i++;} while( i‬‬
             ‫ﻓﻔﻲ ﻛل ﻋدة ﺑﺎﻟﻧﺳﺑﺔ ﻟل )‪ (do--While‬اﻟﺧﺎرﺟﯾﺔ ﺗﻌد ال )-‪ ( do-while‬اﻟداﺧﻠﯾﺔ ﺧﻣس ﻣرات وﺗﻧﻔذ‬
 ‫)‪ ( statement‬ﺧﻣس ﻣرات أي أن إذا ﻛﺎن )0=‪ (i‬ﺳﯾﻌد ال )‪( j‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0( و إذا أﺻﺑﺢ )1=‪ (i‬ﺳﯾﻌد‬
 ‫ال )‪ ( j‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0( و إذا أﺻﺑﺢ )2=‪ (i‬ﺳﯾﻌد ال )‪ ( j‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0( و إذا أﺻﺑﺢ )3=‪ (i‬ﺳﯾﻌد‬
                        ‫ال )‪ ( j‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0( و إذا أﺻﺑﺢ )4=‪ (i‬ﺳﯾﻌد ال )‪ ( j‬ﻗﯾﻣﮫ وھﻲ )4,3,2,1,0(‬

 ‫**ﺗﺑﻘﻰ اﻟﻣﺑﺎدئ ﺛﺎﺑﺗﺔ ﻛل ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﯾﺗﺑﻌﮭﺎ ﺳطر ﺑرﻣﺟﻲ واﺣد إذا ﻟم ﻧﺳﺗﺧدم أﻗواس وإذا وﺿﻌﻧﺎ أﻗواس ﻛل اﻟذي‬
                                                                  ‫داﺧل اﻷﻗواس ھو ﺗﺎﺑﻊ ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ.‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                 ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﺟدول ﺿرب ﻣن )١( إﻟﻰ )٠١( .؟‬

                        ‫ﺗﺣﻠﯾل :)اﻟﻣﺛﺎل ﻧﻔﺳﮫ ﻣوﺟود ﻓﻲ ﻋﺑﺎرة )‪ (for‬اﻟﺗﻛرارﯾﺔ اﻟﻣﺗداﺧﻠﺔ ﺳﺗﺟد ﺗﺣﻠﯾل ﺑﺷﻛل ﻣﻔﺻل.(‬

        ‫++‪C‬‬                                                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i=1,j‬‬
        ‫{ ‪2.do‬‬
        ‫;"‪3.cout<<"Multiply tabel for("<<i<<").\n-------------------------------\n‬‬
        ‫;1=‪4. j‬‬
        ‫{ ‪5.do‬‬
        ‫;"‪6.cout<< j<<" * " <<i<<"="<<i*j<<"\n‬‬
        ‫;)01=<‪7.j++;} while( j‬‬
        ‫;"‪8.cout<<"\n‬‬
        ‫;)01=<‪9.i++;} while( i‬‬
        ‫}‬


        ‫‪C‬‬                                                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫;‪{1.int i=1,j‬‬
        ‫{ ‪2.do‬‬
        ‫;)‪3.prin ("Mul ply tabel for(%d).\n-------------------------------\n", i‬‬
        ‫;1=‪4. j‬‬
        ‫{ ‪5.do‬‬
        ‫;)‪6.prin ("%d * %d=%d\n",i, j, i*j‬‬
        ‫;)01=<‪7.j++;} while( j‬‬
        ‫;)"‪8.prin ("\n‬‬
        ‫;)01=<‪9.i++;} while( i‬‬
        ‫}‬
                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

      ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾرﯾن اﻟﻣﺗﻐﯾر )‪ (i‬ھو ﺟدول ﺿرب اﻟرﻗم )ﻛﺎن ﯾﻛون ﺟدول ﺿرب ﺛﻼﺛﺔ ﻣﺛﻼ(‬
                                      ‫واﻟﻣﺗﻐﯾر )‪ (j‬ھوا ﯾﺿرب ﺑﺎﻟﻣﺗﻐﯾر اﻷول اﻷرﻗﺎم ﻣن واﺣد إﻟﻰ اﻟﻌﺷرة‬

      ‫٢.ﺧطوة رﻗم )٢( ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﻌد ﻣن )١( إﻟﻰ )٠١( وﻓﻲ ﻛل ﻋدة ﻟﮭﺎ ﺗﺗﻛرر اﻟﺧطوات رﻗم )٣ إﻟﻰ ٩(‬

    ‫٣.ﺧطوة رﻗم )٣( ھﻲ رﺳﺎﻟﺔ ﺗظﮭر ﺑداﯾﺔ ﻛل ﺟدول ﺗﺑﯾن ﻟﻠﻣﺳﺗﺧدم اﻧﮫ ھذا اﻟﺟدول ھو ﻟﻠرﻗم اﻟﻣﻌﯾن وھﻲ ﺑﺿﺑط‬
  ‫اﻟرﺳﺎﻟﺔ اﻟﻣوﺟودة ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻓﻲ اﻷﺳﻔل وﻣؤﺷر ﻋﻠﯾﮭﺎ ب )" ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٣("( وﻛﻣﺎ ﺗﻼﺣظ أن ﻓﻲ‬
            ‫ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟﺧطوة رﻗم )٢( ﺗﺗﻛرر اﻟﺧطوة رﻗم )٣( ﻣرة واﺣدة ﻟﺗظﮭر ﺑداﯾﺔ ﻛل ﺟدول‬

     ‫٤.ﺧطوة رﻗم )٤( ھﻲ ﻋﻣﻠﯾﺔ وﺿﻊ ﻗﯾﻣﺔ اﺑﺗداﺋﯾﺔ ﻟل )‪ (do--while‬اﻟداﺧﻠﯾﺔ ﻋﻧد ﻛل ﻋدة ﻟل )‪ (do-- while‬ﻓﻲ‬
                                                                                        ‫ﺧطوة رﻗم )٢(‬



    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                                  ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




  ‫٥.ﺧطوة رﻗم )٥( ھﻲ ﻋﺑﺎرة ﺗﻛرارﯾﺔ داﺧﻠﯾﺔ وﻓﻲ ﻛل ﻋدة ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ اﻟﺧطوة رﻗم )٢( ﺗﻌﻣل ھذه اﻟﻌﺑﺎرة‬
   ‫ﺑﺎﻟﻌد ﻣن )١( إﻟﻰ )٠١( ﻟﻛﻲ ﻧﺿرب ﻛل رﻗم ﻣن اﻷرﻗﺎم اﻟﺗﻲ ﺗﻌدھﺎ اﻟﺧطوة رﻗم )٢( ﺑﺎﻷرﻗﺎم ﻣن )١( إﻟﻰ )٠١(‬
                                                            ‫وھذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﯾﺗﺑﻌﮭﺎ ﺧطوات رﻗم )٦ و ٧(‬

‫٦. ﺧطوة رﻗم )٦( ھﻲ ﻋﻣﻠﯾﺔ طﺑﺎﻋﺔ ﻛل ﻗﯾﻣﺔ ﻣن اﻟﺗﻲ ﺗﻌدھﺎ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ اﻟﺧطوة رﻗم )٢( ﺑﺎﻷرﻗﺎم ﻣن )١(‬
 ‫إﻟﻰ )٠١( اﻟﺗﻲ ﺗﻌدھﺎ اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ ﺧطوة رﻗم )٥( وھذه ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ ھﻲ ﺗﺎﺑﻌﺔ ﻟﮭذه اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ وﻣﺎ‬
    ‫ﺗﻧﺗﺟﮫ ھذه ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ ﺷﺎھده ﺑﺎﻟرﺳﺎﻟﺔ اﻟﻣوﺟودة ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻓﻲ اﻷﺳﻔل وﻣؤﺷر ﻋﻠﯾﮭﺎ ب )" ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ‬
                                                                                                ‫اﻟﺧطوة )٥("(‬

                                              ‫٧.ھو ﻋداد ﺧﺎص ﺑﺎﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ ﯾﻌد ﻣن )١( إﻟﻰ )٠١(‬

     ‫٨. ﺧطوة رﻗم )٨( ھﻲ ﻋﻣﻠﯾﺔ طﺑﺎﻋﺔ ﺳطر ﺟدﯾد ﺑﻌد ﻛل ﺟدول ﺿرب وﻻﺣظﮭﺎ ھﻲ ﺗﺎﺑﻌﺔ ﻟﻠﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ‬
   ‫ﺧطوة رﻗم)٢( وﻣﺎ ﺗﻧﺗﺟﮫ ھذه ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ ﺷﺎھده ﺑﺎﻟرﺳﺎﻟﺔ اﻟﻣوﺟودة ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻓﻲ اﻷﺳﻔل وﻣؤﺷر ﻋﻠﯾﮭﺎ ب‬
                                                                             ‫)" ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٦("(‬

                                            ‫٩. ھو ﻋداد ﺧﺎص ﺑﺎﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟﺧﺎرﺟﯾﺔ ﯾﻌد ﻣن )١( إﻟﻰ )٠١(‬

                                                                         ‫ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٣(‬




                                                                              ‫ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٥(‬




                                                                               ‫ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺧطوة )٦(‬




                                                                                                                ‫ﻣﮭم‬



                               ‫ﻛﯾف ﻧﻌرف أن اﻟﺧطوة رﻗم )٨( ھﻲ ﺗﺎﺑﻌﮫ ﻟﻠﺧطوة رﻗم )٢( وﻟﯾس ﻟﻠﺧطوة رﻗم )٥(..؟‬

  ‫ﻛﻣﺎ ﺗﻼﺣظ أن ﺧطوة رﻗم )٢( ﺗﺣﺻر ﺑﯾن ﻗوﺳﯾﮭﺎ ﺧطوات رﻗم)٣ إﻟﻰ ٩( وﻧﻼﺣظ أن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﻓﻲ اﻟﺧطوة‬
    ‫رﻗم )٥( ﺗﺗﺑﻌﮭﺎ ﻓﻘط ﺧطوة رﻗم )٦ و٧( ﻓﺗﺑﻘﻰ اﻟﺧطوة رﻗم )٦( ﺧﺎرج ﻗوس اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟداﺧﻠﯾﺔ وﺑﻣﺎ أﻧﮭﺎ‬
                                                                  ‫داﺧل ﻗوﺳﯾن اﻟﺧطوة رﻗم )٢( ﻓﮭﻲ ﺗﺎﺑﻌﺔ ﻟﮭﺎ.‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                              ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬


                                                                                                           ‫ﻣﮭم‬



                           ‫٠١.٣- اﻟﻔرق ﺑﯾن دوال اﻟﺗﻛرار )‪(for,while,do—while‬‬
 ‫ﻛﻣﺎ ﻗﻠﻧﺎ أن اﻻﺧﺗﻼف ﺑﯾﻧﮭﺎ وﺑﯾﻧﮭم أن داﻟﺔ )‪ (Do—While‬اﻟﺗﻛرارﯾﺔ ﺗﻧﻔذ ﻣﺎ ﺑﯾن ﻗوﺳﯾﮭﺎ ﺛم ﯾﺗﺣﻘق ﻣن اﻟﺷرط ﻓﺈذا‬
    ‫ﻛﺎن ﻧﺎﺗﺞ اﻟﺷرط )‪ ( True‬ﺗﻌﯾد ﺗﻧﻔﯾذ ﻣﺎ ﺑﯾن ﻗوﺳﯾﮭﺎ ﻣن ﺟدﯾد وإذا ﻛﺎن )‪ (False‬ﻓﺗﻧﺗﻘل ﻟﻠﺧطوة اﻟﺗﻲ ﺗﻠﯾﮫ. أﻣﺎ‬
     ‫)‪ (For‬و )‪ (while‬ﯾﺗﺣﻘق ﻣن اﻟﺷرط ﺛم ﺗﻧﻔذ ﻣﺎﺑﯾن ﻗوﺳﯾﮭﺎ ﻛﺎن ﻧﺎﺗﺞ اﻟﺷرط )‪ ( True‬ﺗﻧﻔذ ﻣﺎﺑﯾن ﻗوﺳﯾﮭﺎ وإذا‬
                                                                    ‫ﻛﺎن )‪ (False‬ﻓﺗﻧﺗﻘل ﻟﻠﺧطوة اﻟﺗﻲ ﺗﻠﯾﮫ.‬
                                                                                  ‫ﻟﺗوﺿﯾﺢ اﻟﻔﻛرة ﺑﮭذا اﻟﻣﺛﺎل.‬
      ‫ﻣﺛﺎل:ﺑرﻧﺎﻣﺞ ﯾطﻠب ﻣﻧك أن ﺗدﺧل رﻗم وﯾﻘدر اﻟرﻗم ﯾطﺑﻊ ﻋﺑﺎرة )!‪ (Hello‬أي ﻟو أدﺧﻠت )٥( ﺳﯾطﺑﻊ ھذه اﻟﻌﺑﺎرة‬
                                                           ‫ﺧﻣﺳﺔ ﻣرات وإذا أدﺧﻠت واﺣد ﯾطﺑﻌﮭﺎ ﻣرة واﺣدة.‬

  ‫ﺗﺣﻠﯾل :ﻣﺎدام ﻋدد ﻣرات اﻟطﺑﺎﻋﺔ ﻣرﺗﺑط ﺑﺈدﺧﺎل اﻟﻣﺳﺗﺧدم ﻓﺎﻟﺣل ﯾﻛون ﻋﺑﺎرة ﺗﻛرارﯾﺔ ﺗﺑدأ ﻣن اﻟواﺣد إﻟﻰ اﻟرﻗم اﻟذي‬
             ‫ادﺧﻠﮫ اﻟﻣﺳﺗﺧدم وﺗﺣﺗﮫ ﺟﻣﻠﺔ طﺑﺎﻋﺔ )أي إذا ادﺧل ٢ ﺳﯾﻌد اﻟﻌداد )2,1( أي ﻋدﺗﺎن وﯾطﺑﻊ اﻟﺟﻣﻠﺔ ﻣرﺗﺎن(.‬

                                                                         ‫اﻟﺣل ﺑﺎﺳﺗﺧدام داﻟﺔ )‪ (For‬اﻟﺗﻛرارﯾﺔ.‬

        ‫++‪C‬‬                                                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<iostream.h‬‬
        ‫)(‪main‬‬
        ‫{‬
        ‫;‪1.int i,input_numbe‬‬
        ‫; ‪2.cin>> input_numbe‬‬
        ‫)++‪3.for (i=1 ;i<= input_numbe ;i‬‬
        ‫;"‪4.cout<<"Hello!\n‬‬
        ‫}‬


        ‫‪C‬‬                                                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        ‫>‪#include<stdio.h‬‬
        ‫)(‪main‬‬
        ‫{‬
        ‫;‪1.int i,input_numbe‬‬
        ‫; )‪2.scanf("%d",& input_numbe‬‬
        ‫)++‪3.for (i=1 ;i<= input_numbe ;i‬‬
        ‫;)"‪4.prin ("Hello!\n‬‬
        ‫}‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(loop) ‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار‬                                                         ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                  .‫( اﻟﺗﻛرارﯾﺔ‬While) ‫اﻟﺣل ﺑﺎﺳﺗﺧدام داﻟﺔ‬

        C++                                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        #include<iostream.h>
        main()
        {1.int i=1,input_numbe;
        2.cin>> input_numbe ;
        3.while(i<= input_numbe )
        { 4.cout<<"Hello!\n";
        5.i++; }
        }


        C                                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        #include<stdio.h>
        main()
        {1.int i=1,input_numbe;
        2.scanf("%d",& input_numbe) ;
        3.while(i<= input_numbe )
        {4.prin ("Hello!\n");
        5.i++; }
        }


                                             .‫( اﻟﺗﻛرارﯾﺔ‬Do--While) ‫اﻟﺣل ﺑﺎﺳﺗﺧدام داﻟﺔ‬

        C++                                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        #include<iostream.h>
        main()
        {1.int i=1,input_numbe;
        2.cin>> input_numbe ;
        3.do
        { 4.cout<<"Hello!\n";
        5.i++; } while(i<= input_numbe ) ;
        }


        C                                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
        #include<stdio.h>
        main()
        {1.int i=1,input_numbe;
        2.scanf("%d",& input_numbe) ;
        3.do
        {4.prin ("Hello!\n");
        5.i++; } while(i<= input_numbe ) ;
        }



    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                      C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫ﻋﺑﺎرات أو ﺟﻣل اﻟﺗﻛرار )‪(loop‬‬                                                                            ‫اﻟﻔﺻل اﻟﺛﺎﻟث‬




                                                                               ‫أﻻن ﻟﻧﻘﺎرن ﻧﺗﺎﺋﺞ اﻷﻣﺛﻠﺔ اﻟﺛﻼﺛﺔ‬

                                                                      ‫١.إذا أدﺧﻠﻧﺎ اﻟرﻗم )٥( ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

     ‫ﺳوف ﯾطﺑﻊ )‪ (for,while‬اﻟﺟﻣﻠﺔ ﺧﻣس ﻣرات ﻷﻧﮫ ﻋداد ﯾﻌد ﻣن )١( إﻟﻰ )٥( وإذا ﺗﺟﺎوز اﻟرﻗم )٥( ﻻ ﯾﺳﻣﺢ ﻟﮫ‬
                                                          ‫ﺑطﺑﺎﻋﺔ اﻟﺟﻣﻠﺔ ﻣن ﺟدﯾد وﯾﺧرج ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ‬



    ‫ﺳوف ﯾطﺑﻊ )‪ (do--while‬اﻟﺟﻣﻠﺔ ﺧﻣس ﻣرات ﻷﻧﮫ ﻋداد ﯾﻌد ﻣن )١( إﻟﻰ )٥( وإذا ﺗﺟﺎوز اﻟرﻗم )٥( ﻻ ﯾﺳﻣﺢ ﻟﮫ‬
                                                          ‫ﺑطﺑﺎﻋﺔ اﻟﺟﻣﻠﺔ ﻣن ﺟدﯾد وﯾﺧرج ﻣن اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ‬

                                                                       ‫وﺗﻛون ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﺑﺎﻟﻧﺳﺑﺔ ﻟﻠﺟﻣﯾﻊ ھﻛذا‬



                                                          ‫وأي رﻗم ﻣن واﺣد ﻓﻣﺎ ﻓوق ﺗﻌطﻲ اﻟﺟﻣﯾﻊ ﻧﻔس اﻟﻧﺗﺎﺋﺞ‬
                                                                                                         ‫ﻣﮭم‬

                                                                      ‫١.إذا أدﺧﻠﻧﺎ اﻟرﻗم )0( ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

            ‫ﺳوف ﻻ ﯾطﺑﻊ )‪ (for,while‬ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ وﻻ ﻣرة ﻷﻧﮫ ﻋﻧدﻣﺎ ﯾﺗﺣﻘق ﻣن اﻟﺷرط ﻓﻲ ﺧطوة رﻗم )٣(‬
‫وھو )‪ (i<= input_numbe‬وھو ھﻛذا)‪ (1<=0=false‬ﺳوف ﻻ ﯾﺣﻘق اﻟﺷرط اﻟﻌﺑﺎرة اﻟﺷرطﯾﺔ ﻟذاﻟك ﺳوف ﻻ ﯾﻧﻔذ‬
                                             ‫اﻟﺟﻣﻠﺔ اﻟﺗﺎﺑﻌﺔ ﻟﻌﺑﺎرة اﻟﺗﻛرار .وﻻ ﯾطﺑﻊ ﺟﻣﻠﺔ اﻟطﺑﺎﻋﺔ اﻟﺗﺎﺑﻌﺔ ﻟﮭﺎ‬

                                                                                     ‫وﺗﻛون ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھﻛذا‬




‫ﺳوف ﯾطﺑﻊ )‪ (do--while‬اﻟﺟﻣﻠﺔ ﻣرة واﺣدة ﻷﻧﮫ أوﻻ ﯾﻧﻔذ اﻟﺧطوات)٣و٤و٥( ﺑﻌد ﺧطوة ﺧﺎﻣﺳﺔ ﯾﺗﺣﻘق ﻣن اﻟﺷرط‬
       ‫وﯾﺟد اﻧﮫ اﻟﺷرط ﻻ ﯾﺗﺣﻘق وﻻ ﯾﻌﯾد ﻋﺑﺎرة اﻟﺗﻛرار.وﻷﻛﻧﮫ طﺑﻊ اﻟﺟﻣﻠﺔ ﻓﻲ ﺧطوة )٤( ﻗﺑل اﻟﺗﺣﻘق ﻣن اﻟﺷرط‬

                                                                                     ‫وﺗﻛون ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھﻛذا‬




                                     ‫وھذا ﻣﻌﻧﻰ ﻗوﻟﻧﺎ )ﺗﻧﻔذ )‪ (do-while‬ﻣﺎﺑﯾن ﻗوﺳﯾﮭﺎ ﺛم ﺗﺗﺣﻘق ﻣن اﻟﺷرط(‬




    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                      ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                     ‫اﻟﻤﺼﻔﻮﻓﺎت وأﻧﻮاﻋﮭﺎ‬

                        ‫١.٤- اﻟﻣﺻﻔوﻓﺎت اﻷﺣﺎدﯾﺔ اﻷﺑﻌﺎد :‬
                         ‫٢.٤- ﺗرﺗﯾب ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺎت:‬
                           ‫٣.٤- اﻟﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ اﻷﺑﻌﺎد:‬
                     ‫٤.٤- ﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ اﻷﺑﻌﺎد:‬
                               ‫٥.٤- اﻟﻧﺻوص )‪:(string‬‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                          ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                              ‫١.٤- اﻟﻣﺻﻔوﻓﺎت اﻷﺣﺎدﯾﺔ اﻷﺑﻌﺎد :‬
                 ‫ﻗﺑل أن ﻧﺗﺣدث ﻋن اﻟﻣﺻﻔوﻓﺎت ﻋﻠﻣﻧﺎ أن اﻟﻣﺗﻐﯾرات ﺗﺣﺟز ﻣﻛﺎن ﻓﻲ اﻟذاﻛرة ﺗﺧزن ﻓﯾﮫ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر .‬
                           ‫ﻟو أﺧذﻧﺎ ھذا اﻟﺟزء ﻣن اﻟذاﻛرة واﻓﺗرﺿﻧﺎ ان اﻟﻣﺗﻐﯾر )51=‪ (x‬ﻣﺧزن ﻓﻲ اﻟﻣوﻗﻊ )62181(.‬
                                                                     ‫ﻣﻮاﻗﻊ ﺧﻼﯾﺎ اﻟﺬاﻛﺮة‬
                                                                  ‫اﻟﻣوﻗﻊ‬        ‫ﻣﺤﺘﻮاه‬
                                                                  ‫52181‬         ‫‪data‬‬
                  ‫ھذا ھو ﻣوﻗﻊ اﻟﻣﺗﻐﯾر ‪x‬‬                                                                    ‫ﻣﮭم‬
                                                                  ‫62181‬         ‫51‬
                                                                  ‫72181‬         ‫‪data‬‬
                                      ‫ﻛﻣﺎ ﺗﻼﺣظ ﻣن اﻟرﺳم أن اﻟﻣﺗﻐﯾر )‪ (x‬ﺣﺎﺟز ﻣﻛﺎن ﻓﻲ اﻟذاﻛرة وﺧﺎزن ﻗﯾﻣﺗﮫ ﺑداﺧﻠﺔ.‬
‫ﻓﻣﺎ ھﻲ اﻟﻣﺻﻔوﻓﺎت. ھﻲ ﻣﺟﻣوﻋﺔ ﺧﻼﯾﺎ ﻣﺗﺗﺎﻟﯾﺔ ﻓﻲ اﻟذاﻛرة ﺗﺣﺟز ﻟﻐرض ﺧزن ﻣﻌﻠوﻣﺎت ﻣﻌﯾﻧﺔ ﻓﻲ داﺧﻠﮭﺎ ﻛﺄن ﻧﺧزن‬
‫ﻓﻲ داﺧﻠﮭﺎ أرﻗﺎم أو أﺣرف وﺗﺑﻘﻰ ھذه اﻟﻘﯾم اﻟﻣﺧزﻧﺔ داﺧل اﻟﻣﺻﻔوﻓﺔ ﺣﺗﻰ ﻧﻐﻠق اﻟﺑرﻧﺎﻣﺞ إذا ﻟم ﻧﻐﯾرھﺎ داﺧل اﻟﺑرﻧﺎﻣﺞ .‬
      ‫ﻓﻲ ﻣﺻﻔوﻓﺎت ﯾﺟب اﻹﻋﻼن ﻋن ﻋدد اﻟﻣواﻗﻊ اﻟﺗﻲ ﻧﺣﺗﺎﺟﮭﺎ ﻓﻲ اﻟﻌﻣل ﻓﻲ ﺑداﯾﺔ اﻟﺑرﻧﺎﻣﺞ ﺣﺗﻰ ﯾﺣﺟزھﺎ اﻟﻣﺗرﺟم‬
     ‫ﻟﻠﻣﺻﻔوﻓﺔ وﻻ ﯾﺧزن ﻗﯾم أﺧرى ﻓﻲ داﺧﻠﮭﺎ و ﺗﺑﻘﻰ ﻣﺣﺟوزة ﻓﻘط ﻟﻌﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ. وﯾﻛون اﻹﻋﻼن ﻋﻠﯾﮭﺎ ھﻛذا‬
                                                                                                   ‫ھﯾﻛﻠﯾﺔ‬
          ‫]‪Type arrrayname[size of array‬‬

      ‫‪ (arrrayname) ‬ھو اﺳم اﻟﻣﺻﻔوﻓﺔ اﻟذي ﺳﻧﺗﻌﺎﻣل ﻣﻌﮫ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ أي اﺳم ﻣﻣﻛن أن ﻧﺳﻣﻲ اﻟﻣﺻﻔوﻓﺔ‬
          ‫‪ (size of array) ‬ھو ﺣﺟم اﻟذي ﺳﺗﺷﻐﻠﮫ اﻟﻣﺻﻔوﻓﺔ ﻓﻲ اﻟذاﻛرة وﻗد ﯾﻛون أي رﻗم ﺣﺳب اﺣﺗﯾﺎﺟك‬
       ‫‪ (Type) ‬ھو ﻧوع اﻟﻣﺻﻔوﻓﺔ اﻟﺗﻲ ﺳوف ﻧﻌرﻓﮭﺎ ﻗد ﺗﻛون ﺣرﻓﯾﺔ أو رﻗﻣﯾﺔ .ﻟو ﻋرﻓﻧﺎ ﻣﺻﻔوﻓﺔ ﻣن ﻧوع‬
                      ‫)‪ (integer‬ﺟﻣﯾﻊ ﻋﻧﺎﺻرھﺎ ﺗﻛون )‪ (integer‬وﻻ ﯾﺟوز ﺗﺧزﯾن أﺣرف ﻓﻲ داﺧﻠﮭﺎ‬

                             ‫ﻣﺛﺎل: ﺗﻌرﯾف ﻣﺻﻔوﻓﺔ ﻣن ﻧوع )‪ (integer‬ﺣﺟﻣﮭﺎ ﺧﻣﺳﺔ واﺳﻣﮭﺎ )‪.(first_array‬‬

                                                                                                   ‫ھﯾﻛﻠﯾﺔ‬
          ‫‪int‬‬   ‫;]5[ ‪first_array‬‬

                     ‫ﻟﻧﻔرض أن ﺣﺟز أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﺑدء ﺑﻣوﻗﻊ )62181( وﯾﻛون ﺷﻛل ﻣواﻗﻊ اﻟذاﻛرة ھﻛذا‬

                                                               ‫ﻣﻮاﻗﻊ ﺧﻼﯾﺎ اﻟﺬاﻛﺮة‬
                                                ‫ﻣواﻗﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬      ‫اﻟﻣوﻗﻊ‬         ‫ﻣﺤﺘﻮاه‬
                                                                          ‫52181‬          ‫‪data‬‬
                                                    ‫]0[ ‪first_array‬‬       ‫62181‬
‫ھذه اﻟﻣواﻗﻊ ﻣﺣﺟوزة‬                                  ‫]1[ ‪first_array‬‬       ‫72181‬
        ‫ﻟﻠﻣﺻﻔوﻓﺔ‬                                    ‫]2[ ‪first_array‬‬       ‫82181‬
     ‫‪first_array‬‬                                    ‫]3[ ‪first_array‬‬       ‫92181‬
‫وﺑذاﻟك ﻻ ﺗﺳﺗطﯾﻊ اي‬                                  ‫]4[ ‪first_array‬‬       ‫03181‬
     ‫ﻣﺗﻐﯾرات اﺧرى‬                                                         ‫13181‬          ‫‪data‬‬
         ‫اﺳﺗﺧداﻣﮭﺎ‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                          ‫اﻟﻔﺻل اﻟراﺑﻊ‬
                                                                                                              ‫ﻣﮭم‬


 ‫ﻟو ﺗﻼﺣظ أن أول ﻋﻧﺻر ﻟﻠﻣﺻﻔوﻓﺔ وھو )]0[ ‪ (first_array‬ﯾﺣﺟز اﻟﻣوﻗﻊ )62181( وﺗﺧزن ﻓﯾﮫ ﻗﯾﻣﺔ أول ﻋﻧﺻر‬
                    ‫وﯾﻠﯾﮫ ﺑﻘﯾﺔ اﻟﻌﻧﺎﺻر ﺑﺎﻟﺗﺗﺎﻟﻲ أي )]1[ ‪ (first_array‬ﯾﺣﺟز اﻟﻣوﻗﻊ )72181( وﺑﺎﻟﺗﺗﺎﻟﻲ....؟‬

          ‫‪ ‬ﻋﻧوﻧﺔ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺗﺑدأ ﻣن اﻟﺻﻔر ﻛﻣﺎ ﺗﻼﺣظ أول ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ ھو )]0[ ‪(first_array‬‬

                                                                                                ‫ھﯾﻛﻠﯾﺔ‬
        ‫]‪first_array [index‬‬
           ‫)‪ (index‬ھو ﻋﻧوان اﻟﻣوﻗﻊ اﻟذي ﻧرﯾد أن ﻧﺻل إﻟﻰ ﻣﺣﺗوﯾﺎﺗﮫ ﻓﻲ داﺧل اﻟﻣﺻﻔوﻓﺔ ﻟﻧﻌدل ﻋﻠﯾﮭﺎ أو ﻧطﺑﻌﮭﺎ.‬

                                              ‫‪ ‬ﻣﺛﻼ أردﻧﺎ وﺿﻊ )97( ﺑﺛﺎﻟث ﻣوﻗﻊ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻧﻛﺗب ھﻛذا‬

                                                                                                   ‫ﻛود‬
        ‫;97=]2[ ‪first_array‬‬
  ‫ﻟو ﺗﻼﺣظ أن )2=‪ (index‬وﻟﯾس )٣( ﻷﻧﮫ ﻛﻣﺎ ﻗﻠﻧﺎ ﺗﺳﻠﺳل ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﯾﺑدأ ﻣن اﻟﺻﻔر وﻟﯾس ﻣن اﻟواﺣد أي‬
                   ‫ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ ﺧﻣﺳﺔ ﻋﻧﺎﺻر ﻓﺗﺳﻠﺳل )‪ (index‬ﯾﻛون ﻣن اﻟﺻﻔر إﻟﻰ اﻷرﺑﻌﺔ.‬
                     ‫ﻟذاﻟك ﺑﻌد أن وﺿﻌﻧﺎ رﻗم )97( ﺑﺎﻟﻣوﻗﻊ اﻟﺛﺎﻟث ﯾﺻﺑﺢ ﺷﻛل اﻟﻣﺻﻔوﻓﺔ ﻓﻲ ﻣواﻗﻊ اﻟذاﻛرة ھﻛذا‬

                                                       ‫ﻣﻮاﻗﻊ ﺧﻼﯾﺎ اﻟﺬاﻛﺮة‬
                                        ‫ﻣواﻗﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬      ‫اﻟﻣوﻗﻊ‬          ‫ﻣﺤﺘﻮاه‬          ‫ﻣﺣﺗوﯾﺎت‬
                                                                  ‫52181‬           ‫‪data‬‬             ‫اﻟﻣوﻗﻊ‬
                                                                                                    ‫اﻟﺛﺎﻟث‬
                                            ‫]0[ ‪first_array‬‬       ‫62181‬
       ‫ھذه اﻟﻣواﻗﻊ ﻣﺣﺟوزة‬                   ‫]1[ ‪first_array‬‬       ‫72181‬
               ‫ﻟﻠﻣﺻﻔوﻓﺔ‬                     ‫]2[ ‪first_array‬‬       ‫82181‬           ‫97‬
            ‫‪first_array‬‬                     ‫]3[ ‪first_array‬‬       ‫92181‬
                                            ‫]4[ ‪first_array‬‬       ‫03181‬
                                                                  ‫13181‬           ‫‪data‬‬


                                    ‫‪ ‬ﻟو أردﻧﺎ إدﺧﺎل ﻗﯾﻣﺔ )٠٩( ﻓﻲ اﻟﻣوﻗﻊ اﻟراﺑﻊ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻓﯾﻛون اﻟﻛود‬

                                                                                                   ‫ﻛود‬
        ‫;09=]3[ ‪first_array‬‬
                                                                  ‫‪ ‬ﻟو أردﻧﺎ طﺑﺎﻋﺔ ﻣﺣﺗوﯾﺎت اﻟﻣوﻗﻊ اﻟﺛﺎﻟث‬
          ‫++‪C‬‬                             ‫اﻟﻛود ﺑﻠﻐﺔ‬      ‫‪C‬‬                                    ‫اﻟﻛود ﺑﻠﻐﺔ‬
          ‫;]2[ ‪cout<< first_array‬‬                      ‫;)]2[ ‪Printf("%d", first_array‬‬
     ‫ﻟو أردﻧﺎ ﺗﻌرﯾف ﻣﺻﻔوﻓﺔ ﻣن ﻧوع ‪ float‬ﻧﻔس طرﯾﻘﺔ ﻣﺻﻔوﻓﺔ اﻟﺳﺎﺑﻘﺔ وﻛذاﻟك ﺑﻘﯾﺔ اﻷﻧواع ﺗﻌرف ﺑﻧﻔس اﻟطرﯾﻘﺔ‬

                                                                                                ‫ھﯾﻛﻠﯾﺔ‬
        ‫‪float‬‬   ‫;]5[ ‪first_array‬‬



  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                               ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                        ‫ﻧﺳﺗطﯾﻊ أﻋطﺎء ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻗﯾم ﻣﻌﯾﻧﺔ ﻛﻘﯾم أوﻟﯾﺔ وﻗت اﻟﺗﻌرﯾف ﻋن اﻟﻣﺻﻔوﻓﺔ ھﻛذا‬

                                                                                                          ‫ﻛود‬
        ‫‪int‬‬   ‫;}45,32,34,62,43{=]5[ ‪first_array‬‬
                                           ‫ﻓﯾﻛون ﺷﻛل اﻟﻣﺻﻔوﻓﺔ ﻓﻲ ﻣﻘطﻊ اﻟذاﻛرة وھﻲ ﻣﺧزن ﻓﯾﮭﺎ اﻟﻌﻧﺎﺻر ھﻛذا‬

                                                         ‫ﻣﻮاﻗﻊ ﺧﻼﯾﺎ اﻟﺬاﻛﺮة‬
                                          ‫ﻣواﻗﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬      ‫اﻟﻣوﻗﻊ‬            ‫ﻣﺤﺘﻮاه‬
                                                                    ‫52181‬             ‫‪data‬‬
                                              ‫]0[ ‪first_array‬‬       ‫62181‬             ‫43‬
          ‫ھذه اﻟﻣواﻗﻊ ﻣﺣﺟوزة‬                  ‫]1[ ‪first_array‬‬       ‫72181‬             ‫62‬
      ‫ﻟﻠﻣﺻﻔوﻓﺔ ‪first_array‬‬                    ‫]2[ ‪first_array‬‬       ‫82181‬             ‫34‬
                 ‫وﻣﺣﺗوﯾﺎﺗﮭﺎ‬                   ‫]3[ ‪first_array‬‬       ‫92181‬             ‫32‬
                                              ‫]4[ ‪first_array‬‬       ‫03181‬             ‫45‬
                                                                    ‫13181‬             ‫‪data‬‬

   ‫إي أن اﻟﻌﻧﺻر اﻷول ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﺗﻛون ﻗﯾﻣﺗﮫ )43=]0[ ‪ (first_array‬وﺑﻘﯾﺔ اﻟﻣواﻗﻊ ﺑﺎﻟﺗﺳﻠﺳل ﻛﻣﺎ ﻓﻲ اﻟﺷﻛل .‬



                       ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻧدﺧل ﻣﺻﻔوﻓﺔ أﺣﺎدﯾﺔ اﻷﺑﻌﺎد ﻣﻛوﻧﺔ ﻣن ﺳﺗﺔ ﻋﻧﺎﺻر ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وﻧطﺑﻌﮭﺎ.؟‬

 ‫++‪c‬‬                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                     ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                   ‫)(‪main‬‬
 ‫;]6[‪{ 1.int i,first_arry‬‬                                  ‫;]6[‪{1. int i,first_arry‬‬
 ‫)++‪2.for (i=0;i<6;i‬‬                                      ‫)++‪2.for (i=0;i<6;i‬‬
 ‫; ]‪3.cin>> first_arry[i‬‬                                   ‫; )]‪3.scanf("%d",& first_arry[i‬‬
 ‫;"‪4.cout<<"the Content of array is .\n‬‬                   ‫;)"‪4.prin ("the Content of array is .\n‬‬
 ‫)++‪5.for (i=0;i<6;i‬‬                                      ‫)++‪5.for (i=0;i<6;i‬‬
 ‫};"‪6.cout<< first_arry[i]<<"\t‬‬                           ‫};)]‪6.prin ("%d\t", first_arry[i‬‬
                                                                                                    ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                   ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر ﻟﻠﻌداد وﺗم ﺗﻌرﯾف ﻣﺻﻔوﻓﺔ أرﻗﺎم ﺣﺟﻣﮭﺎ ﺳﺗﺔ‬

     ‫٢.ﺧطوة رﻗم )٢( ھوا ﻋداد ﯾﻌد ﻣن ﺻﻔر إﻟﻰ ﺧﻣﺳﺔ وﻛل ﻋدة ﯾﺗم طﻠب ﻓﻲ ﺧطوة )٣( إدﺧﺎل ﻋﻧﺻر ﺟدﯾد ﻣن‬
    ‫اﻟﻣﺻﻔوﻓﺔ ﻛﻣﺎ ھوا ﻣﺑﯾن ﻓﻲ اﻟﺷﻛل ، ﻋﻧدﻣﺎ ﯾﻛون )0=‪ (i‬ﻓﺎن )]‪ (first_arry[i‬ﻣﻌﻧﺎه )]0[‪ (first_arry‬أي ﯾطﻠب ﻣن‬
       ‫اﻟﻣﺳﺗﺧدم إدﺧﺎل اﻟﻌﻧﺻر اﻷول وﯾﺳﺗﻣر ﺑطﻠب اﻹدﺧﺎل إﻟﻰ أﺧر ﻋﻧﺻر وھو )5=‪) (i‬ﻛﻣﺎ ھو ﺑﺎﻟﺷﻛل ﺑﺎﻷﺳﻔل(‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                     ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                    ‫اﻟﻔﺻل اﻟراﺑﻊ‬




‫٣.ﺧطوة رﻗم )٣( ھﻧﺎك طرﯾﻘﺗﯾن ﻟﻠﻘراءة أﻣﺎ ﺿﻐط ﻣﻔﺗﺎح )‪ (enter‬وإدﺧﺎل ﻋﻧﺻر ﺟدﯾد ﻣن ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ أو‬
     ‫ﺿﻐط اﻟﻣﺳطرة وإدﺧﺎل ﻋﻧﺻر ﺟدﯾد . ﺧطوة رﻗم )٤( ھﻲ رﺳﺎﻟﺔ ﺗﻘول اﻧﮫ ﺳوف ﯾﺗم طﺑﺎﻋﺔ ﻣﺣﺗوﯾﺎت اﻟﻣﺻﻔوﻓﺔ‬

   ‫٥.ﺧطوة رﻗم )٦( ﻋداد ﯾﻌد ﻣن ﺻﻔر إﻟﻰ اﻟﺧﻣﺳﺔ ﻟﯾطﺑﻊ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻓﻲ اﻟﺧطوة رﻗم )٦(. أي ﻋﻧدﻣﺎ‬
    ‫ﯾﻌد اﻟﻌداد رﻗم ﺻﻔر ﺳﺗﻧﻔذ ﺧطوة رﻗم )٦( طﺎﺑﻌﺔ )]0[‪ (first_arry‬ﺗم ﻋﻧدﻣﺎ ﯾﻌد اﻟﻌداد رﻗم واﺣد ﺳﺗﻧﻔذ ﺧطوة رﻗم‬
     ‫)٦( طﺎﺑﻌﺔ )]1[‪ (first_arry‬ﺗم ﻋﻧدﻣﺎ ﯾﻌد اﻟﻌداد رﻗم اﺛﻧﺎن ﺳﺗﻧﻔذ ﺧطوة رﻗم )٦( طﺎﺑﻌﺔ )]2[‪ (first_arry‬وﯾﺳﺗﻣر‬
                               ‫ﺑطﺑﺎﻋﺔ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻣن ﻣﺣﺗوﯾﺎت أول ﻣوﻗﻊ إﻟﻰ ﻣﺣﺗوﯾﺎت أﺧر ﻣوﻗﻊ .‬

                                                                                               ‫وﺗﻛون ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھﻛذا‬




                                                                                                                       ‫ﻣﮭم‬


          ‫ﻟو ﻏﯾرﻧﺎ ﻋداد ﺧطوة رﻗم)٥( وﺟﻌﻠﻧﺎه ﯾﺗﻧﺎﻗص ﻣن ﺧﻣﺳﺔ إﻟﻰ اﻟﺻﻔر ﺳوف ﯾطﺑﻊ أوﻻ )]5[‪ (first_arry‬ﺛم‬
                  ‫)]4[‪ (first_arry‬وﯾﺳﺗﻣر إﻟﻰ اﻟﺻﻔر طﺎﺑﻌﺎ اﻟﻣﺻﻔوﻓﺔ ﺑﺎﻟﻣﻘﻠوب )ﻣن أﺧر ﻋﻧﺻر إﻟﻰ أول ﻋﻧﺻر(‬

                                                                                    ‫أي ﯾﺻﺑﺢ ﻋداد ﺧطوة رﻗم )٥( ھﻛذا‬

                                                                                                                ‫ﻛود‬
        ‫)--‪5.for (i=5;i>=0;i‬‬



                                                                                 ‫ﺳﺗﻛون ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﺑﻌد اﻹدﺧﺎل ھﻛذا‬




                                                                                                                        ‫ﻣﮭم‬



   ‫أﺑدال ﺑﯾن ﻗﯾم ﻣوﻗﻌﯾن: ﻹﺑدال ﺑﯾن ﻗﯾﻣﺔ ﻣوﻗﻌﯾن ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻧﺣﺗﺎج إﻟﻰ ﻣﺗﻐﯾر ﺛﺎﻟث ﻣن ﻧﻔس ﻧوع اﻟﻣﺻﻔوﻓﺔ ﺣﺗﻰ‬
   ‫ﻧﺧزن ﺑﮫ ﻧﺗﯾﺟﺔ اﺣد اﻟﻣوﻗﻌﯾن ﺛم ﻧﺑدل ﻻن ﻓﻲ ﺣﺎل ﻋدم وﺟود ﻣﺗﻐﯾر ﺛﺎﻟث ﻻ ﻧﺳﺗطﯾﻊ اﻹﺑدال وﺳﺗﺿﯾﻊ اﺣد اﻟﻘﯾﻣﺗﯾن‬
                                                                                                ‫ِ‬


                                            ‫ﻛود اﻹﺑدال ﺑﯾن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )]5[‪ ( first_arry‬واﻟﻣﺗﻐﯾر )]2[‪( first_arry‬‬
            ‫ھوا اﻟﻣﺗﻐﯾر اﻟﻣؤﻗت اﻟذي ﺳﻧﺧزن ﺑﮫ اﺣد ﻗﯾم اﻟﻣوﻗﻌﯾن// ;‪int item‬‬
           ‫;]5[‪Item= first_arry‬‬
           ‫;]2[‪first_arry[5]= first_arry‬‬
           ‫;‪first_arry[2]=item‬‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                 ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                    ‫ﻣﺛﺎل:ﺑرﻧﺎﻣﺞ ﻧدﺧل ﻣﺻﻔوﻓﺔ أﺣﺎدﯾﺔ اﻷﺑﻌﺎد ﻣﻛوﻧﺔ ﻣن ﺧﻣﺳﺔ ﻋﻧﺎﺻر وﻧﺟﻣﻌﮭﺎ .؟‬

      ‫ﺗﺣﻠﯾل :ﺧطوات اﻹدﺧﺎل ھﻲ اﻋﺗﯾﺎدﯾﺔ وﺗﻘرﯾﺑﺎ ﺛﺎﺑﺗﺔ ﻓﻲ اﻟﻣﺻﻔوﻓﺎت ﻓﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ ﺧﻣﺳﺔ ﻧﺣﺗﺎج ﻋداد ﯾﻌد ﻣن‬
                                  ‫اﻟﺻﻔر إﻟﻰ اﻷرﺑﻌﺔ ﺛم ﺑﻌد اﻹدﺧﺎل ﻧﺟﻣﻊ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻣﻊ ﺑﻌﺿﮭﺎ‬

 ‫++‪c‬‬                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                      ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                    ‫)(‪main‬‬
 ‫;0=‪{ 1.int i,array1[5],sum‬‬                                ‫;0=‪{ 1.int i,array1[5],sum‬‬
 ‫)++‪2.for (i=0;i<5;i‬‬                                       ‫)++‪2.for (i=0;i<5;i‬‬
 ‫; ]‪3.cin>> array1[i‬‬                                       ‫;) ]‪3.scanf("%d",& array1[i‬‬
 ‫)++‪4.for (i=0;i<5;i‬‬                                       ‫)++‪4.for (i=0;i<5;i‬‬
 ‫;]‪5.sum=sum+array1[i‬‬                                      ‫;]‪5.sum=sum+array1[i‬‬
 ‫};‪6.cout<< "sum of array item="<<sum‬‬                      ‫};)‪6.prin ( "sum of array item=%d",sum‬‬



                                                                                                    ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

   ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر ﻟﻠﻌداد وﺗم ﺗﻌرﯾف ﻣﺻﻔوﻓﺔ أرﻗﺎم ﺣﺟﻣﮭﺎ ﺧﻣﺳﺔ وﻣﺗﻐﯾر ﻟﻠﺟﻣﻊ وأﻋطﯾﻧﺎه ﺻﻔر‬
                                                ‫ﻛﻘﯾﻣﺔ اﺑﺗداﺋﯾﺔ ﻛﻣﺎ ﻗﻠﻧﺎ ﺳﺎﺑﻘﺎ ﯾﺟب ﺗﺻﻔﯾر اﻟﻣﺗﻐﯾر اﻟﺟﻣﻊ ﻗﺑل اﻟﺟﻣﻊ‬
     ‫٢.ﺧطوة رﻗم)٢ و٣( إدﺧﺎل اﻟﻣﺻﻔوﻓﺔ ﻛﻣﺎ ﺗﻼﺣظ اﻟﻌداد ﯾﻌد ﻣن اﻟﺻﻔر إﻟﻰ اﻷرﺑﻌﺔ ﻻن ﺣﺟم اﻟﻣﺻﻔوﻓﺔ ﺧﻣﺳﺔ‬
    ‫٣.ﺧطوة رﻗم )٤( ﻋداد ﯾﻣر ﻋﻠﻰ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻋﻧﺻر ﻋﻧﺻر ﻟﻛﻲ ﯾﺟﻣﻌﮭﺎ ﻣﻊ ﺑﻌﺿﮭﺎ أي ﻋﻧدﻣﺎ ﯾﻛون ﻗﯾﻣﺔ‬
           ‫اﻟﻌداد ھﻲ )0=‪ (i‬ﺳﯾﺟﻣﻊ )]0[1‪ (sum=sum+array‬وﯾﺳﺗﻣر ﺑﺎﻟﺟﻣﻊ ﻣﻊ اﻟﻘﯾم اﻟﺳﺎﺑﻘﺔ ﻛﻣﺎ ھﻲ ھذا اﻟﺷﻛل‬
                                     ‫ھذا اﻟﺷﻛل ھو ﺗﺗﺑﻊ ﻟﻠﻌﻣﻠﯾﺎت اﻟﺗﻲ ﺗﺣدث ﻓﻲ ﺧطوة رﻗم )٤( وﺧطوة رﻗم )٥(‬
                     ‫ﺗوﺿﯾﺢ ﻋﻣﻠﯾﺔ ﺟﻣﻊ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ إذا ﻓرﺿﻧﺎ ﻋﻧﺎﺻر اﻟﻣدﺧﻠﺔ ھﻲ )54,65,32,34,11( ﻛﻣﺎ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
        ‫0=‪When i‬‬
        ‫;]0[1‪sum=sum+array‬‬      ‫11=‪ sum=0+11 sum‬‬
        ‫1=‪When i‬‬
        ‫;]1[1‪sum=sum+array‬‬      ‫45=‪ sum=11+43 sum‬‬
        ‫2=‪When i‬‬
        ‫;]2[1‪sum=sum+array‬‬      ‫77=‪ sum=54+23 sum‬‬
        ‫3=‪When i‬‬
        ‫;]3[1‪sum=sum+array‬‬      ‫331=‪ sum=77+56 sum‬‬
        ‫4=‪When i‬‬
        ‫;]4[1‪sum=sum+array‬‬      ‫871 =‪ sum=133+45 sum‬‬

                                                  ‫ﻟو ﺗﻼﺣظ ﻛﯾف ﯾﺟﻣﻊ ﻧﺗﺎﺋﺞ اﻟﺟﻣﻊ اﻟﺳﺎﺑﻘﺔ ﻣﻊ اﻟﻌﻧﺎﺻر اﻟﺟدﯾدة.....!‬
                                                                                ‫٤.ﺧطوة رﻗم )٦( ﯾطﺑﻊ ﻧﺗﯾﺟﺔ اﻟﺟﻣﻊ‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                      ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                ‫ﻣﺛﺎل:ﺑرﻧﺎﻣﺞ ﻧدﺧل ﻣﺻﻔوﻓﺔ أﺣﺎدﯾﺔ اﻷﺑﻌﺎد ﻣﻛوﻧﺔ ﻣن ﺳﺑﻌﺔ ﻋﻧﺎﺻر ﺟد اﻛﺑر رﻗم.؟‬

‫ﺗﺣﻠﯾل :ﺧطوات اﻹدﺧﺎل ھﻲ اﻋﺗﯾﺎدﯾﺔ وﺗﻘرﯾﺑﺎ ﺛﺎﺑﺗﺔ ﻓﻲ اﻟﻣﺻﻔوﻓﺎت ﻓﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ ﺳﺑﻌﺔ ﻧﺣﺗﺎج ﻋداد ﯾﻌد ﻣن اﻟﺻﻔر‬
   ‫إﻟﻰ ﺳﺗﺔ. ﺛم ﺑﻌد اﻹدﺧﺎل ﻧﺟد اﻛﺑر رﻗم ﺑﯾن ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻛﯾف.؟ ﻧﺳﻧد ﻗﯾﻣﺔ أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻟﻣﺗﻐﯾر‬
‫وﺛم ﻧﻘﺎرن ﻗﯾﻣﺔ ھذا اﻟﻣﺗﻐﯾر ﻣﻊ ﺑﻘﯾﺔ اﻟﻌﻧﺎﺻر أي ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻧﺟد أن ﻗﯾﻣﺗﮫ اﻛﺑر ﻣن ﻗﯾﻣﺔ ﻣﺗﻐﯾرﻧﺎ ﻧﺑدل ﻗﯾﻣﺔ‬
 ‫ﻣﺗﻐﯾرﻧﺎ ﺑﻘﯾﻣﺔ ﻋﻧﺻر اﻟﻣﺻﻔوﻓﺔ وﻧﺳﺗﻣر ﺣﺗﻰ اﻟﻧﮭﺎﯾﺔ وﻛل ﻣﺎ وﺟد ﻣﺗﻐﯾرﻧﺎ ﻗﯾﻣﺔ أﻋﻠﻰ ﻣﻧﮫ أﺧذھﺎ وإذا اﻗل ﻣﻧﮫ ﻻﺗﮭﻣﮫ‬
                                                         ‫وﯾﺳﺗﻣر إﻟﻰ اﻟﻧﮭﺎﯾﺔ وﯾﻛون ﻓﻲ اﻟﺗﺎﻟﻲ ﺣﺎﻣﻼ أﻋﻠﻰ ﻗﯾﻣﺔ.‬

 ‫++‪c‬‬                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬      ‫‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                   ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                 ‫)(‪main‬‬
 ‫;‪{ 1.int i,array1[7],max‬‬                               ‫;‪{ 1.int i,array1[7],max‬‬
 ‫)++‪2.for (i=0;i<7;i‬‬                                    ‫)++‪2.for (i=0;i<7;i‬‬
 ‫; ]‪3.cin>> array1[i‬‬                                    ‫; )]‪3.scanf("%d",& array1[i‬‬
 ‫;]0[1‪4.max=array‬‬                                       ‫;]0[1‪4.max=array‬‬
 ‫)++‪5.for (i=0;i<7;i‬‬                                    ‫)++‪5.for (i=0;i<7;i‬‬
 ‫) ‪6.if (array1[i] > max‬‬                                ‫) ‪6.if (array1[i] > max‬‬
 ‫;]‪7.max=array1[i‬‬                                       ‫;]‪7.max=array1[i‬‬
 ‫};‪8.cout<< "max number in array1 is="<<max‬‬             ‫};)‪8.prin ( "max number in array1 is=%d",max‬‬
                                                             ‫وھذا ﺗوﺿﯾﺢ ﻟﻣﺎ ﺳﯾﺣﺻل ﻓﻲ ﺧطوات رﻗم )٥ و٦و٧(‬

                                              ‫ﺟﻌﻠت اﻟﺧطوات اﻟﺗﻲ ﺗﻧﻔذ ذو ﻟون ﻋﻣﯾق واﻟﺗﻲ ﻻ ﺗﻧﻔذ ذات ﻟون رﻓﯾﻊ‬

                        ‫ﺗوﺿﯾﺢ ) ٥ و٦و٧( إذا ﻓرﺿﻧﺎ اﻟﻌﻧﺎﺻر اﻟﻣدﺧﻠﺔ ھﻲ )32,13,34,23,22,23,11( ﻛﻣﺎ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
        ‫11=‪4. max=array1[0];  max‬‬
        ‫0=‪5.When i‬‬
        ‫ھذه اﻟﺧطوة ﻻ ﺗﺣﻘق اﻟﺷرط ﻻن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )11=‪ ( max‬ﻟﯾﺳت اﺻﻐر ﻣن ) 11=]0[1‪6. ( array‬‬
        ‫ﻻ ﺗﻧﻔذ ھذه اﻟﺧطوة إذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط ﻓﻲ ﺧطوة )٦( .7‬
        ‫1=‪5.When i‬‬
        ‫ھذه اﻟﺧطوة ﺗﺣﻘق اﻟﺷرط ﻻن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )11=‪ ( max‬اﺻﻐر ﻣن ) 23=]1[1‪6. ( array‬‬
        ‫اﺧذ اﻟﻣﺗﻐﯾر ﻗﯾﻣﺔ ﺟدﯾدة اﻛﺑر ﻣﻧﮫ ﻟﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ ٢٣// 23=‪7.max =array1[1]  max‬‬
        ‫2=‪5.When i‬‬
        ‫ھذه اﻟﺧطوة ﻻ ﺗﺣﻘق اﻟﺷرط ﻻن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )23=‪ ( max‬ﻟﯾﺳت اﺻﻐر ﻣن ) 22=]2[1‪6. ( array‬‬
        ‫ﻻ ﺗﻧﻔذ ھذه اﻟﺧطوة إذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط ﻓﻲ ﺧطوة )٦( .7‬
        ‫3=‪5.When i‬‬
        ‫ھذه اﻟﺧطوة ﻻ ﺗﺣﻘق اﻟﺷرط ﻻن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )23=‪ ( max‬ﻟﯾﺳت اﺻﻐر ﻣن ) 23=]3[1‪6. ( array‬‬
        ‫ﻻ ﺗﻧﻔذ ھذه اﻟﺧطوة إذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط ﻓﻲ ﺧطوة )٦( .7‬
        ‫4=‪5.When i‬‬
        ‫ھذه اﻟﺧطوة ﺗﺣﻘق اﻟﺷرط ﻻن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )23=‪ ( max‬اﺻﻐر ﻣن )34=]4[1‪6. ( array‬‬
        ‫اﺧذ اﻟﻣﺗﻐﯾر ﻗﯾﻣﺔ ﺟدﯾدة اﻛﺑر ﻣﻧﮫ ﻟﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ ٣٤// 34=‪7.max =array1[4]  max‬‬
        ‫5=‪5.When i‬‬
        ‫ھذه اﻟﺧطوة ﻻ ﺗﺣﻘق اﻟﺷرط ﻻن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )34=‪ ( max‬ﻟﯾﺳت اﺻﻐر ﻣن ) 13=]5[1‪6. ( array‬‬
        ‫ﻻ ﺗﻧﻔذ ھذه اﻟﺧطوة إذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط ﻓﻲ ﺧطوة )٦( .7‬
        ‫6=‪5.When i‬‬
        ‫ھذه اﻟﺧطوة ﻻ ﺗﺣﻘق اﻟﺷرط ﻻن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )34=‪ ( max‬ﻟﯾﺳت اﺻﻐر ﻣن ) 32=]6[1‪6. ( array‬‬
        ‫ﻻ ﺗﻧﻔذ ھذه اﻟﺧطوة إذا ﻟم ﯾﺗﺣﻘق اﻟﺷرط ﻓﻲ ﺧطوة )٦( .7‬


  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                     ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                        ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                                             ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

  ‫١.ﺧطوة رﻗم )١( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر ﻟﻠﻌداد وﺗم ﺗﻌرﯾف ﻣﺻﻔوﻓﺔ أرﻗﺎم ﺣﺟﻣﮭﺎ ﺳﺑﻌﺔ وﻣﺗﻐﯾر ﻟﺧزن اﻛﺑر رﻗم وﺧطوة‬
                                                                     ‫رﻗم )٢ و٣ ( ھﻲ إدﺧﺎل ﻟﻠﻣﺻﻔوﻓﺔ‬

 ‫٢.ﺧطوة رﻗم )٤( ﺳﻧدﻧﺎ ﻗﯾﻣﺔ أول ﻣوﻗﻊ إﻟﻰ ﻣﺗﻐﯾر )‪ (max‬ﺣﺗﻰ ﻧﻘﺎرﻧﮫ ﻣﻊ ﺑﻘﯾﺔ اﻟﻣواﻗﻊ ﺣﺗﻰ أي ﻗﯾﻣﺔ ﺗﻛون اﻛﺑر ﻣﻧﮫ‬
                                                   ‫ﻓﻲ اﻟﻣﻘﺎرﻧﺔ ﻧﺑدﻟﮭﺎ ﺑﻘﯾﻣﺔ )‪ (max‬ﺣﺗﻰ ﻧﺣﺻل ﻋﻠﻰ اﻛﺑر ﻗﯾﻣﺔ.‬

    ‫٣.ﺧطوة رﻗم )٥(ﻋداد ﯾﻣر ﻋﻠﻰ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻟﻛﻲ ﻧﻘﺎرن ﻓﻲ ﺧطوة رﻗم )٦( ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺑﻘﯾﻣﺔ‬
  ‫اﻟﻣﺗﻐﯾر وﻣﺗﻰ ﻣﺎ ﻛﺎن اﺣد ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻗﯾﻣﺗﮫ اﻛﺑر ﻧﺑدل ﻗﯾﻣﺔ )‪ (max‬ﻓﻲ ﺧطوة رﻗم )٧( ﺑﺎﻟﻘﯾﻣﺔ اﻷﻛﺑر ﻣﻧﮫ‬

           ‫ﻟو ﺗﻼﺣظ أن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺧﺎﻣس ھﻲ اﻛﺑر ﻗﯾﻣﺔ ﻣن ﺑﯾن اﻟﻘﯾم )ﺷﺎھد اﻟﺗوﺿﯾﺢ وﻛﯾﻔﯾﺔ ﺗﻐﯾر ﻗﯾﻣﺔ )‪(max‬‬

‫]6[1‪Array1[0] Array1[1] Array1[2] Array1[3] Array1[4] Array1[5] Array‬‬                              ‫ﺗﻐﯿﺮ ﻗﯿﻤﺔ‬
                                                                                                   ‫اﻟﻤﺘﻐﯿﺮ‬
‫11‬            ‫23‬              ‫22‬            ‫23‬            ‫34‬           ‫13‬            ‫32‬            ‫)‪ (max‬ﻋﻨﺪ‬
                                                                                                   ‫ﻣﻘﺎرﻧﺘﮫ‬
‫11=‪Max‬‬        ‫23=‪Max‬‬          ‫23=‪Max‬‬        ‫23=‪Max‬‬        ‫34=‪Max‬‬       ‫34=‪Max‬‬        ‫34=‪Max‬‬
                                                                                                               ‫*‬



                                                                               ‫٤.ﺧطوة رﻗم )٨( ﯾطﺑﻊ اﻛﺑر رﻗم‬


                                                                                                               ‫ﻣﮭم‬

                        ‫ﻟو أردﻧﺎ إﯾﺟﺎد اﺻﻐر رﻗم ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻓﻘط ﻧﺑدل اﻟﺷرط ﻓﻲ اﻟﺧطوة رﻗم )٦( إﻟﻰ اﺻﻐر ھﻛذا‬

                                                                                                    ‫ﻛود‬
        ‫) ‪6.if (array1[i] < max‬‬
                     ‫وطرﯾﻘﺔ اﻟﺗﺗﺑﻊ ھﻧﺎ ﻛﻠﻣﺎ ﯾﺟد رﻗم ﻓﻲ اﻟﻣﺻﻔوﻓﺔ اﺻﻐر ﻣن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﯾﺳﻧد اﻟﻣﺗﻐﯾر ﻟﻠﻘﯾﻣﺔ اﻷﺻﻐر‬


                                                                                                               ‫ﻣﮭم‬


                                                         ‫ﻟو أردﻧﺎ ﺿرب ﻛل ﻋﻧﺻر ﻣن ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻓﻲ )٢(‬

                                                                                                    ‫ﻛود‬
        ‫;]‪array1[i]=2* array1[i‬‬
            ‫ﻛﺄﻧﻣﺎ ﻧﻘول ﻗﯾﻣﺔ اﻟﻌﻧﺻر اﻟﺟدﯾد ﺗﺳﺎوي ﻗﯾﻣﺗﮫ اﻟﻘدﯾﻣﺔ ﻣﺿروﺑﺔ ﻓﻲ )٢( وﻧﻣرر اﻟﻌداد ﻋﻠﻰ ﺟﻣﯾﻊ اﻟﻌﻧﺎﺻر‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                         ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                         ‫وﻛذاﻟك ﺑﻘﯾﺔ اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ ﺗﻌﺎﻣل ﻧﻔس اﻟطرﯾﻘﺔ ﻛﺎﻟﻘﺳﻣﺔ. ﻣﺛﻼ ﻧﻘﺳم ﻛل ﻋﻧﺻر ﻋﻠﻰ ٤‬

                                                                                                                    ‫ﻛود‬
        ‫;4/ ]‪array1[i]= array1[i‬‬
‫وﻻ ﺗوﺿﻊ ﻓﻘط ھذه اﻟﺟﻣﻠﺔ وﺣدھﺎ ﯾﺟب وﺿﻊ ﻗﺑﻠﮭﺎ ﻋداد ﯾﻣر ﻋﻠﻰ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻟﻛﻲ ﯾﻘﺳم ﺟﻣﯾﻊ اﻟﻌﻧﺎﺻر‬
                                 ‫ﻋﻧﺻر ﻋﻧﺻر ﻟو ﺗﻼﺣظ ﺧطوة رﻗم )٢( وﺧطوة رﻗم )٣( ﻓﻲ اﻟﻣﺛﺎل اﻟﺗﺎﻟﻲ.‬




                                         ‫ﻣﺛﺎل: ﻣﺻﻔوﻓﺔ ﻣن ﺧﻣﺳﺔ ﻋﻧﺎﺻر إﺿﺎﻓﺔ ﻗﯾﻣﺔ ﺧﻣﺳﺔ ﻟﻛل ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬

 ‫++‪c‬‬                                          ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                        ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                      ‫)(‪main‬‬
 ‫;}12,23,03,51,01{=]5[1‪{ 1.int i,array‬‬                       ‫;}12,23,03,51,01{=]5[1‪{ 1.int i,array‬‬
 ‫)++‪2.for (i=0;i<5;i‬‬                                         ‫)++‪2.for (i=0;i<5;i‬‬
 ‫;5+]‪{3. array1[i]= array1[i‬‬                                 ‫;5+]‪{3. array1[i]= array1[i‬‬
 ‫};"‪4.cout<< array1[i]<<"\t‬‬                                  ‫};) ]‪4.prin ("%d\t", array1[i‬‬
 ‫}‬                                                           ‫}‬



                                                                                                           ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                          ‫١.ﺧطوة رﻗم )٣( ﻧﺿﯾف ﻓﯾﮭﺎ ﻗﯾﻣﺔ ﺧﻣﺳﺔ ﻟﻛل ﻋﻧﺻر ﻣن ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬

                                                             ‫ﻟو ﻛﺎن ﻗﯾﻣﺔ اﻟﻌداد ھﻲ )3=‪ (i‬ﻓﯾﻛون ﺗﻧﻔﯾذ اﻟﺧطوة رﻗم )٣( ھﻛذا‬
        ‫73=]3[1‪array1[3]= array1[3]+5;  array1[3]=32+5  array‬‬



             ‫٢.وﺿﻌﻧﺎ ﺧطوة رﻗم )٤( داﺧل ﻗوس اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ ﺣﺗﻰ ﯾطﺑﻊ ﻣﺑﺎﺷرة ﻗﯾﻣﺔ ﻛل ﻣوﻗﻊ ﺑﻌد اﻹﺿﺎﻓﺔ .‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                         ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                               ‫٢.٤- ﺗرﺗﯾب ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺎت :‬
‫ﺗرﺗﯾب اﻷرﻗﺎم أو اﻷﺣرف ﺗﺻﺎﻋدﯾﺎ أو ﺗﻧﺎزﻟﯾﺎ ﯾﻛون ﺑﻣﻘﺎرﻧﺔ ﻛل ﻋﻧﺻر ﻣن ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻣﻊ اﻟﻌﻧﺎﺻر اﻟذي ﺗﻠﯾﮫ‬
   ‫ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻓﻌﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل إذا أردﻧﺎ ﺗرﺗﯾب اﻟﻌﻧﺎﺻر ﺗﺻﺎﻋدﯾﺎ ﻓﻧﻘﺎرن ﻛل ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﺑﺎﻟﻌﻧﺎﺻر اﻟذي‬
     ‫ﺗﻠﯾﮫ ﻓﺈذا وﺟدﻧﺎ رﻗم اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻌﻧﺻر ﻧﺑدل ﺑﯾن اﻟﻌﻧﺻرﯾﯾن )ﻣﺛﻼ إذا ﻛﺎن 2=]3[‪ (array[0]=50,array‬ﻓﻌﻧد‬
   ‫اﻟﺑدء اﻟﻣﻘﺎرﻧﺔ ﻧﺟد اﻟﻘﯾﻣﺔ ﻓﻲ اﻟﻣوﻗﻊ اﻟراﺑﻊ ﻣن اﻟﻣﺻﻔوﻓﺔ ھو )٢( وﻓﻲ اﻟﻣوﻗﻊ اﻷول ھو )٠٥( وﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟراﺑﻊ‬
    ‫اﻗل ﻟذاﻟك ﺳﻧﺑدل ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟراﺑﻊ ﺑﻘﯾﻣﺔ اﻟﻣوﻗﻊ اﻷول وﻧﻘﺎرن ﺑﻘﯾﺔ اﻟﻣواﻗﻊ ﺑﻘﯾﻣﺔ اﻟﻣوﻗﻊ اﻷول اﻟﺟدﯾدة وھو أﺻﺑﺢ‬
     ‫)٠٥( وﻧﺳﺗﻣر ﺑﺎﻹﺑدال إﻟﻰ أن ﻧﺻل ﻓﻲ اﻟﻣﻘﺎرﻧﺔ إﻟﻰ أﺧر رﻗم ﺑﺎﻟﻣﺻﻔوﻓﺔ ﺛم ﻧﺄﺧذ ﺛﺎﻧﻲ ﻋﻧﺻر ﺑﺎﻟﻣﺻﻔوﻓﺔ وﻧﻘﺎرﻧﮫ‬
     ‫ﺑﺑﻘﯾﺔ اﻟﻌﻧﺎﺻر ﺛم اﻟﺛﺎﻟث إﻟﻰ إن ﻧﺻل إﻟﻰ أﺧر ﻋﻧﺻر ﻧﺟد اﻟﻣﺻﻔوﻓﺔ ﻣرﺗﺑﺔ وﺷﺎھد ھذه ﺧطوات ﺗﻔﺻﯾﻠﯾﺔ ﻟﻠﺗرﺗﯾب‬

  ‫ﻟﻧﻔرض أن ﻟدﯾﻧﺎ ﻣﺻﻔوﻓﺔ ﻣن ﺧﻣﺳﺔ ﻋﻧﺎﺻر وﻧرﯾد ﺗرﺗﯾﺑﮭﺎ ﺗﺻﺎﻋدﯾﺎ وﻛﺎﻧت اﻟﻘﯾم اﻟﻣﺧزﻧﺔ ﺑﺎﻟﻣﺻﻔوﻓﺔ ﻛﻣﺎ ﻓﻲ اﻟﺷﻛل‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬     ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬                                                ‫ﻣﮭم‬
  ‫54‬          ‫24‬           ‫58‬           ‫6‬            ‫46‬
             ‫ﻋﻧد اﻟﺗرﺗﯾب اﻟﺗﺻﺎﻋدي ﻧﺿﻊ اﻟرﻗم اﻻﻗل اﻟﻰ اﻻﻣﺎم واﻻﻋﻠﻰ اﻟﻰ اﻟﺧﻠف ﻓﻲ اﻟﻣﻘﺎرﻧﺔ واﻟﺗﻧﺎزﻟﻲ ﺑﺎﻟﻌﻛس‬

                                                  ‫ﻟﻠﺗرﺗﯾب ﻛﻣﺎ ﻗﻠﻧﺎ ﻧﻘﺎرن ﻛل ﻣوﻗﻊ ﺑﺟﻣﯾﻊ اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﻠﯾﮫ ھﻛذا..؟‬

                                                                  ‫١.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻷول ﺑﺑﻘﯾﺔ اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﻠﯾﮫ:‬

                                                                      ‫١.ﻣﻘﺎرﻧﺔ ﻣن اﻟﻣوﻗﻊ اﻷول ﻣﻊ اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬     ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫54‬           ‫24‬           ‫58‬           ‫6‬             ‫46‬
                                         ‫وﺟدﻧﺎ إن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻷول ﻟذاﻟك ﺳﻧﺑدل ﺑﯾﻧﮭﻣﺎ‬

                                                                            ‫٢.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻷول ﺑﺎﻟﻣوﻗﻊ اﻟﺛﺎﻟث‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬     ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫24‬           ‫54‬           ‫58‬           ‫6‬             ‫46‬
                                       ‫وﺟدﻧﺎ إن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث أﻋﻠﻰ ﻣن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻷول ﻟذاﻟك ﻻ ﻧﺑدل ﺑﯾﻧﮭﺎ‬

                                                                            ‫٣.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻷول ﺑﺎﻟﻣوﻗﻊ اﻟراﺑﻊ‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬     ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫24‬           ‫54‬           ‫58‬           ‫6‬            ‫46‬
                                        ‫وﺟدﻧﺎ أن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟراﺑﻊ اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻷول ﻟذاﻟك ﺳﻧﺑدل ﺑﯾﻧﮭﻣﺎ‬

                                                                         ‫٤.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻷول ﺑﺎﻟﻣوﻗﻊ اﻟﺧﺎﻣس‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬     ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫6‬            ‫54‬           ‫58‬            ‫24‬            ‫46‬
                                    ‫وﺟدﻧﺎ أن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺧﺎﻣس أﻋﻠﻰ ﻣن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻷول ﻟذاﻟك ﻻ ﻧﺑدل ﺑﯾﻧﮭﻣﺎ‬



  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                         ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                ‫٢.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ ﺑﺑﻘﯾﺔ اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﻠﯾﮫ:‬

                                                                    ‫١.ﻣﻘﺎرﻧﺔ ﺑﯾن اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ ﻣﻊ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬    ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫6‬            ‫54‬          ‫58‬           ‫24‬            ‫46‬
                                         ‫وﺟدﻧﺎ أن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث أﻋﻠﻰ ﻣن اﻟﺛﺎﻧﻲ ﻟذاﻟك ﺳوف ﻻ ﯾﺑدل ﺑﯾﻧﮭﻣﺎ.‬

                                                                        ‫٢.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ ﻣﻊ اﻟﻣوﻗﻊ اﻟراﺑﻊ‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬    ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫6‬            ‫54‬          ‫58‬           ‫24‬             ‫46‬
                                              ‫وﺟدﻧﺎ أن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟراﺑﻊ اﻗل ﻣن اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ ﻟذاﻟك ﺳﻧﺑدل ﺑﯾﻧﮭﺎ‬

                                                                         ‫٣.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ ﺑﺎﻟﻣوﻗﻊ اﻟﺧﺎﻣس‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬    ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫6‬            ‫24‬          ‫58‬           ‫54‬          ‫46‬
                             ‫وﺟدﻧﺎ أن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺧﺎﻣس أﻋﻠﻰ ﻣن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ ﻟذاﻟك ﺳوف ﻻ ﯾﺑدل ﺑﯾﻧﮭﻣﺎ‬

                                                                ‫٣.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث ﺑﺑﻘﯾﺔ اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﻠﯾﮫ:‬

                                                                           ‫١.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث ﺑﺎﻟﻣوﻗﻊ اﻟراﺑﻊ‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬    ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫6‬            ‫24‬          ‫58‬           ‫54‬            ‫46‬
                                          ‫وﺟدﻧﺎ ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟراﺑﻊ اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث ﻟذاﻟك ﺳﻧﺑدل ﺑﯾﻧﮭﻣﺎ‬

                                                                         ‫٢.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث ﺑﺎﻟﻣوﻗﻊ اﻟﺧﺎﻣس‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬    ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫6‬            ‫24‬          ‫54‬           ‫58‬             ‫46‬
                                    ‫ﻟذاﻟك ﺳﻧﺑدل ﺑﯾﻧﮭﻣﺎ‬      ‫وﺟﻧﺎ ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺧﺎﻣس اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟراﺑﻊ‬

      ‫٣.ﻣﻘﺎرﻧﺔ اﻟﻣوﻗﻊ اﻟراﺑﻊ ﺑﺑﻘﯾﺔ اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﻠﯾﮫ: ﯾﻘﺎرن ﻓﻘط ﺑﺎﻟﻣوﻗﻊ اﻟﺧﺎﻣس ﻷﻧﮫ أﺧر ﻣوﻗﻊ وﺳﻧﺟد أن ﻗﯾﻣﺔ‬
                                            ‫اﻟﻣوﻗﻊ اﻟﺧﺎﻣس اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟراﺑﻊ ﻟذاﻟك ﺳﻧﺑدل ﺑﯾﻧﮭﻣﺎ‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬    ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫6‬             ‫24‬          ‫54‬          ‫58‬           ‫46‬
            ‫ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟﺧﺎﻣس اﻗل ﻣن ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟراﺑﻊ ﻟذال ﺳﻧﺑدل ﺑﯾﻧﮭﻣﺎ وﺳﺗﺻﺑﺢ اﻟﻣﺻﻔوﻓﺔ ﻣرﺗﺑﺔ ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬
  ‫]0[‪array‬‬     ‫]1[‪array‬‬    ‫]2[‪array‬‬     ‫]3[‪array‬‬      ‫]4[‪array‬‬
  ‫6‬            ‫24‬          ‫54‬           ‫46‬            ‫58‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                    ‫أﻻن ﻟﻧﺣول اﻟﻛﻼم اﻟذي ﻛﺗﺑﺎه واﻟﻣﺧططﺎت إﻟﻰ ﻣﺛﺎل‬

                                                 ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﺗرﺗﯾب ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﯾدﺧﻠﮭﺎ اﻟﻣﺳﺗﺧدم ﺗﺻﺎﻋدﯾﺎ..؟‬

   ‫ﺗﺣﻠﯾل:ﻛﯾف ﻧرﺗب ﺑرﻣﺟﯾﺎ؟ﻋﻠﻣﻧﺎ اﻧﮫ ﺑﺎﻟﺗرﺗﯾب ﻧﻘﺎرن ﻛل ﻣوﻗﻊ ﺑﺟﻣﯾﻊ اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﻠﯾﮫ ﻟذاﻟك ﺳﻧﺣﺗﺎج إﻟﻰ ﻋدادان‬
   ‫اﻷول ﺧﺎص ﺑﺎﻟﻣرور ﻋﻠﻰ ﻛل ﻣوﻗﻊ ﻣرة واﺣدة وﻋداد داﺧﻠﻲ ﯾﻘﺎرن ﻛل ﻋﻧﺻر ﻣرة ﻋﻠﯾﮫ اﻟﻌداد اﻟﺧﺎرﺟﻲ ﺑﺟﻣﯾﻊ‬
                                          ‫اﻟﻌﻧﺎﺻر اﻟﺗﻲ ﺗﻠﯾﮫ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ وأﯾﻧﻣﺎ وﺟد رﻗم اﻗل ﻣﻧﮫ ﯾﺑدل ﺑﯾﻧﮭﻣﺎ.‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
 ‫)(‪int main‬‬                                                 ‫)(‪int main‬‬
 ‫;‪{1.int array[5],i,j‬‬                                       ‫;‪{1.int array[5],i,j‬‬
 ‫;0=‪2. int item‬‬                                             ‫;0=‪2. int item‬‬
 ‫;"‪3.cout<<"Here is the Array befor sorted enter it\n‬‬       ‫; )"‪3.prin ("Here is the Array befor sorted enter it\n‬‬
 ‫)++‪4. for (i=0;i<5;i‬‬                                       ‫)++‪4. for (i=0;i<5;i‬‬
 ‫; ]‪5.cin>>array[i‬‬                                          ‫; )]‪5.scanf("%d",&array[i‬‬
 ‫)++‪6. for ( i=0;i<5-1;i‬‬                                    ‫)++‪6. for ( i=0;i<5-1;i‬‬
 ‫)++‪7.for ( j=i; j<5;j‬‬                                      ‫)++‪7.for ( j=i; j<5;j‬‬
 ‫{)]‪8.if (array[j] <array[i‬‬                                 ‫{)]‪8.if (array[j] <array[i‬‬
  ‫;]‪9.item =array[j‬‬                                          ‫;]‪9.item =array[j‬‬
 ‫;]‪10.array[j]=array[i‬‬                                      ‫;]‪10.array[j]=array[i‬‬
 ‫}; ‪11. array[i]= item‬‬                                      ‫}; ‪11. array[i]= item‬‬
 ‫;"‪12.cout<<"Here is the Array a er sorted\n‬‬                ‫;)"‪12. prin ("Here is the Array a er sorted\n‬‬
 ‫)++‪13.for (i=0;i<5;i‬‬                                       ‫)++‪13.for (i=0;i<5;i‬‬
 ‫};"‪14.cout<<array[i]<<"\n‬‬                                  ‫};)]‪14.prin ("%d\n",array[i‬‬




                                                                                                    ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

          ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ ﺧﻣﺳﺔ وﻣﺗﻐﯾر ﻟﻠﻌداد اﻟﺧﺎرﺟﻲ )‪ (i‬وﻣﺗﻐﯾر أﺧر ﻟﻠﻌداد اﻟداﺧﻠﻲ )‪(j‬‬

                     ‫٢.ﺧطوة رﻗم )٢( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ﻟﺗﺧزﯾن ﻗﯾﻣﺔ اﺣد اﻟﻣﺗﻐﯾرﯾن ﻋﻧد اﻹﺑدال ﻟﻛﻲ ﻻ ﺗﺿﯾﻊ ﻗﯾﻣﺔ اﺣدھﻣﺎ‬

     ‫٣.ﺧطوة رﻗم )٣( ھﻲ رﺳﺎﻟﺔ طﺑﺎﻋﯾﮫ ﺗطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل اﻟﻣﺻﻔوﻓﺔ وﺧطوة رﻗم )٤ و ٥(ﻗراءة اﻟﻣﺻﻔوﻓﺔ‬

 ‫٤.ﺧطوة رﻗم )٦( ھوا ﻋداد ﺧﺎرﺟﻲ ﯾﺑدأ ﺑﺎﻟﻌد ﻣن اﻟﺻﻔر إﻟﻰ اﻟﻣوﻗﻊ اﻟﻘﺑل اﻷﺧﯾر ﻟﻛﻲ ﯾرﺗﺑﮭم وﻻ ﯾﻌد اﻟﻣوﻗﻊ اﻷﺧﯾر‬
     ‫ﻻن اﻟﻣوﻗﻊ اﻷﺧﯾر ﻣرﺗب أﺻﻼ ﻣن ﻗﺑل اﻟﺧطوة اﻟﺗﻲ ﺗﺳﺑﻘﮫ ﻟذاﻟك ﻧرى ﺷرط اﻟﺗوﻗف ﻓﻲ اﻟﻌداد ھو)1-5<‪.(i‬‬
                                            ‫أي ﻓﻲ ﻛل ﻋدة ﻟﮭذا اﻟﻌداد ﺗﺗﻛرر اﻟﺧطوات رﻗم )٧ و٨و٩و٠١و١١(‬

     ‫٥.ﺧطوة رﻗم )٧( ھوا ﻋداد ﯾﺑدأ ﺑﺎﻟﻌد ﻣن ﻗﯾﻣﺔ اﻟﻌداد اﻟﺧﺎرﺟﻲ إﻟﻰ أرﺑﻌﺔ أي إذا ﻋد اﻟﻌداد اﻟﺧﺎرﺟﻲ ﺻﻔر ﺳﯾﻌد‬
  ‫اﻟﻌداد اﻟداﺧﻠﻲ ﻣن ﺻﻔر إﻟﻰ أرﺑﻌﺔ ﻟﻛﻲ ﯾﻘﺎرن اﻟﻣوﻗﻊ اﻷول ﺑﺟﻣﯾﻊ اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﻠﯾﮫ. وإذا ﻋد اﻟﻌداد اﻟﺧﺎرﺟﻲ واﺣد‬
  ‫ﺳﯾﻌد اﻟﻌداد اﻟداﺧﻠﻲ ﻣن واﺣد إﻟﻰ أرﺑﻌﺔ ﻟﻛﻲ ﯾﻘﺎرن اﻟﻣواﻗﻊ اﻟﺛﺎﻧﻲ ﺑﺟﻣﯾﻊ اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﻠﯾﮫ وﯾﺳﺗﻣر إﻟﻰ ﻣوﻗﻊ اﻟراﺑﻊ‬

           ‫٦.ﺧطوة رﻗم )٨( ھوا ﺷرط أذا ﻛﺎن ﻗﯾﻣﺔ اﻟﻌﻧﺻر اﻗل ﻣن ﻗﯾﻣﺔ اﺣد اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﻠﯾﮫ ﯾﺑدل ﺑﯾﻧﮭم ﻓﻲ ﺧطوة‬
                                                                                           ‫رﻗم )٩ و٠١و١١(‬


  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                      ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                           ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                    ‫٧.ﺧطوات رﻗم )٢١و٣١و٤١( ھوا ﻋﻣﻠﯾﺔ طﺑﺎﻋﺔ ﻟﻠﻣﺻﻔوﻓﺔ ﺑﻌد اﻟﺗرﺗﯾب ھﻛذا‬




                                                                      ‫اﻟﻘﯾﻣﺔ اﻟوﺳطﯾﺔ ﺑﻌد اﻟﺗرﺗﯾب ﺗﻘﻊ ﻣﻧﺗﺻف ﻋﻧﺎﺻر‬
                                                                      ‫اﻟﻣﺻﻔوﻓﺔ وﺑﻣﺎ إن ﺣﺟم ﻣﺻﻔوﻓﺗﻧﺎ ﺧﻣﺳﺔ ﻓﺎﻟﻘﯾﻣﺔ‬
                                                                           ‫اﻟوﺳطﯾﺔ ھﻲ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث أي )]2[‪(array‬‬




                                                                                                             ‫ﻣﮭم‬



                             ‫ﻟو أردﻧﺎ ﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺔ ﺗﻧﺎزﻟﯾﺎ ﻧﻔس اﻟطرﯾﻘﺔ ﻓﻘط ﻧﺑدل اﻟﺷرط ﻓﻲ ﺧطوة رﻗم )٨( إﻟﻰ‬

                                                                                                      ‫ﻛود‬
        ‫)]‪8.if (array[j] >array[i‬‬




                                                                                                               ‫ﻣﮭم‬


  ‫ﻟو أردﻧﺎ ﺗرﺗﯾب ﻓﻘط اﻟﻣواﻗﻊ اﻟﺛﻼث اﻷوﻟﻰ وﻻﺗﮭﻣﻧﺎ اﻟﺑﻘﯾﺔ ﻓﻘط ﻧﻐﯾر ﺷرط اﻟﺗوﻗف ﻓﻲ ﺧطوة رﻗم )٦ و٧( ﻧﺑدل رﻗم‬
                              ‫ﺧﻣﺳﺔ ب ﺛﻼﺛﺔ ھﻛذا )وﺿﻌﻧﺎ ﺛﻼﺛﺔ ﻋﻧد ﺷرط اﻟﺗوﻗف ﻟﻛﻲ ﯾرﺗب ﻓﻘط اﻟﻣوﻗﻊ اﻟﺛﻼﺛﺔ اﻷوﻟﻰ(‬


                                                                                                      ‫ﻛود‬
        ‫)++‪6. for ( i=0;i<3-1;i‬‬
        ‫)++‪7.for ( j=i; j<3;j‬‬


                                                                                                                    ‫ﻣﮭم‬

                          ‫ﻟو أردﻧﺎ ﺗرﺗﯾب اﻟﻣواﻗﻊ اﻟزوﺟﯾﺔ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﺗرﺗﯾﺑﺎ ﺗﺻﺎﻋدﯾﺎ ﻓﻘط ﻧﻐﯾر ھﺎﺗﺎن اﻟﺧطوﺗﺎن‬

                                                                                                      ‫ﻛود‬
        ‫)2+‪6. for ( i=0;i<5-1;i=i‬‬
        ‫)2+‪7.for ( j=i; j<5;j=j‬‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                        ‫اﻟﻔﺻل اﻟراﺑﻊ‬




            ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﻣﻌرﻓﺔ ھل اﻟرﻗم ﻣﺗﻧﺎظر )أي ﯾﻘرأ ﻣن اﻟﺟﮭﺗﯾن( وﯾﻛون ﻋدد اﻷرﻗﺎم ﺧﻣﺳﺔ ﻣﺛﻼ ١٢٣٢١‬

‫ﺗﺣﻠﯾل:ﻟﻛﻲ ﻧﻌرف ھل اﻟرﻗم ﻣﺗﻧﺎظر ھﻧﺎ ﻓﻲ ﻣﺻﻔوﻓﺔ ﺧﻣﺎﺳﯾﺔ ﯾﺟب أن ﯾﺳﺎوي ﻣﺣﺗوﯾﺎت اﻟﻣوﻗﻊ اﻷول ﻣﺣﺗوﯾﺎت اﻟﻣوﻗﻊ‬
               ‫اﻟﺧﺎﻣس واﻟﺛﺎﻧﻲ ﯾﺳﺎوي اﻟراﺑﻊ )اﻟﻣﺛﺎل اﻟﺗﺎﻟﻲ ﻟﯾس ﯾﺗﺣﻘق ﻓﻘط ﻣن ﺗﻧﺎظر اﻷرﻗﺎم ﺑل اﻟﺣروف أﯾﺿﺎ(‬

 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                   ‫>‪#include<stdio.h‬‬
 ‫>‪#include<conio.h‬‬                                      ‫>‪#include<conio.h‬‬
 ‫)(‪main‬‬                                                 ‫)(‪main‬‬
 ‫;]5[‪{1.int i, bol=0, a‬‬                                 ‫;]5[‪{1.int i, bol=0, a‬‬
 ‫)++‪2.for(i=0;i<5;i‬‬                                     ‫)++‪2.for(i=0;i<5;i‬‬
  ‫;)(‪3.a[i]=getche‬‬                                       ‫;)(‪3.a[i]=getche‬‬
 ‫)++‪4.for(i=0;i<5;i‬‬                                     ‫)++‪4.for(i=0;i<5;i‬‬
 ‫)]1-‪5.if(a[i]!= a[5-i‬‬                                  ‫)]1-‪5.if(a[i]!= a[5-i‬‬
 ‫;1=‪6.bol‬‬                                               ‫;1=‪6.bol‬‬
 ‫)0==‪7. if(bol‬‬                                          ‫)0==‪7. if(bol‬‬
 ‫;"‪8. cout<<"\nthe data is symmetric‬‬                    ‫;)"‪8. prin ("\nthe data is symmetric‬‬
 ‫‪9.else‬‬                                                 ‫‪9.else‬‬
 ‫};"‪10.cout<<"\nthe data is no symmetric‬‬                ‫};)"‪10.prin ("\nthe data is no symmetric‬‬




                                                                                           ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

   ‫١.ﺧطوة رﻗم )٣( ھﻲ داﻟﺔ ﻹدﺧﺎل ﺣرف وﻟﯾس رﻗم ورﻏم أﻧﮭﻣﺎ ﺳﺗدﺧل ﺑﺷﻛل ﺣرف وﻣداﺧﻼﺗﻧﺎ ﻗد ﺗﻛون أرﻗﺎم ﻓﻼ‬
‫ﯾﮭم ﻓﻔﻲ اﻟﻣﻘﺎرﻧﺔ ﻓﺑدﻻ ﻣﺎ ﯾﻘﺎرن اﻟرﻗم )١( ﯾﻘﺎرن اﻻﺳﻛﻲ ﻛود ﻟﮫ أي )٠٥( ﻓﻼ ﯾﺿر ﻟﻛن ﻟﻠﺟﻣﺎﻟﯾﺔ اﺳﺗﺧدﻣﻧﺎ ھذه اﻟداﻟﺔ‬

‫٢.ﺧطوة رﻗم )٥( ﯾﻘﺎرن اﻟﻌﻧﺎﺻر اﻷول ﺑﺎﻷﺧر واﻟﺛﺎﻧﻲ ﺑﺎﻟﻘﺑل اﻷﺧﯾر وھﻛذا ﻣﺎداﻣﺎ ﻣﺗﺳﺎوﯾﯾن ﯾﻛون اﻟﻣﺗﻐﯾر )0=‪(bol‬‬
                  ‫ﻓﺈذا ﻛﺎﻧﺎ ﻏﯾر ﻣﺗﺳﺎوﯾﯾن وﯾﺗﺣﻘق ﺷرط ﺧطوة رﻗم )٥( وﯾﻧﻔذ ﺧطوة )٦( ﺳﺗﺗﺣول ﻗﯾﻣﺗﮫ إﻟﻰ واﺣد‬

       ‫٣.ﺧطوة رﻗم )٧( ﯾﺗﺣﻘق ﻣن ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (bol‬إذا ﺑﻘت ﺛﺎﺑﺗﺔ ﺣﺳب ﺗﻌرﯾﻔﮭﺎ طﺑﻊ رﺳﺎﻟﺔ إن اﻟرﻗم ﻣﺗﻧﺎظر وإذا‬
                                                             ‫ﺗﻐﯾرت إﻟﻰ واﺣد ﯾطﺑﻊ رﺳﺎﻟﺔ أن اﻟرﻗم ﻏﯾر ﻣﺗﻧﺎظر‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                         ‫اﻟﻔﺻل اﻟراﺑﻊ‬




       ‫ﻣﺛﺎل: ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ )٥( اﺳﻣﮭﺎ )‪ (a‬ﺿﻊ اﻟﻌﻧﺎﺻر اﻟزوﺟﯾﺔ ﻟﮭﺎ ﻓﻲ ﻣﺻﻔوﻓﺔ )‪ (b‬واﻷﻋداد اﻟﻔردﯾﺔ ﻓﻲ )‪(c‬‬

  ‫ﺗﺣﻠﯾل: اﻟﻣوﺿوع ﺑﺳﯾط ﺟدا ﻟﯾدك ﺛﻼث ﻣﺻﻔوﻓﺎت ﻧﻔس اﻟﺣﺟم أو ﺑﺎﻷﺣرى ﻧﻔس ﺣﺟم اﻟﻣﺻﻔوﻓﺔ )‪ (a‬ﻷﻧﮭﺎ ﻗد ﺗﻛون‬
   ‫ﺟﻣﯾﻊ اﻹﻋداد ﻓردﯾﺔ أو زوﺟﯾﺔ.وﺑﻌد أن ﻧدﺧل اﻟﻣﺻﻔوﻓﺔ )‪ (a‬ﻧﻛون ﺷرط إذا ﻛﺎن ﻋددھﺎ ﻓردي ﻧﺿﻌﮫ ﻓﻲ )‪ (c‬وإذا‬
                                                ‫ﻛﻠن زوﺟﻲ ﻧﺿﻌﮭﺎ ﻓﻲ )‪ (b‬وﻟﻛل ﻣﺻﻔوﻓﺔ ﻋداد ﺧﺎص ﺑﮭﺎ.‬

 ‫++‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                         ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                       ‫)(‪main‬‬
 ‫;]5[‪{1.int count_a, count_b=0, count_c=0,a[5],b[5], c‬‬        ‫;]5[‪{1.int count_a, count_b=0, count_c=0,a[5],b[5], c‬‬
 ‫)++‪2.for( count_a=0; count_a<5; count_a‬‬                      ‫)++‪2.for( count_a=0; count_a<5; count_a‬‬
 ‫;]‪3.cin>>a[ count_a‬‬                                          ‫;)]‪3.scanf("%d",&a[ count_a‬‬
 ‫)++‪4.for( count_a=0; count_a<5; count_a‬‬                      ‫)++‪4.for( count_a=0; count_a<5; count_a‬‬
 ‫)0==2% ]‪5.if ( a[ count_a‬‬                                    ‫)0==2% ]‪5.if ( a[ count_a‬‬
 ‫;]‪{6.b[ count_b ]=a[count_a‬‬                                  ‫;]‪{6.b[ count_b ]=a[count_a‬‬
 ‫};1+‪7.count_b= count_b‬‬                                       ‫};1+‪7.count_b= count_b‬‬
 ‫‪8.else‬‬                                                       ‫‪8.else‬‬
 ‫;]‪{9.c[ count_c ]=a[count_a‬‬                                  ‫;]‪{9.c[ count_c ]=a[count_a‬‬
 ‫};1+‪10.count_c= count_c‬‬                                      ‫};1+‪10.count_c= count_c‬‬
 ‫;"‪11.cout<<"items in array b is\n‬‬                            ‫;)"‪11.prin ("items in array b is\n‬‬
 ‫)++‪12.for( count_a=0; count_a< count_b; count_a‬‬              ‫)++‪12.for( count_a=0; count_a< count_b; count_a‬‬
 ‫;"‪13.cout<< b[ count_a ]<<"\t‬‬                                ‫;)] ‪13.prin ("%d\t", b[ count_a‬‬
 ‫;"‪14.cout<<"\nitems in array c is\n‬‬                          ‫;)"‪14. prin ("\nitems in array c is\n‬‬
 ‫)++‪15.for( count_a=0; count_a< count_c; count_a‬‬              ‫)++‪15.for( count_a=0; count_a< count_c; count_a‬‬
 ‫};"‪16.cout<< c[ count_a ]<<"\t‬‬                               ‫};)] ‪16. prin ("%d\t", c[ count_a‬‬




                                                                                                         ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

    ‫١.ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻋداد ﻟﻠﻣﺻﻔوﻓﺔ )‪ (a‬وھو )‪ (count_a‬و ﻋداد ﻟﻠﻣﺻﻔوﻓﺔ )‪ (b‬وھو )‪ (count_b‬و ﻋداد‬
                                          ‫ﻟﻠﻣﺻﻔوﻓﺔ )‪ (c‬وھو )‪ (count_c‬وﻋرﻓﻧﺎ اﻟﻣﺻﻔوﻓﺎت ﺑﻧﻔس اﻷﺣﺟﺎم‬

                                                         ‫٢.ﺧطوة رﻗم )٢و٣( ھﻲ ﻗراءة ﻟﻠﻣﺻﻔوﻓﺔ )‪ (a‬ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

       ‫٣.ﺧطوة رﻗم )٤( ھوا ﻋداد ﻻﺧﺗﺑﺎر ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ )‪ (a‬ﺗﺗﺑﻌﮫ اﻟﺧطوات رﻗم )11—5( ﻛﻠﮭﺎ داﺧﻠﮫ اﻟﺗﻛرار‬

    ‫٤.ﺧطوة رﻗم )٥( ھوا ﺷرط اﻟﺗﺣﻘق إذا ﻛﺎن رﻗم اﻟﻣﺻﻔوﻓﺔ زوﺟﯾﺔ ﺳﯾوﺿﻊ ﻓﻲ ﻣﺻﻔوﻓﺔ )‪ (b‬ﻓﻲ ﺧطوة رﻗم )٦(‬
  ‫وﻧزود ﻋداد ھذه اﻟﻣﺻﻔوﻓﺔ ﻓﻲ ﺧطوة رﻗم )٧( )ﻟﻛل ﻣﺻﻔوﻓﺔ ﻋدادھﺎ ﻟﻛﻲ ﻧﻣﯾز ﺑﯾﻧﮭم ﺑﺎﻹﺿﺎﻓﺔ ﺣﺗﻰ ﺗﻛون اﻹﺿﺎﻓﺔ‬
                                                                                            ‫ﺻﺣﯾﺣﺔ(‬

   ‫٥. ﺧطوة رﻗم )٨( ھوا ﺷرط اﻟﺗﺣﻘق إذا ﻟم ﯾﻛون رﻗم اﻟﻣﺻﻔوﻓﺔ زوﺟﻲ ﺳﯾوﺿﻊ ﻓﻲ ﻣﺻﻔوﻓﺔ )‪ (c‬ﻓﻲ ﺧطوة رﻗم‬
     ‫)9( وﻧزﯾد ﻋداد ھذه اﻟﻣﺻﻔوﻓﺔ ﻓﻲ ﺧطوة رﻗم )01( )ﻟﻛل ﻣﺻﻔوﻓﺔ ﻋدادھﺎ ﻟﻛﻲ ﻧﻣﯾز ﺑﯾﻧﮭم ﺑﺎﻹﺿﺎﻓﺔ ﺣﺗﻰ ﺗﻛون‬
                                                                                    ‫اﻹﺿﺎﻓﺔ ﺻﺣﯾﺣﺔ(‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                   ‫اﻟﻔﺻل اﻟراﺑﻊ‬

                                                                                                      ‫ﻣﮭم‬


   ‫٦.ﺧطوة رﻗم )٢١( ھو ﻋداد ﯾﺑدأ ﺑﺎﻟﺻﻔر وﯾﻧﺗﮭﻲ ﺑﺄﻗل ﻣن ﻋداد اﻟﻣﺻﻔوﻓﺔ )‪ (b‬ﻟﻛﻲ ﻧطﺑﻊ ﻓﻘط اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﺣﺗوي‬
   ‫ﻋﻠﻰ ﻋﻧﺎﺻر ﻓﻲ ھذه اﻟﻣﺻﻔوﻓﺔ وﻻﻧطﺑﻊ اﻟﻣواﻗﻊ اﻟﻔﺎرﻏﺔ اﻋﺗﻣﺎدا ﻋﻠﻰ ﻋدادھﺎ اﻟذي ﯾزداد ﺑﻌد ﻛل إﺿﺎﻓﺔ ﻓﻲ ﺧطوة‬
                                                                                                 ‫رﻗم )7(‬

   ‫٧. ﺧطوة رﻗم )٥١( ھو ﻋداد ﯾﺑدأ ﺑﺎﻟﺻﻔر وﯾﻧﺗﮭﻲ ﺑﺄﻗل ﻣن ﻋداد اﻟﻣﺻﻔوﻓﺔ )‪ (c‬ﻟﻛﻲ ﻧطﺑﻊ ﻓﻘط اﻟﻣواﻗﻊ اﻟﺗﻲ ﺗﺣﺗوي‬
   ‫ﻋﻠﻰ ﻋﻧﺎﺻر ﻓﻲ ھذه اﻟﻣﺻﻔوﻓﺔ وﻻﻧطﺑﻊ اﻟﻣواﻗﻊ اﻟﻔﺎرﻏﺔ اﻋﺗﻣﺎدا ﻋﻠﻰ ﻋدادھﺎ اﻟذي ﯾزداد ﺑﻌد ﻛل إﺿﺎﻓﺔ ﻓﻲ ﺧطوة‬
                                                                                                ‫رﻗم )٠١(‬



                                                                             ‫ھذا ﻣﺎ ﺳﯾظﮭر ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




                                                                                                       ‫ﻣﮭم‬


     ‫ﻣن أﻻن ﻓﺻﺎﻋدا ﻣﺗﻰ ﻣﺎ ﻗﺎل ﻟك ﻗﺳم ﻋﻧﺎﺻر ﻣﺻﻔوﻓﺔ إﻟﻰ ﻣﺻﻔوﻓﺗﯾن اﺳﺗﺧدم ﻧﻔس ھذا اﻷﺳﻠوب ﻓﻘط اﻟﺷرط ﻓﻲ‬
                             ‫ﺧطوة رﻗم ﺧﻣﺳﺔ ﯾﺗﻐﯾر أو ﺗﻐﯾر أﺧر ﺑﺳﯾط ﻟﻛن ﺗﺑﻘﻰ اﻟﮭﯾﻛﻠﯾﺔ ﺗﻘرﯾﺑﺎ ﻧﻔﺳﮭﺎ........!‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                        ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                 ‫٣.٤- اﻟﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ اﻷﺑﻌﺎد:‬
    ‫ﻻ ﺗﺧﺗﻠف اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ ﻛﺛﯾرا ﻋن اﻟﻣﺻﻔوﻓﺔ أﺣﺎدﯾﺔ اﻹﺑﻌﺎد .ﺗﺧﺗﻠف ﻓﻘط ﻓﻲ اﻟﻌﻧوﻧﺔ ﻓﺑدﻻ ﻣن )‪ (index‬واﺣد‬
          ‫ﻧﺳﺗﺧدم اﺛﻧﺎن واﺣد ﻟﻠﺻﻔوف وأﺧر ﻟﻸﻋﻣدة )ﻣﺛﻼ ﻣﺻﻔوﻓﺔ )2*3( أي ﻣﻛوﻧﺔ ﻣن ﺛﻼث ﺻﻔوف وﻋﻣودﯾﯾن(‬
                               ‫ﺷﻜﻞ ﻣﺼﻔﻮﻓﺔ )2*3(‬          ‫ﻋﻤﻮد 0‬         ‫ﻋﻤﻮد 1‬
                                    ‫ﺻف 0‬                     ‫)0,0(‬         ‫)1,0(‬
                                    ‫ﺻف 1‬                     ‫)0,1(‬         ‫)1,1(‬                           ‫ﻣﮭم‬
                                    ‫ﺻف 2‬                     ‫)0,2(‬         ‫)1,2(‬

 ‫اﻟﻌﻧوﻧﺔ ﺗﻛون )رﻗم اﻟﻌﻣود ،رﻗم اﻟﺻف( وان اﻟﻌﻧوﻧﺔ اﻷﻋﻣدة واﻟﺻﻔوف ﺗﺑدأ ﻣن اﻟﺻﻔر وﻟﯾس ﻣن اﻟواﺣد أي ﻟو أردﻧﺎ‬
                                             ‫اﻟوﺻول إﻟﻰ ﻋﻧﺻر ﻓﻲ اﻟﺻف اﻟﺛﺎﻧﻲ اﻟﻌﻣود اﻷول ﺗﻛون ﻋﻧوﻧﮫ )0,1(.‬
 ‫واﻟﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ أﯾﺿﺎ ﻣﺟﻣوﻋﺔ ﺧﻼﯾﺎ ﻣﺗﺗﺎﻟﯾﺔ ﻓﻲ اﻟذاﻛرة ﺗﺣﺟز ﻟﻐرض ﺧزن ﻣﻌﻠوﻣﺎت ﻣﻌﯾﻧﺔ ﻓﻲ داﺧﻠﮭﺎ ﻛﺄن ﻧﺧزن‬
   ‫ﻓﻲ داﺧﻠﮭﺎ أرﻗﺎم أو أﺣرف وﺗﺑﻘﻰ ھذه اﻟﻘﯾم ﻣﺧزﻧﺔ داﺧل اﻟﻣﺻﻔوﻓﺔ ﺣﺗﻰ ﻧﻐﻠق اﻟﺑرﻧﺎﻣﺞ إذا ﻟم ﻧﻐﯾرھﺎ داﺧل اﻟﺑرﻧﺎﻣﺞ.‬
‫اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ: ﯾﺟب اﻹﻋﻼن ﻋن ﻋدد اﻟﻣواﻗﻊ اﻟﺗﻲ ﻧﺣﺗﺎﺟﮭﺎ ﻓﻲ اﻟﻌﻣل ﻓﻲ ﺑداﯾﺔ اﻟﺑرﻧﺎﻣﺞ ﺣﺗﻰ ﯾﺣﺟزھﺎ اﻟﻣﺗرﺟم‬
   ‫ﻟﻠﻣﺻﻔوﻓﺔ وﻻ ﯾﺧزن ﻗﯾم أﺧرى داﺧل ھذه اﻟﻣواﻗﻊ ﺗﺑﻘﻰ ﻣﺣﺟوزة ﻓﻘط ﻟﻌﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ وﯾﻛون اﻹﻋﻼن ﻋﻠﯾﮭﺎ ھﻛذا‬
                                                                                                ‫ھﯾﻛﻠﯾﺔ‬
        ‫]‪Trype of array arrrayname[row][columns‬‬

                          ‫‪ (arrrayname) ‬ھوا اﺳم اﻟﻣﺻﻔوﻓﺔ اﻟﺗﻲ ﺳﻧﺗﻌﺎﻣل ﻣﻌﮫ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ أي اﺳم ﻣﻣﻛن‬
         ‫‪ (row) ‬ھو ﻋدد ﺻﻔوف اﻟﻣﺻﻔوﻓﺔ ، )‪ (columns‬ھو ﻋدد اﻷﻋﻣدة ﻷﻧﻧﺎ ﻧﺗﻌﺎﻣل ﻣﻊ ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ اﻹﺑﻌﺎد‬
    ‫‪ (array of Trype) ‬ھو ﻧوع اﻟﻣﺻﻔوﻓﺔ اﻟﺗﻲ ﺳوف ﻧﻌرﻓﮭﺎ ﻗد ﺗﻛون ﺣرﻓﯾﺔ أو رﻗﻣﯾﺔ .ﻟو ﻋرﻓﻧﺎ ﻣﺻﻔوﻓﺔ‬
              ‫ﻣن ﻧوع )‪ (integer‬ﺟﻣﯾﻊ ﻋﻧﺎﺻرھﺎ ﺗﻛون )‪ (integer‬وﻻ ﯾﺟوز ﺗﺧزﯾن أﺣرف ﻓﻲ داﺧﻠﮭﺎ‬

                           ‫ﻣﺛﺎل:ﺗﻌرﯾف ﻣﺻﻔوﻓﺔ ﻣن ﻧوع )‪ (integer‬ﺣﺟﻣﮭﺎ )2*3( واﺳﻣﮭﺎ )‪.(first_array‬‬

                                                                                                 ‫ھﯾﻛﻠﯾﺔ‬
        ‫‪int‬‬   ‫;]2[]3[ ‪first_array‬‬

                                                         ‫ﻟﻧرﺳم اﻟﻣﺻﻔوﻓﺔ ھذه ذات ﺣﺟم ﺛﻼث ﺻﻔوف وﻋﻣودان‬

                     ‫ﺷﻜﻞ ﻣﺼﻔﻮﻓﺔ )2*3(‬           ‫ﻋﻤﻮد 0‬                ‫ﻋﻤﻮد 1‬
                          ‫ﺻف 0‬                   ‫]0[]0[ ‪first_array‬‬     ‫]1[]0[ ‪first_array‬‬
                          ‫ﺻف 1‬                   ‫]0[]1[ ‪first_array‬‬     ‫]1[]1[ ‪first_array‬‬
                          ‫ﺻف 2‬                   ‫]0[]2[ ‪first_array‬‬     ‫]1[]2[ ‪first_array‬‬
                                                                                                             ‫ﻣﮭم‬


             ‫ﻛﻣﺎ ﺗﻼﺣظ ﻓﻲ اﻟﻌﻧوﻧﺔ ﻛﯾف ﺗﻛون: ﻋﻣود رﻗم )0( وھو اﻟﻌﻣود اﻷول وﻋﻣود رﻗم )1( وھو اﻟﻌﻣود اﻟﺛﺎﻧﻲ‬
        ‫وﺻف رﻗم )0( وھو اﻟﺻف اﻷول و ﺻف رﻗم )1( وھو اﻟﺻف اﻟﺛﺎﻧﻲ و ﺻف رﻗم )2( وھو اﻟﺻف اﻟﺛﺎﻟث.‬



  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                    ‫اﻟﻔﺻل اﻟراﺑﻊ‬




‫وﺗﺧزﯾن ھذه اﻟﻌﻧﺎﺻر ﻓﻲ اﻟذاﻛرة ﯾﻛون ﻧﻔس طرﯾﻘﺔ ﺗﺧزﯾن اﻟﻣﺻﻔوﻓﺔ اﻷﺣﺎدﯾﺔ ﻟﻛن ھﻧﺎ ﯾﺧزن ﺻف وﺑﻌده ﺻف أﺧر‬
                                                                   ‫ﺑﺎﻟﺗﺳﻠﺳل إﻟﻰ أن ﺗﻧﺗﮭﻲ اﻟﺻﻔوف.‬

                   ‫ﻟﻧﻔرض أن ﺗﺧزﯾن أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﺑدء ﺑﻣوﻗﻊ )62181( وﯾﻛون ﺷﻛل ﻣواﻗﻊ اﻟذاﻛرة ھﻛذا‬
                                                                 ‫ﻣﻮاﻗﻊ ﺧﻼﯾﺎ اﻟﺬاﻛﺮة‬
                                                ‫ﻣواﻗﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬        ‫اﻟﻣوﻗﻊ‬  ‫ﻣﺤﺘﻮاه‬
                                                                            ‫52181‬   ‫‪data‬‬
                                                    ‫]0[]0[ ‪first_array‬‬      ‫62181‬
                                                    ‫]1[]0[ ‪first_array‬‬      ‫72181‬
                                                    ‫]0[]1[ ‪first_array‬‬      ‫82181‬
     ‫ھذه اﻟﻣواﻗﻊ ﻣﺣﺟوزة‬                             ‫]1[]1[ ‪first_array‬‬      ‫92181‬
              ‫ﻟﻠﻣﺻﻔوﻓﺔ‬                              ‫]0[]2[ ‪first_array‬‬      ‫03181‬
         ‫‪first_array‬‬                                ‫]1[]2[ ‪first_array‬‬      ‫13181‬
                                                                            ‫23181‬   ‫‪data‬‬
                                                                                                        ‫ﻣﮭم‬


‫ﻟو ﺗﻼﺣظ أن أول ﻋﻧﺻر ﻟﻠﻣﺻﻔوﻓﺔ وھو )]0[]0[ ‪ (first_array‬ﯾﺣﺟز اﻟﻣوﻗﻊ )62181( وﺗﺧزن ﻓﯾﮫ ﻗﯾﻣﺔ أول ﻋﻧﺻر‬
                   ‫وﯾﻠﯾﮫ ﺑﻘﯾﺔ اﻟﻌﻧﺎﺻر ﺑﺎﻟﺗﺗﺎﻟﻲ أي )]1[]0[ ‪ (first_array‬ﯾﺣﺟز اﻟﻣوﻗﻊ )72181( وﺑﺎﻟﺗﺗﺎﻟﻲ....؟‬

  ‫ﻋﻧوﻧﺔ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺗﺑدأ ﻣن اﻟﺻﻔر ﻟﻠﺻف واﻟﻌﻣود ﻛﻣﺎ ﺗﻼﺣظ أول ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ ھو )]0[]0[ ‪(first_array‬‬


                                                                                             ‫ھﯾﻛﻠﯾﺔ‬
        ‫]‪first_array [index_row][index_columns‬‬


                           ‫‪ (index_row) ‬ھو رﻗم اﻟﺻف اﻟذي ﻧرﯾد أن ﻧﺻل إﻟﯾﮫ وﯾﻣﺛل داﺋﻣﺎ ﺑﺎﻟﻣﺗﻐﯾر )‪.(i‬‬
                      ‫‪ (index_columns) ‬ھو رﻗم اﻟﻌﻣود اﻟذي ﻧرﯾد أن ﻧﺻل إﻟﯾﮫ وﯾﻣﺛل داﺋﻣﺎ ﺑﺎﻟﻣﺗﻐﯾر )‪.(j‬‬



                             ‫ﻣﺛﺎل:ﻟو أردﻧﺎ وﺿﻊ )97( ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻓﻲ اﻟﺻف اﻟﺛﺎﻧﻲ اﻟﻌﻣود اﻷول ﻧﻛﺗب ھﻛذا‬

                                                                                             ‫ھﯾﻛﻠﯾﺔ‬
        ‫;97=]0[]1[ ‪first_array‬‬
 ‫ﻟو ﺗﻼﺣظ أن )1=‪ (index_row‬وﻟﯾس )2( ﻷﻧﮫ ﻛﻣﺎ ﻗﻠﻧﺎ ﺗﺳﻠﺳل ﺻﻔوف اﻟﻣﺻﻔوﻓﺔ ﺗﺑدأ ﻣن اﻟﺻﻔر وﻟﯾس ﻣن اﻟواﺣد‬
                ‫أي اﻟﺻف اﻟﺛﺎﻧﻲ ﻓﻲ اﻟﺣﻘﯾﻘﺔ ھوا ﺻف رﻗم واﺣد ﻓﻲ اﻟﺑرﻣﺟﺔ وﻻﺣظ اﻟﻣﺧطط ﻓﻲ اﻟﺻﻔﺣﺔ اﻟﺳﺎﺑﻘﺔ‬

   ‫ﻟو ﺗﻼﺣظ أن )0=‪ (index_columns‬وﻟﯾس )1( ﻷﻧﮫ ﻛﻣﺎ ﻗﻠﻧﺎ ﺗﺳﻠﺳل ﺻﻔوف اﻟﻣﺻﻔوﻓﺔ ﺗﺑدأ ﻣن اﻟﺻﻔر وﻟﯾس ﻣن‬
        ‫اﻟواﺣد أي اﻟﻌﻣود اﻷول ﻓﻲ اﻟﺣﻘﯾﻘﺔ ھوا ﻋﻣود رﻗم ﺻﻔر ﻓﻲ اﻟﺑرﻣﺟﺔ وﻻﺣظ اﻟﻣﺧطط ﻓﻲ اﻟﺻﻔﺣﺔ اﻟﺳﺎﺑﻘﺔ‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                          ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                         ‫ﻟذاﻟك ﺑﻌد أن وﺿﻌﻧﺎ رﻗم )97( ﺑﺎﻟﻣوﻗﻊ اﻟﺛﺎﻟث ﯾﺻﺑﺢ ﺷﻛل اﻟﻣﺻﻔوﻓﺔ ﻓﻲ ﻣواﻗﻊ اﻟذاﻛرة ھﻛذا‬

                                                            ‫ﻣﻮاﻗﻊ ﺧﻼﯾﺎ اﻟﺬاﻛﺮة‬
                                           ‫ﻣواﻗﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬        ‫اﻟﻣوﻗﻊ‬      ‫ﻣﺤﺘﻮاه‬
                                                                       ‫52181‬       ‫‪data‬‬                   ‫ﻣﺣﺗوﯾﺎت‬
                                                                                                        ‫اﻟﻣوﻗﻊ ﺑﻌد‬
                                               ‫]0[]0[ ‪first_array‬‬      ‫62181‬                               ‫اﻹﺿﺎﻓﺔ‬
                                               ‫]1[]0[ ‪first_array‬‬      ‫72181‬
                                               ‫]0[]1[ ‪first_array‬‬      ‫82181‬       ‫97‬
    ‫ھذه اﻟﻣواﻗﻊ ﻣﺣﺟوزة‬                         ‫]1[]1[ ‪first_array‬‬      ‫92181‬
            ‫ﻟﻠﻣﺻﻔوﻓﺔ‬                           ‫]0[]2[ ‪first_array‬‬      ‫03181‬
        ‫‪first_array‬‬                            ‫]1[]2[ ‪first_array‬‬      ‫13181‬
                                                                       ‫23181‬       ‫‪data‬‬


                                                             ‫ﻟو أردﻧﺎ طﺑﺎﻋﺔ ﻣﺣﺗوﯾﺎت اﻟﺻف اﻟﺛﺎﻟث اﻟﻌﻣود اﻟﺛﺎﻧﻲ‬
              ‫++‪C‬‬                                                                             ‫اﻟﻛود ﺑﻠﻐﺔ‬
              ‫;]1[]2[ ‪Cout<< first_array‬‬


              ‫‪C‬‬                                                                                ‫اﻟﻛود ﺑﻠﻐﺔ‬
              ‫;)]1[]2[ ‪Printf("%d", first_array‬‬


                           ‫ﻟو أردﻧﺎ ﺗﻌرﯾف ﻣﺻﻔوﻓﺔ ﻣن ﻧوع ‪ float‬ﻧﻔس طرﯾﻘﺔ ﻣﺻﻔوﻓﺔ اﻟﺳﺎﺑﻘﺔ وﻛذاﻟك ﺑﻘﯾﺔ اﻷﻧواع‬

                                                                                                  ‫ھﯾﻛﻠﯾﺔ‬
        ‫‪float‬‬    ‫;]3[]5[ ‪first_array‬‬
                                                       ‫ﻧﺳﺗطﯾﻊ أﻋطﺎء ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻗﯾم وﻗت اﻟﺗﻌرﯾف ھﻛذا‬

                                                                                                  ‫ھﯾﻛﻠﯾﺔ‬
        ‫‪int‬‬     ‫;} }32,34{,}62,43{{=]2[]2[ ‪first_array‬‬
                                           ‫ﻓﯾﻛون ﺷﻛل اﻟﻣﺻﻔوﻓﺔ ﻓﻲ ﻣﻘطﻊ اﻟذاﻛرة وھﻲ ﻣﺧزن ﻓﯾﮭﺎ اﻟﻌﻧﺎﺻر ھﻛذا‬

                                                  ‫ﻣﻮاﻗﻊ ﺧﻼﯾﺎ اﻟﺬاﻛﺮة‬                            ‫إﻋطﺎء ﻗﯾم ﻟﻌﻧﺎﺻر‬
                                 ‫ﻣواﻗﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬        ‫اﻟﻣوﻗﻊ‬     ‫ﻣﺤﺘﻮاه‬              ‫اﻟﻣﺻﻔوﻓﺔ وﻗت اﻟﺗﻌرﯾف‬
         ‫ھذه اﻟﻣواﻗﻊ‬                                         ‫52181‬      ‫‪data‬‬                ‫ﯾﻛون ﺑوﺿﻊ ﻋﻧﺎﺻر ﻛل‬
  ‫ﻣﺣﺟوزة ﻟﻠﻣﺻﻔوﻓﺔ‬                    ‫]0[]0[ ‪first_array‬‬      ‫62181‬      ‫43‬                  ‫ﺻف ﺑﯾن ﻗوﺳﯾن ووﺿﻊ‬
      ‫‪first_array‬‬                    ‫]1[]0[ ‪first_array‬‬      ‫72181‬      ‫62‬                    ‫ﻓﺎرزة ﺑﯾن ﻛل ﺻﻔﯾﯾن‬
         ‫وﻣﺣﺗوﯾﺎﺗﮭﺎ‬                  ‫]0[]1[ ‪first_array‬‬      ‫82181‬      ‫34‬
                                     ‫]1[]1[ ‪first_array‬‬      ‫92181‬      ‫32‬



  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                           ‫اﻟﻔﺻل اﻟراﺑﻊ‬

                                                                                                              ‫ﻣﮭم‬


                              ‫ﻟو أردﻧﺎ وﺿﻊ رﻗم ﻣﻌﯾن ﻓﻲ ﺟﻣﯾﻊ ﻣواﻗﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ وﻗت اﻟﺗﻌرﯾف ﻧﻛﺗب ھﻛذا‬
                                           ‫ﻣﺛﻼ إذا أردﻧﺎ وﺿﻊ رﻗم ﺻﻔر ﻓﻲ ﺟﻣﯾﻊ ﻣواﻗﻊ ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ )٢*٢(‬
                                                                                                    ‫ھﯾﻛﻠﯾﺔ‬
        ‫‪int‬‬    ‫;} 0{=]2[]2[ ‪first_array‬‬


                                                                                                               ‫ﻣﮭم‬

              ‫ﺗﻌرﯾف وإدﺧﺎل اﻟﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ:ھذه اﻟﺧطوات ﺛﺎﺑﺗﺔ ﻓﻲ ﺗﻌرﯾف وإدﺧﺎل أي ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ ﻻ ﺗﺗﻐﯾر اﺑد‬
                                                ‫ﻣﺛﺎل: ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ )3*4( ﻣن ﻧوع ‪ integer‬ﺗﻌرﯾﻔﮭﺎ وإدﺧﺎﻟﮭﺎ‬


                                    ‫اﻟﻛود ﺑﺎﻟﻐﺔ ++‪C‬‬                                          ‫اﻟﻛود ﺑﺎﻟﻐﺔ ‪C‬‬
       ‫;]3[]4[‪1.int first_arry‬‬                          ‫;]3[]4[‪1.int first_arry‬‬
       ‫)++‪2.for (i=0;i<4;i‬‬                              ‫)++‪2.for (i=0;i<4;i‬‬
       ‫)++‪3.for (j=0;j<3;j‬‬                              ‫)++‪3.for (j=0;j<3;j‬‬
       ‫; ]‪4.cin>> first_arry[i][j‬‬                       ‫; )]‪4.scanf("%d",& first_arry[i][j‬‬

                                                    ‫اﻟذي ﯾﺗﻐﯾر ﺑﯾن ﺳؤال وأﺧر ﻓﻘط اﻟﻣﻛﺗوب ﺑﺧط ﻋرﯾض .‬
     ‫١.ﻓﻲ ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻧوع اﻟﻣﺻﻔوﻓﺔ ﻣﻣﻛن أن ﯾﺗﺑدل ﻧوﻋﮭﺎ ﺣﺳب اﻟطﻠب وﺣﺟﻣﮭﺎ ﺣﺳب اﻟﺳؤال ﻗﺎل ﻓﻲ‬
                                       ‫اﻟﺳؤال )3*4( ﻓﻛوﻧﺎ ﻣﺻﻔوﻓﺔ ﻋدد ﺻﻔوﻓﮭﺎ أرﺑﻌﺔ وﻋدد اﻷﻋﻣدة ﺛﻼﺛﺔ‬
  ‫٢.ﺧطوة رﻗم )٢( ﻓﻘط ﺷرط ﻋدد اﻟﺻﻔوف ﯾﺗﺑدل ھﻧﺎ أرﺑﻊ ﺻﻔوف ﻛﺗﺑﻧﺎ اﺻﻐر ﻣن أرﺑﻌﺔ وإذا ﺧﻣﺳﺔ ﻧﻛﺗب اﺻﻐر‬
                                                                            ‫ﻣن ﺧﻣﺳﺔ وﻛذاﻟك ﺑﻘﯾﺔ اﻷرﻗﺎم‬
   ‫٣.ﺧطوة رﻗم )٢( ﻓﻘط ﺷرط ﻋدد اﻷﻋﻣدة ﯾﺗﺑدل ھﻧﺎ ﺛﻼث أﻋﻣدة ﻛﺗﺑﻧﺎ اﺻﻐر ﻣن ﺛﻼﺛﺔ وإذا أرﺑﻌﺔ ﻧﻛﺗب اﺻﻐر ﻣن‬
                                                                                ‫أرﺑﻌﺔ وﻛذاﻟك ﺑﻘﯾﺔ اﻷرﻗﺎم‬
                                                ‫٤.ﺧطوة اﻹدﺧﺎل أﯾﺿﺎ ﺗﺑﻘﻰ ﺛﺎﺑﺗﺔ ﯾدﺧل ﺻف ﺻف ﺑﺎﻟﺗﺳﻠﺳل‬
                                                                                                                    ‫ﻣﮭم‬

     ‫ﻟﺣل أي ﺳؤال ﯾﺗﻌﻠق ﺑﺎﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ ﻧرﺳﻣﮭﺎ أوﻻ ﻗﺑل اﻟﺣل ﻓﻠو ﺟﺎء ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻓﻲ اﻟﺳؤال ﻣﺻﻔوﻓﺔ‬
                                                               ‫ﺣﺟﻣﮭﺎ )5*5( ﻧرﺳم ھذه اﻟﻣﺻﻔوﻓﺔ أوﻻ ھﻛذا‬
    ‫اﻟﻘطر اﻟرﺋﯾﺳﻲ‬
                           ‫)0,0(‬        ‫)1,0(‬         ‫)2,0(‬        ‫)3,0(‬        ‫)4,0(‬
                           ‫)0,1(‬        ‫)1,1(‬         ‫)2,1(‬        ‫)3,1(‬        ‫)4,1(‬
                           ‫)0,2(‬        ‫)1,2(‬         ‫)2,2(‬        ‫)3,2(‬        ‫)4,2(‬
                           ‫)0,3(‬        ‫)1,3(‬         ‫)2,3(‬        ‫)3,3(‬        ‫)4,3(‬
                           ‫)0,4(‬        ‫)1,4(‬         ‫)2,4(‬        ‫)3,4(‬        ‫)4,4(‬


  ‫أﻻن ﻧﺳﺗطﯾﻊ ﺣل ﺟﻣﯾﻊ اﻷﺳﺋﻠﺔ ﻋن اﻟﻣﺻﻔوﻓﺔ ھذه ﻓﻌﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو ﻗﺎل ﺟد ﻋﻧﺎﺻر اﻟﻘطر اﻟرﺋﯾﺳﻲ وھو اﻟذي‬
             ‫ﻧﺣن واﺿﻌون ﺧط ﻋﻠﯾﮫ وھو ﻣﻧﺻف اﻟﻣﺻﻔوﻓﺔ ﻣﺎ اﻟذي ﯾﻣﻛﻧﻧﺎ ﻣن ﺗﻣﯾزه ﻋن ﻏﯾره ﻣن اﻟﺻﻔوف ؟؟‬
 ‫اﻟذي ﯾﻣﯾز ﻋﻧﺎﺻر اﻟﻘطر اﻟرﺋﯾﺳﻲ ﻋن ﻏﯾره ﻣن اﻟﻌﻧﺎﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ھو ﻗﯾﻣﺔ اﻟﺻف ﺗﺳﺎوي ﻗﯾﻣﺔ اﻟﻌﻣود ﻻﺣظ‬
     ‫اﻟﻘﯾم ) )4,4(, )3,3(,)2,2(,)1,1(,)0,0( ﻓﯾﻛون اﻟﺷرط ھو ﺛﺎﺑت ﻓﻲ ﻛل ﻣﺻﻔوﻓﺔ ﻧرﯾد إﯾﺟﺎد ﻗطر اﻟرﺋﯾﺳﻲ.‬


  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                       ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                                               ‫اﻟﺑرﻣﺟﺔ‬
         ‫)‪If(i==j‬‬
        ‫ھﻧﺎ ﻧﻘوم ﺑطﺑﺎﻋﺔ اﻟﻌﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻓﻲ ﻗطر اﻟرﺋﯾﺳﻲ ‪// print the diagonal‬‬
                                                           ‫ﻗﯾﻣﺔ )‪ (i‬ھﻲ ﻋﻧوان اﻟﺻف وﻗﯾﻣﺔ )‪ (j‬ھﻲ ﻋﻧوان اﻟﻌﻣود‬

                                                                          ‫** اﻟﺣﺻول ﻋﻠﻰ ﻋﻧﺎﺻر اﻟﻘطر اﻟﺛﺎﻧوي‬

                          ‫)0,0(‬         ‫)1,0(‬         ‫)2,0(‬          ‫)3,0(‬      ‫)4,0(‬
                          ‫)0,1(‬         ‫)1,1(‬         ‫)2,1(‬          ‫)3,1(‬      ‫)4,1(‬
                          ‫)0,2(‬         ‫)1,2(‬         ‫)2,2(‬          ‫)3,2(‬      ‫)4,2(‬
                          ‫)0,3(‬         ‫)1,3(‬         ‫)2,3(‬          ‫)3,3(‬      ‫)4,3(‬
                          ‫)0,4(‬         ‫)1,4(‬         ‫)2,4(‬          ‫)3,4(‬      ‫)4,4(‬
    ‫اﻟﻘطر اﻟﺛﺎﻧوي‬

    ‫اﻟذي ﯾﻣﯾز ﻋﻧﺎﺻر اﻟﻘطر اﻟﺛﺎﻧوي ﻋن ﻏﯾرھﺎ ﻣن اﻟﻌﻧﺎﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ أن ﻗﯾﻣﺔ اﻟﺻف ﻋﻧد ﺟﻣﻌﮭﺎ ﺑﻘﯾﻣﺔ اﻟﻌﻣود‬
   ‫ﺗﺳﺎوي أرﺑﻌﺔ ﻻﺣظ )4=4+0(,)4=3+1(,)4=2+2(,)4=1+3(,)4=0+4( ﻓﻌﻼ ﺣﺎﺻل ﺟﻣﻊ رﻗم اﻟﺻف ﻣﻊ رﻗم‬
  ‫اﻟﻌﻣود ﻓﻲ اﻟﻘطر اﻟﺛﺎﻧوي ﯾﺳﺎوي أرﺑﻌﺔ ﻟﻛن ﯾﺧﺗﻠف ﻣن ﻣﺻﻔوﻓﺔ إﻟﻰ أﺧرى ھذه اﻟﻘﯾﻣﺔ اﻟﺟﻣﻊ ﺣﺳب إﺑﻌﺎد اﻟﻣﺻﻔوﻓﺔ‬
   ‫أﻧت ارﺳم اﻟﻣﺻﻔوﻓﺔ ﺣﺳب ﺣﺟﻣﮭﺎ وﺳﺗﺟد اﻟﻌﻼﻗﺔ ﻛﻣﺎ وﺟدﻧﺎھﺎ ﻧﺣن أﻻن .ﻓﯾﻛون اﻟﺷرط ھﻛذا وھو ﻏﯾر ﺛﺎﺑﺗﺔ ﻗﯾﻣﺔ‬
                                                                                               ‫اﻷرﺑﻌﺔ‬

                                                                                               ‫اﻟﺑرﻣﺟﺔ‬
         ‫)4=‪If(i+j‬‬



     ‫اﻟﻌﻧﺎﺻر‬
                                                                    ‫**اﻟﺣﺻول ﻋﻠﻰ اﻟﻌﻧﺎﺻر ﻓوق اﻟﻘطر اﻟرﺋﯾﺳﻲ‬
    ‫ﻓوق اﻟﻘطر‬
      ‫اﻟرﺋﯾﺳﻲ‬             ‫)0,0(‬         ‫)1,0(‬         ‫)2,0(‬          ‫)3,0(‬      ‫)4,0(‬
                          ‫)0,1(‬         ‫)1,1(‬         ‫)2,1(‬          ‫)3,1(‬      ‫)4,1(‬
                          ‫)0,2(‬         ‫)1,2(‬         ‫)2,2(‬          ‫)3,2(‬      ‫)4,2(‬
                          ‫)0,3(‬         ‫)1,3(‬         ‫)2,3(‬          ‫)3,3(‬      ‫)4,3(‬
                          ‫)0,4(‬         ‫)1,4(‬         ‫)2,4(‬          ‫)3,4(‬      ‫)4,4(‬


  ‫اﻟذي ﯾﻣﯾز ﻋﻧﺎﺻر ﻓوق اﻟﻘطر اﻟرﺋﯾﺳﻲ ﻋن ﻏﯾرھﺎ ﻣن اﻟﻌﻧﺎﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ أن ﻗﯾﻣﺔ اﻟﻌﻣود اﻛﺑر ﻣن ﻗﯾﻣﺔ اﻟﺻف‬
       ‫ﻻﺣظ اﻟﺗﺎﻟﻲ ))4,3(,)4,1(,)3,1(,)2,1(,)4,0(,)3,0(,)2,0(,)1,0( ﻓﻌﻼ ﻗﯾم اﻷﻋﻣدة ﺟﻣﯾﻌﮭﺎ أﻋﻠﻰ ﻣن ﻗﯾم‬
                                                 ‫اﻟﻣﺻﻔوﻓﺔ ﻓﻲ اﻟﻘطر اﻟﺛﺎﻧوي ﻓﯾﻛون اﻟﺷرط ھﻛذا وھو ﺛﺎﺑت‬

                                                                                               ‫اﻟﺑرﻣﺟﺔ‬
         ‫)‪If(i<j‬‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                   ‫اﻟﻔﺻل اﻟراﺑﻊ‬




     ‫اﻟﻌﻧﺎﺻر‬
                                                              ‫**اﻟﺣﺻول ﻋﻠﻰ اﻟﻌﻧﺎﺻر ﺗﺣت اﻟﻘطر اﻟرﺋﯾﺳﻲ‬
   ‫ﺗﺣت اﻟﻘطر‬
     ‫اﻟرﺋﯾﺳﻲ‬            ‫)0,0(‬       ‫)1,0(‬        ‫)2,0(‬         ‫)3,0(‬       ‫)4,0(‬
                        ‫)0,1(‬       ‫)1,1(‬        ‫)2,1(‬         ‫)3,1(‬       ‫)4,1(‬
                        ‫)0,2(‬       ‫)1,2(‬        ‫)2,2(‬         ‫)3,2(‬       ‫)4,2(‬
                        ‫)0,3(‬       ‫)1,3(‬        ‫)2,3(‬         ‫)3,3(‬       ‫)4,3(‬
                        ‫)0,4(‬       ‫)1,4(‬        ‫)2,4(‬         ‫)3,4(‬       ‫)4,4(‬


  ‫اﻟذي ﯾﻣﯾز ﻋﻧﺎﺻر ﺗﺣت اﻟﻘطر اﻟرﺋﯾﺳﻲ ﻋن ﻏﯾرھﺎ ﻣن اﻟﻌﻧﺎﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ أن ﻗﯾﻣﺔ ﻛل اﻟﻌﻣود اﻗل ﻣن ﻗﯾﻣﺔ ﻛل‬
 ‫اﻟﺻف ﻻﺣظ اﻟﺗﺎﻟﻲ ))3,4(,)1,4(,)1,3(,)1,2(,)0,4(,)0,3(,)0,2(,)0,1( ﻓﻌﻼ ﻗﯾم اﻷﻋﻣدة ﺟﻣﯾﻌﮭﺎ أﻋﻠﻰ ﻣن ﻗﯾم‬
                                                  ‫اﻟﻣﺻﻔوﻓﺔ ﻓﻲ اﻟﻘطر اﻟﺛﺎﻧوي ﻓﯾﻛون اﻟﺷرط ھﻛذا وھو ﺛﺎﺑت‬

                                                                                           ‫اﻟﺑرﻣﺟﺔ‬
         ‫)‪If(i>j‬‬



     ‫اﻟﻌﻧﺎﺻر‬
                                                               ‫**اﻟﺣﺻول ﻋﻠﻰ اﻟﻌﻧﺎﺻر ﻓوق اﻟﻘطر اﻟﺛﺎﻧوي‬
    ‫ﻓوق اﻟﻘطر‬
     ‫اﻟﺛﺎﻧوي‬            ‫)0,0(‬       ‫)1,0(‬        ‫)2,0(‬         ‫)3,0(‬       ‫)4,0(‬
                        ‫)0,1(‬       ‫)1,1(‬        ‫)2,1(‬         ‫)3,1(‬       ‫)4,1(‬
                        ‫)0,2(‬       ‫)1,2(‬        ‫)2,2(‬         ‫)3,2(‬       ‫)4,2(‬
                        ‫)0,3(‬       ‫)1,3(‬        ‫)2,3(‬         ‫)3,3(‬       ‫)4,3(‬
                        ‫)0,4(‬       ‫)1,4(‬        ‫)2,4(‬         ‫)3,4(‬       ‫)4,4(‬


    ‫اﻟذي ﯾﻣﯾز ﻋﻧﺎﺻر ﻓوق اﻟﻘطر اﻟﺛﺎﻧوي ﻋن ﻏﯾرھﺎ ﻣن اﻟﻌﻧﺎﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ أن ﻗﯾﻣﺔ اﻟﻌﻣود ﻋﻧد ﺟﻣﻌﮭﺎ ﻣﻊ ﻗﯾﻣﺔ‬
                                 ‫اﻟﺻف ﻻ ﯾﺗﺟﺎوز ﻧﺎﺗﺞ اﻟﺟﻣﻊ ﺛﻼﺛﺔ ﺑﯾﻧﻣﺎ ﺑﻘﯾﺔ اﻟﻌﻧﺎﺻر ﺗﺗﺟﺎوز ﺛﻼﺛﺔ ﻻﺣظ اﻟﺗﺎﻟﻲ‬
     ‫))0,3(,)1,2(,)0,2(,)2,1(,)1,1(,)0,1(,)3,0(,)2,0(,)1,0(,)0,0( . ﻓﯾﻛون اﻟﺷرط ھﻛذا وھو ﻏﯾر ﺛﺎﺑت ﻣن‬
                                                                            ‫ﻣﺻﻔوﻓﺔ إﻟﻰ أﺧرى ﺣﺳب ﺣﺟﻣﮭﺎ‬

                                                                                           ‫اﻟﺑرﻣﺟﺔ‬
         ‫)4<‪If(i+j‬‬


                                                               ‫**اﻟﺣﺻول ﻋﻠﻰ اﻟﻌﻧﺎﺻر ﺗﺣت اﻟﻘطر اﻟﺛﺎﻧوي‬

                        ‫)0,0(‬       ‫)1,0(‬        ‫)2,0(‬         ‫)3,0(‬       ‫)4,0(‬
                        ‫)0,1(‬       ‫)1,1(‬        ‫)2,1(‬         ‫)3,1(‬       ‫)4,1(‬
                        ‫)0,2(‬       ‫)1,2(‬        ‫)2,2(‬         ‫)3,2(‬       ‫)4,2(‬
     ‫اﻟﻌﻧﺎﺻر‬            ‫)0,3(‬       ‫)1,3(‬        ‫)2,3(‬         ‫)3,3(‬       ‫)4,3(‬
   ‫ﺗﺣت اﻟﻘطر‬            ‫)0,4(‬       ‫)1,4(‬        ‫)2,4(‬         ‫)3,4(‬       ‫)4,4(‬
     ‫اﻟﺛﺎﻧوي‬

  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                         ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                  ‫اﻟﻔﺻل اﻟراﺑﻊ‬




    ‫اﻟذي ﯾﻣﯾز ﻋﻧﺎﺻر ﺗﺣت اﻟﻘطر اﻟﺛﺎﻧوي ﻋن ﻏﯾرھﺎ ﻣن اﻟﻌﻧﺎﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ أن ﻗﯾﻣﺔ اﻟﻌﻣود ﻋﻧد ﺟﻣﻌﮭﺎ ﻣﻊ ﻗﯾﻣﺔ‬
                        ‫اﻟﺻف ﯾﺗﺟﺎوز ﻧﺎﺗﺞ اﻟﺟﻣﻊ ﻓوق اﻷرﺑﻌﺔ ﺑﯾﻧﻣﺎ ﺑﻘﯾﺔ اﻟﻌﻧﺎﺻر ﻻ ﺗﺗﺟﺎوز اﻷرﺑﻌﺔ ﻻﺣظ اﻟﺗﺎﻟﻲ‬
      ‫))4,1(,)4,2(,)3,2(,)4,3(,)3,3(,)3,3(,)4,4(,)3,4(,)2,4(,)1,4( .ﻓﯾﻛون اﻟﺷرط ھﻛذا وھو ﻏﯾر ﺛﺎﺑت ﻣن‬
                                                                           ‫ﻣﺻﻔوﻓﺔ إﻟﻰ أﺧرى ﺣﺳب ﺣﺟﻣﮭﺎ‬

                                                                                          ‫اﻟﺑرﻣﺟﺔ‬
         ‫)4>‪If(i+j‬‬




                                                         ‫‪ ‬اﻟﺣﺻول ﻋﻠﻰ اﻟﻌﻧﺎﺻر اﻟﻌﻣود اﻷول واﻟراﺑﻊ‬
    ‫ﻋﻧﺎﺻر‬
‫اﻟﻌﻣود اﻷول‬
                          ‫)0,0(‬        ‫)1,0(‬     ‫)2,0(‬         ‫)3,0(‬       ‫)4,0(‬
    ‫واﻟراﺑﻊ‬
                          ‫)0,1(‬        ‫)1,1(‬     ‫)2,1(‬         ‫)3,1(‬       ‫)4,1(‬
                          ‫)0,2(‬        ‫)1,2(‬     ‫)2,2(‬         ‫)3,2(‬       ‫)4,2(‬
                          ‫)0,3(‬        ‫)1,3(‬     ‫)2,3(‬         ‫)3,3(‬       ‫)4,3(‬
                          ‫)0,4(‬        ‫)1,4(‬     ‫)2,4(‬         ‫)3,4(‬       ‫)4,4(‬


     ‫ﻣﺎ ﯾﻣﯾز ﻋﻧﺎﺻر اﻟﻌﻣود اﻷول ﻋن ﻏﯾره ﻣن اﻷﻋﻣدة أن ﻗﯾﻣﺔ )0=‪ (j‬ﻣﺎ ﯾﻣﯾز ﻋﻧﺎﺻر اﻟﻌﻣود اﻟراﺑﻊ ﻋن ﻏﯾره ﻣن‬
                                                     ‫اﻷﻋﻣدة أن ﻗﯾﻣﺔ)3=‪ (j‬ﻓﺷرط اﻟﺣﺻول ﻋﻠﯾﮭﻣﺎ وھو ﺛﺎﺑت‬

                                                                                          ‫اﻟﺑرﻣﺟﺔ‬
         ‫))3==‪If((j==0)||(j‬‬


                                                          ‫اﻟﺣﺻول ﻋﻠﻰ ﻋﻧﺎﺻر اﻟﺻف اﻷول و اﻟﺛﺎﻟث واﻟراﺑﻊ‬
    ‫ﻋﻧﺎﺻر‬
‫اﻟﺻف اﻷول‬                 ‫)0,0(‬        ‫)1,0(‬     ‫)2,0(‬         ‫)3,0(‬       ‫)4,0(‬
    ‫واﻟﺛﺎﻟث‬               ‫)0,1(‬        ‫)1,1(‬     ‫)2,1(‬         ‫)3,1(‬       ‫)4,1(‬
    ‫واﻟراﺑﻊ‬               ‫)0,2(‬        ‫)1,2(‬     ‫)2,2(‬         ‫)3,2(‬       ‫)4,2(‬
                          ‫)0,3(‬        ‫)1,3(‬     ‫)2,3(‬         ‫)3,3(‬       ‫)4,3(‬
                          ‫)0,4(‬        ‫)1,4(‬     ‫)2,4(‬         ‫)3,4(‬       ‫)4,4(‬


  ‫ﻣﺎ ﯾﻣﯾز ﻋﻧﺎﺻر اﻟﺻف اﻷول ﻋن ﻏﯾره ﻣن اﻟﺻﻔوف أن ﻗﯾﻣﺔ )0=‪ (i‬وﻣﺎ ﯾﻣﯾز ﻋﻧﺎﺻر اﻟﺻف اﻟﺛﺎﻟث ﻋن ﻏﯾره ﻣن‬
   ‫اﻟﺻﻔوف أن ﻗﯾﻣﺔ )2=‪ (i‬و ﻣﺎ ﯾﻣﯾز ﻋﻧﺎﺻر اﻟﺻف اﻟراﺑﻊ ﻋن ﻏﯾره ﻣن اﻟﺻﻔوف أن ﻗﯾﻣﺔ )3=‪ (i‬ﻓﺷرط اﻟﺣﺻول‬
                                                                                 ‫ﻋﻠﯾﮭﻣﺎ وھو ﺛﺎﺑت‬

                                                                                          ‫اﻟﺑرﻣﺟﺔ‬
         ‫))3==‪If((i==0)||(i==2) ||(i‬‬


  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                       ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                ‫ﻣﺛﺎل: ﻣﺻﻔوﻓﺔ ﻣرﺑﻌﺔ )5*5( أطﺑﻊ ﻓﻘط ﻋﻧﺎﺻر اﻟﻘطر اﻟرﺋﯾﺳﻲ ؟‬

       ‫ﺗﺣﻠﯾل :ﻧﻌﻠم أن ﺷرط اﻟﺣﺻول ﻋﻠﻰ ﻋﻧﺎﺻر اﻟﻘطر اﻟرﺋﯾﺳﻲ ﻓﻲ أي ﻣﺻﻔوﻓﺔ ھو ﺛﺎﺑت وھو )‪ (i==j‬وﻟﻠﻛﺛﯾر ﻣن‬
                                           ‫اﻟﻣﻌﻠوﻣﺎت راﺟﻊ اﻟﻣﺧطط اﻟﺳﺎﺑق ﻋن اﻟﺣﺻول ﻋﻠﻰ اﻟﻘطر اﻟرﺋﯾﺳﻲ‬

 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                   ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                 ‫)(‪main‬‬
 ‫;‪{1.int i‬‬                                              ‫; ‪{1.int i‬‬
 ‫;‪2.int j‬‬                                               ‫;‪2.int j‬‬
 ‫;]5[]5[‪3.int a‬‬                                         ‫;]5[]5[‪3.int a‬‬
 ‫)++‪4.for(i=0;i<5;i‬‬                                     ‫)++‪4.for(i=0;i<5;i‬‬
 ‫)++‪5.for(j=0;j<5;j‬‬                                     ‫)++‪5.for(j=0;j<5;j‬‬
 ‫;]‪6.cin>>a[i][j‬‬                                        ‫;)]‪6.scanf("%d",&a[i][j‬‬
 ‫)++‪7.for(i=0;i<5;i‬‬                                     ‫)++‪7.for(i=0;i<5;i‬‬
 ‫)++‪8.for(j=0;j<5;j‬‬                                     ‫)++‪8.for(j=0;j<5;j‬‬
 ‫)‪9.if(i==j‬‬                                             ‫)‪9.if(i==j‬‬
 ‫};"‪10.cout<<a[i][j]<<"\n‬‬                               ‫};)]‪10.prin ("%d \n ",a[i][j‬‬




                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

 ‫١.ﺧطوة رﻗم )٣ و٤و٥و٦( ھﻲ ﺗﻌرﯾف وإدﺧﺎل اﻟﻣﺻﻔوﻓﺔ وھﻲ ﺛﺎﺑﺗﺔ ﻓﻲ ﻛل ﺑرﻧﺎﻣﺞ ﻧدﺧل ﻓﯾﮫ ﻣﺻﻔوﻓﺔ ﺣﺳب ﺣﺟم‬
                                                     ‫اﻟﻣﺻﻔوﻓﺔ ﻓﻘط ﺗﺗﻐﯾر ﻗﯾم ﺗوﻗف اﻟﻌدادان ﻛﻣﺎ ﻗﻠﻧﺎ ﺳﺎﺑﻘﺎ‬

 ‫٢.ﺧطوة رﻗم)٧ و ٨( ﻋدادان ﯾﻣران ﻋﻠﻰ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺑﺎﻟﺗﺳﻠﺳل ﺻف ﺻف ﻟﻛﻲ ﻧﺗﺣﻘق ﻣن اﻟﺷرط ﻓﺄي‬
   ‫رﻗم ﯾﻘﻊ ﻓﻲ اﻟﻘطر اﻟرﺋﯾﺳﻲ ﺳﯾﻛون ﻋﻧدھﺎ ﻗﯾﻣﺔ اﻟﻌدادان )‪ (i==j‬ﻟذاﻟك ﺳﯾﺣﻘق اﻟﺷرط ﻓﻲ اﻟﺧطوة رﻗم )٩( وﯾطﺑﻊ‬
                                                                              ‫اﻟرﻗم ﻓﻲ اﻟﺧطوة رﻗم )٠١(‬

                                                                                               ‫ﻛﻣﺎ ﻓﻲ اﻟﺷﻛل‬

                                                                                                          ‫ﻣﻌﻠوﻣﺔ‬



 ‫*ﺟﻣﯾﻊ اﻷﻣﺛﻠﺔ اﻟﺗﻲ ﺣﻠﯾﻧﺎھﺎ ﻓﻲ اﻟﻣﺻﻔوﻓﺎت اﻷﺣﺎدﯾﺔ ﻧﺳﺗطﯾﻊ اﺳﺗﺧداﻣﮭﺎ ﻓﻲ اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ ﻓﻘط ﻧﺑدل اﻟﺑﻌد اﻟواﺣد‬
                                                                                ‫إﻟﻰ ﺑﻌدﯾن واﻟﻌداد إﻟﻰ ﻋدادﯾن‬

                                     ‫*ﻟو أردﻧﺎ ﺿرب ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺑرﻗم ﻣﻌﯾن ﻣﺛﻼ )٢( ﻧﺿرب ھﻛذا‬

                                                                                               ‫اﻟﺑرﻣﺟﺔ‬
          ‫;]‪a[i][j]=2*a[i][j‬‬
                                           ‫وﻛذاﻟك ﺑﻘﯾﺔ اﻟﻌﻣﻠﯾﺎت ﺟﻣﻊ ﻋﻧﺻر ﻣﻊ ﻛل ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ أو ﺿرﺑﮫ‬

                      ‫ﻻ ﺗﻧﺳﻰ أن ﺗﺿﻊ ﻋداد ﻟﻠﺻﻔوف وﻋداد ﻷﻋﻣدة اﻟﻣﺻﻔوﻓﺔ ﻗﺑل ھذه اﻟﺧطوة ﻟﯾﺿر ﻋﻧﺻر ﻋﻧﺻر‬



  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                             ‫اﻟﻔﺻل اﻟراﺑﻊ‬




 ‫ﻣﺛﺎل: ﻣﺻﻔوﻓﺔ ﻣرﺑﻌﺔ )5*5( اﺟﻣﻊ اﻟﻌﻧﺎﺻر ﻓوق اﻟﻘطر اﻟرﺋﯾﺳﻲ وﺟﻣﻊ اﻟﻌﻧﺎﺻر ﺗﺣﺗﮫ وﺟﻣﻊ اﻟﻌﻧﺎﺻر ﻓوق اﻟﻘطر‬
                                                                           ‫اﻟﺛﺎﻧوي وﺗﺣﺗﮫ ﻛل ﻋﻠﻰ ﺣدة‬

          ‫ﺗﺣﻠﯾل:ارﺟﻊ إﻟﻰ ﺧطوات اﻟﺗﺣﻠﯾل اﻟﺳﺎﺑﻘﺔ وﺳﺗﻔﮭم اﻟﺷروط اﻟﻣراد إﯾﺟﺎدھﺎ وطرﯾﻘﺔ ﺗﺣﻠﯾﻠﮭﺎ ورﺳم اﻟﻣﺻﻔوﻓﺔ .‬

 ‫++‪c‬‬                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                     ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                   ‫)(‪main‬‬
 ‫;3‪{1.int i,j,sum,sum1,sum2,sum‬‬                           ‫;3‪{i1.int i,j,sum,sum1,sum2,sum‬‬
 ‫;0=3‪2.sum=sum1=sum2=sum‬‬                                  ‫;0=3‪2.sum=sum1=sum2=sum‬‬
 ‫;]5[]5[‪3.int a‬‬                                           ‫;]5[]5[‪3.int a‬‬
 ‫)++‪4.for(i=0;i<5;i‬‬                                       ‫)++‪4.for(i=0;i<5;i‬‬
 ‫)++‪5.for(j=0;j<5;j‬‬                                       ‫)++‪5.for(j=0;j<5;j‬‬
 ‫;]‪6.cin>>a[i][j‬‬                                          ‫;)]‪6.scanf("%d",&a[i][j‬‬
 ‫)++‪7.for(i=0;i<5;i‬‬                                       ‫)++‪7.for(i=0;i<5;i‬‬
 ‫{ )++‪8.for(j=0;j<5;j‬‬                                     ‫{ )++‪8.for(j=0;j<5;j‬‬
 ‫)‪9.if(i<j‬‬                                                ‫)‪9.if(i<j‬‬
 ‫;]‪10.sum+=a[i][j‬‬                                         ‫;]‪10.sum+=a[i][j‬‬
 ‫)‪11.if(i>j‬‬                                               ‫)‪11.if(i>j‬‬
 ‫;]‪12.sum1+=a[i][j‬‬                                        ‫;]‪12.sum1+=a[i][j‬‬
 ‫)4<)‪13. if((i+j‬‬                                          ‫)4<)‪13. if((i+j‬‬
 ‫;]‪14sum2+=a[i][j‬‬                                         ‫;]‪14sum2+=a[i][j‬‬
 ‫)4>)‪15if((i+j‬‬                                            ‫)4>)‪15if((i+j‬‬
 ‫};]‪16.sum3+=a[i][j‬‬                                       ‫};]‪16.sum3+=a[i][j‬‬
 ‫;2‪17.cout<<"\n sum above secondary diagonal= "<<sum‬‬      ‫;)2‪17.prin ("\n sum above secondary diagonal= %d ",sum‬‬
 ‫;‪18.cout<<"\n sum above main diagonal= "<<sum‬‬            ‫;)‪18. prin ("\n sum above main diagonal=%d ",sum‬‬
 ‫;1‪19.cout<<"\n sum under main diagonal= "<<sum‬‬            ‫;)1‪19.prin ("\n sum under main diagonal= %d ",sum‬‬
 ‫};3‪20.cout<<"\n sum under secondary diagonal= "<<sum‬‬      ‫};)3‪20.prin ("\n sum under secondary diagonal=%d ",sum‬‬



                                                                                                 ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

‫١.ﺧطوة رﻗم )٣ و٤و٥و٦( ھﻲ ﺗﻌرﯾف وإدﺧﺎل اﻟﻣﺻﻔوﻓﺔ وھﻲ ﺛﺎﺑﺗﺔ ﻓﻲ ﻛل ﺑرﻧﺎﻣﺞ ﻧدﺧل ﻓﯾﮫ ﻣﺻﻔوﻓﺔ ﺣﺳب اﻟﺣﺟم‬

       ‫٢.ﺧطوة رﻗم)٧ و٨ (ﻋدادان ﯾﻣران ﻋﻠﻰ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺑﺎﻟﺗﺳﻠﺳل ﺻف ﺻف ﻟﻛﻲ ﻧﺗﺣﻘق ﻣن اﻟﺷروط‬

   ‫٣.ﺧطوة رﻗم )٩( ھو ﺷرط ﻟﺟﻣﻊ اﻟﻌﻧﺎﺻر ﻓوق اﻟﻘطر اﻟرﺋﯾﺳﻲ أي أذا ﺟﺎء أي ﻋﻧﺻر ﺿﻣن ﻋﻧﺎﺻر ﻓوق اﻟﻘطر‬
                            ‫اﻟرﺋﯾﺳﻲ ﺳﯾﻧﻔذ اﻟﺧطوة رﻗم )٠١( ﻟﻛﻲ ﯾﺟﻣﻌﮫ ﺑﺑﻘﯾﺔ ﻋﻧﺎﺻر ﻓوق اﻟﻘطر اﻟرﺋﯾﺳﻲ‬

‫٤.ﺧطوة رﻗم )١١( ھو ﺷرط ﻟﺟﻣﻊ اﻟﻌﻧﺎﺻر ﺗﺣت اﻟﻘطر اﻟرﺋﯾﺳﻲ أي إذا ﺟﺎء أي ﻋﻧﺻر ﺿﻣن ﻋﻧﺎﺻر ﺗﺣت اﻟﻘطر‬
                          ‫اﻟرﺋﯾﺳﻲ ﺳﯾﻧﻔذ اﻟﺧطوة رﻗم )٢١( ﻟﻛﻲ ﯾﺟﻣﻌﮫ ﺑﺑﻘﯾﺔ ﻋﻧﺎﺻر ﺗﺣت اﻟﻘطر اﻟرﺋﯾﺳﻲ‬

  ‫٥.ﺧطوة رﻗم )٣١( ھو ﺷرط ﻟﺟﻣﻊ اﻟﻌﻧﺎﺻر ﻓوق اﻟﻘطر اﻟﺛﺎﻧوي أي إذا ﺟﺎء أي ﻋﻧﺻر ﺿﻣن ﻋﻧﺎﺻر ﻓوق اﻟﻘطر‬
                             ‫اﻟﺛﺎﻧوي ﺳﯾﻧﻔذ اﻟﺧطوة رﻗم )٤١( ﻟﻛﻲ ﯾﺟﻣﻌﮫ ﺑﺑﻘﯾﺔ ﻋﻧﺎﺻر ﻓوق اﻟﻘطر اﻟﺛﺎﻧوي‬

 ‫٦.ﺧطوة رﻗم )٥١( ھو ﺷرط ﻟﺟﻣﻊ اﻟﻌﻧﺎﺻر ﺗﺣت اﻟﻘطر اﻟﺛﺎﻧوي أي إذا ﺟﺎء أي ﻋﻧﺻر ﺿﻣن ﻋﻧﺎﺻر ﺗﺣت اﻟﻘطر‬
                            ‫اﻟﺛﺎﻧوي ﺳﯾﻧﻔذ اﻟﺧطوة رﻗم )٦١( ﻟﻛﻲ ﯾﺟﻣﻌﮫ ﺑﺑﻘﯾﺔ ﻋﻧﺎﺻر ﺗﺣت اﻟﻘطر اﻟﺛﺎﻧوي‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                      ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                             ‫ﻣﺛﺎل: ﺗﻛوﯾن ﻣﺻﻔوﻓﺔ)٤*٤( ﻛﻣﺎ ﻓﻲ اﻟﺷﻛل‬

                                                                         ‫ﺗﺣﻠﯾل: ﻛﻣﺎ ﻗﻠﻧﺎ ﺳﺎﺑﻘﺎ ﻧرﺳم اﻟﻣﺻﻔوﻓﺔ ﻓﻲ اﻟﺑداﯾﺔ‬

                                                                   ‫)0,0(‬          ‫)1,0(‬            ‫)2,0(‬          ‫)3,0(‬
                                                                   ‫)0,1(‬          ‫)1,1(‬            ‫)2,1(‬          ‫)3,1(‬
                                                                   ‫)0,2(‬          ‫)1,2(‬            ‫)2,2(‬          ‫)3,2(‬
                                                                   ‫)0,3(‬          ‫)1,3(‬            ‫)2,3(‬          ‫)3,3(‬

    ‫ﻛﻣﺎ ﻧﻼﺣظ ﻛن اﻟرﺳم أﻧﻧﺎ ﻧرﯾد أن ﻧﺿﻊ ﻗﯾﻣﺔ واﺣد ﻓﻲ اﻟﺻف اﻷول واﻟﺻف اﻟراﺑﻊ واﻟﻌﻣود اﻷول واﻟﻌﻣود اﻟراﺑﻊ‬
  ‫واﻟﻣواﻗﻊ ﺧﻼﻓﮭﻣﺎ ﻧﺿﻊ ﻓﯾﮭﺎ ﺻﻔر.وان ﻣﺎ ﯾﻣﯾز اﻟﺻف اﻷول ﻋن ﺑﺎﻗﻲ اﻟﺻﻔوف أن ﻗﯾﻣﺔ )0=‪ (i‬وﻣﺎ ﯾﻣﯾز اﻟﺻف اﻟراﺑﻊ ﻋن ﺑﻘﯾﺔ‬
‫اﻟﺻﻔوف أن ﻗﯾﻣﺔ )3=‪ (i‬وان ﻣﺎ ﯾﻣﯾز اﻟﻌﻣود اﻷول ﻋن ﺑﺎﻗﻲ اﻷﻋﻣدة أن ﻗﯾﻣﺔ )0=‪ (j‬وﻣﺎ ﯾﻣﯾز اﻟﻌﻣود اﻟراﺑﻊ ﻋن ﺑﻘﯾﺔ اﻷﻋﻣدة أن ﻗﯾﻣﺔ‬
                                         ‫)3=‪ (j‬وﺳﯾﻛون ﻟذاﻟك اﻟﺷرط ﯾﺟﻣﻊ ﺑﯾن ھذه اﻟﺷروط اﻷرﺑﻌﺔ ﻛﻣﺎ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
  ‫)(‪main‬‬                                                     ‫)(‪main‬‬
 ‫{‬                                                          ‫{‬
 ‫;‪1.int i,j‬‬                                                 ‫;‪1.int i,j‬‬
 ‫;}0{=]4[]4[‪2.int a‬‬                                         ‫;}0{=]4[]4[‪2.int a‬‬
 ‫{)++‪3.for(i=0;i<4;i‬‬                                        ‫{)++‪3.for(i=0;i<4;i‬‬
 ‫{)++‪4.for(j=0;j<4;j‬‬                                        ‫{)++‪4.for(j=0;j<4;j‬‬
 ‫))0==‪5.if((j==0)||(i==3)||(j==3)||(i‬‬                       ‫))0==‪5.if((j==0)||(i==3)||(j==3)||(i‬‬
 ‫;1=]‪6.a[i][j‬‬                                               ‫;1=]‪6.a[i][j‬‬
 ‫};"‪7.cout<< a[i][j]<<"\t‬‬                                   ‫};) ]‪7.printf("%d\t", a[i][j‬‬
 ‫};"‪8.cout<<"\n‬‬                                              ‫};)"‪8. printf("\n‬‬
 ‫}‬                                                          ‫}‬



                                                                                                           ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                           ‫ﺧطوة رﻗم )٢( ﻋرﻓﻧﺎ ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ )٤*٤( وﺧزﻧﺎ ﺻﻔر ﻓﻲ ﺟﻣﯾﻊ ﻣواﻗﻌﮭﺎ‬                           ‫١.‬
                                  ‫ﺧطوة رﻗم)٣ و٤( ﻋداد ﯾﻣر ﻋﻠﻰ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺻف ﺻف‬                              ‫٢.‬
   ‫ﺧطوة رﻗم)٥( ھو ﺷرط اﺧﺗﯾﺎر إذا ﻛﺎن اﻟﺻف اﻷول أو اﻟﺻف اﻟراﺑﻊ أو اﻟﻌﻣود اﻷول أو اﻟﻌﻣود اﻟراﺑﻊ‬                        ‫٣.‬
                                            ‫ﺳوف ﯾﻧﻔذ ﺧطوة رﻗم )٦( ﻟﯾﺿﻊ واﺣد ﺑد اﻟﺻﻔر ﻓﻲ اﻟﻣوﻗﻊ‬
                                                             ‫ﺧطوة رﻗم )٧( طﺑﻊ ﻣﺣﺗوﯾﺎت اﻟﻣﺻﻔوﻓﺔ‬                       ‫٤.‬
     ‫ﺧطوة رﻗم )٨( وھﻲ ﺧطوة اﻟﻧزول إﻟﻰ ﺳطر ﺟدﯾد ﺑﻌد طﺑﺎﻋﺔ ﺻف ﻛﺎﻣل ﺣﺗﻰ ﯾﻛون ﺷﻛل اﻟﻣﺻﻔوﻓﺔ‬                               ‫٥.‬
 ‫اﻟﻣطﺑوﻋﺔ ﺑﺎﻟﺷﻛل اﻟﻣطﻠوب وﻣطﺎﺑﻘﺔ ﻟﮭﯾﻛﻠﯾﺔ اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ وﻟﻛﻲ ﺗﺗﺄﻛد ﻣن ﻣوﻗﻌﮭﺎ ﻗﺑل أن ﺗﻐﻠق ﻗوس‬
                                            ‫اﻟﻌﺑﺎرة اﻟﺗﻛرارﯾﺔ اﻟﺧﺎﺻﺔ ﺑﺎﻟﻌداد )‪ (i‬ﺿﻌﮭﺎ ﻓﻲ ﻛل ﺑرﻧﺎﻣﺞ‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                       ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                               ‫ﻣﺛﺎل:ﺑرﻧﺎﻣﺞ ﻟﺟﻣﻊ ﻣﺻﻔوﻓﺗﯾن ﺣﺟﻣﮭﻣﺎ )3*3(‬
 ‫ﺗﺣﻠﯾل:ﻟﺟﻣﻊ ﻣﺻﻔوﻓﺗﯾن ﻧﺟﻣﻊ اﻟﻌﻧﺻر اﻷول ﺑﺎﻟﻣﺻﻔوﻓﺔ اﻷوﻟﻰ ﻣﻊ اﻟﻌﻧﺻر اﻷول ﻓﻲ اﻟﻣﺻﻔوﻓﺔ اﻟﺛﺎﻧﯾﺔ وﻛذاﻟك اﻟﺑﻘﯾﺔ‬

             ‫ﻣﺻﻔوﻓﺔ ‪a‬‬                            ‫ﻣﺻﻔوﻓﺔ ‪b‬‬                                   ‫ﻣﺻﻔوﻓﺔ ‪c‬‬

 ‫)0,0(‬    ‫)1,0(‬      ‫)2,0(‬             ‫)0,0(‬    ‫)1,0(‬         ‫)2,0(‬               ‫)0,0(‬    ‫)1,0(‬       ‫)2,0(‬
 ‫)0,1(‬    ‫)1,1(‬      ‫)2,1(‬             ‫)0,1(‬    ‫)1,1(‬         ‫)2,1(‬               ‫)0,1(‬    ‫)1,1(‬       ‫)2,1(‬
 ‫)0,2(‬    ‫)1,2(‬      ‫)2,2(‬             ‫)0,2(‬    ‫)1,2(‬         ‫)2,2(‬               ‫)0,2(‬    ‫)1,2(‬       ‫)2,2(‬


                                                               ‫+‬

                                           ‫ھذا اﻟﺷﻛل ﯾﻣﺛل ﺟﻣﻊ اﻟﻣوﻗﻊ اﻷول واﻟﻣواﻗﻊ اﻟﺑﻘﯾﺔ ﻧﻔس اﻟﺷﻲء اﻟﺛﺎﻧﻲ ﻣﻊ اﻟﺛﺎﻧﻲ وﺑﺎﻟﺗﺗﺎﺑﻊ‬

 ‫++‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                         ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                       ‫)(‪main‬‬
 ‫;‪{ 1.int i,j‬‬                                                 ‫;‪{ 1.int i,j‬‬
 ‫;]3[]3[‪2.int a‬‬                                               ‫;]3[]3[‪2.int a‬‬
 ‫;]3[]3[‪3.int b‬‬                                               ‫;]3[]3[‪3.int b‬‬
 ‫;]3[]3[‪4. int c‬‬                                              ‫;]3[]3[‪4. int c‬‬
 ‫;"‪5.cout<<"enter first matrixs\n‬‬                             ‫;)"‪5.printf("enter first matrixs\n‬‬
 ‫)++‪6. for(i=0;i<3;i‬‬                                          ‫)++‪6. for(i=0;i<3;i‬‬
 ‫)++‪7.for(j=0;j<3;j‬‬                                           ‫)++‪7.for(j=0;j<3;j‬‬
 ‫;]‪8.cin>>a[i][j‬‬                                              ‫;)]‪8.scanf("%d",&a[i][j‬‬
 ‫;"‪9. cout<<"enter second matrixs\n‬‬                           ‫;)"‪9. printf("enter second matrixs\n‬‬
 ‫)++‪10.for(i=0;i<3;i‬‬                                          ‫)++‪10.for(i=0;i<3;i‬‬
 ‫)++‪11.for(j=0;j<3;j‬‬                                          ‫)++‪11.for(j=0;j<3;j‬‬
 ‫;]‪12. cin>>b[i][j‬‬                                            ‫;)]‪12. scanf("%d",&b[i][j‬‬
 ‫{)++‪13.for(i=0;i<3;i‬‬                                         ‫{)++‪13.for(i=0;i<3;i‬‬
 ‫{)++‪14. for(j=0;j<3;j‬‬                                        ‫{)++‪14. for(j=0;j<3;j‬‬
 ‫;]‪15.c[i][j]=a[i][j]+b[i][j‬‬                                  ‫;]‪15.c[i][j]=a[i][j]+b[i][j‬‬
 ‫};"‪16.cout<<c[i][j]<<"\t‬‬                                     ‫};)]‪16. printf("%d\t",c[i][j‬‬
 ‫}};"‪17.cout<<"\n‬‬                                             ‫}};)"‪17. printf("\n‬‬
                                                                                                         ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

    ‫١.ﺧطوة رﻗم )٦ و٧ و٨( ھﻲ ﻋﻣﻠﯾﺔ إدﺧﺎل ﻟﻠﻣﺻﻔوﻓﺔ اﻷوﻟﻰ .ﺧطوة رﻗم)٠١ و١١و٢١( إدﺧﺎل اﻟﻣﺻﻔوﻓﺔ اﻟﺛﺎﻧﯾﺔ‬

 ‫٢.ﺧطوة ﺧطوة رﻗم)٣١ و٤١( ھوا ﻋدادا ﯾﻣر ﻋﻠﻰ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺻف ﺻف ﻟﯾﺟﻣﻊ ﻓﻲ ﺧطوة رﻗم)٥١(‬
                 ‫اﻟﻌﻧﺻر اﻷول ﻓﻲ اﻟﻣﺻﻔوﻓﺔ اﻷوﻟﻰ ﻣﻊ اﻟﻌﻧﺻر اﻷول ﺑﺎﻟﻣﺻﻔوﻓﺔ اﻟﺛﺎﻧﯾﺔ واﻟﺛﺎﻧﻲ ﺑﺎﻟﺛﺎﻧﻲ ﺑﺎﻟﺗﺗﺎﺑﻊ‬

                                                                   ‫٣.ﺧطوة رﻗم )٦١( ھو ﻋﻣﻠﯾﺔ طﺑﺎﻋﺔ ﻟﻌﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬



                                          ‫ﻋﻣﻠﯾﺔ طرح ﻣﺻﻔوﻓﺗﯾن ﻧﻔس اﻟﺧطوات اﻟﺳﺎﺑﻘﺔ ﻓﻘط ﻧﺑدل ﺧطوة )٥١( ﺑﺎﻟﺗﺎﻟﻲ‬

                                                                                                               ‫اﻟﺑرﻣﺟﺔ‬
         ‫;]‪15.c[i][j]=a[i][j]-b[i][j‬‬


  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                              ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                           ‫ﻣﺛﺎل:ﺑرﻧﺎﻣﺞ ﻟﺿرب ﻣﺻﻔوﻓﺗﯾن )4*2(* )2*3( .؟‬

          ‫ﺗﺣﻠﯾل:ﻟﺿرب ﻣﺻﻔوﻓﺗﯾن )4*2(* )2*3( ﯾﺟب أن ﯾﻛون اﻟﻧﺎﺗﺞ ﻣﺻﻔوﻓﺔ ﺑﺣﺟم )4*3( ﺣﺳب ﻗواﻋد اﻟﺿرب‬

       ‫ﻣﺻﻔوﻓﺔ ‪a‬‬                                                                                        ‫ﻣﺻﻔوﻓﺔ ‪c‬‬
                                            ‫ﻣﺻﻔوﻓﺔ ‪b‬‬
 ‫)0,0(‬     ‫)1,0(‬              ‫)0,0(‬    ‫)1,0(‬         ‫)2,0(‬         ‫)3,0(‬                ‫)0,0(‬     ‫)1,0(‬      ‫)2,0(‬        ‫)3,0(‬
 ‫)0,1(‬     ‫)1,1(‬              ‫)0,1(‬    ‫)1,1(‬         ‫)2,1(‬         ‫)3,1(‬                ‫)0,1(‬     ‫)1,1(‬      ‫)2,1(‬        ‫)3,1(‬
 ‫)0,2(‬     ‫)1,2(‬                                                                        ‫)0,2(‬     ‫)1,2(‬      ‫)2,2(‬        ‫)3,2(‬


                                            ‫*‬
                                                                              ‫+‬
                                                                                       ‫ﺑﮭذا اﻟﺷﻛل ﺣﺻﻠﻧﺎ ﻋﻠﻰ أول ﻗﯾﻣﺔ وﻛذاﻟك اﻟﺑﻘﯾﺔ‬
                                        ‫*‬
 ‫++‪c‬‬                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                              ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                            ‫)(‪main‬‬
 ‫;‪{1.int i,j,k‬‬                                                     ‫;‪{1.int i,j,k‬‬
 ‫;]2[]3[‪2. int a‬‬                                                   ‫;]2[]3[‪2. int a‬‬
 ‫;]4[]2[‪3.int b‬‬                                                    ‫;]4[]2[‪3.int b‬‬
 ‫‪4. int c[3][4]={0}; //put zero in every location‬‬                  ‫‪4. int c[3][4]={0}; //put zero in every location‬‬
 ‫; "‪5.cout<<"enter first matrixs\n‬‬                                 ‫; )"‪5. printf("enter first matrixs\n‬‬
 ‫)++‪6. for(i=0;i<3;i‬‬                                               ‫)++‪6. for(i=0;i<3;i‬‬
 ‫)++‪7.for(j=0;j<2;j‬‬                                                ‫)++‪7.for(j=0;j<2;j‬‬
 ‫;]‪8.cin>>a[i][j‬‬                                                   ‫;)]‪8. scanf("%d",&a[i][j‬‬
 ‫; "‪9.cout<<"enter second matrixs\n‬‬                                ‫; )"‪9.prin ("enter second matrixs\n‬‬
 ‫)++‪10. for(i=0;i<2;i‬‬                                              ‫)++‪10. for(i=0;i<2;i‬‬
 ‫)++‪11.for(j=0;j<4;j‬‬                                               ‫)++‪11.for(j=0;j<4;j‬‬
 ‫;]‪12.cin>>b[i][j‬‬                                                  ‫;)]‪12. scanf("%d",&b[i][j‬‬
 ‫{)++‪13.for(i=0;i<3;i‬‬                                              ‫{)++‪13.for(i=0;i<3;i‬‬
 ‫{)++‪14.for(j=0;j<4;j‬‬                                              ‫{)++‪14.for(j=0;j<4;j‬‬
 ‫)++‪15.for(k=0;k<2;k‬‬                                               ‫)++‪15.for(k=0;k<2;k‬‬
 ‫;]‪16.c[i][j]+=a[i][k]*b[k][j‬‬                                      ‫;]‪16.c[i][j]+=a[i][k]*b[k][j‬‬
 ‫}; "‪17. cout<<c[i][j]<<"\t‬‬                                        ‫};)]‪17. prin ("%d\t",c[i][j‬‬
 ‫} };"‪18.cout<<"\n‬‬                                                 ‫} };)"‪18.prin ("\n‬‬
                                                                                        ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
   ‫١.ﺧطوة رﻗم)٤( ﻋرﻓﻧﺎ ﻣﺻﻔوﻓﺔ ووﺿﻌﻧﺎ ﺻﻔر ﻓﻲ ﺟﻣﯾﻊ ﻣواﻗﻌﮭﺎ ﻷﻧﻧﺎ ﺳﻧﺧزن ﻓﺳﮭﺎ ﻧﺗﯾﺟﺔ اﻟﺿرب وﻛﻣﺎ ﺗرى ﻓﻲ‬
    ‫اﻟﻣﺧطط ﯾﺿرب ﺛم ﯾﺟﻣﻊ أي ﺗوﺟد ﻋﻣﻠﯾﺔ ﺟﻣﻊ أﻛﺛر ﻣن ﻣرة ﻟذاﻟك ﯾﺟب ﺗﺻﻔﯾر اﻟﻣواﻗﻊ ﺣﺗﻰ ﻻ ﺗؤﺛر ﻋﻠﻰ اﻟﺟﻣﻊ‬
  ‫٢.ﺧطوة رﻗم )٣١ و٤١( ھوا اﻟﺗﺣرك ﺑﺑﻌد اﻟﻣﺻﻔوﻓﺔ اﻟﺟدﯾدة وھﻲ ﺑﺣﺟم )4*3( وﺑﻌدھﺎ ﺧطوة رﻗم )٥١( ھوا اﻟﺑﻌد‬
                                ‫اﻟﻣﻔﻘود اﻟذي ﺳﯾﻔﻘد ﻓﻲ ﻋﻣﻠﯾﺔ اﻟﺿرب وﺧطوة رﻗم )٦١( ھو ﻛﻣﺎ ﻣوﺿﺢ ﻓﻲ اﻟﻣﺧطط‬
‫أي إﻧﻧﺎ ﻣﺗﻰ ﻣﺎ ﺟﺎءﺗﻧﺎ ﻋﻣﻠﯾﺔ ﺿرب ﻣﺻﻔوﻓﺗﯾن ﻧﺄﺧذ ﻋدادان ﺑﺄﺑﻌﺎد ﻣﺻﻔوﻓﺔ ﻧﺎﺗﺟﺔ وﻋداد ﺑﺎﻟﺑﻌد اﻟﻣﻔﻘود وﺑﻌدھﺎ ﺧطوة‬
           ‫رﻗم)٦١( أي ﻟو ﺿرﺑﻧﺎ اﻟﻣﺻﻔوﻓﺎت اﻟﺗﺎﻟﯾﺔ )3*6(*)6*4( وﻧﺎﺗﺞ ﯾﻛون ﻣﺻﻔوﻓﺔ)3*4( واﻟﺑﻌد اﻟﻣﻔﻘود )6(‬
                                                                                                                      ‫اﻟﺑرﻣﺟﺔ‬
         ‫{)++‪13.for(i=0;i<4;i‬‬                                                                                                       ‫ﻣﮭم‬
         ‫{)++‪14.for(j=0;j<3;j‬‬
         ‫)++‪15.for(k=0;k<6;k‬‬
         ‫]‪16.c[i][j]+=a[i][k]*b[k][j‬‬



  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                            ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                      ‫٤.٤- ﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ اﻷﺑﻌﺎد:‬
    ‫ﻻ ﯾﺧﺗﻠف ﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ ﻋن ﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺎت اﻷﺣﺎدﯾﺔ ﻓﻲ ﺷﻲء ﻧﻔس اﻟﺻﯾﻐﺔ ﻧﺄﺧذ أول ﻋﻧﺻر ﻓﻲ‬
            ‫اﻟﻣﺻﻔوﻓﺔ وﻧﻘﺎرﻧﮫ ﻣﻊ ﺑﻘﯾﺔ اﻟﻌﻧﺎﺻر واﻟﺛﺎﻧﻲ وﺑﺎﻟﺗﺗﺎﻟﻲ ﻟذاﻟك راﺟﻊ ﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺎت اﻷﺣﺎدﯾﺔ أوﻻ ...‬

                                                                     ‫ﻣﺛﺎل: ﺗﺮﺗﯿﺐ ﻣﺼﻔﻮﻓﺔ ﺛﻨﺎﺋﯿﺔ اﻹﺑﻌﺎد )5*5( ﺗﺮﺗﯿﺐ ﺗﻨﺎزﻟﯿﺎ‬

 ‫++‪c‬‬                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                            ‫>‪#include<stdio.h‬‬
 ‫)(‪int main‬‬                                                      ‫)(‪int main‬‬
 ‫;5=‪{1.int const row‬‬                                             ‫;5=‪{1.int const row‬‬
 ‫;5=‪2.int const col‬‬                                              ‫;5=‪2.int const col‬‬
 ‫;]‪3. int array[row][col‬‬                                         ‫;]‪3. int array[row][col‬‬
 ‫; ‪4.int i,j,k,x,l‬‬                                               ‫; ‪4.int i,j,k,x,l‬‬
 ‫; "‪5.cout<<"Here is the Array befor sorted\n‬‬                    ‫;)"‪5.printf("Here is the Array befor sorted\n‬‬
 ‫)++‪6. for ( i=0;i<row;i‬‬                                         ‫)++‪6. for ( i=0;i<row;i‬‬
 ‫)++‪7. for ( j=0;j<col;j‬‬                                         ‫)++‪7. for ( j=0;j<col;j‬‬
 ‫; ]‪8.cin>>array[i][j‬‬                                            ‫;)]‪8.scanf("%d",&array[i][j‬‬
 ‫{)++‪9.for( k=0;k<row;k‬‬                                          ‫{)++‪9.for( k=0;k<row;k‬‬
 ‫{)++‪10. for( l=0;l<col;l‬‬                                        ‫{)++‪10. for( l=0;l<col;l‬‬
 ‫{)++‪11. for( i=0;i<row;i‬‬                                        ‫{)++‪11. for( i=0;i<row;i‬‬
 ‫{)++‪12. for ( j=0;j<col;j‬‬                                       ‫{)++‪12. for ( j=0;j<col;j‬‬
 ‫{)]‪13. if (array[i][j] < array[k][l‬‬                             ‫{)]‪13. if (array[i][j] < array[k][l‬‬
 ‫;]‪14.x=array[k][l‬‬                                               ‫;]‪14.x=array[k][l‬‬
 ‫;]‪15.array[k][l]=array[i][j‬‬                                     ‫;]‪15.array[k][l]=array[i][j‬‬
 ‫;‪16.array[i][j]=x‬‬                                               ‫;‪16.array[i][j]=x‬‬
 ‫} }} }}.71‬                                                      ‫} }} }}.71‬
 ‫; "‪18. cout<<"Here is the Array after sorted\n‬‬                  ‫;)"‪18.printf("Here is the Array after sorted\n‬‬
 ‫{)++‪19. for ( i=0;i<row;i‬‬                                       ‫{)++‪19. for ( i=0;i<row;i‬‬
 ‫)++‪20. for ( j=0;j<row;j‬‬                                        ‫)++‪20. for ( j=0;j<row;j‬‬
 ‫;"‪21. cout<<array[i][j]<<"\t‬‬                                    ‫;)]‪21.printf("%d\t",array[i][j‬‬
 ‫} }; "‪22. cout<<"\n‬‬                                             ‫} };)"‪22.printf("\n‬‬
                                                                                                             ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                                                                                                      ‫ﻣﮭم‬
‫١.ﺧطوة رﻗم )١و٢( ھو اﻹﻋﻼن ﻋن أﺑﻌﺎد اﻟﻣﺻﻔوﻓﺔ وھذه اﻟﺻﯾﻐﺔ ﻣﮭﻣﺔ ﺟدا ﻟﻠﻣطور ﻓﻔﻲ اﻟﺑراﻣﺞ اﻟﺳﺎﺑﻘﺔ ﻟو أردت‬
       ‫ﻓﻘط ﻧﻔس اﻟﻣﺛﺎل ﻓﻘط ﺗﻐﯾر أﺑﻌﺎد اﻟﻣﺻﻔوﻓﺔ ﻟﻛﻧت ﺑﺣﺎﺟﺔ ﻟﺗﻐﯾر ﺑﻌد اﻟﻣﺻﻔوﻓﺔ وﺷروط ﺗوﻗف اﻟﻌدادات ﻓﻲ ﻛل‬
        ‫اﻟﺧطوات أﻣﺎ ھﻧﺎ إذا أردﻧﺎ أن ﻧﻐﯾر ﺑﻌد اﻟﻣﺻﻔوﻓﺔ ﻣﺛﻼ ﻗﺎل رﺗب ﻣﺻﻔوﻓﺔ )4*4( ﻓﻘط ﻧﻐﯾر ﻗﯾﻣﺔ )4=‪(row‬‬
                                                      ‫و)4=‪ (col‬وﯾﺗﺣول اﻟﺳؤال ﻛﻠﮫ ﻛﻣﺎ ﻧرﯾد ﺑدون أي ﺧطﺎء‬

 ‫٢.ﺧطوة رﻗم)٩ و٠١( ﻋدادان ﯾﻣران ﻋﻠﻰ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻟﻛﻲ ﯾﻘﺎرن ﻛل ﻋﻧﺻر ﺑﺟﻣﯾﻊ اﻟﻌﻧﺎﺻر اﻟﺗﻲ ﺗﻠﯾﮫ‬
                                                                 ‫ﺑواﺳطﺔ اﻟﻌدادان ﻓﻲ اﻟﺧطوة )١١و٢١(‬

                   ‫٣.ﺧطوة رﻗم)٣١ و٤١و٥١و٦١( ھﻲ ﻋﻣﻠﯾﺔ أﺑدال ﺑﯾن ﻣوﻗﻌﯾن ﺷرﺣت ﺳﺎﺑﻘﺎ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ اﻷﺣﺎدﯾﺔ‬

                                                            ‫٤.ﺧطوة رﻗم)٩١ و٠٢و١٢و٢٢(طﺑﺎﻋﺔ ﻟﻠﻣﺻﻔوﻓﺔ ﺑﻌد اﻟﺗرﺗﯾب‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                             ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                         ‫ﻣﺛﺎل: ﺗﺮﺗﯿﺐ ﺻﻔﻮف ﻣﺼﻔﻮﻓﺔ ﺛﻨﺎﺋﯿﺔ اﻹﺑﻌﺎد )5*5( ﺗﺮﺗﯿﺐ ﺗﻨﺎزﻟﯿﺎ‬
‫ﯾﻘﺎرن ﻋﻧﺎﺻر اﻟﺻف اﻟواﺣد ﻟﯾرﺗﺑﮭﺎ ١.اﻷول ﻣﻊ اﻟﺟﻣﯾﻊ‬



                                                                                 ‫ﺗﺣﻠﯾل:ﻟﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺔ ﻛل ﺻف‬
        ‫)0,0(‬           ‫)1,0(‬            ‫)2,0(‬            ‫)3,0(‬           ‫)4,0(‬
        ‫)0,1(‬           ‫)1,1(‬            ‫)2,1(‬            ‫)3,1(‬             ‫ﻋﻠﻰ ﺣدة ﻧﺣن ﺑﺣﺎﺟﺔ ﻟﻌداد ﺧﺎرﺟﻲ ﯾﻘف‬
                                                                          ‫)4,1(‬
        ‫)0,2(‬           ‫)1,2(‬            ‫)2,2(‬            ‫)3,2(‬           ‫)4,2(‬ ‫ﻋﻠﻰ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺻف ﺻف‬
        ‫)0,3(‬           ‫)1,3(‬            ‫)2,3(‬            ‫)3,3(‬           ‫)4,3(‬‫وﻟﯾﻛن اﺳﻣﮫ)‪ (k‬وﯾﺑدأ ﺑﺗرﺗﯾب ﻋﻧﺎﺻر‬
        ‫)0,4(‬           ‫)1,4(‬            ‫)2,4(‬            ‫)3,4(‬           ‫)4,4(‬
                                                                            ‫اﻟﺻف اﻟواﺣد ﺑﻣﻘﺎرﻧﺔ اﻟﻌﻧﺻر اﻷول ﻣﻊ‬
                  ‫ﺟﻣﯾﻊ اﻟﻌﻧﺎﺻر اﻟﺗﻲ ﺗﻠﯾﮫ ﻓﻲ اﻟﺻف اﻟذي ﻋﻠﯾﮫ اﻟﻣؤﺷر اﻟﻌداد ﺛم ﺑﻌد أن ﯾرﺗﺑﮫ ﯾﻧﺗﻘل إﻟﻰ اﻟﺻف اﻟﺗﺎﻟﻲ.‬
    ‫ﻋﻧدﻣﺎ ﯾﻛون اﻟﺗرﺗﯾب ﻋﻠﻰ اﻟﺻف اﻷول )0=‪(k‬‬


 ‫++‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                             ‫>‪#include<stdio.h‬‬
 ‫)(‪int main‬‬                                                       ‫)(‪int main‬‬
 ‫;5=‪{1.int const row‬‬                                              ‫;5=‪{1.int const row‬‬
 ‫;5=‪2. int const col‬‬                                              ‫;5=‪2. int const col‬‬
 ‫;]‪3.int array[row][col‬‬                                           ‫;]‪3.int array[row][col‬‬
 ‫; ‪4.int i,j,k,x‬‬                                                  ‫; ‪4.int i,j,k,x‬‬
 ‫; "‪5.cout<<"Here is the Array befor sorted\n‬‬                     ‫;)"‪5.printf("Here is the Array befor sorted\n‬‬
 ‫)++‪6. for ( i=0;i<row;i‬‬                                          ‫)++‪6. for ( i=0;i<row;i‬‬
 ‫)++‪7. for ( j=0;j<col;j‬‬                                          ‫)++‪7. for ( j=0;j<col;j‬‬
 ‫; ]‪8.cin>>array[i][j‬‬                                             ‫;)]‪8.scanf("%d",&array[i][j‬‬
 ‫)++‪9.for( k=0;k<row;k‬‬                                            ‫)++‪9.for( k=0;k<row;k‬‬
 ‫)++‪10.for( i=0;i<row;i‬‬                                           ‫)++‪10.for( i=0;i<row;i‬‬
  ‫{)++‪11.for ( j=0;j<col;j‬‬                                         ‫{)++‪11.for ( j=0;j<col;j‬‬
 ‫{)]‪12. if (array[k][j] <array[k][i‬‬                               ‫{)]‪12. if (array[k][j] <array[k][i‬‬
 ‫;]‪13. x=array[k][j‬‬                                               ‫;]‪13. x=array[k][j‬‬
 ‫;]‪14.array[k][j]=array[k][i‬‬                                      ‫;]‪14.array[k][j]=array[k][i‬‬
 ‫}};‪15.array[k][i]=x‬‬                                              ‫}};‪15.array[k][i]=x‬‬
 ‫; "‪16. cout<<"Here is the Array after sorted\n‬‬                   ‫;)"‪16.printf("Here is the Array after sorted\n‬‬
 ‫{)++‪17.for ( i=0;i<row;i‬‬                                         ‫{)++‪17.for ( i=0;i<row;i‬‬
 ‫)++‪18. for ( j=0;j<row;j‬‬                                         ‫)++‪18. for ( j=0;j<row;j‬‬
 ‫;"‪19. cout<<array[i][j]<<"\t‬‬                                     ‫;)]‪19.printf("%d\t",array[i][j‬‬
 ‫} }; "‪20.cout<<"\n‬‬                                               ‫} };)"‪20.printf("\n‬‬

                                                                                                                               ‫ﻣﮭم‬

                                                                                      ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                                                                 ‫ﻣﺎذا ﺳﯾﺣﺻل ﻓﻲ ﺧطوة رﻗم)51—9(...؟‬
  ‫ﻛﯾف رﺗﺑﻧﺎ ﺻﻔوف اﻟﻣﺻﻔوﻓﺔ؟ﻧﺟد اﻧﮫ ﯾﻘوم ﺑﻣﻘﺎرﻧﺔ ﻋﻧﺎﺻر اﻟﺻف اﻟواﺣد ﯾﺑﻌﺿﮭﺎ وﺗرﺗﯾﺑﮭﺎ ﺣﯾث أن اﻟﻣﺗﻐﯾر )‪( k‬‬
    ‫ﯾﻧﺗﻘل ﻓﻲ ﻛل ﻟوب إﻟﻰ ﺻف ﺟدﯾد ﺑﻌد أن ﯾﻧﺗﮭﻲ ﻣن ﺗرﺗﯾب اﻟﺻف اﻟذي ﯾﺳﺑﻘﮫ وﻓﻲ اﻟﻣﻘﺎرﻧﺔ ﺧطوة رﻗم)٢١( ﻧﺛﺑت‬
 ‫اﻟﺻف ﺑﯾن اﻟﻣﺻدر واﻟﻣﺳﺎر اﻟﺗرﺗﯾﺑﻲ وﻧﻧﻘل اﻟﻌداد اﻟﺧﺎرﺟﻲ)‪ ( i‬ﻓﻲ ﻛل ﻟوب إﻟﻰ ﻋﻣود ﺟدﯾد ﺿﻣن اﻟﺻف اﻟواﺣد‬
   ‫وﯾﻌﻣل اﻟﻌداد اﻟداﺧﻠﻲ )‪(j‬ﻋﻠﻰ ﻣﻘﺎرﻧﺔ ھذا اﻟﻌﺻر اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ )‪ ( i‬ﻓﻲ اﻟﺻف اﻟواﺣد ﺑﻛل اﻟﻌﻧﺎﺻر ﻓﻲ اﻷﻋﻣدة‬
                                                     ‫اﻟﺗﻲ ﺗﻠﯾﮫ ﻓﻲ ﻧﻔس اﻟﺻف ﻓﺈذا وﺟد ﻓﯾﮭﺎ اﺻﻐر ﻣﻧﮫ ﯾﺑدﻟﮫ‬
‫أﺗﻣﻧﻰ أن ﺗﻛون ﻗد اﺳﺗوﻋﺑت اﻟﻔﻛرة )اﺑوﻣﺷﺎري(‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                            ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                               ‫ﻣﺛﺎل: ﺗﺮﺗﯿﺐ أﻋﻤﺪة ﻣﺼﻔﻮﻓﺔ ﺛﻨﺎﺋﯿﺔ اﻹﺑﻌﺎد )5*5( ﺗﺮﺗﯿﺐ ﺗﻨﺎزﻟﯿﺎ‬
 ‫ﯾﻘﺎرن ﻋﻧﺎﺻر اﻟﻌﻣود اﻟواﺣد ﻟﯾرﺗﺑﮭﺎ ١.اﻷول ﻣﻊ اﻟﺟﻣﯾﻊ‬



                                                                                      ‫ﺗﺣﻠﯾل:ﻟﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺔ ﻛل ﻋﻣود‬
         ‫)0,0(‬            ‫)1,0(‬             ‫)2,0(‬            ‫)3,0(‬           ‫)4,0(‬
         ‫)0,1(‬            ‫)1,1(‬             ‫)2,1(‬            ‫)3,1(‬              ‫ﻋﻠﻰ ﺣدة ﻧﺣن ﺑﺣﺎﺟﺔ ﻟﻌداد ﺧﺎرﺟﻲ ﯾﻘف‬
                                                                             ‫)4,1(‬
         ‫)0,2(‬            ‫)1,2(‬             ‫)2,2(‬            ‫)3,2(‬           ‫)4,2(‬  ‫ﻋﻠﻰ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻋﻣود ﻋﻣود‬
         ‫)0,3(‬            ‫)1,3(‬             ‫)2,3(‬            ‫)3,3(‬               ‫وﻟﯾﻛن اﺳﻣﮫ )‪ (k‬وﯾﺑدأ ﺑﺗرﺗﯾب ﻋﻧﺎﺻر‬
                                                                             ‫)4,3(‬
         ‫)0,4(‬            ‫)1,4(‬             ‫)2,4(‬            ‫)3,4(‬           ‫)4,4(‬
                                                                                ‫اﻟﻌﻣود اﻟواﺣد ﺑﻣﻘﺎرﻧﺔ اﻟﻌﻧﺻر اﻷول ﻣﻊ‬
                    ‫ﺟﻣﯾﻊ اﻟﻌﻧﺎﺻر اﻟﺗﻲ ﺗﻠﯾﮫ ﻓﻲ اﻟﻌﻣود اﻟذي ﻋﻠﯾﮫ اﻟﻣؤﺷر اﻟﻌداد ﺛم ﺑﻌد إن ﯾرﺗﺑﮫ ﯾﻧﺗﻘل إﻟﻰ اﻟﻌﻣود اﻟﺗﺎﻟﻲ.‬
     ‫ﻋﻧدﻣﺎ ﯾﻛون اﻟﺗرﺗﯾب ﻋﻠﻰ اﻟﻌﻣود اﻷول )0=‪(k‬‬


 ‫++‪c‬‬                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                                ‫>‪#include<stdio.h‬‬
 ‫)(‪int main‬‬                                                          ‫)(‪int main‬‬
 ‫;5=‪{1.int const row‬‬                                                 ‫;5=‪{1.int const row‬‬
 ‫;5=‪2. int const col‬‬                                                 ‫;5=‪2. int const col‬‬
 ‫;]‪3.int array[row][col‬‬                                              ‫;]‪3.int array[row][col‬‬
 ‫; ‪4.int i,j,k,x,l‬‬                                                   ‫; ‪4.int i,j,k,x,l‬‬
 ‫; "‪5.cout<<"Here is the Array befor sorted\n‬‬                        ‫;)"‪5.printf("Here is the Array befor sorted\n‬‬
 ‫)++‪6.for ( i=0;i<row;i‬‬                                              ‫)++‪6.for ( i=0;i<row;i‬‬
 ‫)++‪7. for ( j=0;j<col;j‬‬                                             ‫)++‪7. for ( j=0;j<col;j‬‬
 ‫; ]‪8.cin>>array[i][j‬‬                                                ‫;)]‪8.scanf("%d",&array[i][j‬‬
 ‫)++‪9. for( k=0;k<row;k‬‬                                              ‫)++‪9. for( k=0;k<row;k‬‬
 ‫)++‪10.for( i=0;i<row;i‬‬                                              ‫)++‪10.for( i=0;i<row;i‬‬
 ‫{ )++‪11. for ( j=0;j<col;j‬‬                                          ‫{ )++‪11. for ( j=0;j<col;j‬‬
 ‫{)]‪12. if (array[j][k] <array[i][k‬‬                                  ‫{)]‪12. if (array[j][k] <array[i][k‬‬
 ‫;]‪13. x=array[j][k‬‬                                                  ‫;]‪13. x=array[j][k‬‬
 ‫;]‪14.array[j][k]=array[i][k‬‬                                         ‫;]‪14.array[j][k]=array[i][k‬‬
 ‫}};‪15.array[i][k]=x‬‬                                                 ‫}};‪15.array[i][k]=x‬‬
 ‫; "‪16. cout<<"Here is the Array after sorted\n‬‬                      ‫;)"‪16.printf("Here is the Array after sorted\n‬‬
 ‫{)++‪17.for ( i=0;i<row;i‬‬                                            ‫{)++‪17.for ( i=0;i<row;i‬‬
 ‫)++‪18. for ( j=0;j<row;j‬‬                                            ‫)++‪18. for ( j=0;j<row;j‬‬
 ‫;"‪19. cout<<array[i][j]<<"\t‬‬                                        ‫;)]‪19.printf("%d\t",array[i][j‬‬
 ‫}}; "‪20. cout<<"\n‬‬                                                  ‫}};)"‪20.printf("\n‬‬

                                                                                                  ‫ﻣﮭم‬
                                                                                        ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                                                                  ‫ﻣﺎذا ﺳﯾﺣﺻل ﻓﻲ ﺧطوة رﻗم)51—9(...؟‬
  ‫ﻛﯾف رﺗﺑﻧﺎ أﻋﻣدة اﻟﻣﺻﻔوﻓﺔ؟ﻧﺟد اﻧﮫ ﯾﻘوم ﺑﻣﻘﺎرﻧﺔ ﻋﻧﺎﺻر اﻟﻌﻣود اﻟواﺣد ﯾﺑﻌﺿﮭﺎ وﺗرﺗﯾﺑﮭﺎ ﺣﯾث أن اﻟﻣﺗﻐﯾر )‪( k‬‬
 ‫ﯾﻧﺗﻘل ﻓﻲ ﻛل ﻟوب إﻟﻰ ﻋﻣود ﺟدﯾد ﺑﻌد أن ﯾﻧﺗﮭﻲ ﻣن ﺗرﺗﯾب اﻟﻌﻣود اﻟذي ﯾﺳﺑﻘﮫ. وﻓﻲ اﻟﻣﻘﺎرﻧﺔ ﺧطوة رﻗم)٢١( ﻧﺛﺑت‬
‫اﻟﻌﻣود ﺑﯾن اﻟﻣﺻدر واﻟﻣﺳﺎر اﻟﺗرﺗﯾﺑﻲ وﻧﻧﻘل اﻟﻌداد اﻟﺧﺎرﺟﻲ)‪ ( i‬ﻓﻲ ﻛل ﻟوب إﻟﻰ ﺻف ﺟدﯾد ﺿﻣن اﻟﻌﻣود اﻟواﺣد‬
‫وﯾﻌﻣل اﻟﻌداد اﻟداﺧﻠﻲ )‪ (j‬ﻋﻠﻰ ﻣﻘﺎرﻧﺔ ھذا اﻟﻌﻧﺻر اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ )‪ ( i‬ﻓﻲ اﻟﻌﻣود اﻟواﺣد ﺑﻛل اﻟﻌﻧﺎﺻر ﻓﻲ اﻟﺻﻔوف‬
                                     ‫اﻟﺗﻲ ﺗﻠﯾﮫ ﻓﻲ ﻧﻔس اﻟﻌﻣود اﻟذي ﻋﻠﯾﮫ اﻟﻣؤﺷر ﻓﺈذا وﺟد ﻓﯾﮭﺎ اﺻﻐر ﻣﻧﮫ ﯾﺑدﻟﮫ‬

                                              ‫*ﻟو أردﻧﺎ ﺗرﺗﯾب ﺗﺻﺎﻋدي ﻓﻘط ﻧﺑدل ﻋﻼﻣﺔ اﻷﺻﻐر ﻓﻲ ﺷرط اﻟﻣﻘﺎرﻧﺔ إﻟﻰ اﻛﺑر‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                               ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                              ‫٥.٤- اﻟﻧﺻوص )‪:(string‬‬
                                                      ‫١. ﺗﻣﺛﯾﻠﮭﺎ ﺑﺎﻟﻣﺻﻔوﻓﺎت اﻷﺣﺎدﯾﺔ اﻷﺑﻌﺎد:‬
   ‫ھﻲ ﻣﺻﻔوﻓﺎت ﻣﻛوﻧﮫ ﻣن ﺳﻠﺳﻠﺔ ﻣن اﻟﺣروف وﺗﺧزن ﺑﻧﻔس طرﯾﻘﺔ اﻟﻣﺻﻔوﻓﺔ اﻻﻋﺗﯾﺎدﯾﺔ وﯾﺧزن ﺑﻌد أﺧر‬
                             ‫ﻣوﻗﻊ ﻧﺧزن ﻓﯾﮫ اﻟﻣﺻﻔوﻓﺔ اﻟﺣرف )'0\'( ﻟﻠدﻻﻟﺔ ﻋﻠﻰ أن اﻟﺳﻠﺳﻠﺔ اﻧﺗﮭت.‬
                ‫ﻟو أردﻧﺎ ﺗﻛوﯾن ﻣﺻﻔوﻓﺔ ﺣرﻓﯾﮫ اﺳﻣﮭﺎ)‪ (name‬ﻧﺧزن ﻓﯾﮭﺎ اﺳم ﺷﺧص وﻟﯾﻛن)‪(hussien‬‬

                                                                                                  ‫ھﯾﻛﻠﯾﺔ ﺗﻌرﯾف‬
        ‫;"‪Char name[8]="hussien‬‬

                                                           ‫أو ﺗﻛﺗب ھﻛذا ﻟﻛن ھﻧﺎ ﯾﺟب وﺿﻊ )'0\'( ﻓﻲ ﻧﮭﺎﯾﺔ اﻟﺳﻠﺳﻠﺔ‬

                                                                                                  ‫ھﯾﻛﻠﯾﺔ ﺗﻌرﯾف‬
        ‫;}'0\','‪Char name[8]={'h','u','s','s','i','e','n‬‬

 ‫ﻧﻼﺣظ إﻧﻧﺎ ﺣﺟزﻧﺎ ﺛﻣﺎﻧﯾﺔ ﻣواﻗﻊ ورﻏم أن اﻻﺳم ﻣﻛون ﻣن ﺳﺑﻌﺔ أﺣرف ﻷﻧﮫ ﻛﻣﺎ ﻗﻠﻧﺎ ﯾﺿﯾف )'0\'( إﻟﻰ ﻧﮭﺎﯾﺔ اﻟﺳﻠﺳﻠﺔ‬
                     ‫ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ اﻷﺣرف اﻟﺗﻲ أدﺧﻠﻧﺎھﺎ )أي داﺋﻣﺎ ﻧﺣﺟز ﺣﺟم اﻟﻣﺻﻔوﻓﺔ اﻛﺑر ﻣن ﻣﺎ ﻧﺣﺗﺎﺟﮫ ﺑواﺣد(‬

       ‫أي ﺳﻠﺳﺔ ﺗﺧزن ﻓﻲ اﻟذاﻛرة ﺑﺎﻟﺗﺳﻠﺳل أي أن ﻣﺻﻔوﻓﺔ ‪ name‬اﻟﺗﻲ ﺗﺣوي ﻋﻠﻰ "‪ "hussien‬ﺗﺧزن ھﻛذا إذا‬
              ‫اﻓﺗرﺿﻧﺎ اﻧﮫ أول ﻣوﻗﻊ ﯾﺧزن ﻓﯾﮫ أول ﺣرف ھوا )002( ﻛﻣﺎ ﻻﺣظت أن ﺑﻘﯾﺔ اﻷﺣرف ﯾﺧزﻧﮭم ﺑﺎﻟﺗﺗﺎﻟﻲ.‬
                            ‫]0[‪name‬‬        ‫]1[‪name‬‬    ‫]2[‪name‬‬       ‫]3[‪name‬‬   ‫]4[‪name‬‬   ‫]5[‪name‬‬        ‫]6[‪name‬‬
 ‫ﻋﻨﻮﻧﺔ اﻟﻤﺼﻔﻮﻓﺔ ﻣﻮاﻗﻊ‬
 ‫ﻋﻧوان اﻟﻣوﻗﻊ ﺧﻼﯾﺎ‬              ‫002‬           ‫102‬          ‫202‬        ‫302‬       ‫402‬        ‫502‬          ‫602‬      ‫702‬
‫اﻟﺬاﻛﺮة‬    ‫ﻣﺣﺗواه‬                ‫‪h‬‬             ‫‪u‬‬            ‫‪s‬‬          ‫‪s‬‬         ‫‪i‬‬          ‫‪e‬‬            ‫‪n‬‬        ‫0\‬
       ‫*ﻧﻌﻠم أن ﺗرﻗﯾم اﻟﻣﺻﻔوﻓﺔ ﻓﻲ ھذه اﻟﻠﻐﺔ ﯾﺑدءا ﻣن اﻟﺻﻔر أي أن ﺣرف )‪ (h‬ﯾﺧزن ﻓﻲ ﻣوﻗﻊ ﺻﻔر وﺣرف )‪ (i‬ﯾﺧزن ﻓﻲ ﻣوﻗﻊ ٤‬

                          ‫ﻟو أردﻧﺎ أن ﻧﺿﻊ ﺣرف )‪ (o‬ﺑدل ﺣرف )‪ (u‬وﺑﻣﺎ اﻧﮫ ﺛﺎﻧﻲ ﻣوﻗﻊ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻧﺧزﻧﮫ ھﻛذا‬

                                                                                                       ‫اﻟﺑرﻣﺟﺔ‬
        ‫;'‪name[1]='o‬‬


                            ‫]0[‪name‬‬        ‫]1[‪name‬‬    ‫]2[‪name‬‬       ‫]3[‪name‬‬   ‫]4[‪name‬‬   ‫]5[‪name‬‬        ‫]6[‪name‬‬
 ‫ﻋﻨﻮﻧﺔ اﻟﻤﺼﻔﻮﻓﺔ ﻣﻮاﻗﻊ‬
 ‫ﻋﻧوان اﻟﻣوﻗﻊ ﺧﻼﯾﺎ‬              ‫002‬           ‫102‬          ‫202‬        ‫302‬       ‫402‬        ‫502‬          ‫602‬      ‫702‬
‫اﻟﺬاﻛﺮة‬    ‫ﻣﺣﺗواه‬                ‫‪h‬‬             ‫‪o‬‬            ‫‪s‬‬          ‫‪s‬‬         ‫‪i‬‬          ‫‪e‬‬            ‫‪n‬‬        ‫0\‬


                       ‫ھذا اﻟﺣرف اﻟذي ﺗم أﺑداﻟﮫ‬
                                                       ‫‪ ‬اﻟﻣﻛﺗﺑﺔ اﻟﺗﻲ ﻧﺳﺗﺧدﻣﮭﺎ ﻣﻊ )‪ (string‬ھﻲ >‪<string.h‬‬



  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                         ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                                                                         ‫دوال اﻹدﺧﺎل واﻹﺧراج )‪:(string‬‬

    ‫ﻓﻲ ﺣﺎل إدﺧﺎل )‪ (string‬ﻣن ﻗﺑل اﻟﻣﺳﺗﺧدم .ﻋﺑﺎرات اﻹدﺧﺎل اﻻﻋﺗﯾﺎدﯾﺔ ﺗﻛون ﻏﯾر ﻛﺎﻓﯾﺔ ﻹدﺧﺎﻟﮭﺎ أو ﻏﯾر ﻣﻼﺋﻣﺔ‬
               ‫ﻟدرﺟﺔ %001. ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل داﻟﺔ اﻹدﺧﺎل اﻻﻋﺗﯾﺎدﯾﺔ وﻧﺣﺎول إدﺧﺎل )‪ (string‬ﺑﮭﺎ ﻣﺎذا ﺳﯾﺣدث‬

                                                                                                    ‫داﻟﺔ اﻹدﺧﺎل ﺑﻠﻐﺔ ++‪C‬‬
         ‫;]03[‪char name‬‬
         ‫;)‪scanf("%s",name‬‬


                                                                                                      ‫داﻟﺔ اﻹدﺧﺎل ﺑﻠﻐﺔ ‪C‬‬
         ‫;]03[‪char name‬‬
         ‫; ‪cin>>name‬‬


       ‫اﻟﻔراغ اﻷول‬
                                     ‫ﺳوف ﯾﺄﺧذ اﻟﺟﻣﻠﺔ اﻟﻣدﺧﻠﺔ ﻟﻛن ﻟﯾس ﻛﻠﮭﺎ ﯾﺄﺧذھﺎ ﺣﺗﻰ أول ﻓراغ ﺑﺎﻹدﺧﺎل أي ﻟو أدﺧﻠﻧﺎ‬
     ‫‪Hussien Ahmmed Taleb‬‬

                                 ‫ﻟذاﻟك ﺳوف ﯾﺄﺧذ اﻟﻣدﺧﻼت ﻓﻘط ﻛﻠﻣﺔ )‪ (Hussien‬وﺑﮭﻣل ﻣن اﻟﻔراغ اﻷول إﻟﻰ اﻟﻧﮭﺎﯾﺔ‬
                     ‫ﻣﮭم‬
                                          ‫إذا أدﺧﻠﻧﺎ ﻋدة ﻛﻠﻣﺎت ﻓﻣﺎ اﻟذي ﺳوف ﯾﺣدث ﻟﻠذي ﻣﮭﻠﺗﮫ داﻟﺔ اﻹدﺧﺎل اﻷوﻟﻰ..؟‬
   ‫اﻟذي ﻣﮭﻠﺗﮫ داﻟﺔ اﻹدﺧﺎل اﻷوﻟﻰ ﻟن ﯾذھب ﺳدى إﻧﮭﻣﺎ ﯾﺑﻘﻰ ﯾﻧﺗظر ﻋﻣﻠﯾﺔ إدﺧﺎل ﺛﺎﻧﯾﺔ ﻟﯾﻛون ھو ﻛﻣدﺧل ﻟﮭﺎ) أي ﻓﻲ‬
    ‫ﻋﻣﻠﯾﺔ اﻹدﺧﺎل اﻟﺛﺎﻧﯾﺔ ﺳوف ﻻ ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل ھو ﯾﻌﺗﺑر ﻣﺎ ﺗﺑﻘﻰ ﻣن داﻟﺔ اﻹدﺧﺎل اﻷوﻟﻰ ﻛﻣدﺧل ﻟداﻟﺔ‬
        ‫اﻹدﺧﺎل اﻟﺛﺎﻧﯾﺔ( أي ﻟو رﺟﻌﻧﺎ إﻟﻰ اﻟﻣﺛﺎل اﻟﺳﺎﺑق ووﺿﻌﻧﺎ داﻟﺔ إدﺧﺎل أﺧرى وأدﺧﻠﻧﺎ ﻧﻔس اﻟﺟﻣﻠﺔ ﻛﻣﺎ ﻓﻲ اﻟﻣﺛﺎل‬

 ‫++‪c‬‬                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                           ‫>‪#include<stdio.h‬‬
  ‫)(‪int main‬‬                                                     ‫)(‪int main‬‬
  ‫;]02[2‪{1.char string1[20],string‬‬                               ‫;]02[2‪{1.char string1[20],string‬‬
 ‫; 1‪2.cin>>string‬‬                                               ‫;)1‪2.scanf("%s",&string‬‬
 ‫; 2‪3 . cin>>string‬‬                                             ‫;)2‪3 .scanf("%s",&string‬‬
 ‫; 2‪4.cout<<string‬‬                                              ‫;)2‪4.prin ("%s",string‬‬
 ‫}‬                                                              ‫}‬
‫ﻓﻲ ھذا اﻟﺑرﻧﺎﻣﺞ اﻟﻣﻔروض ﺗﻧﻔذ ﺧطوة رﻗم )٢( ﯾدﺧل اﻟﻣﺳﺗﺧدم )1‪ (string‬ﺛم ﺗﻧﻔذ ﺧطوة رﻗم )٣( وﯾدﺧل اﻟﻣﺳﺗﺧدم‬
                                        ‫)2‪ (string‬ھذه اﻟﻛﻼم ﺻﺣﯾﺢ إذا ﻟم ﯾﺗﺟﺎوز اﻟﻣدﺧﻼت أﻛﺛر ﻣن ﻛﻠﻣﺔ ھﻛذا‬
                     ‫ﻟو ﺗﻼﺣظ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﻧﻔذ ﺧطوة رﻗم)٢( وطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل وادﺧل )‪ (alxs‬وﻧﻔذ ﺧطوة‬
                  ‫رﻗم)٣( وطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل وادﺧل )‪ (hussien‬وﺑﻌدھﺎ ﻧﻔذ ﺧطوة راﺑﻌﺔ وطﺑﻊ اﻻﺳم اﻟﺛﺎﻧﻲ‬
                                 ‫** أﻣﺎ إذا ادﺧل اﻟﻣﺳﺗﺧدم ﻓﻲ ﺧطوة رﻗم)٢( ﺟﻣﻠﺔ ﻣﻛوﻧﺔ ﻣن أﻛﺛر ﻣن ﻛﻠﻣﺔ وھﻲ‬
                                 ‫ﻓﺎﻟذي ﯾﺣدث ﻛﻣﺎ ﻗﻠﻧﺎ ﯾﺄﺧذ ﺣﺗﻰ اﻟﻔراغ اﻷول وﯾﻌﺗﺑره ﻛﻣدﺧل ﻟداﻟﺔ اﻹدﺧﺎل اﻷوﻟﻰ‬
                             ‫وھو)‪ (Hussien‬وﯾﺗرك ﺑﻘﯾﺔ اﻟﺟﻣﻠﺔ .وﻋﻧدﻣﺎ ﯾﻧﻔذ ﺧطوة رﻗم)٣( ﻻ ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم‬
‫اﻹدﺧﺎل أﻧﻣﺎ ﯾﻌﺗﺑر ﻣﺎ ﺗﺑﻘﻰ ﻣن اﻟﺟﻣﻠﺔ اﻷوﻟﻰ وھو)‪ (Ahmmed Taleb‬ﻛﻣدﺧل ﻟﮫ وﯾﺄﺧذ أﯾﺿﺎ ﺣﺗﻰ اﻟﻔراغ اﻟﺛﺎﻧﻲ أي‬
                  ‫ﺳوف ﯾﺄﺧذ )‪ (Ahmmed‬ﻓﻘط وﺑﮭﻣل اﻟﺑﻘﯾﺔ وﺳوف ﯾطﺑﻊ ﻓﻲ ﺧطوة رﻗم)٤( ﻣﺣﺗوﯾﺎت )2‪(string‬‬



  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                    ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                      ‫إذن اﻟﺣل ﻣﻊ ھذه اﻟﻣﺷﺎﻛل ﺗوﺟد دوال إدﺧﺎل ﺗﺄﺧذ اﻟﺟﻣﻠﺔ اﻟﻣدﺧﻠﺔ ﻛﺎﻣﻠﺔ وھﻲ:‬
                                     ‫)‪ (cin.get‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻓﻲ ﻟﻐﺔ )++‪ (c‬ﻹدﺧﺎل ﺟﻣﻠﺔ ﻛﺎﻣﻠﺔ وﺷﻛﻠﮭﺎ ﯾﻛون‬
                                                                                               ‫داﻟﺔ اﻹدﺧﺎل ﺑﻠﻐﺔ ++‪C‬‬
         ‫)‪Cin.get(string,number of input‬‬

                                                           ‫١.)‪ ( string‬ھﻲ اﻟﻣﺻﻔوﻓﺔ اﻟﻣراد إدﺧﺎﻟﮭﺎ ك )‪(string‬‬
‫٢.)‪ (number of input‬ھﻲ ﻋدد اﻟﺣروف اﻟﻣﺣﺗﻣﻠﺔ اﻟﺗﻲ ﺳﻧدﺧﻠﮭﺎ ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وداﺋﻣﺎ اﺟﻌﻠﮭﺎ أﻛﺛر ﻣن اﺣﺗﯾﺎﺟك‬
                           ‫وان ﻻ ﺗﺗﺟﺎوز ﺣﺟم اﻟﻣﺻﻔوﻓﺔ.وأﻧﻧﺎ إذا ﺗﺟﺎوزﻧﺎ اﻹدﺧﺎل ھذا اﻟرﻗم ﺳوف ﺳﯾﮭﻣل اﻟﺑﻘﯾﺔ .‬
                                        ‫)‪ (cin.getline‬ﻧﻔس طرﯾﻘﺔ اﻟداﻟﺔ )‪ (cin.get‬ﻟﻛﻧﮭﺎ ﺗﻘرئ ﺳطر واﺣد ﻓﻘط‬
                         ‫ﻣﺛﺎل: ﻟو ﻛﺎن ﻟدﯾﻧﺎ )1‪ (string‬وﺣﺟﻣﮭﺎ )٥٢( وﻧرﯾد إدﺧﺎﻟﮭﺎ ﺑﮭذه اﻟداﻟﺔ ﻓﯾﻛون اﻟﻛود ھﻛذا‬
                                                                                               ‫داﻟﺔ اﻹدﺧﺎل ﺑﻠﻐﺔ ++‪C‬‬
         ‫]52[1‪Char string‬‬
         ‫)52,1‪Cin.get(string‬‬


‫)‪ (gets‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻓﻲ ﻟﻐﺔ )‪ (c‬ﻹدﺧﺎل ﺟﻣﻠﺔ ﻛﺎﻣﻠﺔ ﻓﻘط ﻧﻛﺗﺑﮭﺎ وﻧﻛﺗب اﺳم)‪ (string‬اﻟﺗﻲ ﻧرﯾد أن ﻧدﺧﻠﮭﺎ ﺑﮭﺎ‬
                                                                                               ‫داﻟﺔ اﻹدﺧﺎل ﺑﻠﻐﺔ ++‪C‬‬
         ‫]52[1‪Char string‬‬
         ‫)1‪gets(string‬‬


        ‫دوال اﻹﺧراج ﻓﻲ ﻟﻐﺔ )++‪ (c‬ﻧﺳﺗﺧدم ﻧﻔس داﻟﺔ اﻹﺧراج اﻻﻋﺗﯾﺎدﯾﺔ ﺗﻛﺗب اﺳم )‪ (string‬وﺳﺗطﺑﻊ ﺳﻠﺳﻠﺔ ﻛﺎﻣﻠﺔ‬

                                                                                               ‫داﻟﺔ اﻹدﺧﺎل ﺑﻠﻐﺔ ++‪C‬‬
         ‫;1‪cout<<string‬‬



          ‫دوال اﻹﺧراج ﻓﻲ ﻟﻐﺔ )‪ (c‬ﻧﺳﺗﺧدم ﻧﻔس داﻟﺔ اﻹﺧراج اﻻﻋﺗﯾﺎدﯾﺔ وﻧﺳﺗﺧدم ﻓﻲ داﻟﺔ اﻟطﺑﺎﻋﺔ اﻟرﻣز)‪ (%s‬واﺳم‬
                                                               ‫)‪ (string‬وﺳﺗطﺑﻊ ﺳﻠﺳﻠﺔ ﻛﺎﻣﻠﺔ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

                                                                                               ‫داﻟﺔ اﻹدﺧﺎل ﺑﻠﻐﺔ ++‪C‬‬
         ‫;)1‪Prin ("%s",string‬‬

                                                    ‫*ﻻ ﻧﺳﺗﺧدم "‪ %c‬ﻻن "‪ "%c‬ﺗطﺑﻊ ﺣرف واﺣد ﻓﻘط وﻟﯾس ﺟﻣﻠﺔ‬

‫ﻟﻧﺻﺣﺢ اﻟﻣﺛﺎل اﻟﺳﺎﺑق اﻟذي ﻛﺎﻧت ﺑﮫ ﻣﺷﻛﻠﺔ ﺑدوال اﻹدﺧﺎل ﺑﺎﺳﺗﺧدام ھذه اﻟدوال اﻟﺟدﯾدة )اﻓﺣص اﻟﻣﺛﺎل وﺷﺎھد اﻟﻔرق(‬

 ‫++‪c‬‬                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                      ‫>‪#include<stdio.h‬‬
  ‫)(‪int main‬‬                                                ‫)(‪int main‬‬
  ‫;]02[2‪{1.char string1[20],string‬‬                          ‫;]02[2‪{1.char string1[20],string‬‬
 ‫; )02,1‪2.cin.get(string‬‬                                   ‫;)1‪2.gets(string‬‬
 ‫; )02,2‪3 . cin.get(string‬‬                                 ‫;)2‪3 . gets(string‬‬
 ‫; 2‪4.cout<<string‬‬                                         ‫;)2‪4.prin ("%s",string‬‬
 ‫}‬                                                         ‫}‬



  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                       ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                            ‫ھﻧﺎك ﻋدة دوال ﻟﻠﺗﻌﺎﻣل ﻣﻊ )‪ (string‬ﺗﻘﻊ ﺿﻣن ﻣﻛﺗﺑﺔ >‪ <string.h‬وھﻲ:‬

 ‫١.)(‪ :strlen‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻹﯾﺟﺎد طول اﻟﺳﻠﺳﺔ اﻟﻧﺻﯾﺔ )أي ﻋدد اﻷﺣرف ﻓﻲ اﻟﺳﻠﺳﻠﺔ وﻛذاﻟك ﻋدد اﻟﻔراﻏﺎت( .‬

                                                                                                    ‫وطرﯾﻘﺔ اﺳﺗﺧداﻣﮭﺎ ھﻲ‬

                                                                                                         ‫ھﯾﻛﻠﯾﺔ اﻟداﻟﺔ‬
          ‫)‪strlen(string‬‬

                                                                              ‫)‪ (string‬ھﻲ اﻟﻣﺻﻔوﻓﺔ اﻟﻣراد إﯾﺟﺎد طوﻟﮭﺎ‬

                                                                                           ‫ﻣﺛﺎل:إﯾﺟﺎد طول اﻟﻣﺻﻔوﻓﺔ اﻟﺗﺎﻟﯾﺔ‬

                                                                                                             ‫اﻟﺑرﻣﺟﺔ‬
          ‫;"‪char string1[5]="alxs go‬‬
          ‫;‪int len‬‬
          ‫7=‪len=strlen(string1); // len‬‬
                             ‫ﯾﻛون طول اﻟﻣﺻﻔوﻓﺔ )٧( ﻻن ﺣﺗﻰ اﻟﻔراغ أﯾﺿﺎ ﯾﻌﺗﺑر ﻛﺣرف ﻓﻲ ﺣﺳﺎب اﻟطول اﻟﺳﻠﺳﻠﺔ‬

                                                                           ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻧدﺧل ﺳﻠﺳﻠﺔ وﯾطﺑﻌﮭﺎ ﺑﺎﻟﻣﻘﻠوب .؟‬

    ‫ﺗﺣﻠﯾل:ﻟطﺑﺎﻋﺔ أي ﻣﺻﻔوﻓﺔ ﺑﺎﻟﻣﻘﻠوب)أي أﺧر ﺣرف ﯾطﺑﻊ أول ﺣرف( ﯾﻛون ﺑوﺿﻊ اﻟﻣؤﺷر ﻋﻠﻰ أﺧر ﺣرف ﺛم‬
 ‫ﻧﺗﻧﺎزل إﻟﻰ أول ﺣرف ﺑﺎﻟﺗﺳﻠﺳل ﻓﺗﺗم اﻟطﺑﺎﻋﺔ وﻧﺳﺗطﯾﻊ ﻣﻌرﻓﺔ أﺧر ﺣرف ﺑواﺳطﺔ داﻟﺔ ﻣﻌرﻓﺔ طول اﻟﺳﻠﺳﺔ ﺳﯾﻌطﯾك‬
                    ‫طوﻟﮭﺎ وﻧطرح ﻣن طوﻟﮭﺎ واﺣد ﻧﺟد أﺧر رﻗم ﺑﺎﻟﻣﺻﻔوﻓﺔ ﻻن ﺗرﻗﯾم اﻟﻣﺻﻔوﻓﺔ ﯾﺑدأ ﻣن اﻟﺻﻔر‬

 ‫++‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                         ‫>‪#include<stdio.h‬‬
 ‫>‪#include<string.h‬‬                                           ‫>‪#include<string.h‬‬
  ‫)(‪int main‬‬                                                  ‫)(‪int main‬‬
 ‫;]04[1‪{1.char string‬‬                                         ‫;]04[1‪{1.char string‬‬
 ‫;‪2.int I,len‬‬                                                 ‫;‪2.int i,len‬‬
 ‫; )04,1‪3 . cin.get(string‬‬                                    ‫;)1‪3 . gets(string‬‬
 ‫;1-)1‪4.len=strlen(string‬‬                                     ‫;1-)1‪4.len=strlen(string‬‬
 ‫)--‪5.for(i=len ;i>=0;i‬‬                                       ‫)--‪5.for(i=len ;i>=0;i‬‬
 ‫};]‪6.cout<<string1[i‬‬                                         ‫};)]‪6.prin ("%c",string1[i‬‬
                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                                                                      ‫١.ﺧطوة رﻗم)١( ﻋرﻓﻧﺎ ﻣﺻﻔوﻓﺔ ﻧﺻﯾﺔ،‬
                                 ‫٢.ﺧطوة رﻗم)٢( ﻋرﻓﻧﺎ ﻋداد ﻟﻠﻣﺻﻔوﻓﺔ وﻣﺗﻐﯾر )‪ (len‬ﻟﻛﻲ ﻧﺧزن ﻓﯾﮫ طول اﻟﺳﻠﺳﻠﺔ‬
                                                    ‫٣.ﺧطوة رﻗم )٣( ﻗﻣﻧﺎ ﺑﺈدﺧﺎل اﻟﺳﻠﺳﺔ ﺑواﺳطﺔ دوال اﻹدﺧﺎل‬
       ‫٤.ﺧطوة رﻗم)٤( ﺧزن طول اﻟﺳﻠﺳﻠﺔ ﺑﺎﻟﻣﺗﻐﯾر )‪ (len‬وطرﻧﺎ ﻣن طول اﻟﺳﻠﺳﻠﺔ واﺣد ﻻن ﺗرﻗﯾم اﻟﻣﺻﻔوﻓﺔ ﯾﺑدأ ﻣن‬
                               ‫اﻟﺻﻔر وطول اﻟﻣﺻﻔوﻓﺔ ﯾﻌطﯾك ﻋدد اﻷﺣرف ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻟذاﻟك ﯾﺟب طرﺣﮫ ﺑواﺣد‬
               ‫٥.ﻋداد ﯾﺑدأ ﺑﺎﻟﻌد ﻣن أﺧر ﻋﻧﺻر ﺑﺎﻟﻣﺻﻔوﻓﺔ وﯾﺗﻧﺎﻗص إﻟﻰ أول ﻋﻧﺻر وﯾطﺑﻊ ﻛل ﻋﻧﺻر ﻓﻲ ﺧطوة)٦(‬

                                          ‫* وﻟو ﺗﻼﺣظ ﻓﻲ اﻟطﺑﺎﻋﺔ ﺑﻠﻐﺔ)‪ (c‬اﺳﺗﺧدﻣﻧﺎ "‪ "%c‬ﻷﻧﻧﺎ ﺳﻧطﺑﻊ ﺣرف ﺣرف وﻟﯾس ﺳﻠﺳﻠﺔ‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                     ‫اﻟﻔﺻل اﻟراﺑﻊ‬




 ‫٢.)(‪ :strcpy‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻟﻧﺳﺦ ﺟﻣﯾﻊ ﻣﺣﺗوﯾﺎت ﺳﻠﺳﻠﺔ إﻟﻰ ﺳﻠﺳﻠﺔ أﺧرى وﺗﻛون طرﯾﻘﺔ اﻟﻧﺳﺦ اﻧﮫ ﯾﺑدأ ﺑﺈﺿﺎﻓﺔ‬
                               ‫ﻋﻧﺎﺻر اﻟﺳﻠﺳﻠﺔ اﻟﺛﺎﻧﯾﺔ ﺑﻣﻛﺎن ﻋﻧﺎﺻر اﻟﺳﻠﺳﻠﺔ اﻷوﻟﻰ اﻟﺗﻲ ﻟﮭﺎ ﻧﻔس اﻟﺗﺳﻠﺳل ﺑﺎﻟﻣوﻗﻊ‬

                                                                                                       ‫ھﯾﻛﻠﯾﺔ اﻟداﻟﺔ‬
         ‫;)2‪strcpy(string1, string‬‬
                                                               ‫ﻣﺛﺎل: ﻟﻧﺳﺦ ﺟﻣﯾﻊ ﻣﺣﺗوﯾﺎت ﻣﺻﻔوﻓﺔ إﻟﻰ ﻣﺻﻔوﻓﺔ أﺧرى‬

                                                                                                           ‫اﻟﺑرﻣﺟﺔ‬
         ‫;" ‪char string1[5]="alxs‬‬
         ‫;" ‪char string2[5]="me‬‬
         ‫;)2‪strcpy(string1, string‬‬



                  ‫"‪ string1 ="alxs‬ﻗﺑل اﻟﻧﺳﺦ‬                                       ‫"‪ string1="mexs‬ﺑﻌد اﻟﻧﺳﺦ‬
 ‫]0[1‪string‬‬    ‫]1[1‪string‬‬    ‫]2[1‪string‬‬   ‫]3[1‪string‬‬
                                                                         ‫]0[1‪string‬‬   ‫]1[1‪string‬‬   ‫]2[1‪string‬‬    ‫]3[1‪string‬‬
     ‫‪a‬‬              ‫‪l‬‬               ‫‪x‬‬         ‫‪s‬‬
                                                                            ‫‪m‬‬             ‫‪e‬‬            ‫‪x‬‬               ‫‪s‬‬
               ‫"‪String2="me‬‬

              ‫]0[2‪String‬‬    ‫]1[2‪String‬‬
                 ‫‪m‬‬              ‫‪e‬‬

         ‫ﻟو ﺗﻼﺣظ أن )2‪ (String‬ﺑﻘﯾت ﻣﺣﺎﻓظﺔ ﻋﻠﻰ ﻣﺣﺗوﯾﺎﺗﮭﺎ ﻧﻔﺳﮭﺎ ﺑﻌد اﻟﻧﺳﺦ ﻷن اﻟﻧﺳﺦ ﯾﻛون ﻣﻧﮭﺎ إﻟﻰ )1‪(string‬‬
            ‫وان )1‪ (string‬ﺗم أﺑدال ﻣﺣﺗوﯾﺎت ﻛل ﻣوﻗﻊ ﺑﻣﺎ ﯾﻛﺎﻓﺋﮫ ﻓﻲ)2‪ (String‬وﺑﻘﯾت اﻟﻣواﻗﻊ اﻟﺗﻲ ﻻ ﯾﻘﺎﺑﻠﮭﺎ ﻗﯾم ﻣن‬
                                                                                     ‫)2‪ (String‬ﻣﺣﺗﻔظﺔ ﺑﻘﯾﻣﮭﺎ‬

  ‫٣.)(‪ :strncpy‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻟﻧﺳﺦ ﻋدد ﻣﺣدد ﻣن ﻣﺣﺗوﯾﺎت ﺳﻠﺳﻠﺔ إﻟﻰ ﺳﻠﺳﻠﺔ أﺧرى وﺗﻛون طرﯾﻘﺔ اﻟﻧﺳﺦ اﻧﮫ‬
                   ‫ﯾﺑدأ ﺑﺈﺿﺎﻓﺔ ﻋﻧﺎﺻر اﻟﺳﻠﺳﻠﺔ اﻟﺛﺎﻧﯾﺔ ﺑﻣﻛﺎن ﻋﻧﺎﺻر اﻟﺳﻠﺳﻠﺔ اﻷوﻟﻰ اﻟﺗﻲ ﻟﮭﺎ ﻧﻔس اﻟﺗﺳﻠﺳل ﺑﺎﻟﻣوﻗﻊ‬

                                                                                                       ‫ھﯾﻛﻠﯾﺔ اﻟداﻟﺔ‬
         ‫;)‪strncpy(string1, string2,number of copy‬‬
                            ‫)‪ (number of copy‬ھو ﻋدد اﻷﺣرف اﻟﻣراد ﻧﺳﺧﮭﺎ ﻣن اﻟﺳﻠﺳﻠﺔ اﻟﺛﺎﻧﯾﺔ إﻟﻰ اﻟﺳﻠﺳﻠﺔ اﻷوﻟﻰ‬



                                                       ‫ﻣﺛﺎل: ﻟﻧﺳﺦ ﺛﻼث ﻋﻧﺎﺻر ﻣن ﻣﺣﺗوﯾﺎت ﻣﺻﻔوﻓﺔ إﻟﻰ ﻣﺻﻔوﻓﺔ أﺧرى‬

                                                                                                           ‫اﻟﺑرﻣﺟﺔ‬
         ‫;" ‪char string1[5]="alxs‬‬
         ‫;" ‪char string2[5]="suha muhamed‬‬
         ‫;)3,2‪strncpy(string1, string‬‬
           ‫ﺳوف ﯾﻧﺳﺦ اﻟﺣروف اﻟﺛﻼﺛﺔ اﻷوﻟﻰ ﻣن اﻟﺳﻠﺳﻠﺔ اﻟﺛﺎﻧﯾﺔ وھﻲ)‪ (suh‬إﻟﻰ اﻟﺳﻠﺳﺔ اﻷوﻟﻰ وﯾﻛون ﻣﺣﺗوﯾﺎت )‪(string1=suhs‬‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                              ‫اﻟﻔﺻل اﻟراﺑﻊ‬




            ‫٤.)(‪ :strcat‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻟﻺﻟﺣﺎق ﻣﺣﺗوﯾﺎت ﺳﻠﺳﻠﺔ ﻓﻲ ﻧﮭﺎﯾﺔ ﺳﻠﺳﻠﺔ أﺧرى وﻣﺣﺎﻓظﺎ ﻋﻠﻰ ﻣﺣﺗوﯾﺎﺗﮭﺎ .‬

                                                                                                                ‫ھﯾﻛﻠﯾﺔ اﻟداﻟﺔ‬
          ‫;)2‪strcat(string1, string‬‬



                                                                    ‫ﻣﺛﺎل: ﻹﻟﺣﺎق ﺟﻣﯾﻊ ﻣﺣﺗوﯾﺎت ﻣﺻﻔوﻓﺔ إﻟﻰ ﻣﺻﻔوﻓﺔ أﺧرى‬

                                                                                                                    ‫اﻟﺑرﻣﺟﺔ‬
          ‫;" ‪char string1[7]="alxs‬‬
          ‫;" ‪char string2[5]="me‬‬
          ‫;)2‪strcat(string1, string‬‬



                  ‫"‪ string1="alxs‬ﻗﺑل اﻟﻧﺳﺦ‬

 ‫]0[1‪string‬‬    ‫]1[1‪string‬‬    ‫]2[1‪string‬‬   ‫]3[1‪string‬‬                                           ‫"‪ string1 ="alxsme‬ﺑﻌد اﻟﻧﺳﺦ‬
     ‫‪a‬‬              ‫‪l‬‬               ‫‪x‬‬         ‫‪s‬‬
                                                       ‫]0[1‪string‬‬    ‫]1[1‪string‬‬   ‫]2[1‪string‬‬   ‫]3[1‪string‬‬   ‫]4[1‪string‬‬    ‫]5[1‪string‬‬
                ‫"‪String2 ="me‬‬                              ‫‪a‬‬             ‫‪l‬‬            ‫‪x‬‬            ‫‪s‬‬           ‫‪m‬‬                ‫‪e‬‬
              ‫]0[2‪String‬‬    ‫]1[2‪String‬‬
                 ‫‪m‬‬              ‫‪e‬‬

      ‫ﻟو ﺗﻼﺣظ أن )2‪ (String‬ﺑﻘﯾت ﻣﺣﺎﻓظﺔ ﻋﻠﻰ ﻣﺣﺗوﯾﺎﺗﮭﺎ ﻧﻔﺳﮭﺎ ﺑﻌد اﻟدﻣﺞ ﻷن اﻹﻟﺣﺎق ﯾﻛون ﻣﻧﮭﺎ إﻟﻰ )1‪(string‬‬
   ‫وان )1‪ (string‬ﺗم إﺿﺎﻓﺔ ﻣﺣﺗوﯾﺎت ﺳﻠﺳﻠﺔ)2‪ (String‬إﻟﻰ ﻧﮭﺎﯾﺗﮭﺎ . ﯾﺟب أن ﯾﻛون ﺣﺟم اﻟﻣﺻﻔوﻓﺔ اﻟﻣراد اﻹﺿﺎﻓﺔ‬
‫إﻟﯾﮭﺎ ﻣﺳﺎوي ﻟﻌدد أﺣرﻓﮭﺎ وﻋدد اﻷﺣرف اﻟﻣﺿﺎﻓﺔ ﻟو ﺗﻼﺣظ أن ﻓﻲ اﻟﻣﺛﺎل وﺿﻌﻧﺎ ﺣﺟم)1‪ (string‬ھو)٧( وھﻲ ﻣﻛوﻧﺔ‬
                               ‫ﻣن أرﺑﻌﺔ أﺣرف ﻷﻧﻧﺎ ﺳﻧﺿﯾف إﻟﯾﮭﺎ ﺳﻠﺳﻠﺔ ﻣﻛوﻧﺔ ﻣن ﺣرﻓﺎن ﻓﯾﺻﺑﺢ طوﻟﮭﺎ ﺳﺑﻌﺔ‬

         ‫٥.)(‪ :strncat‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﺑﺈﻟﺣﺎق ﻋدد ﻣﺣدد ﻣن ﻣﺣﺗوﯾﺎت ﺳﻠﺳﻠﺔ ﻓﻲ ﻧﮭﺎﯾﺔ ﺳﻠﺳﻠﺔ أﺧرى وﺗﻛون طرﯾﻘﺔ‬

                                                                                                                ‫ھﯾﻛﻠﯾﺔ اﻟداﻟﺔ‬
          ‫;)‪strncat(string1, string2,number of copy‬‬
                            ‫)‪ (number of copy‬ھو ﻋدد اﻷﺣرف اﻟﻣراد ﻧﺳﺧﮭﺎ ﻣن اﻟﺳﻠﺳﻠﺔ اﻟﺛﺎﻧﯾﺔ إﻟﻰ اﻟﺳﻠﺳﻠﺔ اﻷوﻟﻰ‬

                                                  ‫ﻣﺛﺎل: ﻹﻟﺣﺎق ﺛﻼث ﻋﻧﺎﺻر ﻣن ﻣﺣﺗوﯾﺎت ﻣﺻﻔوﻓﺔ إﻟﻰ ﻣﺻﻔوﻓﺔ أﺧرى‬

                                                                                                                    ‫اﻟﺑرﻣﺟﺔ‬
          ‫;" ‪char string1[5]="alxs‬‬
          ‫;" ‪char string2[5]="suha muhamed‬‬
          ‫;)3,2‪strncat(string1, string‬‬
 ‫ﺳوف ﯾﻧﺳﺦ اﻟﺣروف اﻟﺛﻼﺛﺔ اﻷوﻟﻰ ﻣن اﻟﺳﻠﺳﻠﺔ اﻟﺛﺎﻧﯾﺔ وھﻲ)‪ (suh‬إﻟﻰ اﻟﺳﻠﺳﺔ اﻷوﻟﻰ وﯾﻛون ﻣﺣﺗوﯾﺎت )‪(string1=alxssuh‬‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                           ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                        ‫٦.)(‪ :strcmp‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻟﻠﻣﻘﺎرﻧﺔ ﺑﯾن ﺳﻠﺳﻠﺗﯾن وﺗﻛون ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                                             ‫ھﯾﻛﻠﯾﺔ اﻟداﻟﺔ‬
        ‫;)2‪strcmp(string1, string‬‬


                                                                 ‫ھﻧﺎك ﺛﻼﺛﺔ ﻧﺗﺎﺋﺞ ﻟﻠﻣﻘﺎرﻧﺔ ﺑﯾن ﺳﻠﺳﻠﺗﯾن وھﻲ.‬
                                            ‫١.ﻓﺈذا ﻛﺎﻧت ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ ﺻﻔر ﻓﺄن )1‪ (String‬ﺗﺳﺎوي )2‪(String‬‬
                                   ‫٢. ﻓﺈذا ﻛﺎﻧت ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ اﻛﺑر ﻣن ﺻﻔر ﻓﺄن )1‪ (String‬اﻛﺑر ﻣن )2‪(String‬‬
                                ‫٣. ﻓﺈذا ﻛﺎﻧت ﻧﺗﯾﺟﺔ اﻟﻣﻘﺎرﻧﺔ اﺻﻐر ﻣن ﺻﻔر ﻓﺄن )1‪ (String‬اﺻﻐر ﻣن )2‪(String‬‬

                                                                                   ‫ﻣﺛﺎل: ﻟﻠﻣﻘﺎرﻧﺔ ﺑﯾن ﺳﻠﺳﻠﺗﯾن‬

                                                                                                 ‫اﻟﺑرﻣﺟﺔ‬
        ‫;" ‪char string1[7]="aa‬‬
        ‫;" ‪char string2[5]="ab‬‬
        ‫;‪int cmper‬‬
        ‫1<‪cmper=strcmp(string1, string2) ; //cmper‬‬
                                       ‫ﻛﺎﻧت ﻧﺗﯾﺟﺔ اﻟﻣﺗﻐﯾر )‪ (cmper‬ﺳﺎﻟﺑﺔ ﻻن )1‪ (String‬اﺻﻐر ﻣن )2‪(String‬‬



                                ‫٧.)(‪ :strncmp‬ﺗﺳﺗﺧدم ھذه اﻟداﻟﺔ ﻟﻠﻣﻘﺎرﻧﺔ ﺑﯾن ﻋدد ﻣﺣدد ﻣن اﻷﺣرف ﻣن ﺳﻠﺳﻠﺗﯾن‬

                                                                                             ‫ھﯾﻛﻠﯾﺔ اﻟداﻟﺔ‬
        ‫;)‪strncmp (string1, string2,number of comper‬‬
                                     ‫)‪ (number of comper‬ھو ﻋدد اﻷﺣرف اﻟﻣراد ﻣﻘﺎرﻧﺗﮭﺎ ﻣن ﻛﻼ اﻟﺳﻠﺳﻠﺗﯾن‬



                                           ‫ﻣﺛﺎل: ﻟﻣﻘﺎرﻧﺔ أول ﻋﻧﺻر ﻣن ﻣﺣﺗوﯾﺎت ﻣﺻﻔوﻓﺔ اﻷوﻟﻰ واﻟﻣﺻﻔوﻓﺔ اﻟﺛﺎﻧﯾﺔ‬

                                                                                                 ‫اﻟﺑرﻣﺟﺔ‬
        ‫;" ‪char string1[5]="hussien‬‬
        ‫;" ‪char string2[5]="hakmet‬‬
        ‫;‪int cmper‬‬
        ‫0=‪cmper=strncmp(string1, string2,1) ; //cmper‬‬
       ‫ﻛﺎﻧت ﻧﺗﯾﺟﺔ اﻟﻣﺗﻐﯾر )‪ (cmper‬ﺻﻔر ﻻن اﻟﺣرف اﻷول ﻓﻲ )1‪ (String‬ﯾﺳﺎوي اﻟﺣرف اﻷول ﻓﻲ )2‪(String‬‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                             ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                    ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻧدﺧل ﺳﻠﺳﻠﺔ ﺣرف وﯾﺣﺳب ﻋدد ﻣرات ظﮭور اﻟﺣرف )‪ (a‬ﻓﻲ اﻟﺳﻠﺳﻠﺔ‬

‫ﺗﺣﻠﯾل:ﺑﻣﺎ اﻧﮫ ﻗﺎل ﺳﻠﺳﻠﺔ ﺣروف ﻧﺳﺗﺧدم دوال اﻹدﺧﺎل اﻟﺧﺎﺻﺔ ب)‪ (string‬وﺑﻌدھﺎ ﻧﺿﻊ ﺷرط ﺑﺳﯾط ﻟﻠﺗﺣﻘق إذا ﻛﺎن‬
                                          ‫اﺣد اﻟﺣروف ھو )‪ (a‬وﻧزﯾد ﻋداد ﻓﻲ ﻛل ﻣرة ﯾﺟد ﻓﯾﮭﺎ ﺣرف )‪(a‬‬

 ‫++‪c‬‬                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                            ‫>‪#include<stdio.h‬‬
 ‫>‪#include<string.h‬‬                                              ‫>‪#include<string.h‬‬
  ‫)(‪int main‬‬                                                     ‫)(‪int main‬‬
 ‫;]04[1‪{1.char string‬‬                                            ‫;]04[1‪{1.char string‬‬
 ‫;0=‪2.int i,len,number_appear‬‬                                    ‫;0=‪2.int i,len,number_appear‬‬
 ‫; )04,1‪3 . cin.get(string‬‬                                       ‫;)1‪3 . gets(string‬‬
 ‫;1-)1‪4.len=strlen(string‬‬                                        ‫;1-)1‪4.len=strlen(string‬‬
 ‫)++‪5.for(i=0;i<=len;i‬‬                                           ‫)++‪5.for(i=0;i<=len;i‬‬
 ‫)'‪6.If ( string1[i]=='a‬‬                                         ‫)'‪6.If ( string1[i]=='a‬‬
 ‫;1+‪7. number_appear=number_appear‬‬                               ‫;1+‪7. number_appear=number_appear‬‬
 ‫};‪8.cout<<"number appear of (a)="<< number_appear‬‬               ‫};)‪8.prin ("number appear of (a)=%d", number_appear‬‬
                                                                                       ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
‫١.ﺧطوة رﻗم )٥( ﻛوﻧﺎ ﻋداد ﯾﺑدأ ﺑﺄول ﺣف ﺑﺎﻟﺳﻠﺳﻠﺔ وﯾﻧﺗﮭﻲ ﺑﺄﺧر ﺣرف ﻟﻛﻲ ﯾﺗﺣﻘق ﻣن أﺣرف اﻟﺳﻠﺳﻠﺔ ﺣرف ﺣرف‬
 ‫ﻣﺗﻰ ﻣﺎ وﺟد ﺣرف )‪ (a‬ﺳﺗﺣﻘق اﻟﺷرط ﻓﻲ اﻟﺧطوة رﻗم)٦( وﯾﻧﻔذ ﺧطوة رﻗم )٧( ﯾزﯾد ﻓﯾﮭﺎ ﻗﯾﻣﺔ اﻟﻌداد ﺑواﺣد دﻻﻟﺔ‬
‫ﻋﻠﻰ اﻧﮫ وﺟد ﺣرف ﺟدﯾد وﻛﻠﻣﺎ ﯾﺟد اﻟﺣرف ﯾزﯾد اﻟﻌداد وﻓﻲ اﻟﻧﮭﺎﯾﺔ ﺗﻛون ﻗﯾﻣﺔ اﻟﻌداد ﺑﻘدر ﻋدد ﻣرات ظﮭور اﻟﺣرف‬
                                                                                        ‫)‪ (a‬ﻓﻲ اﻟﺳﻠﺳﻠﺔ‬



        ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻧدﺧل ﺳﻠﺳﻠﺔ ﺣرف وﯾﺣﺳب ﻋدد ﻣرات ظﮭور أﺣرف اﻟﻌﻠﺔ وطﺑﺎﻋﺗﮭﺎ أﯾﻧﻣﺎ وﺟدت ﻓﻲ اﻟﺳﻠﺳﻠﺔ.؟‬

   ‫ﺗﺣﻠﯾل: ﻓﻛرة ھذا اﻟﺳؤال ﻧﻔس ﻓﻛرة اﻟﺳؤال اﻟﺳﺎﺑق ﻓﻘط اﻟذي ﯾﻐﯾر ﺷرط اﻟﺗﺣﻘق ﻓﺑدﻻ ﻣن أن ﯾﺗﺣﻘق ﻣن ﺣرف واﺣد‬
                                                            ‫ﺳﯾﺗﺣﻘق ﻣن ﺧﻣس ﺣرف وأﯾﻧﻣﺎ وﺟدھﺎ ﯾطﺑﻌﮭﺎ‬

 ‫++‪c‬‬                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                            ‫>‪#include<stdio.h‬‬
 ‫>‪#include<string.h‬‬                                              ‫>‪#include<string.h‬‬
  ‫)(‪int main‬‬                                                      ‫)(‪int main‬‬
 ‫;]04[1‪{1.char string‬‬                                             ‫;]04[1‪{1.char string‬‬
 ‫;0=‪2.int i,len,number_appear‬‬                                    ‫;0=‪2.int i,len,number_appear‬‬
 ‫; )04,1‪3 . cin.get(string‬‬                                       ‫;)1‪3 . gets(string‬‬
 ‫;1-)1‪4.len=strlen(string‬‬                                        ‫;1-)1‪4.len=strlen(string‬‬
 ‫)++‪5.for(i=0;i<=len;i‬‬                                           ‫)++‪5.for(i=0;i<=len;i‬‬
 ‫(||)'‪6.If ( ( string1[i]=='a')||( string1[i]=='u‬‬                ‫(||)'‪6.If ( ( string1[i]=='a')||( string1[i]=='u')||( string1[i]=='o‬‬
 ‫{) )'‪string1[i]=='o')||( string1[i]=='i')||( string1[i]=='e‬‬     ‫{) )'‪string1[i]=='i')||( string1[i]=='e‬‬
 ‫;"‪7.cout<<string1[i]<<"\n‬‬                                       ‫;)]‪7.prin ("%c",string1[i‬‬
 ‫};1+‪8. number_appear=number_appear‬‬                              ‫};1+‪8. number_appear=number_appear‬‬
 ‫};‪9.cout<<"number appear of vowel="<< number_appear‬‬             ‫};)‪9.printf("number appear of vowel =%d\n", number_appear‬‬



       ‫ﺗوﺿﯾﺢ اﻟﺧطوات: اﻟﺷرط ﻓﻲ ﺧطوة رﻗم )٦( ﯾﺗﺣﻘق ﻣﺗﻰ ﻣﺎ ﺟﺎء أي ﺣرف ﻣن ﺣروف اﻟﻌﻠﺔ اﻟﺧﻣﺳﺔ ﯾطﺑﻌﮫ ﻓﻲ‬
                               ‫ﺧطوة رﻗم )٧( وﯾزﯾد ﻗﯾﻣﺔ ﻋداد ﻋدد ﻣرات ظﮭور أﺣرف اﻟﻌﻠﺔ ﻓﻲ ﺧطوة رﻗم)٨(.‬


  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                           ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                            ‫٢.اﺳﺗﺧدام اﻟﺣروف ﻓﻲ اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ:‬
  ‫ﻻ ﯾﺧﺗﻠف اﺳﺗﺧدام اﻟﺣروف ﻓﻲ اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ ﻋن اﺳﺗﺧدام اﻷرﻗﺎم ﻓﻲ اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ ﺗﺳﺗﺧدم ﻓﻲ اﻹدﺧﺎل‬
                                       ‫ﺣرف ﺣرف ﻣﻛوﻧﺔ ﻣﺻﻔوﻓﺔ ﺣرف وﺣﺗﻰ ﻓﻲ اﻟطﺑﺎﻋﺔ ﺗطﺑﻊ ﺣرف ﺣرف‬

                                       ‫طرﯾﻘﺔ اﻟﺗﻌرﯾف )ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻣﺻﻔوﻓﺔ ﺣرﻓﯾﺔ ﺛﻧﺎﺋﯾﺔ ﺣﺟﻣﮭﺎ )3*3( (‬

                                                                                             ‫ھﯾﻛﻠﯾﺔ اﻟداﻟﺔ‬
        ‫; ]3[]3[ ‪char first_arraychar‬‬




                                      ‫وطرﯾﻘﺔ اﻹدﺧﺎل أﯾﺿﺎ ﺛﺎﺑﺗﺔ ﻓﻘط اﻟﻌدادات ﺗﺗﻐﯾر ﺣﺳب ﺣﺟم اﻟﻣﺻﻔوﻓﺔ وھﻲ‬

 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫;]3[]3[ ‪1. char first_arrychar‬‬                      ‫;]3[]3[ ‪1.char first_arrychar‬‬
 ‫)++‪2.for (i=0;i<3;i‬‬                                ‫)++‪2.for (i=0;i<3;i‬‬
 ‫)++‪3.for (j=0;j<3;j‬‬                                ‫)++‪3.for (j=0;j<3;j‬‬
 ‫; )]‪4.scanf("%c",& first_arry[i][j‬‬                 ‫; ]‪4.cin>> first_arrychar [i][j‬‬
     ‫** ﻻﺣظ ﺧطوة رﻗم)٤( ﻓﻲ اﻹدﺧﺎل اﺳﺗﺧدﻣﻧﺎ اﻟرﻣز )"‪ ("%c‬ﻓﻲ ﻟﻐﺔ )‪ (C‬ﻷﻧﻧﺎ ﺳﻧدﺧل ﺣرف ﺣرف وﻟﯾس ﺳﻠﺳﻠﺔ ﺣروف‬

                                                                                           ‫وﺗدﺧل ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ‬

                                        ‫‪a‬‬               ‫‪f‬‬             ‫‪c‬‬
                                        ‫‪d‬‬               ‫‪e‬‬             ‫‪l‬‬
                                        ‫‪k‬‬               ‫‪m‬‬             ‫‪o‬‬




                                      ‫وطرﯾﻘﺔ اﻟطﺑﺎﻋﺔ أﯾﺿﺎ ﺛﺎﺑﺗﺔ ﻓﻘط اﻟﻌدادات ﺗﺗﻐﯾر ﺣﺳب ﺣﺟم اﻟﻣﺻﻔوﻓﺔ وھﻲ‬

 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫)++‪1.for (i=0;i<3;i‬‬                                    ‫)++‪1.for (i=0;i<3;i‬‬
 ‫)++‪2.for (j=0;j<3;j‬‬                                    ‫)++‪2.for (j=0;j<3;j‬‬
 ‫; )]‪3.printf("%c", first_arry[i][j‬‬                     ‫; ]‪3.cout<< first_arrychar [i][j‬‬




                                                            ‫** ﯾﺿﺄ ﯾﺟب رﺳم اﻟﻣﺻﻔوﻓﺔ ﻗﺑل اﻟﺑدء ﺑﺎﻟﺣل ﺑﺄي ﺳؤال‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﺻﻔوﻓﺎت وأﻧواﻋﮭﺎ‬                                                                                                     ‫اﻟﻔﺻل اﻟراﺑﻊ‬




                                          ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻧدﺧل ﻣﺻﻔوﻓﺔ )4*4( وﯾﺣﺳب ﻋدد أﺣرف اﻟﻌﻠﺔ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ.‬

                                               ‫ﺗﺣﻠﯾل:ﻧﻔس طرﯾﻘﺔ اﻟﺣل اﻟﺳﺎﺑﻘﺔ ﻓﻘط ﻧﻐﯾر اﻟﺳﻠﺳﻠﺔ إﻟﻰ ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ اﻟﺣﺟم‬

 ‫++‪c‬‬                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                            ‫>‪#include<stdio.h‬‬
  ‫)(‪main‬‬                                                          ‫)(‪main‬‬
 ‫;‪{1.int i,j,k‬‬                                                   ‫;‪{1.int i,j,k‬‬
 ‫; ‪2.int number_appear‬‬                                           ‫; ‪2.int number_appear‬‬
 ‫;0= ‪3. number_appear‬‬                                            ‫;0= ‪3. number_appear‬‬
 ‫;}'‪4.char vowel [7]={'a','o','u','i','e','n','\o‬‬                ‫;}'‪4.char vowel[7]={'a','o','u','i','e','n','\o‬‬
 ‫;]4[]4[‪5.char a‬‬                                                 ‫;]4[]4[‪5.char a‬‬
 ‫)++‪6.for(i=0;i<4;i‬‬                                              ‫)++‪6.for(i=0;i<4;i‬‬
 ‫)++‪7.for(j=0;j<4;j‬‬                                              ‫)++‪7.for(j=0;j<4;j‬‬
 ‫;]‪8.cin>>a[i][j‬‬                                                 ‫; )]‪8.scanf("%c",& a[i][j‬‬
 ‫)++‪9.for(k=0;k<6;k‬‬                                              ‫)++‪9.for(k=0;k<6;k‬‬
 ‫)++‪10.for(i=0;i<4;i‬‬                                             ‫)++‪10.for(i=0;i<4;i‬‬
 ‫)++‪11.for(j=0;j<4;j‬‬                                             ‫)++‪11.for(j=0;j<4;j‬‬
 ‫)]‪12.if(a[i][j]== vowel [k‬‬                                      ‫)]‪12.if(a[i][j]== vowel [k‬‬
 ‫;1+ ‪13.number_appear = number_appear‬‬                            ‫;1+ ‪13.number_appear = number_appear‬‬
 ‫};‪14.cout<<"number appear of vowel="<< number_appear‬‬            ‫};)‪14.printf("number appear of vowel=%d", number_appear‬‬



                                                                                                         ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                                        ‫١.ﺧطوة رﻗم )٤( ﺗم ﺗﻌرﯾف ﻣﺻﻔوﻓﺔ ﺧزﻧﺎ ﻓﯾﮭﺎ ﺟﻣﯾﻊ أﺣرف اﻟﻌﻠﺔ‬

      ‫٢.ﺧطوة رﻗم )٩( ھو ﻋداد ﻟﻠﻣﺻﻔوﻓﺔ اﻟﺗﻲ ﺗﺣوي أﺣرف اﻟﻌﻠﺔ ﺣﯾث ﯾﻌﻣل ھذا اﻟﻌداد ﻋﻠﻰ ﻣﻘﺎرﻧﺔ ﻛل ﻋﻧﺻر ﻓﻲ‬
      ‫ﻣﺻﻔوﻓﺔ )‪ (vowel‬ﻣﻊ ﺟﻣﯾﻊ اﻟﻌﻧﺎﺻر اﻟﻣﺧزوﻧﺔ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ اﻟﻣدﺧﻠﺔ )‪ (a‬ﻓﻛﻠﻣﺎ ﯾﺟد ﺣرف ﻋﻠﺔ ﯾﺗﺣﻘق اﻟﺷرط‬
                   ‫ﺑﺧطوة رﻗم)٢١( ﻟﻛﻲ ﯾﻧﻔذ ﺧطوة رﻗم )٣١( وﯾزﯾد ﻗﯾﻣﺔ اﻟﻌداد ﺑواﺣد داﻻ ﻋﻠﻰ إﺿﺎﻓﺔ ﺣرف ﻋﻠﺔ‬

                                                             ‫٣.ﺧطوة رﻗم )٤١( ﺗﺗم طﺑﺎﻋﺔ ﻋدد أﺣرف اﻟﻌﻠﺔ ﻛﻣﺎ ﻓﻲ اﻟﺷﻛل‬




  ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                              ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                             ‫اﻟﺪوال )‪(function‬‬

                                     ‫١.٥- اﻟدوال )‪:(Function‬‬
                       ‫٢.٥- دوال )‪ (function‬ﺑدون ﻗﯾﻣﺔ ﻣﻌﺎدة :‬
                          ‫٣.٥- اﻹرﺳﺎل ﺑﺎﻟﻘﯾﻣﺔ واﻹرﺳﺎل ﺑﺎﻟﻣرﺟﻊ:‬
                                              ‫٤.٥- اﻟدوال اﻟزاﺋدة‬
                    ‫٥.٥- اﺳﺗدﻋﺎء اﻟداﻟﺔ ﻟﻧﻔﺳﮭﺎ )‪:(Recursively‬‬
                                       ‫٦.٥- اﻟﻣﺻﻔوﻓﺎت واﻟدوال:‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                       ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                            ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                                                                     ‫١.٥- اﻟدوال )‪:(Function‬‬
  ‫ﺗطرﻗﻧﺎ ﻓﻲ ﻣﺎ ﻣﺿﻰ ﻋﻠﻰ ﻋدد ﻛﺑﯾر ﻣن اﻟدوال اﻟﺧﺎﺻﺔ ﺑﻠﻐﺔ ) ++‪ (c,c‬وﺑﯾﻧﺎ طرﯾﻘﺔ اﺳﺗﺧداﻣﮭﺎ وﻣﻧﮭﺎ داﻟﺔ )‪(pow‬‬
  ‫اﻟﺗﻲ ﺗﺳﺗﺧدم ﻻ ﯾﺟﺎد ﻗﯾﻣﺔ اﻟرﻗم اﻟﻣرﻓوع إﻟﻰ ﻗوى . وھذه اﻟدوال ﻛﻠﮭﺎ ﻣﺻﻣﻣﺔ ﻣن ﻗﺑل ﻣﺻﻣﻣﻲ ﻟﻐﺔ ) ++‪ (c,c‬ﻟﻛﻲ‬
          ‫ﯾﺳﮭل اﻟﻌﻣل ﻋﻠﻰ ﻣﺑرﻣﺟﯾن ﻓﺑدﻻ أن ﯾﻛﺗب اﻟﻣﺑرﻣﺞ ﻋدد ﻣن اﻷﺳطر ﻹﯾﺟﺎد ﻗﯾﻣﺔ رﻗم اﻟﻣرﻓوﻋﺔ إﻟﻰ ﻗوى‬

                  ‫ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل إذا أردﻧﺎ ﻗﯾﻣﺔ ﺧﻣﺳﺔ ﻣرﻓوع إﻟﻰ ﻗوى ﺛﻼﺛﺔ)3^5( ﻓﺑدون داﻟﺔ )‪ (pow‬ﻧﺟده ھﻛذا‬

                                                                               ‫إﯾﺟﺎد اﻟﻘوى ﺑدون داﻟﺔ )‪(pow‬‬
       ‫;1=1‪1.int i,pow‬‬
       ‫)++‪2.For(i=0 ;i<3 ;i‬‬
       ‫;5*1‪3.pow1=pow‬‬
                                                                           ‫ﯾﺣﻠﮭﺎ ﻣﺑﺎﺷرة ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ )‪(pow‬‬

                                                                           ‫إﯾﺟﺎد اﻟﻘوى ﺑﺎﺳﺗﺧدام داﻟﺔ )‪(pow‬‬
       ‫)3,5(‪1.int pow1=pow‬‬
       ‫ﻓوﺟدﻧﺎ اﻟﻔرق اﻟطرﯾﻘﺔ اﻷوﻟﻰ اﺳﺗﺧدﻣﻧﺎ ﺛﻼث اﺳطر ﺑرﻣﺟﯾﺔ وﺛﺎﻧﻲ طرﯾﻘﺔ اﺳﺗﺧدﻣﻧﺎ ﺳطر ﺑرﻣﺟﻲ واﺣد وﻛﺎﻧت‬
     ‫اﻟﻧﺗﯾﺟﺔ ﻧﻔﺳﮭﺎ ﻟذاﻟك ﻓﺎﺋدة اﻟدوال ھو ﺗﻘﻠﯾل اﻷﺳطر اﻟﺑرﻣﺟﯾﺔ وﻣﻧﻊ ﺗﻛرار اﻛواد ﻷﻛﺛر ﻣن ﻣرة أي ﻟو اﺣﺗﺎﺟﯾﻧﺎ ﻋﻠﻰ‬
  ‫ﺳﺑﯾل اﻟﻣﺛﺎل رﻓﻊ رﻗم إﻟﻰ ﻗوى ﻋﺷر ﻣرات ﻓﻲ ﺑرﻧﺎﻣﺟﻧﺎ ﻓﻲ ﺣﺎل دون اﺳﺗﺧدام اﻟداﻟﺔ )‪ (pow‬ﻓﺳﻧﺿطر إﻟﻰ ﺗﻛرار‬
‫اﻟﺧطوات اﻟﺛﻼث ﻋﺷر ﻣرات ﻛﻠﻣﺎ اﺣﺗﺟﻧﺎ إﻟﯾﮭﺎ اﻟﺗﻲ ﺳوف ﺗزﯾد ﻣن ﺗﻌﻘﯾد اﻟﺑرﻧﺎﻣﺞ ﺑﯾﻧﻣﺎ ﺑواﺳطﺔ ھذه اﻟداﻟﺔ ﺳوف ﺗﻘﻠل‬
 ‫اﻻﻛواد وﺗﻣﻧﻊ اﻟﺗﻛرار ﻛﻠﻣﺎ ﻧﺣﺗﺎﺟﮭﺎ ﻧﺳﺗدﻋﯾﮭﺎ.إذا ھذا اﻟﻛﻼم ﺑﺎﻟﻧﺳﺑﺔ ﻟﻠدوال اﻟﺟﺎھزة وأﯾﺿﺎ ﻧﺳﺗطﯾﻊ ﺑﻧﺎء دوال ﺑﻧﻔﺳﻧﺎ‬
            ‫ﻟﻛﻲ ﻧﻣﻧﻊ ﺗﻛرار اﺳطر ﺑرﻣﺟﯾﺔ ﻣﻌﯾﻧﺔ وﻧزﯾد ﻣن ﺳﮭوﻟﺔ ﺗﺗﺑﻊ اﻟﺑرﻧﺎﻣﺞ ﻛﻣﺎ ﻓﻌل اﻟﻣﺑرﻣﺟون ﻓﻲ ﺑﻧﺎء دوال‬

                                                                                  ‫ھﯾﻛﻠﯾﺔ دوال )‪(function‬‬
       ‫).……,2‪Type name(parameter1, parameter‬‬
       ‫{‬
       ‫;‪Statement‬‬
       ‫;)‪Return(type‬‬
       ‫}‬
 ‫‪: (Type) ‬ھو ﻧوع اﻟﻘﯾﻣﺔ اﻟﺗﻲ ﺳوف ﺗرﺟﻌﮭﺎ اﻟداﻟﺔ )‪ (function‬ﺑﻌد أن ﺗﻧﺗﮭﻲ ﻣن ﻋﻣﻠﮭﺎ .ﻻن اﻟدوال ﺗﻛون‬
                                                                                      ‫ﻋﻠﻰ ﻧوﻋﯾن‬

 ‫١.اﺣدھﺎ ﺗﻌﯾد ﺑﻌد اﺳﺗدﻋﺎﺋﮭﺎ وﺗﻛون ﺑﺷﻛل اﻟﺗﺎﻟﻲ ﻋﻧد اﺳﺗدﻋﺎﺋﮭﺎ وﯾﺟب أن ﺗﺣﺗوي ﻋﻠﻰ)‪ (return‬ﻟﺗﻌﯾد ﻗﯾﻣﺔ ﻟﻠﺑرﻧﺎﻣﺞ‬

                                                                                                      ‫ﻛود‬
       ‫;)..…,2‪1. reslt =name(var1,var‬‬
    ‫وﺑﻣﺎ أﻧﮭﺎ ﺗﻌﯾد ﻗﯾﻣﺔ ﯾﺟب ﺧزن اﻟﻘﯾﻣﺔ اﻟﻣﻌﺎدة ﻓﻲ ﻣﺗﻐﯾر ﺑﻧﻔس ﻧوع اﻟﻘﯾﻣﺔ اﻟﻣﻌﺎدة اي ﻟو ﻛﺎن ﻧوع اﻟﻘﯾﻣﺔ اﻟﻣﻌﺎدة ھو‬
     ‫)‪ (integer‬ﯾﺟب أن ﯾﺗم ﺗﻌرﯾف )‪ (reslt‬ﻋﻠﻰ اﻧﮫ ﻣﺗﻐﯾر ﻣن ﻧوع )‪ (integer‬ﻟﺗﺧزن ﺑﮫ اﻟﻧﺗﯾﺟﺔ اﻟﻘﯾﻣﺔ اﻟﻣرﺟﻌﺔ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                           ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




‫٢.اﻟﺛﺎﻧﯾﺔ ﻻ ﺗﻌﯾد أي ﻗﯾﻣﺔ ﻟﻠﺑرﻧﺎﻣﺞ ﺗﺳﺗدﻋﻰ ﻟﺗﻧﻔذ ﻣﺎ ﻓﻲ داﺧﻠﮭﺎ وﯾﻧﺗﮭﻲ ﻛل ﺷﻲء وﻻ ﺗﺣﺗوي ﻓﻲ داﺧﻠﮭﺎ ﻋﻠﻰ )‪(return‬‬
                               ‫ﻷﻧﮭﺎ ﻻ ﺗﻌﯾد أي ﻗﯾﻣﺔ وطرﯾﻘﺔ اﺳﺗدﻋﺎﺋﮭﺎ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ ﻓﻘط ﻧﻛﺗب اﺳم اﻟداﻟﺔ ھﻛذا‬

                                                                                                      ‫ﻛود‬
       ‫;)..…,2‪name(var1,var‬‬
  ‫‪ :(name) ‬ھو اﺳم اﻟداﻟﺔ )‪ (function‬وﯾﻣﻛن أن ﯾﻛون أي اﺳم ﻟﻛن ﻟﻠوﺿوح اﺟﻌل اﺳم اﻟداﻟﺔ داﻻ ﻋﻠﻰ‬
                     ‫ﻋﻣل داﻟﺗك ﻓﻠو ﺑﻧﯾت داﻟﺔ ﺗﺟﻣﻊ رﻗﻣﯾﯾن ﻓﺳﻣﻲ اﻟداﻟﺔ )‪ (addition‬ﺣﺗﻰ ﺗﻛون واﺿﺣﺔ.‬
 ‫‪:(parameter) ‬ھﻲ ﻣﺗﻐﯾرات ﯾﺗم إرﺳﺎل ﻗﯾم إﻟﻰ اﻟداﻟﺔ ﻟﻧﻣﺛﻠﮭﺎ داﺧل اﻟداﻟﺔ ﻟﻐرض ﺗﻧﻔﯾذ اﻟﻌرض اﻟﻣطﻠوب‬
       ‫وﺗﻘوم اﻟداﻟﺔ ﺑﺎﺳﺗﻘﺑﺎل اﻟﻣﺗﻐﯾرات اﻟﻣرﺳﻠﺔ ﺣﺳب اﻟﺗرﺗﯾب .وﻛل ﻣﺗﻐﯾر داﺧل اﻟداﻟﺔ ﯾﺟب ﺗﻌرﯾﻔﮫ ﻣﺛﺎل.‬

                                                                                                      ‫ﻛود‬
       ‫;}‪Int disp(parameter1, parameter2,……) { statement‬‬


        ‫اﺳﺗدﻋﺎء اﻟداﻟﺔ ﻣن داﺧل اﻟﺑرﻧﺎﻣﺞ )..……, 2‪Reslt=disp(var1 , var‬‬

                    ‫ﻛﻣﺎ ﺗﻼﺣظ ﻓﻲ اﻻﺳﺗدﻋﺎء ﻛﺎن ﺑﺎﻟﺗﺳﻠﺳل أﺳﻧدت ﻗﯾﻣﺔ)1‪(parameter2= var2, parameter1= var‬‬

                                                                              ‫ﺗﺳﻠﺳل ﺗﻧﻔﯾذ اﻟﺧطوات ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬




‫ﺗﺳﻠﺳل ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ ﯾﺑدأ ﺧطوة ﺧطوة ﻟﻛن ﻻﺣظ ﻋن وﺻول إﻟﻰ اﻟﺧطوة رﻗم )٥( ﺗم اﺳﺗدﻋﺎء داﻟﺔ ﻟذاﻟك ﺳﯾﻧﻘل ﺗﻧﻔﯾذ‬
 ‫اﻟﺑرﻧﺎﻣﺞ ﻟﮭﺎ ﻟﻛﻲ ﯾﻧﻔذ اﻟﺧطوات رﻗم)8—6( اﻟﺗﻲ ﻓﻲ داﺧﻠﮭﺎ ﺛم ﯾﻌود إﻟﻰ اﻟﺑرﻧﺎﻣﺞ ﺣﺗﻰ ﯾﻧﻔذ ﺧطوة رﻗم )٩و٠١و١١(‬
                             ‫‪: (Statement) ‬ھﻲ اﻟﻌﻣﻠﯾﺔ اﻟﻣراد ﻣن اﻟداﻟﺔ ﺗﻧﻔﯾذھﺎ ﻋﻧد اﺳﺗدﻋﺎﺋﮭﺎ.‬
                                                                                                                 ‫ﻣﮭم‬

  ‫١. اﻟﻣﺗﻐﯾرات اﻟﻣﻌرﻓﺔ داﺧل اﻟدوال ﺗﻧﺗﮭﻲ ﺣﯾﺎﺗﮭﺎ ﺑﺎﻧﺗﮭﺎء ﺗﻧﻔﯾذ أﺧر ﺳطر ﻓﻲ اﻟداﻟﺔ. أي ﻟو ﻛﺎن ﻣﺗﻐﯾر)‪ (i‬ﻓﻲ اﻟداﻟﺔ‬
    ‫أﺻﺑﺣت ﻗﯾﻣﺗﮫ )5=‪ (i‬ﻋﻧد اﻧﺗﮭﺎء ﺗﻧﻔﯾذ اﻟداﻟﺔ ﻓﻌﻧد اﺳﺗدﻋﺎء اﻟداﻟﺔ ﻣرة أﺧرى ﻻ ﺗﻛون ﻗﯾﻣﺗﮫ ﺧﻣﺳﺔ ﻻن ﺣﯾﺎﺗﮫ اﻧﺗﮭت‬
                                               ‫ﺑﺎﻧﺗﮭﺎء اﻻﺳﺗدﻋﺎء اﻟﺳﺎﺑق وﻋﺎد إﻟﻰ ﻗﯾﻣﺗﮫ اﻷوﻟﯾﺔ ﻗﺑل اﻟﺗﻐﯾر.........!‬
                                                                 ‫٢. وﺗﻛﺗب اﻟداﻟﺔ ﺑﻌد اﻟﺗﺻرﯾﺢ ﻋن اﻟﻣﻛﺗﺑﺎت ﻣﺑﺎﺷرة‬
                                   ‫٣.اﻟداﻟﺔ اﻟﺗﻲ ﺗﺗم ﻛﺗﺎﺑﺗﮭﺎ ﺗﻌﺎﻣل داﺧل اﻟﺑرﻧﺎﻣﺞ ﺣﺎﻟﮭﺎ ﻛﺣﺎل أي داﻟﺔ ﻣن دوال اﻟﻠﻐﺔ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                               ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                                     ‫ﻣﺛﺎل: داﻟﺔ )‪ (function‬ﺗﻘوم ﺑﺟﻣﻊ رﻗﻣﯾﯾن وﺗﻌﯾد اﻟﻧﺗﯾﺟﺔ إﻟﻰ اﻟﺑرﻧﺎﻣﺞ..؟‬
  ‫ﺗﺣﻠﯾل: ﻣن اﻟﺳؤال ﻧﻔﮭم أن ھذه اﻟداﻟﺔ ﺗﺣﺗوي ﻋﻠﻰ )‪ (parameter‬اﺛﻧﺎن ﻛل واﺣد ﺧﺎص ﺑرﻗم ﻣﻌﯾن وﺗﻌﯾد ﻗﯾﻣﺔ ﻣن‬
                                                                              ‫ﻧوع )‪ (integer‬وھﻲ اﻟﻧﺗﯾﺟﺔ.‬

 ‫++‪c‬‬                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
 ‫)‪1.int addi on(int a,int b‬‬                                ‫)‪1.int addi on(int a,int b‬‬
 ‫{‬                                                         ‫{‬
 ‫;‪2.int reslt‬‬                                              ‫;‪2.int reslt‬‬
 ‫;‪3.reslt=a+b‬‬                                              ‫;‪3.reslt=a+b‬‬
 ‫;)‪4.return( reslt‬‬                                         ‫;)‪4.return( reslt‬‬
 ‫}‬                                                         ‫}‬
 ‫)(‪5.main‬‬                                                  ‫)(‪5.main‬‬
 ‫;‪6.{int reslt‬‬                                             ‫;‪6.{int reslt‬‬
 ‫;)7,3(‪7.reslt= addi on‬‬                                    ‫;)7,3(‪7.reslt= addi on‬‬
 ‫;"‪8.cout<< reslt<<"\n‬‬                                     ‫;)‪8.printf("%d\n", reslt‬‬
 ‫;)3,2(‪9.reslt= addition‬‬                                   ‫;)3,2(‪9.reslt= addition‬‬
 ‫;"‪10.cout<< reslt<<"\n‬‬                                    ‫;)‪10. printf("%d\n", reslt‬‬
 ‫}‬                                                         ‫}‬
                                                                                                  ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                    ‫١.ﺧطوة رﻗم )١( ھﻲ ﺗﻌرﯾف داﻟﺔ ﻟﺟﻣﻊ ﻣﺗﻐﯾرﯾن وﺗﻌﯾد ﻗﯾﻣﺔ ﻣن ﻧوع )‪(integer‬‬

                              ‫٢.ﺧطوة رﻗم )٢( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ﺟدﯾد وﺧطوة رﻗم)٣( ﺟﻣﻌﻧﺎ اﻟﻣﺗﻐﯾرﯾن اﻟﻠذان ﺗم إرﺳﺎﻟﮭﻣﺎ‬
           ‫ﻣﮭم‬
                                                                  ‫٣.ﺧطوة رﻗم )٤( ﺗم إﻋﺎدة ھذه اﻟﻘﯾﻣﺔ إﻟﻰ اﻟﻣﺻﻔوﻓﺔ‬

     ‫٤.ﺧطوة رﻗم )٦( ﺗم ﺗﻌرﯾف ﻣﺗﻐﯾر ﺑﺎﺳم )‪ (reslt‬ﻟﻛﻲ ﯾﺟﻣل ﻧﺗﯾﺟﺔ اﻟﺟﻣﻊ وھﻧﺎك ﻣﺗﻐﯾر داﺧل اﻟداﻟﺔ)‪(addition‬‬
        ‫ﺑﻧﻔس اﻻﺳم ﻟﻛن ﻻ ﯾؤﺛر ﻋﻠﯾﮫ ﻻن اﻟﻣﺗﻐﯾرات داﺧل اﻟداﻟﺔ ﺗﻛون ﻏﯾر ﻣﻌرﻓﺔ ﻟﻠﻣﺗﻐﯾرات داﺧل اﻟﺑرﻧﺎﻣﺞ وﻛذاﻟك‬
                                              ‫اﻟﻣﺗﻐﯾرات داﺧل اﻟﺑرﻧﺎﻣﺞ ﺗﻛون ﻏﯾر ﻣﻌرﻓﺔ ﻟﻠﻣﺗﻐﯾرات داﺧل اﻟداﻟﺔ‬

                                             ‫٥.ﺧطوة رﻗم)٧( ﺗم اﺳﺗدﻋﺎء داﻟﺔ اﻟﺟﻣﻊ وإﻋطﺎء ﻗﯾﻣﺔ)7=‪ (a=3,b‬ھﻛذا‬

                                                                                                          ‫ﻛود‬
        ‫)‪Int addition(int a,int b‬‬
                                                                           ‫ﻟﻛﻲ ﯾﻧﻔذ ﺧطوة رﻗم)4—1( ﺟﺎﻣﻌﺎ ً اﻟرﻗﻣﯾن‬
       ‫)7 ,3( ‪Reslt= addition‬‬
                                                                            ‫اﻟذان ﺗم ارﺳﺎﻟﮭﻣﺎ ﻟﻠداﻟﺔ ﻓﻲ ﺧطوة رﻗم )٣(‬

  ‫٦.ﺧطوة رﻗم)٨( ﺗم طﺑﺎﻋﺔ ﻧﺎﺗﺞ اﻟﺟﻣﻊ وھو ﻋﺷرة ) ﻓﻲ ﻟﻐﺔ ‪ C‬اﺳﺗﺧدﻣﺎ "‪ "%d‬ﻻ اﻟﻘﯾﻣﺔ اﻟﻣﻌﺎدة ھﻲ ‪(integer‬‬

  ‫٧. ﺧطوة رﻗم)٩( ﺗم اﺳﺗدﻋﺎء داﻟﺔ اﻟﺟﻣﻊ ﻣرة أﺧرى وإﻋطﺎء ﻗﯾﻣﺔ)3=‪ (a=2,b‬ھﻛذا وﯾطﺑﻊ ﻧﺎﺗﺞ اﻟﺟﻣﻊ ﻓﻲ اﻟﺧطوة‬
                                                                       ‫رﻗم)٠١( وﻧﺎﺗﺞ اﻟﺟﻣﻊ ھو ﺧﻣﺳﺔ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                     ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                         ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                                                 ‫٢.٥- دوال )‪ (function‬ﺑدون ﻗﯾﻣﺔ ﻣﻌﺎدة :‬
   ‫وھﻲ اﻟدوال اﻟﺗﻲ ﻻ ﺗﺣﺗوي ﻋﻠﻰ ﻗﯾﻣﺔ ﻣرﺟﻌﺔ إﻟﻰ اﻟﺑرﻧﺎﻣﺞ.أي ﺗﻧﻔذ ﻣﺎ ﻓﻲ داﺧﻠﮭﺎ وﻻ ﺗﻌﯾد أي ﻗﯾﻣﺔ إﻟﻰ اﻟﺑرﻧﺎﻣﺞ ﻗد‬
                                                                   ‫ﺗﺳﺗﻘﺑل ﻗﯾم ﻟﻛﻧﮭﺎ ﻻ ﺗﻌﯾد أي ﻗﯾﻣﺔ وﺗﻌرف ھﻛذا‬

                                                                                                    ‫ﻛود‬
       ‫;}‪name(parameter1, parameter2,……) { statement‬‬


                                              ‫ﻣﺛﺎل: داﻟﺔ )‪ (function‬ﺗﻘوم ﺑطﺑﺎﻋﺔ رﺳﺎﻟﺔ ﻣﻌﯾﻧﺔ ﻋﻧد اﺳﺗدﻋﺎﺋﮭﺎ..؟‬

                                           ‫ﺗﺣﻠﯾل:ھذه اﻟداﻟﺔ ﺗطﺑﻊ رﺳﺎﻟﺔ أي ﻻ ﺗرﺟﻊ أي ﻗﯾﻣﺔ وﻻ ﺗﺳﺗﻘﺑل أي ﻗﯾﻣﺔ‬

 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                            ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                    ‫>‪#include<stdio.h‬‬
 ‫)(‪1. massageShow‬‬                                       ‫)(‪1. massageShow‬‬
 ‫{‬                                                      ‫{‬
 ‫;;"‪2.cout>>"hi Mr.hussien‬‬                              ‫;)"‪2.prin ("hi Mr.hussien‬‬
 ‫}‬                                                      ‫}‬
 ‫)(‪3.main‬‬                                               ‫)(‪3.main‬‬
 ‫{‬                                                      ‫{‬
 ‫)(‪4. massageShow‬‬                                       ‫)(‪4. massageShow‬‬
 ‫}‬                                                      ‫}‬
                                                                                            ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                                ‫١. ﺧطوة رﻗم)١( ھﻲ داﻟﺔ ﻻ ﺗﺳﺗﻘﺑل أي ﻣﺗﻐﯾر وﻻ ﺗﻌﯾد أي ﻣﺗﻐﯾر ﻟذﻟك ﺗﻛﺗب ھﻛذا‬
                                             ‫٢. ﺧطوة رﻗم)٢( ھﻲ اﻟرﺳﺎﻟﺔ اﻟﺗﻲ ﺳﯾﺗم طﺑﺎﻋﺗﮭﺎ ﻋﻧد اﺳﺗدﻋﺎء اﻟداﻟﺔ‬
                                           ‫٣.ﺧطوة رﻗم)٤( ھﻲ اﺳﺗدﻋﺎء ﻟداﻟﺔ اﻟطﺑﺎﻋﺔ ﻟطﺑﺎﻋﺔ اﻟرﺳﺎﻟﺔ اﻟﻣطﻠوﺑﺔ.‬

                                                                   ‫ﻣﺛﺎل : داﻟﺔ ﺗطﺑﻊ رﻗم ﻣﻌﯾن ﯾﺗم إرﺳﺎﻟﮫ ﻟﮭﺎ...‬
                                      ‫ﺗﺣﻠﯾل:ﺑﻣﺎ أﻧﮭﺎ ﺗطﺑﻊ ﻗﯾﻣﺔ ﺗرﺳل ﻟﮭﺎ أي ﺗﺳﺗﻘﺑل ﻗﯾﻣﺔ واﺣدة وﻻ ﺗﻌﯾد أي ﻗﯾﻣﺔ.‬

 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                            ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                    ‫>‪#include<stdio.h‬‬
 ‫)‪1. massageShow(int a‬‬                                  ‫)‪1. massageShow(int a‬‬
 ‫{‬                                                      ‫{‬
 ‫;‪2.cout<<" the number send is="<<a‬‬                     ‫;)‪2.prin ("the number send is=%d",a‬‬
 ‫}‬                                                      ‫}‬
 ‫)(‪3.main‬‬                                               ‫)(‪3.main‬‬
 ‫{‬                                                      ‫{‬
 ‫)3(‪4. massageShow‬‬                                      ‫)3(‪4. massageShow‬‬
 ‫}‬                                                      ‫}‬
      ‫ﺗوﺿﯾﺢ ﺧطوات: ﺧطوة رﻗم واﺣد ھﻲ داﻟﺔ ﺗﺳﺗﻘﺑل ﻗﯾﻣﺔ واﺣد ﻻ ﺗﻌﯾد أي ﻗﯾﻣﺔ وﺧطوة رﻗم)٢(ﺗطﺑﻊ ھذه اﻟﻘﯾﻣﺔ‬
                                                   ‫وﺧطوة رﻗم )٤( ھو اﺳﺗدﻋﺎء ﻟﮭذه اﻟداﻟﺔ ﻣن داﺧل اﻟﺑرﻧﺎﻣﺞ.‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                           ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                                                             ‫٣.٥- اﻹرﺳﺎل ﺑﺎﻟﻘﯾﻣﺔ واﻹرﺳﺎل ﺑﺎﻟﻣرﺟﻊ:‬
                           ‫ﻣﮭم‬
                                                               ‫ﻹرﺳﺎل ﻣﺗﻐﯾرات إﻟﻰ داﻟﺔ ﯾﺟب أن ﺗرﺳل ﺑﺄﺣد اﻟطرﯾﻘﺗﯾن‬

‫١. اﻹرﺳﺎل ﺑﺎﻟﻘﯾﻣﺔ:ﺗرﺳل ﻓﻘط ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر إﻟﻰ اﻟداﻟﺔ أي إذا ﺗﻐﯾر ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر داﺧل اﻟداﻟﺔ ﻻ ﺗﺗﻐﯾر ﻗﯾﻣﺗﮫ اﻷﺻﻠﯾﺔ‬
   ‫داﺧل اﻟﺑرﻧﺎﻣﺞ ﻷﻧﻧﺎ أرﺳﻠﻧﺎ ﻓﻘط ﻗﯾﻣﺗﮫ إﻟﻰ اﻟداﻟﺔ ﻟﻣﻌﺎﻟﺟﺗﮭﺎ .)أي ﻻ ﺗﻌﺎد أﻛﺛر ﻣن ﻗﯾﻣﺔ واﺣدة إﻟﻰ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ(‬

  ‫ﻣﺛﺎل: ﺑﻧﺎء داﻟﺔ ﺗﻌﻣل ﻧﻔس ﻋﻣل اﻟداﻟﺔ )‪ (pow‬اﻟﺗﻲ ﺗﺟد ﻗﯾﻣﺔ اﻟرﻗم ﻣرﻓوع إﻟﻰ أس )‪ (x^n‬وﻟﻧﺳﻣﯾﮭﺎ)‪ (powA‬ﻣﻌﻧﺎه‬
                                 ‫ھذه اﻟداﻟﺔ ﻋرﺑﯾﺔ ﻓﻘط ﻟﻠﺗﻣﯾز ﺑﯾﻧﮭﺎ وﺑﯾن اﻷﺻﻠﯾﺔ واﻻﺛﻧﺎن ﯾؤدﯾﺎن ﻧﻔس اﻟﻌﻣل .‬

 ‫++‪c‬‬                                          ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                          ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                         ‫>‪#include<stdio.h‬‬
 ‫)‪1.int powA(int x,int n‬‬                                     ‫)‪1.int powA(int x,int n‬‬
 ‫{‬                                                           ‫{‬
 ‫;1= ‪2.int i, reslt‬‬                                          ‫;1= ‪2.int i, reslt‬‬
 ‫)++‪3.for(i=0 ;i<n ;i‬‬                                        ‫)++‪3.for(i=0 ;i<n ;i‬‬
 ‫;‪4. reslt = reslt *x‬‬                                        ‫;‪4. reslt = reslt *x‬‬
 ‫;)‪5.return( reslt‬‬                                           ‫;)‪5.return( reslt‬‬
 ‫}‬                                                           ‫}‬
 ‫)(‪6.main‬‬                                                    ‫)(‪6.main‬‬
 ‫;‪7.{int reslt,x,n‬‬                                           ‫;‪7.{int reslt,x,n‬‬
 ‫;4=‪8.x=3,n‬‬                                                  ‫;4=‪8.x=3,n‬‬
 ‫;)‪9.reslt= powA (x,n‬‬                                        ‫;)‪9.reslt= powA (x,n‬‬
 ‫;"‪10.cout<<" powA="<<reslt<<"\n‬‬                             ‫; )‪10. printf("powA=%d\n", reslt‬‬
 ‫;2=‪11.x=5,n‬‬                                                 ‫;2=‪11.x=5,n‬‬
 ‫;)‪12.reslt= powA (x,n‬‬                                       ‫;)‪12.reslt= powA (x,n‬‬
 ‫};"‪13.cout<<" powA="<<reslt<<"\n‬‬                            ‫}; )‪13. prin ("powA=%d\n", reslt‬‬
                                                                                                ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                                   ‫١.ﺧطو رﻗم)١ إﻟﻰ ٥( ھﻲ داﻟﺔ ﻹﯾﺟﺎد ﻗﯾﻣﺔ أي رﻗم ﻣرﻓوع إﻟﻰ أس‬

                  ‫٢.ﺧطوة رﻗم )٨( ھو إﻋطﺎء ﻗﯾم ﻟﻠﻣﺗﻐﯾر وﻷس اﻟﻣراد إﯾﺟﺎده واﻟﻣطﻠوب ھﻧﺎ )‪ (x^n‬أي اﻧﮫ )4^3(‬
     ‫ﻣﮭم‬
                           ‫٣.ﺧطوة رﻗم )٩( ﺗم إرﺳﺎل ﻗﯾم اﻟﻣﺗﻐﯾرﯾن )‪ (x,n‬داﻟﺔ )‪ (powA‬ﻹﯾﺟﺎد ﺣل ل)4^3( ھﻛذا‬

                                                                                                      ‫ﻛود‬
       ‫)‪Int powA (int x,int n‬‬
                       ‫3‬         ‫4‬

        ‫)‪Reslt= powA (x , n‬‬

 ‫ﻟو ﺗﻼﺣظ ﺗم إرﺳﺎل ﻗﯾم اﻟﻣﺗﻐﯾرﯾن وﻟﯾس اﻟﻣﺗﻐﯾرﯾن ﻧﻔﺳﮭﻣﺎ وھذا ﻣﺎ ﯾﺳﻣﻰ ﺑﺎﻹرﺳﺎل ﺑﺎﻟﻘﯾﻣﺔ )أي أن اﻟﻣﺗﻐﯾر)‪(x,n‬‬
                                                    ‫ﻓﻲ اﻟداﻟﺔ ﻟﯾس ﻧﻔس اﻟﻣﺗﻐﯾر )‪ (x,n‬ﻓﻲ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ‬

                                     ‫٤.ﺧطوة رﻗم)٠١( ﺗم إرﺳﺎل ﻗﯾم اﻟﻣﺗﻐﯾرﯾن )‪ (x,n‬داﻟﺔ )‪ (powA‬ﻹﯾﺟﺎد ﺣل )2^5(‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                          ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬
                                                                                                               ‫ﻣﮭم‬


 ‫٢. اﻹرﺳﺎل ﺑﺎﻟﻣرﺟﻊ:ﺗرﺳل ﻣوﻗﻊ اﻟﻣﺗﻐﯾر إﻟﻰ اﻟداﻟﺔ أي أن اﻟداﻟﺔ ﺗﺳﺗﻘﺑل اﻟﻣﺗﻐﯾر ﻧﻔﺳﮫ اﻟﻣرﺳل ﺑﻧﻔس اﻻﺳم أو ﺑﺄس‬
       ‫ﻣﺎﺧر. أي إذا ﺗﻐﯾر ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر داﺧل اﻟداﻟﺔ ﺗﺗﻐﯾر ﻗﯾﻣﺗﮫ اﻷﺻﻠﯾﺔ داﺧل اﻟﺑرﻧﺎﻣﺞ ﻷﻧﻧﺎ أرﺳﻠﻧﺎ ﻣوﻗﻌﮫ إﻟﻰ اﻟداﻟﺔ‬
                                                                 ‫واﻟﺗﻐﯾر ﯾﻛون ﻓﻲ ﻣﺣﺗوى اﻟﻣوﻗﻊ . وﺷﻛﻠﮭﺎ ھﻛذا‬

                                                                                                     ‫ﻛود‬
       ‫;}‪Type name(&parameter1, &parameter2,……) { statement‬‬
            ‫ﻧﺿﻊ )&( ﻗﺑل ﻛل )‪ (parameter‬ﻧرﯾد أن ﻧﻌﯾد اﻟﺗﻐﯾر ﻓﻲ ﻗﯾﻣﺗﮫ ﻟﻠﺑرﻧﺎﻣﺞ ﺑﻣﻌﻧﻰ أﻧﻧﺎ ﺳﻧﺳﺗﻘﺑل اﻟﻣوﻗﻊ.‬
       ‫وﻓﺎﺋدة اﻹرﺳﺎل ﺑﺎﻟﻣرﺟﻊ ھو أن اﻹرﺳﺎل ﺑﻠﻘﯾﻣﺔ ﻻ ﯾﻌﯾد أﻛﺛر ﻣن ﻗﯾﻣﺔ ﻣﺗﻐﯾر واﺣد إﻟﻰ اﻟﺑرﻧﺎﻣﺞ ﺑﯾﻧﻣﺎ ﺑﺎﻹرﺳﺎل‬
                                                        ‫ﺑﺎﻟﻣرﺟﻊ ﻧﺳﺗطﯾﻊ أﻋﺎدة أﻛﺛر ﻣن ﻗﯾﻣﺔ ﻣﺗﻐﯾر إﻟﻰ اﻟﺑرﻧﺎﻣﺞ‬

                                             ‫ﻣﺛﺎل: داﻟﺔ ﻧرﺳل ﻟﮭﺎ ﻣﺗﻐﯾرﯾن وﺗﻘوم ﺑﺿرب ﻛل واﺣد ﻣﻧﮭﻣﺎ ﺑﺧﻣﺳﺔ؟‬

    ‫ﺗﺣﻠﯾل: ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد ﺿرب ﻛل واﺣد ﻣﻧﮭﻣﺎ ﺑﺧﻣﺳﺔ أي أن اﻻﺛﻧﺎن ﯾﺗﻐﯾران وﯾﻌودان إﻟﻰ اﻟداﻟﺔ اﻷﺻﻠﯾﺔ ﺑﻘﯾم ﺟدﯾدة‬
                  ‫وﻧﺣن ﻧﻌﻠم إﻧﻧﺎ ﻧﺳﺗطﯾﻊ إﻋﺎدة ﻗﯾﻣﺔ واﺣدة ﻓﻲ ﺣﺎﻟﺔ اﻹرﺳﺎل ﺑﺎﻟﻘﯾﻣﺔ ﻟذاﻟك ﺳﻧﺳﺗﺧدم اﻹرﺳﺎل ﺑﺎﻟﻣرﺟﻊ‬

 ‫++‪c‬‬                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                  ‫>‪#include<stdio.h‬‬
 ‫)‪1. mulByFive (int & x,int &n‬‬                        ‫)‪1. mulByFive(int & x,int &n‬‬
 ‫{‬                                                    ‫{‬
 ‫;5*‪2. x=x‬‬                                            ‫;5*‪2. x=x‬‬
 ‫;5*‪3. n=n‬‬                                            ‫;5*‪3. n=n‬‬
 ‫}‬                                                    ‫}‬
 ‫)(‪5.main‬‬                                             ‫)(‪4.main‬‬
  ‫;‪6.{int x,n‬‬                                         ‫;‪6.{int x,n‬‬
 ‫;‪7. int y,z‬‬                                          ‫;‪7. int y,z‬‬
 ‫;4=‪8.x=3,n‬‬                                           ‫;4=‪8.x=3,n‬‬
 ‫;)‪9. mulByFive (x,n‬‬                                  ‫;)‪9. mulByFive (x,n‬‬
 ‫;"‪10.cout<<" x="<<x<<"\nn="<<n<<"\n‬‬                  ‫; )‪10. prin ("x=%d\nn=%d\n", x,n‬‬
 ‫;2=‪11.y=5,z‬‬                                          ‫;2=‪11.y=5,z‬‬
 ‫;)‪12. mulByFive (y,z‬‬                                 ‫;)‪12. mulByFive (x,n‬‬
 ‫};"‪13. cout<<" y="<<y<<"\nz="<<z<<"\n‬‬                ‫}; )‪13. prin ("y=%d\nz=%d\n", y,z‬‬
                                                                                             ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

‫١.ﺧطوة رﻗم )٩( أرﺳﻠﻧﺎ ﻗﯾم اﻟﻣﺗﻐﯾرﯾن )4=‪ (x=3,n‬إﻟﻰ اﻟداﻟﺔ وﺗم اﺳﺗﻘﺑﺎﻟﮭﻣﺎ ﺑﺎﻟﻣرﺟﻊ وطرب ﻛل واﺣد ﻣﻧﮭﻣﺎ ﺑﺧﻣﺳﺔ‬
                                                ‫ﻻﺣظ ﺧطوة رﻗم )٠١( ﺳﯾطﺑﻊ ﻗﯾﻣﮭم اﻟﺟدﯾدة ﻣﺿروﺑﺔ ﺑﺧﻣﺳﺔ‬

                                                                                                     ‫ﻛود‬
       ‫)‪Int mulByFive(int &x,int &n‬‬
                         ‫‪x‬‬     ‫‪n‬‬

     ‫, ‪Reslt= mulByFive (x‬‬    ‫)‪n‬‬                             ‫ﻛﻣﺎ ﻧﻼﺣظ ﻣن اﻟﻣﺧطط ﺗم إرﺳﺎل ﻣواﻗﻊ اﻟﻣﺗﻐﯾرات‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                            ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬

                                                                                                               ‫ﻣﮭم‬


    ‫٢. ﺧطوة رﻗم )٢١( أرﺳﻠﻧﺎ ﻗﯾم اﻟﻣﺗﻐﯾرﯾن )5=‪ (y=5,z‬إﻟﻰ اﻟداﻟﺔ وﺗم اﺳﺗﻘﺑﺎﻟﮭﻣﺎ ﺑﺎﻟﻣرﺟﻊ وطرب ﻛل واﺣد ﻣﻧﮭﻣﺎ‬
 ‫ﺑﺧﻣﺳﺔ ﻻﺣظ ﺧطوة رﻗم )٣١( ﺳﯾطﺑﻊ ﻗﯾﻣﮭم اﻟﺟدﯾدة ﻣﺿروﺑﺔ ﺑﺧﻣﺳﺔ ﻛﺎل اﺣﺿﻧﺎ ﻻ ﯾﮭﺗم ﻣﮭﻣﺎ ﻛﺎن اﺳم اﻟﻣﺗﻐﯾر ﻷﻧﮫ‬
                                                          ‫ﺳﯾﺳﺗﻘﺑل ﻣوﻗﻌﮫ ﺑﺎأﺳم أﺧر وﯾﻐﯾر ﻋﻠﻰ اﻟﻘﯾم اﻟﺗﻲ ﻓﯾﮫ‬

                                                                                                       ‫ﻛود‬
       ‫)‪Int mulByFive(int &x,int &n‬‬
                        ‫‪y‬‬      ‫‪z‬‬

     ‫)‪Reslt= mulByFive (y , z‬‬                                  ‫ﻛﻣﺎ ﻧﻼﺣظ ﻣن اﻟﻣﺧطط ﺗم إرﺳﺎل ﻣواﻗﻊ اﻟﻣﺗﻐﯾرات‬
                                                               ‫وﺗم اﻟﺗﻌﺑﯾر ﻋﻧﮭﻣﺎ ﺑﺎﻟداﻟﺔ ﺑﺄﺳﻣﺎء ﺟدﯾدة ﻟﻧﻔس اﻟﻣواﻗﻊ‬

                                                                                                                 ‫ﻣﮭم‬

  ‫وﺑﺎﺧﺗﺻﺎر إذا وﺿﻌﻧﺎ )&( ﻗﺑل أي )‪ .(parameter‬أي ﺗﻐﯾر ﻓﻲ ھذا )‪ (parameter‬ﺳوف ﯾؤﺛر ﻋﻠﻰ ﻗﯾﻣﺗﮫ ﻓﻲ‬
                      ‫اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ .وإذا ﻟم ﻧﺿﻊ ھذه اﻟﻌﻼﻣﺔ ﯾﺑﻘﻰ ﻣﺣﺎﻓظﺎ ﻋﻠﻰ ﻗﯾﻣﺗﮫ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ‬




                                                                                                               ‫ﻣﮭم‬


   ‫إﺳﻧﺎد ﻗﯾم ﻟﻣﺗﻐﯾرات اﻟداﻟﺔ )‪ : (function‬ھﻲ ﻗﯾم ﯾﺗم إﺳﻧﺎدھﺎ ﻟﻠﻣﺗﻐﯾرات ﻓﻲ اﻟداﻟﺔ ﻓﺈذا ﻟم ﻧذﻛر ھذه اﻟﻣﺗﻐﯾرات ﻓﻲ‬
                  ‫اﻻﺳﺗدﻋﺎء ﯾﺗم اﻻﻋﺗﻣﺎد ﻋﻠﻰ ھذه اﻟﻘﯾم وإذا ذﻛرﻧﺎھﺎ وأﻋطﯾﻧﺎھﺎ ﻗﯾﻣﺔ ﯾﺄﺧذ اﻟﻘﯾﻣﺔ اﻟﺗﻲ أﻋطﯾﻧﺎھﺎ ﻟﮫ.‬

                                                         ‫ﻣﺛﺎل: داﻟﺔ ﺗﺣﺗوي ﻋﻠﻰ ﻗﯾﻣﺔ زاﺋدة )داﻟﺔ ﻟﺿرب رﻗﻣﯾن(.؟‬

 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                   ‫>‪#include<stdio.h‬‬
 ‫)3=‪1.int mul (int a,int b‬‬                              ‫)3=‪1.int mul (int a,int b‬‬
 ‫};)‪2. {return(a*b‬‬                                      ‫};)‪2. {return(a*b‬‬
 ‫)(‪3.main‬‬                                               ‫)(‪3.main‬‬
 ‫;)3( ‪4. {cout<<"mul="<< mul‬‬                            ‫;))3( ‪4. {printf("mul=%d\n", mul‬‬
 ‫};)5,3( ‪5. cout<<"\nmul="<< mul‬‬                        ‫};))5,3( ‪5. prin ("mul=%d", mul‬‬
                                                                                               ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                            ‫١.ﺧطوة رﻗم)١( ھﻲ داﻟﺔ ﺗﺳﺗﻘﺑل ﻗﯾﻣﺗﯾن وﺗﻛون ﻗﯾﻣﺔ )‪ (b‬ھﻲ ﻗﯾﻣﺔ زاﺋدة ﻣﺳﺎوﯾﺔ ل )٣(‬

  ‫٢.ﺧطوة رﻗم)٤( ھو اﺳﺗدﻋﺎء ﻟﻠداﻟﺔ وأﻋطﯾﻧﺎ ﻓﻘط ﻗﯾﻣﺔ )‪ (a‬وﻟم ﻧذﻛر اﻟﻣﺗﻐﯾر )‪ (b‬ﻟذاﻟك ﺳﯾﻌﺗﻣد اﻟﻣﺗﻐﯾر )‪ (b‬ﻋﻠﻰ‬
                                   ‫اﻟﻘﯾﻣﺔ اﻟزاﺋدة وھﻲ )٣( وﯾﺿرب )9=3*3( وﯾطﺑﻊ رﻗم )٩( ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬

‫٣.ﺧطوة رﻗم )٥( ھو اﺳﺗدﻋﺎء ﻟﻠداﻟﺔ وأﻋطﯾﻧﺎ ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر )‪ (a,b‬ﻟذاك ﺳﯾﮭﻣل اﻟﻘﯾﻣﺔ اﻟزاﺋدة وﯾﻌﺗﻣد ﻋﻠﻰ ﻗﯾﻣﺔ )5=‪(b‬‬
                                                            ‫وﯾﺿرب )51=5*3( وﯾطﺑﻊ )٥١( ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(Function) ‫اﻟدوال‬                                                                             ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                                         ‫ﻓﺎﺋدة اﻟدوال ﻓﻲ ﺗﻘﻠﯾل ﻋدد اﻻﻛواد اﻟﺑرﻣﺟﯾﺔ وﺗرﺗﯾب اﻟﺑرﻧﺎﻣﺞ‬

                                                                 ‫ﻣﺛﺎل :ﺑرﻧﺎﻣﺞ ﻟرﺳم اﻟﺷﺟرة اﻟﺗﺎﻟﯾﺔ..؟‬

                        ‫ﺗﺣﻠﯾل:ﻋﻧد ﺗﺣﻠﯾﻠﻧﺎ ﻟﮭذه اﻟﺷﺟرة ﻧرى أن اﻟﺟزء اﻟﻣﺛﻠث ﯾﻌﺎد أرﺑﻊ ﻣرات ﻣﻌﻧﺎه‬

                                         ‫ﻧﻔس اﻟﻛود وﺑﻌده ﻛود أﺧر ﻟﻘﺎﻋدة اﻟﺷﺟرة. أي أﻧﻧﺎ ﻟدﯾﻧﺎ ﻛودان‬

                                                        !.. ‫اﺣدھﻣﺎ ﯾﻌﺎد أرﺑﻊ ﻣرات وآﺧر ﻣرة واﺣدة‬

                                                 !.......................(function) ‫اﻟﺣل ﺑدون دوال‬

 c++                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    c                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                     #include<stdio.h>
 main()                                   main()
 {int i,j,k;                              {int i,j,k;
 for(i=1;i<=10;i+=2){                     for(i=1;i<=10;i+=2){
 for(k=i;k<10;k+=2)                       for(k=i;k<10;k+=2)
 cout<<" " ;                              printf(" " );
 for(j=i;j>0;j--)                         for(j=i;j>0;j--)
 cout<<"*" ;                              printf("*") ;
 cout<<"\n" ;                             printf("\n") ;
 }                                        }
 for(i=1;i<=10;i+=2){                     for(i=1;i<=10;i+=2){
 for(k=i;k<10;k+=2)                       for(k=i;k<10;k+=2)
 cout<<" " ;                              printf(" " );
 for(j=i;j>0;j--)                         for(j=i;j>0;j--)
 cout<<"*" ;                              printf("*") ;
 cout<<"\n" ;                             printf("\n") ;
 }                                        }
 for(i=1;i<=10;i+=2){                     for(i=1;i<=10;i+=2){
 for(k=i;k<10;k+=2)                       for(k=i;k<10;k+=2)
 cout<<" " ;                              printf(" " );
 for(j=i;j>0;j--)                         for(j=i;j>0;j--)
 cout<<"*" ;                              printf("*") ;
 cout<<"\n" ;                             printf("\n") ;
 }                                        }
 for(i=1;i<=10;i+=2){                     for(i=1;i<=10;i+=2){
 for(k=i;k<10;k+=2)                       for(k=i;k<10;k+=2)
 cout<<" " ;                              printf(" " );
 for(j=i;j>0;j--)                         for(j=i;j>0;j--)
 cout<<"*" ;                              printf("*") ;
 cout<<"\n" ;                             printf("\n") ;
 }                                        }
 for(i=1;i<=6;i+=2){                      for(i=1;i<=6;i+=2){
 for(k=4;k>0;k-=1)                        for(k=4;k>0;k-=1)
 cout<<" " ;                              printf(" " );
 for(j=3;j>0;j--)                         for(j=3;j>0;j--)
 cout<<"*" ;                              printf("*") ;
 cout<<"\n" ;}}                             printf("\n") ;}}



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                     C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟدوال )‪(Function‬‬                                                                                         ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                                                          ‫اﻟﺣل ﺑﺎﺳﺗﺧدام دوال )‪!.......................(function‬‬

     ‫ﺗﺣﻠﯾل:وﻟو ﻛﺗﺑﺎ اﻟﻛود اﻟﻣﻌﺎد أرﺑﻊ ﻣرات ﻓﻲ داﻟﺔ واﺳﺗدﻋﯾﻧﺎھﺎ أرﺑﻊ ﻣرات وﺑﻌدة ﻧﻛﺗب ﻛود ﻗﺎﻋدة اﻟﺷﺟرة ﻟﺗﺑﺳط‬
                                                                      ‫اﻟﺑرﻧﺎﻣﺞ ﻛﺛﯾرا وأﺻﺑﺢ واﺿﺢ وﺳﮭل.‬

 ‫++‪c‬‬                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                  ‫>‪#include<stdio.h‬‬
   ‫)(‪Draw_tree‬‬                                          ‫)(‪Draw_tree‬‬
  ‫;‪{ int i,j,k‬‬                                         ‫;‪{ int i,j,k‬‬
  ‫{)2=+‪for(i=1;i<=10;i‬‬                                 ‫{)2=+‪for(i=1;i<=10;i‬‬
  ‫)2=+‪for(k=i;k<10;k‬‬                                   ‫)2=+‪for(k=i;k<10;k‬‬
 ‫; " "<<‪cout‬‬                                           ‫; )" "(‪printf‬‬
 ‫)--‪for(j=i;j>0;j‬‬                                      ‫)--‪for(j=i;j>0;j‬‬
 ‫; "*"<<‪cout‬‬                                           ‫; )"*"(‪printf‬‬
 ‫}}; "‪cout<<"\n‬‬                                        ‫}};) "‪printf("\n‬‬
 ‫)(‪main‬‬                                                ‫)(‪main‬‬
 ‫;‪{ int i,j,k‬‬                                          ‫;‪{ int i,j,k‬‬
 ‫;)(‪Draw_tree‬‬                                          ‫;)(‪Draw_tree‬‬
 ‫;)(‪Draw_tree‬‬                                          ‫;)(‪Draw_tree‬‬
 ‫;)(‪Draw_tree‬‬                                          ‫;)(‪Draw_tree‬‬
 ‫;)(‪Draw_tree‬‬                                          ‫;)(‪Draw_tree‬‬
 ‫{)2=+‪for(i=1;i<=6;i‬‬                                   ‫{)2=+‪for(i=1;i<=6;i‬‬
 ‫)1=-‪for(k=4;k>0;k‬‬                                     ‫)1=-‪for(k=4;k>0;k‬‬
 ‫; " "<<‪cout‬‬                                           ‫; )" "(‪printf‬‬
 ‫)--‪for(j=3;j>0;j‬‬                                      ‫)--‪for(j=3;j>0;j‬‬
 ‫; "*"<<‪cout‬‬                                           ‫; )"*"(‪printf‬‬
 ‫}}; "‪cout<<"\n‬‬                                          ‫}};) "‪printf("\n‬‬
  ‫ﻟو ﺗﻼﺣظ ﻛم ﺗﺑﺳط اﻟﻛود وﻛم أﺻﺑﺢ اﻟﺑرﻧﺎﻣﺞ واﺿﺢ ﻋﻧدﻣﺎ وﺿﻌﻧﺎ اﻟﺟزء اﻟﻣﻛرر أرﺑﻊ ﻣرات ﻓﻲ داﻟﺔ واﺳﺗدﻋﯾﻧﺎه‬
                                                ‫أرﺑﻊ ﻣرات ﻓﻛون ﺷﺟرة وﺑﻘﯾﺔ ﻗﺎﻋدة اﻟﺷﺟرة ﻛﺗﺑﻧﺎ ﻛودھﺎ وﺣده.‬

                                                                                                                  ‫ﻣﮭم‬

 ‫اﻟﻣﺗﻐﯾرات اﻟﺗﻲ ﺗﻌرف ﺗﺣت ﺗﻌرﯾف اﻟﻣﻛﺗﺑﺎت ﺗﺳﻣﻰ ﻣﺗﻐﯾرات ﻋﺎﻣﺔ ﺗﻛون ﻣﻌرﻓﺔ ﺑﺎﻟﻧﺳﺑﺔ إﻟﻰ ﺟﻣﯾﻊ أﺟزاء اﻟﺑرﻧﺎﻣﺞ‬
       ‫أي ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو ﻋرﻓﻧﺎ ﻣﺗﻐﯾر اﺳﻣﮫ )‪ (item‬ﯾﻛون ھذا اﻟﻣﺗﻐﯾر ﻣﻌرف ﺑﺎﻟﻧﺳﺑﺔ إﻟﻰ ﺟﻣﯾﻊ اﻟدوال أو إﻟﻰ‬
          ‫اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ ﻋﻠﻰ ﺧﻼف اﻟﻣﺗﻐﯾرات اﻟﺧﺎﺻﺔ اﻟﺗﻲ ﺗﻌرف داﺧل اﻟدوال ﺗﻛون ﻓﻘط ﻣﻌرﻓﺔ ﻧﺳﺑﺔ إﻟﻰ اﻟداﻟﺔ‬
                                                                                                  ‫ﺗوﺿﯾﺢ‬
       ‫<‪#Include‬‬       ‫>‬
       ‫‪Global variable‬‬                 ‫ﻣﺗﻐﯾرات ﻋﺎﻣﺔ ﻣﻌرﻓﺔ إﻟﻰ ﺟﻣﯾﻊ أﺟزاء اﻟﺑرﻧﺎﻣﺞ‬

       ‫)(‪Main‬‬
       ‫{‬
        ‫‪Local variable‬‬              ‫ﻣﺗﻐﯾرات ﺧﺎﺻﺔ ﺗﻛون ﻣﻌرﻓﺔ ﻓﻘط داﺧل اﻟداﻟﺔ ) ‪(main‬‬
       ‫}‬
 ‫وھذه اﻟﻣﺗﻐﯾرات ﻻ ﺗﻧﺗﮭﻲ ﺣﯾﺎﺗﮭﺎ إﻻ ﺑﺎﻧﺗﮭﺎء اﻟﺑرﻧﺎﻣﺞ وﺗﺑﻘﻰ ﻣﺣﺎﻓظﺔ ﻋﻠﻰ ﻗﯾﻣﮭﺎ اﻟﺟدﯾدة وﻻ ﺗﻌود ﻟﻘﯾﻣﺗﮭﺎ اﻟﺑداﺋﯾﺔ.‬
                                                        ‫ﻧﺳﺗطﯾﻊ ﺗﻌرﯾف واﺳﺗﺧدام أﻛﺛر ﻣن داﻟﺔ ﻓﻲ ﺑرﻧﺎﻣﺞ واﺣد..‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                             ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬

                                                                                                                ‫ﻣﮭم‬


     ‫:ھﻲ ﻣﺟﻣوﻋﺔ دوال ﻟﮭﺎ ﻧﻔس اﻻﺳم وﺗﺧﺗﻠف ﻓﻲ اﻟﻘﯾﻣﺔ اﻟﻣﻌﺎدة أو ﺗﺧﺗﻠف ﻓﻲ ﻧوع‬             ‫٤.٥- اﻟدوال اﻟزاﺋدة‬
  ‫)‪ (parameter‬اﻟﻣﺳﺗﻘﺑل ﻟﻠداﻟﺔ. ﻓﻌﻧد اﺳﺗدﻋﺎء اﺣد ھذه اﻟدوال وﺑﻣﺎ أﻧﮭﺎ ﺟﻣﯾﻌﺎ ﺑﻧﻔس اﻻﺳم ﻟذاﻟك ﺳوف ﯾﺳﺗدﻋﻲ‬
                             ‫اﻟﻣﺗرﺟم اﻟداﻟﺔ اﻟﺗﻲ ﺗﺳﺗﻘﺑل اﻗرب ﻧوع ﻟﻠﻣﺗﻐﯾر اﻟذي أرﺳﻠﺗﮫ ﻟﮭﺎ أو ﻧﻔس اﻟﻧوع.‬

    ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﯾﺣوي ﻋﻠﻰ دوال اﻵﺗﯾﺔ اﺣدھﺎ ﺗﺟﻣﻊ اﻟرﻗﻣﯾن واﻷﺧرى ﺗﻘﺳﻣﮭم واﻷﺧرى ﺗﺿرﺑﮭم وﻟﮭم ﻧﻔس اﻻﺳم؟‬

 ‫++‪c‬‬                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                     ‫>‪#include<stdio.h‬‬
 ‫)‪1.int opera on (int a, int b‬‬                           ‫)‪1.int opera on (int a, int b‬‬
 ‫};)‪2. {return(a*b‬‬                                       ‫};)‪2. {return(a*b‬‬
 ‫)‪3. float operation (float a , int b‬‬                    ‫)‪3.float opera on (float a, float b‬‬
 ‫};)‪4. {return(a+b‬‬                                       ‫};)‪4. {return(a/b‬‬
 ‫)‪5.float operation (float a, float b‬‬                    ‫)‪5. float opera on (float a , int b‬‬
 ‫};)‪6. {return(a/b‬‬                                       ‫};)‪6. {return(a+b‬‬
 ‫)(‪7.main‬‬                                                ‫)(‪7.main‬‬
 ‫;2=‪8. {int a=3,b‬‬                                        ‫;2=‪8. {int a=3,b‬‬
 ‫;5.4=‪9.float c=2.5,d‬‬                                     ‫;5.4=‪9.float c=2.5,d‬‬
 ‫;)‪10.cout<<"reslt="<< opera on (a,b‬‬                     ‫;))‪10. printf("reslt=%d\n", operation (a,b‬‬
 ‫;)‪11. cout<<"\n reslt="<< operation (c,d‬‬                ‫;) )‪11. printf("reslt=%f\n", operation (c,d‬‬
 ‫;)‪12. cout<<"\n reslt="<< operation (c,a‬‬                ‫;) )‪12. printf("reslt=%f\n", operation (c,a‬‬
 ‫}‬                                                       ‫}‬
                                                                                                 ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

  ‫١.ﺧطوة رﻗم )٠١( ﺗم إرﺳﺎل ﻣﺗﻐﯾرﯾن )‪(a,b‬ﻣن ﻧوع ‪ integer‬ﻟذاﻟك ﺳﺗﺳﺗﻘﺑﻠﮫ اﻟداﻟﺔ ﻓﻲ اﻟﺧطوة رﻗم )١( وﺗﺿرب‬
                                                   ‫اﻟرﻗﻣﯾﯾن ﻻن ھذه اﻟداﻟﺔ ﺗﺳﺗﻘﺑل اﻟﻣﺗﻐﯾرﯾن ﻣن ﻧوع ‪integer‬‬

                                                                                                        ‫ﻛود‬
        ‫)‪1.int opera on (int a, int b‬‬
                              ‫3‬         ‫2‬
                  ‫, ‪operation ( a‬‬    ‫)‪b‬‬

        ‫٢.ﺧطوة رﻗم )١١( ﺗم إرﺳﺎل ﻣﺗﻐﯾرﯾن )‪(c,d‬ﻣن ﻧوع ‪ float‬ﻟذاﻟك ﺳﺗﺳﺗﻘﺑﻠﮫ اﻟداﻟﺔ ﻓﻲ اﻟﺧطوة رﻗم )5( وﺗﻘﺳم‬
                                                         ‫اﻟرﻗﻣﯾﯾن ﻻن ھذه اﻟداﻟﺔ ﺗﺳﺗﻘﺑل اﻟﻣﺗﻐﯾرﯾن ﻣن ﻧوع ‪float‬‬

                                                                                                        ‫ﻛود‬
        ‫)‪5.float operation (float a, float b‬‬
                                    ‫5.2‬      ‫5.4‬

                      ‫, ‪operation ( x‬‬       ‫)‪n‬‬

    ‫٣.ﺧطوة رﻗم )٢١( ﺗم إرﺳﺎل ﻣﺗﻐﯾرﯾن )‪(a‬ﻣن ﻧوع ‪ (c ) , integer‬ﻣن ﻧوع ‪ float‬ﻟذاﻟك ﺳﺗﺳﺗﻘﺑﻠﮫ اﻟداﻟﺔ ﻓﻲ‬
            ‫اﻟﺧطوة رﻗم )3( وﺗﺟﻣﻊ اﻟرﻗﻣﯾﯾن ﻻن ھذه اﻟداﻟﺔ ﺗﺳﺗﻘﺑل ﻣﺗﻐﯾر ﻣن ﻧوع ‪ integer‬وﻣﺗﻐﯾر ﻣن ﻧوع ‪float‬‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                           ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬

                                                                                                                 ‫ﻣﮭم‬


                                            ‫٥.٥- اﺳﺗدﻋﺎء اﻟداﻟﺔ ﻟﻧﻔﺳﮭﺎ )‪:(Recursively‬‬
‫وﺗﺳﻣﻰ أﯾﺿﺎ )‪ ( Recursive Function‬أي اﺳﺗدﻋﺎء اﻟداﻟﺔ ﻟﻧﻔﺳﮭﺎ ﻟﻣرة أو أﻛﺛر ﻣن ﻣرة.ﻓﺗﻛون ﺷﻛﻠﮭﺎ ﻣﻌروف أﻧﮭﺎ‬
                ‫ﻣن داﺧل داﻟﺔ )‪ (function‬ﻧﻘوم ﺑﺎﺳﺗدﻋﺎﺋﮭﺎ ﻟﻧﻔﺳﮭﺎ)أي ﯾذﻛر اﺳﻣﮭﺎ ﻓﻲ داﺧﻠﮭﺎ( وﯾﻛون ﺷﻛﻠﮭﺎ ھﻛذا‬

                                                                        ‫ھﯾﻛﻠﯾﺔ دوال )‪( Recursive function‬‬
        ‫).……,2‪Type name(parameter1, parameter‬‬
        ‫{‬
        ‫;‪Statement‬‬
        ‫;) ).……,2‪Return( name(parameter1, parameter‬‬
        ‫}‬



                       ‫ﻣﺛﺎل: ﺑﻧﺎء اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ )‪ (X^n‬أي داﻟﺔ )‪ (pow‬ﺑﺎﺳﺗﺧدام أﺳﻠوب )‪( Recursive Function‬‬

    ‫ﺗﺣﻠﯾل:ﻋﻧدﻣﺎ ﯾذﻛر )‪ ( Recursive Function‬ﯾﺟب أن ﺗرك أي ﻓﻛرة ﻓﻲ ذھﻧﻧﺎ ﻟﺣل اﻟﺳؤال ﺑدون اﺳﺗدﻋﺎء اﻟداﻟﺔ‬
                ‫ﻟﻧﻔﺳﮭﺎ.وﻛﻣﺎ ﻧرى أن رﻓﻊ اﻟرﻗم ﻷس ﻣﻌﻲ ﻣﻌﻧﺎه ﺿرب اﻟرﻗم ﺑﻧﻔﺳﮫ ﺑﻣﻘدار ﻗﯾﻣﺔ اﻷس ﻣﺛﺎل ﻋﻠﻰ ذاﻟك‬

                                                                                                      ‫ﻛود‬
        ‫4*4*4=3^4‬
      ‫أذن ﺳﻧﻛون داﻟﺔ ﺗﻌﯾد اﺳﺗدﻋﺎء ﻟﻧﻔﺳﮭﺎ ﺑﻣﻘدار ﻗﯾﻣﺔ اﻷس اﻟﻣرﻓوع ﻟﮫ اﻟرﻗم وﺑﻛل اﺳﺗدﻋﺎء ﺗﺿرب اﻟرﻗم ﻓﻲ ﻧﻔﺳﮫ‬

 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                   ‫>‪#include<stdio.h‬‬
 ‫) ‪1.int power(int x,int n‬‬                              ‫) ‪1.int power(int x,int n‬‬
 ‫{‬                                                      ‫{‬
 ‫)0>‪2.if (n‬‬                                             ‫)0>‪2.if (n‬‬
 ‫;)) 1-‪3.return(x*power(x,n‬‬                             ‫;)) 1-‪3.return(x*power(x,n‬‬
 ‫‪4.else‬‬                                                 ‫‪4.else‬‬
 ‫;1 ‪5.return‬‬                                            ‫;1 ‪5.return‬‬
 ‫}‬                                                      ‫}‬
 ‫{ )(‪6.main‬‬                                             ‫{ )(‪6.main‬‬
 ‫};)3,4(‪7.cout<<power‬‬                                   ‫};))3,4(‪7.printf("%d",power‬‬

                                                                                              ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

   ‫١.ﺧطوة رﻗم )٧( أردﻧﺎ أﯾﺟﺎد ﻗﯾﻣﺔ )3^4( ﻟذاﻟك ﺳﯾﺳﺗدﻋﻲ اﻟداﻟﺔ ﻓﻲ اﻟﺧطوة رﻗم )١( ﺟﺎﻋﻼ ﻗﯾﻣﺔ )3=‪ (x=4,n‬ﺛم‬
‫ﯾﻧﻔذ ﺧطوة رﻗم )٢( ﻻن)0>‪ (n‬وﯾﻧﻔذ ﺑﻌده ﺧطوة رﻗم )٣( ﻟﻛﻲ ﯾﻌﯾد اﻟرﻗم ﻣﺿروب ﺑﺎﺳﺗدﻋﺎء اﻟداﻟﺔ ﻟﻧﻔﺳﮭﺎ ﻣرﺳﻠﺔ ﻟﮭﺎ‬
  ‫اﻟرﻗم واﻷس ﻣﻧﻘص ﻣﻧﮫ واﺣد وﯾﺳﺗﻣر ﺑﺎﻻﺳﺗدﻋﺎء اﻟذاﺗﻲ إﻟﻰ أن ﺗﺻﺑﺢ ﻗﯾﻣﺔ اﻷس )0=‪ (n‬ﯾﻌﯾد ﻋﻧدھﺎ واﺣد وﯾﺧرج‬
                                                                                    ‫ﻣن اﻻﺳﺗدﻋﺎء اﻟذاﺗﻲ .‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                                ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                                       ‫ﺗوﺿﯾﺢ ﻣﺎذا ﺳﯾﺣﺻل ﻓﻲ ﺧطوات رﻗم)١ إﻟﻰ ٥( ﻓﻲ ﺣﺎل ﻛﺎن )3=‪(x=4,n‬‬

           ‫ﺗوﺿﯾﺢ ﻣﺎذا ﺳﯾﺣﺻل ﻓﻲ ﺧطوات رﻗم)١ إﻟﻰ ٥( ﻓﻲ ﺣﺎل ﻛﺎن )3=‪) (x=4,n‬ﻓﻘط اﻟﺧطوات اﻟﺗﻲ ﺳوف ﺗﻧﻔذ ﺑﻛل اﺳﺗدﻋﺎء(‬
       ‫اﻻﺳﺗدﻋﺎء اﻷول‬
       ‫)3=‪1.power(x=4,n‬‬
       ‫‪2. n=3 is large than zero‬‬
       ‫))1-3,4(‪3. return(4*power‬‬
       ‫اﻻﺳﺗدﻋﺎء اﻟﺛﺎﻧﻲ‬
       ‫)2=‪1.power(x=4,n‬‬
       ‫‪2. n=2 is large than zero‬‬
       ‫))1-2,4(‪3. return(4*4*power‬‬
       ‫اﻻﺳﺗدﻋﺎء اﻟﺛﺎﻟث‬
       ‫)1=‪1.power(x=4,n‬‬
       ‫‪2. n=1 is large than zero‬‬
       ‫))1-1,4(‪3. return(4*4*4*power‬‬
       ‫اﻻﺳﺗدﻋﺎء اﻟراﺑﻊ‬
       ‫)0=‪1.power(x=4,n‬‬
       ‫‪4. n=0 is equal to zero‬‬
       ‫)1*4*4*4(‪5. return‬‬
 ‫اﺳﺗدﻋت اﻟداﻟﺔ ﻟﻧﻔﺳﮭﺎ أرﺑﻊ ﻣرات ؟ واﻟﻧﺗﯾﺟﺔ ھﻲ)46=1*4*4*4( أذن اﻟﻧﺗﯾﺟﺔ ﺻﺣﯾﺣﺔ..،ﻛﺗﺑﻧﺎ ﻓﻘط اﻟﺧطوات اﻟﺗﻲ‬
                                                      ‫ﺳوف ﺗﻧﻔذ ﺑﻛل اﺳﺗدﻋﺎء ﻟﻠداﻟﺔ واﻟﺗﻲ ﻟم ﺗﻧﻔذ ﻟم ﻧﻛﺗﺑﮭﺎ‬




                                          ‫ﻣﺛﺎل: أﯾﺟﺎد ﻣﻔﻛوك اﻟرﻗم ﺑﺎﺳﺗﺧدام أﺳﻠوب )‪..( Recursive Function‬؟‬

    ‫ﺗﺣﻠﯾل:ﻋﻧدﻣﺎ ﯾذﻛر )‪ ( Recursive Function‬ﯾﺟب أن ﺗرك أي ﻓﻛرة ﻓﻲ ذھﻧﻧﺎ ﻟﺣل اﻟﺳؤال ﺑدون اﺳﺗدﻋﺎء اﻟداﻟﺔ‬
             ‫ﻟﻧﻔﺳﮭﺎ.وﻛﻣﺎ ﻧرى أن اﻟﻣﻔﻛوك ھو ﻧﺎﺗﺞ ﻣن ﺣﺎﺻل ﺿرب اﻟرﻗم ﺑﺎﻷرﻗﺎم اﻟﺗﻲ اﻗل ﻣﻧﮫ وﺻوﻻ إﻟﻰ اﻟواﺣد‬

                                                                                                           ‫ﻛود‬
       ‫1*2*3*4*5=!5‬



 ‫أذن ﺳﻧﻛون داﻟﺔ ﺗﻌﯾد اﺳﺗدﻋﺎء ﻟﻧﻔﺳﮭﺎ ﺑﻣﻘدار ﻗﯾﻣﺔ اﻟرﻗم ﻣﺛﻼ ﻣﻔﻛوك ﺧﻣﺳﺔ ﺳﺗﺳﺗدﻋﻲ اﻟداﻟﺔ ﻧﻔﺳﮭﺎ ﺧﻣس ﻣرات وﻓﻲ‬
                        ‫ﻛل ﻣرة ﺗﺳﺗدﻋﻲ اﻟداﻟﺔ ﻟﻧﻔﺳﮭﺎ ﻧطرح ﻣن اﻟرﻗم اﻟﻣرﺳل واﺣد وﻧﺿرﺑﮫ ﺑﺑﻘﯾﺔ اﻷرﻗﺎم ھﻛذا‬

                                                                                                           ‫ﻛود‬
       ‫!)1-‪N!=N*(n‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                     ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                                   ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
 ‫) ‪1.int fact (int x‬‬                                        ‫) ‪1.int fact (int x‬‬
 ‫{‬                                                          ‫{‬
 ‫)1>‪2.if (x‬‬                                                 ‫)1>‪2.if (x‬‬
 ‫;)) 1-‪3.return(x* fact (x‬‬                                  ‫;)) 1-‪3.return(x* fact (x‬‬
 ‫‪4.else‬‬                                                     ‫‪4.else‬‬
 ‫;1 ‪5.return‬‬                                                ‫;1 ‪5.return‬‬
 ‫}‬                                                          ‫}‬
 ‫{ )(‪6.main‬‬                                                 ‫{ )(‪6.main‬‬
 ‫};)4(‪7.cout<<fact‬‬                                          ‫};))4(‪7.prin ("%d",fact‬‬
                                                                                                     ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

‫‪ ‬ﺧطوة رﻗم )٧( اﺳﺗدﻋﯾﻧﺎ داﻟﺔ اﻟﻣﻔﻛوك وأردﻧﺎ إﯾﺟﺎد ﻣﻔﻛوك اﻟرﻗم أرﺑﻌﺔ ﻓﻌﻧد اﻟدﺧول ﻟﻠداﻟﺔ ﻧرى وﺟود ﺧطوة‬
‫رﻗم)٣( ھذه اﻟﺧطوة ﺗﺿرب اﻟرﻗم ﺑﻣﻔﻛوك اﻷرﻗﺎم اﻟﺗﻲ اﻗل ﻣﻧﮫ ھﻛذا)!)1-‪ (n*(n‬وﺗﺳﺗﻣر ﺑﺎﻟﺿرب إﻟﻰ أن‬
                                                                                ‫ﯾﺻل إﻟﻰ اﻟرﻗم ﺻﻔر‬

                                         ‫ﺗوﺿﯾﺢ ﻣﺎذا ﺳﯾﺣﺻل ﻓﻲ ﺧطوات رﻗم)١ إﻟﻰ ٥( ﻓﻲ ﺣﺎل ﻛﺎن )3=‪(x=4,n‬‬

                 ‫ﺗوﺿﯾﺢ ﻣﺎذا ﺳﯾﺣﺻل ﻓﻲ ﺧطوات رﻗم)١ إﻟﻰ ٥( ﻓﻲ ﺣﺎل ﻛﺎن )4=‪) (x‬ﻓﻘط اﻟﺧطوات اﻟﺗﻲ ﺳوف ﺗﻧﻔذ ﺑﻛل اﺳﺗدﻋﺎء(‬
        ‫اﻻﺳﺗدﻋﺎء اﻷول‬
        ‫)4=‪1.fact(x‬‬
        ‫‪2. x=4 is large than one‬‬
        ‫))1-4( ‪3. return(4* fact‬‬
        ‫اﻻﺳﺗدﻋﺎء اﻟﺛﺎﻧﻲ‬
        ‫)3=‪1. fact (x‬‬
        ‫‪2. x=3 is large than one‬‬
        ‫))1-3(‪3. return(4*3*power‬‬
        ‫اﻻﺳﺗدﻋﺎء اﻟﺛﺎﻟث‬
        ‫)2=‪1. fact (x‬‬
        ‫‪2. x=2 is large than one‬‬
        ‫))1-2(‪3. return(4*3*2*power‬‬
        ‫اﻻﺳﺗدﻋﺎء اﻟراﺑﻊ‬
        ‫)1=‪1. fact (x‬‬
        ‫‪4. x=1 is equal to one‬‬
        ‫)1*2*3*4(‪5. return‬‬
  ‫اﺳﺗدﻋت اﻟداﻟﺔ ﻟﻧﻔﺳﮭﺎ أرﺑﻊ ﻣرات ؟ واﻟﻧﺗﯾﺟﺔ ھﻲ)42=1*2*3*4( أذن اﻟﻧﺗﯾﺟﺔ ﺻﺣﯾﺣﺔ..،ﻛﺗﺑﻧﺎ ﻓﻘط اﻟﺧطوات اﻟﺗﻲ‬
                                                       ‫ﺳوف ﺗﻧﻔذ ﺑﻛل اﺳﺗدﻋﺎء ﻟﻠداﻟﺔ واﻟﺗﻲ ﻟم ﺗﻧﻔذ ﻟم ﻧﻛﺗﺑﮭﺎ‬

                                                                                                                         ‫ﻣﮭم‬

                 ‫أذا ﻛﺎﻧت اﻟداﻟﺔ ﻣﻛوﻧﺔ ﻣن ﺳطر ﺑرﻣﺟﻲ واﺣد ﺗﺳﻣﻰ دوال ﺳطرﯾﮫ )‪ (inline function‬وﺗﻛﺗب ھﻛذا‬

                                                                                   ‫ھﯾﻛﻠﯾﺔ دوال )‪( inline function‬‬
        ‫).……,2‪inlineType name(parameter1, parameter‬‬
        ‫};‪{Statement‬‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟدوال )‪(Function‬‬                                                                                             ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬

                                                                                                                   ‫ﻣﮭم‬


                                                                       ‫٦.٥- اﻟﻣﺻﻔوﻓﺎت واﻟدوال :‬
                                   ‫ﯾﻣﻛن إرﺳﺎل ﻣﺻﻔوﻓﺎت أﺣﺎدﯾﺔ اﻹﺑﻌﺎد إﻟﻰ اﻟدوال ﺑذﻛر اﺳﻣﮭﺎ ﻓﻘط ﺑدون أﺑﻌﺎد .‬



                                     ‫ﻣﺛﺎل:ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻣﺻﻔوﻓﺔ اﺳﻣﮭﺎ )‪ (a‬وﻧرﯾد إرﺳﺎﻟﮭﺎ إﻟﻰ داﻟﺔ اﺳﻣﮭﺎ )‪(name‬‬

                                                                  ‫إرﺳﺎل ﻣﺻﻔوﻓﺔ أﺣﺎدﯾﺔ إﻟﻰ اﻟدوال )‪(function‬‬
       ‫;) ‪name( a‬‬



                               ‫وطرﯾﻘﺔ اﺳﺗﻘﺑﺎل اﻟﻣﺻﻔوﻓﺔ اﻷﺣﺎدﯾﺔ ﻓﻲ اﻟدوال ﻧﺿﻊ ﻓﻘط أﻗواس اﻟﻣﺻﻔوﻓﺔ ﺑدون إﺑﻌﺎد‬

                                                                  ‫إرﺳﺎل ﻣﺻﻔوﻓﺔ أﺣﺎدﯾﺔ إﻟﻰ اﻟدوال )‪(function‬‬
       ‫;) ][‪Type name(type a‬‬
                                                                  ‫‪ : (type) ‬ھو ﻧوع اﻟﻣﺻﻔوﻓﺔ اﻟﻣرﺳﻠﺔ‬



                                   ‫ﯾﻣﻛن إرﺳﺎل ﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ اﻷﺑﻌﺎد إﻟﻰ اﻟدوال ﻓﻘط ﺑذﻛر اﺳﻣﮭﺎ ﺑدون أﺑﻌﺎد .‬



                    ‫ﻣﺛﺎل:ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻣﺻﻔوﻓﺔ اﺳﻣﮭﺎ )‪ (a‬وإﺑﻌﺎدھﺎ )3*2( وﻧرﯾد إرﺳﺎﻟﮭﺎ إﻟﻰ داﻟﺔ اﺳﻣﮭﺎ )‪(name‬‬

                                                                  ‫إرﺳﺎل ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ إﻟﻰ اﻟدوال )‪(function‬‬
       ‫;) ‪name( a‬‬



                                    ‫وطرﯾﻘﺔ اﺳﺗﻘﺑﺎل اﻟﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ اﻷﺑﻌﺎد ﻓﻲ اﻟدوال ﻧذﻛر ﻓﻘط اﻟﺑﻌد اﻟﺛﺎﻧﻲ ھﻛذا‬

                                                                  ‫إرﺳﺎل ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ إﻟﻰ اﻟدوال )‪(function‬‬
       ‫;) ]3[][‪Type name(type a‬‬




    ‫‪ ‬اﻟﻣﺻﻔوﻓﺎت ﻋﻧد إرﺳﺎﻟﮭﺎ ﺑﮭذه اﻟطرق إﻟﻰ اﻟدوال ﺗرﺳل ﺑﺎﻟﻘﯾﻣﺔ وﻟﯾس ﺑﺎﻟﻣرﺟﻊ.إذا إي ﺗﻐﯾر ﻋﻠﻰ ﻋﻧﺎﺻر‬
   ‫اﻟﻣﺻﻔوﻓﺔ ﻓﻲ اﻟداﻟﺔ ﺳوف ﻻ ﯾؤﺛر ﻋﻠﻰ ﻗﯾم اﻟﻌﻧﺎﺻر ﻓﻲ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ.أي ﺗرﺳل ﻧﺳﺧﺔ ﻣن اﻟﻣﺻﻔوﻓﺔ‬
                                                                           ‫وﻟﯾس اﻟﻣﺻﻔوﻓﺔ ﻧﻔﺳﮭﺎ.‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(Function) ‫اﻟدوال‬                                                                                            ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                    ‫ﻣﺛﺎل: ﺧﻣس ﻣﺻﻔوﻓﺎت أﺣﺎدﯾﺔ اﻹﺑﻌﺎد ﺣﺟﻣﮭﺎ )7( ﺟد ﺟﻣﻊ ﻛل ﻣﺻﻔوﻓﺔ واﻛﺑر ﻋدد ﺑﻛل ﻣﺻﻔوﻓﺔ..؟‬

        ‫ﺗﺣﻠﯾل: ﻛﻣﺎ ﻧرى اﻧﮫ ﯾرﯾد ﻧﺎﺗﺞ ﺟﻣﻊ ﻛل ﻣﺻﻔوﻓﺔ واﻛﺑر ﻋدد ﻓﯾﻛون اﻟﺑرﻧﺎﻣﺞ ﻛﺑﯾر ﺟدا إذا ﻟم ﻧﺳﺗﻌﻣل اﻟدوال‬
(function) ‫( ﻷﻧﮫ ﻟدل ﻣﺻﻔوﻓﺔ ﯾﺟب ﻛﺗﺎﺑﺔ ﻛود ﯾﺟد اﻛﺑر رﻗم وﯾﺟﻣﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻟﻛن ﻣﻊ اﻟدوال‬function)
                 ‫ﻧﻛون داﻟﺔ ﺗﺟد ﻣﺟﻣوع ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ وداﻟﺔ ﺗﺟد اﻛﺑر رﻗم وﻧﻣرر ﻛل ﻣﺻﻔوﻓﺔ ﻟﮭﺎﺗﺎن اﻟداﻟﺗﺎن‬
    c++                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   c                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                      #include<stdio.h>
 1.int maxN(int array1[])                                  1.int maxN(int array1[])
 2.{ int i, max;                                           2.{ int i, max;
 3.max=array1[0];                                          3.max=array1[0];
 4.for (i=0;i<7;i++)                                       4.for (i=0;i<7;i++)
 5.if (array1[i] > max )                                   5.if (array1[i] > max )
 6.max=array1[i];                                          6.max=array1[i];
 7.return(max);}                                           7.return(max);}
 8.int sumN(int array1[])                                  8.int sumN(int array1[])
 9.{ int i, sum=0;                                         9.{ int i, sum=0;
 10.for (i=0;i<7;i++)                                      10.for (i=0;i<7;i++)
 11.sum=sum+ array1[i];                                    11.sum=sum+ array1[i];
 12.return(sum);}                                          12.return(sum);}
 13.main()                                                 13.main()
 14.{ int i, a[7],b[7],c[7],d[7],e[7];                     14.{ int i, a[7],b[7],c[7],d[7],e[7];
 15.cout<< "enter element (1) array=";                     15.printf( "enter element (1) array=");
 16.for (i=0;i<7;i++)                                      16.for (i=0;i<7;i++)
 17.cin>>a[i];                                             17.scanf("%d",&a[i]);
 18.cout<<"max="<<maxN(a)<<"\tsum="<<sumN(a)<<"\n";        18.printf("max=%d\tsum=%d\n",maxN(a),sumN(a) );
 19.cout<< "enter element (2) array=";                     19. printf( "enter element (2) array=");
 20.for (i=0;i<7;i++)                                      20.for (i=0;i<7;i++)
 21.cin>>b[i];                                             21. scanf("%d",&b[i]);
 22.cout<<"max="<<maxN(b)<<"\tsum="<<sumN(b)<<"\n";        22. printf("max=%d\tsum=%d\n",maxN(b),sumN(b) );
 23.cout<< "enter element (3) array=";                     23. printf( "enter element (3) array=");
 24.for (i=0;i<7;i++)                                      24.for (i=0;i<7;i++)
 25.cin>>c[i];                                             25. scanf("%d",&c[i]);
 26.cout<<"max="<<maxN(c)<<"\tsum="<<sumN(c)<<"\n";        26. printf("max=%d\tsum=%d\n",maxN(c),sumN(c) );
 27.cout<< "enter element (4) array=";                     27. printf( "enter element (4) array=");
 28.for (i=0;i<7;i++)                                      28.for (i=0;i<7;i++)
 29.cin>>d[i];                                             29. scanf("%d",&d[i]);
 30.cout<<"max="<<maxN(d)<<"\tsum="<<sumN(d)<<"\n";        30. printf("max=%d\tsum=%d\n",maxN(d),sumN(d) );
 31.cout<< "enter element (5) array=";                     31. printf( "enter element (5) array=");
 32.for (i=0;i<7;i++)                                      32.for (i=0;i<7;i++)
 33.cin>>e[i];                                             33. scanf("%d",&e[i]);
 34.cout<<"max="<<maxN(e)<<"\tsum="<<sumN(e)<<"\n";}       34. printf("max=%d\tsum=%d\n",maxN(e),sumN(e) );}
                                                                                             :‫ﺗوﺿﯾﺢ اﻟﺧطوات‬
   ‫١.ﺧطوة رﻗم )١( ھﻲ داﻟﺔ ﺗﺳﺗﻘﺑل اﻟﻣﺻﻔوﻓﺔ وﺗﻘوم ﺑﺈﯾﺟﺎد اﻛﺑر رﻗم ﻟو ﺗﻼﺣظ اﻟﺧطوات )٢ إﻟﻰ ٧( ھﻲ ﺧطوات‬
          ‫إﯾﺟﺎد اﻛﺑر رﻗم ﻧﻔﺳﮭﺎ اﻟﺗﻲ ﺷرﺣﻧﺎھﺎ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ اﻷﺣﺎدﯾﺔ وﻛﯾﻔﯾﺔ أﯾﺟﺎد اﻛﺑر رﻗم ﻓﻘط وﺿﻌﻧﺎھﺎ ﻓﻲ داﻟﺔ‬
                                                              ‫٢.ﺧطوة رﻗم)٨( ھﻲ داﻟﺔ ﻟﺟﻣﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬
 ‫( وﺧطوة رﻗم )٨١( ھﻲ اﺳﺗدﻋﺎء داﻟﺔ اﻛﺑر رﻗم وداﻟﺔ ﺟﻣﻊ ﻋﻧﺎﺻر‬a) ‫٣.ﺧطوة رﻗم)٦١ و٧١( ھﻲ إدﺧﺎل اﻟﻣﺻﻔوﻓﺔ‬
                             ‫اﻟﻣﺻﻔوﻓﺔ وطﺑﺎﻋﺔ اﻟرﻗم وﺑﻘﯾﺔ اﻟﺧطوات ﺗﺗﻛرر ﻧﻔس اﻟﻌﻣﻠﯾﺔ ﺑﺎﻟﻧﺳﺑﺔ ﻟﺑﻘﯾﺔ اﻟﻣﺻﻔوﻓﺎت‬
                                                          .‫** أﻻن أﺻﺑﺢ ﻟدﯾﻧﺎ داﻟﺔ ﻣﺗﻰ اﺳﺗدﻋﯾﻧﺎھﺎ ﺗﺟد اﻛﺑر رﻗم‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                    C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟدوال )‪(Function‬‬                                                                                                       ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




            ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﺣﺳﺎب اﻟﺣرف اﻷﻛﺛر ﺗﻛرار وﻋدد ﻣرات ﺗﻛراره. ﻓﻲ ﺧﻣس ﺳﻼﺳل ﻧﺻﯾﺔ ﻛل ﻋﻠﻰ ﺣدة .؟‬

      ‫ﺗﺣﻠﯾل:ﻹﯾﺟﺎد اﻟﺣرف اﻷﻛﺛر ﺗﻛرار ﺿﻣن إي ﺳﻠﺳﻠﺔ ﯾﺟب ﺧزن ﺟﻣﯾﻊ اﻷﺣرف ﻓﻲ ﻣﺻﻔوﻓﺔ وﺣﺳﺎب ﻋدد ﻣرات‬
                                 ‫ظﮭور ﻛل ﺣرف ﻓﻲ اﻟﺳﻠﺳﻠﺔ وطﺑﺎﻋﺔ اﻟﺣرف اﻟذي ﯾظﮭر أﻛﺛر ﻣن ﻏﯾره.‬

 ‫++‪c‬‬                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                            ‫>‪#include<stdio.h‬‬
 ‫>‪#include<string.h‬‬                                              ‫>‪#include<string.h‬‬
 ‫;‪1.int i,m, max,fou‬‬                                             ‫;‪1.int i,m, max,fou‬‬
 ‫;]552[‪2.char a[45], charSaved‬‬                                   ‫;]552[‪2.char a[45], charSaved‬‬
 ‫)‪3.repeat(char string[],int len‬‬                                 ‫)‪3.repeat(char string[],int len‬‬
 ‫;}0{=]552[‪4.{ int equavelentnumber‬‬                              ‫;}0{=]552[‪4.{ int equavelentnumber‬‬
 ‫)++‪5. for(i=0;i<255;i‬‬                                           ‫)++‪5. for(i=0;i<255;i‬‬
 ‫;)‪6.charSaved[i]=char(i‬‬                                         ‫;)‪6.charSaved[i]=char(i‬‬
 ‫{)++‪7.for(m=0;m<255;m‬‬                                           ‫{)++‪7.for(m=0;m<255;m‬‬
 ‫)++‪8.for(i=0;i<len-1;i‬‬                                          ‫)++‪8.for(i=0;i<len-1;i‬‬
 ‫))' '=! ]‪9.if (( charSaved [m]== string [i]) && ( string [i‬‬     ‫))' '=! ]‪9.if (( charSaved [m]== string [i]) && ( string [i‬‬
 ‫}; 1 =+]‪10.equavelentnumber [m‬‬                                  ‫}; 1 =+]‪10.equavelentnumber [m‬‬
 ‫;]0[ ‪11.max= equavelentnumber‬‬                                   ‫;]0[ ‪11.max= equavelentnumber‬‬
 ‫)++‪12.for(i=0;i<255;i‬‬                                           ‫)++‪12.for(i=0;i<255;i‬‬
 ‫{)‪13.if ( equavelentnumber [i]>max‬‬                              ‫{)‪13.if ( equavelentnumber [i]>max‬‬
 ‫;]‪14.max= equavelentnumber [i‬‬                                   ‫;]‪14.max= equavelentnumber [i‬‬
 ‫};‪15.fou =i‬‬                                                     ‫};‪15.fou =i‬‬
 ‫;"‪16.cout<<"charcter more repeat "<< charSaved [ fou ]<<" \n‬‬    ‫;)] ‪16.printf("charcter more repeat=%c\n", charSaved [ fou‬‬
 ‫} ;"‪17.cout<<"it repeat="<<max <<"\n‬‬                            ‫} ;) ‪17.printf("it repeat=%d\n", max‬‬
 ‫)(‪18.main‬‬                                                       ‫)(‪18.main‬‬
 ‫;1‪19.{int count‬‬                                                 ‫;1‪19.{int count‬‬
 ‫{)++1‪20.for ( count1=1; count1<6; count‬‬                         ‫{)++1‪20.for ( count1=1; count1<6; count‬‬
 ‫;" :)"<<1‪21.cout<<"enter the Sting( "<<count‬‬                    ‫;)1‪21.prin ("enter the S ng(%d): ", count‬‬
 ‫;) ‪22.cin.getline(a‬‬                                             ‫;) ‪22.gets(a‬‬
 ‫}};))‪23.repeat(a,strlen(a‬‬                                       ‫}};))‪23.repeat(a,strlen(a‬‬
                                                                                                            ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                           ‫١.ﺧطوة رﻗم)١( ﻋرﻓﻧﺎ ﻣﺗﻐﯾرات ﻋﺎﻣﺔ ﻣﻌرﻓﺔ ﻟﺟﻣﯾﻊ أﺟزاء اﻟﺑرﻧﺎﻣﺞ‬
 ‫٢.ﺧطوة رﻗم )٢( ﻋرﻓﻧﺎ ﻣﺻﻔوﻓﺔ )‪ (charSaved‬ﻟﻧﺧزن ﻓﯾﮭﺎ ﺟﻣﯾﻊ اﻷﺣرف ﺣﺗﻰ ﻧﺣﺳب ﻋدد ﻣرات ظﮭور ﻛل ﺣرف‬
              ‫٣.ﺧطوة رﻗم )٣(ھﻲ داﻟﺔ ﺗﺳﺗﻘﺑل اﻟﺳﻠﺳﻠﺔ وطوﻟﮭﺎ وﺗطﺑﻊ اﻟﺣرف اﻷﻛﺛر ﺗﻛرار وﻋدد ﻣرات ﺗﻛراره‬
                ‫٤.ﺧطوة رﻗم)٤( ﻋرﻓﻧﺎ ﻣﺻﻔوﻓﺔ )‪ (equavelentnumber‬ﻟﻧﺧزن ﻓﯾﮭﺎ ﻋدد ﻣرات ظﮭور ﻛل ﺣرف‬
                        ‫٥.ﺧطوة رﻗم )٥ و٦( ﻧﺧزن ﺟﻣﯾﻊ اﻷﺣرف واﻟرﻣوز ﻓﻲ ﻣﺻﻔوﻓﺔ اﺳﻣﮭﺎ )‪(charSaved‬‬
    ‫٦.ﺧطوة رﻗم )٧ و٨و٩و٠١( ﻧﺣﺳب ﻋدد ﻣرات ظﮭور ﻛل ﺣرف ﻓﻲ اﻟﺳﻠﺳﻠﺔ اﻟﺗﻲ ادﺧﻠﮭﺎ اﻟﻣﺳﺗﺧدم وﻧﺧزن ﻓﻲ‬
‫ﻣﺻﻔوﻓﺔ )‪ (equavelentnumber‬وﺗﻛون ھذه اﻟﻣﺻﻔوﻓﺔ ﻣﻛﺎﻓﺊ ﻟﻣواﻗﻊ ﻛل رﻣز أو ﺣرف ﻓﻲ ﻣﺻﻔوﻓﺔ )‪(charSaved‬‬
               ‫٧.ﺧطوة رﻗم)١١ إﻟﻰ ٧١( ﻧﺣﺳب اﻟﺣرف اﻟذي ظﮭر أﻛﺛر ﻣرة وﻧطﺑﻊ و ﻧطﺑﻊ ﻋدد ﻣرات ظﮭوره‬
                                          ‫٨.ﺧطوة رﻗم )٠٢ إﻟﻰ ٣٢( ھو ادﺧل اﻟﻣﺻﻔوﻓﺎت وإرﺳﺎﻟﮭﺎ إﻟﻰ اﻟداﻟﺔ‬
                                           ‫**ﻻ ﯾﺟوز ﺗﻌرﯾف ﻣﺗﻐﯾر )ﻣﺗﻐﯾر ﻋﺎم( واﺳﺗﺧداﻣﮫ ﻛﻌداد ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬
                                            ‫اﻟرﺋﯾﺳﻲ وھو ﻣﺳﺗﺧدم داﺧل اﺣد اﻟدوال ﻛﻌداد أو ﺗﺗﻐﯾر ﻗﯾﻣﺗﮫ ﺳوف‬
                                                   ‫ﻻ ﯾﻧﻔذ اﻟﺑرﻧﺎﻣﺞ ﻷﻧﮫ ﺳوف ﯾﺟﻌل ﻋﺑﺎرة اﻟﺗﻛرار ﻓﻲ ﻏﻣوض‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(Function) ‫اﻟدوال‬                                                                                               ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                                            ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﺗرﺗﯾب ﺛﻼث ﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ اﻹﺑﻌﺎد )5*5( ﺗﺻﺎﻋدﯾﺎ.؟‬

   (function)‫ﺗﺣﻠﯾل:ﻟﺗرﺗﯾب ﺛﻼث ﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ ﻧﺳﺗﺧدم ﻧﻔس طرﯾﻘﺔ ﺗرﺗﯾب اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ وﻧﺿﻌﮭﺎ ﻓﻲ داﻟﺔ‬
                                                                                  .‫وﻧﺳﺗدﻋﯾﮭﺎ ﺛﻼث ﻣرات‬

 c++                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    c                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                     #include<stdio.h>
 1.int const row=5;                                       1.int const row=5;
  2.int const col=5;                                       2.int const col=5;
 4.int i,j,k,x,l ;                                        4.int i,j,k,x,l ;
 3.Sort2D(int array[][col])                               3.Sort2D(int array[][col])
 {                                                        {
 4.for( k=0;k<row;k++){                                   4.for( k=0;k<row;k++){
 5. for( l=0;l<col;l++){                                  5. for( l=0;l<col;l++){
 6. for( i=0;i<row;i++){                                  6. for( i=0;i<row;i++){
  7. for ( j=0;j<col;j++){                                 7. for ( j=0;j<col;j++){
  8. if (array[i][j] >array[k][l]){                        8. if (array[i][j] > array[k][l]){
 9.x=array[k][l];                                         9.x=array[k][l];
  10.array[k][l]=array[i][j];                              10.array[k][l]=array[i][j];
  11.array[i][j]=x;                                        11.array[i][j]=x;
  12.}} }} }                                               12.}} }} }
 13. cout<<"Here is the Array after sorted\n" ;           13. printf("Here is the Array after sorted\n") ;
 14. for ( i=0;i<row;i++){                                14. for ( i=0;i<row;i++){
  15. for ( j=0;j<row;j++)                                 15. for ( j=0;j<row;j++)
 16. cout<<array[i][j]<<"\t";                             16. printf("%d\t",array[i][j] );
 17. cout<<"\n" ;}}                                       17. printf("\n" );}}
 18. main()                                               18. main()
  19.{ int array1[row][col];                               19.{ int array1[row][col];
 20. int array2[row][col];                                20. int array2[row][col];
 21. int array3[row][col];                                21. int array3[row][col];
 22.cout<<"Here is the Array(1) befor sorted\n" ;         22. printf("Here is the Array(1) befor sorted\n") ;
 23. for ( i=0;i<row;i++)                                 23. for ( i=0;i<row;i++)
  24. for ( j=0;j<col;j++)                                 24. for ( j=0;j<col;j++)
 25.cin>>array1[i][j] ;                                   25.scanf("%d",&array1[i][j] );
 26.Sort2D(array1);                                       26.Sort2D(array1);
 27.cout<<"Here is the Array (2) befor sorted\n" ;        27. printf("Here is the Array (2) befor sorted\n") ;
 28. for ( i=0;i<row;i++)                                 28. for ( i=0;i<row;i++)
  29. for ( j=0;j<col;j++)                                 29. for ( j=0;j<col;j++)
 30.cin>>array1[i][j] ;                                   30. scanf("%d",&array2[i][j] );
 31.Sort2D(array2);                                       31.Sort2D(array2);
 32.cout<<"Here is the Array (3) befor sorted\n" ;        32. printf("Here is the Array (3) befor sorted\n" );
 33. for ( i=0;i<row;i++)                                 33. for ( i=0;i<row;i++)
  34. for ( j=0;j<col;j++)                                 34. for ( j=0;j<col;j++)
 35.cin>>array3[i][j] ;                                   35. scanf("%d",&array3[i][j] );
 36.Sort2D(array3);}                                      36.Sort2D(array3);}
                                      ‫ﺗوﺿﯾﺢ اﻟﺧطوات: ﺧطوة رﻗم)٣( ھﻲ داﻟﺔ ﻟﺗرﺗﯾب ﻋﻧﺎﺻر ﻣﺻﻔوﻓﺔ ﺗﺻﺎﻋدﯾﺎ‬
                ‫وﻧﻼﺣظ ﺧطوة رﻗم)٢٢ إﻟﻰ ٥٢( ھﻲ إدﺧﺎل ﻟﻠﻣﺻﻔوﻓﺔ اﻷوﻟﻰ وﺧطوة رﻗم)٦٢( ھﻲ إرﺳﺎﻟﮭﺎ ﻟﺗرﺗﯾﺑﮭﺎ‬
                                                         .‫وﻟﺧطوات اﻟﺑﻘﯾﺔ ھﻲ إدﺧﺎل ﺑﻘﯾﺔ اﻟﻣﺻﻔوﻓﺎت وﺗرﺗﯾﺑﮭﺎ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                      C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
(Function) ‫اﻟدوال‬                                                                                                         ‫اﻟﻔﺻل اﻟﺧﺎﻣس‬




                ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻹﯾﺟﺎد أﺣرف اﻟﻌﻠﺔ وﻋددھﺎ ﻓﻲ ﺛﻼث ﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ اﻹﺑﻌﺎد )4*4( ﻛل ﻋﻠﻰ ﺣدة .؟‬

                        . (function) ‫ﺗﺣﻠﯾل: إﯾﺟﺎد أﺣرف اﻟﻌﻠﺔ ﻓﻲ ﻣﺻﻔوﻓﺎت ﺛﻧﺎﺋﯾﺔ ﻷﻛﺛر ﻣن واﺣدة ﻧﺣﺗﺎج إﻟﻰ دوال‬

 c++                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    c                                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                           #include<stdio.h>
 1.char vowelchar [7]={'a','o','u','i','e','n','\o'};           1.char vowelchar [7]={'a','o','u','i','e','n','\o'};
 2..int i,j,k;                                                  2..int i,j,k;
 3.int indexofprintarray=1;                                     3.int indexofprintarray=1;
 4.vowel( char a[][4])                                          4.vowel( char a[][4])
 5.{ cout<<"\nvowel Char in                                     5.{ printf("\nvowel Char in array(%d)\n
 array("<<indexofprintarray<<")\n";                             ",indexofprintarray) ;
 6.indexofprintarray=indexofprintarray+1;                       6.indexofprintarray=indexofprintarray+1;
 7.int number_appear ;                                          7.int number_appear ;
 8. number_appear =0;                                           8. number_appear =0;
 9.for(k=0;k<6;k++)                                             9.for(k=0;k<6;k++)
 10.for(i=0;i<4;i++)                                            10.for(i=0;i<4;i++)
 11.for(j=0;j<4;j++)                                            11.for(j=0;j<4;j++)
 12.if(a[i][j]== vowelchar [k])                                 12.if(a[i][j]== vowelchar [k])
 13.{cout<< "\n"<<a[i][j];                                      13.{printf( "\n%d",a[i][j]);
 14.number_appear = number_appear +1;}                          14.number_appear = number_appear +1;}
 15.cout<<"\nnumber appear of vowel="<<                         15.printf("\nnumber appear of vowel=%d",
 number_appear;}}                                               number_appear);}}
 16.main()                                                       16.main()
 17.{char a[4][4],b[4][4], c[4][4];                             17.{char a[4][4],b[4][4], c[4][4];
 18.cout<<"\nenter (1) array:\n";                               18.printf("\nenter (1) array:\n");
 19..for(i=0;i<4;i++)                                           19..for(i=0;i<4;i++)
 20.for(j=0;j<4;j++)                                            20.for(j=0;j<4;j++)
 21.cin>>a[i][j];                                               21.scanf("%d",&a[i][j]);
 22.cout<<"\nenter (2) array:\n";                               22. printf("\nenter (2) array:\n");
 23.for(i=0;i<4;i++)                                            23.for(i=0;i<4;i++)
 24.for(j=0;j<4;j++)                                            24.for(j=0;j<4;j++)
 25.cin>>b[i][j];                                               25. scanf("%d",&b[i][j]);
 26.cout<<"\nenter (3) array:\n";                               26. printf("\nenter (3) array:\n");
 27.for(i=0;i<4;i++)                                            27.for(i=0;i<4;i++)
 28.for(j=0;j<4;j++)                                            28.for(j=0;j<4;j++)
 29.cin>>c[i][j];                                               29. scanf("%d",&c[i][j]);
 30.vowel( a );                                                 30.vowel( a );
 31.vowel( b);                                                  31.vowel( b);
 32.vowel( c);}                                                 32.vowel( c);}
   ‫( ﻛﻣﺗﻐﯾر ﻋﺎم وﻧﻼﺣظ اﻧﮫ ﻛﻠﻣﺎ ﻧﺳﺗدﻋﻲ‬indexofprintarray) ‫ﺗوﺿﯾﺢ اﻟﺧطوات: ﺧطوة رﻗم )٣( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر‬
   ‫( ﻓﻲ اﻟﺧطوة رﻗم )٤( ﺳﺗزداد ﻗﯾﻣﺗﮫ ﺑواﺣد ﻓﻲ ﺧطوة رﻗم )٦( ﻷﻧﮫ ﻛﻣﺎ ﻗﻠﻧﺎ اﻟﻣﺗﻐﯾر اﻟﻌﺎم ﻻ ﯾﻣوت‬vowel) ‫اﻟداﻟﺔ‬
     (٣٢‫ﯾﺑﻘﻰ ﺣﯾﺎ ﺣﺗﻰ ﻧﮭﺎﯾﺔ اﻟﺑرﻧﺎﻣﺞ وﻻ ﯾرﺟﻊ إﻟﻰ ﻗﯾﻣﮫ اﻻﺑﺗداﺋﯾﺔ )أي ﺑﻌد ﺛﻼث اﺳﺗدﻋﺎﺋﺎت ﻟﺧطوة رﻗم)٠٣و١٣و‬
(٥)‫ﺗﺻﺑﺢ ﻗﯾﻣﺗﮫ أرﺑﻌﺔ ( وﻧﺣن اﺣﺗﺎﺟﯾﻧﺎه ﺣﺗﻰ ﻓﻲ ﻛل اﺳﺗدﻋﺎء ﯾطﺑﻊ رﻗم اﻟﻣﺻﻔوﻓﺔ اﻟﺟﺎري اﻟﺑﺣث ﻓﯾﮭﺎ ﻓﻲ ﺧطوة رﻗم‬

                                                                                   ‫وﺑﻘﯾﺔ اﻟﺧطوات واﺿﺣﺔ وﻣﺷروﺣﺔ ﺳﺎﺑﻘﺎ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                               C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                  ‫اﻟﻔﺻل اﻟﺳﺎدس‬




                     ‫اﻟﻤﺆﺷﺮات )‪(pointer‬‬
                                      ‫١.٦- اﻟﻣؤﺷرات:‬
                            ‫٢.٦- اﻟﻣؤﺷرات واﻟﻣﺗﻐﯾرات:‬
                                 ‫٣.٦- اﻟداﻟﺔ )‪: (NEW‬‬
                           ‫٤.٦- اﻟﻣؤﺷرات واﻟﻣﺻﻔوﻓﺎت:‬
                     ‫٥.٦- اﻟﻣؤﺷرات واﻟدوال )‪(function‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                      ‫اﻟﻔﺻل اﻟﺳﺎدس‬




                                                                                   ‫١.٦- اﻟﻣؤﺷرات:‬
      ‫ھو إﺷﺎرة أو ﺗﺄﺷﯾر ﻋﻠﻰ ﻣوﻗﻊ ﻓﻲ اﻟذاﻛرة. ﻋرﻓﻧﺎ ﺳﺎﺑﻘﺎ إن ﻛل ﻣﺗﻐﯾر أو ﻛل ﻣﺗﻐﯾر ﯾﺧزن ﻓﻲ اﻟذاﻛرة ﺑﻣوﻗﻊ ذو‬
            ‫ﻋﻧوان ﻣﻌﯾن واﻟﻣؤﺷر ﺳوف ﯾؤﺷر ﻋﻠﻰ ھذا اﻟﻌﻧوان وﯾﻣﻛﻧﺎ ﻣن اﻟوﺻول إﻟﻰ اﻟﻘﯾﻣﺔ اﻟﻣﺧزﻧﺔ ﻓﻲ داﺧﻠﮫ.‬


           ‫اﻟﻣؤﺷر‬                                                ‫ﻋﻧوان اﻟﻣوﻗﻊ‬           ‫ﻣﺣﺗواه‬
                                                               ‫8‪0x244f23e‬‬               ‫‪data‬‬

                  ‫اﻟﻣؤﺷر ﯾؤﺷر ﻋﻠﻰ ﻋﻧوان اﻟﻣﺗﻐﯾر ﻓﻲ اﻟذاﻛرة وﯾﺣﻣل ﻗﯾﻣﺔ ھذا اﻟﻌﻧوان وھو ھﻧﺎ )8‪(0x244f23e‬‬

                                                                   ‫٢.٦- اﻟﻣؤﺷرات واﻟﻣﺗﻐﯾرات:‬
   ‫اﻟﻣﺗﻐﯾرات ﺗﺧزن ﻓﻲ اﻟذاﻛرة وﯾﻣﻛن أن ﻧؤﺷر ﻋﻠﻰ ﻗﯾﻣﮭﺎ ﺑواﺳطﺔ )‪ (pointer‬وﻧﺗﻼﻋب ﺑﻘﯾﻣﺔ ھذا اﻟﻣوﻗﻊ ﺑواﺳطﺗﮫ‬
                                                     ‫وﺗﻛون طرﯾﻘﺔ ﺗﻌرﯾف )‪ (pointer‬ﻣﻊ اﻟﻣﺗﻐﯾرات ھﻛذا.‬

                                                                                        ‫ھﯾﻛﻠﯾﺔ اﻟﻣؤﺷر‬
       ‫‪Type *ptr=&var‬‬
           ‫‪ : (ptr) ‬ھو اﺳم اﻟﻣؤﺷر وﻗد ﯾﻛون أي اﺳم ﯾﻌرﻓﮫ اﻟﻣﺳﺗﺧدم وﯾﺟب وﺿﻊ ﻋﻼﻣﺔ اﻟﻧﺟﻣﺔ )*( ﻗﺑﻠﮫ‬
                               ‫‪ :(Type) ‬ھو ﻧوع اﻟﻣؤﺷر وﯾﻛون ﻧوﻋﮫ ﻧﻔس ﻧوع اﻟﻣﺗﻐﯾر اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ‬
‫‪ :(var) ‬ھو اﺳم اﻟﻣﺗﻐﯾر اﻟذي ﻧرﯾد أن ﯾؤﺷر ﻋﻠﯾﮫ اﻟﻣؤﺷر وﯾﺟب وﺿﻊ ﻋﻼﻣﺔ )&( ﻗﺑﻠﮫ ﻋﻧدﻣﺎ ﻧﺟﻌل اﻟﻣؤﺷر‬
   ‫ﯾؤﺷر ﻋﻠﯾﮫ ﻻن وﺿﻊ ھذه اﻟﻌﻼﻣﺔ ﻗﺑل أي ﻣﺗﻐﯾر ﻣﻌﻧﺎه اﻟﻣطﻠوب ﻋﻧوان اﻟﻣﺗﻐﯾر وﻟﯾس ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﻧﻔﺳﮫ‬
 ‫واﻟﻣؤﺷرات ﺗؤﺷر ﻋﻠﻰ اﻟﻌﻧﺎوﯾن اﻟﻣﺗﻐﯾرات ﻓﻠو وﺿﻌﻧﺎ ھذه اﻟﻌﻼﻣﺔ أﻣﺎم أي ﻣﺗﻐﯾر ﻓﻲ اﻟطﺑﺎﻋﺔ ﺳﯾطﺑﻊ ﻣوﻗﻊ‬
                                                                               ‫اﻟﻣﺗﻐﯾر وﻟﯾس ﻗﯾﻣﺗﮫ.‬

                      ‫ﻣﺛﺎل: ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻣﺗﻐﯾر )5=‪ (x‬وﯾؤﺷر ﻋﻠﯾﮫ ﻣؤﺷر )‪ (ptr‬ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ ﻓﯾﻛون اﻟﻣﺧطط ھﻛذا‬

                                                                                                 ‫ﻛود‬
       ‫;5=‪int x‬‬
       ‫;‪int *ptr=&x‬‬


 ‫اﺳم اﻟﻣؤﺷر‬       ‫اﻟﻌﻧوان اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ‬
    ‫‪ptr‬‬               ‫8‪0x244f23e‬‬                     ‫ﻋﻧوان اﻟﻣوﻗﻊ اﺳم اﻟﻣﺗﻐﯾر‬         ‫ﻣﺣﺗواه‬
                                                          ‫‪x‬‬      ‫8‪0x244f23e‬‬              ‫5‬

                               ‫‪ ‬اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ ) ‪ (ptr‬ھو )8‪ (0x244f23e‬وﻣﺣﺗواه ھو )٥(‬
          ‫‪ ‬ﻟﻠوﺻول ﻋﻠﻰ ﻋﻧوان اﻟﻣوﻗﻊ ﻧﻛﺗب )‪ (ptr‬أو ﻧﻛﺗب ) ‪ ( &x‬ﻻن اﻻﺛﻧﺎن أﺻﺑﺢ ﻟﮭﻣﺎ ﻧﻔس اﻟﻣوﻗﻊ.‬
        ‫‪ ‬ﻟﻠوﺻول ﻋﻠﻰ ﻣﺣﺗوﯾﺎت اﻟﻣوﻗﻊ ﻧﻛﺗب ) ‪ (*ptr‬أو ﻧﻛﺗب )‪ (x‬ﻻن اﻻﺛﻧﺎن أﺻﺑﺢ ﻟﮭﻣﺎ ﻧﻔس اﻟﻘﯾﻣﺔ.‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                       ‫اﻟﻔﺻل اﻟﺳﺎدس‬




                                                                      ‫ﻣﺛﺎل: ﺗﺄﺷﯾر ﻋﻠﻰ ﻣوﻗﻊ ﻣﺗﻐﯾر وطﺑﺎﻋﺔ ﻗﯾﻣﺗﮫ.‬
 ‫++‪c‬‬                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬     ‫‪c‬‬                                            ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                   ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                 ‫)(‪main‬‬
 ‫;5=‪1.{int x‬‬                                            ‫;5=‪1.{int x‬‬
 ‫;‪2.int *ptr=&x‬‬                                         ‫;‪2.int *ptr=&x‬‬
 ‫;‪3.cout<<"loca on Ptr="<<ptr‬‬                           ‫;)‪3.prin ("location Ptr=%d",ptr‬‬
 ‫;‪4.cout<<"\nlocation var="<<&x‬‬                         ‫;)‪4.printf("\nlocation var=%d ",&x‬‬
 ‫;‪5.cout<<"\nvalue Ptr="<<*ptr‬‬                          ‫;)‪5.prin ("\nvalue Ptr=%d ",*ptr‬‬
 ‫;‪6.cout<<"\n value var="<<x‬‬                            ‫;)‪6.prin ("\n value var=%d",x‬‬
 ‫}‬                                                      ‫}‬
                                                                                             ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                             ‫١.ﺧطوة رﻗم )٢( ﺟﻌﻠﻧﺎ اﻟﻣؤﺷر)‪ (ptr‬ﯾؤﺷر ﻋﻠﻰ ﻣوﻗﻊ اﻟﻣﺗﻐﯾر )‪(x‬‬

   ‫٢.ﺧطوة رﻗم )٣( طﺑﻌﻧﺎ ﻋﻧوان اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ اﻟﻣؤﺷر )‪ (ptr‬وھو ﻧﻔس ﻋﻧوان ﻣوﻗﻊ اﻟﻣﺗﻐﯾر )‪ (x‬ﻷﻧﮭﻣﺎ‬
                        ‫ﯾؤﺷران ﻋﻠﻰ ﻧﻔس اﻟﻣوﻗﻊ.أي أﻧﻧﺎ إذا ﻛﺗﺑﻧﺎ ﻓﻘط اﺳم اﻟﻣؤﺷر ﺳﯾطﺑﻊ اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ‬

              ‫٣.ﺧطوة رﻗم )٤( طﺑﻌﻧﺎ ﻋﻧوان اﻟﻣﺗﻐﯾر )‪ (x‬ﻷﻧﻧﺎ إذا وﺿﻌﻧﺎ ﻋﻼﻣﺔ )&( ﻗﺑل أي ﻣﺗﻐﯾر ﺳﯾطﺑﻊ ﻣوﻗﻌﮫ‬

 ‫٤.ﺧطوة رﻗم )٥( طﺑﻌﻧﺎ اﻟﻘﯾﻣﺔ اﻟﺗﻲ ﯾؤﺷر ﻋﻠﯾﮭﺎ اﻟﻣؤﺷر)‪ (ptr‬وھﻲ ﻧﻔس ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (x‬ﻷﻧﮭﻣﺎ ﯾؤﺷران ﻋﻠﻰ ﻧﻔس‬
                     ‫اﻟﻣوﻗﻊ. أي أﻧﻧﺎ إذا ﻛﺗﺑﻧﺎ ﻧﺟﻣﺔ ﻗﺑل اﺳم اﻟﻣؤﺷر)‪ (ptr‬ﺳﯾطﺑﻊ ﻣﺣﺗوى اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ‬

                                                       ‫٥.ﺧطوة رﻗم )٦( ﺳﯾطﺑﻊ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (x‬ﺷﺎھد ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




                                                              ‫ﻣﺛﺎل : ﺗﻐﯾر ﻣﺣﺗوﯾﺎت اﻟﻣﺗﻐﯾر )‪ (g‬ﺑواﺳطﺔ اﻟﻣؤﺷر.؟‬

 ‫++‪c‬‬                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬     ‫‪c‬‬                                            ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                   ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                 ‫)(‪main‬‬
 ‫;5=‪1.{int g‬‬                                            ‫;5=‪1.{int g‬‬
 ‫;‪2.int *ptr=&g‬‬                                         ‫;‪2.int *ptr=&g‬‬
 ‫;23=‪3. *ptr‬‬                                            ‫;23=‪3. *ptr‬‬
 ‫};‪4.cout<<"\nx="<<g‬‬                                    ‫};)‪4.printf("\nx=%d ",g‬‬

                                                                                             ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬

                                                        ‫١.ﺧطوة رﻗم)٢( ﺟﻌﻠﻧﺎ اﻟﻣؤﺷر ﯾﺷﯾر إﻟﻰ ﻣوﻗﻊ اﻟﻣﺗﻐﯾر )‪(g‬‬

          ‫٢.ﺧطوة رﻗم )٣( وﺿﻌﻧﺎ ﻗﯾﻣﺔ ﺟدﯾدة ﻓﻲ اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ اﻟﻣؤﺷر )‪ (*ptr‬وھو ﻣوﻗﻊ اﻟﻣﺗﻐﯾر )‪(g‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                          ‫اﻟﻔﺻل اﻟﺳﺎدس‬
                                                                                                                ‫ﻣﮭم‬


       ‫٣.٦- اﻟداﻟﺔ )‪ : (NEW‬ھﻲ داﻟﺔ ﺗﺳﺗﺧدم ﻟﺣﺟز ﻣﻛﺎن ﻓﻲ اﻟذاﻛرة ﻟﻣؤﺷر ﻣﻌﯾن ﻻن اﻟﻣؤﺷرات‬
     ‫ﺑطﺑﯾﻌﺗﮭﺎ ﺳوف ﺗؤﺷر ﻋﻠﻰ ﻣواﻗﻊ ﻣﺗﻐﯾرات وﻟن ﺗﺣﺟز ﻣواﻗﻊ أﻣﺎ ﻣﻊ ھذا اﻹﯾﻌﺎز ﻧﺳﺗطﯾﻊ ﺣﺟز ﻣوﻗﻊ ﻟﻠﻣؤﺷر‬
                                                                              ‫وﺗﻌرﯾﻔﮭﺎ ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                                            ‫ھﯾﻛﻠﯾﺔ اﻟﻣؤﺷر‬
       ‫]‪Type *ptr=new type[size‬‬
            ‫‪ : (ptr) ‬ھو اﺳم اﻟﻣؤﺷر وﻗد ﯾﻛون أي اﺳم ﯾﻌرﻓﮫ اﻟﻣﺳﺗﺧدم وﯾﺟب وﺿﻊ ﻋﻼﻣﺔ اﻟﻧﺟﻣﺔ )*( ﻗﺑﻠﮫ‬
                               ‫‪ :(Type) ‬ھو ﻧوع اﻟﻣؤﺷر وﯾﻛون ﻧوﻋﮫ ﻧﻔس ﻧوع اﻟﻣﺗﻐﯾر اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ‬
                                ‫‪ :(size) ‬ھو اﻟﺣﺟم أو ﻋدد اﻟﻣوﻗﻊ اﻟذي ﺳوف ﻧﺣﺟزه ﻟﻠﻣؤﺷر ﻓﻲ اﻟذاﻛرة .‬

              ‫ﻣﺛﺎل : ﺗﻛوﯾن ﻣؤﺷر ﺟدﯾد وﺣﺟز ﻣﻛﺎن ﺟدﯾد ﻟﮫ وإﺑدال ﺑﯾن ﻣﺣﺗوى اﻟﻣؤﺷر وﻣﺣﺗوﯾﺎت اﻟﻣﺗﻐﯾر )‪.(g‬؟‬

 ‫++‪c‬‬                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                              ‫)(‪main‬‬
 ‫;‪1.{int g=15,item‬‬                                   ‫;‪1.{int g=15,item‬‬
 ‫;]1[ ‪2.int *ptr=new int‬‬                             ‫;]1[ ‪2.int *ptr=new int‬‬
 ‫;23=‪3. *ptr‬‬                                         ‫;23=‪3. *ptr‬‬
 ‫;‪4.item=*ptr‬‬                                        ‫;‪4.item=*ptr‬‬
 ‫;‪5.*ptr=g‬‬                                           ‫;‪5.*ptr=g‬‬
 ‫;‪6.g=item‬‬                                           ‫;‪6.g=item‬‬
 ‫};‪7.cout<<"\ng="<<g<<"\n*ptr="<<*ptr‬‬                ‫};)‪7.printf("\ng=%d\n*ptr=%d",g,*ptr‬‬
                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                     ‫١.ﺧطوة رﻗم)٢( ﺟﻌﻠﻧﺎ اﻟﻣؤﺷر ﯾﺷﯾر إﻟﻰ ﻣوﻗﻊ ﺟدﯾد .وﺧطوة ﻟرﻗم)٣( ﺧزﻧﺎ ﺑﺎﻟﻣوﻗﻊ ﻗﯾﻣﺔ )٢٣(‬
                                          ‫٢.ﺧطوة رﻗم )٤( وﺿﻌﻧﺎ ﻗﯾﻣﺔ اﻟﻣؤﺷر )‪ (*ptr‬ﻓﻲ ﻣﺗﻐﯾر ﻣؤﻗت ﻟﻺﺑدال‬
                            ‫٣.ﺧطوة رﻗم )٥(وﺿﻌﻧﺎ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (g‬ﻓﻲ اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ اﻟﻣؤﺷر )‪(*ptr‬‬
                               ‫٤.ﺧطوة رﻗم )٦( وﺿﻌﻧﺎ ﻗﯾﻣﺔ اﻟﻣؤﺷر اﻟﺗﻲ ﺧزﻧﺎھﺎ ﻓﻲ ﻣﺗﻐﯾر ﻣؤﻗت إﻟﻰ ﻣﺗﻐﯾر)‪(g‬‬

                  ‫ﻗﺑل اﻹﺑدال‬                                                       ‫ﺑﻌد اﻹﺑدال‬

 ‫ﻋﻧوان اﻟﻣوﻗﻊ اﺳم اﻟﻣؤﺷر‬            ‫ﻣﺣﺗواه‬                   ‫ﻋﻧوان اﻟﻣوﻗﻊ اﺳم اﻟﻣؤﺷر‬                ‫ﻣﺣﺗواه‬
    ‫‪ptr‬‬     ‫8‪0x244f23e‬‬               ‫23‬                         ‫‪ptr‬‬     ‫8‪0x244f23e‬‬                   ‫51‬
                                                     ‫1‬

 ‫ﻋﻧوان اﻟﻣوﻗﻊ اﺳم اﻟﻣﺗﻐﯾر‬           ‫ﻣﺣﺗواه‬                    ‫ﻋﻧوان اﻟﻣوﻗﻊ اﺳم اﻟﻣﺗﻐﯾر‬              ‫ﻣﺣﺗواه‬
    ‫‪item‬‬     ‫2‪0x244f23a‬‬              ‫ﻓﺎرغ‬                        ‫‪item‬‬     ‫2‪0x244f23a‬‬                  ‫23‬

                                                                                                        ‫3‬
 ‫ﻋﻧوان اﻟﻣوﻗﻊ اﺳم اﻟﻣﺗﻐﯾر‬           ‫ﻣﺣﺗواه‬           ‫2‬        ‫ﻋﻧوان اﻟﻣوﻗﻊ اﺳم اﻟﻣﺗﻐﯾر‬              ‫ﻣﺣﺗواه‬
      ‫‪g‬‬      ‫4‪0x244f23b‬‬               ‫51‬                           ‫‪g‬‬      ‫4‪0x244f23b‬‬                  ‫23‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                         ‫اﻟﻔﺻل اﻟﺳﺎدس‬



                                                     ‫ﻣﮭم‬
                                                                    ‫٤.٦- اﻟﻣؤﺷرات واﻟﻣﺻﻔوﻓﺎت:‬
    ‫اﻟﻣﺻﻔوﻓﺎت اﻷﺣﺎدﯾﺔ واﻟﻣؤﺷرات: ﻋرﻓﻧﺎ أن اﻟﻣﺻﻔوﻓﺔ اﻷﺣﺎدﯾﺔ ھﻲ ﻣﺟﻣوﻋﺔ ﻣن اﻟﻣواﻗﻊ اﻟﻣﺗﺗﺎﻟﯾﺔ اﻟﻣﺣﺟوزة ﻓﻲ‬
    ‫اﻟذاﻛرة وﯾﻣﻛن أن ﻧﺳﺗﺧدم اﻟﻣؤﺷر ﻣﻊ اﻟﻣﺻﻔوﻓﺔ اﻷﺣﺎدﯾﺔ وﺟﻌﻠﮫ ﯾؤﺷر ﻋﻠﻰ اﺣد اﻟﻘﯾم وﺳﮭوﻟﺔ ﺗﻣرﯾره ﻋﻠﻰ ﺟﻣﯾﻊ‬
                 ‫اﻟﻌﻧﺎﺻر ﻓﻘط ﻧزﯾد ﻗﯾﻣﺔ ﻋﻧوان اﻟﻣؤﺷر ﺑواﺣد ﻓﯾﻧﺗﻘل اﻟﻣؤﺷر ﻟﯾؤﺷر ﻋﻠﻰ اﻟﻣوﻗﻊ اﻟﺗﺎﻟﻲ اﻟذي ﯾﻠﯾﮫ.‬

 ‫ﻣﺛﺎل ﺗوﺿﯾﺣﻲ :ﻟو ﻋرﻓﻧﺎ اﻟﻣﺻﻔوﻓﺔ اﻟﺗﺎﻟﯾﺔ ﺣﺟﻣﮭﺎ ﺧﻣﺳﺔ ﻋﻧﺎﺻر وﺟﻌﻠﻧﺎ اﻟﻣؤﺷر ﯾؤﺷر ﻋﻠﻰ أول ﻋﻧﺻر ﺑﺎﻟﻣﺻﻔوﻓﺔ‬

                                                                                                     ‫ﻛود‬
       ‫;}45,32,34,62,43{=]5[‪Int first_array‬‬
       ‫;]0[‪int *ptr=& first_array‬‬
                                                      ‫واﻓﺗرﺿﻧﺎ أن أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﺧزن ﺑﻣوﻗﻊ )62181(‬

                                                                           ‫ﻣﻮاﻗﻊ ﺧﻼﯾﺎ اﻟﺬاﻛﺮة‬
                                                            ‫ﻣواﻗﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬      ‫اﻟﻣوﻗﻊ‬        ‫ﻣﺤﺘﻮاه‬
                                            ‫‪*ptr‬‬                                      ‫52181‬         ‫‪data‬‬
                                                                ‫]0[ ‪first_array‬‬       ‫62181‬         ‫43‬
                             ‫)1+‪*(ptr‬‬
                                                                ‫]1[ ‪first_array‬‬       ‫72181‬         ‫62‬
                                               ‫)2+‪*(ptr‬‬
                                                                ‫]2[ ‪first_array‬‬       ‫82181‬         ‫34‬
                            ‫)3+‪*(ptr‬‬
                                                                ‫]3[ ‪first_array‬‬       ‫92181‬         ‫32‬
                                        ‫)4+‪*(ptr‬‬                ‫]4[ ‪first_array‬‬       ‫03181‬         ‫45‬
                                                                                      ‫13181‬         ‫‪data‬‬

 ‫اﺳم اﻟﻣؤﺷر‬       ‫اﻟﻌﻧوان اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ‬
    ‫‪ptr‬‬                  ‫62181‬

                       ‫‪ ‬ﻻﺣظ أن اﻟﻣؤﺷر)‪ (ptr‬ﯾؤﺷر ﻋﻠﻰ )]0[ ‪ (first_array‬أي ﻋﻠﻰ اﻟﻣوﻗﻊ )62181(‬
   ‫‪ ‬إذا أردﻧﺎ أن ﯾؤﺷر اﻟﻣؤﺷر )‪ (ptr‬ﻋﻠﻰ اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ ﺑﺎﻟﻣﺻﻔوﻓﺔ ﻧزﯾد ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ اﻟﻣؤﺷر‬
                                                                             ‫)‪ (ptr‬ﺑﻣﻘدار واﺣد ھﻛذا‬

                                                                                                     ‫ﻛود‬
       ‫72181‪ptr+118126+1‬‬
                      ‫ﻟﯾﺻﺑﺢ اﻟﻣؤﺷر ﯾؤﺷر ﻋﻠﻰ اﻟﻣوﻗﻊ )72181( وھو ﻋﻧوان ﺛﺎﻧﻲ ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ‬

  ‫‪ ‬إذا أردﻧﺎ أن ﯾؤﺷر اﻟﻣؤﺷر )‪ (ptr‬ﻋﻠﻰ اﻟﻣوﻗﻊ اﻟراﺑﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ ﻧزﯾد ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ اﻟﻣؤﺷر‬
 ‫)‪ (ptr‬ﺑﻣﻘدار ﺛﻼﺛﺔ ھﻛذا . ﻟﯾﺻﺑﺢ اﻟﻣؤﺷر ﯾؤﺷر ﻋﻠﻰ اﻟﻣوﻗﻊ )92181( وھو ﻋﻧوان راﺑﻊ ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ‬

                                                                                                     ‫ﻛود‬
       ‫92181‪ptr+118126+3‬‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                                 ‫اﻟﻔﺻل اﻟﺳﺎدس‬




                     ‫ﻣﺛﺎل: ﻣﺻﻔوﻓﺔ ﻣﻛوﻧﺔ ﻣن ﺧﻣﺳﺔ ﻋﻧﺎﺻر أﺿف ﻣﻘدار )٤١( ﻟﻛل ﻋﻧﺻر ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷرات..؟‬

 ‫++‪c‬‬                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                      ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                    ‫)(‪main‬‬
 ‫;}45,32,34,62,43{=]5[‪1.{ int i, first_array‬‬                ‫;}45,32,34,62,43{=]5[‪1.{ int i, first_array‬‬
 ‫;]0[‪2.int *ptr=& first_array‬‬                               ‫;]0[‪2.int *ptr=& first_array‬‬
 ‫{)++‪3. for(i=0;i<5;i‬‬                                      ‫{)++‪3. for(i=0;i<5;i‬‬
 ‫;41+)‪4. *(ptr+i)=*(ptr+i‬‬                                  ‫;41+)‪4. *(ptr+i)=*(ptr+i‬‬
 ‫}};)‪5.cout<<"\n first_array["<<i<<"]="<<*(ptr+i‬‬           ‫}};))‪4.printf("\n first_array[%d]=%d",i,*(ptr+i‬‬
                                                                                    ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                             ‫١.ﺧطوة رﻗم )٢( ﺟﻌﻠﻧﺎ اﻟﻣؤﺷر )‪ (ptr‬ﯾؤﺷر ﻋﻠﻰ ﻋﻧوان أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬
                             ‫٢.ﺧطوة رﻗم )٣( ھو ﻋداد ﯾﻌد ﻣن )4—0( وﯾﻛرر ﺧطوة رﻗم )٤ و٥( ﻓﻲ ﻛل ﻋدة‬
‫٣.ﺧطوة رﻗم )٤( ھو إﺿﺎﻓﺔ ﻣﻘدار )٤١( ﻟﻛل ﻣوﻗﻊ ﻣن ﻣواﻗﻊ اﻟﻣﺻﻔوﻓﺔ ﻓﻣﺛﻼ ﻋﻧد اﻹﺿﺎﻓﺔ ﻓﻲ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث ﺗﻛون‬
                                                                   ‫ﻗﯾﻣﺔ )2=‪ (i‬ﻓﺗﻛون ﺧطوة رﻗم)٤( ھﻛذا‬
                                                                                                             ‫ﻛود‬
        ‫;41+)2+‪4. *(ptr+i)=*(ptr+i)+14;*(ptr+2)=*(ptr‬‬
    ‫وﺑﻣﺎ أن اﻟﻣؤﺷر ﻓﻲ ﺧطوة رﻗم )٢( ﯾؤﺷر ﻋﻠﻰ أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻓﻌد إﺿﺎﻓﺔ ﻗﯾﻣﺔ )٢( إﻟﻰ ﻋﻧوان اﻟﻣوﻗﻊ‬
                                                                  ‫ﺳوف ﯾؤﺷر ﻋﻠﻰ ﺛﺎﻟث ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ.‬



                                              ‫ﻣﺛﺎل: ﻣﺻﻔوﻓﺔ ﻣﻛوﻧﺔ ﻣن ﺛﻼث ﻋﻧﺎﺻر أﺟﻣﻌﮭﺎ ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷرات..؟‬

 ‫++‪c‬‬                                        ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                      ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                    ‫)(‪main‬‬
 ‫;}45,32,34 {=]3[‪1.{ int sum=0, first_array‬‬                ‫;}45,32,34 {=]3[‪1.{ int sum=0, first_array‬‬
 ‫;]0[‪2.int *ptr=& first_array‬‬                               ‫;]0[‪2.int *ptr=& first_array‬‬
 ‫;++‪3. sum+=*ptr‬‬                                           ‫;++‪3. sum+=*ptr‬‬
 ‫;++‪4. sum+=*ptr‬‬                                           ‫;++‪4. sum+=*ptr‬‬
 ‫;++‪5. sum+=*ptr‬‬                                           ‫;++‪5. sum+=*ptr‬‬
 ‫};‪6.cout<<"\n sum="<<sum‬‬                                  ‫};)‪6.printf("\n sum=%d ",sum‬‬
                                                                                         ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                                    ‫١.ﺧطوة رﻗم )٢( ﺟﻌﻠﻧﺎ اﻟﻣؤﺷر )‪ (ptr‬ﯾؤﺷر ﻋﻠﻰ أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬
      ‫٢.ﺧطوة رﻗم )٣( أﺿﻔﻧﺎ ﻗﯾﻣﺔ أول ﻣوﻗﻊ إﻟﻰ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬وزودﻧﺎ ﻗﯾﻣﺔ اﻟوﻗﻊ ﺑﻣﻘدار واﺣد ﻟﯾؤﺷر ﻋﻠﻰ‬
          ‫اﻟﻌﻧﺻر اﻟﺛﺎﻧﻲ )ﻟو ﺗﻼﺣظ اﻟزﯾﺎدة ﺑﻌد اﻟﺟﻣﻊ إي ﯾﺟﻣﻊ ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻷول ﺛم ﯾﻧﻘل اﻟﻣؤﺷر ﻟﻠﻣوﻗﻊ اﻟﺛﺎﻧﻲ(‬
     ‫٣. ﺧطوة رﻗم )٤( أﺿﻔﻧﺎ ﻗﯾﻣﺔ ﺛﺎﻧﻲ ﻣوﻗﻊ إﻟﻰ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬وزودﻧﺎ ﻗﯾﻣﺔ اﻟوﻗﻊ ﺑﻣﻘدار واﺣد ﻟﯾؤﺷر ﻋﻠﻰ‬
                                                                                            ‫اﻟﻌﻧﺻر اﻟﺛﺎﻟث‬
               ‫٤. ﺧطوة رﻗم )٥( أﺿﻔﻧﺎ ﻗﯾﻣﺔ ﺛﺎﻟث ﻣوﻗﻊ إﻟﻰ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬وزودﻧﺎ ﻗﯾﻣﺔ اﻟوﻗﻊ ﺑﻣﻘدار واﺣد‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                          ‫اﻟﻔﺻل اﻟﺳﺎدس‬
                                                                                                                 ‫ﻣﮭم‬


‫اﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ واﻟﻣؤﺷرات: ﻋرﻓﻧﺎ أن اﻟﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ ھﻲ ﻣﺟﻣوﻋﺔ ﻣن اﻟﻣواﻗﻊ اﻟﻣﺗﺗﺎﻟﯾﺔ اﻟﻣﺣﺟوزة ﻓﻲ اﻟذاﻛرة‬
‫وﯾﻣﻛن أن ﻧﺳﺗﺧدم اﻟﻣؤﺷر ﻣﻊ اﻟﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ وﺟﻌﻠﮫ ﯾؤﺷر ﻋﻠﻰ اﺣد اﻟﻘﯾم وﺳﮭوﻟﺔ ﺗﻣرﯾره ﻋﻠﻰ ﺟﻣﯾﻊ اﻟﻌﻧﺎﺻر ﻓﻘط‬
                                  ‫ﻧزﯾد ﻗﯾﻣﺔ ﻋﻧوان اﻟﻣؤﺷر ﺑواﺣد ﻓﯾﻧﺗﻘل اﻟﻣؤﺷر ﻟﯾؤﺷر ﻋﻠﻰ اﻟﻣوﻗﻊ اﻟﺗﺎﻟﻲ اﻟذي ﯾﻠﯾﮫ.‬

       ‫ﻣﺛﺎل ﺗوﺿﯾﺣﻲ:ﻟو ﻋرﻓﻧﺎ اﻟﻣﺻﻔوﻓﺔ اﻟﺗﺎﻟﯾﺔ ﺣﺟﻣﮭﺎ )2*2( وﺟﻌﻠﻧﺎ اﻟﻣؤﺷر ﯾؤﺷر ﻋﻠﻰ أول ﻋﻧﺻر ﺑﺎﻟﻣﺻﻔوﻓﺔ‬

                                                                                                      ‫ﻛود‬
        ‫;} }32,34{,}62,43{{=]2[]2[‪int first_array‬‬
        ‫;]0[]0[‪int *ptr=& first_array‬‬
                                                     ‫واﻓﺗرﺿﻧﺎ أن أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﺧزن ﺑﻣوﻗﻊ )62181(‬

                                                                            ‫ﻣﻮاﻗﻊ ﺧﻼﯾﺎ اﻟﺬاﻛﺮة‬
                                                           ‫ﻣواﻗﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ‬        ‫اﻟﻣوﻗﻊ‬        ‫ﻣﺤﺘﻮاه‬
                                           ‫‪*ptr‬‬                                        ‫52181‬         ‫‪data‬‬
                                                               ‫]0[]0[ ‪first_array‬‬      ‫62181‬         ‫43‬
                             ‫)1+‪*(ptr‬‬
                                                               ‫]1[]0[ ‪first_array‬‬      ‫72181‬         ‫62‬
                                              ‫)2+‪*(ptr‬‬
                                                               ‫]0[]1[ ‪first_array‬‬      ‫82181‬         ‫34‬
                            ‫)3+‪*(ptr‬‬
                                                               ‫]1[]1[ ‪first_array‬‬      ‫92181‬         ‫32‬
                                                                                       ‫13181‬         ‫‪data‬‬

 ‫اﺳم اﻟﻣؤﺷر‬       ‫اﻟﻌﻧوان اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ‬
    ‫‪ptr‬‬                  ‫62181‬

                       ‫‪ ‬ﻻﺣظ أن اﻟﻣؤﺷر)‪ (ptr‬ﯾؤﺷر ﻋﻠﻰ )]0[]0[ ‪ (first_array‬أي ﻋﻠﻰ اﻟﻣوﻗﻊ )62181(‬
  ‫‪ ‬إذا أردﻧﺎ أن ﯾؤﺷر اﻟﻣؤﺷر )‪ (ptr‬ﻋﻠﻰ اﻟﻣوﻗﻊ اﻟﺛﺎﻧﻲ ﺑﺎﻟﻣﺻﻔوﻓﺔ )أي اﻟﺻف اﻷول اﻟﻌﻣود اﻟﺛﺎﻧﻲ( ﻧزﯾد ﻗﯾﻣﺔ‬
                                             ‫اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ اﻟﻣؤﺷر )‪ (ptr‬ﺑﻣﻘدار واﺣد ھﻛذا‬

                                                                                                      ‫ﻛود‬
        ‫72181‪ptr+118126+1‬‬
                       ‫ﻟﯾﺻﺑﺢ اﻟﻣؤﺷر ﯾؤﺷر ﻋﻠﻰ اﻟﻣوﻗﻊ )72181( وھو ﻋﻧوان ﺛﺎﻧﻲ ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ‬

  ‫‪ ‬إذا أردﻧﺎ أن ﯾؤﺷر اﻟﻣؤﺷر )‪ (ptr‬ﻋﻠﻰ اﻟﻣوﻗﻊ اﻟراﺑﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ )أي اﻟﺻف اﻟﺛﺎﻧﻲ اﻟﻌﻣود اﻟﺛﺎﻧﻲ( ﻧزﯾد ﻗﯾﻣﺔ‬
    ‫اﻟﻣوﻗﻊ اﻟذي ﯾؤﺷر ﻋﻠﯾﮫ اﻟﻣؤﺷر )‪ (ptr‬ﺑﻣﻘدار ﺛﻼﺛﺔ ھﻛذا . ﻟﯾﺻﺑﺢ اﻟﻣؤﺷر ﯾؤﺷر ﻋﻠﻰ اﻟﻣوﻗﻊ )92181(‬
                                                                      ‫وھو ﻋﻧوان راﺑﻊ ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ‬

                                                                                                      ‫ﻛود‬        ‫ﻣﮭم‬
      ‫92181‪ptr+118126+3‬‬
‫‪ ‬ﺗﻌﺎﻣل اﻟﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ ﻧﻔس ﻣﻌﺎﻣﻠﺔ اﻟﻣﺻﻔوﻓﺔ اﻷﺣﺎدﯾﺔ ﺑﺎﻟﻣؤﺷرات ﻻن ﻛﻼھﻣﺎ ﻋﺑﺎرة ﻋن ﺧﻼﯾﺎ ﻣﺗﺳﻠﺳﻠﺔ‬
                                                                             ‫ﻣﺣﺟوزة ﺑﺎﻟذاﻛرة‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                                       ‫اﻟﻔﺻل اﻟﺳﺎدس‬




                                 ‫ﻣﺛﺎل: ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ )2*2( أﺿرب ﻛل ﻋﻧﺻر ﺑﻣﻘدار )٤( ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷرات..؟‬

 ‫++‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬     ‫‪c‬‬                                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                          ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                        ‫)(‪main‬‬
 ‫;} }32,34{,}62,43{{=]2[]2[‪1.{ int i, j,first_array‬‬            ‫;} }32,34{,}62,43{{=]2[]2[‪1.{ int i, j,first_array‬‬
 ‫;]0[]0[‪2.int *ptr=& first_array‬‬                                ‫;]0[]0[‪2.int *ptr=& first_array‬‬
 ‫)++‪3. for(i=0;i<2*2;i‬‬                                         ‫)++‪3. for(i=0;i<2*2;i‬‬
 ‫;4*)‪4. *(ptr+i)=*(ptr+i‬‬                                       ‫;4*)‪4. *(ptr+i)=*(ptr+i‬‬
 ‫{)++‪5.for(i=0;i<2 ;i‬‬                                          ‫{)++‪5.for(i=0;i<2 ;i‬‬
 ‫)++‪6.for(j=0;j<2 ;j‬‬                                           ‫)++‪6.for(j=0;j<2 ;j‬‬
 ‫;]‪7.cout<< first_array[i][j‬‬                                   ‫;)]‪7.printf("%d\t", first_array[i][j‬‬
 ‫}};"‪8.cout<<"\n‬‬                                               ‫}};)"‪8.printf("\n‬‬
                                                                                   ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                            ‫١.ﺧطوة رﻗم )٢( ﺟﻌﻠﻧﺎ اﻟﻣؤﺷر )‪ (ptr‬ﯾؤﺷر ﻋﻠﻰ ﻋﻧوان أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬
                            ‫٢.ﺧطوة رﻗم )٣( ھو ﻋداد ﯾﻌد ﻣن )4—0( وﯾﻛرر ﺧطوة رﻗم )٤ و٥( ﻓﻲ ﻛل ﻋدة‬
‫٣.ﺧطوة رﻗم )٤( ھو ﺿرب ﻣﻘدار ) ٤( ﻟﻛل ﻣوﻗﻊ ﻣن ﻣواﻗﻊ اﻟﻣﺻﻔوﻓﺔ ﻓﻣﺛﻼ ﻋﻧد اﻹﺿﺎﻓﺔ ﻓﻲ اﻟﻣوﻗﻊ اﻟﺛﺎﻟث ﺗﻛون‬
                                                                   ‫ﻗﯾﻣﺔ )2=‪ (i‬ﻓﺗﻛون ﺧطوة رﻗم)٤( ھﻛذا‬
                                                                                                                   ‫ﻛود‬
         ‫;4*)2+‪4. *(ptr+i)=*(ptr+i)*4;*(ptr+2)=*(ptr‬‬
    ‫وﺑﻣﺎ أن اﻟﻣؤﺷر ﻓﻲ ﺧطوة رﻗم )٢( ﯾؤﺷر ﻋﻠﻰ أول ﻋﻧﺻر ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﻓﻌد إﺿﺎﻓﺔ ﻗﯾﻣﺔ )٢( إﻟﻰ ﻋﻧوان اﻟﻣوﻗﻊ‬
      ‫ﺳوف ﯾؤﺷر ﻋﻠﻰ ﺛﺎﻟث ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ .ﺧطوة رﻗم )٥ و٦و٧و٨( ھو طﺑﺎﻋﺔ ﻟﻌﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﺑﻌد اﻟﺿرب‬

                                                              ‫ﻣﺛﺎل: ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ )2*2( أﺟﻣﻌﮭﺎ ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷرات..؟‬

 ‫++‪c‬‬                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬     ‫‪c‬‬                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                          ‫>‪#include<stdio.h‬‬
 ‫)(‪main‬‬                                                        ‫)(‪main‬‬
 ‫;} }32,34{,}62,43{{=]2[]2[‪1.{ int sum=0, first_array‬‬           ‫;} }32,34{,}62,43{{=]2[]2[‪1.{ int sum=0, first_array‬‬
 ‫;]0[]0[‪2.int *ptr=& first_array‬‬                                ‫;]0[]0[‪2.int *ptr=& first_array‬‬
 ‫;++‪3. sum+=*ptr‬‬                                               ‫;++‪3. sum+=*ptr‬‬
 ‫;++‪4. sum+=*ptr‬‬                                               ‫;++‪4. sum+=*ptr‬‬
 ‫;++‪5. sum+=*ptr‬‬                                               ‫;++‪5. sum+=*ptr‬‬
 ‫;++‪6. sum+=*ptr‬‬                                               ‫;++‪6. sum+=*ptr‬‬
 ‫};‪7.cout<<"\n sum="<<sum‬‬                                      ‫};)‪7.printf("\n sum=%d ",sum‬‬
                                                                                         ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
‫١.ﺧطوة رﻗم )٣( أﺿﻔﻧﺎ ﻗﯾﻣﺔ أول ﻣوﻗﻊ )0,0( إﻟﻰ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬وزودﻧﺎ ﻗﯾﻣﺔ اﻟوﻗﻊ ﺑﻣﻘدار واﺣد ﻟﯾؤﺷر ﻋﻠﻰ‬
   ‫اﻟﻌﻧﺻر اﻟﺛﺎﻧﻲ )1,0( )ﻟو ﺗﻼﺣظ اﻟزﯾﺎدة ﺑﻌد اﻟﺟﻣﻊ إي ﯾﺟﻣﻊ ﻗﯾﻣﺔ اﻟﻣوﻗﻊ اﻷول ﺛم ﯾﻧﻘل اﻟﻣؤﺷر ﻟﻠﻣوﻗﻊ اﻟﺛﺎﻧﻲ(‬
  ‫٢. ﺧطوة رﻗم )٤( أﺿﻔﻧﺎ ﻗﯾﻣﺔ ﺛﺎﻧﻲ ﻣوﻗﻊ )1,0( إﻟﻰ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬وزودﻧﺎ ﻗﯾﻣﺔ اﻟوﻗﻊ ﺑﻣﻘدار واﺣد ﻟﯾؤﺷر‬
                                                                                 ‫ﻋﻠﻰ اﻟﻌﻧﺻر اﻟﺛﺎﻟث )0,1(‬
    ‫٣. ﺧطوة رﻗم )٥( أﺿﻔﻧﺎ ﻗﯾﻣﺔ ﺛﺎﻟث)0,1( ﻣوﻗﻊ إﻟﻰ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬وزودﻧﺎ ﻗﯾﻣﺔ اﻟوﻗﻊ ﺑﻣﻘدار واﺣد ﻟﯾؤﺷر‬
                                                                                 ‫ﻋﻠﻰ اﻟﻌﻧﺻر اﻟراﺑﻊ )1,1(‬
     ‫٤. ﺧطوة رﻗم )٦( أﺿﻔﻧﺎ ﻗﯾﻣﺔ راﺑﻊ ﻣوﻗﻊ )1,1( إﻟﻰ ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (sum‬وزودﻧﺎ ﻗﯾﻣﺔ اﻟوﻗﻊ ﺑﻣﻘدار واﺣد .‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                             ‫اﻟﻔﺻل اﻟﺳﺎدس‬

                                                                                                                 ‫ﻣﮭم‬


                                                          ‫٥.٦- اﻟﻣؤﺷرات واﻟدوال )‪(function‬‬
‫١. اﻟدوال واﻟﻣﺗﻐﯾرات: ﻋرﻓﻧﺎ طرﯾﻘﺔ إرﺳﺎل ﻣﺗﻐﯾر ﺑﺎﻟﻘﯾﻣﺔ ﻛﯾف وﺑﺎﻟﻣرﺟﻊ ﻛﯾف ﺗﻛون. اﻟﻣؤﺷرات ﺗﻣﻛﻧك ﻣن‬
‫إرﺳﺎل اﻟﻣﺗﻐﯾر ﺑﺎﻟﻣرﺟﻊ أي إرﺳﺎل ﻣوﻗﻊ اﻟﻣﺗﻐﯾر وھذه ﺗﻔﯾد إذا ﻛﻧﺎ ﻧرﯾد أن ﻧﻌﯾد أﻛﺛر ﻣن ﻣﺗﻐﯾر إﻟﻰ اﻟﺑرﻧﺎﻣﺞ‬
    ‫اﻟرﺋﯾﺳﻲ وﻧﻌﻠم إن اﻹرﺳﺎل ﺑﺎﻟﻣرﺟﻊ ﯾﻛون أي ﺗﻐﯾر ﻋﻠﻰ اﻟﻣﺗﻐﯾر ﻓﻲ اﻟدوال ﯾؤﺛر ﻋﻠﻰ ﻗﯾﻣﺗﮫ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬
                                                                                              ‫اﻟرﺋﯾﺳﻲ‬

                                           ‫ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻣﺗﻐﯾر اﺳﻣﮫ )‪ (a‬وﻧرﯾد إرﺳﺎﻟﮫ إﻟﻰ داﻟﺔ اﺳﻣﮭﺎ )‪. (name‬‬

                                                                    ‫إرﺳﺎل ﻣﺻﻔوﻓﺔ ﻣؤﺷر إﻟﻰ اﻟدوال )‪(function‬‬
        ‫;) ‪name( &a‬‬
                                              ‫‪ ‬وﺿﻊ ﻋﻼﻣﺔ )&( ﻗﺑﻠﮫ ﻣﻌﻧﺎه أﻧﻧﺎ أرﺳﻠﻧﺎ ﻋﻧوان أول ﻣوﻗﻊ .‬



             ‫وطرﯾﻘﺔ اﺳﺗﻘﺑﺎل اﻟﻣﺗﻐﯾر ﻓﻲ اﻟدوال ﻧﻌرف ﻣؤﺷر ﻣن ﻧﻔس ﻧوع اﻟﻣﺗﻐﯾر اﻟﻣرﺳل ﻟﻛﻲ ﯾؤﺷر ﻋﻠﻰ ﻣوﻗﻌﮫ .‬

                                                                   ‫اﺳﺗﻘﺑﺎل ﻣﺻﻔوﻓﺔ ﻣؤﺷر إﻟﻰ اﻟدوال )‪(function‬‬
        ‫;)‪Type name(type *ptr‬‬
                                                                     ‫‪ :(type) ‬ھو ﻧوع اﻟﻣﺗﻐﯾر اﻟﻣرﺳل‬
                                                ‫‪ ‬أﻻن أﺻﺑﺢ ھذا اﻟﻣؤﺷر )‪ (ptr‬ﯾؤﺷر ﻋﻠﻰ ﻋﻧوان اﻟﻣﺗﻐﯾر.‬



                                          ‫ﻣﺛﺎل: ﺗﻛوﯾن داﻟﺔ ﺗﺳﺗﻘﺑل وﺣرف ﺻﻐﯾر وﺗﺣوﻟﮫ إﻟﻰ ﺣرف ﻛﺑﯾر..؟‬

   ‫ﺗﺣﻠﯾل: ﻟﺗﺣوﯾل ﺣرف ﻣن ﺻﻐﯾر إﻟﻰ ﻛﺑﯾر ﻧﻌﻠم أن اﻟﻔرق ﺑﯾن أﺳﻛﻲ ﻛود ﻛل ﺣرف ﺻﻐﯾر وﻧﺿﯾره اﻟﻛﺑﯾر ھو‬
   ‫)٢٣( ﻟذاﻟك ﻟﺗﺣوﯾل إﻟﻰ ﺣرف ﻛﺑﯾر ﻧﺣول اﻟﺣرف إﻟﻰ أﺳﻛﻲ ﻛود وﻧطرح ﻣﻧﮫ )٢٣( وﻧرﺟﻊ ﻧﺣوﻟﮫ إﻟﻰ ﺣرف‬
                                                                          ‫ﻓﯾﺗﺣول إﻟﻰ ﺣرف ﻛﺑﯾر‬

                                                                          ‫اﻟﺣل ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷرات...........!‬

 ‫++‪c‬‬                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                   ‫>‪#include<stdio.h‬‬
 ‫)‪1.inline toBigLeter (char *ptr‬‬                        ‫)‪1.inline toBigLeter (char *ptr‬‬
 ‫};23-)‪2.{*ptr=int(*ptr‬‬                                 ‫};23-)‪2.{*ptr=int(*ptr‬‬
 ‫)(‪3.main‬‬                                               ‫)(‪3.main‬‬
 ‫;‪4. { char inputchar‬‬                                   ‫;‪4. { char inputchar‬‬
 ‫;‪5.cin>> inputchar‬‬                                     ‫;)‪5.scanf("%c",&inputchar‬‬
 ‫;) ‪6.toBigLeter (& inputchar‬‬                           ‫;) ‪6.toBigLeter (& inputchar‬‬
 ‫};‪7.cout<<"Big to it is="<< inputchar‬‬                  ‫};)‪7.prin ("Big to it is=%c", inputchar‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                                 ‫اﻟﻔﺻل اﻟﺳﺎدس‬




                                                                             ‫اﻟﺣل ﺑدون اﺳﺗﺧدام اﻟﻣؤﺷرات...........!‬

 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
 ‫)‪1.inline toBigLeter (char charrec‬‬                         ‫)‪1. inline toBigLeter (char charrec‬‬
 ‫};23-) ‪2.{ charrec =int( charrec‬‬                           ‫};23-)‪2.{ charrec =int(charrec‬‬
 ‫)(‪3.main‬‬                                                   ‫)(‪3.main‬‬
 ‫;‪4. { char inputchar‬‬                                       ‫;‪4. { char inputchar‬‬
 ‫;‪5.cin>> inputchar‬‬                                         ‫;)‪5.scanf("%c",&inputchar‬‬
 ‫;) ‪6.toBigLeter ( inputchar‬‬                                ‫;) ‪6.toBigLeter ( inputchar‬‬
 ‫};‪7.cout<<"Big to it is="<< inputchar‬‬                      ‫};)‪7.prin ("Big to it is=%c", inputchar‬‬

                                                                                 ‫ﺗوﺿﯾﺢ اﻟﺧطوات ﺑﺎﻟﻧﺳﺑﺔ ﻟﻠﺣﻠﯾن:‬
   ‫‪ ‬ﺧطوة رﻗم )١( ﻧﺳﺑﺔ إﻟﻰ اﻟﺣل ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷرات: إﻋﻼن ﻋﻧد داﻟﺔ ﺳطرﯾﮫ ﺗﺳﺗﻘﺑل ﻣوﻗﻊ اﻟﺣرف وﺗﻛﺑر‬
                                                                        ‫اﻟﺣرف ﻓﻲ ﺧطوة رﻗم )٢(‬
     ‫‪ ‬ﺧطوة رﻗم )١( ﻧﺳﺑﺔ إﻟﻰ اﻟﺣل ﺑدون اﺳﺗﺧدام اﻟﻣؤﺷرات :إﻋﻼن ﻋﻧد داﻟﺔ ﺳطرﯾﮫ ﺗﺳﺗﻘﺑل اﻟﺣرف وﺗﻛﺑر‬
                                                                        ‫اﻟﺣرف ﻓﻲ ﺧطوة رﻗم )٢(‬
  ‫‪ ‬ﺧطوة رﻗم )٦( ﻧﺳﺑﺔ إﻟﻰ اﻟﺣل ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷرات: إرﺳﺎل ﻋﻧوان اﻟﻣﺗﻐﯾر )‪ (inputchar‬إﻟﻰ اﻟداﻟﺔ ھﻛذا‬
                                                                                                      ‫ﻛود‬   ‫‪‬‬
        ‫) ‪1. toBigLeter (char *ptr‬‬       ‫‪‬‬
                            ‫‪x‬‬        ‫‪‬‬

              ‫) ‪toBigLeter ( &x‬‬

    ‫‪ ‬ﺧطوة رﻗم )٦( ﻧﺳﺑﺔ إﻟﻰ اﻟﺣل ﺑدون اﺳﺗﺧدام اﻟﻣؤﺷرات: إرﺳﺎل ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر )‪ (inputchar‬إﻟﻰ اﻟداﻟﺔ‬
                               ‫ﯾﻛون ھﻛذا )إذا ﻗﺎم اﻟﻣﺳﺗﺧدم ﺑﺈدﺧﺎل اﻟﺣرف ‪ a‬ﻣﺛﻼ ﻓﯾﻛون اﻹرﺳﺎل ھﻛذا(‬
                                                                                                      ‫ﻛود‬   ‫‪‬‬
        ‫) ‪1. toBigLeter (char ptr‬‬    ‫‪‬‬
                            ‫'‪'a‬‬          ‫‪‬‬
                                                                                                                      ‫ﻣﮭم‬
              ‫) ‪toBigLeter ( x‬‬


   ‫‪ ‬ﺧطوة رﻗم )٧( ﻧﺳﺑﺔ إﻟﻰ اﻟﺣل ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷرات :ﺳوف ﯾطﺑﻊ اﻟﺣرف ﺑﻌد اﻟﺗﻛﺑﯾر ﻷﻧﻧﺎ ﻓﻲ اﻟﻣؤﺷرات‬
     ‫ﻧﺗﻌﺎﻣل ﻣﻊ ﻣوﻗﻊ اﻟﻣﺗﻐﯾر ﻓﺄي ﺗﻐﯾر ﻓﻲ اﻟداﻟﺔ ﻋﻠﻰ اﻟﻣوﻗﻊ ﯾﻐﯾر ﻓﻲ ﻗﯾﻣﮫ اﻟﻣﺗﻐﯾر ﻓﻲ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ‬



‫‪ ‬ﺧطوة رﻗم )٦( ﻧﺳﺑﺔ إﻟﻰ اﻟﺣل ﺑدون اﺳﺗﺧدام اﻟﻣؤﺷرات: ﺳوف ﯾطﺑﻊ اﻟﺣرف ﺑدون أي ﺗﻛﺑﯾر ﻧﻔس اﻟﺣرف‬
 ‫اﻟﻣدﺧل ﺳوف ﯾطﺑﻌﮫ ﻷﻧﻧﺎ أرﺳﻠﻧﺎ ﻧﺳﺧﺔ ﻣن اﻟﻣﺗﻐﯾر إﻟﻰ اﻟداﻟﺔ وﻟم ﻧرﺳل اﻟﻣﺗﻐﯾر ﻧﻔﺳﮫ ﻓﺄي ﺗﻐﯾر ﻋﻠﻰ ھذه‬
                                                   ‫اﻟﻧﺳﺧﺔ ﻻ ﯾؤﺛر ﺑﻘﯾﻣﮫ اﻟﻣﺗﻐﯾر ﻓﻲ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                         ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                         ‫اﻟﻔﺻل اﻟﺳﺎدس‬




      ‫٢. اﻟدوال واﻟﻣﺻﻔوﻓﺎت اﻷﺣﺎدﯾﺔ: ﻋرﻓﺎ ﺳﺎﺑﻘﺎ طرﯾﻘﺔ اﻟﺗﻌﺎﻣل ﻣﻊ اﻟﻣﺻﻔوﻓﺎت ﻓﻲ اﻟدوال )‪(function‬‬
‫وﻋرﻓﻧﺎ طرﯾﻘﺔ اﻹرﺳﺎل إﻟﻰ اﻟداﻟﺔ وھﻲ إرﺳﺎل ﻧﺳﺧﺔ ﻣن اﻟﻣﺻﻔوﻓﺔ وﻟﯾس اﻟﻣﺻﻔوﻓﺔ اﻷﺻﻠﯾﺔ أي ﻛﺎن إرﺳﺎل‬
‫ﺑﺎﻟﻘﯾﻣﺔ. أﻣﺎ ﻣﻊ اﻟﻣؤﺷرات ﯾﻛون إرﺳﺎل ﺑﺎﻟﻣرﺟﻊ أي أن أي ﺗﻐﯾر ﻋﻠﻰ اﻟﻣﺻﻔوﻓﺔ داﺧل أي داﻟﺔ )‪(function‬‬
   ‫ﺳوف ﯾؤﺛر ﻋﻠﻰ اﻟﻣﺻﻔوﻓﺔ اﻷﺻﻠﯾﺔ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ اﻟﺗﻲ أرﺳﻠت إﻟﻰ اﻟداﻟﺔ ﻟﻠﻣﻌﺎﻟﺟﺔ ﻷن اﻟﻣؤﺷرات‬
                                         ‫ﺗﺗﻌﺎﻣل ﻣﻊ ﻣواﻗﻊ اﻟذاﻛرة أي ﻣواﻗﻊ اﻟﻣﺗﻐﯾرات وﻟﯾس ﻧﺳﺧﺔ ﻣﻧﮫ‬



 ‫ﺗرﺳل اﻟﻣﺻﻔوﻓﺔ اﻷﺣﺎدﯾﺔ إﻟﻰ اﻟداﻟﺔ ﺑﺗﺣدﯾد ﻋﻧوان اﻟﻣوﻗﻊ اﻟﻣرﺳل ﻛﺄن ﯾﻛون أﻧﻧﺎ ﻧرﺳل ﻋﻧوان أول ﻣوﻗﻊ وﻓﻲ اﻟداﻟﺔ‬
             ‫ﻋﻧدﻣﺎ ﯾﻌرف أول ﻣوﻗﻊ ﯾﺳﺗطﯾﻊ اﻟﺗﻧﻘل إﻟﻰ ﺑﺎﻗﻲ اﻟﻣواﻗﻊ ﺑزﯾﺎدة ﻗﯾﻣﺔ اﻟﻣؤﺷر ﺑواﺣد ﻛل ﻣرة . ھﻛذا ﺗرﺳل‬



                                  ‫ﻣﺛﺎل:ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻣﺻﻔوﻓﺔ اﺳﻣﮭﺎ )‪ (a‬وﻧرﯾد إرﺳﺎﻟﮭﺎ إﻟﻰ داﻟﺔ اﺳﻣﮭﺎ )‪. (name‬‬

                                                                ‫إرﺳﺎل ﻣﺻﻔوﻓﺔ ﻣؤﺷر إﻟﻰ اﻟدوال )‪(function‬‬
       ‫;)]0[ ‪name( &a‬‬
                                       ‫‪ ‬ﻓﻲ ھذه اﻟطرﯾﻘﺔ أرﺳﻠﻧﺎ ﻋﻧوان أول ﻣوﻗﻊ ﺑوﺿﻊ ﻋﻼﻣﺔ )&( ﻗﺑﻠﮫ .‬




                     ‫وطرﯾﻘﺔ اﺳﺗﻘﺑﺎل اﻟﻣﺻﻔوﻓﺔ اﻷﺣﺎدﯾﺔ ﻓﻲ اﻟدوال ﻧﻌرف ﻣؤﺷر ﻣن ﻧﻔس ﻧوع اﻟﻣﺻﻔوﻓﺔ اﻟﻣرﺳﻠﺔ .‬

                                                               ‫اﺳﺗﻘﺑﺎل ﻣﺻﻔوﻓﺔ ﻣؤﺷر إﻟﻰ اﻟدوال )‪(function‬‬
       ‫;)‪Type name(type *ptr‬‬
                                                               ‫‪ :(type) ‬ھو ﻧوع اﻟﻣﺻﻔوﻓﺔ اﻟﻣرﺳﻠﺔ‬
                                  ‫‪ ‬أﻻن أﺻﺑﺢ ھذا اﻟﻣؤﺷر )‪ (ptr‬ﯾؤﺷر ﻋﻠﻰ ﻋﻧوان أول ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ‬




    ‫** ﻓﻲ إرﺳﺎل اﻟﻣﺻﻔوﻓﺔ إﻟﻰ اﻟدوال ﻗد ﻧرﺳل ﻋﻧوان أول ﻣوﻗﻊ أو ﻧرﺳل ﻋﻧوان أﺧر ﻣوﻗﻊ أو أي ﻣوﻗﻊ ﺣﺳب ﻣﺎ‬
                                                                                   ‫ﻧﺣﺗﺎﺟﮫ ﻓﻲ ﺑرﻧﺎﻣﺟﻧﺎ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(pointer) ‫اﻟﻣؤﺷرات‬                                                                                                  ‫اﻟﻔﺻل اﻟﺳﺎدس‬




                            ‫ﻣﺛﺎل : ﺗﻛوﯾن داﻟﺔ ﺗﻌﻛس ﺗﺳﻠﺳل أﺣرف ﺛﻼث ﻣﺻﻔوﻓﺎت ﺑﺎﻟﻌﻛس وﺗطﺑﻌﮭم ﺑﻌد اﻟﻌﻛس .؟‬

  ‫ﺗﺣﻠﯾل: ﺑﻣﺎ اﻧﮫ ﯾرﯾد ﻋﻛس اﻷﺣرف ﻓﻲ اﻟﻣﺻﻔوﻓﺔ ﺑﺎﺳﺗﺧدام اﻟدوال ﻓﯾﺟب اﻹرﺳﺎل ﺑﺎﻟﻣرﺟﻊ ﺣﺗﻰ ﻋﻧدﻣﺎ ﯾﻘﻠب أﺣرف‬
  . ‫( وﯾﻌود ﻟﻠﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ ﺗﻌﻛس اﻟﻣﺻﻔوﻓﺎت أﯾﺿﺎ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ‬function) ‫اﻟﺳﻠﺳﻠﺔ وﻋﻧدﻣﺎ ﯾﻧﺗﮭﻲ ﻣن‬

 c++                                          ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬     c                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                         #include<stdio.h>
 #include<string.h>                                           #include<string.h>
 1.int i;                                                     1.int i;
 2.Reverse(char *string,int len)                              2.Reverse(char *string,int len)
 3.{char item;                                                3.{char item;
 4.for(i=len; i>len/2;i--){                                   4.for(i=len; i>len/2;i--){
 5.item=* (string);                                           5.item=* (string);
 6.*(string )=*(string -i+(len-i));                           6.*(string )=*(string -i+(len-i));
 7. *(string -i+(len-i))= item;                               7. *(string -i+(len-i))= item;
 8. string --;} }                                             8. string --;} }
 9.main()                                                     9.main()
 10. { char string1[55], string2[55], string3[55];            10. { char string1[55], string2[55], string3[55];
 11.int len;                                                  11.int len;
 12.cout<<"enter string (1): ";                               12.prin ("enter string (1): ");
 13.cin.getline( string1,55);                                 13.gets ( string1 );
 14.len=strlen(string1)-1;                                    14.len=strlen(string1)-1;
 15.Reverse( &string1[len], len);                             15.Reverse( &string1[len], len);
 16.cout<< string1 ;                                          16.prin ("%s",string1 );
 17.cout<<"\nenter string (2): ";                             17.prin ("\n enter string (2): ");
 18.cin.getline( string2,55);                                 18.gets ( string2);
 19.len=strlen(string2)-1;                                    19.len=strlen(string2)-1;
 20.Reverse( &string2[len], len);                             20.Reverse( &string2[len], len);
 21.cout<< string2 ;                                          21.prin ("%s",string2 );
 22.cout<<"\n enter string (3): ";                            22.prin ("\n enter string (3): ");
 23.cin.getline( string3,55);                                 23.gets ( string3 );
 24.len=strlen(string3)-1;                                    24.len=strlen(string3)-1;
 25.Reverse( &string3[len], len);                             25.Reverse( &string3[len], len);
 26.cout<< string3 ;}                                         26.prin ("%s",string3);}
                                                                                                       :‫ﺗوﺿﯾﺢ اﻟﺧطوات‬

                                               ‫١.ﺧطوة رﻗم )٢(ھﻲ داﻟﺔ ﺗﺳﺗﻘﺑل أﺧر ﻣوﻗﻊ ﺑﺎﻟﺳﻠﺳﻠﺔ وطول ھذه اﻟﺳﻠﺳﻠﺔ‬

    ‫٢.ﺧطوة رﻗم )٤( ھو ﻋداد ﯾﺑدأ ﺑﺎﻟﻌد ﻣن أﺧر ﻣوﻗﻊ إﻟﻰ اﻟﻣﻧﺗﺻف ﺣﺗﻰ ﯾﺑدل اﻟﻣواﻗﻊ اﻷول ﺑﺎﻷﺧﯾر واﻟﺛﺎﻧﻲ ﺑﺎﻟﻘﺑل‬
                                                        ‫اﻷﺧﯾر ﻓﻲ ﺧطوات رﻗم )٥ و٦و٧و٨( وﯾﺳﺗﻣر ﺑﺎﻹﺑدال‬

                                            ‫٣.ﺧطوة رﻗم )٣١( ھﻲ إدﺧﺎل اﻟﺳﻠﺳﻠﺔ اﻷوﻟﻰ وﺧطوة )٤١( ﺣﺳﺎب طوﻟﮭﺎ‬

                                                     ‫٤.ﺧطوة رﻗم )٥١( ھﻲ إرﺳﺎل أﺧر ﻣوﻗﻊ ﺑﺎﻟﺳﻠﺳﻠﺔ وطول اﻟﺳﻠﺳﻠﺔ‬

                                                             ‫ﺑﻘﯾﺔ اﻟﺧطوات واﺿﺣﺔ وﻣﻛررة.ھذه ﺻورة ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                          C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                           ‫اﻟﻔﺻل اﻟﺳﺎدس‬
                                                                                                                ‫ﻣﮭم‬


       ‫٣. اﻟدوال واﻟﻣﺻﻔوﻓﺎت اﻟﺛﻧﺎﺋﯾﺔ: ﻋرﻓﺎ ﺳﺎﺑﻘﺎ طرﯾﻘﺔ اﻟﺗﻌﺎﻣل ﻣﻊ اﻟﻣﺻﻔوﻓﺎت ﻓﻲ اﻟدوال )‪(function‬‬
‫وﻋرﻓﻧﺎ طرﯾﻘﺔ اﻹرﺳﺎل إﻟﻰ اﻟداﻟﺔ وھﻲ إرﺳﺎل ﻧﺳﺧﺔ ﻣن اﻟﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ وﻟﯾس اﻟﻣﺻﻔوﻓﺔ اﻷﺻﻠﯾﺔ أي ﻛﺎن‬
     ‫إرﺳﺎل ﺑﺎﻟﻘﯾﻣﺔ. أﻣﺎ ﻣﻊ اﻟﻣؤﺷرات ﯾﻛون إرﺳﺎل ﺑﺎﻟﻣرﺟﻊ أي أن أي ﺗﻐﯾر ﻋﻠﻰ اﻟﻣﺻﻔوﻓﺔ داﺧل أي داﻟﺔ‬
 ‫)‪ (function‬ﺳوف ﯾؤﺛر ﻋﻠﻰ اﻟﻣﺻﻔوﻓﺔ اﻷﺻﻠﯾﺔ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ اﻟﺗﻲ أرﺳﻠت إﻟﻰ اﻟداﻟﺔ ﻟﻠﻣﻌﺎﻟﺟﺔ ﻷن‬
                                ‫اﻟﻣؤﺷرات ﺗﺗﻌﺎﻣل ﻣﻊ ﻣواﻗﻊ اﻟذاﻛرة أي ﻣواﻗﻊ اﻟﻣﺗﻐﯾرات وﻟﯾس ﻧﺳﺧﺔ ﻣﻧﮫ‬



  ‫ﺗرﺳل اﻟﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ إﻟﻰ اﻟداﻟﺔ ﺑﺗﺣدﯾد ﻋﻧوان اﻟﻣوﻗﻊ اﻟﻣرﺳل ﻛﺄن ﯾﻛون أﻧﻧﺎ ﻧرﺳل ﻋﻧوان أول ﻣوﻗﻊ وﻓﻲ اﻟداﻟﺔ‬
             ‫ﻋﻧدﻣﺎ ﯾﻌرف أول ﻣوﻗﻊ ﯾﺳﺗطﯾﻊ اﻟﺗﻧﻘل إﻟﻰ ﺑﺎﻗﻲ اﻟﻣواﻗﻊ ﺑزﯾﺎدة ﻗﯾﻣﺔ اﻟﻣؤﺷر ﺑواﺣد ﻛل ﻣرة . ھﻛذا ﺗرﺳل‬



                     ‫ﻣﺛﺎل:ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﻣﺻﻔوﻓﺔ اﺳﻣﮭﺎ )‪ (a‬ﺣﺟﻣﮭﺎ )4*4( وﻧرﯾد إرﺳﺎﻟﮭﺎ إﻟﻰ داﻟﺔ اﺳﻣﮭﺎ )‪. (name‬‬

                                                          ‫إرﺳﺎل ﻣؤﺷر ﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ إﻟﻰ اﻟدوال )‪(function‬‬
       ‫;)]0[]0[ ‪name( &a‬‬
                                       ‫‪ ‬ﻓﻲ ھذه اﻟطرﯾﻘﺔ أرﺳﻠﻧﺎ ﻋﻧوان أول ﻣوﻗﻊ ﺑوﺿﻊ ﻋﻼﻣﺔ )&( ﻗﺑﻠﮫ .‬




                      ‫وطرﯾﻘﺔ اﺳﺗﻘﺑﺎل اﻟﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ ﻓﻲ اﻟدوال ﻧﻌرف ﻣؤﺷر ﻣن ﻧﻔس ﻧوع اﻟﻣﺻﻔوﻓﺔ اﻟﻣرﺳﻠﺔ .‬

                                                        ‫اﺳﺗﻘﺑﺎل ﻣؤﺷر ﻣﺻﻔوﻓﺔ اﻟﺛﻧﺎﺋﯾﺔ إﻟﻰ اﻟدوال )‪(function‬‬
       ‫;)‪Type name(type *ptr‬‬
                                                                ‫‪ :(type) ‬ھو ﻧوع اﻟﻣﺻﻔوﻓﺔ اﻟﻣرﺳﻠﺔ‬
                                   ‫‪ ‬أﻻن أﺻﺑﺢ ھذا اﻟﻣؤﺷر )‪ (ptr‬ﯾؤﺷر ﻋﻠﻰ ﻋﻧوان أول ﻣوﻗﻊ ﺑﺎﻟﻣﺻﻔوﻓﺔ‬




    ‫** ﻓﻲ إرﺳﺎل اﻟﻣﺻﻔوﻓﺔ إﻟﻰ اﻟدوال ﻗد ﻧرﺳل ﻋﻧوان أول ﻣوﻗﻊ أو ﻧرﺳل ﻋﻧوان أﺧر ﻣوﻗﻊ أو أي ﻣوﻗﻊ ﺣﺳب ﻣﺎ‬
                                                                                   ‫ﻧﺣﺗﺎﺟﮫ ﻓﻲ ﺑرﻧﺎﻣﺟﻧﺎ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                      ‫اﻟﻔﺻل اﻟﺳﺎدس‬




              ‫ﻣﺛﺎل : ﺗﻛوﯾن داﻟﺔ ﺗﺿﻊ واﺣد ﻣﻛﺎن اﻟﻌدد اﻷوﻟﻲ ﻓﻲ ﻣﺻﻔوﻓﺔ )4*4( وﺻﻔر ﻣﻛﺎن اﻟﻌدد اﻟﻐﯾر أوﻟﻲ .؟‬

 ‫ﺗﺣﻠﯾل:ﺑﻣﺎ إﻧﻧﺎ ﻧرﯾد ﺗﺣوﯾل اﻟﻣﺻﻔوﻓﺔ إﻟﻰ أﺻﻔﺎر و واﺣدات ﻧرﺳﻠﮭﺎ ﻛﻣؤﺷر إﻟﻰ داﻟﮫ وھﻧﺎك اﻟﻌدد اﻷوﻟﻲ ﻧﺿﻊ ﻣﻛﺎﻧﮫ‬
                                                                           ‫واﺣد واﻟﻐﯾر أوﻟﻲ ﻧﺿﻊ ﺻﻔر‬

 ‫++‪c‬‬                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                          ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include<iostream.h‬‬                                    ‫>‪#include<stdio.h‬‬
 ‫;‪1.int i,j‬‬                                              ‫;‪1.int i,j‬‬
 ‫;4=‪2.int row‬‬                                            ‫;4=‪2.int row‬‬
 ‫;4=‪3.int col‬‬                                            ‫;4=‪3.int col‬‬
 ‫) ‪4.prime2d (int *string‬‬                                ‫) ‪4.prime2d (int *string‬‬
 ‫;1=‪5.{int prime‬‬                                         ‫;1=‪5.{int prime‬‬
 ‫{)++‪6.for(i=0; i<row*col ;i‬‬                             ‫{)++‪6.for(i=0; i<row*col ;i‬‬
 ‫;1=‪7.prime‬‬                                              ‫;1=‪7.prime‬‬
 ‫)++‪8.for(j=2;j<*string;j‬‬                                ‫)++‪8.for(j=2;j<*string;j‬‬
 ‫)0==‪9.if( *string % j‬‬                                   ‫)0==‪9.if( *string % j‬‬
 ‫;0=‪11.prime‬‬                                             ‫;0=‪11.prime‬‬
 ‫;‪12.*string= prime‬‬                                      ‫;‪12.*string= prime‬‬
 ‫} };++ ‪13. string‬‬                                       ‫} };++ ‪13. string‬‬
 ‫)(‪14.main‬‬                                               ‫)(‪14.main‬‬
 ‫;]4[]4[1‪15.{ int string‬‬                                 ‫;]4[]4[1‪15.{ int string‬‬
 ‫)++‪16. for(i=0; i<row ;i‬‬                                ‫)++‪16. for(i=0; i<row ;i‬‬
 ‫)++‪17.for(j=0; j<col ;j‬‬                                 ‫)++‪17.for(j=0; j<col ;j‬‬
 ‫;]‪18.cin>> string1[i][j‬‬                                 ‫;)]‪18.scanf("%d",& string1[i][j‬‬
 ‫;)]0[ ]0[1‪19.prime2d( &string‬‬                           ‫;)]0[ ]0[1‪19.prime2d( &string‬‬
 ‫{)++‪20.for(i=0; i<row ;i‬‬                                ‫{)++‪20.for(i=0; i<row ;i‬‬
 ‫)++‪21.for(j=0; j<col ;j‬‬                                 ‫)++‪21.for(j=0; j<col ;j‬‬
 ‫;"‪22.cout<< string1[i][j]<<"\t‬‬                          ‫;)]‪22.printf("%d\t", string1[i][j‬‬
 ‫}};"‪23.cout<<"\n‬‬                                        ‫}};)"‪23.printf("\n‬‬
                                                                                             ‫ﺗوﺿﯾﺢ اﻟﺧطوات:‬
                                                         ‫١.ﺧطوة رﻗم )٤( داﻟﺔ ﺗﺳﺗﻘﺑل ﻋﻧوان أول ﻋﻧﺻر ﺑﺎﻟﻣﺻﻔوﻓﺔ‬

   ‫٢.ﺧطوة رﻗم )٥( ھو ﻣﺗﻐﯾر إذا ﻛﺎن اﻟرﻗم اﻟذي ﻋﻠﯾﮫ اﻟﻣؤﺷر ﻋدد أوﻟﻲ ﯾﺑﻘﻰ واﺣد وذا ﻛﺎن اﻟرﻗم ﻏﯾر أوﻟﻲ ﯾﺗﺣول‬
                                                                       ‫إﻟﻰ ﺻﻔر ﻟﻛﻲ ﯾﺧزن ﺑدل ﻗﯾﻣﺔ اﻟﻌﻧﺻر‬

  ‫٣.ﺧطوة رﻗم )٦( ھوا ﻋداد ﯾﻣر ﻋﻠﻰ ﺟﻣﯾﻊ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻟﻛﻲ ﯾﺗﺣﻘق ﻣن اﻟﻌﻧﺎﺻر ﻋﻧﺻر ﻋﻧﺻر ﻓﻲ ﺧطوات‬
                                             ‫رﻗم )٨و٧ و٩و٠١و١١و٢١( ھل اﻟﻌﻧﺻر ﻋدد أوﻟﻲ أم ﻻ‬

                          ‫٤.ﺧطوة رﻗم)٣١( ﻟﻛﻲ ﯾﻧﻘل اﻟﻣؤﺷر ﻋﻠﻰ اﻟﻌﻧﺻر اﻟﺗﺎﻟﻲ ﺑﻌد أن ﯾﺗﺣﻘق ﻣن اﻟﻌﻧﺻر اﻟﺳﺎﺑق‬

                                  ‫٥.ﺧطوة رﻗم)٩١( ھﻲ إرﺳﺎل ﻋﻧوان أول ﻋﻧﺻر ﺑﺎﻟﻣﺻﻔوﻓﺔ ﺑﺎﻟﻣﺻﻔوﻓﺔ إﻟﻰ اﻟداﻟﺔ‬

                                                                                             ‫ﺷﺎھد ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                      ‫اﻟﻔﺻل اﻟﺳﺎدس‬

                                                                                                            ‫ﻣﮭم‬


   ‫ﻣﺻﻔوﻓﺔ أﺣﺎدﯾﺔ ﻏﯾر ﻣﺣدودة اﻟﺣﺟم:ﺗﻌﻠﻣﻧﺎ ﺳﺎﺑﻘﺎ أن اﻟﻣﺻﻔوﻓﺎت ﺣﺟﻣﮭﺎ ﺛﺎﺑت وﯾﺟب ﺗﻌرﯾﻔﮫ وﻻ ﯾﻣﻛن ﻛﺗﺎﺑﺔ‬
   ‫ﻣﺻﻔوﻓﺔ دون ﺗﺣدﯾد ﺣﺟﻣﮭﺎ أﻣﺎ ﻣﻊ اﻟﻣؤﺷرات ﻧﺳﺗطﯾﻊ ﻣﻊ داﻟﺔ )‪ (new‬ﺗﻛوﯾن ﻣﺻﻔوﻓﺔ ﻏﯾر ﻣﺣدودة اﻟﺣﺟم ﯾﺣدد‬
                         ‫ﺣﺟﻣﮭﺎ اﻟﻣﺳﺗﺧدم وﻗت اﻟﺗﻧﻔﯾذ .ﺣﯾث أن اﻟﺣﺟم اﻟذي ﻧﺣﺟزه ﺑﻘدر ﺣﺟم اﻟﻣﺻﻔوﻓﺔ اﻟﻣطﻠوب‬

                  ‫ﻟو أردﻧﺎ أن ﻧﺣﺟز ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ )٩( ﻋﻧﺎﺻر ﻣن ﻧوع ‪ integer‬وﻗت اﻟﺗﻧﻔﯾذ ﻧﺣﺟز ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                               ‫ﺣﺟز ﻣﺻﻔوﻓﺔ وﻗت اﻟﺗﻧﻔﯾذ‬
       ‫;]9[ ‪int *Array=new int‬‬
                                     ‫أي ﻛﺄﻧﻣﺎ ﻧﻘول اﻟﻣؤﺷر )‪ (*Array‬ﯾؤﺷر ﻋﻠﻰ ﻣﻛﺎن ﻓﻲ اﻟذاﻛرة ﺣﺟﻣﮫ ﺗﺳﻌﺔ‬



   ‫ﻣﺛﺎل : ﺑرﻧﺎﻣﺞ ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم ﺗﺣدﯾد ﺣﺟم اﻟﻣﺻﻔوﻓﺔ وﻗت اﻟﺗﻧﻔﯾذ وﺑﻌدھﺎ ﯾطﻠب ﻣﻧﮫ أن ﯾدﺧل ﻋﻧﺎﺻر ﺛم ﯾﺟﻣﻊ‬
                                                                                 ‫اﻟﻌﻧﺎﺻر وﯾﺟد اﻟﻣﻌدل ؟‬

 ‫++‪c‬‬                                 ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include <iostream.h‬‬                              ‫>‪#include <stdio.h‬‬
 ‫) (‪void main‬‬                                       ‫) (‪void main‬‬
 ‫;‪1.{int sizearray,j,sum,avg‬‬                        ‫;‪1.{int sizearray,j,sum,avg‬‬
 ‫;0=‪2.sum‬‬                                           ‫;0=‪2.sum‬‬
 ‫; "‪3.cout<<"who size the arrray\n‬‬                  ‫;)"‪3.prin ("who size the arrray\n‬‬
 ‫; ‪4.cin>> sizearray‬‬                                ‫;) ‪4.scanf("%d",& sizearray‬‬
 ‫;] ‪5.int *Array=new int [ sizearray‬‬                ‫;] ‪5.int *Array=new int [ sizearray‬‬
 ‫; "‪6.cout<<"enter the array\n‬‬                      ‫;)"‪6.prin ("enter the array\n‬‬
 ‫)++‪7.for ( j=0;j<sizearray; j‬‬                      ‫)++‪7.for ( j=0;j<sizearray; j‬‬
 ‫; ]‪8. cin>> Array[j‬‬                                ‫;)]‪8. scanf("%d",&Array[j‬‬
 ‫)++‪9.for (j=0;j<sizearray; j‬‬                       ‫)++‪9.for (j=0;j<sizearray; j‬‬
 ‫;]‪10. sum=sum+Array[j‬‬                              ‫;]‪10. sum=sum+Array[j‬‬
 ‫;‪11. avg=sum/sizearray‬‬                             ‫;‪11. avg=sum/sizearray‬‬
 ‫} ;‪12. cout<<"sum="<<sum<<"\navg= "<<avg‬‬           ‫} ;)‪12.prin ("sum=%d\navg=%d",sum,avg‬‬



                                                                                        ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬

  ‫١.ﺧطوة رﻗم )٤( ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل ﺣﺟم اﻟﻣﺻﻔوﻓﺔ ﻟﻛﻲ ﯾﺿﻊ اﻟﺣﺟم اﻟذي ﯾدﺧﻠﮫ اﻟﻣﺳﺗﺧدم ﻓﻲ ﺧطوة رﻗم‬
                              ‫)٥( إي ﻣﺛﻼ إذا ادﺧل اﻟﻣﺳﺗﺧدم اﻟرﻗم ﺧﻣﺳﺔ ﺳﺗﻛون اﻟﺧطوة رﻗم )٤( ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                               ‫ﺣﺟز ﻣﺻﻔوﻓﺔ وﻗت اﻟﺗﻧﻔﯾذ‬
       ‫;]5[ ‪int *Array=new int‬‬
                                                                           ‫إي ﺣﺟز ﺧﻣﺳﺔ ﻣواﻗﻊ ﻓﻲ اﻟذاﻛرة‬

                                                            ‫ﻻﺣظ اﻟﺷﻛل اﻟﺗﺎﻟﻲ ﻟﮭذا اﻹدﺧﺎل ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ .‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣؤﺷرات )‪(pointer‬‬                                                                                       ‫اﻟﻔﺻل اﻟﺳﺎدس‬

                                                                                                             ‫ﻣﮭم‬


 ‫ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ ﻏﯾر ﻣﺣدودة اﻷﺑﻌﺎد: ﻧﺳﺗطﯾﻊ ﻣﻊ داﻟﺔ )‪ (new‬ﺗﻛوﯾن ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ ﻏﯾر ﻣﺣدودة اﻷﺑﻌﺎد ﯾﺣدد‬
                                                                               ‫أﺑﻌﺎدھﺎ اﻟﻣﺳﺗﺧدم وﻗت اﻟﺗﻧﻔﯾذ .‬
                     ‫ﻟو أردﻧﺎ أن ﻧﺣﺟز ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ )5*3( ﻣن ﻧوع ‪ integer‬وﻗت اﻟﺗﻧﻔﯾذ ﻧﺣﺟز ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                                ‫ﺣﺟز ﻣﺻﻔوﻓﺔ وﻗت اﻟﺗﻧﻔﯾذ‬
       ‫;‪1.int k‬‬
       ‫;]‪2.int **Array=new int *[row‬‬
       ‫)++‪3.for (k=0 ; k< row ; k‬‬
       ‫;]‪4.Array[k]=new int[columns‬‬
                                                                       ‫‪: (row) ‬ھو ﻋدد اﻟﺻﻔوف‬
                                                                   ‫‪: (columns) ‬ھو ﻋدد اﻷﻋﻣدة‬
                                              ‫ﺗﻛون طرﯾق اﻟﺣﺟز ﺑﺷﻛل اﻟﺗﺎﻟﻲ ﻣﺛﻼ ﻟﻣﺻﻔوﻓﺔ )2*3(:‬
          ‫١.ﻓﻲ ﺧطوة رﻗم )٢( ﯾؤﺷر اﻟﻣؤﺷر )‪ (Array‬ﻋﻠﻰ ﻣﺻﻔوﻓﺔ ﻣؤﺷرات ﺣﺟﻣﮭﺎ ﺑﻘدر ﻋدد اﻟﺻﻔوف أي )٣(‬


     ‫‪**Array‬‬
                                            ‫]0[* ‪new int‬‬       ‫]1[* ‪new int‬‬                ‫]2[* ‪new int‬‬



   ‫٢.ﺧطوة رﻗم )٣( ﯾﺑدأ ﺑﺎﻟﺗﺣرك ﻋﻠﻰ ﻛل ﺻف ﯾؤﺷر ﻋﻠﯾﮫ اﻟﻣؤﺷر )‪ (Array‬وﯾﻛون ﻟﮫ أﻋﻣدة ﻓﻲ ﺧطوة رﻗم )٤(‬

         ‫‪ .A‬ﻋﻧدﻣﺎ ﺗﻛون ﻗﯾﻣﺔ )0=‪ (k‬ﺳﯾؤﺷر اﻟﻣؤﺷر )‪ (Array‬ﻋﻠﻰ أول ﻣوﻗﻊ ﺑﺻف وﯾﻛون اﻟﻌﻣود ﻟﮫ طوﻟﮫ )٢(‬


    ‫]0[‪Array‬‬
                                            ‫]0[]0[ ‪Array‬‬       ‫]1[* ‪new int‬‬                ‫]2[* ‪new int‬‬
                                            ‫]0[]1[ ‪Array‬‬



        ‫‪ .B‬ﻋﻧدﻣﺎ ﺗﻛون ﻗﯾﻣﺔ )1=‪ (k‬ﺳﯾؤﺷر اﻟﻣؤﺷر )‪ (Array‬ﻋﻠﻰ ﺛﺎﻧﻲ ﻣوﻗﻊ ﺑﺻف وﯾﻛون اﻟﻌﻣود ﻟﮫ طوﻟﮫ )٢(‬


    ‫]1[‪Array‬‬
                                            ‫]0[]0[ ‪Array‬‬       ‫]1[ ]0[ ‪Array‬‬               ‫]2[* ‪new int‬‬
                                            ‫]0[]1[ ‪Array‬‬       ‫]1[]1[ ‪Array‬‬
       ‫‪ .C‬ﻋﻧدﻣﺎ ﺗﻛون ﻗﯾﻣﺔ )2=‪ (k‬ﺳﯾؤﺷر اﻟﻣؤﺷر )‪ (Array‬ﻋﻠﻰ ﺛﺎﻟث ﻣوﻗﻊ ﺑﺻف وﯾﻛون اﻟﻌﻣود ﻟﮫ طوﻟﮫ )٢(‬


    ‫]2[‪Array‬‬
                                            ‫]0[]0[ ‪Array‬‬       ‫]1[ ]0[ ‪Array‬‬               ‫]2[ ]0[ ‪Array‬‬
                                            ‫]0[]1[ ‪Array‬‬       ‫]1[]1[ ‪Array‬‬                ‫]2[]1[ ‪Array‬‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                             ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(pointer) ‫اﻟﻣؤﺷرات‬                                                                                   ‫اﻟﻔﺻل اﻟﺳﺎدس‬




    ‫ﻣﺛﺎل : ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ ﻏﯾر ﻣﺣدودة اﻟﺣﺟم ﯾﺣدد ﺣﺟﻣﮭﺎ اﻟﻣﺳﺗﺧدم وﻗت اﻟﺗﻧﻔﯾذ وﯾﺟﻣﻊ ﻋﻧﺎﺻر اﻟﻘطر اﻟرﺋﯾﺳﻲ ؟‬



 c++                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    c                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include <iostream.h>                                 #include <stdio.h>
 void main ( )                                         void main ( )
 1.{ int i,j,k,sum,rowN,colN;                          1.{ int i,j,k,sum,rowN,colN;
 2. sum=0;                                             2. sum=0;
 3.cin>>rowN>>colN ;                                   3.scanf("%d%d",&rowN,&colN);
 4.int **Array=new int *[ rowN ];                      4.int **Array=new int *[ rowN ];
 5.for (k=0 ; k< rowN ; k++)                           5.for (k=0 ; k< rowN ; k++)
 6.Array[k]=new int[ colN ];                           6.Array[k]=new int[ colN ];
 7.for (i=0 ; i< rowN ; i++)                           7.for (i=0 ; i< rowN ; i++)
 8.for (j=0; j< colN ; j++)                            8.for (j=0; j< colN ; j++)
 9. cin>>Array[i][j] ;                                 9. scanf("%d",&Array[i][j]);
 10.for (i=0 ; i< rowN ; i++)                          10.for (i=0 ; i< rowN ; i++)
 11. for (j=0; j< colN ; j++)                          11. for (j=0; j< colN ; j++)
 12.if (i==j)                                          12.if (i==j)
 13.sum=sum+ Array[i][j];                              13.sum=sum+ Array[i][j];
 14. cout<<"sum="<<sum ; }                             14. printf(""sum="%d",sum); }



                                                                                          :‫ﺗوﺿﯾﺢ اﻟﺧطوات‬

                                        ‫ﺧطوة رﻗم )٣( ھﻲ إدﺧﺎل ﻋدد ﺻﻔوف اﻟﻣﺻﻔوﻓﺔ وﻋدد أﻋﻣدﺗﮭﺎ‬        .١
                                                               ‫ﺧطوة رﻗم )٤ و٥و٦( ﺗﻛوﯾن اﻟﻣﺻﻔوﻓﺔ‬     .٢
                                      ‫ﺧطوة رﻗم )٧ و٨و٩( ھﻲ إدﺧﺎل اﻟﻣﺻﻔوﻓﺔ ﺑﺎﻹﺑﻌﺎد اﻟﺗﻲ ﺣددﻧﺎھﺎ‬      .٣
                              ‫ﺧطوة رﻗم )٠١ و١١و٢١و٣١( ھﻲ أﯾﺟﺎد ﻋﻧﺎﺻر اﻟﻘطر اﻟرﺋﯾﺳﻲ وﺟﻣﻌﮭﺎ‬           .٤
                                                                   ‫ﺧطو رﻗم )٤١( طﺑﺎﻋﺔ ﻧﺎﺗﺞ اﻟﺟﻣﻊ‬    .٥




                                      ‫ﻟو أدﺧﻠﻧﺎ ﻣﺻﻔوﻓﺔ ﺣﺟﻣﮭﺎ )5*5( ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﺗراﻛﯾب ) ‪(Structures‬‬                                                    ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                                      ‫اﻟﺘﺮاﻛﯿﺐ )‪(Structures‬‬

                                               ‫١.٧- اﻟﺗراﻛﯾب )‪(Structures‬‬
                         ‫٢.٧- اﻟﺗراﻛﯾب اﻟﻣﺗداﺧﻠﺔ ) ‪(Structure in Structure‬‬
                                       ‫٣.٧- ﻣﺻﻔوﻓﺔ ﺗراﻛﯾب ) ‪(Structures‬‬
                                ‫٤.٧- ﻣﺻﻔوﻓﺔ ﺗراﻛﯾب ) ‪ (Structures‬ﻣﺗداﺧﻠﺔ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗراﻛﯾب ) ‪(Structures‬‬                                                                       ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                                                     ‫١.٧- اﻟﺗراﻛﯾب )‪(Structures‬‬
 ‫‪ Structure‬أو ‪ Structs‬ھﻲ ﻣﺟﻣوﻋﺔ ﺑﯾﺎﻧﺎت )ﻣﺗﻐﯾرات( ﺑﺄﻧواع ﻣﺧﺗﻠﻔﺔ ﺗﺣت اﺳم واﺣد. ﺗﺳﺗﺧدم ﻓﻲ‬
    ‫ﺣﺎل ﻟدﯾﻧﺎ ﻋدة ﻣﻛوﻧﺎت أو أﺷﺧﺎص ﯾﺷﺗرﻛون ﻓﻲ ﻣﻌﻠوﻣﺎت ﻣﻌﯾﻧﮫ ﻣﺗﺷﺎﺑﮫ ﻓﺗﺳﺗﺧدم ﻟﺟﻣﻊ ﺗﻌﺎرﯾف ﻟﻌدة‬
    ‫أﺷﺧﺎص ﻓﻲ ﺳﺟل واﺣد ﯾﺷﺗرﻛون ﺟﻣﯾﻌﺎ ﺑﻧﻔس اﻟﻣﻌﻠوﻣﺎت . ﺣﯾث ﻧﺷﺗق ھذه اﻟﻣﻌﻠوﻣﺎت ﻷي ﺷﺧص‬
                                                                    ‫ﻧرﯾده. وﺗﻛون ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                  ‫ھﯾﻛﻠﯾﺔ ﺗراﻛﯾب )‪( Structs‬‬
       ‫‪struct Structures_Name‬‬
       ‫{‬
       ‫;1‪Type var‬‬
       ‫;2‪Type var‬‬
       ‫.‬
       ‫.‬
       ‫.‬
       ‫;2‪}ObjectName1,Object_name‬‬
                            ‫)‪ (Structures_Name‬ھو اﺳم اﻟﺳﺟل وﻣﻣﻛن أن ﯾﻛون أي اﺳم‬              ‫‪‬‬
   ‫)‪ : (Type‬ھو ﻧوع اﻟﻣﺗﻐﯾر داﺧل اﻟﺳﺟل وﻣﻣﻛن وﺿﻊ أﻧواع ﻣﺧﺗﻠﻔﺔ ﻣن اﻟﻣﺗﻐﯾرات داﺧل ﺳﺟل‬           ‫‪‬‬
                                            ‫واﺣد .وﯾﻛون ﻋدد ﺗﻌرﯾف اﻟﻣﺗﻐﯾرات ﻏﯾر ﻣﺣدد‬
  ‫)‪: ( ObjectName‬ھو اﺳم اﻟﻛﺎﺋن اﻟﻣﺷﺗق ﻣن اﻟﺳﺟل وﻣﻣﻛن أن ﯾﻛون أي اﺳم .وﻣﻣﻛن اﺷﺗﻘﺎق‬            ‫‪‬‬
   ‫ﻋدد ﻏﯾر ﻣﺣدد ﻣن اﻟﻛﺎﺋﻧﺎت ﻣن ﺳﺟل واﺣد ﻓﻘط ﻧﺿﻊ ﻓﺎرزة ﺑﯾن ﻛل ﻛﺎﺋن وأﺧر. وﻧﺑدأ ﺑﺗﻌرﯾف‬
                                                      ‫ھذه اﻟﻛﺎﺋﻧﺎت ﺑﻌد إﻏﻼق ﻗوس اﻟﺳﺟل‬
                                              ‫وﯾوﺿﻊ اﻟﺳﺟل ﺑﻌد ﺗﻌرﯾف اﻟﻣﻛﺗﺑﺎت ﻣﺑﺎﺷرة.‬         ‫‪‬‬



                                      ‫اﻟﺳﺟﻼت ﺗدﺧل ﺿﻣن ﻣواﺿﯾﻊ اﻟﺑرﻣﺟﺔ ﻛﺎﺋﻧﯾﮫ اﻟﺗوﺟﮫ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗراﻛﯾب ) ‪(Structures‬‬                                                                                  ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




          ‫ﻣﺛﺎل: اﺑﺳط ﻣﺛﺎل ﻋﻠﻰ ﺳﺟل ھﻲ ﺳﯾﺎرة )‪ (car‬ﻟﮭﺎ رﻗم ﻟوﺣﺔ و ﻣودﯾل و اﺳم اﻟﺷرﻛﺔ اﻟﻣﺻﻧﻌﺔ؟‬
                                              ‫ﺗﺣﻠﯾل: ﻟﺗﻛوﯾن ﺳﺟل ﻟﮭذه اﻟﻣﻌﻠوﻣﺎت اﻟﺛﻼﺛﺔ ﺗﻛﺗب ؟‬
                                                                   ‫ﺗراﻛﯾب )‪ ( Structs‬ﻟﻣﻛوﻧﺎت ﺳﯾﺎرة‬
       ‫‪struct car‬‬
       ‫{‬
       ‫;‪int CarNumber‬‬
       ‫;‪int Model‬‬
       ‫;]02[‪char factoryDesgin‬‬
       ‫;‪}HussienCar,WaeelCar‬‬


  ‫ﻧﻼﺣظ أن رﻗم اﻟﺳﯾﺎرة ﻋرف ﻛرﻗم ﻷﻧﮫ رﻗم اﻟﺳﯾﺎرة ﻋﺑﺎرة ﻋن ﻣﺟﻣوﻋﺔ أرﻗﺎم و ﻣودﯾﻠﮭﺎ ﻋرف رﻗم‬
   ‫ﻻن اﻟﻣودﯾل ﻋﺑﺎرة ﻋن ﺗﺎرﯾﺦ وﺷرﻛﺔ اﻟﻣﺻﻧﻌﺔ ﻋرﻓت ﻛﺳﻠﺳﻠﺔ ﻻن اﻟﺷرﻛﺔ اﺳم اﻟﻣﺻﻧﻌﺔ ﻣﻛوﻧﺔ ﻣن‬
      ‫أﺣرف أو رﻣوز وﻧﻼﺣظ أﻧﻧﺎ اﺷﺗﻘﯾﻧﺎ ﻣن اﻟﺳﺟل ﺳﯾﺎرة ﺣﺳﯾن )‪ (HussienCar‬وﺳﯾﺎرة واﺋل‬
    ‫)‪ (WaeelCar‬وﻧرﯾد أن ﻧدﺧل ﻣﻌﻠوﻣﺎت ﻋن ﺳﯾﺎرة ﻛل ﺷﺧص ﺿﻣن اﻟﺑرﻧﺎﻣﺞ اﻟرﺋﯾﺳﻲ ﻓﯾﻛون‬
                                                                       ‫اﻟﻛود ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬
                                                     ‫ﺗراﻛﯾب )‪ ( Structs‬ﻟﻣﻛوﻧﺎت ﺳﯾﺎرة إدﺧﺎل اﻟﻣﻌﻠوﻣﺎت‬
       ‫)(‪main‬‬
       ‫{‬
       ‫;57481= ‪HussienCar. CarNumber‬‬
       ‫; 1102=‪HussienCar. Model‬‬
       ‫;)"‪Strcpy(HussienCar. factoryDesgin,"BMW‬‬
       ‫;54657= ‪WaeelCar. CarNumber‬‬
       ‫; 5002=‪WaeelCar. Model‬‬
       ‫;)"‪Strcpy(WaeelCar. factoryDesgin,"KIA‬‬
       ‫}‬
 ‫ﻟﻠوﺻول ﻟﻣﻌﻠوﻣﺎت أي ﻛﺎﺋن ﻧﻛﺗب اﺳم اﻟﻛﺎﺋن ﺛم ﻧﻘطﺔ ).( ﺛم ﻣﻌﻠوﻣﺔ اﻟﺗﻲ ﻧرﯾد إدﺧﺎﻟﮭﺎ أو طﺑﺎﻋﺗﮭﺎ أو‬
                                                                        ‫اﻟﺗﻌدﯾل ﻋﻠﯾﮭﺎ أو ﻣﻌﺎﻟﺟﺗﮭﺎ‬
                  ‫ﻣﮭم‬


  ‫‪ ‬اﺳم اﻟﺷرﻛﺔ اﻟﻣﺻﻧﻌﺔ ﯾﻛون ﻋﺑﺎرة ﻋن ﻣﺻﻔوﻓﺔ أﺣرف ﻓﻼ ﯾﻣﻛن إﺳﻧﺎد ﺳﻠﺳﻠﺔ أﺣرف ﻣﺑﺎﺷرة‬
                                                                ‫ﻓﻲ اﻟﺳﺟل ھﻛذا‬
                                                                               ‫إﺳﻧﺎد ﻗﯾم ﺑطرﯾﻘﺔ ﺧﺎطﺋﺔ‬
       ‫; "‪HussienCar. factoryDesgin="BMW‬‬
                           ‫ھذا اﻟﺗﻌﺑﯾر ﺧﺎطﺊ ﻟذاﻟك ﯾﺟب ﻧﺳﺦ اﻻﺳم ﺑﺎﺳﺗﺧدام اﻟﺳﻼﺳل ﻛﻣﺎ ﻓﻲ اﻟﺗﺎﻟﻲ.‬
                                                                      ‫ﻧﺳﺦ ﺳﻠﺳﺔ إﻟﻰ ﺳﻠﺳﻠﺔ ﺿﻣن ﺳﺟل‬
       ‫;)"‪Strcpy(HussienCar. factoryDesgin,"BMW‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(Structures ) ‫اﻟﺗراﻛﯾب‬                                                                                        ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                                  !.............‫ﯾﻣﻛن إدﺧﺎل اﻟﺳﻠﺳﻠﺔ ﺑطرﯾﻘﺔ ﻣﺑﺎﺷرة ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھﻛذا‬
 c++                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   c                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 cin.get(HussienCar. factoryDesgin,20);                  gets(HussienCar. factoryDesgin);



                                ‫ﻣﺛﺎل: ﻣﺟﻣوﻋﺔ ﻣن أرﺑﻌﺔ ﻣﺳﺗﺧدﻣﯾن ﻟﻛل ﻣﺳﺗﺧدم اﺳم وﻛﻠﻣﺔ ﻣرور ..؟‬

                                           ‫ ( ﻟﺳﺟل ﻣﺳﺗﺧدﻣﯾﯾن أرﺑﻌﺔ ﻛل واﺣد ﻟﮫ اﺳم وﻛﻠﻣﺔ ﻣرور‬Structs) ‫ﺗراﻛﯾب‬
        struct password_User
        {
        char userName[20];
        int password;
        }Hussien ,Waeel,Modar,Rafeed;


                         ‫وﻛود اﻟﺑرﻧﺎﻣﺞ ﻟﻣﺳﺗﺧدم واﺣد ﻣﻊ اﻹدﺧﺎل واﻟطﺑﺎﻋﺔ ﻷﺳﻣﮫ وﻛﻠﻣﺔ ﻣروره ﯾﻛون‬
 c++                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬      c                                            ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                    #include<stdio.h>
 #include<string.h>                                      #include<string.h>
 1.struct password_User                                  1.struct password_User
 2.{char userName[20];                                   2.{char userName[20];
 3.int password; }Hussien ,Waeel,Modar,Rafeed;           3.int password; }Hussien ,Waeel,Modar,Rafeed;
 4.main()                                                4.main()
 5.{cout<<"enter hussien user name: ";                   5.{prin ("enter hussien user name: ");
 6.cin.get(Hussien. userName,25);                        6. gets( Hussien. userName );
 7.cout<<"\nenter hussien password: ";                   7. prin ("\nenter hussien password: ");
 8.cin>> Hussien. password;                              8.scanf("%d",& Hussien. password );
 9.cout<<"user name: "<< Hussien. userName ;             9. prin ("user name:%s ", Hussien. userName );
 10.cout<<" \npassword: "<< Hussien. password ;}         10 .printf(" \npassword: %d", Hussien. password );}
                                                                                             :‫ﺗوﺿﯾﺢ اﻟﺧطوات‬
    ‫١.ﺧطوة رﻗم )١ (ھو ﺳﺟل ﻟﻠﻣﺳﺗﺧدﻣﯾن ﯾﺣوي اﺳم اﻟﻣﺳﺗﺧدم ﻓﻲ ﺧطوة رﻗم )٢( وﻛﻠﻣﺔ ﻣروره ﻓﻲ‬
        ‫ﺧطوة رﻗم )٣( وﻧﻼﺣظ ﻓﻲ ﺧطوة رﻗم )٣( ﺑﻌد أن أﻏﻠﻘﻧﺎ اﻟﺳﺟل اﺷﺗﻘﯾﻧﺎ أﺳﻣﺎء أرﺑﻌﺔ ﻣﺳﺗﺧدﻣﯾن‬
                                        ‫٢.ﺧطوة رﻗم)٦( ھﻲ إدﺧﺎل اﺳم اﻟﻣﺳﺗﺧدم وھو ﻋﺑﺎرة ﻋن ﺳﻠﺳﻠﺔ‬
       ‫%"( ﻻن ﻛﻠﻣﺔ‬d ") ‫( اﺳﺗﺧدﻣﻧﺎ‬c)‫٣.ﺧطوة رﻗم )٨( ھﻲ إدﺧﺎل ﻛﻠﻣﺔ اﻟﻣرور وﻧﻼﺣظ ﻓﻲ ﻛود ﻟﻐﺔ‬
                                         (integer) ‫اﻟﻣرور ﻋرﻓﻧﺎھﺎ ﻓﻲ ﺧطوة رﻗم )٣( ﻋﻠﻰ أﻧﮭﺎ ﻣﺗﻐﯾر‬
‫( اﺳﺗﺧدﻣﻧﺎ اﻟرﻣز‬c) ‫٤.ﺧطوة رﻗم )٩( ھﻲ طﺑﺎﻋﺔ اﺳم اﻟﻣﺳﺗﺧدم ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وﻧﻼﺣظ ﻓﻲ ﻛود ﻟﻐﺔ‬
                                                               .‫%( ﻷﻧﻧﺎ أدﺧﻠﻧﺎ اﺳم اﻟﻣﺳﺗﺧدم ﺑﺷﻛل ﺳﻠﺳﻠﺔ‬s)


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﺗراﻛﯾب ) ‪(Structures‬‬                                                                         ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                           ‫٢.٧- اﻟﺗراﻛﯾب اﻟﻣﺗداﺧﻠﺔ ) ‪(Structure in Structure‬‬
    ‫ھﻲ طرﯾﻘﺔ وﺿﻊ ﺳﺟل )‪ (Structure‬داﺧل ﺳﺟل أﺧر. اﻟﻔﺎﺋدة ﻣﻧﮭﺎ ھﻲ ﻣﺛﻼ ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﺳﺟل‬
‫ﯾﺣوي رﻗم ﺳﯾﺎرة وﻧوﻋﮭﺎ واﺳم اﻟﺷرﻛﺔ واﻟﻣﺻﻧﻌﺔ وﻛل ﺳﯾﺎرة ﻟﮭﺎ ﺛﻼث ﻣﺣرﻛﺎت ﺑﺄﺳﻣﺎء ﻣﻌﯾﻧﺔ ﻓﻠو‬
 ‫ﺟﻌﻠﻧﺎ أﺳﻣﺎء اﻟﻣﺣرﻛﺎت داﺧل ﺳﺟل وھو داﺧل ﺳﺟل ﻣﻌﻠوﻣﺎت اﻟﺳﯾﺎرة ﻟﻛﺎن ﻛل وﺻول إﻟﻰ ﺳﺟل ﻣن‬
   ‫ﺳﺟﻼت اﻟﺳﯾﺎرة ﺗﺳﺗطﯾﻊ وﺻول إﻟﻰ ﺛﻼث أﻧواع اﻟﻣﺣرﻛﺎت ﻓﯾﻛون اﻟﺑرﻧﺎﻣﺞ ﻣرن وواﺿﺢ . ﻓﺗﻛون‬
                                                                                ‫اﻟﮭﯾﻛﻠﯾﺔ ﻛﺎﻟﺗﺎﻟﻲ‬

                                                                      ‫ھﯾﻛﻠﯾﺔ ﺗراﻛﯾب ﻣﺗداﺧﻠﺔ‬
       ‫1‪struct Structures_Name‬‬
       ‫{‬
       ‫2‪struct Structures_Name‬‬
       ‫{‬
       ‫;12‪Type var‬‬
       ‫;22‪Type var‬‬
       ‫;22‪} ObjectName21,Object_name‬‬
       ‫;11‪Type var‬‬
       ‫;21‪Type var‬‬
       ‫.‬
       ‫.‬
       ‫;21‪}ObjectName11,Object_name‬‬

   ‫ھﻧﺎ )2‪ (Structures_Name‬واﻗﻊ ھو وﻣﺣﺗوﯾﺎﺗﮫ داﺧل )1‪ (Structures_Name‬ﻓﺈذا أردﻧﺎ‬
    ‫أن ﻧﺻل إﻟﻰ ﻣﻛوﻧﺎت اﻟﺳﺟل اﻟداﺧﻠﻲ وھو )2‪ (Structures_Name‬ﻓﻧﺣﺗﺎج إﻟﻰ ﻛﺗﺎﺑﺔ ﻛﺎﺋن ﻣن‬
      ‫اﻟﺳﺟل اﻟﺧﺎرﺟﻲ ﺛم ﻛﺎﺋن ﻣن ﺳﺟل اﻟداﺧﻠﻲ ﺛم ﻣﻛوﻧﺎت اﻟﺳﺟل اﻟداﺧﻠﻲ .ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو أرﻧﺎ‬
                                                                 ‫اﻟوﺻول إﻟﻰ )12‪ (var‬ﻧﻛﺗب‬

                                                                      ‫إﺳﻧﺎد ﻗﯾم ﺑطرﯾﻘﺔ ﺧﺎطﺋﺔ‬
       ‫;12‪ObjectName11. ObjectName21.var‬‬

           ‫ﻛﺎﺋن ﻣن اﻟﺳﺟل‬       ‫ﻛﺎﺋن ﻣن اﻟﺳﺟل‬    ‫ﻣﺗﻐﯾر ﻣن اﻟﺳﺟل‬
                ‫اﻟﺧﺎرﺟﻲ‬               ‫اﻟداﺧﻠﻲ‬          ‫اﻟداﺧﻠﻲ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                  ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗراﻛﯾب ) ‪(Structures‬‬                                                                                ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                         ‫ﻣﺛﺎل: ﺳﺟل ﻟﺳﯾﺎرة ﻟﮭﺎ رﻗم وﻣودﯾل واﺳم اﻟﺷرﻛﺔ وداﺧﻠﺔ ﺳﺟل ﻟﺛﻼث ﻣﺣرﻛﺎت.؟‬


                                                            ‫ﺗراﻛﯾب )‪ ( Structs‬ﻣﺗداﺧﻠﺔ ﻟﻣﻛوﻧﺎت ﺳﯾﺎرة‬
       ‫‪struct car‬‬
       ‫{‬
       ‫‪Struct machine‬‬
       ‫;1‪{int Type‬‬
       ‫;2‪int Type‬‬
       ‫;3‪int Type‬‬
       ‫;‪}MachineCar‬‬
       ‫;‪int CarNumber‬‬
       ‫;‪int Model‬‬
       ‫;]02[‪char factoryDesgin‬‬
       ‫;‪}HussienCar,WaeelCar‬‬


  ‫‪ ‬أﻻن ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻧوع )1‪ (Type‬ﻣن اﻟﻣﺣرﻛﺎت ﻓﻲ ﺳﯾﺎرة ﺣﺳﯾن)‪ (HussienCar‬ﯾﻛون اﻟﻛود‬
                                                                                                ‫ﻛود‬
       ‫;1‪HussienCar. MachineCar.Type‬‬
            ‫ﻟو ﺗﻼﺣظ ﻛﺗﺑﻧﺎ أوﻻ اﺳم اﻟﻛﺎﺋن ﻓﻲ اﻟﺳﺟل اﻟﺧﺎرﺟﻲ)‪ (HussienCar‬ﺛم اﺳم اﻟﻛﺎﺋن ﻓﻲ اﻟﺳﺟل اﻟداﺧﻠﻲ‬
              ‫)‪ ( MachineCar‬ﺛم اﺳم اﻟﻣﺣرك ﻣن اﻟﻧوع اﻷول )1‪ (Type‬وھذه ھﻲ طرﯾﻘﺔ اﻟوﺻول اﻟﺻﺣﯾﺣﺔ‬
 ‫‪ ‬أﻻن ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻧوع )1‪ (Type‬ﻣن اﻟﻣﺣرﻛﺎت ﻓﻲ ﺳﯾﺎرة واﺋل )‪ ( WaeelCar‬وإﻋطﺎء رﻗم‬
                                                                 ‫)455( ﻟﮭذه اﻟﻣﺣرك ﯾﻛون اﻟﻛود‬

                                                                                                ‫ﻛود‬
       ‫;455=1‪WaeelCar . MachineCar.Type‬‬
‫ﻟو ﺗﻼﺣظ ﻛﺗﺑﻧﺎ أوﻻ اﺳم اﻟﻛﺎﺋن ﻓﻲ اﻟﺳﺟل اﻟﺧﺎرﺟﻲ )‪ ( WaeelCar‬ﺛم اﺳم اﻟﻛﺎﺋن ﻓﻲ اﻟﺳﺟل اﻟداﺧﻠﻲ‬
                         ‫)‪ ( MachineCar‬ﺛم اﺳم اﻟﻣﺣرك ﻣن اﻟﻧوع اﻷول)1‪ (Type‬وأﺳﻧدﻧﺎ ﻟﮫ ﻗﯾﻣﺔ‬
 ‫‪ ‬أﻻن ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻧوع )2‪ (Type‬ﻣن اﻟﻣﺣرﻛﺎت ﻓﻲ ﺳﯾﺎرة واﺋل )‪( WaeelCar‬‬
     ‫وإﻋطﺎء رﻗم )4455( ﻟﮭذه اﻟﻣﺣرك وﻟوﺻول ﻟرﻗم ﺳﯾﺎرﺗﮫ وإﻋطﺎﺋﮭﺎ رﻗم)3574( . ﯾﻛون‬
                                                                                            ‫اﻟﻛود‬

                                                                                                ‫ﻛود‬
       ‫;4455=2‪WaeelCar . MachineCar.Type‬‬
       ‫3574=‪WaeelCar .CarNumber‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(Structures ) ‫اﻟﺗراﻛﯾب‬                                                                                    ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                                                        ‫ھذه ﻛود ﻹدﺧﺎل وطﺑﺎﻋﺔ ﻣﻌﻠوﻣﺎت ﺳﯾﺎرة واﺣدة ﻓﻘط‬
 c++                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    c                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                   #include<stdio.h>
 #include<string.h>                                     #include<string.h>
 struct car                                             struct car
 {struct machine                                        {struct machine
 {int Type1;                                            {int Type1;
 int Type2;                                             int Type2;
 int Type3;                                             int Type3;
 }MachineCar;                                           }MachineCar;
 int CarNumber;                                         int CarNumber;
 int Model;                                             int Model;
 char factoryDesgin[20];                                char factoryDesgin[20];
 }HussienCar ;                                          }HussienCar ;
  main()                                                 main()
  {cout<<"enter factory design: ";                       {printf("enter factory design: ");
  cin.get( HussienCar . factoryDesgin ,25);              gets( HussienCar . factoryDesgin );
  cout<<"\nenter car number: ";                           printf("\nenter car number: ");
  cin>> HussienCar. CarNumber ;                           scanf("%d",& HussienCar. CarNumber) ;
  cout<<"\nenter car model: ";                            printf("\nenter car model: ");
  cin>> HussienCar. Model ;                             scanf("%d",& HussienCar. Model) ;
  cout<<"\nenter car machine Type1: ";                    printf("\nenter car machine Type1: ");
  cin>> HussienCar. MachineCar. Type1 ;                 scanf("%d",& HussienCar. MachineCar. Type1) ;
  cout<<"\nenter car machine Type2: ";                    printf("\nenter car machine Type2: ");
  cin>> HussienCar. MachineCar. Type2 ;                 scanf("%d",& HussienCar. MachineCar. Type2) ;
  cout<<"\nenter car machine Type3: ";                    printf("\nenter car machine Type3: ");
  cin>> HussienCar. MachineCar. Type3 ;                   scanf("%d",& HussienCar. MachineCar. Type3 ) ;
 cout<<" \nthe information for the car is …………\n";        printf(" \nthe information for the car is …………\n");
  cout<<" factory design : "<< HussienCar .               printf(" factory design :%s ", HussienCar .
 factoryDesgin ;                                        factoryDesgin);
  cout<<" \n car number : "<< HussienCar.               printf(" \n car number :%d ", HussienCar. CarNumber) ;
 CarNumber ;
  cout<<"\n car model: "<< HussienCar. Model;           printf("\n car model: %d ", HussienCar. Model);
  cout<<" \n machine Type1: "<< HussienCar.               printf(" \n machine Type1: %d ", HussienCar.
 MachineCar. Type1 ;                                    MachineCar. Type1 ) ;
  cout<<"\n machine Type2: "<< HussienCar.                printf("\n machine Type2: %d ", HussienCar.
 MachineCar. Type2 ;                                    MachineCar. Type2 ) ;
  cout<<" \n machine Type3: "<< HussienCar.               printf(" \n machine Type3:%d ",HussienCar.
 MachineCar. Type3 ;                                    MachineCar. Type3 );
 }                                                      }




                                                         ‫اﻟﻛود واﺿﺢ وﻟﯾس ﺑﺣﺎﺟﺔ إﻟﻰ أي ﺷرح أو ﺗوﺿﯾﺢ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﺗراﻛﯾب ) ‪(Structures‬‬                                                                         ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                                          ‫٣.٧- ﻣﺻﻔوﻓﺔ ﺗراﻛﯾب ) ‪(Structures‬‬
         ‫ﻋرﻓﻧﺎ اﻟﻣﺻﻔوﻓﺎت ﺳﺎﺑﻘﺎ وﻋرﻓﻧﺎ ﻣن اھم ﻓواﺋدھﺎ ھﻲ اﻟﺧزن اﻟﻣؤﻗت وﺗﺧزﯾن ﻋدد ﻣن اﻟﻘﯾم أو‬
  ‫اﻟﺣروف ﺑﺷﻛل ﻣﺻﻔوﻓﺔ.إذن ﻣﺻﻔوﻓﺔ ﺳﺟﻼت ھﻲ ﺑدﻻ ﻣن أن ﻧﻌرف ﻋدد ﻣن اﻟﻛﺎﺋﻧﺎت ﻣن ﻛل ﺳﺟل‬
     ‫ﻧﻌرف ﻛﺎﺋن واﺣد ﻣن ﻧوع ﻣﺻﻔوﻓﺔ ﺑدﯾﻼ ﻋن ﻛل ھذه اﻟﻛﺎﺋﻧﺎت.ﻓﻌﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو ﻋدﻧﺎ إﻟﻰ ﻣﺛﺎل‬
    ‫اﻟﺳﯾﺎرة وأردﻧﺎ أرﺑﻌﯾن ﻣﺳﺗﺧدم ھل ﻧﻌرف أرﺑﻌﯾن ﻛﺎﺋن ﻧﻌرف ﻛﺎﺋن واﺣد ﻣن ﻧوع ﻣﺻﻔوﻓﺔ وﺣﺟﻣﮫ‬
                                                                   ‫أرﺑﻌﯾن .ﻓﺗﻛون اﻟﮭﯾﻛﻠﯾﺔ ھﻛذا‬

                                                             ‫ھﯾﻛﻠﯾﺔ ﻣﺻﻔوﻓﺔ ﺗراﻛﯾب )‪( Structs‬‬
      ‫‪struct Structures_Name‬‬
      ‫{‬
      ‫;1‪Type var‬‬
      ‫;2‪Type var‬‬
      ‫.‬
      ‫.‬
      ‫.‬
      ‫;]‪}ObjectName1[size‬‬
‫‪: (ObjectName1[size]) ‬ھﻲ ﻛﺎﺋن وواﺣد ﻣن ﻧوع ﻣﺻﻔوﻓﺔ ﻟﮫ ﺣﺟم ﻣﻌﯾن ﯾﺣدده اﻟﻣﺳﺗﺧدم.‬

   ‫ﻓﻠﻧﻌود إﻟﻰ ﻣﺛﺎل ﻣﻌﻠوﻣﺎت ﺳﯾﺎرة وھﻲ رﻗم وﻧوع واﺳم اﻟﺷرﻛﺔ ﻟﻛن ﻧرﯾدھﺎ ﻷرﺑﻌﯾن ﺳﯾﺎرة ﻓﯾﻛون‬
                                                                     ‫اﻟﺳﺟل ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬
                                                            ‫ﺗراﻛﯾب )‪ ( Structs‬ﻟﻣﻛوﻧﺎت ﺳﯾﺎرة‬
       ‫‪struct car‬‬
       ‫{‬
       ‫;‪int CarNumber‬‬
       ‫;‪int Model‬‬
       ‫;]02[‪char factoryDesgin‬‬
       ‫;]04[‪}userCar‬‬


          ‫ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻣﻌﻠوﻣﺎت ﺻﺎﺣب أول ﺳﺟل )اﻟوﺻول إﻟﻰ اﺳم اﻟﺷرﻛﺔ اﻟﻣﺻﻧﻌﺔ (‬
                                                                                         ‫ﻛود‬
       ‫; ‪userCar[0]. factoryDesgin‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(Structures ) ‫اﻟﺗراﻛﯾب‬                                                                                         ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




      ( ‫ ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻣﻌﻠوﻣﺎت ﺻﺎﺣب ﺛﺎﻧﻲ ﺳﺟل )اﻟوﺻول إﻟﻰ اﺳم اﻟﺷرﻛﺔ اﻟﻣﺻﻧﻌﺔ‬
                                                                                                         ‫ﻛود‬
        userCar[1]. factoryDesgin ;
                                                                  .‫وﻛذاﻟك اﻟﺑﻘﯾﺔ ﻧﺻل إﻟﯾﮭم ﺑﻧﻔس اﻟطرﯾﻘﺔ‬
                                            ‫ ﻟو أردﻧﺎ ﺗﻌﺑﺋﺔ ﻣﻌﻠوﻣﺎت ﺻﺎﺣب أول ﺳﯾﺎرة ﯾﻛون اﻟﻛود‬

                                                                                                         ‫ﻛود‬
        strcpy(userCar[0]. factoryDesgin,"BMW") ;
        userCar[0]. Model=2011;
        userCar[0]. CarNumber=45356;
                                                      ‫**اﻟﻛود ﻛﺎﻣل ﻹدﺧﺎل ﻣﻌﻠوﻣﺎت أرﺑﻌﯾن ﺳﯾﺎرة وطﺑﺎﻋﺗﮭﺎ‬
 c++                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    c                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                    #include<stdio.h>
 #include<stdio.h>
 struct car                                              struct car
 {int CarNumber;                                         {int CarNumber;
 int Model;                                              int Model;
 char factoryDesgin[20];                                 char factoryDesgin[20];
 }userCar[40];                                           }userCar[40];
  main()                                                  main()
 {int i;                                                 {int i;
 for (i=0;i<40;i++)                                      for (i=0;i<40;i++)
  {cout<<"\ninforma on for("<<(i+1)<<") car : ";          {printf("\ninforma on for(%d) car : ",(i+1));
 cout<<"enter Car factory: ";                            printf("enter Car factory: ");
   gets( userCar[i]. factoryDesgin );                      gets( userCar[i]. factoryDesgin );
  cout<<"enter Car number: ";                              printf("enter Car number: ");
  cin>> userCar[i]. CarNumber ;                          scanf("%d",& userCar[i]. CarNumber) ;
 cout<<"enter Car Model: ";                              printf("enter Car Model: ");
  cin>> userCar[i]. Model;}                                scanf("%d",& userCar[i]. Model);}
 cout<<"\n-------------the information saved…\n";        printf("\n-------------the information saved…\n");
 for (i=0;i<40;i++)                                      for (i=0;i<40;i++)
  {cout<<"\ninforma on sav e ("<<(i+1)<<") car : ";       { printf("\ninforma on save(%d) car : ",(i+1));
 cout<<" Car factory: ";                                 printf(" Car factory: ");
  cout<< userCar[i]. factoryDesgin ;                       printf( "%s",userCar[i]. factoryDesgin) ;
  cout<<" Car number: ";                                   printf(" Car number: ");
  cout<< userCar[i]. CarNumber ;                           printf( "%d",userCar[i]. CarNumber) ;
 cout<<" Car Model: ";                                   printf(" Car Model: ");
  cout<< userCar[i]. Model;}}                              printf("%d", userCar[i]. Model);}}
     ‫ﺗوﺿﯾﺢ: ﻟو ﺗﻼﺣظ اﺳﺗﺧدﻣﻧﺎ ﻋداد ﯾﻌد ﺣﺗﻰ)٠٤( ﺣﺗﻰ ﻧدﺧل ﺟﻣﯾﻊ ﻣﻌﻠوﻣﺎت اﻟﺳﯾﺎرات ﺑﺎﻟﻧﺳﺑﺔ إﻟﻰ‬
                                             ‫( ﻛل ﻋدة ﻟﻠﻌداد ﻧﻘوم ﺑﺈدﺧﺎل ﺳﺟل ﺟدﯾد..؟‬userCar[i])




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                    C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﺗراﻛﯾب ) ‪(Structures‬‬                                                                          ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                                 ‫٤.٧- ﻣﺻﻔوﻓﺔ ﺗراﻛﯾب ) ‪ (Structures‬ﻣﺗداﺧﻠﺔ‬
  ‫ﻻ ﯾﺧﺗﻠف ﺷﯾﺋﺎ ﻋن ﺗرﻛﯾب داﺧل ﺗرﻛﯾب ﻧﻔس اﻷﺳﻠوب ﻟﻛن ھﻧﺎ ﻧﺳﺗﺧدم اﻟﻣﺻﻔوﻓﺎت ﻓﺗﻛون ﻣﺻﻔوﻓﺔ‬
                                    ‫ﺗراﻛﯾب داﺧل ﻣﺻﻔوﻓﺔ ﺗراﻛﯾب و اﻟﮭﯾﻛﻠﯾﺔ ﺗﻛون ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                        ‫ھﯾﻛﻠﯾﺔ ﺗراﻛﯾب ﻣﺗداﺧﻠﺔ‬
       ‫1‪struct Structures_Name‬‬
       ‫{‬
       ‫2‪struct Structures_Name‬‬
       ‫{‬
       ‫;12‪Type var‬‬
       ‫;22‪Type var‬‬
       ‫;]2‪} ObjectName21[size‬‬
       ‫;11‪Type var‬‬
       ‫;21‪Type var‬‬
       ‫.‬
       ‫.‬
       ‫;]1‪}ObjectName11[size‬‬
          ‫ﻓﻛل ﻛﺎﺋن ﻣن ﻛﺎﺋﻧﺎت ﻣﺻﻔوﻓﺔ اﻟﺳﺟﻼت )]1‪ (ObjectName11[size‬ﯾﺣوي ﻋﻠﻰ ﺳﺟل‬
          ‫)]2‪ (ObjectName21[size‬ﺑﺣﺟم )2‪ (size‬ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ﻟو ﻛﺎن ﻟدﯾﻧﺎ اﻟﻣﺛﺎل اﻟﺗﺎﻟﻲ‬


 ‫ﻣﺛﺎل: ﺳﺟل ﻟﻌﺷر ﺳﯾﺎرات ﻟﮭﺎ رﻗم وﻣودﯾل واﺳم اﻟﺷرﻛﺔ وداﺧﻠﺔ ﺳﺟل ﻟﺧﻣس ﻣﻛﺎﺋن ﻟﻛل ﻣﺎﻛﻧﺔ ﺛﻼث‬
                                                                                       ‫ﻣﺣرﻛﺎت.؟‬

                                                     ‫ﺗراﻛﯾب )‪ ( Structs‬ﻣﺗداﺧﻠﺔ ﻟﻣﻛوﻧﺎت ﺳﯾﺎرة‬
       ‫‪struct car‬‬
       ‫{‬
       ‫‪Struct machine‬‬
       ‫;1‪{int Type‬‬
       ‫;2‪int Type‬‬
       ‫;3‪int Type‬‬
       ‫;]5[‪}MachineCar‬‬
       ‫;‪int CarNumber‬‬
       ‫;‪int Model‬‬
       ‫;]02[‪char factoryDesgin‬‬
       ‫;]01[‪} userCar‬‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﺗراﻛﯾب ) ‪(Structures‬‬                                                                       ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                    ‫‪ ‬ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻣﻌﻠوﻣﺎت ﺻﺎﺣب أول ﺳﺟل ﻣﺎﻛﻧﺔ ﻷوﻟﻰ اﻟﻧوع اﻷول‬
                                                                                       ‫ﻛود‬
       ‫; 1‪userCar[0]. MachineCar[0]. Type‬‬
                                                        ‫وﻛذاﻟك اﻟﺑﻘﯾﺔ ﻧﺻل إﻟﯾﮭم ﺑﻧﻔس اﻟطرﯾﻘﺔ.‬
    ‫ﺻﺎﺣب أول ﺳﺟل‬     ‫ﻣﺎﻛﻧﺔ اﻷوﻟﻰ‬     ‫اﻟﻧوع اﻷول‬



                         ‫‪ ‬ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻣﻌﻠوﻣﺎت ﺻﺎﺣب أول ﺳﺟل ﻣﺎﻛﻧﺔ ﺛﺎﻧﯾﺔ اﻟﻧوع اﻷول‬
                                                                                       ‫ﻛود‬
       ‫; 1‪userCar[0]. MachineCar[1]. Type‬‬



    ‫ﺻﺎﺣب أول ﺳﺟل‬     ‫ﻣﺎﻛﻧﺔ اﻟﺛﺎﻧﯾﺔ‬   ‫اﻟﻧوع اﻷول‬



                     ‫‪ ‬ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻣﻌﻠوﻣﺎت ﺻﺎﺣب ﺛﺎﻧﻲ ﺳﺟل ﻣﺎﻛﻧﺔ أوﻟﻰ اﻟﻧوع اﻟﺛﺎﻧﻲ‬
                                                                                       ‫ﻛود‬
       ‫; 2‪userCar[1]. MachineCar[0]. Type‬‬



   ‫ﺻﺎﺣب ﺛﺎﻧﻲ ﺳﺟل‬     ‫ﻣﺎﻛﻧﺔ اﻷوﻟﻰ‬     ‫اﻟﻧوع اﻟﺛﺎﻧﻲ‬



 ‫‪ ‬ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻣﻌﻠوﻣﺎت ﺻﺎﺣب أول ﺳﺟل ﻣﺎﻛﻧﺔ ﻷوﻟﻰ اﻟﻧوع اﻷول وﻧﻌطﯾﮫ ﻗﯾﻣﺔ)02(‬
                                                                                       ‫ﻛود‬
       ‫;02=1‪userCar[0]. MachineCar[0]. Type‬‬



    ‫ﺻﺎﺣب أول ﺳﺟل‬     ‫ﻣﺎﻛﻧﺔ اﻷوﻟﻰ‬     ‫اﻟﻧوع اﻷول‬




   ‫‪ ‬ﻟو أردﻧﺎ اﻟوﺻول إﻟﻰ ﻣﻌﻠوﻣﺎت ﺻﺎﺣب أول ﺳﺟل اﺳم اﻟﺷرﻛﺔ اﻟﻣﺻﻧﻌﺔ وﻧﻌطﯾﮫ )‪(BMW‬‬
                                                                                       ‫ﻛود‬
       ‫; )"‪Strcpy(userCar[0]. factoryDesgin,"BMW‬‬
                                                        ‫وﻛذاﻟك اﻟﺑﻘﯾﺔ ﻧﺻل إﻟﯾﮭم ﺑﻧﻔس اﻟطرﯾﻘﺔ.‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(Structures ) ‫اﻟﺗراﻛﯾب‬                                                                                       ‫اﻟﻔﺻل اﻟﺳﺎﺑﻊ‬




                                                                                      ‫وھذا ﻛود اﻟﻣﺛﺎل ﻛﺎﻣل‬
 c++                                   ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬     c                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                  #include<stdio.h>
 #include<stdio.h>
 1.struct car                                          1.struct car
 2.{struct machine                                     2.{struct machine
 3.{int Type1;                                         3.{int Type1;
 4.int Type2;                                          4.int Type2;
 5.int Type3;                                          5.int Type3;
 6.}MachineCar[5];                                     6.}MachineCar[5];
 7.int CarNumber;                                      7.int CarNumber;
 8.int Model;                                          8.int Model;
 9.char factoryDesgin[20];                             9.char factoryDesgin[20];
 10.} userCar[10];                                     10.} userCar[10];
 11.main()                                             11.main()
 12.{int i, cont ;                                     12.{int i, cont ;
 13.for (i=0;i<10;i++)                                 13.for (i=0;i<10;i++)
 14.{                                                  14.{
 15.cout<<"\ninforma on for("<<(i+1)<<") car : ";      15.prin ("\ninforma on for(%d) car : ",(i+1));
 16.cout<<"enter Car factory: ";                       16.prin ("enter Car factory: ");
 17. gets( userCar[i]. factoryDesgin );                17. gets( userCar[i]. factoryDesgin );
 18.cout<<"enter Car number: ";                         18.prin ("enter Car number: ");
 19.cin>> userCar[i]. CarNumber ;                      19.scanf("%d",& userCar[i]. CarNumber) ;
 20.cout<<"enter Car Model: ";                         20.prin ("enter Car Model: ");
 21. cin>> userCar[i]. Model;                          21 scanf("%d",& userCar[i]. Model);
 22.for( cont =0; cont <5; cont ++)                    22.for( cont =0; cont <5; cont ++)
 23.{                                                  23.{
 24.cout<<"\nmachine name("<<( cont +1)<<") : ";       24. prin ("\n nmachine name (%d): ",( cont +1));
 25.cout<<"\nenter car machine Type1: ";               25. prin ("\nenter car machine Type1: ");
 26.cin>> userCar[i]. MachineCar[cont]. Type1 ;        26. prin ( "%d",userCar[i]. MachineCar[cont]. Type1) ;
 27.cout<<"\nenter car machine Type2: ";               27. prin   ("\nenter car machine Type2: ");
 28.cin>> userCar[i]. MachineCar[cont]. Type2 ;        28. prin   ( "%d", userCar[i]. MachineCar[cont]. Type2) ;
 29.cout<<"\nenter car machine Type3: ";               29. prin   ("\nenter car machine Type3: ");
                                                       30. prin   ( "%d",userCar[i]. MachineCar[cont]. Type3) ;
 30.cin>> userCar[i]. MachineCar[cont]. Type3 ;
                                                       31.}
 31.}
                                                       32.}
 32.}
                                                       33.}
 33.}
                                                                                             : ‫ﺗوﺿﯾﺢ اﻟﺑرﻧﺎﻣﺞ‬
  ‫ﻧﻼﺣظ ﻓﻲ ﻛل ﻋدة ﻟﻠﻌداد ﻓﻲ ﺧطوة رﻗم )٣١( ﺗﺗﻛرر اﻟﺧطوات ﻣن )٤١ اﻟﻰ٢٣( ﻓﻔﻲ اﻟﺧطوات ﻣن‬
  ‫)٦١ إﻟﻰ ١٢( ﯾدﺧل ﻣﻠوﻣﺎت اﻟﺳﺟل اﻟﺧﺎرﺟﻲ وﺧطوة رﻗم )٢٢( ھو ﻋدد ﺑﻌدد ﺳﺟل اﻟﻣﻛﺎﺋن اﻟداﺧﻠﻲ‬
              ‫اﻟﻣﻛون ﻣن ﺧﻣس ﻣﻛﺎﺋن ﻟﻸﻧواع اﻟﺛﻼث وﯾدﺧل ﻛل ھذه اﻟﻣﻛﺎﺋن ﻟﻸﻧواع اﻟﺛﻼث ﻓﻲ ﺧطوة‬
                                                      ‫)٥٢ إﻟﻰ ٠٣( ﻟﻛل ﺳﺟل ﻣن ﺳﺟﻼت اﻟﺳﺟل اﻟﺧﺎرﺟﻲ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                  C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                               ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                           ‫اﻟﻤﻠﻔﺎت )‪(File‬‬
                                        ‫١.٨- اﻟﻣﻠﻔﺎت )‪:(File‬‬
                            ‫٢.٨- اﻟﻛﺗﺎﺑﺔ ﻓﻲ اﻟﻣﻠﻔﺎت اﻟﻧﺻﯾﺔ:‬
                           ‫٣.٨- اﻟﻘراءة ﻣن اﻟﻣﻠﻔﺎت اﻟﻧﺻﯾﺔ:‬
                            ‫٤.٨- اﻟﻛﺗﺎﺑﺔ ﻓﻲ اﻟﻣﻠﻔﺎت اﻟﺛﻧﺎﺋﯾﺔ:‬
                           ‫٥.٨- اﻟﻘراءة ﻣن اﻟﻣﻠﻔﺎت اﻟﺛﻧﺎﺋﯾﺔ:‬
                  ‫٦.٨- داﻟﺔ )‪ (seek‬ﻟﻠﺗﺣرك داﺧل اﻟﻣﻠﻔﺎت :‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                          ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                                            ‫١.٨- اﻟﻣﻠﻔﺎت )‪: (File‬‬
                                  ‫ﻣن اﺣد ﺳﻣﺎت ﻟﻐﺔ )++‪ ( c,c‬ﺗوﻓر إﻣﻛﺎﻧﯾﺔ ﺗﺧزﯾن ﻣﻛوﻧﺎت أو ﻧﺗﺎﺋﺞ أو ﻣﺗطﻠﺑﺎت‬
                                 ‫اﻟﺑرﻧﺎﻣﺞ ﻋﻠﻰ اﻟﻘرص اﻟﺻﻠب )‪ (hard Disk‬ﺑﺷﻛل داﺋم أو ﻣؤﻗت ﺣﺳب اﻟﺣﺎﺟﺔ‬
                               ‫وﻣن ﺛم ﻓﺗﺢ ھذه اﻟﻣﻛوﻧﺎت واﺳﺗﺧداﻣﮭﺎ .اي اﻧﻧﺎ ﻧﺳﺗطﯾﻊ ﺗﺧزﯾن ﻣﻌﻠوﻣﺎت ﻣﻌﯾﻧﺔ ﻋﻠﻰ‬
    ‫اﻟﻘرص اﻟﺻب ﺑﺄﺳﺗﺧدام ﻣﻠﻔﺎت ذات اﻣﺗدادات ﻣﺧﺗﻠﻔﺔ وﻣن ﺛم ﻧﺳﺗﺧدﻣﮭﺎ وﻗت اﻟﺣﺎﺟﺔ وان ھذه اﻟﺑﯾﺎﻧﺎت اﻟﻣﺧزﻧﺔ ﻻ‬
 ‫ﺗزول ﻋﻧد اﻏﻼق اﻟﺣﺎﺳوب ﺑل ﺗﺑﻘﻰ ﻣﺣﻔوﺿﺔ داﺧل )‪ (hard Disk‬وﺗﺧزن اﻟﻣﻠﻔﺎت ﺑﺎﻟﻘرص اﻟطﻠب ﻋن طرﯾق ﻟﻐﺔ‬
‫)++‪ (c,c‬ﺑﺎﻣﺗدادات ﻣﺧﺗﻠﻔﺔ ﻣﻧﮭﺎ )‪. (.txt , .bin‬وﻣن اﻷﻣﺛﻠﺔ ﻋﻠﻰ اﺳﺗﺧدام اﻟﻣﻠﻔﺎت ﻟو ﻛﺎن ﻟدﯾﻧﺎ ﺑرﻧﺎﻣﺞ ﻻ ﯾﺳﺗطﯾﻊ‬
     ‫اﻟﻣﺳﺗﺧدم اﻟدﺧول ﻟﮫ إﻻ ﺑﻛﻠﻣﺔ ﻣرور ﻓﺗﺧزن ﻛﻠﻣﺔ اﻟﻣرور ﻓﻲ اﻟﻘرص اﻟطﻠب ﺑداﺧل ﻣﻠف وﻣﺗﻰ ﻣﺎ ﻓﺗﺣﻧﺎ اﻟﺑرﻧﺎﻣﺞ‬
    ‫ﯾطﻠب ﻣن اﻟﻣﺳﺗﺧدم إدﺧﺎل ﻛﻠﻣﺔ اﻟﻣرور وإذا ﻛﺎﻧت اﻟﻛﻠﻣﺔ اﻟﻣدﺧﻠﺔ ﻣﺷﺎﺑﮫ ﻟﻠﻛﻠﻣﺔ اﻟﻣﺧزﻧﺔ ﯾﻔﺗﺢ ﻟﮫ اﻟﺑرﻧﺎﻣﺞ إي ﺧزﻧﺎ‬
        ‫ﻛﻠﻣﺔ اﻟﻣرور ﺑﺷﻛل داﺋم داﺧل اﻟﺣﺎﺳوب وﻻﺗزول ﺑزوال اﻟطﺎﻗﺔ ﻋن اﻟﺣﺎﺳوب ﻛﻣﺎ ﻓﻲ اﻟﻣﺻﻔوﻓﺎت اﻟﺗﻲ ﺗﺧﺗﻔﻲ‬
                                                         ‫ﻣﺣﺗوﯾﺎﺗﮭﺎ ﻣﻊ اﻟﺧروج ﻣن اﻟﺑرﻧﺎﻣﺞ او اﻏﻼق اﻟﺣﺎﺳوب.‬


   ‫‪ ‬اﻟدوال اﻟﺗﻲ ﺗﺳﺗﺧدم ﻣﻊ اﻟﻣﻠﻔﺎت ﻓﻲ ﻟﻐﺔ )++‪ (c‬ﺗﻘﻊ ﺿﻣن ﻣﻛﺗﺑﺔ >‪ <iostream.h‬و >‪<fstream.h‬‬
                                ‫‪ ‬اﻟدوال اﻟﺗﻲ ﺗﺳﺗﺧدم ﻣﻊ اﻟﻣﻠﻔﺎت ﻓﻲ ﻟﻐﺔ )‪ (c‬ﺗﻘﻊ ﺿﻣن ﻣﻛﺗﺑﺔ >‪<stdio.h‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                                            ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                                        ‫٢.٨- اﻟﻛﺗﺎﺑﺔ ﻓﻲ اﻟﻣﻠﻔﺎت اﻟﻧﺻﯾﺔ:‬
                               ‫ﯾﻣﻛن ﺗﻛوﯾن ﻣﻠف ﺟدﯾد او ﻓﺗﺢ ﻣﻠف ﻣوﺟود داﺧل اﻟﺣﺎﺳوب واﻟﻛﺗﺎﺑﮫ ﻓﯾﮫ ﺑﺄﺳﺗﺧدام اﻟﺗﺎﻟﻲ.‬

                                                                  ‫ﻟﻠﻛﺗﺎﺑﺔ اﻟﻰ داﺧل إي ﻣﻠف ﺗوﺟد ﺛﻼث ﺧطوات وھﻲ.!‬
                                                             ‫‪ ‬ﺧطوة اﻷوﻟﻰ ﻧﻌرف ﻛﺎﺋن ﻣن ﻧوع ﻣﻠف‬
                                                                     ‫‪ ‬ﺧطوة ﺛﺎﻧﯾﺔ ﻧﻔﺗﺢ اﻟﻣﻠف ﻟﻠﻛﺗﺎﺑﺔ‬
                                                               ‫‪ ‬اﻟﺧطوة اﻟﺛﺎﻟﺛﺔ ﻧﻛﺗب اﻟﻰ داﺧل اﻟﻣﻠف‬

                                                ‫١. ﻓﻲ ﻟﻐﺔ )++‪ (c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﻠﻛﺗﺎﺑﺔ إﻟﻰ داﺧل اﻟﻣﻠﻔﺎت‬


                                                                                         ‫ﻛﺗﺎﺑﺔ اﻟﻰ داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ++‪c‬‬
         ‫; ‪1. ofstream fout‬‬
                      ‫‪("file‬‬               ‫;)‪family‬‬
         ‫)‪2. fout.open("file path",iostream family‬‬
         ‫;"‪3.fout<<"data‬‬


      ‫‪ ‬اﻟﺧطوة اﻷوﻟﻰ ﻋرﻓﻧﺎ )‪ (fout‬ﻣن ﻧوع ﻣﻠف ﻛﺗﺎﺑﺔ ھو اﺳم ﻟﻠﻣﻠف اﻟذي ﻧرﯾد اﻟﻛﺗﺎﺑﺔ ﻓﯾﮫ. ﻟﻠﺗﻌﺎﻣل ﻣﻌﮫ داﺧل‬
                                                                                  ‫اﻟﺑرﻧﺎﻣﺞ وﻣﻣﻛن أن ﯾﻛون أي اﺳم‬
                 ‫‪ : ( file path ) ‬ھو ﻣﺳﺎر اﻟﻣﻠف اﻟﻣراد ﺧزﻧﺔ ﻓﯾﮫ داﺧل اﻟﺟﮭﺎز ﯾوﺿﻊ ﺑﯾن ﻋﻼﻣﺗﻲ ﺗﻧﺻﯾص‬
                    ‫)‪ : (iostream family‬ھﻲ رﻣوز اﻟﻣﺳﺗﺧدﻣﺔ ﻣﺛل ﺗﺳﺗﺧدم ﻟﻠدﻻﻟﺔ ﻋﻠﻰ ﻋﻣﻠﯾﺎت ﻣﻌﯾﻧﺔ‬                              ‫‪‬‬


                                                                                          ‫ﺟدول ﺑرﻣوز ‪iostream family‬‬
                                                                                                 ‫وﺿﯾﻔﺗﮫ‬                   ‫اﻟرﻣز‬
                                                                     ‫ﯾﻠﺤﻖ اﻹدﺧﺎل اﻟﺠﺪﯾﺪ ﺑﻨﮭﺎﯾﺔ اﻟﻤﻠﻒ‬                 ‫‪ios::app‬‬
                                                                ‫ﯾﻘﻮم ﺑﺎﻟﻘﺮاءة أو اﻟﻜﺘﺎﺑﺔ ﻣﻦ ﻧﮭﺎﯾﺔ اﻟﻤﻠﻒ‬               ‫‪ios::ate‬‬
                                                   ‫ﻓﻲ ﺣﺎل وﺟﻮد اﻟﻤﻠﻒ ﻓﺴﯿﻘﻮم ﺑﺒﺘﺮھﺎ أي ﺣﺬف ﻣﺤﺘﻮﯾﺎﺗﮭﺎ‬               ‫‪ios::trunce‬‬
                                              ‫ﻓﺗﺢ اﻟﻣﻠف ﻟﻠﻘراءة وھﻲ ﺣﺎﻟﺔ اﻓﺗراﺿﯾﺔ ﻟﻛﺎﺋﻧﺎت ‪ifstream‬‬                      ‫‪ios::in‬‬
                                               ‫ﻓﺗﺢ اﻟﻣﻠف ﻟﻠﻛﺗﺎﺑﺔ وھﻲ ﺣﺎﻟﺔ اﻓﺗراﺿﯾﺔ ﻟﻛﺎﺋﻧﺎت ‪ofstream‬‬                   ‫‪ios::out‬‬
                                                               ‫ﻓﺘﺢ اﻟﻤﻠﻔﺎت ﻋﻠﻰ ھﯿﺌﺔ ﺛﻨﺎﺋﯿﺔ وﻟﯿﺲ ﻧﺼﯿﺔ‬              ‫‪ios::binary‬‬


 ‫ﻻﺳﺗﺧدام أﻛﺛر ﻣن رﻣز ﻓﻲ اﻟﺣل ﻧﺿﻊ ﺑﯾﻧﮭم )|( ﻣﺛﻼ إذا اردﻧﺎ ﻧﻛﺗب وﻧﻠﺣق ﻛﺗﺎﺑﺗﻧﺎ ﺑﻣﺣﺗوﯾﺎت اﻟﻣﻠف اﻟﺳﺎﺑق ) ‪(ios::app| ios::out‬‬   ‫‪‬‬
                                                       ‫‪ ‬وﻓﻲ ﺧطوة رﻗم )3( ﻗﻣﻧﺎ ﺑﺈدﺧﺎل اﻟﺑﯾﺎﻧﺎت إﻟﻰ داﺧل اﻟﻣﻠف‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                              ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                                  ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                             ‫٢. ﻓﻲ ﻟﻐﺔ )‪ ( c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﻠﻛﺗﺎﺑﺔ إﻟﻰ داﺧل اﻟﻣﻠﻔﺎت‬
                                                                                  ‫ﻛﺗﺎﺑﺔ اﻟﻰ داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ‪c‬‬
        ‫;‪1.FILE *fout‬‬
        ‫;)"‪2.fout=fopen("file path","symbol‬‬
        ‫;),‪3.fputs("data", fout‬‬
                 ‫‪ : (fout) ‬ھو اﺳم ﻟﻠﻣﻠف اﻟذي ﻧرﯾد اﻟﻛﺗﺎﺑﺔ ﻓﯾﮫ. ﻋرﻓﻧﺎه ﻓﻲ اﻟﺧطوة رﻗم )١( اﻧﮫ ﻣﻠف‬
          ‫‪ : ( file path ) ‬ھو ﻣﺳﺎر اﻟﻣﻠف اﻟﻣراد ﺧزﻧﺔ ﻓﯾﮫ داﺧل اﻟﺟﮭﺎز ﯾوﺿﻊ ﺑﯾن ﻋﻼﻣﺗﻲ ﺗﻧﺻﯾص‬
‫‪ : (symbol) ‬ھﻲ رﻣوز اﻟﻣﺳﺗﺧدﻣﺔ ﻣﺛل ﺗﺳﺗﺧدم ﻟﻠدﻻﻟﺔ ﻋﻠﻰ ﻋﻣﻠﯾﺎت ﻣﻌﻧﯾﺔ ﺗوﺿﻊ ﺑﯾن ﻋﻼﻣﺗﻲ ﺗﻧﺻﯾص‬
                  ‫وھﻧﺎ ﻧﺳﺗﺧدم اﻟرﻣز ) ‪ (w‬ﻷﻧﻧﺎ ﻧرﯾد اﻟﻛﺗﺎﺑﺔ ﺑداﺧل اﻟﻣﻠف. وھذا ﺟدول ﺑﮭذه اﻟرﻣوز‬

                                                                                           ‫ﺟدول ﺑرﻣوز ‪symbol‬‬
                                                                                      ‫وﺿﯾﻔﺗﮫ‬                    ‫اﻟرﻣز‬
                                                               ‫ﯾﻠﺤﻖ اﻹدﺧﺎل اﻟﺠﺪﯾﺪ ﺑﻨﮭﺎﯾﺔ اﻟﻤﻠﻒ‬               ‫‪a‬‬
                                       ‫ﻓﺗﺢ اﻟﻣﻠف ﻟﻠﻘراءة واذا ﻛﺎن اﻟﻣﻠف ﻏﯾر ﺻﺎﻟﺢ ﺗﻌﯾد ﻗﯾﻣﺔ ﺻﻔر‬               ‫‪r‬‬
              ‫اﺳﺗﺣداث اﻟﻣﻠف ﻟﻠﻛﺗﺎﺑﺔ واذا ﻛﺎن اﻟﻣﻠف ﻣوﺟود ﻓﻲ اﻟﻘرص اﻟﺻﻠب ﺳﯾﻣﺳﺢ ﻣﺣﺗوﯾﺎﺗﮫ‬                      ‫‪w‬‬
                                                                 ‫ﻛﺘﺎﺑﺔ وﻗﺮاءة وإﻟﺤﺎق ﻓﻲ اﻟﻤﻠﻔﺎت اﻟﺜﻨﺎﺋﯿﺔ‬ ‫‪rb,wb,ab‬‬
                   ‫ﻓﺗﺢ اﻟﻣﻠف ﻟﻠﻛﺗﺎﺑﺔ أو اﻟﻘﺮاءة ﻟﻜﻦ ﻓﻲ اﻹﺿﺎﻓﺔ ﯾﻜﺘﺐ اﻟﺒﯿﺎﻧﺎت اﻟﺠﺪﯾﺪة ﻓﻮق اﻟﺒﯿﺎﻧﺎت اﻟﺴﺎﺑﻘﺔ‬    ‫+‪r‬‬
              ‫اﺳﺗﺣداث اﻟﻣﻠف ﻟﻠﻛﺗﺎﺑﺔ أو اﻟﻘﺮاءة ﻟﻜﻦ ﻓﻲ اﻹﺿﺎﻓﺔ ﯾﻜﺘﺐ اﻟﺒﯿﺎﻧﺎت اﻟﺠﺪﯾﺪة ﻓﻮق اﻟﺒﯿﺎﻧﺎت اﻟﺴﺎﺑﻘﺔ‬     ‫+‪w‬‬
        ‫ﻻﺳﺗﺧدام أﻛﺛر ﻣن رﻣز ﻓﻲ اﻟﺣل ﻧﺿﻊ ﺑﯾﻧﮭم ﺟﻣﻊ ﻣﺛﻼ إذا أردﻧﺎ ﻧﻛﺗب وﻧﻠﺣق ﻛﺗﺎﺑﺗﻧﺎ ﺑﻣﺣﺗوﯾﺎت اﻟﻣﻠف اﻟﺳﺎﺑق‬
                                                                                                            ‫)‪(w+a‬‬
‫‪ ‬وﻓﻲ ﺧطوة رﻗم )٣( ﻗﻣﻧﺎ ﺑﺈدﺧﺎل اﻟﺑﯾﺎﻧﺎت إﻟﻰ داﺧل اﻟﻣﻠف ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ )‪ (fput‬اﻟﺗﻲ ﺗﺄﺧذ اﻟﻧص اﻟﻣراد‬
                                                        ‫ﻛﺗﺎﺑﺗﮫ ﺑداﺧل اﻟﻣﻠف ﺑﺷﻛل ﺳﻠﺳﻠﺔ و اﺳم اﻟﻣﻠف‬
  ‫‪ ‬ﯾﻣﻛن ﻛﺗﺎﺑﺔ ﺣرف واﺣد ﻓﻘط اﻟﻰ داﺧل اﻟﻣﻠف ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ )‪ (putc‬اﻟﺗﻲ ﺗﺄﺧذ اﺳم اﻟﻣﻠف واﻟﺣرف اﻟﻣراد‬
                                                                                            ‫إدﺧﺎﻟﮫ‬

                                                                                  ‫ﻛﺗﺎﺑﺔ اﻟﻰ داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ‪c‬‬
          ‫;),‪putc("data", fout‬‬


                                 ‫ﺑﻌد أﻛﻣﺎل ﻋﻣﻠﻧﺎ ﻣﻊ إي ﻣﻠف ﯾﺟب إﻏﻼﻗﮫ وﻻ ﯾﺟوز ﺗرﻛﮫ ﻣﻔﺗوح وﯾﻐﻠق ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬

                                                                                      ‫إﻏﻼق ﻣﻠف ﻓﻲ ﻟﻐﺔ ++‪c‬‬
        ‫;‪fout.close‬‬
                                                             ‫ﻧﻛﺗب اﺳم اﻟﻣﻠف اﻟﻣﺳﺗﺧدم داﺧل اﻟﺑرﻧﺎﻣﺞ ﺛم ﻧﻐﻠﻘﮫ‬

                                                                                         ‫إﻏﻼق ﻣﻠف ﻓﻲ ﻟﻐﺔ ‪c‬‬
         ‫;)‪fclose(fout‬‬
                                                             ‫ﻧﺳﺗﺧدم داﻟﺔ ﺗﺄﺧذ اﺳم اﻟﻣﻠف داﺧل اﻟﺑرﻧﺎﻣﺞ ﻟﺗﻐﻠﻘﮫ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                                    ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                   ‫ﻣﺛﺎل : ﺑرﻧﺎﻣﺞ ﻟﻛﺗﺎﺑﺔ ﺟﻣل ﻋﻠﻰ أﻛﺛر ﻣن ﺳطر داﺧل ﻣﻠف .؟‬

 ‫++‪c‬‬                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
  ‫>‪#include <fstream.h‬‬                                    ‫>‪#include <stdio.h‬‬
  ‫)(‪int main‬‬                                               ‫)(‪int main‬‬
 ‫;‪1. { ofstream fout‬‬                                       ‫;‪1.{ FILE * fout‬‬
   ‫;)"‪2. fout.open("D:\\firstExa.txt‬‬                        ‫;)"‪2. fout=fopen("D:\\firstExa.txt","w‬‬
 ‫"‪3. fout << "HELLOW HUSSIEN AH-ROB.\n‬‬                     ‫‪3. fputs("HELLOW HUSSIEN AH-ROB.\n WELCOME‬‬
  ‫"‪<< "WELCOME YOU PROGRAM\n‬‬                              ‫," ‪YOU PROGRAM\n WHAT DA YOU LIKE OF ME\n‬‬
  ‫;"‪<< "WHAT DA YOU LIKE OF ME\n‬‬                          ‫;)‪fout‬‬
  ‫;)(‪4. fout.close‬‬                                        ‫;)‪4.fclose(fout‬‬
   ‫}‬                                                        ‫}‬
                                                                                                  ‫ﺗو ﺿﯾﺢ اﻟﺧطوات‬
                         ‫١.ﺧطوة رﻗم واﺣد ﻋرﻓﻧﺎ )‪ (fout‬ﻣن ﻧوع ﻣﻠف، ﺧطوة رﻗم )٢( ﻛوﻧﺎ ﻣﻠف ﺑﺎﻟﻣﺳﺎر )\:‪ (d‬ﻟﻠﻛﺗﺎﺑﺔ ﻓﯾﮫ‬
          ‫٢.ﺧطوة رﻗم )٣( ﻛﺗﺎﺑﻧﺎ ﻓﻲ اﻟﻣﻠف ﻻﺣظ ﻛﯾف ﻧﻛﺗب ﺑﯾﺎﻧﺎت ﻋل أﻛﺛر ﻣن ﺳطر،ﺧطوة رﻗم )٤( أﻏﻠﻘﻧﺎ اﻟﻣﻠف‬
                                                                       ‫ﻻﺣظ ﻛﯾﻔﯾﺔ ﺗﻛون اﻟﻣﻠف داﺧل ﺟﮭﺎز اﻟﻛوﻣﺑﯾوﺗر‬




                                                              ‫واذا ﻓﺗﺣﻧﺎ اﻟﻣﻠف )‪ (firstExa‬ﺳﻧﺟد ﻣﻛﺗوب ﻓﯾﮫ اﻷﺳطر اﻟﺗﺎﻟﯾﺔ‬



                                                                             ‫ﺧزﻧت ﻓﯾﮫ ﻧﻔس اﻷﺳطر اﻟذي ﻛﺗﺑﻧﺎھﺎ ﻓﻲ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                      ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                                          ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬

                                                                                                                          ‫ﻣﮭم‬

‫ﺧطوة رﻗم )٢( ﻓﻲ اﻟﻣﺛﺎل اﻟﺳﺎﺑق إذا ﻛﺎن اﻟﻣﻠف )‪ (firstExa‬أﺻﻼ ﻣﺧزن ﻓﯾﮫ ﻣﻌﻠوﻣﺎت ﻣﻌﯾﻧﺔ ﻓﺎﻟذي ﺳوف ﯾﺣدث اﻧﮫ‬
 ‫ﺳﯾﺣذف اﻟﻣﺣﺗوﯾﺎت اﻟﺳﺎﺑﻘﺔ وﯾﺿﯾف اﻟﻣﺣﺗوﯾﺎت اﻟﺟدﯾدة ﻓﻲ ﺧطوة رﻗم )٣( ﺑدﻻ ﻣن اﻟﻣﺣﺗوﯾﺎت اﻟﺳﺎﺑﻘﺔ.واذا أردﻧﺎ أن‬
          ‫ﻻ ﯾﺣذف اﻟﻣﺣﺗوﯾﺎت اﻟﺳﺎﺑﻘﺔ إﻧﻣﺎ ﯾﺿﯾف اﻟﻣﺣﺗوﯾﺎت اﻟﺟدﯾد ﺧﻠﻔﮭﺎ ﻓﻲ اﻟﻣﻠف ﻓﻘط ﻧﻐﯾر اﻟﺧطوة رﻗم )٢( اﻟﻰ‬
 ‫++‪c‬‬                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
   ‫;)‪2. fout.open("D:\\firstExa.txt",ios::app‬‬                ‫;)"‪2. fout=fopen("D:\\firstExa.txt"," a‬‬


  ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻣذﻛرة ﻧﻛﺗب ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ وھو ﯾﺧزن ﻣﺎ ﻧﻛﺗﺑﮫ وﯾﺳﺗﻣر اﻟﺑرﻧﺎﻣﺞ ﺑﺎﻟطﻠب ﻣن اﻟﻣﺳﺗﺧدم ﺑﺎﻟﻛﺗﺎﺑﺔ اﻟﻰ‬
                                                                                   ‫أن ﯾدﺧل اﻟﻣﺳﺗﺧدم اﻟﻧﻘطﺔ ).(‬
‫ﺗﺣﻠﯾل: ﻣن اﻟﺳؤال اﻧﮫ ﯾﺗوﻗف إذا ادﺧل اﻟﻣﺳﺗﺧدم رﻣز اﻟﻧﻘطﺔ ).( إي أن اﻟﺑرﻧﺎﻣﺞ ﯾﻘرئ ﺣرف ﺣرف ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
  ‫وﯾﻘﺎرن اﻟﺣرف اﻟﻣدﺧل ﺑﺷرط اﻟﺗوﻗف ﻓﻲ دوارة )‪ (loop‬ﻣﺳﺗﻣرة ﻻ ﺗﺗوﻗف اﻷ إذا ادﺧل اﻟﻣﺳﺗﺧدم رﻣز اﻟﻧﻘطﺔ وﺑﻣﺎ‬
       ‫إﻧﻧﺎ ﻧدﺧل ﺣرف ﺣرف وﻻ ﻧرﯾد أن ﯾﺣس اﻟﻣﺳﺗﺧدم اﻧﮫ ﯾدﺧل أﺣرف ﻧﺳﺗﺧدم اﻟداﻟﺔ )‪ (getche‬ﻓﻲ اﻹدﺧﺎل ﻟﻛﻲ‬
    ‫ﺗﻘرئ ﻣﺎ ﯾدﺧﻠﮫ اﻟﻣﺳﺗﺧدم ﻣﺑﺎﺷرة. ﺑﻣﺎ اﻧﮫ ﯾرﯾد أن ﻧﺧزن ﻣﺎ ﻧﻛﺗﺑﮫ ﺑﺎﺳﺗﻣرار إي اﻧﮫ ﻓﻲ ﻛل إدﺧﺎل ﺑﻌد إﻏﻼق وﻓﺗﺢ‬
       ‫اﻟﺑرﻧﺎﻣﺞ ﯾﺿﯾف اﻟﺣرف اﻟﺟدﯾد اﻟﻣدﺧل اﻟﻰ اﻟﻣﻠف وﻻ ﯾﻣﺳﺢ ﻣﺣﺗوﯾﺎﺗﮫ إﻧﻣﺎ ﯾﻠﺣق اﻟﻛﺗﺎﺑﺔ اﻟﺟدﯾدة ﺑﻧﮭﺎﯾﺔ اﻟﻛﺗﺎﺑﺔ‬
                                                                                                        ‫اﻟﺳﺎﺑﻘﺔ‬
 ‫++‪c‬‬                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
  ‫>‪#include <fstream.h‬‬                                   ‫>‪#include <stdio.h‬‬
 ‫>‪#include <conio.h‬‬                                      ‫>‪#include <conio.h‬‬
  ‫)(‪int main‬‬                                              ‫)(‪int main‬‬
 ‫; ‪2. {char symbol‬‬                                       ‫; ‪1. {char symbol‬‬
 ‫;‪3. ofstream fout‬‬                                       ‫;‪2. FILE * fout‬‬
 ‫;)‪3. fout.open("D:\\note.txt",ios::app‬‬                  ‫;)"‪3. fout=fopen("D:\\note .txt"," a‬‬
 ‫{‪4. do‬‬                                                  ‫{‪4. do‬‬
 ‫;)(‪5.symbol=getche‬‬                                      ‫;)(‪5.symbol=getche‬‬
 ‫;‪6.fout << symbol‬‬                                       ‫;)‪6. putc(symbol, fout‬‬
 ‫;)'.' =! ‪7.} while(symbol‬‬                               ‫;)'.' =! ‪7.} while(symbol‬‬
 ‫;"‪8.cout<<"\ncontent is saved‬‬                           ‫;)"‪8.printf("\ncontent is saved‬‬
 ‫;)(‪9. fout.close‬‬                                        ‫;)‪9.fclose(fout‬‬
 ‫}‬                                                         ‫}‬
                                                                                                ‫ﺗوﺿﯾﺢ اﻟﺧطوات‬
                         ‫١. اﻟﺧطوة رﻗم )٣( ﻓﺗﺣﻧﺎ ﻣﻠف ﻟﻠﻛﺗﺎﺑﺔ ﻣﻊ ﻣﯾزة إﻟﺣﺎق اﻟﻛﺗﺎﺑﺔ اﻟﺟدﯾدة ﺑﺎﻟﻛﺗﺎﺑﺔ اﻟﺳﺎﺑﻘﺔ‬
                                                                  ‫٢. ﺧطوة رﻗم )٥( ھو ﻗراءة ﻣن ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
                                                ‫٣. ﺧطوة رﻗم )٦( طﺑﺎﻋﺔ اﻟﺣرف اﻟذي ﺗﻣت ﻗراءﺗﮫ ﻓﻲ اﻟﻣﻠف‬
   ‫٤. ﺧطوة رﻗم )٤ اﻟﻰ ٧( ﺗﺗﻛرر ﺑﺎﺳﺗﻣرار ﻣﺎدام اﻟﻣﺳﺗﺧدم ﻟم ﯾدﺧل رﻣز اﻟﻧﻘطﺔ ﻻن ﺷرط اﻟﺗوﻗف ﻓﻲ اﻟﺧطوة‬
                 ‫ﻣﺣﺗوﯾﺎت اﻟﻣﻠف‬                                    ‫رﻗم )٧( أن ﯾﻛون اﻟرﻣز اﻟﻣدﺧل ھو ﻧﻘطﺔ‬




                                                                                 ‫ﺗوﻗﻔت اﻟﻘراﺋﺔ ﻋﻧدﻣﺎ ادﺧﻠﻧﺎ ﻧﻘطﺔ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                         ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(File) ‫اﻟﻣﻠﻔﺎت‬                                                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                         ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﺧزن أﺳﻣﺎء )٦( ﻣﺳﺗﺧدﻣﯾن وﻛﻠﻣﺎت ﻣرورھم ھﻲ ﻣﻠف .؟‬
                                    ‫ﺗﺣﻠﯾل: ﻧﻛون ﺳﺟل ﺣﺟﻣﮫ ﺳﺗﺔ ﯾﺣوي اﺳم ﻣﺳﺗﺧدم وﻛﻠﻣﺔ ﻣرور وﻧدﺧﻠﮫ ﻓﻲ ﻣﻠف‬
 c++                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    c                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                    #include<stdio.h>
 #include<stdio.h>                                       1.struct password_User
 #include <fstream.h>                                    2.{char username[20];
 1.struct password_User                                  3. char password[20]; }userProtec on[6];
 2.{char username[20];                                   4.main()
 3. char password[20]; }userProtec on[6];                5.{int i;
 4.main()                                                6.for(i=0;i<6;i++){
 5.{int i;                                               7. prin ("\nenter hussien user name: ");
 6.for(i=0;i<6;i++){                                     8. gets( userProtec on[i]. username );
 7.cout<<"\nenter user name: ";                          9. prin ("enter hussien password: ");
 8. gets(userProtec on[i]. username );                   10.gets( userProtec on[i]. password );}
 9.cout<<"enter password: ";                             11.FILE * fout;
 10. gets( userProtection[i]. password);}                12. fout=fopen("D:\\up.txt","w");
 11.ofstream fout;                                       13.for(i=0;i<6;i++){
 12. fout.open("D:\\up.txt");                            14.fprin (fout ,"User ID :");
 13.for(i=0;i<6;i++){                                    fprintf(fout , userProtection [i]. username);
 14.fout << "User ID :";                                 fprintf(fout , "\tuser Password: ");
  fout <<<< userProtection [i]. username;                fprintf(fout , userProtection [i]. password);
  fout <<<< "\tuser Password: ";                         fprintf(fout , "\n");}
 fout <<<< userProtection [i]. password;                 15. fclose(fout);
 fout <<<<"\n";}                                         }
 15. fout.close();
 }
                                                                                                :‫ﺗوﺿﯾﺢ اﻟﺧطوات‬
                                     ‫١.ﺧطوة رﻗم )١و٢و٤( ﻛوﻧﺎ ﺳﺟل ﺣﺟﻣﮫ ﺳت ﻣﺳﺗﺧدﻣﯾن ﻓﯾﮫ اﺳم وﻛﻠﻣﺔ ﻣرور‬
                                          ‫٢.ﺧطوة رﻗم)٦ اﻟﻰ ٠١(( ھﻲ إدﺧﺎل أﺳﻣﺎء اﻟﻣﺳﺗﺧدﻣﯾن وﻛﻠﻣﺎت ﻣرورھم‬
                                   ‫٣.ﺧطوة رﻗم )١١( ﻋرﻓﻧﺎ ﻣﻠف ﺟدﯾد وﺧطوة رﻗم )٢١( ﻓﺗﺣﻧﺎ اﻟﻣﻠف ﻟﻠﻛﺗﺎﺑﺔ ﻓﯾﮫ‬
(١٤) ‫٤.ﺧطوة رﻗم )٣١( ھو ﻋداد ﻟﻛﻲ ﯾدﺧل أﺳﻣﺎء وﻛﻠﻣﺎت ﻣرور ﻛل اﻟﻣﺳﺗﺧدﻣﯾن واﺣد ﯾﺗﻠو اﻷﺧر ﻓﻲ ﺧطوة رﻗم‬


          ‫ﺳﯾﺧزﻧون ﻓﻲ اﻟﻣﻠف ﻓﻲ اﻟﺷﻛل اﻟﺗﺎﻟﻲ‬                          ‫ﻟو أدﺧﻠﻧﺎ أﺳﻣﺎء اﻟﻣﺳﺗﺧدﻣﯾن ﻛﻣﺎ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                   C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                               ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                              ‫٣.٨- اﻟﻘراءة ﻣن اﻟﻣﻠﻔﺎت اﻟﻧﺻﯾﺔ:‬
                                  ‫ﺑﻌد ان ﻛﺗﺑﻧﺎ داﺧل اﻟﻣﻠف ﻗد ﻧﺣﺗﺎج اﻟﻰ ﻗراﺋﺔ ﻣﺣﺗوﯾﺎﺗﮫ اﻟﺗﻲ ﻗﻣﻧﺎ ﺑﺧزﻧﮭﺎ ﻓﻲ داﺧﻠﮫ‬
                                                           ‫ﻟﻠﻘراءة ﻣن داﺧل إي ﻣﻠف ﺗوﺟد ﺛﻼث ﺧطوات وھﻲ ؟‬
                                                     ‫‪ ‬ﺧطوة اﻷوﻟﻰ ﻧﻌرف ﻛﺎﺋن ﻣن ﻧوع ﻣﻠف‬
                                                               ‫‪ ‬ﺧطوة ﺛﺎﻧﯾﺔ ﻧﻔﺗﺢ اﻟﻣﻠف ﻟﻠﻘراءة‬
                                                        ‫‪ ‬اﻟﺧطوة اﻟﺛﺎﻟﺛﺔ ﻧﻘرئ ﻣن داﺧل اﻟﻣﻠف‬
                                               ‫١.ﻓﻲ ﻟﻐﺔ )++‪ (c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﻠﻘراءة ﻣن داﺧل اﻟﻣﻠﻔﺎت‬
                                                                             ‫ﻗراءة ﻣن داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ++‪c‬‬
        ‫; ‪1. ifstream fin‬‬
                      ‫‪file‬‬               ‫;)‪family‬‬
        ‫)‪2. fin.open("file path",iostream family‬‬
        ‫;)08,‪3.fin.getline(array‬‬
‫اﻟﺧطوة اﻷوﻟﻰ ﻋرﻓﻧﺎ )‪ (fin‬ﻣن ﻧوع ﻣﻠف ﻟﻠﻘراءة. ھو اﺳم ﻟﻠﻣﻠف اﻟذي ﻧرﯾد اﻟﻘراءة ﻣﻧﮫ ﻟﻠﺗﻌﺎﻣل ﻣﻌﮫ داﺧل‬             ‫‪‬‬
                                                                     ‫اﻟﺑرﻧﺎﻣﺞ وﻣﻣﻛن أن ﯾﻛون أي اﺳم‬
            ‫) ‪ : ( file path‬ھو ﻣﺳﺎر اﻟﻣﻠف اﻟﻣراد ﻓﺗﺣﮫ ﻣن داﺧل اﻟﺟﮭﺎز ﯾوﺿﻊ ﺑﯾن ﻋﻼﻣﺗﻲ ﺗﻧﺻﯾص‬                    ‫‪‬‬
            ‫)‪ : (iostream family‬ھﻲ رﻣوز اﻟﻣﺳﺗﺧدﻣﺔ ﻣﺛل ﺗﺳﺗﺧدم ﻟﻠدﻻﻟﺔ ﻋﻠﻰ ﻋﻣﻠﯾﺎت ﻣﻌﻧﯾﺔ‬                         ‫‪‬‬
                     ‫وﻓﻲ ﺧطوة رﻗم )3( ﻗﻣﻧﺎ ﺑﺧزن ﺳطر واﺣد ﻣن اﻟﺑﯾﺎﻧﺎت ﻣن اﻟﻣﻠف اﻟﻰ داﺧل ﻣﺻﻔوﻓﺔ‬                ‫‪‬‬


                                           ‫١. ﻓﻲ ﻟﻐﺔ )‪ ( c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﻠﻘراءة ﻣن داﺧل اﻟﻣﻠﻔﺎت‬
                                                                                ‫ﻗراءة ﻣن داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ‪c‬‬
        ‫; ‪1.FILE *f fin‬‬
                                   ‫;)"‪symbol‬‬
        ‫‪2. fin =fopen("file path","symbol‬‬
        ‫;) ‪3.fgets( fin ,80, array‬‬

                     ‫)‪ : (fout‬ھو اﺳم ﻟﻠﻣﻠف اﻟذي ﻧرﯾد اﻟﻘراءة ﻣﻧﮫ. ﻋرﻓﻧﺎه ﻓﻲ اﻟﺧطوة رﻗم )١( اﻧﮫ ﻣﻠف‬           ‫‪‬‬
         ‫) ‪ : ( file path‬ھو ﻣﺳﺎر اﻟﻣﻠف اﻟﻣراد ﻓﺗﺢ اﻟﻣﻠف ﻣن داﺧل اﻟﺟﮭﺎز ﯾوﺿﻊ ﺑﯾن ﻋﻼﻣﺗﻲ ﺗﻧﺻﯾص‬                  ‫‪‬‬
 ‫)‪ : (symbol‬ھﻲ رﻣوز اﻟﻣﺳﺗﺧدﻣﺔ ﻣﺛل ﺗﺳﺗﺧدم ﻟﻠدﻻﻟﺔ ﻋﻠﻰ ﻋﻣﻠﯾﺎت ﻣﻌﯾﺔ ﺗوﺿﻊ ﺑﯾن ﻋﻼﻣﺗﻲ ﺗﻧﺻﯾص‬                         ‫‪‬‬
                  ‫وھﻧﺎ ﻧﺳﺗﺧدم اﻟرﻣز ) ‪ (r‬ﻷﻧﻧﺎ ﻧرﯾد اﻟﻘراءة ﻣن داﺧل اﻟﻣﻠف. وھذا ﺟدول ﺑﮭذه اﻟرﻣوز‬
     ‫وﻓﻲ ﺧطوة رﻗم )٣( ﻗﻣﻧﺎ ﺑﻘراءة اﻟﺑﯾﺎﻧﺎت ﻣن داﺧل اﻟﻣﻠف ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ )‪ (fgets‬اﻟﺗﻲ ﺗﺄﺧذ اﺳم اﻟﻣﻠف‬         ‫‪‬‬
   ‫واﻟﻧص اﻟﻣراد اﻟﻘراءة ﻣﻧﮫ وﺗﺧزن اﻟﻧﺎﺗﺞ ﻓﻲ ﻣﺻﻔوﻓﺔ و )08( ھو ﻋدد اﻷﺣرف اﻟﻣرد ﻗراءﺗﮭﺎ ﻣن اﻟﻣﻠف‬
 ‫ﯾﻣﻛن ﻗراءة ﺣرف واﺣد ﻓﻘط ﻣن داﺧل اﻟﻣﻠف ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ ) ‪ (get‬اﻟﺗﻲ ﺗﺄﺧذ اﺳم اﻟﻣﻠف وﺗﻌطﻲ واﻟﺣرف‬
                                     ‫‪getc‬‬                                                                    ‫‪‬‬
                                                                                          ‫اﻟﻣراد ﻗراﺋﺗﮫ‬

                                                                               ‫ﻗراءة ﻣن داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ‪c‬‬
          ‫;) ‪var= getc(fin‬‬
                                                                 ‫‪: (fin) ‬ھو اﺳم اﻟﻣﻠف اﻟﻣراد اﻟﻘراءة ﻣﻧﮫ‬
                                             ‫‪ (var) ‬ھو اﺳم اﻟﻣﺗﻐﯾر اﻟﻣراد ﺧزن اﻟﻘﯾﻣﺔ اﻟﻣﻘروءة ﻓﻲ داﺧﻠﮫ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                                ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                            ‫‪ ‬اﻟﻘراءة ﻣن اﻟﻣﻠف ﺗﺑدأ ﺑﻘراءة اﻟﺑﺎﯾت اﻷول ﺛم اﻟﺛﺎﻧﻲ وﺑﺎﻟﺗﺗﺎﺑﻊ‬
‫ﻣﺛﺎل : ﻗم ﺑﻘراءة ﺟﻣﯾﻊ ﻣﺣﺗوﯾﺎت اﻟﻣﻠف اﻟذي ﯾﻘﻊ ﻓﻲ اﻟﻣﺳﺎر اﻟﺗﺎﻟﻲ ) ‪ ( D:\\firstExa.txt‬وﯾﺣﺗوي اﻟﻣﻠف ﻋﻠﻰ اﻟﺑﯾﺎﻧﺎت‬
                                                                                                         ‫اﻟﺗﺎﻟﯾﺔ.؟‬

                                          ‫ﺗﺣﻠﯾل: ﻟﻘراءة ﺟﻣﯾﻊ ﻣﺣﺗوﯾﺎت ﻣﻠف ﻧﺳﺗﺧدم دوال اﻟﺗﻛرار ﻓﻲ اﻟﻘراءة ﺣﯾث‬
                                          ‫ﻛل ﻣﺎ ﯾﻘرئ ﺑﺎﯾت ﯾﻧﺗﻘل اﻟﻣؤﺷر إﻟﻰ اﻟﺑﺎﯾت اﻟﺛﺎﻧﻲ ﻟﯾﻘرﺋﮫ ﻓﻲ اﻟﻣرة اﻟﻘﺎدﻣﺔ‬
                                             ‫ﻟﻛن ﻻ ﺑد ﻣن وﺟود داﻟﺔ ﺗوﻗف اﻟﻘراءة ﻋﻧد اﻟوﺻول إﻟﻰ ﻧﮭﺎﯾﺔ اﻟﻣﻠف‬




 ‫++‪c‬‬                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                              ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫>‪#include <fstream.h‬‬                                     ‫>‪#include <stdio.h‬‬
  ‫>‪#include <iostream.h‬‬                                   ‫>‪#include <stdlib.h‬‬
   ‫)(‪main‬‬                                                   ‫)(‪main‬‬
 ‫;]08[ ‪1. { char array‬‬                                     ‫;‪8.{ char reading‬‬
 ‫;‪2. ifstream fin‬‬                                         ‫;‪9. FILE * fin‬‬
 ‫;)"‪3. fin.open("D:\\firstExa.txt‬‬                         ‫;)"‪10.fin=fopen("D:\\firstExa.txt","r‬‬
 ‫))(‪4.while(!fin.eof‬‬                                      ‫)‪11.while( (reading=getc(fin)) !=EOF‬‬
 ‫;)08,‪5.{fin.getline(array‬‬                                ‫{.21‬
 ‫};‪6.cout<<array<<endl‬‬                                    ‫};) ‪13.printf("%c", reading‬‬
 ‫} ;)(‪7. fin.close‬‬                                        ‫};)‪14.fclose(fin‬‬

                                                                                          ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬
                                    ‫١. ﺧطوة رﻗم )١( ﻋرﻓﻧﺎ ﻣﺻﻔوﻓﺔ ﻟﺧزن اﻟذي ﻧﻘرﺋﮫ ﻓﯾﮫ ﻋﻧد ﻛل ﻗراءة‬
                          ‫٢. ﺧطوة رﻗم )٨( ﻋرﻓﻧﺎ ﻣﺗﻐﯾر ﺣرﻓﻲ ﻟﻧﺧزن اﻷﺣرف اﻟﺗﻲ ﻧﻘرﺋﮭﺎ ﺣرف ﺣرف‬
                      ‫٣. ﺧطوة رﻗم )٢و٩( ﻋرﻓﻧﺎ ﻛﺎﺋن ﻣن ﻧوع ﻣﻠف ،ﺧطوة رﻗم )٣( ﻓﺗﺣﻧﺎ اﻟﻣﻠف ﻟﻠﻘراءة‬
                                                            ‫٤. ﺧطوة رﻗم )٣ و٠١( ﻓﺗﺣﻧﺎ اﻟﻣﻠف ﻟﻠﻘراءة‬
‫٥. ﺧطوة رﻗم ) ١١و٤( ھﻲ دوارة ﻻ ﺗﺗوﻗف إﻻ أن ﯾﻧﺗﮭﻲ ﻣن ﻗراءة أﺧر ﺳطر ﻓﻲ اﻟﻣﻠف )‪ (eof‬ھﻲ ﻣﺧﺗﺻر‬
‫ﻟﻛﻠﻣﺔ )‪ (end of file‬ھو ﻣؤﺷر ﻋﻠﻰ ﻧﮭﺎﯾﺔ اﻟﻣﻠف أي ھﻧﺎ اﺳﺗﺧدﻣﻧﺎه ﻛﺷرط ﺗوﻗف إذا ﻗرء أﺧر ﺳطر ﯾﺗوﻗف‬
                                                               ‫ﺣﺗﻰ ﻻ ﯾﺳﺗﻣر ﺑﺎﻟﻘراءة إﻟﻰ أﻟﻣﺎ ﻻﻧﮭﺎﯾﺔ‬
                                     ‫٦. ﺧطوة رﻗم )٥( ﻧﻘرئ ﺳطر ﺳطر ﻣن اﻟﻣﻠف ﺗﻘﻊ اﻟداﻟﺔ ﺿﻣن ﻣﻛﺗﺑﺔ‬
               ‫٧. ﺧطوة رﻗم )٦( ھﻲ طﺑﺎﻋﺔ ﺳطر ﺳطر وﻛﻠﻣﺔ )‪ (endl‬ﻹﻧزال اﻟﻣؤﺷر إﻟﻰ اﻟﺳطر اﻟﺗﺎﻟﻲ‬
                                                            ‫٨. ﺧطوة رﻗم )٣١( ھﻲ طﺑﺎﻋﺔ ﺣرف ﺣرف‬
                                                     ‫‪ ‬ﻻﺣظ ﻷﺳم ﺗﺑﯾن ﻟك ﻛل داﻟﺔ وﺗﻘﻊ ﺗﺣت إي ﻣﻛﺗﺑﺔ‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                                        ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                                     ‫٤.٨- اﻟﻛﺗﺎﺑﺔ ﻓﻲ اﻟﻣﻠﻔﺎت اﻟﺛﻧﺎﺋﯾﺔ:‬
                        ‫اﻟﻣﻠﻔﺎت اﻟﺛﻧﺎﺋﯾﺔ ﺗﺳﺗﺧدم ﻟﺗﺧزﯾن اﻟﻣﺻﻔوﻓﺎت واﻟﻣﺗﻐﯾرات واﻟﺗراﻛﯾب.وﻟﻠﻛﺗﺎﺑﺔ ﺗوﺟد ﺛﻼث ﺧطوات‬
                                                     ‫‪ ‬ﺧطوة اﻷوﻟﻰ ﻧﻌرف ﻛﺎﺋن ﻣن ﻧوع ﻣﻠف‬
                                                              ‫‪ ‬ﺧطوة ﺛﺎﻧﯾﺔ ﻧﻔﺗﺢ اﻟﻣﻠف ﻟﻠﻛﺗﺎﺑﺔ‬
                                                        ‫‪ ‬اﻟﺧطوة اﻟﺛﺎﻟﺛﺔ ﻧﻛﺗب إﻟﻰ داﺧل اﻟﻣﻠف‬

                                          ‫١. ﻓﻲ ﻟﻐﺔ )++‪ (c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﻠﻛﺗﺎﺑﺔ إﻟﻰ داﺧل اﻟﻣﻠﻔﺎت‬
                                                                                     ‫ﻛﺗﺎﺑﺔ اﻟﻰ داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ++‪c‬‬
        ‫; ‪1. ofstream fout‬‬
                     ‫‪("file‬‬                ‫;)‪family|ios::binary‬‬
        ‫‪2. fout.open("file path",iostream family‬‬
                                     ‫; ))‪,sizeof(data‬‬
        ‫(‪3. fout.write((char*)& data ,sizeof‬‬
   ‫‪ : (iostream family) ‬ھﻲ رﻣوز اﻟﻣﺳﺗﺧدﻣﺔ ﻣﺛل ﺗﺳﺗﺧدم ﻟﻠدﻻﻟﺔ ﻋﻠﻰ ﻋﻣﻠﯾﺎت ﻣﻌﻧﯾﺔ وﻧﺳﺗﺧدم ھﻧﺎ اﻟرﻣز‬
                                                       ‫)‪ (ios::binary‬ﺑﻣﻌﻧﻰ أن اﻟﻣﻠف اﻟﻣدﺧل ھو ﺛﻧﺎﺋﻲ‬
    ‫‪ ‬وﻓﻲ ﺧطوة رﻗم )3( ﻗﻣﻧﺎ ﺑﺈدﺧﺎل اﻟﺑﯾﺎﻧﺎت إﻟﻰ داﺧل اﻟﻣﻠف ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ )‪ (write‬اﻟﺗﻲ ﺗﺄﺧذ )‪ (data‬ﻗد‬
                                                              ‫ﯾﻛون ﻣﺗﻐﯾر أو ﻣﺻﻔوﻓﺔ أو ﺳﺟل وﺣﺟﻣﮭﺎ‬


                                             ‫٢. ﻓﻲ ﻟﻐﺔ )‪ ( c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﻠﻛﺗﺎﺑﺔ إﻟﻰ داﺧل اﻟﻣﻠﻔﺎت‬
                                                                                        ‫ﻛﺗﺎﺑﺔ اﻟﻰ داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ‪c‬‬
        ‫;‪1.FILE *fout‬‬
                                  ‫;)"‪symbol‬‬
        ‫‪2.fout=fopen("file path","symb‬‬
                                    ‫,‪),n‬‬
        ‫;)‪3.fwrite(& data ,sizeof(data) fout‬‬
 ‫‪ : (symbol) ‬ھﻲ رﻣوز اﻟﻣﺳﺗﺧدﻣﺔ ﻣﺛل ﺗﺳﺗﺧدم ﻟﻠدﻻﻟﺔ ﻋﻠﻰ ﻋﻣﻠﯾﺎت ﻣﻌﯾﺔ ﺗوﺿﻊ ﺑﯾن ﻋﻼﻣﺗﻲ ﺗﻧﺻﯾص‬
                                        ‫وھﻧﺎ ﻧﺳﺗﺧدم اﻟرﻣز ) ‪ (wb‬ﻷﻧﻧﺎ ﻧرﯾد اﻟﻛﺗﺎﺑﺔ ﺑداﺧل اﻟﻣﻠف ﺛﻧﺎﺋﻲ.‬
 ‫‪ ‬وﻓﻲ ﺧطوة رﻗم )٣( ﻗﻣﻧﺎ ﺑﺈدﺧﺎل اﻟﺑﯾﺎﻧﺎت إﻟﻰ داﺧل اﻟﻣﻠف ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ )‪ (fwrite‬اﻟﺗﻲ ﺗﺄﺧذ اﻟﻧص اﻟﻣراد‬
                  ‫ﻛﺗﺎﺑﺗﮫ )‪ (data‬ﺑداﺧل اﻟﻣﻠف وﺣﺟﻣﮫ وﻋدد اﻟﻣواﻗﻊ أو ﺳﺟﻼت )‪ (n‬و اﺳم اﻟﻣﻠف )‪(fout‬‬


                                                         ‫ﻣﺛﺎل : ﺗﺧزﯾن ﻣﺻﻔوﻓﺔ أﺣﺎدﯾﺔ ﺣﺟﻣﮭﺎ )٠١( داﺧل ﻣﻠف .؟‬
 ‫++‪c‬‬                                          ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                  ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
  ‫>‪#include<iostream.h‬‬                                        ‫>‪#include<stdio.h‬‬
 ‫>‪#include <fstream.h‬‬                                        ‫>‪#include <fstream.h‬‬
 ‫)(‪main‬‬                                                      ‫)(‪main‬‬
  ‫;‪1.{ int Array[80],i‬‬                                        ‫;‪1.{ int Array[80],i‬‬
 ‫)++‪2.for(i=0;i<10;i‬‬                                         ‫)++‪2.for(i=0;i<10;i‬‬
 ‫;]‪3.cin>> Array[i‬‬                                           ‫;)]‪3.scanf("%d",&Array[i‬‬
 ‫;‪4.ofstream fout‬‬                                            ‫;‪4.FILE * fout‬‬
 ‫;)‪5. fout.open("D:\\ar.bin",ios::binary‬‬                                           ‫;)"‪bin","wb‬‬
                                                             ‫;)"‪5. fout=fopen("D:\\ar.bin","wb‬‬
 ‫;))‪6. fout .write((char *) & Array , sizeof(Array‬‬                                         ‫,01,)‬
                                                             ‫;)‪6.fwrite(& Array ,sizeof(Array),10, fout‬‬
 ‫} ;)(‪7.fout.close‬‬                                           ‫} ;)‪7. fclose(fout‬‬
                                                                                                     ‫ﺗوﺿﯾﺢ اﻟﺧطوات :‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                           ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(File) ‫اﻟﻣﻠﻔﺎت‬                                                                                             ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                    ‫١. ﺧطوة رﻗم )٥( ﻓﺗﺣﻧﺎ ﻣﻠف ﺛﻧﺎﺋﻲ ﻟﻛﻲ ﻧﻛﺗب ﻓﻲ داﺧﻠﮫ‬
                  ‫٢. ﺧطوة رﻗم )٦( أدﺧﻠﻧﺎ ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ ﻓﻲ اﻟﻣﻠف وﺣددﻧﺎ ﺣﺟم اﻟﺑﯾﺎﻧﺎت اﻟﻣدﺧﻠﺔ ھﻲ ﻋﺷرة‬

                                                                                           ‫وﺗﺧزن ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬




                                     (*bin) ‫ اﻟﻣﻠف ﻻ ﯾﻣﻛن ﻓﺗﺣﮫ ﺑﻣﺗﺻﻔﺣﺎت اﻟﻣﻠﻔﺎت اﻻﻋﺗﯾﺎدﯾﺔ ﻷن اﻣﺗداده‬



                                         ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﻟﺧزن أﺳﻣﺎء )٦( ﻣﺳﺗﺧدﻣﯾن وﻛﻠﻣﺎت ﻣرورھم ھﻲ ﻣﻠف .؟‬
 c++                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    c                                           ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                   #include<stdio.h>
 #include<stdio.h>                                      1.struct password_User
 #include <fstream.h>                                   2.{char username[20];
 1.struct password_User                                 3. char password[20]; }userProtec on[6];
 2.{char username[20];                                  4.main()
 3. char password[20]; }userProtec on[6];               5.{int i;
 4.main()                                               6.for(i=0;i<6;i++){
 5.{int i;                                              7. prin ("\nenter user name: ");
 6.for(i=0;i<6;i++){                                    8. gets( userProtec on[i]. username );
 7.cout<<"\nenter user name: ";                         9. prin ("enter password: ");
 8. gets(userProtec on[i]. username );                  10.gets( userProtec on[i]. password );}
 9.cout<<"enter password: ";                            11.FILE * fout;
 10. gets( userProtec on[i]. password);}                12. fout=fopen("D:\\up.bin","wb");
 11.ofstream fout;                                      13.for(i=0;i<6;i++)
 12. fout.open("D:\\up.bin",ios::binary);               14..fwrite(& userProtection[i] ,sizeof(
 13.for(i=0;i<6;i++)                                    userProtection[i]),6, fout);
 14. fout.write((char*)& userProtection[i]              15. fclose(fout);
 ,sizeof( userProtection[i]));                          }
 15. fout.close();}
                                                                                            :‫ﺗوﺿﯾﺢ اﻟﺧطوات‬
                                                             ‫١. ﺧطوة رﻗم )٢١( ﻓﺗﺣﻧﺎ ﻣﻠف ﺛﻧﺎﺋﻲ ﻟﻠﻛﺗﺎﺑﺔ ﻓﯾﮫ‬
                                                                 ‫٢. ﺧطوة رﻗم)٦ إﻟﻰ ٠١( ھﻲ إدﺧﺎل ﺑﯾﺎﻧﺎت‬
                                                              ‫٣. ﺧطوة رﻗم)٤١( ﻗﻣﻧﺎ ﺑﺈدﺧﺎل ﻛل ﺳﺟل ﻛﺎﻣل‬
                                                                                ‫ﻣرة واﺣدة إﻟﻰ داﺧل اﻟﻣﻠف‬


                           ‫ﻗﺎرن ھذا اﻟﺣل ﺑﺎﻟﺣل اﻟﺳﺎﺑق ﻟﻧﻔس ھذا اﻟﻣﺛﺎل ﻓﻲ ﺣﺎﻟﺔ ﻛﺗﺎﺑﺔ اﻟﻣﻠﻔﺎت اﻟﻧﺻﯾﺔ‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                               C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                                     ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                                   ‫٥.٨- اﻟﻘراءة ﻣن اﻟﻣﻠﻔﺎت اﻟﺛﻧﺎﺋﯾﺔ:‬
                                             ‫ﻟﻠﻘراءة ﻣن داﺧل إي ﻣﻠف ﺗوﺟد ﺛﻼث ﺧطوات وھﻲ. .....................!‬
                                                            ‫‪ ‬ﺧطوة اﻷوﻟﻰ ﻧﻌرف ﻛﺎﺋن ﻣن ﻧوع ﻣﻠف‬
                                                                      ‫‪ ‬ﺧطوة ﺛﺎﻧﯾﺔ ﻧﻔﺗﺢ اﻟﻣﻠف ﻟﻠﻘراءة‬
                                                                ‫‪ ‬اﻟﺧطوة اﻟﺛﺎﻟﺛﺔ ﻧﻘرئ ﻣن داﺧل اﻟﻣﻠف‬

                                                    ‫١.ﻓﻲ ﻟﻐﺔ )++‪ (c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﻠﻘراءة ﻣن داﺧل اﻟﻣﻠﻔﺎت‬
                                                                                  ‫ﻗراءة ﻣن داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ++‪c‬‬
        ‫; ‪1. ifstream fin‬‬
                    ‫‪("file‬‬                 ‫;)‪family‬‬
        ‫)‪2. fin.open("file path",iostream family‬‬
                                   ‫;))‪,sizeof(data‬‬
        ‫(‪3. fin.read((char*)& array,sizeof‬‬
      ‫‪ : (iostream family) ‬ھﻲ رﻣوز اﻟﻣﺳﺗﺧدﻣﺔ ﻣﺛل ﺗﺳﺗﺧدم ﻟﻠدﻻﻟﺔ ﻋﻠﻰ ﻋﻣﻠﯾﺎت ﻣﻌﻧﯾﺔ وﻧﺳﺗﺧدم ھﻧﺎ‬
                                                ‫اﻟرﻣز )‪ (ios::binary‬ﺑﻣﻌﻧﻰ أن اﻟﻣﻠف اﻟﻣدﺧل ھو ﺛﻧﺎﺋﻲ‬
        ‫‪ ‬وﻓﻲ ﺧطوة رﻗم )3( ﻗﻣﻧﺎ ﺑﻘراءة اﻟﺑﯾﺎﻧﺎت ﻣن اﻟﻣﻠف إﻟﻰ داﺧل ﻣﺻﻔوﻓﺔ )‪ (data‬وھذه ﻣﻣﻛن أن ﺗﻛون‬
              ‫ﻣﺻﻔوﻓﺔ أو ﺳﺟل أو ﻣﺗﻐﯾر وان )‪ sizeof(array‬ﻣﻌﻧﺎه ﺣﺟم اﻟﺑﯾﺎﻧﺎت اﻟﺗﻲ ﺳﻧﻘرﺋﮭﺎ ﻣن اﻟﻣﻠف‬


                                                ‫٢. ﻓﻲ ﻟﻐﺔ )‪ ( c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﻠﻘراءة ﻣن داﺧل اﻟﻣﻠﻔﺎت‬
                                                                                     ‫ﻗراءة ﻣن داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ‪c‬‬
        ‫; ‪1.FILE *f fin‬‬
                                   ‫;)"‪symbol‬‬
        ‫‪2. fin =fopen("file path","symbol‬‬
        ‫)‪3.fread(& data ,sizeof( data ),n,fin‬‬

  ‫‪ : (symbol) ‬ھﻲ رﻣوز اﻟﻣﺳﺗﺧدﻣﺔ ﻣﺛل ﺗﺳﺗﺧدم ﻟﻠدﻻﻟﺔ ﻋﻠﻰ ﻋﻣﻠﯾﺎت ﻣﻌﯾﺔ ﺗوﺿﻊ ﺑﯾن ﻋﻼﻣﺗﻲ ﺗﻧﺻﯾص‬
                                        ‫وھﻧﺎ ﻧﺳﺗﺧدم اﻟرﻣز ) ‪ (br‬ﻷﻧﻧﺎ ﻧرﯾد اﻟﻘراءة ﻣن داﺧل اﻟﻣﻠف‬
  ‫‪ ‬وﻓﻲ ﺧطوة رﻗم )٣( ﻗﻣﻧﺎ ﺑﻘراءة اﻟﺑﯾﺎﻧﺎت ﻣن داﺧل اﻟﻣﻠف ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ )‪ (fread‬إﻟﻰ )‪ (data‬ﻣﻣﻛن أن‬
   ‫ﺗﻛون اﻟﻣﺻﻔوﻓﺔ أو اﻟﺳﺟل أو اﻟﻣﺗﻐﯾر وﺣﺟم اﻟذي ﻧرﯾده ) أن ﻧﻘرﺋﮫ أو ﻋدد اﻟﻣواﻗﻊ و اﺳم اﻟﻣﻠف )‪(fout‬‬


        ‫.؟‬   ‫اﻟﺗﺎﻟﻲ )" ‪("D:\\ar.bin‬‬   ‫ﻣﺛﺎل : ﻗراءة ﻣﺣﺗوﯾﺎت ﻣﺻﻔوﻓﺔ أﺣﺎدﯾﺔ ﺣﺟﻣﮭﺎ )٠١( ﻣن داﺧل ﻣﻠف ﻓﻲ اﻟﻣﺳﺎر‬
 ‫++‪c‬‬                                         ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    ‫‪c‬‬                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
  ‫>‪#include<iostream.h‬‬                                       ‫>‪#include<stdio.h‬‬
 ‫>‪#include <fstream.h‬‬                                       ‫>‪#include <fstream.h‬‬
 ‫)(‪main‬‬                                                     ‫)(‪main‬‬
  ‫;‪1.{ int Array[10],i‬‬                                       ‫;‪1.{ int Array[10],i‬‬
 ‫;‪2.ifstream fout‬‬                                           ‫;‪2.FILE * fout‬‬
 ‫;)‪3. fout.open("D:\\ar.bin",ios::binary‬‬                                                 ‫;)"‪b‬‬
                                                            ‫;)"‪3. fout=fopen("D:\\ar.bin","rb‬‬
 ‫;))‪4. fout .read((char *) & Array , sizeof(Array‬‬                                          ‫,1,‬
                                                            ‫;)‪4.fread(& Array ,sizeof(Array) ,1 fout‬‬
 ‫)++‪5.for(i=0;i<10;i‬‬                                        ‫)++‪5.for(i=0;i<10;i‬‬
 ‫;"‪6.cout<< Array[i]<<"\t‬‬                                   ‫;)]‪6.prin ("%d\t", Array[i‬‬
 ‫} ;)(‪7.fout.close‬‬                                          ‫} ;)‪7. fclose(fout‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(File) ‫اﻟﻣﻠﻔﺎت‬                                                                                                   ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                                                       : ‫ﺗوﺿﯾﺢ اﻟﺧطوات‬
                                                     ‫٣. ﺧطوة رﻗم )3( ﻓﺗﺣﻧﺎ ﻣﻠف ﺛﻧﺎﺋﻲ ﻟﻛﻲ ﻧﻘرئ ﻣن داﺧﻠﮫ‬
                 ‫( ﻣن اﻟﻣﻠف وﯾﺧزﻧﮭﺎ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬Array) ‫٤. ﺧطوة رﻗم )4( ﻗﻣﻧﺎ ﺑﻘراءة ﻋﻧﺎﺻر ﺑﺣﺟم اﻟﻣﺻﻔوﻓﺔ‬
                                             ‫٥. ﺧطوة رﻗم )٥و٦( وطﺑﻌﻧﺎ ﻣﺣﺗوﯾﺎت اﻟﻣﺻﻔوﻓﺔ ﺑﺷﻛل اﻟﺗﺎﻟﻲ‬




                                                             ‫ھذه اﻟﻌﻧﺎﺻر ﺳﺑق وان ﺧزﻧﺎھﺎ ﻓﻲ اﻟﻣﻠف ﻓﻲ ﻣﺛﺎل ﺳﺎﺑق‬




                             ‫ﻣﺛﺎل: ﺑرﻧﺎﻣﺞ ﯾطﺑﻊ أﺳﻣﺎء اﻟﻣﺳﺗﺧدﻣﯾن وﻛﻠﻣﺎت ﻣرورھم اﻟﺗﻲ ﺧزﻧت ﻓﻲ ﻣﻠف ﻛﺛﻧﺎﺋﻲ .؟‬


 c++                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬    c                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                     #include<stdio.h>
 #include<stdio.h>                                        1.struct password_User
 #include <fstream.h>                                     2.{char username[20];
 1.struct password_User                                   3. char password[20]; }userProtec on[6];
 2.{char username[20];                                    4.main()
 3. char password[20]; }userProtec on[6];                 5.{int i;
 4.main()                                                 6.FILE * fout;
 5.{int i;                                                7. fout=fopen("D:\\up.bin","rb");
 6.ifstream fout;                                         8. fread(& userProtection ,sizeof(userProtection) ,1,
 7. fout.open("D:\\up.bin",ios::binary);                  fout);
 8. fout .read((char *) & userProtection ,                9. fclose(fout);
 sizeof(userProtection));                                 10.for(i=0;i<6;i++){
 9. fout.close();                                         11. printf("\n User ID :\t");
 10.for(i=0;i<6;i++){                                     12. printf("%s", userProtection [i].username);
 11.cout << "\nUser ID :\t";                              13. printf("user Password: ");
 12.cout << userProtection [i]. username;                 14. printf("%s", userProtection [i]. password );}
 13.cout << "\tuser Password: ";                          }
 14.cout << userProtection [i]. password;}}


                                                                                                   :‫ﺗوﺿﯾﺢ اﻟﺧطوات‬
   ‫١. ﺧطوة رﻗم )٧( ﻗرﺋﻧﺎ ﻣن داﺧل اﻟﻣﻠف ﺑﯾﺎﻧﺎت ﺑﺣﺟم اﻟﺳﺟل وھو )٦( وﻛل واﺣد ﻓﻲ اﻟﺳﺟل ﻟﮫ اﺳم ﻣﺳﺗﺧدم‬
  ‫وﻛﻠﻣﺔ ﻣرور ﺳﯾﻘوم اﻟﻣﺗرﺟم ﺗﻠﻘﺎﺋﯾﺎ ﺑﺈﺳﻧﺎد ﻛل اﺳم ﻣﺳﺗﺧدم وﻛﻠﻣﺔ ﻣروره ﻣﺧزن داﺧل اﻟﻣﻠف اﻟﻰ ﻣوﻗﻊ ﻣن‬
                                                                                     ‫ﻣواﻗﻊ اﻟﺳﺟل‬

                                ‫٢. ﺧطوة رﻗم)٠١ إﻟﻰ ٤١( ﻗﻣﻧﺎ ﺑطﺑﺎﻋﺔ ﻣﺣﺗوﯾﺎت اﻟﺳﺟل اﻟﺗﻲ ﻣﻠﺋﻧﺎھﺎ ﻣن اﻟﻣﻠف‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                      C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                                      ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                       ‫وﺗﻛون ﺷﻛل ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ ھﻛذا ﺣﺳب ﻣﺎ ھو ﻣﺧزن ﻓﻲ اﻟﻣﻠف‬




                            ‫‪ ‬ﻟو أردﻧﺎ أن ﯾطﺑﻊ ﻣﺣﺗوﯾﺎت ﺳﺟل ﻟﻣﺳﺗﺧدﻣﯾن اﺛﻧﯾن ﻓﻘط ﻧﻐﯾر ﺧطوة رﻗم )٨( إﻟﻰ‬
 ‫++‪c‬‬                                       ‫‪ c‬اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬                                               ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
                            ‫‪erProtection‬‬
 ‫, ‪8. fout .read((char *) & userProtection‬‬                                        ‫,2, )]0[‪,sizeof(userProtection‬‬
                                                        ‫(‪8. fread(& userProtection ,sizeof‬‬
 ‫;))]0[‪2*sizeof(userProtection‬‬                          ‫;)‪fout‬‬


   ‫اﻟذي ﻓﻌﻠﻧﺎه ھو أﺧذﻧﺎ ﺣﺟم ﺳﺟل واﺣد وھو اﻟﺳﺟل اﻷول )]0[‪ (userProtection‬وﺿرﺑﻧﺎه ﻓﻲ اﺛﻧﺎن ﻟﻛﻲ ﻧﺣﺻل‬
                   ‫ﻋﻠﻰ ﺣﺟم ﺳﺟﻠﯾن ﻣن داﺧل اﻟﻣﻠف ﻓﻘط ﻟذاﻟك ﺳﯾطﺑﻊ ﻣﺣﺗوﯾﺎت ﺳﺟﻠﯾن ﻓﻘط ﻛﻣﺎ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬




                                                                                           ‫اﻟﺳﺟﻼت اﻟﺑﻘﯾﺔ ﺗﺑﻘﻰ ﻓﺎرﻏﺔ‬


   ‫وﻧﺳﺗطﯾﻊ ﺗﺣدﯾد ﻋدد اﻟﻣﻠﻔﺎت ﻣن اﻟرﻗم اﻟﻣﺿروب ﺑﺎﻟﺣﺟم ﻓﻠو أردﻧﺎ ﺛﻼث ﻣﻠﻔﺎت ﻧﺿرب ﻓﻲ ﺛﻼﺛﺔ ﻟﻛن ھذه اﻟطرﯾﻘﺔ‬
                                            ‫ﺗطﺑﻊ ﺑﻌدد اﻟﺳﺟﻼت اﻟﻣطﻠوب ﻟﻛن ﻣن اﻷول ﺛم اﻟﺛﺎﻧﻲ وﺑﺎﻟﺗﺳﻠﺳل‬


                                                  ‫٦.٨- داﻟﺔ )‪ (seek‬ﻟﻠﺗﺣرك داﺧل اﻟﻣﻠﻔﺎت :‬

  ‫ﻣﺎذا ﻟو أردﻧﺎ طﺑﺎﻋﺔ ﻓﻘط اﻟﺳﺟل اﻟﺛﺎﻟث أو ﻓﻘط اﻟﺳﺟل اﻟراﺑﻊ ھذا ﻣﺎ ﺗﻘدﻣﮫ داﻟﺔ )‪ (seek‬اﻟﺗﻲ ﺗﻣﻛﻧك ﻣن ﺗﺣرﯾك‬
 ‫اﻟﻣؤﺷر داﺧل اﻟﻣﻠف ﻷن اﻟﻣؤﺷر ﺑطﺑﯾﻌﺗﮫ ﯾﺑدأ ﻣن أول ﻣوﻗﻊ ﻟذاﻟك ﺳﯾطﺑﻊ اﻟﺳﺟﻼت ﺑﺎﻟﺗﺳﻠﺳل إﻣﺎ ھذه اﻟداﻟﺔ ﺗﻣﻛﻧك‬
                                                             ‫ﻣن ﺗﺣرﯾك ﻣﻛﺎن اﻟﻣؤﺷر وﺗﻛون ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
                                          ‫١.ﻓﻲ ﻟﻐﺔ )++‪ (c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﺗﺣرﯾك اﻟﻣؤﺷر داﺧل اﻟﻣﻠف‬
                                                                                    ‫ﺗﺣرﯾك داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ++‪c‬‬
        ‫;) ‪fin.seekg(offset, iostream family‬‬
                                                                           ‫)‪: (fin‬ھو اﺳم اﻟﻣﻠف داﺧل اﻟﺑرﻧﺎﻣﺞ‬
                                            ‫)‪ :(offset‬ﻣﻛﺎن ﺑدء اﻟﻘراءة إي ﻣن إي ﺑﺎﯾت ﺗﺑدأ اﻟﻘراءة أو اﻟﻛﺗﺎﺑﺔ‬
    ‫)‪ : (iostream family‬إذا ﻟم ﻧﺿﻊ إي رﻣز ﻣﻌﻧﺎه ﺳﯾﺑدأ )‪ (offset‬ﻣن ﺑداﯾﺔ اﻟﻣﻠف وإذا وﺿﻌﻧﺎ )‪(ios::end‬‬
                                                                         ‫ﻣﻌﻧﺎه ﺳﯾﺑدأ )‪ (offset‬ﻣن ﻧﮭﺎﯾﺔ اﻟﻣﻠف‬
                                                                ‫ﺟﻌل اﻟﻣؤﺷر ﯾﺑدأ ﻣن ﻧﮭﺎﯾﺔ اﻟﻣﻠف ﺑﺄزاﺣﺔ ﻣﻘدارھﺎ -٠٥‬
        ‫;)‪fin.seekg(-50,ios::end‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                       ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫اﻟﻣﻠﻔﺎت )‪(File‬‬                                                                                                     ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                ‫٢. ﻓﻲ ﻟﻐﺔ )‪ (c‬ﻧﺳﺗﺧدم اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ ﻟﺗﺣرﯾك اﻟﻣؤﺷر داﺧل اﻟﻣﻠف‬
                                                                                 ‫ﻛﺗﺎﺑﺔ اﻟﻰ داﺧل ﻣﻠف ﻓﻲ ﻟﻐﺔ ++‪c‬‬
        ‫;)‪fseek(fin,offset,whence‬‬
                                                                           ‫)‪: (fin‬ھو اﺳم اﻟﻣﻠف داﺧل اﻟﺑرﻧﺎﻣﺞ‬
                                            ‫)‪ :(offset‬ﻣﻛﺎن ﺑدء اﻟﻘراءة إي ﻣن إي ﺑﺎﯾت ﺗﺑدأ اﻟﻘراءة أو اﻟﻛﺗﺎﺑﺔ‬
   ‫)‪ : (whence‬إذا وﺿﻌﻧﺎ )0(ﻣﻌﻧﺎه ﺳﯾﺑدأ )‪ (offset‬ﻣن ﺑداﯾﺔ اﻟﻣﻠف وإذا وﺿﻌﻧﺎ )١( ﻣﻌﻧﺎه ﺳﯾﺑدأ )‪ (offset‬ﻣن‬
                                        ‫اﻟﻣوﻗﻊ اﻟﺣﺎﻟﻲ وإذا وﺿﻌﻧﺎ )2( ﻣﻌﻧﺎه ﺳﯾﺑدأ )‪ (offset‬ﻣن ﻧﮭﺎﯾﺔ اﻟﻣﻠف‬
                                                               ‫ﺟﻌل اﻟﻣؤﺷر ﯾﺑدأ ﻣن ﻧﮭﺎﯾﺔ اﻟﻣﻠف ﺑﺄزاﺣﺔ ﻣﻘدارھﺎ -٠٥‬
        ‫;)2,05-,‪int fseek(fin‬‬


                                                          ‫‪ ‬ﻓﻲ ﻣﺛﺎل اﻟﺳﺟﻼت ﻟو أردﻧﺎ طﺑﺎﻋﺔ اﻟﺳﺟل اﻟﺛﺎﻟث‬
 ‫ﺗﺣﻠﯾل: ﻧﺿرب ﺣﺟم واﺣد ﻣن اﻟﺳﺟﻼت ﻓﻲ اﺛﻧﺎن وﻧﺟﻌﻠﮭﺎ ﻗﯾﻣﺔ )‪ (offset‬ﺣﺗﻰ ﯾؤﺷر ﻓﻲ ﻧﮭﺎﯾﺔ اﻟﺳﺟل اﻟﺛﺎﻧﻲ وﻋﻧدﻣﺎ‬
  ‫ﯾﺑدأ اﻟﻘراءة ﯾﺑدؤھﺎ ﻣن اﻟﺳﺟل اﻟﺛﺎﻟث. وﻧﺟﻌل اﻟﺗﺣرك ﻣن اﻟﺑداﯾﺔ وﻓﻲ داﻟﺔ اﻟﻘراءة ﻧﺟﻌﻠﮫ ﯾﻘرأ ﺳﺟل واﺣد وھو اﻟﺛﺎﻟث‬
                            ‫ﻧﻐﯾر اﻟﺧطوة رﻗم )٨( ﻓﻲ اﻟﻣﺛﺎل إﻟﻰ ﺧطوﺗﯾن ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ ﻟﻛﻲ ﯾطﺑﻊ ﺳﺟل اﻟﺛﺎﻟث ﻓﻘط‬
 ‫++‪c‬‬                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫;))]0[‪fout.seekg(2*sizeof(userProtec on‬‬                 ‫;) 0 ,)]0[‪fseek(fout,2*sizeof(userProtec on‬‬
 ‫,‪fout .read((char *) & userProtection‬‬                   ‫,1, )]0[‪fread(& userProtection ,sizeof(userProtec on‬‬
 ‫;))]0[‪sizeof(userProtec on‬‬                              ‫;)‪fout‬‬




                 ‫ﻧﺟﻌﻠﮫ ﯾﻘرأ ﺳﺟل‬          ‫ﻧﺿرب ﺣﺟم واﺣد ﻣن اﻟﺳﺟﻼت‬                             ‫وﻧﺟﻌل اﻟﺗﺣرك ﻣن اﻟﺑداﯾﺔ‬
                                        ‫ﻓﻲ اﺛﻧﺎن وﻧﺟﻌﻠﮭﺎ ﻗﯾﻣﺔ )‪(offset‬‬
                                        ‫ﺣﺗﻰ ﯾؤﺷر ﻓﻲ ﻧﮭﺎﯾﺔ اﻟﻣﻠف اﻟﺛﺎﻧﻲ‬



                                                         ‫‪ ‬ﻓﻲ ﻣﺛﺎل اﻟﺳﺟﻼت ﻟو أردﻧﺎ طﺑﺎﻋﺔ اﻟﺳﺟل اﻟراﺑﻊ‬
‫ﺗﺣﻠﯾل: ﻧﺿرب ﺣﺟم واﺣد ﻣن اﻟﺳﺟﻼت ﻓﻲ ﺛﻼﺛﺔ وﻧﺟﻌﻠﮭﺎ ﻗﯾﻣﺔ )‪ (offset‬ﺣﺗﻰ ﯾؤﺷر ﻓﻲ ﻧﮭﺎﯾﺔ اﻟﺳﺟل اﻟﺛﺎﻟث وﻋﻧدﻣﺎ‬
             ‫ﯾﺑدأ اﻟﻘراءة ﯾﺑدؤھﺎ ﻣن اﻟﺳﺟل اﻟراﺑﻊ وﻧﺟﻌل اﻟﺗﺣرك ﻣن اﻟﺑداﯾﺔ وﻓﻲ داﻟﺔ اﻟﻘراءة ﻧﺟﻌﻠﮫ ﯾﻘرأ ﺳﺟل واﺣد‬
                           ‫ﻧﻐﯾر اﻟﺧطوة رﻗم )٨( ﻓﻲ اﻟﻣﺛﺎل إﻟﻰ ﺧطوﺗﯾن ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ ﻟﻛﻲ ﯾطﺑﻊ ﺳﺟل اﻟﺛﺎﻟث ﻓﻘط‬
 ‫++‪c‬‬                                      ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   ‫‪c‬‬                                                    ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 ‫;))]0[‪fout.seekg(3*sizeof(userProtec on‬‬                  ‫;) 0 ,)]0[‪fseek(fout,3*sizeof(userProtec on‬‬
 ‫,‪fout .read((char *) & userProtection‬‬                   ‫,1, )]0[‪fread(& userProtection ,sizeof(userProtec on‬‬
 ‫;))]0[‪sizeof(userProtec on‬‬                              ‫;)‪fout‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                      ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
(File) ‫اﻟﻣﻠﻔﺎت‬                                                                                                  ‫اﻟﻔﺻل اﻟﺛﺎﻣن‬




                                                          ‫وھذا ﻛود اﻟﺑرﻧﺎﻣﺞ ﻛﺎﻣل ﻟطﺑﺎﻋﺔ ﻣﺣﺗوﯾﺎت ﺳﺟل اﻟراﺑﻊ ﻓﻘط‬
 c++                                     ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬      c                                             ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 #include<iostream.h>                                     #include<stdio.h>
 #include<stdio.h>                                        1.struct password_User
 #include <fstream.h>                                     2.{char username[20];
 1.struct password_User                                   3. char password[20]; }userProtec on[6];
 2.{char username[20];                                    4.main()
 3. char password[20]; }userProtec on[6];                 5.{FILE * fout;
 4.main()                                                 6. fout=fopen("D:\\up.bin","rb");
 5.{ifstream fout;                                        7.fseek(fout,3*sizeof(userProtec on[0]), 0 );
 6. fout.open("D:\\up.bin",ios::binary);                  8.fread(& userProtection ,sizeof(userProtec on[0]) ,1,
 7. fout.seekg(3*sizeof(userProtec on[0]));               fout);
 8.fout .read((char *) & userProtection                   9. fclose(fout);
 ,sizeof(userProtec on[0]));                              10. prin ("\n User ID :\t");
 9. fout.close();                                         11. prin ("%s", userProtec on [0].username);
 10.cout<< "User ID :";                                   12. prin ("user Password: ");
 11.cout << userProtec on [0]. username;                  13. prin ("%s", userProtec on [0]. password );
 12.cout<< "\tuser Password: ";                           }
 13.cout << userProtec on [0]. password;}


                  ‫ﺑﻣﺎ اﻧﮫ ﺳﺟل واﺣد ﻓﻠﯾس ﺑﺣﺎﺟﺔ إﻟﻰ ﻋداد ﯾﻌد ﻟﻠﺳﺗﺔ ﻓﻘط ﻧطﺑﻊ اﻟﻣوﻗﻊ اﻷول اﻟذي ﻓﯾﮫ اﻟﻣﺳﺗﺧدم ھﻛذا‬




                                      ‫ ﻓﻲ ﻣﺛﺎل اﻟﺳﺟﻼت ﻟو أردﻧﺎ طﺑﺎﻋﺔ اﻟﺳﺟل اﻟراﺑﻊ واﻟﺧﺎﻣس واﻟﺳﺎدس‬
 ‫( ﺣﺗﻰ ﯾؤﺷر ﻓﻲ ﻧﮭﺎﯾﺔ اﻟﺳﺟل اﻟﺛﺎﻟث وﻧﺟﻌل‬offset) ‫ﺗﺣﻠﯾل: ﻧﺿرب ﺣﺟم واﺣد ﻣن اﻟﺳﺟﻼت ﻓﻲ ﺛﻼﺛﺔ وﻧﺟﻌﻠﮭﺎ ﻗﯾﻣﺔ‬
         ‫اﻟﺗﺣرك ﻣن اﻟﺑداﯾﺔ وﻓﻲ داﻟﺔ اﻟﻘراءة ﻧﺟﻌﻠﮫ ﯾﻘرأ ﺛﻼث ﺳﺟﻼت ﻟﻛﻲ ﯾﻘرئ اﻟﺳﺟل اﻟراﺑﻊ واﻟﺧﺎﻣس واﻟﺳﺎدس‬
                           ‫ﻧﻐﯾر اﻟﺧطوة رﻗم )٨( ﻓﻲ اﻟﻣﺛﺎل إﻟﻰ ﺧطوﺗﯾن ﺑﺎﻟﺷﻛل اﻟﺗﺎﻟﻲ ﻟﻛﻲ ﯾطﺑﻊ ﺳﺟل اﻟﺛﺎﻟث ﻓﻘط‬
 c++                                       ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬   c                                                ‫اﻟﺑرﻣﺟﺔ ﺑﻠﻐﺔ‬
 fout.seekg(3*sizeof(userProtec on[0]));                   fseek(fout,3*sizeof(userProtec on[0]), 0 );
 fout .read((char *) & userProtection,                    fread(& userProtection ,sizeof(userProtec on[0]) ,3,
 3*sizeof(userProtec on[0]));                             fout);

                  ‫وﻧﻐﯾر ﺷرط ﺗوﻗف اﻟﻌداد ﻓﻲ ﺧطوة رﻗم )٠١( إﻟﻰ اﺻﻔر ﻣن ﺛﻼﺛﺔ ﻷﻧﻧﺎ ﺳﻧطﺑﻊ ﺛﻼث ﺳﺟﻼت ﻓﻘط‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                    C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                    ‫اﻟﻣﻠﺣﻘﺎت‬




                                              ‫اﻟﻣﻠﺣﻘﺎت‬

 ‫ھذه اﻟﻣﻠﺣﻘﺎت ھﻲ اﻻﻣﺛﻠﺔ اﻟﻣرﻓﻘﺔ ﻟﻛﺗﺎب ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ﻟﻐﺔ )++‪ (C,C‬ﯾﺣﺗوي ﻋﻠﻰ‬
 ‫ﻋدد ﻛﺑﯾر ﻣن اﻻﻣﺛﻠﺔ اﻟﻣﺣﻠوﻟﺔ ﻛﺗوﺿﯾﺢ ﻟﺷروﺣﺎت ﻛل ﻓﺻل ﻣن اﻓﺻل اﻟﻛﺗﺎب ﺣﺗﻰ ﯾﻛون‬
                                    ‫اﻟﻘﺎرئ ﻋﻠﻰ ﺗواﺻل ﺑﯾن اﻟﺷرح واﻟﺗﻧﻔﯾذ.....؟‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                   ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                     ‫اﻟﻣﻠﺣﻘﺎت‬




                       ‫١:اﻛﺗب ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻻﺷﻛﺎل اﻟﺗﺎﻟﯾﺔ‬
A)
#include<iostream.h>
main()
{
int z,x;
for(z=1;z<=5;z++){
cout<<"*\n" ;
for(x=0;x<=z-1;x++)
cout<<" " ;
}}
B)

#include<iostream.h>
main()
{
int z,x;
for(z=1;z<=5;z++){
for(x=z;x<=5;x++)
cout<<" " ;
cout<<"*\n" ;
}}

c)

#include<iostream.h>
main()
{
int I,j,k;
for(i=1;i<=7;i+=2){
for(k=i;k<7;k+=2)
cout<<" " ;
for(j=i;j>0;j--)
cout<<"*" ;
cout<<"\n" ;}}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                    C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                          ‫اﻟﻣﻠﺣﻘﺎت‬




                                                             ‫٢:اﻛﺗب ﺑرﻧﺎﻣﺞ ﻟﺗﻘرﯾب أي ﻋدد ﺗدﺧﻠﮫ‬
#include<iostream.h>
main()
{
int i,k;
float y,m;
cin>>y ;
i=y;// ١ ‫ھﻧﺎ ﺳﺎوﯾﻧﺎ ﻛﺳر ﺑﺻﺣﯾﺢ ﺑﯾﻘﻰ ﻓﻘد اﻟﺛﺎﺑت ﻣﺛﻼ ٧.١ ﯾﺻﺑﺢ‬
k=i+1;
m=i+0.5;
if(y>=m)
cout<<"near to= "<< k ;
else
cout<<"near to= "<<i;
}

                                                                   ‫٣:ﺑرﻧﺎﻣﺞ ﻻﯾﺟﺎد ﻣﻔﻛوك اﻻﻋداد‬
#include<stdio.h>
main()
{
int x,n,f;
scanf("%d",&n);
f=1;
if(n>=12)
printf("no factoral");
else
for(x=1;x<=n;x++)
f=f*x;
printf("factoral=%d",f);
}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                         C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                     ‫اﻟﻣﻠﺣﻘﺎت‬




                                               ‫٤:ﺑرﻧﺎﻣﺞ ﻻﯾﺟﺎد ﻣﺟﻣوع أي ﻋدد ﻣﻊ اﻻﻋداد اﻟﺗﻲ ﻓوﻗﮫ ﺣﺗﻰ اﻟﻣﺋﺔ‬
‫>‪#include<stdio.h‬‬
‫)(‪main‬‬
‫{‬
‫;‪int x,sum,n‬‬
‫;0=‪sum‬‬
‫;)‪scanf("%d",&n‬‬
‫)++‪for(x=n;x<=100;x‬‬
‫;‪sum=sum+x‬‬
‫;)‪printf("he sum=%d$",sum‬‬
‫}‬



                                    ‫٥:اﻛﺗب ﺑرﻧﺎﻣﺞ ﻟﺣﺳﺎب ﻋدد اﻻرﻗﺎم اﻟﻣدﺧﻠﺔ اﻟﯾﮫ ﺑﺣﯾث اذا ادﺧﻠﻧﺎ ٠٠١ ﯾﻧﺗﺞ ٣‬
‫>‪#include<iostream.h‬‬
‫)(‪main‬‬
‫{‬
‫;‪int i,k,m‬‬
‫;‪cin>>k‬‬
‫;1=‪m‬‬
‫)++‪for(i=1;i<=4;i‬‬
‫;01*‪{m=m‬‬
‫)‪if(k<m‬‬
‫{‬
‫;‪Cout<<"number of bit=<<i‬‬
‫}};‪break‬‬
‫}‬
   ‫٦:ﺑرﻧﺎﻣﺞ ﻻﺧرج رواﺗب ﻋﻣﺎل ﺑﺣﯾت اذا ﻋﻣل ٠٥١ﺳﺎﻋﺔ ﯾﺎﺧذ ﺛﻼﺛﺔ دوﻻرات وﻋﻠﻰ ﻛل ﺳﺎﻋﺔ ﻋﻣل اﺿﺎﻓﯾﺔ ﯾﺎﺧذ دوﻻران‬
‫>‪#include<iostream.h‬‬
‫)(‪main‬‬
‫;‪{ int i,j,k‬‬
‫;3=‪j‬‬
‫; "‪cout<<"enter the hower\n‬‬
‫; ‪cin>>k‬‬
‫)++‪for(i=151;i<300;i‬‬
‫)051=<‪{ if(k‬‬
‫; "$3 =‪{cout<<"he cost‬‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                    ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                            ‫اﻟﻣﻠﺣﻘﺎت‬




break;}
j=j+2;
if(k==i)
cout<<"he cost="<<j;
}}




                        (‫7:ﺑرﻧﺎﻣﺞ ﻻﺟراء ﻋﻣﻠﯾﺎت رﯾﺎﺿﯾﺔ ﻟﻌددﯾن ﺑﺻﯾﻐﺔ ﯾﻔﮭﻣﮭﺎ اﻟﻣﺳﺗﺧدم)ﺑﺻﯾﻐﺔ اﻟﻘواﺋم‬
#include<iostream.h>
#include<stdlib.h>//) exit‫ﺿﻣﻧﺎ ھذه اﻟﻣﻛﺗﺑﺔ ﻻﻧﻧﺎ ﻧﺳﺗﺧدم اﻟداﻟﺔ ا‬
main()
{
int a,b ,x,z;
char r=00;
float f;
m:
cout<<"This program make arthmetic operation between two mumber
press"<<"\n";
cout<<"1(sum),2(sub),3(mult),4(divide),5(exit)"<<"\n";
cin>>x;
for(;;)
switch(x) {
case 1:cout<<"enter first number"<<" press(00)to return"<<"\n";
cin>>a;       if(a==r)goto m;
cout<<"enter second number"<<"\n";
cin>>b;
z=a+b;
cout<<"sum="<<z<<"\n";
break;
case 2:cout<<"enter first number"<<" press(00)to return"<<"\n";



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                           C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                    ‫اﻟﻣﻠﺣﻘﺎت‬




cin>>a;         if(a==r)goto m;
cout<<"enter second number"<<"\n";
cin>>b;
z=a-b;
cout<<"sub="<<z<<"\n";
break;
case 3:cout<<"enter first number"<<" press(00)to return"<<"\n";
cin>>a; if(a==r)goto m;
cout<<"enter second number"<<"\n";
cin>>b;
z=a*b;
cout<<"mult="<<z<<"\n";
break;
case 4:cout<<"enter first number"<<" press(00)to return"<<"\n";
cin>>a; if(a==r)goto m;
cout<<"enter second number"<<"\n";
cin>>b;
f=a/b;
cout<<"divd="<<f<<"\n";
break;
case 5: exit(1);
default:cout<<"error correct you chose"<<"\n"; goto m;

}}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                   C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                    ‫اﻟﻣﻠﺣﻘﺎت‬




                                                ‫8:ﺗﺄﻣل ﻧﺎﺗﺞ اﻟﺑرﻧﺎﻣﺞ اﻻﺗﻲ‬
#include<stdio.h>
main()
{
int x,y,z;
x=y=z=5;
x*=y+=z-=1;
printf("z=%d\ny=%d\nx=%d\n",z,y,x);
}

                                      ‫ ﻓﻲ دوارة ﻻﻧﮭﺎﺋﯾﺔ‬do-while ‫٩:ادﺧﺎل‬

#include<stdio.h>
main()
{
int x ,m,n;
x=0;
do{
scanf("%d%d",&m,&n); if(m>n){
m=m+n;
printf("m=%d\n",m ); }
else
break; }
while(1);}
                                        ‫ ﻓﻲ دوارة ﻻﻧﮭﺎﺋﯾﺔ‬while ‫٠١:ادﺧﺎل‬
#include<stdio.h>
main()
{
int x ,m,n;
x=0;
while(1){
scanf("%d%d",&m,&n); if(m>n){
printf("m=%d\n",m );}
else
break; }}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                   C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                            ‫اﻟﻣﻠﺣﻘﺎت‬




                                                     ‫١١:ﻟﻣﻌرﻓﺔ ھل اﻟﻌدد اﻟذي ادﺧﻠﺗﮫ ﻋدد اوﻟﻲ ام ﻻ‬
#include<iostream.h>
main()
{
int i,m,booleanx;
booleanx=0;
cin>>m;
for(i=2;i<m;i++)
if(m%i==0)
booleanx=1;
if (booleanx==1)
cout<<"is no prime" ;
else
cout<<"is prime" ;
}
                                    ‫21:اﻛﺗب ﺑرﻧﺎﻣﺞ ﻟﻘﺳﻣﺔ ﻋددﯾن ﺑدون اﺳﺗﺧدام اﻟﻘﺳﻣﺔ وﺑﺎﻗﻲ اﻟﻘﺳﻣﺔ‬

#include<iostream.h>
main()
{
int a,b,i;
cin>>a>>b;
if(a>=b){
for(i=1;i<20;i++){
a=a-b;
if(a<b){
cout<<"divide=="<<i<<"ncarry"<<a;
break;}
}}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                           C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                          ‫اﻟﻣﻠﺣﻘﺎت‬




                                                 ‫٣١:ﺑرﻧﺎﻣﺞ ﯾﻧﺗﺞ اﻟﻣﻌﺎدﻟﺔ اﻟﺗﺎﻟﯾﺔ‬




#include<stdio.h>
main()
{
int a,b,y,x;
cin>>a>>b ;
if(a==0)
x=1;
if(a==1)
x=0;
y=(a||b)&&(x||b);
cout<<"y="<<y; }



                        (١٢٣٤٥٦٧٦٥٤٣٢١) ‫٤١:ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟﻣﺗﺳﻠﺳﻠﺔ اﻻﺗﯾﺔ‬

#include <iostream.h>
main()
{
int i,j;
for(i=1;i<7;i++)
cout<<i;
for(j=i;j>0;j--)
cout<<j; }
                                          ‫٥١:ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟداﻟﺔ اﻻﺗﯾﺔ‬


#include <iostream.h>
main()
{
int i;
float y,x,s,f,m,n,d;



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                         C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                      ‫اﻟﻣﻠﺣﻘﺎت‬




f=y=1;
m=-1;
n=0;
cout<<"enter the power of";
cin>>d;
cout<<"enter the number";
cin>>x;
for(i=1;i<=d;i++){
f=f*i;
m=m*x;
n=-m; // inverse sgnal inevery loop
s=n/f;
y=y+s;}
cout<<y;}

                     ‫٦١:ﺑرﻧﺎﻣﺞ ﻟﻣﻌرﻓﺔ ھل اﻟﻌدد اﻟذي ادﺧﻠﺗﮫ زوﺟﻲ ام ﻓردي دون اﺳﺗﺧدام اﻟﻘﺳﻣﺔ وﺑﺎﻗﯾﮭﺎ‬
#include<iostream.h>
main()
{
int i,j,a;
cin>>a;
for(i=1;i<30 ;i=i+2) {
if(a==i)
cout<<a<<" is odd";}
for(j=0;j<30 ;j=j+2){
if(a==j)
cout<<a<<" is even ";
}}

                                            (decimal) ‫(اﻟﻰ ﺻﯾﻐﺔ‬octal) ‫٧١:ﺑرﻧﺎﻣﺞ ﯾﺣول ﻣن ﺻﯾﻐﺔ‬
#include<iostream.h>
main()
{
int n,i,b,m;
cout<<"enter number of bits"<<"\n";
cin>>n;
cout<<"note:enter octal number from right bite after bite"<<"\n";


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                     C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                       ‫اﻟﻣﻠﺣﻘﺎت‬




‫;0=‪int f=1,sum‬‬
‫{) ++‪for(i=0;i<n;i‬‬
‫;‪cin>>b‬‬
‫;‪m=f*b‬‬
‫;8*‪f=f‬‬
‫};‪sum=sum+m‬‬
‫};‪cout<<sum‬‬

‫*اﻟﺑرﻧﺎﻣﺞ ﻣﺻﻣم ﺑطرﯾﻘﺔ ﺑداﺋﯾﺔ ﺳوف ﯾﺗم ﺗﺻﻣﯾﻣﮫ ﺑطرﯾﻘﺔ اطور ﺑﻧﮭﺎﯾﺔ اﻟﻛﺗﺎب‬

                                      ‫٨١:ﺑرﻧﺎﻣﺞ ﯾدﺧل ﻋددﯾن وﯾﺑﯾن اﯾﮭﻣﺎ ا ﻻﺻﻐر دون اﺳﺗﺧدام)==;<;>(‬

‫>‪#include<iostream.h‬‬
‫)(‪main‬‬
‫{‬
‫;‪int a,b,m‬‬
‫;‪cin>>a>>b‬‬
‫;‪m=a/b‬‬
‫)0==‪if(m‬‬
‫;"‪cout<<a<<" is minimum‬‬
‫‪else‬‬
‫;"‪cout<<b<<" is minumum‬‬
‫}‬

                                                           ‫٩١:اطﺑﻊ اﻟﺷﻛل اﻟﺗﺎﻟﻲ دون اﺳﺗﺧدام اﻟﻣﺻﻔوﻓﺔ‬

‫>‪#include <iostream.h‬‬
‫)(‪main‬‬
‫{‬
‫;‪int i,j,k,m,n,o,p‬‬
‫{)--‪for(i=3;i>0;i‬‬
‫;""<<‪cout‬‬
‫;" "<<‪for(j=i;j>0;j--) cout‬‬
‫)++‪for(k=i*2;k<=6;k‬‬
‫;"*" <<‪cout‬‬
‫;"‪cout<<"\n‬‬
‫}‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                      ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                          ‫اﻟﻣﻠﺣﻘﺎت‬




for(m=7;m>0;m=m-2){
cout<<"";
for(n=m;n>0;n--)
cout<<"*";
cout<<"\n";
for(o=m;o<=7;o=o+2)
cout<<" ";}}



                                        (A,b,c ) ‫(ﻟﻼﺣرف اﻻﺗﯾﺔ‬ascii code ) ‫02:ﻟﻣﻌرﻓﺔ‬
#include<iostream.h>
#include <stdio.h>
main()
{
printf("the number %c is the character %d in ascii code.\n",'a','a');
printf("the number%c is the character %d in ascii code.\n",'b','b');
printf("the number%c is the character %d in ascii code.\n",'c','c');
}




                                                    ‫( ﻟﺣﻣﯾﻊ اﻟﻌﻧﺎﺻر ﻧﻛﺗب‬ascii)‫وﻟﻣﻌرﻓﺔ‬
#include <stdio.h>
main()
{
int i,j;
for(i=0;i<=255;i++)
printf("%d:%c\n",i,i);
}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                         C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                    ‫اﻟﻣﻠﺣﻘﺎت‬




                       ‫١٢:اﻗﻠب ﻣﺻﻔوﻓﺔ ٠٩ درﺟﺔ ﺑﺎﺗﺟﺎه ﻋﻘرب اﻟﺳﺎﻋﺔ‬
#include<iostream.h>
main()
{
int i,j;
int a[3][3];
for(i=0;i<3;i++)
for(j=0;j<3;j++)
cin>>a[i][j];
for(j=0;j<3;j++){
cout<<"\n";
for(i=2;i>=0;i--)
cout<<a[i][j]<<"\t";
}}
                                                .‫اﻗﻠﺑﮭﺎ ٠٨١ درﺟﺔ‬
#include<iostream.h>
main()
{
int i,j;
int a[3][3];
for(i=0;i<3;i++)
for(j=0;j<3;j++)
cin>>a[i][j];
for(i=2;i>=0;i--){
cout<<"\n";
for(j=2;j>=0;j--)
cout<<a[i][j]<<"\t";
}}
                                                .‫اﻗﻠﺑﮭﺎ 072 درﺟﺔ‬
#include<iostream.h>
main()
{
int i,j;
int a[3][3];
for(i=0;i<3;i++)
for(j=0;j<3;j++)
cin>>a[i][j];


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                   C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                         ‫اﻟﻣﻠﺣﻘﺎت‬




for(j=2;j>=0;j--){
cout<<"\n";
for(i=0;i<3;i++)
cout<<a[i][j]<<"\t";
}}
                                   ‫٢٢:ﺣذف ﻋﻧﺻر ﻣن ﻣﺻﻔوﻓﺔ ذات ﺑﻌدﯾن واﺑﻘﺎء ﻣﻛﺎﻧﮫ ﻓﺎرغ‬
#include<iostream.h>
main()
{
int i,j;
int a[3][3];
for(i=0;i<3;i++)
for(j=0;j<3;j++)
cin>>a[i][j];
for(i=0;i<3;i++){
cout<<"\n";
for(j=0;j<3;j++)
if((i==0)&&(j==0))
a[i][j]=0; {
cout<<""<<"\t";}
else
cout<<a[i][j]<<"\t";
}}
                                          ‫٣٢:ﺗرﺗﯾب ﻋﻧﺎﺻر ﻣﺻﻔوﻓﺔ ذات ﺑﻌد واﺣد ﺗﺻﺎﻋدﯾﺎ‬

#include<iostream.h>
int main()
{int array[5]={50,32,93,2,74};
int sure=0;
int x=0;
cout<<"Here is the Array befor sorted\n" ;
for (int j=0;j<5;j++)
cout<<array[j];
for (int i=0;i<5-1;i++) {
sure=0;
for (int j=i; j<5;j++) {
if (array[j] <array[i]){


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                        C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                  ‫اﻟﻣﻠﺣﻘﺎت‬




 x=array[j];
 array[j]=array[i];
 array[i]=x;
 sure=1;}}
 if (sure ==0) break;}
 cout<<"Here is the Array after sorted\n";
 for (i=0;i<5;i++)
 cout<<array[i]<<"\n";
 }
      ‫٤٢.ﺳﺟل ﻓﯾﺔ ﻋﺷرون طﺎﻟب ﻟﻛل طﺎﻟب ﻟﮫ اﺳم وﻋﻣر وﻋﻧوان وﻋﺷرة درﺟﺎت اطﺑﻊ اﺳﻣﺎء اﻟطﻼب اﻟﻧﺎﺟﺣون‬
                                                                                      ‫وﻣﻌدﻻﺗﮭم‬
#include<iostream.h>
#include<stdio.h>
 struct student
{ char name[10];
 int age;
 int id;
 int degres;
 }st[20];
main()
{
int i,j,sum,avg;
sum=0;
for(i=0;i<20;i++)
{cout<<"please enter the student information\n";
 cout<<"enter his name\n";
 gets(st[i].name );
  cout<<"enter his age\n";
 cin>>st[i].age;
 cout<<"enter his ID adress\n";
  cin>>st[i].id;
  cout<<"enter his degress\n";
  for(j=0;j<10;j++)
{cin>>st[i].degres;
sum+= st[i].degres ;}
avg=sum/10;
sum=0;



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                 C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                 ‫اﻟﻣﻠﺣﻘﺎت‬




  st[i].degres=avg;}
  for(i=0;i<20;i++)
if (st[i].degres>=50)    {
{cout<<"this student is succes..his name is "<<st[i].name<<endl;
cout<<"his aveg is "<<st[i].degres<<endl;}
else
{cout<<"this student is fail..his name is "<<st[i].name<<endl;
cout<<"his aveg is "<<st[i].degres<<endl;} }}
                                 ‫٥٢. ﺑرﻧﺎﻣﺞ ﻟوﺿﻊ ﻓﺎﺻﻠﺔ ﻋﺷرﯾﺔ ﺑﯾن ﻛل ﺛﻼﺛﺔ ارﻗﺎم ﻟﺗﺳﮭﯾل اﻟﻘراءة‬
#include<iostream.h>
#include<ctype.h>
#include<string.h>
int main()
{char stack[100],b[100]; //a[100] represent matraix for enter
int i,len,count_semicol,b_count,count_return_v,semicoll_number, k;
b_count=count_return_v=count_semicol=semicoll_number=0;
cout<<"enter your number here: ";
cin.getline(stack,100);
len=strlen(stack);
for(i=len-1;i>=0;i--)
 {
if ((count_semicol%3==0)&&(i!=len-1)) //put space
 {b[b_count]=',';
 ++b_count;
  semicoll_number=semicoll_number+1 ;
 }
 b[b_count]=stack[i];
++b_count;
count_semicol=count_semicol+1;}
 --b_count; //return pointer to last value
 for(i=b_count;i>=0;i--)
 {stack[count_return_v]=b[i];
cout<<stack[count_return_v];
  ++count_return_v;} }




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                      ‫اﻟﻣﻠﺣﻘﺎت‬




  ‫٦٢:ﻣﺻﻔوﻓﺔ ﻣرﺑﻌﺔ اﺟﻣﻊ اﻟﻌﻧﺎﺻر ﻓوق اﻟﻘطر اﻟرﺋﯾﺳﻲ وﺟﻣﻊ اﻟﻌﻧﺎﺻر ﺗﺣﺗﮫ وﺟﻣﻊ اﻟﻌﻧﺎﺻر ﻓوق اﻟﻘطر اﻟﺛﺎﻧوي‬
                                                                                             ‫وﺗﺣﺗﮫ‬
#include<iostream.h>
main()
{
int i,j,sum,sum1,sum2,sum3;
sum=sum1=sum2=sum3=0;
int a[3][3];
for(i=0;i<3;i++)
for(j=0;j<3;j++)
cin>>a[i][j];
for(i=0;i<3;i++)
for(j=0;j<3;j++) {
if(i<j)
sum+=a[i][j];
if(i>j)
sum1+=a[i][j];
if((i+j)<2)
sum2+=a[i][j];
if((i+j)>2)
sum3+=a[i][j];

}
cout<<"\n sum above secondary diagonal= n"<<sum2;
cout<<"\n sum above main diagonal= "<<sum;
cout<<"\n sum under main diagonal= "<<sum1;
cout<<"\n sum under secondary diagonal= "<<sum3;
}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                     C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                 ‫اﻟﻣﻠﺣﻘﺎت‬




                  ‫72:ﻣﺻﻔوﻓﺔ ﻣﻛوﻧﺔ ﻣن ﺧﻣس ﻋﻧﺎﺻر اﺟﻣﻌﮭﺎ واﺣﺳب اﻟﻣﻌدل واطﺑﻊ اﻟﻣﺻﻔوﻓﺔ ﺑﺎﻟﻣﻘﻠوب‬
#include<iostream.h>
main()
{
int i ,sum,avg;
int a[5];
sum=0;
cout<<"enter the matrixs\n";
for(i=0;i<5;i++)
cin>>a[i];
for(i=0;i<5;i++)
sum+=a[i];
avg=sum/5;
cout<<"sum="<< sum <<"navg="<<avg<<endl;
cout<<"the matrixs invers is\n";
for(i=4;i>=0;i--)
cout<<a[i];
}
                                                                ٣٠‫اطﺑﻊ اﻻﺣرف اﻟزوﺟﯾﺔ ﺑﯾن ٠ و‬
 #include<iostream.h>
 main()
 {
 int i,j;
 for(i=2;i<30;i+=2)
 cout<<i<<"\t";
 }
                                                                 ٣٠‫اطﺑﻊ اﻻﺣرف اﻟﻔردﯾﺔ ﺑﯾن ٠ و‬
 #include<iostream.h>
 main()
 {
 int i,j;
 for(i=١;i<30;i+=2)
 cout<<i<<"\t";}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                          ‫اﻟﻣﻠﺣﻘﺎت‬




                                                        (٣*٢) *(٢*٤) ‫82:ﺿرب ﻣﺻﻔوﻓﺗﯾن‬
 #include<iostream.h>
 main()
 {
 int i,j,k;
 int a[3][2];
 int b[2][4];
 int c[3][4]={0}; //put zero in every location to sum with other value
 cout<<"enter first matrixs\n" ;
 for(i=0;i<3;i++)
 for(j=0;j<2;j++)
 cin>>a[i][j];
cout<<"enter second matrixs\n" ;
 for(i=0;i<2;i++)
 for(j=0;j<4;j++)
 cin>>b[i][j];
for(i=0;i<3;i++){
 cout<<"\n";
 for(j=0;j<4;j++){
 for(k=0;k<2;k++)
 c[i][j]+=a[i][k]*b[k][j];
 cout<<c[i][j]<<"\t" ;}}}
                                                    (٢) ‫92:ﺿرب ﻣﺻﻔوﻓﺔ ﻓﻲ رﻗم ﺛﺎﺑت ﻣﺛﻼ‬
#include<iostream.h>
 main()
 {
 int i,j;
 int a[3][3];
 cout<<"enter matrixs\n" ;
 for(i=0;i<3;i++)
 for(j=0;j<3;j++)
cin>>a[i][j];
 for(i=0;i<3;i++){
 cout<<"\n";
 for(j=0;j<3;j++){
 a[i][j]=2*a[i][j];
 cout<<a[i][j]<<"\t" ;}}}



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                         C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                            ‫اﻟﻣﻠﺣﻘﺎت‬




                                       ‫03: ﺟﻣﻊ ﻣﺻﻔوﻓﺗﯾن‬
#include<iostream.h>
 main()
 {
 int i,j;
 int a[3][3];
 int b[3][3];
 int c[3][3];
 cout<<"enter first matrixs"<<"\n";
 for(i=0;i<3;i++)
 for(j=0;j<3;j++)
 cin>>a[i][j];
 cout<<"enter second matrixs"<<"\n";
 for(i=0;i<3;i++)
 for(j=0;j<3;j++)
 cin>>b[i][j];
 for(i=0;i<3;i++){
 cout<<"\n";
 for(j=0;j<3;j++){
c[i][j]=a[i][j]+b[i][j];
cout<<c[i][j]<<"\t";}
 }}
                                       ‫١٣:طرح ﻣﺻﻔوﻓﺗﯾن‬

#include<iostream.h>
 main()
 {
 int i,j;
 int a[3][3];
 int b[3][3];
 int c[3][3];
 cout<<"enter first matrixs"<<"\n";
 for(i=0;i<3;i++)
 for(j=0;j<3;j++)
 cin>>a[i][j];
 cout<<"enter second matrixs"<<"\n";



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                           C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                   ‫اﻟﻣﻠﺣﻘﺎت‬




 for(i=0;i<3;i++)
 for(j=0;j<3;j++)
 cin>>b[i][j];
 for(i=0;i<3;i++){
 cout<<"\n";
 for(j=0;j<3;j++){
c[i][j]=a[i][j]-b[i][j];
cout<<c[i][j]<<"\t";}
 }}
                                ‫23:اﺳﺗﺧراج اﻛﺑر ﻋدد واﺻﻐر ﻋدد ﻟﻣﺻﻔوﻓﺔ ذات ﺑﻌدﯾن‬
#include<iostream.h>
 main()
 {
 int i,j,max,min;
 int a[3][3];
 cout<<"enter matrixs"<<"\n";
 for(i=0;i<3;i++)
 for(j=0;j<3;j++)
 cin>>a[i][j];
 max=a[0][0];
 for(i=0;i<3;i++)
 for(j=0;j<3;j++)
 if(a[i][j]>max)
 max=a[i][j];
 cout<<"max="<< max<<"\t";
 min=a[0][0];
 for(i=0;i<3;i++)
 for(j=0;j<3;j++)
 if(a[i][j]<min)
 min=a[i][j];
 cout<<"min="<< min;
 }




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                  C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                     ‫اﻟﻣﻠﺣﻘﺎت‬




       ‫33:ﺑرﻧﺎﻣﺞ ﯾﺑﯾن ﻣﺎھو اﻛﺑر واﻗل رﻗم ﺿﻣن ﻣﺻﻔوﻓﺗﯾن أي ﯾﻌطﯾك ﻧﺎﺗﺟﯾن ﻓﻘط اﺣدھﻣﺎ اﻻﻛﺑر وﻻﺧر اﻻﺻﻐر‬
#include<iostream.h>
main()
{int i,j,max,min;
int a[2][2];
int b[2][2];
int c[2][4];
cout<<"enter first matrixs matrixs"<<"\n";
for(i=0;i<2;i++)
for(j=0;j<2;j++)
cin>>a[i][j];
for(i=0;i<2;i++)
for(j=0;j<2;j++)
c[i][j]=a[i][j];
cout<<"enter second matrixs"<<"\n";
for(i=0;i<2;i++)
for(j=2;j<4;j++)
cin>>b[i][j];
for(i=0;i<2;i++)
for(j=2;j<4;j++)
c[i][j]=b[i][j];
cout<<"the new matrixs after combine is";
for(i=0;i<2;i++){
cout<<"\n";
for(j=0;j<4;j++)
cout<<c[i][j]<<"\t";}
max=c[0][0];
for(i=0;i<2;i++)
for(j=0;j<4;j++)
if(c[i][j]>max)
max=c[i][j];
cout<<"\n"<<"max="<< max<<"\t";
min=c[0][0];
for(i=0;i<2;i++)
for(j=0;j<4;j++)
if(c[i][j]<min)
min=c[i][j];
cout<<"min="<< min;}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                    C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                              ‫اﻟﻣﻠﺣﻘﺎت‬




                                 ‫43:اطﺑﻊ اﻟﺷﻛل اﻟﺗﺎﻟﻲ دون اﺳﺗﺧدام اﻟﻣﺻﻔوﻓﺔ‬

** **
*****
*****
** **
#include<iostream.h>
main()
{int i,j,k; //for print my na
for(i=1;i<5;i++){
for(j=0;j<2;j++)
cout<<"*";
if((i==1)||(i==4))
cout<<" ";
else
cout<<"*";
for(k=0;k<2;k++)
cout<<"*";
cout<<"\n";}}
                                ‫٥٣: اطﺑﻊ اﻟﺷﻛل اﻟﺗﺎﻟﻲ دون اﺳﺗﺧدام اﻟﻣﺻﻔوﻓﺔ‬
#include<iostream.h>
main()
{
int i,j,k;
for(i=5;i>=0;i--){
for(j=0;j<=i;j++)
cout<<"*";
cout<<"\n";
for(k=i;k<=5;k++)
cout<<" ";
}}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                             C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                        ‫اﻟﻣﻠﺣﻘﺎت‬




                                            ‫63:اطﺑﻊ اﻟﺷﻛل اﻟﺗﺎﻟﻲ دون اﺳﺗﺧدام اﻟﻣﺻﻔوﻓﺔ‬

#include<iostream.h>
main()
{
int i,j;
for(i=5;i>=0;i--){
for(j=i;j<=5;j++)
cout<<"*";
cout<<"\n";
}}
                         ‫73:ﺑرﻧﺎﻣﺞ ﯾﺑﯾن ﻋدد اﻻﺣرف اﻟﺻﺣﯾﺣﺔ واﻟﻌﻠﺔ ﻓﻲ ﻣﺻﻔوﻓﺔ ذات ﺑﻌدﯾن‬
#include<iostream.h>
main()
{
int i,j,m,h,s;
h=0;
char a[5][4];
char c[6]={'o','u','a','i','e','\o'};
for(i=0;i<5;i++)
for(j=0;j<4;j++)
cin>>a[i][j];
for(i=0;i<5;i++)
for(j=0;j<4;j++){
for(m=0;m<5;m++)
if(a[i][j]==c[m])
h=h+1;
}
s=i*j-h;
cout<<"vowel="<<h<<"\n"<<"const="<<s;
}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                       C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                 ‫اﻟﻣﻠﺣﻘﺎت‬




                                  ‫٨٣:ﺑرﻧﺎﻣﺞ ﯾﺑﯾن ﻋدد ﻣرات ﺗﻛرار اﺣرف اﺳﻣك ﻓﻲ ﻣﺻﻔوﻓﺔ ذات ﺑﻌدﯾن‬
#include<iostream.h>
main()
{int i,j,m,h;
h=0;
char a[5][4];
  har c[7]={'h','u','s','i','e','n','\o'};
char c[7]={'h','u','s','i','e','n','
for(i=0;i<5;i++)
for(j=0;j<4;j++)
cin>>a[i][j];
 for(i=0;i<5;i++)
for(j=0;j<4;j++){
for(m=0;m<6;m++) {
if(a[i][j]==c[m])
h=h+1;
else
cout<<"";}}
cout<<"iteration number="<<h;}
                       ‫٩٣:ﻣن ﻣﺻﻔوﻓﺔ ٤*٤ ﻛون ﻣﺻﻔوﻓﺔ ذات ﺑﻌد واﺣد ﻣﻛوﻧﺔ ﻣن اﻛﺑر ﻋﻧﺻر ﻓﻲ ﻛل ﺻف‬
#include<iostream.h>
main()
{
int i,j,h,max;
h=0;
int c[6];
int a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
cin>>a[i][j];
for(i=0;i<4;i++){
max=a[h][0];
h=h+1;
for(j=0;j<4;j++)
if(a[i][j]>max)
max=a[i][j];
cout<<(c[max]=max)<<"\t";}}      t";}}



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                     ‫اﻟﻣﻠﺣﻘﺎت‬




                                                         ‫04:ﺑرﻧﺎﻣﺞ ﯾطﺑﻊ اﻻﻋداد ﻛﻣﺎ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ‬
#include<iostream.h>
 main()
 {
 int i,s,b,d ;
 s=0;
 d=1;
 for(i=0;i<20;i++)
 {
 cout<<d<<"\t";
 b=s;
 s=d;
 d=s+b;
 }}
                 ‫١٤:ﺑرﻧﺎﻣﺞ ﺗدﺧل ﻓﯾﮫ رﻗم ﻣﻛون ﻣن ﺧﻣس اﺟزاء وﯾﺑﯾن ھل اﻟرﻗم اﻟذي ادﺧﻠﺗﮫ ﻣﺗﻧﺎﺿر ام ﻻ‬
#include<iostream.h>
main()
{
int i,count=4,bol=0;
int a[5],b[5];
for(i=0;i<5;i++)
{cin>>a[i];
b[i]=a[i];}
for(i=0;i<5;i++)
{if(a[i]!=b[count])
bol=1;
count=count-1;}
 if(bol==0)
 cout<<"the number is symmetric";
else
cout<<"the number is no symmetric";
}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                    C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                  ‫اﻟﻣﻠﺣﻘﺎت‬




                   (‫٢٤:ﻣﺻﻔوﻓﺔ ﻣﻛوﻧﺔ ﻣن اﻛﺑر اﻻﻋداد ﻓﻲ اﻟﻣﺛﻠث اﻟﻌﻠوي)ﻓﻲ ﻛل ﺳطر ﻣن اﻟﻣﺛﻠت اﻟﻌﻠوي‬
#include<iostream.h>
main()
{int i,j,h,m,max;
 h=0;
 m=1;
int c[6];
int a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
cin>>a[i][j];
cout<<"the new natrix is"<<"\n";
for(i=0;i<3;i++){
max=a[h][m];
h=h+1;
m=m+1;
for(j=i+1;j<4;j++)
if(a[i][j]>max)
max=a[i][j];
cout<<(c[max]=max)<<"\t";}}
                   (‫٣٤:ﻣﺻﻔوﻓﺔ ﻣﻛوﻧﺔ ﻣن اﻛﺑر اﻻﻋداد ﻓﻲ اﻟﻣﺛﻠث اﻟﺳﻔﻠﻲ)ﻓﻲ ﻛل ﺳطر ﻣن اﻟﻣﺛﻠت اﻟﺳﻔﻠﻲ‬
#include<iostream.h>
main()
{int i,j,h,m,max;
 h=1;
int c[6], a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
cin>>a[i][j];
cout<<"the new natrix is"<<"\n";
for(i=1;i<4;i++){
max=a[h][0];
h=h+1;
for(j=0;j<i;j++){
if(a[i][j]>max)
max=a[i][j]; }
cout<<(c[max]=max)<<"\t";}}



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                 C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                     ‫اﻟﻣﻠﺣﻘﺎت‬




                               (٤*٤ ) ‫٤٤:ﻣﺻﻔوﻓﺔ ﻣﻛوﻧﺔ ﻣن اﻛﺑر ﻋدد ﻓﻲ ﻛل ﻋﻣود ﻣﺎﺧوذة ﻣن ﻣﺻﻔوﻓﺔ‬
#include<iostream.h>
main()
{int i,j,h,max;
h=0;
int c[6];
int a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
cin>>a[i][j];
cout<<"the new natrix is"<<"\n";
for(j=0;j<4;j++){
max=a[h][0];
h=h+1;
for(i=0;i<4;i++)
if(a[i][j]>max)
max=a[i][j];
cout<<(c[max]=max)<<"\t";}}
      ‫٥٤:ﻣن ﻣﺻﻔوﻓﺔ) ٤* ٤( ﻛون ﻣﺻﻔوﻓﺔ ﻣن ﻋﻣودﯾن اﻟﻌﻣود اﻻول ﻧﻔس اﻟﻌﻣود اﻻول ﻓﻲ اﻟﻣﺻﻔوﻓﺔ اﻻﺻﻠﯾﺔ‬
                                           ‫واﻟﻌﻣود اﻟﺛﺎﻧﻲ ﻣن ﺣﺎﺻل ﺿرب اﻟﻌﻣود اﻻول ﻓﻲ اﻟﻌﻣود اﻻﺧﯾر‬
#include<iostream.h>
 main()
{int i,j;
int c[4]={1,1,1,1};
int a[4][4];
 for(i=0;i<4;i++)
for(j=0;j<4;j++)
cin>>a[i][j];
for(i=0;i<4;i++){
cout<<"\n";
for(j=0;j<4;j++)
if((j==3)||(j==0)) {
c[i]*=a[i][j];
cout<<c[i]<<"\t"; }
else
cout<<"";
}}



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                    C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                  ‫اﻟﻣﻠﺣﻘﺎت‬




  ‫٦٤:ﻣن ﻣﺻﻔوﻓﺔ ) ٤*٤ ( ﻛون ﻣﺻﻔوﻓﺔ ﻣن ﻋﻣود واﺣد ﻣﻛون ﻣن ﺣﺎﺻل ﺿرب اﻟﻌﻣود اﻻول ﻓﻲ اﻟﻌﻣود اﻻﺧﯾر‬

‫>‪#include<iostream.h‬‬
 ‫)(‪main‬‬
‫{‬
‫;‪int i,j‬‬
‫;}1,1,1,1{=]4[‪int c‬‬
‫;]4[]4[‪int a‬‬
 ‫)++‪for(i=0;i<4;i‬‬
‫)++‪for(j=0;j<4;j‬‬
‫;]‪cin>>a[i][j‬‬
‫{)++‪for(i=0;i<4;i‬‬
‫;"‪cout<<"\n‬‬
‫)++‪for(j=0;j<4;j‬‬
‫))0==‪if((j==3)||(j‬‬
‫;]‪c[i]*=a[i][j‬‬
‫‪else‬‬
‫;""<<‪cout‬‬
‫;"‪cout<<c[i]<<"\t‬‬
‫}}‬

                                     ‫٧٤:اطﺑﻊ ﻣﺻﻔوﻓﺔ ﻛﻣﺎ ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ)ورد ﻓﻲ اﻻﻣﺗﺣﺎن اﻟﻧﮭﺎﺋﻲ(‬




‫}};"‪cout<<"\n‬‬




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                 ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                         ‫اﻟﻣﻠﺣﻘﺎت‬




        (‫٨٤:ﻛون اﺳﻣك ﻣن ﻣﺻﻔوﻓﺔ ﺣرﻓﯾﺔ )أي ﺗﺑﺣث ﻋن اﺣرف اﺳﻣك ﻓﻲ اﻟﻣﺻﻔوﻓﺔ وﺗﻛون اﺳﻣك ﻣن اﻻﺣرف‬
#include<iostream.h>
 main()
{int i,j,k,n;
n=0;
char m[7];
char c[7]={'h','u','s','i','e','n','\o'};
char a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
cin>>a[i][j];
for(k=0;k<6;k++){
for(i=0;i<4;i++)
for(j=0;j<4;j++){
if(a[i][j]==c[k]){
m[k]=a[i][j];
n=n+1;}}}
if(n>=6)
for(k=0;k<6;k++)
cout<<m[k];
if(n==0)
cout<<"your name is not found in this matrixs";
if((n<6)&&(n>0))
cout<<"found deficit in your name letter";}
                                        (‫٩٤:ﺑرﻧﺎﻣﺞ ﯾﻘوم ﺑﺣﺳﺎب اﻟﻣﻌﺎدﻟﺔ اﻟﺗﺎﻟﯾﺔ )ورد ﻓﻲ اﻻﻣﺗﺣﺎن اﻟﻧﮭﺎﺋﻲ‬

#include<stdio.h>
main()
{
int i,j,m,n,sum;
sum=0;
scanf("%d",&n);
for(i=1;i<=n;i++){
m=i*i;
sum=sum+m;}
printf("seque=%d",sum);}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                           ‫اﻟﻣﻠﺣﻘﺎت‬




                                   (‫٠٥:ﺑرﻧﺎﻣﺞ ﯾﻘوم ﺑطﺑﺎﻋﺔ اﻟﻣﺗﺳﻠﺳﻠﺔ اﻟﺗﺎﻟﯾﺔ ﺣﺗﻰ اﻟﻣﺋﺔ ﺣد )ورد ﻓﻲ اﻟﻧﮭﺎﺋﻲ‬


#include<stdio.h>
main()
{float i,j,m,sum;
j=3;
sum=0;
for(i=1;i<=100;i++){
m=(i*i)/(j*j);
j=j+2;
sum=sum+m;}
printf("seque=%f",sum);}

  (٧ ) ‫15:ﻗم ﺑطﺑﺎﻋﺔ اﯾﺎم اﻻﺳﺑوع ﺑﺣﯾت اذا ﺿﻐطﻧﺎ) ١ ( ﯾظﮭر ﯾوم اﻻﺣد ﻓﻲ ﺷﺎﺷﺔ اﻟﺗﻧﻔﯾذ واﻟﺑﻘﯾﺔ ﺑﺎﻟﺗﺳﻠﺳل اﻟﻰ‬
                                                                            (‫ﯾﻣﺛل اﻟﺳﺑت )ورد ﻓﻲ اﻟﻧﮭﺎﺋﻲ‬
#include<stdio.h>
main()
{int x;
scanf("%d",&x);
switch(x) {
case 1:
printf("sumday");
break;
case 2:printf("monday");
break;
case 3:printf("Tuerday");
break;
case 4:printf("wednesday");
break;
case 5:printf("thursday");
break;
case 6:printf("fridaay");
break;
case 7:printf("saturday");
break;
default: printf("error"); }}



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                          C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                         ‫اﻟﻣﻠﺣﻘﺎت‬




        (‫٢٥:ﺑرﻧﺎﻣﺞ ﯾدﺧل ﻋﺷرﯾن رﻗم وﯾﺑﯾن أﯾﮭم اوﻟﻲ وﯾﺣﺳب ﻋدد اﻻﻋداد اﻻوﻟﯾﺔ اﻟﺗﻲ ظﮭرت )ورد ﻓﻲ اﻟﻧﮭﺎﺋﻲ‬
#include<stdio.h>
main()
{int x,i,m,h,t;
int a[20];
h=t=0;
for(x=0;x<20;x++)
scanf("%d",&a[x]);
for(x=0;x<20;x++) {
for(i=2;i<a[x];i++)
if(a[x]%i==0)
t=1;
if (t==1)
printf("%d is no prime\n",a[x]);
else {
h=h+1;
printf("%d is prime\n",a[x]);
}t=0;}
printf("number of prime=%d",h);
}
  ‫35:ﻣﺻﻔوﻓﺗﯾن ﻛل واﺣدة ﻣﻧﮭﻣﺎ ﻣﻛوﻧﺔ ﻣن ﺧﻣس ﻋﻧﺎﺻر ادﻣﺞ ھﺎﺗﯾن اﻟﻣﺻﻔوﻓﺗﯾن ﻓﻲ ﻣﺻﻔوﻓﺔ ﺛﺎﻟﺛﺔ ﻟﻠﻌﻠم ان ﻛل‬
                                                                (‫اﻟﻣﺻﻔوﻓﺎت اﺣﺎدﯾﺔ اﻟﺑﻌد)ورد ﻓﻲ اﻟﻧﮭﺎﺋﻲ‬
#include<stdio.h>
main()
{
int i,j,n;
n=0;
int a[5];
int b[5];
int c[10];
printf("enter first matrixs\n");
for(i=0;i<5;i++)
scanf("%d",&a[i]);
for(i=0;i<5;i++)
c[i]=a[i];
printf("enter second matrixs\n");
for(j=5;j<10;j++)



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                 ‫اﻟﻣﻠﺣﻘﺎت‬




scanf("%d",&b[j]);
for(j=5;j<10;j++)
c[j]=b[j];
for(n=0;n<10;n++)
printf("%d\t",c[n]);}
                              ‫٤٥:ﻣﺻﻔوﻓﺔ )٥*٥( ﺿﻊ اﻟﻘطر اﻟرﺋﯾﺳﻲ ﻟﮭﺎ ﻓﻲ ﻣﺻﻔوﻓﺔ ﺗﺎﻧﯾﺔ واطﺑﻌﮭﺎ‬
#include<stdio.h>
main()
{
int i,j,n;
n=0;
int a[5][5];
int b[5];
printf("enter matrixs\n");
for(i=0;i<5;i++)
for(j=0;j<5;j++)
scanf("%d",&a[i][j]);
printf("the new matrixs is\n");
for(i=0;i<5;i++)
for(j=0;j<5;j++){
if(i==j)
printf("%d\t",(b[i]=a[i][j]));
else
printf(""); }}
                                                                 ‫55:ﺑرﻧﺎﻣﺞ ﯾطﺑﻊ اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ‬


#include<stdio.h>
 #include<math.h>
 main()
 {
 float i,m,n,b,a,y,x,s;
 y=0;
 b=2;
 printf("enter the last power of\n");
 scanf("%f",&n);
 printf("enter the volue of(x)\n");



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                               C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                ‫اﻟﻣﻠﺣﻘﺎت‬




scanf("%f",&s);
for(i=1;i<=n;i++){
x=pow(s,i);
a=pow(b,i);
m=x/a;
y=y+m; }
printf("y=%f",y);
}
                                        ‫٦٥:اﯾﺟﺎد اﻟﺟذر ﻟرﻗم ﻣﻌﯾن ﺑﺎﺳﺗﺧدام داﻟﺔ اﻟﺟذر اﻟﺗرﺑﯾﻌﻲ‬
#include<stdio.h>
#include<math.h>
 main()
 {
float n;
 printf("who the number you want to find root for it\n");
 scanf("%f",&n);
n= sqrt (n);
 printf("root=%f",n);
 }



                                           ‫٧٥:اﯾﺟﺎد اﻟﺗﻘرﯾب ﻟرﻗم ﻣﻌﯾن ﺑﺎﺳﺗﺧدام داﻟﺗﻲ اﻟﺗﻘرﯾب‬
#include<stdio.h>
#include<math.h>
 main()
 {float n;
int h;
 printf("who the number you want to near it\n");
 scanf("%f",&n);
 h=ceil(n);
 printf("near to max=%d\n",h);
 h=floor(n);
 printf("near to min=%d",h); }




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                              C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                         ‫اﻟﻣﻠﺣﻘﺎت‬




      ‫٨٥:ﺑرﻧﺎﻣﺞ ﺗدﺧل ﻓﯾﮫ اﺳم وﺑدل ﻛل ﺣرف ﺗدﺧﻠﮫ ﺗظﮭر ﻧﺟﻣﺔ وﯾﻘﺎرن اﻻﺳم اﻟذي ادﺧﻠﺗﮫ ﺑﺎﻻﺳم اﻟﻣوﺟود ﻋﻧده‬
                     ( ‫وﻻﯾﺧرج ﻣن اﻟﺑرﻧﺎﻣﺞ اﻻ ﺗدﺧل اﻟﻛود اﻟﺻﺣﯾﺢ)ﺑرﻧﺎﻣﺞ اﻟرﻗم اﻟﺳري اﻟﻣوﺟود ﻓﻲ اﻟﺣﺎﺳﺑﺔ‬
#include <stdio.h>
#include <conio.h>
 int main()
 {int sure=0;
 char x[]="rana";
 char pass[4];
 for(;;){
 for(int i=0;i<4;i++){
 pass[i]=getch();
 putchar('*');}
 for (i=0;i<4;i++){
 if (pass[i]==x[i]) sure++;
 else break;}
 if (sure == 4){
 printf("\n Password Correct\n");
 break;}
printf("\n");
 printf("\n False....Try Againe\n");}
 return 0; }



                                                                         ‫95:ﺑرﻧﺎﻣﺞ ﯾطﺑﻊ اﻟداﻟﺔ اﻟﺗﺎﻟﯾﺔ‬


#include<stdio.h>
#include<math.h>
main()
{
float i,m,n,b,a,y,x,s;
y=a=0;
b=2;
printf("enter the last power of\n");
scanf("%f",&n);
printf("enter the volue of(x)\n");
scanf("%f",&s);



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                       C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                       ‫اﻟﻣﻠﺣﻘﺎت‬




 for(i=1;i<=n;i++){
 x=pow(s,a);
 a=pow(b,i);
 m=x/a;
 y=y+m; }
 printf("y=%f",y);
 }
   ‫06:ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟﺷﻛل اﻟﺗﺎﻟﻲ)ﻻﯾﺣﺗﺎج اﺣدد ﻣﺎذا ﺳﺗﺳﺗﻌﻣل ﻓﻲ اﻟﺣل ﻓﻣﺟرد اﻟﻧﺿرة. اﻟﻰ اﻟرﺳم وﺗرى ﺗﻛرار‬
                                                            (Function ‫اﻻﺿﻠﻊ ﺗﻌرف ان ﻋﻠﯾك اﺳﺗﺧدام‬
#include<stdio.h>
max1()
{
int z,x;
for(z=1;z<=5;z++){
printf("*\n");
for(x=0;x<=z-1;x++)
printf(" ");
}}
 main()
{
max1 ();
max1();
max1();
}
                                                                       ‫16:ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
#include<stdio.h>
max1(){
int z,x;
for(z=1;z<=5;z++){
printf("*\n");
for(x=0;x<=z-1;x++)
printf(" ");}}
max2(){
int z,x;
for(z=1;z<=5;z++){
printf("*\n");
for(x=z;x<=5;x++)


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                      C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                ‫اﻟﻣﻠﺣﻘﺎت‬




printf(" ");}}
main(){
max1 ();
max2();
max1();
max2();
}
                                ‫٢٦:ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
#include<stdio.h>
max1()
{
int z,x,b;
for(z=1;z<=5;z++){
for(b=1;b<=5;b++)
printf(" ");
printf("*\n");
for(x=0;(x<=z-1)&&(z!=5);x++)
printf(" ");
}}
max2()
{
int z;
for(z=1;z<12;z++)
printf("*");
printf("\n");
}
 max3()
{
int m,n,c;
for(n=1;n<=5;n++){
for(m=n;m<5;m++)
printf(" ");
for(c=1;c<=5;c++)
printf(" ");
printf("*\n");}}
 main(){
max2 ();



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                               C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                ‫اﻟﻣﻠﺣﻘﺎت‬




max3();
max1();
max2();
printf("");
max2 ();
max3();
max1();
max2();}
                                ‫٣٦:ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
#include<stdio.h>
max1(){
int z,x,b;
for(z=1;z<=5;z++){
printf("*\n");
for(x=0;(x<=z-1)&&(z!=5);x++)
printf(" ");}}
max3(){
int m,n;
for(n=1;n<=5;n++){
for(m=n;m<5;m++)
printf(" ");
printf("*\n");}}
main(){
max1 ();
max1();
max3 ();
max3();}

                                ‫46:ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
#include<stdio.h>
max1(){
int z,x;
for(z=1;z<=5;z++){
printf("*\n");
for(x=0;(x<=z-1)&&(z!=5);x++)
printf(" ");}}
max2(){


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                               C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                ‫اﻟﻣﻠﺣﻘﺎت‬




int z;
for(z=1;z<=5;z++)
printf("*");
printf("\n");}
main()
{max1 ();
max2();
max1();
max2();
max1();
max2();
max1();
max2();}
                                ‫56:ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟﺷﻛل اﻟﺗﺎﻟﻲ‬
#include<stdio.h>
max1(){
int z,x;
for(z=1;z<=5;z++){
printf("*\n");
for(x=0;(x<=z-1)&&(x!=5);x++)
printf(" ");}}
max2(){
int z;
for(z=1;z<=7;z++)
printf("*");
printf("\n");}
main(){
max1 ();
max2();
max1();
max2();
max1();
max2();}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                               C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                              ‫اﻟﻣﻠﺣﻘﺎت‬




   ‫66:ﻧﻔﺗرض اﻧك ﻛﻧت ﻓﻲ ﺻدد ﺑﻧﺎء ﻧظﺎم ﺗﺷﻐﯾل وﻗد اﺣﺗﺟت ﻣراراً ﻓﻲ ﻛﺛﯾر ﻣن اﺟزاء اﻟﺑرﻧﺎﻣﺞ اﻟﻰ اﻟﻣﻌﺎدﻟﺔ اﻟﺗﻲ‬
                                                       ‫َ‬
    ‫ﻓﻲ اﻻﺳﻔل ھل ﻣن اﻟﻣﻌﻘول ان ﺗﻌﯾد اﻟﻣﻌﺎدﻟﺔ ﻛل ﻣرة ھذا اﻗرب اﻟﻰ اﻟﺟﻧون وﻧﺣن ﻧﻌﻠم ان اﻟﻣﺗﻐﯾرات ﻗد ﺗﺗﻐﯾر ﻓﻲ‬
                                                   ‫اﺳﺗﻌﻣﺎﻟﮭﺎ ﻓﻲ اﺣد اﻻﺟراءات وﻟﺣل ھذه اﻟﻣﺷﻛﻠﺔ ﻣﺎذا ﻧﺳﺗﺧدم ؟‬

‫>‪#include<stdio.h‬‬
‫>‪#include<math.h‬‬
‫)‪hus(int a ,int b‬‬
‫;‪{ int x‬‬
‫;‪x=a+b‬‬
‫};)‪return(x‬‬
‫{)‪rana (int a‬‬
‫;‪int z‬‬
‫;)5,‪z=pow(a‬‬
‫};)‪return(z‬‬
‫{)(‪main‬‬
‫;‪int a,b,n,m,z‬‬
‫;)‪scanf("%d%d",&a,&b‬‬
‫;)‪n=hus(a,b‬‬
‫;)‪m=rana(a‬‬
‫;‪z=n+m‬‬
‫};)‪printf("z=%d",z‬‬
       ‫٧٦:ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ ﺟﻣﯾﻊ اﻻﺣرف اﻻﻧﻛﻠﯾزﯾﺔ ﺑﻠﺗﺳﻠﺳل ﺑﺣﯾث اﻻﺣرف اﻟﻛﺑﯾرة ﺑﺗﻧﺎﻗص ) ‪ (Function‬و‬
                                                            ‫اﻟﺻﻐﯾرة ﺑﺗزاﯾد اطﺑﻌﮭم ﻣرﺗﯾن ﺑﺎﺳﺗﺧدام‬
‫>‪#include<stdio.h‬‬
‫{)(‪smo‬‬
‫;‪char r‬‬
‫)++‪for(r='a';r<='z';r‬‬
‫};)‪printf("%c\t",r‬‬
‫{)(‪cap‬‬
‫;‪char h‬‬
‫)--‪for(h='Z';h>='A';h‬‬
‫};)‪printf("%c\t",h‬‬
‫{)(‪main‬‬
‫;)(‪smo‬‬
‫;)"‪printf("\n‬‬
‫;)(‪cap‬‬
‫;)"‪printf("\n‬‬



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                            ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                         ‫اﻟﻣﻠﺣﻘﺎت‬




‫;)(‪smo‬‬
‫;)"‪printf("\n‬‬
‫};)(‪cap‬‬
                                      ‫86:ھل ﺳﺑق وراﯾت ﺻﻧدوق ﺑرﯾد ﻟﻧﻔرض اﻧك وﺿﻌت رﺳﺎﻟﺔ ﻓﻲ ﺻﻧدوق‬
  ‫اﻟﺑرﯾد ﺗﺣﺗوي ﻋﻠﻰ)اذﻛرﯾﻧﻲ ﻛﻠﻣﺎ ﺗﻐﯾب اﻟﺷﻣس....( وطﻠﺑت اﻧﺎ ﻣﻧك اﻧت ﺗطﺑﻌﻠﻲ ﻋﻧوان اﻟرﺳﺎﻟﺔ ھل ﺳوف ﺗطﺑﻌﻠﻲ‬
   ‫ﻣﺎﻣوﺟود ﻓﯾﮭﺎ)ﷲ ﯾدري اﺷﻛﺎﺗب( اﻛﯾد ﻻ ﺳوف ﺗطﺑﻌﻠﻲ ﻋﻧوان اﻟﺻﻧدوق اﻟذي وﺿﻌت ﻓﯾﮫ اﻟرﺳﺎﻟﺔ وﻟﯾﻛن)٠١١(‬
                                                               ‫وھذا ﻣﺎﻣوﺟود ﺑﻠﺿﺑط ﻓﻲ ﻣوﺿوع اﻟﻣؤﺷرات‬
‫>‪#include <stdio.h‬‬
‫) (‪main‬‬
‫;55=‪{int c‬‬
‫;)‪printf("%d",&c‬‬
‫};0 ‪return‬‬
     ‫اﺟﻌل ﻣؤﺷر ﯾﺷﯾر ﻟﻣﺣﺗوﯾﺎت ﻣﺗﻐﯾر ﻣﻌﯾن وطﺑﻊ اﻟﻘﯾﻣﺔ اﻟﺗﻲ ﻓﯾﮫ)اﻟؤﺷر ھوا رﻗم اﻟﺻﻧدوق اﻟﺑرﯾد اﻟﻣﻛﺗوب ﻋﻠﻰ‬
                                                                                              ‫اﻟرﺳﺎﻟﺔ(‬
‫>‪#include <stdio.h‬‬
‫) (‪main‬‬
‫;55=‪{int f‬‬
‫;)‪printf("f=%d\n",&f‬‬
‫; ‪int *a=&f‬‬
‫;)‪printf("*a=%d",*a‬‬
‫};0 ‪return‬‬
  ‫٩٦:ﻛون ﻣﺻﻔوﻓﺔ اﺣﺎدﯾﺔ اﻟﺑﻌد ﻏﯾر ﻣﺣدودة اﻟﺣﺟم اﻧت ﺗﺣدد ﻋﻧﺎﺻرھﺎ ﻓﻲ ﻛل ادﺧﺎل)ﻧﻌﻠم ھذااﻟﺳؤال ﻣﺳﺗﺣﯾل ﻣﻊ‬
                            ‫اﻟﻣﺻﻔوﻓﺔ اﻻﻋﺗﯾﺎدﯾﺔ وﻻﻛن ﻣﻣﻛن ﻣﻊ اﻟﻣؤﺷرات( وﺟد ﻣﺟﻣوع اﻟﻣﺻﻔوﻓﺔ واﻟﻣﻌدل .‬
‫>‪#include <stdio.h‬‬
 ‫) (‪void main‬‬
 ‫;‪{int i,j,sum,avg‬‬
‫;0=‪sum‬‬
‫;)"‪printf("who size the arrray\n‬‬
‫;)‪scanf("%d",&i‬‬
 ‫;]‪int *Array=new int [i‬‬
 ‫;)"‪printf("enter the array\n‬‬
 ‫)++‪for ( j=0;j<i; j‬‬
 ‫;)]‪scanf("%d",&Array[j‬‬
 ‫)++‪for (j=0;j<i; j‬‬
 ‫;]‪sum=sum+Array[j‬‬
 ‫;‪avg=sum/i‬‬
 ‫};)‪printf("sum=%d\navg=%d",sum,avg‬‬


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                      ‫اﻟﻣﻠﺣﻘﺎت‬




             (‫٠٧:ﻛون ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ اﻻﺑﻌﺎد ﻏﯾر ﻣﺣدودة اﻟﺣﺟم وأﺟﻣﻊ اﻟﺻف اﻻول )اﻛﯾد ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷرات‬
#include <stdio.h>
 void main ( )
 {
 int i,j,sum;
 sum=0;
 scanf("%d%d",&i,&j);
 int **Array=new int *[i];
 for (int k=0 ; k< i ; k++)
 Array[k]=new int[j];
 for (k=0 ; k< i ; k++)
 for (int kk=0; kk< j ; kk++)
 scanf("%d",&Array[k][kk]);
 for (k=0 ; k< i ; k++)
 for (int kk=0; kk< j ; kk++)
 if (k==0)
 sum=sum+ Array[k][kk];
 printf("%d",sum);
 }
  ‫١٧:أوﻷ راﺟﻊ اﻻﺳﺋﻠﺔ رﻗم)٢٢ و ٤٢ و٥٢ ( ﺑﻌد ان راﺟﻌﺗﮭﺎ اﻻن ﻛون ﻣﺻﻔوﻓﺔ واﺣذف ﻣﻧﮭﺎ ﻋﻧﺻر وﺿف ﻟﮭﺎ‬
                        (‫ﻋﻧﺻر واﺑدل اﺣد اﻟﻌﻧﺎﺻر اي اﺟﻣﻊ اﻻﺳﺋﻠﺔ اﻟﺛﻼﺛﺔ ﻓﻲ ﺳؤال واﺣد )ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷر‬
#include <stdio.h>
 void main( )
 {
 int i,f,d;
 int m[9];
 printf("enter matrixs\n");
 for ( i=0;i<5; i++)
scanf("%d",&m[i]);
printf("who location you want to replace\n");
scanf("%d",&f);
 int *array=&m[f];
 printf("enter item\n");
 scanf("%d",&d);
 *array=d;
 for ( i=0;i<5; i++)
printf("%d\t", m[i]);



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                     C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                   ‫اﻟﻣﻠﺣﻘﺎت‬




printf("\nwho location you want to delet content it\n");
scanf("%d",&f);
 int *hu=&m[f];
*hu=0;
 for ( i=0;i<5; i++)
printf("%d\t", m[i]);
 int *rana=&m[5];
 printf("\nenter item you wand to add\n");
 scanf("%d",&d);
 *rana=d;
 for ( i=0;i<6; i++)
printf("%d\t", m[i]);
 }
  ‫٢٧:ﺑرﻧﺎﻣﺞ ﺗدﺧل ﻓﯾﮫ ﻣﺻﻔوﻓﺔ ﺣرﻓﯾﺔ وﺗظﮭر ﻟك ﻓﻲ اﻟﺷﺎﺷﺔ ﺟﻣﯾﻊ اﻻﺣرف اﻻﻧﻛﻠﯾزﯾﺔ واﻣﺎم ﻛل ﺣرف ﻋدد ﻣرات‬
                                                                             ‫ظﮭوره ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬
#include<stdio.h>
main()
{
int i,h,s;
char a[5];
char k[26];
char m;
h=0;
for(i=0;i<5;i++)
scanf("%s",&a[i]);
for(m='a';m<='z';m++) {
k[m]=m;
for(i=0;i<5;i++)
if (k[m]==a[i])
h=h+1;
printf("%c=%d\t",k[m],h);
h=0;}
}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                  C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                                ‫اﻟﻣﻠﺣﻘﺎت‬




    ‫( ظﮭور‬a) (‫37:ادﺧل ﻣﺻﻔوﻓﺔ ﻣﻛوﻧﺔ ﻣن ﺧﻣس اﺣرف وﺣﺳب ﻋدد ﻣرات ﻓﻲ ھذه اﻟﻣﺻﻔوﻓﺔ)ورد ﻓﻲ اﻟﻧﮭﺎﺋﻲ‬
#include<stdio.h>
main()
{
int i,j,n;
n=0;
char c[2]={'a','\0'};
char a[5];
for(i=0;i<5;i++)
scanf("%s",&a[i]);
for(i=0,j=0;i<5;i++) {
if (a[i]==c[j])
n=n+1;
else
printf(""); }
}
                         (‫()ورد ﻓﻲ اﻟﻧﮭﺎﺋﻲ‬Function) ‫٤٧: ﺑرﻧﺎﻣﺞ ﺗدﺧل ﻓﯾﮫ ﻣﺻﻔوﻓﺔ ﺣرﻓﯾﺔ وﺑﺎﺳﺗﺧدام‬
                                                                       ‫١.اوﺟد ﻋدد اﺣرف اﻟﻌﻠﺔ ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬
                                                                    ‫٢.اوﺟد اﻟﺣرف اﻻﻛﺛر ﺗﻛرارا ﻓﻲ اﻟﻣﺻﻔوﻓﺔ‬
#include<stdio.h>
int i,h,m,s;
char a[7],b;
vowel(char a[])
{
h=0;
char c[6]={'o','u','a','i','e','\0'};
for(i=0;i<7;i++){
for(m=0;m<5;m++)
if(a[i]==c[m])
h=h+1;}
printf("vowel=%d\n",h);}
repeat(char a[])
{
int i,h,r,max,salah;
char
k[26]={'q','e','w','r','t','y','u','i','o','p','a','s','d','f','g','h','j','k','l','m','n','b','v','c','x','z
'};



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                               ‫اﻟﻣﻠﺣﻘﺎت‬




char m;
h=r=0;
int p[26];
for(m=0;m<26;m++){
for(i=0;i<7;i++)
if (k[m]==a[i])
h=h+1;
p[r]=h;
r=r+1;
h=0;}
max=p[0];
for(h=0;h<26;h++)
if (p[h]>max){
max=p[h];
salah=h;}
printf("charcter more repeat=%c\n",k[salah]);}
main()
{
for(i=0;i<7;i++)
scanf("%c",&a[i]);
vowel(a);
repeat(a);
}
                                                     ‫٥٧: ﻣﺻﻔوﻓﺗﺎن ﺣرﻓﯾﺗﺎن ﺗﺣﺗوﯾﺎن ﻋﻠﻰ‬
                                                                   = she love eng.١
                                                         2= he work in Microsoft
                  (she love work in Microsoft)‫اﺣﺻل ﻋﻠﻰ اﻟﻌﺑﺎرة اﻟﺗﺎﻟﯾﺔ ﻣن ھﺎﺗﯾن اﻟﻣﺻﻔوﻓﺗﺎن‬
#include <stdio.h>
#include <cstring.h>
 main()
 {
 char string[40];
 char string2[]= "she love eng.";
 char string3[]= "he work in microsoft";
 printf("%s\n", string2);
 printf("%s\n\n", string3);
 char *string1=strpbrk(string3," ");



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                              C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                      ‫اﻟﻣﻠﺣﻘﺎت‬




strncpy(string,string2,8);
strcat(string,string1);
printf("%s\n", string);
}
                                                                  ‫٦٧: ﻣﺻﻔوﻓﺗﺎن ﺣرﻓﯾﺗﺎن ﺗﺣﺗوﯾﺎن ﻋﻠﻰ‬
                                                                       = c++ language from١
                                                                   2= fortran best language
          ‫ ( اﺣﺻل ﻋﻠﻰ اﻟﻌﺑﺎرة اﻟﺗﺎﻟﯾﺔ ﻣن ھﺎﺗﯾن اﻟﻣﺻﻔوﻓﺗﺎن‬c++ best language from fortran )
#include <stdio.h>
#include <cstring.h>
 main()
 {char string4[]="we mow ";
 char string[40];
 char string2[]= "c++ language from ";
 char string3[]= "fortran best language ";
 printf("%s\n",string2);;
printf("%s\n",string3);
 char *string1=strpbrk(string3,"b");
 strncat(string,string2,4);
 strcat(string,string1);
 string1=strpbrk(string2,"f");
 strcat(string,string1);
 strncpy(string4,string3,7);
 strcat(string,string4);
printf("%s\n",string);}
                                              ‫٧٧:ادﺧل ﻣﺻﻔوﻓﺔ ﺣرﻓﯾﺔ وﺑﯾن ﻣوﻗﻊ ﻣﺟﻣوﻋﺔ ﻣن اﻻﺣرف ﻓﯾﮭﺎ‬
#include <stdio.h>
#include <cstring.h>
 main()
 {
int b;
 char string3[]= "momohameednonoor ";
 char string2[]= "hame";
 printf("number of char=%s\n",string3);
char *x= strstr(string3,string2);
b=x- string3+1;
 printf("number of char=%d",b); }


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                     C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                    ‫اﻟﻣﻠﺣﻘﺎت‬




                       ‫٨٧:ادﺧل ﻣﺻﻔوﻓﺔ ﺣرﻓﯾﺔ وﺑﯾن ﻋدد ﻣﺟﻣوﻋﺔ ﻣن اﻻﺣرف ﻓﻲ اﻟﻣﺻﻔوﻓﺔ وﺑﯾن ﻣوﻗﻌﮭﺎ‬
#include <stdio.h>
#include <cstring.h>
 main(){
int x,b;
 char string3[]= "momohameednonoor ";
 printf("location of char=%s\n",string3);
 x= strspn(string3,"mo");
 printf("number of char=%d\n",x);
 b= strcspn(string3,"mo");
 printf("location of char=%d",b); }
 ‫٩٧:ﺑرﻧﺎﻣﺞ ﺗدﺧل ﻓﯾﮫ ﺟﻣل ﺣرﻓﯾﺔ ﺑﺎﻟﻌﻛس وﯾطﺑﻊ اﻟﺟﻣﻠﺔ ﺑﺎﻻﺗﺟﺎه اﻟﺻﺣﯾﺢ واﻟﻌﻛس ﺻﺣﯾﺢ)ھذا اﻟﺑرﻧﺎﻣﺞ ﺣل ﻟﻣن‬
                                                              (‫ﯾﮭوي اﻟﻛﺗﺎﺑﺔ ﺑﺎﻟﻌﻛس ﻓﮭذا ﯾﻛﺷف ﺳره‬
 #include <stdio.h>
 #include <cstring.h>
#include <string.h>
 void main( )
 { char * string3;
 int i,j,b;
 printf("who size the word\n");
 scanf("%d",&i);
 string3=new char [i];
 printf("enter the word\n");
gets(string3);
gets(string3);
 b=strlen (string3)-1;
 printf("afler rotate\n");
 for(i=b;i>=0;i--)
 printf("%c",string3[i]); }




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                   C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                 ‫اﻟﻣﻠﺣﻘﺎت‬




                                                            ‫٠٨: ﻣﺻﻔوﻓﺗﺎن ﺣرﻓﯾﺗﺎن ﺗﺣﺗوﯾﺎن ﻋﻠﻰ‬
                                                                     arwa hate bananas
                                                                        mohameed noor
    (mohameed noor hate bananas) ‫اذا ﻛﺎﻧت اﻟﻣﺻﻔوﻓﺔ اﻻوﻟﻰ اﻛﺑر ﻣن اﻟﺛﺎﻧﯾﺔ ﯾطﺑﻊ اﻟﻌﺑﺎرة اﻟﺗﺎﻟﯾﺔ‬
                                                                 .‫وﺑﺧﻼﻓﮫ ﯾطﺑﻊ اﻟﻣﺻﻔوﻓﺔ اﻻوﻟﻰ‬
#include <stdio.h>
#include <cstring.h>
 main()
 {
int x;
];٥٠ char string4[
];٥٠ char string1[
 char string2[]= "arwa hate bananas";
 char string3[]= "mohameed noor ";
 printf("%s\n", string2 );
printf("%s\n\n", string3 );
x=strcmp(string3,string2);
 if ( x>0) {
 char*string1=strpbrk(string2,"h");
 strcat(string3,string1);
 printf("%s\n", string3 ); }
 else
printf("%s\n", string2 );
 }
                             ‫١٨:ادﺧل ﻣﺻﻔوﻓﺔ ﺣرﻓﯾﺔ وﺗﺧﻠص ﻣن )) ( ،(اﻟﺗﻲ ﺗوﺟد داﺧل اﻟﻣﺻﻔوﻓﺔ‬
#include <stdio.h>
#include <cstring.h>
 main()
 {
 char string2[]= ",(myfriend)";
 char tok[]="(),";
 printf("%s\n\n",string2);
char *string =strtok(string2,tok);
printf("%s\n",string);}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                               ‫اﻟﻣﻠﺣﻘﺎت‬




                             ‫28:ﺑرﻧﺎﻣﺞ ﻷدﺧﺎل درﺟﺎت ﺛﻼث طﻼب ﻟﺧﻣس ﻣواد دراﺳﯾﺔ واﯾﺟﺎد اﻟﻣﻌدل‬
#include <stdio.h>
#include <cstring.h>
main()
{
int i,j;
char name;
float avg,degree ,sum ;
i=sum=0;
while(i<3){
printf("enter name of st.\n");
scanf("%s",&name);
printf("enter his degree\n");
for(j=0;j<4;j++){
scanf("%f",&degree);
sum=sum+degree;}
avg=sum/4;
printf("avg=%f\n",avg);
sum=0;
++i;
}}
                                            ‫38:ادﺧل ﻣﺗﻐﯾرﯾن واﺑدل ﺑﯾن ﻗﯾﻣﮭﻣﺎ ﺑﺎﺳﺗﺧدام اﻟﻣؤﺷر‬
#include<stdio.h>
void change(int *a,int *b)
{int c=*a;
*a=*b;
*b=c;
}
main(){
int a,b;
scanf("%d%d",&a,&b);
printf("a=%d\nb=%d\n",a,b);
change(&a,&b);
printf("a=%d\nb=%d\n",a,b);




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                              C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                                ‫اﻟﻣﻠﺣﻘﺎت‬




   ‫٤٨:ﺑرﻧﺎﻣﺞ ﺗدﺧل ﻓﯾﮫ ﻋﺷرة اﻋداد وﯾﺑن ﻟك ﻣﺎﯾﻠﻲ )اﻻﻋداد اﻟﻔردﯾﺔ اﻟﺳﺎﻟﺑﺔ،و اﻻﻋداد اﻟزوﺟﯾﺔ اﻟﺳﺎﻟﺑﺔ، و اﻻﻋداد‬
 ‫اﻟﻔردﯾﺔ اﻟﻣوﺟﺑﺔ،و اﻻﻋداد اﻟزوﺟﯾﺔ أاو اﻟﻣوﺟﺑﺔ،واﻻﻋداد اﻟﻣوﺟﺑﺔ،واﻻﻋداد اﻟﺳﺎﻟﺑﺔ()ورد ﻓﻲ ﻧﺻف اﻟﺳﻧﺔ ﺟزء ﻣن‬
                                                                              (‫ھذا اﻟﺳؤال ﻓﻘط اﻟﻔردﯾﺔ اﻟﺳﺎﻟﺑﺔ‬
 For ‫ﺑﺎﺳﺗﺧدام‬
#include<stdio.h>
main(){
int a,b,i;
for(i=0;i<10;i++){
printf("enter number: ");
scanf("%d",&a);
if((a<0)&&(a%2==-1))
printf("%d is negitive odd\n",a);
if((a<0)&&(a%2==0))
printf("%d is negitive even\n",a);
if((a>=0)||(a%2==1))
printf("%d is positive or odd\n",a);
if((a>=0)&&(a%2==0))
printf("%d is positive even\n",a);
if(a>=0)
printf("%d is positive\n",a);
if(a<0)
printf("%d is negitive\n",a);
}}
 While ‫ﺑﺎﺳﺗﺧدام‬
#include<stdio.h>
main(){
int a,b,i;
i=0;
while(i<10){
printf("enter number: ");
scanf("%d",&a);
if((a<0)&&(a%2==-1))
printf("%d is negitive odd\n",a);
if((a<0)&&(a%2==0))
printf("%d is negitive even\n",a);
if((a>=0)&&(a%2==1))
printf("%d is positive odd\n",a);



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                              C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                 ‫اﻟﻣﻠﺣﻘﺎت‬




if((a>=0)||(a%2==0))
                          even\n",a);
printf("%d is positive or even
if(a>=0)
                       n",a);
printf("%d is positive\n",a);
if(a<0)
                       n",a);
printf("%d is negitive\n",a);
++i;
}}
                                        (Decimal to Binary)   ‫58:ﺑرﻧﺎﻣﺞ ﯾﺣول‬
#include <stdio.h>
void converttobinary(int num){
int i=0;
int binary[32];
while(num>0){
int h=num%2;
binary[i]=h;
num/=2 ;
++i; }
--i;
printf("binary=");
while(i>=0){
printf("%d",binary[i]);
--i;}
printf("\n");}
void main( )
{int decimal;
printf("decimal mumber: ");
scanf("%d",&decimal);
converttobinary(decimal);
}




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                      ‫اﻟﻣﻠﺣﻘﺎت‬




                               (Decimal to octal ) ‫٦٨:ﺑرﻧﺎﻣﺞ ﯾﺣول‬
#include <stdio.h>
void convertooctal(int num)
{
int i=0;
int octal[32];
while(num>0){
int h=num%8;
octal[i]=h;
num/=8 ;
++i;}
--i;
printf("octal=");
while(i>=0){
 printf("%d",octal[i]);
 --i;}
 printf("\n");}
 void main( )
 {int decimal;
 printf("decimal mumber: ");
 scanf("%d",&decimal);
 convertooctal(decimal);}
                               (Hexi to Decimal ) ‫٧٨:ﺑرﻧﺎﻣﺞ ﯾﺣول‬
#include <stdio.h>
void convertohexi(int num)
{int i=0;
int hexi[32];
while(num>0){
int h=num%16;
hexi[i]=h;
num/=16 ;
++i;}
--i;
printf("hexi=");
while(i>=0){
printf("%d",hexi[i]);
--i;}



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                     C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                      ‫اﻟﻣﻠﺣﻘﺎت‬




printf("\n");}
void main( )
{int decimal;
printf("decimal mumber: ");
scanf("%d",&decimal);
convertohexi(decimal);
}
                          (A ) ‫٨٨.اﻛﺗب ﺑرﻧﺎﻣﺞ ﻟﻘراﺋﺔ ﺛﻼﺛون ﺣرف وﺑﯾن ﻋدد ﻣرات ظﮭور اﻟﺣرف‬

#include<stdio.h>
#include<conio.h>
main()
{
char a;
int x,i;
x=0;
for(i=0;i<30;i++){
a=getch();
if(a=='a')
x=x+1;}
printf("\n%d",x);
}
         ‫٩٨:ﺑرﻧﺎﻣﺞ ﻻدﺧﺎل ﻣﻌﻠوﻣﺎت ﺧﻣس ﻛﺗب ﻓﻲ ﺳﺟل واﻟﻣﻌﻠوﻣﺎت وھﻲ)ﻋﻧوان اﻟﻛﺗﺎب،اﺳم اﻟﻣؤﻟف ،وﻋﻧوان‬
                                                               (‫اﻟطﺑﻊ،وﺳﻧﺔ اﻟطﺑﺎﻋﺔ()ورد ﻓﻲ اﻟﻧﮭﺎﺋﻲ‬
#include <stdio.h>
struct _libri
{
char book_title[10];
char auther_name[13];
char publish_address[6];
int publish_year[4];
}books[5];
 main()
{ int i;
for(i=0;i<5;i++){
 printf("\nbooks.book_title: ");
gets(books[i].book_title);


 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                     C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                                            ‫اﻟﻣﻠﺣﻘﺎت‬




‫;)" :‪printf("books.auther_name‬‬
‫;)‪gets(books[i].auther_name‬‬
‫;)" :‪printf("books.publish_address‬‬
‫;)‪gets(books[i].publish_address‬‬
‫;)" :‪printf("books.publish_year‬‬
‫;)‪scanf("%d",&books[i].publish_year‬‬
‫}}‬


         ‫=‬      ‫=‬                ‫+‬
                                   ‫٠٩ : ﺣول اﻟﺗﻌﺎﺑﯾر اﻟرﯾﺎﺿﯾﺔ اﻟﺗﺎﻟﯾﺔ ﺑﺷﻛل ﺟﻣل ﺑﻠﻐﺔ ) ‪( C‬‬
‫.1‬


        ‫=‬      ‫+‬                 ‫∗‬
                                         ‫.‬
    ‫;)‪y=z=2*a+(5*c/d‬‬
‫.2‬


        ‫=‬                    ‫∗‬               ‫+‬      ‫+‬
    ‫;)‪y=7+(3*x/(k+2))*(1.1/z*z‬‬


‫. (*‪y=sin(x‬‬                      ‫∗ ((‪/180))+ pow‬‬               ‫+‬   ‫;)2/1,) ∗‬
‫.‬                                                          ‫٣‬


‫.4‬      ‫=‬            ‫−‬
‫;)‪Y=((5+A)/D)-(B/C‬‬
‫وﺿﻌت ھﻧﺎ اﻗواس اﻟﻘﺳﻣﺔ ﻓﻘط ﻟﻸﻣﺎن ﻻﻧﻧﺎ‬


         ‫=‬
               ‫( .‬           ‫.‬   ‫)‬
‫‪y=(5+A)/D-B/c‬ﻧﺳﺗطﯾﻊ ان ﻧﺳﺗﻐﻧﻲ ﻋﻧﮭﺎ ﻻن اﻟﻘﺳﻣﺔ ﻟﮭﺎ اﺳﺑﻘﯾﺔ ﻋﻠﻰ اﻟطرح وﺗﻛﺗب‬
‫.5‬
‫;)‪y=4.5*pow((x+2.3*y),2)*2/(x+y‬‬


‫= .6‬
                     ‫(‬               ‫)‬
‫اﻟﻣﺗﻐﯾرات اﻟﻣرﻓوﻋﺔ ﻟﻘوى ﻟﮭﺎ اﺳﺑﻘﯾﺔ ﻋﻠﻰ اﻟﺿرب واﻟﺿرب ﻟﮫ اﺳﺑﻘﯾﺔ ﻋﻠﻰ اﻟﻘﺳﻣﺔ‬

                         ‫(‬       ‫)‬
‫‪The solve home work‬‬




                                                 ‫١٩: اﻛﺗب ﺑرﻧﺎﻣﺞ ﻟطﺑﺎﻋﺔ اﻟﺷﻛل اﻟﺗﺎﻟﻲ دون اﺳﺗﺧدام اﻟﻣﺻﻔوﻓﺔ)ورد ﻓﻲ اﻟﻧﮭﺎﺋﻲ(‬
‫>‪#include <stdio.h‬‬
‫)(‪main‬‬
‫{‬
‫;‪int i,j,k,m,n,o,p‬‬
‫{)2-‪for(m=7;m>0;m=m‬‬
‫)--‪for(n=m;n>0;n‬‬
‫;)"*"(‪printf‬‬


    ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                                        ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم ++‪C,C‬‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                    ‫اﻟﻣﻠﺣﻘﺎت‬




printf("\n");
for(o=m;(o<=7)&&(m!=1);o=o+2)
printf(" ");}
for(i=3;i<=7;i+=2){
for(k=i;k<7;k+=2)
printf(" ");
for(j=i;j>0;j--)
printf("*");
printf("\n");
}}
                           ‫٢٩:ﺑرﻧﺎﻣﺞ ﻷﺑدال اﻛﺑر ﻗﯾﻣﺔ ﺑﺎﺻﻐر ﻗﯾﻣﺔ واﻟﻌﻛس واﯾﺟﺎد اﻟرﻗم اﻻﻛﺑر واﻻﺻﻐر‬
#include<stdio.h>
main()
{
int i,m,max,min;
int a[6] ;
printf("enter first matrixs\n");
for(i=0;i<6;i++)
scanf("%d",&a[i] );
printf("the new matrixs after combine is\n") ;
max=a[0] ;
min=a[0];
for(i=0;i<6;i++)
{if(a[i] >max) //find max value
max=a[i] ;
if(a[i] <min) //find min value
min= a[i] ;
}
printf(" max=%d\n", max);
printf(" min=%d\n ", min);
m=0;
for(i=0;i<6;i++)
{if(a[i] ==max) //find loction equal max value
 {a[i]=min ; // put min in location max
 m=1; //if the first if correct the second stop his work for not ambigude
 }




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                   C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                  ‫اﻟﻣﻠﺣﻘﺎت‬




if((a[i] ==min) &&(m==0)) //find loction equal max value //then put max in
location min
          a[i]=max ;
 printf("%d ",a[i]);
 m=0;}
 }
               ‫ (ﺑواﺳطﺔ اﻟﻣؤﺷر ﻣرة وﻣرة ﺑدوﻧﮫ‬function) ‫٣٩: طﺑﺎﻋﺔ ﻋﻧﺎﺻر ﻣﺻﻔوﻓﺔ ﺛﻧﺎﺋﯾﺔ اﻻﺑﻌﺎد ﻓﻲ‬
#include <iostream.h>
void displaywithpointe(int *array )
{‫اﺳﺗﻘﺑﺎل اﻟﻣﺻﻔوﻓﺔ ﺑﺷﻛل ﻣؤﺷر‬
int i=0;
 while ( i<25) //to display 25 element
 {cout<<"array=["<<i<<"]="<<*array <<"\n";
  *array++; //increment the location of pointer
  i++;}}
void displaywithoutpointer(int array[][5] )
 {
 for (int i=0;i<5;i++)
for (int j=0;j<5;j++)
cout<<"array=["<<i<<"]["<<j<<"]="<< array[i][j] <<"\n";
 }
main()
 {
 int array[5][5];
 cout << "Enter Here the Array\n";
 for (int i=0;i<5;i++)
for (int j=0;j<5;j++)
cin>>array[i][j];
displaywithpointe(&array[0][0]); //sent location first etement
‫ﻧرﺳل ﻣوﻗﻊ اﻟﻧﺻر اﻻو ل ﺣﺗﻰ ﯾﺳﺗطﯾﻊ اﻟﻣؤﺷر اﯾﺟﺎده وﯾؤﺷر ﻋﻠﯾﮫ‬
 displaywithoutpointer( array ); }




 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                 C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                  ‫اﻟﻣﻠﺣﻘﺎت‬




                                                     ‫٤٩:اﯾﺟﺎد اﻟﻘﯾﻣﺔ اﻟوﺳطﯾﺔ ﺿﻣن ﻣﺟﻣوﻋﺔ ارﻗﺎم‬
#include<stdio.h>
int main()
{char array[5],i,j;
int sure=0;
char x=0;
printf("Here is the Array \n");//sort array
for ( j=0;j<5;j++)
scanf("%d\n",&array[j]);
for ( i=0;i<5-1;i++) {
sure=0;
for ( j=i; j<5;j++) {
if (array[j] <array[i]){
x=array[j];
array[j]=array[i];
array[i]=x;
sure=1;}}
if (sure ==0) break;}
printf("Here is the mid number\n");
for (i=0;i<5;i++)
if (i==2) //take value mid in arry after sort it is the mid
printf("%d\n",array[i]);
}
  ‫٥٩.ھذا اﻟﺑرﻧﺎﻣﺞ ﯾﺑﯾن ﻟﻧﺎ ﻛﯾف ﻧﺿﻊ ﻣﺻﻔوﻓﺔ ﺳﺟﻼت داﺧل ﻣﺻﻔوﻓﺔ ﺳﺟﻼت اﺧرى اﻟﮭدف ھوا اﻟﻣﺣﺎﻓظﺔ ﻋﻠﻰ درﺟﺎت ﻛل‬
             ‫طﺎﻟب)اﻟﻣﻌﻠوﻣﺎت اﺳم وﻋﻣر وﻋﻧوان وﺧﻣس درﺟﺎت( وﺻﺑﺎﻋﺔ اﺳﻣﺎء اﻟطﻼب واﻟدروس اﻟﻧﺎﺟﺣون ﻓﯾﮭﺎ ﻓﻘط‬
#include<iostream.h>
#include<stdio.h>
struct student
{ char name[10];
int age;
int id;
struct myboy
{
int degres;
}de[5];
}st[20];
main()



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                                 C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                ‫اﻟﻣﻠﺣﻘﺎت‬




{
int i,j,sum,avg;
sum=0;
for(i=0;i<3;i++)
{cout<<"please enter the student information\n";
cout<<"enter his name\n";
gets(st[i].name );
cout<<"enter his age\n";
cin>>st[i].age;
cout<<"enter his ID adress\n";
cin>>st[i].id;
cout<<"enter his degress\n";
for(j=0;j<5;j++)
cin>>st[i].de[j].degres;
}
for(i=0;i<3;i++)
{cout<<"name: "<<st[i].name<<endl;
 for(j=0;j<5;j++)
if (st[i].de[j].degres>=50)
cout<<"his aveg is "<<st[i].de[j].degres<<endl;
}}
                                         ‫٦٩: ﺑرﻧﺎﻣﺞ ﺗﻛﺑﯾر أﺣرف اﻟﻛﻠﻣﺔ وأﯾﺟﺎد ﻋدد اﻷﺣرف اﻟﻌﻠﺔ‬
#include<stdio.h>
#include<ctype.h> //call this lab. for hs instruction(toupper)
int i,h,m,s;
char a[7],b,x;
char c[6]={'o','u','a','i','e','\0'};
main()
{
for(i=0;i<7;i++)
scanf("%s",&a[i]);
h=0;
for(i=0;i<7;i++)
{x=toupper(a[i]) ; //for big the the char.
printf("%c\t",x );}
printf("\n");
for(i=0;i<7;i++){ //compare every location with all value in the array {c[6]}



 ‫ﺣﺳﯾن أﺣﻣد طﺎﻟب‬                                                               C,C++ ‫ﺧطوة ﺑﺧطوة ﻟﺗﻌﻠم‬
‫أﻣﺛﻠﺔ ﻣﺣﻠوﻟﺔ‬                                                                                     ‫اﻟﻣﻠﺣﻘﺎت‬




for(m=0;m<5;m++)
if(a[i]==c[m]) // compare the new array with char. Vowel if it found increment
counter
h=h+1;}
printf("vowel=%d\n",h);
}