برمجه

// this is comment 
/* an example on comment in c++ language* / 
main( ) /* start your program */ 
{ 
int x,y,z; //this line declares type of x,y,z 
}

U

 ﺃﺳﺎﻟﻴﺐ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ

input\output

 ﻫﻨﺎﻟﻚ ﻣﺠﻤﻮﻋﺘﻴﻦ ﻣﻦ ﺩﻭﺍﻝ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ﺣﻴﺚ ﺗﻌﺘﺒﺮ ﺍﻟﻤﺠﻤﻮﻋﺔ ﺍﻷﻭﻟﻰ ﺿﻤﻦ ﻟﻐﺔ

C 

   ﻭﻟﻜﻦ

 ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﺿﻤﻦ ﻟﻐﺔ

C

P

++

P

  ﺃﻣﺎ ﺍﻟﻤﺠﻤﻮﻋﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻓﺘﻌﺘﺒﺮ ﺍﻟﻤﺠﻤﻮﻋﺔ ﺍﻟﻤﺴﺘﺤﺪﺛﺔ ﻓﻲ ﻟﻐﺔ،

C

P

++

P

 ﻭﻳﻌﺘﺒﺮ ﻫﺬﺍ ﺍﻻﺧﺘﻼﻑ ﻓﻲ ﺩﻭﺍﻝ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ﻣﻦ ﺃﻫﻢ ﺍﻟﻔﺮﻭﻕ ﺑﻴﻦ ﻟﻐﺔ

C

  ﻭ

C

P

++

P

 ﻭﻓﻴﻤﺎ ﻳﻠﻲ

 :

ﻃﺮﻳﻘﺔ ﺍﺳﺘﺨﺪﺍﻡ ﺗﻠﻚ ﺍﻟﺪﻭﺍﻝ

U

1

 : ( ﺍﻟﻤﺠﻤﻮﻋﺔ ﺍﻷﻭﻟﻰ

 ﺗﻮﻓﺮ ﻟﻐﺔ

C

 ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﻭ ﺍﻟﺮﻭﺗﻴﻨﻴﺎ

ﺕ

  ﺍﻟﻤﻌﺮﻓﺔ ﺿﻤﻦ

stdio

  ﻣﺜﻞ

printf( )

  ﻟﻺﺧﺮﺍﺝ ﻭ

scanf( )

  ﻟﻺﺩﺧﺎﻝ. ﻭﺍﻟﻤﻠﻒ

stdio.h

 :

 ﻳﻌﻨﻲ

Std

 .

 ﻣﻜﺘﺒﺔ ﻗﻴﺎﺳﻴﺔ ﺧﺎﺻﺔ ﺑﺎﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ: 

io

: 

 ـ ﻣﺨﺘﺼﺮ ﻟ

input/output

 .

 ﺁﻱ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ

h

: 

header file

 .

 ﺁﻱ ﺍﻟﻤﻠﻒ ﺍﻟﺪﻟﻴﻞ

 ﺍﻹﺧﺮﺍﺝ )ﺍﻟﻜﺘﺎﺑﺔ( ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ

printf( )

:

 ﺗﺴﺘﺨﺪﻡ ﺍﻟﺪﺍﻟﺔ

printf( )

 :

 ﻓﻲ ﺇﻇﻬﺎﺭ ﺍﻟﻤﻌﻠﻮﻣﺎﺕ ﺑﺼﻮﺭﺓ ﻣﺮﺗﺒﺔ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ ﻭ ﺗﺄﺧﺬ ﺍﻟﺼﻴﻐﺔ ﺍﻟﺘﺎﻟﻴﺔ

printf( format string , list of variables); 

 ﺍﻟﺤﺪ ﺍﻷﻭﻝ ﻣﻦ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﻋﺒﺎﺭﺓ ﻋﻦ ﺭﻣﺰ ﻧﺼﻲ ﻳﺴﻤﻰ ﺑﻨﺺ ﺍﻟﺘﺮﺗﻴﺐ

(format string)

 ﻭﻳﺤﺘﻮﻱ ﻋﻠﻰ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﻣﺤﺪﺩﺍﺕ ﺍﻟﺘﺮﺗﻴﺐ ﺍﻟﺘﻲ ﺗﺆﺩﻱ ﺇﻟﻰ ﺇﻇﻬﺎﺭ ﺍﻟﻜﺘﺎﺑﺔ ﺑﺎﻟﺸﻜﻞ ﺍﻟﻤﻄﻠﻮﺏ. ﺃﻣﺎ

 ﺍﻟﺠﺰء ﺍﻟﺜﺎﻧﻲ ﻓﻴﺤﺘﻮﻱ ﻋﻠﻰ ﻗﺎﺋﻤﺔ ﺑﺎﻟﻘﻴﻢ ﺃﻭ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ ﺍﻟﺘﻲ ﻳﺮﺍﺩ ﺇﻇﻬﺎﺭ ﻗﻴﻤﻬﺎ ﺑﺪﻝ ﻣﺤﺪﺩ ﺍﻟﺘﺮﺗﻴﺐ ﻓﻲ

 .

ﺍﻟﺤﺪ ﺍﻷﻭﻝ ﻭ ﻫﺬﺍ ﺍﻟﺠﺰء ﻻ ﺿﺮﻭﺭﺓ ﻟﻪ ﺇﺫﺍ ﻟﻢ ﻳﺤﺘﻮﻱ ﺍﻟﺤﺪ ﺍﻷﻭﻝ ﻋﻠﻰ ﻣﺤﺪﺩ ﺗﺮﺗﻴﺐ

 :

ﻳﺄﺧﺬ ﻛﻞ ﻣﺤﺪﺩ ﺗﺮﺗﻴﺐ ﺍﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ

%[flags] [width] [.precision] [h/l] <data type>  

:

ﺗﻤﺜﻞ ﺍﻟﺮﻣﻮﺯ ﺩﺍﺧﻞ ﺍﻷﻗﻮﺍﺱ ﺍﻟﻤﺮﺑﻌﺔ ﺧﻴﺎﺭﺍﺕ ﻳﻤﻜﻦ ﺇﻫﻤﺎﻟﻬﺎ. ﺃﺩﻧﺎﻩ ﻭﺻﻒ ﻣﺤﺪﺩ ﺍﻟﺘﺮﺗﻴﺐ

•

%

  ﻳﺴﺘﺨﺪﻡ ﻣﻦ ﻗﺒﻞ ﺍﻟﻤﻌﺎﻟﺞ ﻓﻲ ﺗﺤﺪﻳﺪ ﺍﻟﻤﻜﺎﻥ ﺩﺍﺧﻞ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺍﻟﺬﻱ ﻳﺮﺍﺩ ﺇﻇﻬﺎﺭ ﻓﻴﻪ: 

.

ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ

•

[flags]

  ﺗﻤﺜﻞ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺮﻣﻮﺯ ﺍﻟﺘﻲ ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻭﺍﺣﺪ ﻣﻨﻬﺎ ﺃﻭ ﺃﻛﺜﺮ ﻓﻲ ﻧﻔﺲ: 

)

 ﺍﻟﻮﻗﺖ ﻭﻛﻤﺎ ﻣﺒﻴﻦ ﻓﻲ ﺍﻟﺠﺪﻭﻝ ﺭﻗﻢ

1

.(

•

[width]

.

ﻋﺪﺩ ﺻﺤﻴﺢ ﻳﻤﺜﻞ ﺍﻟﺤﺪ ﺍﻷﺩﻧﻰ ﻟﻄﻮﻝ ﺍﻟﺤﻘﻞ ﺍﻟﻤﺨﺼﺺ ﻟﻘﻴﻤﺔ ﻣﻌﻴﻨﺔ: 

•

[.precision]

:

 ﻋﺪﺩ ﺻﺤﻴﺢ ﻣﺴﺒﻮﻕ ﺑﻨﻘﻄﺔ ﻭ ﻳﻤﺜﻞ: 



 :

 ﺍﻟﺤﺪ ﺍﻷﺩﻧﻰ ﻣﻦ ﺭﻣﻮﺯ ﺍﻟﺮﻗﻢ ﺍﻟﺘﻲ ﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﻬﺎ ﻟﻸﻧﻮﺍﻉ

d, i

. 



 ﻋﺪﺩ ﺭﻣﻮﺯ ﺍﻟﺮﻗﻢ ﺍﻟﺘﻲ ﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﻬﺎ ﺑﻌﺪ ﺍﻟﻔﺎﺭﺯﺓ ﺍﻟﻌﺸﺮﻳﺔ ﻟﻸﻧﻮﺍﻉ

f, e

  .ﻓﻲ ﺣﺎﻟﺔ

 ﻋﺪﻡ ﺍﻟﺘﺤﺪﻳﺪ ﻳﻜﻮﻥ ﻋﺪﺩ ﺍﻟﺮﻣﻮﺯ

6

.



 ﺍﻟﺤﺪ ﺍﻷﻋﻠﻰ ﻟﻌﺪﺩ ﺍﻟﺮﻣﻮﺯ ﺍﻟﺘﻲ ﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﻬﺎ ﻣﻦ ﺭﻣﺰ ﻧﺼﻲ

(string)

.

•

[h/l]

  ﻳﺴﺘﺨﺪﻡ ﺍﻟﺮﻣﺰ: 

l

  ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ ﺑﻴﺎﻧﺎﺕ ﻣﻦ ﻧﻮﻉ

long

  ﺃﻭ

double

  ﻭ ﺍﻟﺮﻣﺰ

h

 ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ ﺑﻴﺎﻧﺎﺕ ﻣﻦ ﻧﻮﻉ

short

. 

•

<data type>

  ﻳﻤﺜﻞ ﻫﺬﺍ ﺍﻟﺤﻘﻞ ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ ﺍﻟﻜﺘﺎﺑﺔ ﻭﻛﻤﺎ ﻣﺒﻴﻦ ﻓﻲ: 

)

 ﺍﻟﺠﺪﻭﻝ ﺭﻗﻢ

2

.(

 ﺍﻟﺮﻣﺰ

 ﺍﻟﻤﻌﻨﻰ

 ــ

 ﺗﻜﻮﻥ ﺑﺪﺍﻳﺔ ﺍﻟﻜﺘﺎﺑﺔ ﻣﻦ ﺍﻟﻴﺴﺎﺭ ﺿﻤﻦ ﺍﻟﺤﻘﻞ ﺍﻟﻤﺨﺼﺺ ﻟﻠﻘﻴﻤﺔ. ﻓﻲ ﺍﻟﺤﺎﻟﺔ

 .

ﺍﻻﻋﺘﻴﺎﺩﻳﺔ ﻳﻤﻸ ﺍﻟﺤﻘﻞ ﻣﻦ ﺍﻟﻴﻤﻴﻦ

 +

 .

ً ﺃﻭ ﻣﻮﺟﺒﺎًﺎﺒﻟﺎﺳ ﻢﻗﺮﻟﺍ ﻥﺎﻛ ءﺍﻮﺳ ﻢﻗﺮﻟﺍ ﻊﻣ ﺓﺭﺎﺷﻹﺍ ﺔﺑﺎﺘﻛ

Space

 .

ًﺗﺮﻙ ﻓﺮﺍﻍ ﻣﻜﺎﻥ ﺍﻹﺷﺎﺭﺓ ﻓﻲ ﺣﺎﻟﺔ ﻛﻮﻥ ﺍﻟﺮﻗﻢ ﻣﻮﺟﺒﺎ

)

 ﺟﺪﻭﻝ

1

 ( ﺭﻣﻮﺯ ﺍﻟﺴﻴﻄﺮﺓ ﻋﻠﻰ ﻣﻜﺎﻥ ﺍﻟﻜﺘﺎﺑﺔ ﺿﻤﻦ ﺍﻟﺤﻘﻞ ﺍﻟﻤﺤﺪﺩ

[flags]

 . 

 ﺔــــــــــــــــــﺌﻴﻬﻟﺍ

 ﺍﻟﺮﻣﺰ

 ﺭﻣﺰ ﻣﻔﺮﺩ

%c

 ﻋﺪﺩ ﺻﺤﻴﺢ ﺃﻭ ﻋﺪﺩ ﺻﺤﻴﺢ ﻃﻮﻳﻞ ﺑﺎﺳﺘﺨﺪﺍﻡ

%ld

%d

  ﻋﺪﺩ ﺻﺤﻴﺢ

%i

 :

ﻋﺪﺩ ﻋﺸﺮﻱ ﺑﺎﻟﺼﻴﻐﺔ

d.dddde+ddd

%e

 ﻋﺪﺩ ﻋﺸﺮﻱ)ﺣﻘﻴﻘﻲ( ﺃﻭ ﻋﺪﺩ ﻋﺸﺮﻱ ﻣﻀﺎﻋﻒ ﺍﻟﺪﻗﺔ ﺑﺎﺳﺘﺨﺪﺍﻡ

%lf

%f

 ﺭﻣﺰ ﻧﺼﻲ

(string)

%s

  %

 ﻳﻄﺒﻊ

%%

)

 ﺟﺪﻭﻝ

2

 .

( ﺭﻣﻮﺯ ﺃﻧﻮﺍﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ

:ﻣﺜﺎﻝ

 .

ﺍﻟﻤﺜﺎﻝ ﺍﻟﺘﺎﻟﻲ ﻳﺒﻴﻦ ﻋﺪﺓ ﺍﺳﺘﺨﺪﺍﻣﺎﺕ ﻟﻤﺤﺪﺩ ﺍﻟﻨﻮﻉ

#include<stdio.h> 

 main(){ 

 float x=123.456; 

 printf("%-5.2f\n",x); 

 printf("%5.2f\n",3.234); 

 printf("%10s\n","hello"); 

 printf("%-s\n","hello"); 

 printf("%5.7s\n","abcdefghijk"); } 

 :

ﺳﻴﻜﻮﻥ ﺍﻟﺘﻨﻔﻴﺬ

123.46 

□□3.23 
□□□□□hello 

Hello 

abcdefg 

 ﺣﻴﺚ ﻳﻤﺜﻞ ﺍﻟﺮﻣﺰ

□

  ﻓﺮﺍﻍ

(space)

. 

 ﺍﻹﺩﺧﺎﻝ )ﺍﻟﻘﺮﺍءﺓ( ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ

scanf( )

: 

 ﺗﺴﺘﺨﺪﻡ ﺍﻟﺪﺍﻟﺔ

scanf( )

 :

  ﻟﻌﻤﻠﻴﺔ ﺍﻟﻘﺮﺍءﺓ )ﺍﻹﺩﺧﺎﻝ( ﻭﺍﻟﺘﻲ ﺗﺄﺧﺬ ﺍﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ

scanf(<control string>, <list of variables to store values in>); 

ﺟﻤﻠﺔ ﺍﻟﺴﻴﻄﺮﺓ

 ﺗﺘﻜﻮﻥ ﺟﻤﻠﺔ ﺍﻟﺴﻴﻄﺮﺓ

(control string)

 :

 ﻣﻦ

•

 ﻣﺤﺪﺩﺍﺕ ﺍﻟﻨﻮﻉ

(format specifiers)

  ﻭﻳﻠﻴﻪ ﺭﻣﺰ% ﺰﻣﺮﻟﺍ ﻦﻣ ﻉﻮﻨﻟﺍ ﺩﺪﺤﻣ ﻥﻮﻜﺘﻳ : 

)

 ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﻤﻄﻠﻮﺏ ﻗﺮﺍءﺗﻬﺎ ﻭﻫﻲ ﻧﻔﺴﻬﺎ ﺍﻟﺘﻲ ﺫﻛﺮﺕ ﻓﻲ ﺍﻟﺠﺪﻭﻝ ﺭﻗﻢ

2

.(

•

 ﺍﻟﺮﻣﻮﺯ ﻏﻴﺮ ﺍﻟﻤﺮﺋﻴﺔ

(white space characters)

  ﻫﺬﻩ ﺍﻟﺮﻣﻮﺯ ﻫﻲ ﺍﻟﻔﺮﺍﻍ: 

(space)

  ﺍﻟﺘﺎﺏ،

(tab)

  ﺃﻭ ﺍﻟﺴﻄﺮ ﺍﻟﺠﺪﻳﺪ

(new line)

  . ﻭﺟﻮﺩ ﺃﺣﺪ ﻫﺬﻩ ﺍﻟﺮﻣﻮﺯ ﻓﻲ ﺟﻤﻠﺔ

 ﺍﻟﺴﻴﻄﺮﺓ ﻳﺆﺩﻱ ﺇﻟﻰ ﺇﻫﻤﺎﻝ ﻛﺎﻓﺔ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻐﻴﺮ ﻣﺮﺋﻴﺔ ﻓﻲ ﻣﺠﺮﻯ ﺍﻟﻘﺮﺍءﺓ ﻟﻐﺎﻳﺔ ﺃﻭﻝ ﺭﻣﺰ

.

ﻣﺮﺋﻲ

•

  ﻭﺟﻮﺩ ﺃﺣﺪ ﻫﺬﻩ ﺍﻟﺮﻣﻮﺯ ﻳﺆﺩﻱ ﺑﺎﻟﺪﺍﻟﺔ: ﺔﻴﺋﺮﻤﻟﺍ ﺯﻮﻣﺮﻟﺍ

scanf( )

  ﺇﻟﻰ ﻣﻄﺎﺑﻘﺔ ﻫﺬﺍ ﺍﻟﺮﻣﺰ

  ﺇﺫﺍ ﻛﺎﻧﺖ ﺟﻤﻠﺔ ﺍﻟﺴﻴﻄﺮﺓًﻼﺜﻤﻓ . ﺓءﻭﺮﻘﻤﻟﺍ ﺕﺎﻧﺎﻴﺒﻟﺍ ﻲﻓ ﺩﻮﺟﻮﻤﻟﺍ ﺰﻣﺮﻟﺍ ﻊﻣ

"%d,%d"

 ﻓﺄﻥ

scanf( )

  ﺳﺘﻘﻮﻡ ﺑﻘﺮﺍءﺓ ﺍﻟﻌﺪﺩ ﺍﻟﺼﺤﻴﺢ ﺍﻷﻭﻝ ﻭﻣﻦ ﺛﻢ ﻗﺮﺍءﺓ ﻭ ﺇﻫﻤﺎﻝ ﺍﻟﻔﺎﺭﺯﺓ

","

 ﻭﻣﻦ ﺛﻢ ﻗﺮﺍءﺓ ﺍﻟﻌﺪﺩ ﺍﻟﺼﺤﻴﺢ ﺍﻟﺜﺎﻧﻲ . ﺃﻣﺎ ﺇﺫﺍ ﻟﻢ ﺗﺠﺪ

scanf( )

  ﺍﻟﺮﻣﺰ

","

  ﻓﻲ ﺍﻟﺒﻴﺎﻧﺎﺕ

 ﺍﻟﻤﻘﺮﻭءﺓ ﻓﻬﺬﺍ ﺳﻮﻑ ﻳﺆﺩﻱ ﺇﻟﻰ ﺗﻮﻗﻒ

scanf( )

.

 ﻭ ﻓﺸﻞ ﻋﻤﻠﻴﺔ ﺍﻟﻘﺮﺍءﺓ

ﻗﺎﺋﻤﺔ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ

 ﺗﺤﻮﻱ ﻫﺬﻩ ﺍﻟﻘﺎﺋﻤﺔ

(variable list)

  ﻋﻠﻰ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ ﺍﻟﺘﻲ ﺳﻮﻑ ﺗﺨﺰﻥ ﻓﻴﻬﺎ ﺍﻟﻘﻴﻢ ﺍﻟﺘﻲ ﺗﻘﺮﺃ ﻣﻦ

 ﻗﺒﻞ

scanf( )

  ﻭﻳﺴﺒﻖ ﻛﻞ ﻣﺘﻐﻴﺮ ﺑﺎﻟﺮﻣﺰ

&

  ﻭﺍﻟﺬﻱ ﻳﺸﻴﺮ ﺇﻟﻰ ﻣﻮﻗﻊ ﺍﻟﻤﻜﺎﻥ ﺍﻟﻤﺨﺼﺺ ﻟﻠﻤﺘﻐﻴﺮ ﻓﻲ

  ﻟﻘﺮﺍءﺓ ﻋﺪﺩ ﺻﺤﻴﺢ ﻭ ﺧﺰﻧﻪ ﻓﻲ ﻣﺘﻐﻴﺮ ﺍﺳﻤﻪ، ًﻼﺜﻤﻓ .ﺓﺮﻛﺍﺬﻟﺍ

count

 :

 ﻧﺴﺘﺨﺪﻡ ﺍﻹﻳﻌﺎﺯ

scanf("%d",&count); 

  ﻣﻊ ﻛﺎﻓﺔ ﺃﻧﻮﺍﻉ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ ﻋﺪﺍ ﺍﻟﻤﺘﻐﻴﺮ ﻣﻦ ﺍﻟﻨﻮﻉ ﺍﻟﻨﺼﻲ& ﺰﻣﺮﻟﺍ ﻡﺪﺨﺘﺴﻳ

(string)

  . 

 ، ﻳﺠﺐ ﺃﻥ ﻳﻔﺼﻞ ﺑﻴﻦ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﻤﻘﺮﻭءﺓ ﺃﺣﺪ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻐﻴﺮ ﻣﺮﺋﻴﺔ ﻓﻲ ﺣﺎﻟﺔ ﻗﺮﺍءﺓ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﻌﺪﺩﻳﺔ

:

ﺍﻹﻳﻌﺎﺯًﻼﺜﻣ

scanf("%d%d",&x,&y); 

 ﻳﺘﻘﺒﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ

10

□20

  ﻭﻟﻜﻨﻪ ﺳﻴﻔﺸﻞ ﻋﻨﺪ ﻗﺮﺍءﺓ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺑﺎﻟﺸﻜﻞ

10,20

 . 

:

 ﻋﻨﺪ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺘﺎﻟﻲ:ﻝﺎﺜﻣ

scanf("%d %*d %d",&x,&y); 

                                                                     :

ﻟﻘﺮﺍءﺓ ﺍﻟﺒﻴﺎﻧﺎﺕ

123 456 789     

 ﻓﺄﻥ

scanf( )

  ﺳﻮﻑ ﺗﻘﺮﺃ ﺍﻟﻌﺪﺩ

123

  ﻭﺗﺨﺰﻧﻪ ﻓﻲ ﺍﻟﻤﺘﻐﻴﺮ

x

  ﻭﻣﻦ ﺛﻢ ﺗﻘﺮﺃ ﻭ ﺗﻬﻤﻞ ﺍﻟﻌﺪﺩ

456

 ﻭﺫﻟﻚ ﻟﻜﻮﻥ ﺍﻟﻤﺤﺪﺩ ﻣﻦ ﻧﻮﻉ

%*

  ﺗﻘﺮﺃ ﺍﻟﻌﺪﺩًﺍﺮﻴﺧﺃﻭ ، (ﻥﺰﺧ ﻡﺪﻋ) ﻝﺎﻤﻫﺇﻭ ﺓءﺍﺮﻗ ﻲﻨﻌﻳﻭ 

789

 ﻭﺗﺨﺰﻧﻪ ﻓﻲ ﺍﻟﻤﺘﻐﻴﺮ

y

 . 

2

 :(ﺍﻟﻤﺠﻤﻮﻋﺔ ﺍﻟﺜﺎﻧﻴﺔ

 ﺗﻮﻓﺮ ﻟﻐﺔ

C

P

++

P

 ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﻭ ﺍﻟﺮﻭﺗﻴﻨﻴﺎ

ﺕ

  ﺍﻟﻤﻌﺮﻓﺔ ﺿﻤﻦ

iostream

  ﻣﺜﻞ

cout<<

 ﻟﻺﺧﺮﺍﺝ ﻭ

cin>>

  ﻟﻺﺩﺧﺎﻝ. ﻭﺍﻟﻤﻠﻒ

iostream.h

 :

 ﻳﻌﻨﻲ

stream

 .

 ﻣﻜﺘﺒﺔ ﺗﺪﻓﻖ ﺍﻟﻤﻌﻠﻮﻣﺎﺕ ﺍﻟﺨﺎﺻﺔ ﺑﺎﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ: 

io

: 

 ـ ﻣﺨﺘﺼﺮ ﻟ

input/output

 .

 ﺁﻱ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ

h

: 

header file

.

 ﺁﻱ ﺍﻟﻤﻠﻒ ﺍﻟﺪﻟﻴﻞ

 ﺍﻹﺧﺮﺍﺝ )ﺍﻟﻜﺘﺎﺑﺔ( ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ

cout<<

:

 ﺍﻟﻄﺒﺎﻋﺔ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ

cout<< 

  ﻳﻜﻮﻥ ﺃﺳﻬﻞ ﻓﻲ ﺍﻟﻄﺒﺎﻋﺔ ﻣﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ

printf( )

  ﺣﻴﺚ

  ﺑﻌﺪ ﻋﻼﻣﺔ ﻣﻌﺎﻣﻞ ﺍﻹﺩﻣﺎﺝ ﺃﻱ ﺍﻟﺮﻣﺰًﺎﺗﺮﺷﺎﺒﻣ ﻪﻌﺿﻮﺑ ﻥﻮﻜﻳ ﻲﺷ ﻱﺃ ﺔﻋﺎﺒﻄﻟ ﺎﻨﻫ

<<

  ﺣﻴﺚ ﻫﺬﺍ

 ﺍﻟﻤﻌﺎﻣﻞ ﻳﻘﻮﻡ ﺑﻮﺿﻊ ﺧﺮﺝ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﻣﺠﺮﻯ ﺍﻟﺨﺮﺝ ﺍﻟﻤﺴﻤﻰ ﻋﻠﻰ ﻳﺴﺎﺭﻩ ﺍﻟﺬﻱ ﻫﻮ

cout

  ﺍﻟﺬﻱ

 ﻳﺸﻴﺮ ﺇﻟﻰ ﺷﺎﺷﺔ ﺍﻟﺤﺎﺳﺐ ﻟﺬﻟﻚ ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﺍﻟﺠﻤﻠﺔ

cout<<76

  ﺳﻮﻑ ﻳﻈﻬﺮ ﺍﻟﺮﻗﻢ

76

 ، ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ

 ﻣﻦ ﻫﻨﺎ ﻧﻌﺮﻑ ﺍﻧﻪ ﻗﺒﻞ ﻛﻞ ﺷﻲ ﻧﺤﺘﺎﺝ ﻃﺒﺎﻋﺘﻪ ﻳﺠﺐ ﺃﻥ ﻧﻀﻊ ﺍﻟﻤﻌﺎﻣﻞ

<<

  ﺃﻱ ﺃﺫﺍ ﺍﺣﺘﺠﻨﺎ ﻃﺒﺎﻋﺔ

 ﺃﻛﺜﺮ ﻣﻦ ﻣﺘﻐﻴﺮ ﺃﻭ ﺛﺎﺑﺖ ﻓﻲ ﺟﻤﻠﺔ ﻭﺍﺣﺪﺓ ﻳﺠﺐ ﻭﺿﻊ ﺍﻟﻤﻌﺎﻣﻞ

<<

 .

 ﻗﺒﻞ ﻛﻞ ﻭﺍﺣﺪ ﻣﻨﻬﻢ

 ﻣﻌﺎﻣﻞ ﺍﻟﺨﺮﺝ

<<

  ﻳﻘﻮﻡ ﺑﺈﺭﺳﺎﻝ ﻗﻴﻤﺔ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﻌﺒﻴﺮﻳﺔ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻋﻠﻰ ﻳﻤﻴﻨﻪ ﺇﻟﻰ ﻣﺠﺮﻯ ﺍﻟﺨﺮﺝ

 ﺍﻟﻤﻮﺟﻮﺩﺓ ﻋﻠﻰ ﻳﺴﺎﺭﻩ ﻭﺣﻴﺚ ﺃﻥ ﺗﻨﻔﻴﺬ ﻫﺬﺍ ﺍﻟﻌﻤﻞ ﻳﺘﻢ ﻣﻦ ﺍﻟﻴﻤﻴﻦ ﺇﻟﻰ ﺍﻟﻴﺴﺎﺭ ﻟﺬﻟﻚ ﺗﻢ ﺍﺧﺘﻴﺎﺭ ﺍﻟﺮﻣﺰ

<<

 .

 ﻟﻴﻤﺜﻞ ﻣﻌﺎﻣﻞ ﺍﻟﺨﺮﺝ. ﻳﺠﺐ ﺃﻥ ﺗﺘﺬﻛﺮ ﺃﻥ ﺍﺗﺠﺎﻩ ﺍﻟﺴﻬﻢ ﻳﺸﻴﺮ ﺇﻟﻰ ﺍﻟﻴﺴﺎﺭ

 :

ﻣﺜﺎﻝ

#include < iostream.h> 
main ( ) 
{ 
cout<<“smoking is dangerous \n”; 
}

 ﺇﻥ ﺍﻟﻌﻼﻣﺔ

\n

 ﺗﻤﺜﻞ ﺍﻻﻧﺘﻘﺎ

ﻝ

  ﺇﻟﻰ ﺳﻄﺮ ﺟﺪﻳﺪ ﻭﻣﻤﻜﻦ ﺃﻥ ﻧﺴﺘﺨﺪﻡ ﺍﻟﻌﺒﺎﺭﺓ

endl

#include < iostream.h> 
main ( ) 
{ 
cout<<“ smoking is dangerous”<<endl; 
}

:

ﻣﺜﺎﻝ

   ﻟﻄﺒﺎﻋﺔ ﺃﻛﺜﺮ ﻣﻦ ﻣﺘﻐﻴﺮ ﻣﻊ ﻧﺼﻮﺹ ﻣﻤﻜﻦ ﺃﻥ ﻧﻜﺘﺐ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ

#include < iostream.h> 
main ( ) 
{ 
int a=100; 
float x=4.25; 
cout<<“a=”<<a<<“\n”<<“x=”<<x; 
}

  ﺳﻴﻜﻮﻥ ﻧﺎﺗﺞ ﺍﻟﻄﺒﺎﻋﺔ

a= 100

x= 4.25

 ﺍﻹﺩﺧﺎﻝ )ﺍﻟﻘﺮﺍءﺓ( ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ

cin>>

: 

 ﻓﻲ ﻟﻐﺔ

C

P

++

P

  ﺍﻹﺩﺧﺎﻝ ﻫﻮ ﺍﻟﻤﻨﺎﻇﺮ ﻟﻺﺧﺮﺍﺝ . ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺨﺎﺭﺟﺔ ﻣﻦ ﺗﻨﻔﻴﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺗﻤﺮ ﻓﻲ ﻣﺠﺮﻯ

 ﺍﻟﺨﺮﺝ

cout

  ﻭﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺪﺍﺧﻠﺔ ﻣﻦ ﻟﻮﺣﺔ ﺍﻟﻤﻔﺎﺗﻴﺢ ﺇﻟﻰ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺃﺛﻨﺎء ﺍﻟﺘﺸﻐﻴﻞ ﺗﻤﺮ ﻓﻲ ﻣﺠﺮﻯ

 ﺍﻟﺪﺧﻞ

cin

  ﻭﺍﺗﺠﺎﻩ ﺍﻟﺴﻬﻢ ﻓﻲ ﺣﺎﻟﺔ ﺍﻹﺩﺧﺎﻝ ﻳﻜﻮﻥ

>>

 :

 ﺃﻱ ﻋﻜﺲ ﺍﻹﺧﺮﺍﺝ ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺑﻌﺾ ﺍﻷﻣﺜﻠﺔ

ﻣﻼﺣﻈﺔ

 ﻻ

ﻳﺠﻮﺯ

ﺃﻥ

ﻧﺴﺘﺨﺪﻡ

ﺍﻟﻤﺘﻐﻴﺮ

ﻗﺒﻞ

ﺗﻌﺮﻳﻔﺔ

.

#include < iostream.h>” 
main ( ){ 
int a; 
cin>>a; 
cout<<a; 
} 

:

ﻣﺜﺎﻝ

ﺍﻛﺘﺐ

ﺑﺮﻧﺎﻣﺠﺎ

ﻹﺩﺧﺎﻝ

ﻋﻤﺮﻙ

ﺛﻢ

ﻃﺒﺎﻋﺘﻪ

، 

ﻭﻃﺒﺎﻋﺔ

ﻧﺼﻔﻪ

؟ﻭﺿﻌﻔﻪ

#include < iostream.h> 
main ( ){ 
int a; 
cin>>a; 
cout<<a; 
cout<<a/2; 
cout<<a*2; 
} 

ﻣﺜﺎﻝ

 ﺍﻛﺘﺐ:

ﺑﺮﻧﺎﻣﺞ

ﻹﺩﺧﺎﻝ

ﺛﻼﺙ

ﺩﺭﺟﺎﺕ

ﻟﻄﺎﻟﺐ ﻭﻃﺒﺎﻋﺔ

ﻣﻌﺪﻝ

 ؟ﺍﻟﺪﺭﺟﺎﺕ

#include < iostream.h> 
main ( ) { 
int a,b,c; 
cin>>a>>b>>c; 
cout<<(a+b+c)/3; 
} 

) ﻣﺜﺎﻝ

1

:(

  ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺘﺎ ﻣﺘﻐﻴﺮﻳﻦ

x

  ﻭ

y 

  ﻣﻦ ﻧﻮﻉ ﻋﺪﺩ ﺻﺤﻴﺢ ﻫﻲ

10

  ﻭ

15

  ﻋﻠﻰ ﺍﻟﺘﺮﺗﻴﺐ ﻓﻤﺎ

 ﻫﻲ ﻗﻴﻤﺔ ﻛﻞ ﻣﻦ

x

 ، 

y

  ﻭ

z

 :

 ﺑﻌﺪ ﺗﻨﻔﻴﺬ ﻛﻞ ﻣﻦ ﺍﻹﻳﻌﺎﺯﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ

i.

  z = x++ + y++                    z=25             x=11          y = 16 

ii.

  z = ++x + y--                      z = 26           x = 11        y = 14 

iii.

  z = ( x*=2, x % ++y)          z = 4             x = 20        y = 16  

) ﻣﺜﺎﻝ

2

:(

 .

 ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮﻡ ﺑﻘﺮﺍءﺓ ﺛﻼﺛﺔ ﺃﺭﻗﺎﻡ ﻭ ﻳﻜﺘﺐ ﻣﻌﺪﻟﻬﺎ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ

#include<stdio.h> 

main( ){ 

int x,y,z; 

float av; 

scanf("%d%d%d",&x,&y,&z); 

av=(x+y+z)/3; 

printf("\n av= %f",av); 

} 

) ﻣﺜﺎﻝ

3

:(

 .

 ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺤﺴﺎﺏ ﻣﺴﺎﺣﺔ ﺩﺍﺋﺮﺓ ﻋﻨﺪ ﺇﺩﺧﺎﻝ ﻧﺼﻒ ﻗﻄﺮﻫﺎ

#include<stdio.h> 

main( ){ 

float r,a,p=3.14; 

printf("input radius:"); 

scanf("%f",&r); 

a=r*r*p; 

printf("\n the area = %f",a); 

} 

 ﺍﻟﺘﺮﺍﻛﻴﺐ ﺍﻟﺸﺮﻃﻴﺔ ﻭ ﺍﻟﺘﻜﺮﺍﺭﻳﺔ

:ﺍﻟﺘﺮﺍﻛﻴﺐ ﺍﻟﺸﺮﻃﻴﺔ

 ﺗﻮﻓﺮ ﻟﻐﺔ

++

C

  ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻹﻳﻌﺎﺯﺍﺕ ﺍﻟﺸﺮﻃﻴﺔ ﺍﻟﺘﻲ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻘﻬﺎ ﺗﻨﻔﻴﺬ ﻣﺠﻤﻮﻋﺔ ﻣﻦ

  ﻣﺨﺘﻠﻔﺔ ﻭًﻻﺎﻜﺷﺃ ﻲﻃﺮﺸﻟﺍ ﺯﺎﻌﻳﻹﺍ ﺬﺨﺘﻳﻭ .ﺔﻨﻴﻌﻣ ﻁﻭﺮﺷ ﻖﻘﺤﺗ ءﻮﺿ ﻲﻓ ﺎﻫﺮﻴﻏ ﻥﻭﺩ ﺕﺍﺯﺎﻌﻳﻻﺍ

 .

ﺍﻟﺘﻲ ﺳﻨﻮﺿﺤﻬﺎ ﻓﻲ ﺍﻟﻔﻘﺮﺍﺕ ﺃﺩﻧﺎﻩ

1

.

 ﺍﻹﻳﻌﺎﺯ ﺍﻟﺸﺮﻃﻲ

if – else

: 

 :

ﻭﻳﻤﺜﻞ ﻫﺬﺍ ﺍﻟﺘﺮﻛﻴﺐ ﺑﺎﻟﺼﻴﻐﺔ ﺍﻟﻘﺎﻋﺪﻳﺔ ﺍﻟﺘﺎﻟﻴﺔ

If ( expression ) 

      Statement_1; 

else 

      statement_2; 

 ﺣﻴﺚ ﻳﻤﻜﻦ ﺃﻥ ﺗﻜﻮﻥ ﻛﻞ ﻣﻦ ﺍﻟﻌﺒﺎﺭﺗﻴﻦ

statement_1& statement_2

  ﻋﺒﺎﺭﺓ ﺑﺴﻴﻄﺔ

(simple statement)

  ﺃﻭ ﻣﺮﻛﺒﺔ

(compound statement)

  ﻭﺍﻟﺘﻲ ﺑﺪﻭﺭﻫﺎ ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻦ

 ﻣﺠﻤﻮﻋﺔ ﻋﺒﺎﺭﺍﺕ ﺑﺴﻴﻄﺔ ﻣﺤﺼﻮﺭﺓ ﺩﺍﺧﻞ ﺍﻟﻘﻮﺳﻴﻦ

{ }

  .  ﻭ ﻳﺴﺘﺨﺪﻡ ﻣﺼﻄﻠﺢ ﺍﻟﻌﺒﺎﺭﺓ

(statement)

  ﺑﺼﻮﺭﺓ ﻋﺎﻣﺔ ﻟﻺﺷﺎﺭﺓ ﺇﻟﻰ ﻋﺒﺎﺭﺓ ﺑﺴﻴﻄﺔ ﺃﻭ ﻋﺒﺎﺭﺓ ﻣﺮﻛﺒﺔ. ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻤﻘﺪﺍﺭ

(expression)

  ﺳﺎﻟﺒﺔ ﺃﻭ ﻣﻮﺟﺒﺔ ﻓﺴﻴﻨﻔﺬ

statement_1

  ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻘﻴﻤﺔ ﺻﻔﺮ ﻓﺴﻴﻨﻔﺬ ﺍﻹﻳﻌﺎﺯ

statement_2

  . ﻻﺣﻆ ﺃﻧﻪ ﻓﻲ ﻟﻐﺔ

++

C

  ﻗﻴﻤﺔ ﺍﻟﺘﻌﺒﻴﺮ ﺇﺫﺍ ﻛﺎﻧﺖ ﺃﻱ ﻋﺪﺩ ﻏﻴﺮ ﺍﻟﺼﻔﺮ ﺗﻌﻨﻲ

 ﺍﻹﻳﺠﺎﺏ

(true)

  ﻭﻗﻴﻤﺔ ﺍﻟﺼﻔﺮ ﺗﻌﻨﻲ ﺍﻟﻨﻔﻲ

(false)

  . ﻛﻤﺎ ﺗﻢ ﺍﻹﺷﺎﺭﺓ ﺇﻟﻰ ﺫﻟﻚ ﻓﻲ ﺃﺩﻭﺍﺕ ﺍﻟﻌﻼﻗﺔ

 .

)ﺍﻟﻤﻘﺎﺭﻧﺔ( ﻭ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻤﻨﻄﻘﻴﺔ

)

 ﻣﺜﺎﻝ

1

:(

if(x>y) 

Max=x; 

else 

Max=y; 

)

 ﻣﺜﺎﻝ

2

:(

if(x>y){ 

Max=x; 

Min=y;} 

else{ 

Max=y; 

Min=x; 

} 

 ﻻﺣﻆ ﻓﻲ ﻫﺬﺍ ﺍﻟﻤﺜﺎﻝ ﺍﺳﺘﺨﺪﻣﺖ ﺍﻷﻗﻮﺍﺱ

{ }

  ﻭﺫﻟﻚ ﻟﻮﺟﻮﺩ ﺃﻛﺜﺮ ﻣﻦ ﻋﺒﺎﺭﺓ ﺑﺴﻴﻄﺔ ﻭﺍﺣﺪﺓ ﻳﺠﺐ

.

ﺗﻨﻔﻴﺬﻫﺎ ﻓﻲ ﻛﻼ ﺍﻟﺤﺎﻟﺘﻴﻦ

)

 ﻣﺜﺎﻝ

3

:(

 :

 ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﺭﻗﻢ ﺻﺤﻴﺢ ﻭ ﻳﻄﺒﻊ ﻓﻴﻤﺎ ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﺮﻗﻢ ﺯﻭﺟﻲ ﺃﻡ ﻓﺮﺩﻱ

#include<iostream.h> 

main( ){ 

int number; 

cout<<"\n Enter an integer: "; 

cin>>number; 

if(number%2==0) 

cout<<"\n Number "<<number<<" is even."; 

else 

cout<<"\n Number "<<number<<" is odd."; 

} 

 ﺍﻟﺠﺰء ﺍﻟﺜﺎﻧﻲ ﻣﻦ ﻋﺒﺎﺭﺓ

if-else

  ﻳﻤﻜﻦ ﺃﻥ ﻳﻜﻮﻥ ﺍﺧﺘﻴﺎﺭﻳﺎ ﻋﻨﺪ ﻋﺪﻡ ﺍﻟﺤﺎﺟﺔ ﺇﻟﻴﻪ ﻭﻓﻲ ﻫﺬﻩ ﺍﻟﺤﺎﻟﺔ

 :

ﺗﻜﻮﻥ ﺍﻟﺼﻴﻐﺔ ﺍﻟﻘﺎﻋﺪﻳﺔ ﻟﻺﻳﻌﺎﺯ

if ( expression ) 

    statement; 

 ﻓﻲ ﻫﺬﻩ ﺍﻟﺤﺎﻟﺔ ﺗﻨﻔﺬ ﺍﻟﻌﺒﺎﺭﺓ

statement

  ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻤﻘﺪﺍﺭ ﺍﻟﻤﻨﻄﻘﻴﺔ ﻧﻌﻢ

(true)

  . ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ

 ﻗﻴﻤﺔ ﺍﻟﻤﻘﺪﺍﺭ ﺍﻟﻤﻨﻄﻘﻴﺔ ﻛﻼ

(false)

  ﻓﺴﻴﺴﺘﻤﺮ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺩﻭﻥ ﺗﻨﻔﻴﺬ ﺍﻟﻌﺒﺎﺭﺓ

statement

 . 

2

.

 ﺍﻹﻳﻌﺎﺯ ﺍﻟﺸﺮﻃﻲ

if-else

:  ﺍﻟﻤﺘﺪﺍﺧﻞ

     ﺇﻳﻌﺎﺯ

if-else

  ﺍﻟﻤﺘﺪﺍﺧﻞ ﻳﻌﻨﻲ ﺃﻥ ﻳﻜﻮﻥ ﺍﻹﻳﻌﺎﺯ

if-else

  ﻧﻔﺴﻪ ﻛﺄﺣﺪ ﻋﺒﺎﺭﺍﺕ ﺇﻳﻌﺎﺯ

if-else

)

 ﺃﺧﺮ ﻛﻤﺎ ﻣﺒﻴﻦ ﻓﻲ ﺍﻟﻤﺜﺎﻝ

4

 .

( ﺃﺩﻧﺎﻩ

)

 ﻣﺜﺎﻝ

4

:(

 :

 ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﺛﻼﺛﺔ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﻭﻳﻜﺘﺐ ﺃﻛﺒﺮﻫﺎ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ

#include<iostream.h> 
main( ){ 
int a,b,c; 
cout<<"\n Enter three integers: "; 
cin>>a>>b>>c; 
if(a>b) 
if(a>c)cout<<"\n Max= "<<a; 
else cout<<"\n Max= "<<c; 
else 
if(b>c)cout<<"\n Max= "<<b; 
else cout<<"\n Max= "<<c; 
} 

 ﻋﻨﺪ ﺍﺳﺘﺨﺪﺍﻡ ﺇﻳﻌﺎﺯ

if-else 

  ﺍﻟﻤﺘﺪﺍﺧﻞ ﻭﻋﻨﺪﻣﺎ ﻻ ﻳﻮﺟﺪ ﺍﻟﺠﺰء

else

  ﻟﻮﺍﺣﺪﺓ ﺃﻭ ﺃﻛﺜﺮ ﻣﻦ ﻋﺒﺎﺭﺍﺕ

if

  ﻗﺪ ﻳﻜﻮﻥ ﻫﻨﺎﻙ ﻏﻤﻮﺽ ﻟﻠﻤﺒﺮﻣﺞ ﻭﻫﻮ ﻷﻱ

if

  ﺗﺘﺒﻊ ﻛﻞ

else

  ﺍﻟﺠﻮﺍﺏ ﻫﻮ ﺃﻧﻪ ﻓﻲ ﻟﻐﺔ؟ 

++

C

 ﻭﻋﻨﺪ ﻋﺪﻡ ﺍﻻﺳﺘﻌﺎﻧﺔ ﺑﺎﻷﻗﻮﺍﺱ ﻟﺘﺤﺪﻳﺪ ﺍﻟﻌﺎﺋﺪﻳﺔ ﺗﺮﺗﺒﻂ ﻛﻞ

else

  ﺑﺄﻗﺮﺏ

if

 ـ ﻏﻴﺮ ﻣﺮﺗﺒﻄﺔ ﺑ

else

 . 

 :

ﻭﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻷﻗﻮﺍﺱ ﻟﺘﻐﻴﻴﺮ ﻫﺬﻩ ﺍﻟﻘﺎﻋﺪﺓ ﻛﻤﺎ ﻳﻠﻲ

if (expression_1){ 

    if (expression_2) 

       statement_1; 

} 

else 

     statement_2; 

 ﻓﻲ ﻫﺬﻩ ﺍﻟﺤﺎﻟﺔ ﺳﺘﻨﻔﺬ ﺍﻟﻌﺒﺎﺭﺓ

statement_1

  ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﻛﻞ ﻣﻦ ﺍﻟﻤﻘﺪﺍﺭﻳﻦ

expression_1

  ﻭ

expression_2

 . ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ"ﻢﻌﻧ" 

expression_1

"

ﻛﻼ"

  ﻓﺴﺘﻨﻔﺬ ﺍﻟﻌﺒﺎﺭﺓ

statement_2

  . ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ

expression_1

  ﻭﻗﻴﻤﺔ"ﻢﻌﻧ" 

expression_2

  ﻓﻠﻦ"ﻼﻛ" 

 .

ﻳﺤﺪﺙ ﺷﻲء

3

.

 ﺍﻹﻳﻌﺎﺯ ﺍﻟﺸﺮﻃﻲ

if-else if

: 

 :

ﺍﻟﺸﻜﻞ ﺍﻟﻘﻮﺍﻋﺪﻱ ﻟﻬﺬﺍ ﺍﻹﻳﻌﺎﺯ ﻫﻮ ﻛﺂﻻﺗﻲ

if (expression_1) 
    statement_1; 
else if (expression_2) 
          statement_2; 
else if (expression_3) 
       statement_3; 
…………………… 
else if (expression_n) 
           statement_n; 
else 
     statement_last; 

 ﻳﻘﻮﻡ ﺍﻟﻤﻌﺎﻟﺞ ﺑﺎﺣﺘﺴﺎﺏ ﺍﻟﻘﻴﻢ ﺍﻟﻤﻨﻄﻘﻴﺔ ﻟﻠﻌﺒﺎﺭﺍﺕ ﺍﻟﻤﻨﻄﻘﻴﺔ ﻣﻦ ﺍﻷﻋﻠﻰ ﺇﻟﻰ ﺍﻷﺳﻔﻞ ﻭﻳﻘﻮﻡ ﺑﺘﻨﻔﻴﺬ ﺃﻭﻝ

 ﻣﺠﻤﻮﻋﺔ ﺇﻳﻌﺎﺯﺍﺕ

(statement_i)

  ﻟﻠﺠﺰء

i

  ﺍﻟﺬﻱ ﺗﻜﻮﻥ ﻗﻴﻤﺘﻪ ﺍﻟﻤﻨﻄﻘﻴﺔ ﻟﻠﻌﺒﺎﺭﺓ

expression_i

  ﻭﺗﻬﻤﻞ ﺑﺎﻗﻲ ﺍﻷﺟﺰﺍء ﻭﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺬﻱ ﻳﻠﻲ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺸﺮﻃﻲ"ﻢﻌﻧ"

if-else if

  . ﺃﻣﺎ

 ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻨﻄﻘﻴﺔ ﻟﻜﺎﻓﺔ ﺍﻟﻌﺒﺎﺭﺍﺕ

expression_i

  ﻓﻔﻲ ﻫﺬﻩ ﺍﻟﺤﺎﻟﺔ ﺗﻨﻔﺬ ﻣﺠﻤﻮﻋﺔ"ﻼﻛ" 

 ﺍﻹﻳﻌﺎﺯﺍﺕ ﺍﻷﺧﻴﺮﺓ

statement_last

  . ﺍﻟﺠﺰء ﺍﻷﺧﻴﺮ ﻣﻦ ﺍﻹﻳﻌﺎﺯ ﺍﺧﺘﻴﺎﺭﻱ. ﻓﻲ ﺣﺎﻟﺔ ﻋﺪﻡ ﻭﺟﻮﺩ

 ﻫﺬﺍ ﺍﻟﺠﺰء ﻭﻛﻮﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻨﻄﻘﻴﺔ ﻟﻜﺎﻓﺔ ﺍﻟﻌﺒﺎﺭﺍﺕ

expression_i

  ﻓﺴﻮﻑ ﻟﻦ ﺗﻨﻔﺬ ﺃﻱ"ﻼﻛ" 

 ﺇﻳﻌﺎﺯﺍﺕ ﻭﻳﺴﺘﻤﺮ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﻨﻔﻴﺬ ﺍﻟﻌﺒﺎﺭﺍﺕ ﺍﻟﺘﻲ ﺗﻠﻲ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺸﺮﻃﻲ

if-else if

 . 

)

 ﻣﺜﺎﻝ

5

:(

 :

 ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﺛﻼﺛﺔ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﻭﻳﻜﺘﺐ ﺃﻛﺒﺮﻫﺎ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ

#include <iostream.h> 
main( ){ 
int max,a,b,c; 
cout<<"\n Enter three integers: "; 
cin>>a>>b>>c; 
if((a>=b)&&(a>=c)) 
max=a; 
else if((b>=a)&&(b>=c)) 
max=b; 
else 
max=c; 
cout<<"\n Maximum number is: "<<max; 
} 

4

.

 ﺍﻹﻳﻌﺎﺯ ﺍﻟﺸﺮﻃﻲ

switch

: 

 :

ﺍﻟﺸﻜﻞ ﺍﻟﻘﻮﺍﻋﺪﻱ ﻟﻬﺬﺍ ﺍﻹﻳﻌﺎﺯ ﻫﻮ

switch (integer expression) { 

        case constant_1: statements_ sequence_1; 

                                 break; 

        case constant_2: statements_ sequence_2; 

                                 break; 

        ……………………………………….. 

        case constant_n: statements_ sequence_n; 

                                 break; 

        default: statements_ sequence_last; 

}  

 ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻤﻘﺪﺍﺭ

(integer expression)

  ﻣﺴﺎﻭﻳﺔ ﺇﻟﻰ

constant_1

  ﻓﻴﺘﻢ ﺗﻨﻔﻴﺬ ﻣﺠﻤﻮﻋﺔ

 ﺍﻟﻌﺒﺎﺭﺍﺕ

statements_ sequence_1

  ﻭﻋﻨﺪ ﺗﻨﻔﻴﺬ ﺍﻹﻳﻌﺎﺯ

break

  ﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﻣﺒﺎﺷﺮﺓ ﺇﻟﻰ

 ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﻲ ﺗﻠﻲ ﺍﻹﻳﻌﺎﺯ

switch

  . ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻤﻘﺪﺍﺭ ﻣﺴﺎﻭﻳﺔ ﺇﻟﻰ

constant_2

  ﻓﻴﺘﻢ ﺗﻨﻔﻴﺬ

 ﻣﺠﻤﻮﻋﺔ ﺍﻟﻌﺒﺎﺭﺍﺕ

statements_ sequence_2

  ﻓﻘﻂ ﻭﻋﻨﺪ ﺗﻨﻔﻴﺬ ﺍﻹﻳﻌﺎﺯ

break

  ﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ

 ﺇﻟﻰ ﻣﺎ ﺑﻌﺪ ﺇﻳﻌﺎﺯ

switch

  ﻣﺒﺎﺷﺮﺓ ﻭﻫﻜﺬﺍ. ﺇﺫﺍ ﻟﻢ ﺗﻜﻦ ﻗﻴﻤﺔ ﺍﻟﻤﻘﺪﺍﺭ ﻣﺴﺎﻭﻳﺔ ﺇﻟﻰ ﺃﻱ ﻣﻦ ﺍﻟﺜﻮﺍﺑﺖ

constant_1, constant_2, ….

  ﻓﻌﻨﺪﺋﺬ ﺗﻨﻔﺬ ﻣﺠﻤﻮﻋﺔ ﺍﻟﻌﺒﺎﺭﺍﺕ

statements_ sequence_ 

last

  ﻓﻘﻂ. ﺍﻟﺠﺰء ﺍﻷﺧﻴﺮ ﻣﻦ ﺍﻹﻳﻌﺎﺯ

(default)

  ﺍﺧﺘﻴﺎﺭﻱ ﻭﻳﻤﻜﻦ ﺇﻫﻤﺎﻟﻪ ﻭﻓﻲ ﻫﺬﻩ ﺍﻟﺤﺎﻟﺔ ﻟﻦ ﺗﻨﻔﺬ

 .

ﺇﻟﻰ ﺃﺣﺪ ﺍﻟﺜﻮﺍﺑﺖًﺎﻳﻭﺎﺴﻣ ﺯﺎﻌﻳﻹﺍ ﺭﺍﺪﻘﻣ ﻦﻜﻳ ﻢﻟ ﺍﺫﺇ ﺓﺭﺎﺒﻋ ﻱﺃ

 ﺇﺫﺍ ﻟﻢ ﺗﻜﻦ ﻋﺒﺎﺭﺓ

break

  ﻣﻮﺟﻮﺩﺓ ﻓﻲ ﻧﻬﺎﻳﺔ ﺍﻟﻤﺠﻤﻮﻋﺔ ﺍﻟﺘﻲ ﻳﺒﺪﺃ ﻋﻨﺪﻫﺎ ﺍﻟﺘﻨﻔﻴﺬ ﻓﺴﻮﻑ ﻳﺴﺘﻤﺮ

 ﺍﻟﻤﻌﺎﻟﺞ ﺑﺘﻨﻔﻴﺬ ﻣﺠﻤﻮﻋﺔ ﺍﻟﻌﺒﺎﺭﺍﺕ ﺍﻟﻼﺣﻘﺔ ﻭﻫﻜﺬﺍ ﺇﻟﻰ ﺃﻥ ﻳﺼﺎﺩﻑ ﺍﻟﻤﻌﺎﻟﺞ ﻋﺒﺎﺭﺓ

break

  ﺃﻭ ﻳﺼﻞ

 ﺇﻟﻰ ﻧﻬﺎﻳﺔ ﺍﻹﻳﻌﺎﺯ

switch

 . 

)

 ﻣﺜﺎﻝ

6

:(

 :

 ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﻋﺪﺩ ﺻﺤﻴﺢ ﻭﻳﻜﺘﺐ ﺍﺳﻢ ﺍﻟﻴﻮﻡ ﺍﻟﺬﻱ ﻳﻘﺎﺑﻠﻪ

#include<iostream.h> 
main( ){ 
int number; 
cout<<"\n Enter a number in the range 1-7: "; 
cin>>number; 
switch (number) { 
case 1: cout<<"\n Saturday."; 
 

 break; 

case 2: cout<<"\n Sunday."; 
 

 break; 

case 3: cout<<"\n Monday."; 
 

 break; 

case 4: cout<<"\n Tuesday."; 
 

 break; 

case 5: cout<<"\n Wednesday."; 
 

 break; 

case 6: cout<<"\n Thursday."; 
 

 break; 

case 7:cout<<"\n Friday."; 
 

 break; 

default : cout<<"\n Number out of range!!"; 
} 
} 
 

 ﺍﻟﺘﺮﺍﻛﻴﺐ ﺍﻟﺘﻜﺮﺍﺭﻳﺔ

Loops

: 

 ﺗﻮﻓﺮ ﻟﻐﺔ

++

C

 :

 ﺛﻼﺛﺔ ﺃﻧﻮﺍﻉ ﻣﻦ ﺍﻟﺘﺮﺍﻛﻴﺐ ﺃﻭ ﺍﻹﻳﻌﺎﺯﺍﺕ ﺍﻟﺘﻜﺮﺍﺭﻳﺔ

•

 ﺍﻟﺘﺮﻛﻴﺐ ﺍﻟﺘﻜﺮﺍﺭﻱ

for

•

 ﺍﻟﺘﺮﻛﻴﺐ ﺍﻟﺘﻜﺮﺍﺭﻱ

while

•

 ﺍﻟﺘﺮﻛﻴﺐ ﺍﻟﺘﻜﺮﺍﺭﻱ

do – while 

1

(

 ﺍﻟﺘﺮﻛﻴﺐ ﺍﻟﺘﻜﺮﺍﺭﻱ

for

 :

ﺍﻟﺸﻜﻞ ﺍﻟﻘﻮﺍﻋﺪﻱ ﻟﻬﺬﺍ ﺍﻹﻳﻌﺎﺯ ﻫﻮ

for(initialization expression; expression; increment) 

statement;       /* body of the loop */ 

  ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﺍﻟﻘﺴﻢ ﺍﻷﻭﻝًﻻﻭﺃ ﺬﻔﻨﺗ :ﻲﻟﺎﺘﻟﺎﻛ ﺯﺎﻌﻳﻹﺍ ﺍﺬﻫ ﺬﻴﻔﻨﺗ ﺔﻘﻳﺮﻃ ﻒﺻﻭ ﻦﻜﻤﻳ

(initialization expression)

 ﺎﺯـــــﻌﻳﻹﺍ ﻰﻠﻋ ﺓﺮــﻄﻴﺴﻟﺍ ﺕﺍﺮﻴﻐﺘﻤﻟ ﺔـــــﻴﺋﺍﺪﺘﺑﻻﺍ ﻢﻴﻘﻟﺍ ﺪﻳﺪﺤﺘﻟ 

(loop control variables)

  . ﺛﻢ ﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﻤﻨﻄﻘﻴﺔ

logical expression

 ـ ﻳﺘﻮﻗﻒ ﺗﻨﻔﻴﺬ ﺍﻟ"ﻼﻛ" ﺔﻤﻴﻘﻟﺍ ﺖﻧﺎﻛ ﺍﺫﺈﻓ ﺎﻬﺑﺎﺴﺘﺣﺍ ﻢﺘﻳﻭ

for

  ﻭﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺬﻱ ﻳﻠﻲ

ـﺍﻟ

for

  ﻓﻴﺘﻢ ﺗﻨﻔﻴﺬ ﺍﻹﻳﻌﺎﺯ"ﻢﻌﻧ" ﺔﻴﻘﻄﻨﻤﻟﺍ ﺔﻤﻴﻘﻟﺍ ﺖﻧﺎﻛ ﺍﺫﺇ ﺎﻣﺃ .ﺓﺮﺷﺎﺒﻣ 

statement

  ﺍﻟﺬﻱ ﻗﺪ ﻳﻜﻮﻥ

  ﻭﻳﺴﻤﻰ ﺍﻟﺒﺪﻥًﺎﺒﻛﺮﻣ ﻭﺃ ًﺎﻄﻴﺴﺑ ًﺍﺯﺎﻌﻳﺇ

loop body

  . ﺑﻌﺪ ﺫﻟﻚ ﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺍﻟﻌﺒﺎﺭﺓ

increment

  ﻭﺍﻟﺘﻲ ﺗﺤﺪﺩ ﻓﻴﻬﺎ ﻃﺒﻴﻌﺔ ﺗﻐﻴﺮ ﻗﻴﻢ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ ﺍﻟﻤﺴﻴﻄﺮﺓ ﻋﻠﻰ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺘﻜﺮﺍﺭﻳﺔ ﻭﻣﻦ

 ﺛﻢ ﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﻤﻨﻄﻘﻴﺔ ﻭﻳﺘﻢ ﺍﺣﺘﺴﺎﺑﻬﺎ ﻭﻓﻲ ﺿﻮء ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻨﻄﻘﻴﺔ ﺍﻟﻤﺤﺘﺴﺒﺔ ﻳﻨﺘﻘﻞ

 ﺍﻟﺘﻨﻔﻴﺬ ﺃﻣﺎ ﺇﻟﻰ ﻣﺎ ﺑﻌﺪ ﺍﻹﻳﻌﺎﺯ

for

  ﺃﻭ ﺗﻨﻔﺬ ﺍﻟﻌﺒﺎﺭﺓ

statement

  ﻭﻣﻦ ﺛﻢ ﻳﻨﺘﻘﻞ ﺇﻟﻰ ﺍﻟﻌﺒﺎﺭﺓ

increment

 ."

ﻛﻼ" ﺯﺎﻌﻳﻺﻟ ﺔﻴﻘﻄﻨﻤﻟﺍ ﺔﻤﻴﻘﻟﺍ ﺢﺒﺼﺗ ﺎﻣﺪﻨﻋ ﻱﺭﺍﺮﻜﺘﻟﺍ ﺯﺎﻌﻳﻹﺍ ﻒﻗﻮﺘﻳ ﻥﺇ ﻰﻟﺇ ﺍﺬﻜﻫﻭ 

)

 ﻣﺜﺎﻝ

7

(

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻄﺒﻊ ﺍﻷﻋﺪﺍﺩ ﻣﻦ:

1

  ﺇﻟﻰ

10

 :

#include <iostream.h> 

main( ){ 

int n; 

for(n=1;n<=10;++n) 

cout<<"\n "<<n; 

} 

)

 ﻣﺜﺎﻝ

8

(

  ﺍﻟﻤﺜﺎﻝ ﺍﻟﺘﺎﻟﻲ ﻳﻄﺒﻊ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺰﻭﺟﻴﺔ ﺑﻴﻦ:

1

  ﺇﻟﻰ

10

 : 

# include <iostream.h> 

main( ){int n; 

for(n=1;n<=10;++n) 

if(n%2==0) 

cout<<"\n "<<n; 

} 

 ﻣﻴﺰﺍﺕ ﺍﻟﺘﺮﻛﻴﺐ

for

: 

 ﻳﻤﺘﻠﻚ ﺍﻟﺘﺮﻛﻴﺐ

for

 :

 ﺧﺼﺎﺋﺺ ﻏﻴﺮ ﻣﺘﻮﻓﺮﺓ ﻓﻲ ﻟﻐﺎﺕ ﺑﺮﻣﺠﻴﺔ ﺃﺧﺮﻯ ﻭﻫﺬﻩ ﺍﻟﺨﺼﺎﺋﺺ

1

.

 ـﺇﻫﻤﺎﻝ ﺑﻌﺾ ﺃﺟﺰﺍء ﺍﻟ

for loop

 ــﻳﻤﻜﻦ ﺇﻫﻤﺎﻝ ﻭﺍﺣﺪ ﺃﻭ ﺃﻛﺜﺮ ﻣﻦ ﻣﻜﻮﻧﺎﺕ ﺍﻟ

for

)

  ﻭﻛﻤﺎ ﻣﺒﻴﻦ ﻓﻲ ﺍﻟﻤﺜﺎﻝ

9

 :

( ﺃﺩﻧﺎﻩ

)

 ﻣﺜﺎﻝ

9

:(

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﺤﺘﻮﻱ ﻋﻠﻰ ﺗﺮﻛﻴﺐ ﺗﻜﺮﺍﺭﻱ ﻣﻦ ﻧﻮﻉ

for

 ــ ﺑﺪﻭﻥ ﺟﺰء ﺍﻟ

increment

 ــ ﻭﻳﺴﺘﻤﺮ ﺍﻟ

loop

  ﺑﺎﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺇﻥ ﻳﺘﻢ ﻗﺮﺍءﺓ ﺍﻟﺤﺮﻑ

'N'

  ﺃﻭ

'Y'

 : 

# include <iostream.h> 

main( ){char ch; 

for(ch='A';ch!='N' && ch!='Y';){ 

cout<<"\n Enter either Y or N:"; 

cin>>ch; 

}} 

2

.

 ﺍﺳﺘﺨﺪﺍﻡ ﺃﻛﺜﺮ ﻣﻦ ﻣﺘﻐﻴﺮ ﺳﻴﻄﺮﺓ ﻭﺍﺣﺪ

)

 ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺃﻛﺜﺮ ﻣﻦ ﻣﺘﻐﻴﺮ ﺳﻴﻄﺮﺓ ﻭﺍﺣﺪ ﻛﻤﺎ ﻣﺒﻴﻦ ﻓﻲ ﺍﻟﻤﺜﺎﻝ

10

 :

( ﺍﻟﺘﺎﻟﻲ

)

 ﻣﺜﺎﻝ

10

:(

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻄﺒﻊ ﺍﻷﻋﺪﺍﺩ ﻣﻦ

0

  ﺇﻟﻰ

98

 : 

# include <iostream.h> 

main( ){int x,y; 

for (x=0,y=0 ;x<50,y<50 ;++x,++y) 

cout<<" \t"<<x+y; 

} 

           ﻳﻼﺣﻆ ﻓﻲ ﻫﺬﺍ ﺍﻟﻤﺜﺎﻝ ﺗﻢ ﺍﺳﺘﺨﺪﺍﻡ ﻣﺘﻐﻴﺮﻳﻦ ﻟﻠﺴﻴﻄﺮﺓ ﻋﻠﻰ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺘﻜﺮﺍﺭﻳﺔ ﺣﻴﺚ ﺃﺳﻨﺪﺕ ﻟﻬﻤﺎ

 ــ ﺍﺑﺘﺪﺍﺋﻴﺔ ﻓﻲ ﺟﺰء ﺍﻟًﺎﻤﻴﻗ

initialization

 ( ﻟﻠﻔﺼﻞ ﺑﻴﻦ,) ﺓﺯﺭﺎﻔﻟﺍ ﻡﺍﺪﺨﺘﺳﺍ ًﺎﻀﻳﺃ ﻆﺣﻼﻳ ﺎﻤﻛ . 

 ﻣﻜﻮﻧﺎﺕ ﺍﻷﺟﺰﺍء ﺍﻟﺜﻼﺛﺔ ﻓﻲ ﺣﻴﻦ ﺗﺴﺘﺨﺪﻡ ﺍﻟﻔﺎﺭﺯﺓ ﺍﻟﻤﻨﻘﻮﻃﺔ ﻟﻠﻔﺼﻞ ﺑﻴﻦ ﺍﻷﺟﺰﺍء ﺍﻟﺜﻼﺛﺔ

 ﺍﻟﺮﺋﻴﺴﻴﺔ. ﻟﻴﺲ ﺑﺎﻟﻀﺮﻭﺭﺓ ﺃﻥ ﻳﻜﻮﻥ ﺗﻮﻗﻒ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺘﻜﺮﺍﺭﻳﺔ ﻋﻠﻰ ﺃﺳﺎﺱ ﺍﺧﺘﺒﺎﺭ ﻗﻴﻢ ﻣﺘﻐﻴﺮﺍﺕ

 ﺍﻟﺴﻴﻄﺮﺓ ﺿﻤﻦ ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﻤﻨﻄﻘﻲ ﻓﻴﻤﻜﻦ ﺃﻥ ﻧﺨﺘﺒﺮ ﻗﻴﻢ ﻣﺘﻐﻴﺮﺍﺕ ﺃﺧﺮﻯ ﻣﺴﺘﺨﺪﻣﺔ ﻓﻲ ﺑﺪﻥ

 .

ﺍﻹﻳﻌﺎﺯ ﺍﻟﺘﻜﺮﺍﺭﻱ

3

.

ﺍﻟﺘﻜﺮﺍﺭ ﺍﻟﻐﻴﺮ ﻣﻨﺘﻬﻲ

 ﻳﺒﻨﻰ ﺍﻟﺘﻜﺮﺍﺭ ﺍﻟﻐﻴﺮ ﻣﻨﺘﻬﻲ

(infinite loop)

 ﻲـــﻘﻄﻨﻤﻟﺍ ﺮــــــــــﻴﺒﻌﺘﻟﺍ ءﺰﺟ ﻙﺮــــﺘﺑ 

logical expression

)

  ﻓﺎﺭﻍ ﻛﻤﺎ ﻓﻲ ﺍﻟﻤﺜﺎﻝ

11

 :

( ﺍﻟﺘﺎﻟﻲ

)

 ﻣﺜﺎﻝ

11

:(

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﺣﺮﻑ ﺻﻐﻴﺮ ﻭﻳﻜﺘﺐ ﺍﻟﺤﺮﻑ ﺍﻟﻜﺒﻴﺮ ﺍﻟﻤﻘﺎﺑﻞ ﻭﻳﻼﺣﻆ ﺍﻧﻪ ﻻ

 :

ﺗﻮﺟﺪ ﻭﺳﻴﻠﺔ ﻹﻳﻘﺎﻑ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺘﻜﺮﺍﺭﻱ

# include <stdio.h> 

# include <ctype.h> 

main( ){char ch; 

for( ; ; ) {printf("\n Enter a small letter:"); 

scanf("\n%c",&ch); 

printf("Captital letter is %c",toupper(ch)); 

}} 

4

.

 ــﺍﺳﺘﺨﺪﺍﻡ ﺍﻟ

for loop

  ﺑﺪﻭﻥ ﺑﺪﻥ

 ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﻔﺎﺭﻏﺔ

empty statement 

  ﻛﺒﺪﻥ

(body)

  ﺇﻟﻰ

for

  ﻭﻓﻲ ﻫﺬﻩ ﺍﻟﺤﺎﻟﺔ

 :

ﻳﺄﺧﺬ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ

for(initialization expression; expression; increment); 

 .

ﻭﻳﺴﺘﺨﺪﻡ ﻣﺜﻞ ﻫﺬﺍ ﺍﻟﺘﺮﻛﻴﺐ ﻛﻮﺳﻴﻠﺔ ﻹﻳﻘﺎﻑ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻟﻔﺘﺮﺓ ﻣﻌﻴﻨﺔ

2

(

 ﺍﻟﺘﺮﻛﻴﺐ ﺍﻟﺘﻜﺮﺍﺭﻱ

while

 :

ﺍﻟﺸﻜﻞ ﺍﻟﻌﺎﻡ ﻟﻬﺬﺍ ﺍﻟﺘﺮﻛﻴﺐ ﻫﻮ

while (expression) 

          statement;      /*body of the loop*/ 

 ﺣﻴﺚ ﺃﻥ ﺍﻟﻌﺒﺎﺭﺓ

statement

  ﺗﻤﺜﻞ ﺑﺪﻥ ﺍﻹﻳﻌﺎﺯ

(loop body)

 :

 ﻭﻳﻤﻜﻦ ﺃﻥ ﺗﻜﻮﻥ

•

 ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﻔﺎﺭﻏﺔ

(empty statement)

•

 ﻋﺒﺎﺭﺓ ﺑﺴﻴﻄﺔ

(simple statement)

•

 ﻋﺒﺎﺭﺓ ﻣﺮﻛﺒﺔ

(compound statement)

 ﻳﻘﻮﻡ ﻫﺬﺍ ﺍﻹﻳﻌﺎﺯ ﺑﺘﻨﻔﻴﺬ ﺍﻟﻌﺒﺎﺭﺓ

statement

  ﺑﺼﻮﺭﺓ ﻣﺘﻜﺮﺭﺓ ﻃﺎﻟﻤﺎ ﺃﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻨﻄﻘﻴﺔ ﻟﻠﻤﻘﺪﺍﺭ

(expression)

  ﻳﺘﻮﻗﻒ ﺗﻨﻔﻴﺬ ﺍﻟﻌﺒﺎﺭﺓ"ﻼﻛ" ﺔﻴﻘﻄﻨﻤﻟﺍ ﺔﻤﻴﻘﻟﺍ ﺢﺒﺼﺗ ﺎﻣﺪﻨﻋﻭ "ﻢﻌﻧ" ﻲﻫ 

statement

  ﻭﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺬﻱ ﻳﻠﻲ

while

 . 

)

 ﻣﺜﺎﻝ

12

:(

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻜﺘﺐ ﺍﻷﻋﺪﺍﺩ ﻣﻦ

1

  ﺇﻟﻰ

10

  ﻣﻊ ﻣﺮﺑﻌﺎﺗﻬﺎ ﺑﺎﺳﺘﺨﺪﺍﻡ

while

 : 

# include <iostream.h> 

main( ){int n; 

n=1; 

while(n<=10){ 

cout<<"\n square of " <<n<<" is "<< n*n; 

++n; 

}} 

3

(

 ﺍﻟﺘﺮﻛﻴﺐ ﺍﻟﺘﻜﺮﺍﺭﻱ

do – while

 :

   ﺍﻟﺸﻜﻞ ﺍﻟﻌﺎﻡ ﻟﻬﺬﺍ ﺍﻟﺘﺮﻛﻴﺐ ﻫﻮ

do {  

      statement; 

      }while (expression) 

 ﺣﻴﺚ ﺃﻥ ﺍﻟﻌﺒﺎﺭﺓ

statement

  ﺑﺴﻴﻄﺔ ﺃﻭ ﻣﺮﻛﺒﺔ. ﻳﺒﺪﺃ ﻫﺬﺍ ﺍﻹﻳﻌﺎﺯ ﺑﺘﻨﻔﻴﺬ، ﺔﻏﺭﺎﻓ ﻥﻮﻜﺗ ﻥﺃ ﻦﻜﻤﻣ 

 ﺍﻟﻌﺒﺎﺭﺓ

statement

  ﻳﺴﺘﻤﺮ"ﻢﻌﻧ" ﺔﻤﻴﻘﻟﺍ ﺖﻧﺎﻛ ﺍﺫﺈﻓ ﻲﻘﻄﻨﻤﻟﺍ ﺭﺍﺪﻘﻤﻟﺍ ﺔﻤﻴﻗ ﺏﺎﺴﺘﺣﺍ ﻢﺘﻳ ﻚﻟﺫ ﺪﻌﺑ 

 ﻋﻤﻞ ﺍﻹﻳﻌﺎﺯ ﻭﺗﻨﻔﺬ ﺍﻟﻌﺒﺎﺭﺓ

statement

 "

ﻛﻼ" ﺭﺍﺪﻘﻤﻟﺍ ﺔﻤﻴﻗ ﺖﻧﺎﻛ ﺍﺫﺇ ﺎﻣﺃ .ﺍﺬﻜﻫﻭ ﻯﺮﺧﺃ ﺓﺮﻣ 

 ﻳﺘﻮﻗﻒ ﻋﻤﻞ ﺍﻹﻳﻌﺎﺯ ﻭﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺬﻱ ﻳﻠﻲ ﺇﻳﻌﺎﺯ

do-while

 .

 ﻣﺒﺎﺷﺮﺓ

)

 ﻣﺜﺎﻝ

13

:(

  ﺍﻟﻤﺜﺎﻝ ﺍﻟﺘﺎﻟﻲ ﻳﻄﺒﻊ ﺍﻷﻋﺪﺍﺩ ﻣﻦ

1

  ﺇﻟﻰ

10

  ﻣﻊ ﻣﺮﺑﻌﺎﺗﻬﺎ ﺑﺎﺳﺘﺨﺪﺍﻡ

do-while

 : 

# include <iostream.h> 

main( ){int n; 

n=1; 

do { 

cout<<"\n square of "<<n<<" is "<< n*n; 

++n; 

} while(n<=10); 

} 

 ﺍﻟﻌﺒﺎﺭﺓ

break;

 ﻳﺘﻮﻗﻒ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺘﻜﺮﺍﺭﻱ

(for, while, do-while)

  ﺇﺫﺍ ﻣﺎ ﺻﺎﺩﻑ ﺍﻟﻤﻌﺎﻟﺞ ﻋﺒﺎﺭﺓ

break;

  ﺇﺛﻨﺎء

 ﺗﻨﻔﻴﺬﻩ ﻟﻠﻌﺒﺎﺭﺍﺕ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﺑﺪﻥ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺘﻜﺮﺍﺭﻱ ﻭﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺬﻱ ﻳﻠﻲ ﺍﻹﻳﻌﺎﺯ

)

 ﺍﻟﺘﻜﺮﺍﺭﻱ ﻣﺒﺎﺷﺮﺓ ﻛﻤﺎ ﻣﻮﺿﺢ ﻓﻲ ﺍﻟﻤﺜﺎﻝ

14

 :

( ﺍﻟﺘﺎﻟﻲ

)

 ﻣﺜﺎﻝ

14

:(

)

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﺗﻄﻮﻳﺮ ﻟﻠﺒﺮﻧﺎﻣﺞ ﺭﻗﻢ

11

 ( ﺣﻴﺚ ﺗﻢ ﺇﺿﺎﻓﺔ ﺇﻳﻌﺎﺯﺍﺕ ﻟﺴﺆﺍﻝ ﺍﻟﻤﺴﺘﺨﺪﻡ

 :

ﻓﻴﻤﺎ ﺇﺫﺍ ﻛﺎﻥ ﻳﺮﻏﺐ ﺑﺎﻻﺳﺘﻤﺮﺍﺭ ﺃﻭ ﺍﻟﺘﻮﻗﻒ ﻭﺇﻧﻬﺎء ﺍﻟﺒﺮﻧﺎﻣﺞ

# include <stdio.h> 

# include <ctype.h> 

main( ){char ch, answer; 

for( ; ; ) { 

printf("\n Enter a small letter:"); 

scanf("\n %c", &ch); 

printf("Captital letter is %c",toupper(ch)); 

answer ='A'; 

while(answer != 'Y' && answer != 'N'){ 

printf("\n Do you want to continue? Enter (Y/N):"); 

scanf("\n %c", &answer); } 

if(answer == 'N') 

break; 

}} 

 ﺍﻟﻌﺒﺎﺭﺓ

continue;

 ﺇﺫﺍ ﻣﺎ ﺻﺎﺩﻑ ﺍﻟﻤﻌﺎﻟﺞ ﻋﺒﺎﺭﺓ

continue;

  ﺃﺛﻨﺎء ﺗﻨﻔﻴﺬﻩ ﻟﻠﻌﺒﺎﺭﺍﺕ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﺑﺪﻥ ﺃﺣﺪ ﺍﻹﻳﻌﺎﺯﺍﺕ

 ﺍﻟﺘﻜﺮﺍﺭﻳﺔ

(for, while, do-while)

  ﺗﻬﻤﻞ ﺑﻘﻴﺔ ﺍﻟﻌﺒﺎﺭﺍﺕ ﺍﻟﻤﻮﺟﻮﺩﺓ ﺑﻴﻦ ﺍﻟﻌﺒﺎﺭﺓ

continue;

 ﻭﻧﻬﺎﻳﺔ ﺍﻹﻳﻌﺎﺯ ﺍﻟﺘﻜﺮﺍﺭﻱ ﺍﻟﺬﻱ ﻳﺤﺘﻮﻱ ﻋﻠﻰ ﻋﺒﺎﺭﺓ

continue;

  ﻭﻳﻨﺘﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺑﺪﺍﻳﺔ ﺍﻹﻳﻌﺎﺯ

 :

ﺍﻟﺘﻜﺮﺍﺭﻱ ﻭﺗﺒﺪﺃ ﺩﻭﺭﺓ ﺟﺪﻳﺪﺓ ﻛﻤﺎ ﻣﻮﺿﺢ ﻓﻲ ﺍﻟﻤﺜﺎﻝ ﺍﻟﺘﺎﻟﻲ

)

 ﻣﺜﺎﻝ

15

:(

  ﺍﻟﻤﺜﺎﻝ ﺍﻟﺘﺎﻟﻲ ﻳﻄﺒﻊ ﺍﻷﻋﺪﺍﺩ ﺍﻟﻔﺮﺩﻳﺔ ﺍﻟﻤﺤﺼﻮﺭﺓ ﺑﻴﻦ

1

  ﻭ

100

 : 

# include <iostream.h> 

main( ) { 

int n; 

for(n=1 ;n <=100 ; ++n) { 

if(n%2==0) 

continue; 

cout<<"\n Number "<<n<<" is odd"; 

} } 

 ﻳﻼﺣﻆ ﻓﻲ ﻫﺬﺍ ﺍﻟﻤﺜﺎﻝ ﺃﻥ ﺍﻹﻳﻌﺎﺯ

continue;

  ﻳﻨﻔﺬ ﻓﻲ ﻛﻞ ﻣﺮﺓ ﻳﻜﻮﻥ ﻓﻴﻬﺎ ﺍﻟﻌﺪﺩ

n

 .

ً ﺯﻭﺟﻴﺎ

 ﻋﺒﺎﺭﺓ

goto

 ﺗﺤﺘﺎﺝ ﻋﺒﺎﺭﺓ

goto

  ﺇﻟﻰ ﺍﺳﻢ ﺩﻻﻟﺔ

(label)

 :

  ﻳﺘﺒﻌﻪ

(colon)

  ﻟﻌﻤﻠﻬﺎ ﻭﺍﺳﻢ ﺍﻟﺪﻻﻟﺔ ﻫﺬﺍ ﻫﻮ ﻋﺒﺎﺭﺓ

 ﻋﻦ ﻣﻌﺮﻑ

(identifier)

  ﻟﻘﻮﺍﻋﺪ ﻟﻐﺔًﺎﻘﺒﻃ ﺐﺘﻜﻳ 

C

++

)

  . ﺍﻟﻤﺜﺎﻝ

16

 ( ﻳﺒﻴﻦ ﻛﻴﻔﻴﺔ ﺑﻨﺎء ﺗﺮﻛﻴﺐ

 ﺗﻜﺮﺍﺭﻱ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻋﺒﺎﺭﺓ

goto

)

 ﻣﺜﺎﻝ

16

:(

  ﺍﻟﻤﺜﺎﻝ ﺍﻟﺘﺎﻟﻲ ﻳﺒﻴﻦ ﻛﻴﻔﻴﺔ ﺑﻨﺎء ﺇﻳﻌﺎﺯ ﺗﻜﺮﺍﺭﻱ ﻟﻜﺘﺎﺑﺔ ﺍﻷﺭﻗﺎﻡ ﻣﻦ

1

  ﺇﻟﻰ

10

 :

 ﻣﻊ ﻣﺮﺑﻌﺎﺗﻬﺎ

# include <iostream.h> 

main( ) { 

int n=1; 

loop1: 

cout<<"\n Square of "<<n<<" is "<<n*n; 

++n; 

if(n<=10) goto loop1; 

} 

 ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﻭ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ

:ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

 ﺍﻟﻤﺼﻔﻮﻓﺔ ﻫﻲ ﻋﺒﺎﺭﺓ  ﻋﻦ ﻣﺠﻤﻮﻋﺔ ﻣﺘﻐﻴﺮﺍﺕ ﻣﻦ ﻧﻔﺲ ﺍﻟﻨﻮﻉ ﻭﻳﺸﺎﺭ ﺇﻟﻴﻬﺎ ﺑﻨﻔﺲ ﺍﻻﺳﻢ ﺗﺘﻜﻮﻥ

 ﺍﻟﻤﺼﻔﻮﻓﺔ ﻣﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺨﻼﻳﺎ ﺍﻟﻤﺘﺠﺎﻭﺭﺓ ﻓﻲ ﺍﻟﺬﺍﻛﺮﺓ ﺑﺤﻴﺚ ﺗﺨﺰﻥ ﻗﻴﻤﺔ ﻛﻞ ﻣﺘﻐﻴﺮ ﻓﻲ ﺍﺣﺪ

 ﻫﺬﻩ ﺍﻟﺨﻼﻳﺎ ﻭﻳﻌﺘﻤﺪ ﺣﺠﻢ ﺍﻟﺨﻠﻴﺔ ﻋﻠﻰ ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺘﻲ ﺗﻤﺜﻠﻬﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ. ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻓﻲ

 ﺍﻟﻤﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻷﺩﻧﻰ ﻓﻲ ﺍﻟﺬﺍﻛﺮﺓ ﺗﻤﺜﻞ ﺍﻟﻌﻨﺼﺮ ﺃﻭ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻷﻭﻝ ﻭ ﺍﻟﺨﻠﻴﺔ ﺍﻷﺧﻴﺮﺓ ﺫﺍﺕ

 .

ﺍﻟﻌﻨﻮﺍﻥ ﺍﻷﻋﻠﻰ ﺗﻤﺜﻞ ﺍﻟﻌﻨﺼﺮ ﺃﻭ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻷﺧﻴﺮ

 ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﻳﻤﻜﻦ ﺃﻥ ﺗﻜﻮﻥ ﺫﺍﺕ ﺑﻌﺪ ﻭﺍﺣﺪ

(one dimensional)

  ﺃﻭ ﺃﻛﺜﺮ. ﺍﻹﺷﺎﺭﺓ ﺇﻟﻰ ﻋﻨﺼﺮ

 ﻣﻌﻴﻦ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﺍﺳﺘﺨﺪﺍﻡ ﺍﺳﻢ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻭﻓﻬﺮﺱ

(Index)

  ﻭﺍﻟﺬﻱ ﻫﻮ ﻋﺪﺩ

 ﺻﺤﻴﺢ ﻳﻤﺜﻞ ﺗﺴﻠﺴﻞ ﺍﻟﻌﻨﺼﺮ ﺍﻟﻤﻌﻨﻲ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ. ﺃﻣﺎ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ

(strings)

  ﻓﻬﻲ ﻋﺒﺎﺭﺓ

 ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻌﺪ ﻭﺍﺣﺪ ﻣﻦ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻤﻔﺮﺩﺓ

(characters)

 . 

: ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﺫﺍﺕ ﺍﻟﺒﻌﺪ ﺍﻟﻮﺍﺣﺪ

 ﺗﻌﺮﻑ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺍﻟﺒﻌﺪ ﺍﻟﻮﺍﺣﺪ

(one dimensional arrays)

 :

 ﺑﺎﻟﺼﻴﻐﺔ ﺍﻟﺘﺎﻟﻴﺔ

data_type array_name [size] ; 

 :

ﺣﻴﺚ ﺃﻥ

data_type

 .

 ﻳﺒﻴﻦ ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺨﺎﺻﺔ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ: 

array_name

 .

 ﺍﺳﻢ ﺍﻟﻤﺼﻔﻮﻓﺔ: 

size

 .

 ﻋﺪﺩ ﺍﻟﻌﻨﺎﺻﺮ ﺍﻟﺘﻲ ﺗﺘﻜﻮﻥ ﻣﻨﻬﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ: 

 ﻟﺘﻌﺮﻳﻒ ﻣﺼﻔﻮﻓﺔ ﺍﺳﻤﻬﺎ

num

  ﻭﻳﻤﻜﻦ ﺧﺰﻥ ﺛﻤﺎﻧﻴﺔ ﻋﻨﺎﺻﺮ ﻓﻴﻬﺎ ﻛﺤﺪ ﺃﻗﺼﻰ ﻣﻦ ﻧﻮﻉ ﺍﻷﻋﺪﺍﺩ

 :

 ﻧﺴﺘﺨﺪﻡ ﺍﻟﺘﻌﺮﻳﻒ، ﺔﺤﻴﺤﺼﻟﺍ

int num[8]; 

 ﻳﺸﺎﺭ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺮ ﺍﻷﻭﻝ ﻓﻲ ﻟﻐﺔ

C

  ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﻔﻬﺮﺱ ﺻﻔﺮ ﻭﺍﻟﻌﻨﺼﺮ ﺍﻟﺜﺎﻧﻲ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﻔﻬﺮﺱ

 ﻭﺍﺣﺪ ﻭﻫﻜﺬﺍ. ﺍﻟﻌﻨﺼﺮ ﺍﻷﻭﻝ ﻓﻲ ﻫﺬﻩ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻫﻮ

num[0]

  ﻭﺍﻟﻌﻨﺼﺮ ﺍﻷﺧﻴﺮ

num[7]

 . 

)

 ﻣﺜﺎﻝ

1

:(

 :

 ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﻭﻳﺨﺰﻥ ﻋﺸﺮﺓ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﻭﻣﻦ ﺛﻢ ﻳﻄﺒﻊ ﺃﻛﺒﺮﻫﺎ

#include <iostream.h> 
main( ){ 
int i,max,num[10]; 
for(i=0 ; i<10;++i){ 
cout<<"\n Enter an integer:"; 
cin>>num[i]; 
} 
max=num[0]; 
for(i=1;i<10;++i) 
if(num[i]>max)max=num[i]; 
cout<<"\n Maximum number is "<<max; 
} 

)

 ﻣﺜﺎﻝ

2

:(

 :

 ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﻣﺠﻤﻮﻋﺔ ﺃﺭﻗﺎﻡ ﻭﻳﻮﺟﺪ ﻣﻌﺪﻟﻬﺎ

#include <iostream.h> 
main( ){ 
int i; 
float  n[10],sum,average; 
sum = 0; 
for(i=0;i<10;++i){ 
cout<<"\n Enter a number:"; 
cin>>n[i]; 
sum + = n[i]; 
} 
average =sum/10; 
cout<<"\n Average =  "<<average; 
} 

)

 ﻣﺜﺎﻝ

3

:(

 :

 ﺍﻟﻤﺜﺎﻝ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻭﻳﻄﺒﻊ ﻋﺪﺩ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺰﻭﺟﻴﺔ

# include <iostream.h> 
# define Length 100 
main( ){ 
int num[Length]; 
int i,size,count=0; 
cout<<"\n Enter size of array:"; 
cin>>size; 
for(i=0;i<size;++i){ 
cout<<"\n Enter element "<<i+1<<":"; 
cin>>num[i]; 
} 
for(i=0;i<size;++i) 
if(num[i]%2==0)count+=1; 

cout<<"\n Number of even elements: "<<count; 
} 

: ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ

 ﺗﺴﺘﺨﺪﻡ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺍﻟﺒﻌﺪ ﺍﻟﻮﺍﺣﺪ ﻓﻲ ﺗﻌﺮﻳﻒ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ ﻣﻦ ﻧﻮﻉ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ

(string)

  ﺣﻴﺚ

 ﻻ ﺗﻮﻓﺮ ﻟﻐﺔ

++

C

  ﺑﻴﺎﻧﺎﺕ ﻣﻦ ﻫﺬﺍ ﺍﻟﻨﻮﻉ ﻣﺒﺎﺷﺮﺓ. ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﻫﻮ ﻋﺒﺎﺭﺓ ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻌﺪ

 ﻭﺍﺣﺪ ﻣﻦ ﻧﻮﻉ ﺍﻟﺮﻣﺰ ﺍﻟﻤﻔﺮﺩ

(character)

  ﻭﺍﻟﺬﻱ ﻳﻜﻮﻥ ﺃﺧﺮ ﺭﻣﺰ ﻣﻨﻔﺮﺩ ﻓﻴﻪ ﻫﻮ ﺍﻟﺮﻣﺰ

'\0'

(null)

  . ﻭﻟﻬﺬﺍ ﺍﻟﺴﺒﺐ ﻳﺠﺐ ﺃﻥ ﻳﻜﻮﻥ ﻃﻮﻝ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺃﻛﺒﺮ ﻣﻦ ﺍﻟﻄﻮﻝ ﺍﻟﻤﻄﻠﻮﺏ ﺑﻤﻘﺪﺍﺭ

1

 .

 ﻟﺘﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ

name

 :

 ﻧﺴﺘﺨﺪﻡ ﺍﻟﺘﻌﺮﻳﻒ ﺍﻟﺘﺎﻟﻲ، ﻰﺼﻗﺃ ﺪﺤﻛ ﺓﺩﺮﻔﻣ ﺯﻮﻣﺭ ﺓﺮﺸﻋ ﺐﻋﻮﺘﺴﻳ 

char name[11]; 

 ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﻨﺼﻴﺔ ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻦ ﻣﺠﻤﻮﻋﺔ ﺭﻣﻮﺯ ﻣﻔﺮﺩﺓ ﻣﺤﺼﻮﺭﺓ ﺑﻴﻦ ﻋﻼﻣﺎﺕ ﺍﻗﺘﺒﺎﺱ. ﻭﻻ ﺗﻮﺟﺪ

 ﺣﺎﺟﺔ ﺇﻟﻰ ﺇﺿﺎﻓﺔ ﺍﻟﺮﻣﺰ ﺍﻟﻤﻔﺮﺩ

'\0'

  ﺇﻟﻰ ﻧﻬﺎﻳﺔ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺣﻴﺚ ﻳﻘﻮﻡ ﺍﻟﻤﻌﺎﻟﺞ ﺃﻭﺗﻮﻣﺎﺗﻴﻜﻴﺎ

 .

ﺑﺈﺿﺎﻓﺔ ﻫﺬﺍ ﺍﻟﺮﻣﺰ ﺇﻟﻰ ﻧﻬﺎﻳﺔ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ

: ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ

 ﺗﻮﻓﺮ ﻟﻐﺔ

++

C

  ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﻟﻤﻌﺎﻟﺠﺔ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ ﺗﺘﻄﻠﺐ ﻫﺬﻩ ﺍﻟﺪﻭﺍﻝ ﻭﺟﻮﺩ ﺍﻟﻤﻠﻒ

string.h

  ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻹﻳﻌﺎﺯ

#include <string.h>

  ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺃﻫﻢ ﺍﻟﺪﻭﺍﻝ ﺍﻟﺘﻲ ﺗﺴﺘﺨﺪﻡ ﻓﻲ

 .

ﻣﻌﺎﻟﺠﺔ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ

1

(

:ﻗﺮﺍءﺓ ﺭﻣﺰ ﻧﺼﻲ

 ﺃﻓﻀﻞ ﻃﺮﻳﻘﺔ ﻟﻘﺮﺍءﺓ ﺭﻣﺰ ﻧﺼﻲ ﻣﻦ ﻟﻮﺣﺔ ﺍﻟﻤﻔﺎﺗﻴﺢ ﻫﻮ ﺍﺳﺘﺨﺪﺍﻡ ﺩﺍﻟﺔ ﺍﻟﻘﺮﺍءﺓ

gets( )

  ﻭﺍﻟﺘﻲ

 :

ﺗﺴﺘﺪﻋﻰ ﺑﺎﻟﺼﻴﻐﺔ ﺍﻟﺘﺎﻟﻴﺔ

gets(string_variable); 

 ﻋﻨﺪ ﺍﺳﺘﺪﻋﺎء ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺗﻘﻮﻡ ﺑﻘﺮﺍءﺓ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ ﺍﻟﺪﺍﺧﻠﺔ ﻋﻦ ﻃﺮﻳﻖ ﻟﻮﺣﺔ ﺍﻟﻤﻔﺎﺗﻴﺢ ﺑﻌﺪ ﺃﻥ ﻳﺘﻢ

 ﺍﻟﻀﻐﻂ ﻋﻠﻰ ﻣﻔﺘﺎﺡ

enter

 . 

)

 ﻣﺜﺎﻝ

4

:(

 :

 ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﻮﻡ ﺑﻘﺮﺍءﺓ ﺭﻣﺰ ﻧﺼﻲ ﻣﻦ ﻟﻮﺣﺔ ﺍﻟﻤﻔﺎﺗﻴﺢ ﻭﻣﻦ ﺛﻢ ﻳﻈﻬﺮﻩ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ

#include <stdio.h> 
#include <iostream.h> 
main( ){ 
char text[80]; 
cout<<"\n Enter a sentence:"; 
gets(text); 
cout<<"\n Sentence is: "<<text; 
} 

2

(

: ﺍﺳﺘﻨﺴﺎﺥ ﺭﻣﺰ ﻧﺼﻲ

 ﻟﺘﻮﻟﻴﺪ ﻧﺴﺨﺔ ﻣﻦ ﺭﻣﺰ ﻧﺼﻲ

(string copy)

  ﺗﺴﺘﺨﺪﻡ ﺍﻟﺪﺍﻟﺔ

strcpy( )

  ﻭﺗﺴﺘﺪﻋﻰ ﺑﺎﻟﺼﻴﻐﺔ ﺍﻟﺘﺎﻟﻴﺔ

strcpy(string1,string2); 

 ﺣﻴﺚ ﺗﻘﻮﻡ ﺍﻟﺪﺍﻟﺔ ﻋﻨﺪ ﺍﺳﺘﺪﻋﺎﺋﻬﺎ ﺑﻨﻘﻞ ﻣﺤﺘﻮﻳﺎﺕ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺍﻟﺜﺎﻧﻲ

string2

  ﺇﻟﻰ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ

 ﺍﻷﻭﻝ

string1

 . 

)

 ﻣﺜﺎﻝ

5

:(

#include <iostream.h> 
#include <string.h> 
main( ){ 
char text[40]; 
strcpy(text,"Hello,this is an example."); 
cout<<"\n Message: "<<text; 
} 

3

(

:ﺩﻣﺞ ﺭﻣﺰﻳﻦ ﻧﺼﻴﻴﻦ

 ﺗﺴﺘﺨﺪﻡ ﺍﻟﺪﺍﻟﺔ

strcat( )

 :

 ﻟﻬﺬﺍ ﺍﻟﻐﺮﺽ ﻭﺗﺴﺘﺪﻋﻰ ﺑﺎﻟﺼﻴﻐﺔ ﺍﻟﺘﺎﻟﻴﺔ

strcat(string1,string2); 

 .

ﺗﻘﻮﻡ ﺍﻟﺪﺍﻟﺔ ﻋﻨﺪ ﺗﻨﻔﻴﺬﻫﺎ ﺑﺈﺿﺎﻓﺔ ﻣﺤﺘﻮﻳﺎﺕ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺍﻟﺜﺎﻧﻲ ﺇﻟﻰ ﻧﻬﺎﻳﺔ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺍﻷﻭﻝ

)

 ﻣﺜﺎﻝ

6

:(

#include <iostream.h> 
#include <string.h> 
main( ){ 
char first[20],second[20]; 
strcpy(first,"Enter your "); 
strcpy(second,"name:"); 
strcat(first,second); 
cout<<first; 
} 

 :

ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﻫﺬﺍ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺳﺘﻈﻬﺮ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ

Enter your name: 

4

(

:ﻣﻘﺎﺭﻧﺔ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ

 ﺗﺴﺘﺨﺪﻡ ﺍﻟﺪﺍﻟﺔ

strcmp( )

 :

 ﻟﻤﻘﺎﺭﻧﺔ ﺭﻣﺰﻳﻦ ﻣﻦ ﺍﻟﻨﻮﻉ ﺍﻟﻨﺼﻲ . ﺗﺴﺘﺪﻋﻰ ﺍﻟﺪﺍﻟﺔ ﺑﺎﻟﺼﻴﻐﺔ

strcmp(string1,string2); 

 ﺗﻜﻮﻥ ﻗﻴﻤﺔ ﺍﻟﺪﺍﻟﺔ ﺻﻔﺮ ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺍﻷﻭﻝ ﻣﻄﺎﺑﻖ ﻟﻠﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺍﻟﺜﺎﻧﻲ ﻭﺗﻜﻮﻥ ﺍﻟﻘﻴﻤﺔ

 ﻣﻮﺟﺒﺔ ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺍﻷﻭﻝ ﺃﻛﺒﺮ ﻣﻦ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺍﻟﺜﺎﻧﻲ. ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ

 .

ﺍﻷﻭﻝ ﺃﻗﻞ ﻣﻦ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﺍﻟﺜﺎﻧﻲ ﻓﺘﻜﻮﻥ ﺍﻟﻘﻴﻤﺔ ﺳﺎﻟﺒﺔ

)

 ﻣﺜﺎﻝ

7

:(

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﺭﻣﺰ ﻧﺼﻲ ﻭﻳﻄﺒﻌﻪ ﺑﺼﻮﺭﺓ ﻣﺘﻜﺮﺭﺓ ﺇﻟﻰ ﺃﻥ ﻳﺘﻢ ﺇﺩﺧﺎﻝ ﺍﻟﺮﻣﺰ

 ﺍﻟﻨﺼﻲ

"quit"

: 

#include<stdio.h> 
#include <iostream.h> 
#include <string.h> 
main( ){ 
char text[80]; 
for( ; ; ){ 
cout<<"\n Enter a sentence:"; 
gets(text); 
if( !strcmp(text,"quit")) break; 
cout<<"\n "<<text; 
}} 

5

(

: ﺍﺣﺘﺴﺎﺏ ﻃﻮﻝ ﺭﻣﺰ ﻧﺼﻲ

 :

ﻳﻜﻮﻥ ﺍﺳﺘﺪﻋﺎء ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﺎﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ

strlen(string) 

 .

ﻭﺗﻜﻮﻥ ﻗﻴﻤﺔ ﺍﻟﺪﺍﻟﺔ ﻋﺪﺩ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻤﻔﺮﺩﺓ ﺍﻟﺘﻲ ﻳﺘﻜﻮﻥ ﻣﻨﻬﺎ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ

)

 ﻣﺜﺎﻝ

8

:(

#include<stdio.h> 
#include <iostream.h> 
#include <string.h> 
main( ){ 
char text[80]; 
for( ; ; ){ 
cout<<"\n Enter a sentence:"; 
gets(text); 
if(!strcmp(text,"quit"))break; 
cout<<"\n Length of string "<<strlen(text); 
}} 

6

(

: ﺍﺳﺘﺨﺪﺍﻡ ﺭﻣﺰ ﻧﻬﺎﻳﺔ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ

 ﻳﻤﻜﻦ ﺍﻻﺳﺘﻔﺎﺩﺓ ﻣﻦ ﻭﺟﻮﺩ ﺍﻟﺮﻣﺰ

'\0'

(null)

  ﻓﻲ ﻧﻬﺎﻳﺔ ﻛﻞ ﺭﻣﺰ ﻧﺼﻲ ﻓﻲ ﺗﺴﻬﻴﻞ ﻋﻤﻠﻴﺔ ﻣﻌﺎﻟﺠﺔ

 ﺍﻟﻨﺼﻮﺹ ﺣﻴﺚ ﻳﺴﺘﺨﺪﻡ ﻛﺈﺷﺎﺭﺓ ﻋﻠﻰ ﺍﻧﺘﻬﺎء ﺍﻟﻨﺺ ﻭﺗﻮﻗﻒ ﺍﻟﻤﻌﺎﻟﺠﺔ ﺍﻟﺨﺎﺻﺔ ﺑﺎﻟﻨﺺ ﻛﻤﺎ ﻣﺒﻴﻦ ﻓﻲ

 :

ﺍﻟﻤﺜﺎﻝ ﺍﻟﺘﺎﻟﻲ

)

 ﻣﺜﺎﻝ

9

:(

#include<stdio.h> 
#include <iostream.h> 
#include <ctype.h> 
main( ){ 
char text[80]; 
int n; 
cout<<"\n Enter a text:\n"; 
gets(text); 
for(n=0;text[n];++n) 
text[n]=toupper(text[n]); 
cout<<"\n "<<text; 
} 

: ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﺫﺍﺕ ﺑﻌﺪﻳﻦ

 :

ﺗﻌﺮﻑ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺍﻟﺒﻌﺪﻳﻦ ﺑﺎﻟﺼﻴﻐﺔ ﺍﻟﺘﺎﻟﻴﺔ

type array_name [size1] [size2]; 

 ﺣﻴﺚ ﻳﺸﻴﺮ

size1

  ﺇﻟﻰ ﻋﺪﺩ ﺍﻷﺳﻄﺮ

(rows)

  ﻟﻠﻤﺼﻔﻮﻓﺔ ﻭ

size2

  ﺇﻟﻰ ﻋﺪﺩ ﺍﻷﻋﻤﺪﺓ

(columns)

)

 ﻣﺜﺎﻝ

10

:(

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻌﺮﻑ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ

3

 ﺍﺳﻄﺮ ﻭ

4

  ﺃﻋﻤﺪﺓ ﻭﻳﺨﺰﻥ ﻓﻴﻬﺎ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ

 :

ﺑﺎﺳﺘﺨﺪﺍﻡ ﻣﻌﺎﺩﻟﺔ ﻣﻌﻴﻨﺔ ﺗﺒﻴﻦ ﺗﺴﻠﺴﻞ ﻛﻞ ﺧﻠﻴﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ

#include <iostream.h> 
main( ){ 
int i, j, num[3][4]; 
for(i=0;i<3;++i) 
for(j=0;j<4;++j) 
num[i][j]=(i*4)+j+1; 
} 

 ﻳﻘﻮﻡ ﻫﺬﺍ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺑﺨﺰﻥ ﺍﻟﻘﻴﻤﺔ

1

  ﻓﻲ ﺍﻟﺨﻠﻴﺔ

num[0][0]

  ﻭﺍﻟﻘﻴﻤﺔ

2

  ﻓﻲ ﺍﻟﺨﻠﻴﺔ

num[0][1]

  ﻭ

3

 ﻓﻲ ﺍﻟﺨﻠﻴﺔ

num[0][2]

 :

 ﻭﻫﻜﺬﺍ. ﻭﻳﻤﻜﻦ ﺗﻤﺜﻴﻞ ﻣﺤﺘﻮﻳﺎﺕ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺑﺎﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ

0

1

2

3

0

1

2

3

4

1

5

6

7

8

2

9

10

11

12

)

 ﻣﺜﺎﻝ

11

:(

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺍ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻻﺭﻗﺎﻡ ﻭﻳﺨﺰﻧﻬﺎ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻭﻣﻦ ﺛﻢ ﻳﻄﺒﻊ ﻣﻌﺪﻝ

 ﺍﻻﺭﻗﺎﻡ ﻓﻲ ﻛﻞ ﺳﻄﺮ

(row)

 : 

#include <iostream.h> 
#define rows 3 
#define columns 5 
main( ){ 
int i, j, matrix[rows][columns]; 
float sum, average; 
for(i=0;i<rows;++i){           /*Read numbers into the matrix*/ 
cout<<"\n Enter "<<columns<<" elements for row "<<i+1<<":"; 
for(j=0;j<columns;++j) 
cin>>matrix[i][j]; 
}                                     /*Compute sum & average for each row*/ 
for(i=0;i<rows;++i){ 
sum=0; 
for(j=0;j<columns;++j) 
sum+=matrix[i][j]; 
average=sum/columns; 
cout<<"\n Average row "<<i+1<<" = "<<average; 
}} 

: ﻣﺼﻔﻮﻓﺎﺕ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ

 ﻳﻤﻜﻦ ﺗﻌﺮﻳﻒ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻌﺪ ﻭﺍﺣﺪ ﻣﻦ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ

(array of strings)

  ﻋﻠﻰ ﺷﻜﻞ

 ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻌﺪﻳﻦ ﻣﻦ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻤﻔﺮﺩﺓ

(characters)

  ﻭﻓﻲ ﻫﺬﻩ ﺍﻟﺤﺎﻟﺔ ﻳﻤﺜﻞ ﺍﻟﻔﻬﺮﺱ ﺍﻷﻭﻝ ﻋﺪﺩ

 ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ ﻭﺍﻟﻔﻬﺮﺱ ﺍﻟﺜﺎﻧﻲ ﻋﺪﺩ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻤﻔﺮﺩﺓ ﺍﻟﺘﻲ ﻳﻤﻜﻦ ﺃﻥ ﻳﺴﺘﻮﻋﺒﻬﺎ ﺍﻟﺮﻣﺰ ﺍﻟﻨﺼﻲ ﻣﻦ

  ﻟﻘﺮﺍءﺓ ﻭﺧﺰﻥ ﺧﻤﺴﺔ ﺃﺳﻤﺎء ﻃﻮﻝ ﺃﻛﺒﺮﻫﺎ ﺗﺴﻌﺔ ﺭﻣﻮﺯ ﻣﻔﺮﺩﺓ ﻧﺴﺘﺨﺪﻡًﻼﺜﻤﻓ .ﺓﺩﺮﻔﻤﻟﺍ ﺯﻮﻣﺮﻟﺍ

 :

 ﺍﻟﺘﻌﺮﻳﻒ

char names [5] [9]; 

  ﻟﻘﺮﺍءﺓ ﻭﺧﺰﻥ ﺃﺳﻢ ﻓﻲ ﺍﻟﺨﻠﻴﺔًﻼﺜﻤﻓ .ﻦﻴﻌﻣ ﻲﺼﻧ ﺰﻣﺭ ﻰﻟﺇ ﺓﺭﺎﺷﻺﻟ ﻂﻘﻓ ﻝﻭﻷﺍ ﺱﺮﻬﻔﻟﺍ ﻡﺪﺨﺘﺴﻳﻭ

 :

ﺍﻟﺜﺎﻧﻴﺔ ﻧﺴﺘﺨﺪﻡ

gets(name[1]); 

)

 ﻣﺜﺎﻝ

12

:(

  ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﺮﺃ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻷﺳﻤﺎء ﻭﻳﺨﺰﻧﻬﺎ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻌﺪ ﻭﺍﺣﺪ ﻣﻦ

 :

ﺍﻟﺮﻣﻮﺯ ﺍﻟﻨﺼﻴﺔ ﻭﻣﻦ ﺛﻢ ﻳﻄﺒﻊ ﻫﺬﻩ ﺍﻷﺳﻤﺎء

#include<stdio.h> 
#include <iostream.h> 
main( ){ 
char name[100][20]; 

int n, i; 
n =0; 
do{ 
cout<<"\n Enter name (press RETURN to stop):"; 
gets(name[n]); 
}while(name[n++][0] != '\0'); 
for(i=0;i<n;++i) 
cout<<"\n "<<name[i]; 
} 

: ﺇﺳﻨﺎﺩ ﻗﻴﻢ ﺍﺑﺘﺪﺍﺋﻴﺔ ﻟﻠﻤﺼﻔﻮﻓﺎﺕ

 ﺗﺴﻤﺢ ﻟﻐﺔ

++

C

 :

 ﺑﺈﺳﻨﺎﺩ ﻗﻴﻢ ﺍﺑﺘﺪﺍﺋﻴﺔ ﻟﻠﻤﺼﻔﻮﻓﺎﺕ ﻭﺗﺴﺘﺨﺪﻡ ﺍﻟﺼﻴﻐﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻟﺬﻟﻚ

type array_name [size1] [size2] = { list of values }; 

  ( ﻭﺗﺴﻨﺪ ﺍﻟﻘﻴﻤﺔ ﺍﻷﻭﻟﻰ ﻓﻲ ﺍﻟﻘﺎﺋﻤﺔ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺮ ﺍﻷﻭﻝ ﻭﺍﻟﻘﻴﻤﺔ, ) ﺓﺯﺭﺎﻔﻟﺍ ﻢﻴﻘﻟﺍ ﻦﻴﺑ ﻞﺼﻔﺗ ﺚﻴﺣ

 .

ﺍﻟﺜﺎﻧﻴﺔ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺮ ﺍﻟﺜﺎﻧﻲ ﻭﻫﻜﺬﺍ

 ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻌﺮﻑ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻌﺪ ﻭﺍﺣﺪ ﻭﻣﻜﻮﻧﺔ ﻣﻦ ﻋﺸﺮﺓ ﻋﻨﺎﺻﺮ. ﺗﻢ ﺇﺳﻨﺎﺩ ﺍﻟﻘﻴﻤﺔ

3

  ﺇﻟﻰ

 ﺍﻟﻌﻨﺼﺮ ﺍﻷﻭﻝ

number [0]

  ﻭﺍﻟﻘﻴﻤﺔ

56

  ﺇﻟﻰ ﺍﻟﻌﻨﺼﺮ ﺍﻟﺜﺎﻧﻲ

number[1]

 .

 ﻭﻫﻜﺬﺍ

int number [10] = { 3, 56, 34, 32, 89, 12, 22, 77, 57, 48 }; 

 :

ﺃﻣﺎ ﺑﺎﻟﻨﺴﺒﺔ ﺇﻟﻰ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﻣﻦ ﺍﻟﻨﻮﻉ ﺍﻟﻨﺼﻲ ﻓﻴﻤﻜﻦ ﺇﺳﻨﺎﺩ ﺍﻟﻘﻴﻤﺔ ﺍﻻﺑﺘﺪﺍﺋﻴﺔ ﺑﺎﻟﺼﻴﻐﺔ

char array_name [size] = "string"; 

 ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻌﺮﻑ ﺭﻣﺰ ﻧﺼﻲ ﻭﺗﺴﻨﺪ ﺇﻟﻴﻪ ﺍﻟﻨﺺ

"hello"

 : 

char text [6] = "hello"; 

 ﻻﺣﻆ ﺃﻥ ﻃﻮﻝ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻫﻮ

6

  ﻓﻲ ﺣﻴﻦ ﺃﻥ ﻋﺪﺩ ﺍﻟﺤﺮﻭﻑ ﻫﻮ

5

  ﻭﺍﻟﺴﺒﺐ ﻳﻌﻮﺩ ﺇﻟﻰ ﺿﺮﻭﺭﺓ ﺗﻮﻓﻴﺮ

 ﺧﻠﻴﺔ ﻟﺮﻣﺰ ﻧﻬﺎﻳﺔ ﺍﻟﻨﺺ

'\0'

 :

 ﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﺃﻥ ﺍﻟﻌﺒﺎﺭﺓ ﺃﻋﻼﻩ ﻫﻲ ﻣﻄﺎﺑﻘﺔ ﻟﻠﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ

char text [6] = { 'h', 'e', 'l', 'l', 'o', '\0' }; 

 ﻛﻤﺎ ﻳﻤﻜﻦ ﺇﺳﻨﺎﺩ ﻗﻴﻢ ﺍﺑﺘﺪﺍﺋﻴﺔ ﻟﻠﻤﺼﻔﻮﻓﺎﺕ ﺫﺍﺕ ﺑﻌﺪﻳﻦ ﺑﻨﻔﺲ ﺍﻟﻄﺮﻳﻘﺔ ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺗﻌﺮﻳﻒ ﻟﻤﺼﻔﻮﻓﺔ

 ﺫﺍﺕ ﺑﻌﺪﻳﻦ ﺗﻢ ﺇﺳﻨﺎﺩ ﻗﻴﻢ ﻣﻦ

1

  ﺇﻟﻰ

10

 :

 ﻭﻣﺮﺑﻌﺎﺗﻬﺎ ﺇﻟﻰ ﻋﻨﺎﺻﺮ ﺍﻟﻤﺼﻔﻮﻓﺔ

int square [10] [2] = { 1, 1, 2, 4, 3, 9, 4, 16, 5, 25, 6, 36, 7, 49, 8, 64, 9, 

                                 81, 10, 100 }; 

 .

ﻻﺣﻆ ﺃﻥ ﺍﻟﻘﻴﻢ ﺗﺴﻨﺪ ﺇﻟﻰ ﺍﻟﺴﻄﺮ ﺍﻷﻭﻝ ﻭﻣﻦ ﺛﻢ ﺇﻟﻰ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻧﻲ ﻭﻫﻜﺬﺍ

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

)

 ﺳﺆﺍﻝ

1

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻻﻳﺠﺎﺩ ﺍﻛﺒﺮ ﻋﻨﺼﺮ ﻣﻦ ﻋﻨﺎﺻﺮ ﺍﻟﻘﻄﺮ ﺍﻟﺮﺋﻴﺴﻲ ﻟﻤﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻌﺪﻳﻦ

 ﻋﻨﺎﺻﺮﻫﺎ ﻫﻲ





















8

2

5

25

14

3

16

12

7

 ؟ ﻭﻃﺒﺎﻋﺘﻪ

#include <stdio.h> 
main( ){ 
int  i ,max; 
int x[3][3]={7, 12, 16, 3, 14, 25, 5, 2, 8}; 
max = x[0][0]; 
for(i=0;i<3;++i) 
if(x[i][i] >max)max = x[i][i]; 
printf("\n max =%d",max); 
} 

)

 ﺳﺆﺍﻝ

2

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺤﻮﻳﻞ ﻋﻨﺎﺻﺮ ﺍﻟﻘﻄﺮ ﺍﻟﺜﺎﻧﻮﻱ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﻣﻊ ﻋﻨﺎﺻﺮ ﺍﻟﻘﻄﺮ

 ﺍﻟﺮﺋﻴﺴﻲ ﻟﻠﻤﺼﻔﻮﻓﺔ

[B]

  ﺇﻥ ﺍﻟﻤﺼﻔﻮﻓﺘﻴﻦ ﻫﻤﺎًﺎﻤﻠﻋ 

[ ]

























=

4

1

2

18

5

17

19

7

9

31

12

14

25

23

21

16

A

[ ]

























=

32

14

5

16

12

10

9

7

18

2

8

3

11

5

6

1

B

#include <stdio.h> 
main( ){ 
int i,j,c; 
int a[4][4]={16, 21, 23, 25, 14, 12, 31, 9, 7, 19, 17, 5, 18, 2, 1, 4}; 
int b[4][4]={1, 6, 5, 11, 3, 8, 2, 18, 7, 9, 10, 12, 16, 5, 14, 32}; 
for(i=0;i<4;++i) 
for(j=0;j<4;++j) 
if(i+j ==3){ 
c=a[i][j]; 
a[i][j]=b[i][i]; 
b[i][i]=c;} 
printf("\n A="); 
for(i=0;i<4;++i){ 
printf("\n"); 
for(j=0;j<4;++j) 
printf("%d \t",a[i][j]);} 
printf("\n B="); 
for(i=0;i<4;++i){ 
printf("\n"); 
for(j=0;j<4;++j) 

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

printf("%d \t",b[i][j]);} 
} 

)

 ﺳﺆﺍﻝ

3

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻻﻳﺠﺎﺩ ﻣﺠﻤﻮﻋﺔ ﻋﻨﺎﺻﺮ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﺫﺍﺕ ﺍﻟﺒﻌﺪﻳﻦ ﻭﺍﻟﺘﻲ ﻗﻴﻢ

 ﻋﻨﺎﺻﺮﻫﺎ ﻫﻲ





















8

3

5

12

6

4

4

2

8

#include < stdio.h > 
main(){ 
int i,j,a[3][3]={8, 2, 4, 4, 6, 12, 5, 3, 8}; 
int sum = 0; 
for(i=0;i<3;++i) 
for(j=0;j<3;++j) 
sum + = a[i][j]; 
printf("\n sum = %d ",sum); 
} 

)

 ﺳﺆﺍﻝ

4

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﻜﻮﻳﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ

[C]

  ﺍﻟﺘﻲ ﺗﻜﻮﻥ ﻗﻴﻤﺘﻬﺎ ﻧﺎﺗﺠﺔ ﻣﻦ ﺟﻤﻊ ﻗﻴﻢ ﺍﻟﻤﺼﻔﻮﻓﺔ

[B]

  ﻣﻊ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﻣﻄﺮﻭﺡ ﻣﻨﻬﺎ ﻗﻴﻢ ﺍﻟﻤﺼﻔﻮﻓﺔ

[D]

  ﺇﻥ ﻗﻴﻢ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﻫﻲًﺎﻤﻠﻋ 

[ ]





















=

3

9

4

5

7

8

12

6

12

A

[ ]





















=

4

4

5

2

4

3

8

7

6

B

[ ]





















=

3

24

16

12

5

7

13

21

9

D

 
 
#include < stdio.h > 
main( ){ 
int i, j, a[3][3] ={12, 6, 12, 8, 7, 5, 4, 9, 3}; 
int b[3][3]={6, 7, 8, 3, 4, 2, 5, 4, 4}; 
int c[3][3],d[3][3]={9, 21, 13, 7, 5, 12, 16, 24, 3}; 
for(i=0;i<3;++i) { 
printf("\n"); 
for(j=0;j<3;++j) { 
c[i][j] =(a[i][j] + b[i][j]) - d[i][j]; 
printf("\t %d", c[i][j]); 
}}} 

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

)

 ﺳﺆﺍﻝ

5

:(

 ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﻜﻮﻳﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ

A[3][3]

  ﻭﺍﺑﺪﺍﻝ ﻋﻨﺎﺻﺮ ﺍﻟﻘﻄﺮ ﺍﻟﺮﺋﻴﺴﻲ

 ﺑﻌﻨﺎﺻﺮ ﺍﻟﺴﻄﺮ ﺍﻻﻭﻝ

#include < stdio.h > 
main( ){ 
int i, j, b, a[3][3]; 
for(i=0;i<3;++i) 
for(j=0;j<3;++j) 
scanf("%d", & a[i][j]); 
for(i=0;i<3;++i) 
for(j=0;j<3;++j) 
if(i == 0){ 
b =a[i][j]; 
a[i][j] =a[j][j]; 
a[j][j] =b; 
} 
for(i=0;i<3;++i){ 
printf("\n"); 
for(j=0;j<3;++j) 
printf("\t %d", a[i][j]); 
}} 

)

 ﺳﺆﺍﻝ

6

:(

 ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎﺩ ﻣﻌﺪﻝ ﺍﺭﺑﻊ ﻃﻼﺏ ﻷﺭﺑﻊ ﺩﺭﺟﺎﺕ ﺑﺎﺳﺨﺪﺍﻡ

 ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

#include < stdio.h > 
main( ){ 
int i, j, a[4][4]; 
float  v[4]; 
for(i=0;i<4;++i) { 
v[i]=0.0; 
for(j=0;j<4;++j) 
scanf("%d", & a[i][j]); } 
for(i=0;i<4;++i) { 
for(j=0;j<4;++j) 
v[i] += a[i][j]; 
v[i] = v[i]/4;  } 
for(i=0;i<4;++i) 
printf("\n %10.2f", v[i]); 
} 

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

)

 ﺳﺆﺍﻝ

7

:(

 ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺤﻮﻳﻞ ﺍﺳﻄﺮ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

   ﺑﺎﻋﻤﺪﺗﻬﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻫﻲ

[ ]

























=

17

21

12

8

11

15

31

35

13

22

21

15

7

18

22

16

A

#include < stdio.h > 
main( ){ 
int i, j, b; 
int a[4][4]={16, 22, 18, 7, 15, 21, 22, 13, 35, 31, 15, 11, 8, 12, 21, 17}; 
for(i=0;i<4;++i) 
for(j=0;j<4;++j) 
if(j >i){ 
B = a[i][j]; 
a[i][j] = a[j][i]; 
a[j][i] = b; } 
for(i=0;i<4;++i) { 
printf("\n"); 
for(j=0;j<4;++j) 
printf("\t  %d", a[i][j]); 
}} 

)

 ﺳﺆﺍﻝ

8

:(

 ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮﻡ ﺑﻀﺮﺏ ﺍﻟﺴﻄﺮ ﺍﻻﻭﻝ ﻣﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﻣﻊ ﺍﻟﻌﻤﻮﺩ

 ﺍﻻﻭﻝ ﻣﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ

[B]

   ﻋﻠﻤﺎ ﺍﻥ ﺍﻟﻤﺼﻮﻓﺘﻴﻦ ﺛﻨﺎﺋﻴﺔ ﺍﻟﺒﻌﺪ ﻭﻫﻤﺎ ﺑﺎﻟﺸﻜﻞ ﺍﻻﺗﻲ

[ ]













=

7

2

4

5

3

2

A

[ ]





















=

1

8

5

2

7

6

9

6

2

B

 
#include < stdio.h > 
main( ){ 
int i, j, c=0, a[2][3]={2,3,5,4,2,7}; 
int b[3][3]={2,6,9,6,7,2,5,8,1}; 
for(i=0;i<3;++i) 
c += a[0][i]*b[i][0]; 
printf("\n %d", c); 
} 

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

)

 ﺳﺆﺍﻝ

9

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻹﻳﺠﺎﺩ ﺣﺎﺻﻞ ﺿﺮﺏ ﺍﻟﻤﺼﻔﻮﻓﺘﻴﻦ

[B]*[A]

  ﺇﻥ ﻗﻴﻢ ﺍﻟﻤﺼﻔﻮﻓﺔًﺎﻤﻠﻋ 

[A]

  ﻫﻲ

3,6,7,8,12

  ﻭﻗﻴﻢ ﺍﻟﻤﺼﻔﻮﻓﺔ

[B]

  ﻫﻲ

20,6,14,9,7

  ﺇﻥ ﺍﻟﻤﺼﻔﻮﻓﺘﻴﻦ ﻫﻤﺎ ﺫﺍﺕًﺎﻤﻠﻋ 

 .

ﺑﻌﺪ ﻭﺍﺣﺪ

#include < stdio.h > 
main( ){ 
int i, a[5] = {3,6,7,8,12}, b[5] = {20,6,14,9,7}, c=0; 
for(i=0;i<5;++i) 
c += a[i]*b[i]; 
printf("\n %d",c); 
} 

)

 ﺳﺆﺍﻝ

10

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﺣﻼﻝ ﻋﻨﺎﺻﺮ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﻣﻜﺎﻥ ﻋﻨﺎﺻﺮ ﺍﻟﻤﺼﻔﻮﻓﺔ

[B]

 ﻭﺇﺣﻼﻝ ﻋﻨﺎﺻﺮ ﺍﻟﻤﺼﻔﻮﻓﺔ

[B]

  ﻣﻜﺎﻥ ﻋﻨﺎﺻﺮ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﺇﻥ ﺍﻟﻤﺼﻔﻮﻓﺘﻴﻦ ﻫﻤﺎًﺎﻤﻠﻋ 

  ﻣﺼﻔﻮﻓﺘﺎﻥ ﺍﺣﺎﺩﻳﺘﺎﻥ ﻭﻋﻨﺎﺻﺮﻫﻤﺎ ﻫﻲ

[ ]





















=

17

6

3

A

[ ]





















=

4

7

15

B

#include < stdio.h > 
main( ){ 
int i, c, a[3] = {3,6,17}, b[3] = {15,7,4}; 
for(i=0;i<3;++i) { 
c = a[i]; 
a[i] = b[i]; 
b[i] = c; } 
for(i=0;i<3;++i) 
printf("\n %d \t %d", a[i], b[i]); 
} 
 

)

 ﺳﺆﺍﻝ

11

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻹﻳﺠﺎﺩ ﻣﻔﻜﻮﻙ ﻋﻨﺎﺻﺮ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﻭﻃﺒﺎﻋﺔ ﻗﻴﻢ ﻣﻔﻜﻮﻙ ﺍﻟﻌﻨﺎﺻﺮ

 ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﺍﺧﺮﻯ ﻫﻲ

[B]

  ﺇﻥ ﻣﺼﻔﻮﻓﺔًﺎﻤﻠﻋ 

[A]

  ﻫﻲ





















8

6

12

4

15

2

3

17

1

  ﻭﺍﻟﻤﺼﻔﻮﻓﺔ

[B]

  ﺫﺍﺕ

 .

ﺑﻌﺪ ﻭﺍﺣﺪ

#include < stdio.h > 
main( ){ 
int i, j, k=0, x, a[3][3]={1, 17, 3, 2, 15, 4, 12, 6, 8}; 
double b[9]; 
for(i=0;i<3;++i) 

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

for(j=0;j<3;++j) { 
b[k] = 1; 
x = a[i][j]; 
for(x; x>=1;--x) 
b[k] *= x; 
k = k+1; } 
for(i=0;i<k;++i) 
printf("\n %10.2f", b[i]); 
} 

)

 ﺳﺆﺍﻝ

12

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻹﻳﺠﺎﺩ ﻣﺮﺑﻊ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺰﻭﺟﻴﺔ ﺩﺍﺧﻞ ﺍﻟﻘﻄﺮ ﺍﻟﺜﺎﻧﻮﻱ ﻟﻠﻤﺼﻔﻮﻓﺔ

[A]

 ﻭﻭﺿﻊ ﻫﺬﻩ ﺍﻟﻘﻴﻢ ﺃﻱ ﻣﺮﺑﻌﺎﺕ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺰﻭﺟﻴﺔ ﻓﻲ ﻣﺼﻔﻮﻓﺔ

[B]

  ﺃﻥ ﺍﻟﻤﺼﻔﻮﻓﺔًﺎﻤﻠﻋ 

[A]

  ﻫﻲ

























7

9

18

26

17

1

12

13

8

6

14

7

15

11

8

12

#include < stdio.h > 
main( ){ 
int i, j, k=0, b[4]; 
int a[4][4] = {12, 8, 11, 15, 7, 14, 6, 8, 13, 12, 1, 17, 26, 18, 9, 7}; 
for(i=0;i<4;++i) 
for(j=0;j<4;++j) 
if( i+j == 3 && a[i][j]%2 == 0) { 
b[k] = a[i][j]*a[i][j]; 
k = k+1; } 
for(i=0;i<k;++i) 
printf("\n %d", b[i]); 
} 

)

 ﺳﺆﺍﻝ

13

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻹﻳﺠﺎﺩ ﺍﻛﺒﺮ ﻋﻨﺼﺮ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﻭﺛﻢ ﺍﻳﺠﺎﺩ ﺍﻛﺒﺮ ﻋﻨﺼﺮ ﻓﻲ

 ﺍﻟﻤﺼﻔﻮﻓﺔ

[B]

 :

 ﺇﻥ ﻗﻴﻢ ﺍﻟﻤﺼﻔﻮﻓﺘﻴﻦ ﻫﻲًﺎﻤﻠﻋ ﺎﻤﻬﻨﻣ ﺮﺒﻛﻻﺍ ﺔﻋﺎﺒﻃﻭ ﺎﻤﻬﺘﻧﺭﺎﻘﻣﻭ 

[ ]

































=

10

15

20

30

40

A

[ ]





















=

6

8

12

20

45

13

65

8

9

B

#include < stdio.h > 
main( ) { 
int i, j, maxa, maxb, a[5] = {40, 30, 20, 15, 10}; 
int b[3][3] = {9, 8, 65, 13, 45, 20, 12, 8, 6}; 

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

maxa = a[0]; 
for(i=0;i<5;++i) 
if(a[i] > maxa) maxa = a[i]; 
printf("\n maxa= %d", maxa); 
maxb = b[0][0]; 
for(i=0;i<3;++i) 
for(j=0;j<3;++j) 
if(b[i][j] > maxb) maxb = b[i][j]; 
printf("\n maxb= %d", maxb); 
if(maxa > maxb) printf("\n max. is maxa= %d", maxa); 
else   printf("\n max. is maxb= %d", maxb); 
} 

)

 ﺳﺆﺍﻝ

14

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻹﻳﺠﺎﺩ ﺍﻛﺒﺮ ﻋﻨﺼﺮ ﻭﺍﺻﻐﺮ ﻋﻨﺼﺮ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﻭﺿﺮﺏ

 ﺍﻟﻤﺼﻔﻮﻓﺔ

[B]

  ﺑﺎﻛﺒﺮ ﻋﻨﺼﺮ ﻟﺘﻜﻮﻳﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ

[C]

  ﻭﺿﺮﺏ ﺍﻟﻤﺼﻔﻮﻓﺔ

[B]

  ﺑﺎﺻﻐﺮ ﻋﻨﺼﺮ

 ﻟﺘﻜﻮﻳﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ

[D]

 .

ﺃﻥ ﺟﻤﻴﻊ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﺫﺍﺕ ﺑﻌﺪ ﻭﺍﺣﺪ ﻭﻣﻜﻮﻧﺔ ﻣﻦ ﺳﺘﺔ ﻋﻨﺎﺻﺮًﺎﻤﻠﻋ 

 #include < stdio.h > 
main( ){ 
int i, max, min, a[6], b[6], c[6], d[6]; 
printf("input a & b matrix"); 
for(i=0;i<6;++i) 
scanf("%d  %d", &a[i], &b[i]); 
max = a[0]; 
min = a[0]; 
for(i=0;i<6;++i) { 
if(a[i] > max) max = a[i]; 
if(a[i] < min) min = a[i];} 
for(i=0;i<6;++i){ 
c[i] = max*b[i]; 
d[i] = min*b[i];  } 
printf("\n a[6] \t b[6] \t c[6] \t d[6]"); 
for(i=0;i<6;++i) 
printf("\n %d \t %d \t %d \t %d ", a[i], b[i], c[i], d[i]); 
} 

)

 ﺳﺆﺍﻝ

15

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻹﻳﺠﺎﺩ ﺍﻻﻋﺪﺍﺩ ﺍﻷﻭﻟﻴﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﻭﻛﺘﺎﺑﺔ ﻛﻠﻤﺔ

(not found)

  ﺍﻥ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻫﻲًﺎﻤﻠﻋ .ﺔﻓﻮﻔﺼﻤﻟﺍ ﻞﺧﺍﺩ ﺔﻴﻟﻭﻻﺍ ﺩﺍﺪﻋﻻﺍ ﻰﻟﺇ ﻲﻤﺘﻨﻳ ﺮﺼﻨﻋ ﻱﺍ ﺪﺠﻳ ﻢﻟ ﺍﺫﺍ

[ ]





















=

9

18

6

32

41

9

3

27

5

12

7

13

A

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

#include < stdio.h > 
main( ){ 
int i, j, x, k=0; 
int a[3][4] = {13, 7, 12, 5, 27, 3, 9, 41, 32, 6, 18, 9}; 
for(i=0;i <3;++i) 
for(j=0;j <4;++j) { 
for(x = 2; x <a[i][j];++x) 
if(a[i][j]%x == 0) goto stop; 
printf("\n %d", a[i][j]); 
k=k+1; 
stop: } 
if(k == 0) printf("not found"); 
} 

)

 ﺳﺆﺍﻝ

16

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻹﻳﺠﺎﺩ ﻛﻠﻤﺔ

(why)

  ﻣﻦ ﺑﻴﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﺨﺰﻭﻧﺔ ﻓﻲ

 ﻣﺼﻔﻮﻓﺔ ﻭﻋﻨﺪ ﻭﺟﻮﺩﻫﺎ ﻳﻄﺒﻊ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻛﻠﻤﺔ

(why not)

  ﻭﻋﻨﺪ ﻋﺪﻡ ﻭﺟﻮﺩﻫﺎ ﻳﻄﺒﻊ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻛﻠﻤﺔ

(forget it)

 . 

#include < stdio.h > 
#include < string.h > 
main( ){ 
 int i; 
char a[5][10] = {"yes", "why", "go", "sit", "there"}; 
for(i=0;i <5;++i) 
if(strcmp(a[i],"why") == 0) { 
printf("\n %s not", a[i]); 
goto end; } 
printf("\n forget it"); 
end: 
} 

)

 ﺳﺆﺍﻝ

17

:(

  ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﺍﺧﺮﻯًﺎﻴﺴﻜﻋ ًﺎﺒﻴﺗﺮﺗ ﺎﻬﺒﻴﺗﺮﺗﻭ ﺔﻓﻮﻔﺼﻣ ﻲﻓ ﺩﺍﺪﻋﺍ ﺓءﺍﺮﻘﻟ ﺞﻣﺎﻧﺮﺑ ﺐﺘﻛﺍ 

 .

ﺇﻥ ﺍﻟﻤﺼﻔﻮﻓﺘﻴﻦ ﺫﺍﺕ ﺑﻌﺪ ﻭﺍﺣﺪًﺎﻤﻠﻋ

#include < stdio.h > 
main( ){ 
int i, x[4] = {11,8,5,6}, b[4]; 
for(i=0;i<4;++i) { 
b[i] = x[3-i]; 
printf("\n %d", b[i]); 
}} 

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

)

 ﺳﺆﺍﻝ

18

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮﺍءﺓ ﻣﺼﻔﻮﻓﺔ

[A]

  ﺛﻢ ﻋﺰﻝ ﺍﻻﻋﺪﺍﺩ ﺍﻟﻔﺮﺩﻳﺔ ﻓﻲ ﻣﺼﻔﻮﻓﺔ

[B]

 ﻭﺍﻻﻋﺪﺍﺩ ﺍﻟﺰﻭﺟﻴﺔ ﻓﻲ ﻣﺼﻔﻮﻓﺔ

[C]

 .

 ﻭﻃﺒﺎﻋﺔ ﻫﺬﻩ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﺍﻟﺜﻼﺙ

#include < stdio.h > 
main( ){ 
int i, a[6] = {5,7,8,10,12,11}; 
int b[6], c[6], j=0, k=0; 
for(i=0;i<6;++i) 
if(a[i]%2 == 0) { 
c[k] = a[i]; 
k=k+1;  } 
else  { 
b[j] = a[i]; 
j = j+1;  } 
for(i=0;i<6;++i) 
printf("%d  \t", a[i]); 
printf("\n"); 
for(i=0;i<j;++i) 
printf("%d  \t", b[i]); 
printf("\n"); 
for(i=0;i<k;++i) 
printf("%d  \t", c[i]); 
} 

)

 ﺳﺆﺍﻝ

19

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺮﺗﻴﺐ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﺇﻥ ﺍﻟﻤﺼﻔﻮﻓﺔًﺎﻤﻠﻋ ًﺎﻳﺪﻋﺎﺼﺗ 

[A]

  ﻫﻲ

































8

3

15

11

9

#include < stdio.h > 
main( ){ 
int i, j, k, b; 
int a[5] = {9,11,15,3,8}; 
for(i=0;i<5;++i) 
{ k=i; 
for(j=i;j<5;++j) 
if(a[j] < a[k]) k = j; 
b = a[i]; 
a[i] = a[k]; 
a[k] = b; 
printf("\n %d", a[i]); 
}} 

 ﺃﻣﺜﻠﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ

)

 ﺳﺆﺍﻝ

20

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺮﺗﻴﺐ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﺃﻥ ﺍﻟﻤﺼﻔﻮﻓﺔًﺎﻤﻠﻋ ًﺎﻴﻟﺯﺎﻨﺗ 

[A]

  ﻫﻲ













































20

16

31

17

15

32

21

#include < stdio.h > 
main( ){ 
int i, j, k, b; 
int a[7] = {21,32,15,17,31,16,20}; 
for(i=0;i<7;++i) 
{ k=i; 
for(j=i;j<7;++j) 
if(a[j] > a[k]) k=j; 
b = a[i]; 
a[i] = a[k]; 
a[k] = b; 
printf("\n %d", a[i]); 
}} 

)

 ﺳﺆﺍﻝ

21

:(

  ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎﺩ ﺍﻻﻋﺪﺍﺩ ﺍﻟﺘﻲ ﺗﻘﺒﻞ ﺍﻟﻘﺴﻤﺔ ﻋﻠﻰ

3

  ﺩﺍﺧﻞ ﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﺫﺍﺕ

 ﺍﻟﺒﻌﺪﻳﻦ ﻭﺍﻳﺠﺎﺩ ﻣﺠﻤﻮﻉ ﻫﺬﻩ ﺍﻻﻋﺪﺍﺩ ﻭﺍﻟﻤﺼﻔﻮﻓﺔ

[A]

  ﻫﻲ





















15

7

12

8

13

5

17

21

22

#include < stdio.h > 
main( ) { 
int i, j, a[3][3] = {22,21,17,5,13,8,12,7,15}; 
int s = 0; 
for(i=0;i<3;++i) 
for(j=0;j<3;++j) 
if(a[i][j]%3 == 0) { 
printf("\n"); 
printf("%d \t", a[i][j]); 
s += a[i][j]; } 
printf("\n %d", s); 
}