Vul een tweedimensionale matrix in c met rangtelwoorden. Statische array: aangifte, vulling, gebruik. Hoeveel geheugen is toegewezen aan de array

laat een reactie achter 6,950

secties: Computertechnologie

Thema: Tweedimensionale arrays. Een tweedimensionale array vullen volgens een bepaalde regel.

doelen: om de vaardigheden uit te werken van het werken met elementen van een tweedimensionale array, leren hoe je tweedimensionale arrays vult volgens een bepaalde regel, leren hoe je de relatie tussen het rijnummer en het kolomnummer kunt afleiden; ontwikkeling van het logisch denken van studenten.

PROCES VAN DE LES

1. Kennis bijwerken

Arrays, de positie van elementen waarin wordt beschreven door twee indices, worden tweedimensionaal genoemd. De structuur van zo'n array kan worden weergegeven door een rechthoekige matrix. Elk element van de matrix wordt uniek geïdentificeerd door de rij- en kolomnummers, rijnummer - i, kolomnummer - j aan te geven.
Beschouw een n * m matrix A:

een 11 een 12 een 13 een 14
een 21 een 22 een 23 een 24
een 31 een 32 een 33 een 34

Matrix van 3 rijen en 4 kolommen, aantal rijen n = 3, aantal kolommen m = 4. Elk element heeft zijn eigen nummer, dat uit twee cijfers bestaat: het nummer van de regel waarin het element zich bevindt en het kolomnummer. A23 is bijvoorbeeld het item in de tweede rij en derde kolom.
Een tweedimensionale array in Turbo Pascal-taal kan op verschillende manieren worden beschreven. Om een ​​tweedimensionale array te beschrijven, is het noodzakelijk om te bepalen welk type van zijn elementen en hoe ze zijn genummerd (welk type is de index). Er zijn verschillende manieren om een ​​tweedimensionale array te beschrijven.

Const maxN = ...; (Maximale waarden voor het aantal regels)
maxM = ...; (Maximale waarden voor het aantal kolommen)

1 manier

Type Mas = array van<тип элементов>; (Eendimensionale matrix)
Type TMas = array van Mas; (Eendimensionale array, waarvan de elementen eendimensionale arrays zijn)

2 wegen

Type TMas = array of array of<тип элементов>;
(Eendimensionale array, waarvan de elementen eendimensionale arrays zijn)

3 manier

Type<имя типа>= reeks van<тип элементов>; (Tweedimensionale matrix)

De voorkeur gaat uit naar de derde manier om een ​​tweedimensionale array te beschrijven.

Bijvoorbeeld:

Const N = 3; M = 4;
Typ TMas = array van geheel getal; (Tweedimensionale reeks gehele getallen)

Een tweedimensionale array kan op vier manieren worden gevormd: invoer vanaf het toetsenbord, via een generator voor willekeurige getallen, volgens een bepaalde regel of met behulp van een bestand.

1) Vorming van een tweedimensionale array met behulp van toetsenbordinvoer en een algoritme voor regel-voor-regel-uitvoer van matrixelementen.

Const N = 10, M = 10;
Typ Tmas = matrix van geheel getal;
Var A: Tmas; i, j: geheel getal;
Beginnen
(Matrixelementen invoeren)
Voor i: = 1 tot N do
Voor j: = 1 tot M do
Lees een);
(Uitvoer van matrixelementen)
Voor i: = 1 tot N beginnen
Voor j: = 1 tot M do
Schrijf (A: 4); (De eerste regel wordt afgedrukt)
Writeln (regeleinde)
einde;
Einde.

2) Een fragment van het programma voor het vormen van een tweedimensionale array via een generator voor willekeurige getallen.

Beginnen
Willekeurig maken; (De generator voor willekeurige getallen initialiseren)
(Matrixelementen invoeren)
Voor i: = 1 tot N do
Voor j: = 1 tot M do
A: = willekeurig (45) -22;

2. Nieuw materiaal leren. Een array vullen volgens de regel

Laten we eens kijken naar verschillende fragmenten van programma's voor het vullen van een tweedimensionale array volgens een bepaalde wet. Om dit te doen, moet u de vulregel afleiden.

1. Vul de array A van grootte n * m als volgt, bijvoorbeeld:

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

De array wordt gevuld volgens het "slangen" principe. Vulregel: als het regelnummer een oneven getal is, dan is A = (i-1) * m + j, anders A = i * m-j + 1.

programma M1A;

n, m, i, j: geheel getal;
beginnen
lees (n, m);
voor i: = 1 tot n beginnen
voor j: = 1 tot m do
beginnen
als ik mod 2 = 1 dan
A = (i-1) * m + j
anders
A = ik * m-j + 1;
schrijf (A: 3);
einde;
schrijven;
einde;
lees;
einde.

Hier is een voorbeeld van een programma voor een andere vulmethode volgens een bepaalde regel:

programma M1B;
var A: matrix van geheel getal;
n, m, i, j: geheel getal;
c: geheel getal;
beginnen
lees (n, m);
c: = 1;
voor i: = 1 tot n do
beginnen
voor j: = 1 tot m do
beginnen
een: = c;
als (i mod 2 = 0) en (j<>m) dan
december (c)
anders
inclusief (c);
schrijf (A: 3);
einde;
c: = c + m-1;
schrijven;
einde;
lees;
einde.

2. Vul de array A volgens het volgende principe:

1 0 2 0 3 0 4
0 5 0 6 0 7 0
8 0 9 0 10 0 11
0 12 0 13 0 14 0

programma M2;
var A: matrix van geheel getal;
n, m, i, j: geheel getal;
c: geheel getal;
beginnen
lees (n, m);
c: = 0;
voor i: = 1 tot n do
beginnen
voor j: = 1 tot m do
beginnen
als (i-1 + j) mod 2 = 0 dan
EEN: = 0
anders
beginnen
inclusief (c);
een: = c;
einde;
schrijf (A: 5);
einde;
schrijven;
einde;
lees;
einde.

3. Vul de array A volgens het volgende principe:

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

var A: matrix van geheel getal;
n, m, i, j: geheel getal;
c: geheel getal;
beginnen
lees (n, m);
c: = 1;
voor j: = 1 tot m do
beginnen
voor i: = 1 tot n do
beginnen
een: = c;
als (j mod 2 = 0) en (i<>n) dan
december (c)
anders
inclusief (c);
einde;
c: = c + n-1;
einde;
voor i: = 1 tot n do
beginnen
voor j: = 1 tot m do
schrijf (A: 5);
schrijven;
einde;
lees;
einde.

4. Vul de array A volgens het volgende principe:

1 2 3 4 5
2 3 4 5 1
3 4 5 1 2
4 5 1 2 3
5 1 2 3 4

var i, j, m, c, d: geheel getal;

beginnen
c: = 1;
lees (m);
voor j: = 1 tot m do
beginnen
ik: = c;
d: = 1;
herhalen
een: = d;
incl. (ik);
als ik> ben dan
ik: = 1;
inclusief (d);
totdat ik = c;
december (c);
als c<= 0 then
c: = m-c;
einde;
voor i: = 1 tot m do
beginnen
voor j: = 1 tot m do
schrijf (A: 2);
schrijven;
einde;
einde.

5. Vul array A volgens het volgende principe:

1 0 0 0 1
0 1 0 1 0
0 0 1 0 0
0 1 0 1 0
1 0 0 0 1

var m, i, j: geheel getal;
A: array van geheel getal;
beginnen
lees (m);
voor i: = 1 tot m do
beginnen
voor j: = 1 tot m do
beginnen
als (i = j) of (m-i + 1 = j) dan
EEN: = 1
anders
EEN: = 0;
schrijf (A: 2);
einde;
schrijven;
einde;
einde.

3. Taken voor onafhankelijke oplossing

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

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

0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0

4) Vul de array als volgt:

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

5) Vul de array als volgt:

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

Huiswerk:

1) Vul de array als volgt:

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

2) Vul de array als volgt:

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

3) Vul de array als volgt:

0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0

Bij het oplossen van problemen met een grote hoeveelheid gegevens van hetzelfde type, bemoeilijkt het gebruik van variabelen met verschillende namen, niet geordend op geheugenadressen, het programmeren. In dergelijke gevallen gebruikt C objecten die arrays worden genoemd.

Is een aaneengesloten stuk geheugen dat een reeks objecten van hetzelfde type bevat, aangeduid met één naam.

De array wordt gekenmerkt door de volgende basisconcepten:

Matrixelement (waarde matrixelement)- de waarde die is opgeslagen in een specifieke geheugenlocatie binnen de array, evenals het adres van deze geheugenlocatie.
Elk element van de array wordt gekenmerkt door drie waarden:

  • elementadres - het adres van de initiële geheugencel waarin dit element zich bevindt;
  • de index van het element (het volgnummer van het element in de array);
  • de waarde van het element.

Array-adres - het adres van het startelement van de array.

De arraynaam is een id die wordt gebruikt om naar arrayelementen te verwijzen.

Grootte van array - het aantal array-elementen

Elementgrootte - het aantal bytes dat wordt ingenomen door één element van de array.

Grafisch kan de locatie van de array in het computergeheugen worden weergegeven als een doorlopende band met adressen.

De array in de afbeelding bevat q-elementen met indices van 0 tot q-1. Elk element neemt k bytes in beslag in het computergeheugen en de rangschikking van de elementen in het geheugen is sequentieel.

De adressen van het i-de element van de array hebben de waarde

Het array-adres is het adres van het startelement (nul) van de array. Om toegang te krijgen tot de elementen van een array, wordt de ordinale (index) van het element gebruikt, waarvan de beginwaarde 0 is. Dus als de array q-elementen bevat, veranderen de indices van de array-elementen in het bereik van 0 tot q-1.

Arraylengte - het aantal bytes dat in het geheugen is toegewezen voor het opslaan van alle arrayelementen.

Matrixlengte = artikelgrootte * artikelhoeveelheid

Om de grootte van een array-element te bepalen, kan de functie worden gebruikt

int sizeof (type);

Bijvoorbeeld,

sizeof (char) = 1;
grootte van (int) = 4;
sizeof (float) = 4;
sizeof (dubbel) = 8;

Arrays declareren en initialiseren

Om een ​​array in C te declareren, wordt de volgende syntaxis gebruikt:

type naam [dimensie] = (initialisatie);

Initialisatie is een set beginwaarden voor array-elementen, gespecificeerd tussen accolades en gescheiden door komma's.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // array a van 10 gehele getallen

Als het aantal initialisatiewaarden dat is opgegeven tussen accolades kleiner is dan het aantal array-elementen dat is opgegeven tussen vierkante haken, zijn alle resterende elementen in de array (waarvoor er niet voldoende initialisatiewaarden waren) gelijk aan nul. Deze eigenschap is handig voor het instellen van nulwaarden voor alle elementen van een array.

intb = (0); // array b van 10 elementen, geïnitialiseerd op 0


Als de array tijdens de declaratie wordt geïnitialiseerd, worden de constante beginwaarden van de elementen opgegeven, gescheiden door komma's, tussen accolades. In dit geval kan het aantal items tussen vierkante haken worden weggelaten.

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

Bij toegang tot array-elementen wordt de index van het vereiste element tussen vierkante haken weergegeven.

Voorbeeld in C

1
2
3
4
5
6
7
8

#erbij betrekken
int hoofd ()
{
int a = (5, 4, 3, 2, 1); // array a bevat 5 elementen
printf ("% d% d% d% d% d \ n", a, a, a, a, a);
getchar ();
retourneer 0;
}

Het resultaat van de uitvoering van het programma:

Het is echter vaak nodig om de waarden van array-elementen in te stellen tijdens de uitvoering van het programma. Dit maakt gebruik van een array-declaratie zonder initialisatie. In dit geval is de aanduiding van het aantal elementen tussen vierkante haken vereist.

int een;

Om de beginwaarden van array-elementen in te stellen, wordt heel vaak een parametrische lus gebruikt:

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


#erbij betrekken
int hoofd ()
{
int een;
int ik;
// Invoer array-elementen
voor (i = 0; i<5; i++)
{
printf ("a [% d] =", ik);
scanf ("% d", & a [i]);
}
// Array-elementen weergeven
voor (i = 0; i<5; i++)
printf ("% d", a [i]); // ruimte in printformaat is vereist
getchar (); getchar ();
retourneer 0;
}

Resultaat programma uitvoering

Multidimensionale arrays

Multidimensionale arrays kunnen ook worden gedeclareerd in C. Het verschil tussen een multidimensionale array en een eendimensionale array is dat in een eendimensionale array de positie van een element wordt bepaald door één index, en in een multidimensionale array door meerdere. Een voorbeeld van een multidimensionale array is een matrix.

Algemene vorm van het declareren van een multidimensionale array

typenaam [dimensie1] [dimensie2] ... [dimensiem];

De elementen van een multidimensionale array bevinden zich in opeenvolgende cellen van het willekeurig toegankelijke geheugen in oplopende volgorde van adressen. In het computergeheugen zijn de elementen van een multidimensionale array in een rij gerangschikt, bijvoorbeeld een array met 2 rijen en 3 kolommen,

int een;


wordt als volgt in het geheugen gelokaliseerd:

Het totale aantal elementen in de gegeven tweedimensionale array wordt bepaald als

Aantal rijen * Aantal kolommen = 2 * 3 = 6.

Het aantal bytes geheugen dat nodig is om de array te accommoderen, wordt bepaald als:

Aantal items * Grootte van items = 6 * 4 = 24 bytes.

Multidimensionale arrays initialiseren

De waarden van de elementen van een multidimensionale array, zoals in het eendimensionale geval, kunnen worden gespecificeerd door constante waarden wanneer gedeclareerd, ingesloten tussen accolades (). In dit geval moet de aanduiding van het aantal elementen in rijen en kolommen echter tussen vierkante haken worden aangegeven.

Voorbeeld in C

1
2
3
4
5
6
7
8
9

#erbij betrekken
int hoofd ()
{
int a = (1, 2, 3, 4, 5, 6);
printf ("% d% d% d \ n", a, a, a);
getchar ();
retourneer 0;
}



Vaker moet u echter de waarden van de elementen van een multidimensionale array invoeren tijdens de uitvoering van het programma. Voor dit doel is het handig om een ​​geneste parametrische lus te gebruiken.

Voorbeeld in C

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

#define _CRT_SECURE_NO_WARNINGS
#erbij betrekken
int hoofd ()
{
int een; // matrix van 2 rijen en 3 kolommen
int i, j;
// Invoer array-elementen
voor (i = 0; i<2; i++) // loop door de lijnen
{
voor (j = 0; j<3; j++) // loop door de kolommen
{
printf ("a [% d] [% d] = ", i, j);
scanf ("% d", & a [i] [j]);
}
}
// Array-elementen weergeven
voor (i = 0; i<2; i++) // loop door de lijnen
{
voor (j = 0; j<3; j++) // loop door de kolommen
{
printf ("% d", a [i] [j]);
}
printf ("\ n"); // nieuwe lijn
}
getchar (); getchar ();
retourneer 0;
}



Een array doorgeven aan een functie

Het is handig om de verwerking van arrays te organiseren met behulp van speciale functies. Om de array als argumenten voor de functie te verwerken, moet u doorgeven

  • array adres,
  • de grootte van de array.

De uitzondering zijn de stringverwerkingsfuncties, waaraan het voldoende is om alleen het adres door te geven.

Bij het doorgeven van variabelen als argumenten aan een functie, worden de gegevens als kopieën doorgegeven. Dit betekent dat als de parameterwaarde binnen de functie verandert, dit op geen enkele manier de waarde binnen de aanroepende functie zal beïnvloeden.

Als het adres van een variabele (of het adres van een array) wordt doorgegeven aan een functie, dan worden alle bewerkingen die in de functie worden uitgevoerd met gegevens binnen het bereik van het opgegeven adres uitgevoerd op de oorspronkelijke gegevens, dus de oorspronkelijke array (of de waarde van de variabele) kan worden gewijzigd door de aangeroepen functie.

Een voorbeeld in C Dan is een array van 10 elementen. Verwissel de grootste en de startelementen van de array. Gebruik de functie voor de bewerkingen om het maximale element te vinden en uit te wisselen.

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

#define _CRT_SECURE_NO_WARNINGS
#erbij betrekken
// Wisselfunctie
ongeldige wijziging (int * x, int n)
{
// x is een pointer naar een array (array-adres)
// n is de grootte van de array
int ik;
int max, index;
maximaal = x;
index = 0;
// Vind het maximale element
voor (i = 1; i {
als (x [i]> max)
{
max = x [i];
index = ik;
}
}
// Aandelenbeurs
x = x;
x = maximaal;
}
// Hoofdfunctie
int hoofd ()
{
int een;
int ik;
voor (i = 0; i<10; i++)
{
printf ("a [% d] =", ik);
scanf ("% d", & a [i]);
}
verandering (a, 10); // bel de uitwisselingsfunctie
// Array-elementen weergeven
voor (i = 0; i<10; i++)
printf ("% d", a [i]);
getchar ();
getchar ();
opbrengst
p = p * x [i];
}
retour p;
}
// Hoofdfunctie
int hoofd ()
{
int een; // verklaarde een array a van 5 elementen
int ik;
int pr;
// Invoer array-elementen
voor (i = 0; i<5; i++)
{
printf ("a [% d] =", ik);
scanf ("% d", & a [i]); // & a [i] - adres van het i-de element van de array
}
pr = func (a, 5); // bereken het product
printf ("\ n pr =% d", pr); // voer het product van even elementen uit
getchar (); getchar ();
retourneer 0;
}



Een array is een gegevensstructuur die wordt gepresenteerd als een groep cellen van hetzelfde type, verenigd onder één enkele naam. Arrays worden gebruikt om een ​​grote hoeveelheid gegevens van hetzelfde type te verwerken. De naam van de array is wat pointers zijn, ik zal het je wat later vertellen. Een enkele cel met arraygegevens wordt een array-element genoemd. De elementen van de array kunnen gegevens van elk type zijn. Arrays kunnen één of meer dan één dimensie hebben. Afhankelijk van het aantal dimensies worden arrays onderverdeeld in eendimensionale arrays, tweedimensionale arrays, driedimensionale arrays, enzovoort tot een n-dimensionale array. Eendimensionale en tweedimensionale arrays worden het vaakst gebruikt bij het programmeren, dus we zullen alleen deze arrays beschouwen.

Eendimensionale arrays in C ++

Eendimensionale array - een array met één parameter die het aantal elementen van de eendimensionale array karakteriseert. In feite is een eendimensionale array een array die slechts één rij en een n-de aantal kolommen kan hebben. De kolommen in een eendimensionale array zijn de elementen van de array. Figuur 1 toont de structuur van een integer eendimensionale array een... De grootte van deze array is 16 cellen.

Figuur 1 - Arrays in C ++

Merk op dat de maximale index van een eendimensionale array een is gelijk aan 15, maar de grootte van de array is 16 cellen, omdat de nummering van de cellen in de array altijd begint bij 0. De celindex is een niet-negatief geheel getal waarmee je naar elke cel in de array kunt verwijzen en voer er acties op uit (cel).

// syntaxis voor het declareren van een eendimensionale array in C ++: / * datatype * / / * naam van een eendimensionale array * /; // voorbeeld van het declareren van een eendimensionale array getoond in figuur 1: int a;

waarbij int een geheel getal is;

A is de naam van de eendimensionale array;
16 - de grootte van een eendimensionale array, 16 cellen.

Altijd direct na de naam van de array staan ​​vierkante haken, waarin de grootte van een eendimensionale array wordt gezet, dit is wat de array verschilt van alle andere variabelen.

// een andere manier om eendimensionale arrays int mas, a te declareren;

Twee eendimensionale arrays mas en a worden gedeclareerd met respectievelijk de maten 10 en 16. Bovendien zullen bij deze declaratiemethode alle arrays hetzelfde gegevenstype hebben, in ons geval - int.

// arrays kunnen worden geïnitialiseerd wanneer gedeclareerd: int a = (5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // initialiseer eendimensionale array

Initialisatie van een eendimensionale array wordt uitgevoerd tussen accolades na het teken gelijk aan, wordt elk element van de array van het vorige gescheiden door een komma.

Int a = (5, -12, -12,9,10,0, -9, -12, -1,23,65,64,11,43,39, -15); // initialiseer de array zonder de grootte ervan te bepalen.

In dit geval bepaalt de compiler zelf de grootte van de eendimensionale array. De grootte van de array kan alleen worden weggelaten wanneer deze is geïnitialiseerd; bij de gebruikelijke declaratie van een array is het noodzakelijk om de grootte van de array aan te geven. Laten we een eenvoudig programma ontwikkelen voor het verwerken van een eendimensionale array.

// array.cpp: definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// code Code :: Blokken

// Dev-C ++-code

// array.cpp: definieert het toegangspunt voor de consoletoepassing. #erbij betrekken namespace std; gebruiken; int main (int argc, char * argv) (cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

V lijnen 10 - 11 gedeclareerd en geïnitialiseerd een integer eendimensionale array genaamd array1, waarvan de grootte 16 cellen is, dat wil zeggen dat een dergelijke array 16 getallen kan opslaan. Elke verwerking van een array is alleen mogelijk in combinatie met lussen. Welke lus u kiest voor het verwerken van een array, is aan u. Maar het is het meest geschikt voor deze taak. De counter-variabele-teller wordt gebruikt om te verwijzen naar de elementen van de eendimensionale array-array1. De voorwaarde voor voortzetting van de for-lus bevat een strikt ongelijkheidsteken, aangezien er geen zestiende index is in de eendimensionale array-array1. En aangezien de nummering van cellen bij nul begint, zijn de elementen in de array 16. In de body van de for-lus drukt de cout-operator de elementen van een eendimensionale array af (zie figuur 2).

Obrabotka massief indeks element massief array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Druk op een toets om door te gaan. ... ...

Figuur 2 - Arrays in C ++

Laten we een ander programma ontwikkelen voor het verwerken van een eendimensionale array in C++. Het programma moet achtereenvolgens tien ingevoerde cijfers van het toetsenbord lezen. Tel alle ingevoerde getallen op, toon het resultaat.

// array_sum.cpp: definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// code Code :: Blokken

// Dev-C ++-code

// array_sum.cpp: definieert het toegangspunt voor de consoletoepassing. #erbij betrekken namespace std; gebruiken; int main (int argc, char * argv) (int array1; // declareer een integer array cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> reeks1; // lees de cijfers die zijn ingevoerd vanaf het toetsenbord cout<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Voordat de array wordt verwerkt, moet deze worden gedeclareerd en de grootte van de eendimensionale array is 10, omdat dit wordt bepaald door de toestand van het probleem. In de variabele som zullen we de som van de elementen van een eendimensionale array accumuleren. De eerste for-lus vult de gedeclareerde eendimensionale array met de getallen die met het toetsenbord zijn ingevoerd, lijnen 12 - 13... De counter-variabele-teller wordt gebruikt voor sequentiële toegang tot de elementen van de eendimensionale array-array1, vanaf index 0 tot en met de 9e. De tweede for-lus geeft de elementen van de array weer, lijnen 15 - 16... De derde for-lus leest opeenvolgend de elementen van de eendimensionale array en telt ze op, de som wordt geaccumuleerd in de somvariabele, lijnen 17 - 18... Zie het resultaat van het programma in figuur 3.

Voer elementi massiva in: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9) sum = 45 Druk op een willekeurige toets om door te gaan. ... ...

Figuur 3 - Arrays in C ++

Eerst werden alle 10 getallen achter elkaar ingevoerd, waarna een eendimensionale array werd weergegeven en de som van de array-nummers werd afgedrukt.

Tweedimensionale arrays in C ++

Tot nu toe hebben we eendimensionale arrays overwogen, waartoe niet altijd beperkt kan worden. Stel dat u enkele gegevens uit een tabel moet verwerken. Een tabel heeft twee kenmerken: het aantal rijen en het aantal kolommen. Ook in een tweedimensionale array zijn er naast het aantal arrayelementen kenmerken zoals het aantal rijen en het aantal kolommen van een tweedimensionale array. Dat wil zeggen, visueel is een tweedimensionale array een gewone tabel, met rijen en kolommen. In feite is een tweedimensionale array een eendimensionale array van eendimensionale arrays. De structuur van een tweedimensionale array met de naam a, maat m bij n, wordt hieronder weergegeven (zie figuur 4).

Figuur 4 - Arrays in C ++

waarbij m het aantal lijnen in een tweedimensionale matrix is;
n is het aantal kolommen van een tweedimensionale array;
m * n is het aantal elementen in de array.

// syntaxis voor het declareren van een tweedimensionale array / * datatype * / / * arraynaam * /;

In de declaratie van een tweedimensionale array, evenals in de declaratie van een eendimensionale array, moet u allereerst specificeren:

  • data type;
  • de naam van de array.

Daarna wordt in de eerste vierkante haken het aantal rijen van een tweedimensionale array aangegeven, in de tweede vierkante haken - het aantal kolommen van een tweedimensionale array. Een tweedimensionale array verschilt visueel van een eendimensionale array door het tweede paar vierkante haken. Overweeg een voorbeeld van het declareren van een tweedimensionale array. Stel dat we een tweedimensionale array moeten declareren, met het aantal elementen gelijk aan 15. In dit geval kan een tweedimensionale array drie rijen en vijf kolommen hebben, of vijf rijen en drie kolommen.

// voorbeeld van het declareren van een tweedimensionale array: int a;

  • a - de naam van de integer-array
  • het getal tussen de eerste vierkante haken geeft het aantal lijnen van de tweedimensionale array aan, in dit geval zijn het er 5;
  • het getal tussen de tweede vierkante haken geeft het aantal kolommen in de tweedimensionale array aan, in dit geval zijn het er 3.

// initialiseer een tweedimensionale array: int a = ((4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), (1 , 1, 1));

Deze array heeft 5 rijen, 3 kolommen. na het toewijzingsteken worden gewone accolades geplaatst, waarbinnen er net zoveel paren accolades zijn als er lijnen in een tweedimensionale array zouden moeten zijn, en deze haakjes worden gescheiden door komma's. Schrijf in elk paar accolades de elementen van een tweedimensionale array, gescheiden door komma's. Alle accolades moeten hetzelfde aantal elementen hebben. Omdat er vijf regels in de array zijn, zijn er ook vijf binnenste haakjes. De binnenste haakjes bevatten elk drie elementen, aangezien het aantal kolommen drie is. Grafisch ziet onze array eruit als een tweedimensionale tabel (zie figuur 5).

Figuur 5 - Arrays in C ++

In elke cel van een tweedimensionale array een de waarde wordt weergegeven, het adres van deze cel wordt weergegeven in de rechter benedenhoek. Het celadres van een tweedimensionale array is de arraynaam, het rijnummer en het kolomnummer.

Laten we een eenvoudig programma ontwikkelen voor het verwerken van een tweedimensionale array, genaamd "Labyrinth". Het doolhof moet worden gebouwd op basis van een tweedimensionale array. We zullen naar eigen goeddunken de grootte van het doolhof kiezen.

// array2.cpp: definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) anders<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// code Code :: Blokken

// Dev-C ++-code

// array2.cpp: definieert het toegangspunt voor de consoletoepassing. #erbij betrekken namespace std; gebruiken; int main (int argc, char * argv) (// 1-voorwaardelijk "muren van het doolhof" // 2- "juist pad, verlaat het doolhof" // 0- "vals pad" int mas = ((1, 2,1 , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // initialisatie van een tweedimensionale reeks (1,2,1,0 , 0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1 ,1,0,1,0, 1,2,1,2,2,2,2,2,1,0,1,1,0,1,), (1,2,2,2,2, 2,2,1,2,1,1 , 1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2 ,1,0,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0, 0,2,0,0,0,1 , 0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1 ,1,1,0,1,), (1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2,1,0,0,0, 0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,2,1,0,1,1,1,1,) , (1,1,0,0,0,1,0 , 0,1,1,2,1,1,1,1,0,0,0,0,1,), (1,0,0 ,1,0,0,0,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1, 1,1,1,1,1,1,1,2 , 1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2 ,2,2,2,2,2,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1, 1,1,1,0,0,0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0 ,1,1,0,1,), (1,2,1 , 1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0, 1,), (1,2,1,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1, 2,1,2,1,2,1,2,1.0 , 1,2,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1 ,2,1 , 2,1,0,1,1,1,1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0, 0,0,0,0,0,0,0,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1 , 1,1,0,1,2,1,), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0, 1,2,1,), (1,2,1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,) , (1,2,1,1,2,1,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1 1,2,1,0,0,1,1,1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2, 1, 1,0,1,2,2,2,2,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0 ,1,2 , 1,1,1,1,1,1,1,1,1,1,1,), (1,2,1,1,2,1,0,1,1,2, 1,1,1, 1,1,1,1,1,2,2,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2 ,2,2,2,2, 2,2,1,), (1,2,1,1,2,1,0,1,1,2,1,1,2,1,1,1, 1,1,1,1,1, ), (1,2,1,1,2,1,0,0,1,2,1,1,2,1,0,0,0,1,0 ,1,), (1,2, 2,2,2,1,0,1,1,2,2,2,2,2,0,0,1,0,0,0,1,), (1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,)); // twee lussen - een interne en een externe, die toegang hebben tot elk element van de array voor (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) anders<< " "; // вывести два пробела cout << endl; } return 0; }

De juiste en valse paden kunnen worden aangeduid met hetzelfde nummer, bijvoorbeeld nul, maar voor de duidelijkheid wordt het juiste pad aangeduid met het nummer 2. De array is handmatig geïnitialiseerd, alleen om het programma te vereenvoudigen. Aangezien het programma een tweedimensionale array verwerkt, zijn er twee lussen nodig om tussen de elementen van een tweedimensionale array te schakelen. De eerste for-lus schakelt tussen de rijen van een tweedimensionale array. Aangezien er 33 regels in een tweedimensionale array zijn, wordt de tellervariabele i verhoogd van 0 tot 33, lijn 46... Binnen de eerste lus bevindt zich een for-lus die schakelt tussen de elementen van de string van een tweedimensionale array. In de hoofdtekst van de tweede for-lus wordt intern een conversiebewerking van het unaire gegevenstype uitgevoerd - static_cast<>(), dat teken afdrukt, op nummer 176. De conversiebewerking van het gegevenstype wordt gedupliceerd om de breedte van het doolhof te vergroten. Het resultaat van het programma (zie figuur 6).

Figuur 6 - Arrays in C ++

Een tweedimensionale array in Pascal wordt behandeld als een eendimensionale array, waarvan het elementtype ook een array is (een array van arrays). De positie van elementen in tweedimensionale Pascal-arrays wordt beschreven door twee indices. Ze kunnen worden weergegeven als een rechthoekige tafel of matrix.

Overweeg een tweedimensionale Pascal-array met afmetingen 3 * 3, dat wil zeggen dat deze drie lijnen zal hebben en elke lijn heeft drie elementen:

Elk element heeft zijn eigen nummer, zoals in eendimensionale arrays, maar nu bestaat het nummer al uit twee nummers - het nummer van de regel waarin het element zich bevindt en het nummer van de kolom. Het elementnummer wordt dus bepaald door het snijpunt van de rij en de kolom. Een 21 is bijvoorbeeld het item in de tweede rij en eerste kolom.

Beschrijving van een tweedimensionale Pascal-array.

Er zijn verschillende manieren om een ​​tweedimensionale Pascal-array aan te geven.

We weten al hoe we eendimensionale arrays moeten beschrijven, waarvan de elementen van elk type kunnen zijn, en daarom kunnen de elementen zelf arrays zijn. Bekijk de volgende beschrijving van typen en variabelen:

Een voorbeeld van het beschrijven van een tweedimensionale Pascal-array

Type
Vector = reeks van<тип_элементов>;
Matrix = reeks vectoren;
Var m: matrix;

We hebben een tweedimensionale Pascal-array m gedeclareerd, bestaande uit 10 rijen met elk 5 kolommen. In dit geval is elke i-de regel toegankelijk m [i], en elk j -de element binnen de i-de regel - m [i, j].

Typedefinities voor tweedimensionale Pascal-arrays kunnen ook in één regel worden gespecificeerd:

Type
Matrix = array van array van< тип элементов >;
of nog eenvoudiger:
type
matrix = matrix van<тип элементов>;

De verwijzing naar de elementen van een tweedimensionale array ziet er als volgt uit: M [i, j]. Dit betekent dat we het element in de i-de rij en j-de kolom willen krijgen. Het belangrijkste hier is om rijen niet te verwarren met kolommen, anders kunnen we opnieuw een oproep krijgen naar een niet-bestaand element. Een aanroep naar het element M heeft bijvoorbeeld de juiste notatie, maar kan een fout in het programma veroorzaken.

Basisbewerkingen met tweedimensionale Pascal-arrays

Alles wat is gezegd over basisbewerkingen met eendimensionale arrays, geldt ook voor matrices. De enige actie die kan worden uitgevoerd op matrices van hetzelfde type als geheel is toewijzing. Dat wil zeggen, als ons programma twee matrices van hetzelfde type beschrijft, bijvoorbeeld,

type
matrix = matrix van geheel getal;
var
a, b: matrix;

dan kun je tijdens de uitvoering van het programma de matrix toewijzen een matrixwaarde B(a: = b). Alle andere acties worden element voor element uitgevoerd, terwijl u op de elementen alle geldige bewerkingen kunt uitvoeren die zijn gedefinieerd voor het gegevenstype van de array-elementen. Dit betekent dat als een array uit gehele getallen bestaat, bewerkingen die voor gehele getallen zijn gedefinieerd, kunnen worden uitgevoerd op zijn elementen, maar als de array uit tekens bestaat, dan zijn de bewerkingen die zijn gedefinieerd voor het werken met tekens daarop van toepassing.

Invoer van een tweedimensionale Pascal-array.

Om de elementen van een eendimensionale array achtereenvolgens in te voeren, gebruikten we een for-lus, waarin we de indexwaarde van de 1e naar de laatste veranderden. Maar de positie van een element in een tweedimensionale Pascal-array wordt bepaald door twee indices: het rijnummer en het kolomnummer. Dit betekent dat we het rijnummer achtereenvolgens moeten veranderen van de 1e naar de laatste, en in elke rij de elementen van de kolommen herhalen van de 1e naar de laatste. Dit betekent dat we twee for-lussen nodig hebben, en de ene zal in de andere worden genest.

Overweeg een voorbeeld van het invoeren van een tweedimensionale Pascal-array vanaf het toetsenbord:

Een voorbeeld van een programma voor het invoeren van een tweedimensionale Pascal-array vanaf het toetsenbord

type
matrix = matrix van geheel getal;
var
een,: matrix;
i, j: geheel getal; (array-indexen)
beginnen
voor i: = 1 tot 5 do (lus om alle regels te herhalen)
leesln (a [i, j]); (toetsenbordinvoer van het element in de i-de rij en j-de kolom)

Een tweedimensionale Pascal-array kan willekeurig worden gevuld, d.w.z. gebruik de willekeurige (N)-functie en wijs ook de waarde van een uitdrukking toe aan elk element van de matrix. De manier om de tweedimensionale Pascal-array te vullen, wordt gekozen afhankelijk van de uit te voeren taak, maar in elk geval moet elk element in elke rij en elke kolom worden gedefinieerd.

Geeft een tweedimensionale Pascal-array weer op het scherm.

De uitvoer van de elementen van een tweedimensionale Pascal-array wordt ook opeenvolgend uitgevoerd, het is noodzakelijk om de elementen van elke rij en elke kolom af te drukken. Tegelijkertijd wil ik dat de elementen op dezelfde regel naast elkaar worden afgedrukt, d.w.z. in een rij, en de elementen van de kolom bevonden zich onder elkaar. Om dit te doen, moet u de volgende reeks acties uitvoeren (denk aan het programmafragment voor de array die in het vorige voorbeeld is beschreven):

Een voorbeeld van een programma voor de uitvoer van een tweedimensionale Pascal-array

voor i: = 1 tot 5 do (lus om alle regels te herhalen)
beginnen
voor j: = 1 tot 10 do (herhaal alle elementen van de rij per kolom)
schrijf (a [i, j]: 4); (afdrukken van elementen in de i-de rij van de matrix in één schermregel, terwijl 4 posities worden toegewezen voor de uitvoer van elk element)
schrijven; (voordat u het regelnummer in de matrix wijzigt, moet u de cursor naar het begin van een nieuwe schermregel verplaatsen)
einde;

Opmerking ( Het is belangrijk!): heel vaak treedt er in studentenprogramma's een fout op wanneer toetsenbordinvoer of array-uitvoer als volgt wordt geprobeerd: readln (a), writeln (a), waarbij een Is een variabele van het type array. Ze zijn echter verrast door de boodschap van de compiler dat een variabele van dit type niet kan worden gelezen of afgedrukt. Misschien begrijp je waarom dit niet kan als je je voorstelt N mokken op een rij te staan, en je hebt bijvoorbeeld een ketel water in je handen. Kun jij alle mokken in één keer vullen op het commando "water gieten"? Hoe hard je ook probeert, je zult in elke mok apart moeten schenken. Het vullen en weergeven van array-elementen moet ook opeenvolgend en element voor element worden uitgevoerd, aangezien: in het computergeheugen bevinden de elementen van de array zich in opeenvolgende cellen.

Een tweedimensionale Pascal-array in het geheugen weergeven

De elementen van een abstracte array in het geheugen van de machine bevinden zich fysiek opeenvolgend, volgens de beschrijving. Bovendien neemt elk element in het geheugen het aantal bytes in beslag dat overeenkomt met zijn grootte. Als de array bijvoorbeeld bestaat uit elementen van het type integer, dan neemt elk element twee bytes in beslag. En de hele array duurt S ^ 2 bytes, waarbij S het aantal elementen in de array is.

En hoeveel ruimte zal een array bestaande uit arrays innemen, d.w.z. Matrix? Vanzelfsprekend: S i ^ S j, waarbij Si het aantal regels is en S j het aantal elementen in elke regel. Bijvoorbeeld, voor een array als

Matrix = matrix van geheel getal;

het zal 12 bytes geheugen in beslag nemen.

Hoe zullen de elementen van deze array zich in het geheugen bevinden? Beschouw de lay-out van een array M van het type matrix in het geheugen.

Voor elk element M van het type integer zijn twee geheugencellen toegewezen. Plaatsing in het geheugen gebeurt "van onder naar boven". De elementen worden in de volgorde van indexverandering geplaatst, wat overeenkomt met het schema van geneste lussen: eerst wordt de eerste regel geplaatst, dan de tweede, de derde ... Binnen de regel gaan de elementen op volgorde: eerste, tweede, enzovoort.

Zoals we weten, is toegang tot elke variabele alleen mogelijk als het adres van de geheugencel waarin de variabele is opgeslagen bekend is. Een specifiek geheugen wordt toegewezen aan een variabele wanneer het programma wordt geladen, dat wil zeggen dat er een wederzijdse overeenkomst tot stand wordt gebracht tussen de variabele en het celadres. Maar als we de variabele als een array hebben gedeclareerd, "kent" het programma het adres van het begin van de array, dat wil zeggen het eerste element. Hoe krijg je toegang tot alle andere elementen van de array? Met echte toegang tot een geheugencel die een element van een tweedimensionale array opslaat, berekent het systeem zijn adres met behulp van de formule:

Addr + SizeElem * Cols * (I -1) + SizeElem * (J -1),

waarbij Addr het werkelijke startadres is waarop de array zich in het geheugen bevindt; I, J - elementindexen in een tweedimensionale array; SizeElem - de grootte van het array-element (bijvoorbeeld twee bytes voor integer-elementen); Cols - het aantal elementen in de regel.

De uitdrukking SizeElem * Cols * (I -1) + SizeElem * (J -1) wordt de offset vanaf het begin van de array genoemd.

Hoeveel geheugen is toegewezen aan de array?

Laten we niet zozeer kijken naar de vraag hoeveel geheugen is toegewezen aan de array (we hebben dit in de vorige paragraaf besproken), maar wat de maximaal toegestane grootte van de array is, gezien de beperkte hoeveelheid geheugen.

Om het programma te laten werken, wordt geheugen toegewezen in segmenten van elk 64 KB, en ten minste één ervan is gedefinieerd als: gegevenssegment... In dit segment bevinden zich de gegevens die het programma zal verwerken. Geen enkele programmavariabele kan zich in meer dan één segment bevinden. Daarom, zelfs als er maar één variabele in het segment is, beschreven als een array, kan deze niet meer dan 65536 bytes ontvangen. Maar vrijwel zeker zullen naast de array nog enkele variabelen in het datasegment worden beschreven, dus de werkelijke hoeveelheid geheugen die aan de array kan worden toegewezen, wordt gevonden met de formule: 65536-S, waarbij S de hoeveelheid is van geheugen dat al is toegewezen voor andere variabelen.

Waarom moeten we dit weten? Om niet verrast te zijn, als de vertaler tijdens het compileren een foutmelding genereert over de declaratie van een array die te lang is wanneer hij een beschrijving in het programma tegenkomt (correct qua syntaxis):

Typ myArray = array van geheel getal;

Je weet al dat je, gezien de twee-byte-weergave van gehele getallen, een array kunt declareren met het aantal elementen gelijk aan 65536/2 –1 = 32767. En dan alleen als er geen andere variabelen zijn. 2D-arrays zouden nog kleinere indexgrenzen moeten hebben.

Voorbeelden van het oplossen van problemen met tweedimensionale Pascal-arrays

Taak: Vind het product van niet-nul elementen van de matrix.

Oplossing:

  • Om dit probleem op te lossen hebben we variabelen nodig: een matrix die bijvoorbeeld bestaat uit integer-elementen; P is het product van andere elementen dan 0; I, J - array-indexen; N, M - het aantal rijen en kolommen in de matrix.
  • Invoergegevens zijn N, M - we voeren hun waarden in via het toetsenbord; matrix - we regelen de invoer van de matrix in de vorm van een procedure, we vullen de matrix op een willekeurige manier, d.w.z. met behulp van de willekeurige () functie.
  • De uitvoergegevens zijn de waarde van de variabele P (product).
  • Om de juistheid van de uitvoering van het programma te controleren, is het noodzakelijk om de matrix op het scherm weer te geven, hiervoor zullen we de procedure voor het weergeven van de matrix formuleren.
  • Voortgang bij het oplossen van het probleem:

we zullen eerst de uitvoering van het hoofdprogramma bespreken, we zullen iets later de implementatie van de procedures bespreken:

  • voer de waarden van N en M in;
  • Laten we een tweedimensionale Pascal-array introduceren, hiervoor gaan we naar de procedure vvod (a), waarbij a een matrix is;
  • Laten we de resulterende matrix printen, hiervoor verwijzen we naar de print (a) procedure;
  • Laten we de beginwaarde toewijzen aan de variabele P = 1;
  • We zullen achtereenvolgens alle rijen van I van de 1e tot de N-de herhalen, in elke rij zullen we alle kolommen van J van de 1e tot de M-de herhalen, voor elk element van de matrix zullen we de voorwaarde controleren: als een ij ? 0, dan wordt het product P vermenigvuldigd met het element a ij (P = P * a ij);
  • Laten we de waarde van het product van niet-nul matrixelementen weergeven - P;

Laten we het nu hebben over de procedures.

Opmerking (Het is belangrijk!) Een procedureparameter kan elke variabele van een vooraf gedefinieerd type zijn, wat betekent dat om een ​​array als parameter aan de procedure door te geven, het type van tevoren moet worden beschreven. Bijvoorbeeld:

Type
Matrix = matrix van geheel getal;
procedure-primer (a: matrix);
..............................

Laten we nu teruggaan naar onze procedures.

De procedure voor het invoeren van een matrix wordt vvod genoemd, de parameter van de procedure is een matrix en daarom moet deze worden doorgegeven aan het hoofdprogramma, daarom moet de parameter als referentie worden doorgegeven. Dan ziet de kop van onze procedure er als volgt uit:

Procedure vvod (var m: matrix);

Om geneste lussen in een procedure te implementeren, hebben we lokale tellervariabelen nodig, bijvoorbeeld k en h. Het matrixvulalgoritme is al besproken, dus we zullen het niet herhalen.

De procedure voor het weergeven van een matrix op het scherm wordt print genoemd, de parameter van de procedure is een matrix, maar in dit geval is het een invoerparameter, daarom wordt deze doorgegeven door waarde. De titel van deze procedure ziet er als volgt uit:

Procedure print (m: matrix);

En nogmaals, om geneste lussen binnen een procedure te implementeren, hebben we tellers nodig, laat ze hetzelfde heten - k en h. Het algoritme voor het weergeven van de matrix op het scherm is hierboven beschreven, we zullen deze beschrijving gebruiken.

Een voorbeeldprogramma voor een tweedimensionale Pascal-array

Programma proizvedenie;
Type
Matrix = matrix van geheel getal;
Var
een: matrix;
N, m, i, j: byte;
P: geheel getal;
Procedure vvod (var m: matrix);
Var k, h: byte;
Beginnen
Voor i: = 1 tot n do (de variabele n voor de procedure is globaal, wat "bekend" betekent)
Voor j: = 1 tot m do (de variabele m voor de procedure is globaal, wat "bekend" betekent)
M: = willekeurig (10);
Einde;
Procedure print (m: matrix);
Var k, h: byte;
Beginnen
Voor i: = 1 tot n do
beginnen
Voor j: = 1 tot m do
Schrijf (M: 4);
Schrijf;
einde;
Einde;
Begin (het begin van het hoofdprogramma)
Writeln ("Voer de afmeting van de matrix in:");
Leesln (N, M);
Vvod (a);
Afdrukken (a);
P: = 1;
Voor i: = 1 tot N do
Voor j: = 1 tot M do
Als een<>0 dan p: = p * a;
Schrijf (p);
Einde.

Array (ook indexarray, soms tafel, rij) - een benoemde (geordende) set van hetzelfde type variabelen (data) die zich direct na elkaar in het geheugen bevinden en die toegankelijk zijn voor inhoudsopgave... In het eenvoudigste geval reeks heeft een constante lengte en slaat data-eenheden van hetzelfde type op.

Inhoudsopgave dezelfde array is een getal geheel verwijzend naar een specifiek element in de array.

Het aantal gebruikte array-indexen kan variëren. Arrays met één index heten eendimensionaal, met twee - tweedimensionaal enzovoort.

Eendimensionaal array komt losjes overeen vector in wiskunde, tweedimensionaal - Matrix ... Meest gebruikte arrays met een of twee indices, minder vaak - met drie, zelfs meer indices zijn uiterst zeldzaam.

De array wordt als volgt beschreven:

Het meest voorkomende type index is een bereik, bijvoorbeeld:

Het bovenstaande beschrijft: matrix B, bestaande uit 5 elementen en symbolisch matrix R, bestaande uit 34 elementen. Voor een array V 5 * 6 = 30 bytes geheugen worden toegewezen (aangezien voor variabelen van het type Echt valt op 6 bytes geheugen), voor de R-array - 1 * 34 = 34 bytes geheugen (voor variabelen van het type Char - 1 byte). basistype: array-elementen kunnen elk zijn, zowel eenvoudig als gestructureerd, behalve bestand! Array kan worden gedeclareerd met eigen type:

Fiets elke herbruikbare reeks instructies die op enigerlei wijze is georganiseerd (bijvoorbeeld met behulp van een voorwaardelijke vertakking) kan worden aangeroepen.

Een enkele uitvoering van het luslichaam wordt genoemd iteratie. Uitdrukking definiëren, wordt opnieuw uitgevoerd iteratie, of fiets einde is een exit-voorwaarde of end-of-loop conditie(maar misschien een voortzettingsvoorwaarde). De variabele die het huidige iteratienummer opslaat, wordt genoemd iteratieteller fietsen of gewoon balie fiets. Fiets bevat niet noodzakelijk balie.

Cycli zijn:

- Fiets met toonbank, waarin een variabele zijn waarde verandert van een gegeven voorletter waarden tot de laatste waarden met wat stap, en voor elke waarde van deze variabele wordt de hoofdtekst van de lus eenmaal uitgevoerd. Uitgevoerd door de operator voor

Voorbeeld. Vul in reeks:

En zo kun je vullen tweedimensionaal reeks:

- Fiets met de voorwaarde, waaraan wordt voldaan terwijl een voorwaarde die is opgegeven vóór het begin waar is. Uitgevoerd door de operator terwijl.

- Fiets met postconditie, waarbij de voorwaarde wordt gecontroleerd nadat de lus-body is uitgevoerd, wat betekent dat de body altijd minstens één keer wordt uitgevoerd. In Pascal wordt deze lus geïmplementeerd door de operator herhaal tot

Er is een operatie iteratie overslaan wanneer in de huidige iteratie fiets het is noodzakelijk om alle commando's over te slaan naar het einde van de hoofdtekst van de lus die wordt uitgevoerd. In dit geval mag de lus zelf niet worden onderbroken, de voorwaarden voor voortzetting of exit moeten op de gebruikelijke manier worden berekend. Uitgevoerd door de operator doorgaan met.

Ook wordt in lussen het commando vaak gebruikt vervroegd uit de cyclus stappen, bijvoorbeeld wanneer een fout wordt gedetecteerd tijdens de uitvoering van de lusbody, waarna verder werken aan de lus zinloos is. Uitgevoerd door de operator UITGANG of pauze.

Laten we teruggaan naar het begin, of liever naar het begin voorbeeld. We moeten definiëren wat dit stukje programma doet:

Op basis van het bovenstaande is de gebruikte 2D-array: EEN is een matrix van grootte N x N... De cyclus wordt gebruikt met toonbank van één tot N, blijkbaar eerder gedefinieerd.

Binnen de lus: variabel met krijgt de waarde van een tweedimensionale array met index (c: = A), eerst is het ... Dan, in plaats van dit element van de array, de waarde van het element van dezelfde array, maar met de index (A: = A), of voor k: = 1 (A: = A). Die. de elementen van de eerste regel worden ingevoerd, aangezien het eerste getal in de index is verantwoordelijk voor het rijnummer in de matrix - [ l, j], en de tweede voor het kolomnummer is. En aan het einde, in plaats van het element met de index , de beginwaarde van het array-element wordt ingevoerd EEN met index , die we in de variabele zetten met (A: = c).

En met elke iteratie van onze lus, de waarde l neemt toe met eenheid... Laten we de stappen volgen. Eerst is het :

c: = EEN EEN: = EEN EEN: = c

c: = EEN EEN: = EEN EEN: = c

c: = EEN EEN: = EEN EEN: = c

Dus N keer eerder ... Die. de waarde van de diagonaal van de richtingsmatrix van links naar rechts en van boven naar beneden. EN elementen van deze diagonaal wissel waarden met elementen de eerste matrix zinkt(of k-de regel). Dus het juiste antwoord is optie 3: dit algoritme wisselt elementen van de diagonaal enkde kolom van de tabel.



© Copyright 2017, https://qzoreteam.ru