C++ da bir va ko‘p qiymat qaytaruvchi funksiyalar, funksiya tarkibidagi global va lokal o‘zgaruvchilar

 “ C++ da bir va ko'p qiymat qaytaruvchi funksiyalar, funksiya tarkibidagi
global va lokal o'zgaruvchilar ” mavzusida
MUNDARIJA:
2
KIRISH ...................................................................................................................... 3
1. C++ tilidagi funksiyalarning ahamiyati va turlari ................................................. 4
2. Funksiyalarning umumiy ko’rinishi ...................................................................... 6
2.1. Bir qiymat qaytaruvchi funksiyalar .................................................................. 10
3.1. Global o’zgaruvchilarning qamrovi va ishlash muddati ................................... 22
3.2. Lokal o’zgaruvchilarning qamrovi va ishlash muddati .................................... 24
Funksiya   parametrlarining   turlari.   Funksiya   parametri   -   bu   funksiyada
ishlatiladigan   va   qiymatini   chaqiruvchi   (murojaat   qiluvchi)   tomonidan
ta’minlanadigan   o zgaruvchidir.   Parametrlar   funksiyani   e'lon   qilishda   qavs   ichidaʻ
ko rsatiladi. Agar ularning soni ko p bo lsa, ular vergul bilan ajratiladi, masalan:	
ʻ ʻ ʻ 25
29
#include <iostream> ................................................................................................ 29
using namespace std; ............................................................................................... 29
float tortburchakyuzi(int a, int b) ............................................................................. 29
{ ............................................................................................................................... 29
 return a*b; ............................................................................................................... 29
} ............................................................................................................................... 29
int main() ................................................................................................................. 29
{ ............................................................................................................................... 29
int a, b; ..................................................................................................................... 29
cout << "Tortburchakning 1-tomonini kiriting: ", cin >> a; .................................... 29
 cout << "Tortburchakning 2-tomonini kiriting: ", cin >> b; ................................... 29
 cout << "To'rtburchakning yuzi: S = a * b = " << tortburchakyuzi(a,b); ............... 29
 return 0; ................................................................................................................... 29
} ............................................................................................................................... 29
1 //Dastur natijasi ........................................................................................................ 29
#include <iostream> ................................................................................................ 30
#include <cmath> .................................................................................................... 30
using namespace std; ............................................................................................... 30
float tortburcha(float a, float b, float* yuzi, float* peremetri, float* diagonali) .... . 30
{ *yuzi = a*b; .......................................................................................................... 30
 *peremetri = 2*(a+b); ............................................................................................. 30
 *diagonali = sqrt(a*a+b*b); } ................................................................................. 30
int main() ................................................................................................................. 30
{ float a, b; ............................................................................................................... 30
 float yuzi, peremetri, diagonali; .............................................................................. 30
 cout << "Tortburchakning 1-tomonini kiriting: ", cin >> a; ................................... 30
 cout << "Tortburchakning 2-tomonini kiriting: ", cin >> b; ................................... 30
 tortburcha(a,b, &yuzi, &peremetri, &diagonali); ................................................... 30
 cout << "To'rtburchakning yuzi: " << yuzi << " ga teng!" << endl; ...................... 30
 cout << "To'rtburchakning peremetri: " << peremetri << " ga teng!" << endl; . . . . . 30
 cout << "To'rtburchakning diagonali: " << diagonali << " ga teng!" << endl; ...... 30
 return 0; } ................................................................................................................ 30
XULOSA ................................................................................................................. 31
FOYDALANILGAN ADABIYOTLAR ................................................................. 32
3. Funs
2 KIRISH
Funksiyalar   C ++   dasturlarining   qurilish   bloklari   bo ’ lib ,   modulli   kod
birliklari   doirasida   maxsus   vazifalar   yoki   operatsiyalarni   qamrab   oladi .   Dasturlash
mobaynida   bir   xil   ifodalarni,   hisoblash   jarayonlarini   qayta   –   qayta   hisoblashga
to`g`ri   keladi.   Dasturlash   tillarida,   kompyuter   hotirasini   va   dasturchining   vaqtini
tejash maqsadida, bunday takkorlanuvchi jarayonlarni dasturda ajratib yozib, unga
asosiy   daturdan,   boshqa   funksiyalardan   murojaat   qilish   imkoniyatlari   keltirilgan.
Funksiyalarning   asosiy   xususiyati   ularning   qiymatlarni   qaytarish   qobiliyatidir,   bu
ularga   natijalarni   chaqiruvchiga   qaytarish   imkonini   beradi.   C++   da   funksiyalar
bitta   qiymatni   yoki   bir   nechta   qiymatlarni   qaytarishi   mumkin,   ularning   har   biri
alohida   maqsadlarga   xizmat   qiladi   va   noyob   afzalliklarga   ega.   Yagona   va   bir
nechta   qaytarish   funktsiyalaridan   qanday   samarali   f-oydalanishni   tushunish
mustahkam va barqaror kod yozish uchun juda muhimdir.  
C++   tilidagi   funksiyalar   ma’lum   bir   vazifani   bajarish   uchun   mo‘ljallangan.
Ular modullilik va kodning qayta ishlatilishini targ'ib qiladi, bu esa dasturchilarga
murakkab   muammolarni   kichikroq,   boshqariladigan   qismlarga   ajratish   imkonini
beradi. 
C++   tilidagi   o zgaruvchilar   dasturni   bajarish   jarayonida   o zgartirilishiʻ ʻ
mumkin   bo lgan   ma lumotlarni   saqlash   uchun   xizmat   qiladi.   Ularni   ko'lami   va	
ʻ ʼ
ishlash   muddatiga   qarab   global   va   mahalliy   o'zgaruvchilarga   bo'lish   mumkin.
Global   o'zgaruvchilarga   butun   dastur   davomida   kirish   mumkin,   mahalliy
o'zgaruvchilar esa ular e'lon qilingan funksiya yoki blok bilan chegaralanadi. 
3 1. C++ tilidagi funksiyalarning ahamiyati va turlari
Dasturning  istalgan qismidan murojaat qilib, bir necha bor ishlatish mumkin
bo`lgan   operatorlar   guruhiga   funksiya   deyiladi.   C++   funksiyalar   tili   deyiladi.
Chunki   dasturda   kamida   bitta   main   funksiyasi   bo'ladi.   Asosiy   dastur,   asosiy
funksiya deganda aynan manashu main funksiyasini tushunamiz.
Asosiy   dasturdan   (yoki   chaqiruvchi   funksiyadan)   xech   qanday   parameter
qabul   qilib   olmaydigan   funksiyalarga,   parametrsiz   funksiyalar   deyiladi.
Parametrsiz funksiyaning o'zi ham 2 xil bo'lishi mumkin:
1) Asosiy dasturga (yoki chaqiruvchi funksiyaga) natijani qaytaruvchi. 
2)   void   turidagi   funksiya   bo'lib,   asosiy   dasturdan   (yoki   chaqiruvchi
funksiyadan) xech qanday parametr qabul qilib olmaydi xam, asosiy dasturga xech
qanday   natija   qaytarmaydi   ham.   Parametrsiz   funksiyaga   murojaat   qilishda   dastur
tanasida   funksiya   nomi   yoziladi.   Dasturda   funksiya   nomi   operatorlar   kabi
ishlatiladi.
Parametrli   funksiyalar   asosiy   dasturdan   (funksiyadan)   chaqiriluvchi
funksiyaga   uzatilgan   parametrlarni   qabul   qilib   qayta   ishlovchi   funksiyalar
parametrli funksiyalar deyiladi. 
Qiymat   parametrlar   –   asosiy   dasturdan   funksiyaga   uzatiladigan
o'zgaruvchilar   qiymatlarni   qabul   qilib   oluvchi   parametrlar.   Funksiyaga   murojaat
qilinganida   qiymat   parametrlari   uchun   xotiradan   joy   ajratiladi.   Funksiya
tugaganida qiymat parametrlari uchun ajratilgan xotira bo'shatiladi. 
Ko rsatkich   parametrlar   -   asosiy   dasturdan   funksiyaga   uzatiladiganʻ
o'zgaruvchilarning xotiradagi adresini qabul qilib oluvchi parametrlar.
Ko'rsatkich   parametrlari   ustida   bajarilgan   har   qanday   o'zgarish,   asosiy
dasturdagi o'zgaruchilarning xotira adresida sodir bo'ladi. (Ya’ni asosiy dasturdagi
o'zgaruvchi   qiymati   o'zgaradi).   Qiymat   parametrlari   va   ko'rsatkich   parametrlar
toifasi, asosiy dasturdagi qiymati uzatilayotgan o`zgaruvchilar toifasi  bilan bir xil
bo`lishi lozim. 
4 Funksiyadan chiqish . Ixtiyoriy funksiyadan  chiqish  uchun return xizmatchi
so'zi ishlatiladi.
Umumiy   olib   aytadigan   bo'lsak,   yagona   va   ko'p   qaytariladigan   qiymat
funktsiyalari   C++   dasturchilarining   ajralmas   vosita   bo'lib,   kodni   samarali   tashkil
etish,   qayta   foydalanish   va   natijalarni   uzatish   imkonini   beradi.   Funksiyani
sintaksisi,   qo'llanilishi,   afzalliklari   va   mulohazalarini   tushunib,   ulardan   aniqroq,
barqaror va samarali kod yozish uchun foydalanish mumkin.
5 2. Funksiyalarning umumiy ko’rinishi
C++   da   dasturlashning   asosiy   bloklaridan   biri   funksiyalardir.   Funksiyalar
dasturchi   ishini   juda   yengillashtiradi.   Funksiyalar   yordamida   programma
modullashadi,   qismlarga   bo'linadi.   Bu   esa   keyinchalik   dasturni   rivojlantirishni
osonlashtiradi. Bunda dasturchi yozgan funksiyalar C++ ning standart kutubhonasi
va   boshqa   kutubhonalar   ichidagi   funksiyalar   bilan   birlashtiriladi.   Bu   esa   ishni
osonlashtiradi. Ko'p holda dasturda takroran bajariladigan amalni funksiya sifatida
yozish   va   kerakli   joyda   ushbu   funksiyani   chaqirish   mumkin.   Dastur   yozilish
davrida hatolarni topishni yengillashtiradi. 
C++   dasturlash   tilida   funksiyalarni   e'lon   qilishning   umumiy   ko rinishiʻ
quyidagicha bo'ladi:
tur <funksiya nomi> (tur <argument>);
Funksiyani   e'lon   qilish   jarayonida   birinchi   funksiya   natijasining,   ya'ni
funksiya   qaytaradigan   turi   keltiriladi,   keyin   funksiya   nomi   qavs   ichida   funksiya
o'zgaruvchilari turi va o zgaruvchilari keltiriladi.	
ʻ
int foo(int k, int t) 
{
int result;
result = k * t;
return (result); 
} 
bunda, foo funksiyamizning ismi, () qavslar ichidagi parametrlar – int tipidagi k va
t   lar   kirish   argumentlaridir,   ular   faqat   ushbu   funksiya   ichida   ko'rinadi   va
qo'llaniladi.                                     Bunday o'zgaruvchilar lokal (local - mahalliy) deyiladi.
result   foo()   ning   ichida   e’lon   qilinganligi   uchun   u   ham   lokaldir.   Demak   biz
funksiya ichida o'zgaruvchilarni va sinflarni (class) e’lon qilishimiz mumkin ekan.
Lekin funksiya ichida boshqa funksiyani e’lon qilib bo'lmaydi. foo() funksiyamiz
qiymat   ham   qaytaradi.   Qaytish   qiymatining   tipi   foo()   ning   e’lonida   eng   boshida
6 kelgan - int tipiga ega. Biz funksiyadan qaytarmoqchi bo'lgan qiymatning tipi ham
funksiya   e’lon   qilgan   qaytish   qiymati   tipiga   mos   kelishi   kerak   -   ayni   o'sha   tipda
bo'lishi   yoki   o'sha   tipga   keltirilishi   mumkin   bo'lgan   tipga   ega   bo'lishi   shart.
Funksiyadan   qiymatni   return   ifodasi   bilan   qaytaramiz.   Agar   funksiya   hech   narsa
qaytarmasa e’londa void tipini yozamiz. Ya’ni:
void funk() 
{ 
int g = 10; 
cout << g; 
return; 
}
bunda, funksiya void (bo’sh, hech narsasiz) tipidagi qiymatni qaytaradi. Boshqacha
qilib   aytganda   qaytargan   qiymati   bo’sh   to’plamdir.   Lekin   funksiya   hech   narsa
qaytarmaydi   deya   olmaymiz.   Chunki   hech   narsa   qaytarmaydigan   mahsus
funksiyalar   ham   bor.   Ularning   qaytish   qiymati   belgilanadigan   joyga   hech   narsa
yozilmaydi.
Funksiyaning   qismlari   bajaradan   vazifasiga   ko’ra   turlicha   nomlanadi.
Yuqorida   korib   chiqqanimiz   funksiya   aniqlanishi   (function   definition)   deyiladi,
chunki biz bunda funksiyaning bajaradigan amallarini funksiya nomidan keyin, {}
qavslar   ichida   aniqlab   yozib   chiqyapmiz.   Funksiya   aniqlanishida   {}   qavslardan
oldin   nuqta-vergul   (;)   qo'yish   hatodir.   Bundan   tashqari   funksiya   e’loni,   prototipi
yoki deklaratsiyasi (function prototype) tushunchasi qo'llaniladi.
           Bunda funksiyaning   nomidan keyin hamon nuqta-vergul qo'yiladi, funksiya
tanasi   esa   berilmaydi.   C++   da   funksiya   qo’llanilishidan   oldin   uning   aniqlanishi
yoki   hech   bo'lmaganda   e’loni   kompilyatorga   uchragan   bo'lishi   kerak.   Agar
funksiya e’loni boshqa funksiyalar aniqlanishidan tashqarida berilgan bo'lsa, uning
kuchi ushbu fayl ohirigacha boradi. Biror bir funksiya ichida berilgan bo'lsa kuchi
faqat o'cha funksiya ichida tarqaladi. E’lon fayllarda aynan shu funksiya e’lonlari
7 berilgan   bo’ladi.   Funksiya   e’loni   va   funksiya   aniqlanishi   bir-biriga   mos   tushishi
kerak. Funksiya e’loniga misol:
double square(char, bool); 
float average(int a, int b, int c); 
Funksiyalarni aniqlashda ulaming qaytarishi lozim bo‘lgan qiymatlar tipi va
funksiya  uchun zarur  bo‘lgan parametrlar  tipini  ko'rsatish  lozim  edi. Ikkita  butun
sonni  qo‘shish   uchun  funksiya  qurilgan   bo‘lsin.   Agar  uchta   butun  sonni   qo‘shish
talab qilingan bo‘lsa, ular uchun boshqa nomdagi funksiyani qurish talab qilinadi.
Ikkita   haqiqiy   sonni   qo‘shish   uchun   esa   boshqa   funksiya   qurish   lozim   bo'ladi.
Bunday hollarda bir xil funksiyani takror va takror yozishning o'rniga, C++ tili bir
xil   nomdagi   funksiyalarni   qurish   imkonini   beradi.   Dasturni   kompilatsiya   qilish
jarayonida C++ funksiyalaming har biridagi argumentlar miqdori e’tiborga olinadi
va aynan kerak bo'lgan funksiyani chaqiradi. Kompilyatorga bir nechta funksiyalar
orasidan   keragini   tanlash   imkoniyati   funksiyalarni   qayta   yuklash   deb   ataladi.
Funksiyalami   qayta   yuklash   amali   bir   xil   nomdagi   parametrlami   har   xil   tipga
mansub   bo‘lgan   turli   funksiyalar   uchun   qo‘llashga   ruxsat   beradi.   Masalan,
quyidagi   dastur   add_values   nomli   ikkita   funksiyani   qayta   yuklash   uchun   xizmat
qiladi:
#include using namespace std;
int add_values (int a, int b) 
{ 
return(a + b);
}
int add_values (int a, int b, int c) {
return(a + b + c);
}
int main()
{
8 cout « “200 + 801 = “ « add_values(200, 801) « endl;
cout « “100 + 201 + 700 = “ « add_values(100, 201, 700) « endl;
}
bunda,   dasturda   ikkita   bir   xil   nomdagi,   ammo   parametrlari   soni   har   xil   bo‘lgan
add_values funksiyasi aniqlangan. Bu holda kompilyator parametrlar soniga ko‘ra
qaysi funksiyani qo‘llash haqida mustaqil ravishda xulosa qiladi.
9 2.1. Bir qiymat qaytaruvchi funksiyalar
Funksiya   -  bu  ma’lum   bir   vazifani  bajarish  uchun  bayonotlar   ketma-ketligi.
Ko pincha,   dastur   kodi   funksiyani   bajarishi   uchun   boshqa   operatorlarni   to xtatibʻ ʻ
turadi.   Funksiyaga   murojaat   –   bu   protsessorga   joriy   funksiyani   bekor   qilishni   va
boshqa funksiyani ishlatishni aytadigan ifoda. Protsessor joriy bajarilish nuqtasida
"xatcho p   qoldiradi"   va   keyin   chaqirilgan   funksiyani   ishlatadi.   Murojaat   qilingan	
ʻ
funksiyani   bajarish   tugagandan   so ng,   protsessor   “xatcho p”ga   qaytadi   va	
ʻ ʻ
to xtatilgan funksiya bajarilishini davom ettiradi.	
ʻ
Funksiyani e’lon 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. 
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	
ʻ ʻ
boshlanadigan asosiy funksiya ta’rifi: 
int main() 
{ 
return 0; 
}
main()
bunda,   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.	
ʻ
10 So ngra,   chaqirilgan   funksiya   ichida,   qaytish   qiymatini   belgilash   uchun   returnʻ
operatoridan foydalanamiz - qaysi qiymat murojaat qiluvchiga qaytariladi.
Butun sonni qaytaradigan oddiy funksiyani ko rib chiqaylik: 	
ʻ
int Funk() 
{ 
// Ushbu funksiya butun qiymatni qaytaradi 
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 qiymati return bayonotidan keyin joylashtiriladi. 
Funksiyalar   qiymatlarni   qaytarishi   yoki   qaytarmasligi   mumkin.
Kompilyatorga   funksiya   qiymatni   qaytarmasligini   aytish   uchun   siz   void   return
turidan   foydalanishingiz   kerak.   Quyida   berilgan   print()   funksiyasini   ko rib	
ʻ
chiqamiz:  void print() 
{ 
cout<<"Salom"; 
}
bu kodda funksiya void qaytarish turiga ega, ya’ni funksiya qiymatni qaytarmaydi.
Hech   qanday   qiymat   qaytarilmasligi   sababli,   hech   qanday   return   bayonoti   talab
qilinmaydi.
Bir qiymat qaytaruvchi funksiyalardan quyidagi maqsadda foydalaniladi:
 Matematik   hisoblar   :   qo shish,   ayirish,   ko paytirish   va   bo lish   kabi   arifmetik	
ʻ ʻ ʻ
amallarni bajaradigan funksiyalar.
 String   manipulyatsiyasi   :   satrlarni   o'zgartiruvchi   yoki   tahlil   qiluvchi
funktsiyalar, masalan, birlashtirish, uzunlikni hisoblash va pastki qatorni ajratib
olish.
11  Ma'lumotlarni   qayta ishlash   :  statistik  hisob-kitoblar, ma'lumotlarni   o'zgartirish
va   yig'ish   kabi   ma'lumotlarni   qayta   ishlaydigan   va   natijalarni   qaytaradigan
funktsiyalar.
Matematik funksiyaga misol :
int add(int a, int b) {
    return a + b;
}
int main() {
    int result = add(3, 4);  // result is 7
    return 0;
}
String funksiyaga misol : 
#include <iostream>
#include <string>
using namespace std;
string reverseString(const string& str) {
    string reversed;
    for (int i = str.length() - 1; i >= 0; --i) {
        reversed += str[i];
    }
    return reversed;
}
int main() {
string input = "hello";
string reversed = reverseString(input);
cout << "Reversed string: " << reversed << endl;
12     return 0;
}
bu kodda  berilgan satrni teskarisiga o‘zgartiruvchi funksiyasiya keltirilgan.
Bitta   qiymatni   qaytaruvchi   funksiyalar   mantiqni   qamrab   olish   va   kodni   samarali
qayta ishlatish mexanizmini ta'minlovchi  dasturlashning asosi  hisoblanadi. Ushbu
funktsiyalarni   qanday   yaratish   va   ulardan   foydalanishni   tushunish   turli   tillar   va
ilovalarda samarali dasturlash uchun zarurdir.
13 2.2.  Ko’p qiymat qaytaruvchi funksiyalar
  
Ko'pgina   dasturlash   tillarida   funktsiyalar   an'anaviy   ravishda   faqat   bitta
qiymatni   qaytaradi.   Biroq,   massivlar,   ob'ektlar,   kortejlar   kabi   ma'lumotlar
tuzilmalaridan yoki havolalar yoki ko'rsatkichlar kabi tilga xos konstruktsiyalardan
foydalanish   kabi   bir   nechta   qiymatlarni   qaytarishni   simulyatsiya   qilish   usullari
mavjud.  
Bir nechta qiymatlarni qaytarishni to'g'ridan-to'g'ri qo'llab-quvvatlamaydigan
tillarda   protseduralar   ularga   o'tkazilgan   o'zgaruvchilarni   o'zgartirishi   va   shunga
o'xshash natijaga samarali erishishi mumkin.  
C++   yoki Java kabi tillarda o'zgaruvchilarni  mos yozuvlar  bo'yicha uzatish
mumkin, bu esa protseduralarga ularni o'zgartirish imkonini beradi.  
#include <iostream>
#include <vector>
void getStats(const std::vector<int>& numbers, int& total, double& average) {
    total = 0;
    for (int num : numbers) {
        total += num;
    }
    average = static_cast<double>(total) / numbers.size();
}
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    int total;
    double average;
    getStats(numbers, total, average);
    std::cout << "Total: " << total << ", Average: " << average << std::endl;
    return 0;
14 } 
ushbu kodda “getStats” funksiyasi uchta parametrni oladi:
1) const std::vector<int>& numbers: Butun sonlar vektoriga doimiy havola.
Katta vektorlarni keraksiz nusxalashdan qochish uchun havola orqali o'tkaziladi.
2)   int&   total:   Raqamlarning   umumiy   yig'indisi   saqlanadigan   butun
o'zgaruvchiga havola.
3)   double&   average:   O'rtacha   raqamlar   saqlanadigan   qo'sh   o'zgaruvchiga
havola.
Funksiya   tanasida   “num”   vektordagi   har   bir   “numbers”   element   ustida
takrorlanadi va ularning yig'indisini “total” ga to'playdi.
Loopdan   keyin   vektordagi   elementlar   soniga   “average”   hisoblanadi.   “total”   bu
static_cast<double>(total) arifmetik bo’lish bajarilishini ta'minlaydi.
Asosiy funktsiyada vektorga “numbers” ba'zi butun sonlar ta’minlanadi.
O'zgaruvchilar  e'lon qiladi  “total” va “average”.  Natijasini  olish  uchun “getStats"
chaqiriladi,  qiymatlarni chop etiladi.
Ushbu dastur vektorda saqlangan raqamlarning umumiy va o'rtacha qiymatini 
hisoblab chiqadi va ularni konsolga chop etadi.
C++   tilidagi yana bir yondashuv bir nechta qiymatlarni saqlash uchun strukturani
aniqlash va funksiyadan ushbu strukturaning namunasini qaytarishdir:
#include <iostream>
#include <vector>
struct Stats {
    int total;
    double average;
};
Stats getStats(const std::vector<int>& numbers) {
15     int total = 0;
    for (int num : numbers) {
        total += num;
    }
    double average = static_cast<double>(total) / numbers.size();
    return {total, average}; // C++11 syntax for initializing struct
}
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    Stats stats = getStats(numbers);
    std::cout << "Total: " << stats.total << ", Average: " << stats.average << 
std::endl;
    return 0;
}
ushbu kodda “Stats” ikki o’zgaruvchidan iborat:
1) total: Raqamlarning umumiy yig'indisini saqlash uchun butun son.
2) average: O'rtacha raqamlarni saqlash.
“getStats” funksiyasi bitta parametrni oladi.
Funksiya tanasida “num” vektordagi har bir “numbers” element ustida takrorlanadi
va ularning yig'indisini “total” ga to'playdi.
Loopdan   keyin   vektordagi   elementlar   soniga   “average”   hisoblanadi.   “total”   bu
static_cast<double>(total) arifmetik bo’lish bajarilishini ta'minlaydi.
Asosiy funktsiyada vektorga “numbers” ba'zi butun sonlar ta’minlanadi.
“Stats”   struktura   o'zgaruvchisini   e'lon   qiladi   va   unga   “getStats”   tomonidan
qaytarilgan natijani taminlaydi, qiymatlarni chop etiladi.
16 Ushbu   dastur   vektorda   saqlangan   raqamlarning   umumiy   va   o'rtacha
qiymatini hisoblab chiqadi va “Stats” natijalarni saqlash uchun maxsus tuzilmadan
foydalangan holda ularni konsolga chop etadi.
Ikkala   yondashuv   ham   C++   da   funksiyadan   bir   nechta   qiymatlarni   samarali
tarzda qaytarish imkonini beradi.
17 3 . Funksiya tarkibidagi o’zgaruvchilar
C++   dasturlash   tilida   tuziladigan   dasturlar   tarkibida   bir   nechta
o zgaruvchilardan   foydalaniladi.   C++   dasturlash   tilida   o'zgaruvchilar   ikki   turgaʻ
ajratiladi, ya'ni global va lokal o zgaruvchilar.	
ʻ
Ta'rif :   Dastur   tarkibining   ixtiyoriy   joyida   foydalanish   mumkin   bo'lgan
o'zgaruvchilar global o'zgaruvchilar deyiladi.
Global   o'zgaruvchilar   dasturning   ixtiyoriy   qismida   o'z   qiymatini   saqlaydi,
hattoki,  main()   funksiyasining   ichidagi   o'zgaruvchilar   ham   global   hisoblanmaydi,
chunki   main()   funksiyasidan   tashqarida   main()   funksiyasi   ichidagi   o'zgaruvchilar
o z qiymatini saqlamaydi. Global o zgaruvchilar main() funksiyasidan oldin e'lon	
ʻ ʻ
qilinadi.   C++   dasturlash   tilidagi   funksiyalar   tarkibidagi   o zgaruvchilar   global	
ʻ
hisoblanmaydi. Global bo'lmagan o zgaruvchilar faqatgini o'z funksiya blok ichiga	
ʻ
tegishli bo ladi.	
ʻ
Ta'rif :   C++   dasturlash   tilidagi   funksiyalar   tarkibidagi   o'zgaruvchilar   lokal
o'zgaruvchilar deyiladi.
Dastur   tarkibidagi   funksiyalar   tarkibidagi   barcha   o'zgaruvchilar   lokal
hisoblanadi,   funksiya   tarkibidagi   o zgaruvchilar   faqatgina   funksiyaning   o z   bloki	
ʻ ʻ
ichida o'rinli bo ladi. 	
ʻ
Global   va   lokal   o zgaruvchilarni   aniqlash   uchun   quyidagi   keltirilgan	
ʻ
sonning bo'luvchilar yig'indisini hisoblovchi dastur mavjud:
#include <iostream.>
int buluvchi (int x);
float m;
int x=16;
using namespace std;
int main() 
{
cout<<buluvchi(x);
18 return 0;
}
int buluvchi(int n)
{
int p=0;
for(int i=1;i<=n;i++)
if(n%i==0) p++;
return p;
}
// Dastur natijasi : 5
ushbu dastur tarkibiga e'tibor qaratsak, main() funksiyasidan oldin e'lon qilingan m
va   x   o zgaruvchilar   global   hisoblanadi,   main()   va   bo’luvchi   (n)   funksiyalariʻ
tarkibidagi   o zgaruvchilar   lokal   hisoblanadi.   Global   o zgaruvchilarni   dasturning	
ʻ ʻ
ixtiyoriy   joyida   foydalanish   imkoniyati   mavjud,   lokal   o zgaruvchilarni   esa	
ʻ
faqatgina o'z funksiya bloki ichida foydalanish mumkin.
Global   va   lokal   o zgaruvchilar   haqida   aytilganda   global   va   lokal	
ʻ
o zgaruvchilarni yashash davri haqida tushuncha beriladi.	
ʻ
Global   o'zgaruvchilarni   yashash   davri   dastur   ishga   tushirilgandan   toki
tugaguncha   hisoblanadi.   Lokal   o zgaruvchilarni   yashash   davri   esa   faqatgina	
ʻ
o zgaruvchi keltirilgan funksiya ishga tushurilgan vaqti hisoblanadi.	
ʻ
Agar   dasturdagi   global   o zgaruvchilar   funksiya   tarkibida   alohida	
ʻ
boshlang'ich qiymati berilsa, uning global qiymati unutiladi va funksiya tarkibidagi
qiymat hisobga olinadi.
Global   va   lokal   o zgaruvchilarni   yashash   davri   quyidagi   masala   orqali	
ʻ
aniqlanadi:
#include <iostream.h>
int yig(int a, int b);
19 int a=20, b=10;
using namespace std;
int main()
{
cout<<yig(a,b);
return 0;
}
int yig(int a, int b)
{
a=4; b=5;
return a+b;
}
// Dastur natijasi: 9
ushbu   dastur   tarkibida   a=20,   b=10   global   sifatida   aniqlangan   edi,   lekin   yig(a,b)
funksiyasini   tarkibida   a=4,   b=5   bo lganligi   uchun   a   va   b   larning   boshlang'ichʻ
qiymatlari unitiladi va natija 9 ga teng bo'ladi.
Global   o'zgaruvchilarning   qiymatlarini   saqlab   qolish   uchun   o'zgaruvchini
boshqacha qilib e'lon qilish kerak.
C++   dasturlash  tilida global  o zgaruvchilarni  lokal  sifatida ishlatilsa  global
ʻ
o zgaruvchining   boshlang'ich   qiymatini   saqlab   qolish   uchun   a   o'zgaruvchini   ::a	
ʻ
sifatida ishlatish kerak.
Global   o zgaruvchilarni   lokal   sifatida   ishlatilsa,   global   o zgaruvchining	
ʻ ʻ
boshlang'ich qiymatini saqlab qolish uchun quyidagi dastur mavjud.
#include <iostream>
int yig(int a, int b);
int a=20, b=10;
using namespace std;
20 int main()
{
cout<<yig(a,b);
return 0;
}
int yig(int a, int b)
{
a=4; b=5;
return a+::b;
}
// Dastur natijasi: 14
21 3.1. Global o’zgaruvchilarning qamrovi va  ishlash muddati
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 qayerda ishlatishni aniqlaydi. Yashash vaqti	
ʻ ʻ
(yoki   "yashash   muddati")   o zgaruvchining   qayerda   yaratilganligini   va   u   yo q	
ʻ ʻ
qilinishini aniqlaydi. Ushbu ikkita tushuncha bir-biriga bog liqdir.	
ʻ  
Dastur   tarkibining   ixtiyoriy   joyida   foydalanish   mumkin   bo'lgan
o'zgaruvchilar   global   o'zgaruvchilar   deyiladi.   Har   qanday   funktsiya   yoki   blokdan
tashqarida   aniqlangan   o'zgaruvchi   global   qamrovga   ega.   Kod   e'lon   qilinganidan
keyin unga kodning istalgan qismidan kirish mumkin. Global o'zgaruvchilar dastur
boshlanganda yaratiladi va dastur tugashi bilan yo'q qilinadi.
Global   o zgaruvchilar   dastur   faylida   har   qanday   funksiyalardan   tashqarida	
ʻ
aniqlanadi va har qanday funksiya tomonidan ishlatilishi mumkin.
#include <iostream>
int globalVar = 10;
void displayGlobalVar() {
    std::cout << "Global Variable: " << globalVar << std::endl;
}
void modifyGlobalVar() {
    globalVar = 20;
}
22 int main() {
    std::cout << "Initial Global Variable: " << globalVar << std::endl;
    displayGlobalVar();
    modifyGlobalVar();
    std::cout << "Modified Global Variable: " << globalVar << std::endl;
    displayGlobalVar();
    return 0;
} 
ushbu   kodda  Global   o'zgaruvchi   “globalVar”  har   qanday   funktsiyadan   tashqarida
aniqlanadi.
Funktsiya “displayGlobalVar”: “globalVar” qiymatini konsolga chiqaradi
Funktsiya “modifyGlobalVar”: global o'zgaruvchining qiymatini o'zgartiradi.
main() funksiyasi “globalVar” ning boshlang'ich qiymatini chop etadi.
“displayGlobalVar” va “modifyGlobalVar” funksiyasi chaqiriladi.
O'zgartirilgan qiymatini chop etiladi. 
Global   o'zgaruvchilar   bir   nechta   funksiyalari   bo'ylab   ma'lumotlarni
almashishning   oddiy   usulini   ta'minlaydi.   Biroq   muammolarni   oldini   olish   uchun
ulardan   oqilona   foydalanish   kerak.   Kattaroq   dasturlarda   ma'lumotlarni
almashishning     boshqa   usullaridan   foydalanish   yaxshiroqdir,   masalan,
funksiyalarga parametrlarni o'tkazish yoki sinflar va ob'ektlardan foydalanish.
23 3.2. Lokal o’zgaruvchilarning qamrovi va ishlash muddati
C++   dasturlash   tilidagi   funksiyalar   tarkibidagi   o'zgaruvchilar   lokal
o'zgaruvchilar deyiladi.   Lokal  o zgaruvchilar  funksiya yoki  blokda e lon qilinganʻ ʼ
o zgaruvchilardir.   Ularga   faqat   ular   belgilangan   funksiya   yoki   blokda   kirish	
ʻ
mumkin.   Fuksiya   ichida   e'lon   qilingan   o'zgaruvchilarga   faqat   shu   funksiya
doirasida   kirish   mumkin.   Blok   ichida   e'lon   qilingan   o'zgaruvchilarga   (bir   juft
jingalak qavslar {}) faqat shu blokda kirish mumkin.
#include <iostream>
void someFunction() {
    int localVar = 5; 
    std::cout << "Inside someFunction, localVar: " << localVar << std::endl;
}
int main() {
    someFunction(); 
{
    int blockVar = 10; 
    std::cout << "Inside block, blockVar: " << blockVar << std::endl;
}
    return 0;
}
ushbu kodda “localVar” funksiya “someFunction” ichida e'lon qilinadi,
uning doirasi “someFunction” bilan cheklangan.
24 “localVar” “someFunction” chaqirilganda yaratiladi va “someFunction” ga qaytib
kelganda yo'q qilinadi.
Main() funksiyasida “blockVar” blok ichida e'lon qilinadi.
“blockVar” qo'llanilish doirasi blok bilan cheklangan.
“blockVar” blokga kirganda yaratiladi va blokdan chiqqanda yo'q qilinadi.
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.   Lokal   o zgaruvchilar   lokal   ko rinish   sohasiga   (yoki   "blok")   ega,	
ʻ ʻ ʻ
ya’ni   ular   e’lon   qilingan   nuqtadan   kelib   chiqadi   va   ular   aniqlangan   blokning
oxirida chiqadi.
Funk siy a   paramet rlarining   t urlari .     Funksiya   parametri   -   bu
funksiyada   ishlatiladigan   va   qiymatini   chaqiruvchi   (murojaat   qiluvchi)
tomonidan   ta’minlanadigan   oʻzgaruvchidir.   Parametrlar   funksiyani
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" << 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) 
25 { 
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);  
ushbu   kodda   argumentlar   vergul   bilan   ham   ajratilgan.   Argumentlar   soni
parametrlar   soniga   to g ri   kelishi   kerak,   aks   holda   kompilyator   xato   xabari	
ʻ ʻ
chiqaradi. 
Funksiya   parametrlari   va   argumentlari   qanday   ishlaydi?   Funksiya
chaqirilganda uning barcha parametrlari lokal 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 using namespace std; 
void printValues(int a, int b) 
{
cout<<a<<endl;  
cout<<b<<endl;  
}
int main() 
{ 
printValues(8,9);
return 0;
26 }
ushbu   kodda   printValues()   funksiyasi   chaqirilganda,   8   va   9   argumentlari   a   va   b
parametrlariga ko chiriladi. a parametrga 8, b parametrga esa 9 qiymat beriladi.ʻ
  Parametrlar   va   funksiyalarning   qaytish   qiymatlari   qanday   ishlaydi?
Parametrlar va qaytish qiymatlari yordamida biz ma’lumotlarni qabul qiladigan va
ishlov   beradigan   funksiyalarni   yaratib,   so ngra   murojaat   qiluvchiga   natijani	
ʻ
qaytaramiz. 
C++   da   funksiya   parametrlari   (argumentlar   deb   ham   ataladi)   funksiya
chaqirilganda   unga   uzatiladigan   qiymatlar   yoki   havolalardir.   Ular   ma'lumotlarni
funktsiyalarga o'tkazishga imkon beradi, bu esa funktsiyalarga ushbu ma'lumotlar
ustida operatsiyalarni bajarish imkonini beradi. C++ da parametrlarni o'tkazishning
bir  necha yo'li mavjud, ularning har biri o'ziga xos foydalanish holatlari  va xatti-
harakatlariga ega:
Qiymat   bo'yicha   o'tish.   Bu   usul   argumentning   haqiqiy   qiymatini
funktsiyaning   rasmiy   parametriga   ko'chiradi.   Funktsiya   qiymatning   nusxasida
ishlaydi, shuning uchun funktsiya ichidagi parametrga kiritilgan o'zgartirishlar asl
argumentga ta'sir qilmaydi.
void func(int x) {
    x = 10;  // Bu o'zgarish asl argumentga ta'sir qilmaydi
}
Havola orqali o'tish.   Ushbu usul argumentning havolasini (yoki manzilini)
rasmiy   parametrga   o'tkazadi.   Funktsiya   asl   qiymatda   ishlaydi,   shuning   uchun
funktsiya ichidagi parametrga kiritilgan o'zgartirishlar asl argumentga ta'sir qiladi.
 void func(int &x) {
    x = 10;  // Bu o'zgarish asl argumentga ta'sir qiladi
}
27 Ko’rsatkich   orqali   o'tish.   Bu   usul   argumentning   manzilini   uzatishni   o'z
ichiga oladi. Bu funksiyasiga asl qiymatni o'zgartirish imkonini beradi. 
void func(int *x) {
    *x = 10;  // Bu o'zgarish asl argumentga ta'sir qiladi
}
int main() {
    int a = 5;
    func(&a);  // 'a' ning manzilini uzatish.
}  
Standart   parametrlar.   C++   funksiyalarga   parametrlar   uchun   standart
qiymatlarga   ega   bo‘lish   imkonini   beradi.   Agar   standart   qiymatga   ega   bo'lgan
parametr uchun argument taqdim etilmasa, standart ishlatiladi.
 void func(int x = 10) {
    // If no argument is passed, x will be 10.
} 
Funksiya parametrlaridan qanday qilib samarali foydalanishni tushunish C+
+   dasturlashda   juda   muhim,   chunki   u   moslashuvchan   va   samarali   funktsiyani
loyihalash imkonini beradi.  
28 #include <iostream>
using namespace std;
float tortburchakyuzi(int a, int b)
{
 return a*b;
}
int main()
{
int a, b;
cout << "Tortburchakning 1-tomonini kiriting: ", cin >> a;
 cout << "Tortburchakning 2-tomonini kiriting: ", cin >> b;
 cout << "To'rtburchakning yuzi: S = a * b = " << tortburchakyuzi(a,b);
  return 0;
}
//Dastur natijasi 
Tortburchakning 1-tomonini kiriting:  1
Tortburchakning 2-tomonini kiriting:  2
Tortburchakning yuzi: s=a*b=2
Natija: 2
29 #include <iostream>
#include <cmath>
using namespace std;
float tortburcha(float a, float b, float* yuzi, float* peremetri, float* diagonali)
{   *yuzi = a*b;
  *peremetri = 2*(a+b);
    *diagonali = sqrt(a*a+b*b);      }
int main()
{   float a, b;
    float yuzi, peremetri, diagonali;
    cout << "Tortburchakning 1-tomonini kiriting: ", cin >> a;
    cout << "Tortburchakning 2-tomonini kiriting: ", cin >> b;
    tortburcha(a,b, &yuzi, &peremetri, &diagonali);
    cout << "To'rtburchakning yuzi: " << yuzi << " ga teng!" << endl;
    cout << "To'rtburchakning peremetri: " << peremetri << " ga teng!" << endl;
    cout << "To'rtburchakning diagonali: " << diagonali << " ga teng!" << endl;
    return 0;        }
//Dastur natijasi:
To’rtburchakning 1-tomonini kiriting:    3
To’rtburchakning 2-tomonini kiriting:    2
To’rtburchakning yuzi: 6 ga teng!
To’rtburchakning parametric: 10 ga teng !
To’rtburchakning diagonali: 3.60555 ga teng!
30 XULOSA
C++  dasturlash tilida dastur funksiya va funksiyalardan tashkil topadi. Agar
dastur bir nechta funksiyalardan tashkil topgan bo’lsa, bir funksiyaning nomi main
deb   nomlanishi   shart.   Dastur   aynan   main   funksiyasining   birinchi   operatoridan
boshlab bajariladi.
Bir qiymat qaytaruvchi  funksiyalar oddiy va ulardan foydalanish oson, ular
eng   oddiy   operatsiyalarda   ishlatish   uchun   mos   keladi.   Misol   uchun   i kki   sonning
yig'indisini qaytaruvchi funksiya.
C++  to'g'ridan-to'g'ri funksiyadan bir nechta qiymatlarni qaytarishni qo'llab-
quvvatlamaydi.   Biroq,   ko'rsatkichlar,   havolalar   yoki   tuzilmalar   yordamida   bir
nechta qiymatlarni qaytarish mumkin.
Lokal  o'zgaruvchilar: Funksiya doirasida e'lon qilinadi va faqat shu funksiya
doirasida amal qiladi. Ular funksiya chaqirilganda yaratiladi va funksiya tugaganda
yo'q   qilinadi.   Lokal   o'zgaruvchilar   xotirani   boshqarishga   yordam   beradi   va
kutilmagan nojo'ya ta'sirlarni kamaytiradi.
Global   o'zgaruvchilar:   har   qanday   funksiyadan   tashqarida   e'lon   qilinadi.
Ularga   dasturdagi   istalgan   funksiya   orqali   kirish   va   o zgartirish   mumkin,   bu   esaʻ
ularni   bir   nechta   funksiyalar   bo ylab   taqsimlanishi   kerak   bo lgan   ma lumotlar	
ʻ ʻ ʼ
uchun   foydali   qiladi.   Biroq,   haddan   tashqari   foydalanish   nojo’ya   ta'sirlar   va
qaramliklar tufayli tushunish va saqlash qiyin bo'lgan kodga olib kelishi mumkin.
31 FOYDALANILGAN ADABIYOTLAR
1.   O.   R.   Yusupov,   F.   F.   Meliyev,   E.   Sh.   Eshonqulov   (2021).   “Dasturlash
asoslari”
2.   Boris   Ryabko   (1989).   "Quick   Online   Code"   (PDF)   .   Soviet   mathematics.
Dock. 39 (3): 533–537.
3.   Boris   Ryabko   (1992).   "Fast   Online   Adaptive   Code"   (PDF).   IEEE
Transactions on Information Theory. 28 (1): 1400–1404.
4.   Narasimha   Karumanchi   -   Data   structures   and   algorithms   made   easy
Copyright ©2010 by CareerMonk.com All rights reserved.
5.   Vanderbilt   University   www.dre.vanderbilt.edu/   schmidt   /   (615)   343-8197
Workshop on Algorithms and Data Structures. LNCS, Vol. 955. Springer-Verlag.
6. Pages 191–207: Conference on the Mathematics of Program Construction.
LNCS, Vol. 669. Springer-Verlag.
7. “The C++ Programming Language" Bjarne Stroustrup.
8. “Algorithms Unlocked" Thomas H. Cormen.
9. “Programming Pearls" Jon Bentley.
10. "C++ Data Science Handbook" by Jake Vander.
32