KURS JĘZYKA PASCAL

1. Podstawy programowania - wprowadzenie (Aplikacja01.dpr)

2. Deklaracje stałych i zmiennych, operacje we-wy (Aplikacja02.dpr)

3. Instrukcje warunkowe

• Instrukcja if (Aplikacja03.dpr)

• Instrukcja case (Aplikacja04.dpr)

Pętle

• Instrukcja for (Aplikacja05.dpr)

• Instrukcja while, operator mod i div (Aplikacja06.dpr)

• Instrukcja repeat, generowanie liczb pseudolosowych (Aplikacja07.dpr)

• Procedury (Aplikacja08.dpr)

• Funkcje (Aplikacja09.dpr)

• Funkcje i procedury - ciąg dalszy

• Przykłady (Aplikacja10.dpr)

• Przykłady c.d. (Aplikacja11.dpr)

• Przykłady c.d. (Aplikacja12.dpr)

• Typy tablicowe - wektory

• Szukanie elementu maksymalnego, sortowanie (Aplikacja13.dpr)

• Typy tablicowe - tablice dwu- i wielowymiarowe (Aplikacja14.dpr)

• Typ łańcuchowy string

• Podstawowe operacje (Aplikacja15.dpr)

• Podstawowe operacje c.d. (Aplikacja16.dpr)

• Operacje konwersji do typow liczbowych (Aplikacja17.dpr)

• Typ rekordowy (Aplikacja18.dpr)

• Typ zbiorowy

• Podstawowe operacje (Aplikacja19.dpr)

• Podstawowe operacje c.d. (Aplikacja20.dpr)

• Pliki w pascalu

• Pliki tekstowe (Aplikacja21.dpr)

• Pliki tekstowe c.d. (Aplikacja22.dpr)

• Pliki binarne (Aplikacja23.dpr)

• Wskaźniki

• Podstawowe operacje (Aplikacja24.dpr)

• Zmienne dynamiczne (Aplikacja25.dpr)

Aplikacja01.dpr






program Aplikacja01;
{tematyka:
    - wprowadzenie do jezyka Pascal}

//tu sie zaczyna czesc deklaracyjna programu

{$APPTYPE CONSOLE}     //informacja dla kompilatora

begin
//tu sie zaczyna czesc wykonawcza programu

//tak mozna stawiac komentarze o dlugosci jednej linii...

{...a tak podaje sie komentarze
   dluzsze niz jedna linia}

   write('Jan ');  //wypisane na ekranie bez znaku konca linii
   write('Kowalski');

   writeln;   //oddzielenie tekstu linia

   writeln('ul. Skowronkow 13'); // wypisanie na ekranie ze znakiem konca linii

   readln;    //czekanie na nacisniecie klawisza ENTER
end.

Deklaracje stałych i zmiennych, operacje we-wy

Aplikacja02.dpr






program Aplikacja02;
{tematyka:
    - deklaracje stalych i zmiennych
    - operacje wejscia-wyjscia}


{$APPTYPE CONSOLE}

const
   pi=3.14;        //stala

var
   x:integer;    //deklaracja zmiennej typu calkowitego
   y,a:double;   //deklaracja zmiennych typu rzeczywistego
   s:string;     //lancuch tekstowy
   b:boolean;    //zmienna logiczna

begin

   //pi:=15;     //nie mozna modyfikowac stalej!!!

   x:=2;         //przyporzadkowanie wartosci
   y:=x+pi;

   write('Podaj wartosc a: ');
   readln(a);    //odczytanie wartosci z klawiatury;

   write('Podaj tekst   s: ');
   readln(s);    //tu wpisz jakis tekst

   b:=false;     //lub true

   writeln;
   writeln('x wynosi:  ',x);
   writeln('y wynosi:  ',y:8:3);  {formatowanie (8 miejsc na liczbe
                                  i 2 po przecinku)}
   writeln('pi wynosi: ',pi:8:3);
   writeln('a wynosi:  ',a:8:3);
   writeln('s wynosi:  ',s);
   writeln('b wynosi:  ',b);

   readln;

end.

Wstecz

Instrukcje warunkowe

• Instrukcja if (Aplikacja03.dpr)

• Instrukcja case (Aplikacja04.dpr)

Aplikacja03.dpr





Wstecz

program Aplikacja03;
{tematyka:
    - instrukcja warunkowa if}

{$APPTYPE CONSOLE}

var
   x:integer;  //liczba calkowita
   y:double;   //liczba rzeczywista

begin
   write('Podaj wartosc x:');
   readln(x);

   //zastosowanie instrukcji if
   if x>0 then
      writeln('Podales liczbe dodatnia.');

   {//inna mozliwa wersja...
    if x>0 then
      writeln('Podales liczbe dodatnia.')  //UWAGA!!! Przed else nie ma srednika!!!
    else
        writeln('Podales liczbe niedodatnia.');
    }

   {//...i jeszcze inna mozliwa wersja:
   if x>0 then
      writeln('Podales liczbe dodatnia.')
    else
        if x<0 then
           writeln('Podales liczbe ujemna.')
          else
             writeln('Podales zero.');
    }


    //... i jeszcze jeden przyklad...

    write('Podaj wartosc z ktorej chcesz obliczyc pierwiastek:');
    readln(y);

    {Poniewaz w instrukcji if stosuje wiecej niz jedna instrukcje
     to musze zastosowac begin i end}
    if (y>=0) then
       begin
          writeln('Z tej wartosci mozna obliczyc pierwiastek.');
          writeln('Pierwiastek wynosi: ',sqrt(y):8:3);
          {Wyzej zastosowane zostalo formatowanie liczb rzeczywistych
           8 - liczba miejsc zarezerwowanych na cala liczbe,
           3 - liczba miejsc dziesietnych.}
       end
      else
         writeln('Podales liczbe ujemna...');

   readln;

end.

Wstecz

Aplikacja04.dpr





Wstecz

program Aplikacja04;
{tematyka:
  - insrukcja warunkowa case}

{$APPTYPE CONSOLE}

var
   x:integer;

begin
   write('Podaj ocene w postaci liczbowej: ');
   readln(x);

   write('Forma slowna: ');
   case x of   //case zmienna of
      2:write('ocena niedostateczna');
      3:write('ocena dostateczna');
      4:write('ocena dobra');
      5:write('ocena bardzo dobra')
      else //a co w innym wypadku?
        write('Zle podana liczba');
   end; //od case

   //UWAGA!!! Zmienna x musi byc typu porzadkowego!!!

   readln;

end.

Wstecz

Pętle

• Instrukcja for (Aplikacja05.dpr)

• Instrukcja while, operator mod i div (Aplikacja06.dpr)

• Instrukcja repeat, generowanie liczb pseudolosowych (Aplikacja07.dpr)

Aplikacja05.dpr





Wstecz

program Aplikacja05;
{tematyka:
  - petla for}

{$APPTYPE CONSOLE}

var
   x:integer;
begin
   //program ma wypisac liczby od 1 do 10 i ich kwadraty

   //zmienna sterujaca x zmienia sie w zakresie od 1 do 10, co 1
   for x:=1 to 10 do
       begin //bedzie wiecej niz jedna linia w petli, czyli stosuje begin i end
          write(x,' ');
          writeln(sqr(x)); //sqr - kwadrat z danej liczby
       end;

   writeln('---------');

   //mozna tez w porzadku malejacym, z jednym poleceniem writeln
   for x:=10 downto 1 do
      writeln(x,' ',sqr(x));

   readln;

end.

Aplikacja06.dpr






program Aplikacja06;
{tematyka:
  - zastosowanie petli while
  - operator reszty z dzielenia mod
  - operator dzielenia bez reszty div}

{$APPTYPE CONSOLE}

var
   x,n,q:integer;

begin
   {Nalezy wypisac wszystkie liczby niepodzielne przez q,
    z zakresu od 1 do n.}

   write('Podaj q: ');
   readln(q);

   write('Podaj n: ');
   readln(n);

   writeln;
   writeln('A oto liczby niepodzielne przez ',q,' z zakresu <0,',n,'>:');
   x:=0;
   while x<=n do //warunek kontynuacji petli
      begin
         //jezeli reszta z dzielenia calkowitego jest niezerowa
         if x mod q<>0 then
            writeln(x);
         x:=x+1;
      end;

   {UWAGA!!! W petli while najpierw sprawdzany jest warunek a nastepnie
    jest wykonywany ciag instrukcji.}

   //i jeszcze jeden przyklad...
   //...tym razem wszystkie liczby podzielne przez q...
   //...z wykorzystaniem operatora div

   writeln('A oto liczby podzielne przez ',q,' z zakresu <0,',n,'>:');
   x:=0;
   while x<=n do
      begin
         //jezeli reszta z dzielenia calkowitego jest niezerowa
         if (x div q)=x/q then
            writeln(x);
         x:=x+1;
      end;

   readln;

end.

Aplikacja07.dpr





Wstecz

program Aplikacja07;
{tematyka:
  - petla repeat
  - generowanie liczb pseudolosowych}

{$APPTYPE CONSOLE}

var
   x,y,n:integer;

begin
   //napisac gre w zgadywanie liczb z okreslonego zakresu <1,n>

   write('Podaj maksymalna wartosc losowania: ');
   readln(n);

   randomize;  //przygotowanie do losowania

   y:=random(n)+1; //losowanie zgadywanej liczby

   {UWAGA!!! Polecenie random(n) losuje liczbe z zakresu od 0 do n-1.}

   repeat
      write('Podaj wartosc:');
      readln(x);

      if x<y then
         writeln('Podana liczba jest za mala.')
        else
           if x>y then
              writeln('Podana liczba jest za duza.');
   until x=y;  //warunek zakonczenia petli

   writeln('Gratulacje!!! Wygrales!!!');

   {UWAGA!!! W petli repeat:
               - Najpierw wykonywany jest ciag instrukcji a potem
                 sprawdzany warunek.
               - Nie trzeba obejmowac polecen w petli przy pomocy begin i end.}

    //Cwiczenie: Sproboj dodac zmienna zliczajaca ilosc trafien
   
    readln;

end.

Procedury

Aplikacja08.dpr


program Aplikacja08;
{tematyka:
  - procedury}
{$APPTYPE CONSOLE}
var
  a,b:integer;

//Deklaracje procedur i funkcji piszemy w czesci deklaracyjnej programu

//wypisanie wizytowki
procedure wizytowka;
begin
   writeln('***************************');
   writeln('*     Imie i Nazwisko     *');
   writeln('*     ul.  Skowronkow     *');
   writeln('*  43-300  Bielsko-Biala  *');
   writeln('***************************');
end;
//wypisanie wspolrzednych punktu
procedure wypisz_punkt(x,y:integer);  //w nawiasie sa podane parametry x i y
begin
  writeln('Wspolrzedne punktu wynosza: (',x,',',y,')');
end;

{powyzszy naglowek procedury mozna napisac inaczej:
 procedure wypisz_punkt(x:integer;y:integer);
}
//procedura ktora powieksza parametr x o wartosc q
procedure powieksz(var x:integer; q:integer);
begin
   x:=x+q;
end;

{UWAGA!!! Parametr x jest modyfikowany w procedurze, wiec w naglowku piszemy
          slowo kluczowe var}

begin
  wizytowka;
  writeln;
  {procedury lub funkcje mozna uzywac wielokrotnie dla roznych wartosci
   parametrow}
  wypisz_punkt(3,4);
  a:=6; b:=7;
  wypisz_punkt(a,b);
  powieksz(a,3);    {pierwszym parametrem musi byc zmienna bo bedzie
                     modyfikowana w procedurze}
  wypisz_punkt(a,b);
  readln;
end.

Funkcje Aplikacja09.dpr





Wstecz

program Aplikacja09;
{tematyka:
  - funkcje}

{$APPTYPE CONSOLE}

{funkcja tym sie rozni od procedury, ze dodatkowo zwraca jeszcze wartosc}
function potega(a:double; b:integer):double;
var
  i:integer;
  pot:double;
begin
   pot:=1;
   for i:=1 to b do
      pot:=pot*a;

   potega:=pot  //co ma zwrocic funkcja
end;

{inny sposob rozwiazania (zeby wykladnik byl rzeczywisty)}
function potega2(a,b:double):double;
begin
  potega2:=exp(b*ln(a));
end;

{i jeszcze jeden sposob z wykorzystaniem rekurencji}
function potega3(a:double; b:integer):double;
begin
  if b=0 then
     potega3:=1
    else
       potega3:=a*potega3(a,b-1);   {rekurencja polega na wywolaniu funkcji w
                                     tej samej funkcji}
end;


var
  x:double;      //podstawa potegi
  y:integer;     //wykladnik calkowity potegi
  y2:double;     //wykladnik rzeczywisty potegi
  wybor:integer;

begin
   write('Podaj x :');
   readln(x);

   write('Podaj y :');
   readln(y);

   write('Podaj y2:');
   readln(y2);

   //potega(2,3);   //blad!!! cos trzeba zrobic ze zwracana wartoscia funkcji
   writeln('Potega  ',x:6:3,'^',y,' wynosi: ',potega(x,y):6:3);

   //z zastosowaniem funkcji potega2
   writeln('Potega2 ',x:6:3,'^',y2:6:3,' wynosi: ',potega2(x,y2):6:3);

   //potega(2,3);   //blad!!! cos trzeba zrobic ze zwracana wartoscia funkcji
   writeln('Potega3 ',x:6:3,'^',y,' wynosi: ',potega3(x,y):6:3);

   readln;
end.

Funkcje i procedury - ciąg dalszy

• Przykłady (Aplikacja10.dpr)

• Przykłady c.d. (Aplikacja11.dpr)

• Przykłady c.d. (Aplikacja12.dpr)

Aplikacja10.dpr





Wstecz

program Aplikacja10;
{tematyka:
  - funkcje c.d.}

{$APPTYPE CONSOLE}

//napisac funkcje obliczajaca silnie z danej liczby (n!)

function silnia(n:integer):LongInt;
var
   i:integer;
   sil:integer;
begin
   sil:=1;
   for i:=2 to n do
      sil:=sil*i;

   silnia:=sil;
end;

//obliczanie silni z wykorzystaniem rekurencji
function silnia2(n:integer):LongInt;
begin
   if n<=1 then
     silnia2:=1
    else
       silnia2:=n*silnia2(n-1);
end;

var
  x:integer;

begin
  write('Podaj x: ');
  readln(x);

  writeln('Silnia  x!= ',silnia(x));
  writeln('Silnia2 x!= ',silnia2(x));
  readln;
end.

Aplikacja11.dpr


program Aplikacja11;
{tematyka:
  - funkcje c.d.2}
{$APPTYPE CONSOLE}
{funkcja obliczajaca n-ty wyraz ciagu fibonacciego
  a[1]:=0
  a[2]:=1
  a[n]:=a[n-1]+a[n-2]}
//- z wykorzystaniem rekurencji
function fib(n:integer):integer;
begin
   if n=1 then
      fib:=0
     else
        if n=2 then
           fib:=1
          else
             fib:=fib(n-1)+fib(n-2);
end;
//- z wykorzystaniem odpowiednich petli
function fib2(n:integer):integer;
var
  tmp,tmp2,i,f:integer;
begin
  if n=1 then
     f:=0
    else
       if n=2 then
          f:=1
         else
           begin
            tmp:=0;
            f:=1;
            for i:=3 to n do
               begin
                 tmp2:=f;
                 f:=f+tmp;
                 tmp:=tmp2;
               end;
           end;
   fib2:=f;
end;

var
   nn:integer;
  
begin
   writeln('Obliczanie n-tego wyrazu ciagu Fibonacciego:');
   write('Podaj n:');
   readln(nn);

   writeln('Wyraz ',nn,'-ty ciagu Fibonacciego wynosi (fib) :',fib(nn));
   writeln('Wyraz ',nn,'-ty ciagu Fibonacciego wynosi (fib2):',fib2(nn));

   readln;
end.

Aplikacja12.dpr





Wstecz

program Aplikacja12;
{tematyka:
   - funkcje c.d.3}

{$APPTYPE CONSOLE}

{napisac funkcje obliczajaca wartosc n-tego wielomianu czebyszewa
  T[0](x):=sqrt(2)/2,
  T[1](x):=x,
  T[n](x)=2*x*T[n-1]-T[n-2],

  wykorzystujac rekurenyjne wykonywanie funkcji.}

function czebyszew(n:integer; x:double):double;
begin
   if n=0 then
      czebyszew:=sqrt(2)/2   //lub 1
     else
        if n=1 then
           czebyszew:=x
          else
              czebyszew:=2*x*czebyszew(n-1,x)-czebyszew(n-2,x);

end;

var
  nn:integer;
  xx:double;
begin
   writeln('Obliczanie wartosci n-tego wielomianu Czebyszewa:');
   write('Podaj n:');
   readln(nn);
   write('Podaj x:');
   readln(xx);

   writeln('Wartosc wielomianu Czebyszewa T[',nn,'](',xx:6:3,')=',
           czebyszew(nn,xx):6:3);
   readln;
end.

Typy tablicowe - wektory

• Szukanie elementu maksymalnego, sortowanie

Aplikacja13.dpr





Wstecz

program Aplikacja13;
{tematyka:
   - typy tablicowe: wektory
   - szukanie maksymalnego elementu
   - sortowanie babelkowe}

{$APPTYPE CONSOLE}

const
   n=5;   //deklaracja stalej
type
   {deklaracja typu wektorowego o indeksach od 1 do 5,
      o elementach typu calkowitego (double)}
   wek  = array[1..n] of double;

   {deklaracja typu wektorowego o indeksach od 5 do 8,
      o elementach typu rzeczywistego (integer)}
   wek2 = array[5..8] of integer;

var
   w1:wek;

{procedura sluzaca do wpisywania wartosci do elementów wektora}
procedure wpisz(var a:wek);  //wektor bedzie modyfikowany!!!
var
  i:integer;  //zmienna sterujaca dla petli for
begin
  writeln('Podaj elementy wektora:');
  for i:=1 to n do  //wartosci zgodne z numeracja indeksow
     begin
        write('  [',i,']=');
        readln(a[i]);
     end;
end;

{procedura sluzaca do wypisywania wartosci wektora}
procedure wypisz(a:wek);
var
  i:integer;
begin
   writeln('Elementy wektora:');
   for i:=1 to n do
      writeln('  [',i,']=',a[i]:6:3);
end;

{szukanie maksymalnego elementu wektora}
function max(a:wek):double;  //typ zwracany tego samego typu co el. wektora
var
   tmp:double;
   i:integer;
begin
   tmp:=a[1];  //pewna zmienna pomocnicza
   for i:=2 to n do
      if a[i]>tmp then
         tmp:=a[i];
         //w innym wypadku program ma nic nie robic
   max:=tmp;  //wartosc zwracana funkcji
end;
{P.S. analogicznie jest zbudowana funkcja na obliczanie minimum}

{procedura na sortowanie elementow wektora
  z wykorzystaniem algorytmu sortowania babelkowego}
procedure sort(var a:wek);
var
   i,o:integer;
   p:double;
begin
   for o:=1 to n do
      for i:=n-1 downto o do
         if a[i+1]<a[i] then
            begin
                p:=a[i];       //zamiana elementow
                a[i]:=a[i+1];  //z wykorzystaniem zmiennej
                a[i+1]:=p;     //pomocniczej p
            end;
end;

begin
   wpisz(w1);
   writeln;
   wypisz(w1);

   writeln;
   writeln('Maksymalny element wynosi: ',max(w1):6:3);

   sort(w1);
   writeln;
   writeln('A po posortowaniu:');
   wypisz(w1);
  
   readln;
end.

Typy tablicowe - tablice dwu- i wielowymiarowe

Aplikacja14.dpr





Wstecz

program Aplikacja14;
{tematyka:
  - tablice dwuwymiarowe
  - generowanie macierzy zerowej
  - generowanie macierzy jednostkowej}

{$APPTYPE CONSOLE}
const
   n=3;
   m=n;
type
   mac=array[1..n,1..m] of double; //macierz kwadratowa n x n

var
   m1:mac;

{wpisywanie wartosci do macierzy}
procedure wpisz(var a:mac);
var
   i,j:integer;
begin
   writeln('Podaj wartosci macierzy:');
   for i:=1 to n do
      for j:=1 to m do
         begin
            write('  [',i,',',j,']=');
            readln(a[i,j]);
         end;
end;

{zerowanie macierzy}
procedure zeruj(var a:mac);
var
   i,j:integer;
begin
   for i:=1 to n do
      for j:=1 to m do
          a[i,j]:=0;
end;

{wypisywanie wartosci macierzy}
procedure wypisz(a:mac);
var
   i,j:integer;
begin
   writeln('Elementy macierzy wynosza:');
   for i:=1 to n do
     begin
        for j:=1 to m do
            write(a[i,j]:8:3,' ');
        writeln;
     end;
end;

procedure jednostkowa(var a:mac);
var
   i:integer;
begin
   zeruj(a);  //zastosowanie innej , wczesniejszej procedury
   for i:=1 to n do
          a[i,i]:=1;  //elementy po glownej przekatnej maja byc rowne 1
end;
{UWAGA!! Macierza jednostkowa moze byc jedynie macierz kwadratowa.
   Sugestia: Mozna by napisac jakies zabezpieczenie (np. czy n=m)...}

{Cwiczenie: Sprobuj znalezc element maksymalny (minimalny) w macierzy
            (patrz 'Aplikacja13.dpr').}

begin
  wpisz(m1);
  writeln;
  wypisz(m1);

  readln;
  writeln;
  writeln('Po wyzerowaniu:');
  zeruj(m1);
  wypisz(m1);

  readln;
  writeln;
  writeln('Macierz jednostkowa:');
  jednostkowa(m1);
  wypisz(m1);
  readln;
end.

Typ łańcuchowy string

• Podstawowe operacje (Aplikacja15.dpr)

• Podstawowe operacje c.d. (Aplikacja16.dpr)

• Operacje konwersji do typow liczbowych (Aplikacja17.dpr)

Aplikacja15.dpr





Wstecz

program Aplikacja15;
{tematyka:
  - dzialania na lancuchach tekstowych}

{$APPTYPE CONSOLE}

var
  s,s2:string;
  s3:string[10];  //lancuch 10 znakow
  i:integer;

begin
  write('Podaj jakis tekst: ');
  readln(s);
  writeln('Podales: ',s);

  //tekst rozstrzelony
  write('Tekst rozstrzelony: ');
  for i:=1 to Length(s) do   //dlugosc lancucha
     write(s[i],' '); //znak po znaku

  writeln;
  {kopiowanie tekstu z lancucha tekstowego s
   od pozycji z numerem 1 ; dwa znaki}
  s2:=copy(s,1,2);
  writeln('Dwie pierwsze litery teksu wynosza: ',s2);

  {pozycja lancucha 'a' w lancuchu s}
  i:=Pos('a',s);
  if i=0 then
     writeln('Tekst nie posiada literki "a".')
   else
      writeln('Literka "a" znajduje sie na pozycji: ',i);

  readln;
end.

Aplikacja16.dpr





Wstecz

program Aplikacja16;
{tematyka:
  - dzialania na lancuchach tekstowych}

{$APPTYPE CONSOLE}

var
  s:string;

begin
  writeln;
  {laczenie paru lancuchow}
  s:='Ala '+'ma '+'kota.';
  {ten sam efekt mozna uzyskac inaczej...}
  s:=concat('Ala ','ma ','kota.');
  writeln(s); //'Ala ma kota'

  s:='abcdefghij';
  {usuniecie dwoch znakow, poczawszy od trzeciego znaku w lancuchu}
  delete(s,3,2);
  writeln(s); //'abefghij'  (bez 'cd')

  {wstawianie lancucha 'cd' do zmiennej s w pozycji 3}
  insert('cd',s,3);
  writeln(s); //'abcdefghij'

  readln;
end.

Aplikacja17.dpr





Wstecz

program Aplikacja17;
{tematyka:
  - lancuchy tekstowe - konwersja do innych typow}

{$APPTYPE CONSOLE}

uses
   SysUtils;    //dolaczenie biblioteki

var
   s:string;
   i,kod:integer;
   d:double;

begin
  s:='2';
  writeln('Zawartosc lancucha tekstowego: ',s);
  {konwersja lancucha tekstowego s na liczbe calkowita i
   kod=0  - nie ma bledu konwersji
   kod<>0 - wystapil blad}
  val(s,i,kod);
  if kod<>0 then
     writeln('Wystapil blad konwersji.')
    else
       writeln('Konwersja poprawna. i=',i);


  {...i analogicznie dla liczby rzeczywistej}
  writeln;
  s:='2.1';
  writeln('Zawartosc lancucha tekstowego: ',s);
  val(s,d,kod);
  if kod<>0 then
     writeln('Wystapil blad konwersji.')
    else
       writeln('Konwersja poprawna. d=',d:8:3); //2.100


  {konwersja z wartosci liczbowej d do lancucha tekstowego s
   8 - liczba miejsc zarezerwowanych na cala liczbe
   3 - liczba cyfr po przecinku}
  writeln;
  d:=3.5454545;
  writeln('Zawartosc liczby rzeczywistej: ',d);
  str(d:8:3,s);
  writeln('W lancuchu tekstowym: ',s);


  {i jeszcze kilka polecen zapozyczonych z Borland Delphi
   (bez wyswietlania na ekranie)
   UWAGA!! Wymagane jest dolaczenie biblioteki SysUtils}

  s:='2';
  i:=StrToInt(s); //i=2   string-->integer

  s:='2,43434';
  {UWAGA!! Znak czesci dziesietnej jest zgodny z ustawieniami miedzynarodowymi
           systemu operacyjnego}
  d:=StrToFloat(s); //d=2.43434  string-->typ rzeczyw. (np.double)

  i:=3;
  s:=IntToStr(i); //s='3'  integer-->string

  d:=11.34344;
  s:=FloatToStr(d); //s='11,34344';  double-->string
  {lub tez z dodatkowym formatowaniem liczby:
     8 - liczba miejsc zarezerwowanych na cala liczbe
     3 - liczba cyfr po przecinku}
   //s:=FloatToStrF(d,ffFixed,8,3);

  readln;
end.

Typ rekordowy (Aplikacja18.dpr)

Aplikacja18.dpr



program Aplikacja18;
{tematyka:
  - rekordy - wprowadzenie}

{$APPTYPE CONSOLE}

type
  data=record
       dzien,miesiac:byte;  //skladowe rekordu zwane sa 'polami'
       rok:integer;
  end;

  osoba=record
     imie,nazwisko:string;
     dataur:data;   //rekord w rekordzie
  end;

var
   o:osoba;

{procedura wpisujaca wartosci}
procedure wpisz(var os:osoba);
begin
   writeln('Podaj dane osobowe:');
   write('Imie:     ');  readln(os.imie);
   write('Nazwisko: ');  readln(os.nazwisko);
   writeln('Podaj date urodzenia:');
   write('  Dzien:   ');  readln(os.dataur.dzien);
   write('  Miesiac: ');  readln(os.dataur.miesiac);
   write('  Rok:     ');  readln(os.dataur.rok);
end;

{procedura wypisujaca pojedynczy rekord}
procedure wypisz(os:osoba);
begin
  {mozna tez skorzystac z operatora zakresu 'with'}
  with os do
     begin
        writeln('Imie i Nazwisko: ',imie,' ',nazwisko);
        with dataur do
           writeln('Data urodzenia:  ',dzien,'.',miesiac,'.',rok);
     end;
end;

begin
   wpisz(o);

   writeln;
   wypisz(o);

   readln;
end.

Typ zbiorowy

• Podstawowe operacje (Aplikacja19.dpr)

• Podstawowe operacje c.d. (Aplikacja20.dpr)

Aplikacja19.dpr





Wstecz

program Aplikacja19;
{tematyka:
  - typy zbiorowe}

{$APPTYPE CONSOLE}

type
   //deklaracja typu zbiorowego, czyli co moze sie w danym zbiorze znalezc
   tznaki=set of char;  //zbior znakow
   tcyfry=set of 0..9;  //zbior cyfr

var
   //deklaracja wlasciwych zbiorow
   samogloski,spolgloski,pare_literek:tznaki;
   cyfry:tcyfry;

begin
   //przyklad zastosowania zbioru cyfr
   cyfry:=[3,2,6];

  
   //przyklad zastosowania zbioru znakow
   pare_literek:=['f','g'];  //przypisanie pierwszych literek do zbioru
   pare_literek:=pare_literek+['h']; //dodanie literki

   samogloski:=['a','e','i','o','u'];
   spolgloski:=['b','c','d','f','g','h','j','k','l','m','n','p',
               'q','r','s','t','w','x','z'];

   if pare_literek<=samogloski then  //czy jeden zbior zawiera sie w drugim
     writeln('W podanym zbiorze znajduja sie same samogloski.')
    else
       if pare_literek<=spolgloski then
          writeln('W podanym zbiorze znajduja sie same spolgloski.')
         else
            writeln('W podanym zbiorze znajduja sie samogloski i spolgloski.');

   readln;
end.

Aplikacja20.dpr





Wstecz

program Aplikacja20;
{tematyka:
   - typ zbiorowy c.d.}

{$APPTYPE CONSOLE}

type
   tdzien=(pn,wt,sr,czw,pt,so,nd); //typ wyliczeniowy
   tdni=set of tdzien; //zbior dni tygodnia

var
   dni:tdni;

{wprowadzanie elementow zbioru}
procedure wpisz(var d:tdni);
var
  x:integer;
  dzien:tdzien;
  dec:char;
begin
   repeat
      write('Podaj numer dnia (1-po,2-wt,3-sr,4-czw,5-pt,6-so,7-nd):');
      readln(x);
      case x of
         1:dzien:=pn;
         2:dzien:=wt;
         3:dzien:=sr;
         4:dzien:=czw;
         5:dzien:=pt;
         6:dzien:=so;
         7:dzien:=nd;
         else
            writeln('Podales zly dzien tygodnia!');
      end;
      d:=d+[dzien];  //dodawanie elementu do zbioru
      write('Czy jeszcze dodajesz element do zbioru? (t/n): ');
      readln(dec);
   until not (dec in ['t','T']); //jezeli znak nie zawiera sie w zbiorze...
end;


{funkcja sprawdzajaca, czy w zbiorze znajduje sie so lub nd}
function czy_weekend(d:tdni):boolean;
begin
   czy_weekend:=(so in d) or (nd in d);
end;


procedure usun_dni_weekendowe(var d:tdni);
begin
   d:=d-[so,nd];  //roznica zbiorow
end;


begin
   wpisz(dni);
   if czy_weekend(dni) then
      writeln('Podane dni zawieraja dni weekend`owe.')
     else
        writeln('Podane dni nie zawieraja dni weekend`owych.');

   writeln('Usuwam wszystkie dni weekendowe...');
   usun_dni_weekendowe(dni);

   //ponowne sprawdzenie...
   if czy_weekend(dni) then
      writeln('Podane dni zawieraja dni weekend`owe.')
     else
        writeln('Podane dni nie zawieraja dni weekend`owych.');

   readln;
end.

Pliki w pascalu

• Pliki tekstowe (Aplikacja21.dpr)

• Pliki tekstowe c.d. (Aplikacja22.dpr)

• Pliki binarne (Aplikacja23.dpr)

Aplikacja21.dpr





Wstecz

program Aplikacja21;
{tematyka:
  - pliki tekstowe
  - zapis do pliku
  - odczyt z pliku}

{$APPTYPE CONSOLE}

var
   plik:text; //zmienna plikowa (dla plikow tekstowych)
   s:string;

begin
   {skojarzenie zmiennej plikowej z fizycznym plikiem na dysku}
   assign(plik,'dane.txt');
   {UWAGA!! Nie podanie sciezki jest rownoznaczne z katalogiem,
            w ktorym znajduje sie plik exe.}

   rewrite(plik);  //otwarcie pliku do zapisu
   {UWAGA!! Jezeli plik o podanej nazwie juz istnial, to zostanie wyczyszczony}

   {wpisanie lancucha tekstowego i liczby do pliku bez znaku konca linii}
   write(plik,'abc ',8);

   {wpisanie lancucha tekstowego do pliku ze znakiem konca linii}
   writeln(plik,' xyz');

   close(plik); //zamkniecie pliku
   writeln('Zapisano do pliku...');
   readln;

//------------------------------------------------------------------------------

   {ponowne otwarcie pliku do zapisu - tym razem po to aby cos do niego dopisac}

   append(plik); //otwarcie pliku do zapisu i przejscie do ostatniej pozycji
   {UWAGA!! Polecenie Assign nie jest juz potrzebne, poniewaz zmienna plikowa
            byla juz wczesniej skojarzona z plikiem.}

   writeln(plik,'Ala ma kota.');

   close(plik);
   writeln('Dopisano do pliku...');
   readln;

//------------------------------------------------------------------------------

   writeln('Zawartosc pliku wynosi:');
   writeln;
   reset(plik); //...i ponowne otwarcie pliku - tym razem do odczytu


   while not eof(plik) do  //dopoki nie osiagniety zostanie koniec pliku
      begin
         readln(plik,s);  //odczytanie jednej linii z pliku...
         writeln(s);     //...i wypisanie jej na ekranie
      end;

   close(plik);
   readln;
end.

Aplikacja22.dpr





Wstecz

program Aplikacja22;
{tematyka:
  - pliki tekstowe c.d.
  - prosta baza danych osobowych}

{$APPTYPE CONSOLE}

uses
   SysUtils; //dolaczenie biblioteki, ktora zawiera 'FileExists'

var
   plik:text;

procedure dopisz(npliku:string);
var
   imie,nazwisko:string;
   wiek,wzrost:integer;
begin
  assign(plik,npliku);
  if fileexists(npliku) then  //czy plik istnieje na dysku
     append(plik)   //tryb dodawania danych na koncu pliku
    else
       rewrite(plik);  //tworzenie nowego pliku

  write('Podaj imie:     ');  readln(imie);
  write('Podaj nazwisko: ');  readln(nazwisko);
  write('Podaj wiek:     ');  readln(wiek);
  write('Podaj wzrost:   ');  readln(wzrost);

  writeln(plik,imie);  //zmienna string
  writeln(plik,nazwisko); //zmienna string
  writeln(plik,wiek);  //zmienna integer
  writeln(plik,wzrost);  //zmienna integer
  close(plik);
end;

procedure wypisz_wszystkie(npliku:string);
var
   imie,nazwisko:string;
   wiek,wzrost:integer;
begin
  assign(plik,npliku);
  if fileexists(npliku) then
     begin
      reset(plik);  //otwarcie do odczytu
      writeln('Imie nazwisko wiek wzrost');
      while not eof(plik) do
         begin
            readln(plik,imie);  //string
            readln(plik,nazwisko);  //string
            readln(plik,wiek);  //integer
            readln(plik,wzrost);   //integer
            writeln(imie,' ',nazwisko,' ',wiek,' ',wzrost); //ekran
         end;

      close(plik);
     end
   else
      writeln('Plik nie istnieje...');

   readln;
end;

begin
  dopisz('dane.txt');
  writeln;
  wypisz_wszystkie('dane.txt');
end.

Aplikacja23.dpr





Wstecz

program Aplikacja23;
{tematyka:
  - pliki binarne
  - zapis do pliku
  - odczyt z pliku}

{$APPTYPE CONSOLE}

var
   plik:file of integer;  //plik binarny z wartosciami typu integer;
   x,i:integer;

begin
   assign(plik,'dane.dat');   //skojarzenie zmiennej z plikiem na dysku
   {UWAGA!! Nie podanie sciezki jest rownoznaczne z katalogiem,
            w ktorym znajduje sie plik exe.}

   rewrite(plik);  //otwarcie pliku do zapisu
   {UWAGA!! Jezeli plik o podanej nazwie juz istnial, to zostanie wyczyszczony.}

   x:=2;   write(plik,x);
   x:=8;   write(plik,x);
   x:=5;   write(plik,x);

   close(plik); //zamkniecie pliku
   writeln('Zapisano do pliku...');

//------------------------------------------------------------------------------

   reset(plik); //otwarcie pliku do odczytu
   writeln('Odczyt z pliku:');

   while not eof(plik) do //dopoki nie osiagniety zostanie koniec pliku
   begin
      read(plik,x); //odczytanie jednej wartosci...
      write(x,' '); //...i zapis na ekranie
   end;

   close(plik);

   readln;

//------------------------------------------------------------------------------

   reset(plik);

   seek(plik,1);  //przemieszczenie sie do drugiej pozycji w pliku
   {UWAGA!! Pozycje w pliku numerowane sa od zera.}

   x:=55;   write(plik,x);  //zastapienie starej wartosci nowa (8-->55)

   close(plik);
   writeln('Zapisano zmiany do pliku...');

//------------------------------------------------------------------------------
   reset(plik);
   writeln('Powtorny odczyt z pliku:');

   //inny sposob odczytu z pliku...
   for i:=0 to filesize(plik)-1 do
      begin
         seek(plik,i);
         read(plik,x);
         write(x,' ');
      end;

   close(plik);

   readln;
end.

1. Wskaźniki

• Podstawowe operacje (Aplikacja24.dpr)

• Zmienne dynamiczne (Aplikacja25.dpr)

Aplikacja24.dpr





Wstecz

program Aplikacja24;
{tematyka:
  - wskazniki}

{$APPTYPE CONSOLE}

{Wskazniki to zmienne zawierajace adres pamieci komputera.
 Wskazniki moga wiec zawierac adres pamieci, gdzie przechowywana jest inna
 zmienna.}

var
   wsk:^integer; //wskaznik do zmiennej typu integer
   a:integer;
   b:integer;
   d:double;

begin
   a:=2;
   wsk:=@a; //przypisanie zmiennej wskaznikowej adresu zmiennej 'a'
   writeln('Wartosc zmiennej a:',a);
   writeln('Wartosc zmiennej, na ktora wskazuje wskaznik wsk:',wsk^);
   {UWAGA!! Oczywiscie w tym przypadku oba powyzsze polecenia dadza
            ten sam skutek.}

   wsk^:=5; //zmiana wartosci zmiennej, na ktora wskazuje wskaznik wsk
   writeln('Wartosc zmiennej a:',a);

   wsk:=@b; //teraz 'wsk' wskazuje na 'b'
   wsk^:=6; //lub b:=6;
   writeln('Wartosc zmennej b:',b);

   //wsk=@d; //dzialanie nieprawidlowe poniewaz wskaznik moze tylko zawierac
             //adres zmiennej typu integer

   wsk:=nil; //wskaznik ma nie wskazywac na zadna zmienna

   readln;
end.

Aplikacja25.dpr





Wstecz

program Aplikacja25;
{tematyka:
  - wskazniki
  - zmienne dynamiczne}

{$APPTYPE CONSOLE}

var
   wsk:^integer;

{Wskazniki moga rowniez sluzyc do inicjalizacji tzw. zmiennych dynamicznych.
 Zmienne dynamiczne to zmienne, ktore moga byc zainicjalizowane w dowolnym
 fragmencie programu i dealokowane w dowolnej chwili.}

begin
   new(wsk); //inicjalizacja zmiennej dynamicznej
   {UWAGA!! W rzeczywistosci polecenie 'new' wykonuje dwie czynnosci:
            inicjalizuje zmienna dynamiczna i rownoczesnie przypisuje adres
            tej zmiennej do wskaznika 'wsk'}

   wsk^:=5; //przypisanie wartosci do zmiennej
   writeln(wsk^);

   dispose(wsk); //usuwanie zmiennej dynamicznej
   //writeln(wsk^); //blad, poniewaz wsk nie wskazuje juz na zadna zmienna

   readln;
end.

1

---