C++ da matritsalar ustida amallar bajaruvchi dastur ishlab chiqish
![II .Asosiy qism
Jadvallar funktsiyalar argumentlari sifatida kelganda jadvallarning birinchi
parametridan boshqa parametrining chegaralari ko’rsatilishi shartdir. Misol
tariqasida uch o’lchovli kvadrat matritsani uch o’lchovli vektorga
ko’paytirish funktsiyasini k’orib chiqamiz.
Void Umn_vec( float a[3][3],float b[3], float c[3])
{
for(I=0;i<3;++) {
c[I]=0;
for(j=0;j<3;j++)
c[I]+=a[I,j]*b[j];
};
}
Har hil chegarali jadvallar bilan funktsiyalardan foydalanishning bir yuli bu
oldindan kiritiluvchi konstantalardan foydalanishdir. Lekin asosiy yuli
ko’rsatkichlar massivlaridan foydalanish. Matritsani vektorga ko’paytirish
funktsiyasi ko’rsatkichlar massivlari yordamida qo’yidagicha yoziladi:
Void Umn_vec( int n,float* a[],float b[], float c[])
{ int I,j;
for(I=0;i
c[I]=0;
for(j=0;j
c[I]+=a[I,j]*b[j];
};
4](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_4.png?v=1)
![Matritsani matritsaga ko’paytirish funktsiyasi esa qo’yidagicha yoziladi:
Void Umn_matr( float* a[],float* b[], float* c[])
{
int I,j,k;
for(I=0;i
for(j=0;j<n;j++)
{c[I,j]=0;
for(k=0;k<n;k++)
c[I,j]+=a[I,k]*b[j,k];
};
Funktsiyalarda satrli massivlar ishlatilganda ularning chegarasini ko’rsatish
shart emas. Satrlarning uzunligini hisoblash len funktsiyasii qo’yidagicha
ta'riflash mumkin:
Int len(char c[])
{ int m=0;
for(m=0;c[m]!=’0’;m++);
return m;
};
Shu funktsiyadan foydalanilgan dasturni keltiramiz:
Include #
Int len(char c[])
{ int m=0;
while(c[m++]);
return m-1
5](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_5.png?v=1)
![}
void main()
{char e[]=”Pro Tempore!”;
Cout<<(“\n%I”,len(E));
};
PASKAL' tilida copy funktsiyasi mavjud bo’lib, berilgan satrning, berilgan
pozitsiyasidan boshlab berilgan sondagi simvollarini ajratib olishga imkon
beradi. Shu funktsiyani C++ tilida qo’yidagicha ta'riflash mumkin:
Void copy(char a[], char b[], int k, int m)
{ int l;
for(int n=0; a[n]!=’\0’;n++);
if (k>m) {b[0]=’\0’;break};
if (k+m>n) l=n-k else l=m;
for(int i=0;i
}
Berilgan satrni teskariga aylantiruvchi funktsiya:
reverse(char s[]s) /* reverse string s in place */
int c, i, j
for(i = 0, j = strlen(s) - 1; i < j; i++, j--)
c = s[i];
s[i] = s[j];
s[j] = c;
6](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_6.png?v=1)
![Keyingi misolimizda T qatorni S qator ohiriga o’lovchi STRCAT(S, T)
funktsiyasini ko’rib chiqamiz:
strcat(s,t) /* concatenate t to end of s */
char s[], t[]; /* s must be big enough */
int i, j;
i = j = 0;
while (s[i] != '\0') / *find end of s */
i++;
while((s[i++] = t[j++]) != '\0') /*copy t*/
Satrli massivlar funktsiya argumenti sifatida ishlatilganda satrlarning
umumiy uzunligi aniq ko’rsatilishi shartdir.
Misol tariqasida ihtiyoriy sondagi satrlar massivini alfavit bo’yicha tartiblash
funktsiyasidan foydalanilgan dasturni ko’rib chiqamiz :
Include
Define m 10
Void sort(int n, char a[][m]);
{char c[m];int I,l;
for (i=0;i<n;i++)
for (j=i+1;j<m;j++)
if (a[i][0]
for (l=0;l
}
Void main()
{
char aa[][m]={“Alimov”,”Dadashev”,”Boboev”};
por(3,aa);
7](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_7.png?v=1)
![for(int i=0;i<3;i++) Cout<<(“\n %s”,aa[i]);
}
Bu misolda funktsiya spetsifikatsiyasida ko’rsatish shart bo’lgan satrlar
massivining ikkinchi parametrini m konstanta orqali kiritdik.
Funktsiyada bu shartdan kutilishning eng umumiy yuli ko’rsatkichlar
massividan foydalanishdir:
Include
Void sort(int n, char* a[]);
{char* c;int I;
for (i=0;i<n;i++)
for (j=i+1;j<m;j++)
if (a[i][0]
{c=a[i];a[i]=a[j];a[j]=c;};
}
Void main()
{ char* pa[];
char aa[][3]={“Alimov”,”Dadashev”,”Boboev”};
for(int i=0;i<3;i++) pa[i]=&aa[i];
sort(3,aa);
for(int i=0;i<3;i++) Cout<<(“\n %s”,aa[i]);
}
Bu misolda shunga e'tibor berish kerakki satrli massivning tartiblanmagan
e'lementlarini almashtirish uchun qo’shimcha tsikl kiritilgan edi.
Ko’rsatkichlar massivining elementlari adreslardan iborat bo’lgani uchun,
qo’shimcha tsiklga hojat qolmadi. Ko’rsatkichlar massivini initsializatsiya
qilish. Nchi oy nomidan iborat bo’lgan simvolli qatorga ko’rsatkich
qaytaruvchi MONTH_NAME(N) funktsiyasini ko’rib chiqamiz. Bu
funktsiyada ichki statik massiv ishlatilgan bo’lib, funktsiyana murojaat
kerakli qatorga ko’rsatkich qayta oladi.
8](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_8.png?v=1)
![char *month_name(n) /* return name of n-th month */
int n;
\(
static char *name[] = \(
"illegal month",
"january",
"february",
"march",
"april",
"may",
"jun",
"july",
"august",
"september",
"october",
"november",
"december"
\);
return ((n < 1 \!\! n > 12) ? name[0] : name[n]);
\)
</m;j++)
</n;i++)
</m;j++)
</n;i++)
</n;k++)
</n;j++)
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. Misol uchun 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
9](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_9.png?v=1)
![o’lchovli va ikki o’lchovli massivlar qo’llaniladi. Bir ulchovli massivlarga
matematikada vektor tushunchasi mos keladi. 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. Misol uchun:
float C[]={1,-1,2,10,-12.5};
Bu misolda massiv chegarasi avtomatik aniqlanadi. Agar massiv initsializatsiya
qilinganda elementlar chegarasi ko’rsatilgan bo’lsa , ruyhatdagi elementlar soni
bu chegaradan kam bo’lishi mumkin, lekin ortiq bo’lishi mumkin emas. Misol
uchun int A[5]={2,-2}. Bu holda a[0] va a[1] qiymatlari aniqlangan bo’lib, mos
holda 2 va –2 ga teng.
Massivda musbat elemenlar soni va summasini hisoblash.
# include ;
# include ;
Main() {
Int x[]={-1;2;5;-4;8;9};
Clrscr();
For (int s=0,int k=0, int I=0; I<6; I++) {
If (x[I]<=0) continue;
k++;s++;
10](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_10.png?v=1)
![};
Cout<<(“%d”,k);
Cout<<(“%d”,k);
getch();
};
Massivning eng katta, eng kichik elementi va o’rta qiymatini aniqlash:
#include
Void main()
{
Int I,j,n;
Float a,b,d,x[100];
While(1)
{
Cout<<(“\n n=”); Cin>>(“%i”,&n);
If ( n>0 && n < = 100 ) break;
Cout<<(“\n Hato 0<n
}
Cout<<(“\n elementlar kiymatlarini kiriting:\n”);
For (i=0;i
{ Cout<<(“x[%i]=”,i);Cin>>(“%f”,&x[i]);}
max=x[0];min=x[0];
For (s=0,i=0;i
{ s++;
If (max
11](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_11.png?v=1)
![If (min>x[i]) min=x[i];
};
s/=n;
Cout<<(“\n max=%f”,max);
Cout<<(“\n min=%f”,min);
Cout<<(“\n urta kiymat=%f”,s);
Ikki ulchovli 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. Misol uchun ikki qator va uch ustundan iborat bo’lgan haqiqiy
tipga tegishli d massiv boshlang’ich qiymatlari qo’yidagicha 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’yhat 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.
Misol uchun: int x[3][3]={(1,-2,3),(1,2),(-4)}.
Bu yozuv qo’yidagi 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;
12](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_12.png?v=1)
![Initsializatsiya yordamida boshlang’ich qiymatlar aniqlanganda massivning
birinchi indeksi chegarasi ko’rsatilishi shart emas, lekin qolgan indekslar
chegaralari ko’rsatilishi shart.
Misol uchun:
Double x[][2]={(1.1,1.5),(-1.6,2.5),(3,-4)}
Bu misolda avtomatik ravishda qatorlar soni uchga teng deb olinadi.
Qo’yidagi ko’radigan misolimizda jadval kiritilib har bir qatorning maksimal
elementi aniqlanadi va bu elementlar orasida eng kichigi aniqlanadi:
#include
void main()
{ double a[4,3]; double s,max=0.0,min=0.0;
int 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
};
Cout<<(“\n”);
if (max
}
Cout<<(“\n min=%f”,min);
}
C ++ tilida satrlar simvolli massivlar sifatida ta'riflanadi. Simvolli massivlar
13](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_13.png?v=1)
![qo’yidagicha tasvirlanishi mumkin: Char pas[10];
Simvolli massivlar qo’yidagicha initsializatsiya qilinadi:
Char capital[]=”TASHKENT”; Bu holda avtomatik ravishda massiv elementlari
soni aniqlanadi va massiv ohiriga satr ko’chirish ‘\n’ simvoli qo’shiladi.
Yuqoridagi initsializatsiyani qo’yidagicha amalga oshirish mumkin:
Char capital[]={‘T’,’A’,’S’,’H’,’K’,’E’,’N’,’T’,’\n’};
Bu holda so’z ohirida ‘\n’ simvoli aniq ko’rsatilishi shart.
Misol uchun palindrom masalasini ko’rib chiqamiz. Palindrom deb oldidan ham
ohiridan ham bir hil o’qiladigan so’zlarga aytiladi. Misol uchun non. Dasturda
kiritilgan so’z palindrom ekanligi aniqlanadi:
#include
void main()
{
gets(a);
for( int j=0, a[j]!=’\0’;j++);
I=0;
while(I
if ((j-I)>1) Cout<<(“Palindrom emas”) else Cout<<(“Palindrom”);
Keyingi misolimizda kiritilgan so’zdan berilgan harf olib tashlash dasturi
berilgan:
#include
void main()
{
14](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_14.png?v=1)
![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);
}
Har gal 's' dan farqli simvol uchraganda , u J pozitsiyaga yoziladi va faqat
shundan so’ng J qiymati 1 ga oshadi. Bu qo’yidagi yozuvga ekvivalent:
if(s[i]!=c)
s[j]=s[i];
j++;
C ++ tilida so’zlar massivlari ikki o’lchovli simvolli massivlar sifatida
ta'riflanadi. Misol uchun:
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:
15](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_15.png?v=1)
![Char Name[3][8]={“Anvar”,”Mirkomil”,”Yusuf”}.
Bu ta'rifda har bir so’z uchun hotiradan 8 bayt joy ajratiladi va har bir so’z ohiriga
‘\0’ belgisi qo’yiladi.
So’zlar massivlari initsializatsiya qilinganda so’zlar soni ko’rsatilmasligi mumkin.
Bu holda so’zlar soni avtomatik aniqlanadi:
Char comp[][9]={“komp'yuter”,”printer”,”kartridj”}.
Quyidagi dasturda berilgan harf bilan boshlanuvchi so’zlar ruyhati bosib
chiqariladi:
#include
void main()
{ 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]);
}
Qo’yidagi dasturda fan nomi, talabalar ruyhati va ularning baholari kiritiladi.
Dastur bajarilganda ikki olgan talabalar ruyhati bosib chiqariladi:
#include
void main()
{ char a[10][10];
char s[10];
16](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_16.png?v=1)
![int k[10];
gets(s);
for (int i=0;i<10;i++) gets(a[i]);
for (i=0;i<10;i++) {Cin>>(“%d”,k[i]};
for (int i=0;i<10;i++) if (k[i]==2) puts(a[i]);
}
Ko’rsatkichlar massivlari qo’yidagicha ta'riflanadi
*[]
Misol uchun int *pt[6] ta'rif int tipidagi ob'ektlarga olti elementli massivni
kiritadi. Ko’rsatkichlar massivlari satrlar massivlarini tasvirlash uchun qulaydir.
Misol uchun familiyalar ruyhatini kiritish uchun ikki ulchovli massivdan
foydalani kerak.
char fam[][20]={“Olimov”,”Rahimov”,”Ergashev”}
Hotirada 60 elementdan iborat bo’ladi, chunki har bir familiya gacha 0 lar bilan
to’ldiriladi. Ko’rsatkichlar massivi yordamida bu massivni qo’yidagicha ta'riflash
mumkin.
Char *pf[]= {“Olimov”,”Rahimov”,”Ergashev”}.
Bu holda ruyhat hotirada 23 elementdan iborat bo’ladi, chunki har bir familiya
ohiriga 0 belgisi qo’yiladi
Ko’rsatkichlar massivlari murakkab elemenlarni sodda usulda tartiblashga imkon
beradi. Quyidagi misolda matritsa satrlari birinchi elementlari o’sishi tartibida
17](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_17.png?v=1)
![chiqariladi. Bu misolda yordamchi ko’rsatkichlar massivi yaratilib shu massiv
tartiblanadi va massiv asosida matritsa elementlari chiqariladi.
# include
void main()
{int n=2;
int m=3;
array[][3]={(1,3,5),(3,1,4),(5,7,1)};
int *pa[n];
for (I=0;I
for (I=o;I<n-1;i++)
{for (int k=I=1;k<n;k++)
if a[I][1]>a[k][1]
{ int *pp=pa[I];
pa[I]=pa[k];pa[k]=pp;};
for (I=0;I<n;i++)
{Cout<<(“\n%I”,I+1);
for (int j=0;j<magistr;j++)
Cout<<(“%I”,pa[I][j]);}
};
Ko’rsatkichlar massivlari funktsiyalarda matritsalar qiymatlarini o’zgartirish
uchun mumkin. Qo’yidagi misolda matritsani transponirlash funktsiyasi
ishlatiladi.
Void trans(int n,double *p[]);
{ double x;
18](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_18.png?v=1)
![for (int I=0;I<n-1;i++)
for (int j=I+1;j<n;j++)
{x=p[I][j];
p[I][j]=p[j][I];
p[j][I]=x;
}
};
void main()
{double a[3,3]={11,12,13,21,22,23,31,32,33};
double ptr={(double*)&a[0], (double*)&a[1], (double*)&a[2]};
int n=3;
trans(n,ptr);
for (int I=0;I<n;i++)
{Cout<<(“\n %i”,i+1);
for (int j=0;j<n;j++)
Cout<<(“\n %f”,a[I][j]);
};
Funktsiyalar va sonli massivlar.
Funktsiyalarda bir o’lchovli sonli massivlar argument sifatida ishlatilganda
ularning chegarasini ko’rsatish shart emas. Misol tariqasida n o’lchovli vektorlar
bilan bog’lik funktsiyalarni ta'riflashni ko’rib chiqamiz.
19](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_19.png?v=1)
![Vektorning uzunligini aniqlash funktsiyasi:
float mod_vec(int n,float x[])
{ float a=0;
for (int I=0;I<n;i++)
a+=x[I]*x[I];
return sqrt(double(a));
}
Ikki vektorning skalyar kupaytmasi funktsiyasi:
float scalar(int n,float x[],float y[])
{ float a=0;
for (int I=0;I<n;i++)
a+=x[I]*y[I];
return a;
}
Qo’yidagi dasturda ikki vektor orasidagi burchak kosinusini hisoblash funktsiyasi
kiritiladi va bu funktsiya yordamida berilgan vektorlar orasidagi burchak kosinusi
hisoblanadi:
#include
#include
float cosinus(int n,float x[],float y[])
{ float a=0,b=0,c=0;
for (int I=0;I<n;i++)
{ a+=x[I]*y[I];
b+=x[I]*x[I];
c+=y[I]*y[I];
}
20](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_20.png?v=1)
![return a/sqrt(double(b*c));
}
void main()
{float e[]={1,2,3};
float g[]={-1,7,4};
Cout<<(“\n%I”,cosinus(3,e,g));
}
Funktsiyalarda bir o’lchovli massivlar qaytariluvchi qiymatlar sifatida ham kelishi
mumkin. Misol uchun ikki vektor summasini hisoblovchi funktsiya protsedurani
ko’ramiz:
Void sum_vec(int n, float a,float b, float c)
{
for(int i=0;i
}
Bu funktsiyaga qo’yidagicha murojaat qilish mumkin:
Float a[]={1,-1.5,-2},b[]={-5.2,1.3,-4},c[3]; sum_vec(3,a,b,c);
Massiv qiymat qaytaruvchi funktsiya ta'rifini:
Float *sum_vec(int n,float a,float b)
{ float d[n];
for(int i=0;i
return d;
21](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_21.png?v=1)
![}
Bu funktsiyaga qo’yidagicha murojaat qilish mumkin:
Float a[]={1,-1.5,-2},b[]={-5.2,1.3,-4};float c[]=sum_vec(3,a,b);
Massivlarni tartiblash.
Keyingi misolimizda massivlarni qiymatlari o’sish tartibida joylashtirish
funktsiyasi berilgan:
Void function sort(int n, double a[])
{ int i,j; double c;
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
if (a[i]>a[j]) {c=a[i];a[i]=a[j];a[j]=c;}
Bu usulda har bir element a[0] dan boshlab keyingi hamma elementlar bilan
solishtiriladi. Biror element ko’rilayotgan a[i] dan kichik bo’lsa bu elementlar
o’rin almashtiriladi. Ohir natijada a[i] urniga i dan n gacha elementlar ichida eng
kichigi qo’yiladi.
Qo’yidagi funktsiya butun sonlar massivini Shell usuli asosida tartiblaydi. Bu
usulda oldin bir biridan uzoqda joylashgan elementlar solishtiriladi. Elementlar
orasidagi interval birgacha kamayib boradi.
shell(v, n) /* sort v[0]...v[n-1]
22](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_22.png?v=1)
![into increasing order */
int v[], n;
int gap, i, j, temp;
for (gap = n/2; gap > 0; gap /= 2)
for (i = gap; i < n; i++)
for (j=i-gap; j>=0 && v[j]>v[j+gap]; j-=gap)
temp = v[j];
v[j] = v[j+gap];
v[j+gap] = temp;
Keyingi misolimizda berilgan x qiymat tartiblangan massivda majudmi yoki
yukligini aniqlovchi funktsiyani ko’rib chiqamiz. Bu funktsiya ikkiga bo’lish
usulidan foydalanadi. Massiv elementlari o’sish tartibida joylashgan bo’lishi
kerak. Funktsiya agar x qiymat V massivda mavjud bo’lsa shu qiymat nomerini
mavjud bo’lmasa –1 ni qaytaradi.
binary(x, v, n) /* find x in v[0]...v[n-1] */
int x, v[], n;
int low, high, mid;
low = 0;
high = n - 1;
23](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_23.png?v=1)
![while (low <= high)
mid = (low + high) / 2;
if (x < v[mid])
high = mid - 1;
else if (x > v[mid])
low = mid + 1;
else /* found match */ return(mid);
return(-1);</n;j++)
</n;i++)
</n;i++)
</n;i++)
</n;i++)
</n;j++)
</n;i++)
</n;j++)
</n-1;i++)
</magistr;j++)
</n;i++)
</n;k++)
</n-1;i++)
</n
24](https://docx.uz/documents/64b8fd12-abb1-4623-b2d5-6416ab9ea1d2/page_24.png?v=1)
C++ da matritsalar ustida amallar bajaruvchi dastur ishlab chiqish