Im dalej w las tym więcej drzew - przynajmniej tak jest w teorii. W niniejszym rozdziale zapoznamy się z tablicami zmiennych. Zanim jednak przejdziemy do właściwej nauki postaram się przytoczyć (chyba) sensowną opowieść po której sam z siebie będziesz mógł powiedzieć: "o tablice są fajne".
Dlaczego wprowadzono tablice zmiennych
Wyobraź sobie, że jesteś pilotem dużego samolotu. Na pokład wchodzą pasażerowie i z niego wychodzą. Przyszedł jednak dzień, że zaczęło Ciebie interesować kto na jakim miejscu siedzi i ponumerowałeś sobie miejsca od 1 do 200. Na każdym miejscu siedzi jakaś osoba, która ma swoje imię i nazwisko, a zatem również i PESEL. Gdybyś chciał teraz we własnym programie utworzyć 200 miejsc do przechowywania np. peselu. Musiałbyś utworzyć 200 zmiennych i wyglądałoby to mniej więcej tak:
int miejsce1_pesel;
int miejsce2_pesel;
int miejsce3_pesel;
int miejsce199_pesel;
int miejsce200_pesel;
Takie klepanie kodu z pewnością byłoby męczące. A co teraz jeżeli zechcesz jeszcze przechowywać imię i nazwisko? Kolejne 400 linijek pisania by utworzyć zmienne? Tak by było gdyby nie istniały tablice zmiennych. Tablice zmiennych jednak istnieją i zamiast tworzyć każdą zmienną osobno to można określić ile ma być zmiennych danego typu:
int miejsce_pesel[ 200 ];
Jednowymiarowe tablice zmiennych
Tworzenie jednowymiarowych tablic zmiennych jest bardzo proste - wystarczy, że za deklaracją zwykłej zmiennej podamy liczbę elementów. W ogólnym przypadku wygląda to tak:
typ_zmiennej nazwa_zmiennej[ liczba_elementow ];
Uwaga!
Tworząc tablicę za pomocą powyższego zapisu należy pamiętać, że liczba_elementow musi być wartością stałą, która będzie znana w chwili kompilacji programu. Oznacza to, że użytkownik nie może określać rozmiaru tablicy w trakcie działania aplikacji (wspomniane ograniczenie dotyczy tylko i wyłącznie tablicy tworzonej w powyższy sposób). Poniższy kod prezentuje nieprawidłowe tworzenie tablicy, którego nie można stosować w kodzie.
int iloscElementow;
std::cin >> iloscElementow;
int tablica[ iloscElementow ];
|
Jak korzystać ze zmiennych tablicowych?
Gdy mieliśmy zmienną zwykłą, np.
int liczba;
to dostęp do niej uzyskiwaliśmy zapisem:
liczba
. Teraz gdy posiadamy tablicę, np.
int liczby[ 100 ];
to dostęp do poszczególnych elementów uzyskujemy poprzez zapis
liczby[ numer_indeksu ]
, gdzie numer_indeksu to liczba z przedziału od 0 do 99.
Pierwszy element tablicy w językach C i C++ zaczyna się
zawsze od indeksu 0, natomiast ostatni element posiada indeks
liczba_elementow-1, co łącznie daje nam 100 elementów (gdy zmienna
liczba_elementow wynosi 100).
Zobaczmy teraz jak to będzie wyglądało w praktyce:
#include <iostream>
int main()
{
int liczby[ 3 ];
std::cout << "Podaj liczbe 1:";
std::cin >> liczby[ 0 ];
std::cout << "Podaj liczbe 2:";
std::cin >> liczby[ 1 ];
liczby[ 2 ] = 567;
std::cout << "liczby[2] wynosi " << liczby[ 2 ] << std::endl;
int suma = liczby[ 0 ] + liczby[ 1 ] + liczby[ 2 ];
std::cout << "Suma trzech liczb wynosi:" << suma << std::endl;
return 0;
}
Powyższy program demonstruje:
Jeżeli przeanalizowałeś kod uważnie to zapewne zauważyłeś, że korzystanie ze zmiennych tablicowych praktycznie niczym się nie różni od zwykłych zmiennych poza tym, że należy podać w nawiasach kwadratowych indeks elementu z którym chcemy pracować.
Tablice zmiennych, a pętle
Zastosowanie tablic zmiennych daje nam nie tylko korzyść w postaci krótszego kodu, który tworzy określoną liczbę zmiennych ale również daje nam możliwość wielokrotnego przetwarzania danych dla różnych zmiennych tym samym kodem. Co to oznacza? Oznacza to, że jeżeli staniesz teraz przed sytuacją, w której będziesz chciał wczytać załóżmy 10 liczb do tablicy zmiennych to nie będziesz musiał tego robić tak:
int liczba[ 10 ];
std::cin >> liczba[ 0 ];
std::cin >> liczba[ 1 ];
std::cin >> liczba[ 2 ];
std::cin >> liczba[ 3 ];
std::cin >> liczba[ 4 ];
std::cin >> liczba[ 5 ];
std::cin >> liczba[ 6 ];
std::cin >> liczba[ 7 ];
std::cin >> liczba[ 8 ];
std::cin >> liczba[ 9 ];
Skoro indeksem jest liczba to równie dobrze może być to zmienna liczbowa, a skoro tak to nic nie stoi na przeszkodzie by wczytywanie liczb zrobić np. tak:
int liczba[ 10 ];
int licznik = 0;
do
{
std::cin >> liczba[ licznik ];
licznik++;
} while( licznik < 10 );
Kompletny program demonstrujący połączenie tablic i pętli może więc wyglądać tak:
#include <iostream>
int main()
{
int liczba[ 10 ];
int licznik = 0;
do
{
std::cin >> liczba[ licznik ];
licznik++;
} while( licznik < 10 );
std::cout << "Podales nastepujace liczby: ";
licznik = 0;
do
{
std::cout << liczba[ licznik ] << ", ";
licznik++;
} while( licznik < 10 );
return 0;
}
Tablice, a stabilność aplikacji
Najczęstszym błędem, jaki jest popełniany przez początkujących programistów (jak również i tych bardziej doświadczonych) jest wychodzenie poza zakres tablicy. Przykładowo:
int tablica[ 10 ];
tablica[ 10 ] = 123;
Pisząc poza tablicą modyfikujesz wartości innych zmiennych lub kodu maszynowego aplikacji - w efekcie uszkadzasz kod swojego programu co prowadzi do błędu krytycznego aplikacji. Wychodząc poza zakres tablicy może się zdarzyć również, że podejmiesz próbę pisania po pamięci innej aplikacji na co współczesne systemy operacyjne nie pozwalają. System operacyjny ochroni Twój komputer przed taką ewentualnością i wyrzuci błąd krytyczny Twojej aplikacji, zapobiegając jednocześnie możliwości modyfikacji zasobów, które do Ciebie nie należały.
Uwaga!
Wychodząc poza zakres tablicy narażasz się na błąd krytyczny aplikacji. Pamiętaj więc, aby zwracać szczególną uwagę na indeksy jakie ustawiasz odwołując się do elementu tablicy.
|
Zadanie domowe
Napisz program, który wylosuje 999 liczb całkowitych z zakresu od 4 do 10 włącznie, wypisze te wartości na ekran, po czym zsumuje je i wynik wypisze na ekran. Program ma wykorzystywać tablicę, która zostanie najpierw wypełniona liczbami losowymi z określonego przedziału, a następnie wynik zostanie obliczony na podstawie zawartości całej tablicy.