Massiv elementlariga murojaat qilish uchun nomdan keyin kvadrat qavsda har bir o‘lcham uchun indeks yozilishi kerak, masalan b[i][j][k]. Bu elementga vositali murojaat ham qilish mumkin va uning variantlari:
int c[3] [3] [3]={{{0}},{{100,101},{110}} , {{200,201,202},{210,211,212},{220,221,222}};
return;
}
Dinamik massivlar bilan ishlash:[1(282-290), 3(92-95)] Statistik massivlarning kamchiliklari shundaki, ularning o‘lchami oldindan ma’lum bo‘lishi kerak, undan tashqari bu o‘lcham berilganlarga ajratilgan xotira segmentining o‘lchami bilan chegaralangan. Ikkinchi tomondan, yetarlicha katta o‘lchamdagi massiv e’lon qilib, konkret masala yechilishida ajratilgan xotira to‘liq ishlatilmasligi mumkin. Bu kamchiliklar dinamik massivlardan foydalanish orqali bartaraf etiladi, chunki ular programma ishlashi jarayonida zarur bo‘lganda kerak o‘lchamdagi massivlarni yaratish va zarurat qolmaganda yo‘qotish imkoniyatini beradi.
Dinamik massivlarga xotira ajratish uchun malloc (), calloc () funksiyalaridan yoki new operatoridan foydalanish mumkin. Dinamik obyektga ajratilgan xotirani bo‘shatish uchun free() funksiyasi yoki delete operatori ishlatiladi.
Yuqorida qayd qilingan funksiyalar alloc.h kutubxonasida joylashgan.
Malloc() funksiyasining sintaksisi
void * malloc(size_t size) ;
ko‘rinishida bo‘lib, u xotiraning uyum qismidan size bayt o‘lchamidagi uzluksiz sohani ajratadi. Agar xotira ajratish muvaffaqiyatli bo‘lsa, malloc() funksiyasi shu soha boshlanishining adresini qaytaradi. Talab qilingan xotirani ajratish muvaffaqiyatsiz bo‘lsa, funksiya NULL qiymatini qaytaradi.
Sintaksisdan ko‘rinib turibdiki, funksiya void turidagi qiymat qaytaradi. Amalda esa konkret turdagi obyekt uchun xotira ajratish zarur bo‘ladi. Buning uchun void turini konkret turga keltirish texnologiyasidan foydalaniladi. Masalan, butun turdagi uzunligi 3 ga teng massivga joy ajratishni quyidagicha amalga oshirish mumkin:
int * pInt=(int*)malloc(3*sizeof(int));
malloc() funksiyasidan farqli ravishda calloc() funksiyasi massiv uchun joy ajratishdan tashqari massiv elementlarini 0 qiymati bilan initsializatsiya qiladi. Bu funksiya sintaksisi
void * calloc (size_t num, size_t size) ;
ko’rinishda bo‘lib, num parametri ajratilgan sohada nechta element borligini, size har bir element o‘lchamini bildiradi.
Free() xotirani bo‘shatish funksiyasi o‘chiriladigan xotira bo‘lagiga ko‘rsatkich bo‘lgan yagona parametrga ega bo‘ladi:
void free (void * blok)
free() funksiyasi parametrining void turida bo‘lishi ixtiyoriy turdagi xotira bo‘lagini o‘chirish imkonini beradi.
Quyidagi programmada 10 ta butun sondan iborat dinamik massiv yaratish, unga qiymat berish va o‘chirish amallari bajarilgan.
#include
#include
int main()
{
int * pVector;
if ((pVector=(int*)malloc(10*sizeof(int)))==NULL)
{
cout<
return 1;
}
// ajratilgan xotira sohasini to‘ldirish
for(int i=0; i
// vektor elementlarini chop etish
for(int i=0; i<<*(pVector+i)<<”end1”;
// ajratilgan xotira bo‘lagini qaytarish (o‘chirish)
free (pVector) ;
return 0;
}
Keyingi programmada nxn o‘lchamli haqiqiy sonlar massivining bosh diagonalidan yuqorida joylashgan elementlar yig‘indisini hisoblash masalasi yechilgan.
#include
#include
int main()
{
int n ;
float * pMatr, s=0;
cout<
cin>>n;
if((pMatr=(float*)malloc(n*n*sizeof(float)))==NULL)
{
cout<< Xotira yetarli emas!!!”;
return 1;
}
for(int i=0; i
for(int j=0; j>*(pMatr+i*n+j);
for(int i=0; i
for(int j=i+1; j
cout<
cout<<
return 0;
}
new operatori yordamida, massivga xotira ajratishda. Obyekt turidan keyin kvadrat qavs ichida obyektlar soni ko‘rsatiladi. Masalan, butun turdagi 10 ta sondan iborat massivga joy ajratish uchun
pVector=new int[10];
ifodasi yozilishi kerak. Bunga qarama-qarshi ravishda, bu usulda ajratilgan xotirani bo‘shatish uchun
delete []pVector;
ko‘rsatmasini berish kerak bo‘ladi.
Ikki o‘lchamli dinamik massivni tashkil qilish uchun
int **a;
ko’rinishidagi «ko‘rsatkichga ko‘rsatkich» ishlatiladi.
Boshda massiv satrlari soniga qarab ko‘rsatkichlar massiviga
dinamik xotiradan joy ajratish kerak:
a=new int *[m] // bu yerda m massiv satrlari soni
Keyin, har bir satr uchun takrorlash operatori yordamida xotira ajratish va ularning boshlang‘ich adreslarini a massiv elementlariga joylashtirish zarur bo‘ladi:
for(int i=0; i
Shuni qayd etish kerakki, dinamik massivning har bir satri xotiraning turli joylarida joylashishi mumkin (7.1 va 7.3-rasmlar).
Ikki o‘lchamli massivni o‘chirishda oldin massivning har bir elementi (satri), so‘ngra massivning o‘zi yo‘qotiladi:
for (i=0;i
delete [] a [i] ;
delete [] a;
Matritsani vektorga ko‘paytirish masalasi uchun dinamik massivlardan foydalanishga misol:
void main()
{
int n,m;
int I,j; float s;
cout<>n; // matritsa satrlari soni
cout<>m; // matritsa ustunlari soni
float *b=new float[m];
float *c=new float[n];
// ko‘rsadakichlar massiviga xotira ajratish
float **a=new float *[n];
for(int i=0; i
a[i]=new float[m]; //dinamik xotira ajratish
for(j=0; j>b[j];
for(i=0; i
for(j=0;j>a[i,j];
for(i=0;i
{
for(j=0,s=0; j
c[i]=s;
}
for(i=0; i
delete[]b;
delete[]c;
for(i=0; i
delete[]a;
return;
}
Funksiya va massivlar: [3(95-100)]Funksiyalar massivni parametr sifatida ishlatishi va uni funksiyaning natijasi ko‘rinishida qaytarishi mumkin.
Agar massiv parametr orqali funksiyaga uzatilsa, elementlar sonini aniqlash muammosi tug‘iladi, chunki massiv nomidan uning uzunligini aniqlashning iloji yo‘q. Ayrim hollarda, masalan, belgilar massivi sifatida aniqlangan satr (ASCIIZ satrlar)bilan ishlaganda massiv uzunligini aniqlash mumkin, chunki satrlar ‘\0’ belgisi bilan tugaydi (8-bobga qarang).
Misol uchun:
#include
int len(char s[])//massivni parametr sifatida ishlatish
{
int m=0;
while(s[m++]);
return m-1;
}
void main()
{
char z[]=”Ushbu satr uzunligi =”;
cout<
}
Funksiya parametri satr bo‘lmagan hollarda fiksirlangan uzunlikdagi massivlar ishlatiladi. Agar turli uzunlikdagi massivlarni uzatish zarur bo‘lsa, massiv o‘lchamlarini parametr sifatida uzatish mumkin yoki bu maqsadda global o‘zgaruvchidan foydalanishga to‘g‘ri keladi.
Мисол:
#include
float sum(int n,float *x) //bu ikkinchi usul
{
float s=0;
for (int i=0; i
return s;
}
void main()
{
float E[]={1.2,2.0,3.0,4.5,-4.0};
cout<
}
Massiv nomi ko’rsatkich bo’lganligi sababli massiv elеmеntlarini funksiyada o’zgartirish mumkin va bu o’zgartirishlar funksiyadan chiqqandan kеyin ham saqlanib qoladi.
#include
void vector_01(int n,int*x,int*y) //bu ikkinchi usul
{
for (int i=0; i
y[i]=x[i]>0?1:0;
}
void main()
{
int a[]={1,2,-4,3,-5,0,4};
int c[7];
vector_01(7,a,c);
for (int i=0; i<<’\t’<
}
Masala. Butun turdagi va elеmеntlari kamaymaydigan holda tartiblangan
bir o’lchamli ikkita massivlarni yagona massivga, tartiblanish saqlangan holda birlashtirish amalga oshirilsin.
Programma matni:
#include
\\butun turdagi massivga ko’rsatkich qaytaradigan funksiya
int *massiv_ulash(int,int*,int,int*);
void main()
{
int c[]={-1,2,5,10},d[]={1,7,8};
int *h;
h=massiv_ulash(5,c,3,d);
for(int i=0;i<<’\t’<
delete[]h;
}
int *massiv_ulash(int n,int *a,int m,int *b);
{
int *x=new int[n+m];
int ia=0,ib=0,ix=0;
while (ia
a[ia]>b[ib]?x[ix++]=b[ib++]:x[ix++]=a[ia++];
while (ib
while (ia
return x;
}
Ko’p o’lchamli massivlar bilan ishlash ma’lum bir murakkablikka ega, chunki massivlar xotirada joylash tartibi turli variantda bo’lishi mumkin. Masalan, funksiya paramеtrlar ro’yxatida n×n o’lchamdagi haqiqiy turdagi x[n][n] massivga mos kеluvchi paramеtrni
float sum(float x[n][n]) ko’rinishda yozib bo’lmaydi. Muammo yechimi– bu massiv o’lchami paramеtr sifatida uzatish va funksiya sarlavhasini quyidagicha yozish kеrak:
float sum(int n,float x[][]);
Ko’p o’lchamli massivlarni paramеtr sifatida ishlatishda bir nеchta usullardan foydalanish mumkin.
1-usul. Massivning ikkinchi o’lchamini o’zgarmas ifoda (son) bilan ko’rsatish:
float sum(int n,float x[][10]);
{
float s=0.0;
for (int i=0; i
for (int j=0; j
s+=x[i][j];
return s;
}
2-usul. Ikki o’lchamli massiv ko’rsatkichlar massivi ko’rinishida aniqlangan holatlar uchun ko’rsatkichlar massivini (matrisa satrlar adrеslarini) bеrish orqali:
float sum(int ,float *p[])
{
float s=0.0;
for(int i=0;i
for(int j=0;j
s+=p[i][j]; \\”p[i][j]” emas,chunki massivga murojat
return s;
}
void main()
{
float *x[][4]={{11,12,13,14},{21,22,23,24},
{31,32,33,34},{41,42,43,44}};
float *ptr[4];
for (int=0;i
cout<
}
3-usul. Ko’rsatkichlarga ko’rsatkich ko’rinishida aniqlangan dinamik massivlarni ishlatish bilan:
float sum(int n,float **x)
{float s=0.0;
for(int i=0;i
for(int j=0;j
s+=x[i][j];
return s;}
void main()
{
float **ptr;
int n;
cin>>n;
ptr=new float *[n];
for(int i=0;i
{
ptr[i]=new float[n]
for(int j=0;j
ptr[i][j]=(float)((i+1)*10+j);
}
cout<
for(int i=0;i
delete[]ptr;
}
Navbatdagi programmada funksiya tomonidan ikki o’lchamli massivni natija sifatida qaytarishiga misol kеltirilgan. Massiv elеmеntlarning qiymatlari tasodifiy sonlardan tashkil topadi. Tasodifiy sonlar «math.h» kutubxonasidagi random() funksiya yordamida hosil qilinadi:
#include
#include
int **rmatr(int n,int m)
{int **ptr;
{ptr=new int *[n];
for(int i=0;i
{ptr[i]=new int[m];
for(int j=0;j
}
return ptr;
}
int sum(int n,int m,int **ix)
{float s=0;
for(int i=0;i
for(int j=0;j
return s;
}
void main()
{
int n,m;
cin>>n>>m;
int **matr;
randomize();
matr=rmatr(n,m);
for(int i=0;i
{cout<
{ for(int j=0;j
}
cout<
for(int i=0;i
delete[]matr;
}
2.2 Massivlarni tezkor saralash.
