logo

Dinamik massivlar va ulardan foydalanish

Загружено в:

12.08.2023

Скачано:

0

Размер:

523.830078125 KB
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];	  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:	  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]	  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.  	  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	 	
 	  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  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	  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];	  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},	  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  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);	  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.	 	
 	  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);	=	
 
  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); }	 	
 
  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:	  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:	 	
  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); }	 	
 
  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()	 	
 
  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() {	  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";	 	
    	}  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;	 	
} 	
 
 	  26	 	
 	
II.BOB. DINAMIK MASSIVLAR 	V	A	 ULARD	A	N FOYDALANISH.	 	
2.1. 	Dinamik	 massivlar	 	
 	Massivlar  uchun  asosan  dasturning  boshidanoq  ma’lum  o’lchamlar  mos 	
qo’yiladi. Masalan a{3} bir o’lchovli massivi uchun operativ xotiradan 4 ta (0,1,2,3) 
joy ajratiladi. b{2,4} ikki o’lchovli massivi uchun esa (3x5)	, ya’ni 15 ta joy ajratiladi 	
va hokazo. Lekin, ba’zida	 shunday holatlar uchraydiki	, bunda massiv elementlari soni 	
aniq  bo’lmaydi.  Agar  massiv  elementlarining  soni  aniq  bo’lmasa,  ya’ni  ular 
dasturnin	g  bajarilishi  davomida  aniqlanadigan  bo’lsa,  bunday  massivlarni  dinamik 	
massivlar  deyiladi.  Dinamik  massivlar  uchun  operativ  xotiradan  ajratiladigan  joyni 
avvaldan  bilib  bo’lmaydi.  Shuning  uchun  ular  dastur  bajarilishi  davomida  ma’lum 
qilinadi.	 	
 	Buni  oddiy	gina  bir  misol  keltirish  orqali  tushuntirishga  harakat  qilamiz. 	
Masalan,  o’quvchi  kompyuterga  so’z  kiritib,  uning  har  bir  harfini  massiv  elementi 
sifatida  xotirada  saqlamoqchi  bo’lyapti.  Buning  uchun  u  ixtiyoriy  so’zni  dasturga 
kiritadi.  Dastur  esa  uni  har	flarga  bo’laklab,  har  bir  harfni  massiv  elementi  sifatida 	
xotirada  saqlab  qolishi  kerak.  Bunda  so’zning  nechta  harfdan  iboratligi  aniq 
bo’lmaganligi uchun massiv elementlari soni ham noma’lum bo’ladi.	 	
Savol tug’iladi, u holda massiv elementlari soni qanday	 aniqlanadi?	 	
 	Dasturga kiritilgan so’zdagi harflar sonini aniqlash uchun maxsus funksiyalar 	
mavjudligini bilamiz. Xuddi shu usul orqali topilgan harflar soni massiv elementlari 
soni  hisoblanadi.  Mana  shu  misol  orqali  ko’rinib	 turibdiki	,  massiv  elementlari  soni 	
dastur bajarilishi davomida aniqlanyapti. Shu kabi hosil qilingan massivlarga dinamik 
massivlar  deyiladi.  Dinamik  massiv  elementlari  uchun  xotiradan  ajratilgan  joylar 
massiv  elementlari  bilan  ban	d  qilingan  bo’ladi  va  keyinchalik  bu  joylardan  boshqa 	
ma’lumotlar uchun foydalanishning iloji bo’lmaydi. Shuning uchun dastur davomida 
foydalaniladigan  tezkor  (operativ)  xotiradagi  joylar  hajmi  qisqaradi  va  dasturda 
xatoliklar  yuzaga  kelish  ehtimolini  oshi	radi.  Shuning  uchun  dinamik  massivlar  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;	 	
    	} 	
}  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++)	  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];	 	
    	}  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;	 	
}  31	 	
 
int main()	 	
{ 
    	int n;	 	
    	cin>>n;	 	
    	int i=2;	 	
    	while(n>1)	 	
    	{ 	
        	if(TubSon(i))	 	
        	{ 	
           	if(n%i==0)	 	
            	{ 	
            	cout<<i<<" ";	 	
            	n=n/i;	 	
            	} 	
            	else i++;	 	
        	} 	
        	else	 	
    	        	i++;	 	
    	} 	
    	return 0;	 	
} 	
2.1. 	Dinamik massivlardan foydalanib dasturlar yozish	 	
3)  Bir  o’lchamli  massiv  berilgan.  Ushbu  massivda  faqat  bir  marta  qatnashgan 
elementlar sonini aniqlab, shuncha elementdan iborat yangi massiv hosil qiling.	 	
#include <iostre	am>	 	
#include <time.h>	 	
using namespace std;	 	
int main()	 	
{  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++;	  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++;	 	
        	}  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;	 	
} 
 	  35	 	
 	
XULOSA	 	
 	Bu  kursh  ishmni  tayorlash  jarayonida  kuplam  masalalar	 va  kunksiyalar 	
kutbxonallardan  foydalandim.  C++  da  ko’pgina	 meridlar  yaniy  Massivlar	,  Dinamik 	
massivlar,  yaratish  va  ulardan  foydalanish  yullarni  kurib  ch	iqdim.	 	
Yuqori darajali dasturlash tillarini kunnan kunga har xil versialari oylap topilmoqda. 
Bundan maxsad insonlarning dastur tuzish paytida eng birinshi orinda vaqtini tejash 
undan  keyin  esa  qulaylilik  yaratish  hisoplanadi.  Bugungi  kunga  kelip  C++,  Delp	hi, 	
Pascal  dasturlash  tillari  mavjud  ekan.  Bu  dasturlash  tillari  orqali  axborot 
texnolagiyalari boyisha harqanday maumualarni hal etish mumkun. Delphi dasturlash 
tilining asosini esa Pascal dasturlash tili tashkil etar ekan. Buning sababi esa Pascal 
tilini	 takomillashtirish  bolip  hisoplanadi.  Bu  takomillashtirish  natiyjasida  esa  yangi 	
bir Delphi dasturlash tili juvudga keldi. Bu yuqori darajali dasturlash tillari ishida C++ 
dasturlash  tili  juda.	 C++  kabi  kompilyatsiya  qiluvchi  dasturlash  tillarining  afzalli	gi 	
hosil  bo’lgan  kompyuterda  kompilyatorsiz  ham  bajarilaveradi.  Interpretatsiya 
qiluvchi tillarda esa tayyor dasturni ishlatish uchun albatta mos interpretator dasturi 
talab qilinadi.  Ayrim tillaarda (masalan VISUAL BASIC) interpretator rolini dinamik 
bib	liotekalar  bajaradi.  Java  tilining  interpretatori  esa  Virtual  Mashinalar(Virtual 	
Maxine yoki VM). Virtual mashinalar sifatida odatda baruzer(Internet Explorer yoki 
Netscape)  lar  qo’llaniladi.  Ko’p  yillar  davomida  dasturlarning  asosiy  imkoniyati 
uning qisqa	ligi va tez bajarilishi bilan belgilanib kelar edi. Dasturni kichikroq qilishga 	
intilish  kompyuter  xotirasini  juda  qimmatliligi  bilan  bog’liq  bo’lsa,  uning  tez 
bajarilishiga  qiziqish  protssessor  vaqtining  qimmatbaholigiga  bog’liq  edi.  Lekin 
kompyuterlarnin	g narxi tushishi bilan dastur imkoniyatini baholash mezoni o‘zgaradi. 	
Hozirgi  kunda  dasturchining  ish  vaqti  biznesda  ishlatiladigan  ko’pgina 
kompyuterlarning  narxidan  yuqori.  Hozirda  professional  tarzda  yozilgan  va  oson 
expluatatsiya  qilinadigan  dasturlarg	a  talab  oshib  bormoqda.  Expluatatsiyaning 	
oddiyligi, konkret masalani yechish bilan bog’liq bo’lgan talabni ozroq o’zgarishiga, 
dasturni  ortiqcha  chiqimlarsiz  oson  moslashtirish  bilan  bog’liq  moslashtirish  bilan 
izohlanadi. 	  36	 	
 	
FOYDALANILGAN ADABIYOTLAR RO`YX	ATI.	 	
1.	 	A.A.  Xoidjigitov  ,  Sh.f.Madraximov,  U.E.Adamboyev  “Informatika  va 	
programmalash ”.O`quv qo`llanma, O`z.MU . 2005	-yil.	 	
2.	 	B. Straustrop. “Yazik programmirovaniya C++. ”	 Binom press	, 2006	-yil.	 	
3.	 	Qobulov “C++ tili “Toshkent nash. 2008	-yil.	 	
4.	 	Madraximov. F “C++ dasturlash tili” uslubiy qo`llanma. 2009	-yil.	 	
5.	 	Sayfiyev J.F “C++ tiliga kirish”	-uslubiy qo`llanma.Buxoro	-2005.	 	
6.	 	http	.//	www	.dastur	.uz	 	
7.	 	Жесс Либерти, “Освой  сам	остоятельно  С++ за 21 день”, Санкт Петербург 	
2000, 815 с. 	 	
8.	 	Либерти  Д.  Освой  самостоятельно  С++:  10  минут  на  урок.  Пер  с  англ. 	
Вильямс, 374 стр,2004 г. 	 	
9.	 	Шмидский Я.К. Прораммирование на языке С++: Самоучитель. 	 	
10.	 	Учебное пособие. Диалектика. 361 стр, 2004 г. 	 	
11.	 	Киммел  П., «Borland C++5» . 	 СПб.: BHV, 1997г. 	 	
12.	 	Sayfiyev J. F., «	С++  tiliga kirish», Buxoro 2004 y. 	 	
13.	 	Nazirov  Sh.  A.,  Qobulov  R.  V.,  «Ob’yektga  mo`ljallangan  dasturlash», 	
Toshkent 2006 y. 	 	
14.	 	Boltayev Sh. J., E	lov B. B., «Zmonaviy dasturlash tillari», Buxoro    2004 y. 	 	
15.	 	Elov B. E., Boltayev Sh. J., «Dasturlash texnologiyalari», Toshkent 	- 2002 y. 	 	
INTERNET SAYTLAR.	 	
1.	 	https://www	.quora.com/search?q=c%2B%2B%20is%20about%20Function	 	
2.	 	https://www.sparknotes.com/cs/c	-plus	-plus	-	
fundamentals/pointersandbasicstructures/summary/	 	
3.	 	https://favtutor.com/blogs/recursion	-cpp	 	
4.	 	https://uzbekdevs.uz/darsliklar/cpp/cpp	-da	-funksiya	 	
5.	 	http	s://www.cprogramming.com/	 	
  37

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];