Category Archives: Pascal

Tutorijali i primeri za Pascal, Lazarus i sve sto je vezano za Pascal.

Pascal: Dodatne teme

U danasnjoj lekciji obradjujemo teme koje se nisu nasle na dnevnom redu. To su Setovi, grananje sa upotrebom Case Of, i rad sa greskom uz Try-Except konstrukciju. Obzirom da nisu esencijalne, dacemo samo osnovne primere za svaki pristup. Ako vam se bas dopadnu, uvek ih mozete bolje upoznati preko preporucenih sajtova.

1) Case Of

U ranijem textu o kontroli toka programa, obradili smo if/then komande, koje se generalno najvise koriste u razlicitim programskim jezicima. U Pascalu postoji i elegantna Case Of konstrukcija, pomocu koje mozemo proveriti vise mogucnosti odjednom. Pogledajmo primer sa pogadjanjem brojeva.

program CaseOf;

var
b:integer;

begin
b := 0;
while (b<>35) do begin
write('Unesite broj od 1 do 70: ');
readln(b);
case (b) of
1..34 : begin writeln;
writeln('Trazeni broj je veci'); writeln;
end;
36..70 : begin writeln;
writeln('Trazeni broj je manji'); writeln;
end;
35 : begin writeln;
writeln('Cestitamo, pogodili ste broj');
readln; end;
else begin writeln;
writeln('Broj mora biti izmedju 1 i 70'); writeln;
end; end;
end;
end.

U ovom primeru najpre smo definisali uslov za izvrsenje programa i zatrazili unos broja koji zatim proveravamo kroz nekoliko mogucnosti. U prvom slucaju broj je manji, u drugom veci, u trecem tacan dok else opcija daje odgovor u koliko korisnik nije sledio uputstva. Za Case-Of konstrukciju Else deo nije neophodan. Vise o mogucnostima Case Of pogledajte ovde i ovde.

2) Try-Except

Ovde se radi o dobroj praxi provere mogucnosti rada, da ne bi doslo do nekontrolisanog izlaska iz programa. Uvek je pametnije kontrolisati izlaz uz planirani output, nego prepustiti greske slucaju. U tom smislu za jednostavan a koristan primer, upotrebicemo nas prethodni program. Najpre pokrenite program CaseOf koji smo upravo probali, i umesto punog broja unesite decimalni broj ili neko slovo. Videcete da se program jednostavno zatvorio sam od sebe. Ono sto se zapravo desava je da ocekivani unos mora biti integer tipa, i u svakom drugom slucaju dolazi do greske koja nekontrolisano zatvara program. Sada cemo preraditi prethodni primer da hvata ovu gresku i daje odgovor.

program TryExcept;
uses
sysutils;
var
a:boolean;
b:integer;

begin
b := 0;
while (b<>35) do begin
write('Unesite broj od 1 do 70: ');
try //pokusaj citanja b
a := true; readln(b);
except //ako dodje do greske
writeln;
writeln('Neophodno je da unesete integer');
writeln; a := false; end;
case (b) of
1..34 : begin writeln;
writeln('Trazeni broj je veci'); writeln;
end;
36..70 : begin writeln;
writeln('Trazeni broj je manji'); writeln;
end;
35 : begin writeln;
writeln('Cestitamo, pogodili ste broj');
readln; end;
else begin
if a then begin writeln;
writeln('Broj mora biti izmedju 1 i 70'); writeln;
a := false; end; end; end;
end;

end.

Najpre smo ucitali unit sysutils, koji je neophodan za rad sa sistemskim greskama. Nakon toga smo organizovali tok programa kao u prethodnom slucaju, uz hvatanje greske prilikom unosa varijable b. Ako do nje dodje, umesto izlaska iz programa, pokrece se alternativni kod koji salje poruku, dok program nastavlja sa izvrsavanjem. Kontrolni boolean omogucava elegantniji nastavak programa jer preskace nepotrebnu finalnu poruku u slucaju sistemske greske. Vise o Try-Except pogledajte ovde i ovde.

Inace, Lazarusov forum je odlicno mesto za nalazenje resenja kada je Pascal u pitanju.

Advertisements

Pascal: Rekordi

Rekordi predstavljaju skup razlicitih tipova podataka, rasporedjenih po jedinicama. Na primer, dva stringa i dva broja, pa vise jedinica koje ih sadrze. U tom smislu oni su zapravo rudimentarne baze podataka, koje su vremenom izasle iz upotrebe sa razvojem modernih i nezavisnih baza. Ipak, u cilju ucenja programiranja, obradicemo i ovu kategoriju. Pogledajmo osnovni primer rekorda.

program Rekordi;
//definisemo rekord bla sa elementima
type bla = record
im,pre,op:string;
god:integer;
end;
var //definisemo varijable tipa bla
b1,b2:bla;

begin
//unos podataka
b1.im := 'John';
b1.pre := 'Smith';
b1.god := 1983;
b2.im := 'Elvis';
b2.pre := 'Prisli';
b2.god := 1935;
//ispis podataka
writeln(b1.im,' ',b1.pre,' je rodjen ',b1.god, ' godine.');
writeln(b2.im,' ',b2.pre,' je rodjen ',b2.god, ' godine.');
readln;
end.

U nasem programu smo najpre definisali bla kao rekord sa odredjenim elementima, a zatim deklarisali dve varijable tipa bla. Nakon toga smo uneli podatke u nas rekord a zatim ih ispisali na ekranu. Za sledeci primer cemo preraditi ovaj program tako da kombinuje rekorde i nizove.

program Rekordi2;
uses crt;
//definisemo rekord bla sa elementima
type bla = record
im,pre:string;
god:integer;
end;
var
//definisemo varijablu kao bla niz
b:array[1..3] of bla;
n:integer;

begin
//unos podataka
for n := 1 to 3 do begin
write('Unesite Ime broj ',n,': '); readln(b[n].im);
write('Unesite Prezime broj ',n,': '); readln(b[n].pre);
write('Unesite Godiste broj ',n,': '); readln(b[n].god);
clrscr;
end;
//ispis podataka
writeln('Podaci su sledeci:');
for n := 1 to 3 do begin
writeln(n,'. ','Ime: ',b[n].im,' - Prezime: ',b[n].pre,' - Godiste: ',b[n].god);
end;
readln;
end.

Ovde smo najpre definisali rekord za elementima, a onda smo deklarisali niz za pomenuti rekord. To nam omogucava da koristimo loopove za unos i ispis podataka, sto smo i iskoristili.

Vise o rekordima mozete videti ovde i ovde. Takodje, pogledajte primere odavde.

Pascal: Rad sa fajlovima

Kao i vecina modernih programskih jezika, Pascal ima brojne funkcije vezane za fajlove. Moguce ih je kreirati, pisati u njima, dodavati materijal, brisati, kopirati itd. Komande za fajlove nalaze se u unitu Sysutils, koji najpre standardno ucitavamo pomocu Uses. Pogledajmo nekoliko primera.

program Kreiranje;
uses sysutils;
var
a:textfile;
b:string;

begin
AssignFile(a, 'bla.txt'); //definisemo ime fajla
rewrite(a); //kreiramo ga
writeln(a,'Hello World!'); //upisujemo text
closefile(a); //zatvaramo fajl
writeln('Fajl je napravljen');
readln; //pauza za proveru
writeln('Text za dodavanje:');
readln(b);
append(a); //produzavamo fajl nasim textom
writeln(a,b);
closefile(a); //zatvaramo fajl drugi put
writeln('Text je dodat');
readln;
end.

U ovom programu najpre smo definisali fajl tako sto smo mu dali ime. Zatim smo ga kreirali, upisali u njega kratak text i zatvorili. Nakon toga smo ga opet otvorili, dodali novi text na postojeci i zatvorili. Inace, preporuka je da primere u ovoj lekciji isprobavate u Lazarusu sa: Project > New Project > Simple Program. U koliko ipak zelite Dev-Pascal, najpre iskompajlirajte program, pa ga pokrenite iz sopstvenog foldera. Ovo je neophodno zbog nedostataka u pomenutom okruzenju, koji su otklonjeni u Lazarusu.

Za sledeci program neophodno je da prethodno kreirani bla.txt bude u istom folderu sa izvrsnim exe fajlom. Ako pravite projekte u zasebnim folderima, jednostavno iskopirajte text fajl iz prethodnog primera u njega.

program Citanje;
uses sysutils;
var
a:textfile;
b:file of byte;
n:string;

begin
//proveravamo prisustvo fajla
if fileexists('bla.txt') then
begin
writeln('Nasli smo ga!'); //obavestenje ako je tu
//otvaramo fajl kao binarni
assign(b,'bla.txt');
reset(b);
//proveravamo duzinu
writeln('Duzina fajla u bajtovima: ', filesize(b));
close(b);
//otvaramo fajl kao textualni
assign(a,'bla.txt');
reset(a);
writeln('----------');
writeln;
writeln('Sadrzaj fajla je:');
//ispisujemo sadrzaj do kraja
while not eof(a) do //provera da li je kraj
begin
readln(a,n);
writeln(n);
end;
readln;
end else begin
//obavestavamo ako nije tu
writeln('2x0=0, Fajla nije ni bilo');
readln; end;
end.

U ovom primeru najpre proveravamo da li fajl postoji. Zatim ga otvaramo kao binarni, da bi mogli da iscitamo njegovu duzinu. Nakon toga ga ponovo otvaramo kao textualni, da bi iscitali sadrzaj. Ovaj pristup je neophodan jer nisu sve funkcije dostupne za svaki tip fajla. Na kraju ispisujemo gresku za slucaj da ga nismo nasli.

Ovim smo pokrili neke od osnovnih metoda za rad sa fajlovima. Vise informacija mozete naci ovde i ovde.

Pascal: Funkcije i procedure (nastavak)

Ovo je nastavak prethodnog texta koji odvajamo zbog preglednosti. Kao sto smo vec pomenuli, funkcije i procedure su dva tipa potprograma. Ovo vazi za pascal, python kao i vecinu modernih programskih jezika. Razlika je sto funkcije vracaju neku vrednost u glavni program, dok procedure jednostavno urade ono zbog cega su pozvane i tu im se zadatak zavrsava. One medjutim mogu primati argumente iz glavnog programa, na osnovu kojih ce izvrsiti svoj zadatak. Pogledajmo primer:

program Procedura;
uses crt;
var
n:integer;

procedure lines(c:byte; lin:integer);
var
m:integer;
begin
textcolor(c);
gotoXy(10,lin);
for m := 1 to 10 do
begin
Write(chr(196));
end; end;

begin
for n := 1 to 7 do
begin
lines (n,n);
end;
readln;
end.

U ovom primeru nasa procedura ispisuje linije u razlicitim bojama u sukcesivnim redovima. Argumente koje prima su boja i linija. Iz glavnog programa for petlja poziva proceduru i salje joj parametre za oba elementa koji se povecavaju za jedan. Rezultat je program koji ispisuje 7 linija u isto toliko boja.

Kao sto smo vec pomenuli, procedure mogu da rade i bez argumenata. Tada ih jednostavno pozivamo iz glavnom programa imenom. U tom slucaju funkcionisu recimo kao klasicni potprogrami iz Basica. Sada cemo prethodni primer preraditi tako da funkcionise na ovaj nacin.

program Procedura2;
uses crt;

procedure xyz;
var
n,m:integer;
begin
for n := 1 to 7 do
begin
textcolor(n);
gotoXy(10,n+5);
for m := 1 to 10 do
begin
Write(chr(196));
end; end; end;

begin
write('Nasih 7 linija >>');
xyz;
readln;
end.

Ovde smo najpre definisali proceduru xyz koja crta 7 linija u duginim bojama. Zatim smo jednostavno pozvali xyz iz glavnog programa. Naravno, ovaj pristup ima smisla u koliko se radnja ponavlja vise puta. Primere namerno pravimo tako da budu jednostavni, da bi se lakse ilustrovali principi i metod rada.

Vise o procedurama procitajte ovde i ovde.

Pascal: Funkcije i procedure

U Pascalu postoje dva tipa potprograma, funkcije i procedure. Razlike je sto funkcije vracaju neku vrednost u glavni program, dok procedure jednostavno izvrse ono zbog cega su pozvane. Inace glavni razlog za koriscenje potprograma je bolja organizacija. Ako neki proces ponavljamo nekoliko puta na vise mesta u programu, logicno je da ga napisemo jednom i kasnije pozivamo kada nam treba. Takodje, ovakve potprograme mozemo koristiti kasnije i u drugim programima. Pogledajmo nekoliko primera.

program Funkcije;
var
a,b,v: integer;

//funkcija koja vraca veci broj
function max(x,y:integer): integer;
//lokalna varijabla unutar funkcije
var
calc: integer;
begin
if (x > y) then calc := x else calc :=y;
max := calc;
end;

//glavni program
begin
write('Unesite prvi broj: ');
readln(a);
write('Unesite drugi broj: ');
readln(b);
writeln('--------------------');
//pozivamo funkciju
v := max(a,b);
writeln ('Veci broj je: ',v);
readln;
end.

U ovom primeru smo najpre deklarisali funkciju max koja od dva poslata broja vraca veci. Zatim smo je pozvali iz glavnog programa da bi odredili koji je broj veci od dva uneta, i na kraju ispisali rezultat na ekranu. Kao sto ste mogli da vidite, funkcije se definisu sintaxom:

function ime(argumenti:tip; argumenti2:tip2;..):izlazni tip

.. i na kraju vraca rezultat u formatu: ime := neki proracun. Ona moze sadrzati i lokalne varijable koje smo u nasem primeru ubacili samo radi demonstracije, inace nije bilo neophodno. Pogledajmo jos jedan primer.

program Funkcije2;
var
a,b:integer;
//direktno vracena funkcija
function god(a,b:integer):integer;
begin
god := a-b;
end;

//glavni program
begin
write('Unestite vase godiste: ');
readln(a);
write('Unestite aktuelnu godinu: ');
readln(b);
writeln('--------------------');
writeln('Ove godine punite ',god(b,a),' god.');
readln;
end.

Ovaj program je vrlo slican, i demonstrira vracanje rezultata u jednoj liniji bez dodatnih internih varijabli. Takodje i pozivanje funkcije direktno iz druge komande ili izraza, bez dodatnih spoljnih varijabli.

Vise o potprogramima u Pascalu mozete pogledati ovde.

Pascal: Stringovi

Stringove smo vec pominjali i koristili u prethodnim primerima. Oni predstavljaju niz karaktera i kao takvi su jedan od najbitnijih elemenata u svim modernim programskim jezicima opste namene. Ovde cemo obraditi neke od brojnih funkcija i operacija sa stringovima u Pascalu.

Pogledajmo sada jedan primer sa stringovima:

program Stringovi;
uses
crt;

var
ime,pre,c,n:string;

begin
write('Unesite ime: ');
readln(ime);
write('Unesite prezime: ');
readln(pre);
c := ' '; //dodajemo razmak
clrscr;
//nastavljanje
writeln('Puno ime je: ', concat(ime,c,pre));
//moze i sa +
c := ime+pre;
writeln('Zbir imena i prezimena je: ', c);
//brisanje dela stringa
n := c; //cuvamo originalni zbir
delete(c,2,3);
writeln('Zbir bez tri slova: ', c);
//razno
writeln('Broj karaktera u imenu: ', length(ime));
writeln('Zbir malim slovima: ', lowercase(n));
writeln('Zbir velikim slovima: ',upcase(n));
writeln('Pozicija prezimena u zbiru: ',pos(pre,n));
readln;
end.

U nasem programu najpre smo uneli ime i prezime. Zatim smo pomocu funkcije concat sastavili tri stringa u jedan, i demonstrirali kako se isti efekat moze postici sa prostim sabiranjem. Zatim smo obrisali deo stringa pomocu funkcije delete. Argumetni su delete(string,pocetak brisanja,duzina brisanja). U delu razno smo obradili jos nekoliko funkcija. To su length koja vraca duzinu stringu, zatim prebacivanje u mala i velika slova pomocu lowercase i upcase, kao i odredjivanje pozicije stringa u stringu pomocu funkcije pos.

U koliko pod Uses ucitate i sysutils, bice vam dostupne dodatne korisne funkcije, poput IntToStr i StrToInt. Pogledajmo jos jedan primer.

program Stringovi2;
uses
crt, sysutils;

var
ime,god,lin:string;
g,x:integer;

begin
write('Unesite ime: ');
readln(ime);
write('Unesite godiste: ');
readln(god);
clrscr;
//prebacivanje u integer i nazad
g := strtoint(god);
g := 2020 - g;
god := inttostr(g);
//sabiranje stringa
lin := '2020te punite ' + god + ' godina';
writeln(lin);
//vracamo vrednost u god
g := 2020 - g;
god := inttostr(g);
//prebacivanje u ASCII i nazad
x := ord(ime[1]);
writeln('ASCII prvog slova imena: ', x);
lin := chr(x);
writeln('Prvo slovo imena iz ASCII: ',lin);
insert(god,ime,3);
writeln('Godiste ubaceno u ime: ',ime);
delete(ime,3,4);
writeln('Obrisano godiste iz imena: ',ime);
readln;
end.

Ovde smo najpre uneli ime i godiste. Zatim smo prebacili godiste u integer da bi izvrsili racunsku operaciju, nakon cega smo vrednost opet vratili u string i ispisali na ekranu. Zatim smo prebacili slovo u ASCII vrednost i nazad, i na kraju pokazali kako se string ubacuje i izbacuje iz drugog stringa. Argumenti funkcije insert su (string koji ubacujemo, string u koji ubacujemo, mesto odakle pocinjemo). Argumenti funkcije delete su vec objasnjenji u prethodnom primeru.

Svi moderni jezici imaju brojne funkcije sa stringovima. Ovde smo obradili samo neke koje se cesto koriste. Vise o stringovima u pascalu pogledajte ovde i ovde.

Pretežno vedro v1.1

Program: Pretežno vedro
Verzija: 1.1
Namena: Prikaz meteoroloških podataka
Licenca: GNU GPL v3
Autor: SkYNeT

Program preuzima podatke sa rss fida republickog hidrometeoroloskog zavoda Srbije i prikazuje aktuelne meteoroloske podatke za izabrani grad u prozoru programa. Podaci se automatski azuriraju na svakih 30 minuta, a mozete ih i rucno azurirati, pritiskom na dugme.

Razvijam ga za Linux 32Bit/64Bit i Windows 32Bit.

———————

Program mozete preuzeti na Download strani.

Pretezno vedro

Pretezno vedro

Pascal: Nizovi (Arrays)

Nizovi su, kako im samo ime govori, elementi u programiranju koji sadrze sredjeni niz podataka. To mogu biti brojevi, stringovi, bajtovi itd. Nizovi se definisu u var bloku a zatim inicijalizuju pre koriscenja, tako sto se ispunjavaju nekim standardnim podacima. Elementima niza se pristupa pomocu rednog broja. Ovo vazi i za citanje i za pisanje. Pogledajmo sada sve ovo u praksi.

program Nizovi;
uses
crt;

var
n:integer;
//definisanje niza
a:array[1..10] of Integer;

begin
//inicijalizacija
for n := 1 to 10 do
//punimo niz brojevima
a[n] := n*n;
//citamo redne brojeve 2 i 7
writeln('Na broju 2 je ',a[2]);
writeln('Na broju 7 je ',a[7]);
readln;
clrscr;
//upisujemo 30 na mesto broj 5
a[5] := 30;
//citamo sve brojeve
for n in a do
writeln('Na broju ',round(sqrt(n)), ' je vrednost: ',n);
readln;
end.

Napomena: Ovaj program nece raditi u Dev-Pascalu zato sto on koristi verziju FPC kompajlera u kojoj ne postoji podrska za For/In strukturu. Mozete ga probati u Lazarusu, jer je podrska za ovo dodata od FPC v2.4.2. Ako insistirate na Dev-Pascal IDEu isti efekat cete dobiti ako poslednjih pet redova napisete ovako:

//citamo sve brojeve
for n := 1 to 10 do
writeln('Na broju ',n, ' je vrednost: ',a[n]);
readln;
end.

Da podsetimo, u Lazarusu ovakve programe mozete kreirati sa Project > New Project > Simple Program ili Program. Za nase potrebe preporucljiva je prva opcija.

Pogledajmo sta nas program radi. Najpre definisemo sam niz u var bloku. Zatim ga punimo brojevima tako sto na svako mesto u nizu stavljamo kvadrat rednog broja elementa. Nakon toga ocitavamo vrednost na dva mesta, da bi se uverili sta se tu nalazi. Zatim upisujemo drugaciju vrednost na mestu broj 5 (gde se nalazi 25 kao kvadrat rednog broja). I na kraju iscitavamo sve vrednosti po redu, kao demonstraciju For/In strukture. Da bi simulirali redne brojeve koristimo zaokruzivanje korena vrednosti na tom mestu. Drugi nacin da se uradi ista stvar objasnjen je u delu napomene.

Vise o nizovima mozete pogledati ovde.

Pascal: Loo(m)povanje plus

Drugi text o lupovima odvajamo zbog preglednosti. Ovde cemo obraditi jos nekoliko korisnih stvari vezano za Pascal petlje. To su brojanje unazad, brojanje na preskoke i petlja u petlji. Ovde necemo obraditi korisnu For/in strukturu, jer su nam za to potrebni nizovi. Primeri ce kao i ranije biti vrlo jednostavni da bi se video princip. A nakon toga vam mogu posluziti kao modeli za sopstvene programe.

1) Brojanje unazad

program ForUnazad;
var
a:integer;

begin
for a := 10 downto 1 do
begin
writeln('Vrednost a je ',a);
end;
readln;
end.

2) Preskoci Do/While

program Neparni;
var
a:integer;

begin
a := 1;
while a <= 10 do
begin
writeln('Vrednost a je ',a);
a := a+2; //preskacemo za 2
end;
readln;
end.

3) Preskoci Repeat/Until

program Parni;
var
a:integer;

begin
a := 2;
repeat
writeln('Vrednost a je ',a);
a := a+2;
until a > 10;
readln;
end.

4) Petlja u petlji

program PuP;
var
a,n:integer;

begin
for n := 1 to 3 do
begin
for a := 1 to 5 do
writeln('Za krug: ',n,' - Vrednost a je: ',a);
end;
readln;
end.

Ovde su data 4 jednostavna primera koriscenja petlji. Najpre smo demonstrirali kako se broji unazad pomocu for-a. Nakon toga smo dali dva primera preskakanja pomocu DoWhile i RepeatUntil i na kraju smo demonstrirali petlju u petlji pomocu dva for lupa. Za unutrasnji for nismo otvarali begin/end blok jer smo koristili samo jednu komandu, te u tom slucaju nije neophodno. U Pascalu ne postoji For/Step struktura, tipicna za neke druge programske jezike, i zato se preskoci rade pomocu drugih metoda. Naravno, sve ove petlje je moguce kombinovati u zavisnosti od situacije, potreba ili kako vama odgovara.

Pascal: Loo(m)povanje

Petlje ili lupovi su strukture u programiranju koje nam omogucavaju da delove koda ponavljamo vise puta na kontrolisan nacin. U Pascalu, slicno kao i u drugim programskim jezicima, postoji tri tipa petlji. To su Reapeat/Until, Do/While i For petlja. U koliko se unutar petlje nalazi vise komandi, one se nalaze u begin/end bloku, slicno kao kod If/then. Pogledajmo sada svaku od njih:

1) Do/While:

program DoWhile;
var
a:integer;

begin
a := 1;
while a <= 10 do
begin
writeln('Vrednost a je ',a);
a := a+1
end;
readln;
end.

2) Reapeat/Until:

program RepeatUntil;
var
a:integer;

begin
a := 1;
repeat
writeln('Vrednost a je ',a);
a := a+1;
until a = 11;
readln;
end.

3) For petlja:

program ForPetlja;
var
a:integer;

begin
for a := 1 to 10 do
begin
writeln('Vrednost a je ',a);
end;
readln;
end.

Ovde su data tri vrlo jednostavna primera, tako da mozete lako videti razliku u pristupima. Takodje ih mozete koristiti kao modele za svoje petlje. Sva tri programa jednostavno broje od 1 do 10 i ispisuju vrednost na ekranu. Obratite paznju na 2) primer u kome smo brojac postavili do 11. Ovo je zato sto kod Reapeat/Until, brojanje pocinje nakon izvrsenja prvog ciklusa. Samim tim, morali smo dodati jos jedan ciklus da bi bio ispisan i broj 10. Inace bi samo izasli iz petlje na broju 9, pa se 10ti krug ne bi ni izvrsio.

Vise o petljama u Pascalu mozete videti ovde.

%d bloggers like this: