Vytvorenie celočíselného poľa c. Jednorozmerné polia

Posledná aktualizácia: 17.09.2017

Pole predstavuje množinu údajov rovnakého typu. Formálna definícia poľa je nasledovná:

Názov_poľa typu premennej [dĺžka_poľa]

Za typom premennej nasleduje názov poľa a potom jeho veľkosť v hranatých zátvorkách. Napríklad definujme pole 4 čísel:

Int čísla;

Toto pole má štyri čísla, ale všetky tieto čísla majú nedefinovanú hodnotu. Môžeme však vykonať inicializáciu a priradiť niektoré počiatočné hodnoty týmto číslam pomocou zložených zátvoriek:

Int čísla = (1,2,3,4);

Hodnoty v kučeravé zátvorky nazývané aj inicializátory. Ak je inicializátorov menej ako prvkov v poli, potom sa pre prvé prvky použijú inicializátory. Ak je v poli viac inicializátorov ako prvkov, počas kompilácie sa vyskytne chyba:

Int čísla = (1, 2, 3, 4, 5, 6);

Tu má pole veľkosť 4, ale odovzdáva sa mu 6 hodnôt.

Ak veľkosť poľa nie je explicitne špecifikovaná, odvodí sa z počtu inicializátorov:

Int čísla = (1, 2, 3, 4, 5, 6);

V tomto prípade má pole 6 prvkov.

Inicializácia polí znakov má svoje zvláštnosti. Do poľa znakov môžeme odovzdať sadu inicializátorov aj reťazec:

Char s1 = ("h", "e", "l", "l", "o"); char s2 = "svet";

Navyše v druhom prípade pole s2 nebude mať 5 prvkov, ale 6, pretože pri inicializácii reťazcom sa do poľa znakov automaticky pridá nulový znak „\0“.

V tomto prípade nie je priradenie jedného poľa inému poľu povolené:

Int nums1 = (1,2,3,4,5); int nums2 = nums1; // chyba nums2 = nums1; // chyba

Keď je pole definované, môžeme pristupovať k jeho jednotlivým prvkom pomocou indexu. Indexy začínajú na nule, takže na prístup k prvému prvku musíme použiť index 0. Prístupom k prvku po indexe môžeme získať jeho hodnotu alebo ju zmeniť:

#include int main() ( int čísla = (1,2,3,4); int prvé_číslo = čísla; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

Počet prvkov poľa možno určiť aj pomocou konštanty:

Const int n = 4; int čísla[n] = (1,2,3,4);

Iterácia cez polia

Pomocou slučiek môžete iterovať celé pole a pristupovať k jeho prvkom prostredníctvom indexov:

#include int main() ( int čísla = (1,2,3,4); int veľkosť = veľkosť(čísla)/veľkosť(čísla); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Ak chcete prejsť cez pole, musíte najprv nájsť dĺžku poľa. Na zistenie dĺžky sa používa operátor sizeof. Dĺžka poľa sa v podstate rovná celkovej dĺžke jeho prvkov. Všetky prvky predstavujú rovnaký typ a zaberajú rovnakú veľkosť v pamäti. Preto pomocou výrazu sizeof(numbers) zistíme dĺžku celého poľa v bajtoch a pomocou výrazu sizeof(numbers) zistíme dĺžku jedného prvku v bajtoch. Vydelením týchto dvoch hodnôt získate počet prvkov v poli. A potom pomocou cyklu for iterujeme cez všetky prvky, kým sa počítadlo i nestane rovným dĺžke poľa. V dôsledku toho sa na konzole zobrazia všetky prvky poľa:

Existuje však aj iná forma cyklu for, ktorá je navrhnutá špeciálne na prácu s kolekciami vrátane polí. Tento formulár má nasledujúcu formálnu definíciu:

For(typ premennej: zbierka) ( pokyny; )

Tento formulár používame na iteráciu cez pole:

#include int main() ( int čísla = (1,2,3,4); for(int number: čísla) std::cout<< number << std::endl; return 0; }

Pri iterácii cez pole sa každá iterovaná položka umiestni do premennej číslo, ktorej hodnota sa vytlačí do konzoly v slučke.

Ak nepoznáme typ objektov v poli, na určenie typu môžeme použiť automatický špecifikátor:

For(auto number: numbers) std::cout<< number << std::endl;

Viacrozmerné polia

Okrem jednorozmerných polí má C++ aj viacrozmerné. Prvky takýchto polí sú zase polia, v ktorých môžu byť prvky tiež poliami. Napríklad definujme dvojrozmerné pole čísel:

Int čísla;

Takéto pole pozostáva z troch prvkov, pričom každý prvok predstavuje pole dvoch prvkov. Inicializujeme pole takto:

Int čísla = ( (1, 2), (4, 5), (7, 8) );

Vnorené zložené zátvorky vymedzujú prvky pre každé podpole. Takéto pole môže byť reprezentované aj ako tabuľka:

Počas inicializácie môžete tiež vynechať zložené zátvorky:

Int čísla = ( 1, 2, 4, 5, 7, 8 );

Je tiež možné inicializovať nie všetky prvky, ale iba niektoré:

Int čísla = ( (1, 2), (), (7) );

A na prístup k prvkom vnoreného poľa potrebujete dva indexy:

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

Poďme iterovať cez dvojrozmerné pole:

#include int main() ( const int rows = 3, columns = 2; int čísla = ( (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; }

Na iteráciu cez prvky viacrozmerného poľa môžete použiť aj inú formu cyklu for:

#include int main() ( const int rows = 3, columns = 2; int numbers = ( (1, 2), (3, 4), (5, 6) ); for(auto &subnumbers: numbers) ( for(int number : podčísla) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

Na iteráciu polí, ktoré sú zahrnuté v poli, sa používajú odkazy. To znamená, že vo vonkajšej slučke for(auto &subnumbers:numbers) &subnumbers predstavuje referenciu podpolia v poli. Vo vnútornej slučke for(int number: subnumbers) z každého podpola v podčíslach dostaneme jeho jednotlivé prvky do premennej číslo a vypíšeme jeho hodnotu do konzoly.

Pole je dátová štruktúra reprezentovaná ako skupina buniek rovnakého typu zjednotených pod jedným názvom. Polia sa používajú na spracovanie veľkého množstva údajov rovnakého typu. Názov poľa je to, čo sú ukazovatele, poviem vám o niečo neskôr. Jednotlivá dátová bunka poľa sa nazýva prvok poľa. Prvky poľa môžu byť dáta akéhokoľvek typu. Polia môžu mať jeden alebo viac rozmerov. V závislosti od počtu rozmerov sa polia delia na jednorozmerné polia, dvojrozmerné polia, trojrozmerné polia atď. až po n-rozmerné pole. Pri programovaní sa najčastejšie používajú jednorozmerné a dvojrozmerné polia, preto budeme brať do úvahy iba tieto polia.

Jednorozmerné polia v C++

Jednorozmerné pole je pole s jedným parametrom charakterizujúcim počet prvkov jednorozmerného poľa. V skutočnosti je jednorozmerné pole pole, ktoré môže mať iba jeden riadok a n počet stĺpcov. Stĺpce v jednorozmernom poli sú prvkami poľa. Obrázok 1 znázorňuje štruktúru celočíselného jednorozmerného poľa a. Veľkosť tohto poľa je 16 buniek.

Obrázok 1 - Polia v C++

Všimnite si, že maximálny index jednorozmerného poľa a je 15, ale veľkosť poľa je 16 buniek, pretože číslovanie buniek poľa vždy začína od 0. Index bunky je nezáporné celé číslo, pomocou ktorého môžete pristupovať ku každej bunke poľa a vykonávať s ňou akékoľvek akcie ( bunka).

//syntax pre deklaráciu jednorozmerného poľa v C++: /*údajový typ*/ /*názov jednorozmerného poľa*/; //príklad deklarovania jednorozmerného poľa znázorneného na obrázku 1: int a;

kde, int je celé číslo;

A je názov jednorozmerného poľa;
16 je veľkosť jednorozmerného poľa, 16 buniek.

Vždy hneď za názvom poľa sú hranaté zátvorky, v ktorých je špecifikovaná veľkosť jednorozmerného poľa, čím sa pole odlišuje od všetkých ostatných premenných.

//iný spôsob ako deklarovať jednorozmerné polia int mas, a;

Dve jednorozmerné polia mas a a sú deklarované s veľkosťou 10 a 16. Navyše v tomto spôsobe deklarácie budú mať všetky polia rovnaký dátový typ, v našom prípade - int.

// polia môžu byť inicializované pri deklarácii: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // inicializácia jednorozmerného poľa

Inicializácia jednorozmerného poľa sa vykonáva v zložených zátvorkách za znamienkom rovná sa, každý prvok poľa je od predchádzajúceho oddelený čiarkou.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // inicializácia poľa bez určenia jeho veľkosti.

V tomto prípade kompilátor sám určí veľkosť jednorozmerného poľa. Veľkosť poľa je možné vynechať iba pri jeho inicializácii, pri normálnej deklarácii poľa je potrebné zadať veľkosť poľa. Vyvinieme jednoduchý program na spracovanie jednorozmerného poľa.

// array.cpp: Definuje vstupný bod pre aplikáciu konzoly. #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; }

// kód Kód::Blocks

// Kód Dev-C++

// array.cpp: Definuje vstupný bod pre aplikáciu konzoly. #include pomocou menného priestoru 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; }

IN riadky 10-11 Bolo deklarované a inicializované celočíselné jednorozmerné pole s názvom pole1, ktorého veľkosť je 16 buniek, to znamená, že takéto pole môže uložiť 16 čísel. Akékoľvek spracovanie poľa je možné len v spojení so slučkami. Akú slučku zvoliť na spracovanie poľa, je na vás, aby ste sa rozhodli. Na túto úlohu sa však najlepšie hodí. Na prístup k prvkom jednorozmerného poľa poľa1 použijeme čítač premenných čítač. Podmienka pre pokračovanie cyklu for obsahuje striktné znamienko nerovnosti, keďže v jednorozmernom poli poľa1 nie je žiadny šestnásty index. A keďže číslovanie buniek začína od nuly, v poli je 16 prvkov V tele cyklu for vytlačí operátor cout prvky jednorozmerného poľa (pozri obrázok 2).

Obrabotka massiva indexy prvok massiva pole1 5 pole1 -12 pole1 -12 pole1 9 pole1 10 pole1 0 pole1 -9 pole1 -12 pole1 -1 pole1 23 pole1 65 pole1 64 pole1 11 pole1 43 pole1 39 pole1 -15 Pokračujte stlačením ľubovoľného klávesu. . .

Obrázok 2 - Polia v C++

Vyvinieme ďalší program na spracovanie jednorozmerného poľa v C++. Program musí postupne prečítať desať zadaných čísel z klávesnice. Všetky zadané čísla sa spočítajú a výsledok sa zobrazí na obrazovke.

// array_sum.cpp: Definuje vstupný bod pre aplikáciu konzoly. #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; }

// kód Kód::Blocks

// Kód Dev-C++

// array_sum.cpp: Definuje vstupný bod pre aplikáciu konzoly. #include pomocou menného priestoru std; int main(int argc, char* argv) ( int pole1; // vyhlásenie celočíselného poľa cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>pole1; // čítanie čísel zadaných z klávesnice 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; }

Pred spracovaním poľa musí byť deklarované a veľkosť jednorozmerného poľa je 10, pretože to určuje podmienka úlohy. V premennej sum budeme akumulovať súčet prvkov jednorozmerného poľa. Prvý cyklus for vyplní deklarované jednorozmerné pole číslami zadanými z klávesnice, riadky 12-13. Premenná počítadla sa používa na sekvenčný prístup k prvkom jednorozmerného poľa poľa1, počnúc indexom 0 a až 9. vrátane. Druhá slučka for zobrazuje prvky poľa, riadky 15-16. Tretí cyklus for sekvenčne číta prvky jednorozmerného poľa a sčítava ich, pričom súčet je akumulovaný v premennej sum. riadky 17-18. Výsledok programu je znázornený na obrázku 3.

Zadajte elementi massiva: 0 1 2 3 4 5 6 7 8 9 pole1 = (0 1 2 3 4 5 6 7 8 9 ) súčet = 45 Ak chcete pokračovať, stlačte ľubovoľný kláves. . .

Obrázok 3 - Polia v C++

Najprv sa postupne zadalo všetkých 10 čísel, potom sa zobrazilo jednorozmerné pole a vytlačil sa súčet čísel v poli.

Dvojrozmerné polia v C++

Až do tohto bodu sme uvažovali o jednorozmerných poliach, ktoré nemožno vždy obmedziť. Povedzme, že potrebujete spracovať nejaké údaje z tabuľky. Tabuľka má dve charakteristiky: počet riadkov a počet stĺpcov. V dvojrozmernom poli sú okrem počtu prvkov poľa aj také charakteristiky, ako je počet riadkov a počet stĺpcov dvojrozmerného poľa. To znamená, že vizuálne je dvojrozmerné pole obyčajná tabuľka s riadkami a stĺpcami. V skutočnosti je dvojrozmerné pole jednorozmerné pole jednorozmerných polí. Štruktúra dvojrozmerného poľa s názvom a s veľkosťou m x n je znázornená nižšie (pozri obrázok 4).

Obrázok 4 - Polia v C++

kde m je počet riadkov dvojrozmerného poľa;
n je počet stĺpcov dvojrozmerného poľa;
m * n — počet prvkov poľa.

// syntax pre deklarovanie dvojrozmerného poľa /*údajový typ*/ /*názov poľa*/;

Pri deklarovaní dvojrozmerného poľa, ako aj pri deklarovaní jednorozmerného poľa, musíte v prvom rade špecifikovať:

• Dátový typ;
• názov poľa.

Potom prvé hranaté zátvorky označujú počet riadkov dvojrozmerného poľa a druhé hranaté zátvorky označujú počet stĺpcov dvojrozmerného poľa. Dvojrozmerné pole je vizuálne odlíšené od jednorozmerného poľa druhým párom hranatých zátvoriek. Pozrime sa na príklad deklarácie dvojrozmerného poľa. Povedzme, že potrebujeme deklarovať dvojrozmerné pole s počtom prvkov rovným 15. V tomto prípade môže mať dvojrozmerné pole tri riadky a päť stĺpcov alebo päť riadkov a tri stĺpce.

// príklad deklarácie dvojrozmerného poľa: int a;

• a je názov celočíselného poľa
• číslo v prvých hranatých zátvorkách označuje počet riadkov dvojrozmerného poľa, v tomto prípade je ich 5;
• číslo v druhej hranatej zátvorke označuje počet stĺpcov dvojrozmerného poľa, v tomto prípade sú 3.

// inicializácia dvojrozmerného poľa: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1));

Toto pole má 5 riadkov, 3 stĺpce. za priraďovacím znakom sú umiestnené všeobecné zložené zátvorky, do ktorých je umiestnených toľko párov zložených zátvoriek, koľko má byť čiar v dvojrozmernom poli, pričom tieto zátvorky sú oddelené čiarkami. Do každého páru zložených zátvoriek napíšte prvky dvojrozmerného poľa oddelené čiarkami. Vo všetkých zložených zátvorkách musí byť počet prvkov rovnaký. Keďže v poli je päť riadkov, existuje aj päť vnútorných párov zátvoriek. Vo vnútorných zátvorkách sú napísané tri prvky, keďže počet stĺpcov je tri. Graficky bude naše pole vyzerať ako dvojrozmerná tabuľka (pozri obrázok 5).

Obrázok 5 - Polia v C++

V každej bunke dvojrozmerného poľa a je zobrazená hodnota, adresa tejto bunky je zobrazená v pravom dolnom rohu. Adresa bunky dvojrozmerného poľa je názov poľa, číslo riadku a číslo stĺpca.

Vytvorme jednoduchý program na spracovanie dvojrozmerného poľa s názvom „Labyrint“. Labyrint musí byť postavený na základe dvojrozmerného poľa. Veľkosť labyrintu zvolíme podľa vlastného uváženia.

// array2.cpp: Definuje vstupný bod pre aplikáciu konzoly. #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); ) inak cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kód Kód::Blocks

// Kód Dev-C++

// array2.cpp: Definuje vstupný bod pre aplikáciu konzoly. #include pomocou menného priestoru std; int main(int argc, char* argv) ( // 1-podmienene „steny bludiska“ // 2-„správna cesta, výstup z bludiska“ // 0-„falošná cesta“ int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // inicializácia dvojrozmerného poľa ( 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,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,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,)); // dva cykly – interné a externé, pristupujúce ku každému prvku poľa for (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); ) inak cout<< " "; // вывести два пробела cout << endl; } return 0; }

Správna a nepravdivá cesta mohli byť označené rovnakým číslom, napríklad nula, ale pre prehľadnosť je správna cesta označená číslom 2. Pole bolo inicializované ručne, len kvôli zjednodušeniu programu. Keďže program spracováva dvojrozmerné pole, na prepínanie medzi prvkami dvojrozmerného poľa sú potrebné dve slučky. Prvá slučka for prepína medzi riadkami dvojrozmerného poľa. Keďže v dvojrozmernom poli je 33 riadkov, premenná počítadla i sa zvýši z 0 na 33, riadok 46. Vo vnútri prvej slučky je slučka for, ktorá cyklicky prechádza medzi riadkovými prvkami dvojrozmerného poľa. V tele druhého cyklu for sa vnútri vykoná operácia konverzie jednočlenného dátového typu - static_cast<>() , ktorá vytlačí znak číslo 176. Operácia konverzie typu údajov je duplikovaná, aby sa zväčšila šírka bludiska. Výsledok programu (pozri obrázok 6).

Obrázok 6 - Polia v C++

Čo sú polia v C?

Ako deklarovať polia v C?

Ako inicializovať polia v C?

Polia v C pre figuríny.

Polia v C

Pole v C je kolekcia prvkov rovnakého typu, ku ktorým možno pristupovať pomocou indexu. Prvky polí v C sú umiestnené jeden po druhom v pamäti počítača.

Jednoduchý príklad vytvorenia a vyplnenia poľa v C:

// @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); návrat 0 ;

Dostaneme:

V príklade deklarujeme pole obsahujúce prvky typu int:

tu je názov poľa nArr, počet prvkov poľa sú tri, typ prvku poľa je int.

Pole je zbierka prvkov. Každý prvok poľa môže byť označený jeho číslom. Číslo sa zvyčajne nazýva index. Prvky poľa sú číslované od nuly. Priraďme hodnotu prvému prvku poľa a prvý prvok má index nula:

Priraďme hodnotu druhému prvku poľa a druhý prvok má index jedna:

Priraďme hodnotu tretiemu prvku poľa a tretí prvok má index dva:

Keď zobrazíme prvky poľa na obrazovke, dostaneme ich hodnoty. Páči sa ti to:

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

Ak chcete získať prvok poľa, musíte zadať názov poľa a index prvku:

Toto je prvý prvok poľa, pretože prvý prvok má index nula.

Priraďme hodnotu tretieho prvku poľa premennej int a:

index tretieho prvku poľa sa rovná dvom, pretože indexy sa počítajú od nuly.

Teraz všeobecné pravidlo pre deklarovanie polí v C: pri deklarovaní poľa musíte uviesť jeho názov, typ prvkov a počet prvkov. Počet prvkov je prirodzené číslo, t.j. celok je pozitívny. Nula nemôže byť počet prvkov. Nemôžete zadať premenlivý počet prvkov poľa. Tu sú príklady deklarácií polí v C:

int nArr; // Pole bolo deklarované tak, že obsahuje sto celých čísel;
float farArr; // Bolo deklarované pole navrhnuté na uloženie 5 plávajúcich čísel;
char cArr; // Pole bolo deklarované na uloženie dvoch znakov;

Bolo by chybou deklarovať pole s premenlivým počtom prvkov:

Int varElem;
int nArr; // Chyba! Počet prvkov nemožno nastaviť na premennú;

Ale môžete nastaviť počet prvkov s konštantnou hodnotou: buď priame kladné celé číslo 1, 2, 3... alebo konštanta:

Const int dĺžka poľa = 3;
int nArr;

Pri deklarovaní poľa v C ho môžete okamžite inicializovať:

int nMasiv = (1, 2, 3);

Počet prvkov poľa v hranatých zátvorkách môžete vynechať, ak sú inicializované všetky prvky poľa:

int nMasiv = (1, 2, 3);

počet prvkov sa v tomto prípade určí automaticky.

Pri deklarovaní poľa môžete definovať iba časť prvkov poľa:

int nMasiv = (1, 2);

v tomto príklade sú prvé dva prvky poľa inicializované, ale tretí nie je definovaný.

Príklad poľa znakov:

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

Pri deklarovaní poľa nemôžete zadať počet prvkov premennej. Pri prístupe k prvkom poľa však môžete použiť premenné:

Int ind = 0;
char cr = cArr;

Používa sa pri práci so slučkami. Príklad:

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

V príklade v prvej slučke naplníme pole prvkami typu int a v druhej slučke tieto prvky zobrazíme na obrazovke.

Pri riešení problémov s veľkým množstvom údajov rovnakého typu používanie premenných s rôznymi názvami, ktoré nie sú usporiadané podľa adries pamäte, sťažuje programovanie. V takýchto prípadoch jazyk C používa objekty nazývané polia.

je súvislá časť pamäte obsahujúca postupnosť objektov rovnakého typu, označená jedným menom.

Pole sa vyznačuje nasledujúcimi základnými pojmami:

Prvok poľa (hodnota prvku poľa)– hodnota uložená v špecifickej pamäťovej bunke umiestnenej v poli, ako aj adresa tejto pamäťovej bunky.
Každý prvok poľa je charakterizovaný tromi hodnotami:

• adresa prvku - adresa štartovacej pamäťovej bunky, v ktorej sa tento prvok nachádza;
• index prvku (poradové číslo prvku v poli);
• hodnota prvku.

Adresa poľa – adresa počiatočného prvku poľa.

Názov poľa je identifikátor používaný na označenie prvkov poľa.

Veľkosť poľa – počet prvkov poľa

Veľkosť prvku je počet bajtov, ktoré zaberá jeden prvok poľa.

Graficky možno umiestnenie poľa v pamäti počítača znázorniť ako súvislý pás adries.

Pole zobrazené na obrázku obsahuje q prvkov s indexmi od 0 do q-1. Každý prvok zaberá v pamäti počítača k bajtov a usporiadanie prvkov v pamäti je sekvenčné.

Adresy i-tého prvku poľa sú

Adresa poľa je adresa počiatočného (nulového) prvku poľa. Na prístup k prvkom poľa sa používa sériové číslo (index) prvku, ktorého počiatočná hodnota je 0. Ak teda pole obsahuje q prvkov, potom sa indexy prvkov poľa menia od 0 do q-1.

Dĺžka poľa je počet bajtov pridelených v pamäti na uloženie všetkých prvkov poľa.

Dĺžka poľa = Veľkosť prvku * Počet prvkov

Funkciu možno použiť na určenie veľkosti prvku poľa

int sizeof(type);

Napríklad,

sizeof(char) = 1;
sizeof(int) = 4;
sizeof(float) = 4;
sizeof(double) = 8;

Deklarovanie a inicializácia polí

Na deklarovanie poľa v C sa používa nasledujúca syntax:

zadajte názov[dimenzia]=(init);

Inicializácia je množina počiatočných hodnôt prvkov poľa, zadaných v zložených zátvorkách, oddelených čiarkami.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // pole a 10 celých čísel

Ak je počet inicializačných hodnôt zadaných v zložených zátvorkách menší ako počet prvkov poľa zadaný v hranatých zátvorkách, potom všetky zostávajúce prvky v poli (pre ktoré nebol dostatok inicializačných hodnôt) budú nulové. Túto vlastnosť je vhodné použiť na nastavenie všetkých prvkov poľa na nulové hodnoty.

int b = (0); // pole b s 10 prvkami inicializované na 0

Ak je pole pri deklarácii inicializované, konštantné počiatočné hodnoty jeho prvkov sú označené oddelenými čiarkami v zložených zátvorkách. V tomto prípade možno počet prvkov v hranatých zátvorkách vynechať.

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

Pri prístupe k prvkom poľa je index požadovaného prvku uvedený v hranatých zátvorkách.

Príklad v C

1
2
3
4
5
6
7
8

#include
int main()
{
int a = (5, 4, 3, 2, 1); // pole a obsahuje 5 prvkov
printf("%d %d %d %d %d\n" , a, a, a, a);
getchar();
návrat 0;
}

Výsledok spustenia programu:

Často je však potrebné nastaviť hodnoty prvkov poľa počas vykonávania programu. Toto používa deklaráciu poľa bez inicializácie. V tomto prípade je povinné uviesť počet prvkov v hranatých zátvorkách.

int a;

Na nastavenie počiatočných hodnôt prvkov poľa sa veľmi často používa parametrická slučka:

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

#include
int main()
{
int a;
int i;
// Zadávanie prvkov poľa
pre (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
// Výstup prvkov poľa
pre (i = 0; i<5; i++)
printf("%d" , a[i]); // je potrebné miesto vo formáte tlače
getchar(); getchar();
návrat 0;
}

Výsledok spustenia programu

Viacrozmerné polia

Viacrozmerné polia môžu byť deklarované aj v C. Rozdiel medzi viacrozmerným a jednorozmerným poľom je v tom, že v jednorozmernom poli je poloha prvku určená jedným indexom a vo viacrozmernom poli niekoľkými. Príkladom viacrozmerného poľa je matica.

Všeobecná forma deklarovania viacrozmerného poľa

názov typu[rozmer1][rozmer2]...[rozmer];

Prvky viacrozmerného poľa sú umiestnené v po sebe nasledujúcich bunkách RAM vo vzostupnom poradí adries. V pamäti počítača sú prvky viacrozmerného poľa usporiadané v rade, napríklad pole s 2 riadkami a 3 stĺpcami,

int a;

Celkový počet prvkov v danom dvojrozmernom poli je určený ako

Počet riadkov * Počet stĺpcov = 2 * 3 = 6.

Počet bajtov pamäte potrebnej na umiestnenie poľa je daný

Počet položiek * Veľkosť položky = 6 * 4 = 24 bajtov.

Inicializácia viacrozmerných polí

Hodnoty prvkov viacrozmerného poľa, ako v jednorozmernom prípade, môžu byť špecifikované konštantnými hodnotami, keď sú deklarované, uzavreté v zložených zátvorkách (). V tomto prípade však musí byť počet prvkov v riadkoch a stĺpcoch uvedený v hranatých zátvorkách.

Príklad v C

1
2
3
4
5
6
7
8
9

#include
int main()
{
int a = (1, 2, 3, 4, 5, 6);
printf("%d %d %d\n" , a, a, a);
getchar();
návrat 0;
}

Častejšie však musíte počas vykonávania programu zadávať hodnoty prvkov viacrozmerného poľa. Na tento účel je vhodné použiť vnorenú parametrickú slučku.

Príklad v 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
#include
int main()
{
int a; // pole 2 riadkov a 3 stĺpcov
int i, j;
// Zadávanie prvkov poľa
pre (i = 0; i<2; i++) // prechádzanie riadkami
{
pre (j = 0; j<3; j++) // prechádzať stĺpcami
{
printf("a[%d][%d] = " , i, j);
scanf("%d" , &a[i][j]);
}
}
// Výstup prvkov poľa
pre (i = 0; i<2; i++) // prechádzanie riadkami
{
pre (j = 0; j<3; j++) // prechádzať stĺpcami
{
printf("%d " , a[i][j]);
}
printf("\n" ); // Nový riadok
}
getchar(); getchar();
návrat 0;
}

Odovzdanie poľa funkcii

Spracovanie poľa možno pohodlne organizovať pomocou špeciálnych funkcií. Ak chcete spracovať pole, musíte funkciu odovzdať ako argumenty

• adresa poľa,
• veľkosť poľa.

Výnimkou sú funkcie spracovania reťazcov, kde stačí odovzdať iba adresu.

Pri odovzdávaní premenných ako argumentov do funkcie sa údaje odovzdávajú ako kópie. To znamená, že ak sa hodnota parametra zmení vo funkcii, neovplyvní to jej hodnotu vo volanej funkcii.

Ak je funkcii odovzdaná adresa premennej (alebo adresa poľa), všetky operácie vykonávané vo funkcii s údajmi v rozsahu zadanej adresy sa vykonajú s pôvodnými údajmi, takže pôvodné pole (alebo hodnotu premennej) možno zmeniť volanou funkciou.

Príklad v C Dan pole 10 prvkov. Vymeňte najväčšie a počiatočné prvky poľa. Pre maximálne operácie vyhľadávania a výmeny prvkov použite funkciu.

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
#include
// Funkcia výmeny
void change(int *x, int n)
{
// x - ukazovateľ na pole (adresa poľa)
// n - veľkosť poľa
int i;
int max, index;
max = x;
index = 0;
// Nájdenie maximálneho prvku
pre (i = 1; i {
if (x[i]>max)
{
max = x[i];
index = i;
}
}
// Výmena
x = x;
x = max;
}
// Hlavná funkcia
int main()
{
int a;
int i;
pre (i = 0; i<10; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
zmena(a, 10); // volanie funkcie výmeny
// Výstup prvkov poľa
pre (i = 0; i<10; i++)
printf("%d" , a[i]);
getchar();
getchar();
vrátiť
p = p* x[i];
}
vrátiť p;
}
// Hlavná funkcia
int main()
{
int a; // deklarované pole a s 5 prvkami
int i;
int pr;
// Zadávanie prvkov poľa
pre (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]); // &a[i] - adresa i-tého prvku poľa
}
pr = func(a, 5); // výpočet súčinu
printf("\n pr = %d" , pr); // výstup súčinu párnych prvkov
getchar(); getchar();
návrat 0;
}

Polia sú navrhnuté na ukladanie viacerých hodnôt rovnakého typu. Napríklad v programe Fahrenheita až Celzia sme vypočítali priemernú hodnotu teploty z troch. Ak neexistujú tri hodnoty, ale oveľa viac, potom musíte použiť polia.

Skôr ako budete môcť použiť pole, musíte ho definovať. Definícia poľa zahŕňa: typ údajov uložených v poli, názov poľa a počet prvkov poľa v hranatých zátvorkách:

int pole;

V tomto kóde sme definovali pole s identifikátorom (názvom) pole desiatich prvkov typu int.
V tejto forme sú všetky prvky poľa stále neinicializované. Ak ich chcete inicializovať pri deklarácii, musíte použiť nasledujúcu syntax:

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

V tomto prípade má prvý prvok poľa priradenú hodnotu 0 a posledný - hodnotu 9.
Na priradenie hodnôt prvkom poľa môžete použiť slučky. Najvhodnejšia na to by bola slučka for.

kód v jazyku c++ int pole; //definícia poľa pre (int i = 0; i< 10; i++) { array[i] = i; }

Tu pristupujeme ku každému prvku poľa prostredníctvom indexu – čísla v hranatých zátvorkách. Pri každej iterácii cyklu nadobúda hodnoty od nuly do 9.

Všimnite si, že číslovanie indexov začína od nuly. Preto je počet indexov vždy o jeden menší ako počet prvkov poľa.

S výnimkou hranatých zátvoriek a dolných indexov sa prvok poľa používa rovnako ako každá premenná.

Struny

Doteraz sme reťazce mohli ukladať len do konštánt: "Príklad konštantného reťazca." Do premenných sme mohli uložiť len jeden znak – v type char. C++ používa dva typy reťazcov: pole prvkov typu char a typu str. Zatiaľ sa zameriame na prvú možnosť.

Na uloženie reťazca potrebujeme pole. Vyzerá to asi takto:

char string = ("s","t","p","o"."k","a");

Našťastie existuje jednoduchší spôsob :)

char string = "reťazec";

V tomto prípade sa automaticky vytvorí pole siedmich prvkov. Prečo zo siedmich? Ide o to, že každý riadok musí končiť znakovou konštantou "\0", ktorá predstavuje prázdny bajt.

Ak sa v predchádzajúcich príkladoch pokúsime zadať reťazec väčší ako šesť znakov do poľa reťazcov, pole sa preplní, pretože Keď je program spustený, nemôžete zmeniť veľkosť poľa (aj keď nie vždy):

reťazec znaku; // reťazec môže uložiť šesť znakov a "\0"

string = "reťazec!"; // riadok obsahuje sedem znakov
Toto sa neodporúča :)

Je tu ešte jeden bod, na ktorý chcem upriamiť vašu pozornosť. Keď používateľ zadá reťazec, medzery sa počítajú ako "\0". Zatiaľ nebudeme zadávať reťazce do našich programov, takže tento prípad nebudem podrobne vysvetľovať.

Polia polí (dvojrozmerné polia)

No a konečne sa dostávame k tomu najdôležitejšiemu v tejto problematike.

Mapa v strategických (nielen) hrách (RTS) je rozdelená na bunky (v angličtine - tile). Je vhodné reprezentovať tieto bunky pomocou dvojrozmerného poľa.

V tomto príklade budeme pokračovať v práci s programom pseudo_game a pomocou dvojrozmerného poľa nasimulujeme mapu, po ktorej sa môže hráč pohybovať. Doteraz bol „pohyb“ reprezentovaný pomocou súradníc x, y.

Bunky budeme reprezentovať symbolmi. Veľkosť "kartičky" je 15x20. Pätnásť vysoký, dvadsať široký. Hráča budeme reprezentovať symbolom T.

Najprv pridajte hlavičkový súbor stdlib.h.

Vylepšená pseudo_hra

Dám len kúsky kódu. Je vhodné, aby ste mali celý program pred očami. Nájdete ho v sekcii „výpisy programov“ - pseudo_game_0_2. Kompiluje sa a beží. Stačí ho skopírovať do editora vášho IDE a postupovať podľa textu.

Inicializácia dát:

kód v jazyku c++ charakt; // premenná na čítanie užívateľského vstupu int ch; // premenná pre uloženie redukovanej hodnoty premennej act int x = 0; // dve premenné na uloženie súradníc hráča int y = 0; mapa znakov; // pole na uloženie hernej karty // inicializácia poľa pre (int i = 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Tu je pre nás novým operátorom definícia dvojrozmerného poľa. Ale takmer sa nelíši od toho jednorozmerného, ​​len pridáva ďalší pár hranatých zátvoriek. V prvých zátvorkách sme uviedli počet riadkov, v druhej - počet stĺpcov.

Potom v dvoch cykloch inicializujeme každý prvok poľa s hodnotou " " - čo je len medzera. Najprv vo vonkajšej slučke prechádzame všetkými riadkami. Pre každý riadok vo vnútornej slučke "prechádzame" stĺpiky.

Uvediem podrobný príklad: po niekoľkých iteráciách vonkajšej slučky sa počítadlo i stane rovným 9. Telo vonkajšej slučky sa začne vykonávať: premenná j (počítadlo vnútornej slučky) sa inicializuje na nulu, skontroluje sa podmienka a vykoná sa telo vnútornej slučky: map = " ";, To znamená, že prvému znaku (index nula) desiateho riadku (nezabudnite, že odpočítavanie je od nuly) je priradená medzera. Potom sa čítaču j priradí 1, vykoná sa telo cyklu... a tak ďalej, kým sa čítač j nerovná 20 – podmienka nie je splnená a vnútorný cyklus sa opustí. Potom sa zvýši externé počítadlo. Teraz sa rovná 10 a telo vonkajšej slučky sa vykoná znova...

Po inicializácii s medzerami umiestnime postavu našej hry do prvého stĺpca prvého riadku.

Na začiatku hlavnej slučky zavoláme funkciu system(), aby sme vyčistili obrazovku od predchádzajúceho výstupu.

Potom existujú dva cykly podobné inicializačným cyklom. Používajú sa na zobrazenie prvkov poľa na obrazovke. Jediným podstatným rozdielom je výstup znaku nového riadku na konci tela prvej slučky.

No a potom je tu vetvenie, v ktorom sa určuje, ktorá klávesa je stlačená. Samotné vetvenie sa od minula zmenilo málo, ale rozdiely sú v obsahu blokov: po prvé, súradniciam, kde sa objekt nachádza, priradíme medzeru. To znamená, že vyčistíme predchádzajúce miesto. Potom zmeníme jednu zo súradníc. A potom prvku poľa s novými indexmi priradíme znak „T“.

Príklad pre kód "75" - pohyb doľava:

kód v jazyku c++ if else (ch == 75) ( mapa[x][y] = " "; y--; mapa[x][y] = "T"; )

No, to je v podstate všetko. Momentálne máme mapu 15x20, na ktorej môžete šípkami pohybovať postavičkou – písmenom „T“. Nie je to zlé na šiestu lekciu! Táto aplikácia sa stane základom pre všetky naše konzolové programy. Nebudú chýbať žiadne grafické vylepšenia. Z konzoly DOS jednoducho nemôžete získať viac a nebudeme brať do úvahy konzolu Windows. To výrazne ušetrí čas a námahu.

Podrobne som sa vyjadril k programu pseudo_game a s najväčšou pravdepodobnosťou ho bez problémov pochopíte. Ak nie, tak si ešte raz prečítajte výpis programu a nepochopíte túto problematiku, kým ju nepochopíte :). Cvičenia vám pomôžu upevniť látku. Vykonávanie cvičení je povinné. Ak je niečo nejasné, napíšte mi na môj e-mail - pokúsim sa pomôcť.

Cvičenia:

1. V kompletnom výpise programu som použil vetvenie prepínačov. Tu je tiež zobrazený kód pre jeden blok vetvy if. Pridajte zostávajúce bloky if.

2. Teraz môže program zapisovať do neexistujúcich prvkov poľa. Skontrolujte, či ste opustili limity mapy.

3. Na precvičenie si vytvorte program, ktorý na obrazovke nakreslí dve polia pre námornú bitku. Prvý je pre hráča, druhý pre nepriateľa. Druhé pole by malo byť umiestnené napravo od prvého.
Vyplňte vnútorné bunky medzerami. Ak chcete nakresliť okraj, použite mínus a rovnú deliacu čiaru: -, | a pre rohy použite krížik #. Naľavo od každého poľa je hromada čísel; navrchu sú písmená.
Inicializácia celého poľa vám môže trvať niekoľko cyklov. Takto môže vyzerať kód na vyplnenie stĺpca čísel v druhom poli:

kód v jazyku c++ int reťazec; // premenná reprezentujúca riadky int stĺpec; // premenná reprezentujúca stĺpce char map; stĺpec = 15; for (reťazec = 2; reťazec< 12; string++) { map = string - 1; }