Metodat për specifikimin e një vargu në c. Vargu statik: deklarimi, plotësimi, përdorimi

Çfarë janë vargjet në C?

Si mund t'i deklaroj vargjet në C?

Si të inicializohen vargjet në C?

Vargjet në C për Dummies.

Vargjet në C

Një grup në C është një koleksion elementësh të të njëjtit lloj që mund të aksesohen me indeks. Elementet e vargjeve në C ndodhen njëri pas tjetrit në memorien e kompjuterit.

Një shembull i thjeshtë i krijimit dhe plotësimit të një grupi në C:

// @author Subbotin BP.h> kryesore e pavlefshme (void) (int nArr; nArr = 1; nArr = 2; nArr = 3; printf ("\ n \ tArray \ n \ n"); printf ("nArr \ t = \ t% d \ n ", nArr); printf (" nArr \ t = \ t% d \ n ", nArr); printf (" nArr \ t = \ t% d \ n ", nArr); kthej 0 ;)

Ne marrim:

Në shembull, ne deklarojmë një grup që përmban elementë të llojit int:

këtu emri i grupit është nArr, numri i elementeve të grupit është tre, lloji i elementeve të grupit është int.

Një grup është një koleksion elementësh. Çdo element i grupit mund të referohet me numrin e tij. Numri zakonisht quhet indeks. Elementet e grupit numërohen duke filluar nga zero. Le t'i caktojmë një vlerë elementit të parë të grupit dhe elementi i parë ka indeksin zero:

Le t'i caktojmë një vlerë elementit të dytë të grupit, dhe elementi i dytë ka indeksin një:

Le t'i caktojmë një vlerë elementit të tretë të grupit, dhe elementi i tretë është në indeksin dy:

Kur shfaqim elementet e grupit, marrim vlerat e tyre. Si kjo:

printf ("nArr \ t = \ t% d \ n", nArr);

Për të marrë një element të një grupi, duhet të specifikoni emrin e grupit dhe indeksin e elementit:

ky është elementi i parë i grupit, sepse elementi i parë ka një indeks zero.

Le t'i caktojmë vlerën e elementit të tretë të grupit variablit int a:

indeksi i elementit të tretë të grupit është i barabartë me dy, pasi indekset numërohen nga zero.

Tani rregulli i përgjithshëm për deklarimin e vargjeve në C: kur deklaroni një grup, duhet të specifikoni emrin e tij, llojin e elementeve, numrin e elementeve. Numri i elementeve është numër natyror, d.m.th. krejt pozitive. Zero nuk mund të jetë numri i elementeve. Ju nuk mund të specifikoni një numër të ndryshueshëm të elementeve të grupit. Këtu janë shembuj të deklaratave të grupeve në C:

int nArr; // Deklarohet një grup për ruajtjen e njëqind numrave të plotë;
float fArr; // Deklarohet një grup për ruajtjen e 5 numrave float;
char cArr; // Deklarohet një grup për ruajtjen e dy karaktereve;

Do të ishte gabim të deklarohej një grup me një numër të ndryshueshëm elementësh:

Int varElem;
int nArr; // Gabim! Numri i elementeve nuk mund të vendoset në një variabël;

Por ju mund të vendosni numrin e elementeve si një konstante: ose një numër i plotë pozitiv i menjëhershëm 1, 2, 3 ... ose një konstante:

Const int arrayLength = 3;
int nArr;

Kur deklaroni një grup në C, mund ta inicializoni menjëherë:

int nMassiv = (1, 2, 3);

Ju mund të hiqni numrin e elementeve të grupit në kllapa katrore nëse të gjithë elementët e grupit janë inicializuar:

int nMassiv = (1, 2, 3);

numri i elementeve do të përcaktohet automatikisht në këtë rast.

Ju mund të përcaktoni vetëm një pjesë të elementeve të grupit kur e deklaroni atë:

int nMassiv = (1, 2);

në këtë shembull, dy elementët e parë të grupit janë inicializuar dhe i treti është i papërcaktuar.

Një shembull i një grupi karakteresh:

char cArr = ("S", "B", "P");

Kur deklaroni një grup, nuk mund të specifikoni numrin e elementeve në një variabël. Por ju mund të përdorni variabla kur aksesoni elementët e grupit:

Int ind = 0;
char cr = cArr;

Kjo përdoret kur punoni me sythe. Shembull:

// @author Subbotin B.P..h> void main (void) (const int arrayLength = 3; int nArr; for (int inn = 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

Në shembull, në ciklin e parë mbushim grupin me elementë int, dhe në ciklin e dytë i shfaqim këto elemente në ekran.

Vargjeve

Arrayështë një koleksion variablash të të njëjtit lloj me një emër të përbashkët për t'iu referuar atyre. Në C #, vargjet mund të jenë ose njëdimensionale ose shumëdimensionale. Vargjet shërbejnë për një larmi qëllimesh, sepse ato ofrojnë një mjet të përshtatshëm për të kombinuar variablat që janë të lidhur së bashku.

Ju mund të përdorni vargje në C # në të njëjtën mënyrë si në gjuhët e tjera të programimit. Sidoqoftë, ato kanë një veçori: ato zbatohen si objekte.

Përdorimi i një grupi në një program kërkon një procedurë me dy hapa, pasi C # zbaton vargje si objekte. Së pari, duhet të deklaroni një variabël që mund të hyjë në grup. Dhe së dyti, ju duhet të instantoni grupin duke përdorur operatorin e ri.

Përdorimi i Sistemit; duke përdorur System.Collections.Generic; duke përdorur System.Linq; duke përdorur System.Text; namespace ConsoleApplication1 (Programi i klasës (programi statik i zbrazët (statike args) (// Deklaroni një grup int myArr = int i ri; // Inicializoni çdo element të grupit manualisht myArr = 100; myArr = 23; myArr = 25; myArr = 31; myArr = 1 ; foreach (int i në myArr) Konsola.WriteLine (i); Console.ReadLine ();)))

Duhet të kihet parasysh se nëse një grup deklarohet vetëm por nuk inicializohet në mënyrë eksplicite, secili prej elementeve të tij do të vendoset në vlerën e paracaktuar për llojin përkatës të të dhënave (për shembull, elementët e një grupi të tipit bool do të vendosen në false , dhe elementet e një grupi të tipit int do të vendosen në 0).

Inicializimi i grupit

Përveç plotësimit të një elementi të grupit për element (siç tregohet në shembullin e mëparshëm), mund ta plotësoni gjithashtu duke përdorur një sintaksë të inicializimit të grupit të personalizuar. Për ta bërë këtë, duhet të rendisni elementët që do të përfshihen në grup në kllapa kaçurrelë (). Kjo sintaksë është e dobishme kur krijoni një grup me madhësi të njohur, kur duhet të vendosni shpejt vlerat e tij fillestare:

// Sintaksa për inicializimin e një grupi duke përdorur // fjalen kyçe new int myArr = new int (10,20,30,40,50); // Sintaksë për inicializimin e një grupi pa përdorur // fjalën kyçe new string info = ("Mbiemri", "Emri", "Patronimi"); // Përdorni fjalën kyçe të re dhe madhësinë e dëshiruar simbol char = char i ri ("X", "Y", "Z", "M");

Vini re se kur përdorni sintaksën e kllapave kaçurrelë, nuk keni nevojë të specifikoni madhësinë e grupit (siç mund ta shihni në shembullin e krijimit të ndryshores myArr), pasi kjo madhësi llogaritet automatikisht bazuar në numrin e elementeve brenda kaçurrelës mbajtëset. Gjithashtu, aplikoni fjalën kyçe i ri opsionale (si kur krijoni grupin e informacionit).

Fjala kyçe var ju lejon të përcaktoni një variabël në mënyrë që lloji themelor të përcaktohet nga përpiluesi. Në mënyrë të ngjashme, ju gjithashtu mund të përcaktoni vargje lokale të shtypura në mënyrë implicite. Duke përdorur këtë qasje, ju mund të përcaktoni një variabël të ri të grupit pa specifikuar llojin e elementeve të përfshira në grup. Le të marrim një shembull:

Përdorimi i Sistemit; duke përdorur System.Collections.Generic; duke përdorur System.Linq; duke përdorur System.Text; namespace ConsoleApplication1 (Programi i klasës (programi statik i zbrazët (args varg) (var arr1 = i ri (1, 2, 3); Console.WriteLine ("lloji Arr1 - (0)", arr1.GetType ()); var arr2 = i ri ("Një", "Dy", "Tre"); Console.WriteLine ("Lloji i grupit arr2 - (0)", arr2.GetType ()); Console.ReadLine ();)))

Natyrisht, si me krijimin e një grupi duke përdorur sintaksë eksplicite C #, elementët e specifikuar në listën e inicializimit të grupit duhet të jenë të të njëjtit lloj bazë (d.m.th., të gjithë duhet të jenë int, string ose MyCar).

Përcaktimi i një grupi objektesh

Në shumicën e rasteve, gjatë përcaktimit të një grupi, lloji i elementit të përfshirë në grup specifikohet në mënyrë eksplicite. Edhe pse kjo tingëllon mjaft e thjeshtë në shikim të parë, ekziston një veçori e rëndësishme. Çdo lloj në sistemin e tipit .NET (duke përfshirë llojet themelore të të dhënave) përfundimisht bazohet në klasën bazë System.Object. Si rezultat, rezulton se në rastin e përcaktimit të një grupi objektesh, elementët brenda tij mund të jenë çdo gjë:

Përdorimi i Sistemit; duke përdorur System.Collections.Generic; duke përdorur System.Linq; duke përdorur System.Text; namespace ConsoleApplication1 (programi i klasës (programi statik i zbrazët (statike args) (// Deklaroni dhe inicializoni një grup objektesh të objektit arrByObject = (e vërtetë, 10, "Përshëndetje", 13.7 m); // Printoni në konsolë llojin e secilit anëtar e grupit foreach (object me në arrByObject) Console.WriteLine ("Type (0) - (1)", me, me.GetType ()); Console.ReadLine ();)))

Kur zgjidhni probleme me një sasi të madhe të dhënash të të njëjtit lloj, përdorimi i variablave me emra të ndryshëm, të pa renditur sipas adresave të memories, e ndërlikon programimin. Në raste të tilla, C përdor objekte të quajtura vargje.

Është një pjesë e memories ngjitur që përmban një sekuencë objektesh të të njëjtit lloj, të shënuar me një emër.

Vargu karakterizohet nga konceptet themelore të mëposhtme:

Elementi i grupit (vlera e elementit të grupit)- vlera e ruajtur në një vendndodhje specifike memorie të vendosur brenda grupit, si dhe adresa e këtij lokacioni memorie.
Çdo element i grupit karakterizohet nga tre vlera:

• adresa e elementit - adresa e qelizës fillestare të memories në të cilën ndodhet ky element;
• indeksi i elementit (numri rendor i elementit në grup);
• vlera e elementit.

Adresa e grupit - adresa e elementit fillestar të grupit.

Emri i grupit është një identifikues që përdoret për t'iu referuar elementeve të grupit.

Madhësia e grupit - numri i elementeve të grupit

Madhësia e elementit - numri i bajteve të zëna nga një element i grupit.

Grafikisht, vendndodhja e grupit në memorien e kompjuterit mund të paraqitet si një shirit i vazhdueshëm adresash.

Vargu i paraqitur në figurë përmban q elementë me indekse nga 0 në q-1. Çdo element zë k byte në memorien e kompjuterit dhe renditja e elementeve në memorie është sekuenciale.

Adresat e elementit i-të të grupit kanë vlerën

Adresa e grupit është adresa e elementit fillestar (zero) të grupit. Për të hyrë në elementët e një grupi, përdoret rendorja (indeksi) i elementit, vlera fillestare e të cilit është 0. Pra, nëse grupi përmban q elementë, atëherë indekset e elementeve të grupit ndryshojnë në intervalin nga 0 në q-1.

Gjatësia e vargut - numri i bajteve të alokuara në memorie për ruajtjen e të gjithë elementëve të grupit.

Gjatësia e grupit = Madhësia e artikullit * Sasia e artikullit

Për të përcaktuar madhësinë e një elementi të grupit, mund të përdoret funksioni

madhësia int (lloji);

Për shembull,

madhësia e (char) = 1;
madhësia e (int) = 4;
madhësia e (float) = 4;
madhësia (dyfish) = 8;

Deklarimi dhe inicializimi i vargjeve

Për të deklaruar një grup në C, përdoret sintaksa e mëposhtme:

emri i tipit [dimension] = (initializimi);

Inicializimi është një grup vlerash fillestare për elementët e grupit, të specifikuara në kllapa kaçurrelë dhe të ndara me presje.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // grup a prej 10 numrash të plotë

Nëse numri i vlerave të inicializimit të specifikuara në kllapat kaçurrelë është më i vogël se numri i elementeve të grupit të specifikuar në kllapa katrore, atëherë të gjithë elementët e mbetur në grup (për të cilët nuk kishte vlera të mjaftueshme inicializimi) do të jenë të barabartë me zero. Kjo veti është e dobishme për vendosjen e vlerave zero për të gjithë elementët e një grupi.

int b = (0); // grup b me 10 elementë, i inicializuar në 0

Nëse grupi inicializohet gjatë deklarimit, atëherë vlerat konstante fillestare të elementeve të tij specifikohen, të ndara me presje, në kllapa kaçurrelë. Në këtë rast, numri i artikujve në kllapa katrore mund të hiqet.

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

Kur aksesoni elementët e grupit, indeksi i elementit të kërkuar tregohet në kllapa katrore.

Shembull në C

1
2
3
4
5
6
7
8

#përfshi
int main ()
{
int a = (5, 4, 3, 2, 1); // grupi a përmban 5 elemente
printf ("% d% d% d% d% d \ n", a, a, a, a, a);
getchar ();
kthimi 0;
}

Rezultati i ekzekutimit të programit:

Sidoqoftë, shpesh është e nevojshme të vendosni vlerat e elementeve të grupit gjatë ekzekutimit të programit. Kjo përdor një deklaratë vargu pa inicializim. Në këtë rast, kërkohet të tregohet numri i elementeve në kllapa katrore.

int a;

Për të vendosur vlerat fillestare të elementeve të grupit, përdoret shumë shpesh një lak parametrik:

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

#përfshi
int main ()
{
int a;
int i;
// Futja e elementeve të grupit
për (i = 0; i<5; i++)
{
printf ("a [% d] =", i);
scanf ("% d", & a [i]);
}
// Dalja e elementeve të grupit
për (i = 0; i<5; i++)
printf ("% d", a [i]); // kërkohet hapësira në formatin e printimit
getchar (); getchar ();
kthimi 0;
}

Rezultati i ekzekutimit të programit

Vargjet shumëdimensionale

Vargjet shumëdimensionale mund të deklarohen gjithashtu në C. Dallimi midis një grupi shumëdimensional dhe një grupi njëdimensional është se në një grup njëdimensional, pozicioni i një elementi përcaktohet nga një indeks, dhe në një grup shumëdimensional - nga disa. Një shembull i një grupi shumëdimensional është një matricë.

Forma e përgjithshme e deklarimit të një grupi shumëdimensional

shkruani emrin [dimension1] [dimension2] ... [dimensionm];

Elementet e një grupi shumëdimensional janë të vendosur në qelizat sekuenciale të kujtesës me akses të rastësishëm në rendin rritës të adresave. Në kujtesën e kompjuterit, elementët e një grupi shumëdimensional janë të rregulluar në një rresht, për shembull, një grup me 2 rreshta dhe 3 kolona,

int a;

do të vendoset në memorie si më poshtë

Numri i përgjithshëm i elementeve në grupin e dhënë dydimensional përcaktohet si

Numri i rreshtave * Numri i kolonave = 2 * 3 = 6.

Numri i bajteve të memories që kërkohet për të akomoduar grupin përcaktohet si

Numri i artikujve * Madhësia e artikujve = 6 * 4 = 24 bajt.

Inicializimi i vargjeve shumëdimensionale

Vlerat e elementeve të një grupi shumëdimensional, si në rastin njëdimensional, mund të specifikohen me vlera konstante kur deklarohen, të mbyllura në kllapa kaçurrelë (). Sidoqoftë, në këtë rast, treguesi i numrit të elementeve në rreshta dhe kolona duhet të tregohet në kllapa katrore.

Shembull në C

1
2
3
4
5
6
7
8
9

#përfshi
int main ()
{
int a = (1, 2, 3, 4, 5, 6);
printf ("% d% d% d \ n", a, a, a);
getchar ();
kthimi 0;
}

Sidoqoftë, më shpesh duhet të futni vlerat e elementeve të një grupi shumëdimensional gjatë ekzekutimit të programit. Për këtë qëllim, është e përshtatshme të përdoret një lak parametrik i mbivendosur.

Shembull në 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
#përfshi
int main ()
{
int a; // grup me 2 rreshta dhe 3 kolona
int i, j;
// Futja e elementeve të grupit
për (i = 0; i<2; i++) // qark nëpër linja
{
për (j = 0; j<3; j++) // kaloni nëpër kolona
{
printf ("a [% d] [% d] =", i, j);
scanf ("% d", & a [i] [j]);
}
}
// Dalja e elementeve të grupit
për (i = 0; i<2; i++) // qark nëpër linja
{
për (j = 0; j<3; j++) // kaloni nëpër kolona
{
printf ("% d", a [i] [j]);
}
printf ("\ n"); // linjë e re
}
getchar (); getchar ();
kthimi 0;
}

Kalimi i një vargu te një funksion

Është i përshtatshëm për të organizuar përpunimin e vargjeve duke përdorur funksione të veçanta. Për të përpunuar grupin si argumente të funksionit, duhet të kaloni

• adresa e grupit,
• madhësia e grupit.

Përjashtim bëjnë funksionet e përpunimit të vargjeve, të cilave mjafton t'u kalohet vetëm adresa.

Kur kalohen variabla si argumente në një funksion, të dhënat kalohen si kopje. Kjo do të thotë që nëse një ndryshim në vlerën e një parametri ndodh brenda funksionit, kjo nuk do të ndikojë në asnjë mënyrë vlerën e tij në funksionin thirrës.

Nëse adresa e një variabli (ose adresa e një grupi) i kalohet një funksioni, atëherë të gjitha operacionet e kryera në funksion me të dhëna brenda fushëveprimit të adresës së specifikuar kryhen në të dhënat origjinale, kështu që grupi origjinal (ose vlera e ndryshores) mund të ndryshohet nga funksioni i thirrur.

Një shembull në C Dan është një grup prej 10 elementësh. Ndërroni elementet më të mëdha dhe fillestare të grupit. Për operacionet e gjetjes së elementit maksimal dhe shkëmbimit, përdorni funksionin.

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
#përfshi
// Funksioni i shkëmbimit
ndryshimi i zbrazët (int * x, int n)
{
// x - treguesi në grup (adresa e grupit)
// n është madhësia e grupit
int i;
int max, indeks;
max = x;
indeksi = 0;
// Gjeni elementin maksimal
për (i = 1; i {
nëse (x [i]> max)
{
max = x [i];
indeksi = i;
}
}
// Shkëmbim
x = x;
x = max;
}
// Funksioni kryesor
int main ()
{
int a;
int i;
për (i = 0; i<10; i++)
{
printf ("a [% d] =", i);
scanf ("% d", & a [i]);
}
ndryshim (a, 10); // thirrni funksionin e shkëmbimit
// Dalja e elementeve të grupit
për (i = 0; i<10; i++)
printf ("% d", a [i]);
getchar ();
getchar ();
kthimi
p = p * x [i];
}
kthimi p;
}
// Funksioni kryesor
int main ()
{
int a; // deklaroi një grup a me 5 elementë
int i;
int pr;
// Futja e elementeve të grupit
për (i = 0; i<5; i++)
{
printf ("a [% d] =", i);
scanf ("% d", & a [i]); // & a [i] - adresa e elementit i-të të grupit
}
pr = func (a, 5); // llogarit produktin
printf ("\ n pr =% d", pr); // nxjerr produktin e elementeve çift
getchar (); getchar ();
kthimi 0;
}

Ju lutemi pezulloni AdBlock në këtë sajt.

Array është lloji më i thjeshtë i të dhënave të përbërë. Kur diskutuam për variablat, kishim një analogji të mirë kuti. Le të kthehemi tek ajo. Nëse një variabël është një kuti, atëherë një grup është disa kuti identike të numëruara që kanë të njëjtin emër dhe ndryshojnë vetëm nga numri i tyre rendor.

Fig.1 Variablat dhe vargjet. Analogji me kutitë.

Fotografia e mësipërme tregon tre grupe:

• një grup i plotë me 8 elementë të quajtur arr_int
• një grup real prej 11 elementësh të quajtur arr_float
• një grup karakteresh me 6 elementë të quajtur arr_char

Një grup, si një variabël, ka emrin dhe llojin e vet të të dhënave. Përveç kësaj, grupi ka një karakteristikë shtesë - madhësinë e grupit. Madhësia e një grupi është numri i elementeve që mund të ruhen në të. Në analogjinë tonë të kutisë, ky është numri i kutive.

Shënim!

Elementet e grupit numërohen duke filluar nga zero, jo një.

Deklarimi dhe inicializimi i grupit

Një deklaratë vargu është shumë e ngjashme me një deklaratë variabël. Dallimi i vetëm është se ju duhet të tregoni gjithashtu madhësinë e grupit në kllapa katrore. Ketu jane disa shembuj:

Listimi 1.

Int arr_int; dyfishtë arr_float; numër notues;

Emrat e grupeve u nënshtrohen kufizimeve të ngjashme me ato të vendosura për emrat e variablave.

Rregulli i emërtimit të grupeve

Emri i grupit është çdo sekuencë karakteresh, numrash dhe nënvizimi "_" që fillon me një shkronjë. Rasti i shkronjave është i rëndësishëm.

Këtu janë disa shembuj të tjerë të deklarimit të vargjeve:

Listimi 2.

notat int, renditja; çmimet e dyfishta;

Një grupi, si çdo ndryshore, mund t'i caktohet vlera fillestare kur deklarohet. Nëse nuk u caktoni asnjë vlerë elementeve të grupit, atëherë mbeturinat do të ruhen në to, si në variablat e zakonshëm.

Listimi 3.

Int arr_int = (2, 5, 5, 3, 4); dyfishtë arr_float = (1.2, -2.3, 4.5, 3.83, 0.01, -0.12, 44.2, 123.7, 23.44, -3.7, 7);

Nëse keni nevojë të caktoni vlera zero për të gjithë elementët e grupit, atëherë mund ta bëni si kjo:

Listimi 4.

Arr i dyfishtë = (0);

Puna me elemente individuale të grupit

Për t'iu referuar një elementi individual të një grupi, duhet të shkruani emrin e tij dhe numrin e sekuencës në kllapa katrore. Mos harroni se numërimi fillon me zero, jo një.

Për shembull, le të printojmë elementet e një grupi me pesë elementë në ekran.

Listimi 5.

#përfshi int main (void) (int arr = (2, 4, 3, 5, 5); printf ("% d% d% d% d% d \ n", arr, arr, arr, arr, arr); kthim (0);)

Sigurisht, nëse grupi është shumë i madh, atëherë shfaqja e tij element pas elementi në një mënyrë të ngjashme është ende një kënaqësi. Dhe askush nuk e bën këtë me grupe të vogla. Është më mirë dhe më korrekte të përdoren sythe. Për shembull:

Listimi 6.

#përfshi int kryesore (void) (int arr = (0); për (int i = 0; i< 100; i = i + 1){ arr[i] = 2*i; } for(int i = 0; i < 100; i = i + 1){ printf("%d\t",arr[i]); } return(0); }

Në ciklin e parë, programi ruan njëqind numrat e parë çift në grup, dhe në ciklin e dytë i shfaq ato në ekran.

Të armatosur me mjetet e reja, le të rishkruajmë programin tonë që nga fillimi i mësimit për të përdorur një grup për të ruajtur statistikat mbi numrat e rastësishëm.

Listimi 7.

#përfshi #përfshi #përfshi int main (void) (srand (koha (NULL)); int count = (0); int rand_number; for (int i = 0; i< 100000; i = i + 1){ rand_number = rand()%3; count = count + 1; } for(int i = 0; i < 3; i = i + 1){ printf("%d - %d\n", i, count[i]); } return 0; }

Kushtojini vëmendje teknikës së përdorur në këtë program.
Elementi zero i grupit ruan numrin e dukurive të numrit 0, në elementin e parë - numrin e dukurive të numrit 1, në elementin e dytë - numrin 2. Kjo do të thotë, vetë numri i gjeneruar ju lejon të përcaktoni se cilit element të grupit duhet të shtoni një. Prandaj, nuk ka nevojë për një deklaratë të përzgjedhjes së ndërprerësit. I përshtatshëm, apo jo?

Por ne duhet të punojmë me një sasi të madhe të dhënash të të njëjtit lloj. Për shembull, ne kemi një mijë matje të koordinatave të një lavjerrës me një hap kohor. Është shumë e rëndë të krijosh 1000 variabla për të ruajtur të gjitha vlerat. Në vend të kësaj, shumë të të njëjtit lloj të dhënash mund të kombinohen me një emër dhe t'i referohen çdo elementi specifik me numrin e tij rendor.
Një grup në C përcaktohet si më poshtë
<тип> <имя массива>[<размер>];
Për shembull,
int a;
Do të marrim një grup me emër a i cili përmban njëqind elementë të llojit ndër... Ashtu si me variablat, grupi përmban mbeturina.
Për të hyrë në elementin e parë, shkruani numrin (indeksin) e tij në kllapa katrore. për shembull

#përfshi #përfshi void main () (int a; a = 10; a = 333; a = 234; printf ("% d% d% d", a, a, a); getch ();)

Elementi i parë numërohet 0. Është e rëndësishme të kuptohet pse. Në vijim, ne do të paraqesim kujtesën e kompjuterit në formën e një shiriti. Emri i grupit është një tregues në adresën e memories ku ndodhen elementët e grupit.

Oriz. 1 Array ruan adresën e elementit të parë. Indeksi i elementit i është një zhvendosje prej i * madhësisë (lloji) bajt që nga fillimi

Indeksi i grupit tregon se sa bajt duhet të zhvendosen nga fillimi i grupit për të hyrë në elementin e dëshiruar. Për shembull, nëse grupi Aështë i llojit ndër, atëherë A do të thotë që ne kemi zhvendosur 10 * madhësinë e (int) bajteve nga fillimi. Elementi i parë është në fillim dhe ka një zhvendosje prej 0 * sizeof (int).
Në C, një grup nuk ruan madhësinë e tij dhe nuk kontrollon indeksin e grupit për korrektësi. Kjo do të thotë që ju mund të dilni jashtë grupit dhe t'i referoheni memories që është më larg se elementi i fundit i grupit (ose më afër).

Inicializimi fillestar i grupit.

Le të shkruajmë një program të thjeshtë. Le të krijojmë një grup dhe më pas të gjejmë elementin e tij maksimal.

#përfshi #përfshi void main () (int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); i panënshkruar; int max; max = a; për (i = 1; i<10; i++) { if (a[i] >

Le të shohim një shembull. Së pari, ne krijojmë një grup dhe e inicializojmë atë në krijimin. Pas kësaj, ne caktojmë vlerën e elementit të parë të grupit në elementin maksimal të gjetur.

Max = a;

Pastaj kalojmë nëpër grup. Meqenëse ne kemi parë tashmë elementin e parë (ai ka një indeks prej 1), nuk ka kuptim ta shikojmë përsëri.
I njëjti shembull, vetëm tani përdoruesi fut vlerat

#përfshi #përfshi void main () (int a; i panënshkruar i; int max; printf ("Fut 10 numra \ n"); për (i = 0; i<10; i++) { printf("%d. ", i); scanf("%d", &a[i]); } max = a; for (i = 1; i<10; i++) { if (a[i] >max) (max = a [i];)) printf ("elementi maksimal është% d", max); getch (); )

Në rast se gjatë inicializimit specifikohen më pak vlera sesa madhësia e grupit, elementët e mbetur mbushen me zero.

#përfshi #përfshi kryesore e pavlefshme () (int a = (1,2,3); i panënshkruar; për (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

Nëse është e nevojshme të mbushni të gjithë grupin me zero, atëherë shkruani

Int a = (0);

Është e mundur të mos vendoset në mënyrë eksplicite madhësia e grupit, për shembull

Int a = (1, 2, 3);

grupi do të ketë madhësinë 3

Madhësia e grupit

M assiv në si duhet të ketë një madhësi konstante. Kjo do të thotë që është e pamundur, për shembull, të kërkosh nga përdoruesi një madhësi dhe më pas ta vendosësh këtë madhësi në një grup.

Printf ("Fut gjatësinë e grupit"); scanf ("% d", & gjatësi); (float x;)

Krijimi i vargjeve dinamike do të diskutohet më vonë, kur punoni me tregues dhe memorie.
Në disa raste, mund të zbuloni madhësinë e grupit duke përdorur funksionin madhësia e.

#përfshi #përfshi void main () (int A; // sizeof kthen madhësinë e të gjithë grupit në bajt // Për të përcaktuar numrin e elementeve, // ndani madhësinë e grupit me madhësinë e elementit të tij int size = sizeof (A) / sizeof (int); printf ("Madhësia e grupit është e barabartë me% d", madhësia); getch ();)

Por kjo nuk ka gjasa të jetë e dobishme. Kur kalon një varg, një tregues do t'i kalohet si argument funksionit, kështu që madhësia e grupit do të jetë e pamundur të dihet.
Vargjet statike janë të dobishme kur numri i elementeve dihet paraprakisht. Ato ofrojnë akses të shpejtë por të pasigurt në elementë.

Mbushje e vargut

Nxitoni, ju keni një kod të tillë

Int A; int i; për (i = 0; i<=10; i++) { A[i] = 1; }

Këtu laku për specifikuar me një gabim. Në disa versione të vjetra të përpiluesve, ky kod u mbërthye në një lak të pafund. Çështja është se ndryshorja i ishte vendosur në përpilim menjëherë pas grupit A... Kur kaloni përtej kufijve të grupit, numëruesi u konvertua në 1.
Vargjet janë të pasigurta, pasi puna jo e duhur me indeksin mund të çojë në akses në një zonë arbitrare të memories (Teorikisht, përpiluesit modernë kujdesen për veten tuaj që të mos gërmoni në kujtesën e dikujt tjetër).
Nëse punoni me vargje, atëherë duhet të siguroheni që numëruesi të mos e kalojë madhësinë e grupit dhe të mos jetë negativ. Për këtë të paktën,

• 1. Përdorni llojin size_t për indeksimin. Do t'ju mbrojë nga vlerat negative dhe do të jetë gjithmonë e mjaftueshme për një grup të çdo madhësie.
• 2. Mos harroni se grupi fillon në zero.
• 3. Elementi i fundit i grupit ka një indeks (madhësia e grupit - 1)

Nuk ka metoda të plota për të kontrolluar nëse kemi shkuar përtej kufijve të grupit apo jo. Prandaj, ose e dimë me siguri madhësinë e tij, ose e ruajmë në një variabël dhe e lexojmë sipas nevojës.

Shembuj të

Këtu janë disa shembuj tipikë të punës me vargje.
1. Kthejeni grupin.

#përfshi #përfshi // Kjo është një makro. SIZE në kod do të zëvendësohet me 10u #define SIZE 10u void main () (int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); i panënshkruar i, j; // numërues i panënshkruar gjysma; // mesi i grupit të panënshkruar tmp; // ndryshore e përkohshme për shkëmbimin e vlerave gjysma = SIZE / 2; // Një numërues shkon nga e majta në të djathtë, tjetra nga e djathta në të majtë për (i = 0, j = MADHËSIA - 1; i< half; i++, j--) { tmp = A[i]; A[i] = A[j]; A[j] = tmp; } for (i = 0; i < SIZE; i++) { printf("%d ", A[i]); } getch(); }

Këtu është një ndërtim i panjohur për ju

#define SIZE 10u

makro. Gjatë gjithë kodit, paraprocesori do të zëvendësojë automatikisht të gjitha dukuritë e SIZE me 10u.
2. Fshirja e një artikulli të zgjedhur nga përdoruesi.

#përfshi #përfshi #define SIZE 10u void main () (int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); i panënshkruar; // indeksi counter int; // indeksi i futur nga përdoruesi / / Nxjerr grupin për (i = 0; i< SIZE; i++) { printf("(%d)=%d ", i, A[i]); } //Просим пользователя ввести валидный индекс while (1) { printf("\nEnter index of element to delete "); scanf("%d", &index); if (index >0 && indeksi< SIZE) { break; } } //Копируем следующий элемент массива на место удаляемого //и так до конца for (i = index; i < SIZE-1; i++) { A[i] = A; } //Выводим результат for (i = 0; i < SIZE-1; i++) { printf("(%d)=%d ", i, A[i]); } getch(); }

Elementi nuk fshihet në këtë rast, natyrisht. Vargu mbetet në të njëjtën madhësi si më parë. Ne thjesht mbishkruajmë artikullin e fshirë me atë tjetër dhe nxjerrim SIZE-1 të artikujve.
3. Përdoruesi fut vlerat në grup. Pas kësaj, printoni të gjitha vlerat e ndryshme që ai futi.
Lëreni përdoruesin të fusë një numër të kufizuar elementesh, le të themi 10. Më pas dihet paraprakisht se nuk do të ketë më shumë se 10 vlera të ndryshme në total. Sa herë që përdoruesi fut një numër, ne do të kalojmë nëpër grup dhe kontrolloni nëse një numër i tillë është futur.

#përfshi #përfshi #define SIZE 10u void main () (int A = (0); i panënshkruar i, j; int counter = 1; // sa numra të ndryshëm janë futur. Të paktën një. int input; int wasntFound; // flamur se numri i futur nuk u gjet // Fut numrin e parë. Nuk është hasur ende. printf ("0."); scanf ("% d", & A); për (i = 1; i< SIZE; i++) { printf("%d. ", i); scanf("%d", &input); wasntFound = 1; //Проверяем, встречалось ли такое число. Если да, //то выставляем флаг и выходим из цикла for (j = 0; j <= counter; j++) { if (input == A[j]) { wasntFound = 0; break; } } //Если флаг был поднят, то заносим число в массив if (wasntFound) { A = input; counter++; } } for (i = 0; i < counter; i++) { printf("%d ", A[i]); } getch(); }

4. Përdoruesi fut një numër - numrin e matjeve (nga 2 në 10). Pastaj hyn në të gjitha matjet. Programi jep vlerën mesatare, variancën, gabimin.

#përfshi #përfshi #përfshi #define SIZE 20u void main () (// Koeficientët e studentit fillojnë nga dy dimensione konst float student = (12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3); float A; limit i panënshkruar; uns; float tmp; float sum = .0f; float mean; float disp; float absError; float relGabim; bëj (printf ("Fut numrin e matjeve"); scanf ("% u", & limit); nëse (kufizim> 1 && limit< 11) { break; } } while(1); for (i = 0; i < limit; i++) { printf("#%d: ", i); scanf("%f", &A[i]); sum += A[i]; } mean = sum / (float)limit; sum = .0f; for (i = 0; i < limit; i++) { tmp = A[i] - mean; sum += tmp * tmp; } disp = sum / (float)limit; absError = student * sqrt(sum / (float)(limit - 1)); relError = absError / mean * 100; printf("Mean = %.6f\n", mean); printf("Dispertion = %.6f\n", disp); printf("Abs. Error = %.6f\n", absError); printf("Rel. Error = %.4f%", relError); getch(); }

5. Renditja e grupit me një flluskë

#përfshi #përfshi #define SIZE 10 #define false 0 #define true! false void main () (float a = (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 0.0 f); float tmp; i panënshkruar i, j; flamuri char; // Nxjerr grupin për (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } printf("\n"); //Пока массив не отсортирован do { flag = false; //Проходим по массиву. Если следующий элемент больше предыдущего, то //меняем их местами и по новой проверяем массив for (i = 1; i < SIZE; i++) { if (a[i] >a) (tmp = a [i]; a [i] = a; a = tmp; flamuri = i vërtetë;))) ndërsa (flamuri == i vërtetë); // Printoni grupin e renditur për (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Përzieni grupin. Për këtë do të përdorim algoritmin