C

Dimitar Bitrakov C++
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 1 -

Programski jazik C++

Skopje, 2014

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 2 -

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 3 -

I. Vovedni informacii

Programskiot jazik C++ se vbrojuva me|u najpopularnite programski jezici za
profesionalna primena. Se koristi i na golemi i personalni kompjuteri. Jazikot e
mnogu sloèn i so golemi mo`nosti , a namenet e najvi{e za stru~nacite koi profesi-
onalno rabotaat na pi{uvawe programi. Tvorec na programskiot jazik c++ e danski-
ot kompjuterski nau~nik Bjame Stroustrup koj vo 1980 godina, vo laboratorija na te-
lekomunikaciskata firma Bell go sozdava ovoj programski jazik.. Go zapo~nal razvojot
na C++ kako pro{iruvawe na programskiot jazik C.. Vo 1983 godina prva komercijalna
distribucija e pretstavena na javnosta vo knigata The C++Programming Language na
avtorot Bjame Stroustrup.
Za razlika od drugite programski jazici ~ii operatori se izbrani zborovi,
operatorite vo C++ se znaci koj ne se del od azbukata a se dostapni na site tastaturi.
Ova go pravi jazikot C++ mnogu pokratok i pove}e internacionalen, zatoa {to koristi
pomalku angliski termini.
Programata vo site programski jazici,pretstavuva raboten nalog na kompjuterot. Taa
pretstavuva niza od naredbi {to ukaùvaat na dejstvata {to kompjuterot treba da gi izvr{i
i redosled vo koi ke se izvr{uvaat tie dejstva so cel da se dobijat baranite rezultati.
Procesot na podgotvuvaweto i pi{uvaweto na programata za re{avawe na edna zada~a se
vika programirawe.

Programiraweto gi obfa}a slednive dejstva :

- definirawe na zada~ata ,
- analiza na zada~ata i opredeluvawe na numeri~ka postapka za nejzinoto re{avawe ,
- proektirawe i razrabotka na algoritam ,
- pi{uvawe na programa ,
- testirawe i proverka na ( ispravnosta ) na programata.

Dvete dejstva zavisno od zada~ata moè da bidat mnogu sloèni i te{ki i se neza-
visni od tipot na kompjuterot na koj }e se rabori. Nezavisni se i od programskiot jazik vo koj
ke se podgotvi programata . No za korisnicite na ovaa kniga }e bidat dostapni i ednostavni.
Knigata e pi{uvana za u~enicite vo srednoto obrazovanie i za studentite . Izborot na zada-
~ite }e bide na nivo na nivnite predznaewa. Vneseni se pove}e primeri so cel da go po-
ednostavi izu~uvaweto na programskiot jazik C++.

Slednoto dejstvo , proektirawe i razrabotka na algoritmot ke go razgledame vo prodol-
ènie. Algoritmot ( angl. Flow chart ) e pomo}no sredstvo koje e nezavisno od program-
skiot jazik i kompjuterot, ja vizualizira zada~ata, pa taa postanuva zna~itelno preg-
ledna. Algoritmot se sastoji od niza ednostavni geometriski likovi spojeni so usme-
reni crti. Usmerenite crti go pokaùvaat tekot na re{avaweto na zada~ata.
Algoritmot redovno go sveduva zadatokot na re{avawe na pove}e ednostavni,
pomali dejstva.. Ako je algoritmot jasno i podrobno napisan, toga{e dovolno vrz nego
da se napi{e programa i re{i zadatokot. Algoritam se prikaùva so dijagram na te-
kot na dejstvaata. Za ednostavno i lesno izrazuvawe na algoritmite naj~esto se koris-
time so blok dijagram,{to pretstavuva grafi~ki na~in za zapi{uvawe na algoritmot.
Vo ovoj na~in na prikaùvawe na algoritmot,sekoj algoritamski ~ekor se vnesuva vo
grafi~ki simbol (blok) ~ii oblik ukaùva na funkcijata na algoritamskiot ~ekor.
Blokovite se povrzuvaat so strelki i tie ukaùvaat na redosledot na ispolnuvawe na
algoritamskite ~ekori . Vakviot grafi~ki zapis se narekuva i algoritamska {ema .
-------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 4 -

Vo izrazuvawe na algoritmite so blok dijagram se koristime so blokovite prikaàni
vo tabelata

Za sekoja zada~a e korisno da se izrazi postapkata za nejzinoto re{avawe na
kompjuter so blok dijagram. Dijagram e patokaz za pi{uvawe na programata, ovozmo-
ùvajki kontrolirawe na ispravnosta na algoritmot,sporedbena analiza na mo`nite
varijanti i izbor na najdobrata , ja olesnuva timskata rabota pri pi{uvawe na prog-
ramite i e sostaven del na dokumentacijata za programata . Pos vo algoritmot
(),

Algoritamski strukturi
Vo zavisnost od zada~ata, blok dijagramot moè da bide ednostaven no i dosta
sloèn , so mnogu blokovi i sloèni vrski. Vrskite me|u blokovite ja odreduvaat
strukturata na algoritmot .No i pokraj mnogute vrski me|u blokovite algotitmite mo-
è da se podelat vo tri vida osnovni (elementarni) algoritamski strukturi .
- , (. sequence),
- , (. selection),
- ,. () (. loop) .
Re ( )
Osnovna karakteristika na liniskata struktura e izvr{uvawe na naredbite
samo edna{vo tekot na izvr{uvaweto na programata .Vo ovaaa struktura po izvr{u-
vawe na naredba moè da se premine na slednata naredba {to ne e prethodno izvr-
{ena. Redosledot na izvr{uvawe na naredbite e odnapred utvrden ,nezavisno od
vrednostite na vleznite golemini ili me|urezultati i ne moè da se menuva vo tekot
na izvr{uvaweto.
--------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 5 -

Algoritmot za prostata liniska struktura moè da se izrazi vo sledniot oblik.:

Vo liniskata struktura se sodràt naredbi za vlez, naredbi za dode-
luvawe, a za izlez naredbi za izlez ( pe~atewe ).,
R ,
Za razlika od liniskata struktura vo koja site naredbi se izvr{uvaat samo
edna{po utvrden redosled,kaj razgranetata struktura odredeni algoritamski ~ekori
ke se izvr{at samo edna{, dodeka postojat algoritamski ~ekori {to ne }e se izvr{at.
Karakteristi~no za ovie strukturi e postoeweto na usloven algoritamski ~ekor so koj
se donesuva odluka za tekot na izvr{uvawe na algoritamskite ~ekori ili kako {to se
veli, algoritamski ~ekor so koj se realizira razgranuvawe na algoritmot. Osno-
vnata kompozicija na razgraneta liniska struktura se izrazuva so algoritamskiot
segment
.
Ako se ispolnuva uslovot vo blokot za razgranuvawe se izvr{uva naredbata -2, Vo
slu~aj na neispolnuvawe na uslovot se preskoknuva naredbata -2. So zadebelena li-
nija se sledi patekata vo edniot ili drug slu~aj.

C .n.
Osnovna karakteristika na cikli~nata struktura e mo`nosta na pove}ekratno
izvr{uvawe na eden ili pove}e algoritamski ~ekori vo algoritmot.Cikli~nata
struktura vo op{t vid se sostoi najmalku od dve prosti liniski strukturi i uslo-
ven algoritamski ~ekor.
------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 6 -

Cikli~nata struktura se prikaùva vo sledniot oblik:

So zadebelena linija se sledi patekata vo edniot ili drug slu~aj.

Kratkiov pregled na algoritamskite strukturi sluì samo za osnovno informirawe.
Na algoritamskite strukturi posvetuvawe posebno vnimanie vo site sledni glavi so
ogled na nivnata va`nost vo programiraweto, osvrnuvajki se na karakteristi~ki za-
da~i. Se razgleduvaat algoritmi i za posloèni zada~i {to pretstavuvaat razli~ni
kombinacii na trite osnovni algoritamski strukturi.
Pi{uvawe programa
Pi{uvawe na programa e etapa koja sledi po proektiraweto i razrabotka na
algoritmot.Pi{uvawe na programa e vsu{nost izrazuvawe na algoritmot vo stroga za-
dadena forma spored sintaksi~nite pravila na jazikot C ++. Kako i sekoj drug prog-
ramski jazik taka i jazikot C++ go so~inuvaaat mno{tvo naredni.Sekoja naredba ima
svoja forma i izrazuva odredeno dejstvo. Za sekoj algoritamski ~ekor vo algoritmot,
po pravilo sleduva sootvetna naredba.
Osnovniot pojm vo programata e promenliva . Se ozna~uva so edna ili pove}e
bukvi so mo`nost na koristewe i na cifri. Pome|u znacite {to go formiraat imeto
na promenlivata ne smee da ima razmak.. Izborot na imeto na promenlivata e proiz-
volno, i se bira ~esto so zna~eweto {to go ima. Ograni~uvawe se odnesuva na zborovi
od angliskiot jazik {to se koristat kako termini, zatoa {to vo toj slu~aj preve-
duva~ot ke gi pome{a so nekoi od standardnite {to gi koristi jazikot C++.
Navedenite termini ne smejat da se koristat:
break, case, char, const, continue, default, delete, do,
double, else, explicit, false, float, for, goto, if,
int, namespace, operator, , return, switch, true, using, while.
ne moè da se koristat kako ime na promenliva. Promenlivite se rasporeduvaat vo
oddelni tipovi spored sodrìna za koja se koristat. Programskiot jazik C++ ovozmo-
ùva koristewe na pove}e tipovi podatoci . Se rasporeduvaat vo tri tipa.
- integer tip ( celobroen tip vo koi spa|at celite broevi)
- float tip (vo koj spa|aat decimalnite broevi )
- character tip ( vo koi spa|aat znakovnite podatoci i tekstovite)
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 7 -

Sekoja promenliva {to }e se koristi vo programata treba da se deklarira vo
programata. Sintaksata za deklarirawe na promenliva e pi{uvawe na eden od termi-
nate int ( kratenka od integer ), float i char (kratenka od character) po {to sleduva ime
na promenlivata . Zapisot zavr{uva so znakot ; .
Na primer, int a ; , float b ; , char c ;
Ova se tri ispravni deklaracii na promenlivi. Prvata ja deklarira promenlivata
a od tipot Int (celobrojna promenlivata ), vtorata ja deklarira promenliva b od
tipot float( decimalna promenliva ), a tretata promeniva ja deklarira promenlivata
c od tipot char ( tekstuana promenliva ).
Prou~uvaweto na programskiot jazik e vsu{nost prou~uvaweto na naredbite na
jazikot. formata i dejstvoto na naredbite a so toa i nivnata povrzanost vo izrazu-
vawe na sloèni algoritamski strukturi {to go nametnuva postakata za re{avawe na
edna zada~a. Neophodno e poznavawe nz naredbite za da se pristapi kon pi{uvawe na
programa .So niv algoritmot ke se prevede vo programa ,vsu{nost, sootvetnite algo-
ritamski ~ekori ke se izrazat so sootvetni naredbi vo C++. Kako rezultat na sprove-
duvawe na ovaa postapka se dobiva niza od naredbi {to pretstavuva programa.
Podgotvenata programa se vika izvorna programa. Nejzina realizacija se izvr{uva
so aktivirawe na preveduva~ot ( kompajlerot ) na programskiot jazik C++.

Upatstvo za izvr{uvawe na programa
Se po~nuva so kliknuvawe na komandite START > Dev-C++.

Po najavnata slika ,koja se prikaùva za nekolku sekundi,

sleduva prikaz na prozorecot.

--------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 8 -

Prviot poteg e kliknuvawe na komandata Project ( ).

Se doveduva na ekranot ramkata pod naslov New project.

Se izbira komandata Conzole Application ,potoa Ok. sleduva osnovniot prozorec

Korisnicite na majkrosovite i linuksovi programi za ureduvawe na tekst, gra-
fika, tabelarno presmetuvawe i drugite programi }e zabeleàt golema sli~nost so
prozorecite na tie programi. ]e ja zabeleàt lentata na glavnite menija, i drugi {to
ne potsetuvaat na lentite na tie programi.

-----------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 9 -

Vo menito File se komandite za otvorawe na proekt ili datoteka, komandite za
memorirawe , komandite za zatvorawe, komandata za pe~atewe i komandata za izbor
na format, margini i drugi dejstva.
-
Vo menito Edit se komandite za prenesuvawe na komandi od edna pozicija vo
druga i za kopirawe.

Vo menito Exsecute naredbite za kompajlirawe,za izvr{uvawe na programata i
komandata za dvete dejstva kompajlirawe( Compile) i izvr{uvawe (Run) i drugi
dejstva.

Prvite naredbi {to }e gi koristime se vo tretata lenta.

So broj (1) naredbata Compile, pod (2) Run, pod ( 3) Compile & Run.

Vo prodolènie e prostorot vo koj se vnesuva programata.

--------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 10 -

Informacii za prostorot vo koj se vnesuva programa se na slednava slika..

Vo gorniot lev agol se sistemskite naredbi.Sistemskite naredbi ne treba da
se menuvaat. Ne se menuvaat ni del na sistemkite naredbi pred kraj od levata strana.

Vo redosled sledat :
- znakot { za ozna~uva na po~etok na programata.
- deklarativnite naredbi .
- programata
- po sistemskite naredbi, znakot } za ozna~uvawe na kraj na programata

Izvr{uvawe na programa se realizira po prethodno preveduvawe ( kompajlirawe ).

Kompajlirawe na programata

Vo listata na naredbite moè da se vnesuvaat informacii. Informacijata moè
da se odnesuva na dejstvoto na programata, ozna~uvawe na po~etok od segment na
programata,poraka za korisnikot na programata. Site linii koi po~nuvaat so dve kosi
crti // se smetaat informacija i nemaat nikakvo vlijanie na odnesuvaweto na
programata.

P C++treba da se prevede vo ma{inska
programa ,zatoa {to na kompjuterot moè da se izvr{i samo programa vo ma{inski ili
izvr{ni oblik.Toa se vr{i so programa preveduva~ (compiler ). Preveduva~ot ja
preveduva programata i gi otkriva sintaksnite gre{ki na napisanata programa.
- se izbira komandata Compile

----------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 11 -

Pod sintaksni gre{ki se podrazbira nepo~ituvawe na pravilata na pi{uvaweto
na naredbite. Gre{kite koi preveduva~ot ke gi pronajde vo tekot na preveduvaweto,
ispi{uva poruka i ja otkriva linijata kade e pronajdena gre{ka . Otkriva i od koj tip
e gre{kata. .Soop{tuva so zatemnuvawe na linijata vo koja se naoga gre{no napi{ana
naredba i go doveduva prikazot..Se dobiva informacija za otkriena gre{ka

Otkrienata gre{ka treba da se popravi . Programerot go koregira zapisot na nared-
bata i povtoruva izbor na Compile, ako se najavi druga gre{ka. Kolku vnimatelno da
se raboti neminovni se gre{kite. Ovoj proces se povtoruva se dodeka ne se ispravi i
poslednata gre{ka. Najava za zavr{eno testirawe e sledna sostojba na prikazot.

Po ova moè da se izvr{i programata.
Izvr{uvawe na programata
Za izvr{uvawe na programata se izbira komandata RUN od lentata ili preku
glavnoto meni EXECUTE
Se doveduvuva listata C: \Dev-Cpp\Projest 1.exe za prikaz na rezultatite .

----------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 12 -

Crti~kata vo Project.exe e informacija deka e mo`no da se vnesuvaat vleznite
podatoci, a po izvr{uvawe na programata se vnesuva i dobieniot rezultat .
Voveduvawe na listata so zapisot C: \Dev-Cpp\Projest 1.exe se registrira i vo
linijata na nivo na komandata Start.

a komandite vo leviot del vo lentata vo osnovniot prozorec

Se zamenuvaat so

Onevozmoèno e sekakvo dejstvo so programata.
Za prodolùvawe so rabota vrz tekovna programa ili nova e potrebno da se otst-
rani listata C: \Dev-Cpp\Projest 1.exe .Mo`no e so klik na koja bilo bukva na tas-
taturata, kliknuvawe vo znakot vo gornoto desno }o{e na ramkata ,ili klik-
nuvawe na zapisot C: \Dev-Cpp\Projest 1.exe vo lentata na nivo na komandata Start.

Logi~ki gre{ki
Rezultatot po izvr{uvawe na programata treba da se proveri so podatoci za
koi e odnapred poznat krajniot rezultat. Mo`nite gre{ki {to }e se otkrijat so pro-
verkata se vikat logi~ki gre{ki. Niv gi prouzrukuva pogre{en algoritam na osnova na
koj e podgotvena programata. Najte{ko se otkrivaat logi~kite gre{ki koi se sodràt
vo algoritmot vrz koj e sostavena programata. Kompjuterot ne moè da gi otkrie ovie
gre{ki bidejki ne znae {to saka programerot.
I na kraj, po proverkata na ispravnost na programata , se ureduva formata vo koja se
prikaùva rezultatot. Sreduvawe so vnesuvawe na tekstovi i prereduvawe na
tekstovite za da prikazot na rezultatot bide koregiran od tehni~ka gledna to~ka.
Prikazite vo prodolènie o~igledno ukaùvaat na potrebata od ova dejstvo.

,
() .
---------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 13 -

II . Programi za algoritmi so prosta liniska struktura
Osnovna karakteristika na liniskata struktura e izvr{uvaweto na site
naredbi vo programata samo edna{ .Vo ovaa struktura po izvr{uvawe na naredba mo-
è da se premine na slednata naredba {to ne e prethodno izvr{ena. Redosledot na
izvr{uvawe na naredbite e odnapred utvrden ,nezavisno od vrednostite na vlezite
golemini ili me|urezultati . Vo op{to, algoritmot za prostata liniska struktura se
izrazuva vo sledniot oblik.:

]e gi razgledame naredbite vo redosled.
Naredba za vnez.
Naredbata za vnesuvawe na poznatite podatoci na promenlivite e imenuvana so
kratenkata cin . Cin e kratenka od C input. So komandata cin se vnesuvaat vlezni
podatoci za promenlivite . Promenlivite vo listata vneseni po imeto se razdvoju-
vaat so znakot >> , a krajot na naredbata se ozna~uva so znakot ; . Za vnesuvawe ,
na primer, vlezni podatoci na promenlivite a, b , c i d , promenlivite vo lis-
tata na narebata se vnesuvaat vo sledniov vid :
cin >>a>>b>>c >>d ;
Brojot na promenlivite vo listata ne e ograni~en. Rastojanija vo listata
me|u promenlivite se dozvoleni. Vnesenite numeri~ki podatoci se zabeleùvaat vo
prozorecot Project.exe,koj se pridruùva na ekranot koga }e se aktivira komandata cin.

Numeri~kite podatoci za promenlivite vo listata na naredba cin se
vnesuvaat vo redovi vo redosled kako se poredeni promelnivite vo listata na nared-
bata . Se vnesuvaat so razmak od najmalku eden znak blanko. Ako se vnesat pove}e
podatoci,tie se ignoriraat. No, ako se pomalku od promelivite vo listata po klik na
Enter }e se prezemat vnesenite i vo prozorecot Project.exe vo vtoriot red pak ke se
pojavi crti~kata {to treperi vo o~ekuvawe i na slednite podatoci. .Ke bide potre-
ben u{te eden klik na Enter.
Vnesenite podatoci za promenlivite vo listata so tastaturata se zabeleùvaat
vo Project.exe

--------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 14 -

Naredba za dodeluvawe.
Naredbata za dodeluvawe se pi{uva vo vid
Promelniva = aritmeti~ki izraz ;
pri {to znakot = e operator za dodeluvawe vrednosta na aritmeti~kiot izraz na
promenlivata .
Znakot = nema zna~ewe na ravenstvo vo matamati~ka smisla,, tuku e oznaka
za dodeluvawe na vrednosta na konstanta, promenliva ili aritmeti~kii izraz na
promenlivata {to e od levata strana .Naredbata za dodeluvawe se izvr{uva taka {to
prvo se presmetuva vrednosta na izrazot i potoa vrednosta se dodeluva na promen-
livata .
Operatorite za aritmeti~kite dejstva se slednite :-

Navedenite matemati~ki operacii se izvr{uvaat vo sledniov redosled :
- stepenuvawe, - mnoèwe i delewe , sobirawe i vadewe
Vrednosta na aritmeti~kiot izraz se presmetuva od levo kon desno pri {to se
uvaùva navedeniot redosled (prioritet ) . Izrazite a +b , c d , a *b + c ,
a*b c *d , (a +b) / ( c +2*d ) se najednostavni zapisi na izrazite vo C++.
Utvrdeniot prioritet se izmenuva so koristewe na zagradi. .So upotreba na zagrada
se otstapuva od utvrdeniot priotitet i }e se presmeta pred se izrazot vo zagrada. Vo
izrazite moè da se upotrebuvaat i pove}e zagradi.
Aritmeti~kite izrazi moè da sodràt samo promenlivi i konstanti od tipot int
, promenlivi i konstanti od tipot float, ili ednovremeno od dvata tipa. Vo vrska so
vrednosta na aritmeti~kiot izraz vaàt slednive pravila :
Vrednosta na aritmeti~kiot izraz ke bide int konstata ako site argumenti (pro-
menlivite i konstanti te) vo izrazot se od tipot Int.
Za deklaracija : int i =3 , j =2 ;
i +j =3 +2 =5 , i - j =3 - 2 =1 , i * j =3 * 2 =6 , i / j =3 / 2 =1 .
Vo rezultat od deleweto na dve integer konstanti se dobiva samo celiot del od
koli~nikot
------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 15 -

Vrednosta na aritmeti~kiot izraz ke bide float konstanta ,ako bar eden od
argumentite vo izrazot e od tipot floal ,ili site argumentite vo izrazot se od tipot
float.
Za deklaracija float a =3.0 , b =2.0 , a +b =3.0 +2.0 =5.0 , a - b =3.0 -
2.0 =1.0 , a * b =3.0 *2.0 =6.0, a / b =3.0 /2.0 =1.5
Za deklaracija int i =2 ; float a =3.0 : a + i =3.0 +2 =3.0 +2.0 =5.0 , a - i =
3.0 - 2 =3.0 2.0 = 1.0 a * i =3.0 *2 =3.0 *2.0 =6.0 a / i =3.0 /2 =3.0 /2.0 =1.5
Vrednosta na promenlivata i se konvertira vo tip float i potoa se izvr{uva
najavenoto dejstvo. Ukaùvame na dejstva {to se posledica na koristeweto na
na razni tipovi promenlivi vo formirawe na naredba.
Za deklarirawe :
int i , j ; float a , b :
- za a = 25. 40 , so naredbata i = a ; promenlivata i dobiva vrednost 25 .
Vrednosta na a se konvertira vo tip Integer i potoa dodeluva na promenlivata j.
- za i = 25 , j = 10 izrazot i / j e ramen na 2 ,na celobrojniot del od deleweto.
Naredbata a =i / j dodeluva na promenlivata a vrednost 2 .
- za i = 25 , b = 10.0, izrazot i / b e ramen na 2.5 , So narednata j = i / b na
promenlivata j se dodeluva vrednost 2 . za i = 25 , b = 10.0, izrazot i / b e
ramen na 2.5 , So narednata a = i / b na promenlivata a se dodeluva vrednost 2 .5
Specifi~nosti vo vrska so naredbite za dodeluvawe }e razgledame vo prodol-
ènie.:
So naredbata stepen =30 ;
na promenlivata stepen se dodeluva vrednost 30.
Naredbata k = k +1 ;
vo matematikata nema smisla. No,mnogu ~esto se koristi vakviot vid naredba za do-
deluvawe. So ovaa naredba, vrednosta na promenlivata k }e se zameni so nova
vrednost koja e za eden pogolema od prethodnata.
So naredbata a =a + b
vrednosta na promenlivata a ke bide ednakva na sumata od starata vrednost na
promenlivata a i na promenlivata b. Vsu{nost,naredbata pretstavuva nalog
vrednosta na promenlivata a da se zgolemi za b. Ako vo momentot na izvr{uva-
weto na naredbata, vrednostite za a i b se sootvetgno 60 i 100, po izvr{uvaweto
vrednosta na b ne }e se izmeni, dodeka vrednosta na a }e bide 160.
-----------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 16 -

Znakot % se koristi za slednovo dejstvo. Odnosot a % b go registrira
ostatokot na deleweto na broevite a i b. Ako vo odnosot a % 2 , brojot a e paren
broj, ostatokot na deleweto e nula. Za a neparen broj, ostatokot e 1. Registriraweto
na ostatokot ,ni ovozmoùva preku vrednosta na ostatokot gi izbirame vo programata
parnite odnosno neparnite broevi i drugi odnosi..
Osem ova ,ako vo odnosot na povekecifren broj a % 10 nema ostatok, brojot e
deliv so 10. , pa poslednata cifra e nula. Ako ne e brojot deliv so 10, ostatok e
ednakov na poslednata cifra na broj a .Registriraweto na ova vrednost ni pomaga da
gi otkrivame vo nizata broevi cifrite. Ako se podeli brojot a povtorno so 10, ja
otkriva pretposlednata cifra vo pove}ecifren broj. a .
Mnogukratnite presmetuvawa se vr{at so narebata za dodeluvawe. Nema ogra-
ni~uvawa vo formiraweto na izrazot.Se koristat site aritmeti~ki dejstva.Se koris-
tat i funkcii. Poradi ova, naredbata za dodeluvawe, ~esto ja iskaùvame i kako
naredba za presmetuvawe.. Navedenite primeri go prezentiraat na~inot na formira-
weto na aritmeti~kite naredbi za presmetuvawe na golemini definirani so matema-
ti~ki formuli.
Matemati~ki formuli naredbi za presmetuvawe vo C++
m =3n
2
+4n -5 m = 3*n* n +4*n - 5
c =( x
2
+y
2
+x .y ) /3 c =( x * x + y * y +x * y) / 3
y =a.b / (c +d ) +d y =a *b / ( c +d ) + d

m = r
2
.pi +r.p.s m =r *r * 3.14 +r* 3.14 * s
v =r
2
.pi.h / 3 v =r * r * 3.14* h / 3

Naredba za izlez.
Izdavawe ( prikaz ) na vrednostite na vleznite podatoci, na presmetanite
vrednosti na podatocite kako i pridru`nite tekstovi se ostvaruva so naredbata za
izlez. Na naredbata za prikaz na vrednostite na promenlivite e izbrana kratenkata
cout (toa e kratenka od c output ) . Vo listata na naredbata moè da se vnesat
konstanti, promenlivi i aritmeti~ki izrazi. Promenlivite vo listata vneseni po
imeto se razdvojuvaat so znakot << . Za oznaka na kraj na naredbata se koristi
znakot ; . Za izlez , na primer na promenlivite a, b , c i d , naredbata }e se
zapi{e vo vid :
cout << a << b <<c <<d ;
Vrednostite na promenlivite a, b ,c i d }e se zabeleàt vo Project1.exe

---------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 17 -

Vrednostite na promenlivite a , b , c i d }e se zapi{at vo eden red kako e
prikaàno vo Project1.exe bez rastojanie . So zapisot na naredbite
cout <<a ; cout <<b ; cout <<c ; cout<<d ;
se dobiva istiot zapis na podatocite.
Prikaz na vrednostite na promenlivite vo ~etiri reda , kako e prikazano na
Project1.exe

Se ostvaruva so komandite :
cout <<a <<endl; cout <<b<<endl; cout <<c ; cout<<d <<endl;
So dodatokot endl na kraj na naredbite se vr{i premin na sleden red.
Prikaz po dva podatka vo red,

Se realizira so naredbite
cout <<a <<b<<endl ; cout <<c <<d <<endl ;
Preddefinirano cifrite se ispi{uvaat bez razmak.. Rastojanieto se izbira so
dopolnitelni informacii vneseni vo naredbata cout. Razmakot megu cifrite se odre-
duva so blanko znaci vo navodnici. Brojot na znacite blanko go odreduvaat rasto-
janieto. So naredbata
cout << bbbb <<a<< bbbbbb <<b << bbbb <<c << bbbb <<d ;
Se dobiva sleden prikaz

Oblikuvawe na prikazot na rezultatite
Po razgleduvawe na prikazite na vrednostite na promenlivite,se zadrùvame na
oblikuvawe na rezultatot po izvr{uvawe na programata. Pod ova podrazbirame
vnesuvawe na tekstovi za da se vnesat objasnuvawa za podatocite, rasporeduvawe
na podatocite vo red i rasporeduvawe vo pove}e redovi. Osven ova i prikaùvawe
na naslovni tekstovi, podnaslovi i mnogu drugu objasnuvawa se so cel prekaàniot
rezultat bide pregleden i jasen.
Prikazot se vnesuva vo Project1.exe . [to }e se pokaè vo edna redica zavisi {to
se sodrì vo listata na naredba za izlez i vo koi redosled. Smetame za korisno na
nekolku primeri prezentirame nekolku karakteristi~ni formi vo listata na nared-
bata i prikazite {to se dobivaat po izvr{uvawe na naredbata na Project1.exe.
------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 18 -

So naredbata
cout << Programski jazik C++ ;
se vnesuva sledniov zapis vo linijata Project1.exe

So naredbata
cout << << PROGRAMSKI J AZiK C++ ;
se vnesuva zapisot

So komandata

cout << UCIISNI CENTAR <<ednl ;
cout << O H R I D <<endl :

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 19 -

Re{eni programi

Po prou~uvaweto na naredbite za vnesuvawe podatoci ,naredbi za dode-
luvawe i naredbite za izdavawe , sme vo mo`nost da sostavuvame programi za zada~i
~ie re{enie se izrazuva so prosta liniska struktur.a .
]e razgledame tri primeri.

// presmetuvawe na plo{tinata i volumen na kocka
so poznata strana.
Poznata golemina vo zada~ava e stranata na kockata a, a goleminite {to se
presmetuvaat se plo{tinata ozna~ena so P i volumenot ozna~en so V. Plo{tinata
i volumenot se presmetuvaat po formulate P =6a
2
, V =a
3
.
Po~nuvame so najednostaven primer. Toa e zada~a ,~ija postapka za re{avaweto
sv sveduva na prosta liniska struktura..
Treba da razgrani~ime :
- vlezen podatok ( strana na kockata , }e koristime vo programata oznaka a )
- presmetuvani podatoci: ( plo{tina , formula P =6a
2
, oznaka vo programata p .
Volumen, formula V =a
3
, oznaka vo prograata v .
- pe~atewe : vlezen podatok a, -presmetani podatoci p i v , -pridru`ni tekstovi
Algoritmot za zada~ata ke se izrazi so blok dijagramot

Spored blok dijagramot e podgotvena programata .
#include <cstdlib> #include <iostream> using namespace std; int main()
{ float a , v , p ;
cout<< Vnesete vrednost za promenlivata a <<endl;
cin >>a ;
cout<< potvrdite so klik na enter. <<endl ;
p =6*a*a ; v =a*a*a ;
cout <<" stranata na kockata e " <<a<<endl;
cout <<" plostinata na kockata e " <<p <<endl;
cout <<" volumenot na kockata e " <<v <<endl;
system("PAUSE"); return EXIT_SUCCESS; }
--------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 20 -

Se vnesuva izvornata programa.vo prozorecot .

Se postapuva spored iznesenoto vo vovedniot del ..
-Izberete komanda Compile za da se prevede programata vo izvr{na i otstranat
sintaksnite gre{ki. Po otstanuvawe na sintaksni gre{ki , Izberete komandata RUN
Se doveduva na ekranot listata C;Dev-Cpp\project1.exe

Vnesete podatok za promenlivata a. Potvrdite se klik na enter

. Se dobiva krajniot rezultat.

Za izvr{uvawe na sledna programa treba da se otstrani Proect.exe , prikazano e
otstranuvaweto vo prethodnata glava. Za potsetuvawe, dovolno e da se klikne vo
poleto na zapisot na rezultatot.
------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 21 -

// Poznati se vrednostite na promenlivite x, y, z, u i v {to se vnesuvaat so
tastaturata. Da se presmetaat vrednostite na promenlivite t ,s i r po
formulite;
t =( x
2
+y
2
) / ( z + u )
s =t . ( u +2v ) , r = (s 8 ) / ( s +8)
Vnesenite vrednosti za promenlivite x, y, z, u, i v kako i presmetanite
vrednosti na promenlivite t, s i r da se podredat vo sledniov vid.
V N E S E N I V R E D N O S T I
x =......... y =. z =. u = v =.
P R E S M E T A N I V R E D N O S T I
t =........ s = r =
- algoritam

- programata
{ float x ,y ,z , u , v ; float t ,s , r ;
cout<<" Vnesete gi vrednostite na promenlivite x, y, z " <<endl;
cin >>x >>y >>z ;
cout<<" Vnesete gi vrednostite na promenlivite u , v " <<endl;
cin >>u >>v ;
t =(x * x +y * y )/ (z +u) ; s =t * ( u +2 * v) ; r =( s - 8 ) /( s +8 );
cout <<endl;
cout <<" V N E S E N I V R E D N O S T I "<<endl;
cout <<" x ="<<x << y =" <<y << z ="<<z<<" u ="<<u<<" v ="<<v ;
cout<<endl;
cout <<" P R E S M E T A N I V R E D N O S T I "<<endl;
cout <<" t ="<<t<<" s ="<<s<<" r ="<<r<<endl;
---------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 22 -

- prikaz na rezultatot (Project .exe )

// Presmetuvawe na plo{tina i perimetar na kru`nica
- algoritam

- programa
#include<cstdlib> #include <iostream> using namespace std; int main()
{ float r , p , o ; float pi =3.1415 ;
cout<< " vnesete vrednost za r " <<endl ; cin>>r ;
cout << " presmetuvanje na plostina i perimetar "<< endl;
cout << " na kruznica " <<endl ;
cout << " za radius r =" <<r <<endl ;
p =r * r *pi ; o =2 * r *pi ;
cout <<" plostinata na kruznicata e " << p <<endl;
cout <<" perimetarot na kruznicata e "<<o <<endl; cout <<endl;
system( "PAUSE") return EXIT_SUCCESS }

-----------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 23 -

Matemati~ki funkcii

Korisnikot na programata ima na raspolagawe mnogu podgotveni funkcii
rasporedeni vo sootvetni biblioteki. Del na funkciite memoritani se vo biblio-
tekata Cmath. Ako treba da se koristi funkcija od ovaa biblioteka, treba da se
uklu~i so predprocesorskata naredba #include <math.h > .
Vo ovaa biblioteka se sodràt funkciite:

Ke gi razgleame funkciite :

1 . Funkcijata abs ( x ) .
Funkcijata dodeluva apsolutna vrednost na argumentot x.
2. Funkcijata ceil (x)
Funkcijata zaokruùva argumentot x na najbliskiot pogolem broj
- prilog programa
#include <cstdlib> #include <math.h>
#include <iostream> using namespace std;
int main( )
{ float x , y ;
cout<<" Vnesete broj "; cin>>x ; cout<<endl;
cout <<" Za vnesen broj "<<x<<endl;
y =ceil ( x );
cout<<" zaokruzen na najgolema vrednost e brojot "<<y ;
cout<<endl;
system( "PAUSE") return EXIT_SUCCESS }
- Project.exe
.
-------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 24 -

3. Funkcija floor ( x )
Funkcijata zaokruùva argumentot x na najbliskiot najmal broj.
- prilog programa
#include <iostream> using namespace std;
int main( )
{ float x , y ;
cout<<" Vnesete broj "; cin>>x ; cout<<endl ;
cout <<" Za vnesen broj "<<x<<endl;
y =floor ( x );
cout<<" zaokruzen na najmala vrednost e brojot "<<y ;
cout<<endl; system("PAUSE"); return EXIT_SUCCESS; }
- Project.exe

4 . Funkcija mod ( x , y ) .
Funkcijata presmetuva ostatokot od deleweto na dva realni broja.
#include <iostream> using namespace std; int main( )
{ float x , y , ostatok ;
cout<<" Vnesete broitel : " ; cin>>x ; cout<<endl;
cout<<" Vnesete imenitel : " ; cin>>y ; cout<<endl;
ostatok =mod (x , y ) ;
cout << ostatokot od delenjeto e " <<ostatok<< ;
5. Funkcija pow ( osnova , stepen ).
Funkcijata presmetuva stepen na zadadena osnova.
{float a , n , y ;
cout <<" Vnesete vrednost na osnovata "<<endl;
cin>>a ; cout<<" a =" <<a<<endl;
cout <<" Vnesete vrednost za stepeniot pokazatel" <<endl;
cin>>n ; cout<< " n =" <<n <<endl;
y =pow ( a , n ) ;
cout<< " y ="<<y <<endl;
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 25 -

- proect.exe

6. Funkcija sqrt ( x ) .
Funkcijata presmetuva kvadraten koren na brojot x.
{float x , y ;
cout <<" Vnesete vrednost za x "<<endl; cin>>x ;
y =sqrt (x) ;
cout<<" x ="<<x<<" y= "<<y <<endl;
system("PAUSE") ; return EXIT_SUCCESS; }
- proect.exe

7 . Funkcija sin ( radian ) .
Funkcijata presmetuva sinus za argument radian
#include <iostream> include <math.h>
using namespace std; int main()
// promenlivata alfas e za agolot vo stepeni
/ / promenlivata alfar e za agolot vo radiani
{ float alfas ,alfar , y ; float pi =3.1215 ;
cout <<" Vnesete vrednost na agolot vo stepeni "<<endl;
cin>>alfas ; cout<<" alfas=" <<alfas<<endl;
alfar =alfas * pi / 180 ;
y =sin ( alfar) ;
cout<< " y ="<<y <<endl;
-------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 26 -

- proect.exe

8. Funkcija atan ( radian ) .
Funkcijata presmetuva agol za poznata vrednost na tangensot.
#include <iostream> include <math.h>
{float x , agolr , agols ;
float pi =3.1415;
cout <<" Vneete vrednost na tangensot : " ; cin>>x ;
agolr = atan( x);
agols =180* agolr/ pi ;
cout<<endl; cout<<" vrednost na agolot e "<<agols ;
- proect.exe

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 27 -

Re{eni zadaci
1 . // Presmetuvanje na hipotenuzata, obikolkata i plostinata na pravoagolen
triagolnik. ( poznati se vrednostite na katetite)

Poznati golemini : katetata ( a ) i katetata ( b ).
Presmetuvawa : hipotenuzata (c ) plo{tinata ( P ) i obikolkata ( O )

Pe~atewe : a , b , c , P, O
#include <math.h >
Programa.
{ float a, b , c, p, o ;
cout<<"Vnesete gi stranite a i b na pravoagolnik"<<endl;
cin>>a>>b;
c=sqrt(pow(a,2)+pow(b,2));
p=(a*b)/2;
o=a +b +c;
cout<<" katetata a e "<<a<<endl;
cout<<" katetata b e "<<b<<endl;
cout<<" hipotenuzata e "<<c<<endl;
cout<<" obikolkata e "<<o<<endl;
cout<<" plostinata e "<<p<<endl ;
system ("pause"); return 0; }

2 . Presmetuvawe na elementi na pravoagolen triagolnik

Poznati golemini : katetata ( a ) I agolot ( alfaS ) ;
Presmetuvawa : alfaR =alfaS * PI / 180 ( PI =3.14 )
b =a*cos(alfar)/sin(alfar); c =a/ sin(alfar);
p =a*b/2; o =a +b +c ;
pe~atewe : b , c , p , o
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 28 -

programa:
#include <math.h >

{ float a,b,c,p,o ; float pi =3.1415; alfas ; float alfar ;
// vnesuvanje na podatocite
cout<<"vnesete ja vrednosta na katetata a" <<endl; cin>> a ;
cout <<" vnesete ja vrednosta na agolot alfa "<<endl; cin>> alfas ;
// pretvoruvanje na agolot vo radiani
alfar =alfas *pi/180;
// Presmetuvanje na elementite na triagolnbikot "
b =a*cos(alfar)/sin(alfar); c =a/ sin(alfar); p =a*b/2; o =a +b +c ;
// prikazuvanje na rezultatite
cout <<" b =" <<b <<endl; cout <<" c =" <<c <<endl;
cout <<" p =" <<p <<endl; cout <<" o =" <<o <<endl; cout<<endl;

3. // presmetuvanje na plostina na triagolnik po Heronova formula

Vlezni golemini : stranata (a) , stranata (b) i stranata (c)
Presmetuvawa : s =( a +b + c) / 2

Pe~atewe : a , b , c , P
------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 29 -

Programa :
#include <math.h >
{ float a , b , c , s , p ;
cout<<" vnesete podatoci za a,b,c " <<endl;
cin >>a >>b >>c ;
s =( a +b +c) / 2 ;
p =sqrt ( s *(s-a)* ( s - b)*(s-c)) ;
cout << " strana a = " <<a << endl;
cout<< " strana b = " <<b << endl;
cout<< " strana c = <<c << endl;
cout << " plostina p = " <<p << endl;
system( "PAUSE"); return EXIT_SUCCESS; }

4. // Da se presmeta i pecati na ekran plostinata i volumenot na kvadar so dadeni
stranata a na osnovata , dijagonalata na osnovata d i visinata na kvadarot H.

Vlezni podatoci : strana na osnovata ( a ), dijalonala na osnovata ( d )
Visina na kvadarot ( H ) .
Presmetuvawa :
strana na osnovata ( b )

plostinata na kvadarot (P ) P=2*(a*b+a*H+b*H);
volumen na kvadarot (V) V=a*b*H;
pe~atewe :P , V
-----------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 30 -

programa :
#include <math.h >
{float a,b,d,H,P,V,B,M;
cout<<"Vnesi ja stranata na osnovata na kvadarot a=";
cin>>a;
cout<<"Vnesi ja dijagonalata na osnovata na kvadarot d=";
cin>>d;
cout<<"Vnesi ja visinata na kvadarot H=";
cin>>H;
b=sqrt(d*d-a*a);
P=2*(a*b+a*H+b*H);
V=a*b*H;
cout<<"Plostinata na kvadarot e "<<P<<" a volumenot e "<<V<<endl;
system("pause"); return 0; }
5. Se presmetuva i pecati na ekran plostinata i volumenot na konus so daden r
radius na osnovata i visuna na konusot

Vlezni podatoci : radius na osnovata ( r ) , visinata na konusot ( h )
presmetuvawwa : osnovata ( b ), strani~na visina ( s ) , omota~ot ( m )
,Plo{tina na konusot ( p ), volumen na konusot ( v ).

pe~atewe : p , v
programa
#include <math.h >
{ float r, s , h , p ,v , b , m ; float pi=3.14 ;
cout<<"Vnesi go radiusot na osnovata na konusot" ; cin>>r;
cout<<"Vnesi ja visinata na konusot ; cin>>h;
b=r*r*pi;
s=pow(H,2)+pow(r,2);
m=r * pi * s ;
p=b +m ;
v=b * h / 3 ; cout<<"Plostinata na konusot e "<<p<<" a volumenot e "<<v<<endl;
system("pause"); return 0; }
--------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 31 -

III. Programi za algoritmi so razgraneta struktura
Vo dosega razgledanite programi naredbite se izvr{uvaa vo redosled kako
{to se vneseni vo programata .Me|utoa, i kaj ednostavnite zada~i,postapkite za
nivnoto re{avawe naloùvaat izmenuvawe na redosledot na izvr{uvawe na naredbi-
te vo programata vo zavisnost od ispolnuvawe ili neispolnuvawe na odreden uslov.
Toa e vo zada~ite ~ii algoritam se izrazuva so razgraneta liniska struktura. Vo rea-
lizacija na ovie zada~i,vo programata se koristat naredbi vo koi se donesuva odluka
za natamo{niot tek na izvr{uvawe na naredbite od mestoto na naredba vo programa-
ta. Za realizacija na ova vo C++ se koristat pod zaedni~ki termin naredbi za
razgranuvawe. Analogno na aritmeti~kite izrazi se koristat i logi~ki izrazi. .
Logi~kiot izraz e vo forma .

Aritmeti~kiot izraz moè da bide i konstanta i / ili promenliva.
Za sporeduvawata vo logi~kite izrazi se koristat slednive operatori :

Analogno na aritmeti~kite izrazi i logi~kite izrazi imaat vrednost. Logi~-
kite izrazi imaat samo dve vrednosti i toa, vrednost vistina ( ang. True) odnosno
vrednost nevistina ( ang. False). Ako za konkretni vrednosti na promenlivite i kon-
stantite , izrazite se sovpaaat so postaveniot operator za sporeduvawe, logi~kiot
izraz ima vrednost True. Vo sprotivno vrednosta na logi~kiot izraz ima vrednost
false.
Naredbata za razgranuvawe e vo forma
if ( logi~en izraz ) naredba ;
Vo zagradata po if e logi~en izraz vo mali zagradi so koi se sporeduva odnosot
pome|u konstantite i promenliite ili me|u dva aritmeti~ki izrazi vo logi~kiot
izraz spored koristeniot operator . Po zagrada sleduva naredba ili naredbi na koi
se odnesuva izvr{uvawe ili neizvr{uvawe vo zavisnost na ispolnuvawe ili neispol-
nuvawe na uslovot. Ako se poveke naredbi, tie se vnesuvaat vo golemi zagradi.
Dejstvoto sega se odnesuva na site naredbi.
---------------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 32 -

Razgraneta struktura se izrazuva so sledniov algoritamskiot segment .

Za vrednost na logi~kiot izraz true (vistana) se izvr{uva naredbata (nasoka
da ). Vo sprotivno naredbata if ne izvr{uva nikakvo dejstvo (nasoka ne ).
Konkretno ,vo algoritamskiot segment

ima razgranuvawe. Za vrednost true, po izvr{uvawe na naredbata1 se izvr{uva
naredbata 2 i prodolùva na sledna naredba. Za vrednost false, po izvr{uvawe na
naredbata 1, se preminava na slednata naredba. Dvete mo`ni nasoki se prikaàni
na slikata.
]e razgledame nekolku primeri na koristewe na logi~kata naredba. :
// programa za izbor na pogolemiot od dva vneseni broevi.
Podgotovkata za programata vo konkretniot primer se sveduva na slednive dejstva ;
-za dvata broja ke gi izbereme promenlivite x i y .Vrednostite na dva broja }e se vne-
sat so naredbata za vne
s. Postapkata za izborot na pogolemiot broj ke se izrazi so sledniov apgoritamski
segment.

Se sporeduvaat vrednostita na promenlivite x i y. Ako e vrednsta na logi~kiot izraz
x >y True ( vistina ), se pe~ati vrednosta na promenlivata x. Vo sprotivno ako,
logi~kiot izraz ima vrednost False ( ne e vistina) naredbata ne ke izvr{i nikakvo
dejstvo. Postapkata so povtoruva i so proveruvawe na izrazot x <y . Ako e vrednos-
ta na logi~kiot izraz x <yTrue ( vistina ), se pe~ati vrednosta na promenlivata y. Vo
sprotivno logi~kiot izraz ima vrednost false ( ne e vistina) naredbata ne ke izvr{i
nikakvo dejstvo. Od dvete promenlivi x i y }e se pe~ati samo vrednosta na ednata
promenliva.
------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 33 -

- Vo prilog e algoritmot

- programa
#include <cstdlib> #include <iostream>
using namespace std int main( )
{ float x , y ;
cout<<" Vnesete dva broja "; cin >>x>>y ;
if ( x > y ) cout <<" pogolema e vrednosta na x ";
if ( x < y ) cout <<" pogolema e vrednosta na y ";
programata se dobiva sleden ispis vo Project1.exe

// Da se izbere najgolemiot broj od tri vneseni broevi.
Za broevite {to }e se vnesat se koristat vo programata promenlivite x, y i z.
Za najgolemiot broj se koristi promenlivata max. Algoritamski segment e :

Se vnesuva vrednosta na promenlivata x vo promenlivata max. (pod pretpostavka
deka e promenlivata x so najgolema vrednost) Vrednosta vo promenlivata max se
sporeduva so vrednostite na promenlivite y i z. Ako vo dvata logi~ki izrazi se po-
kaè vrednost false, najgolemata vrednost e vo promenlivata max. Samo koga }e se
pokaè vrednost true vo eden od logi~kite izrazi , ke se zameni vrednosta na pro-
menlivata max so vrednosta na y odnosno z. Izbor go dobivame so pe~atewe na
promenlivata max.
------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 34 -

- blok dijagramot

-programa :
{ int x ; float x ,y, z , max ;
cout<<" Vnesete tri broja " ; cin >>x >>y >>z ;
max =x;
if ( max <y ) max = y ;
if ( max <z ) max =z ;
cout <<" Vneseni se broevite "<<x <<" , " <<y <<" , "<<z <<endl;
cout <<" najgolem e brojot " <<max <<endl <<endl;
- Project1.exe

------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 35 -

Dejstvoto na naredbata If moè da se odnesuva ednovremeno i na pove}e naredbi..
Naredbite se tretiraat kako edna celina t.n. struktuirana naredba.
Naredbata se pi{uva vo vid :
if ( logicen izraz ) { naredba 1; naredba2 . ; }
Znacite { i } go ozna~uvaat po~etokot i krajot na blok naredbite na koi se
odnesuva dejstvoto na naredbata If Formata na naredbata if se odnesuva na dejstvo
prikaàno na algoritamskiot segment

Naredbata If se koristi i vo slednava forma

Razgranuvawe vo dve nasoki. Nasoka koga se ispolnuva uslovot ( ozna~en so da )
odnosno vo nasoka (ozna~ena so , ne ) . Naredba e vo sledniov oblik
If ( logi~en uslov ) naredba else
Se koristat i sloèni logi~ki izrazi. Sloènite logi~ki izrazi nastanuvaat
so povrzuvawe na dva logi~ki izrazi so logi~kite operatori za konjukcija AND i
operatorot za disjunkcija OR.
Izrazot
( Logi~en izraz-1 ) AND ( logi~en izraz -2 )
e sloèn izraz koj se narekuva konjukcijata. Konjukcijata e so vrednost true ako i
dva izrazi imaat vrednost true. Vo site drugi slu~aevi vrednost na konjukcijata e false.
Konjunkcijata vo programskiot jazik C++ se ozna~uva so znakot !! .
Programski zapis na naredbata if e vo slednava forma :
If ( ( uslov -1) !! ( uslov-2 ) ) naredba ;
----------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 36 -

Algoritamskiot ~ekor

ima vrednost True ako brojot a e deliv so 2 i so 5 .
Izrazot
( Logi~en izraz-1 ) OR ( logi~en izraz -2 )
e izraz koi se vika disjunkcija. Disjunkcijata e so vrednost True,toga{ koga dvata
izrazi imaat vrednost false. Vo site drugi slu~aevi vrednost e true.
Disjunkcijata vo programskiot jazik C++ se ozna~uva so znakot && .
Programski zapis e vo slednava frma
If ( ( uslov -1) && ( uslov-2 ) )
Algoritamskiot ~ekor

ima vrednost True ako vrednosta na promenlivata a ima vrednost pogolema od 10
ili pomala ili ramna na 20
Algoritmot e izvonredno sredstvo za prikaz na postapkata spored koja }e se
pi{uva programa. So ogled na toa, namesto tekstualno prikaùvawe na postapkata,
se odlu~ivme da dademe prioritet na prezentirame na postapkite so algoritamski
segmenti., osven vo odredeni slu~aevi. Navika na sostavuvavawe na algoritamski pri-
kaz mora da se sozdade. Mnogu e korisna posebno vo ispravuvawe na gre{ki vo test-
tirawe na programata
Za sekoja programa se zadava algoritamski segment. Pred da se pristapi na
pi{uvawe na programa da se odredi deklarativniot del. Koj promenivi ke se koristat
se otkrivaat od algoritamskiot segment. Isto koj promenlivi spagaat vo grupata poz-
nati podatoci se otkrivaat od segmentot. A sledi i zaklu~okokot deka po algor-
itamskiot segment ke se odredat i koj primenlivi ke se pe~atat. Oblikot na prezen-
tiraweto na rezultatot se sugerira od priloèniot rezultat po izvr{uvawe na
programata vo Proect.exe . A korisno e da se oblikuva po svoja èlba.
---------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 37 -

Re{eni programi
1 . // Presmetuvawe na razlikata me|u dva datuma.
Vlezni podatoci se dva datumi.
Za prviot datum ( sega{niot datum) ( denot, mesecot i godinata ) ke gi koristime
promenlivite DEN1,MES1 i GOD1 ).
Za vtoriot datum ( minatiot datum ) ( denot, mesecot i godinata ) }e gi koristime
promenlivite DEN2 ,MES2 i GOD2 ) . Za razlikata ke gi koristime promenlivite
DEN , MES i GOD.
Se vnesuvaat vleznite podatoci.
Presmetuvaweto zapo~nuva so denovite. Ako e DEN2 < DEN1 ,na DEN2 se
dodavaat 30 dena . Vrednosta na MES2 se namaluva za 1 mesec. Se presmetuva
razlikata na denovite. Se preminuva na presmetuvawe na mesecite. Ako e MES2 <
MES1 se dovadaat na MES2 12 meseci. Po ova se presmetuva razlika na mesecite .
Na kra j se presmetuva razlika na godinite.
- blok dijagram

------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 38 -

-programa
{ int den , mes , god ;
int den2 ,mes2, god2 , den1, mes1, god1 ;
cout <<" vnesete podatoci za segasniot datum "<<endl;
cin>>den2>>mes2>>god2 ;
cout <<" vnesete podatoci za minatiot datum "<<endl;
cin>>den1>>mes1>>god1 ;
cout<<"---------------------------------------------------"<<endl;
if ( den2 <den1 ) {den2 =den2 +30 ; mes2 =mes2 - 1 ; }
den =den2 - den1 ;
if ( mes2 <mes1 ) {mes2 =mes2 +12 ; god2 =god2 - 1 ; }
mes =mes2 - mes1 ;
god =god2 - god1 ;
cout<<"---------------denovi ----meseci------godini---- ----"<<endl;
cout<<"razlika "<<den<<" " <<mes<<" " <<god <<endl;
cout<<"-----------------------------------------------------"<<endl; system("PAUSE"); return
EXIT_SUCCESS; }
-Project1.exe

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 39 -

2.Opredeluvawene zbirot na dva agli izrazeni vo stepeni, minuti i sekundi.
- algoritamski segment

- programa
{float step1,min1,sek1 ; float step2,min2,sek2 ; float step, min , sek ;
cout <<" vnesete gi stepenite,minutite i sekundite na prviot agol "<<endl;
cin >>step1>>min1>>sek1 ;
cout <<" vnesete gi stepenite,minutite i sekundite na vtoriot agol"<<endl;
cin >>step2>>min2 >>sek2 ;
cout <<endl;
cout <<" prviot agol " <<step1<<" "<<min1<<" "<<sek1 <<endl;
cout <<" vtoriot agol " <<step2<<" "<<min2<<" "<<sek2 <<endl;
cout <<" -----------------------------------------------------------"<<endl;
sek =sek1 +sek2 ;
if ( sek >59 ) { sek =sek - 60 ; min1 =min1 +1 ; }
min =min1 +min2 ;
if ( min >59 ) { min =min - 60 ; step1 =step1 +1 ; }
step =step1 +step2;
cout <<" zbir "<<step<<" " <<min<<" "<<sek<<endl;
--Project1.exe

-------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 40 -

3. Opredeluvawe na dvostruka vrednost na agol
Izrazen vo stepeni, minuti i sekundi.

- programa
using namespace std; int main( )
{float step,min,sek ; float rezstep, rezmin , rezsek ;
cout <<" vnesete gi stepenite,minutite i sekundite na agolot "<<endl;
cin >>step>>min>>sek ;
cout <<" -----------------------------------------------------------"<<endl;
cout <<" -----------------------------------------------------------"<<endl;
cout <<" agol " <<step<<" "<<min<<" "<<sek <<endl;
cout<<endl;
cout <<" -----------------------------------------------------------"<<endl;
rezsek =2 *sek ;
if (rezsek >59 ) { rezsek =rezsek - 60 ; min =min +0.5 ; }
rezmin =2 *min ;
if (rezmin >59 ) {rezmin =rezmin -60 ; step =step +0.5; }
rezstep =2 *step;
cout <<" dvojna vrednost "<<rezstep<<" " <<rezmin<<" "<<rezsek<<endl;
-Project1.exe

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 41 -

4 . Opredeluvawe na polovi~nata vrednost na aol
izrazen vo stepeni, minuti i sekundi.
-- algoritamski segment

- programa
{int step,min,sek ; float rezstep, rezmin , rezsek ;
cout <<" vnesete gi stepenite,minutite i sekundite na agolot "<<endl;
cin >>step>>min>>sek ;
cout <<" -----------------------------------------------------------"<<endl;
cout <<" -----------------------------------------------------------"<<endl;
cout <<" agol " <<step<<" "<<min<<" "<<sek <<endl;
cout<<endl;
cout <<" -----------------------------------------------------------"<<endl;
if (step%2 !=0){step =step - 1 ; min =min +60; }
rezstep =step / 2 ;
if (min %2 !=0 ){min =min - 1 ; sek =sek +60 ; }
rezmin =min / 2;
rezsek =sek / 2;
cout <<" polovna vrednost "<<rezstep<<" " <<rezmin<<" "<<rezsek<<endl;
-Project1.exe

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 42 -

5. Presmetuvawe zbirot na dva povekeimenuvani podatoci.
Podatocite se izrazeni vo metri, centimetri i milimetri.

programa
#include <cstdlib> #include <iostream> using namespace std int main( )
{ int metar1 , cm1, mm1, metar2,cm2, mm2 ;
int metar ,cm , mm ;
cout<<" Vnesete numericki vrednosti za prviot podatok" <<endl;
cin>>metar1 >>cm1 >>mm1 ;
cout<<" Vnesete numericki vrednosti za vtoriot podatok" <<endl;
cin >>metar2>>cm2 >>mm2 ;
mm =mm1 +mm2 ;
if ( mm >10 ) {mm =mm - 10 ; cm2 =cm2 +1 ; }
cm =cm1 +cm2 ;
if ( cm >100) {cm =cm -100 ; metar2 =metar2 +1 ; }
metar =metar1 +metar2 ;
cout <<"--------------------------------------------------" <<endl;
cout<<endl;
cout <<"--------------------------------------------------" <<endl;
cout<<" R E Z U L T A T "<<endl;
cout<<endl;
cout <<" "<<metar<<" " <<cm<<" "<<mm<<endl;

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 43 -

6. Presmetuvawe na razlikata na dva pove}eimenuvani podatoci ..

- programa
{ int metar1 , cm1, mm1, metar2,cm2, mm2 ;
int metar ,cm , mm ;
cout<<" Vnesete numericki vrednosti za prviot podatok" <<endl;
cin >>metar2>>cm2 >>mm2 ;
cout<<" Vnesete numericki vrednosti za vtoriot podatok" <<endl;
cin>>metar1 >>cm1 >>mm1 ;
if ( mm2 <mm1 ) {mm2 =mm2 +10 ; cm2 =cm2 - 1 ; }
mm =mm2 - mm1 ;
if ( cm2 <cm1 ) {cm2 =cm2 +100 ; metar2 =metar2 - 1 ; }
cm =cm2 - cm1 ;
metar =metar2 - metar1 ;
cout <<"--------------------------------------------------" <<endl;
cout<<endl;
cout <<"--------------------------------------------------" <<endl;
cout<<" R E Z U L T A T "<<endl;
cout<<endl; cout <<" "<<metar<<" " <<cm<<" "<<mm<<endl;

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 44 -

7. Da se opredeli ocenka na testot spored bodovnata skala.


- programa
{ int bod;
cout<<"Vnesi bodovi (od 1 do 100)" endl;
cin>>bod;
if ((bod>=0)&&(bod<=25)) cout<<"NEDOVOLEN(1)"<<endl;
if ((bod>=26)&&(bod<=39)) cout<<"DOVOLEN(2)"<<endl;
if ((bod>=40)&&(bod<=63)) cout<<"DOBAR(3)"<<endl;
if ((bod>=64)&&(bod<=76)) cout<<"MN. DOBAR(4)"<<endl;
if ((bod>=77)&&(bod<=100)) cout<<"ODLICEN(5)"<<endl;
-----------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 45 -

Naredba SWITCH
na slu~ai . Naredbata switch vr{i pove}ekratno
razgranuvawe vo programa od odredeno mesto.
na . Go prezentirame dejstvoto na naredbata so algoritamski-
ov segment.

Za vrednost na promenlivata parametar =p1, dejstvoto vo programata se usmeruva
vo nasoka p1, na izvr{uvawe na slu~ajot p1 .,Organizaciona {eme e prikazana na
slikata.

Naslovna naredba e CASE parametar : Sledat naredbite na ovoj slu~aj. Za ozna~u-
vawe na krajot na naredbite se vnesuva naredbata BREAK..
Za vrednost na promenlivata parametar =p2 , dejstvoto vo programata se usmeruva
vo nasoka p2, na izvr{uvawe na slu~ajot p2. itn. Od site slu~aevi vo programata se
izvr{uva samo eden Sekoj slu~aj se izbira so parametar, {to se vnesuva po SWITCH.
Parametrite po SWITCH. moè da bidat konstanti,bukvi i znacite na aritmeti~kite
operacii ( +, / , * , ).
Vo dekaracijata treba da se vnese informacija na tipot Konstantite se deklari-
raat vo tip int ,a bukvite i znacite na aritmeti~kite operacii vo tip char . Bukvi-
te i znacite za aritmeti~kite operacii po case naredbata se vnesuvaat vo navodnici.
-----------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 46 -

Op{tiot vid na naredba switch e :
switch (parametar)
{
case parametar 1 : naredba1;
break;
case parametar 2 : naredba2 ;
break;
--------------------------------------------------
case parametar (n- 1) : naredba (n-1) ;
break;
case parametar (n ) : naredba n ;
break; }
- programa
{ int parametar ;
cout <<" vnesete vrednost na parametarot " <<endl; cin>>parametar ;
switch (parametar )
{ case 1 : cout<<" vrednosta na parametarot e " <<parametar<<endl; break ;
case 2 : cout<<" vrednosta na parametarot e " <<parametar<<endl; break ;
case 3 : cout<<" vrednosta na parametarot e " <<parametar<<endl; break ;
case 4 : cout<<" vrednosta na parametarot e " <<parametar<<endl; break ; }

// Se pecati denot vo sedmicata ako e vnesen redniot broj na denot
{ int den ;
cout<<" vnesete podatok za den "<<endl; cin>>den;
switch (den )
{ case 1 : cout << " ponedelnik " <<endl ; break ;
case 2 : cout << " vtornik " <<endl ; break ;
case 3 : cout << " sreda " <<endl ; break ; }
case 4 : cout << " cetvortok " <<endl ; break ;
case 5 : cout << " petok " <<endl ; break ;
case 6 : cout<< " sabota " <<endl ; break ;
case 7 : cout << " nedela " <<endl ; break ; }
system("PAUSE"); return EXIT_SUCCESS; }--------------
-------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 47 -

{ char parametar ;
cout <<" vnesete parametar " <<endl; cin>>parametar ;
switch (parametar )
{
case 'a' : cout<<" vnesovte parametar " <<parametar<<endl;
break ;
case 'b' : cout<<" vnesovte parametar " <<parametar<<endl;
break ;
case 'c' : cout<<" vnesovte parametar " <<parametar<<endl;
break ;
case 'd' : cout<<" vnesovte parametar " <<parametar<<endl;
break ; }
}
Ako vrednosta na promenlivata ne e e ednakva na nieden broj ,ne se vr{i nikakvo
dejstvo..
// Programa so koja ke se presmeta aritmeticka operacija megju dva dadeni broevi
// zavisno od znakot za soodvetnata operacija sto ke se vnese
- programa
{ int a,b; char znak;
cout<<"Vnesete 2 broja"<<endl; cin>>a>>b;
cout<<"Vnesete znak za operacija +ili - ili * ili / ili %"<<endl; cin>>znak;
switch (znak )
{case ' +' : cout << a +b <<end ; break;
case ' -' : cout << a - b <<end ; break
case ' * ' : cout << a * b <<endl ; break;
case ' / ' : cout << a / b <<endl; break;
case ' % ' : cout << a % b <<endl; break; }
system("PAUSE"); return EXIT_SUCCESS;
-------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 48 -

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 49 -

IV . Programi za algoritmi so cikli~na struktura
Osnovna karakteristika na cikli~nata struktura e mo`nosta na pove}ekratno
izvr{uvawe na eden ili pove}e algoritamski ~ekori. Za realizacija na cikli~nite
strukturi vo programskiot jazik C++se koristat :
- naredbata while ,
- naredbata for

1. Naredba while

Op{tiot oblik na naredbata e

while ( logicen izraz ) blok naredbi ;

So naredbata se realizira dejstvoto na cikli~na struktura.

Naredbite po While se izvr{uvaat (povtoruvaat) odreden broj pati. Pred sekoe
izvr{uvawe na ovie naredbi se proveruva logi~niot izraz i dokolku ima vrednost
True }e se povtoruva izvr{uvawe na naredbite. Od momentot na neispolnuvawe na
uslovot( vrednost False ) se prekinuva izvr{uvaweto na naredbite..
Me|utoa, koga se koristi ovoj algoritamski segment mora da naglasime deka vo
negovata realizacija se pridruùvaat zadolìtelno dve naredbi. Kontrola na
povtoruvaweto go vodi promenliva po izbor. Na po~etok mora da se vnese po~etnata
vrednost na izbranata promenlivata. Vo blokot naredbi kako posledna naredba za-
dolìtelno sledi naredba koja ja nagolemuva odnosno namaluva vrednosta na izbra-
nata promenliva.
Zatoa, za kompleten algoritamski sostav na ovaa naredba go predlagame sledniov.

Po~etokot na blokot naredbi se ozna~uva so znakot { a krajot na blokot }

]e razgledame nekolku tipi~ni primeri za podobro go shvatime dejstvoto
na naredbata While.
-------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 50 -

1 . Pe~atewe na prirodni broevi od 1 do n .

Se izbira ime na promenliva koja ima uloga na broja~ vo programata
,konkretno broj. Ke ja koristime i promenliva n za odreduvawe na brojot na povto-
ruvawata.
Postapkata po~nuva so ~itawe na vrednosta na promenlivata n .Na promenlivata
broj se dodeluva po~etna vrednost 1. Povtoruvaweto na naredbite pod kontrola na
naredbata White ke relizira povtorurawe se dodeka e vredosta na promenlivata broj
pomala ili ednakva na n.

Se realizira sleden proces:
Promenliva broj dobiva vrednost 1., Se proveruva uslovot.Za ispolnuvawe na
uslovot se pe~ati vrednosta na broj i zgolemuva vrednosta na broj za eden, Se povto-
ruva procesot se dodeka se isponuva uslovot.

- programa

using namespace std ; int main( )
{ int n , broj ;
// Vnesuvanje na prirodni broevi od 1 do n .
cout <<"Vnesete gi prirodnite broevi od 1 do n" <<endl;
cout <<" vnesete eden broj : " ;
cin >>n ;
broj =1 ;
while ( broj <=n )
{ cout<<" "<<broj<<" , " ;
broj =broj +1 ; }

Programaga se izvrr{uva za vnesen brojot 12.

- Proect.exe

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 51 -

2. Da se vnesat neparnite broevi od 1 do n .
Iidenti~na postapka kako i vo prethodnata programa. Vo sekoe povtoruvawe samo se
izmeniva vrednosta na promenlivata broj za dva.
-algoritamski segment

- programa



// Da se vnesat neparnite broevi od 1 do n .

{ int n , broj ;

cout <<"Vnesete gi neparnite broevi od 1 do n" <<endl;

cout <<" vnesete eden neparen broj : " ;

cin >>n ;

broj =1 ;

while ( broj <=n )

{ cout<<" "<<broj<<" , " ;

broj =broj +2 ; }


- Proect.exe

-----------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 52 -

Re{eni programi

1.. Da se vnesat broevite i kvadratite od 1 do n

1. algoritamski segment

- programa .

// Da se vnesat broevite i kvadratite od 1 do n.
{ int n , broj ,kvadrat ;
cout <<"Vnesete gi broevite i kvadratite 1 do n" <<endl;
cout<<" Vnesete vrednost za n :";
cin >>n ;

broj =1 ;
while ( broj <=n )
{kvadrat =broj*broj ;
cout<<" "<<broj<<" "<<kvadrat<<endl ;
broj =broj +1 ; }

system("PAUSE");
return EXIT_SUCCESS;}

- Proect.exe

---------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 53 -

2 . Da se vnesat broevite ,kvadratite i kubovite od 1 do n


- programa

using namespace std; int main)
// .Da se vnesat broevite ,kvadratite i kubovite od 1 do n
{ int n , broj ,kvadrat , kub ;
cout <<"Vnesete gi broevite, kvadratite i kubovite 1 do n" <<endl;
cout<<" Vnesete vrednost za n :";
cin >>n ;
cout<<"-----------------------------------------------------"<<endl;
cout<<" broj kvadrat kub "<<endl;
cout<<" -----------------------------------------------------"<<endl;
broj =1 ;
while ( broj <=n )
{kvadrat =broj*broj ; kub =broj*broj*broj ;
cout<<" "<<broj<<" "<<kvadrat<<" "<<kub<<endl ;
broj =broj +1 ; }

- Proect.exe

------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 54 -

3. Da se presmeta zbirot na prirodnite broevi od 1 do n .

//.Da se presmeta zbirot na prirodnite broevi od 1 do n .
{ int i , n , suma;
cout<< " vnesete vrednost za n "<<endl;
cin>>n ;
i =1 ;
suma =0 ;
while ( i <=n )
{ suma =suma +i ;
i =i +1 ; }
cout <<" za n =" <<n<<" sumata e "<<suma<<endl;
system("PAUSE");
return EXIT_SUCCESS; }

4. Da se presmeta proizvod na prirodnie broevi od 1 do n.


-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 55 -

- programa

using namespace std; int main ( )
// Da se presmeta proizvod na prirodnie broevi od 1 do n
{ int i , n , proizvod;
cout<< " vnesete vrednost za n : " ; cin>>n ;
i =1 ;
proizvod =1 ;
while ( i <=n )
{proizvod =proizvod*i ;
i =i +1 ; }
cout <<"proivod na proevite od 1 do "<<n<<" e "<<proizvod<<endl;
system("PAUSE");

5. Da se presmeta proizvod na kubnite stepeni na broevite od 1 do n.

// Da se presmeta proizvod na kubnite stepeni na prirodnie broevi od 1 do n

{ int i , kub , n , proizvod;
cout<< " vnesete vrednost za n : " ; cin>>n ;
i =1 ;
proizvod =1 ;
while ( i <=n )
{kub =i*i*i ; proizvod =proizvod* kub ;
i =i +1 ; }
cout <<"proivod na kubovite od 1 do "<<n<<" e "<<proizvod<<endl;
system("PAUSE");

-----------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 56 -

2. Naredba FOR

Naredbata For namenski se koristi vo programite so cikli~na struktura..

Sootveten algoritamski prikaz za komandata for e sledniov:

Dejstvoto na naredbata for e povtoruvawe na naredba, odnosno naredbi vo
programata . Se izbira promenliva od tipot integer. Vrednosta na taa promenliva se
menuva od odredena po~etna vrednost do krajna vrednost. Vrednosta na promenliva
se menuva raste~ki ili opaga~ki .
Voobi~aeno se izbira promenliva i.
Se vnesuvaat vo narebata :
- podatok za po~etnata vrednost na promenlivata i ,se vnesuva znakot ( ; ).
- podatak do koja vrednost ke se povtoruva promenlivata i, pak vnesuva znak ( ; ).
- se vnesuva znak i++ ako vrednosta na promenliva se nagolemuva. Da se
namaluva vrednosta se vnesuva znakot i - - .
Na primer, so naredbata FOR kon koja e pridruèna naredba cout :

FOR ( i =1 ; i <= 10 ; i++ ) cout <<i<< P R I M E R <<endl
se naloùva povtorurvawe na komandata cout so po~etna vrednost na i =1, potoa
za i = 2 i sledni vrednosti na promenlivata i. Povtoruvawe se izvr{uva se dodeka e
vrednosta na i pomala ili ednakva 10. Znakot i++ pokaùva deka pri povtoruvawe-
to vrednosta na i se menuva raste~ki. kratkata programa go ilustrira dejstvoto na
naredbata for.


{ int i ;
for ( i =1 ; i < 10 ; i++) cout << i <<" primer " <<endl;

sledi prikazot vo prodolènie

Vrednostite na izbrana promenlivata vo naredbata for moè da se zadadat so
celobrojna konstanta, celobrojna promenliva ili so celobroen aritmeti~ki
izraz. ---------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 57 -

Vo prilogot na kratki programski segmenti . Komentar ne e potreben. Algori-
tamskite segmenti ja otkrivaat postapkata za zapis na programskite segmenti.

1. // prikaz na prirodnite broevi od 0 do 9 vo eden red.

int i ;
for ( i =0 ; i <=10 ; i++) cout<<" "<<i ;

2 . // prikaz na 9 neparni broevi vo eden red.

int i ; for ( i =1 ; i <=10 ; i++)cout<<" "<<2*i -1 ;

3./1 // prikaz na 7 parni broevi od 4 do 16 vo eden red.

int i ; for ( i =2 ; i <=8 ; i ++ ) cout << <<2 * i ;

3/2. // prikaz na 7 parni broevi od 4 do 12 vo poveke redovi.
for ( i =2 ; i<=6 ; i++)cout<<" "<<2*i <<endl;

---------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 58 -

4 . // prikaz na broevi delivi so tri od 1 do 30

int i ;
for ( i =1 ; i <=30 ; i++) if ( i % 3 ==0 ) cout << <<i << , ;

5. // prikaz na kvadratite na prirodnite broevi od 1 do 10

Int i ;
For (i =1 ; i<=10 ; i++ ) cout << << i * i << , ;

6. // prikaz na kubnite stepeni na prirodnite broevi od 1 do 10

int i ;
for ( i =1 ; i <=10 ; i++ ) cout << << i * i * i << , ;

------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 59 -

Re{eni programi

1. Tabelatren prikaz na i, 2i, 5i i 10i za i od 1 do 5 .


- programa


// tabelatren prikaz na i, 2i, 5i i 10i za i od 1 do 5 .
{ int i ;
cout <<"--------------------------------------------" <<endl;
cout <<" i 2i 5i 10i " <<endl;
cout <<"-------------------------------------- -- - " <<endl;
for ( i =1 ; i <=5 ; i++)
cout <<" "<<i <<" "<<2*i<<" "<<5*i<<" " <<10*i<<endl;

-Proect.exe

2. Presmetuvawe na suma na broevite od 1 - 10


----------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 60 -

- programa
// presmetuvanje na suma na broevite od 1 - 10
{int i , suma ;
suma = 0 ;
for ( i =1 ; i <=10 ; i++) suma =suma +i ;
cout <<"sumata na broevite 1 - 10 e"<<" "<<suma;
cout <<endl;
system("PAUSE");
-Proect.exe

3. Presmetuvawe suma na kvadratite na prirodnite broevi od 1 do 10

- programa

// suma na k vadratite na prirodnite broevi od 1 do 10
{ int i , suma ;
Suma =0 ;
For ( i =1 ; i <=10 ; i ++) suma =suma +i * i ; cout<< suma= <<suma<< ;
system("PAUSE");
-Proect.exe

4. Suma na kubnite stepeni na prirodnite broevi od 1 do 10

- programa
// suma na kubnite stepeni na prirodnite broevi od 1 do 10
{ int i ;
suma = 0 ;
for ( I =1 , I <=10 ; I ++) suma =suma +i * i * i ;
cout << sumata na tretite stepeni e <<suma <<endl ;
system("PAUSE");
-Proect.exe

---------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 61 -

5. Presmetuvanje na 6 faktoriel ; ( faktoriel =1.2.3.4.5.6).


- programa


{ int i, faktoriel ;
// Presmetuvanje na 6 faktoriel ; ( faktoriel =1.2.3.4.5.6).
fak =1 ;
for ( i =1 ; i <=6 ; i++) fak * i ;
cout <<"vrednosta na faktoriel od 6 e"<<" "<<fak <<endl;
system("PAUSE");
-Proect.exe

Algoritamskiot segment

se odnesuva na izvr{uvawe na blok naredbi so naredboata for. Po~etokot na
blokot se ozna~uva so znakot { , a krajot so znakot }
---------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 62 -

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 63 -

V. Programi so koristewe na pole

Obrabotka na zada~i koj baziraat na golem broj podatoci se potgotvuvaat za
programirawe i obrabotka na kompjuter so koristewe na pole. Pod pojmot pole se pod-
razbira kone~na niza na podatoci od ist tip koji se tretiraat za celina. Podatocite
vo poleto se podredeni vo redosled . Na slikata e prikaz na pole

. Niza na podatoci podredeni vo redosled. Polo`bata na sekoi podatok se
odreduva so broj, nare~en indeks {to se pridruùva na sekoj podatok. Voobi~aeno
indeksite se ozna~uvaart so bukvata i . Poleto se zadava so brojot na podatocite
( ozna~uvaweto e obi~no so bukvata n ) i numeri~kite vrednosti na podatocite.
Vo poleto, vo redosled se, podatokot 12 so indeks 0, sledniot podatok 4
so indeks 1 i.t.n. do podatokot 4 posleden vo poleto so indeks ( n 1) .

Prikaànata simbolika na poleto da moè da se koristi vo programata treba da
se usoglasi so pravilata na programskiot jazik C++.
Se izbira ime na poleto po pravilata za izbor na promenliva. .Za izbor na
ime na poleto , na primer so a , elementite na poleto se ozna~uvaat sootvetno so

a [ 0 ] , a[ 1 ], a[3] , a[4] , ...........................................a[ n-1]

Indeksot na sekoj element so vnesuva vo sredna zagrada

Prikaz na poleto po pravilata na programskiot jazik. e vo prodolènie.

Sekoj od elementite na poleto se ozna~uva so celobroen indeks i toa taka da
prviot element od poleto ima vrednost 0, a posledniot element indeks za eden
pomalu od dolìna na poleto ( vo gorniot primer dolìnata na poleto e n ).
Polo`bata ( pozicijata ) na sekoj element vo poleto e odreden so indeksot koi se
zapi{uva vo sredni zagradi. Indeksot moè da se ozna~i i so promenliva i celobroen
izraz..

Poleto se deklarira . Op{tiot tip na deklariraweto sodrì informacija za
ime na poleto, tip na elementite na poleto, i dolìnata na poleto.

Deklariraweto na pole e vo sledniov vid
Int i , a [ 100 ] ;
Se deklarira indeksot i , i poleto so maksimalno koristewe na100 elementi.
------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 64 -

Poleto se nadovrzuva i koristi so naredbata For. Se koristi cikli~na
struktura vo najgolem broj slu~aevi , i se koristi kako e prikaàno so algoritamski
segment.

Dejstvata vo koristeweto na poliwa se izvr{uvaat so naredbite razgledani
vo prethodnite naslovi. Potrebno e samo da se uvaùvaat formite na zapisite na
komandite koga naredbata se odnesuva na dejstva na pole. Informacii na po~etok se
odnesuvaat za naredbata za vnes i za pe~atewe.

Naredba za vnes na podatoci vo pole

Podatocite se dodeluvaat po pravilo so naredbata za ~itawe .Poleto
pretstavuva golemo olesnuvawe vo obrabotkata . Potencirame sega deka narednata
za ~itawe, se odnesuva na ~itawe na pole.Se odnesuva na ~itawe na brojot na
elementite na polwto i vrednostite na elementite na poleto.
Algoritamski segment e vo prilog.

îtawe na pole se realizira so programskiot segment :

cout<<" Vnesete broj na podatocite " ; cin >>n ;
cout <<" Vnesete gi podatocite ";
for ( i =0 ; i <n ; i++) cin >> a[ i ] ;

Se odnesuva za pole vo koe }e se vnesat n podatoci. Podatocite se vnesuvaat
vo redosled od podatokot na nultata pozicija do podatokot na pozicijata ( n - 1 ) .

Na programskiot segment prethodi doveduvawe na ekranot na prozorecot Project1.exe

Trepte~kata crti~ka vo prviot red ukaùva deka se o~ekuva vnesuvawe na poda-
tokot na n (brojot na podatocite ) .Po vneseniot podatok se potvrduva so Enter.
----------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 65 -

Trepte~kata crti~ka najavuva vnesuvawe na podatocite na elementite . Vo tekot
na vnesuvaweto na podatocite, se vnesuva razmak od najmalku eden znak blanko. Po
sekoi vnesen podatok crti~kata se pomestuva nadesno.
Se klik na Enter se prezemaat podatocite .Me|utoa, ako vo prviot red se vnesat
pomalku podatoci ( vo primerot pomalku od 10 ) po klik na Enter se prezemaat samo
vnesenite a pojavata na trepta~kata crti~ka vo sledniot red ukaùva deka se
o~ekuvaat i drugite podatoci. Po vnesuvaweto na podatocite povtorno ke se upotrebi
komandata Enter. Ako se vnesat pove}e podatocite , }e se ignoriraat.

Prikaz na Project.exe.

Na elementite na poleto moàt da se pridruàt numeri~kite vrednosti i
voedno so deklariranoto. Podatocite se vnesuvaat me|u golemi zagradi. Primer za
dodeleni vrednosti na ~lenovite na pole voedno so deklariraweto e..

int a [10 ] = {2 , 3, 8, 6 , 1 , 9, 5, 7, 1, 1 } ;

Naredba za pe~atewe na vrednostite na elementite vo pole

- Za pe~atewe na ~lenovite na pole se koristi algoritamskiot segment

Za algoritamskiot segment mu sootvetstvuva programskiot segment.

for ( i =0 ; i <10 ; i++) cout << a[ i ] ;

Podatocite vneseni vo poleto, so programskiov segment ke se otpe~atat kako e
prikazano na listata Proect. Exe

Tova e preddefiniran prikaz. Ne e dovolno jasen i zatova e potrebno da se
vo komandata cout vnese na~inot na prikazot . ]e go uredime prikazot na podotocite
so zapis definiran so navodnici.
So naredbata , na primer
for ( i =0 ; i<10 ; i++) cout<<" "<<a[i]<<" ";
se dobiva prikazot.

Mnogu e va`no sekoga{da se obrnuva vnimanie na pridru`nite tekstovi vo tekot
na sostavuvawe na programata so koristewe na zapisi vo navodnici.
----------------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 66 -

Vo proadolènie se prikazi ,vo koj se prezentira kako dobar primer na
pridru`nite tekstovi vo vnesuvaweto na poznatite podastoci vo poleto..i nivnoto
zabeleùvawe vo izve{tajot.

Primer 1

// Vnesuvanje podatoci vo pole. Prikaz na vnesuvanje na podatoci
{ int i , n , a [10 ] ;
cout <<" Vnesete go brojot na podatocite " ; cin>>n ;
cout<<endl; cout<<" vnesete podatoci vo poleto" ;
for ( i =1 ; i<=n ; i++) cin>>a[i];
cout<<" Prikaz na vnesenite podatoci vo poleto " <<endl;
for ( i =1 ; i<=n ; i++) cout<<" "<<a[i]<<" "; cout<<endl;

Prikaz na rezultatot.

Primer 2.


// Vnesuvanje podatoci vo pole. ednovremeno so deklariranjeto na poleto
{ int i , n =10 ;
int a [ 10] = {2 , 3 , 8 , 6 , 1 , 9 , 5 , 7 , 1 , 1 };
cout<<endl; cout<<" Prikaz na vnesenite podatoci vo poleto " <<endl;
for ( i =0 ; i<n ; i++) cout<<" "<<"["<<i<<"]="<<a[i]<<endl;
cout <<endl;

Prikaz na rezutatot.

----------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 67 -

Re{eni programi

Vo prodolènie se programi za karakteristi~ni dejstva vrz podatoci
vo pole

1. Izbor na podatok vo poleto so maksimalna vrednost

Deklarirame ednodimenzionalno pole pod imeto a , indeksot na poleto so i
.Deklarirame promenliva max za vnesuvawe na vrednosta na elementot so maksi-
malna vrednost.
Opis na postapkata e sleden.
Vrednost na brojot na elementite i vrednostite na elementite se vnesuvaat so
naredbata za vnes..
Na promenlivasta maxse dodeluva vrednost na prviot element od poleto.
Komandata for po~nuva povtoruvawe .Po~nuva so vrednost na indeksot 1 . Za
max <a [i] vo promenlivata max se vnesuva vrednosta na a [1 ]. Povtoruvawto se
izvr{uva i za broevite pomali ili ednakvi na 10.
Po zavr{enoto povtoruvawe , maksimalnata vrednost na elementite se sodrì
vo promenlivata max. Vnesenite podatoci za poleto i presmenatata vrednost na pro-
menlivata max se pe~atat.

Del od postapkata e prikaàn so algoritamskiot segment

Vo prilog e podgotvenata programa.

#include <cstdlib>
#include <iostream>
using namespace std;
int main( )
// Izbor na podatok vo poleto so maksimalna vrednost .
{ int i , a[ 10] = {2, 5, 1, 8, 7, 4, 2, 9, 10, 3 };
int max ;
max =a [ 0 ] ;
for ( i =0 ; i<10 ; i++) if ( max <a[ i ] ) max =a [i ] ;
cout <<" maksimalna vrednost ima brojot "<<max<<" " ;
cout <<endl; system("PAUSE"); return EXIT_SUCCESS; }

Prikaz na rezultatot .

---------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 68 -

2. Broewe na podatocite vo pole so vrednost pomala od 5 .

Deklarirame ednodimenzionalno pole pod imeto a , indeksot na poleto so i .
Vnesuvawe na vrednostite na podatocite vo poleto e so deklariraweto.
Deklarirame promenliva broj za registrirawe na brojot na podatocite. Na
promenlivata broj dodeluvame po~etna vrednost nula so deklariraweto.

Opis na postapkata e sleden
a [i] < 5 se ispolnuva naredbata broj =broj +1. So izvr{uvawe na naredba vrednost
na promenlibata broj dobiva vrednost 1. Povtoruvawto se izvr{uva i za prirodnite
broevi pomali ili ednakvi na 10.

Po zavr{enoto povtoruvawe , brojot na elementite so vrednost pomala od 5 se
sodrì vo promenlivata broj. Vnesenite podatoci za poleto i presmenatata vrednost
na promenlivata broj se pe~atat.

Del od opisot e prikaàn so algoritamskiot segment

Vo prilog e podgotvenata programa.

#include <iostream>
int main( )
// Broenje na podatocite vo pole so vrednost pomala od 5 .

{ int i , a [10] ={2 , 5 , 1 , 8 , 7 , 4 , 2 , 9 , 10 , 3 };
int broj=0 ;
for ( i =0 ; i<10 ; i++)
if ( a[i] <5 ) broj =broj +1 ;
cout <<" vo poleto ima "<<broj<<" broevi pomali od 5. ";
cout <<endl;

- rezultat

----------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 69 -

3. Pe~atewe na pozicijata na elementite pomali od 5.

Vnesuvawe na vrednostite na podatocite vo poleto e so deklariraweto. Dekla-
rirame promenliva broj za registrirawe na brojot na podatocite. Na promenlivata
broj dodeluvame vrednost nula so deklariraweto.

a [i] < 5 se izvr{uva naredba za pe~atewe na elementot a[1]. Povtoruvawto se
izvr{uva i za prirodnite broevi pomali ili ednakvi na 10..


4. #include <cstdlib>
#include <iostream>
int main( )
// Odreduvanje na koja pozicija se naogaat broevite pomali od 5.
{ int i , a [10] ={2,5,1,8,7,4,2,9,10,3 };
int broj=0 ;
cout <<" broevite pomali od 5 se "<<endl;
for ( i =0 ; i<10 ; i++)
if ( a[i]<5 ) cout<<" : na pozicija "<<i <<endl; cout <<endl;

Programata e podgotvena spored algoritamskiot segment

- Rezultat

--------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 70 -

4. Izbor na podatok so maksimalna vrednost vo pole
i pozicijata na elementot

Deklarirame promenliva max vo koja ke se vnese vrednosta na maksimalnata
vrednost na element i promenlivata pozicija za registrirawe na indeksot na ele-
mentot so najgolema vrednost.
Opis na postapkata e sleden :
So naredbata max =a[ 0 ] se dodeluva po~etna vrednost na prviot element od
poleto a so naredbata pozicija =0 po~etna vrednost na indeksot 0 .
Komandata for po~nuva povtoruvawe . Po~nuva so vrednost na indeksot ).
Za max < a [ i ] se izvr{uvaat naredbite max =a[ i ] (se vnesuva vo promenlivta
max vrednosta na elementot so najgolema vrednost ) a vo promelivata pozicija
vrednosta na indeksot na toj element)
Povtoruvawto se izvr{uva za broevite pomali ili ednakvi na 10..
Po zavr{enoto povtoruvawe , vrednosta na elementot so najgolema vrednost se
memorira vo promenlivata max , a vo promenlivata pozicija se registrira indeksot
na elementot. Programata e podgotvena spored algoritamskiot segment

#include <cstdlib>
#include <iostream
// Izbor na podatok vo poleto so maksimalna vrednost i pozicija.
{ int i , a[ 10] = {2, 5, 1, 8, 10, 4, 2, 9, 3 , 4 };
int max ,pozicija ;
max =a[ 0 ] ;pozicija =0 ;
for ( i =0 ; i<10 ; i++)
if ( max <a[ i ] ){max =a [i] ;pozicija =i ;}
cout<<endl; cout<<endl;
cout <<" maksimalna vrednost ima brojot "<<max<<" " <<endl;
cout <<" se naoga na pozicijata "<<pozicija <<endl; cout <<endl;

- Prikaz na rezultatot

-----------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 71 -

5. Odreduvawe na brojot na pozitivnite i na negativnite podatoci vo pole .

Deklarirame promenliva poz vo koja ke se registrira brojot na pozitivnite i
promenlivata neg za registrirawe na negativniie elementi.
Na promenlivite poz i neg se dodeluva po~etna vrednost nula.
Komandata for po~nuva povtoruvawe .Po~nuva so vrednost na indeksot 0.
Za a [ I ] < 0 vrednosta na promenlivata neg se zgolemuva za eden. Za a [i] > 0
vrednosta na promenlivata poz se zgolemuva za eden Povtoruvawto se izvr{uva i
za broevite pomali ili ednakvi na 16
Po zavr{enoto povtoruvawe , brojot na elementite so negativna vrednot se
sodrì vo promenlivata neg a brojot na elementite so pozitivna vrednost vo
promenlivata poz


// Odreduvanje na brojot na pozitivnite i
// brojot na negativnite podatoci vo poleto a .
{ int i , a[ 20 ]={12,-4,-8, 5,8,-16,17,-1,-2,25,26,65,13,88,6,30};
int poz, neg ;
poz =0 ; neg =0 ;
for (i =0; i <16 ;i++)
{ if ( a[i] <0 ) neg =neg +1;
if ( a[i] >0 ) poz =poz +1; }
cout <<" vo poleto a [ ] :" <<endl;
cout <<"pozitivni broevi ima "<<poz<<endl;
cout<< "negativni broevi ima "<<neg <<endl; cout <<endl;

-rezultat

---------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 72 -

6. Presmetuvawe na suma na podatocite vo poleto

Vnesuvawe na vrednostite na podatocite vo poleto e so deklariraweto Deklarirame
promenliva suma za vnesuvawe na vrednosta na zbirot na elementite na poleto..


Na promenlivasta suma se dodeluva po~etna vrednost nula.
Komandata for po~nuva povtoruvawe .Po~nuva so vrednost na indeksot 0 . Vo
promenlivata suma se dodava vrednosta na a [i ]. Povtoruvawto se izvr{uva i za
broevite pomali ili ednakvi na 10..
Po zavr{enoto povtoruvawe ,zbirot na podatocite vo poleto se sodrì vo
promenlivata suma .Vneenite podatoci za poleto i presmenatata vrednost na zbirot
se pe~atat.

Del od opisot e prikaàn so algoritamskiot segment

// Presmetuvanje na sumata na podatocite vo poleto.
{ int i ,suma; int a [ 10] ={2, 5, 1, 8, 7, 4, 2, 9, 10, 3 }; cout<<endl;
cout<<" Prikaz na vnesenite podatoci vo poleto " <<endl ;
for ( i =0 ; i<10 ; i++) cout<<" "<<"["<<i<<"]="<<a [ i ] ;
suma =0 ; for ( i =0 ; i<10 ; i++) suma =suma +a [ I ] ;
cout<<endl; cout <<" vrednosta na sumata e "<<suma ; cout <<endl;
- rezultat

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 73 -

6. 1 // programski segment za presmetuvawe zbirot na parnite podatoci
- Algoritamski segment

- programski segment
suma =0 ; for ( i =0 ; i<10 ; i++ )
{ if ( a[i] % 2== 0 ) suma =suma +a[i]; }
Slednive programski segmenti se bez komantar.
6.2 // programski segment za presmetuvane na zbirot na neparnite podatoci
suma =0 ; for ( i =0 ; i<10 ; i++ )
{ if ( a[i] % 2 !=0 ) suma =suma +a[i]; }
6.3 // programski segment za presmetuvawje na sumata na podatocite
delivi so 3
suma =0 ; for ( i =0 ; i<10 ; i++ )
{ if ( a[i]%3==0 ) suma =suma +a[i]; }
6.4. // programski segment za presmetuvanje na sumata na podatocite
pomali od 5.
suma =0 ; for ( i =0 ; i<10 ; i++ )
{ if ( a[i]<5 ) suma =suma +a[i]; }
6.5. // programski segment za prebrojuvanje na podatocite
// so vrednost pogolema i ramna na 5.
broj =0 ; for ( i =0 ; i<10 ; i++ )
{ if ( a[i]<5 )broj =broj +1 ; }
6.6 // Da se nabrojat poziciite na podatocite so vrednost pomala od 5.
for ( i =0 ; i<10 ; i++ )
if ( a[i]<5 ) cout<<" na pozicija "<<i <<endl;
------------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 74 -

7. P resmetuvawe na proizvod na ~lenovite vo pole.

Deklarirame promenliva proizvod za vnesuvawe na vrednosta na proizvodot na
elementot na poleto..
Vrednost na brojot na elementite i vrednostite na elementite na poleto se
vnesuvaat so naredbata za vnes..
Na promenlivasta proizvod se dodeluva vrednost 1.
Komandata for po~nuva povtoruvawe .Po~nuva so vrednost na indeksot 0 . Na
promenlivata proizvod I se dodeluva nova vrednost proizvod =proizvod * a[ i ] ;
Povtoruvawto se izvr{uva i za broevite pomali ili ednakvi na 10..
Po zavr{enoto povtoruvawe , proizvodot se sodrì vo promenlivata Proizvod.
Vnesenite podatoci za poleto i presmetanata vrednost na promenlivata proizvod se
pe~atat.


- programa

// Da se presmeta proizvod na clenovite vo pole.
{int i , a[10], n ;
int proizvod ;
cout<<"broj na podatocite vo poleto " ;
cin>>n ; cout <<endl ;
cout <<" vnesete gi podatocite " <<endl;
for ( i=0 ; i <n ; i++) cin>>a [i ] ; cout<<endl;
for ( i=0 ; i <n ; i++) cout<<a [i ] ; cout<<endl; cout<<endl;
proizvod=1;
for ( i=0 ; i <n ; i++) proizvod =proizvod * a[i ] ;
cout<<" proizvod na clenovite vo nizata e " <<proizvod<<endl ;
- Rezultat

--------------------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 75 -

VI. Programi so koristewe na tabela

Obrabotka na zada~i koj baziraat na golem broj podatoci rasporedeni vo
tabela se potgotvuvaat za programirawe i obrabotka na kompjuter so koristewe na
tabela.Pod pojmot tabela se podrazbira kone~na niza na podatoci od ist tip raspo-
redeni vo tabelata koji se tretiraat za celina.. Podatocite sega se rasporedeni vo
redovi i koloni..

Na slikata e prikaz na tabela.

Vo zapisot za redovite i kolonite se koristeni oznakite :

m ( brojot na redovite )
n ( broj na kolonite )

Podatocite se podredeni vo tabelata . Polo`bata na sekoi podatok so odreduva
so dva broja, nare~eni indeksi {to se pridruùvaat na sekoj podatok. Odreduvawe na
pozicijata na elementite se odreduva so pomo{ta na dvata indeksi, prviot indeks go
odreduva redot a vtoriot indeks kolonata vo koj se nao|a elementot.
Elementot vo prviot red od tabelata e vo indeks 0 .Posledniot ~len od prviot
red e so indeks ( broj na redovi -1) . Vkupniot broj na elementite vo redovite e m.
Elementot vo prvata kolona od tabelata e so indeks 0. Posledniot element vo kolo-
nata e so indeks (broj na koloni - 1 ) Vkupniot broj koloni vo tabelata e n .

Prikaànata simbolika na poleto da moè da se koristi vo programata treba da
se usoglasi so pravilata na programskiot jazik C++.
Se izbira ime na tabelata .Po imeto indeksite na elementite vo tabelata se
ozna~uvaat vo sredni zagradi . Za izbor na ime a, element se ozna~uva a [i][j].
Voobi~aeno za indeksite se koristat bukvite i i j ..
Tabelata se deklarira . Op{tiot tip na deklariraweto sodrì informa-
cija za ime na poleto, tip na elementite na poleto, i dolìnata na poleto.
Vo na{iot izbor deklaracijata na tabelata e :

Int i , j , a [ m ] [ n ] ;
---------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 76 -

Vo prilog e zapis vo C++ na redosledot na elementite vo tabelata so ~e-tiri
redovi i pet koloni.

- rasporedot na elementite.

Tabelite pretstavuvaat golemo olesnuvawe vo programiraweto . Za rabota so
tabelite se koristat dve for naredbi.vo struktura prikaàna vo prodolènie. Tova
e struktura na dve vgnezdeni for naredbi. Se koristi struktuktura vo prilog.

Na{eto vnimanie ke bide naso~eno na programite so priloènata struktura..
Polo`bata na sekoi element vo tabelata se registrira so dva indeksi (indeksot
na redot vo koj se naoga elementot i indeksot na kolona vo koja se naoga elementot.).
Sekoi element vrz koj treba da se izvr{i odredeno dejstvo se odreduva so ukaùvawe
na indeksite na elementot.
Iindeksite na elementite vo strukturata se izmenuvaat vo sleden redosled.:
Prvata naredba For dodeluva na indeksot i vrednost 0.
Zapo~nuva izvr{uvawe na naredbita pri {to pri povtoruraweto indeksot i =0
a vrednostite na indeksot j se slednive , j =0, 1 ,2, 3, 4, 5, ----------, n 1.
Se prenesuva kontrolata na prvata For naredba. Se dodeluva na indeksot i =1 ,
a vrednostite na indeksot j se slednive , j =0, 1 ,2, 3, 4, 5, ----------, n 1.
Povtoruvawata se izvr{uvaat i za i =3, i = 4 it.n se dodeka e vrednosta
na i pomala od m. ( prikazot na izmenuvaweto na indeksite e vo prodolènie.

0 0 0 1 0 2 0 3 0 4 -------------------------------- 0 n - 1
1 0 1 1 1 2 1 3 1 4 -------------------------------- 1 n - 1
2 0 2 1 2 2 2 3 2 4 ------------------------------- 2 n - 1
3 0 3 1 3 2 3 3 3 4 ----------------------------- 3 n - 1

m-1 0 m-1 1 m-1 2 m-1 3 m-1 4 ----------------------------m -1 n - 1
-----------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 77 -

Tabelata treba da se deklarira. Deklaracijata sodrì informacija za ime na
tabelata, tip na ~lenovite na tabelata, i maksimalniot broj na redovite i kolonite .
Na deklarirawe na poleto sekoga{prethodi deklaracija za indeksite. Indeksite
za site tipovi tabela se sekoga{tip Integer.
Primerite na deklarirawe :

int a [10 ] [10] ;
float b [20 ] [20] ;
char tekst [ 50][ 20] ;

se odnesuvaat na tabela a so celobrojni podatoci ( maksimalno do 10 x 10, na tabe-
lata b na podatoci od tipot float ( maksimalen broj podatoci 20 x 20 ) i na tabelata
tekst ( so podatoci tip char ( maksimalno do 50 x 20 znaci) .

Naredba za vnes na podatoci vo tabela

Podatocite se dodeluvaat po pravilo so naredbata za vnes ..
Potencirame sega deka narednata za vnes, se odnesuva na tabela.Se odnesuva na
vnesuvawe na brojot na elementite na tabelata ( brojot na redovite i brojot na
kolonite ) i vrednostite na elementite na tabelata.
Algoritamski segment e vo prilog.

îtawe na tabela se realizira so programskiot segment :

cout<<" Vnesete broj na redovi i koloni" ; cin >>m >>n ;
for ( i=0; i<m ;i++)
{ cout<<"vnesete podatoci za red :"<< i;
for ( j =0; j <n ; j++)
cin>>a[i][j]; }

Se odnesuva za tabela vo koja }e se vnesat podatocite za brojot na redovite (m ) i
brojot na kolonite (n) na tabela i podatocite na tabelata ( m x n ) vo redosled na
redovi. Podatocite se vnesuvaat vo redosled od podatokot na nultata pozicija do
podatokot na pozicijata ( n - 1 ) .
----

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 78 -

Na programskiot segment prethodi doveduvawe na ekranot na prozorecot Project1.exe

Za vnesuvawe ,, na primer na tabelata

vnesuvawe broj na redovite 4 i brojot na kolonite 5.
Trepte~kata crti~ka vo prviot red ukaùva deka se o~ekuva vnesuvawe na poda-
tocite za m (brojot na redovite ) i n ( brojot na kolonite ) a potoa vrednostite na
elementite rasporedeni vo redovi..

Za programskiov segment se vnesuvaat prvo brojot na redovite (m) i brojot na
kolonite (n) vo prviot red .Se potvrduva so Enter

Podatocite se vnesuvaat po redovi. Se vnesuvaat podatocite vo prviot red. Se
kliknuva na Enter.So prodolùva so vnesuvawe i na drugite redovi. Po vnesuvawe na
podatocite vo red se kliknuva na Enter. Prikazot na vnesenite podatoci se vo listata
vo prodolènie.

Na ~lenovite na tabelata moàt da se dodelat vrednosti voedno so dekla-
riranoto. Podatocite se vnesuvaat me|u golemi zagradi. Primer za dodeleni vred-
nosti na ~lenovite na pole :

Deklaracija :

int i , j , m =4 , n = 5 ;

int a[4][5] = { {10 , 12, 14, 16, 18 },
{ 4, 8, 10, 20, 11 },
{ 2, 1, 11, 30, 33 },
{ 5, 6, 4, 35, 31 } };

-------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 79 -

Naredba za pe~atewe na podatoci vo tabela

Za izdavaweto na podatocite vo tabelata se koristi algoritamskiot segment

Za sledniot programski segment
for ( i=0; i <m ;i++)
{ for ( j =0; j <n ; j++)
cout<<" a[" <<i<<"]["<<j<<"]="<<a[i][j];
cout<<endl; cout<<endl; }

Vo prilog e programa so dvata programski segmenti.

#include <cstdlib> #include <iostream> using namespace std; int main( )
int i , j , int a[4][5] ;
cout<<" Vnesete broj na redovi i koloni" ; cin >>m >>n ;
for ( i=0; i<m ;i++)
{ cout<<"vnesete podatoci za red :"<< i;
for ( j =0; j <n ; j++) cin>>a[i][j]; }
cout<<" rezultat : "<<endl<<endl;
for ( i=0; i<4 ;i++)
{ for ( j=0; j<5 ;j++)
cout<<" a[" <<i<<"]["<<j<<"]="<<a[i][j];
cout<<endl; cout<<endl; }

Na listata project.exe se prikazite po izvr{uvawe na programata

---

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 80 -

Re{eni programi

Vo prodolènie se programi za karakteristi~ni dejstva vrz podatoci
vo tabela

1.
// Presmetuvawe na suma na elementite vo tabelata.


- programa


int i,j ; int suma ;
int a[4][5] = { {10 , 12, 14, 16, 18 },
{4, 8, 10, 20, 11 },
{2, 1, 11, 30, 33 },
{5, 6, 4, 35 , 31} };
for ( i =0 ; i<4 ; i++)
{ for ( j =0 ; j <5 ; j++)
{ cout<<" a[" <<i<<"]"<<"["<<j<<"]="<<a[i][j]<<" " ; }
cout <<endl; };
suma =0;
for ( i =0 ; i<4 ; i++)
for ( j =0 ; j <5 ; j++)
suma =suma +a[i][j];
cout<<endl; cout <<" sumata na podatocite e "<<suma ; cout<<endl;
system ("PAUSE"); return EXIT_SUCCESS; }

- prikaz na Proect.exe

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 81 -

2. // Odreduvawe na podatok vo tabela so maksimalna vrednost.


- programa


{ int i , j , max ;
int a[4][5] = { {10 , 12, 14, 16, 18 },
{ 4, 8, 10, 20, 11 },
{ 2, 1, 11, 30, 33 },
{ 5, 6, 4, 35 , 31 } };
for ( i =0 ; i<4 ; i++){cout<<endl;
for ( j =0 ; j <5 ; j++)
cout<<" a[" <<i<<"]"<<"["<<j<<"]="<<a[i][j]<<" " ; }
max =0;
for ( i =0 ; i<4 ; i ++)
{ for ( j =0 ; j <5 ; j++)
if( max <a[i][j] ) max =a[i][j]; }
cout<<endl; cout<<"maksimalna vrednost e "<< max ;

- prikaz na Project.exe

-----------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 82 -

3. // Prebrojuvawe na podatocite vo tabelata so vrednost pomala od 10.


- programa


int i , j , broj ;
int a[4][5] = { {10 , 12, 14, 16, 18 },
{ 4, 8, 10, 20, 11 },
{ 2, 1, 11, 30, 33 },
{ 5, 6, 4, 35 , 31 } };
for ( j =0 ; j <5 ; j++)
cout<<" a[" <<i<<"]"<<"["<<j<<"]="<<a[i][j]<<" " ; }
broj =0;
for ( i =0 ; i<4 ; i ++)
{ for ( j =0 ; j <5 ; j++)
if ( a[i][j]<10 ) broj=broj +1; }
cout<<endl; cout<<"Vo tabelata ima " <<broj ;
cout << " podatoci so vrednost pomala od 10 " ;


- prikaz na Project.exe

----------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 83 -

4. // Presmetuvawe na zbirot na podatoci delivi so 3 .

- algoritamasi segment

- programa


{ int i , j , suma ;
int a[4][5] = { {10 , 12, 14, 16, 18 },
{ 4, 8, 10, 20, 11 },
{ 2, 1, 11, 30, 33 },
{ 5, 6, 4, 35 , 31 } };
for ( j =0 ; j <5 ; j++)
cout<<" a[" <<i<<"]"<<"["<<j<<"]="<<a[i][j]<<" " ; }
suma =0;
for ( i =0 ; i<4 ; i ++)
{ for ( j =0 ; j <5 ; j++)
if ( a[i][j] % 3==0 ) suma=suma +1; }
cout<<endl; cout<<"Vo tabelata ima " <<suma ;
cout << " podatoci delivi so 3 " ;


Prikaz na Project.exe

-------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 84 -

5. // Odreduvawe na elementi vo redovi delivi so tri.

-algoritamski segment

- programa.

{ int i , j ;
int a[4][5] = { {10 , 12, 14, 16, 18 },
{ 4, 8, 10, 20, 11 },
{ 2, 1, 11, 30, 33 },
{ 5, 6, 4, 35 , 31 } };
cout<< endl;
cout <<" podatoci vo tabelata "; cout<<endl;
for ( j =0 ; j <5 ; j++)
cout<<" a[" <<i<<"]"<<"["<<j<<"]="<<a[i][j]<<" " ; }
cout <<endl; cout <<endl;cout << " podatoci delivi so 3 " ;
cout<<endl;

for ( i =0 ; i<4 ; i ++)
for ( j =0 ; j <5 ; j++)
{ if ( a[i][j] % 3==0 )
cout<<" red ="<<i<<" "<<"kol. ="<<j<<" " <<" broj ="<<a[i][j]<<endl; }

- Prikaz na Project.exe

---------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 85 -

6. // Odreduvanje na podatocite so maksimalna vrednost vo redovite


int i,j ; int max[4];
int a[4][5] = { {10 , 12, 14, 16, 18 },
{ 4, 8, 10, 20, 11 },
{ 2, 1, 11, 30, 33 },
{ 5, 6, 4, 35 , 31 } };
for ( i =0 ; i<4 ; i++)
{ for ( j =0 ; j <5 ; j++)
{ cout<<" a[" <<i<<"]"<<"["<<j<<"]="<<a[i][j]<<" " ; }
cout <<endl; };
for ( i =0 ; i<4 ; i++)
{ max[i]=0 ;
for ( j =0 ; j <5 ; j++) if (max [i] <a[i][j]) max[i]=a[i][j];}
for ( i =0 ; i<4 ; i++)
cout <<" maksimalna vredost vo redot " <<i<<" e "<<max[i]<<endl;

---------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 86 -

7 . .// Odreduvanje na sumi vo redovite na tabela.


int i,j ; int suma[4];
int a[4][5] = { {10 , 12, 14, 16, 18 },
{4, 8, 10, 20, 11 },
{2, 1, 11, 30, 33 },
{5, 6, 0, 35, 31 } };

for ( i =0 ; i<4 ; i++)
{ for ( j =0 ; j <5 ; j++)
{ cout<<" a[" <<i<<"]"<<"["<<j<<"]="<<a[i][j]<<" " ; }
cout <<endl; };

for ( i =0 ; i<4 ; i++)
{ suma[i]=0 ;
for ( j =0 ; j <5 ; j++) suma [i]=suma[i] +a[i][j];}

for ( i =0 ; i<4 ; i++)
cout <<" sumata na elementite vo redot " <<i<<" e "<<suma[i]<<endl;

-----------
-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 87 -

8. // Odreduvanje na sumi vo redovite na tabela na podatocite delivi so cetiri.


int i,j ; int suma[4];
int a[4][5] = { {10 , 12, 14, 16, 18 },
{4, 8, 10, 20, 11 },
{2, 1, 11, 30, 33 },
{5, 6, 0, 35, 31 } };
for ( i =0 ; i<4 ; i++)
{ for ( j =0 ; j <5 ; j++)
{ cout<<" a[" <<i<<"]"<<"["<<j<<"]="<<a[i][j]<<" " ; }
cout <<endl; };
for ( i =0 ; i<4 ; i++)
{ suma[i]=0 ;
for ( j =0 ; j <5 ; j++)
if ( a[i][j]%4 ==0 ) suma [i]=suma[i]+a[i][j];}
for ( i =0 ; i<4 ; i++)
{cout <<" sumata na elementite delivi so cetiri vo redot " ;
cout<<i<<" e "<<suma[i]<<endl; }

----------------

-------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------- 88 -

C

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

C

Uploaded by

Copyright:

Available Formats

Dimitar Bitrakov C++

You might also like