Kako izgleda niz u c. Statički niz: deklaracija, punjenje, korištenje. Inicijalizacija početnog polja

Zadnje ažuriranje: 17.09.2017

Niz predstavlja skup podataka iste vrste. Formalna definicija niza je sljedeća:

Variable_type array_name [array_length]

Nakon tipa varijable dolazi naziv niza, a zatim in uglate zagrade njegova veličina. Na primjer, definirajmo niz od 4 broja:

Int brojevi;

Ovaj niz ima četiri broja, ali svi ti brojevi imaju nedefiniranu vrijednost. Međutim, možemo izvršiti inicijalizaciju i dodijeliti neke početne vrijednosti ovim brojevima kroz vitičaste zagrade:

Int brojevi = (1,2,3,4);

Vrijednosti u vitičaste zagrade također se nazivaju inicijalizatori. Ako postoji manje inicijalizatora nego što ima elemenata u nizu, tada se inicijalizatori koriste za prve elemente. Ako ima više inicijalizatora nego elemenata u nizu, tada će se pojaviti pogreška tijekom kompilacije:

Int brojevi = (1, 2, 3, 4, 5, 6);

Ovdje niz ima veličinu 4, ali mu se prosljeđuje 6 vrijednosti.

Ako veličina niza nije eksplicitno navedena, ona se zaključuje iz broja inicijalizatora:

Int brojevi = (1, 2, 3, 4, 5, 6);

U ovom slučaju niz ima 6 elemenata.

Inicijalizacija nizova znakova ima svoje osobitosti. Možemo proslijediti i skup inicijalizatora i niz nizu znakova:

Znak s1 = ("h", "e", "l", "l", "o"); char s2 = "svijet";

Štoviše, u drugom slučaju, niz s2 neće imati 5 elemenata, već 6, jer kada se inicijalizira s nizom, nulti znak "\0" automatski se dodaje nizu znakova.

U ovom slučaju nije dopušteno dodjeljivanje jednog polja drugom polju:

Int nums1 = (1,2,3,4,5); int brojevi2 = brojevi1; // pogreška nums2 = nums1; // pogreška

Nakon što je niz definiran, možemo mu pristupiti pojedinačni elementi po indeksu. Indeksi počinju od nule, tako da za pristup prvom elementu moramo koristiti indeks 0. Pristupom elementu po indeksu možemo dobiti njegovu vrijednost ili je promijeniti:

#uključi int main() ( int brojevi = (1,2,3,4); int prvi_broj = brojevi; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

Broj elemenata niza također se može odrediti preko konstante:

Const int n = 4; int brojevi[n] = (1,2,3,4);

Ponavljanje nizova

Koristeći petlje, možete iterirati kroz cijeli niz i pristupiti njegovim elementima putem indeksa:

#uključi int main() ( int brojevi = (1,2,3,4); int veličina = sizeof(brojevi)/sizeof(brojevi); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Da biste prošli kroz niz, prvo morate pronaći duljinu niza. Za pronalaženje duljine koristi se operator sizeof. U osnovi, duljina niza jednaka je ukupnoj duljini njegovih elemenata. Svi elementi predstavljaju isti tip i zauzimaju istu veličinu u memoriji. Stoga pomoću izraza sizeof(numbers) nalazimo duljinu cijelog niza u bajtovima, a pomoću izraza sizeof(numbers) nalazimo duljinu jednog elementa u bajtovima. Dijeljenjem dviju vrijednosti možete dobiti broj elemenata u nizu. Zatim, koristeći for petlju, ponavljamo kroz sve elemente dok brojač i ne postane jednak duljini niza. Kao rezultat toga, svi elementi niza bit će prikazani na konzoli:

Ali postoji i drugi oblik for petlje, koji je dizajniran posebno za rad sa kolekcijama, uključujući nizove. Ovaj obrazac ima sljedeću formalnu definiciju:

Za (tip varijable: zbirka) ( upute; )

Koristimo ovaj obrazac za ponavljanje niza:

#uključi int main() ( int brojevi = (1,2,3,4); for(int broj: brojevi) std::cout<< number << std::endl; return 0; }

Prilikom ponavljanja niza, svaka stavka koja se ponavlja bit će smještena u brojčanu varijablu, čija se vrijednost ispisuje na konzoli u petlji.

Ako ne znamo vrstu objekata u nizu, možemo upotrijebiti auto specifikator da odredimo vrstu:

Za(automatski broj: brojevi) std::cout<< number << std::endl;

Višedimenzionalni nizovi

Osim jednodimenzionalnih nizova u C++-u postoje i višedimenzionalni. Elementi takvih nizova sami su nizovi, u kojima elementi također mogu biti nizovi. Na primjer, definirajmo dvodimenzionalni niz brojeva:

Int brojevi;

Takav niz se sastoji od tri elementa, pri čemu svaki element predstavlja niz od dva elementa. Inicijalizirajmo niz ovako:

Int brojevi = ( (1, 2), (4, 5), (7, 8) );

Ugniježđene vitičaste zagrade ocrtavaju elemente za svaku podnizu. Takav niz se također može predstaviti kao tablica:

Također možete izostaviti vitičaste zagrade tijekom inicijalizacije:

Int brojevi = ( 1, 2, 4, 5, 7, 8 );

Također je moguće inicijalizirati ne sve elemente, već samo neke:

Int brojevi = ( (1, 2), (), (7) );

A za pristup elementima ugniježđenog niza potrebna su vam dva indeksa:

Int brojevi = ( (1, 2), (3, 4), (5, 6) ); std::cout<< numbers << std::endl; // 3 numbers = 12; // изменение элемента std::cout << numbers << std::endl; // 12

Iterirajmo preko dvodimenzionalnog niza:

#uključi int main() ( const int redaka = 3, stupaca = 2; int brojeva = ( (1, 2), (3, 4), (5, 6) ); for(int i=0; i< rows; i++) { for(int j=0; j < columns; j++) { std::cout << numbers[i] [j] << "\t"; } std::cout << std::endl; } return 0; }

Također možete koristiti drugi oblik for petlje za ponavljanje kroz elemente višedimenzionalnog niza:

#uključi int main() ( const int redovi = 3, stupci = 2; int brojevi = ( (1, 2), (3, 4), (5, 6) ); for(auto &podbrojevi: brojevi) ( for(int broj : podbrojevi) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

Za iteraciju nizova koji su uključeni u niz, koriste se reference. To jest, u vanjskoj petlji for(auto &podbrojevi: brojevi) &podbrojevi predstavljaju referencu podniza u nizu. U unutarnjoj petlji for(int number: subnumbers), iz svakog podniza u podbrojevima dobivamo njegove pojedinačne elemente u varijablu broja i ispisujemo njegovu vrijednost na konzolu.

Recimo da moramo raditi s velikom količinom podataka iste vrste. Na primjer, imamo tisuću mjerenja koordinata njihala s nekim vremenskim korakom. Stvaranje 1000 varijabli za pohranjivanje svih vrijednosti vrlo je... glomazno. Umjesto toga, mnogi isti tipovi podataka mogu se kombinirati pod jednim imenom i svakom specifičnom elementu može se pristupiti njegovim serijskim brojem.
Niz u C-u definiran je na sljedeći način
<тип> <имя массива>[<размер>];
Na primjer,
int a;
Dobit ćemo niz pod nazivom a, koji sadrži stotinu elemenata tipa int. Kao i kod varijabli, polje sadrži smeće.
Za pristup prvom elementu upišite njegov broj (indeks) u uglate zagrade. Na primjer

#uključi #uključi void main() ( int a; a = 10; a = 333; a = 234; printf("%d %d %d", a, a, a); getch(); )

Prvi element ima indeksni broj 0. Važno je razumjeti zašto. U nastavku ćemo memoriju računala prikazati kao vrpcu. Ime niza je pokazivač na memorijsku adresu na kojoj se nalaze elementi niza.

Riža. 1 Niz pohranjuje adresu prvog elementa. Indeks i elementa je pomak i*sizeof(type) bajtova od početka

Indeks niza pokazuje koliko bajtova mora biti pomaknuto od početka niza da bi se pristupilo željenom elementu. Na primjer, ako niz A ima tip int, tada A znači da smo pomaknuli 10*sizeof(int) bajtova u odnosu na početak. Prvi element je na samom početku i ima pomak 0*sizeof(int) .
U C-u polje ne pohranjuje svoju veličinu i ne provjerava ispravnost indeksa polja. To znači da možete izaći izvan niza i pristupiti memoriji koja je dalje od posljednjeg elementa niza (ili bliže).

Početna inicijalizacija niza.

Napišimo jednostavan program. Kreirajmo niz i zatim pronađimo njegov najveći element.

#uključi #uključi void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); unsigned i; int max; max = a; for (i = 1; i<10; i++) { if (a[i] >

Pogledajmo primjer. Prvo kreiramo niz i inicijaliziramo ga nakon stvaranja. Nakon toga, najvećem pronađenom elementu dodjeljujemo vrijednost prvog elementa niza.

Max = a;

Zatim prolazimo nizom. Budući da smo prvi element već pogledali (ima indeks 1), nema smisla ponovno ga gledati.
Isti primjer, samo što sada korisnik unosi vrijednosti

#uključi #uključi void main() ( int a; unsigned i; int max; printf("Unesite 10 brojeva\n"); for (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("max element je %d", max); dobiti(); )

Ako je tijekom inicijalizacije navedeno manje vrijednosti od veličine niza, preostali elementi popunjavaju se nulama.

#uključi #uključi void main() ( int a = (1,2,3); unsigned i; for (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

Ako trebate ispuniti cijeli niz nulama, tada napišite

Int a = (0);

Na primjer, ne morate eksplicitno odrediti veličinu niza

Int a = (1, 2, 3);

niz će imati veličinu 3

Veličina polja

Niz u C-u mora imati konstantnu veličinu. To znači da je nemoguće, na primjer, pitati korisnika za veličinu i zatim postaviti tu veličinu na niz.

Printf("Unesite duljinu niza "); scanf("%d", &duljina); (float x;)

O stvaranju dinamičkih nizova raspravljat ćemo dalje pri radu s pokazivačima i memorijom.
U nekim slučajevima možete saznati veličinu niza pomoću funkcije veličina.

#uključi #uključi void main() ( int A; //sizeof vraća veličinu cijelog niza u bajtovima //Da odredite broj elemenata, //podijelite veličinu niza s veličinom njegovog elementa int size = sizeof(A) / sizeof(int); printf("Veličina niza jednaka je %d", veličina); getch(); )

Ali malo je vjerojatno da će ovo biti korisno. Prilikom prosljeđivanja niza kao argumenta funkciji, bit će proslijeđen pokazivač, tako da veličina niza neće biti poznata.
Statički nizovi korisni su kada je broj elemenata unaprijed poznat. Omogućuju brz, ali nesiguran pristup elementima.

Prelijevanje polja

Nadajmo se da imate ovaj kôd

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

Evo petlje za navedeno s greškom. U nekim starijim verzijama prevoditelja, ovaj kod bi se ponavljao. Stvar je u tome da varijabla ja nalazio se tijekom kompilacije odmah nakon niza A. Kada je niz prešao granice, brojač je postavljen na 1.
Nizovi nisu sigurni, budući da pogrešan rad s indeksom može dovesti do pristupa proizvoljnom dijelu memorije (teoretski. Moderni prevoditelji sami brinu da ne zadirete u tuđu memoriju).
Ako radite s nizovima, morate osigurati da brojač ne premašuje veličinu niza i da nije negativan. Za ovo, u najmanju ruku,

• 1. Za indeksiranje koristite tip size_t. Zaštitit će vas od negativnih vrijednosti i uvijek će biti dovoljno za niz bilo koje veličine.
• 2. Zapamtite da niz počinje od nule.
• 3. Zadnji element niza ima indeks (veličina niza je 1)

Primjeri

Evo nekoliko tipičnih primjera rada s nizovima
1. Obrnite niz.

#uključi #uključi //Ovo je makronaredba. SIZE u kodu bit će zamijenjen s 10u #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i, j; // brojači unsigned half; //sredina niza unsigned tmp; //privremena varijabla za razmjenu vrijednosti half = SIZE / 2; //Jedan brojač ide s lijeva na desno, drugi s desna na lijevo za (i = 0, j = VELIČINA - 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(); }

Ovdje je dizajn koji vam nije poznat

#definiraj VELIČINU 10u

makro. U cijelom kodu, predprocesor će automatski zamijeniti sva pojavljivanja SIZE s 10u.
2. Brisanje elementa odabranog od strane korisnika.

#uključi #uključi #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i; //brojač int indeks; //indeks koji unosi korisnik / /Izlazni niz za (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 && indeks< 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(); }

U ovom slučaju, naravno, element se ne briše. Niz ostaje iste veličine kao prije. Jednostavno prepisujemo element koji se briše sljedećim i ispisujemo elemente SIZE-1.
3. Korisnik unosi vrijednosti u polje. Nakon toga ispišite sve različite vrijednosti koje je unio.
Neka korisnik unese konačan broj elemenata, recimo 10. Tada se unaprijed zna da ukupno neće biti više od 10 različitih vrijednosti. Svaki put kada korisnik unese broj, proći ćemo kroz niz i provjeriti da li je takav broj upisan.

#uključi #uključi #define SIZE 10u void main() ( int A = (0); unsigned i, j; int counter = 1; //koliko je različitih brojeva uneseno. Najmanje jedan. int input; int wasntFound; //oznaka da je uneseni broj nije pronađen //Unesite prvi broj. Još nije pronađen. printf("0. "); scanf("%d", &A); for (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. Korisnik upisuje broj - broj mjerenja (od 2 do 10). Nakon toga unosi sva mjerenja. Program prikazuje prosječnu vrijednost, varijancu i pogrešku.

#uključi #uključi #uključi #define SIZE 20u void main() ( //Studentski koeficijenti počinju od dvije dimenzije const float student = (12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3); float A; unsigned i; unsigned limit; float tmp; float sum = .0f; float mean; float disp; float absError; float relError; do ( printf("Unesite broj mjerenja "); scanf("%u", &limit); if (limit > 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. Mjehuričasto sortiranje polja

#uključi #uključi #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; unsigned i, j; char zastavica; //Izlaz niza za (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; zastavica = istina; ) ) ) dok(zastavica == istina); //Izlaz sortiranog niza za (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Pomiješajte niz. Upotrijebimo algoritam za ovo

Nizovi su izuzetno važna tema u C++. Oni se vrlo često koriste u programima i potrebno je temeljito razumjeti ovu temu. Odmah ću vas usrećiti - razumjeti i naučiti kako koristiti nizove prilično je jednostavno čak i za početnika.

Dakle, zašto su potrebni nizovi i što su oni? Do sada ste već dobro svjesni da se programski podaci pohranjuju u . Ali događa se da program treba pohraniti stotine (ili čak i više) varijabli iste vrste podataka, a također mora raditi s njima - dodjeljivati ​​vrijednosti, mijenjati ih itd.

Na primjer, trebate pohraniti serijske brojeve redaka. Slažem se - svatko bi se uplašio pomisli na stvaranje pet stotina varijabli tipa int, dajući svakoj jedinstveno ime i dodjeljujući joj vrijednost od 1 do 500. (Već se bojim :) U ovom slučaju jednostavno će nas spasiti nizovi.

Zabilježimo glavne točke i prijeđimo na praktični primjer:

• Niz u C++ je kolekcija određenog broja varijabli iste vrste koje imaju isto ime. npr. int polje;. Ovaj unos znači da smo deklarirali niz tzv niz, koji sadrži 3 varijable tipa int ;
• varijable polja nazivamo elementima;
• Svaki element ima svoj jedinstveni indeks - svoj serijski broj. Pomoću indeksa možemo pristupiti određenom elementu. VAŽNO - indeksiranje elemenata niza počinje od 0 . Dakle u nizu niz int prvi element ima indeks 0 , a posljednji je 2 . Da biste pristupili, na primjer, nultom elementu niza i promijenili njegovu vrijednost, trebate navesti naziv niza i označiti indeks elementa u uglatim zagradama - niz = 33 .

Pogledajmo primjer:

C++ nizovi

// u ovom programu stvaramo niz s veličinom veličine, // koristeći for petlju unosimo podatke u sve ćelije // niza i prikazujemo njihov sadržaj na ekranu #include korištenje imenskog prostora std; int main() ( setlocale(LC_ALL, "rus"); const int SIZE = 10; //deklariraj konstantu int firstArray; //deklariraj niz s brojem elemenata SIZE za (int i = 0; i< SIZE ; i++) //заполняем и отображаем значения на экран { firstArray[i] = i + 1; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray[i] << endl; } cout << endl; return 0; }

U retku 12 definiramo cjelobrojnu konstantu VELIČINA, koji će pohraniti veličinu niza (koji smo definirali, broj njegovih elemenata). U retku 13 deklariramo polje: označavamo vrstu podataka koji će biti pohranjeni u ćelijama polja, dajemo naziv i označavamo veličinu u uglatim zagradama.

Važno je da konstantne cjelobrojne vrijednosti možemo pisati samo u uglatim zagradama. Morate ili odmah unijeti cijeli broj u uglate zagrade kada deklarirate niz ( int prvi niz;), ili definirajte cjelobrojnu konstantu prije deklaracije niza i unesite naziv te konstante u uglate zagrade (kao u našem primjeru).

Poželjno je koristiti drugu metodu ako tijekom programa morate nekoliko puta pristupiti nizu kroz petlju. To se objašnjava činjenicom da kada deklariramo petlju, možemo u njoj specificirati uvjet za promjenu brojača u vrijednost VELIČINA .

Zamislite samo da trebamo promijeniti veličinu niza s 10 elemenata na 200. U ovom slučaju, sve što trebamo učiniti je promijeniti vrijednost konstante cijelog broja, i tako ćemo automatski zamijeniti nove vrijednosti veličine iu niz i u svim petljama programa.

U našem primjeru, možete pokušati dodati bilo koji drugi broj konstanti VELIČINA. I vidjet ćete da će program raditi odlično – napravit će niz s onoliko elemenata koliko vi odredite, unijeti podatke i prikazati ih na ekranu.

A ako je niz vrlo mali, na primjer s 5 elemenata, možete ga inicijalizirati odmah nakon deklaracije:

Dakle, element s indeksom 0 – firstArray– bit će dodijeljena vrijednost 11 , i posljednji element niza firstArray- značenje 1 5 . Postoji takav trik - ne možete naznačiti veličinu niza u uglatim zagradama i napisati ovo:

Prethodni unos je ekvivalentan ovom. Samo u drugom slučaju prevodilac će automatski izračunati veličinu niza na temelju količine podataka u vitičastim zagradama.

Također, tijekom početne inicijalizacije elemenata niza, kada niz treba očistiti od "smeća" (preostalih podataka iz drugih programa u memoriji), bolje je odmah dodijeliti vrijednost svim elementima 0 . Ovako izgleda:

Treba imati na umu da je takva inicijalizacija moguća samo za popunjavanje nulama. Ako elemente niza trebate popuniti nekim drugim brojevima, bolje je koristiti petlju. U C++11 (standard kodiranja), kada koristite inicijalizaciju popisa (inicijalizaciju s vitičastim zagradama), čak vam je dopušteno odbaciti znak = .

Želio bih pokazati još jednu tehniku ​​inicijalizacije pri stvaranju niza. Na primjer, za niz od 30 elemenata moramo unijeti vrijednosti 33 I 44 samo na ćelije s indeksom 0 I 1 sukladno tome, a ostatak ispunite nulama. Zatim radimo ovo:

ti će se podaci unijeti u nultu i prvu ćeliju, a ostali će automatski preuzeti vrijednost 0 .

Također možete organizirati punjenje niza pomoću operatora cin:

za (int i = 0; i< size; i++) //заполняем и выводим значения на экран { cout << "Введите значение в ячейку №" << i << " :"; cin >> prvi niz[i]; )

Što su nizovi u C-u?

Kako deklarirati nizove u C-u?

Kako inicijalizirati nizove u C-u?

Nizovi u C-u za lutke.

Nizovi u C

Niz u C-u je zbirka elemenata istog tipa kojima se može pristupiti putem indeksa. Elementi nizova u C-u nalaze se jedan za drugim u memoriji računala.

Jednostavan primjer stvaranja i popunjavanja polja u C-u:

// @author Subbotin B.P..h> void main(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); vrati 0 ;)

Dobivamo:

U primjeru deklariramo niz koji sadrži elemente tipa int:

ovdje je naziv niza nArr, broj elemenata niza je tri, tip elementa niza je int.

Niz je skup elemenata. Svaki element niza može se označiti njegovim brojem. Broj se obično naziva indeks. Elementi niza su numerirani počevši od nule. Dodijelimo vrijednost prvom elementu niza, a prvi element ima indeks nula:

Dodijelimo vrijednost drugom elementu niza, a drugi element ima indeks jedan:

Dodijelimo vrijednost trećem elementu niza, a treći element ima indeks dva:

Kada prikažemo elemente niza na ekranu, dobivamo njihove vrijednosti. Kao ovo:

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

Da biste dobili element niza, morate navesti naziv niza i indeks elementa:

Ovo je prvi element niza, jer prvi element ima indeks nula.

Dodijelimo vrijednost trećeg elementa niza varijabli int a:

indeks trećeg elementa niza je jednak dva, jer se indeksi broje od nule.

Sada opće pravilo za deklariranje nizova u C-u: kada deklarirate niz, trebate navesti njegovo ime, vrstu elemenata i broj elemenata. Broj elemenata je prirodan broj, tj. sve je pozitivno. Nula ne može biti broj elemenata. Ne možete navesti promjenjivi broj elemenata niza. Evo primjera deklaracija polja u C-u:

int nArr; // Niz je deklariran da sadrži stotinu cijelih brojeva;
plovak fArr; // Deklarirano je polje dizajnirano za pohranjivanje 5 float brojeva;
char cArr; // Niz je deklariran za pohranu dva znaka;

Bila bi pogreška deklarirati niz s promjenjivim brojem elemenata:

Int varElem;
int nArr; // Pogreška! Broj elemenata ne može se postaviti na varijablu;

Ali možete postaviti broj elemenata s konstantnom vrijednošću: bilo izravnim pozitivnim cijelim brojem 1, 2, 3... ili konstantom:

Const int arrayLength = 3;
int nArr;

Kada deklarirate niz u C-u, možete ga odmah inicijalizirati:

int nMasiv = (1, 2, 3);

Možete izostaviti broj elemenata niza u uglatim zagradama ako su svi elementi niza inicijalizirani:

int nMasiv = (1, 2, 3);

broj elemenata će se u ovom slučaju automatski odrediti.

Možete definirati samo dio elemenata polja kada ga deklarirate:

int nMasiv = (1, 2);

u ovom primjeru, prva dva elementa niza su inicijalizirana, ali treći je nedefiniran.

Primjer niza znakova:

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

Kada deklarirate niz, ne možete odrediti broj elemenata varijable. Ali možete koristiti varijable kada pristupate elementima niza:

Int ind = 0;
char cr = cArr;

Ovo se koristi pri radu s petljama. Primjer:

// @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; }

U primjeru, u prvoj petlji popunjavamo polje elementima tipa int, au drugoj petlji te elemente prikazujemo na ekranu.

Niz je struktura podataka predstavljena kao grupa ćelija iste vrste, ujedinjenih pod jednim imenom. Nizovi se koriste za obradu velikih količina podataka iste vrste. Ime niza je ono što su pokazivači, reći ću vam malo kasnije. Pojedinačna podatkovna ćelija niza naziva se element niza. Elementi niza mogu biti podaci bilo koje vrste. Nizovi mogu imati jednu ili više od jedne dimenzije. Ovisno o broju dimenzija, nizovi se dijele na jednodimenzionalne nizove, dvodimenzionalne nizove, trodimenzionalne nizove i tako dalje do n-dimenzionalnog niza. U programiranju se najčešće koriste jednodimenzionalni i dvodimenzionalni nizovi, pa ćemo razmatrati samo te nizove.

Jednodimenzionalni nizovi u C++

Jednodimenzionalni niz je niz s jednim parametrom koji karakterizira broj elemenata jednodimenzionalnog niza. Zapravo, jednodimenzionalni niz je niz koji može imati samo jedan redak i n broj stupaca. Stupci u jednodimenzionalnom nizu su elementi niza. Slika 1 prikazuje strukturu cjelobrojnog jednodimenzionalnog niza a. Veličina ovog niza je 16 ćelija.

Slika 1 - Nizovi u C++

Imajte na umu da je maksimalni indeks jednodimenzionalnog niza a je 15, ali je veličina niza 16 ćelija, jer numeriranje ćelija niza uvijek počinje od 0. Indeks ćelije je nenegativan cijeli broj pomoću kojeg možete pristupiti svakoj ćeliji niza i izvršiti bilo kakve radnje na njoj ( ćelija).

//sintaksa za deklariranje jednodimenzionalnog niza u C++: /*tip podataka*/ /*ime jednodimenzionalnog niza*/; //primjer deklaracije jednodimenzionalnog niza prikazan na slici 1: int a;

gdje je int cijeli broj;

A je naziv jednodimenzionalnog niza;
16 je veličina jednodimenzionalnog niza, 16 ćelija.

Uvijek odmah iza naziva niza nalaze se uglate zagrade u kojima se navodi veličina jednodimenzionalnog niza, po čemu se niz razlikuje od svih ostalih varijabli.

//još jedan način za deklariranje jednodimenzionalnih nizova int mas, a;

Dva jednodimenzionalna niza mas i a deklarirana su veličinama 10 odnosno 16. Štoviše, u ovoj metodi deklaracije, svi nizovi će imati isti tip podataka, u našem slučaju - int.

// nizovi se mogu inicijalizirati kada su deklarirani: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // inicijalizacija jednodimenzionalnog niza

Inicijalizacija jednodimenzionalnog niza izvodi se u vitičastim zagradama iza znaka jednaki, svaki element niza odvojen je od prethodnog zarezom.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // inicijaliziranje niza bez određivanja njegove veličine.

U ovom slučaju, prevodilac će sam odrediti veličinu jednodimenzionalnog niza. Veličina niza može se izostaviti samo kada ga inicijalizirate; kada normalno deklarirate niz, veličina niza mora biti navedena. Razvijmo jednostavan program za obradu jednodimenzionalnog niza.

// array.cpp: Definira ulaznu točku za konzolnu aplikaciju. #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; }

// kod Code::Blocks

// Dev-C++ kod

// array.cpp: Definira ulaznu točku za konzolnu aplikaciju. #uključi korištenje imenskog prostora std; 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; }

U retke 10 - 11 Deklariran je i inicijaliziran cjelobrojni jednodimenzionalni niz imena array1 čija je veličina 16 ćelija, odnosno takav niz može pohraniti 16 brojeva. Bilo kakva obrada polja moguća je samo u kombinaciji s petljama. Koju petlju odabrati za obradu niza ovisi o vama. Ali najprikladniji je za ovaj zadatak. Za pristup elementima jednodimenzionalnog niza array1 koristit ćemo se counter varijablom counter. Uvjet za nastavak for petlje sadrži strogi znak nejednakosti, budući da u jednodimenzionalnom nizu array1 nema šesnaestog indeksa. A budući da numeriranje ćelija počinje od nule, elemenata u nizu ima 16. U tijelu for petlje, operator cout ispisuje elemente jednodimenzionalnog niza (vidi sliku 2).

Obrabotka massiva indeksira element massiva 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 Za nastavak pritisnite bilo koju tipku. . .

Slika 2 - Nizovi u C++

Razvijmo još jedan program za obradu jednodimenzionalnog niza u C++. Program mora sekvencijalno pročitati deset unesenih brojeva s tipkovnice. Svi uneseni brojevi se zbrajaju i rezultat se prikazuje na ekranu.

// array_sum.cpp: Definira ulaznu točku za konzolnu aplikaciju. #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; }

// kod Code::Blocks

// Dev-C++ kod

// array_sum.cpp: Definira ulaznu točku za konzolnu aplikaciju. #uključi korištenje imenskog prostora std; int main(int argc, char* argv) ( int array1; // deklarira niz cjelobrojnih brojeva cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>niz1; // čitanje brojeva unesenih s tipkovnice 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; }

Prije obrade polja potrebno ga je deklarirati, a veličina jednodimenzionalnog niza je 10, što je i određeno uvjetom zadatka. U varijabli zbroj akumulirati ćemo zbroj elemenata jednodimenzionalnog niza. Prva for petlja ispunjava deklarirani jednodimenzionalni niz brojevima unesenim s tipkovnice, retke 12 - 13. Varijabla brojača koristi se za sekvencijalni pristup elementima jednodimenzionalnog niza array1, počevši od indeksa 0 pa do 9. uključivo. Druga for petlja prikazuje elemente niza, retke 15 - 16. Treća for petlja sekvencijalno čita elemente jednodimenzionalnog niza i zbraja ih, zbroj se akumulira u varijabli sum. redovi 17 - 18. Rezultat programa prikazan je na slici 3.

Unesite elemente massiva: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) zbroj = 45 Za nastavak pritisnite bilo koju tipku. . .

Slika 3 - Nizovi u C++

Prvo je redom uneseno svih 10 brojeva, nakon čega je prikazan jednodimenzionalni niz, te je ispisan zbroj brojeva u nizu.

Dvodimenzionalni nizovi u C++

Do ove točke razmatrali smo jednodimenzionalne nizove na koje se ne može uvijek ograničiti. Recimo da trebate obraditi neke podatke iz tablice. Tablica ima dvije karakteristike: broj redaka i broj stupaca. Također u dvodimenzionalnom nizu, pored broja elemenata niza, postoje karakteristike kao što su broj redaka i broj stupaca dvodimenzionalnog niza. To jest, vizualno, dvodimenzionalni niz je pravilna tablica, s redovima i stupcima. Zapravo, dvodimenzionalni niz je jednodimenzionalni niz jednodimenzionalnih nizova. Struktura dvodimenzionalnog niza, nazvanog a, veličine m puta n prikazana je dolje (vidi sliku 4).

Slika 4 - Nizovi u C++

gdje je m broj redaka dvodimenzionalnog niza;
n je broj stupaca dvodimenzionalnog niza;
m * n — broj elemenata niza.

// sintaksa za deklariranje dvodimenzionalnog niza /*tip podataka*/ /*ime niza*/;

Kod deklaracije dvodimenzionalnog niza, kao i kod deklaracije jednodimenzionalnog niza, prije svega potrebno je navesti:

• tip podataka;
• ime niza.

Nakon toga prve uglate zagrade označavaju broj redaka dvodimenzionalnog niza, a druge uglate zagrade označavaju broj stupaca dvodimenzionalnog niza. Dvodimenzionalni niz se vizualno razlikuje od jednodimenzionalnog niza po drugom paru uglatih zagrada. Pogledajmo primjer deklaracije dvodimenzionalnog niza. Recimo da trebamo deklarirati dvodimenzionalni niz s brojem elemenata jednakim 15. U ovom slučaju, dvodimenzionalni niz može imati tri reda i pet stupaca ili pet redaka i tri stupca.

// primjer deklaracije dvodimenzionalnog niza: int a;

• a je naziv niza cijelih brojeva
• broj u prvim uglatim zagradama označava broj redaka dvodimenzionalnog niza, u ovom slučaju ih je 5;
• broj u drugoj uglatoj zagradi označava broj stupaca dvodimenzionalnog niza, u ovom slučaju ih je 3.

// inicijalizacija dvodimenzionalnog niza: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Ovaj niz ima 5 redaka, 3 stupca. iza znaka dodijeli stavljaju se opće vitičaste zagrade unutar kojih se stavlja onoliko pari vitičastih zagrada koliko treba biti linija u dvodimenzionalnom nizu, a te se zagrade odvajaju zarezima. U svaki par vitičastih zagrada upišite elemente dvodimenzionalnog niza odvojene zarezima. U svim vitičastim zagradama broj elemenata mora biti isti. Budući da niz ima pet redaka, postoji i pet unutarnjih parova zagrada. U unutarnjoj zagradi ispisana su tri elementa, jer je broj stupaca tri. Grafički, naš niz će izgledati kao dvodimenzionalna tablica (vidi sliku 5).

Slika 5 - Nizovi u C++

U svakoj ćeliji dvodimenzionalnog niza a prikazana vrijednost, adresa ove ćelije prikazana je u donjem desnom kutu. Adresa ćelije dvodimenzionalnog niza je naziv niza, broj retka i broj stupca.

Razvijmo jednostavan program za obradu dvodimenzionalnog niza, nazvan “Labirint”. Labirint mora biti izgrađen na temelju dvodimenzionalnog niza. Veličinu labirinta biramo prema vlastitom nahođenju.

// array2.cpp: Definira ulaznu točku za konzolnu aplikaciju. #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); ) else cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kod Code::Blocks

// Dev-C++ kod

// array2.cpp: Definira ulaznu točku za konzolnu aplikaciju. #uključi korištenje imenskog prostora std; int main(int argc, char* argv) ( // 1-uvjetno “zidovi labirinta” // 2-“ispravan put, izlaz iz labirinta” // 0-“lažni put” int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // inicijalizacija dvodimenzionalnog niza ( 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,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,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,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 ,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,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,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,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,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,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,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,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,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,) ); // dvije petlje - unutarnja i vanjska, pristup svakom elementu niza za (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); ) else cout<< " "; // вывести два пробела cout << endl; } return 0; }

Točna i lažna staza mogu se označiti istim brojem, na primjer nulom, ali radi jasnoće, točna staza je označena brojem 2. Niz je inicijaliziran ručno, samo radi pojednostavljenja programa. Budući da program obrađuje dvodimenzionalni niz, potrebne su dvije petlje za prebacivanje između elemenata dvodimenzionalnog niza. Prva for petlja prebacuje se između redaka dvodimenzionalnog niza. Budući da postoje 33 retka u dvodimenzionalnom nizu, varijabla brojača i se povećava od 0 do 33, linija 46. Unutar prve petlje nalazi se for petlja koja kruži kroz elemente retka dvodimenzionalnog niza. U tijelu druge petlje for, unutra se izvodi operacija pretvorbe unarnog tipa podataka - static_cast<>() , koji ispisuje znak broj 176. Operacija pretvorbe tipa podataka se duplicira kako bi se povećala širina labirinta. Rezultat programa (vidi sliku 6).

Slika 6 - Nizovi u C++