Statik massiv: goloshennya, napovnennya, vikoristannya.

.

C++ da massivlar orasidagi kundalik tekshiruvlar mavjud.

Siz chegarangizdan tashqariga chiqib, qo'shiqdagi qiymatlarni yozishingiz yoki dastur kodini kiritishingiz mumkin. Dasturchi bunday nazorat haqida biladi. .

Statik massivlardan foydalanishda muammolar paydo bo'ladi, chunki biz massiv hajmini allaqachon bilamiz.

Bir o'lchovli massiv - bu bitta nom bilan birlashtirilgan, har bir element o'z raqamiga ega bo'lgan bir xil turdagi elementlarning qat'iy soni. Massivning elementlariga kengaytirish massiv nomini va elementlarning raqamlarini kiritish orqali amalga oshiriladi.

Var a: butun sonlar massivi;

//yoki turi arr = butun sonlar massivi;

var a: arr;

Tur nomi va o'zgartirish nomi o'rtasida "ikki" belgisi qo'yiladi.

Massiv – xizmat so‘zi (ingliz tilidan tarjima qilinganda “massiv”, “yollash” degan ma’noni anglatadi);

- kvadrat qo'llar uchun birinchi elementning raqami, keyin ikki nuqtadan keyin massivning qolgan elementining raqami ko'rsatiladi; of – xizmat so‘zi (ingliz tilidan “z” dan tarjima qilingan); integer - massiv elementlarining turi.

Indeks sifatida nafaqat natural sonlardan foydalanish mumkin: biz shunday yozishimiz mumkin: , [-29..45], ['a'..'z'], - har qanday belgilar yoki raqamlardan foydalanishimiz uchun - biz mumkin. to'g'ri fikrga osongina erishing: o'ng uchun liva qismi kamroq.

Nima kamroq ekanligini bildirish uchun - do'l belgisi ('!') yoki nuqta ('.') biz ASCII jadvali va funktsiyalaridan foydalanamiz.

Bir o'lchovli massivni qanday kiritish kerak?

Bunday massiv elementlarining qiymatlarini kiritish yoki ko'rsatish uchun parametrga ega bo'lgan tsikl (yoki postum bilan yoki fikrni o'zgartirish - buyruq bilan, u tsikl bo'lsin).. i:= 1 dan N gacha o'qing(a[i]);

//de a[i] - bir o'lchovli massivning elementi

a

indeks bilan (tartib raqami); i.. N butun son va N nutq raqamlari to'plami berilgan: A 1, A 2, …, A N.

Quyidagi raqamlarni kiriting:

(A 1) N , (A 2) N−1 , …, (A N−1) 2 , A N.

//de a[i] - bir o'lchovli massivning elementi

Qadamlar sonining ortishi haqidagi hisobotda biz eng yuqori vazifa haqida gapirdik<>Var a: butun sonlar massivi;<>N, i, j, n_pow: butun son;

d, r: haqiqiy;

yozishni boshlash ("N = "); readln(N);

write("Enter", N, "butun sonlar:");

i uchun: = 1 dan N gacha o'qiladi(a[i]);

(Qadamlarga massiv elementlarini qo'shing) for i:= 1 to N do begin n_pow:= N + 1 - i;

d:=a[i];<= N) and (A < MaxN) Do {Второе условие позволяет избежать выхода из границ диапазона, если количество цифр в факториале превзойдет 300.} begin r:= 0; i:= 1; {r - перенос из разряда в разряд при выполнении умножения числа j на очередную цифру A[i] предыдущего результата.} while (i <= A) or (r <>agar n_pow mod 2 bo'lsa<>0 keyin Inc(A);(Elementlar soni ko'paygan bo'lsa, ularni o'zgartirish mumkin.) Inc(i);

oxiri; Inc(j);

oxiri; write("Faktorial:");

for i:= A pastga 1 Do Write(A[i]);(Natijani ko'rsatish) oxiri.

Xalta tanlash:

Bir o'lchovli massiv - bu hech qanday elementsiz to'liq tartiblangan.

Birinchi elementdan keyin boshqasi, ikkinchisidan keyin - uchinchi va hokazo. Indeks butun son yoki belgi bo'lishi mumkin.

Ko'pincha, biz hali ham tajovuzkor spektrdan foydalanamiz: .

Bugun hammasi shu!

Agar dastur qanday ishlashi haqida ma'lumotni allaqachon yo'qotgan bo'lsangiz, ularni sharhlardan olib tashlang.

Va juda tez orada biz massivdagi xazinalarni ko'ramiz.

Boy massivning tavsifi dasturda uning istalgan elementini indekslangan o'zgaruvchi sifatida qidirish imkonini beradi.

Indekslangan o'zgaruvchi (indeks virusi) - massivning identifikatori va teri orqasidagi element indekslari bilan massivdagi ma'lum bir elementni saqlash uchun belgilangan o'rta.

.

.

.

Si/C++ massivlarida matematik jihatdan berilgan qiymatlar uchun elementlar indekslari bittaga kam.

.

.

.

Bu holat dasturga, ayniqsa tsiklni takrorlaydigan shakllangan aqlga bog'liq bo'lishi mumkin.

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

s k-1i0

s k-1i1

s k-1ij s k-1i n-1 s k-1m-10

s k-1 m-1 1

Shunday qilib, har qanday uch o'lchovli massiv ikki o'lchovli matritsalarning (tomonlarning) bir o'lchovli massivi sifatida taqdim etiladi, ularning har biri o'ziga xos tarzda, bir o'lchovli qatorlar (qatorlar) massivi sifatida ko'riladi.

Shuningdek, n-o‘lchovli C/C++ massivi (n-1) o‘lchamli massivlar to‘plami sifatida talqin qilinadi, ular hatto kichikroq o‘lchamli massivlar to‘plami bilan ham ifodalanishi mumkin.

Indekslangan o'zgaruvchan boy dunyo massivining tuzilishi:

men qaerda - massiv identifikatori;

index_i - i-o'lchovdagi elementning sonini ko'rsatuvchi butun son konstantasi;

- teri virusiga ko'ra element indeksini almashtiring.

Shunday qilib, ilgari tasvirlangan D (20 30) massivda birinchi qatorning birinchi ustuniga qo'shilgan element d indeks ifodasi bilan belgilanadi, xuddi shu qatorning boshqa ustuni uchun - d, boshqa qatorning birinchi ustuni uchun - d, joriy – d[i][j ], qolgan ustun elementi, qolgan qator – d.

D massivdagi elementlarni identifikatsiyalashning ko'rib chiqilgan misoli mos keladigan identifikatorga tayinlangan ikki o'lchovli massivlarning har qandayiga tuziladi.

Trivariativ massivlar uchun tayinlangan elementlar xuddi shunday tarzda chiziladi.

Masalan, S(10 5 15) massivida (ilgari tasvirlangan), birinchi qator va birinchi ustunning to'ridagi birinchi tomonning elementi s indeks ifodasi bilan ko'rsatilgan, ikkinchi tomonning elementi. bir tomonning birinchi qatori s, boshqa qatorning ikkinchi tomoni birinchi oí̈ storínky – s, aniq – s[k][i][j] va qolgan ustun elementi, qolgan qator, qolgan tomoni – s.

Indeks, iste'mol uchun, arifmetik shaklda ko'rsatilishi mumkin.

Masalan, d, d[i], s, s[i].

ü Hurmat!

O'zgartirish vaqtidagi indeks qiymatlar (sug'urta) bilan bog'liq va diapazonni tavsiflovchi vazifalarga mos keladi.

Indekslangan o'zgaruvchilarni taqdim etishning ko'rib chiqilgan shakllari turli xil boy massivlardan algoritm elementlarini dasturiy amalga oshirishni amalga oshirish imkonini beradi.

Operativ xotiradagi boy massiv elementlarining uzluksiz va izchil qayta tashkil etilishi teri elementining manzilini joyida paydo bo'lishiga imkon beradi:

a = a1 + usunennya,

de a – massivning joriy oqim elementining manzillari;

a1 – massivning birinchi elementining manzillari;

usunennya - birinchi navbatda oqim elementining raqami.

Har xil o'lchamdagi massivlar uchun o'xshash usullardan foydalangan holda joy o'zgartirish ta'minlanadi.

joy almashish = indeks_1 * (siz_2 * o'lcham_3) +

Birinchi qo'shimcha ilgari joylashtirilgan tomonlardagi elementlarning sonini, ikkinchisi - oqim tomonining oldingi qatorlarida, uchinchisi - oqim tomonining oqim qatoridagi elementlarning sonini ko'rsatadi.

ü Hurmat!

Har qanday massiv uchun birinchi o'lchamning o'lchami (size_1) siljish bilan aniqlanmaydi.

Spívnomniki (size_i) vikoristovuyutsya qiymatlari sifatida massivlar ro'yxatida tayinlanadi.

Rozrhunki (n) da vikorystvuetsya hajmi,

Rozrhunki (m) da vikorystvuetsya hajmi,

Ro'yxatdagi vazifalar hajmi (maksimal qatorlar soni m max)

Kichik

9.6.

Biz haqiqiy o'lchamlarni tasvirlaymiz

Ro'yxatga kiritilgan o'lchamlar RAMdagi zaxiralar sonini ko'rsatadi.

Bunday holda, yaratilgan ikki o'lchovli massaning o'rtasi ketma-ket va chiziqli (qatorda) o'stiriladi.

Rezervasyon holatlarida tez-tez qoidabuzarliklar sodir bo'lganligi sababli (kamroq qatorlar va / yoki aktsiyadorlar bilan), keyin jamg'armasi bo'lmagan uchastkalar vikorist bo'lmaganlar bilan almashtiriladi, ularning ko'pchiligi ívtsy dozhniyu teriga buyurtma berishda sug'urta qilinishi kerak. indeks virusidagi qator.

Teri qatori elementlarining umumiy soni tavsif massivida ko'rsatilgan.

Shuning uchun o'rtadagi istalgan manzil indeks ifodasi bilan ko'rsatiladi, u o'lcham tavsifidagi yozuvlarning parametrlaridan biri sifatida ishlatiladi.

Vazifalarni dasturlashning klassik versiyasi

#o'z ichiga oladi /* Direktivlar */

#o'z ichiga oladi /* protsessor */

#o'z ichiga oladi

#define M 10 /* ortadi */

#define N 12 /* massiv o'lchamlari */

main() /* asosiy funksiya sarlavhasi */

char buf;

/*ramziy massivning tavsifi*/<= ",buf); /* запрос */

CharToOem(" m kiriting (m

printf("\n%s%d):",buf,M);

/* bu */<= ",buf); /* фактических */

scanf("%d", &m);

/* kiritish */

CharToOem(" n kiriting (n

printf("\n%s%d):",buf,N);< m; i++) /*заголовок внешнего цикла ввода x[i][j]*/

/* o'lchamlar */< n; j++) /*заголовок внутр. цикла ввода x[i][j]*/

scanf("%d", &n);

/* massivlar */

printf("n=%d m=%d", n, m);

/*massiv o‘lchamlarini ko‘rsatish*/

printf("\n%s%d):",buf,N);< m; i++)/* заголовок внешн. цикла вывода x[i][j]*/

uchun (i = 0; i< n; j++)/*заголовок внутр. цикла вывода x[i][j]*/

for(j = 0; j

printf("\n%s%d):",buf,N);< m ; i++ /*заголовок внешн. цикла расчета y[i][j]*/

/* o'lchamlar */< n; j++)/*заголовок внутр. цикла расчета y[i][j]*/

CharToOem("Qiymatni kiriting",buf);

/* kiritish */

printf("\n%s%d):",buf,N);< m ; i++)/*заголовок внешн. цикла вывода y[i][j]*/

/* o'lchamlar */< n; j++) /*заголовок внутр. цикла вывода y[i][j]*/

printf("\n %s x[%d][%d]:",buf,i+1, j+1);

/* elementlar */

scanf("%f", & x[i][j]);

/*masivu X*/

CharToOem (“X massivi”, buf);

printf("%5.2f", x[i][j]);

CharToOem (“Y massivi”, buf);

/* visnovok */

printf("\n%s\n", buf);

/*sarlavha*/

printf("%5.2f", y[i][j]);

2 3 – massivni kattalashtirish;

Qaror natijalari 9.1-ilovaga taqdim etiladi.

Grafik interfeys bilan vazifani dasturlash

Grafik interfeysni dasturlash uning rivojlanishidan oldinda.

ListBoxXi

ListBoxYi

Massivga bir qator ustunlar va qatorlarni kiritish uchun bir qatorli tahrirlash maydonlari (EditN, EditM) rejalashtirilgan.

X massiviga elementlarni kiritish uchun ko'p tartibli tahrirlash maydonidan foydalaning (EditX).

X va Y massiv elementlarini ko'rsatish ro'yxat oynasida (ListBoxXi, ListBoxYi) amalga oshiriladi.

Yechim jarayoni oynaning pastki qismida joylashgan ikkita buyruq tugmasi bilan boshqariladi.

Terining vazifalari uning nomi bilan ko'rsatilgan.

1. Buf1 va buf2 operandlari ramziy qatorlardir.

Buf1 qatori funksiyani buf2 qiymatiga o'zgartirgandan so'ng o'z qiymatini oshiradi.

2. Buf1 va buf2 qatorlarini obovyazkovaya yuvish qolipi teri belgisi “\0” bilan tugaydi.

3. Bo'shliqlar, kerak bo'lganda, qo'llab-quvvatlovchi qatorning tuzilishi (uning oldiga kiritilganlar) tomonidan shakllantiriladi.

4. Bir martalik vikoristik funksiyalar – buf1 qatorini o‘qish, keyingi qatorga buf2 qo‘shish va natijani buf1ga qo‘shish.

Shuning uchun tavsifdagi buf1 hajmi kattaroq (qo'shilgan komponentlar miqdori bo'yicha).

5. Bagatorning vicor funksiyasi - oldin olib tashlangan buf1 qatoriga ketma-ket boshqa operandni (buf2) qo'shish.

6. Yangi natija qatorini yaratish uchun funksiyadan qayta-qayta foydalanish, avvalo, funksiyaning birinchi argumentini tozalashni talab qiladi.

Variantlardan biri bo'sh qatorning buf1 qatorini belgilashdir: sprintf(buf1,"%s","");

#o'z ichiga oladi 7. Olingan qatorni orqaga qaytarish uchun qayta tekshirish tuzatishga olib kelmaydi.

8. Vikory funksiyasi arifmetik ifodaning operandi yoki mustaqil operator sifatida ishlatilishi mumkin.

str va buf ramziy qatorlarini "yopishtirish" dasturining bir qismining yashirin ko'rinishi:

/* Preprotsessor direktivasi */

char ko'chasi, buf;

/*ramziy qatorlarni tavsiflash*/

EditStr-> EditBuf->GetText(buf, 10);

#o'z ichiga oladi 7. Olingan qatorni orqaga qaytarish uchun qayta tekshirish tuzatishga olib kelmaydi.

/*EditBuf maydonidan buf kiritish*/

Tur str va buf massivlari tomonidan maksimal maksimal 25 va 10 ta belgidan iborat belgilar sifatida tavsiflanadi.

Beshinchi va oltinchi qatorlar EditStr va EditBuf maydonlaridan str va buf qatorlarini alohida kiritishni talab qiladi.

strcat operatori (str, buf);

“yopishtirilgan” qator hosil qiladi va uni str nomlari ostida saqlaydi.

Bagatorning oʻrinbosar funksiyasi buf1 oʻlchami bilan ajratilgan chegaralarda istalgan miqdordagi komponentlardan natijaviy qatorni yaratishga imkon beradi.

Tur str, buf1 va buf2 massivlarida belgilar sifatida tavsiflanadi, maksimal 25, 10 va 5 ta belgidan iborat.

Beshinchi, oltinchi va ettinchi qatorlar EditStr, EditBuf1 va EditBuf2 maydonlaridan str, buf1 va buf2 ni doimiy ravishda kiritish orqali jazolanadi. Operatorlar strcat(str, buf1);

#o'z ichiga oladi 7. Olingan qatorni orqaga qaytarish uchun qayta tekshirish tuzatishga olib kelmaydi.

ta strcat(str, buf2);

str, buf1 va buf2 dan doimiy ravishda "yopishtiruvchi" qator hosil qiladi.

/* o'lchamlar */< 5 ; j++) /* заголовок цикла ввода buf и формирования str*/

Qatorlar qatorida str nomlari mavjud.

Variant 2:

tana tsiklidagi vikoristik funktsiyalar.

char str = “ ”, buf;/* tavsifni ishga tushirish

#o'z ichiga oladi

#o'z ichiga oladi

#o'z ichiga oladi

ramziy qatorlar*/

EditBuf->GetLine (buf, 10, j);

/* buf kiriting */

strcat (str, buf);

/* str va buf chiqish qatorlarini “bir-biriga yopishtirish” uchun hosil bo‘lgan str qatorini yaratish*/

Tur str va buf massivlarini mos ravishda maksimal 50 ta belgi va 10 ta belgi sifatida tavsiflaydi va str ni bo'sh qator bilan ishga tushiradi.

Operator EditBuf->GetLine (buf, 10, j);

ko'p qatorli EditBuf maydonining j-qatoridan buf kiritilishini jazolaydi.

strcat operatori (str, buf);

tsikldagi shakllar, ketma-ket kiritilgan buf qatorlaridan qatorni “yopishadi” va ularni str nomlari ostida saqlaydi.

printf("\n%s%d):",buf,N);< m ; i++) /* заголовок внешн. цикла ввода x[i][j] */

/* o'lchamlar */< n ; j++) /* заголовок внутр. цикла ввода x[i][j] */

Rejalashtirilgan interfeys o'rnatilishini ta'minlash uchun vazifani dasturlash tugallandi.

void TSumprDlgClient::Ok()

printf("\n%s%d):",buf,N);< m; i++) /*заголовок внешн. цикла вывода x[i][j]*/

/* o'lchamlar */< n; j++)/*заголовок внутр. цикла вывода x[i][j]*/

// INSERT>> Sizning kodingiz shu yerda.

float x[M][N], y[M][N];

/* Massivlarni tavsiflash */

printf("\n%s%d):",buf,N);< m; i++)/*заголовок внешн. цикла расчета y[i][j]*/

/* o'lchamlar */< n; j++) /*заголовок внутр. цикла расчета y[i][j]*/

char buf,buf1="";

printf("\n%s%d):",buf,N);< m ; i++)/*заголовок внешн. цикла вывода y[i][j]*/

/* o'lchamlar */< n; j++)/*заголовок внутр. цикла вывода y[i][j]*/

/*ramziy massivning tavsifi*/

ListBoxYi->

ListBoxXi->ClearList();

/* Massivlarni tavsiflash */

/*ko‘rish sohasini tozalash*/

EditN->

n = atoi (buf);

/* stovptsiv massivi*/

EditM->GetText(buf, 10);

/*miqdorni kiriting*/

m = atoi (buf);

/* massivdagi satrlar */

EditX->GetLine (buf, 30, i * n + j);

Massiv element (massiv elementning ma'nosi)– xotira bo‘limida saqlanadigan, massiv o‘rtasida taqsimlangan qiymat, shuningdek, ushbu xotira bo‘limining manzili.
Massivning teri elementi uchta qiymat bilan tavsiflanadi:

• element manzili - bu element aylanadigan kob xotirasining manzili;
• element indeksi (massivdagi elementning tartib raqami);
• element qiymatlari.

Massivu manzillari - massivu kob elementining manzillari.

Massiv nomi - massiv elementlarini bo'linish uchun ishlatiladigan identifikator.

Massivning o'lchami - massivdagi elementlar soni

Element hajmi - massivning bitta elementini egallagan baytlar soni.

Kompyuter xotirasidagi massivni grafik jihatdan qayta tartiblash uzluksiz manzil sahifasiga qarash orqali amalga oshirilishi mumkin.

Indekslari 0 dan q-1 gacha boʻlgan q elementlardan iborat kichik massivni ifodalaydi.

Teri elementi kompyuter xotirasining k baytini egallaydi va elementlar xotirada ketma-ket almashtiriladi.

Massivning i-elementining manzillari qiymatlarga ega

Massiv manzillari massivning kob (nol) elementining manzilidir.

Massivdagi elementlarni ko'paytirish uchun birinchi qiymati 0 ga teng bo'lgan elementning seriya raqami (indeks) hisoblanadi.

Demak, agar massivda q element bo'lsa, u holda massiv elementlarining indekslari 0 va q-1 oralig'ida o'zgaradi.

Dovjina massivi - massivning barcha elementlarini saqlash uchun xotiraga ajratilgan baytlar soni.

Dovjina Massivu = Element hajmi * Elementlar miqdori

Massiv elementining hajmini aniqlash uchun funksiyadan foydalanishingiz mumkin
int sizeof(turi);
Masalan,
sizeof(char) = 1;

sizeof(int) = 4;

sizeof(float) = 4;

sizeof(double) = 8;

Massivlarni hayratda qoldirish va ishga tushirish

Tildagi massivni soqov qilish uchun quyidagi sintaksisdan foydalaniladi: nom turi [o'lcham] = (boshlash);

Initializatsiya - bu figurali kamarlarga tayinlangan va koma bilan ajratilgan massiv elementlarining kob qiymatlari to'plami.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // 10 ta butun sonli a massivi

Jingalak qo'llardagi boshlang'ich qiymatlar soni, massivdagi elementlar sonidan kamroq, kvadrat qo'llarda ko'rsatilganligi sababli, massivda yo'qolgan barcha elementlar (ular uchun ruxsat berish qiymati yo'q) nolga teng.

int a = (1, 2, 3, 4, 5, 6, 7, 8, 9);

Massivni elementlarga kengaytirganda, kerakli elementning indeksi kvadrat qo'llarda ko'rsatiladi.

Butt C ichida

1
2
3
4
5
6
7
8

#o'z ichiga oladi
int main()
{
int a = (5, 4, 3, 2, 1); // a massivida 5 ta element mavjud
printf("%d%d%d%d%d", a, a, a, a, a);
getchar();
qaytish 0;
}

Dastur natijasi:

Biroq, ko'pincha dasturlash jarayonida massiv elementlarining qiymatlarini ko'rsatish kerak bo'ladi.

Kimning vikoristi boshlang'ichsiz hayratda qoldirgan massaga ega.

Bunday holda, kvadrat qo'llardagi bir qator elementlarning kiritilishi bog'langan.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#o'z ichiga oladi
int main()
{
Kimning vikoristi boshlang'ichsiz hayratda qoldirgan massaga ega.
int a;
Massiv elementlarining kob qiymatlarini aniqlash uchun ko'pincha parametrik tsikl ishlatiladi:
int i;<5; i++)
{
// Massivga elementlarni kiritish
uchun (i = 0; i
}
printf("a[%d] = ", i);
int i;<5; i++)
scanf("%d", &a[i]); // Massiv elementlarini ko'rsatish
printf("%d", a[i]);
qaytish 0;
}

// Formatda bo'shliq bor

Indeks turi skalyar tartib turi yoki butun son bo'lishi mumkin (Turbo Paskal ilovalarida).

getchar();

getchar();

Vikonannya dasturining natijasi

Dunyo bo'ylab keng doiradagi hududlarga kirishingiz mumkin.

Kimning vikoristi boshlang'ichsiz hayratda qoldirgan massaga ega.

Boy massivning dumbasi matritsadir.

Boy dunyo massivining stuporining zagal shakli

nom turi[o‘lcham1][o‘lcham2]...[o‘lcham];

Boy dunyo massivining elementlari o'sib borayotgan manzilning operativ xotirasining ketma-ket qismlarida aylantiriladi.

Kompyuter xotirasida boy massivning elementlari aylantiriladi, masalan, 2 qator va 3 ustundan iborat massiv,

kelayotgan martabada xotirada retush qilinadi

Butt C ichida

1
2
3
4
5
6
7
8
9

#o'z ichiga oladi
int main()
{
Induktsiyalangan ikki o'lchovli massivdagi elementlar soni quyidagicha ko'rinadi
Qatorlar soni * Qatorlar soni = 2 * 3 = 6.
getchar();
qaytish 0;
}

Massivni ajratish uchun zarur bo'lgan xotira baytlari soni quyidagicha hisoblanadi

Butt C ichida

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Elementlar soni * Element hajmi = 6 * 4 = 24 bayt.
#o'z ichiga oladi
int main()
{
Kimning vikoristi boshlang'ichsiz hayratda qoldirgan massaga ega. Dunyoning eng boy massivlarini ishga tushirish
Ko'p o'lchovli massiv elementlarining qiymatlari, bir o'lchovli ifodada bo'lgani kabi, kamon () shaklida joylashtirilgan ustun holatida doimiy qiymatlar bilan belgilanishi mumkin.
Massiv elementlarining kob qiymatlarini aniqlash uchun ko'pincha parametrik tsikl ishlatiladi:
int i;<2; i++) Biroq, bu holda, qatorlar va ustunlardagi bir qator elementlar kvadrat qo'llarda qat'iy ravishda ko'rsatilishi mumkin.
{
int a = (1, 2, 3, 4, 5, 6);<3; j++) printf("%d%d%d\n", a, a, a);
{
Biroq, dasturlash jarayonida ko'proq boy massiv elementlarining qiymatlarini kiritish kerak bo'ladi.
Ushbu usul yordamida siz parametrik tsiklning qo'shimchalarini qo'lda tahlil qilishingiz mumkin.
}
}
printf("a[%d] = ", i);
int i;<2; i++) Biroq, bu holda, qatorlar va ustunlardagi bir qator elementlar kvadrat qo'llarda qat'iy ravishda ko'rsatilishi mumkin.
{
int a = (1, 2, 3, 4, 5, 6);<3; j++) printf("%d%d%d\n", a, a, a);
{
printf("%d", a[i][j]);
}
printf("\n"); // Yangi qatorga o'tkazildi
}
printf("%d", a[i]);
qaytish 0;
}

Massivni funktsiyaga o'tkazish

Massivlarni qayta ishlash qo'shimcha maxsus funktsiyalar yordamida qo'lda tashkil etilishi mumkin.

• Massivni funktsiya argumentlari sifatida qayta ishlash uchun siz o'tishingiz kerak
• masivu manzillari,

massivning kattaligi.

Qatorlarni qayta ishlash funktsiyalarini o'rnatish kerak, shuning uchun ularni manzilga o'tkazish kifoya.

O'zgarishlar funktsiyaga argument sifatida uzatilganda, ma'lumotlar nusxa sifatida uzatiladi.

Bu shuni anglatadiki, funktsiyaning o'rtasida parametr qiymati o'zgaradi, lekin chaqirilgan funktsiyaning o'rtasidagi qiymatda hech qanday tarzda o'zgarmaydi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

Elementlar soni * Element hajmi = 6 * 4 = 24 bayt.
#o'z ichiga oladi
Agar o'zgartirish manzili (yoki massivning manzili) funktsiyaga uzatilsa, u holda belgilangan manzilning ko'rinishi doirasidagi ma'lumotlar bilan funktsiyani o'z ichiga olgan barcha operatsiyalar dastlabki ma'lumotlarda amalga oshiriladi, keyin chiqish massivi. (yoki minnoy qiymati) qichqiruvchi funksiya tomonidan o'zgartirilishi mumkin.
Butt on C 10 ta elementdan iborat massiv berilgan.
{
Massivning maksimal va chiqish elementlarini almashtiring.
Maksimal elementni qidirish va almashish uchun funksiyadan foydalaning.
int a;
// Almashtirish funktsiyasi
bekor o'zgarish (int * x, int n)
// x - massivga ko'rsatgich (massivning manzillari)
// n - massivning o'lchami
int max, indeks; {
max = x;
{
indeks = 0;
// Maksimal elementni qidiring
}
}
uchun (i = 1; i
agar (x[i]>maks)
max = x[i];
}
indeks = i;
int main()
{
Kimning vikoristi boshlang'ichsiz hayratda qoldirgan massaga ega.
int a;
int i;<10; i++)
{
// Massivga elementlarni kiritish
uchun (i = 0; i
}
// almashish x = x;
printf("a[%d] = ", i);
int i;<10; i++)
scanf("%d", &a[i]);
getchar();
getchar();
x = maksimal;
// Bosh funktsiyasi
}
o'zgartirish (a, 10);
}
indeks = i;
int main()
{
Kimning vikoristi boshlang'ichsiz hayratda qoldirgan massaga ega. // almashish funksiyasini bosing
int a;
qaytish
Massiv elementlarining kob qiymatlarini aniqlash uchun ko'pincha parametrik tsikl ishlatiladi:
int i;<5; i++)
{
// Massivga elementlarni kiritish
uchun (i = 0; i p = p * x[i];
}
qaytish p; // 5 ta elementdan iborat bo'sh massiv a
int pr; // &a[i] - massivning i-elementining manzillari
printf("%d", a[i]);
qaytish 0;
}