C++ dasturlash tilida ko‘rsatkichlar, funksiyalar va rekursiv funksiyalar asosida murakkab jarayonlarni dasturlash

Информация о документе

Цена	10000UZS
Размер	606.5KB
Покупки	0
Дата загрузки	06 Ноябрь 2026
Расширение	pdf
Раздел	Курсовые работы
Предмет	Информатика и ИТ

C++ dasturlash tilida ko‘rsatkichlar, funksiyalar va rekursiv funksiyalar asosida murakkab jarayonlarni dasturlash

Купить

O`ZBEKISTON RESPUBLIKASI OLIY VA O‘RTA MAXSUS
TA’LIM VAZIRLIGI SHAROB RASHIDOV NOMIDAGI SAMARQAND
DAVLAT UNIVERSITETI MATEMATIKA FAKULTETI
MATEMATIKA VA INFORMATIKA
YO’NALISHI 275 -A GURUH TALABASI
SUYUNOVA RUXSORA NING
DASTURLASH ASOSLARI VA TILLARI FANIDAN
YOZGAN
KURS ISHI
MAVZU : C++ DASTURLASH TILIDA KO’RSATKICHLAR,
FUNKSIYALAR VA REKURSIV FUNKSIYALAR ASOSIDA MURAKKAB
JARAYONLARNI DASTURLASH

Bajardi: Suyunova Ruxsora
Ilmiy rahbar: dots. F.M. Nazarov

SAMARQAND 2022

2

Mundarija
Kirish ................................ ................................ ................................ ................................ ................. 3
I-BOB. C++ DASTURLASH TILIDA KO‘RSATKICHLAR, ADRES OLUVCHI
O‘ZGARU VCHILAR ................................ ................................ ................................ ....................... 5
1.1. Ko’rsatkich tush unchasi va uni to`g`ri qo`llash ................................ ................................ .............. 5
1.2.Adreslarni saqlash uchun ko'rsatkichlardan foydalani sh ................................ ................................ . 7
1.3. Funksiyaga ko’rsatkichlarni uzatish ................................ ................................ ............................ 15
II-BOB. C++ DASTURLASH TILIDADA FUNKSIYALAR BILAN ISHLASH. FUNKS IYA
PARAMETRLARI VA ARGUMENTLARI. KELISHUV BO’YICHA ARGUMENTLAR. ....... 19
2.1.Funksiya yaratish va u bilan ishlash ................................ ................................ ............................. 19
2.2. Qayta yuk lanuvchi funksiyalar ................................ ................................ ................................ .... 34
III -BOB. C++ DASTURLASH TILIDA REKURSIV FUNKSI YALAR BILAN ISHLASH
TEXNALOGIYASI ................................ ................................ ................................ ......................... 39
3.1. Rekursiv funksiyalar ................................ ................................ ................................ ................... 39
3.2. Rekursiya va Iteratsiya. ................................ ................................ ................................ .............. 42
3.3. C++ da rekursiya qo’llanilish, avzalliklari va kamchiliklar i................................ ......................... 44
Xulosa ................................ ................................ ................................ ................................ .............. 53
Foydalanilgan adabiyotlar ................................ ................................ ................................ .............. 54

3

Kirish
Yangi XXI - asrda axborot texnologiyalari hayotimizning turli jabhalariga
kirib borishi axborotlashgan jamiyatning shakllantirishga zamin yaratib bermoqda.
"Internet", "Elektron pochta", "Elektron ta'lim", "Elektron boshqaruv", "Elektron
hukumat", "Masofaviy ta'lim", "Ochiq ta'lim", "Axborotlashgan iqtisod" kabi
tushunchalar hayotimizga kirib kelishi jamiyatimizning axborotlashishiga intensiv
ta'sir ko`rsatmoqda. Axborot – kommunikatsiyalari orqali mamlakatlarning milliy
iqtisodi globallashib, axborotlashgan iqtisod shakliga o'tmoqda, ya'ni milliy
iqtisoddagi axborot va bilimlarning atilgan ax borot va bilimlarning 90 % so'nggi 30
yil mobaynida yaratilgan bo'lib, ular hajmining ko'payib borishi axborot -
kommunikatsiyalaridan samarali foydalanishni talab etmoqda.
Ko'plab mamlakatlar o'zlarining istiqboldagi rivojlanishini axborot -
kommunikatsiyalar i asosida yo'lga qo'yishni anglab yetishgan. Mustaqil O'zbekiston
Respublikamizda ham jamiyatni axborotlashtirish, kompyuter ilmini o’qitishni
rivojlantirish bo'yicha Qonunlar qabul qilinib, ular asosida bir qator dastur va
tadbirlar amalga oshirib kelinmo qda. Jumladan, O'zbekiston Respublikasi
Prezidentining «Axborotlashtirishni yanada rivojlantirish to'g'risida» 2002 - yil 30 -
maydagi PF -3080 -son Farmoni asosida 2010 - yilgacha Axborot -
kommunikatsiyalarini rivojlantirish bo'yicha milliy dastur ishlab chiq ilgan bo'lib, u
hozirda butun respublikamiz milliy iqtisodiyotning turli tarmoqlari va sohalarida
tatbiq qilinmoqda.
Jamiyat hayotiga axborotlarni kеng darajada kirib kеlishi fuqarolarga axborot
olishga bo‘lgan imkoniyatlar eshigini ochib bеrdi. Mazkur o‘zgarishlar birinchi
navbatda, yangi axborot kommunikatsiyalarini ta'siri ostida yuz bеrib, inson
faoliyatining har bir sohasida axborotga bo‘lgan ehtiyojning ortishi bilan
tavsiflanadi. Bugungi kunda mutaxassislar axborotni asosiy bеlgisi sifatida
ma'lumotni qayta ishlash jarayonining muayyan bosqichlarga bo‘linishini e'tirof
etadilar. Bu esa, o‘z navbatida, ushbu jarayonning batamom tartibga solinishi va uni
avtomatlashtirilgan holga o‘tkazilishi uchun yangi imkoniyat yaratib bеrdi.Hozirda
jurnali stikani tezkor axborotlarsiz tassavvur qilish qiyin. OAV’ning qaysi turiga

4

nazar tashlamang, axborotni istе'molchiga uzatish jarayonida, aynan
jurnalistika hodimlari ishiga guvoh bo’lasiz. XXI asr jahon hamjamiyati tomonidan
“axborot kommunikatsiyalari asr i” dеya e'tirof etilmoqda. Bunday sharoitda bilim,
axborotga egalik ishlab chiqarish va iqtisodiy aloqalar ustidan hukmronlik qilish
imkonini bеradi. Kompyutеr madaniyatining kirib kеlishi tufayli insonning o‘z
ustida ishlashi, malakasini oshirishga intili shiga asoslangan fikrlash, bilim olishning
yangi ko‘rinishi yuzaga kеldi.Bu esa isonda axborotga bo’lgan talabni
kuchaytiradi.O’z navbatida bu axborotlar kurashuvini belgilab beradi.
Kurs ishnin g tuzilishi: Kurs ishi kirish, uchta bob, xulosa, foydalanilgan
adabiyotlar hamda internet resurslar ro‘yxatidan iborat.

5

I-BOB. C++ DASTURLASH TILIDA KO‘RSATKICHLAR, ADRES
OLUVCHI O‘ZGARUVCHILAR
1.1. Ko’rsatkich tush unchasi va uni to`g`ri qo`llash

C ++ tilining eng katta afzalliklaridan biri shundaki, u mashina darajasidan
abstraktlash paytida yuqori darajadagi dasturlarni yozish, shu bilan birga kerak
bo'lganda apparatga yaqin ishlash imkoniyatini ham beradi. C ++ ilova ishlashini
bayt va bit daraj asida sozlash imkonini beradi. Ko'rsatkichlarning qanday ishlashini
tushunish tizim resurslaridan samarali foydalanadigan dasturlarni yozishni o'rganish
bosqichlaridan biridir.
Ko’rsatkichlar. Ko’rsatkich – bu maydon manzilini xotirada saqlaydigan
o'zgaruvchidir. int o'zgaruvchisi butun qiymatni saqlash uchun ishlatilgandek,
ko'rsatgich o'zgaruvchisi xotira maydoni manzilini saqlash uchun ishlatiladi (1 -
rasm).

Shunday qilib, ko'rsatkich o'zgaruvchidir va barcha o'zgaruvchilar singari
u ham xotiradan joy egallaydi (1 -rasmda 0x101 manzilda). Ko'rsatkichlarni maxsus
ko’rinishga keltiradigan xususiyat shundaki, ular tarkibidagi qiym atlar (bu holda,
0x558) xotira maydonlarining manzillari sifatida talqin etiladi. Demak, ko'rsatkich -
bu xotiradagi maydonni ko'rsatadigan maxsus o'zgaruvchidir.
Xotira manzillari odatda o'n oltilik sanoq sistemasida ko'rsatiladi, ya'ni 16 xil
belgilar yordamida - 0-9, so'ngra A -F. An'anaga ko'ra 0x prefiksi o'n oltilik sanoq
sistemasidan oldin yoziladi. Shunday qilib, 0xA o'n oltilik oltilik sanoq
sistemasidagi raqam o'nlik sanoq sistemasida 10ni ifodalaydi; 0xF - 15; va 0x10 –
16 ni ifodalaydi .
Ko’rsatkichni e’lon qilish. Ko'rsatkich o'zgaruvchi bo'lgani uchun, uni
boshqa har qanday o'zgaruvchi singari e'lon qilish kerak. Odatda, ko'rsatkich ma'lum
bir turdagi qiymatga ishora qiladi (masalan, int tipiga). Bu shuni anglatadiki,
ko'rsatkichda joy lashgan manzil butun sonni o'z ichiga olgan xotiradagi maydonga
0x101 manzilidagi
ko'rsatkich 0x558
qiymatini o'z ichiga
oladi
Xotiradagi
ma'lumotlar 0x558
manzili da

6

ishora qiladi. Shuningdek, xotiraning tipga ega bo’lmagan blokiga ko'rsatkichni
belgilashingiz mumkin (void ga ko'rsatkich deb ham ataladi).
Ko'rsatkich boshqa barcha o'zgaruvchilar singari e' lon qilinishi kerak:
Tip_nomi * Ko’rsatkich nomi;
Ko'pgina o'zgaruvchilar bilan bo'lgani kabi, agar ko'rsatgichni ishga
tushirmasangiz, unda tasodifiy qiymat bo'ladi. Tasodifiy xotira maydoniga kirmaslik
uchun ko'rsatkich nullptr qiymati bilan boshlanadi. Ko'rsatkich qiymati har doim
nullptr qiymatiga tengligini tekshirishi mumkin, bu haqiqiy xotira maydonining
manzili bo'lishi mumkin emas:
Tip_nomi * Ko’rsatkich_nomi = nullptr;
Shunday qilib, butun sonli ko'rsatkichni e'lon qilish quyidagicha bo’ladi:
int *pInteger = nullptr;
Ko'rsatkich, shu paytgacha o'rganilgan har qanday boshqa ma'lumotlar
turining o'zgaruvchisi kabi, initsializatsiyadan oldin tasodifiy qiymatni o'z ichiga
oladi. Ko'rsatkich uchun bu tasodifiy qiymat ayniqsa xavflidir, chunki u xotira
maydonining ba'zi manzillarini anglatadi. Initsializatsiya qilinmagan ko'rsatgichlar
dasturingizning yaroqsiz xotira maydoniga kirishiga olib kelishi va u dasturni ishdan
chiqarishi mumkin.
& adres olish amali. O'zgaruvchilar - bu til tomonidan xoti rada ma'lumotlar
bilan ishlashni ta'minlaydigan imkoniyat.
Agar varName o'zgaruvchi bo'lsa, &varName uning qiymati saqlanadigan
xotira adres o’rnini qaytaradi. Shunday qilib, agar sintaksisdan foydalangan holda
butun o'zgaruvchini e'lon qilgan bo'lsangiz, sizga tanish bo'lgan
int age = 30;
u holda &age ifodasi belgilangan qiymat 30 joylashtirilgan xotira
maydonining manzilini qaytaradi.
1-masalada saqlangan qiymatga kirish uchun foydalaniladigan butun sonli
o'zgaruvchi xotira manzilini olish ko’rsatilgan t ushunchasi ko'rsatilgan.
1-misol

$7 #include <iostream> using namespace std; int main() { int age = 30; const double Pi =3.1416; cout <<"age manzili: "<<&age<<endl; cout <<"Pi manzili: "<<&Pi<<endl; return 0; } 1.2. Adreslarni saqlash uchun ko'rsatkichlardan foydalanish Ko'rsatkichlarni qanday e'lon qilishni va o'zgaruvchining manzilini aniqlashni, shuningdek, ko'rsatgichlar xotira maydoni manzilini saqlash uchun ishlatiladigan o'zgaruvchini bilasiz. Ushbu ma'lumotni birlashtiri sh va & adres olish operatori yordamida olingan adreslarni saqlash uchun ko'rsatgichlardan foydalanish vaqti keldi. Allaqachon ma'lum bir turdagi o'zgaruvchini e'lon qilish sintaksisini yaxshi bilasiz: Tip O’zgaruvchi_nomi = Boshlang’ich qiymat; Ushbu o'zg aruvchining adresini ko'rsatgichda saqlash uchun siz belgilan Tip orqali ko'rsatgichni e'lon qilishingiz va uni adresni olish operatori yordamida initsializatsiyalashingiz kerak: Tip* Ko’rsatkich = &O’zgaruvchi_nomi; int tipidagi age o'zgaruvchisini shunday e'lon qildingiz deylik: int age = 30; Keyinchalik foydalanish uchun age o'zgaruvchisi qiymatining manzilini saqlaydigan int ko'rsatgichi quyidagicha e'lon qilinadi: int *pointsToInt = &age; //age butun sonli o’zgaruvchisiga ko’rsatk ich$

8

2-misolda & operatori bilan olingan manzilni saqlash uchun ko'rsatgichdan
foydalanishni keltirilgan.
#include <iostream>
using namespace std;
int main()
{
int age = 30;
int* pointsToInt = &age;
//Ko'rsatkich qiymatini chiqarish
cout<<"age manzili: "<<pointsToInt<<endl;
return 0;
}
Endi adres ko'rsatgich o'zgaruvchisida qanday saqlashni bilganingizdan so'ng,
3-misolda ko'rsatilgandek, xuddi shu ko'rsatgichga boshqa xotira adresi berilishi va
keyin boshqa qiymatga ishora qilish i mumkin deb taxmin qilish mantiqan to'g'ri
keladi.
#include <iostream>
using namespace std;
int main()
{
int age = 30;
int* pointsToInt = &age;
cout<<"pointsToInt age ga ko'rsatkich"<<endl;
cout<<"pointstoInt = "<<pointsToInt<<endl;
int dogsAge = 9;
pointsToInt = &dogsAge;
cout<<"pointsToInt dogsAge ga ko'rsatkich"<<endl;
cout<<"pointstoInt = "<<pointsToInt<<endl;
return 0;
}

9

Ajratish operatori * yordamida ma'lumotlarga kirish
Sizda to'liq manzilni o'z ichiga olga n ko'rsatgich bor deylik. Qanday qilib biz
o'z ichiga olgan ma'lumotlarni yozish yoki o'qish uchun ushbu maydonga kirishimiz
mumkin? Buning uchun ajratish operatori * ishlatiladi.
Aslida, agar pData ko'rsatkichi mavjud bo'lsa, *pData ifodasi ushbu
ko'rsatg ichda joylashgan manzilda saqlangan qiymatga kirishga imkon beradi.
* operatoridan foydalanish quyidagi dasturda ko'rsatilgan.
#include <iostream>
using namespace std;
int main()
{
int age = 30;
int dogsAge = 9;
cout<<"age ="<<age<<endl;
cout<<"dogsAge = "<<dogsAge<<endl;
int* pointsToInt = &age;
cout<<"pointsToInt age ga ko'rsatkich"<<endl;
//Ko'rsatkich qiymatini chiqarish
cout<<"pointstoInt = "<<pointsToInt<<endl;
//Ko'rsatilgan sohadan qiymatni chiqarish
cout<<"*pointsToInt="<<*pointsToInt<<endl;
pointsToInt = &dogsAge;
cout<<"pointsToInt dogsAge ga ko'rsatkich"<<endl;
cout<<"*pointstoInt = "<<*pointsToInt<<endl;
return 0;
}
Yuqoridagi misoldagi ko'rsatkich u ko'rsatgan xotira maydonida n qiymatni
o'qish uchun ishlatilgan. Quyidagi dastur esa *pointsToInt operatoridan birinchi

10

qiymat sifatida foydalanilganda nima sodir bo'lishini ko'rsatadi - ya'ni qiymatni
o'qish uchun emas, balki belgilash uchun.
#include <iostream>
using namespace std;
int main()
{
int dogsAge = 30;
cout<<"Boshlang'ich qiymati dogsAge = "<< dogsAge<<endl;
int* pAge = &dogsAge;
cout<<"pAge DogsAgega ko'rsatkich"<<endl;
cout<<"dosAgening qiymatini kiriting: ";
//pAgening manzili bo'yicha xotira soh asiga qiymatni saqlash
cin>>*pAge;
//Manzilni kiritish
cout<<"Qiymat quyidagi manzilda saqlanadi: "<<hex<<pAge<<endl;
cout<<"Endi dogsAge = "<<dec<<dogsAge<<endl;
return 0;
}
Ko’rsatkich uchun sizeof() qiymati
Yuqoridagi fikrlardan bilganimizdek, ko'rsatkich faqat xotira maydoni
manzilini o'z ichiga olgan o'zgaruvchidir. Shuning uchun, qaysi turiga ishora
qilmasin, ko'rsatkichning tarkibi manzilning raqamli qiymatidir. Manzilning
uzunligi - uni saqlash uchun zarur bo'lgan baytlar soni; u ma'lum bir tizim uchun
doimiydir. Shunday qilib, sizeof() ko'rsatkichi bo'yicha bajarilish natijasi dastur
tuzilgan kompilyatorga va operatsion tizimga bog'liq bo'lib, quyidagi dasturda
ko'rsatilgandek u ko'rsatadigan ma'lumotlarning tabiat iga bog'liq emas.
#include <iostream>
using namespace std;
int main()
{

11

cout<<"tiplar uchun sizeof:"<<endl;
cout<<"sizeof(char) = "<<sizeof(char)<<endl;
cout<<"sizeof(int) = "<<sizeof(int)<<endl;
cout<<"sizeof(double) = "<<sizeof (double)<<endl;
cout<<"Ko'rsatkichli tiplar uchun sizeof:"<<endl;
cout<<"sizeof(char*) = "<<sizeof(char*)<<endl;
cout<<"sizeof(int*) = "<<sizeof(int*)<<endl;
cout<<"sizeof(double*) = "<<sizeof(double*)<<endl;
return 0;
}
Xotirani dinami k ravishda taqsimlash
Quyidagicha ko’rinishdagi statik massivlarni e’lon qilishda bizda muammolar
paydo bo’ladi:
int Numbers[100]; //100 ta butun son uchun statik massiv.
1-muammo: Bu yerda dasturimizning imkoniyatlarini chegaralaymiz, chunki
u 100 dan ort iq raqamni saqlay olmaydi.
2-muammo: Masalan, faqat 1 ta raqamni saqlash kerak bo'lganda va 100 ta
raqam uchun xotira ajratilganda resurslardan samarasiz foydalanyapmiz.
Ushbu muammolarning asosiy sababi kompilyator tomonidan massiv uchun
statik bo’lgan, d oimiy xotirani ajratishdir.
Dastur foydalanuvchidan o'ziga xos ehtiyojlariga qarab xotiradan maqbul
foydalanishi uchun xotirani dinamik taqsimotidan foydalanish zarur. Bu sizga kerak
bo'lganda ko'proq xotira ajratish va kerak bo'lmaganda bo'shatish imkonin i beradi.
C++ dasturida xotiradan foydalanishni boshqarish imkonini beradigan ikkita
operator, new va delete mavjud. Xotira manzillarini saqlaydigan ko'rsatkichlar
xotirani samarali dinamik ravishda taqsimlashda hal qiluvchi rol o'ynaydi.
Xotirani ajratish va bo'shatish uchun new va delete operatorlaridan
foydalanish

12

new operatori yangi xotira bloklarini ajratish uchun ishlatiladi. new
operatorining eng ko'p ishlatiladigan versiyasi, u muvaffaqiyat haqida so'ralgan
xotira maydoniga ko'rsatkichni qaytaradi va aks holda istisno qiladi. new
operatoridan foydalanishda siz xotira ajratiladigan ma'lumotlar turini ko'rsatishingiz
kerak:
Tip* Ko’rsatkich = new Tip; //Xotiraga bitta element uchun so’rov
Shuningdek, siz xotirani ajratmoqchi bo'lgan elementlar sonini belgilashingiz
mumkin (agar siz elementlar qatori uchun xotira ajratishingiz kerak bo'lsa):
Tip* Ko’rsatkich = new Tip [Miqdor] // Belgilangan elementlar soni uchun
xotirani so'rash
Shunday qilib, xotirada butun sonlarni joylashtirish ker ak bo'lsa, quyidagi
koddan foydalanishimiz mumkin:
int* pointToAnInt = new int; //Butun songa ko’rsatkich
int* pointToNums = new int[10]; //10 ta butun sondan iborat massivga
ko’rsatkich
new operatori bilan ajratilgan har bir xotira maydoni tegishli delete operatori
tomonidan bo'shatilishi kerak:
Tip* Ko’rsatkich = new Tip;
Delete Ko’rsatkich;
Bu bir nechta element uchun xotira ajratilganda ham shu usul yordamida
o’chirish mumkin:
Tip* Ko’rsatkich = new Tip[Miqdor];
Deletep[] Ko’rsatkich;
Agar siz ajrati lgan xotirani tugatgandan so'ng bo'shatmasangiz, u ajratilgan
bo'lib qoladi va keyinchalik sizning yoki boshqa ilovalaringizga ajratish uchun
mavjud bo'lmaydi. Xotiraning bunday sarflanishi hatto dastur yoki umuman
kompyuter ishini sekinlashtirishi mumkin va bunga har qanday holatda yo'l
qo'ymaslik kerak.
Quyidagi dasturda xotirani dinamik ajratish va taqsimlash ko'rsatilgan.

13

#include <iostream>
using namespace std;
int main()
{
//int tipi uchun xotira ajratish
int* pointsToAn Age = new int;
//Ajratilgan xotiradan foydalanish
cout<<"Yoshni kiriting: ";
cin>> *pointsToAnAge;
//* Ajratish operatorini qo'llash
cout<<"Yosh "<< *pointsToAnAge<<" " <<hex<<pointsToAnAge<<"
adresida saqlanadi"<<endl;
delete pointsToAnAge; //Xotirani bo'shatish
return 0;
}
E'tibor bering, new [] operatoridan foydalangan holda bir qator elementlar
uchun xotirani ajratganda, quyidagi dasturda ko'rsatilgandek, uni delete [] operatori
yordamida bo'shatish kerak.
#include <i ostream>
using namespace std;
int main()
{
cout<<"Massiv miqdorini kiriting?"<<endl;
int numEntries = 0;
cin>>numEntries;
int* myNumbers = new int[numEntries];
cout<<"Ajratilgan xotira manzili: "<<myNumbers<<hex<<endl;
//Xotirani bo'shatish
delete[] myNumbers;
return 0;

14

}
Ko’rsatkichlarda const kalit so’zidan foydalanish
Oldingi darslarda o'zgaruvchini const deb e'lon qilish, ishga tushirilgandan
so'ng o'zgaruvchining qiymati o’zgarmas turishini bilib olgandik. Bunday
o'zgaruvchining qiymatini o'zgartirish mumkin emas.
Ko'rsatkichlar ham o'zgaruvchidir, shuning uchun const kalit so'zi ham ularga
mos keladi. Biroq, ko'rsatkichlar - bu xotira maydonlarining manzillarini o'z ichiga
olgan va xotiradagi ma'lumotlarni o'zgart irishga imkon beradigan
o'zgaruvchilarning maxsus turi.
Shunday qilib, ko'rsatkichlar va doimiylar haqida gap ketganda, quyidagi
kombinatsiyalar bo’lishi mumkin.
1) Ko'rsatkichda joylashgan manzil doimiy bo'lib, uni o'zgartirish mumkin
emas, ammo u ko'rsat gan ma'lumotlar o'zgarishi mumkin:
int daysInMonth = 30;
int* const pDaysInMonth = &daysInMonth;
*pDaysInMonth = 31;
int daysInLunarMonth = 30;
pDaysInMonth = &daysInLunarMonth //Xatolik: adresni o'zgartirish
mumkin emas
Ko'rsatkich ko'rsatgan ma'lumotlar doimiy va ularni o'zgartirish mumkin
emas, lekin ko'rsatkichda joylashgan manzilning o'zi o'zgarishi mumkin (ya'ni
ko'rsatkich boshqa joyga ishora qilishi mumkin):
int hoursInDay = 24;
const int* pointsToInt= &hoursInDay;
int mon thsInYear = 12;
pointsToInt = &monthsInYear; //OK!
*pointsToInt = 13; //Kompilyatsiya vaqtida xatolik
//Ma'lumotni o'zgartirish mumkin emas
int* newPointer = pointsToInt; //Kompilyatsiya vaqtida xatolik:
//doimiy ko'rsatgichga

15

//doimiy ko'rsatgichni belgilay olmaysiz
Ko'rsatkichda joylashgan manzil ham, u ko'rsatadigan qiymat ham doimiy
bo'lib, ularni o'zgartirish mumkin emas (eng cheklovchi variant):
int hoursInDay = 24;
const int* const pHoursInDay= &hoursInDay;
*pHoursInDay = 25; //Kompilyatsiya xatoligi:
//ushbu ko'rsatgich tomonidan ko'rsatilgan
//qiymatni o'zgartirish mumkin emas
int daysInMonth = 30;
pHoursInDay = &daysInMonth;
Ushbu turli xil konstruktsiyalar, ayniqsa funksiyalarga ko'rsatkichlarni
uzatishda foydalidir. Funksiya parametrlari funksiyani ko'rsatkich tomonidan
ko'rsatilgan qiymatni o'zgartira olmasligini ta'minlash uchun agar funksiyada
bunday o'zg artirish nazarda tutilmagan bo'lsa, eng cheklangan darajadagi
barqarorlikni ta'minlash uchun e'lon qilinishi kerak. Bu dasturchining
ko'rsatkichning qiymatini yoki u ko'rsatgan ma'lumotni noto'g'ri o'zgartirishiga yo'l
qo'ymaydi.
1.3. Funksiyaga ko’rsatkichlarni uzatish
Ko'rsatkichlar - bu qiymatlarni o'z ichiga olgan va natijani o'z ichiga
oladigan xotiraning funksional sohalariga o'tishning samarali vositasi. Funksiyalar
bilan ko'rsatkichlardan foydalanishda, chaqirilgan funktsiyani faqat siz o' zgartirishni
xohlagan parametrlarni o'zgartirishga ruxsat berilishini ta'minlash kerak. Masalan,
ko'rsatkich orqali o'tgan radiusdan doiraning maydonini hisoblaydigan funksiyaga
ushbu radiusni o'zgartirishga yo'l qo'yib bo'lmaydi. Bunday holda, doimiy
ko'r satkichlar yordam beradi, bu qanday funksiyalarni o'zgartirishga ruxsat
berilishini va nimani o’zgartirish mumkin emasligini samarali boshqarish imkonini
beradi (pastdagi dasturga qarang)
#include <iostream>
using namespace std;

16

void CalcArea( const double* const pPi, const double* const pRadius, double*
const pArea)
{
//Ishlatishdan oldin ko'rsatgichlarning to'g'riligini tekshirish!
if (pPi && pRadius && pArea)
*pArea = (*pPi) * (*pRadius) * (*pRadius);
}
int main()
{
const do uble Pi = 3.1416;
cout<<"Aylananing radiusini kiriting: ";
double radius = 0;
cin>>radius;
double area = 0;
CalcArea (&Pi, &radius, &area);
cout<<"Yuza:"<<area<<endl;
return 0;
}
C++da ishlaydigan parametrlar ko'rsatkichlarni ko'rsatishi mumkin.
Ko'rsatkichlar funktsiyaga qiymat bo'yicha uzatiladi, ya'ni funksiya ko'rsatkichning
nusxasini oladi. Shu bilan birga, ko'rsatkich nusxasi asl ko'rsatkich bilan bir xil
manzilga ega bo'ladi. Shuning uchun parametr sifatida parametrlarda n foydalanib,
biz argument qiymatiga kirishimiz va uni o'zgartirishimiz mumkin.
Masalan, bizda sonni birga oshiradigan oddiy funksiya mavjud deylik:
#include <iostream>
using namespace std;
void increment(int x)
{
x++;
cout << "Funksiya natijasi x=: " << x << endl;

17

}
int main()
{
int n = 10;
increment(n);
cout << "Bosh funksiyada n= " << n << endl;
return 0;
}
Bu yerda n o'zgaruvchisi x parametriga argument sifatida uzatiladi. U qiymat
bilan uzatiladi, shuning uchun inkr ement funktsiyasidagi x parametrining har
qanday o'zgarishi n qiymatiga ta'sir qilmaydi. Dasturni ishga tushirsak:
Funksiya natijasi x= 11;
Bosh funksiyada n= 10;
Keling, parametr sifatida ko'rsatkichni ishlatish uchun increment funksiyasini
o'zgartiraylik :
#include <iostream>
using namespace std;
void increment(int *x)
{
(*x)++;
cout << "Increment funksiyasida x=: " << *x << endl;
}
int main()
{
int n = 10;
increment(&n);
cout << "Bosh funksiyada n=: " << n << endl;
return 0;
}

18

Parametr qiymatini o'zgartirish uchun keyingi increment bilan ajratish
jarayoni qo'llaniladi: (*x)++. Bu x ko'rsatkichida saqlangan manzildagi qiymatni
o'zgartiradi.
Endi funksiya parametr sifatida ko'rsatkichni oladi, uni chaqirganda siz
o'zgaruvchining manzilini kiritishingiz kerak: increment (&n);.
Natijada x parametrining o'zgarishi n o'zgaruvchiga ham ta'sir qiladi:
Shu bilan birga, argument funksiyaga qiymat bo'yicha uzatilganligi sababli,
funksiya manzilning nusxasini oladi, agar fun ksiya ichida ko'rsatkich manzili
o'zgartirilsa, bu tashqi ko'rsatkichga ta'sir qilmaydi argument sifatida qabul qilinadi:
#include <iostream>
using namespace std;
void increment(int *x)
{
int z = 6;
x = &z; // x ko'rsatkichining manzilini qayta o'rnating
cout << "increment funksiyasida x= " << *x << endl;
}
int main()
{
int n = 10;
int *ptr = &n;
increment(ptr);
cout << "main function: " << n << endl;
return 0;
}
Ptr ko'rsatkichi increment funksiyasiga uzatiladi. Qachon chaqirilsa, funksiya
bu ko'rsatkichning x parametri sifatida nusxasini oladi. Funksiyada x
ko'rsatkichining manzili o'zgartirilgan. Ammo bu ptr ko'rsatkichiga hech qanday
ta'sir qilmaydi, chunki u boshqa nusxani anglatadi. Natijada, manzi lni tiklash
maydoni, x va ptr ko'rsatkichlari turli manzillarni saqlaydi.

$19 II -BOB. C++ DASTURLASH TILIDA DA FUNKSIYALAR BILAN ISHLASH. FUNKSIYA PARAMETRLARI VA ARGUMENTLARI. KELISHUV BO’YICHA ARGUMENTLAR. 2.1.Funksiya yaratish va u bilan ishlash Funksiya - bu ma'lum bir vazifani bajarish uchun bayonotlar ketma -ketligi. Ko'pincha, dastur kodi funksiyani bajarishi uchun boshqa operatorlarni to’xtatib turadi. Haqiqiy hayotda ham shunga o'xshash narsalarni doimo bajarasiz. Masalan, siz kitob o'qiyapsiz va telefon orqali qo'ng'iroq qilishingiz kerakligini eslaysiz. Kitobingizda xatcho'p qoldirasiz, telefonni ko'tarib raqamni terasiz. Suhbatlashgandan so'ng, kitobni o'qishga qaytasiz, ya’ni qoldirgan sahifangizdan kitobni o’qishni davom ettirasi z. C++ dasturlari shunga o'xshash tarzda ishlaydi. Ba'zan, dastur kodni bajarayotganda, funksiya murojaatiga duch kelishi mumkin. Funksiyaga murojaat – bu protsessorga joriy funksiyani bekor qilishni va boshqa funktsiyani ishlatishni aytadigan ifoda. Prots essor joriy bajarilish nuqtasida "xatcho'p qoldiradi" va keyin chaqirilgan funktsiyani ishlatadi. Murojaat qilingan funksiyani bajarish tugagandan so'ng, protsessor “xatcho'p”ga qaytadi va to'xtatilgan funktsiya bajarilishini davom ettiradi. Funksiyani e’l on qilish. Funksiya dastur bajaradigan harakatlarni belgilaydi. Funksiyalar sizga ko'rsatmalar to'plamini ajratib ko'rsatish va unga nom berish imkonini beradi. Keyin dasturning turli qismlarida tayinlangan funksiya nomi yordamida bir necha marta murojaat qilish mumkin. Funksiya aslida kodning nomlangan blokidir. tip funksiya_nomi(parametrlar) { ko’rsatmalar }$

20

Birinchi satr funksiya sarlavhasini aks ettiradi. Dastlab, funksiyani qaytarish
turi (tipi) ko'rsatiladi. Agar funktsiya hech qanday qiymat qaytarma sa, u holda void
turi ishlatiladi.
Keyin ixtiyoriy identifikatorni ifodalovchi funktsiya nomi keladi. Funksiyani
nomlashda o'zgaruvchi nomlashda qo'llaniladigan qoidalardan foydalaniladi.
Funksiya nomidan keyin parametrlar qavs ichida keltirilgan. Funktsiy aning
parametrlari bo'lmasligi mumkin, bu holda bo'sh qavslar ko'rsatiladi.
Funksiya sarlavhasidan so'ng, sistemali qavslarda bajariladigan ko'rsatmalar
berilgan funksiya tanasini ifodalaydi.
Qaytish qiymati. Natija qaytarish uchun funksiya return operatoridan
foydalanadi. Agar funksiya qaytarish turi sifatida void tipidan boshqa har qanday
turga ega bo'lsa, u return operatori yordamida qiymatni qaytarishi shart. Masalan,
har qanday C++ dasturida bo'lishi kerak bo'lgan va uning bajarilishi boshlanad igan
asosiy funksiya ta'rifi:
int main()
{
return 0;
}
main() bajarilishini tugatgandan so'ng, return operatori yordamida butun sonni
operatsion tizimga qaytaradi.
Biz yozadigan funksiyalar qiymatlarni ham qaytarishi mumkin. Buning uchun
siz qaytish turini (yoki "qaytish tipini") belgilashingiz kerak. Bu funksiyani e'lon
qilishda, uning nomidan oldin ko'rsatiladi. Qaytish turi qaysi qiymat qaytarilishini
ko'rsatmasligini unutmang. Bu faqat ushbu qiymat turini bildiradi.
So'ngra, chaqirilgan funksiya ichida, qaytish qiymatini belgilash uchun return
operatoridan foydalanamiz - qaysi qiymat murojaat qiluvchiga qaytariladi.
Butun sonni qaytaradigan oddiy funktsiyani ko'rib chiqaylik:
int return7()
{

$21 // Ushbu funktsiya butun qiymatni qaytaradi, shuning uchun biz return operatoridan foydalanishimiz kerak return 7; } void tipi. Yuqoridagi funksiyaning qaytish turi int, shuning uchun funksiya return operatoridan foydalanishi va int turiga mos keladigan ba'zi bir qiymatni qaytarishi kerak. Qaytish qiymat i return bayonotidan keyin joylashtiriladi. Funksiyalar qiymatlarni qaytarishi yoki qaytarmasligi mumkin. Kompilyatorga funksiya qiymatni qaytarmasligini aytish uchun siz void return turidan foydalanishingiz kerak. Quyida berilgan doPrint() funksiyasini ko 'rib chiqamiz: void doPrint() { cout<<"Salom"; } Ushbu funksiya void qaytarish turiga ega, ya'ni funksiya qiymatni qaytarmaydi. Hech qanday qiymat qaytarilmasligi sababli, hech qanday return bayonoti talab qilinmaydi. Funksiyaga murojaat qilish . Funksiyadan foydalanish uchun uni chaqirish kerak. Funksiya quyidagi shaklda chaqiriladi: funksiya_nomi(argumentlar); Funksiya nomidan keyin qavslar qo'shiladi, unda argumentlar - funksiya parametrlari uchun qiymatlar keltirilgan. Masalan, eng oddiy funksi yani aniqlaymiz va uni chaqiramiz #include <iostream> void hello() { std::cout << "Salom \n"; } int main() {$

22

hello();
hello();
return 0;
}
Bu hello funksiyasini belgilaydi, bu asosiy funksiyada ikki marta chaqiriladi.
Bu funktsiyalarning afzalligi: biz ba'zi bir umumiy harakatlarni alohida funksiyaga
o'tkazamiz va keyin ularni dasturning turli joylarida ko'p marta chaqiramiz. Natijada,
dastur "Salom" satrini ikki marta bosib chiqaradi.
Funksiyalarni chaqirishda quyidagi xa toliklarga yo’l qo’ymaslik kerak.
Quyidagi misolni qarab chiqaylik:
#include <iostream>
void returnNothing()
{
cout<<"Salom!"<<endl;
}
int main()
{
returnNothing();
cout<<returnNothing();// bu xatolik
return 0;
}
ReturnNothing() ga birinchi murojatt “Salom!” ni bosib chiqaradi, ammo
murojaat qiluvchiga hech narsa qaytarilmaydi. Bajarilish nuqtasi main()
funksiyasiga qaytadi, bu yerda dastur o'z bajarilishini davom ettiradi.
ReturnNothing() ga ikkinchi murojaat hatto tuzilmaydi. Retur nNothing()
funksiyasi void qaytarish turiga ega, ya'ni bu funktsiya qiymat bermaydi. Biroq,
main() funksiyasi ushbu qiymatni (qaytarilmagan) cout operatoriga chiqish uchun
yuborishga harakat qiladi. cout bu ishni ko'rib chiqa olmaydi, chunki chiqish qiymat i
berilmagan. Shunday qilib, kompilyator xatoga yo'l qo'yadi.

23

main() funksiyasi haqida. Endi siz main() funksiyasi qanday ishlashini
tushunasiz. Dastur bajarilgach, operatsion tizim main() funksiyasini chaqiradi va
uning bajarilishini boshlaydi. main() da gi ifodalar ketma -ket bajariladi. Nihoyat,
main() funktsiyasi operatsion tizimga butun qiymatni qaytaradi (odatda 0). Shuning
uchun main() funksiyasi int main () deb e'lon qilinadi.
Nima uchun operatsion tizimga qiymatlarni qaytarish kerak? Gap shundaki,
m ain() funksiyasining qaytish qiymati operatsion tizimga dasturning muvaffaqiyati
yoki muvaffaqiyatsizligi to'g'risida ma'lumot beradigan holat kodidir. Odatda,
qaytarish qiymati 0 (nol) har bir narsaning muvaffaqiyatli bo'lganligini anglatadi,
boshqa har q anday qiymat esa xato / xato degan ma'noni anglatadi.
Shuni bilib olingki, C++ standartlari bo'yicha main() funktsiyasi butun sonni
qaytarishi kerakligini unutmang. Ammo, main() funktsiyasi oxirida qaytishni
ko'rsatmasangiz, xatolar bo'lmasa kompilyator av tomatik ravishda 0 qaytaradi.
Lekin main() funktsiyasi oxirida return ni ko'rsatish va main() funktsiyasi uchun int
return turidan foydalanish tavsiya etiladi.
Funksiyaning qaytuvchi tipi haqida quyidagi ma’lumotlarni bilib olsih kerak:
Birinchidan, funksi yani qaytarish turi void bo’lmasa, u belgilangan turdagi
qiymatni qaytarishi kerak (return operatoridan foydalaning). Faqatgina istisno main
() funksiyasi bo'lib, u boshqa qiymat berilmasa 0 qiymatini beradi.
Ikkinchidan, protsessor funksiyada return opera toriga duch kelganda, darhol
qiymatni murojaat qiluvchiga qaytaradi va ijro etish nuqtasi ham murojaat
qiluvchiga o'tadi. Funksiyada qaytarilish orqasida turgan har qanday kod e'tiborga
olinmaydi.
Funktsiya murojaat qiluvchiga return orqali faqat bitta qiy matni qaytarishi
mumkin. Bu raqam yoki (masalan, 7), yoki o'zgaruvchining qiymati, yoki ifoda
(natijaga ega) yoki mumkin bo'lgan qiymatlar to'plamidan ma'lum bir qiymat bo'lishi
mumkin.
Ammo bir vaqtning o'zida bir nechta qiymatlarni qaytarish orqali bitta qiymatni
qaytarish qoidasidan o'tish usullari mavjud, ammo bu haqida boshqa darsda batafsil
gaplashamiz.

24

Nihoyat, funktsiya muallifi uning qaytish qiymati nimani anglatishini hal
qiladi. Ba'zi funktsiyalar funksiyalarni bajarish natijasini (muvaffaqi yatga erishdimi
yoki yo'qmi) ko'rsatish uchun qaytarish qiymatlarini holat kodlari sifatida
ishlatadilar. Boshqa funksiyalar mumkin bo'lgan qiymatlar to'plamidan ma'lum bir
qiymatni qaytaradi. Bundan tashqari, umuman hech narsa qaytarmaydigan
funksiyalar m avjud.
Funksiyalardan bir necha marta foydalanish. Xuddi shu funksiyani hatto
turli xil dasturlarda ham bir necha marta chaqirish mumkin, bu juda foydali:
#include <iostream>
using namespace std;
//getValueFromUser() funksiyasi foydalanuvchidan qiymatni ol adi va keyin
uni murojaat qiluvchiga qaytaradi
int getValueFromUser()
{
cout<<"Raqam kiriting:";
int x;
cin>>x;
return x;
}
int main()
{
int a = getValueFromUser();
int b = getValueFromUser();
cout <<a<<"+"<<b<<"="<<a+b<<endl;
return 0;
}
Bu yerda main () 2 marta to'xtatiladi. E'tibor bering, har ikkala holatda ham
natija x qiymati o'zgaruvchida saqlanadi va keyin return yordamida main () ga
qaytariladi va u yerda a va b o’zgaruvchisi navbat bilan qiymat oladi.

25

Bundan tashqari main() boshqa funksiyalarni chaqira oladigan yagona
funktsiya emas. Har qanday funksiya boshqa har qanday funksiyani chaqira oladi.
#include <iostream>
using namespace std;
void print0()
{
cout << "O" << endl;
}
void printK()
{
cout << "K" << endl;
}
// PrintOK() funksiyasi printO() va printK() ni chaqiradi
void printOK()
{
printO();
printK();
}
int main()
{
cout << "Starting main()" << endl;
printOK();
cout << "Ending main()" << endl;
return 0;
}
Ichki funksiyalar. C ++ da ba'zi funksiyalarni boshqa funksiyalar ichida e'lon
qilish mumkin emas (ya'ni ularni joylashtirish mumkin emas). Quyidagi kod
kompilyatsiya xatoligini keltirib chiqaradi:
#include <iostream>
using namespace std;

26

int main()
{
int boo() // bu funksiya main() funksiyasi ichida joylashgan, bu esa
ta'qiqlangan
{
cout << "boo!";
return 0;
}
boo();
return 0;
}
Bu aslida quyidagicha bo’ladi:
#include <iostream>
using namespace std;
int boo() // bu funksiya m ain() funksiyasi ichida joylashgan, bu esa ta'qiqlangan
{
cout << "boo!";
return 0;
}
int main()
{
boo();
return 0;
}
Funksiya parametrlari va argumentlari. Ko'p hollarda, biz chaqirilgan
funksiyaga qandaydir tarzda ta'sir o'tkazish i uchun ma'lumotlarni uzatishimiz kerak
bo'ladi. Masalan, agar biz ikkita sonni ko'paytirish uchun funksiya yozmoqchi
bo'lsak, unda qanday qilib funktsiyaga ular qaysi raqamlar bo'lishini aytib berishimiz
kerak. Aks holda, u nimani nimaga ko'paytirishni qa yerdan biladi? Bu yerda
parametrlar va argumentlar tushunchasi kerak bo'ladi.

27

Funksiya parametri - bu funksiyada ishlatiladigan va qiymatini chaqiruvchi
(murojaat qiluvchi) tomonidan ta'minlanadigan o'zgaruvchidir. Parametrlar
funktsiyani e'lon qilishda qavs ichida ko'rsatiladi. Agar ularning soni ko'p bo'lsa, ular
vergul bilan ajratiladi, masalan:
// Bu funksiya hech qanday parametrga ega emas
void doPrint()
{
cout << "doPrint() funksiyasi" << std::endl;
}
// Bu funksiya bitta parametrga ega va u int tipiga tegishli
void printValue(int a)
{
cout << a << endl;
}
// Bu funksiya ikkita int tipidagi a va b parametrlariga ega
int add(int a, int b)
{
return a + b;
}
Har bir funksiyaning parametrlari faqat shu funksiya doirasida amal qiladi.
Shuning uchun, agar printValue() va add() parametrlari a deb nomlangan bo'lsa,
unda bu nom ziddiyatli bo'lishini anglatmaydi. Ushbu parametrlar mustaqil deb
hisoblanadi va bir -birlari bilan hech qanday ta'sir qilmaydi.
Funksiya argumenti - bu murojaat qiluvchidan funksiyaga uzatiladigan va
murojaat qiluvchida funksiyani chaqirishda qavs ichida ko'rsatilgan qiymat:
printValue(7);
add(4,5);
E'tibor bering, argumentlar vergul bilan ham ajratilgan. Argumentlar soni
parametrlar soniga to'g'ri kelish i kerak, aks holda kompilyator xato xabari chiqaradi.

28

Funksiya parametrlari va argumentlari qanday ishlaydi? Funksiya
chaqirilganda uning barcha parametrlari local o'zgaruvchilar sifatida yaratiladi va
har bir argumentning qiymati mos keladigan parametrga (lokal o'zgaruvchiga)
ko'chiriladi. Ushbu jarayon qiymat bo’yicha uzatish deyiladi. Masalan:
#include <iostream>
using namespace std;
void printValues(int a, int b)
{
cout<<a<<endl;
cout<<b<<endl;
}
int main()
{
printValues(8,9);
return 0;
}
PrintValues () funksiyasi chaqirilganda, 8 va 9 argumentlari a va b
parametrlariga ko'chiriladi. a parametrga 8, b parametrga esa 9 qiymat beriladi.
Parametrlar va funktsiyalarning qaytish qiymatlari qanday ishlaydi?
Parametrlar va qaytish qiymatlari yordamida biz ma'lumotlarni qabul qiladigan va
ishlov beradigan funktsiyalarni yaratib, so'ngra murojaat qiluvchiga natijani
qaytaramiz.
Masalan, ikkita butun sonni oladigan va ularning yig'indisini qaytaradigan
oddiy funksiya:
#include <iostrea m>
using namespace std;
int add(int a, int b)
{
return a+b;
}

29

int main()
{
cout<<add(7,8)<<endl;
return 0;
}
Misol. Funksiyalarni bir necha usullarida chaqirish
#include <iostream>
using namespace std;
int add(int a, int b)
{
return a+b;
}
int main()
{
cout<<add(7,8)<<endl;
return 0;
}
Ko’rinishi sohasi. Lokal va global o’zgaruvchilar
Ko’rinishi sohasi (scope) dasturning obyektini ishlatish mumkin bo'lgan
qismini ifodalaydi. Odatda, ko’rinish sohasi sistemali qavs ichida joylashgan kod
bloki bilan cheklanadi. Ko’rinish sohasiga qarab, yaratilgan obyektlar global , lokal
yoki avtomatik bo'lishi mumkin.
Dastlab , ikkita atamani tushunishimiz kerak: ko’rinish sohasi va yashash
vaqti . Ko’rinish sohasi o'zgaruvchini qayerd a ishlatishni aniqlaydi. Yashash vaqti
(yoki "yashash muddati") o'zgaruvchining qayerda yaratilganligini va u yo'q
qilinishini aniqlaydi. Ushbu ikkita tushuncha bir -biriga bog'liqdir.
Blok ichida aniqlangan o'zgaruvchilar lokal o'zgaruvchilar deyiladi. Lokal
o'zgaruvchilar avtomatik ishlash muddatiga ega: ular aniqlanish nuqtasida yaratiladi
(va agar kerak bo'lsa, ishga tushiriladi) va blokdan chiqqandan keyin yo'q qilinadi.

30

Lokal o'zgaruvchilar lokal ko’rinish sohasiga (yoki "b lok") ega, ya'ni ular e’lon
qilingan nuqtadan kelib chiqadi va ular aniqlangan blokning oxirida chiqadi.
Masalan, quyidagi dasturni ko'rib chiqaylik:
#include <iostream>
using namespace std;
int main()
{
int x=4;
double y=5.0;
cout<<x;
retu rn 0;
}
Asosiy funksiya bloki ichida x va y o'zgaruvchilar aniqlanganligi sababli,
ikkalasi ham main () bajarilishini tugatgandan so'ng yo'q qilinadi.
Ichki bloklar ichida belgilangan o'zgaruvchilar ichki blok tugashi bilanoq yo'q
qilinadi:
#include <iostream>
int main() // tashqi blok
{
int m=4; // bu yerda m o'zgaruvchisi e'lon qilinyapti va initsializatsiya
qilinyapti
{ // ichki blokning boshlanishi
double k=5.0; //bu yerda k o'zgaruvchisi yaratiladi va ishga tushiriladi
} // k ko'rinish sohasidan chiqib ketadi va bu yerda yo'q qilinadi

// Bu yerda k o'zgaruvchisini ishlatib bo'lmaydi.
k = k+1; //Bu xato
return 0;
}

31

Bunday o'zgaruvchilardan faqat ular aniqlangan bloklar ichida foydalanish
mumkin. Har bi r funksiya o'z blokiga ega bo'lganligi sababli, bitta funksiyadagi
o'zgaruvchilar boshqa funksiyadagi o'zgaruvchilarga ta'sir qilmaydi:
#include <iostream>
using namespace std;
void someFunction()
{
int value=5;
// value o'zgaruvchisidan faqat shu blokda foydalanish mumkin
} // value o'zgaruvchisi ko'rinishi sohasidan chiqdi va u yo'q qilinadi
int main()
{
// value o'zgaruvchisidan bu blokda foydalanib bo'lmaydi
someFunction();
return 0;
}
Turli xil funksiyalar bir xil nomdagi o'zgaruvchilar yoki parametrlarni o'z
ichiga olishi mumkin. Bu yaxshi, chunki ikkita mustaqil funksiya o'rtasidagi
ziddiyatlarni nomlash ehtimoli haqida tashvishlanishingiz shart emas. Quyidagi
misolda ikkala funktsiya ham x va y o'zgaruvchilarga ega. Ular hatto bir -birlarining
mavjudligini bilishmaydi:
#include <iostream>
using namespace std;
// add() funksiyasi
int add(int x, int y)
{
return x + y;
}
// main() ichida ham x va y o'zgaruvchilari ishlatilgan
int main ()

32

{
int x = 5; // x o'zgaruvchisi e'lon qilingan
int y = 6;
cout << add(x, y) << endl; //main() funksiyasining x qiymati add()
funksiyasining x o'zgaruvchisiga ko'chiriladi
return 0;
}
Ichki bloklar ular belgilanadigan tashqi blokning bir qismi hisoblanadi.
Shunday qilib, tashqi blokda aniqlangan o'zgaruvchilar ichki blok ichida ham ko'rish
mumkin:
#include <iostream>
using namespace std;
int main()
{ // tashqi blok
int x=5;
{ // ichki blokning boshlanishi
int y=7;
// x va y dan foydalanish mumkin
cout << x << " + " << y << " = " << x + y;
} // y o'zgaruvchisi yo'q qilinadi

// y o'zgaruvchisini bu yerda ishlatish mumkin emas, chunki u allaqachon
yo'q qilingan!
return 0;
}
Nomlarni yashirish. Ichki blok ichidagi o'zgaruvchi tashqi blok ichidagi
o'zgaruvchiga o'xshash nomga ega bo'lishi mumkin. Bu sodir bo'lganda, ichki (ichki)
blokdagi o'zgaruvchi tashqi o'zgaruvchini "yashiradi". Bunga nomlarni yashirish
deyiladi:
#includ e <iostream>

33

using namespace std;
int main()
{ // tashqi blok
int a=5;
if (a >= 5)
{ // ichki blok
int a; // a o'zgaruvchisi ichki blokda yashirilmoqda

// a identifikatori endi ichki o'rnatilgan a o'zgaruvchiga ishora qiladi.
// a tashqi o'zgaruvchisi vaqtincha yashiringan
a = 10; //Bu yerda tashqi emas, balki ichki a o'zgaruvchisiga qiymat
berilgan
cout << a << endl;
} // ichki a o'zgaruvchisi o'chirildi
// a identifikatori yana tashqi o'zgaruvchiga ishora qiladi
cout << a << endl;
return 0;
}
Imkon qadar nomlarni yashirishga umuman yo'l qo'ymaslik kerak, chunki bu
juda chalkash holatlarda olib kelishi mumkin. Iloji boricha tashqi o'zgaruvchilar
bilan bir xil nomdagi ichki o'zgaruvchilarni ishlatishdan saqlanish lozim .
Global o’zgaruvchilar. Global o'zgaruvchilar dastur faylida har qanday
funktsiyalardan tashqarida aniqlanadi va har qanday funksiya tomonidan ishlatilishi
mumkin.
#include <iostream>
using namespace std;
void print();
int n = 5; //Global o'zgaruvchi
int main()
{

34

print(); // n=6
n++;
cout << "n=" << n << endl; // n=7
return 0;
}
void print()
{
n++;
cout << "n=" << n << endl;
}
Bu yerda n o'zgaruvchisi global va har qanday funksiyadan foydalanish
mumkin. Bundan tashqari, har qanday funksiya o'z qiymatini o'zgartirishi mumkin.
Lokal o’zgaruvchilar . Kod bloki ichida yaratilgan obyektlar (u funksiyani
yoki qandaydir sikl tipidagi konstruktsiyani ifodalashi mumkin) lokal deb
nomlanadi. Bunday obyektlar faqat ular belgilangan kod bloki ichida mavjud
bo’ladi.
2.2. Qayta yuk lanuvchi funksiyalar
Ayr im algoritmlar berilganlar ning har xil turdagi qiymatlari uch un
qo’llan ishi mumki n. Masalan, ik kita son ning mak simumini topish
algoritmida bu sonlar butun yo ki haqiqiy turda bo’ lishi mumkin. Bun day
hollarda bu algoritmlar ama lga oshiril gan fu nk-siyalar nomlari bir xil
bo’l gani ma ’qul. Bir nechta funksi ya ni bir xil nom lash, lekin har xil
turdagi parametrlar bil an ish latish funks iyani qayta yuklash deyiladi.
Kompilyator parame trlar tur iga va soniga qarab mos funksiyani
chaqiradi. Bun day amal ni «hal qilish amali » de yiladi va uni ng maqsadi
parametrlarga ko’ra aynan (nisbatan) to’ g’ ri keladigan funksiyani
cha qirishdir. Agar bunday funksiya topilmasa kompil ya tor xatolik haqida
xabar beradi. Funksiyani aniqlashda funksiya qaytaruvchi qiym at turining
ahamiyati yo’ q. Mis ol:
#include <iostream>

35

using namespace std;
int Max(int,int);
char Max(char,char);
float Max(float,float);
int Max( int,int,int);
int main()
{
int a,b;
char c,d;
int k;
float x,y;
cin>>a>>b>>k>>c>>d>>x>>y;
cout<<Max(a,b)<<endl;
cout<<Max(c,d)<<endl;
cout<<Max(a,b,k)<<endl;
cout<<Max(x,y);
return 0;
}
int Max(int i,int j)
{
return (i>j)?i:j;
}
char Max(char s1,char s2)
{
return (s1>s2)?s1:s2;
}
float Max(float x,float y)
{
return (x>y)?x:y;
}

36

int Max(int i,int j,int k)
{
if(i>j)
if(i>k)
return i;
else
return k;
if(j> k)
return j;
else
return k;
}
Ag ar funksiya chaqirilishida argument turi un ing prototipidagi xud di sh u
o’rindagi parametr turi ga mos kelmasa, kompilyator uni parametr tu riga
keltirilishga harakat qiladi - bool va char turlarini int turiga, float turini double
turiga va int turini double turiga o’tkazishg a.
Qayta yuklanuvchi funksi ya lardan foyda lanishda quyidagi qoidalarga
rioya qilish kera k:
1) qayta yuklanuv ch i funksiyalar bitta ko’rinish sohasida bo’lishi kera k;
2) qayta yu kla nu vchi funksiyalarda ke lishuv bo’yicha parametrlar
ishlatilsa, bunday parametrlar barcha qayta yu klanuvchi funksiya -larda ham
ishl atilishi va ular bir xil qiymatga ega bo’lish kera k;
3) agar funksiyalar parametrlarining turi fa qat «const» va ‘&’ belgilari
bilan farq qilad igan bo’ lsa, bu funk siyalar qayta yuklanmaydi.
Keli sh uv bo’y icha argu me ntlar. С++ tilida funksiya chaqirilga nda
ayrim argumentlarni tushirib qoldirish mumkin. Bunga funksiya prototipida
ushbu parametrlarni kelishuv bo’yi ch a qiymatini ko’rs atish orqali erishish mumkin.
Masala n, quyida prototipi keltir ilgan funksiya turli chaqirishga e ga bo’lishi
m umkin:
//funksiya prototipi

$37 void Butun_Son(int I,bool Bayroq=true,char Blg=’ \n’); //funksiyani chaqirish variantlari Butun_Son(1,false,’a’); Butun_Son(2,false); Butun_Son(3); Birinchi chaqiruvda barcha parame trlar mos ar gume ntlar orq ali qiymatlarini qabul qiladi, ikkinchi holda I paramet ri 2 qiy m atini, bayroq parametri false qiy m atini va Blg o’ zgaruv ch isi ke lishuv bo’yicha ‘ \n’ qiymatini qab ul qila di. Keli sh uv bo’yicha qiymat berishni ng bitta sha rti bor - para -metrlar ro’yxatida kelishuv bo’yicha qiymat beri lgan parametrlardan keyingi parametrlar ham keli sh uv bo’yicha qiymatga ega bo’lishlari shart. Yuqoridagi misolda I par ametri ke lishuv bo’ yicha qiymat qabul qiling an holda, Bay roq yoki Blg parametrlari qiymatsiz bo’l ishi mumkin emas. Misol tariqasida ber ilgan sonni ko’rsatilgan aniqlikda chop etuvchi programmani ko’rayl ik. Qo’yi lgan masalani yechishda sonni daraja ga oshirish funksiyasi - pow() va suz uvchi nuqtali uzun sondan modul olish fabs l() funksiyasidan foydal - niladi. Bu funk siyalar prototipi «math.h» sarlavha faylida joylashgan. #include <iostream> #include <math.h> using namespace std; void Chop_qilish(double Numb, double Aniqlik=1, bool Bayroq = true) { if(!Bayroq) Numb=fabsl(Numb); Numb=(int)(Numb*pow(10,Aniqlik)); Numb=Numb/pow(10,Aniqlik); cout<<Numb<<' \n'; }$ $38 int main() { double Mpi= -3.141592654; Chop_qilish(Mpi,4,false); Chop_qilish(Mpi,2); Chop_qilish(Mpi); return 0; } Programmada sonni turli aniqlikda (Aniql ik parametri qiymati orqali) chop etish uchun har xil variantlarda Chop_ qilish() funksiyasi chaqirilgan. Programma ishla sh i natijasida ekranda quyidagi sonlar chop etil adi: 3.1 415 -3. 14 -3.1 Parametrning kelishuv bo’yicha beriladigan qiymati o’zgarmas, global o’ zgaruv ch i yoki qa ndaydir funksiya tomonidan qaytaradi gan qiymat bo’li sh i mumkin.$ $39 III -BOB. C++ DASTURLASH TILIDA REKURSIV FUNKSIYALAR BILAN ISHLASH TEXNALOGIYASI 3.1. Rekursiv funksiyalar Rekursiya - bu nafaqat ilm -fan sohasida, balki kundalik hayotda ham uchraydigan juda keng tarqalgan hodisa. Dasturlashda rekursiya funksiyalar bilan chambarchas bog'liq, aniqrog'i dasturlashdagi funksiyalar tufayli rekursiya yoki rekursiv funksiya kabi tushunchalar mavjud. Dasturlashda rekursiya funksiyalar bilan chambarchas bog'liq, aniqrog'i dasturlashdagi fu nksiyalar tufayli rekursiya yoki rekursiv funksiya kabi narsalar mavjud. Oddiy so'zlar bilan aytganda, rekursiya - bu funksiya qismini o'zi orqali belgilash, ya'ni o'zini to'g'ridan -to'g'ri (tanasida) yoki bilvosita (boshqa funktsiya orqali) chaqiradigan f unksiya. Odatda rekursiv muammolarga sonning faktorialini topish, Fibonachchi raqamini topish va hokazolarni keltirish mumkin. Bu kabi masalalarni sikllar yordamida ham hal qilish mumkin. Umuman aytganda, iterativ ravishda yechilgan hamma narsani rekursiv , ya'ni rekursiv funksiya yordamida hal qilish mumkin. C++ da rekursiv funksiya (yoki shunchaki "rekursiya") o'zini o'zi chaqiradigan funksiya. Masalan: #include <iostream> using namespace std; void countOut(int count1) { std::cout << "push " << count1 << ' \n'; countOut(count1 -1); //countOut () funktsiyasi o'zini rekursiv chaqiradi } int main() { countOut(4);$ $40 return 0; } countOut(4) ga murojaat qilish “push 4” yozuvini bosib chiqaradi va keyin countOut (3) ni chaqiradi. countOut (3) “push 3” ni bosib chiqaradi va countOut (2) ga murojaat qiladi. Rekursiyani tugatish sharti. Rekursiv funksiya chaqiruvlari odatdagi funktsiya murojaatlari singari ishlaydi. Shu bilan birga, yuqoridagi dastur oddiy funksiyalar va re kursivlar o'rtasidagi eng muhim farqni aks ettiradi: siz rekursiyani tugatish shartini belgilashingiz kerak, aks holda funktsiya cheksiz marta bajariladi. Rekursiyani tugatish sharti - bu bajarilgandan so'ng rekursiv funksiyani o'zi chaqirishni to'xtatadig an shart. Ushbu holat odatda if ifodasini ishlatadi. Bu yerda yuqoridagi funksiyaga misol keltirilgan, ammo bu yerda rekursiya tugashi sharti ham mavjud: #include <iostream> using namespace std; void countOut(int count1) { cout << "push " << count1 << ' \n'; if (count1 > 1) // chiqish sharti countOut(count1 -1); cout << "pop " << count1 << ' \n'; } int main() { countOut(4); return 0; } Ushbu dasturni ishga tushirganimizda quyidagi qiymatlar ekranda c hop etiladi boshlanadi: push 4$

41

push 3
push 2
push 1
Rekursiv algoritmlar. Eng
mashhur matematik rekursiv
algoritmlardan biri bu Fibonachchi
ketma -ketligi. Fibonachchi ketma -
ketligini tabiatda ham ko'rish
mumkin: daraxt shoxlari, spiral
kabuklar, ananas mevalari, ochiladigan fern va boshqalar.
Fibonachchi raqamlarining har biri berilgan son joylashgan kvadratning
gorizontal tomonining uzunligi. Fibonachchi raqamlari matematik jihatdan
quyidagicha aniqlanadi:
F(n) = 0, agar n = 0
1, agar n = 1
F(n -1) + F(n -2), agar n > 1
Shunday qilib, Fibonachchi sonini hisoblash uchun rekursiv funksiyani yozish
juda oson:
#include <iostream>
using namespace std;

int fibonacci(int number)
{
if (number == 0)
return 0;
if (number == 1)
return 1; //
return fibonacci(number -1) + fibonacci(number -2);
}
// Dastlabki 13 ta Fibonachchi sonini topish

42

int main()
{
for (int count=0; count < 13; ++count)
cout << fibonacci(count) << " ";
return 0;
}
3.2. Rekursiya va Iteratsiya.
Rekursiv funksiyalar haqida eng ko'p so'raladigan savol: "Nima uchun rekursiv
funksiyadan foydalanish kerak, chunki bu masalalarni for sikli yoki while sikli
yordamida ham bajarish mumkin?” Ma'lum bo'lishicha, har doim rekursiv masalani
takroriy ravishda hal qilishingiz mumkin. Biroq, ahamiyatsiz bo'lmagan holatlar
uchun rekursiv versiyani yozish va o'qish ko'pincha ancha osonlashadi. Masalan, n -
Fibonachchi raqamini hisoblash funksiyasini takrorlash operatorlari yordamid a
yozish mumkin, ammo bu murakkab bo'ladi.
Iteratsion funktsiyalar ( for yoki while sikllaridan foydalanadigan funksiyalar)
deyarli har doim o'zlarining rekursiv o'xshashlariga qaraganda samaraliroq. Buning
sababi shundaki, har safar funksiya chaqirilganda ma'lum miqdordagi resurslar
sarflanadi. Iterativ funksiyalar ancha kam resurs sarf qiladi.
Bu takrorlanadigan funktsiyalar har doim eng yaxshi variant degani emas.
Ba'zan rekursiv dastur yanada toza va sodda bo'lishi mumkin va qo'shimcha
qo'shimcha xarajat lar ko'proq bo'lishi mumkin, bu kodni kelgusida saqlashdagi
qiyinchiliklarni minimallashtiradi, ayniqsa algoritm echim topishga juda ko'p vaqt
ketmasa.
Umuman olganda, rekursiya, agar quyidagilarning aksariyati to'g'ri bo'lsa,
yaxshi tanlovdir:
– rekursiv kodni amalga oshirish ancha oson;
– rekursiya chuqurligini cheklash mumkin;
– algoritmning takrorlanadigan versiyasi ma'lumotlar to'plamini
boshqarishni talab qiladi;
– bu dasturning ishlashiga bevosita ta'sir ko'rsatadigan muhim kod emas.

43

Funksiyalarda n foydalanish sabablari. Dastlabki boshlovchi dasturchilarda
ko'pincha "Masalani funksiyalarsiz bajarish va barcha kodlarni to'g'ridan -to'g'ri
main() funksiyasiga qo'yish mumkinmi?" degan savol paydo bo’ladi. Agar dastur
kodingiz atigi 10 -20 satrdan iborat bo'lsa, unda siz buni qi la olasiz. Jiddiy eslatma
sifatida, funksiyalar kodni murakkablashtirishga emas, balki soddalashtirishga
qaratilgan. Ularning notrivial dasturlarda juda foydali bo'lgan bir qator afzalliklar
bor.
Struktura. Dasturlar hajmi/murakkabligi oshib borgan sari, b archa kodlarni
main() ichida saqlash qiyin bo'ladi. Funksiya mini -dasturga o'xshaydi, biz uni
kodning qolgan qismi bilan asosiy dasturdan alohida yozishimiz mumkin. Bu sizga
murakkab vazifalarni kichikroq va sodda vazifalarga ajratishga imkon beradi, bu es a
dasturning umumiy murakkabligini keskin pasaytiradi.
Takror foydalanish. Funksiya e'lon qilingandan so'ng, uni ko'p marta
chaqirish mumkin. Bu kodning takrorlanishiga yo'l qo'ymaydi va kodni
nusxalash/joylashtirishda xatolar ehtimolini kamaytiradi. Funks iyalar boshqa
dasturlarda ham ishlatilishi mumkin, bu har safar noldan yozilishi kerak bo'lgan kod
miqdorini kamaytiradi.
Testlash. Funksiyalar keraksiz kodni olib tashlaganligi sababli, uni testlash
osonroq bo'ladi va funksiya mustaqil birlik bo'lgani uch un, uning ishlashiga ishonch
hosil qilish uchun uni bir marta sinab ko'rishimiz kerak, keyin uni sinovdan
o'tkazmasdan (bu funksiyaga o'zgartirish kiritmagunimizcha) qayta -qayta ishlata
olamiz.
Modernizatsiya. Agar dasturga o'zgartirish kiritishingiz yoki uning
funksiyasini kengaytirishingiz kerak bo'lsa, unda funksiyalar juda yaxshi
imkoniyatdir. Ularning yordami bilan hamma joyda ishlashlari uchun ularni bitta
joyda o'zgartirishingiz mumkin.
Abstraktsiya. Funksiyadan foydalanish uchun biz uning nomini, ki rish
ma'lumotlarini, chiqish ma'lumotlarini va funksiya qayerda joylashganligini
bilishimiz kerak. Uning qanday ishlashini bilishimiz shart emas. Bu boshqalar

44

tushunishi mumkin bo'lgan kod yozish uchun juda foydalidir (masalan, C++ standart
kutubxonasi va undagi barcha narsalar shu prinsip asosida tuzilgan).
Har safar kiritish yoki chiqarish operatori uchun std::cin yoki std::cout deb
nomlaganimizda, biz C++ standart kutubxonasidan yuqoridagi barcha
tushunchalarga amal qiladigan funksiyadan foydalanamiz.
Fu nksiyalardan samarali foydalanish. Yangi boshlovchilar duch keladigan
eng keng tarqalgan muammolardan biri bu funksiyalarni qayerda, qachon va qanday
qilib samarali ishlatishni tushunishdir. Funktsiyalarni yozish uchun ba'zi bir asosiy
ko'rsatmalar:
1-tavs iya . Dasturda bir necha marta paydo bo'lgan kod funksiya sifatida yaxshi
yozilgan. Masalan, agar biz xuddi shu tarzda foydalanuvchidan bir necha marta
ma'lumotlarni olsak, bu alohida funktsiyani yozish uchun ajoyib imkoniyat.
2-tavsiya . Biron bir narsani s aralash uchun ishlatiladigan kod alohida funksiya
sifatida yozilgan yaxshiroqdir. Masalan, bizda saralash kerak bo'lgan narsalar
ro'yxati bo'lsa, biz saralash funksiyasini yozamiz, bu yerda biz saralanmagan
ro'yxatni o'tkazamiz va saralangan joyni olamiz.
3-tavsiya . Funksiya bitta (va faqat bitta) vazifani bajarishi kerak.
4-tavsiya . Agar funksiya juda katta, murakkab yoki tushunarsiz bo'lib qolsa,
uni bir nechta kichik funksiyalarga bo'lish kerak. Bunga kodni qayta ishlash deyiladi.
3.3. C++ da rekursiya qo’llanilish, avzalliklari va kamchiliklari
Rekursiya - bu murakkab dasturni hal qilish uchun funktsiyani o'z -o'zidan
uning pastki dasturi sifatida chaqirish jarayoni. Rekursiya bir xil muammoni hal
qilish uchun ko'p kuch va vaqt talab qiladigan iterativ usul o'rniga dasturni kichik
vazifalarga bo'lish va uni qayta -qayta chaqirish usulidan foydalanadi. Shuning
uchun o'zini chaqiradigan funksiya rekursiv funktsiya deb ataladi va funktsiyani o'zi
chaqirish jarayoni rekursiya deb ataladi.. Rekursiya haqida eng muhim narsa
shundaki, u rekursiyani tugatish uchun asosiy holatga ega bo'lishi kerak. Rekursiv
funktsiya uzluksiz ravishda o'zini chaqirganligi sababli, dastur cheksiz tsiklga o'tishi
har doim ham mumkin. Shunday qilib, if..else iborasi yordamid a tugatish asosiy

45

registrini yaratsak, dastur har safar asosiy holat holatini tekshiradi va cheksiz tsiklga
o'tishni oldini oladi.
Rekursiya ta’rifi
Ta’rif: Funksiya o’ziga o’zi to’g’ridan -to’g’ri yoki qandaydir vosita orqali
murojaat qilish jarayoniga rek ursiya deyiladi va bunday funksiya rekursiv funksiya
deb ataladi.
Rekursiya qanday ishlaydi?
Rekursion yondashuvning vazifasi boshqa muammoni hal qilish usuliga
nisbatan muammoni samarali hal qilishdir. Rekursiya jarayoni muammoni funksiya
sifatida kichik vazifaga ajratadi va yakuniy yechimga bir qadam yaqinlashish uchun
doimiy ravishda bir xil funktsiyani qayta chaqiradi. Bu jarayon muammoning
yakuniy yechimini topgunimizcha davom etadi. Har safar yechimning bir qismi
topilganda, u xotirada stek ma' lumotlar strukturasi ko'rinishida saqlanadi va nihoyat
yakuniy yechimni olish uchun chiqariladi. Yakuniy yechimga yaqinlashganimizda,
rekursiya jarayonidan chiqish uchun tekshirilishi kerak bo'lgan asosiy shart mavjud.
Ushbu asosiy shart shartli bayonot yo rdamida tekshiriladi va shuning uchun cheksiz
tsiklga kirish uchun rekursiya jarayonidan qochadi. Agar biron -bir sababga ko'ra
asosiy ish ishlamasa, dastur cheksiz tsiklga tushadi va biz hech qachon dasturning
yechimiga erisha olmaymiz. Quyida C++ da rekur siyaning ishi keltirilgan.
void recursion ()
{
... .. ...
recursion();
... .. ...
}
int main ()
{
... .. ...
recursion();
... .. ...

46

}
Quyidagi rasmda rekursiv funktsiyani qayta -qayta chaqirish orqali rekursiya
qanday ishlashi ko'rsatilgan.

Rekursiv funktsiyaning ikki turi mavjud: to'g'ridan -to'g'ri rekursiya va bilvosita
rekursiya. To'g'ridan -to'g'ri rekursiya - bu funktsiya o'zini xuddi yuqoridagi dasturda
ko'rganimiz kabi chaqiradi. Bilvosita rekursiya - bu funktsiya boshqa funktsiyani
chaqirganda va keyin bu funktsiya chaqiruvchi funktsiyani chaqiradi.
C++ Rekursiyasining afzalliklari
• Rekursiya dasturida kamroq sonli kod satrlari ishlatiladi va shuning
uchun kod qisqaroq va toza ko'rinadi.
• Rekursiyani grafik va daraxt kabi ma'lumotlar strukturasi va
algoritmlari bilan bog'liq muammolarni hal qilish uchun yondashish oson
• Rekursiya vaqt murakkabligini kamaytirishga yordam beradi
• Bu funktsiyani keraksiz chaqirishlarini kamaytirishga yordam beradi

$47 • Bu stek evolyutsiyasi va prefiks, infiks, postfiks baholashni hal qilishga yordam beradi • Rekursiya takroriy tuzilmaviy shakllarga ega bo'lgan ob'ektlarni aniqlashning eng yaxshi usuli hisoblanadi C++ rekursiyasining kamchiliklar i • U juda ko'p stack maydonini sarflaydi • Dasturni qayta ishlash uchun ko'proq vaqt kerak bo'ladi • Agar dasturda xatolik yuzaga kelsa, takrorlanuvchi dasturga nisbatan xatoni tuzatish qiyin. Rekursiya yondashuvi har qanday dasturni hal qilishning eng muhim us uli hisoblanadi va shuning uchun rekursiya tushunchasini tushunish darajasini tekshirish uchun texnik intervyularda so'raladigan ko'plab mashhur muammoli bayonotlar mavjud. C++ dasturi #include <iostream> using namespace std; int fibonnaci(int x) { if((x== 1)||(x== 0)) { return (x); }else { return (fibonnaci(x -1)+fibonnaci(x -2)); } } int main() { int x , i= 0; cout << "Enter the number of terms of series : "; cin >> x; cout << "\ nFibonnaci Series : "; while (i < x) { cout << " " << fibonnaci(i);$ $48 i++; } return 0; } Natija: Seriya shartlari sonini kiriting: 15 Fibonnaci seriyasi: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 Bu erda yuqoridagi dasturda "fibonachchi" funktsiyasi o'zini chaqiradigan va Fibonachchi seriyasini topadigan rekursiv funktsiyadir. Rekursiv Fibonachchi dasturi bo'yicha vaqt murakkabligi O (n ^ 2) yoki eksponent hisoblanadi. 2) C++ da rekursiyadan foydalangan holda faktorial dastur Faktorial butun son va uning ostidagi barcha bos hqa butun sonlarning mahsulotidir. Masalan, 5 (5!) ning faktoriali 5x4x3x2x1 ya'ni 120 ga teng. C++ dasturi #include <iostream> using namespace std; int fact(int n); int main() { int n; cout << "Enter a positive integer: "; cin >> n; cout << "Factorial of " << n << " = " << fact(n); return 0; } int fact(int n) { if(n > 1) return n * fact(n - 1);$ $49 else return 1; } Natija: Musbat butun sonni kiriting: 6 Faktorial 6 = 720 Bu erda "fakt" rekursiv funksiyasi biz faktorialni topmoqchi bo'lgan parametr sifatida raqamni oladi. Va keyin asosiy shart rost bo'lguncha funktsiyani rekursiv chaqiring, ya'ni raqam parametr sifatida 1 ga aylanadi. Rekursiv faktorial dastur uchun vaqt murakkabligi O(n) dir, chunki rekursiv funksiya yordamida sonning faktorialini topishda bir vaqtning o'zida faqat bitta sikl bajariladi. Bundan tashqari, rekursiv qo'ng'iroqlar paytida qo'shimcha joy talab qilinmaydi va shuning uchun fazoning murakkabligi ham O(n). 3) C++ da rekursiya yordamida sonlar quvvatini hisoblash dasturi Ushbu dasturda biz sonning kuchini rekursion yondashuv yordamida hisoblaymiz, bunda baza va ko'rsatkich foydalanuvchi tomonidan kiritiladi. C++ dasturi #include <iostream> using namespace std; int calculate(int, int); int main() { int base, power, result; cout << "Enter base number: "; cin >> base; cout << "Enter power number(positive integer): "; cin >> power; result = calculate(base, power); cout << base << "^" << power << " = " << result;$ $50 return 0; } int calculate(int base, int power) { if (power != 0) return (base*calculate(base, power -1)); else return 1; } Natija: Asosiy raqamni kiriting: 3 Quvvat raqamini kiriting (musbat butun son): 4 3^4 = 81 Bu erda "hisoblash" rekursiya funktsiyasi 0 ga qadar quvvatni tekshirish uchun asosiy shart bilan o'zini qayta -qayta chaqiradi, chunki ko'rsatkich har doim ijobiy butun sond ir. Rekursiya yordamida sonning kuchini topish uchun dasturning ish vaqtining murakkabligi O(logn) dir, chunki har safar rekursiv funksiya chaqirilganda keyingi chaqiruv parametri eksponensial marta ortadi. Shuning uchun vaqt murakkabligi jurnalning vazifa sidir. 4) C++ da rekursiyadan foydalangan holda sonni teskari aylantirish Bu dasturda biz foydalanuvchidan ma'lumotni butun son sifatida qabul qilamiz va uni rekursiv funksiya yordamida teskari aylantiramiz. C++ dasturi #include <iostream.h> using namespace std int reverseNumber(int n) { static temp,sum; if(n>0){ temp = n%10;$

51

sum = sum*10 + temp;
reverseNumber(n/10);
}
else {
return sum;
}
}
int main() {
int n,reverse;
cout<<"Enter number";
cin >> n;
reverse = reverseNumber(n);
cout << "Reverse of number is" << reverse;
return 0;
}
Natija:
Raqamni kiriting: 3456 Raqamning
teskarisi: 6543
Ushbu dasturda biz foydalanuvchi kiritgan parametr bilan "reverseNumber"
funksiyasini rekursiv chaqiramiz.
Dasturning ishlash vaqtining murakkabligi O(log(n)) dir, chunki funksiya har
safar rekursiv chaqirilganda u keyingi chaqiruv uchun parametr sifatida raqamning
1/10 qismini oladi. Shuning uchun rekursiv funksiya yordamida sonni teskari
aylantiri sh uchun vaqt murakkabligi O(log(n)) ga teng.
5) C++ da sonning tub ekanligini yoki rekursiyadan foydalanmasligini
tekshirish
Tut son faqat o'ziga va 1 ga bo'linadigan sondir. Ushbu dasturda berilgan son
tub son yoki yo'qligini tekshiramiz.
C++ dasturi
#in clude <bits/stdc++.h>

52

using namespace std;
bool isprime(int n, int i = 2)
{
if (n <= 2)
return (n == 2) ? true : false;
if (n % i == 0)
return false;
if (i * i > n)
return true;
return isprime(n, i + 1);
}
int main()
{
int n = 18;
if ( isprime(n))
cout << "Yes, Number is Prime Number";
else
cout << "No, Number is not Prime Number";
return 0;
}
Natija: Yo'q, Raqam asosiy raqam emas
Bu erda biz "isprime" rekursiv funksiyasini va uning hammasini rekursiv
ravishda yaratamiz va keyin shartli iboralar yordamida tub son shartini tekshiramiz.
Raqamning tub yoki tub emasligini tekshirish uchun dasturning ish vaqti
murakkabligi O(sqrt(n)) dir, chunki isPrime funksiyasini rekursiv chaqirganimizda
u berilgan sonning kvadrat ildizidan ki chik yoki kichik ekanligini tekshiramiz.

53

Xulosa
Ko'rsatkichlar - bu joyning qiymatini xotirada saqlaydigan o'zgaruvchilar. Aslini
olganda, ular har qanday o'zgaruvchining joylashuviga "ishora qiladi", bu holda ular
ko'rib chiqilayotgan o'zgaruvchiga is hora qiladilar. Ko'rsatkichlardan foydalangan
holda, funktsiya funksiya doirasidan tashqarida joylashgan o'zgaruvchining
qiymatini o'zgartirish imkoniyatiga ega. Ko'rsatkichni funktsiyaga argument sifatida
berish "mos yozuvlar bo'yicha o'tish" deb ataladi, o'zgaruvchilar esa odatda qiymat
bo'yicha uzatiladi. Strukturalar bir nechta bog'liq o'zgaruvchilarni bitta tuzilishga
to'plash uchun ishlatiladi va shu bilan yangi turdagi ma'lumotlar turini
yaratadi. Struktura C ++ da C ga qaraganda kamroq qo'llaniladi, chunki C++
sinflarni amalga oshiradi, bu strukturalar bajaradigan barcha ishlarni va boshqalarni
bajaradi. Fun k si y a f aq at ch aq i r i l g an v aq t d a i sh l ayd ig an k od b l og i
h i so b l an ad i . Fun k si y ag a p ar amet r l ar si f at i d a ma'l u m o t l ar n i u zat i sh
mu mk i n . Fu n k siy al ar mu ay y an b i r v azi f an i b aj ar i sh u chu n i sh l at i l ad i . Kod
y o zi sh j ar ay on i d a y ar at g an f u nk si y ad an b i r y ok i b i r n ech ta mar t a i sh l at i sh
y o ki u mu man i sh l at masl i k i mk on i y at ig a eg a mi z .
Funktsiyalar - bu umumiy vazifalarni bajaradigan kod qismlari . Asosiy funksiya
yoki kichik dasturda funksiya qanday chaqirilishini keyinroq muhokama
qilamiz. Funktsiyaning asosiy qo'llanilishi shundan iboratki, u har doim faqat bitta
qiymatni qaytaradi, lekin C++ da, agar qaytarish qiymati bo'lsa. Funktsiyalar
qiymatn i qaytarishi yoki qiymatni qaytarmasdan jimgina bajarilishi mumkin. Uning
qanday ishlashini ko'rsatish uchun quyidagi dasturni ko'rib chiqing, retlarge.cpp, u
kattaroq tortish raqamlarini topadi. Rekursion yondashuv stek ma'lumotlar
strukturasidan foydalan ish tufayli ko'p xotirani iste'mol qilsa ham, dasturda vaqt
murakkabligi va kodlar qatorini kamaytirish uchun turli xil muammoli bayonotlarni
hal qilishda keng qo'llaniladi. Bog'langan ro'yxatni teskari o'zgartirish uchun
rekursiv funksiyaning shunday ilov alarini ko'rib chiqing . Bu texnik turlarni
tozalashda eng tez -tez so'raladigan intervyu savollaridan biridir va shuning uchun
rekursiya kontseptsiyasini yaxshi tushunish tavsiya etiladi.

54

Foydalanilgan adabiyotlar
1. C Programming Absolute Beginner's Guide
2. The C Programming Lan guage (2 nd Edition)
3. C++ Primer 5th Edition
4. C++ Pocket Reference 1st Edition
5. C++ in One Hour a Day, Sams Teach Yourself 8th Edition
6. C++ All -in -One For Dummies 3rd Edition
7. C++: The Complete Reference Fourth Edition
Internet resur slari
1. https://www.quora.com/search?q=c%2B%2B%20is%20about%20Function
2. https://www.spark notes.com/cs/c -plus -plus -
fundamentals/pointersandbasicstructures/summary/
3. https://favtutor.com/blogs/recursion -cpp
4. ht tps://uzbekdevs.uz/darsliklar/cpp/cpp -da -funksiya
5. https://www.cprogramming.com/

C++ dasturlash tilida ko‘rsatkichlar, funksiyalar va rekursiv funksiyalar asosida murakkab jarayonlarni dasturlash

Купить

Похожие документы
3d-max dasturida obektlarni yaratish
Algoritm va ma’lumotlar strukturasi
3D-MAX dasturi haqida
3D Studio MAX dasturiga kirish. 3D Studio MAX dasturi haqida tushuncha
Adobe photoshop dasturida tasvirlarda ishlov berish,taqdimot yaratish

Информация о документе

Продавец

C++ dasturlash tilida ko‘rsatkichlar, funksiyalar va rekursiv funksiyalar asosida murakkab jarayonlarni dasturlash

Похожие документы