Takrorlanuvchi jarayonlarni dasturlash

Dokument ma'lumotlari

Narxi	2000UZS
Hajmi	71.2KB
Xaridlar	0
Yuklab olingan sana	07 Noyabr 2026
Kengaytma	docx
Bo'lim	Referatlar
Fan	Informatika va AT

Takrorlanuvchi jarayonlarni dasturlash

Sotib olish

Sikl (takrorlanish) - bu ko'rsatmalar to'plamining takroriy bajarilishini
tashkil qilish uchun mo'ljallangan yuqori darajadagi dasturlash tillaridagi
boshqaruv strukturasining bir turi. Shuningdek, siklni bir necha bor
bajarilgan, har qanday usulda tashkil qilingan (masalan, shartli o’tish
yordamida) har qanday ketma-ketlik deb atash mumkin.
Qayta bajarilishi uchun mo'ljallangan ko'rsatmalar ketma-ketligi sikl
tanasi deb ataladi. Sikl tanasining bitta bajarilishi takrorlash deyiladi.
Takrorlashning yana bajarilishini yoki siklning tugashini aniqlaydigan ifoda
chiqish sharti yoki siklni tugatish sharti (yoki davomiylik sharti, uning
haqiqiyligi qanday talqin qilinishiga qarab - siklni to'xtatish yoki davom
ettirish zarurati belgisi sifatida) deb nomlanadi. Joriy takrorlash raqamini
saqlaydigan o'zgaruvchiga sikl takrorlash hisoblagichi yoki oddiygina sikl
hisoblagichi deyiladi. Siklda hisoblagich bo'lishi shart emas, hisoblagich
bitta bo'lishi shart emas - sikldan chiqish sharti sikldagi o'zgargan bir nechta
o'zgaruvchiga bog'liq bo'lishi mumkin yoki uni tashqi sharoitlar bilan
aniqlash mumkin (masalan, ma'lum bir vaqt boshlanishi), ikkinchi holda
hisoblagich umuman kerak bo'lmasligi mumkin.
Har qanday siklning bajarilishi sikl o'zgaruvchilarining dastlabki
initsializatsiyasini, chiqish holatini tekshirishni, sikl tanasini bajarilishini va
har bir takrorlashda sikl o'zgaruvchisini yangilashni o'z ichiga oladi. Bundan
tashqari, aksariyat dasturlash tillarida siklni erta boshqarish uchun vositalar
mavjud, masalan, siklni tugatish bayonotlari, ya'ni chiqish sharti (C++ da
break ) va iteratsiyani o'tkazib yuborish bayonotlari (C da continue )
haqiqatidan qat'i nazar sikldan chiqishga imkon beradi.
Kompyuterlar ma'lumotlarni saqlashdan tashqari ko'proq narsani amalga
oshirishi mumkin. Ular ma'lumotlarni tahlil qiladi, birlashtiradi, buyurtma
qiladi, ajratadi, o'zgartiradi, ekstrapolyatsiya qiladi, sintez qiladi va boshqa
manipulyatsiyalarni amalga oshiradi. Ba'zan ular ma'lumotlarni buzadi va

$yo'q qiladi, ammo biz ularning xatti-harakatlarini boshqarishga harakat qilamiz. Ushbu mo''jizalarni bajarish uchun dasturlarda takrorlanadigan amallarni bajarish va qaror qabul qilish vositalari zarur. Albatta, C++ bunday vositalarni taqdim etadi. Darhaqiqat, u C da for, while, do while va if so'zlarini ishlatiladi. Ushbu har xil boshqaruv bayonotlari dasturning to'g'ri ishlashini ta'minlash uchun ko'pincha taqqoslash iboralari va mantiqiy ifodalardan foydalanadi. Ushbu mavzuda sikllar qanday tashkil qilinishini ko'rib chiqamiz. Parametr bo’yicha takrorlash operatori. for sikli Vaziyat ko'pincha dasturlardan takroriy vazifalarni bajarishni talab qiladi, masalan, qator elementlarini birma-bir qo'shish yoki 20 martalik maqtovni chop etish. For sikli bu kabi vazifalarni bajarishni osonlashtiradi. Quyidagi dasturdagi siklni ko'rib chiqamiz, va keyin qanday ishlashini ko'rib chiqamiz. #include <iostream> int main() { using namespace std; int i; //hisoblagich yaratish for (i = 0; i < 5; i++ ) cout << "Bu matn takrorlanadi \n"; cout << "Takrorlanish to’xtaydi.\n"; return 0; }$ $Ushbu takrorlanish i o'zgaruvchisiga 0 berish bilan boshlanadi: i = 0; Bu siklni boshlashning bir qismidir. So'ngra, siklni tekshirish qismida dastur i 5 dan kamligini tekshiradi: i <5; Agar shunday bo'lsa, dastur quyidagi buyruqni bajaradi, u sikl tanasi deb nomlanadi: cout << "Bu matn takrorlanadi\ n"; Shundan so'ng, dastur siklning yangilanish qismini faollashtiradi va uni 1 ga oshiradi: i++ Siklning yangilanish qismida ++ amalidan foydalaniladi, bu o'sish jarayoni deyiladi. U o'z operandining qiymatini 1 ga oshiradi. Keyin sikl yangi o'tishni boshlaydi, i ning yangi qiymatini 5 bilan taqqoslaydi. Yangi qiymat (1) ham 5 dan kam bo'lganligi sababli, sikl yana bir qatorni bosib chiqaradi va yana i ni oshirish bilan tugaydi. Bu yangi sikldan o'tishni tayyorlaydi - tekshiruv, bayonotni bajarish va i qiymatini yangilash. Jarayon, 5 qiymatini olguncha davom etadi. Shundan so'ng, keyingi tekshiruv yolg’on natijani beradi va dastur sikldan keyingi bayonotga o'tadi. for siklining qismlari. for sikli - takrorlanadigan harakatlar orqali o'tish vositasi. Uning qanday ishlashini batafsil ko'rib chiqamiz. Odatda for siklining qismlari quyidagi amallarni bajaradi. 1. Dastlabki qiymatni belgilash. 2. Siklni davom ettirish shartini tekshirish. 3. Sikl harakatlarini bajarish. 4. Sinov sharoitida ishlatilgan qiymatlarni baholash.$

C++ siklining tuzilishida ushbu elementlar shunday joylashtirilganki,
ular bir qarashda olinishi mumkin. Initsializatsiya, tasdiqlash va yangilash -
bu qavs ichiga kiritilgan boshqaruv qismining uch qismi. Har bir qism boshqa
qismlardan vergul bilan ajratilgan ifoda. Boshqaruv qismidan keyingi
bayonot siklning tanasi deb nomlanadi va u sinov sharti rost bo'lgan taqdirda
bajariladi:
for (initsializatsiya; tekshiriluvchi ifoda; ifodani yangilash)
tana
C ++ sintaksisida to'liq for operatori bitta bayonot deb hisoblanadi,
garchi u o'z tanasida bir yoki bir nechta boshqa bayonotlarni qabul qilsa ham.
(Agar siklning tanasida bir nechta bayonotlar mavjud bo'lsa, ular quyida
tasvirlanganidek, blokga joylashtirilishi kerak.)
Sikl faqat bir marta initsializatsiyani amalga oshiradi. Odatda, dasturlar
ushbu ifoda yordamida o'zgaruvchini ba'zi bir boshlang'ich qiymatni o'rnatadi
va keyin bu o'zgaruvchini sikl hisoblagichi sifatida ishlatadi.
Tekshiriluvchi ifoda siklning tanasi bajarilishi kerakligini aniqlaydi.
Odatda bu ifoda taqqoslash ifodasidir, ya'ni ikkita qiymatni taqqoslaydigan
ifoda. Bizning misolimizda i va 5 qiymatlari taqqoslanadi, agar tekshiruv
muvaffaqiyatli bo'lsa (test ifodasi rost bo'lsa), dastur sikl tanasini bajaradi.
Aslida, C++ da tekshiruv ifodalari faqat rost yoki yolg’on natijalarni
taqqoslash bilan chegaralanmaydi. Bu yerda har qanday ifodadan foydalanish
mumkin va C++ uni bool tipiga o'tkazadi. Shunday qilib, 0 ni qaytaradigan
ifoda mantiqiy yolg'onga aylantiriladi va sikl tugaydi. Agar ifoda nolga teng
bo'lsa, u mantiqiy qiymatga to'g'ri keladi va sikl davom etadi. Ifodani
yangilash sikl oxirida, sikl tanasi bajarilgandan so'ng baholanadi. Odatda
sikldagi qadamlar sonini boshqaruvchi o'zgaruvchining qiymatini oshirish

Operator1
Ifodani
initsializatsiyalash
Tekshiriluvchi
ifoda
Operator3 Operator2 Ifodani yangilash
true
false For sikliyoki kamaytirish uchun ishlatiladi. Biroq, bu boshqa barcha boshqaruv
ifodalari kabi har qanday amaldagi C++ ifodasi bo'lishi mumkin. Bu for
sikliga birinchi misolda bo'lgani kabi, 0 dan 5 gacha hisoblashdan ko'ra
ko'proq moslashuvchanlikni beradi. 1-rasmda for siklining blok
diagrammasini ko'rsatadi.
Operator1
for (ifodani initsializatsiyalash;
tekshiriluvchi ifoda;
ifodani yangilash;)
operator2
operator3

1-rasm. for siklining blok-sxemasi
Sikl qadamini o'zgartirish. Hozirgacha sikl misollarida sikl
hisoblagichi har qadamda bittadan ko'paytirildi yoki kamaytirildi. Buni
yangilash ifodasini o'zgartirish orqali o'zgartirish mumkin. Masalan, quyidagi
dastur sikl hisoblagichini foydalanuvchi kiritgan qadam miqdoriga
ko'paytiradi. Yangilash ifodasi sifatida i++ dan foydalanish o'rniga u i = i +
by ifodasini ishlatadi, bu erda foydalanuvchi tanlagan sikl bosqichi bo’ladi.
#include <iostream>
using namespace std;
int main()
{
cout << "Butun son kiriting: ";
int by;
cin >> by;
cout << "O’sish qadami " << by;
for (int i = 0; i < 100; i = i + by)
cout << i << endl;
return 0;
}
Sikldan chiqish operatori. Break operatori Switch bayonoti va for
sikli haqidagi misollarda allaqachon break operatoriga duch keldingiz.
Uning qanday ishlashi haqida allaqachon tasavvurga ega bo’lgan bo’lishingiz
mumkin. Ushbu operatorni batafsilroq ko’rib chiqamiz.

Ko'pincha sikldan foydalanganda va deyarli har doim switch
operatoridan foydalanganda dasturchi mos ravishda sikl tanasi yoki switch
tanasining bajarilishini to'xtatishi kerak. Bunday hollarda break ishlatiladi.
Shuningdek, ushbu operator yordamida cheksiz sikl uzilib qoladi. Uni
to'xtatish kerak bo'lganda, sikl tanasiga shart qo'shiladi, bajarilgandan so'ng,
break operatori ishga tushiriladi va sikl tugaydi.
Quyidagi misolda oddiy o'yin amalga oshiriladi: bitta o'yinchi 1 dan 7
gacha bo'lgan raqamni taxmin qiladi, ikkinchisi uni topishi kerak.
#include <iostream>
using namespace std;
int main()
{
int digit = 0;
int answer = 0;
cout << "Raqibingiz taxmin qilishi uchun 1 dan 7 gacha raqamni
kiriting:";
for (;;)
{
cin >> digit; // yashirin raqamni kiritish
if (digit >= 1 && digit <= 7) // raqamni belgilangan diapazonga
muvofiqligini tekshirish
{
break; // agar u mos keladigan bo'lsa, sikldan chiqish
}
else // aks holda raqamni qayta kiritishni so'rash

${ cout << "Noto'g'ri oraliq! 1 dan 7 gacha raqam kiriting:"; } } system("cls"); // bu funksiya ekranni tozalaydi va raqib qaysi raqam kiritilganligini ko'rmaydi cout << "Raqibingiz o'ylagan raqamni taxmin qilishga harakat qiling!\ n"; cout << "Bu 1 dan 7 gacha bo'lgan butun son. Javobingizni kiriting:"; for (int myTry = 1;; myTry++) { cin >> answer; if (answer < 1 || answer > 7) { myTry--; // urinishlar sonini bittaga kamaytiring cout << "!!!1 dan 7 gacha oraliqdagi son kiriting:"; } else if (digit == answer) // agar son mos kelsa { cout << "Tabrik! Siz " << myTry << "-urinishda sonni topdingiz!\n\n"; break; // sikldan chiqish } else // aks holda yana bir bor urinish {$

cout << "Siz topa olmadingiz! Yana bir bor urinib ko
`ring:";
}
}
return 0;
}
Barchasini aniq saqlash uchun va taxmin qiladigan o'yinchi yaroqsiz
diapazondan raqamni kirita olmasligi uchun, raqam kiritilib tekshiriladigan
cheksiz sikldan ishlaymiz. Agar raqam kerakli diapazonga to'g'ri keladigan
bo'lsa, sikl to'xtatiladi (15 - 18 qatorlar), agar bo'lmasa, ekranda ogohlantirish
paydo bo'ladi va raqamni qayta kiritishingizni talab qiladi. Bu kiritilgan
raqam kerakli oraliqda bo'lguncha davom etadi.
To'g'ri raqamni kiritgandan so'ng, 25-qatorda maxsus funksiya tizimini
chaqiramiz ("cls") , bu ikkinchi o'yinchi raqamni taxmin qilishni
boshlashidan oldin ekranning tarkibini tozalaydi (faqat konsolda ishlaydi).
Keyin ikkinchi cheksiz siklni aniqlaymiz (29 - 47 qatorlar), lekin bu
safar myTry hisoblagichi bilan. Bu o'yinchi raqamni taxmin qilishga
urinishlar sonini hisoblab chiqadi. O’yinchi raqamni kiritadi va darhol 33 - 37
qatorlar oralig'ida tekshiriladi.
Agar u mos kelmasa, dastur ogohlantiradi va myTry urinish
hisoblagichidan birini chiqaramiz. Aks holda, agar raqam kerakli diapazonda
bo'lsa, biz uning yashirin raqamga (38 - 42 satrlar) to'g'ri kelishini
tekshiramiz: ha - tabriklaymiz va siklni to'xtatamiz, yo'q - 43 - 46 satrlarga
o'ting - xato haqida xabar beramiz va raqamni qayta kiritishni taklif qilamiz.
Continue operatori. Ushbu operator joriy siklning takrorlanishini
to'xtatish (o'tkazib yuborish) va keyingi takrorlashga o'tish zarur bo'lganda
foydalaniladi. U for siklida bajarilganda, joriy takrorlash to'xtatiladi,

boshqaruv o'zgaruvchisini o'zgartirishga o'tish va undan keyin siklning
bajarilishini davom ettirish sharti tekshiriladi.
Quyidagi masalani hal qilaylik: 7 ga bo'linadigan va 1 dan 70 gacha
bo'lgan sonlarni ko'rsatish kerak.
#include <iostream>
using namespace std;
int main()
{
for (int i = 1; i <=70; i++)
{
if (i % 7 != 0) // agar sonni 7 ga bo'lganda qoldiq qolmasa
{
continue; // bu holda ushbu qadam tashlab o'tiladi
}
cout << i << endl;
}
return 0;
}
Agar i raqami qoldiqsiz 7 ga bo'linmasa (bo'linishning qolgan qismi 0
emas), davom etadi. Ya'ni, 12-qator satr endi bajarilmaydi va biz ekranda i
raqamini ko'rmaymiz. Agar i ni 7 ga bo'lishining qoldig’i 0 ga teng bo'lsa
(son 7 ga bo'linadigan bo'lsa), if tanasi bajarilmaydi va raqam ko'rsatiladi.
Ichma-ich sikllar. Oldingi mavzularda C ++ dasturlash tilidagi uchta
takroriy konstruksiyalar bilan tanishishga muvaffaq bo'ldik. Ular for while
hamda do while operatorlaridir. Endi ichma-ich yuz berishi mumkin bo’lgan

takrorlanishlarni ko'rib chiqamiz. Bu bitta siklning tanasiga (tashqi) boshqa
sikl (ichki) joylashgandagi holat hisoblanadi. Tashqi siklda bir nechta
shunday ichki joylashtirilgan sikllar bo'lishi mumkin.
Ichki siklga o'tish uchun dastur avval tashqi siklni bajarishni boshlashi
kerak, ichki sikldan oldin kodda yozilganlar bajariladi va keyin ushbu siklni
bajarishni boshlaydi.
Ichki siklning qanday ishlashini namoyish etish uchun bitta qiziqarli
umumiy misol mavjud. Masala quyidagicha qo’yilgan: sikldan foydalanib,
siz @ belgilaridan 5x15 to'rtburchak chizishingiz kerak.
#include <iostream>
using namespace std;
int main()
{
for (int i = 0; i < 5; i++) // ushbu sikl satrlar sonini sanaydi
{
for (int j = 0; j < 15; j++) // ushbu sikl ichki sikl bo'lib, har bir
satrda nechta belgi chiqishini aniqlaydi
{
cout << '@';
}
cout << endl; // yangi qatorga o'tadi
}
return 0;
}

Dastlab, for sikli 6-satrda bajarila boshlaydi, chunki uning tanasida
ikkinchi siklga qadar hech narsa yozilmaganligi sababli, dastur darhol shu
joylashtirilgan siklni - 8 - 11-satrlarni bajarishni boshlaydi. Uning bajarilishi
natijasida ekranda 15 ta @ belgini chop etadi va undan chiqadi. So’ngra 12-
satrda coutni ishga tushiriladi, i o'zgaruvchisi birga oshiriladi va asosiy
hamda ichki sikldan bajarishni davom ettiradi. Ekranda yana 15 ta belgi va
pastki qatorga o'tadi. Bu 5 marta amalga oshiriladi, shundan so'ng dastur
chiqadi. Ekranda quyidagi natija hosil bo’ladi.

Ushbu vazifani biroz murakkablashtiramiz. Endi foydalanuvchi
klaviaturadan kiritish usuli yordamida shaklni bosib chiqarish uchun belgini
tanlasin. U shuningdek o'lcham - kenglik va balandlikni tanlaydi. Yana bir
yangilik shundaki, shakl avvalgi misolimizda bo'lgani kabi to'ldirilgan emas,
bo'sh bo'lishi kerak. Ya'ni, u faqat konturdan iborat bo'lishi kerak. Dastur
kodi quyidagicha bo’ladi:
#include <iostream>
using namespace std;
int main()
{
int lines = 0;

int symbInLines = 0;
char symbol = 0;
cout << "Belgi kiriting: ";
cin >> symbol;
cout << "Satr miqdori: ";
cin >> lines;
cout << "Satrdagi simvollar miqdori: ";
cin >> symbInLines;
cout << endl;
for (int i = 1; i <= lines; i++)
{
if (i == 1 || i == lines) // birinchi va oxirgi satr
{
for (int j = 1; j <= symbInLines; j++)
{
cout << symbol; //
}
}
else //
{
cout << symbol; // bitta simvolni ko'rsatish
for (int j = 1; j <= symbInLines - 2; j++)
{
cout << ' '; // (symbInLines - 2) marta bo'sh probelni
chiqarish
}

cout << symbol; // yana bir simvolni ko'rsatish
}
cout << endl; // yangi satr
}
cout << endl;
return 0;
}
Yana bir misolni qarab chiqamiz. Ko’paytirish jadvalini chop etish.
#include <iostream>
using namespace std;
int main()
{
for (int f = 2; f <= 9; f++)
{
for (int s = 1; s <= 9; s++)
{
cout << f << " * " << s << " = " << f * s;
cout << endl;
}
cout << endl;
}
cout << endl;

return 0;
}
C++ tilida shartsiz o‘tish operatori va uning ishlash prinsipi
Nishon - bu davomida ikkita nu q ta (‘:’) qo’ y il g an identifikator .
Nishon bilan qandaydir operat o r belgilanadi va keyinchalik , progr a m maning
boshqa bir qismidan unga shartsiz o’ t ish ama l ga oshiriladi . Nishon
bilan har qand a y operator belgilanishi mumkin , shu jumladan e’ l on
operatori va bo’sh operatori ham . N i shon faqat funksiyalar ichida amal
qiladi .
Nishonga shartsiz o’tish goto operatori yordamida ba j ari l a d i . goto
operatori orqali faqat uning o’zi j oylashgan funksiya i chida g i operator l arga
o’tish mumkin. goto operatorini n g sin t aksisi quyidagicha :
g o to < nishon >;

$Ayr i m hollarda , goto operator i ning « sakrab o’ t ishi » his o biga xatoliklar yuzaga keli sh i mum k in . Masalan , int i =0; i++; if( i )go t o m; int j ; m:j + =i; operatorlarining bajar i lishi xatolik k a o l ib keladi , chunki j e’lon qilinmay qoladi . Shartsiz o’tish opera t ori programmani tuzishdagi kuchli va sh u bilan birgalikda xavfli vositalardan biri hisoblanadi . Kuchliligi shundaki , u ning yordam i da a lgor i t mning « boshi ber k » joy l aridan chiqib ketish mumkin . Ikkinchi tomondan , bloklarni n g ichiga o’tish , masalan , takrorlash o pera t orlarini ich i ga « sakra b » k ir i sh kuti l magan holatlarni yu za g a kelt i rishi m u m k in . Shu s abab l i , imkon qadar goto operat o ridan foyda l anmaslik kerak , ishlatilgan taqdirda ham quyidagi qoidaga amal qilish zarur : « blok ichiga , if…else va swi t c h operatorlari ichiga , h am d a takrorlash operat o rlari ta n asiga t ashqaridan kirish m umkin em a s ». Garchi , nishon yordam i da pr o gramman i ng ixtiyoriy joyiga o’tish mumkin bo’lsa ham , boshlang’ich qiymat berish e’lonlaridan sakrab o’tish m a n etiladi , lekin bloklardan sakrab o’tish mum k in . Masalan : ... goto B; \\ xato flo a t x= 0 .0; goto B; \\ to’ g’ ri { int n=1 0 ;x= n *x+ x ; } B: c o ut << “x = ”<< x ; ...$

Xususan , ni sh on yorda m ida ichki blokdan tashqi blo k ka va tashqi
blokdan ichki blok k a o’ti sh ga C++ t ili ruxsat beradi :
{
Goto ABC;
…
{
int i=15;
ABC:
…
Goto XYZ;
int y=10;
…
XYZ:
…
goto KLM:
…
}
Int k=0;
…
KLM:
…
}
Lekin , yuqor i da keltiri l gan misoldagi barcha o’tishlar mazmunan xato
hiso b lanadi .
Quyidagi programmada ikkita n a tural sonl a r eng katta u m umiy
b щ luvchini ( EKU B ) t o pish masalasida g i takrorlash jarayonini nishon
va goto operatori vositasida a m alga oshirish ko’rsatilgan :

$int main() { Int a, b; cout<< “A va B natural sonlarning EKUBini topish. \n”; cout<< “A va B natural sonlarni kiriting:” cin>>a>>b; nishon: if (a==b) { cout<< “Bu sonlar EKUBi”<<a; return 0; } a>b? a-=b: b-=a; goto nishon; } Programmadagi nishon bilan belgi l angan operatorda a va b sonlar n i ten g ligi tekshiriladi . A g ar u lar teng bo’lsa , ixtiyoriy bi t - tasi , m asalan a s oni EKUB bo’ladi va funksiyadan chiqiladi . Aks holda , bu son l arning kattasidan ki ch igi ayriladi va goto orqali ularn i ng tengligi tek sh iriladi . Takrorlash jarayoni a va b sonl a r o’zaro teng bo’lguncha davom e tadi . Shuni qayd etish kera k ki , bu masa l ani takrorlash operator l ari yordamida bajarish ancha samarali hisob l anadi .$

Takrorlanuvchi jarayonlarni dasturlash

Sotib olish

Dokument ma'lumotlari

Sotuvchi

Takrorlanuvchi jarayonlarni dasturlash

O'xshash dokumentlar