Podstawowe operacje na tablicach


Tematy pokrewne   Podrozdziały
Tablice – wektory
Podstawowe operacje na tablicach
Wyszukiwanie liniowe
Wyszukiwanie liniowe z wartownikiem
Zliczanie wg kryterium
Wyszukiwanie max lub min
Jednoczesne wyszukiwanie max i min
Zastosowania wyszukiwania – sortowanie przez wybór
Wyszukiwanie najczęstszej wartości w zbiorze – dominanta
Wyszukiwanie lidera
Wyszukiwanie binarne
Wyszukiwanie interpolacyjne
Wyszukiwanie k-tego największego elementu
Wyszukiwanie szybkie k-tego największego elementu
Wyszukiwanie mediany zbioru
Zbiory rozłączne – implementacja w tablicy
Sumy prefiksowe
Liczby parzyste i nieparzyste
Wbudowane generatory liczb pseudolosowych
Generowanie liczb pseudolosowych
  Deklarowanie tablic
Inicjalizacja tablic
Tablice dynamiczne
Tablice dynamiczne o dynamicznym rozmiarze
Wprowadzanie/wyprowadzanie danych
Wypełnianie tablicy

Deklarowanie tablic

Przed pierwszym użyciem każda tablica musi być zadeklarowana tak jak wszystkie zmienne używane w programie – tablica jest zmienną złożoną. Poniżej podajemy sposoby deklaracji tablicy w wybranych przez nas językach programowania:

 

Lazarus

Deklarację tablicy w języku Pascal umieszczamy w sekcji deklaracji zmiennych var. Składnia deklaracji tablicy jest następująca:

 

nazwa_tablicy : array[indeks_początkowy..indeks_końcowy] of typ_elementów;

nazwa_tablicy  –  tworzona jest wg zwykłych reguł tworzenia nazw zmiennych w języku Pascal
indeks_początkowy  – określa numer pierwszego elementu tablicy
indeks_końcowy  – określa numer ostatniego elementu w tablicy
typ_elementów  – określa rodzaj informacji przechowywanej w każdym elemencie tablicy

 

Słowa array oraz of są słowami kluczowymi, które muszą się pojawić w deklaracji tablicy. Poniżej podajemy kilka przykładów:

 

var
  ...
  a : array[1..3] of integer; // tablica zawierająca 3 elementy, które mogą przechowywać elementy całkowite
  x : array[0..9] of double;  // tablica przechowująca 10 liczb typu double
  c : array[2..7] of char;    // tablica przechowująca 6 wartości znakowych
  ...
 

W powyższym przykładzie zadeklarowano trzy tablice a, x oraz c. Posiadają one elementy o następujących indeksach:

 

Tablica a : a[1] a[2] a[3] - 3 elementy typu integer
Tablica x : x[0] x[1] x[2] x[3] x[4] x[5] x[6] x[7] x[8] x[9] - 10 elementów typu double
Tablica c : c[2] c[3] c[4] c[5] c[6] c[7] - 6 elementów typu char

 

Code::Blocks

Deklarację tablicy umieszczamy w języku C++ na liście deklaracji zmiennych. Składnia jest następująca:

 

typ_danych nazwa_tablicy[liczba_elementów];

typ_danych  –  określa rodzaj informacji przechowywanych przez deklarowane zmienne
nazwa_tablicy  – tworzona jest wg zwykłych reguł tworzenia nazw zmiennych w języku C++
Liczba_elementów  – określa, ile elementów danego typu przechowuje tablica

 

Poniżej podajemy kilka przykładów deklaracji tablic w C++:

 

...
int    a[3];  // tablica zawierająca 3 elementy typu int
double x[10]; // tablica przechowująca 10 liczb typu double
char   c[6];  // tablica przechowująca 6 wartości znakowych
...
 

W języku C++ indeksy tablic rozpoczynają się od 0. Ma to sens, ponieważ nazwa tablicy jest traktowana zawsze jak adres początku obszaru pamięci, w którym tablica przechowuje swoje elementy. Naturalne zatem jest, iż pierwszy element leży właśnie pod adresem tablicy. Stąd jego indeks wynosi 0, czyli nic nie musimy dodawać do adresu początku tablicy, aby uzyskać dostęp do jej pierwszego elementu.

W powyższym przykładzie zadeklarowano trzy tablice a, x oraz c. Posiadają one elementy o następujących indeksach:

 

Tablica a : a[0] a[1] a[2] - 3 elementy typu integer
Tablica x : x[0] x[1] x[2] x[3] x[4] x[5] x[6] x[7] x[8] x[9] - 10 elementów typu double
Tablica c : c[0] c[1] c[2] c[3] c[4] c[5] - 6 elementów typu char

 

Zwróć uwagę, iż tablica nie posiada elementu o indeksie równym ilości elementów. Zatem jeśli zadeklarujemy np. tablicę:

 

double Tlk[168];

 

to jej ostatnim elementem jest Tlk[167], a nie Tlk[168]. Odwołanie się w programie do Tlk[168] jest błędem, którego kompilator zwykle nie zgłosi, zakładając, iż programista wie co robi. Niestety, język C++ nie był tworzony z myślą o początkujących.

 

Free Basic

Deklaracji tablicy w języku Free Basic dokonujemy w obrębie instrukcji Dim wraz z innymi zmiennymi. Składnia jest następująca:

 

Dim nazwa_tablicy(indeks_końcowy) As typ_elementów
Dim nazwa_tablicy(indeks_początkowy To indeks_końcowy) As typ_elementów
Dim As typ_elementów nazwa_tablicy(indeks_końcowy)
Dim As typ_elementów nazwa_tablicy(indeks_początkowy To indeks_końcowy)

 

Dwie końcowe składnie pozwalają szybko deklarować jednym poleceniem Dim zmienne tego samego typu, na przykład:

 

Dim As Integer a, b, x(20), h(3 To 10)
 

Poniżej podajemy kilka przykładów deklaracji tablic:

 

...
Dim a(1 To 3) As Integer   ' tablica zawierająca 3 elementy, które mogą przechowywać elementy całkowite
Dim As Double x(9)         ' tablica przechowująca 10 liczb typu double
Dim c(2 To 7) As Ubyte     ' tablica przechowująca 6 wartości 8 bitowych bez znaku
...
 

W powyższym przykładzie zadeklarowano trzy tablice a, x oraz c. Posiadają one elementy o następujących indeksach:

 

Tablica a : a[1] a[2] a[3] - 3 elementy typu Integer
Tablica x : x[0] x[1] x[2] x[3] x[4] x[5] x[6] x[7] x[8] x[9] - 10 elementów typu Double
Tablica c : c[2] c[3] c[4] c[5] c[6] c[7] - 6 elementów typu Ubyte

 

Inicjalizacja tablic

Często zdarza się, iż chcemy utworzyć tablicę z zadaną z góry zawartością (np. tablica zawierająca początkowe liczby pierwsze). Postępujemy wtedy w sposób następujący:

 

Lazarus

W bloku deklaracji zmiennych var wpisujemy:

 

nazwa_tablicy : array[indeks_początkowy..indeks_końcowy] of typ_elementów = (lista_wartości_dla_kolejnych_elementów);

 

Poniższy przykład tworzy tablicę 10 liczb całkowitych i wypełnia ją kolejnymi liczbami Fibonacciego.

 

var
   ...
   fib : array[0..9] of integer = (0,1,1,2,3,5,8,13,21,33);
   ...
 

Code::Blocks

Składnia inicjalizacji tablicy w języku C++ jest następująca:

 

typ_elementów nazwa_tablicy = {lista_wartości_dla_kolejnych_elementów};

 

Zwróć uwagę, iż nie musimy podawać liczby elementów. Kompilator utworzy tyle elementów, ile podamy dla nich wartości na liście inicjalizacyjnej.  Poniższy przykład tworzy tablicę 10 liczb całkowitych i wypełnia ją kolejnymi liczbami Fibonacciego.

 

...
int fib[] = (0,1,1,2,3,5,8,13,21,33);
...
 

Free Basic

W języku Basic tablicę tworzymy i inicjujemy w obrębie polecenia Dim:

 

Dim nazwa_tablicy(indeks_końcowy) As typ_elementów => {lista_wartości_dla_kolejnych_elementów}
Dim nazwa_tablicy(indeks_początkowy To indeks_końcowy) As typ_elementów => {lista_wartości_dla_kolejnych_elementów}

 

W pierwszym przypadku tablica zawiera elementy o indeksach przebiegających od 0 do wartości podanej jako indeks_końcowy. W przypadku drugim programista może swobodnie określać zakres indeksów tablicy. Liczba wartości na liście inicjalizacyjnej musi się zgadzać z deklaracją indeksów. Poniższy przykład tworzy tablicę 10 liczb całkowitych i wypełnia ją kolejnymi liczbami Fibonacciego.

 

...
Dim fib(9) as integer => {0,1,1,2,3,5,8,13,21,33}
...

 

Tablice dynamiczne

Zdarza się, iż w trakcie pisania programu nie wiemy, ile dokładnie elementów będzie zawierała używana w tym programie tablica. W takim przypadku problem tworzenia tablicy możemy rozwiązać na dwa sposoby:

  1. Utworzyć tablicę o maksymalnej, przewidywanej liczbie elementów. Rozwiązanie nieefektywne ze względu na wykorzystanie pamięci. Jeśli w typowych przypadkach wykorzystujemy małą liczbę elementów tablicy, to i tak musimy rezerwować założoną ilość komórek dla przypadku pesymistycznego, który pojawia się bardzo rzadko, ale jest prawdopodobny.
  2. Utworzyć tablicę dynamicznie o tylu komórkach, ile w danej chwili jest nam potrzebne. Po wykorzystaniu, tablicę dynamiczną usuwamy, zwalniając w ten sposób zajmowany przez nią obszar pamięci, który teraz można wykorzystać do innych celów – np. dla nowej tablicy dynamicznej.

Lazarus

Aby utworzyć tablicę dynamiczną w języku Lazarus najpierw deklarujemy jej typ:

 

type
  nazwa_typu_tablicy = array of nazwa_typu_elementów;

 

Zwróć uwagę, iż w definicji typu za słowem array nie podajemy zakresu indeksów. Ma to sens, ponieważ ilość elementów będzie określana dynamicznie w czasie wykonywania programu. Teraz kompilator potrzebuje jedynie informacji o typie elementów, które będzie przechowywała tablica. Pozwoli mu to później zarezerwować odpowiedni obszar pamięci oraz obliczać adresy indeksowanych elementów. Poniższy przykład tworzy typ dynamicznej tablicy, która będzie przechowywała elementy typu double:

 

type
  Tdouble = array of integer;
 

Po zdefiniowaniu typu dla tablicy dynamicznej możemy go użyć do tworzenia zmiennych w bloku var.

 

var
  nazwa_zmiennej : nazwa_typu_tablicy;

 

Poniższy przykład wykorzystuje typ Tdouble do utworzenia trzech zmiennych a,b,c.

 

var
   a,b,c : Tdouble;

 

Każda ze zmiennych a, b, c jest w rzeczywistości wskaźnikiem, czyli zmienną przechowującą adres właściwych danych. Na początku wszystkie trzy wskaźniki zawierają adres NIL, który w Pascalu nie wskazuje żadnego obiektu. Jeśli chcemy używać tablicy dynamicznej, to na początku programu musimy zarezerwować w pamięci odpowiedni obszar na elementy tablicy i adres początku tego obszaru umieścić we wskaźniku. Dokonujemy tego za pomocą procedury:

 

SetLength(nazwa_zmiennej, liczba_komórek_tablicy);

 

Po tej operacji mamy dostęp do poszczególnych elementów tablicy za pomocą indeksów. W tablicach dynamicznych indeksy kolejnych elementów rozpoczynają się od 0, a kończą na liczbie komórek tablicy - 1. Poniższy przykład tworzy trzy tablice dynamiczne o elementach typu Tdouble zawierające odpowiednio 10, 100 i 1000 elementów:

 

...
SetLength(a,10);    // elementy od a[0] do a[9]
SetLength(b,100);   // elementy od b[0] do b[99]
SetLength(c,1000);  // elementy od c[0] do c[999]
...
 

Jeśli tablica dynamiczne została utworzona w procedurze lub funkcji, to jest automatycznie usuwana z pamięci po zakończeniu działania procedury lub funkcji. Tablicę dynamiczną można usunąć z pamięci ustawiając jej długość na 0. Poniższy przykład usuwa tablicę c:

 

...
SetLength(c,0);
...
 

Należy pamiętać, iż usunięty został obszar pamięci zajmowany przez elementy tablicy c, a nie sama zmienna c, która jest tylko wskaźnikiem.

Ponieważ zmienne tablic dynamicznych są wskaźnikami, to poniższa operacja nie powoduje przepisania elementów tablicy b[] do tablicy a[], jak można by przypuszczać:

 

a := b;
 

W rzeczywistości w zmiennej a znajdzie się adres przechowywany przez zmienną b. Zmienna a będzie wskazywała ten sam obszar pamięci co zmienna b. Do elementów tablicy b możemy się odwoływać poprzez elementy tablicy a – to jest ta sama tablica, tylko jej adres jest teraz w dwóch różnych zmiennych. Należy na to zwrócić baczną uwagę, gdyż złe zrozumienie tych faktów prowadzi do trudnych do wykrycia błędów w programach.

 

Code::Blocks

W celu utworzenia w języku C++ tablicy dynamicznej, tworzymy zmienną wskaźnikową na typ danych, które mają być przechowywane w tablicy:

 

typ_elementów * nazwa_tablicy_dynamicznej;

 

Zmienna wskaźnikowa (ang. pointer variable) nie przechowuje danych tylko adres obszaru pamięci komputera, w którym te dane się znajdują. Deklarację zmiennej wskaźnikowej zawsze poprzedzamy znakiem gwiazdki. W poniższym przykładzie tworzymy trzy wskaźniki a, b i c do danych typu double (czyli do obszaru pamięci, w którym będą przechowywane liczby zmiennoprzecinkowe o podwójnej precyzji):

 

...
double * a, * b, * c;
...
 

Pamięć rezerwujemy operatorem new i adres zarezerwowanego obszaru umieszczamy w zmiennej wskaźnikowej:

 

nazwa_tablicy_dynamicznej = new typ_elementów[liczba_elementów];

 

Poniższy przykład tworzy trzy tablice dynamiczne, w których będzie można przechowywać odpowiednio 10, 100 i 1000 elementów typu double:

 

...
a = new double[10];    // elementy od a[0] do a[9]
b = new double[100];   // elementy od b[0] do b[99]
c = new double[1000];  // elementy od c[0] do c[999]
...
 

Po tej operacji do elementów tablic a, b i c odwołujemy się w zwykły sposób za pomocą indeksów. Istnieje również alternatywna metoda, wykorzystująca fakt, iż zmienne a, b i c są wskaźnikami. W języku C++ dodanie do wskaźnika liczby całkowitej powoduje obliczenie adresu elementu o indeksie równym dodawanej liczbie. Zatem wynik takiej operacji jest również wskaźnikiem:

 

Tablica Wskaźnik
a[2] = 10.54;
cout << a[2] << endl;
* (a + 2) = 10.54;
cout << * (a + 2) << endl;

 

W rzeczywistości zapis a[i] kompilator i tak przekształca sobie na zapis * (a + i). Forma tablicowa jest tylko uproszczeniem zapisu wskaźnikowego.

Tablice dynamiczne nie są automatycznie usuwane z pamięci, jeśli utworzono je w funkcji. Dlatego po zakończeniu korzystania z tablicy program powinien zwolnić zajmowaną przez tablicę pamięć. Dokonujemy tego poleceniem delete w sposób następujący:

 

delete [] nazwa_tablicy_dynamicznej;

 

W poniższym przykładzie zwalniamy pamięć zarezerwowaną wcześniej na elementy tablic b i c.

 

...
delete [] b;  // usuwamy obszar wskazywany przez b
delete [] c;  // usuwamy obszar wskazywany przez c
...
 

Należy również wspomnieć, iż Code::Blocks dopuszcza konstrukcję:

 

typ_elementów nazwa_tablicy[zmienna];

 

co pozwala na tworzenie statycznych tablic o liczbie elementów podanej w zmiennej. Na przykład poniższa konstrukcja programowa tworzy statyczną tablicę a o liczbie elementów odczytanej ze strumienia wejściowego konsoli znakowej:

 

...
int n;
cin >> n;
double a[n];
...
 

Jednakże nie jest to zbyt standardowe rozwiązanie i może nie być przenośne na inne kompilatory C++, dlatego odradzam używania go – lepiej zastosować tablicę dynamiczną.

 

Free Basic

W języku Basic dynamiczna tablica powstaje, gdy w poleceniu Dim użyjemy zmiennej do określenia rozmiaru tablicy. Poniższy przykład tworzy tablicę liczb typu double o rozmiarze odczytanym z klawiatury:

 

Dim n As Integer
Input n
Dim a(n) As Double
 

W tym samym celu możemy również wykorzystać polecenie Redim. Poniższy przykład tworzy trzy tablice dynamiczne zawierające odpowiednio 10, 100 i 1000 elementów typu double:

 

Redim As Double a(9), b(99), c(999)
 

Gdy tablica dynamiczna przestanie być potrzebna, można ją usunąć z pamięci poleceniem:

 

Erase nazwa_tablicy_dynamicznej

 

Inny sposób tworzenia tablic dynamicznych wiąże się z wykorzystaniem wskaźników. Wskaźnik jest zmienną, która zawiera adres innej zmiennej. Procedura tworzenia tablicy dynamicznej za pomocą wskaźnika jest następująca:

 

1. Tworzymy wskaźnik do danych, które ma przechowywać tablica:

 

Dim A As typ_danych Ptr

 

2. Przydzielamy blok pamięci na n danych:

 

A = New typ_danych [n]

 

3. Tablica gotowa, dostęp do elementów uzyskujemy za pomocą indeksów w nawiasach kwadratowych:

 

A[15] = ...

 

4. Gdy tablica przestanie być potrzebna, należy zwolnić zajmowaną przez nią pamięć:

 

Delete [] A

 

Tablice dynamiczne o dynamicznym rozmiarze

Gdy operujemy na dynamicznych strukturach danych, to często okazuje się, że taką strukturę należy zwiększyć lub zmniejszyć w czasie działania programu. Np. utworzyliśmy na początku algorytmu dynamiczną tablicę 100 elementową, lecz dalej okazało się, że w tablicy tej należy dodatkowo umieścić jeszcze 50 kolejnych elementów. Co możemy zrobić? Odpowiedź jest prosta – dynamicznie zmienić rozmiar naszej struktury. Zasada jest następująca:

 

Oprócz wskazania do tablicy tworzymy dodatkową zmienną, która przechowuje jej maksymalny rozmiar. Oznaczmy tę zmienną przez nn. Każdą tablicę tworzymy z pewnym zapasem komórek, oznaczmy go przez z. Zmienna n przechowuje informację o ilości zajętych komórek.

Gdy dodajemy element do tablicy, to najpierw zwiększamy n o 1 i sprawdzamy, czy warunek n >= nn jest spełniony. Jeśli tak, to tablica zawiera za mało komórek, i należy zwiększyć jej rozmiar. Operację tę przeprowadzamy następująco:

  1. Rezerwujemy nowy obszar pamięci o rozmiarze nn + z i zapamiętujemy jego adres w tymczasowej zmiennej.
  2. Przepisujemy zawartość starego obszaru tablicy do nowego.
  3. Usuwamy stary obszar – w ten sposób system odzyska pamięć.
  4. Do wskaźnika tablicy przepisujemy adres ze zmiennej tymczasowej.
  5. Zmienną nn zwiększamy o z

Zwróć uwagę, że cała tablica zmieniła swoje położenie w pamięci. Jeśli zatem posiadałeś jakieś zmienne, które przechowywały adresy jej elementów (wskaźniki), to teraz przestaną one być aktualne, ponieważ wskazują stary obszar, który już do tej tablicy nie należy (chociaż przez pewien czas może zachowywać swoją zawartość aż system zapisze go innymi danymi). Należy to wziąć pod uwagę, gdy planujesz wykorzystywanie dynamicznych tablic o dynamicznym rozmiarze.

 

Lazarus
...
inc(n);
if n >= Length(A) then SetLength(A,Length(A)+z);
...
Code::Blocks
...
if(++n >= nn)
{
  typ_danych * T = new typ_danych[nn+z];
  for(int i = 0; i < nn; i++) T[i] = A[i];
  delete [] A;
  A = T;
  nn += z;
}
...
Free Basic
Dim As typ_danych Ptr T
Dim As Integer i
...
n += 1
If n >= nn Then
  T = New typ_danych [nn+z]
  For i = 0 To nn-1: T[i] = A[i]: Next
  Delete [] A
  A = T
  nn += z
End If
...  

 

Przy usuwaniu elementów z tablicy postępujemy podobnie. Gdy usuniemy element, to rozmiar tablicy n zostanie zmniejszony o 1. Sprawdzamy, czy jest spełniony warunek  nnn - 2z. Jeśli tak, to tablica zajmuje zbyt duży obszar i powinniśmy zmniejszyć jej rozmiar. Dlaczego w nierówności użyliśmy 2z a nie po prostu z? Chodzi o to, aby po zmniejszeniu rozmiaru tablica wciąż posiadała zapas z komórek, co zmniejszy ryzyko częstych przeładowań pamięci, które są przecież kosztowne czasowo. Zmianę rozmiaru tablicy wykonujemy podobnie jak przy zwiększaniu liczby elementów:

 

Lazarus
...
dec(n);
if n <= Length(A)-z-z then SetLength(A,Length(A)-z);
...
Code::Blocks
...
if(--n <= nn-z-z)
{
  typ_danych * T = new typ_danych[nn-z];
  for(int i = 0; i < n; i++) T[i] = A[i];
  delete [] A;
  A = T;
  nn -= z;
}
...
Free Basic
Dim As typ_danych Ptr T
Dim As Integer i
...
n -= 1
If n <= nn-z-z Then
  T = New typ_danych [nn-z]
  For i = 0 To n-1: T[i] = A[i]: Next
  Delete [] A
  A = T
  nn -= z
End If
...  

 

Wprowadzanie/wyprowadzanie danych

Dane dla programu zwykle muszą być odczytywane ze zewnętrznego źródła – konsoli lub pliku. W takim przypadku nie wiemy z góry (tzn. w trakcie pisania programu) ile ich będzie. Narzucającym się rozwiązaniem jest zastosowanie tablic dynamicznych. Ze źródła danych odczytujemy rozmiar tablicy, tworzymy tablicę dynamiczną o odpowiednim rozmiarze, a następnie wczytujemy do jej komórek poszczególne dane.

Poniżej podajemy sposoby odczytu zawartości tablicy z konsoli. Sposób ten jest bardzo ogólny. Wykorzystanie standardowego wejścia jako źródła danych daje nam kilka możliwości wprowadzania danych:

  1. Dane podajemy bezpośrednio z klawiatury. Sposób skuteczny i prosty dla niedużego zbioru danych. Jednakże przy większej ich liczbie staje się bardzo uciążliwy.
  2. Skopiowanie danych poprzez schowek. Procedura postępowania jest następująca:

    – tworzymy w notatniku Windows (aplikacja zawsze pod ręką) odpowiedni zbiór danych
    – zbiór kopiujemy do schowka (zaznaczamy całość Ctrl-A i naciskamy Ctrl-C)
    – uruchamiamy program
    – klikamy prawym przyciskiem myszki w pasek tytułowy okna konsoli
    – z menu kontekstowego wybieramy polecenie EdytujWklej
    – gotowe

  3. Przekierowanie standardowego wejścia z konsoli na plik na dysku. W tym przypadku program będzie pobierał dane z pliku, a nie z klawiatury. Aby to uzyskać uruchamiamy program w oknie konsoli następująco:
    nazwa_programu  < nazwa_pliku_wejściowego

    Na przykład nasz program nazywa się szukaj.exe, a plik nosi nazwę dane.txt. Odpowiednie polecenie odczytu danych z pliku przez nasz program wygląda następująco:

    szukaj < dane.txt

    To rozwiązanie umożliwia również zapis danych wynikowych nie na ekran konsoli, lecz do pliku na dysku. W tym celu wystarczy wydać polecenie:

    nazwa_programu > nazwa_pliku_wynikowego


    Wejście i wyjście można przekierować w jednym poleceniu. Np. nasz program szukaj może odczytać dane wejściowe z pliku dane.txt, a wyniki swojej pracy umieścić w pliku wyniki.txt. W tym celu wydajemy takie oto polecenie:

    szukaj < dane.txt > wyniki.txt


    Jeśli często korzystasz z takich opcji uruchamiania programu, to zamiast wpisywać polecenie z klawiatury, można stworzyć sobie prosty plik wsadowy (ang. batch file), w którym umieszczamy niezbędne polecenia. Plikowi można nadać prostą nazwę, np. !.cmd. Wtedy w celu uruchomienia zawartych w nim poleceń wystarczy wpisać !. Oczywiście plik wsadowy należy umieścić w katalogu projektowym, ale to chyba już wiesz. Poniżej podaję przykładową zawartość takiego pliku wsadowego:

    @echo off
    cls
    echo DANE WEJSCIOWE:
    echo.
    type dane.txt
    echo.
    prg < dane.txt > wyniki.txt
    echo WYNIKI:
    echo.
    type wyniki.txt
    echo.

Program

Ważne:

Zanim uruchomisz program, przeczytaj wstęp do tego artykułu, w którym wyjaśniamy funkcje tych programów oraz sposób korzystania z nich.

 

Program z pierwszego wiersza odczytuje liczbę n określającą ilość danych. Z następnych n wierszy odczytywane są dane i umieszczane w tablicy dynamicznej. Odczytane dane zostają następnie wyświetlone jedna obok drugiej. Wypróbuj z tym programem podane powyżej trzy opcje dostarczania danych i wyprowadzania wyników.

 

Lazarus
// Odczyt danych
// Data:   25.04.2008
// (C)2012 mgr Jerzy Wałaszek
//---------------------------

program prg;

type Tinteger = array of integer;

var T   : Tinteger;
    n,i : integer;

begin
  readln(n);

  SetLength(T,n);

  for i := 0 to n-1 do readln(T[i]);

  writeln;

  for i := 0 to n-1 do write(T[i],' ');

  writeln;
  writeln;

  SetLength(T,0); 

end.
Code::Blocks
// Odczyt danych
// Data:   25.04.2008
// (C)2012 mgr Jerzy Wałaszek
//---------------------------

#include <iostream>

using namespace std;

int main()
{
  int * T,n,i;

  cin >> n;
  
  T = new int[n];
  
  for(i = 0; i < n; i++) cin >> T[i];

  cout << endl;

  for(i = 0; i < n; i++) cout << T[i] << " ";

  cout << endl << endl;

  delete [] T;

  return 0;
}
Free Basic
' Odczyt danych
' Data:   25.04.2008
' (C)2012 mgr Jerzy Wałaszek
'---------------------------

Dim T As Integer Ptr
Dim As Integer n,i

Open Cons For Input As #1

Input #1,n

T = New Integer [n]

For i = 0 To n - 1
  Input #1,T[i]
Next

Close #1

Print

For i = 0 To n - 1
  Print T[i];
Next

Print
Print

Delete [] T

End
Wynik
6
12
34
28
65
121
83

12 34 28 65 121 83

 

Wypełnianie tablicy

Czasami algorytm musi wstępnie wypełnić tablicę określoną zawartością. Operację taką przeprowadza się w pętli iteracyjnej, której zmienna licznikowa przebiega przez wszystkie kolejne indeksy elementów. Następnie wykorzystuje się zmienną licznikową jako indeks elementu tablicy, w którym umieszczamy określoną zawartość.

W poniższych przykładach zakładamy, iż w programie zadeklarowano tablicę T o 100 elementach typu integer. Indeksy elementów tablicy T są w zakresie od 0 do 99.

 

Wypełnianie stałą zawartością x

Lazarus Code::Blocks Free Basic
...
for i := 0 to 99 do T[i] := x;
...
...
for(i = 0; i < 100; i++) T[i] = x;
...
...
For i = 0 To 99
  T(i) = x
Next
...

 

Wypełnianie liczbami parzystymi począwszy od 2

Lazarus Code::Blocks Free Basic
...
for i := 0 to 99 do
  T[i] := (i + 1) shl 1;
...
...
for(i = 0; i < 100; i++)
  T[i] = (i + 1) << 1;
...
...
For i = 0 To 99
  T(i) = (i + 1) shl 1
Next
...

 

Wypełnianie liczbami nieparzystymi począwszy od 1

Lazarus Code::Blocks Free Basic
...
for i := 0 to 99 do
  T[i] := 1 + (i shl 1);
...
...
for(i = 0; i < 100; i++)
  T[i] = 1 + (i << 1);
...
...
For i = 0 To 99
  T(i) = 1 + (i shl 1)
Next
...

 

Wypełnianie liczbami pseudolosowymi z przedziału <a,b>

Lazarus Code::Blocks Free Basic
randomize;
...
for i := 0 to 99 do
  T[i] := a + random(b - a + 1);
...
#include <cstdlib>
#include <time.h>

...
srand((unsigned)time(NULL));
...
for(i = 0; i < 100; i++)
  T[i] = a + rand() % (b - a + 1);
...
Randomize
...
For i = 0 To 99
  T(i) = a + Cint(Rnd * (b - a + 1))
Next
...

 



List do administratora Serwisu Edukacyjnego Nauczycieli I LO

Twój email: (jeśli chcesz otrzymać odpowiedź)
Temat:
Uwaga: ← tutaj wpisz wyraz  ilo , inaczej list zostanie zignorowany

Poniżej wpisz swoje uwagi lub pytania dotyczące tego rozdziału (max. 2048 znaków).

Liczba znaków do wykorzystania: 2048

 

W związku z dużą liczbą listów do naszego serwisu edukacyjnego nie będziemy udzielać odpowiedzi na prośby rozwiązywania zadań, pisania programów zaliczeniowych, przesyłania materiałów czy też tłumaczenia zagadnień szeroko opisywanych w podręcznikach.



   I Liceum Ogólnokształcące   
im. Kazimierza Brodzińskiego
w Tarnowie

©2017 mgr Jerzy Wałaszek

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.