logo

Dasturlash tilida ichma-ich sikllarni ishlatish

Yuklangan vaqt:

12.08.2023

Ko'chirishlar soni:

0

Hajmi:

745.923828125 KB
Mavzu:Dasturlash tilida ichma-ich sikllarni ishlatish
                                             Reja:
1. C++ dasturlash tilida sikllarni ishlatish;
2. Break va continue (goto) operatorlarini ishlatish;
3. Sikllarni ichma-ich qo’llash. Tayanch iboralar:   do-while takrorlash operatori, break operatori, continue 
operatori, goto operatori, nishonlar.
Bilamizki masalani	 yechish	 davomida	 bazi	 bir	 masalani	 javobini	 topish	 uchun	 bir	 
necha	
 bor	 takrorlanadi.	 Buni	 hal	 qilish	 uchun	 albatta	 
bizga   takrorlash   ya’ni   sikl   operatorlari	
 kerak	 bo’ladi.
Takrorlash	
 operatorlari	 quyidagilar:
 For
 Do	
 .. While
 While
Siz	
 yechayotgan	 masalangizni	 berilishiga	 qarab	 shulardan	 birini	 tanlaysiz.
For	
 takrorlash	 operatori	 quyidagicha.
For    	
(<ifoda1>;	 <ifoda2>;	 <ifoda3>)
<operator	
 yoki	 blok>;
Bu	
 operator	 amal	 qilishni	 <ifoda1>	 bajarishdan	 boshlaydi.	 Keyin	 takrorlash	 
qadamlari	
 boshlanadi.	 Har	 bir	 qadamda	 <ifoda2>	 bajariladi,	 agar	 natija	 0 dan	 farqli
yoki	
 rost	 (true)	 bo’lsa,	 sikl	 tanasi	 – <operator	 yoki	 blok>	 bajariladi	 va	 oxirida	 
<ifoda3>	
 bajariladi,	 aks	 holda	 boshqaruv	 takrorlash	 operatoridan	 keyingi	 
operatorga	
 o’tiladi.	 Sikl	 tanasi	 – <operator	 yoki	 blok>	 sifatida	 bitta	 operator,	 shu	 
jumladan	
 bo’sh	 operator,	 yoki	 operatorlar	 bloki	 kelishi	 mumkin.
Sikl	
 takrorlanishi	 davomida	 bajarilishi	 lozim	 bo’lgan	 operatorlar	 majmuasi	 sikl	 
tanasi	
 deyiladi.	 Sikl	 tanasi	 sifatida	 bir	 yoki	 bir	 nechta	 operatordan	 foydalanish	 
mumkin.	
 Agar	 sikl	 tanasida	 bir	 nechta	 operatordan	 foydalanmoqchi	 bo’lsak	 bu	 
operatorlarni	
 blok   {}   orasiga	 olishimiz	 kerak.
1	
 dan	 10	 (sikl	 yordamida)	 gacha	 bo’lgan	 sonlarni	 chiqaruvchi	 dastur:  #
include <iostream>
using	
 namespace	 std ;
int	
 main ()
{
for   ( int	
 i   =	 1;   i   <=	 10;   i ++)
cout     <<    	
i     <<	    “	  ” ;
cout	
    <<    	endl ;
return   0;
}
 E
ekranda
 quyidagicha	 natija	 hosil	 bo’ladi.
T ak r or l a sh	
 qa da m i ni	 a m a l g a	 o sh i r i s h	 u ch un   wh i l e   ka l i t	 so 'z i d an	 
f oy da l a na m i z.   sh ar t   or q al i	
 t s ki l	 h os i l	 b o' l a di .	 q uy i d ag i	 si nt ak si sn i	 
o' zi ng i z ga	
 f or m ul a	 s i f at i d a	 yo dl ab	 q uy i n g.
while(<shart>){
//sikl	
 tanasi
} Mi so l :   wh i l e   da n f o yd al an i b	 0 d an	 7 g ac ha	 so nl ar ni	 e kr an ga	 ch i q ar i sh	 
da st ur i n i	
 t u zi sh .
Da st ur :
# include   <iostream>
using   namespace  	
std;
int   main ()	
 {
    int  	
i =  0 ;
    while  
(i <=	  7 )	 {
        cout	
 <<	 i <<	  "\n" ;
        i++;
 	
 }
    return   0 ;
}
Natija Do/While   Tsikl
do / wh i l e   va   wh i l e   i k ki si ha m	 si kl	 h i s ob l a na di .	 bi r i nc hi si ni	 
i k ki nc hi si da n	
 f ar q l i	 j i ha t i	 s hu nd ak i	 b i r i n   do / wh i l e   av va l	 s ha r t ni	 b aj ar i b	 
ke yi n	
 t e ks hi r a di .   wh i l e   es a	 av va l	 sh ar t	 b aj ar i l a di	 a ga r	 t o 'g 'r i	 bo 'l sa	 t s i k l	 
t a na si da gi	
 k od	 i sh l a t i l a di .	 qu yi da gi   do / wh i l e   si nt ak si si ni	 yo dd a	 
sa ql as hi ng i z	
 zar ur	 b o' l a di .
do  	
{
    //
 tsikl	 tanasi
}
while   (<Shart>) ;
Yu qor i d ag i	
 Mi so l d ag i	 sh ar t g a	 m uaf i q	 s hu ni	 bi z   do / wh i l e   da	 i sh l a b	 
ko 'r am i z .
# include   <iostream>
using   namespace  	
std;
int   main ()   {
    int  	
i =  0 ;
    do  	
{
        cout	
 <<	 i <<	  "\n" ;
        i++;
 	
 }
    while  	
(i <=	  7 );
    return   0 ; }
                                                                         Natija: Sikl aylanayotgan	 vaqtda	 bog'liq	 bo'lgan	 o'zgaruvchini	 o'zgartirishni	 unutmang.	 
agar	
 qiymatini	 o'zgartirmasangiz	 sikl	 tugamaydi .
Break  	
operatori:
Takrorlash	
 operatorlarining	 bajarilishida	 shunday	 holatlar	 yuzaga	 kelishi	 
mumkinki,	
 unda	 qaysidir	 qadamda,	 takrorlashni	 yakuniga
yetkazmasdan	
 takrorlashdan	 chiqish	 zarurati	 bo‘lishi	 mumkin.	 Boshqacha	 
aytganda	
 takrorlashni	 «uzish»	 kerak	 bo‘lishi	 mumkin.	 Bunda	 break	 operatoridan	 
foydalaniladi.	
 Break	 operatorini	 takrorlash	 operatori	 tanasining	 ixtiyoriy	 (zarur)	 
joylariga	
 qo‘yish	 orqali	 shu	 joylardan	 takrorlashdan	 chiqishni	 amalga	 oshirish	 
mumkin.	
 E’tibor	 beradigan	 bo’lsak	 switch-case	 operatorining	 tub	 mohiyatiga	 ham	 
break	
 operatorini	 qo’llash	 orqali	 erishilgan.
Ichma	
 – ich	 joylashgan	 takrorlash	 va	 switch	 operatorlarida	 break	 operatori	 faqat	 
o‘zi	
 joylashgan	 blokdan	 chiqish	 imkoniyatini	 beradi.
br ea k   .	
 Fu nk si ya l a r ,	 S har t	 op er at or l ar i	 v a	 t akr or l as h	 o pe r a t or l ar i d a	 k o' p	 
qo 'l l a ni l a di .
break   –	
 funksiyasini	 har	 qanday	 sikl	 operatoriga	 qo’llash	 mumkin.	 Bu	 funksiya	 
sikl	
 tugatilishini	 ta’minlaydi.	 Ya’ni	 boshqarilishni	 sikl	 operatoridan	 keyingi	 
operatorga	
 uzatadi.
C++   break
break   -
 yakka	 holatda	 o'zi	 keladi.	 funksiya,	 shart	 operatori	 yoki	 tsikl	 ni	 ishini	 
yakunlash	
 uchun	 ishlatiladi. Mi so l :   0 da n	 10	 g ac ha	 t s i k l	 h os i l	 qi l i n g.	 S an as h	 j ar ay on i d a	 4 - 
t a kr o r l a ni sh da	
 s i k l n i	 ya ku nl an g
# include   <iostream>
using   namespace  	
std;
int   main ()	
 {
    for  	
( int  	i =  0 ;	 i <  10 ;	 i++)	 {
        if  	
(i ==	  4 )	 {
            break ;
     	
 }
        cout	
 <<	 i <<	  "\n" ;
 	
 } 
    return   0 ;
}
Natija: GOTO
Odatta shartsiz	 o’tish	 operatorini	 programmangizda	 ishlatmasligimizni	 ko’p
programmistlar	
 maslahat	 berishadi.	 Bu	 gap	 albatta	 to’g’ri.	 Chunki	 bu	 shartsiz
o’tish	
 operatori	 programmangiz	 strukturasini	 buzishi	 mumkin.	 Bu	 programmani
ishlatib	
 bo’lmaydigan	 joylar	 bor	 bunga	 misol:	 shartsiz	 o’tish	 operatori	 orqali	 qism
dasturga	
 o’tib	 bo’lmaydi,	 sikllarga	 o’tib	 bo’lmaydi	 va	 hokazo	 bularni	 o’z
tajribangiz	
 davomida	 o’rganib	 borasiz.
Shartsiz	
 o’tish	 operatorining	 umumiy	 ko’rinishi	 quyidagicha:
Goto   <metka>;
Goto   operatoridan	
 keyin	 boshqarilish	 <metka>	 ga	 uzatiladi	 va	 programmaning	 
bajarilishi	
 shu	 yerdan	 davom	 etadi.
Metkani	
 nishon	 ham	 deb	 aytiladi	 bu	 davomida	 ‘:’	 qo’yilgan	 identifikator.
Misol	
 uchun:	 metka:	 ;
Metka	
 har	 qanday	 operator	 oldidan	 ishlatilishi	 mumkin,	 shuningdek	 shart	 operatori
oldidan	
 ham. Misol:
N natural	 sonini	 kiritishni	 taklif	 qiluvchi	 programma	 tuzilsin.	 Agar	 natural
bo’lmagan	
 son	 kiritilsa,	 qayta	 kiritish	 taklif	 qilinsin.
#include	
 <iostream>
#include
 <math.h>
using	
 namespace	 std;
int	
 main(){
float
 n;
nishon:
cout
 <<	 "natural	 son	 kiriting"<<	 endl;
cin	
 >>	 n;
if	
 (( ceil(n)	 !=n)	 ||
(n	
 <=	 0))
goto
 nishon;
cout
 <<	 "natural	 son"	 <<	 endl;
return	
 0;
}
C++   continue continue   - yakka	 holatda	 kelib	 ushbu	 kalit	 so'zi	 kelganda	 undan	 keyin	 kelgan	 
kodni	
 o'tkazib	 yuboradi.	 tsikl	 da	 kelgan	 vaqtida	 undan	 keyin	 kelgan	 kodni	 o'tkazib	 
yuborib	
 tsiklni	 takrorlashni	 davom	 etadi.
Mi so l :   0	
 da n	 10	 g ac ha	 t a kr or l as h	 a m a l g a	 o sh i r i b	 s hu nd a	 4 s on i n i	 
ch i q ar m a ng .
# include   <iostream>
using   namespace  	
std;
int   main ()	
 {
    for  	
( int  	i =  0 ;	 i <=	  10 ;	 i++)	 {
        if  	
(i ==	  4 )	 {
            continue ;
     	
 }
        cout	
 <<	 i <<	  "\n" ;
 	
 }     
    return   0 ;
}
Continue   –	
 funksiyasini	 har	 qanday	 sikl	 operatoriga	 qo’llash	 mumkin.	 Bu	 
funksiya	
 parametrni	 keyingi	 qiymatni	 qabul	 qilishini	 taminlaydi.	 Boshqacha	 so’z	 
bilan	
 aytganda	 sikl	 tanasi	 tugatiladi.	  Bunda	 siklning	 o’zi	 tugatilmaydi Natija:
0
1
2
3
5
6
7
8
9
10
break   va	 comtinue	                                                                               ikkalasini	 
vaziyatga	
 qarab	 bir	 
yoki	
 bir	 necha	 marta	 ishlatishingiz	 mumkin.
Ba’zan	
 takrorlanuvchi	 algoritmlar	 bir	 nechta	 parametrga	 bog‘liq	 bo‘ladi.	 Odatda	 
bunday	
 algoritmlar	 ichma-ich	 joylashgan	 jarayonlar	 deb	 ataladi.	 
1-misol.	
 Munosabatni	 hisoblang:	 ∑i=1
n	
∏j=1
n	
(i+j)2             Yig‘indi	 hisoblash	 uchun,	 i indeksning	 har	 bir	 qiymatida	 j indeks	 bo‘yicha	 
ko‘paytmani	
 hisoblab,	 avval	 yig‘indi	 ustiga	 ketma-ket	 qo‘shib	 borish	 kerak	 
bo‘ladi.	
 Bu	 jarayon	 quyidagi	 ichma-ich	 joylashgan	 jarayonga	 doir	 blok–sxemada	 
aks	
 ettirilgan	 
.	
 Bu	 yerda	 indeks	 i dan	 tashqi	 takrorlash	 yig‘indi	 uchun,	 j-dan	 esa-ichki	 takrorlash	 
-	
 ko‘paytmani	 hosil	 qilish	 uchun	 foydalanilgan.	  Ichma-ich	 joylashgan	 algoritmga	 
doir	
 blok-sxema	 .
Shu	
 bilan	 birga,	 keltirilgan	 murakkab	 munosabatni	 ikki	 nisbatan	 sodda	 
munosabatlar	
 ketma-ketligi	 bilan	 almashtirish	 (dekompozitsiya	 amali)	 maqsadga	 
muvofiq:	
 
1)	
p❑
i=∏j=1
n	
(i+j)2,i=1,2,3	,…	.,n ;
2)	
   S =∑1
n	
p❑
i ;  2-misol.
 
B = b[i]	 (i=1,2,…,n)	 
massiv	
 elementlarini	 o‘sish	 (kamayish)	  tartibida	 joylashtirish	 algoritmi	 va	 
dasturini	
 yaratish	 uchun	 yuqorida	 keltirilgan	 massiv	 elementlarining	 minimal	 
(maksimal)	
 qiymatli	 elementi	 va	 uning	 indeksini	 aniqlash	 algoritmidan	 
foydalaniladi	
 va	 quyidagi	 amallar	 ketma-ketligi	 bajariladi	 (bunda	 algoritmning	 
so‘zlar	
 orqali	 ifodalangan	 usulidan	 foydalaniladi)	 [2,	 16-18	 b.]:
 	
1)	 kiritish	 (bi	 , n);	 
2)	
 i=1;
 	
3)	 massivning	 i chidan	 to	 n chi	 elementlari	 orasidagi	 eng	 kichik	 (katta)	 element	 - z
va	
 uning	 indeksi	 - k aniqlanadi;	 
4)	
 “uch	 likobcha”	 usuli	 asosida	 i-chi	 va	 minimal	 (maksimal)	 qiymatli	 elementlar	 
joyma-joy	
 almashtiriladi:	 c=b[i];	 b[i]=	 z;	 b[k]=c,	 bunda	 c - yordamchi	 o‘zgaruvchi;
 	
5)	 i=i+1;	 
6)	
 agar	 i (2).	 Yuqoridagi	 algoritmning	 amallar	 ketma-ketligini	 to‘laligicha	 
keltiramiz:	
 
 	
      1)	 kiritish	 (n,	 bi	 ) 
 	
      2)	 i =1;
 	
     3)	 z = b i ;
 	
     4)	 k = i;
 	
     5)	 j = i +1;
 	
     6)	 agar	 ( z < bj	 ) shart	 bajarilsa,	 u holda	 {z=	 bj;	 k=j;}
 	
     7)	 j = j + 1;
 	
     8)	 agar	 ( j <=	 n ) shart	 bajarilsa,	 u holda	 =>	 (6)	 
 	
     9)	 c = bi;	 
 	
     10)	 bi	 = z;	 
 	
     11)	 bk	 =c;
 	
     12)	 i = i+1;
 	
     13)	 agar	 ( j <=	 n-1	 ) shart	 bajarilsa,	 u holda	 =>	 (3)	        14)	 muhrlash	 (bi	 ).
 	
 Natijada,	 B = {bi}–	 massiv	 elementlari	 o‘sish	      
 	
( kamayish)	    tartibida	 qayta	 joylashtiriladi.	 
3-misol.	
 A={aij}	 matritsaning	 satr	 elementlari	 ko‘paytmalarining	 yig‘indisini	 
hisoblash	
 algoritmi	 tuzish	 talab	 etilsin.	 Bu	 masalaning	 matematik	 modeli	 
quyidagicha	
 ko‘rinishga	 ega:	 
S=
∑
i = 1n
∏
j = 1m
aij
.	
 Xususiy	 holda,	 agar	 n=3	 va	 m=4	 bo‘lsa,	 u holda	 {aij}	 matritsaning	 ko‘rinishi	 
quyidagicha	
 bo‘ladi:	  A=( ¿ ¿ ¿ ¿
)
Demak,	
 masalaning	 echimi	 S=	 (a11*a12*a13*a14)+(a21*a22*a23*a24)+	 
(a31*a32*a33*a34)	
 bo‘ladi.	 Tashqi	 (satrlar)	 bo‘yicha	 takrorlash	 jarayonini	 – i 
indeks	
 bilan,	 (i=1,2,3),	 ichki	 (ustunlar)	 bo‘yicha	 j - indeks	 bilan	 (j=1,2,3,4)	 
belgilanadi.
 	
Tashqi	 indeks	 i bo‘yicha	 yig‘indi	 bajariladi,	 demak,	 uning	 boshlang‘ich	 qiymati	 
S=0	
 deb	 olinadi.	 Tashqi	 indeksning	 har	 bir	 qiymatida	 ichki	 indeksning	 barcha	 
qiymatlari	
 bajariladi.	 Endi,	 ichki	 takrorlash	 jarayonida	 satr	 elementlarining	 
ko‘paytmasi	
 bajarilishi	 kerak	 bo‘ladi.	 Ko‘paytmaning	 boshlang‘ich	 qiymati	 uchun	 
yordamchi	
 R=1	 o‘zgaruvchi	 ishlatiladi,	 va	 joriy	 amal	 P = P * aij	 ifoda	 yordamida	 
satr	
 elementlarining	 ko‘paytmasi	 hisoblanadi.	 Tashqi	 takrorlash	 jarayonining	 joriy	 
amali	
 S=S+R	 dan	 iborat.	 Shunday	 qilib,	 masalani	 yechish	 algoritmini	 so‘zlar	 orqali
ifodalangan	
 usulidan	 foydalanilsa,	 quyidagi	 ko‘rinishga	 ega:
 	
1)	 kiritish	 (n,	 m,	 a i j);
 	
2)	 S = 0;
 	
3)	 i = 1;
 	
4)	 P = 1;
 	
5)	 j =1;  6)	 P = P * a i j ; 
7)	
 j = j + 1;	 
8)	
 agar	 ( j <=	 m)	 bo‘lsa,	 u holda	 =>	 (5);
 	
9)	 S = S + P;	 
10)	
 i = i + 1;	 
11)	
 agar	 ( i <=	 n)	 bo‘lsa,	 u holda	 =>	 (4);
 	
12)	 muhrlash	 (S).
 	
Yuqoridagi	 keltirilgan	 munosabat	 ancha	 murakkab	 ma’noga	 va	 ko‘rinishga	 ega.	 
Shu	
 sababli	 masalani	 yechish	 uchun	 dekompozitsiya	 usulidan	 foydalanib,	 berilgan	 
murakkab	
 masalani	 ikki	 sodda	 masala	 ketmaketligi	 ko‘rinishda	 tasvirlash	 mumkin.
Bunda,	
 avval	 mos	 satr	 elementlarning	 yig‘indisi	 {ij}	 oraliq	 massivga	 jamlanib,	 
so‘ngra	
 uning	 elementlari	 yig‘indisi	 S da	 hisoblanadi.
Barcha	
 dasturlash	 tillarida	 ichma-ich	 joylashgan	 sikl	 buyruqlaridan	 foydalanish	 
imkoniyati	
 yechilishi	 mumkin	 bo’lgan	 masalalar	 ko’lamini	 sezilarli	 darajada	 
kengaytiradi.	
 for	 operatori	 yordamida	 tashkil	 qilinadigan	 ichma-ich	 joylashgan	 sikl
buyruqlarining	
 umumiy	 ko’rinishi	 quyidagicha:	 for	 (i = imin;	 i < = imax;	 i = i + i 
qad)	
 for	 (j = jmin;	 j < = jmax;	 j = j + j qad)	 for	 (k	 = kmin;	 k < = kmax;	 k = k + k 
qad)	
 buyruqlar;	 Uchta	 ichma-ich	 joylashgan	 holni	 tanladik.	 Aslida	 ularning	 soniga	 
chegara	
 qo’yilmagan.	 Buyruqning	 bajarilish	 tartibi	 quyidagicha:	 Tashqi	 sikl	 
parametri	
 o’zining	 boshlang’ich	 imin	 qiymatini	 qabul	 qiladi	 va	 oxirgi	 imax	 qiymati
bilan	
 solishtiradi.	 Agar	 i<=imax	 mantiqiy	 ifodaning	 qiymati	 chin	 bo’lsa,	 o’rta	 sikl	 
parametri	
 o’zining	 boshlang’ich	 jmin	 qiymatini	 oladi	 va	 oxirgijmax	 qiymati	 bilan	 
solishtiradi.	
 Agar	 j<=jmax	 mantiqiy	 ifodaning	 qiymati	 chin	 bo’lsa,	 ichki	 sikl	 
parametri	
 o’zining	 boshlang’ichkmin	 qiymatini	 oladi	 va	 oxirgikmax	 qiymati	 bilan	 
solishtiradi.	
 Agar	 k<=kmax	 mantiqiy	 ifodaning	 qiymati	 rost	 bo’lsa,	 buyruqlar	 bir	 
marta	
 bajarilib,	 ichki	 sikl	 parametri	 bir	 qadamga	 ortadi	 (k=k+kqad)	 va	 yana	 
k<=kmax	
 mantiqiy	 iofodaning	 qiymati	 tekshiriladi.	 Agar	 u rost	 bo’lsa,	 buyruq	 
yana	
 bir	 marta	 bajariladi	 va	 hokazo	 bu	 jarayon	 k>kmax	 bo’lguncha	 davom	 etadi.	 
So’ngra	
 o’rta	 sikl	 parametri	 bir	 qadamga	 ortadi(j=j+jqad)	 va	 j<=jmax	 shart	 
tekshiriladi.	
 Agar	 u rost	 bo’lsa,	 ichki	 sikldagi	 takrorlanishlar	 o’rta	 sikl	  parametrining yangi	 qiymati	 uchun	 to’liq	 qaytadan	 amalga	 oshiriladi	 va	 hokazo	 bu	 
jarayon	
 j>jmax	 bo’lguncha	 davom	 etadi.	 Shundan	 so’ng	 tashqi	 sikl	 parametri	 bir	 
qadamga	
 ortadi	 (i=i+iqad)	 va	 i<=imax	 mantiqiy	 ifodaning	 qiymati	 tekshiriladi.	 
Agar	
 u rost	 bo’lsa,	 tashqi	 sikl	 parametrining	 yangi	 qiymati	 uchun	 o’rta	 va	 ichki	 
sikllardagi	
 takrorlanishlar	 to’liq	 qaytadan	 amalga	 oshiriladi	 va	 hokazo	 bu	 jarayon	 
i>imax	
 bo‘lguncha	 davom	 etadi.	 Demak,	 ichma-ich	 joylashgan	 uchta	 siklning	 
bajarilish	
 tartibi	 soatning	 sekund,	 minut	 va	 soat	 millari	 harakatiga	 juda	 o’xshaydi.	 
Haqiqatdan,	
 minut	 mili	 1 minutga	 siljiguncha	 sekund	 mili	 60	 ta	 harakat	 sodir	 
qiladi,	
 soat	 mili	 bir	 soatga	 siljishi	 uchun	 esa	 minut	 mili	 60	 minutga	 siljiydi.	 Ya‘ni	 
tashqi	
 sikl	 parametri	 soat	 miliga,	 o’rta	 sikl	 parametri	 minut	 miliga,	 ichki	 sikl	 
parametri	
 esa	 sekund	 miliga	 mos	 keladi.	 Demak,	 tashqi	 siklda	 5 marta,	 o’rta	 siklda	 
8	
 marta,	 ichki	 siklda	 9 marta	 takrorlanishi	 sodir	 bo‗lsa,	 buyruqlar	 jami	 5 * 8 * 9 = 
360	
 marta	 bajariladi.	 118	 Ichma-ich	 joylashgan	 sikllarning	 umumiy	 ko’rinishida	 
blok	
 belgilari	 ({	 })	 yo’q.	 Agar	 bir	 for	 operatori	 bilan	 ikkinchisi	 oralig’ida	 kamida	 
bitta	
 buyruq	 bo’lsa	 ham	 blok	 belgisi	 ichiga	 olinadi. Foydalanilgan Adabiyotlar:
ALGORITMLASH VA	 DASTURLASH	 ASOSLARI.	   Eshtemirov	 Sodiq	 
Samarqand	
 Davlat	 Universiteti	 ―Axborotlashtirish	 texnologiyalari	 ―	 kafedrasi	 
dotsenti.Nazarov	
 Fayzullo	 Maxmadiyarovich	 Samarqand	 Davlat	 Universiteti	 
―Axborotlashtirish	
 texnologiyalari	 ―	 kafedrasi	 o’qituvchisi.

Mavzu:Dasturlash tilida ichma-ich sikllarni ishlatish Reja: 1. C++ dasturlash tilida sikllarni ishlatish; 2. Break va continue (goto) operatorlarini ishlatish; 3. Sikllarni ichma-ich qo’llash.

Tayanch iboralar:   do-while takrorlash operatori, break operatori, continue operatori, goto operatori, nishonlar. Bilamizki masalani  yechish  davomida  bazi  bir  masalani  javobini  topish  uchun  bir   necha  bor  takrorlanadi.  Buni  hal  qilish  uchun  albatta   bizga   takrorlash ya’ni   sikl operatorlari  kerak  bo’ladi. Takrorlash  operatorlari  quyidagilar:  For  Do  .. While  While Siz  yechayotgan  masalangizni  berilishiga  qarab  shulardan  birini  tanlaysiz. For  takrorlash  operatori  quyidagicha. For     (<ifoda1>;  <ifoda2>;  <ifoda3>) <operator  yoki  blok>; Bu  operator  amal  qilishni  <ifoda1>  bajarishdan  boshlaydi.  Keyin  takrorlash   qadamlari  boshlanadi.  Har  bir  qadamda  <ifoda2>  bajariladi,  agar  natija  0 dan  farqli yoki  rost  (true)  bo’lsa,  sikl  tanasi  – <operator  yoki  blok>  bajariladi  va  oxirida   <ifoda3>  bajariladi,  aks  holda  boshqaruv  takrorlash  operatoridan  keyingi   operatorga  o’tiladi.  Sikl  tanasi  – <operator  yoki  blok>  sifatida  bitta  operator,  shu   jumladan  bo’sh  operator,  yoki  operatorlar  bloki  kelishi  mumkin. Sikl  takrorlanishi  davomida  bajarilishi  lozim  bo’lgan  operatorlar  majmuasi  sikl   tanasi  deyiladi.  Sikl  tanasi  sifatida  bir  yoki  bir  nechta  operatordan  foydalanish   mumkin.  Agar  sikl  tanasida  bir  nechta  operatordan  foydalanmoqchi  bo’lsak  bu   operatorlarni  blok   {} orasiga  olishimiz  kerak. 1  dan  10  (sikl  yordamida)  gacha  bo’lgan  sonlarni  chiqaruvchi  dastur:

 # include <iostream> using  namespace  std ; int  main () { for   ( int  i   =  1;   i   <=  10;   i ++) cout     <<     i     <<     “   ” ; cout     <<     endl ; return   0; }  E ekranda  quyidagicha  natija  hosil  bo’ladi. T ak r or l a sh  qa da m i ni  a m a l g a  o sh i r i s h  u ch un   wh i l e ka l i t  so 'z i d an   f oy da l a na m i z.   sh ar t or q al i  t s ki l  h os i l  b o' l a di .  q uy i d ag i  si nt ak si sn i   o' zi ng i z ga  f or m ul a  s i f at i d a  yo dl ab  q uy i n g. while(<shart>){ //sikl  tanasi }

Mi so l :   wh i l e   da n f o yd al an i b  0 d an  7 g ac ha  so nl ar ni  e kr an ga  ch i q ar i sh   da st ur i n i  t u zi sh . Da st ur : # include   <iostream> using   namespace   std; int   main ()  {     int   i =  0 ;     while   (i <=   7 )  {         cout  <<  i <<   "\n" ;         i++;    }     return   0 ; } Natija

Do/While Tsikl do / wh i l e   va   wh i l e   i k ki si ha m  si kl  h i s ob l a na di .  bi r i nc hi si ni   i k ki nc hi si da n  f ar q l i  j i ha t i  s hu nd ak i  b i r i n   do / wh i l e   av va l  s ha r t ni  b aj ar i b   ke yi n  t e ks hi r a di .   wh i l e   es a  av va l  sh ar t  b aj ar i l a di  a ga r  t o 'g 'r i  bo 'l sa  t s i k l   t a na si da gi  k od  i sh l a t i l a di .  qu yi da gi   do / wh i l e   si nt ak si si ni  yo dd a   sa ql as hi ng i z  zar ur  b o' l a di . do   {     //  tsikl  tanasi } while   (<Shart>) ; Yu qor i d ag i  Mi so l d ag i  sh ar t g a  m uaf i q  s hu ni  bi z   do / wh i l e   da  i sh l a b   ko 'r am i z . # include   <iostream> using   namespace   std; int   main ()   {     int   i =  0 ;     do   {         cout  <<  i <<   "\n" ;         i++;    }     while   (i <=   7 );     return   0 ;