Ro'yxatga olish sanasi 19 Mart 2026
0 SotishC++ tilida aralash tipli ma’lumotlar bilan ishlash
![Eksponensial shakldagi о ‘zgarmas sonlarga misollar:
1e2; 5e+3; .25e4; 31.4e-1 .
Belgi о ‘zgarmaslar q о ‘shtirnoq (‘,’-apostroflar) ichiga olingan alohida
belgilardan tashkil topadi va u char kalit s о ‘zi bilan aniqlanadi. Belgi о ‘zgarmas
uchun xotirada bir bayt joy ajratiladi va unda butun son k о ‘rinishidagi belgining
ASCII kodi joylashadi. Quyidagilar belgi о ‘zgarmaslarga misol b о ‘ladi: ‘e’,
‘@’, ‘7’, ‘z’, ‘w’, ‘+’, ‘sh’, ‘*’, ‘a’, ‘s’.
Ayrim belgi о‘zgarmaslar ‘\’ belgisidan boshlanadi, bu belgi birinchidan, grafik
kо‘rinishga ega bо‘lmagan о‘zgarmaslarni belgilaydi, ikkinchidan, maxsus
vazifalar yuklangan belgilar – apostrof belgisi, savol belgisini (?), teskari yon
chiziq belgisini (\) va ikkita kо‘shtirnoq belgisini (“) chop qilish uchun
ishlatiladi. Undan tashqari, bu belgi orqali belgini kо‘rinishini emas, balki
oshkor ravishda uning ASCII kodi sakkizlik yoki о‘n oltilik shaklda yozish
mumkin. Bunday belgidan boshlangan belgilar escape ketma-ketliklar deyiladi.
C++ tilida qо‘shimcha ravishda wide harfli о‘zgarmaslar va kо‘p belgili
о‘zgarmaslar aniqlangan. Wide harfli о‘zgarmaslar turi milliy kodlarni belgilash
uchun kiritilgan bо‘lib, u shart kalit sо‘zi bilan beriladi, hamda xotirada 2 bayt
joy egallaydi. Bu о‘zgarmas L belgisidan boshlanadi: L’\013\022’ , L/cc’.
Kо‘p belgili о‘zgarmas turi int bо‘lib, u tо‘rtta belgidan iborat bо‘lishi
mumkin: ‘ abs’ , ‘ \001\002\003\004’.
Ikkita qо‘shtirnoq (“,”) ichiga olingan belgilar ketma-ketligi satr
о‘zgarmas deyiladi: “bu satr о‘zgarmas va uning nomi string\n”
Satr ichida escape ketma-ketligi ham ishlatilishi mumkin, faqat bu ketma-
ketlik apostrofsiz yoziladi.
Probel bilan ajratib yozilgan satrlar kompilyator tomonidan yagona satrga
ulanadi:
“satr –bu belgilar massivi” /* bu satr keyingi satrga qо‘shiladi */ “,
uning turi char[]”;
10](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_10.png?v=1)
![Bu yozuvga “ satr –bu belgilar massivi, uning turi char[]”; yozuvi bilan
ekvivalent hisoblanadi. Uzun satrni bir nechta qatorga yozish mumkin va buning
uchun qator oxirida ‘\’ belgisi qо‘yiladi.
Kо‘p miqdordagi, mantiqan bog‘langan о‘zgarmaslardan foydalanganda
sanab о‘tiluvchi turdan foydalanilgani ma’qul. Sanab о‘tiluvchi о‘zgarmaslar
enum kalit sо‘zi bilan aniqlanadi. Mazmuni bо‘yicha bu о‘zgarmaslar oddiy
butun sonlardir. Sanab о‘tiluvchi о‘zgarmaslar C++ standarti bо‘yicha butun
turdagi о‘zgarmaslar hisoblanadi. Har bir о‘zgarmasga (songa) mazmunli nom
beriladi va bu identifikatorni programmaning boshqa joylarida nomlash uchun
ishlatilishi mumkin emas. Sanab о‘tiluvchi tur qо‘yidagi kо‘rinishga ega:
enum <Sanab о‘tiladigan tur nomi> {<nom > =<qiymat >, <nom
iymat >, … <nom > =<qiymat > };
Bu yerda enum – kalit sо‘z (inglizcha enumerate – sanamoq); <Sanab
О‘tiladigan tur nomi>- о‘zgarmaslar rо‘yxatining nomi; <nom> - butun qiymatli
konstantalarning nomlari; <qiymat> shart bо‘lmagan inisializatsiya qiymati
(ifoda).
Misol uchun hafta kunlari bilan bog‘liq masala yechishda hafta kunlari
dush (dushanba), sesh (seshanba), chor (chorshanba), paysh (payshanba), juma
(juma), shanba (shanba), yaksh (yakshanba) о‘zgarmaslarini ishlatish mumkin
va ular sanab о‘tiluvchi tur yordamida bitta satrda yoziladi: enum Hafta{dush,
sesh chor, paysh, juma, shanba,yaksh};
Sanab о‘tiluvchi о‘zgarmaslar quyidagi xossaga ega: agar о‘zgarmas
qiymati kо‘rsatilmagan bо‘lsa, u oldingi о‘zgarmas qiymatidan bittaga ortiq
bо‘ladi. Kelishuv bо‘yicha birinchi о‘zgarmas qiymati 0 bо‘ladi.
§1.3. C ++ о‘zgaruvchilar
11](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_11.png?v=1)
![ustidan amallar bajarish mumkin. Qiymatlari adres bо‘lgan о‘zgaruvchilarga
kо‘rsatkich о‘zgaruvchilar deyiladi.
Kо‘rsatkich uch xil turda bо‘lishi mumkin:
- birorta obyektga, xususan о‘zgaruvchiga kо‘rsatkich;
- funksiyaga kо‘rsatkich;
- void kо‘rsatkich.
Kо‘rsatkichlarining bu xususiyatlari uning qabul qilishi mumkin bо‘lgan
qiymatlarida farqlanadi.
Kо‘rsatkichlar kо‘pincha dinamik xotira (boshqacha nomi «uyum» yoki
«heap») bilan bog‘liq holda ishlatiladi. Xotiraning dinamik deyilishiga sabab,
bu sohadagi bо‘sh xotira programma ishlash jarayonida, kerakli paytida ajratib
olinadi va zarurat qolmaganida qaytariladi (bо‘shatiladi). Keyinchalik, bu xotira
bо‘lagi programma tomonidan boshqa maqsadda yana ishlatilishi mumkin.
Dinamik xotiraga faqat kо‘rsatkichlar yordamida murojaat qilish mumkin.
Bunday о‘zgaruvchilar dinamik о‘zgaruvchilar deyiladi va ularni yashash
vaqti yaratilgan nuqtadan boshlab programma oxirigacha yoki oshkor ravishda
yо‘qotilgan (bog‘langan xotira bо‘shatilgan) joyigacha bо‘ladi.
Kо‘rsatkichlarni e’lon qilishda unga boshlang‘ich qiymatlar berish
mumkin. Boshlang‘ich qiymat (initsializator) kо‘rsatkich nomidan sо‘ng yoki
qavs ichida yoki ‘=’ belgidan keyin beriladi. Boshlang‘ich qiymatlar quyidagi
usullar bilan berilishi mumkin:
I. Kо‘rsatkichga mavjud bо‘lgan obyektning adresini berish:
a) adresni olish amal orqali:
int i =5, k =4; // butun о ‘zgaruvchilar
int * p =& i ; / / p k о ‘rsatkichga I о ‘zgaruvchining adresi yoziladi
int *p1(&k) ; // p1 k о ‘rsatkichga k о ‘zgaruvchining adresi yoziladi
b) boshqa initsializatsiyalangan k о ‘rsatkichni qiymatini berish:
int *r=p; // p oldin e’lon qilingan va qiymatga ega b о ‘lgan k о ‘rsatkich
v) massiv yoki funksiya nomini berish:
int b [10]; // massivni e’lon qilish
14](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_14.png?v=1)
![int *t=b; // massivning boshlang‘ich adresini berish
void f(int a) {/* ... */} // funksiyani aniqlash
void (*pf) (int); // funksiyaga kо‘rsatkichni e’lon qilish
pf=f; // funksiya adresini kо‘rsatkichga berish
II. Oshkor ravishda xotiraning absolyut adresini berish:
Char *vp = (char*)0xB8000000;
Bunda 0xB8000000- о‘n oltilik о‘zgarmas son va (char*) - turga keltirish amali
bо‘lib, u vp о‘zgaruvchini xotiraning absolyut adresidagi baytlarni char sifatida
qayta ishlovchi kо‘rsatkich turiga aylantirilishini anglatadi.
III. Bо‘sh qiymat berish:
int *suxx=NULL;
int *r=0;
Birinchi satrda maxsus NULL о‘zgarmasi ishlatilgan, ikkinchi satrda 0
qiymat ishlatilgan. Ikkala holda ham kо‘rsatkich hech qanday obyektga murojaat
qilmaydi. Bо‘sh kо‘rsatkich asosan kо‘rsatkichni aniq bir obyektga
kо‘rsatayotgan yoki yо‘qligini aniqlash uchun ishlatiladi.
IV. Dinamik xotirada new amali bilan joy ajratish va uni adresini
kо‘rsatkichga berish:
Xotiraning obyektlar о‘rtasidan dinamik taqsimlanuvchi sohasidan joy
ajratish uchun new operatori ishlatiladi. new operatoridan keyin xotiraga
joylashtiriladigan obyekt tipini kо‘rsatish lozim. Bu obyektni saqlash uchun
talab etiladigan xotira sohasi о‘lchovini aniqlash uchun kerak bо‘ladi. Masalan,
new unsigned short int deb yozish orqali biz dinamik taqsimlanuvchi xotiradan
ikki bayt joy ajratamiz. Xuddi shuningdek, new long satri orqali tо‘rt bayt joy
obyektlar о‘trasida dinamik taqsimlanuvchi sohadan ajratiladi.
Int *n=new int; // birinchi operator
Int *m=new int(10); // ikkinchi operator
Int *q=new int[10]; // uchinchi operator
15](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_15.png?v=1)
![butunlay mos keladi, chunki dastur ishini yakunlaguncha xotirani bu qismidan
foydalanib b о ‘lmaydi.
New va delete operatorlarining oddiy foydalanilishiga doir dastur:
#include <iostream.h>
Main (void)
{ int *p;
p=new int;
if(!p){
cout<<”xotira yetarli emas\n”;
return 1;
}
*p=20;
cout <<p<<”\n”;
delete p;
return 0;
}
Massiv uchun xotiradan dinamik joy ajratilishi uchun dastur:
#include <iostream.h>
Main (void)
{ int *p;
unsigned int size;
cout<< “Massiv о‘lchovini kiriting ”;
cin >>size;
p=new int[size];
if(!p){
cout<<”[xotira yetarli emas\n ;”
return 1;
}
for (int i=0; i<size; i++) p[i]=i*I;
inr *q=p;
17](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_17.png?v=1)
![Programmada holat yoki tushunchani tavsiflovchi har bir berilganlar
uchun alohida о‘zgaruvchi aniqlab masalani yechish mumkin. Lekin bu holda
obyekt haqidagi ma’lumotlar «tarqoq» bо‘ladi, ularni qayta ishlash
murakkablashadi, obyekt haqidagi berilganlarni yaxlit holda kо‘rish
qiyinlashadi.
C++ tilida bir yoki har xil turdagi berilganlarni jamlanmasi struktura deb
nomlanadi. Struktura foydalanuvchi tomonidan aniqlangan berilganlarning
yangi turi hisoblanadi, Struktura quyidagicha aniqlanadi:
struct <struktura nomi>
{
<tur
1 > <nom
1 >;
<tur
2 > <nom
2 >;
…
<tur
n > <nom
n >;
};
Bu yerda <struktura nomi> - struktura kо‘rinishida yaratilayotgan yangi
turning nomi, "<tur
i > <nom
i >;” – strukturaning i-maydonining (nomi) e’loni.
Boshqacha aytganda, struktura e’lon qilingan о‘zgaruvchilardan
(maydonlardan) tashkil topadi. Unga har xil turdagi berilganlarni о‘z ichiga
oluvchi qobiq deb qarash mumkin. Qobiqdagi berilganlarni yaxlit holda
kо‘chirish, tashqi qurilmalar (binar fayllarga) yozish, о‘qish mumkin bо‘ladi.
Talaba haqidagi berilganlarni о‘z ichiga oluvchi struktura turining e’lon
qilinishini kо‘raylik.
struct Talaba
{
char FISH[30];
unsigned int Tug_yil;
unsigned int Kurs;
char Yunalish[50];
float Reyting;
20](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_20.png?v=1)
![unsigned char Jinsi[5];
char Manzil[50];
bool status;
};
Programmada strukturalardan foydalanish, shu turdagi о‘zgaruvchilar
e’lon qilish va ularni qayta ishlash orqali amalga oshiriladi:
Talaba talaba;
Struktura turini e’lonida turning nomi b о ‘lmasligi mumkin, lekin bu holda
struktura aniqlanishidan keyin albatta о ‘zgaruvchilar nomlari yozilishi kerak:
struct
{
unsigned int x,y;
unsigned char Rang;
} Nuqta1,Nuqta2;
Keltirilgan misolda struktura turidagi Nuqta1, Nuqta2 о‘zgaruvchilari e’lon
qilingan.
Struktura turidagi о ‘zgaruvchilar bilan ishlash, uning maydonlari bilan
ishlashni anglatadi. Struktura maydoniga murojaat qilish ‘.’ (nuqta) orqali
amalga oshiriladi. Bunda struktura turidagi о ‘zgaruvchi nomi, undan keyin
nuqta q о ‘yiladi va maydon о ‘zgaruvchisining nomi yoziladi. Masalan, talaba
haqidagi struktura maydonlariga murojaat quyidagicha bо‘ladi:
talaba.Kurs=2;
talaba.Tug_yil_1988;
strcpy(talaba.FISH, Abdullayev A.A. );” ”
strcpy(talaba.Yunalish,
21](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_21.png?v=1)
![talaba haqidagi berilganlarni о ‘z ichiga oluvchi Talaba strukturasi turidagi
berilganlarni Talaba_Manzili() funksiyasiga parametr sifatida berish uchun
funksiya prototipi quyidagi k о ‘rinishda b о ‘lishi kerak:
void Talaba_Manzili(Talaba);
Funksiyaga strukturani argument sifatida uzatishga misol sifatidagi
programmaning matni:
#include <iostream.h>
#include <string.h>
struct Talaba
{
char FISh[30];
unsigned int Tug_yil;
unsigned int Kurs;
char Yunalish[50];
float Reyting;
unsigned char Jinsi[5];
char Manzil[50];
bool status;
};
void Talaba_Manzili(Talaba);
int main(int argc,char* argv[])
{
Talaba talaba;
talaba.Kurs=2;
talaba.tug_yil=1988;
strcpy(talaba.FISh,”Abdullayev A.A.”);
24](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_24.png?v=1)
![struktura turining nomi yoziladi. Masalan, talabalar xaqidagi berilganlarni о ‘z
ichiga olgan massiv yaratish e’loni quyidagicha b о ‘ladi:
const int n=25;
Talaba talabalar[n];
Strukturalar massivining elementlariga murojaat odatdagi massiv
elementlariga murojaat usullari orqali, har bir elementning maydonlariga
murojaat esa ‘.’ orqali amalga oshiriladi.
Quyidagi misolda talabalar guruhidagi har bir talaba berilganlarini
klaviaturadan kiritish va guruh talabalarini familiya, ismi va sharifini chop
qiladigan programma matni keltirilgan.
#include <iostream.h>
#include <conio.h>
const n=3;
struct Talaba
{
char FISh[30];
unsigned int Tug_yil;
unsigned int Kurs;
char Yunalish[50];
float Reyting;
unsigned char Jinsi[6];
char Manzil[50];
bool status;
};
void Talaba_Kiritish(Talaba t[]);
void Talaba_FISh(Talaba t[]);
int main(int argc,char* argv[])
26](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_26.png?v=1)
![{
Talaba talabalar[n];
Talaba.Kiritish(talabalar);
Talabalar.FISh(talabalar);
return 0;
}
void Talabalar_FISh(Talaba t[]);
{
for(int i=0; i<n; i++);
cout<<t[i].FISh<<end1;
}
void Talaba_Kiritish(Talaba t[]);
{
for(int i=0; i<n; i++);
{
cout<<i+1<<”- talaba ma’lumotlarini kiriting:”<<end1;
cout<<” Talaba FISh :”;
cin.getline(t[i].FISh,30);
cout<<” Kurs:”;
cin>>t[i].Kurs;
cout<<” Reyting bali:”;
cin>>t[i].Reyting;cout<<”tug’’ilgan yili:”;
cin>>t[i].Tug_yil;
cout<<”Ta’lim_yunalishi:”;
cin.getline(t[i].Yunalsh,50);
cout<<” Jinsi(erkak,ayol):”;
cin.getline(t[i].Jinsi,6);
cout<<” Yashash manzili:”;
cin.getline(t[i].Manzil,50);
}
27](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_27.png?v=1)
![}
§2. 2. Birlashmalar
Birlashmalar xotiraning bitta sohasida (bitta adres b о ‘yicha) har xil turdagi
bir nechta berilganlarni saqlash imkonini beradi.
Birlashma e’loni union kalit s о ‘zi, undan keyin identifikator va blok ichida
xar xil turdagi elementlar e’lonidan iborat b о ‘ladi, masalan:
union Birlashma
{
int n;
unsigned long N;
char Satr[10];
};
Birlashmaning bu e’lonida kompilyator tomonidan Birlashma uchun uning
ichidagi eng kо‘p joy egallovchi elementning - Satr satrining о‘lchamida, ya’ni
10 bayt joy ajratiladi. Vaqtning har bir momentida birlashmada, e’lon qilingan
maydonlarning faqat bittasining turi dagi berilgan mavjud deb hisoblanadi.
Yuqoridagi misolda, Birlashma ustida amal bajarilishida uning uchun ajratilgan
xotirada yoki int turidagi n yoki unsigned long turidagi N yoki Satr qiymati
joylashgan deb hisoblanadi.
Birlashma maydonlariga xuddi struktura maydonlariga murojaat qilgandek
‘.’ orqali murojaat qilinadi.
Strukturalardan farqli ravishda birlashma e’lonida faqat uning birinchi
elementiga boshlangich qiymat berish mumkin:
union Birlashma
{
28](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_28.png?v=1)
![int n;
unsigned long N;
char Satr[10];
}
birlashma=[25];
Bu misolda birlashmasining n maydoni boshlangich qiymat olgan
hisoblanadi.
Birlashma elementi sifatida strukturalar kelishi mumkin va ular odatda
yaxlit berilganni «bо‘laklarga» bо‘lish yoki «bо‘laklardan» yaxlit berilganni
hosil qilish uchun xizmat kiladi. Misol uchun sо‘zni baytlarga, baytlarni
tetradalarga (4 bitga) ajratish (birlashtirish) mumkin.
Quyida baytni katta va kichik yarim baytlarga ajratishda bir lashma va
strukturadan foydalanilgan programmani matni keltirilgan.
#include <iostream.h>
union BCD
{unsigned char bayt;
Struct
{unsigned char lo:4;
unsigned char hi:4;
}bin
}bcd;
int main()
{
bcd.bayt=127;
cout<<”\n Katta yarim bayt : ”<<(int)bcd.bin.hi;
cout<<”\n Kichik yarim bayt : ”<<(int)bcd.bin.lo;
return 0;
}
29](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_29.png?v=1)
![Programma bosh funksiyasida bcd birlashmasining bayt о‘lchamida bayt
maydoniga 127 qiymati beriladi va uning katta va kichik yarim baytlari chop
etiladi.
Programma ishlashi natijasida ekranga quyidagi natijalar chiqadi:
Katta yarim bayt: 7
Kichik yarim bayt: 15
Masala. Haqiqiy turdagi sonning kompyuter xotirasidagi ichki kо‘rinishini
chop qilish. Haqiqiy son float turida deb hisoblanadi va u xotirada 4 bayt joy
egallaydi (1 – ilovaga qarang). Q о ‘yilgan masalani yechish uchun birlashma
xususiyatdan foydalaniladi, ya’ni xotiraning bitta adresiga haqiqiy son va
belgilar massivi joylashtiriladi. haqiqiy son xotiraga о ‘qilib, belgilar massivining
har bir elementi-baytlarning ikkilik k о ‘rinishlari chop etiladi.
Programma matni:
#include <iostream.h>
const unsigned char bitlar_soni=7;
const unsigned char format=sizeof(float);
void Belgi_2kodi(unsigned char blg);
union Son_va_Belgi
{
float son;
unsigned char belgi[format];
};
int main()
{
Son_va_Belgi son_va_belgi
cin>> son_va_belgi.son;
30](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_30.png?v=1)
![for(int b=format-1;b>=0;b--);
Belgi_2kodi(son_va_belgi.belgi[b]);
return 0;
}
void Belgi_2kodi(unsigned char blg);
{
unsigned char 10000000=128;
for(int i=0; i<bitlaR_soni; i++);
{
if(blg&10000000)cout<<’1’;
else cout<<’0’;
blg=blg<<1;
}
cout<<’ ’;
}
Programmada Son_va_Belgi birlashmasini e’lon qilish orkali float
turidagi x о‘zgaruvchisi va 4 ta (float turi formatining baytlardagi uzunligi)
belgidan iborat belgi massivini xotiraning bitta joyiga joylashuviga erishiladi.
Bosh funksiyada birlashma turidagi, son_va_belgi uzgaruvchisi e’lon qilinadi va
uning x maydoniga klaviaturadan haqiqiy son о‘qiladi. Keyin belgilar
massividagi har bir elementning ikkilik kodi chop etiladi. Ikkilik kodni chop
etish 8 marta baytni 7 razryadidagi sonni chop etish va bayt razryadlarini bittaga
chapga surish orqali amalga oshiriladi. Shunga e’tibor berish kerakki, belgilar
massividagi elementlarning ikkilik kodlarini chop qilish о ‘ngdan chap tomonga
bajarilgan. Bunga sabab, son ichki formatidagi baytlarning xotirada «kichik bayt
- kichik adresda» qoidasiga k о ‘ra joylashuvidir.
Programmaga -8.5 soni kiritilsa, ekranda
11000001 00001000 00000000 00000000
k о ‘rinishidagi ikkilik sonlari ketma-ketligi paydo b о ‘ladi.
31](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_31.png?v=1)
![C ++ tilida foydalanuvchi tomonidan nafaqat struktura yoki birlashma
turlari, balki ayni paytda mavjud (aniqlangan) turlar asosida yangi turlarni
yaratishi mumkin.
Foydalanuvchi tomonidan aniqlanadigan tur typedef kalit s о ‘zi bilan
boshlanadi, undan keyin mavjud tur k о ‘rsatiladi va identi fikator yoziladi.
Oxirida yozilgan identifikator - yangi yaratilgan turning nomi hisoblanadi.
Masalan,
typedef unsigned char byte;
ifodasi byte deb nomlanuvchi yangi turni yaratadi va о ‘z mazmuniga k о ‘ra
unsigned char turi bilan ekvivalent b о ‘ladi. Keyinchalik, programmada
xotiradan bir bayt joy egallaydigan va [0..255] oraliqdagi qiymatlarni qabul
qiladigan byte turidagi о‘zgaruvchi (о‘zgarmaslarni) e’lon qilish mumkin:
byte c=65
byte Byte=0xFF;
Massiv k о ‘rinishidagi foydalanuvchi tomonidan aniqlanuvchi tur e’loni
quyidagicha b о ‘ladi:
typedef char Ism[30];
Ism ism;
Ism turidagi ism о ‘zgaruvchisi e’loni - bu 30 belgidan iborat massiv (satr)
e’lonidir.
Odatda yechilayotgan masalaning predmet sohasi terminlarida ishlash
uchun strukturalar qayta nomlanadi. Natijada murakkab tuzilishga ega b о ‘lgan
va zarur xususiyatlarni о ‘ziga jamlagan yangi turlarni yaratishga muvofiq,
b о ‘linadi.
Masalan, kompleks son haqidaga ma’lumotlarni о ‘z ichiga oluvchi Compex
turi quyidagicha aniqlanadi:
typedef struct
32](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_32.png?v=1)
![О‘zgargan rо‘xat elementlari ekranga chop etiladi. Programma oxirida,
Zanjirni _ Uchirish () funksiyasini chaqirish orqali rо‘yxat uchun dinamik
ravishda ajratilgan xotira bо‘shatiladi (garchi bu ishning programma tugashi
paytida bajarilishining ma’nosi yо‘ q ).
Dinamik strukturalarda о‘ zgartirishlar ( r о‘ yxatga element q о‘ shish yoki
о‘ chirish ) nisbatan kam amallarda bajarilishi , ular vositasida masalalarni
samarali yechishning asoslaridan biri hisoblanadi .
§3.2. Rо‘yxatlar, steklar va navbatlar
Ma’lumotlarning rо‘yxatli strukturasi bu о‘zaro kо‘rsatkichlar bilan
bog‘langan о‘zgaruvchilarning tо‘plamidir. Rо‘yxatli strukturaning har bir
elementi bir yoki bir nechta kо‘rsatkichlarni о‘z tarkibiga oladi.
Dastlab, dasturda ma’lumotlarning tipini aniqlash zarur, ya’ni rо‘yxatli
strukturaning elementini keltirish kerak.
Struct elem //struktura tipini aniilanishi
{ int value; //element qiymati
Elem *next; //yagona kо‘rsatkich yoki
Elem *next, *pred; //ikki kо‘rsatkich yoki
Elem *links[10]; // kо‘rsatkichning chekli soni yoki
Elem *plinks; //kо‘rsatkichlarning ixtiyoriy soni
};
Bundan tipli о‘zgaruvchining bir, ikki, 10 dan kо‘p emas va ixtiyoriy
(dinamik massiv) sondagi kо‘rsatkichlarni о‘z ichiga olishi mumkin. Lekin ...
Shunday qilib, ma’lumotlar (chiziqli rо‘yxat, daraxt, graf) bular bilan
ishlovchi funksiyaga bog‘liq.
Demak, ma’lumotlar strukturasi na faqat uning elementlari aniqlanishida
“himoya”, balki ularni qayta ishlash algoritmida ham.
Ma’lumotlarning rо‘yxatli strkuturalari odatda dinamikdir. Buning uchun
ikki sabab bor.
39](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_39.png?v=1)
![Sarlavha
joriy
Ikki bog‘lamli rо‘yxat
Ma’lumotlarning strukturasi sifatida chiziqli rо‘yxatning ketma-ketligi
rо‘yxat elementlarining xotirada fizik joylashuviga bog‘liq emas, ularning
kо‘rsatkichlar bilan bog‘lanish ketma- ketligiga bog‘liq. Xuddi shunday rо‘yxat
elementlarining nomeratsiyasi (ravamlanishi) aniqlanadi. Ruyxatdagi element
mantiqiy raqami – rо‘yxat tayyorlanish jarayonida u ega bо‘ladigan raqam.
Ketma ket kirishli ma’lumotlarning strukturali rо‘yxati. Rо‘yxatlar bilan
ishlash faqatgina kо‘rsatkichlar bilan amalga oshiriladi. Ularning har biri rо‘yxat
bо‘yicha joylashadi (element elementga qayta о‘rnatiladi), unda interpretatsiya
kо‘rsatkichi ma’nolaridan biriga ega bо‘ladi, rо‘yxatning birinchi, oxirgi, joriy,
oldingi , yangi va boshqa elementlariga. Bunda massiv va undagi indekslar bilan
analogiya о‘rinli, biroq bir shart asosida, indeks chiziqli о‘zgaradi, ixtiyoriy
emas, massivdagi tо‘ldirilgan elementlarning joriy miqdori esa alohida
о‘zgaruvchiday berilgan.
Tasvirlanishi
amallar Rо‘yxat Massiv
aniqlanish Struct list {int val,
list *next, *pred;}; Int A[100];
Int n;
Ma’lumotlarning bо‘sh
strukrura List *ph=NULL N=0;
Birinchi List *p; p=ph; Int i=0;
Keyingi p->next I+1
Oldingi p->pred I-1
Keyingiga p=p->next I++
oldingiga p=p->pred i--
41](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_41.png?v=1)
![Kо‘zdan kechirish for (p=ph; p!= NULL;
p=p->next)
… p->val… for (i=0;i<n;i++)
… A[i]…
Oxirgi p->next=NULL I=n-1
Oxirgiga for (p=ph; p ->next!=NULL;
p=p->next); I=n-1
Yangi List *q=new list;
q->val=v; int v;
Oxirgi bо‘lib kiritish for (p=ph; p ->next!=NULL;
p=p->next);
q->next=NULL; p->next=q; A[n++]=v
Birinchi bо‘lib kiritish q->next=ph; ph=q; for (i=n;i>0;i--)
A[i]=A[i-1];
A[0]=v; n++;
Rо‘yxatlarni shakllantirish usullari. Statik rо‘yxat о‘zida oddiy
о‘zgaruvchilarni ifodalaydi – elementlar rо‘yxati, ular orasidagi bog‘lanish
translyator bilan initsializatsiyalanadi. Ma’lumotlarning barcha strukturasi
dastur kodiga “tikiladi”.
Struct list
{
Int val;
List *next;
}
a={0, NULL}, b={1, &a}, c={2, &b}, *ph=&c;
Sezamizki, о‘zgaruvchilar ta’rifining shartiga kо‘ra rо‘yxat “oxiridan
boshiga qarab” yaratiladi.
Rо‘yxat massivdan olingan cheklangan miqdordagi elementga ega bо‘-
l ishi mumkin. Bog‘lanishlar dinmik о‘rnatiladi, ya’ni dastur tomonidan. Bunday
usul elementlarning fiksirlangan miqdori bir nechta turli dinamik strukturalarni
tashkil qiladi.(masalan navbatlar), ularda rо‘yxat elementlari bir strukturadan
boshqasiga kо‘chiriladi.
List A[100], *ph;
for (i=0; i<99; i++) {
A[i].next=A+i+1;
42](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_42.png?v=1)
![A[i].val=I;
A[99].next=NULL;
ph=&A[0];
Dinamik rо‘yxatda elementlar dinamik о‘zgaruvchilardir, ularning
orasidagi bog‘lanish dasturiy о‘rnatiladi.
List *ph=NULL;
For (int i=0; i<10; i++) {
List *q=new list;
q->val=I;
q->next=ph;
ph=q;}
Rо‘yxatning sarlavhasi. Dasturda rо‘yxat odatda birinchi elementga
kо‘rsatkich – sarlavha bilan beriladi. Bо‘sh rо‘yxatga NULL kо‘rsatkich mos
keladi. Rо‘yxat bilan ishlovchi funksiya, zaruriy parametrga ega bо‘lishi kerak,
ya’ni, rо‘yxat sarlavhasiga.
Void F1(list *p) {
for ( ; p!=NULL; p=p->next) puts(p->val);
}
Shunday faktni hisobga olish kerakki, Sida parametr qiymat (nusha
kо‘rinishida) bо‘yicha uzatiladi, bu usul shunday holatda о‘rinliki, u qachonki
rо‘yxatning birinchi (hisob bо‘yicha)elementi rо‘yxat bilan ishlash jarayonida
shunday qolsa. Aks holda, kо‘rsatkichni (sarlavhani) о‘zini о‘zgartirish lozim, u
quyidagicha amalga oshirilishi mumkin:
- sarlavhaning о‘zgargan qiymatini funksiya natijasi kо‘rinishida
qaytarish bilan;
- rо‘yxat sarlavhasiga kо‘rsatkich uzatish bilan (kо‘rsatkichni kо‘r-
satkichga);
- sarlavhaga havola uzatish bilan. Eslatib о‘tamizki, havola yaqqol
bо‘lmagan (mavhum) kо‘rsatkich, u obyekt sintaksisi bilan ishlashda foyda-
laniladi, u unga mos faktik parametrda “tasvirlanadi”.
43](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_43.png?v=1)
![Qо‘shish joyini qidirish birinchi elementi aniqlash bilan yakunlanadi,
beriligandan katta, yoki rо‘yxat boshiga qaytish bilan yakunlanadi. Ikkala
holatda ham joriy elementdan oldin qо‘shish joyi aniq (korrekt) tanlanadi:
birinichidan oldin qо‘yish oxirigisidan keyin qо‘shish bilan tengdir.
Stek va iavbatni bir bog‘lamli rо‘yxat orqali ifodalash. Stekni bir
bog‘lamli rо‘yxat yordamida modellashtirish mumkin, bunda birinchi elementni
chetlashtirsh sifatida POP, rо‘yxat boshiga qо‘shish sifatida esa Push
operatsiyalari amalga oshiriladi. Navbatni modellashtirish uchun rо‘yxatning
birinchi va oxirigi elementlarining ikki kо‘rsatkichi foydalaniladi. (Rо‘yxat
oxiriga tо‘g‘ridan tо‘g‘ri о‘tish uchun)
Void infoFIFO(list *ph[], int v)
{
List *p=new list;
p->val=v;
p->next=NULL;
if (ph(0)=NULL)
ph(0)=ph[1]=p;
else {
ph[1]->nest=p
ph[1]=p;
}}
Int fromFIFO(list *ph[])
{
If(ph[0]=NULL) return -1;
List *q=ph[0];
Ph[0]=q->next;
if (ph[0]=NULL) ph[1]=NULL;
int v=q->val;
delete q; return v;}
47](https://docx.uz/documents/fdce4b35-8de8-42bc-84d8-ccf88a876fae/page_47.png?v=1)
-
O'xshash dokumentlar
- Android tizimli telefonlar uchun skaner ilovasini yaratish
- Web 2.0 servislar orqali oʻquv jarayonini tashkil etish
- Elektron jadvalning vazifalari va imkoniyatlari mavzusini multimedia asosida o‘qitish
- Adobe Muse dasturi yordamida A.Oripov hayoti va ijodi mavzusida multimediali elektron resurs yaratish
- Informatika fanini o‘qitishda innovatsion ishlanmalar yaratish texnologiyasi