Dinamik massivlar va ulardan foydalanish
![5
C++ DASTURLASH TILIDA MASSIVLAR BILAN ISHLASH.
1.1. M аssiv tushunch аsi.
Muhim so`zlar: massiv, bir o`lchovli massiv, ikki o`lchovli massiv, jadval, int,
char, float, tip, simvolli massivlar , so`zli massivlar,ko`rsatkichli massivlar.
Bilib olasiz: C++ tilida massivlarni e`lon qilish, o`zgarmas massivlar bilan ishlash,
bir va ikki o`lchovli, sim volli va so`zli, ko`rsatkichli massivlarni yaratish va
foydalanishni.
C++ tilidagi massivlar
Massiv - qo'shni xotira joylariga joylashtirilgan bir xil turdagi elementlar
to'plami bo'lib, ularni noyob identifikatorga indeks yordamida alohida havola qilis h
mumkin. int tipidagi beshta qiymatni besh xil o‘zgaruvchini e’lon qilmasdan (har biri
o‘z identifikatoriga ega) massiv sifatida e’lon qilish mumkin.
Masalan, besh elementli butun sonli foo massivi mantiqiy ravishda quyidagicha
ifodalanishi mumkin;
bu erda har bir bo'sh panel massivning elementini ifodalaydi. Bunday holda, bu int
tipidagi qiymatlardir. Bu elementlar 0 dan 4 gacha raqamlangan, 0 birinchi, 4 esa
oxirgi; C++ da massivning birinchi elementi indeksi har doim nolga
teng. Kutilgan idek, n massiv uni ishlatishdan oldin e'lon qilinishi kerak. C++ da
massiv uchun odatiy deklaratsiya:
turi nomi [elementlar];
bu erda tur to'g'ri tur (masalan, int, float ...), nom to'g'ri identifikator va elementlar
maydoni (har doim kvadrat qavs ichiga olinadi []), massiv hajmini belgilaydi.
Shunday qilib, besh turdagi elementga ega foo massivini int quyidagicha e'lon
qilish mumkin:
int foo [5];](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_5.png)
![6
Eslatma
M assivdagi elementlar sonini ifodalovchi kvadrat qavslar ichidagi [] elementlar
maydoni doimiy i foda boʻlishi kerak, chunki massivlar hajmi kompilyatsiya vaqtida
maʼlum boʻlishi kerak boʻlgan statik xotira bloklaridir.
M assivlarni ishga tushirish
Odatiy bo'lib, ishga tushirilmagan holda qoldiriladi. Bu shuni anglatadiki,
uning elementlaridan hech bi ri alohida qiymatga o'rnatilmagan; massiv e'lon qilingan
nuqtada ularning mazmuni aniqlanmagan.
Initsializator hatto hech qanday qiymatga ega bo'lmasligi mumkin, faqat qavslar:
int baz [5] = { };
Bu har biri nol qiymati bilan ishga tushirilgan beshta int qiymatli massivni yaratadi:
Biroq, massivning elementlari e'lon qilinganda, bu boshlang'ich qiymatlarni
qavslar ichiga {} qo'shish orqali aniq qiymatlarga o'rnatilishi mumkin. Masalan:
int foo [5] = {16, 2, 77, 40, 12071};
Ushbu bayonot quyidagicha if odalanishi mumkin bo'lgan massivni e'lon qiladi:
Qavslar orasidagi qiymatlar soni {} massivdagi elementlar sonidan ko'p
bo'lmasligi kerak. Masalan, yuqoridagi misolda foo 5 ta elementga ega deb e'lon
qilingan (kvadrat qavs ichiga olingan raqam bilan ko' rsatilgandek, []) va {} qavslari
har bir element uchun bittadan aniq 5 ta qiymatni o'z ichiga olgan. Agar kamroq bilan
e'lon qilingan bo'lsa, qolgan elementlar standart qiymatlariga o'rnatiladi (bu asosiy
turlar uchun ular nol bilan to'ldirilganligini bild iradi). Masalan:](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_6.png)
![7
int satri [5] = {10, 20, 30};
Quyidagi kabi massiv yaratadi:
Agar massiv uchun qiymatlarni ishga tushirish ta'minlansa, C++ kvadrat
qavslarni bo'sh qoldirish imkoniyatini beradi[]. Bunday holda, kompilyator avtomatik
ravishda {} qavs lar orasiga kiritilgan qiymatlar soniga mos keladigan massiv hajmini
qabul qiladi:
int foo [] = {16, 2, 77, 40, 12071};
Ushbu deklaratsiyadan so'ng, massiv foo beshta int uzunlikda bo'ladi, chunki biz
beshta ishga tushirish qiymatini taqdim etdik.
Nihoyat, C++ ning evolyutsiyasi universal initialization massivlar uchun ham
qabul qilinishiga olib keldi. Shuning uchun endi deklaratsiya va ishga tushiruvchi
o'rtasida tenglik belgisiga ehtiyoj qolmaydi. Bu ikkala bayonot ham ekvivalentdir:
int foo[] = {10, 20, 30 };
int foo[] {10, 20, 30};
Bu yerda n massivning soni kompilyator tomonidan n= #of
initializers/sizeof(int) formulasi yordamida hisoblanadi. Statik massivlar va
to'g'ridan -to'g'ri nomlar maydonida e'lon qilinganlar (har qanday funktsiyadan
tashqari) har d oim ishga tushiriladi. Agar aniq ishga tushiruvchi belgilanmagan bo'lsa,
barcha elementlar sukut bo'yicha ishga tushiriladi (asosiy turlar uchun nol bilan).
Massivga kirish
Massivdagi istalgan elementning qiymatlariga xuddi bir turdagi oddiy
o‘zgaruvc hining qiymati kabi kirish mumkin. Sintaksis bu:
name[index]](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_7.png)
![8
Foo 5 ta elementga ega bo'lgan va bu elementlarning har biri int turiga ega bo'lgan
oldingi misollardan so'ng, har bir elementga murojaat qilish uchun ishlatilishi
mumkin bo'lgan nom quyidagicha:
Masalan, quyidagi ibora 75 qiymatini uchinchi elementda saqlaydi foo :
foo [2] = 75;
va, masalan, quyidagi to'rtinchi element qiymatini foo x deb nomlangan o'zgaruvchiga
ko'chiradi:
x = foo[3];
foo[2] Shuning uchun yoki ifodasi foo[4] har doim int ga bahola nadi. ning uchinchi
elementi foo ko'rsatilganiga e'tibor bering foo[2] , ikkinchisi foo[1] , chunki
birinchisi foo[0] . Shuning uchun uning oxirgi elementi foo[4] . Agar biz foo[5] ni
yozsak, biz oltinchi elementga kirgan bo'lamiz foo va shuning uchun aslida mass iv
hajmidan oshib ketgan bo'lamiz.
C++ tilida massiv uchun haqiqiy indekslar oralig'idan oshib ketish sintaktik
jihatdan to'g'ri. Bu muammolarni keltirib chiqarishi mumkin, chunki diapazondan
tashqari elementlarga kirish kompilyatsiya paytida xatolikka ol ib kelmaydi, lekin ish
vaqtida xatolarga olib kelishi mumkin. Buning sababi, indeksni tekshirish dasturning
bajarilishini sekinlashtiradi. Ushbu nuqtada qavslar [] massivlar bilan bog'liq bo'lgan
ikkita foydalanishni aniq ajrata olish muhimdir. Ular ikki x il vazifani bajaradi: biri
e'lon qilinganda massivlar hajmini belgilash; ikkinchisi esa aniq massiv elementlariga
kirishda indekslarni belgilashdir. Qavslarning ushbu ikkita mumkin bo'lgan
ishlatilishini []massivlar bilan aralashtirib yubormang.
int foo[5] ; // yangi massivni e'lon qilish
foo[2] = 75; // massiv elementiga kirish.](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_8.png)
![9
Asosiy farq shundaki, deklaratsiyadan oldin elementlarning turi ko'rsatilgan, kirish
esa yo'q.
Massivlar bilan ba'zi boshqa amallar:
foo[0] = a;
foo[i] = 75;
b = foo [i+2];
foo[f oo[i]] = foo[i] + 5;
Masalan:
// massivlar misoli
#include <iostream>
std nom maydonidan foydalanish;
int foo [] = {16, 2, 77, 40, 12071};
int i, natija=0;
int main ()
{
uchun ( i=0 ; i<5 ; i++ )
{
natija += foo[i];
}
cout << natija;
qayti sh 0;
}
12206](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_9.png)
![10
1. 2. Ko'p o'lchovli massivlar
Ko'p o'lchovli massivlarni "massivlar massivlari" deb ta'riflash
mumkin. Masalan, ikki o'lchovli massivni elementlardan tashkil topgan ikki o'lchovli
jadval sifatida tasavvur qilish mumkin, ularning barc hasi bir xil turdagi elementlarga
ega.
Jadval int tipidagi 5 ta element uchun 3 tadan iborat ikki o'lchovli massivni
ifodalaydi. Buning uchun C++ sintaksisi
int Jadval [3][5];
va, masalan, ifodada ikkinchi elementga vertikal va to'rtinchi gorizontalga mu rojaat
qilish usuli quyidagicha bo'ladi:
Jadval[1][3]
(massiv indekslari har doim noldan boshlanishini unutmang).
Ko'p o'lchovli massivlar ikkita indeks (ya'ni, ikki o'lchov) bilan cheklanmaydi. Ular
kerakli indekslarni o'z ichiga olishi mumkin. Ehtiyot bo'ling: massiv uchun zarur
bo'lgan xotira miqdori har bir o'lchov bilan eksponent ravishda ortadi. Masalan:
char asr [100][365][24][60][60];
Asrdagi har bir soniya uchun char tipidagi elementga ega massivni e'lon qiladi. Bu 3
milliard chardan ko'proqni ta shkil qiladi! Shunday qilib, bu deklaratsiya 3](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_10.png)
![11
gigabaytdan ortiq xotirani iste'mol qiladi! Va bunday deklaratsiya juda mumkin emas
va bu xotira maydonidan samarasiz foydalanishni ta'kidlaydi.
Oxir -oqibat, ko'p o'lchovli massivlar dasturchilar uchun shuncha ki abstraktsiyadir,
chunki oddiy massiv bilan bir xil natijalarga uning indekslarini ko'paytirish orqali
erishish mumkin:
int Jadval [3][5]; // ga teng
int Jadval [15]; // (3 * 5 = 15)
Ko'p o'lchovli massivlardan farqi shundaki, kompilyator har bir xayo liy o'lchamning
chuqurligini avtomatik ravishda eslab qoladi. Quyidagi ikkita kod bo'lagi aynan bir
xil natijani beradi, lekin biri ikki o'lchovli massivdan, ikkinchisi esa oddiy massivdan
foydalanadi:
Ko'p o'lchovli massiv
const int WIDTH = 5;
const i nt HEIGHT = 3;
int Jadval [HEIGHT][WIDTH];
int n,m;
int main ()
{
uchun (n=0; n<BOYILIK; n++)
uchun (m=0; m<WIDTH; m++)
{
Jadval[n][m]=(n+1)*(m+1);
}
}
Psevdo -ko'p o'lchovli massiv](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_11.png)
![12
const int WIDTH = 5;
const int HEIGHT = 3;
int J adval [HEIGHT * WIDTH];
int n,m;
int main ()
{
uchun (n=0; n<BOYILIK; n++)
uchun (m=0; m<WIDTH; m++)
{
Jadval[n*WIDTH+m]=(n+1)*(m+1);
}
}
Yuqoridagi ikkita kod parchalarining hech biri ekranda hech qanday natija bermaydi,
lekin ik kalasi ham jimmy deb nomlangan xotira blokiga quyidagi tarzda qiymatlarni
tayinlaydi:
E'tibor bering, kod to'g'ridan -to'g'ri raqamli qiymatlarni ishlatish o'rniga, kenglik va
balandlik uchun nomlangan konstantalardan foydalanadi. Bu kodni yaxshiroq o'qis h
imkonini beradi va koddagi o'zgarishlarni bir joyda osongina qilish imkonini beradi.
Foydalanuvchidan ikki o'lchovli massivni kiritish uchun loopdan foydalanish
int mat[3][5], qator, kol;
uchun (qator = 0; qator < 3; qator++)
uchun (col = 0; col <5; co l++)
cin >> mat[satr][col];](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_12.png)
![13
Massivlar parametr sifatida
Ikki o'lchovli massivlar funksiyaga parametr sifatida uzatilishi mumkin va ular
havola orqali uzatiladi. Bu funksiya o'tgan massiv tarkibiga bevosita kirishi va
o'zgartirishi mumkinligi ni anglatadi. Ikki o'lchovli massivni rasmiy parametr sifatida
e'lon qilganda, biz birinchi o'lchamning o'lchamini tashlab qo'yishimiz mumkin, lekin
ikkinchisini emas; ya'ni ustunlar sonini ko'rsatishimiz kerak. Masalan:
void print(int A[][3],int N, int M)
Ushbu funktsiyaga o'tish uchun massiv quyidagicha e'lon qilinadi:
int arr[4][3];
biz shunday qo'ng'iroq yozishimiz kerak:
print(arr);
Mana to'liq misol:
#include <iostream>
std nom maydonidan foydalanish;
bekor chop etish(int A[][3],int N, int M)
{
uchu n (R = 0; R < N; R++)
uchun (C = 0; C < M; C++)
cout << A[R][C];
}
int main ()
{
int arr[4][3] ={{12, 29, 11},
{25, 25, 13},](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_13.png)
![14
{24, 64, 67},
{11, 18, 14}};
chop etish (arr,4,3);
qaytish 0 ;
}
Muhandislar matritsalarni ifodalash uchun ikki o'lchovli massivlardan
foydalanadilar. Ikki A va B matritsalarining yig'indisini topadigan funktsiyaning kodi
quyida ko'rsatilgan.
Ikki matritsaning yig'indisini topish funktsiyasi
bekor qoʻshimcha(int A[][20], int B[][20],int N, int M)
{
uchun (int R=0;R<N;R++)
for(int C=0;C<M;C++)
C[R][C]=A[R][C]+B[R][C];
}
A matritsaning transpozitsiyasini aniqlash funktsiyasi
void Transpose(int A[][20], int B[][20],int N, int M)
{
for(int R=0;R<N ;R++)
for(int C=0;C<M;C++)
B[R][C]=A[C][R];
}
Massivlar parametr sifatida
Bir nuqtada biz massivni funktsiyaga parametr sifatida o'tkazishimiz kerak
bo'lishi mumkin. C++ tilida massiv bilan ifodalangan xotira blokini to‘g‘ridan -to‘g‘ri](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_14.png)
![15
argument sifatida funksiyaga o‘tkazish mumkin emas. Lekin uning o'rniga o'tishi
mumkin bo'lgan narsa uning manzilidir. Amalda, bu deyarli bir xil ta'sirga ega va bu
juda tez va samaraliroq operatsiya. Massivni funksiya parametri sifatida qabul qilish
uchun paramet rlarni massiv turi sifatida e’lon qilish mumkin, lekin massivning
haqiqiy hajmini hisobga olmaganda, bo‘sh qavslar bilan. Masalan:
bekor qilish tartibi (int arg[])
int Bu funksiya chaqirilgan "massiv" tipidagi parametrni qabul qiladi arg . Ushbu
funktsiyaga o'tish uchun massiv quyidagicha e'lon qilinadi:
int myarray [40];
shunday qo'ng'iroq yozish kifoya:
protsedura (myarray);
Bu erda sizda to'liq misol bor:
Kod
// massivlar parametr sifatida
#include <iostream>
std nom maydonidan foydalanish;
void bosma massiv (int arg[], int uzunlik) {
uchun (int n=0; n<uzunlik; ++n)
cout << arg[n] << ' ';
cout << ' \n';
}
int main ()
{
int firstarray[] = {5, 10, 15};
int secondarray[] = {2, 4, 6, 8, 10};
bosma massiv (birinchi qator, 3);](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_15.png)
![16
bosma mas siv (ikkinchi qator, 5);
}
Yechim
5 10 15
2 4 6 8 10
Yuqoridagi kodda birinchi parametr ( int arg[] ) uzunligi qanday bo'lishidan
qat'i nazar, elementlari int tipidagi har qanday massivni qabul qiladi. Shuning uchun
biz funktsiyaga birinchi parametr s ifatida o'tadigan har bir massivning uzunligini
bildiruvchi ikkinchi parametrni kiritdik.
Funktsiya deklaratsiyasiga ko'p o'lchovli massivlarni kiritish ham
mumkin. Uch o'lchovli massiv parametri formati:
tayanch_turi[][chuqurlik][chuqurlik]
Masalan, argu ment sifatida ko'p o'lchovli massivga ega bo'lgan funksiya quyidagicha
bo'lishi mumkin:
bekor qilish tartibi (int myarray[][3][4])
E'tibor bering, birinchi qavslar []bo'sh qoldirilgan, keyingilari esa tegishli
o'lchamlar uchun o'lchamlarni belgilaydi. Bu kompilyator har bir qo'shimcha
o'lchamning chuqurligini aniqlay olishi uchun kerak. Bir ma'noda, massivni argument
sifatida o'tkazish har doim o'lchovni yo'qotadi. Buning sababi shundaki, tarixiy
sabablarga ko'ra massivlarni to'g'ridan -to'g'ri nusxalash mu mkin emas va shuning
uchun haqiqatan ham uzatilgan narsa ko'rsatkichdir. Bu yangi boshlanuvchi
dasturchilar uchun keng tarqalgan xatolar manbai. Garchi keyingi bobda
tushuntirilgan ko'rsatkichlarni aniq tushunish ko'p yordam beradi.](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_16.png)
![17
1.3. Bir o`lchovli ma ssivlar.
Massiv bu bir tipli nomerlangan ma`lumotlar jamlanmasidir. Massiv indeksli
o`zgaruvchi tushunchasiga mos keladi. Massiv ta`riflanganda tipi, nomi va indekslar
chegarasi ko`rsatiladi. Masalan, long int a[5]; char w[200]; double f[4][5][7];
char[7] [200]. Massiv indekslar har doim 0 dan boshlanadi. C ++ tili standarti bo`yicha
indekslar soni 31 tagacha bo`lishi mumkin, lekin amalda bir o`lchovli va ikki
o`lchovli massivlar qo`llaniladi. Bir o`lchovli massivlarga matematikada vektor
tushunchasi mos ke ladi. Massivning int z[3] shakldagi ta`rifi, int tipiga
tegishli z[0],z[1],z[2] elementlardan iborat massivni aniqlaydi. Massivlar
ta`riflanganda initsializatsiya qilinishi , ya`ni boshlang`ich qiymatlarlari ko`rsatilishi
mumkin. Masalan, float C[]={1, -1,2,10, -12.5}; Bu misolda massiv chegarasi
avtomatik aniqlanadi. Agar massiv initsializatsiya qil inganda elementlar chegarasi
ko`rsatilgan bo`lsa , ro`yxatdagi elementlar soni bu chegaradan kam bo`lishi mumkin,
lekin ortiq bo`lishi mumkin emas. Masalan, int A[5]={2, -2}. Bu holda a[0] va a[1]
qiymatlari aniqlangan bo`lib, mos holda 2 va –2 ga teng.
49 -listing. Massivda musbat elementlar soni va summasini hisoblash Output:
# include ;
# include ;
void main() {
int x[]={ -1;2;5; -4;8;9};
clrscr();
for (i nt s=0,int k=0, int I=0; I<6; I++) {
if (x[I]<=0) continue;
k++;s++; };
cout<<(“%d”,k); =](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_17.png)
![18
cout<<(“%d”,k);
getch(); };
Massivning eng katta , kichik elementi va o`rta qiymatini aniqlash Output :
#include
void main()
{ int I,j,n;
Float a,b,d,x[100];
While(1) {
cout<<(“ \n n=”); cin>>(n);
If ( n>0 && n < = 100 ) break;
cout<<(“ \n Hato 0<n<="" p=""></n
cout<<(“ \n elementlar qiymatlarini kiriting: \n”);
For (i=0;i<="" p="">
{ cout<<(“x[“,i,”]=”); cin >>(x[i]);}
max=x[0];min=x[0];
For (s=0,i=0;i<="" p="">
{ s++;
If (max
If (min>x[i]) min=x[i]; };
s/=n;
cout<<(“ \n max=”,max);
cout<<(“ \n min=”,min);
cout<<(“ \n o`rta qiymat=”,s); }](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_18.png)
![19
Jadvallar. Ikki o`lchovli massivlar matematikada matritsa yoki jadval
tushunchasiga mos keladi. Jadvallarning initsializatsiya qilish qoidasi , ikki o`lchovli
massivning elementlari massivlardan iborat bo`lgan bir o`lchovli massiv ta`rifiga
asoslangandir. Masalan , ikki qator va uch ustundan iborat bo`lgan haqiqiy tipga
tegishli d massiv boshlang`ich qiymatlari quyidagicha ko`rsatilishi mumkin:
float d[2][3]={(1, -2.5,10),( -5.3,2,14)};
Bu yozuv quyidagi qiymat berish operatorlariga mosdir:
d[0][0]=1;d[0][1]= -2.5;d[0 ][2]=10;d[1][0]= -5.3;d[1][1]=2;d[1][2]=14;
Bu qiymatlarni bitta ro`yxat bilan hosil qilish mumkin:
float d[2][3]={1, -2.5,10, -5.3,2,14};
Initsializatsiya yordamida boshlang`ich qiymatlar aniqlanganda massivning hamma
elementlariga qiymat berish shart emas. Masalan,
int x[3][3]={(1, -2,3),(1,2),( -4)}
Bu yozuv quyidagi qiymat berish operatorlariga mosdir:
x[0][0]=1;x[0][1]= -2;x[0][2]=3;x[1][0]= -1;x[1][1]=2;x[2][0]= -4;
Initsializatsiya yordamida boshlang`ich qiymatlar aniqlanganda massivning
birinchi indeksi ch egarasi ko`rsatilishi shart emas, lekin qolgan indekslar chegaralari
ko`rsatilishi shart. Masalan,
Double x[][2]={(1.1,1.5),( -1.6,2.5),(3, -4)}
Bu misolda avtomatik ravishda qatorlar soni uchga teng deb olinadi. Quyidagi
ko`radigan misolimizda jadval kirit ilib har bir qatorning maksimal elementi
aniqlanadi va bu elementlar orasida eng kichigi aniqlanadi:
51 -listing. Output:](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_19.png)
![20
#include
void main()
{ double a[4,3]; double s ,max=0.0,min=0.0;
in t i,j;
for(i=0;i<4;i++) {
for(j=0;j<3;j++)
{ cout<<(“ a[%d][%d]=”,i,j);cin>>(“%f”,s);a[i,j]=s;
if (max<="" p="">
cout<<(“ \n”);
if (max<="" p="">
cout<<(“ \n min=%f”,min); }
Simvolli massivlar. C++ tilida satrlar simvolli massivlar sifatida ta`riflanadi .
Simvolli massivlar quyidagicha tasvirlanishi mumkin: Char pas[10]; Simvolli
massivlar quyidagicha initsializatsiya qilinadi: Char capital[]=”Buxoro”; Bu holda
avtomatik ravishda massiv elementlari soni aniqlanadi va massiv oxiriga satr
ko`chirish ` \n` si mvoli qo`shiladi. Yuqoridagi initsializatsiyani quyidagicha amalga
oshirish mumkin:
Char capital[]={`B`,`U`,`X`,`O`,`R`,`O`,` \n`};
Bu holda so`z oxirida ` \n` simvoli aniq ko`rsatilishi shart. Masalan, palindrom
masalasini ko`rib chiqamiz. Palindrom deb old idan ham oxiridan ham bir xil
o`qiladigan so`zlarga aytiladi. Masalan, non. Dasturda kiritilgan so`z palindrom
ekanligi aniqlanadi:](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_20.png)
![21
52 -listing. Output:
#include
void main() {
gets(a);
for( int j=0, a[j]!=` \0`;j++);
I=0;
while(I<="" h5="">
if ((j -I)>1) c out<<(“Palindrom emas”) else cout<<(“Palindrom”);
Keyingi misolimizda kiritilgan so`zdan berilgan harf olib tashlash dasturi berilgan:
53 -listing.
Output:
#include
void main() {
char s[];
int c;
gets(a);
int i, j;
for ( i = j = 0; s[i] != ` \0`; i++ )
if ( s[i] != c )
s[j++] = s[i];
s[j] = ` \0`;
puts(s); }](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_21.png)
![22
Har gal `s` dan farqli simvol uchraganda , u J pozitsiyaga yoziladi va faqat shundan
so`ng J qiymati 1 ga oshadi. Bu quyidagi yozuvga ekvivalent:
if ( s[i] != c )
s[j] = s[i];
j++;
So`zlar mass ivlari. C ++ tilida so`zlar massivlari ikki o`lchovli simvolli
massivlar sifatida ta`riflanadi. Masalan,
Char Name[4][5]
Bu ta`rif yordamida har biri 5 ta harfdan iborat bo`lgan 4 ta so`zli massiv kiritiladi.
So`zlar massivlari qo`yidagicha initsializatsiya qilinishi mumkin:
Char Name[3][8]={“Anvar”,”Mirkomil”,”Yusuf”}
Bu ta`rifda har bir so`z uchun xotiradan 8 bayt joy ajratiladi va har bir so`z oxiriga
`\0` belgisi qo`yiladi. So`zlar massivlari initsializatsiya qilinganda so`zlar soni
ko`rsatilmasligi mumk in. Bu holda so`zlar soni avtomatik aniqlanadi:
Char comp[][9]={“komp`yuter”,”printer”,”kartridj”}
Quyidagi dasturda berilgan harf bilan boshlanuvchi so`zlar ro`yxati bosib
chiqariladi:
54 -listing.
Output:
#include
void main()](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_22.png)
![23
{ char a[10][10];
char c ;
for (int i=0;i<10;i++) gets(a[i]);
c=getchar();
for (i=0;i<10;i++) if (a[i][0]==c) puts(a[i]); }
Quyidagi dasturda fan nomi , talabalar ro`yxati va ularning baholari kiritiladi.
Dastur bajarilganda ikki olgan talabalar ro`yxati bosib chiqariladi:
Massiv bu bizlarga qanchalik kerak ekanligini his qilishimiz zarur hisoblanadi.
Massiv - bir xil ma'lumot turiga ega bo'lib bir nechta o'zgaruvchini har biri ni alohida
e'lon qilish o'rniga. Bir o'zgaruvchiga bir nechta qiymat saqlash uchun ishlatiladi.
Massiv e'lon qilishda o'zgaruvchi turini aniqlang va shu bilan birga unga
saqlanadigan element turlarini aniqlang.
string massiv[4];
Endi biz to'rta qiymat ni o'ziga saqlash uchun mujjallangan massivni e'lon
qildik. unga qiymat yuklash uchun qiymatlarni virgul bilan ajratib figurniy qavus
ichida yoziladi. Quyidagiga e'tibor bering.
string massiv[4] = {"Master", "Sherkulov", "CPP", "course"};
Uchta butun son dan iborat qator yaratish uchun siz quyidagicha yozingiz zarur
bo'ladi.
int myNum[3] = {913, 15, 96};
Eslatma: Massiv indekslari 0 dan boshlanadi: [0] birinchi element. [1] ikkinchi
element va boshqalar.
#include <iostream>
#include <string>
using namespac e std;
int main() {](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_23.png)
![24
string massiv[4] = {"Master", "Sherkulov", "CPP", "course"};
cout << massiv[0];
return 0;
}
Master
Massiv elementini o'zgartirish. Muayyan bir elementni o'zgartirish uchun siz
massiv elementining indeks raqamiga murojaat qilib o'zgart irish imkoniyatiga ega
bo'lasiz.
#include <iostream>
#include <string>
using namespace std;
int main() {
string massiv[4] = {"Master", "Sherkulov", "CPP", "course"};
massiv[0] = "Farrukh";
cout << massiv[0];
return 0;
}
Massiv elementlari alohid a chiqarish. Massiv elementlarini alohida chiqarish
uchun for tskil yoki boshqa takrorlash operatorlaridan foydalanishingiz mumkin.
Esdan chiqarmang massiv lar bilan ishlashda ko'pinchi for tsikl dan foydalanishingiz
maqsadga muoffiq hisoblanadi.
#include <iostream>
#include <string>
using namespace std;
int main() {
string massiv[4] = {"Master", "Sherkulov", "CPP", "course"};
for(int i = 0; i < 4; i++) {
cout << massiv[i] << " \n";
}](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_24.png)
![25
return 0;
}
Quyidagi misol har bir element indeksini uning qiymati bilan birga chiqaradi:
#include <iostr eam>
#include <string>
using namespace std;
int main() {
string massiv[4] = {"Master", "Sherkulov", "CPP", "course"};
for(int i = 0; i < 4; i++) {
cout << i << ": " << massiv[i] << " \n";
}
return 0;
}
Massiv elementlari qiymatlarini kir itish!
#include <iostream>
#include <string>
using namespace std;
int main() {
string massiv[4];
for(int i = 0; i < 4; i++) {
cin >> massiv[i];
}
return 0;
}](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_25.png)
![27
foydalanib bo’lingach o’chirib tashlanadi. Shunda dasturda uchrashi mumkin bo’lgan
xatoliklarning oldi olingan bo’ladi. Bu orqali xotiradan unumli foydalaniladi ,
xotiradagi birorta ham joy bekorchi ma’lumotlar bilan band qilinmaydi va dasturning
imkon qadar optimal ishlashi ta’mi nlanadi.
Funksiyalarga massivlarni uzatish
1) Funksiyaga char turidagi satrlarni uzatish . 3 ta matn berilgan. Ushbu matndagi
so’zlar miqdorini aniqlash funksiyasini yozing.
#include <iostream>
#include <string.h>
using namespace std;
int WordCount(char S[])
{
int k=1;
if(strlen(S)==0)
return 0;
for(int i=0; i<strlen(S);i++ )
if(S[i]==' ')
k++;
return k;
}
int main()
{
char S[100];
for(int i=1; i<=3; i++)
{
cout<<"1 -matnni kiriting: ";
cin.getline(S,100);
cout<<i<<" -matnda "<<WordCount(S)<<" ta so'z bor"<<endl;
}
}](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_27.png)
![28
2) N ta elementdan iborat massiv berilgan. Ushbu massivning elementlari
yig’indisini topish funksiyasini yozing.
#include <iostream>
#include <string.h>
using namespace std;
int Summa(int n, int *A)
{
int S=0;
for(int i=0; i<n; i++)
{
S+=A[i];
}
return S;
}
int main()
{
int n;
cin>>n;
int *A = new int[n];
for(int i=0; i<n; i++)
cin>>A[i];
cout<<Summa(n, A);
return 0;
}
3) K ta massiv berilgan. Har bir massivning eng katta elementlarini topib
beruvc hi funksiya yozing.
#include <iostream>
#include <string.h>
using namespace std;
int MaxMassiv(int n, int *A)
{
int max1=A[0];
for(int i=1; i<n; i++)](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_28.png)
![29
{
if(max1<A[i])
max1=A[i];
}
return max1;
}
int main()
{
int K ;
cout<<"K="; cin>>K;
int n; //Massiv elementlari soni
for(int i=1; i<=K; i++)
{
cout<<i<<" -massiv elementlari soni:"; cin>>n;
int *A = new int[n];
for(int j=0; j<n; j++)
{
cin>>A[j];
}
cout<<i<<" -massiv eng katta elementi: "<<MaxMassiv(n,A)<<endl;
delete[] A;
}
return 0;
}
4) N ta elementdan iborat massiv berilgan. Ushbu massivning elementlarini k
marta oshiradigan funksiya yozing
#include <iostream>
#include <str ing.h>
using namespace std;
void MultiArray(int n, int *A, int k)
{
for(int i=1; i<n; i++)
{
A[i]=k*A[i];
}](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_29.png)
![30
}
int main()
{
int n, k;
cout<<"n="; cin>>n;
int *A=new int [n];
cout<<"k="; cin>>k;
for(int i=0; i<n; i++)
{
cin>>A[i];
}
cout<<"Dastlabki massiv:"<<endl;
for(int i=0; i<n; i++)
{
cout<<A[i]<<" ";
}
cout<<endl;
MultiArray(n, A, k);
cout<<"Keyingi massiv:"<<endl;
for(int i=0; i<n; i++)
{
cout<<A[i ]<<" ";
}
return 0;
}
//N sonini tub ko’paytuvchilarga ajratish
#include <iostream>
using namespace std;
bool TubSon(int k)
{
int S=0;
for(int i=1; i<=k; i++)
if(k%i==0)
S++;
if(S==2)
return true;
else return false;
}](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_30.png)
![32
int n;
cin>>n;
int A[n], n1=0, k=0;
srand(time(NULL));
for(int i=0; i<n; i++)
{
if(A[i]==A[j])
k++;
}
if(k==1)
{
cout<<A[i]<<" ";
n1++;
}
k=0;
}
cout<<n1<<" ta";
int *B = new int[n1];
return 0;
}
2. M assivning barcha tub son bo’lgan elementlarini yangi massivga yozing.
#include <iostream>
#include <time.h>
using namespace std;
bool TubSon(int a)
{
int S=0;
for(int i=1; i<=a; i++)
if(a%i==0)
S++;](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_32.png)
![33
if(S==2)
return true;
else
return false;
}
int main()
{
int n;
cin>>n;
int A[n], a, n1=0;
srand(time(NULL));
for(int i=0; i<n; i++)
{
A[i]=rand()%100;
cout<<A[i]<<" ";
a=A[i];
if(TubSon(a))
n1++;
}
cout<<endl;
int *B = new int[n1];
int j=0;
for(int i=0; i<n; i++)
{
a=A[i];
if(TubSon(a))
{
B[j]=A[i];
j++;
}](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_33.png)
![34
}
for(int i=0; i<n1; i++)
cout<<B[i]<<" "; return 0; }
Ikki o’lchamli dinamik massivlarni e’lon qilish
#include <iostream>
#include <string.h>
using namespace std;
int main()
{
int M; //satrlar soni
int N; //ustunlar soni
int i, j;
int** matrix;
cin >> M;
cin >> N;
matrix = new int*[M] ;
for ( i = 0; i < M; i++)
matrix[i] = new int[N];
for ( i = 0; i < M; i++) // kiritish
for ( j = 0; j < N; j++)
{
cout << "Inter element " << "[" << i << "][" << j << "] ";
cin >> matrix[i][j];
}
cout << endl;
for ( i = 0; i < M; i++)
for ( j = 0; j < N; j++)
{
cout << matrix[i][j];
}
cout << endl;
}](/data/documents/3bd9a958-1e98-4ad7-85fa-ac8d1e88c225/page_34.png)
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 XAKIMOV AZIZJON ning DASTURLASH ASOSLARI VA TILLARI FANIDAN “D inamik massivlar va u lardan foydalanish ” mavzusida KURS ISHI Bajardi: Xakimov.A.K Tekshirdi: dots. F.M.Nazarov. SAMARQAND – 2022
2 MUNDARIJA KIRISH ................................ ................................ ................................ ....................... 3 I.BOB. C++ DASTURLASH TILIDA MASSIVLAR BILAN ISHLASH . .......... 5 1.1. M аssiv tushunch аsi. ................................ ................................ ............................. 5 1. 2. Ko'p o'lchovli massivlar ................................ ................................ ..................... 10 1.3. Bir o`lchovli massivlar. ................................ ................................ ...................... 17 II.BOB. DINAMIK MASSIVL AR V A ULARD A N FOYDALANISH. ............. 26 2.1. Dinamik massivlar ................................ ................................ .............................. 26 2.1. Dinamik massivlardan foydalanib dasturlar yozish ................................ ........... 31 XULOSA ................................ ................................ ................................ .................. 35 FOYDALANILGAN ADABIYOTLAR RO`YXATI . ................................ .......... 36 INTERNET SAYTLAR. ................................ ................................ ......................... 36
3 K IR ISH K еyingi yillarda amaliy dasturchilarga juda kup int еgratsion dastur tuzish muhitlari taklif etilayapti. Bu muhitlar u yoki bu imkoniyatlari bilan bir -biridan farq qiladi. Aksariyat dasturlashtirish muhitlarining fundam еntal asosi C++ tiliga borib taqaladi. Biz ushbu mavzuda quyidagi savollarga javob olamiz.Nima uchun C++ tili dasturiy mahsulotlarni ishlab chiqish sohasida standart bulib qoldi? C++ tilida dastur ishlab chiqishni qanday uziga xos tomonlari bor? C++ tilida das tur qanday yoziladi va kompilyatsiya qilinadi? C++ tili tarixi.Birinchi el еktron hisoblash mashinalari paydo b ўlishi bilan dasturlash tillari evolyutsiyasi boshlanadi. Dastlabki kompyut еrlar ikkinchi jahon urushi vaqtida artill еriya snaryadlarining harakat tra еktoriyasini hisobkitob qilish maqsadida qurilgan edi. Oldin dasturch ilar eng sodda mashina tilini uzida ifodalovchi kompyut еr komandalari bilan ishlaganlar. Bu komandalar nol va birlardan tashkil topgan uzun qatorlardan iborat bular edi. K еyinchalik, insonlar uchun tushunarli bulgan mashina komandalarini uzida saqlovchi (m asalan, ADD va MOV komandalari) ass еmbl еr tili yaratildi. Shu vaqtlarda BASIC va COBOL singari yuqori sathli tillar ham paydo buldiki, bu tillar tufayli suz va gaplarning mantiqiy konstruktsiyasidan foydalanib dasturlash imkoniyati yaratildi. Bu komanda larni mashina tiliga int еrpr еtatorlar va kompilyatorlar kuchirar edi. Int еrpr еtator dasturni o`qish jarayonida uning komandalarini k еtma - kеt mashina tiliga utkazadi. Kompilyator esa yaxlit programma kodini biror bir oraliq forma - ob' еkt fay liga utkazadi. Bu bosqich kompilyatsiya bosqichi d еyiladi. Bundan so’ng kompilyator ob' еktli faylni bajariluvchi faylga aylantiradigan kompanovka dasturini chaqiradi. Int еrpr еtatorlar bilan ishlash osonroq, chunki dastur komandalari qanday k еtma - kеtlikda yozilgan bulsa shu tarzda bajariladi. Bu esa dastur bajarilishini nazorat qilishni osonlashtiradi. Kompilyator esa kompilyatsiya va kompanovka kabi qushimcha bosqichlardan iborat bulganligi uchun ulardan hosil bo’ladigan bajariluvchi faylni tahli l qilish va uzgartirish imkoniyati mavjud emas. Faqatgina kompilyatsiya qilingan fayl t еzroq bajariladi, chunki bundagi komandalar kompilyatsiya jarayonida mashina tiliga utkazilgan buladi. C++ kabi kompilyatsiya
4 qiluvchi dasturlash tillarini yana bir a fzalligi hosil bulgan dastur kompyut еrda kompilyatorsiz ham bajarilav еradi. Int еrpr еtatsiya hiluvchi tillarda esa tayyor dasturni ishlatish uchun albatta mos int еrpr еtator dasturi talab qilinadi. Dasturlar aniqlovchi suz, ham yaxlit holdagi bajariluv chi dasturiy mahsulotni b еlgilovchi suz sifatida ishlatiladi. Bu ikki xillik uquvchini chalg’itishi mumkin. Shuning uchun unga aniqlik kiritamiz. D еmak dasturni yo dasturchi tomonidan yoziladigan komandalar tuplami, yoki amallar bajaradigan kompyut еr ma hsuloti sifatida tushunish mumkin. C++ sistemasi asosan quyidagi qismlardan iborat. Bular dasturni yozish redaktori, C++ tili va standart kutubhonalardir. C++ dasturi ma'lum bir fazalardan o'tadi. Dasturchilar oldida turgan masalalar Vaqt o`tish i bilan dasturchilar oldiga quyilgan masalalar o`zgarib boryapti. Bundan yigirma yil oldin dasturlar katta hajmdagi ma'lumotlarni qayta ishlash uchun tuzilar edi. Bunda dasturni yozuvchi ham, uning foydalanuvchisi ham kompyut еr sohasidagi bilimlar buyicha prof еssional bulishi talab etilardi. hozirda esa kupgina uzgarishlar ruy b еrdi. ompyut еr bilan kuproq uning apparat va dasturiy ta'minoti, haqida tushunchalarga ega bulmagan kishilar ishlashyapti. Kompyut еr odamlar tomonidan uni, chuqur urganish vositasi emas, kuproq uzlarining oldilariga quyilgan, uzlarining ishlariga t еgishli bulgan muammolarini еchish instrum еnti bulib qoldi. Foydalanuvchilarning ushbu yangi avlodini dasturlar bilan ishlashlarini osonlashtirilishi bilan bu dasturlarning uzini murakkabligi darajasi oshadi. Zamonaviy dasturlar - foydalanuvchi bilan do’stona munosabatni yuqori darajada tashkil qiladigan kup sondagi oynalar, m еnyu, muloqot oynalari va vizual grafikaviy muhitlardan tarkib topgan int еrfеysga e ga bulishi lozim. Dasturlashga talabni uzgarishi nafaqat tillarning uzgarishiga balki uni yozish tеxnologiyasini ham uzgarishiga olib k еldi. Dasturlash evolyutsiyasi tarixida kupgina bosqichlar bulishiga qaramay biz bu kursimizda prots еdurali dasturlashdan ob' еktlarga muljallangan dasturlashga utishni qaraymiz.
5 C++ DASTURLASH TILIDA MASSIVLAR BILAN ISHLASH. 1.1. M аssiv tushunch аsi. Muhim so`zlar: massiv, bir o`lchovli massiv, ikki o`lchovli massiv, jadval, int, char, float, tip, simvolli massivlar , so`zli massivlar,ko`rsatkichli massivlar. Bilib olasiz: C++ tilida massivlarni e`lon qilish, o`zgarmas massivlar bilan ishlash, bir va ikki o`lchovli, sim volli va so`zli, ko`rsatkichli massivlarni yaratish va foydalanishni. C++ tilidagi massivlar Massiv - qo'shni xotira joylariga joylashtirilgan bir xil turdagi elementlar to'plami bo'lib, ularni noyob identifikatorga indeks yordamida alohida havola qilis h mumkin. int tipidagi beshta qiymatni besh xil o‘zgaruvchini e’lon qilmasdan (har biri o‘z identifikatoriga ega) massiv sifatida e’lon qilish mumkin. Masalan, besh elementli butun sonli foo massivi mantiqiy ravishda quyidagicha ifodalanishi mumkin; bu erda har bir bo'sh panel massivning elementini ifodalaydi. Bunday holda, bu int tipidagi qiymatlardir. Bu elementlar 0 dan 4 gacha raqamlangan, 0 birinchi, 4 esa oxirgi; C++ da massivning birinchi elementi indeksi har doim nolga teng. Kutilgan idek, n massiv uni ishlatishdan oldin e'lon qilinishi kerak. C++ da massiv uchun odatiy deklaratsiya: turi nomi [elementlar]; bu erda tur to'g'ri tur (masalan, int, float ...), nom to'g'ri identifikator va elementlar maydoni (har doim kvadrat qavs ichiga olinadi []), massiv hajmini belgilaydi. Shunday qilib, besh turdagi elementga ega foo massivini int quyidagicha e'lon qilish mumkin: int foo [5];