Object Pascal/Podstawy, zmienne i stałe

Z Wikibooks, biblioteki wolnych podręczników.
Przejdź do nawigacji Przejdź do wyszukiwania

Pierwszy program[edytuj]

Najkrótszy możliwy program w Object Pascalu wygląda tak:

begin
end.

Oczywiście nic nie robi (prawdopodobnie nawet nic się nie pokaże na monitorze).

Natomiast poniższy program wyświetla tradycyjny dla pierwszego programu napis "Witaj świecie!":

program Witaj;               {nazwa programu}
{$APPTYPE CONSOLE}           {obowiązkowa deklaracja dla aplikacji konsolowej tylko i wyłącznie w Delphi}
begin                        {obowiązkowy początek właściwego programu}
  Writeln('Witaj świecie!'); {instrukcja druku, uwaga: jeżeli zaczynasz programować dla ułatwienia pisz: WriteLn}
  Readln;                    {w tym przypadku instrukcja oznacza czekanie na enter, a po jego naciśnięciu aplikacja się wyłączy}
end.                         {Koniec programu}

Po słowie kluczowym program należy wpisać nazwę programu. Powinna być zgodna z nazwą pliku, czyli ten program powinien być zapisany w pliku Witaj.pas.(Nie jest to jednak obowiązkowe jeżeli program nie będzie zawierał elementów modułowych albo objektowych) Jak po większości instrukcji, powinien się po niej znaleźć średnik.

Po instrukcji begin znajduje się właściwy kod programu. W tym wypadku składa się z dwóch instrukcji: wyświetlającej wskazany napis i drugiej, czekającej na wczytanie wiersza tekstu.

Łańcuch tekstowy umieszczamy w pojedynczym cudzysłowie, po instrukcji write.(albo writeln).
Różnica pomiędzy tymi dwoma instrukcjami znajduje się w rozdziale Object Pascal/Instrukcje wejścia i wyjścia.

Jeżeli chcemy uruchomić program w jakimkolwiek środowisku graficznym (Windows, Norton Comander, Free Pascal) warto umieścić instrukcję Readln na końcu programu. Pozwala ona wczytać ciąg znaków zakończonego enterem, jednak w tym przypadku pozwala zobaczyć działanie programu, zanim wciśniemy enter i okno się zamknie. (Bez tej instrukcji program po prostu mignąłby nam przed oczami nic nie zdążylibyśmy zobaczyć (Możemy wywołać tu również instrukcje delay albo readKey [Są zawarte w module Crt, a o modułach później])

Po większości instrukcji należy wpisać średnik (o wyjątkach później).

Blok kodu (rozpoczętego przez begin) kończy instrukcja end (z średnikiem), a blok rozpoczynający program (również begin) kończy end. (z kropką), który zakańcza kod danego programu.

Tekst w nawiasach klamrowych to komentarz. Nie ma wpływu na wykonanie programu. Nie mają też na nie wpływu wcięcia i znaki nowej linii.

Dodatkowe informacje[edytuj]

Przed instrukcją end średnik nie jest potrzebny, ale w niczym nie przeszkadza. Tworzy po prostu tak zwaną instrukcję pustą. Ale lepiej zawsze go wstawiać - na wszelki wypadek (Przekonacie się, że kiedyś zmniejszy wam to ilość błędów kompilatora o co najmniej jeden).

Czytelność kodu - nazwy instrukcji lepiej pisać z dużych liter, to samo dotyczy stałych np. zamiast writeln pisać Writeln, albo zamiast showmessage pisać ShowMessage. Instrukcje, które zostaną wypełnione, gdy warunek jest spełniony (o instrukcjach warunkowych troszkę później), lepiej pisać w następnej linijce. Najlepiej jak nawet każda linijka kodu ma swój komentarz, który określa co wykonuje dany fragment kodu.

Komentarze - jest to tekst ignorowany przez kompilator podczas kompilacji. Po co mi one? - pomyślisz. Jednak, jeśli kod swojego programu udostępnisz innym, to w ten sposób łatwiej zrozumieją, co robi dany fragment.(Poza tym czasami komentarze mogą pomóc w połapaniu się w zaawansowanym programie i ponad to kiedy chcesz sprawdzić jak program będzie działać bez kilku "zbędnych" linijek tekstu możesz umieścić je w klamrze żeby później nie musieć ich wpisywać od nowa) Można je wpisywać w ten sposób:

{nazwa}  program Witaj;
begin  // początek oznaczony komentarzem jednolinijkowym
  Writeln('Witaj świecie!'); {To jest tak zwany
  komentarz wielolinijkowy.}

  Readln; 
 
(*To inny sposób zapisu komentarza,
ale {} wystarczy do wszystkiego*)
end.  {Koniec
      programu}

Zmienne[edytuj]

program zmienne;

var {będą definiowane zmienne}
  napis: string; {łańcuchowa}
  z: char; {znakowa}
  a, b: integer; {dwie całkowite}
  duza,
  mala: real; {i dwie rzeczywiste}
  czy: boolean; {oraz logiczna}

begin
  napis := 'Witaj świecie!'; {Przypisujemy zmiennym wartości}
  z := 'a';
  a := 278;
  b := -556;
  duza := 5678.0;
  mala := -0.0012;
  czy := true;
  
  writeln('Wartość zmiennej "napis" to:'); {Oczywiście drukuje (to znaczy wyświetla) napis "Wartość zmiennej "napis" to:"}
  writeln(napis); {Drukuje "Witaj świecie!"}
  writeln(z); {"a"}
  writeln(a); {"278"}
  writeln(b); {"-556"}
  writeln(duza); {" 5.678000000000000E+003"}
  writeln(MALA); {"-1.200000000000000E-003" - wielkość liter nie ma znaczenia}
  writeln(czy); {"TRUE"}

  readln; 
end.

Zmienne są to pewne fragmenty pamięci, którym możemy zmieniać zawartość dowolną liczbę razy. Deklaracja zmiennych następuje po słowie kluczowym var. Potem następuje nazwa zmiennej, a po dwukropku jej typ i na koniec średnik. Zmienne jednego typu można oddzielać przecinkami. (Dla tępych :] : Wyobraźcie sobie że zmienna to takie "pudełeczko" do którego wkładamy, wyjmujemy i edytujemy jakąś liczbę bądź znak(lub "coś"). Kompilator musi wiedzieć jakie "pojemnik" przygotować (nie trzymamy przecież rybek w tekturowym pudełku albo nie wkładamy 2metrowego misia do pudełeczka po cukierkach) i do tego potrzebne są typy zmiennych.

Zmiennym można przypisywać wartości. Służy do tego operator przypisania := ("staje się równe"). Zmienne można też drukować, przy czym nie zawsze pokazuje się dokładnie to, co zostało wpisanie w programie.

Najważniejsze typy zmiennych to:

  • string - łańcuch (łańcuch znaków czyli tekst)
  • char - pojedynczy znak
  • integer - liczba całkowita
  • real - liczba rzeczywista
  • boolean - zmienna logiczna (wartości true - prawda i false - fałsz.

Inne typy zostały omówione w Object Pascal/Typy zmiennych.

Operatory[edytuj]

program operator;

var
  napis: string;
  z1, z2: char;
  a, b: integer;
  c: real;
  czy: boolean;

begin
  a := 1;
  b := 2 + 2; {dodawanie liczb - b=4}
  a := a + 1; {dodawanie liczby do zmiennej i przypisanie jej samej - a=2}
  z1 := 'a';
  z2 := 'b';
  napis := z1 + z2; {dodawanie łańcuchów - napis='ab'}
  
  writeln(napis); {"ab"}
  writeln(a); {"2"}
  writeln(b); {"4"}

  {a := 4 / 2;} {to byłby błąd - wyniku dzielenia nie można przypisać liczbie całkowitej}
  a := 4 div 2;
  c := 4 / 2;

  czy := (a-b) = (b-a); {bardziej złożone - wykorzystujemy nawiasy}
  writeln('Odejmowanie jest przemienne?');
  writeln(czy); {wyświetla odpowiedź, niestety po angielsku: "false"}

  readln;     
end.

Podstawowy operator to :=. Oznacza przypisanie zmiennych. Inne ważne to

  • + - * / - operatory arytmetyczne
  • div mod - dzielenie całkowite (wynik zaokrąglony w dół) i reszta z dzielenia
  • = > < >= <= <> - operatory porównania, zwracają wartości logiczne
  • and or not - operatory logiczne I LUB NIE

Stałe[edytuj]

program stale;

const {będą definiowane stałe}
  N=3;
  ZZ='Zbzikowany Zawiadowca';
    
var
  napis: string;
  a, b: integer;
  c: real;

begin
  writeln(n); {stałe można drukować}
  writeln(zz);
  a := 1;
  b := n; {można je stosować przy operatorze przypisania}
  c := a * n; {i przy innych operatorach}
  napis := zz + ' szaleje';
  {zz := 'Zielona Zebra'} {to byłby błąd - nie można przypisywać stałym nowych wartości}
  
  writeln(a); {"1"}
  writeln(b); {"3"}
  writeln(c); {"3"}
  writeln(napis); {"Zbzikowany Zawiadowca szaleje"}
  readln;    
end.

Deklaracja stałych następuje po słowie kluczowym const. Potem następuje nazwa stałej, a po znaku równości jej wartość i na koniec średnik. Wartości stałych nie można zmieniać (przypisujemy im wartość podczas deklaracji), ale można je drukować, tak jak zmienne. Zalecane jest nazywanie stałych WIELKIMI LITERAMI.